1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73#include <linux/firmware.h>
74#include <linux/uaccess.h>
75#include <linux/kernel.h>
76#include <linux/module.h>
77#include <linux/vmalloc.h>
78
79#include <asm/microcode.h>
80#include <asm/processor.h>
81#include <asm/msr.h>
82
83MODULE_DESCRIPTION("Microcode Update Driver");
84MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
85MODULE_LICENSE("GPL");
86
87struct microcode_header_intel {
88 unsigned int hdrver;
89 unsigned int rev;
90 unsigned int date;
91 unsigned int sig;
92 unsigned int cksum;
93 unsigned int ldrver;
94 unsigned int pf;
95 unsigned int datasize;
96 unsigned int totalsize;
97 unsigned int reserved[3];
98};
99
100struct microcode_intel {
101 struct microcode_header_intel hdr;
102 unsigned int bits[0];
103};
104
105
106struct extended_signature {
107 unsigned int sig;
108 unsigned int pf;
109 unsigned int cksum;
110};
111
112struct extended_sigtable {
113 unsigned int count;
114 unsigned int cksum;
115 unsigned int reserved[3];
116 struct extended_signature sigs[0];
117};
118
119#define DEFAULT_UCODE_DATASIZE (2000)
120#define MC_HEADER_SIZE (sizeof(struct microcode_header_intel))
121#define DEFAULT_UCODE_TOTALSIZE (DEFAULT_UCODE_DATASIZE + MC_HEADER_SIZE)
122#define EXT_HEADER_SIZE (sizeof(struct extended_sigtable))
123#define EXT_SIGNATURE_SIZE (sizeof(struct extended_signature))
124#define DWSIZE (sizeof(u32))
125
126#define get_totalsize(mc) \
127 (((struct microcode_intel *)mc)->hdr.totalsize ? \
128 ((struct microcode_intel *)mc)->hdr.totalsize : \
129 DEFAULT_UCODE_TOTALSIZE)
130
131#define get_datasize(mc) \
132 (((struct microcode_intel *)mc)->hdr.datasize ? \
133 ((struct microcode_intel *)mc)->hdr.datasize : DEFAULT_UCODE_DATASIZE)
134
135#define sigmatch(s1, s2, p1, p2) \
136 (((s1) == (s2)) && (((p1) & (p2)) || (((p1) == 0) && ((p2) == 0))))
137
138#define exttable_size(et) ((et)->count * EXT_SIGNATURE_SIZE + EXT_HEADER_SIZE)
139
140static int collect_cpu_info(int cpu_num, struct cpu_signature *csig)
141{
142 struct cpuinfo_x86 *c = &cpu_data(cpu_num);
143 unsigned int val[2];
144
145 memset(csig, 0, sizeof(*csig));
146
147 if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
148 cpu_has(c, X86_FEATURE_IA64)) {
149 printk(KERN_ERR "microcode: CPU%d not a capable Intel "
150 "processor\n", cpu_num);
151 return -1;
152 }
153
154 csig->sig = cpuid_eax(0x00000001);
155
156 if ((c->x86_model >= 5) || (c->x86 > 6)) {
157
158 rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
159 csig->pf = 1 << ((val[1] >> 18) & 7);
160 }
161
162 wrmsr(MSR_IA32_UCODE_REV, 0, 0);
163
164 sync_core();
165
166 rdmsr(MSR_IA32_UCODE_REV, val[0], csig->rev);
167
168 printk(KERN_INFO "microcode: CPU%d sig=0x%x, pf=0x%x, revision=0x%x\n",
169 cpu_num, csig->sig, csig->pf, csig->rev);
170
171 return 0;
172}
173
174static inline int update_match_cpu(struct cpu_signature *csig, int sig, int pf)
175{
176 return (!sigmatch(sig, csig->sig, pf, csig->pf)) ? 0 : 1;
177}
178
179static inline int
180update_match_revision(struct microcode_header_intel *mc_header, int rev)
181{
182 return (mc_header->rev <= rev) ? 0 : 1;
183}
184
185static int microcode_sanity_check(void *mc)
186{
187 unsigned long total_size, data_size, ext_table_size;
188 struct microcode_header_intel *mc_header = mc;
189 struct extended_sigtable *ext_header = NULL;
190 int sum, orig_sum, ext_sigcount = 0, i;
191 struct extended_signature *ext_sig;
192
193 total_size = get_totalsize(mc_header);
194 data_size = get_datasize(mc_header);
195
196 if (data_size + MC_HEADER_SIZE > total_size) {
197 printk(KERN_ERR "microcode: error! "
198 "Bad data size in microcode data file\n");
199 return -EINVAL;
200 }
201
202 if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
203 printk(KERN_ERR "microcode: error! "
204 "Unknown microcode update format\n");
205 return -EINVAL;
206 }
207 ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
208 if (ext_table_size) {
209 if ((ext_table_size < EXT_HEADER_SIZE)
210 || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
211 printk(KERN_ERR "microcode: error! "
212 "Small exttable size in microcode data file\n");
213 return -EINVAL;
214 }
215 ext_header = mc + MC_HEADER_SIZE + data_size;
216 if (ext_table_size != exttable_size(ext_header)) {
217 printk(KERN_ERR "microcode: error! "
218 "Bad exttable size in microcode data file\n");
219 return -EFAULT;
220 }
221 ext_sigcount = ext_header->count;
222 }
223
224
225 if (ext_table_size) {
226 int ext_table_sum = 0;
227 int *ext_tablep = (int *)ext_header;
228
229 i = ext_table_size / DWSIZE;
230 while (i--)
231 ext_table_sum += ext_tablep[i];
232 if (ext_table_sum) {
233 printk(KERN_WARNING "microcode: aborting, "
234 "bad extended signature table checksum\n");
235 return -EINVAL;
236 }
237 }
238
239
240 orig_sum = 0;
241 i = (MC_HEADER_SIZE + data_size) / DWSIZE;
242 while (i--)
243 orig_sum += ((int *)mc)[i];
244 if (orig_sum) {
245 printk(KERN_ERR "microcode: aborting, bad checksum\n");
246 return -EINVAL;
247 }
248 if (!ext_table_size)
249 return 0;
250
251 for (i = 0; i < ext_sigcount; i++) {
252 ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
253 EXT_SIGNATURE_SIZE * i;
254 sum = orig_sum
255 - (mc_header->sig + mc_header->pf + mc_header->cksum)
256 + (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
257 if (sum) {
258 printk(KERN_ERR "microcode: aborting, bad checksum\n");
259 return -EINVAL;
260 }
261 }
262 return 0;
263}
264
265
266
267
268
269static int
270get_matching_microcode(struct cpu_signature *cpu_sig, void *mc, int rev)
271{
272 struct microcode_header_intel *mc_header = mc;
273 struct extended_sigtable *ext_header;
274 unsigned long total_size = get_totalsize(mc_header);
275 int ext_sigcount, i;
276 struct extended_signature *ext_sig;
277
278 if (!update_match_revision(mc_header, rev))
279 return 0;
280
281 if (update_match_cpu(cpu_sig, mc_header->sig, mc_header->pf))
282 return 1;
283
284
285 if (total_size <= get_datasize(mc_header) + MC_HEADER_SIZE)
286 return 0;
287
288 ext_header = mc + get_datasize(mc_header) + MC_HEADER_SIZE;
289 ext_sigcount = ext_header->count;
290 ext_sig = (void *)ext_header + EXT_HEADER_SIZE;
291
292 for (i = 0; i < ext_sigcount; i++) {
293 if (update_match_cpu(cpu_sig, ext_sig->sig, ext_sig->pf))
294 return 1;
295 ext_sig++;
296 }
297 return 0;
298}
299
300static int apply_microcode(int cpu)
301{
302 struct microcode_intel *mc_intel;
303 struct ucode_cpu_info *uci;
304 unsigned int val[2];
305 int cpu_num;
306
307 cpu_num = raw_smp_processor_id();
308 uci = ucode_cpu_info + cpu;
309 mc_intel = uci->mc;
310
311
312 BUG_ON(cpu_num != cpu);
313
314 if (mc_intel == NULL)
315 return 0;
316
317
318 wrmsr(MSR_IA32_UCODE_WRITE,
319 (unsigned long) mc_intel->bits,
320 (unsigned long) mc_intel->bits >> 16 >> 16);
321 wrmsr(MSR_IA32_UCODE_REV, 0, 0);
322
323
324 sync_core();
325
326
327 rdmsr(MSR_IA32_UCODE_REV, val[0], val[1]);
328
329 if (val[1] != mc_intel->hdr.rev) {
330 printk(KERN_ERR "microcode: CPU%d update "
331 "to revision 0x%x failed\n",
332 cpu_num, mc_intel->hdr.rev);
333 return -1;
334 }
335 printk(KERN_INFO "microcode: CPU%d updated to revision "
336 "0x%x, date = %04x-%02x-%02x \n",
337 cpu_num, val[1],
338 mc_intel->hdr.date & 0xffff,
339 mc_intel->hdr.date >> 24,
340 (mc_intel->hdr.date >> 16) & 0xff);
341
342 uci->cpu_sig.rev = val[1];
343
344 return 0;
345}
346
347static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size,
348 int (*get_ucode_data)(void *, const void *, size_t))
349{
350 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
351 u8 *ucode_ptr = data, *new_mc = NULL, *mc;
352 int new_rev = uci->cpu_sig.rev;
353 unsigned int leftover = size;
354 enum ucode_state state = UCODE_OK;
355
356 while (leftover) {
357 struct microcode_header_intel mc_header;
358 unsigned int mc_size;
359
360 if (get_ucode_data(&mc_header, ucode_ptr, sizeof(mc_header)))
361 break;
362
363 mc_size = get_totalsize(&mc_header);
364 if (!mc_size || mc_size > leftover) {
365 printk(KERN_ERR "microcode: error!"
366 "Bad data in microcode data file\n");
367 break;
368 }
369
370 mc = vmalloc(mc_size);
371 if (!mc)
372 break;
373
374 if (get_ucode_data(mc, ucode_ptr, mc_size) ||
375 microcode_sanity_check(mc) < 0) {
376 vfree(mc);
377 break;
378 }
379
380 if (get_matching_microcode(&uci->cpu_sig, mc, new_rev)) {
381 if (new_mc)
382 vfree(new_mc);
383 new_rev = mc_header.rev;
384 new_mc = mc;
385 } else
386 vfree(mc);
387
388 ucode_ptr += mc_size;
389 leftover -= mc_size;
390 }
391
392 if (leftover) {
393 if (new_mc)
394 vfree(new_mc);
395 state = UCODE_ERROR;
396 goto out;
397 }
398
399 if (!new_mc) {
400 state = UCODE_NFOUND;
401 goto out;
402 }
403
404 if (uci->mc)
405 vfree(uci->mc);
406 uci->mc = (struct microcode_intel *)new_mc;
407
408 pr_debug("microcode: CPU%d found a matching microcode update with"
409 " version 0x%x (current=0x%x)\n",
410 cpu, new_rev, uci->cpu_sig.rev);
411out:
412 return state;
413}
414
415static int get_ucode_fw(void *to, const void *from, size_t n)
416{
417 memcpy(to, from, n);
418 return 0;
419}
420
421static enum ucode_state request_microcode_fw(int cpu, struct device *device)
422{
423 char name[30];
424 struct cpuinfo_x86 *c = &cpu_data(cpu);
425 const struct firmware *firmware;
426 enum ucode_state ret;
427
428 sprintf(name, "intel-ucode/%02x-%02x-%02x",
429 c->x86, c->x86_model, c->x86_mask);
430
431 if (request_firmware(&firmware, name, device)) {
432 pr_debug("microcode: data file %s load failed\n", name);
433 return UCODE_NFOUND;
434 }
435
436 ret = generic_load_microcode(cpu, (void *)firmware->data,
437 firmware->size, &get_ucode_fw);
438
439 release_firmware(firmware);
440
441 return ret;
442}
443
444static int get_ucode_user(void *to, const void *from, size_t n)
445{
446 return copy_from_user(to, from, n);
447}
448
449static enum ucode_state
450request_microcode_user(int cpu, const void __user *buf, size_t size)
451{
452 return generic_load_microcode(cpu, (void *)buf, size, &get_ucode_user);
453}
454
455static void microcode_fini_cpu(int cpu)
456{
457 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
458
459 vfree(uci->mc);
460 uci->mc = NULL;
461}
462
463static struct microcode_ops microcode_intel_ops = {
464 .request_microcode_user = request_microcode_user,
465 .request_microcode_fw = request_microcode_fw,
466 .collect_cpu_info = collect_cpu_info,
467 .apply_microcode = apply_microcode,
468 .microcode_fini_cpu = microcode_fini_cpu,
469};
470
471struct microcode_ops * __init init_intel_microcode(void)
472{
473 return µcode_intel_ops;
474}
475
476