2 * Copyright (C) 2013 Advanced Micro Devices, Inc.
4 * Author: Jacob Shin <jacob.shin@amd.com>
5 * Fixes: Borislav Petkov <bp@suse.de>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/earlycpio.h>
13 #include <linux/initrd.h>
16 #include <asm/setup.h>
17 #include <asm/microcode_amd.h>
20 * This points to the current valid container of microcode patches which we will
21 * save from the initrd before jettisoning its contents.
24 static size_t container_size
;
26 static u32 ucode_new_rev
;
27 u8 amd_ucode_patch
[PATCH_MAX_SIZE
];
28 static u16 this_equiv_id
;
30 struct cpio_data ucode_cpio
;
33 * Microcode patch container file is prepended to the initrd in cpio format.
34 * See Documentation/x86/early-microcode.txt
36 static __initdata
char ucode_path
[] = "kernel/x86/microcode/AuthenticAMD.bin";
38 static struct cpio_data __init
find_ucode_in_initrd(void)
46 struct boot_params
*p
;
49 * On 32-bit, early load occurs before paging is turned on so we need
50 * to use physical addresses.
52 p
= (struct boot_params
*)__pa_nodebug(&boot_params
);
53 path
= (char *)__pa_nodebug(ucode_path
);
54 start
= (void *)p
->hdr
.ramdisk_image
;
55 size
= p
->hdr
.ramdisk_size
;
58 start
= (void *)(boot_params
.hdr
.ramdisk_image
+ PAGE_OFFSET
);
59 size
= boot_params
.hdr
.ramdisk_size
;
62 return find_cpio_data(path
, start
, size
, &offset
);
65 static size_t compute_container_size(u8
*data
, u32 total_size
)
68 u32
*header
= (u32
*)data
;
70 if (header
[0] != UCODE_MAGIC
||
71 header
[1] != UCODE_EQUIV_CPU_TABLE_TYPE
|| /* type */
72 header
[2] == 0) /* size */
75 size
= header
[2] + CONTAINER_HDR_SZ
;
84 if (header
[0] != UCODE_UCODE_TYPE
)
88 * Sanity-check patch size.
90 patch_size
= header
[1];
91 if (patch_size
> PATCH_MAX_SIZE
)
94 size
+= patch_size
+ SECTION_HDR_SIZE
;
95 data
+= patch_size
+ SECTION_HDR_SIZE
;
96 total_size
-= patch_size
+ SECTION_HDR_SIZE
;
103 * Early load occurs before we can vmalloc(). So we look for the microcode
104 * patch container file in initrd, traverse equivalent cpu table, look for a
105 * matching microcode patch, and update, all in initrd memory in place.
106 * When vmalloc() is available for use later -- on 64-bit during first AP load,
107 * and on 32-bit during save_microcode_in_initrd_amd() -- we can call
108 * load_microcode_amd() to save equivalent cpu table and microcode patches in
109 * kernel heap memory.
111 static void apply_ucode_in_initrd(void *ucode
, size_t size
)
113 struct equiv_cpu_entry
*eq
;
119 u32 rev
, eax
, ebx
, ecx
, edx
;
123 new_rev
= (u32
*)__pa_nodebug(&ucode_new_rev
);
124 cont_sz
= (size_t *)__pa_nodebug(&container_size
);
125 cont
= (u8
**)__pa_nodebug(&container
);
127 new_rev
= &ucode_new_rev
;
128 cont_sz
= &container_size
;
134 header
= (u32
*)data
;
136 /* find equiv cpu table */
137 if (header
[0] != UCODE_MAGIC
||
138 header
[1] != UCODE_EQUIV_CPU_TABLE_TYPE
|| /* type */
139 header
[2] == 0) /* size */
144 native_cpuid(&eax
, &ebx
, &ecx
, &edx
);
147 eq
= (struct equiv_cpu_entry
*)(data
+ CONTAINER_HDR_SZ
);
151 /* Advance past the container header */
152 offset
= header
[2] + CONTAINER_HDR_SZ
;
156 eq_id
= find_equiv_id(eq
, eax
);
158 this_equiv_id
= eq_id
;
159 *cont_sz
= compute_container_size(*cont
, left
+ offset
);
162 * truncate how much we need to iterate over in the
163 * ucode update loop below
165 left
= *cont_sz
- offset
;
170 * support multiple container files appended together. if this
171 * one does not have a matching equivalent cpu entry, we fast
172 * forward to the next container file.
175 header
= (u32
*)data
;
176 if (header
[0] == UCODE_MAGIC
&&
177 header
[1] == UCODE_EQUIV_CPU_TABLE_TYPE
)
180 offset
= header
[1] + SECTION_HDR_SIZE
;
185 /* mark where the next microcode container file starts */
186 offset
= data
- (u8
*)ucode
;
196 /* find ucode and update if needed */
198 native_rdmsr(MSR_AMD64_PATCH_LEVEL
, rev
, eax
);
201 struct microcode_amd
*mc
;
203 header
= (u32
*)data
;
204 if (header
[0] != UCODE_UCODE_TYPE
|| /* type */
205 header
[1] == 0) /* size */
208 mc
= (struct microcode_amd
*)(data
+ SECTION_HDR_SIZE
);
210 if (eq_id
== mc
->hdr
.processor_rev_id
&& rev
< mc
->hdr
.patch_id
) {
212 if (!__apply_microcode_amd(mc
)) {
213 rev
= mc
->hdr
.patch_id
;
216 /* save ucode patch */
217 memcpy(amd_ucode_patch
, mc
,
218 min_t(u32
, header
[1], PATCH_MAX_SIZE
));
222 offset
= header
[1] + SECTION_HDR_SIZE
;
228 void __init
load_ucode_amd_bsp(void)
235 data
= (void **)__pa_nodebug(&ucode_cpio
.data
);
236 size
= (size_t *)__pa_nodebug(&ucode_cpio
.size
);
238 data
= &ucode_cpio
.data
;
239 size
= &ucode_cpio
.size
;
242 cp
= find_ucode_in_initrd();
249 apply_ucode_in_initrd(cp
.data
, cp
.size
);
254 * On 32-bit, since AP's early load occurs before paging is turned on, we
255 * cannot traverse cpu_equiv_table and pcache in kernel heap memory. So during
256 * cold boot, AP will apply_ucode_in_initrd() just like the BSP. During
257 * save_microcode_in_initrd_amd() BSP's patch is copied to amd_ucode_patch,
258 * which is used upon resume from suspend.
260 void load_ucode_amd_ap(void)
262 struct microcode_amd
*mc
;
266 mc
= (struct microcode_amd
*)__pa(amd_ucode_patch
);
267 if (mc
->hdr
.patch_id
&& mc
->hdr
.processor_rev_id
) {
268 __apply_microcode_amd(mc
);
272 ucode
= (void *)__pa_nodebug(&container
);
273 usize
= (size_t *)__pa_nodebug(&container_size
);
275 if (!*ucode
|| !*usize
)
278 apply_ucode_in_initrd(*ucode
, *usize
);
281 static void __init
collect_cpu_sig_on_bsp(void *arg
)
283 unsigned int cpu
= smp_processor_id();
284 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
286 uci
->cpu_sig
.sig
= cpuid_eax(0x00000001);
289 static void __init
get_bsp_sig(void)
291 unsigned int bsp
= boot_cpu_data
.cpu_index
;
292 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ bsp
;
294 if (!uci
->cpu_sig
.sig
)
295 smp_call_function_single(bsp
, collect_cpu_sig_on_bsp
, NULL
, 1);
298 void load_ucode_amd_ap(void)
300 unsigned int cpu
= smp_processor_id();
301 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
302 struct equiv_cpu_entry
*eq
;
303 struct microcode_amd
*mc
;
307 /* Exit if called on the BSP. */
314 rdmsr(MSR_AMD64_PATCH_LEVEL
, rev
, eax
);
316 uci
->cpu_sig
.rev
= rev
;
317 uci
->cpu_sig
.sig
= eax
;
319 eax
= cpuid_eax(0x00000001);
320 eq
= (struct equiv_cpu_entry
*)(container
+ CONTAINER_HDR_SZ
);
322 eq_id
= find_equiv_id(eq
, eax
);
326 if (eq_id
== this_equiv_id
) {
327 mc
= (struct microcode_amd
*)amd_ucode_patch
;
329 if (mc
&& rev
< mc
->hdr
.patch_id
) {
330 if (!__apply_microcode_amd(mc
))
331 ucode_new_rev
= mc
->hdr
.patch_id
;
335 if (!ucode_cpio
.data
)
339 * AP has a different equivalence ID than BSP, looks like
340 * mixed-steppings silicon so go through the ucode blob anew.
342 apply_ucode_in_initrd(ucode_cpio
.data
, ucode_cpio
.size
);
347 int __init
save_microcode_in_initrd_amd(void)
350 enum ucode_state ret
;
358 cont
= (unsigned long)container
;
361 * We need the physical address of the container for both bitness since
362 * boot_params.hdr.ramdisk_image is a physical address.
364 cont
= __pa(container
);
368 * Take into account the fact that the ramdisk might get relocated and
369 * therefore we need to recompute the container's position in virtual
372 if (relocated_ramdisk
)
373 container
= (u8
*)(__va(relocated_ramdisk
) +
374 (cont
- boot_params
.hdr
.ramdisk_image
));
377 pr_info("microcode: updated early to new patch_level=0x%08x\n",
380 eax
= cpuid_eax(0x00000001);
381 eax
= ((eax
>> 8) & 0xf) + ((eax
>> 20) & 0xff);
383 ret
= load_microcode_amd(eax
, container
, container_size
);
388 * This will be freed any msec now, stash patches for the current
389 * family and switch to patch cache for cpu hotplug, etc later.