2 * Intel CPU microcode early update for Linux
4 * Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
5 * H Peter Anvin" <hpa@zytor.com>
7 * This allows to early upgrade microcode on Intel processors
8 * belonging to IA-32 family - PentiumPro, Pentium II,
9 * Pentium III, Xeon, Pentium 4, etc.
11 * Reference: Section 9.11 of Volume 3, IA-32 Intel Architecture
12 * Software Developer's Manual.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
21 * This needs to be before all headers so that pr_debug in printk.h doesn't turn
22 * printk calls into no_printk().
27 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/earlycpio.h>
31 #include <linux/initrd.h>
32 #include <linux/cpu.h>
34 #include <asm/microcode_intel.h>
35 #include <asm/processor.h>
36 #include <asm/tlbflush.h>
37 #include <asm/setup.h>
40 #define pr_fmt(fmt) "microcode: " fmt
42 static unsigned long mc_saved_in_initrd
[MAX_UCODE_COUNT
];
43 static struct mc_saved_data
{
44 unsigned int mc_saved_count
;
45 struct microcode_intel
**mc_saved
;
48 static enum ucode_state
49 load_microcode_early(struct microcode_intel
**saved
,
50 unsigned int num_saved
, struct ucode_cpu_info
*uci
)
52 struct microcode_intel
*ucode_ptr
, *new_mc
= NULL
;
53 struct microcode_header_intel
*mc_hdr
;
56 new_rev
= uci
->cpu_sig
.rev
;
58 for (i
= 0; i
< num_saved
; i
++) {
60 mc_hdr
= (struct microcode_header_intel
*)ucode_ptr
;
62 ret
= get_matching_microcode(uci
->cpu_sig
.sig
,
69 new_rev
= mc_hdr
->rev
;
76 uci
->mc
= (struct microcode_intel
*)new_mc
;
81 copy_initrd_ptrs(struct microcode_intel
**mc_saved
, unsigned long *initrd
,
82 unsigned long off
, int num_saved
)
86 for (i
= 0; i
< num_saved
; i
++)
87 mc_saved
[i
] = (struct microcode_intel
*)(initrd
[i
] + off
);
92 microcode_phys(struct microcode_intel
**mc_saved_tmp
,
93 struct mc_saved_data
*mc_saved_data
)
96 struct microcode_intel
***mc_saved
;
98 mc_saved
= (struct microcode_intel
***)
99 __pa_nodebug(&mc_saved_data
->mc_saved
);
100 for (i
= 0; i
< mc_saved_data
->mc_saved_count
; i
++) {
101 struct microcode_intel
*p
;
103 p
= *(struct microcode_intel
**)
104 __pa_nodebug(mc_saved_data
->mc_saved
+ i
);
105 mc_saved_tmp
[i
] = (struct microcode_intel
*)__pa_nodebug(p
);
110 static enum ucode_state
111 load_microcode(struct mc_saved_data
*mc_saved_data
, unsigned long *initrd
,
112 unsigned long initrd_start
, struct ucode_cpu_info
*uci
)
114 struct microcode_intel
*mc_saved_tmp
[MAX_UCODE_COUNT
];
115 unsigned int count
= mc_saved_data
->mc_saved_count
;
117 if (!mc_saved_data
->mc_saved
) {
118 copy_initrd_ptrs(mc_saved_tmp
, initrd
, initrd_start
, count
);
120 return load_microcode_early(mc_saved_tmp
, count
, uci
);
123 microcode_phys(mc_saved_tmp
, mc_saved_data
);
124 return load_microcode_early(mc_saved_tmp
, count
, uci
);
126 return load_microcode_early(mc_saved_data
->mc_saved
,
133 * Given CPU signature and a microcode patch, this function finds if the
134 * microcode patch has matching family and model with the CPU.
136 static enum ucode_state
137 matching_model_microcode(struct microcode_header_intel
*mc_header
,
140 unsigned int fam
, model
;
141 unsigned int fam_ucode
, model_ucode
;
142 struct extended_sigtable
*ext_header
;
143 unsigned long total_size
= get_totalsize(mc_header
);
144 unsigned long data_size
= get_datasize(mc_header
);
146 struct extended_signature
*ext_sig
;
148 fam
= __x86_family(sig
);
149 model
= x86_model(sig
);
151 fam_ucode
= __x86_family(mc_header
->sig
);
152 model_ucode
= x86_model(mc_header
->sig
);
154 if (fam
== fam_ucode
&& model
== model_ucode
)
157 /* Look for ext. headers: */
158 if (total_size
<= data_size
+ MC_HEADER_SIZE
)
161 ext_header
= (void *) mc_header
+ data_size
+ MC_HEADER_SIZE
;
162 ext_sig
= (void *)ext_header
+ EXT_HEADER_SIZE
;
163 ext_sigcount
= ext_header
->count
;
165 for (i
= 0; i
< ext_sigcount
; i
++) {
166 fam_ucode
= __x86_family(ext_sig
->sig
);
167 model_ucode
= x86_model(ext_sig
->sig
);
169 if (fam
== fam_ucode
&& model
== model_ucode
)
178 save_microcode(struct mc_saved_data
*mc_saved_data
,
179 struct microcode_intel
**mc_saved_src
,
180 unsigned int mc_saved_count
)
183 struct microcode_intel
**saved_ptr
;
190 * Copy new microcode data.
192 saved_ptr
= kcalloc(mc_saved_count
, sizeof(struct microcode_intel
*), GFP_KERNEL
);
196 for (i
= 0; i
< mc_saved_count
; i
++) {
197 struct microcode_header_intel
*mc_hdr
;
198 struct microcode_intel
*mc
;
201 if (!mc_saved_src
[i
]) {
206 mc
= mc_saved_src
[i
];
208 size
= get_totalsize(mc_hdr
);
210 saved_ptr
[i
] = kmalloc(size
, GFP_KERNEL
);
216 memcpy(saved_ptr
[i
], mc
, size
);
220 * Point to newly saved microcode.
222 mc_saved_data
->mc_saved
= saved_ptr
;
223 mc_saved_data
->mc_saved_count
= mc_saved_count
;
228 for (j
= 0; j
<= i
; j
++)
236 * A microcode patch in ucode_ptr is saved into mc_saved
237 * - if it has matching signature and newer revision compared to an existing
239 * - or if it is a newly discovered microcode patch.
241 * The microcode patch should have matching model with CPU.
243 * Returns: The updated number @num_saved of saved microcode patches.
245 static unsigned int _save_mc(struct microcode_intel
**mc_saved
,
246 u8
*ucode_ptr
, unsigned int num_saved
)
248 struct microcode_header_intel
*mc_hdr
, *mc_saved_hdr
;
249 unsigned int sig
, pf
;
252 mc_hdr
= (struct microcode_header_intel
*)ucode_ptr
;
254 for (i
= 0; i
< num_saved
; i
++) {
255 mc_saved_hdr
= (struct microcode_header_intel
*)mc_saved
[i
];
256 sig
= mc_saved_hdr
->sig
;
257 pf
= mc_saved_hdr
->pf
;
259 if (!get_matching_sig(sig
, pf
, ucode_ptr
))
264 if (mc_hdr
->rev
<= mc_saved_hdr
->rev
)
268 * Found an older ucode saved earlier. Replace it with
271 mc_saved
[i
] = (struct microcode_intel
*)ucode_ptr
;
275 /* Newly detected microcode, save it to memory. */
276 if (i
>= num_saved
&& !found
)
277 mc_saved
[num_saved
++] = (struct microcode_intel
*)ucode_ptr
;
283 * Get microcode matching with BSP's model. Only CPUs with the same model as
284 * BSP can stay in the platform.
286 static enum ucode_state __init
287 get_matching_model_microcode(int cpu
, unsigned long start
,
288 void *data
, size_t size
,
289 struct mc_saved_data
*mc_saved_data
,
290 unsigned long *mc_saved_in_initrd
,
291 struct ucode_cpu_info
*uci
)
293 u8
*ucode_ptr
= data
;
294 unsigned int leftover
= size
;
295 enum ucode_state state
= UCODE_OK
;
296 unsigned int mc_size
;
297 struct microcode_header_intel
*mc_header
;
298 struct microcode_intel
*mc_saved_tmp
[MAX_UCODE_COUNT
];
299 unsigned int mc_saved_count
= mc_saved_data
->mc_saved_count
;
302 while (leftover
&& mc_saved_count
< ARRAY_SIZE(mc_saved_tmp
)) {
304 if (leftover
< sizeof(mc_header
))
307 mc_header
= (struct microcode_header_intel
*)ucode_ptr
;
309 mc_size
= get_totalsize(mc_header
);
310 if (!mc_size
|| mc_size
> leftover
||
311 microcode_sanity_check(ucode_ptr
, 0) < 0)
317 * Since APs with same family and model as the BSP may boot in
318 * the platform, we need to find and save microcode patches
319 * with the same family and model as the BSP.
321 if (matching_model_microcode(mc_header
, uci
->cpu_sig
.sig
) !=
323 ucode_ptr
+= mc_size
;
327 mc_saved_count
= _save_mc(mc_saved_tmp
, ucode_ptr
, mc_saved_count
);
329 ucode_ptr
+= mc_size
;
337 if (mc_saved_count
== 0) {
338 state
= UCODE_NFOUND
;
342 for (i
= 0; i
< mc_saved_count
; i
++)
343 mc_saved_in_initrd
[i
] = (unsigned long)mc_saved_tmp
[i
] - start
;
345 mc_saved_data
->mc_saved_count
= mc_saved_count
;
350 static int collect_cpu_info_early(struct ucode_cpu_info
*uci
)
353 unsigned int family
, model
;
354 struct cpu_signature csig
;
355 unsigned int eax
, ebx
, ecx
, edx
;
361 memset(uci
, 0, sizeof(*uci
));
365 native_cpuid(&eax
, &ebx
, &ecx
, &edx
);
368 family
= __x86_family(csig
.sig
);
369 model
= x86_model(csig
.sig
);
371 if ((model
>= 5) || (family
> 6)) {
372 /* get processor flags from MSR 0x17 */
373 native_rdmsr(MSR_IA32_PLATFORM_ID
, val
[0], val
[1]);
374 csig
.pf
= 1 << ((val
[1] >> 18) & 7);
376 native_wrmsr(MSR_IA32_UCODE_REV
, 0, 0);
378 /* As documented in the SDM: Do a CPUID 1 here */
381 /* get the current revision from MSR 0x8B */
382 native_rdmsr(MSR_IA32_UCODE_REV
, val
[0], val
[1]);
393 static void __ref
show_saved_mc(void)
396 unsigned int sig
, pf
, rev
, total_size
, data_size
, date
;
397 struct ucode_cpu_info uci
;
399 if (mc_saved_data
.mc_saved_count
== 0) {
400 pr_debug("no microcode data saved.\n");
403 pr_debug("Total microcode saved: %d\n", mc_saved_data
.mc_saved_count
);
405 collect_cpu_info_early(&uci
);
407 sig
= uci
.cpu_sig
.sig
;
409 rev
= uci
.cpu_sig
.rev
;
410 pr_debug("CPU: sig=0x%x, pf=0x%x, rev=0x%x\n", sig
, pf
, rev
);
412 for (i
= 0; i
< mc_saved_data
.mc_saved_count
; i
++) {
413 struct microcode_header_intel
*mc_saved_header
;
414 struct extended_sigtable
*ext_header
;
416 struct extended_signature
*ext_sig
;
418 mc_saved_header
= (struct microcode_header_intel
*)
419 mc_saved_data
.mc_saved
[i
];
420 sig
= mc_saved_header
->sig
;
421 pf
= mc_saved_header
->pf
;
422 rev
= mc_saved_header
->rev
;
423 total_size
= get_totalsize(mc_saved_header
);
424 data_size
= get_datasize(mc_saved_header
);
425 date
= mc_saved_header
->date
;
427 pr_debug("mc_saved[%d]: sig=0x%x, pf=0x%x, rev=0x%x, toal size=0x%x, date = %04x-%02x-%02x\n",
428 i
, sig
, pf
, rev
, total_size
,
431 (date
>> 16) & 0xff);
433 /* Look for ext. headers: */
434 if (total_size
<= data_size
+ MC_HEADER_SIZE
)
437 ext_header
= (void *) mc_saved_header
+ data_size
+ MC_HEADER_SIZE
;
438 ext_sigcount
= ext_header
->count
;
439 ext_sig
= (void *)ext_header
+ EXT_HEADER_SIZE
;
441 for (j
= 0; j
< ext_sigcount
; j
++) {
445 pr_debug("\tExtended[%d]: sig=0x%x, pf=0x%x\n",
454 static inline void show_saved_mc(void)
459 #if defined(CONFIG_MICROCODE_INTEL_EARLY) && defined(CONFIG_HOTPLUG_CPU)
460 static DEFINE_MUTEX(x86_cpu_microcode_mutex
);
462 * Save this mc into mc_saved_data. So it will be loaded early when a CPU is
463 * hot added or resumes.
465 * Please make sure this mc should be a valid microcode patch before calling
468 int save_mc_for_early(u8
*mc
)
470 struct microcode_intel
*mc_saved_tmp
[MAX_UCODE_COUNT
];
471 unsigned int mc_saved_count_init
;
472 unsigned int mc_saved_count
;
473 struct microcode_intel
**mc_saved
;
478 * Hold hotplug lock so mc_saved_data is not accessed by a CPU in
481 mutex_lock(&x86_cpu_microcode_mutex
);
483 mc_saved_count_init
= mc_saved_data
.mc_saved_count
;
484 mc_saved_count
= mc_saved_data
.mc_saved_count
;
485 mc_saved
= mc_saved_data
.mc_saved
;
487 if (mc_saved
&& mc_saved_count
)
488 memcpy(mc_saved_tmp
, mc_saved
,
489 mc_saved_count
* sizeof(struct microcode_intel
*));
491 * Save the microcode patch mc in mc_save_tmp structure if it's a newer
494 mc_saved_count
= _save_mc(mc_saved_tmp
, mc
, mc_saved_count
);
497 * Save the mc_save_tmp in global mc_saved_data.
499 ret
= save_microcode(&mc_saved_data
, mc_saved_tmp
, mc_saved_count
);
501 pr_err("Cannot save microcode patch.\n");
508 * Free old saved microcode data.
511 for (i
= 0; i
< mc_saved_count_init
; i
++)
517 mutex_unlock(&x86_cpu_microcode_mutex
);
521 EXPORT_SYMBOL_GPL(save_mc_for_early
);
524 static __initdata
char ucode_name
[] = "kernel/x86/microcode/GenuineIntel.bin";
525 static __init
enum ucode_state
526 scan_microcode(struct mc_saved_data
*mc_saved_data
, unsigned long *initrd
,
527 unsigned long start
, unsigned long size
,
528 struct ucode_cpu_info
*uci
)
533 char *p
= (char *)__pa_nodebug(ucode_name
);
535 char *p
= ucode_name
;
541 cd
= find_cpio_data(p
, (void *)start
, size
, &offset
);
545 return get_matching_model_microcode(0, start
, cd
.data
, cd
.size
,
546 mc_saved_data
, initrd
, uci
);
550 * Print ucode update info.
553 print_ucode_info(struct ucode_cpu_info
*uci
, unsigned int date
)
555 int cpu
= smp_processor_id();
557 pr_info("CPU%d microcode updated early to revision 0x%x, date = %04x-%02x-%02x\n",
562 (date
>> 16) & 0xff);
567 static int delay_ucode_info
;
568 static int current_mc_date
;
571 * Print early updated ucode info after printk works. This is delayed info dump.
573 void show_ucode_info_early(void)
575 struct ucode_cpu_info uci
;
577 if (delay_ucode_info
) {
578 collect_cpu_info_early(&uci
);
579 print_ucode_info(&uci
, current_mc_date
);
580 delay_ucode_info
= 0;
585 * At this point, we can not call printk() yet. Keep microcode patch number in
586 * mc_saved_data.mc_saved and delay printing microcode info in
587 * show_ucode_info_early() until printk() works.
589 static void print_ucode(struct ucode_cpu_info
*uci
)
591 struct microcode_intel
*mc_intel
;
592 int *delay_ucode_info_p
;
593 int *current_mc_date_p
;
596 if (mc_intel
== NULL
)
599 delay_ucode_info_p
= (int *)__pa_nodebug(&delay_ucode_info
);
600 current_mc_date_p
= (int *)__pa_nodebug(¤t_mc_date
);
602 *delay_ucode_info_p
= 1;
603 *current_mc_date_p
= mc_intel
->hdr
.date
;
608 * Flush global tlb. We only do this in x86_64 where paging has been enabled
609 * already and PGE should be enabled as well.
611 static inline void flush_tlb_early(void)
613 __native_flush_tlb_global_irq_disabled();
616 static inline void print_ucode(struct ucode_cpu_info
*uci
)
618 struct microcode_intel
*mc_intel
;
621 if (mc_intel
== NULL
)
624 print_ucode_info(uci
, mc_intel
->hdr
.date
);
628 static int apply_microcode_early(struct ucode_cpu_info
*uci
, bool early
)
630 struct microcode_intel
*mc_intel
;
634 if (mc_intel
== NULL
)
637 /* write microcode via MSR 0x79 */
638 native_wrmsr(MSR_IA32_UCODE_WRITE
,
639 (unsigned long) mc_intel
->bits
,
640 (unsigned long) mc_intel
->bits
>> 16 >> 16);
641 native_wrmsr(MSR_IA32_UCODE_REV
, 0, 0);
643 /* As documented in the SDM: Do a CPUID 1 here */
646 /* get the current revision from MSR 0x8B */
647 native_rdmsr(MSR_IA32_UCODE_REV
, val
[0], val
[1]);
648 if (val
[1] != mc_intel
->hdr
.rev
)
652 /* Flush global tlb. This is precaution. */
655 uci
->cpu_sig
.rev
= val
[1];
660 print_ucode_info(uci
, mc_intel
->hdr
.date
);
666 * This function converts microcode patch offsets previously stored in
667 * mc_saved_in_initrd to pointers and stores the pointers in mc_saved_data.
669 int __init
save_microcode_in_initrd_intel(void)
671 unsigned int count
= mc_saved_data
.mc_saved_count
;
672 struct microcode_intel
*mc_saved
[MAX_UCODE_COUNT
];
678 copy_initrd_ptrs(mc_saved
, mc_saved_in_initrd
, initrd_start
, count
);
679 ret
= save_microcode(&mc_saved_data
, mc_saved
, count
);
681 pr_err("Cannot save microcode patches from initrd.\n");
689 _load_ucode_intel_bsp(struct mc_saved_data
*mc_saved_data
,
690 unsigned long *initrd
,
691 unsigned long start
, unsigned long size
)
693 struct ucode_cpu_info uci
;
694 enum ucode_state ret
;
696 collect_cpu_info_early(&uci
);
698 ret
= scan_microcode(mc_saved_data
, initrd
, start
, size
, &uci
);
702 ret
= load_microcode(mc_saved_data
, initrd
, start
, &uci
);
706 apply_microcode_early(&uci
, true);
709 void __init
load_ucode_intel_bsp(void)
713 struct boot_params
*p
;
715 p
= (struct boot_params
*)__pa_nodebug(&boot_params
);
716 start
= p
->hdr
.ramdisk_image
;
717 size
= p
->hdr
.ramdisk_size
;
719 _load_ucode_intel_bsp(
720 (struct mc_saved_data
*)__pa_nodebug(&mc_saved_data
),
721 (unsigned long *)__pa_nodebug(&mc_saved_in_initrd
),
724 start
= boot_params
.hdr
.ramdisk_image
+ PAGE_OFFSET
;
725 size
= boot_params
.hdr
.ramdisk_size
;
727 _load_ucode_intel_bsp(&mc_saved_data
, mc_saved_in_initrd
, start
, size
);
731 void load_ucode_intel_ap(void)
733 struct mc_saved_data
*mc_saved_data_p
;
734 struct ucode_cpu_info uci
;
735 unsigned long *mc_saved_in_initrd_p
;
736 unsigned long initrd_start_addr
;
737 enum ucode_state ret
;
739 unsigned long *initrd_start_p
;
741 mc_saved_in_initrd_p
=
742 (unsigned long *)__pa_nodebug(mc_saved_in_initrd
);
743 mc_saved_data_p
= (struct mc_saved_data
*)__pa_nodebug(&mc_saved_data
);
744 initrd_start_p
= (unsigned long *)__pa_nodebug(&initrd_start
);
745 initrd_start_addr
= (unsigned long)__pa_nodebug(*initrd_start_p
);
747 mc_saved_data_p
= &mc_saved_data
;
748 mc_saved_in_initrd_p
= mc_saved_in_initrd
;
749 initrd_start_addr
= initrd_start
;
753 * If there is no valid ucode previously saved in memory, no need to
754 * update ucode on this AP.
756 if (mc_saved_data_p
->mc_saved_count
== 0)
759 collect_cpu_info_early(&uci
);
760 ret
= load_microcode(mc_saved_data_p
, mc_saved_in_initrd_p
,
761 initrd_start_addr
, &uci
);
766 apply_microcode_early(&uci
, true);
769 void reload_ucode_intel(void)
771 struct ucode_cpu_info uci
;
772 enum ucode_state ret
;
774 if (!mc_saved_data
.mc_saved_count
)
777 collect_cpu_info_early(&uci
);
779 ret
= load_microcode_early(mc_saved_data
.mc_saved
,
780 mc_saved_data
.mc_saved_count
, &uci
);
784 apply_microcode_early(&uci
, false);
This page took 0.052238 seconds and 5 git commands to generate.