2 * AMD CPU Microcode Update Driver for Linux
3 * Copyright (C) 2008-2011 Advanced Micro Devices Inc.
5 * Author: Peter Oruba <peter.oruba@amd.com>
8 * Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
11 * Andreas Herrmann <herrmann.der.user@googlemail.com>
12 * Borislav Petkov <bp@alien8.de>
14 * This driver allows to upgrade microcode on F10h AMD
17 * Licensed under the terms of the GNU General Public
18 * License version 2. See file COPYING for details.
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/firmware.h>
24 #include <linux/uaccess.h>
25 #include <linux/vmalloc.h>
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/pci.h>
30 #include <asm/microcode.h>
31 #include <asm/processor.h>
33 #include <asm/microcode_amd.h>
35 MODULE_DESCRIPTION("AMD Microcode Update Driver");
36 MODULE_AUTHOR("Peter Oruba");
37 MODULE_LICENSE("GPL v2");
39 static struct equiv_cpu_entry
*equiv_cpu_table
;
42 struct list_head plist
;
48 static LIST_HEAD(pcache
);
50 static u16
__find_equiv_id(unsigned int cpu
)
52 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
53 return find_equiv_id(equiv_cpu_table
, uci
->cpu_sig
.sig
);
56 static u32
find_cpu_family_by_equiv_cpu(u16 equiv_cpu
)
60 BUG_ON(!equiv_cpu_table
);
62 while (equiv_cpu_table
[i
].equiv_cpu
!= 0) {
63 if (equiv_cpu
== equiv_cpu_table
[i
].equiv_cpu
)
64 return equiv_cpu_table
[i
].installed_cpu
;
71 * a small, trivial cache of per-family ucode patches
73 static struct ucode_patch
*cache_find_patch(u16 equiv_cpu
)
75 struct ucode_patch
*p
;
77 list_for_each_entry(p
, &pcache
, plist
)
78 if (p
->equiv_cpu
== equiv_cpu
)
83 static void update_cache(struct ucode_patch
*new_patch
)
85 struct ucode_patch
*p
;
87 list_for_each_entry(p
, &pcache
, plist
) {
88 if (p
->equiv_cpu
== new_patch
->equiv_cpu
) {
89 if (p
->patch_id
>= new_patch
->patch_id
)
90 /* we already have the latest patch */
93 list_replace(&p
->plist
, &new_patch
->plist
);
99 /* no patch found, add it */
100 list_add_tail(&new_patch
->plist
, &pcache
);
103 static void free_cache(void)
105 struct ucode_patch
*p
, *tmp
;
107 list_for_each_entry_safe(p
, tmp
, &pcache
, plist
) {
108 __list_del(p
->plist
.prev
, p
->plist
.next
);
114 static struct ucode_patch
*find_patch(unsigned int cpu
)
118 equiv_id
= __find_equiv_id(cpu
);
122 return cache_find_patch(equiv_id
);
125 static int collect_cpu_info_amd(int cpu
, struct cpu_signature
*csig
)
127 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
128 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
129 struct ucode_patch
*p
;
131 csig
->sig
= cpuid_eax(0x00000001);
132 csig
->rev
= c
->microcode
;
135 * a patch could have been loaded early, set uci->mc so that
136 * mc_bp_resume() can call apply_microcode()
139 if (p
&& (p
->patch_id
== csig
->rev
))
142 pr_info("CPU%d: patch_level=0x%08x\n", cpu
, csig
->rev
);
147 static unsigned int verify_patch_size(u8 family
, u32 patch_size
,
152 #define F1XH_MPB_MAX_SIZE 2048
153 #define F14H_MPB_MAX_SIZE 1824
154 #define F15H_MPB_MAX_SIZE 4096
155 #define F16H_MPB_MAX_SIZE 3458
159 max_size
= F14H_MPB_MAX_SIZE
;
162 max_size
= F15H_MPB_MAX_SIZE
;
165 max_size
= F16H_MPB_MAX_SIZE
;
168 max_size
= F1XH_MPB_MAX_SIZE
;
172 if (patch_size
> min_t(u32
, size
, max_size
)) {
173 pr_err("patch size mismatch\n");
181 * Check the current patch level on this CPU.
183 * @rev: Use it to return the patch level. It is set to 0 in the case of
187 * - true: if update should stop
190 bool check_current_patch_level(u32
*rev
)
194 native_rdmsr(MSR_AMD64_PATCH_LEVEL
, *rev
, dummy
);
199 int __apply_microcode_amd(struct microcode_amd
*mc_amd
)
203 native_wrmsrl(MSR_AMD64_PATCH_LOADER
, (u64
)(long)&mc_amd
->hdr
.data_code
);
205 /* verify patch application was successful */
206 native_rdmsr(MSR_AMD64_PATCH_LEVEL
, rev
, dummy
);
207 if (rev
!= mc_amd
->hdr
.patch_id
)
213 int apply_microcode_amd(int cpu
)
215 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
216 struct microcode_amd
*mc_amd
;
217 struct ucode_cpu_info
*uci
;
218 struct ucode_patch
*p
;
221 BUG_ON(raw_smp_processor_id() != cpu
);
223 uci
= ucode_cpu_info
+ cpu
;
232 if (check_current_patch_level(&rev
))
235 /* need to apply patch? */
236 if (rev
>= mc_amd
->hdr
.patch_id
) {
238 uci
->cpu_sig
.rev
= rev
;
242 if (__apply_microcode_amd(mc_amd
)) {
243 pr_err("CPU%d: update failed for patch_level=0x%08x\n",
244 cpu
, mc_amd
->hdr
.patch_id
);
247 pr_info("CPU%d: new patch_level=0x%08x\n", cpu
,
248 mc_amd
->hdr
.patch_id
);
250 uci
->cpu_sig
.rev
= mc_amd
->hdr
.patch_id
;
251 c
->microcode
= mc_amd
->hdr
.patch_id
;
256 static int install_equiv_cpu_table(const u8
*buf
)
258 unsigned int *ibuf
= (unsigned int *)buf
;
259 unsigned int type
= ibuf
[1];
260 unsigned int size
= ibuf
[2];
262 if (type
!= UCODE_EQUIV_CPU_TABLE_TYPE
|| !size
) {
263 pr_err("empty section/"
264 "invalid type field in container file section header\n");
268 equiv_cpu_table
= vmalloc(size
);
269 if (!equiv_cpu_table
) {
270 pr_err("failed to allocate equivalent CPU table\n");
274 memcpy(equiv_cpu_table
, buf
+ CONTAINER_HDR_SZ
, size
);
276 /* add header length */
277 return size
+ CONTAINER_HDR_SZ
;
280 static void free_equiv_cpu_table(void)
282 vfree(equiv_cpu_table
);
283 equiv_cpu_table
= NULL
;
286 static void cleanup(void)
288 free_equiv_cpu_table();
293 * We return the current size even if some of the checks failed so that
294 * we can skip over the next patch. If we return a negative value, we
295 * signal a grave error like a memory allocation has failed and the
296 * driver cannot continue functioning normally. In such cases, we tear
297 * down everything we've used up so far and exit.
299 static int verify_and_add_patch(u8 family
, u8
*fw
, unsigned int leftover
)
301 struct microcode_header_amd
*mc_hdr
;
302 struct ucode_patch
*patch
;
303 unsigned int patch_size
, crnt_size
, ret
;
307 patch_size
= *(u32
*)(fw
+ 4);
308 crnt_size
= patch_size
+ SECTION_HDR_SIZE
;
309 mc_hdr
= (struct microcode_header_amd
*)(fw
+ SECTION_HDR_SIZE
);
310 proc_id
= mc_hdr
->processor_rev_id
;
312 proc_fam
= find_cpu_family_by_equiv_cpu(proc_id
);
314 pr_err("No patch family for equiv ID: 0x%04x\n", proc_id
);
318 /* check if patch is for the current family */
319 proc_fam
= ((proc_fam
>> 8) & 0xf) + ((proc_fam
>> 20) & 0xff);
320 if (proc_fam
!= family
)
323 if (mc_hdr
->nb_dev_id
|| mc_hdr
->sb_dev_id
) {
324 pr_err("Patch-ID 0x%08x: chipset-specific code unsupported.\n",
329 ret
= verify_patch_size(family
, patch_size
, leftover
);
331 pr_err("Patch-ID 0x%08x: size mismatch.\n", mc_hdr
->patch_id
);
335 patch
= kzalloc(sizeof(*patch
), GFP_KERNEL
);
337 pr_err("Patch allocation failure.\n");
341 patch
->data
= kzalloc(patch_size
, GFP_KERNEL
);
343 pr_err("Patch data allocation failure.\n");
348 /* All looks ok, copy patch... */
349 memcpy(patch
->data
, fw
+ SECTION_HDR_SIZE
, patch_size
);
350 INIT_LIST_HEAD(&patch
->plist
);
351 patch
->patch_id
= mc_hdr
->patch_id
;
352 patch
->equiv_cpu
= proc_id
;
354 pr_debug("%s: Added patch_id: 0x%08x, proc_id: 0x%04x\n",
355 __func__
, patch
->patch_id
, proc_id
);
357 /* ... and add to cache. */
363 static enum ucode_state
__load_microcode_amd(u8 family
, const u8
*data
,
366 enum ucode_state ret
= UCODE_ERROR
;
367 unsigned int leftover
;
372 offset
= install_equiv_cpu_table(data
);
374 pr_err("failed to create equivalent cpu table\n");
378 leftover
= size
- offset
;
380 if (*(u32
*)fw
!= UCODE_UCODE_TYPE
) {
381 pr_err("invalid type field in container file section header\n");
382 free_equiv_cpu_table();
387 crnt_size
= verify_and_add_patch(family
, fw
, leftover
);
392 leftover
-= crnt_size
;
398 enum ucode_state
load_microcode_amd(int cpu
, u8 family
, const u8
*data
, size_t size
)
400 enum ucode_state ret
;
402 /* free old equiv table */
403 free_equiv_cpu_table();
405 ret
= __load_microcode_amd(family
, data
, size
);
410 #if defined(CONFIG_MICROCODE_AMD_EARLY) && defined(CONFIG_X86_32)
411 /* save BSP's matching patch for early load */
412 if (cpu_data(cpu
).cpu_index
== boot_cpu_data
.cpu_index
) {
413 struct ucode_patch
*p
= find_patch(cpu
);
415 memset(amd_ucode_patch
, 0, PATCH_MAX_SIZE
);
416 memcpy(amd_ucode_patch
, p
->data
, min_t(u32
, ksize(p
->data
),
425 * AMD microcode firmware naming convention, up to family 15h they are in
428 * amd-ucode/microcode_amd.bin
430 * This legacy file is always smaller than 2K in size.
432 * Beginning with family 15h, they are in family-specific firmware files:
434 * amd-ucode/microcode_amd_fam15h.bin
435 * amd-ucode/microcode_amd_fam16h.bin
438 * These might be larger than 2K.
440 static enum ucode_state
request_microcode_amd(int cpu
, struct device
*device
,
443 char fw_name
[36] = "amd-ucode/microcode_amd.bin";
444 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
445 enum ucode_state ret
= UCODE_NFOUND
;
446 const struct firmware
*fw
;
448 /* reload ucode container only on the boot cpu */
449 if (!refresh_fw
|| c
->cpu_index
!= boot_cpu_data
.cpu_index
)
453 snprintf(fw_name
, sizeof(fw_name
), "amd-ucode/microcode_amd_fam%.2xh.bin", c
->x86
);
455 if (request_firmware_direct(&fw
, (const char *)fw_name
, device
)) {
456 pr_debug("failed to load file %s\n", fw_name
);
461 if (*(u32
*)fw
->data
!= UCODE_MAGIC
) {
462 pr_err("invalid magic value (0x%08x)\n", *(u32
*)fw
->data
);
466 ret
= load_microcode_amd(cpu
, c
->x86
, fw
->data
, fw
->size
);
469 release_firmware(fw
);
475 static enum ucode_state
476 request_microcode_user(int cpu
, const void __user
*buf
, size_t size
)
481 static void microcode_fini_cpu_amd(int cpu
)
483 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
488 static struct microcode_ops microcode_amd_ops
= {
489 .request_microcode_user
= request_microcode_user
,
490 .request_microcode_fw
= request_microcode_amd
,
491 .collect_cpu_info
= collect_cpu_info_amd
,
492 .apply_microcode
= apply_microcode_amd
,
493 .microcode_fini_cpu
= microcode_fini_cpu_amd
,
496 struct microcode_ops
* __init
init_amd_microcode(void)
498 struct cpuinfo_x86
*c
= &cpu_data(0);
500 if (c
->x86_vendor
!= X86_VENDOR_AMD
|| c
->x86
< 0x10) {
501 pr_warning("AMD CPU family 0x%x not supported\n", c
->x86
);
505 return µcode_amd_ops
;
508 void __exit
exit_amd_microcode(void)