2 * AMD CPU Microcode Update Driver for Linux
3 * Copyright (C) 2008 Advanced Micro Devices Inc.
5 * Author: Peter Oruba <peter.oruba@amd.com>
8 * Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
10 * This driver allows to upgrade microcode on AMD
11 * family 0x10 and 0x11 processors.
13 * Licensed under the terms of the GNU General Public
14 * License version 2. See file COPYING for details.
16 #include <linux/firmware.h>
17 #include <linux/pci_ids.h>
18 #include <linux/uaccess.h>
19 #include <linux/vmalloc.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/pci.h>
24 #include <asm/microcode.h>
25 #include <asm/processor.h>
28 MODULE_DESCRIPTION("AMD Microcode Update Driver");
29 MODULE_AUTHOR("Peter Oruba");
30 MODULE_LICENSE("GPL v2");
32 #define UCODE_MAGIC 0x00414d44
33 #define UCODE_EQUIV_CPU_TABLE_TYPE 0x00000000
34 #define UCODE_UCODE_TYPE 0x00000001
36 const struct firmware
*firmware
;
38 struct equiv_cpu_entry
{
40 u32 fixed_errata_mask
;
41 u32 fixed_errata_compare
;
44 } __attribute__((packed
));
46 struct microcode_header_amd
{
52 u32 mc_patch_data_checksum
;
61 } __attribute__((packed
));
63 struct microcode_amd
{
64 struct microcode_header_amd hdr
;
68 #define UCODE_MAX_SIZE 2048
69 #define UCODE_CONTAINER_SECTION_HDR 8
70 #define UCODE_CONTAINER_HEADER_SIZE 12
72 static struct equiv_cpu_entry
*equiv_cpu_table
;
74 static int collect_cpu_info_amd(int cpu
, struct cpu_signature
*csig
)
76 struct cpuinfo_x86
*c
= &cpu_data(cpu
);
79 memset(csig
, 0, sizeof(*csig
));
80 if (c
->x86_vendor
!= X86_VENDOR_AMD
|| c
->x86
< 0x10) {
81 pr_warning("microcode: CPU%d: AMD CPU family 0x%x not "
82 "supported\n", cpu
, c
->x86
);
85 rdmsr(MSR_AMD64_PATCH_LEVEL
, csig
->rev
, dummy
);
86 pr_info("microcode: CPU%d: patch_level=0x%x\n", cpu
, csig
->rev
);
90 static int get_matching_microcode(int cpu
, void *mc
, int rev
)
92 struct microcode_header_amd
*mc_header
= mc
;
93 unsigned int current_cpu_id
;
97 BUG_ON(equiv_cpu_table
== NULL
);
98 current_cpu_id
= cpuid_eax(0x00000001);
100 while (equiv_cpu_table
[i
].installed_cpu
!= 0) {
101 if (current_cpu_id
== equiv_cpu_table
[i
].installed_cpu
) {
102 equiv_cpu_id
= equiv_cpu_table
[i
].equiv_cpu
;
111 if (mc_header
->processor_rev_id
!= equiv_cpu_id
)
114 /* ucode might be chipset specific -- currently we don't support this */
115 if (mc_header
->nb_dev_id
|| mc_header
->sb_dev_id
) {
116 pr_err(KERN_ERR
"microcode: CPU%d: loading of chipset "
117 "specific code not yet supported\n", cpu
);
121 if (mc_header
->patch_id
<= rev
)
127 static int apply_microcode_amd(int cpu
)
130 int cpu_num
= raw_smp_processor_id();
131 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu_num
;
132 struct microcode_amd
*mc_amd
= uci
->mc
;
134 /* We should bind the task to the CPU */
135 BUG_ON(cpu_num
!= cpu
);
140 wrmsrl(MSR_AMD64_PATCH_LOADER
, (u64
)(long)&mc_amd
->hdr
.data_code
);
141 /* get patch id after patching */
142 rdmsr(MSR_AMD64_PATCH_LEVEL
, rev
, dummy
);
144 /* check current patch id and patch's id for match */
145 if (rev
!= mc_amd
->hdr
.patch_id
) {
146 pr_err("microcode: CPU%d: update failed "
147 "(for patch_level=0x%x)\n", cpu
, mc_amd
->hdr
.patch_id
);
151 pr_info("microcode: CPU%d: updated (new patch_level=0x%x)\n", cpu
, rev
);
152 uci
->cpu_sig
.rev
= rev
;
157 static int get_ucode_data(void *to
, const u8
*from
, size_t n
)
164 get_next_ucode(const u8
*buf
, unsigned int size
, unsigned int *mc_size
)
166 unsigned int total_size
;
167 u8 section_hdr
[UCODE_CONTAINER_SECTION_HDR
];
170 if (get_ucode_data(section_hdr
, buf
, UCODE_CONTAINER_SECTION_HDR
))
173 if (section_hdr
[0] != UCODE_UCODE_TYPE
) {
174 pr_err("microcode: error: invalid type field in "
175 "container file section header\n");
179 total_size
= (unsigned long) (section_hdr
[4] + (section_hdr
[5] << 8));
181 if (total_size
> size
|| total_size
> UCODE_MAX_SIZE
) {
182 pr_err("microcode: error: size mismatch\n");
186 mc
= vmalloc(UCODE_MAX_SIZE
);
188 memset(mc
, 0, UCODE_MAX_SIZE
);
189 if (get_ucode_data(mc
, buf
+ UCODE_CONTAINER_SECTION_HDR
,
194 *mc_size
= total_size
+ UCODE_CONTAINER_SECTION_HDR
;
199 static int install_equiv_cpu_table(const u8
*buf
)
201 u8
*container_hdr
[UCODE_CONTAINER_HEADER_SIZE
];
202 unsigned int *buf_pos
= (unsigned int *)container_hdr
;
205 if (get_ucode_data(&container_hdr
, buf
, UCODE_CONTAINER_HEADER_SIZE
))
210 if (buf_pos
[1] != UCODE_EQUIV_CPU_TABLE_TYPE
|| !size
) {
211 pr_err("microcode: error: invalid type field in "
212 "container file section header\n");
216 equiv_cpu_table
= (struct equiv_cpu_entry
*) vmalloc(size
);
217 if (!equiv_cpu_table
) {
218 pr_err("microcode: failed to allocate equivalent CPU table\n");
222 buf
+= UCODE_CONTAINER_HEADER_SIZE
;
223 if (get_ucode_data(equiv_cpu_table
, buf
, size
)) {
224 vfree(equiv_cpu_table
);
228 return size
+ UCODE_CONTAINER_HEADER_SIZE
; /* add header length */
231 static void free_equiv_cpu_table(void)
233 vfree(equiv_cpu_table
);
234 equiv_cpu_table
= NULL
;
237 static enum ucode_state
238 generic_load_microcode(int cpu
, const u8
*data
, size_t size
)
240 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
241 const u8
*ucode_ptr
= data
;
244 int new_rev
= uci
->cpu_sig
.rev
;
245 unsigned int leftover
;
246 unsigned long offset
;
247 enum ucode_state state
= UCODE_OK
;
249 offset
= install_equiv_cpu_table(ucode_ptr
);
251 pr_err("microcode: failed to create equivalent cpu table\n");
256 leftover
= size
- offset
;
259 unsigned int uninitialized_var(mc_size
);
260 struct microcode_header_amd
*mc_header
;
262 mc
= get_next_ucode(ucode_ptr
, leftover
, &mc_size
);
266 mc_header
= (struct microcode_header_amd
*)mc
;
267 if (get_matching_microcode(cpu
, mc
, new_rev
)) {
269 new_rev
= mc_header
->patch_id
;
274 ucode_ptr
+= mc_size
;
282 pr_debug("microcode: CPU%d found a matching microcode "
283 "update with version 0x%x (current=0x%x)\n",
284 cpu
, new_rev
, uci
->cpu_sig
.rev
);
290 state
= UCODE_NFOUND
;
292 free_equiv_cpu_table();
297 static enum ucode_state
request_microcode_fw(int cpu
, struct device
*device
)
299 enum ucode_state ret
;
301 if (firmware
== NULL
)
304 if (*(u32
*)firmware
->data
!= UCODE_MAGIC
) {
305 pr_err("microcode: invalid UCODE_MAGIC (0x%08x)\n",
306 *(u32
*)firmware
->data
);
310 ret
= generic_load_microcode(cpu
, firmware
->data
, firmware
->size
);
315 static enum ucode_state
316 request_microcode_user(int cpu
, const void __user
*buf
, size_t size
)
318 pr_info("microcode: AMD microcode update via "
319 "/dev/cpu/microcode not supported\n");
323 static void microcode_fini_cpu_amd(int cpu
)
325 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
331 void init_microcode_amd(struct device
*device
)
333 const char *fw_name
= "amd-ucode/microcode_amd.bin";
334 if (request_firmware(&firmware
, fw_name
, device
))
335 pr_err("microcode: failed to load file %s\n", fw_name
);
338 void fini_microcode_amd(void)
340 release_firmware(firmware
);
343 static struct microcode_ops microcode_amd_ops
= {
344 .init
= init_microcode_amd
,
345 .fini
= fini_microcode_amd
,
346 .request_microcode_user
= request_microcode_user
,
347 .request_microcode_fw
= request_microcode_fw
,
348 .collect_cpu_info
= collect_cpu_info_amd
,
349 .apply_microcode
= apply_microcode_amd
,
350 .microcode_fini_cpu
= microcode_fini_cpu_amd
,
353 struct microcode_ops
* __init
init_amd_microcode(void)
355 return µcode_amd_ops
;