]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - arch/x86/kernel/microcode_amd.c
Merge branch 'x86-rdrand-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[~shefty/rdma-dev.git] / arch / x86 / kernel / microcode_amd.c
1 /*
2  *  AMD CPU Microcode Update Driver for Linux
3  *  Copyright (C) 2008 Advanced Micro Devices Inc.
4  *
5  *  Author: Peter Oruba <peter.oruba@amd.com>
6  *
7  *  Based on work by:
8  *  Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
9  *
10  *  This driver allows to upgrade microcode on AMD
11  *  family 0x10 and 0x11 processors.
12  *
13  *  Licensed under the terms of the GNU General Public
14  *  License version 2. See file COPYING for details.
15  */
16
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
19 #include <linux/firmware.h>
20 #include <linux/pci_ids.h>
21 #include <linux/uaccess.h>
22 #include <linux/vmalloc.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/pci.h>
26
27 #include <asm/microcode.h>
28 #include <asm/processor.h>
29 #include <asm/msr.h>
30
31 MODULE_DESCRIPTION("AMD Microcode Update Driver");
32 MODULE_AUTHOR("Peter Oruba");
33 MODULE_LICENSE("GPL v2");
34
35 #define UCODE_MAGIC                0x00414d44
36 #define UCODE_EQUIV_CPU_TABLE_TYPE 0x00000000
37 #define UCODE_UCODE_TYPE           0x00000001
38
39 struct equiv_cpu_entry {
40         u32     installed_cpu;
41         u32     fixed_errata_mask;
42         u32     fixed_errata_compare;
43         u16     equiv_cpu;
44         u16     res;
45 } __attribute__((packed));
46
47 struct microcode_header_amd {
48         u32     data_code;
49         u32     patch_id;
50         u16     mc_patch_data_id;
51         u8      mc_patch_data_len;
52         u8      init_flag;
53         u32     mc_patch_data_checksum;
54         u32     nb_dev_id;
55         u32     sb_dev_id;
56         u16     processor_rev_id;
57         u8      nb_rev_id;
58         u8      sb_rev_id;
59         u8      bios_api_rev;
60         u8      reserved1[3];
61         u32     match_reg[8];
62 } __attribute__((packed));
63
64 struct microcode_amd {
65         struct microcode_header_amd     hdr;
66         unsigned int                    mpb[0];
67 };
68
69 #define SECTION_HDR_SIZE        8
70 #define CONTAINER_HDR_SZ        12
71
72 static struct equiv_cpu_entry *equiv_cpu_table;
73
74 static int collect_cpu_info_amd(int cpu, struct cpu_signature *csig)
75 {
76         struct cpuinfo_x86 *c = &cpu_data(cpu);
77
78         if (c->x86_vendor != X86_VENDOR_AMD || c->x86 < 0x10) {
79                 pr_warning("CPU%d: family %d not supported\n", cpu, c->x86);
80                 return -1;
81         }
82
83         csig->rev = c->microcode;
84         pr_info("CPU%d: patch_level=0x%08x\n", cpu, csig->rev);
85
86         return 0;
87 }
88
89 static int get_matching_microcode(int cpu, struct microcode_header_amd *mc_hdr,
90                                   int rev)
91 {
92         unsigned int current_cpu_id;
93         u16 equiv_cpu_id = 0;
94         unsigned int i = 0;
95
96         BUG_ON(equiv_cpu_table == NULL);
97         current_cpu_id = cpuid_eax(0x00000001);
98
99         while (equiv_cpu_table[i].installed_cpu != 0) {
100                 if (current_cpu_id == equiv_cpu_table[i].installed_cpu) {
101                         equiv_cpu_id = equiv_cpu_table[i].equiv_cpu;
102                         break;
103                 }
104                 i++;
105         }
106
107         if (!equiv_cpu_id)
108                 return 0;
109
110         if (mc_hdr->processor_rev_id != equiv_cpu_id)
111                 return 0;
112
113         /* ucode might be chipset specific -- currently we don't support this */
114         if (mc_hdr->nb_dev_id || mc_hdr->sb_dev_id) {
115                 pr_err("CPU%d: chipset specific code not yet supported\n",
116                        cpu);
117                 return 0;
118         }
119
120         if (mc_hdr->patch_id <= rev)
121                 return 0;
122
123         return 1;
124 }
125
126 static int apply_microcode_amd(int cpu)
127 {
128         u32 rev, dummy;
129         int cpu_num = raw_smp_processor_id();
130         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
131         struct microcode_amd *mc_amd = uci->mc;
132         struct cpuinfo_x86 *c = &cpu_data(cpu);
133
134         /* We should bind the task to the CPU */
135         BUG_ON(cpu_num != cpu);
136
137         if (mc_amd == NULL)
138                 return 0;
139
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);
143
144         /* check current patch id and patch's id for match */
145         if (rev != mc_amd->hdr.patch_id) {
146                 pr_err("CPU%d: update failed for patch_level=0x%08x\n",
147                        cpu, mc_amd->hdr.patch_id);
148                 return -1;
149         }
150
151         pr_info("CPU%d: new patch_level=0x%08x\n", cpu, rev);
152         uci->cpu_sig.rev = rev;
153         c->microcode = rev;
154
155         return 0;
156 }
157
158 static unsigned int verify_ucode_size(int cpu, const u8 *buf, unsigned int size)
159 {
160         struct cpuinfo_x86 *c = &cpu_data(cpu);
161         u32 max_size, actual_size;
162
163 #define F1XH_MPB_MAX_SIZE 2048
164 #define F14H_MPB_MAX_SIZE 1824
165 #define F15H_MPB_MAX_SIZE 4096
166
167         switch (c->x86) {
168         case 0x14:
169                 max_size = F14H_MPB_MAX_SIZE;
170                 break;
171         case 0x15:
172                 max_size = F15H_MPB_MAX_SIZE;
173                 break;
174         default:
175                 max_size = F1XH_MPB_MAX_SIZE;
176                 break;
177         }
178
179         actual_size = *(u32 *)(buf + 4);
180
181         if (actual_size + SECTION_HDR_SIZE > size || actual_size > max_size) {
182                 pr_err("section size mismatch\n");
183                 return 0;
184         }
185
186         return actual_size;
187 }
188
189 static struct microcode_header_amd *
190 get_next_ucode(int cpu, const u8 *buf, unsigned int size, unsigned int *mc_size)
191 {
192         struct microcode_header_amd *mc = NULL;
193         unsigned int actual_size = 0;
194
195         if (*(u32 *)buf != UCODE_UCODE_TYPE) {
196                 pr_err("invalid type field in container file section header\n");
197                 goto out;
198         }
199
200         actual_size = verify_ucode_size(cpu, buf, size);
201         if (!actual_size)
202                 goto out;
203
204         mc = vzalloc(actual_size);
205         if (!mc)
206                 goto out;
207
208         get_ucode_data(mc, buf + SECTION_HDR_SIZE, actual_size);
209         *mc_size = actual_size + SECTION_HDR_SIZE;
210
211 out:
212         return mc;
213 }
214
215 static int install_equiv_cpu_table(const u8 *buf)
216 {
217         unsigned int *ibuf = (unsigned int *)buf;
218         unsigned int type = ibuf[1];
219         unsigned int size = ibuf[2];
220
221         if (type != UCODE_EQUIV_CPU_TABLE_TYPE || !size) {
222                 pr_err("empty section/"
223                        "invalid type field in container file section header\n");
224                 return -EINVAL;
225         }
226
227         equiv_cpu_table = vmalloc(size);
228         if (!equiv_cpu_table) {
229                 pr_err("failed to allocate equivalent CPU table\n");
230                 return -ENOMEM;
231         }
232
233         get_ucode_data(equiv_cpu_table, buf + CONTAINER_HDR_SZ, size);
234
235         /* add header length */
236         return size + CONTAINER_HDR_SZ;
237 }
238
239 static void free_equiv_cpu_table(void)
240 {
241         vfree(equiv_cpu_table);
242         equiv_cpu_table = NULL;
243 }
244
245 static enum ucode_state
246 generic_load_microcode(int cpu, const u8 *data, size_t size)
247 {
248         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
249         struct microcode_header_amd *mc_hdr = NULL;
250         unsigned int mc_size, leftover;
251         int offset;
252         const u8 *ucode_ptr = data;
253         void *new_mc = NULL;
254         unsigned int new_rev = uci->cpu_sig.rev;
255         enum ucode_state state = UCODE_OK;
256
257         offset = install_equiv_cpu_table(ucode_ptr);
258         if (offset < 0) {
259                 pr_err("failed to create equivalent cpu table\n");
260                 return UCODE_ERROR;
261         }
262
263         ucode_ptr += offset;
264         leftover = size - offset;
265
266         while (leftover) {
267                 mc_hdr = get_next_ucode(cpu, ucode_ptr, leftover, &mc_size);
268                 if (!mc_hdr)
269                         break;
270
271                 if (get_matching_microcode(cpu, mc_hdr, new_rev)) {
272                         vfree(new_mc);
273                         new_rev = mc_hdr->patch_id;
274                         new_mc  = mc_hdr;
275                 } else
276                         vfree(mc_hdr);
277
278                 ucode_ptr += mc_size;
279                 leftover  -= mc_size;
280         }
281
282         if (!new_mc) {
283                 state = UCODE_NFOUND;
284                 goto free_table;
285         }
286
287         if (!leftover) {
288                 vfree(uci->mc);
289                 uci->mc = new_mc;
290                 pr_debug("CPU%d update ucode (0x%08x -> 0x%08x)\n",
291                          cpu, uci->cpu_sig.rev, new_rev);
292         } else {
293                 vfree(new_mc);
294                 state = UCODE_ERROR;
295         }
296
297 free_table:
298         free_equiv_cpu_table();
299
300         return state;
301 }
302
303 static enum ucode_state request_microcode_amd(int cpu, struct device *device)
304 {
305         const char *fw_name = "amd-ucode/microcode_amd.bin";
306         const struct firmware *fw;
307         enum ucode_state ret = UCODE_NFOUND;
308
309         if (request_firmware(&fw, fw_name, device)) {
310                 pr_err("failed to load file %s\n", fw_name);
311                 goto out;
312         }
313
314         ret = UCODE_ERROR;
315         if (*(u32 *)fw->data != UCODE_MAGIC) {
316                 pr_err("invalid magic value (0x%08x)\n", *(u32 *)fw->data);
317                 goto fw_release;
318         }
319
320         ret = generic_load_microcode(cpu, fw->data, fw->size);
321
322 fw_release:
323         release_firmware(fw);
324
325 out:
326         return ret;
327 }
328
329 static enum ucode_state
330 request_microcode_user(int cpu, const void __user *buf, size_t size)
331 {
332         pr_info("AMD microcode update via /dev/cpu/microcode not supported\n");
333         return UCODE_ERROR;
334 }
335
336 static void microcode_fini_cpu_amd(int cpu)
337 {
338         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
339
340         vfree(uci->mc);
341         uci->mc = NULL;
342 }
343
344 static struct microcode_ops microcode_amd_ops = {
345         .request_microcode_user           = request_microcode_user,
346         .request_microcode_fw             = request_microcode_amd,
347         .collect_cpu_info                 = collect_cpu_info_amd,
348         .apply_microcode                  = apply_microcode_amd,
349         .microcode_fini_cpu               = microcode_fini_cpu_amd,
350 };
351
352 struct microcode_ops * __init init_amd_microcode(void)
353 {
354         return &microcode_amd_ops;
355 }