Merge tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[sfrench/cifs-2.6.git] / arch / x86 / kernel / cpu / microcode / intel.c
1 /*
2  * Intel CPU Microcode Update Driver for Linux
3  *
4  * Copyright (C) 2000-2006 Tigran Aivazian <aivazian.tigran@gmail.com>
5  *               2006 Shaohua Li <shaohua.li@intel.com>
6  *
7  * Intel CPU microcode early update for Linux
8  *
9  * Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
10  *                    H Peter Anvin" <hpa@zytor.com>
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version
15  * 2 of the License, or (at your option) any later version.
16  */
17
18 /*
19  * This needs to be before all headers so that pr_debug in printk.h doesn't turn
20  * printk calls into no_printk().
21  *
22  *#define DEBUG
23  */
24 #define pr_fmt(fmt) "microcode: " fmt
25
26 #include <linux/earlycpio.h>
27 #include <linux/firmware.h>
28 #include <linux/uaccess.h>
29 #include <linux/vmalloc.h>
30 #include <linux/initrd.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/cpu.h>
34 #include <linux/mm.h>
35
36 #include <asm/microcode_intel.h>
37 #include <asm/intel-family.h>
38 #include <asm/processor.h>
39 #include <asm/tlbflush.h>
40 #include <asm/setup.h>
41 #include <asm/msr.h>
42
43 static const char ucode_path[] = "kernel/x86/microcode/GenuineIntel.bin";
44
45 /* Current microcode patch used in early patching on the APs. */
46 static struct microcode_intel *intel_ucode_patch;
47
48 static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
49                                         unsigned int s2, unsigned int p2)
50 {
51         if (s1 != s2)
52                 return false;
53
54         /* Processor flags are either both 0 ... */
55         if (!p1 && !p2)
56                 return true;
57
58         /* ... or they intersect. */
59         return p1 & p2;
60 }
61
62 /*
63  * Returns 1 if update has been found, 0 otherwise.
64  */
65 static int find_matching_signature(void *mc, unsigned int csig, int cpf)
66 {
67         struct microcode_header_intel *mc_hdr = mc;
68         struct extended_sigtable *ext_hdr;
69         struct extended_signature *ext_sig;
70         int i;
71
72         if (cpu_signatures_match(csig, cpf, mc_hdr->sig, mc_hdr->pf))
73                 return 1;
74
75         /* Look for ext. headers: */
76         if (get_totalsize(mc_hdr) <= get_datasize(mc_hdr) + MC_HEADER_SIZE)
77                 return 0;
78
79         ext_hdr = mc + get_datasize(mc_hdr) + MC_HEADER_SIZE;
80         ext_sig = (void *)ext_hdr + EXT_HEADER_SIZE;
81
82         for (i = 0; i < ext_hdr->count; i++) {
83                 if (cpu_signatures_match(csig, cpf, ext_sig->sig, ext_sig->pf))
84                         return 1;
85                 ext_sig++;
86         }
87         return 0;
88 }
89
90 /*
91  * Returns 1 if update has been found, 0 otherwise.
92  */
93 static int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev)
94 {
95         struct microcode_header_intel *mc_hdr = mc;
96
97         if (mc_hdr->rev <= new_rev)
98                 return 0;
99
100         return find_matching_signature(mc, csig, cpf);
101 }
102
103 /*
104  * Given CPU signature and a microcode patch, this function finds if the
105  * microcode patch has matching family and model with the CPU.
106  *
107  * %true - if there's a match
108  * %false - otherwise
109  */
110 static bool microcode_matches(struct microcode_header_intel *mc_header,
111                               unsigned long sig)
112 {
113         unsigned long total_size = get_totalsize(mc_header);
114         unsigned long data_size = get_datasize(mc_header);
115         struct extended_sigtable *ext_header;
116         unsigned int fam_ucode, model_ucode;
117         struct extended_signature *ext_sig;
118         unsigned int fam, model;
119         int ext_sigcount, i;
120
121         fam   = x86_family(sig);
122         model = x86_model(sig);
123
124         fam_ucode   = x86_family(mc_header->sig);
125         model_ucode = x86_model(mc_header->sig);
126
127         if (fam == fam_ucode && model == model_ucode)
128                 return true;
129
130         /* Look for ext. headers: */
131         if (total_size <= data_size + MC_HEADER_SIZE)
132                 return false;
133
134         ext_header   = (void *) mc_header + data_size + MC_HEADER_SIZE;
135         ext_sig      = (void *)ext_header + EXT_HEADER_SIZE;
136         ext_sigcount = ext_header->count;
137
138         for (i = 0; i < ext_sigcount; i++) {
139                 fam_ucode   = x86_family(ext_sig->sig);
140                 model_ucode = x86_model(ext_sig->sig);
141
142                 if (fam == fam_ucode && model == model_ucode)
143                         return true;
144
145                 ext_sig++;
146         }
147         return false;
148 }
149
150 static struct ucode_patch *memdup_patch(void *data, unsigned int size)
151 {
152         struct ucode_patch *p;
153
154         p = kzalloc(sizeof(struct ucode_patch), GFP_KERNEL);
155         if (!p)
156                 return NULL;
157
158         p->data = kmemdup(data, size, GFP_KERNEL);
159         if (!p->data) {
160                 kfree(p);
161                 return NULL;
162         }
163
164         return p;
165 }
166
167 static void save_microcode_patch(void *data, unsigned int size)
168 {
169         struct microcode_header_intel *mc_hdr, *mc_saved_hdr;
170         struct ucode_patch *iter, *tmp, *p = NULL;
171         bool prev_found = false;
172         unsigned int sig, pf;
173
174         mc_hdr = (struct microcode_header_intel *)data;
175
176         list_for_each_entry_safe(iter, tmp, &microcode_cache, plist) {
177                 mc_saved_hdr = (struct microcode_header_intel *)iter->data;
178                 sig          = mc_saved_hdr->sig;
179                 pf           = mc_saved_hdr->pf;
180
181                 if (find_matching_signature(data, sig, pf)) {
182                         prev_found = true;
183
184                         if (mc_hdr->rev <= mc_saved_hdr->rev)
185                                 continue;
186
187                         p = memdup_patch(data, size);
188                         if (!p)
189                                 pr_err("Error allocating buffer %p\n", data);
190                         else
191                                 list_replace(&iter->plist, &p->plist);
192                 }
193         }
194
195         /*
196          * There weren't any previous patches found in the list cache; save the
197          * newly found.
198          */
199         if (!prev_found) {
200                 p = memdup_patch(data, size);
201                 if (!p)
202                         pr_err("Error allocating buffer for %p\n", data);
203                 else
204                         list_add_tail(&p->plist, &microcode_cache);
205         }
206
207         if (!p)
208                 return;
209
210         /*
211          * Save for early loading. On 32-bit, that needs to be a physical
212          * address as the APs are running from physical addresses, before
213          * paging has been enabled.
214          */
215         if (IS_ENABLED(CONFIG_X86_32))
216                 intel_ucode_patch = (struct microcode_intel *)__pa_nodebug(p->data);
217         else
218                 intel_ucode_patch = p->data;
219 }
220
221 static int microcode_sanity_check(void *mc, int print_err)
222 {
223         unsigned long total_size, data_size, ext_table_size;
224         struct microcode_header_intel *mc_header = mc;
225         struct extended_sigtable *ext_header = NULL;
226         u32 sum, orig_sum, ext_sigcount = 0, i;
227         struct extended_signature *ext_sig;
228
229         total_size = get_totalsize(mc_header);
230         data_size = get_datasize(mc_header);
231
232         if (data_size + MC_HEADER_SIZE > total_size) {
233                 if (print_err)
234                         pr_err("Error: bad microcode data file size.\n");
235                 return -EINVAL;
236         }
237
238         if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
239                 if (print_err)
240                         pr_err("Error: invalid/unknown microcode update format.\n");
241                 return -EINVAL;
242         }
243
244         ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
245         if (ext_table_size) {
246                 u32 ext_table_sum = 0;
247                 u32 *ext_tablep;
248
249                 if ((ext_table_size < EXT_HEADER_SIZE)
250                  || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
251                         if (print_err)
252                                 pr_err("Error: truncated extended signature table.\n");
253                         return -EINVAL;
254                 }
255
256                 ext_header = mc + MC_HEADER_SIZE + data_size;
257                 if (ext_table_size != exttable_size(ext_header)) {
258                         if (print_err)
259                                 pr_err("Error: extended signature table size mismatch.\n");
260                         return -EFAULT;
261                 }
262
263                 ext_sigcount = ext_header->count;
264
265                 /*
266                  * Check extended table checksum: the sum of all dwords that
267                  * comprise a valid table must be 0.
268                  */
269                 ext_tablep = (u32 *)ext_header;
270
271                 i = ext_table_size / sizeof(u32);
272                 while (i--)
273                         ext_table_sum += ext_tablep[i];
274
275                 if (ext_table_sum) {
276                         if (print_err)
277                                 pr_warn("Bad extended signature table checksum, aborting.\n");
278                         return -EINVAL;
279                 }
280         }
281
282         /*
283          * Calculate the checksum of update data and header. The checksum of
284          * valid update data and header including the extended signature table
285          * must be 0.
286          */
287         orig_sum = 0;
288         i = (MC_HEADER_SIZE + data_size) / sizeof(u32);
289         while (i--)
290                 orig_sum += ((u32 *)mc)[i];
291
292         if (orig_sum) {
293                 if (print_err)
294                         pr_err("Bad microcode data checksum, aborting.\n");
295                 return -EINVAL;
296         }
297
298         if (!ext_table_size)
299                 return 0;
300
301         /*
302          * Check extended signature checksum: 0 => valid.
303          */
304         for (i = 0; i < ext_sigcount; i++) {
305                 ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
306                           EXT_SIGNATURE_SIZE * i;
307
308                 sum = (mc_header->sig + mc_header->pf + mc_header->cksum) -
309                       (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
310                 if (sum) {
311                         if (print_err)
312                                 pr_err("Bad extended signature checksum, aborting.\n");
313                         return -EINVAL;
314                 }
315         }
316         return 0;
317 }
318
319 /*
320  * Get microcode matching with BSP's model. Only CPUs with the same model as
321  * BSP can stay in the platform.
322  */
323 static struct microcode_intel *
324 scan_microcode(void *data, size_t size, struct ucode_cpu_info *uci, bool save)
325 {
326         struct microcode_header_intel *mc_header;
327         struct microcode_intel *patch = NULL;
328         unsigned int mc_size;
329
330         while (size) {
331                 if (size < sizeof(struct microcode_header_intel))
332                         break;
333
334                 mc_header = (struct microcode_header_intel *)data;
335
336                 mc_size = get_totalsize(mc_header);
337                 if (!mc_size ||
338                     mc_size > size ||
339                     microcode_sanity_check(data, 0) < 0)
340                         break;
341
342                 size -= mc_size;
343
344                 if (!microcode_matches(mc_header, uci->cpu_sig.sig)) {
345                         data += mc_size;
346                         continue;
347                 }
348
349                 if (save) {
350                         save_microcode_patch(data, mc_size);
351                         goto next;
352                 }
353
354
355                 if (!patch) {
356                         if (!has_newer_microcode(data,
357                                                  uci->cpu_sig.sig,
358                                                  uci->cpu_sig.pf,
359                                                  uci->cpu_sig.rev))
360                                 goto next;
361
362                 } else {
363                         struct microcode_header_intel *phdr = &patch->hdr;
364
365                         if (!has_newer_microcode(data,
366                                                  phdr->sig,
367                                                  phdr->pf,
368                                                  phdr->rev))
369                                 goto next;
370                 }
371
372                 /* We have a newer patch, save it. */
373                 patch = data;
374
375 next:
376                 data += mc_size;
377         }
378
379         if (size)
380                 return NULL;
381
382         return patch;
383 }
384
385 static int collect_cpu_info_early(struct ucode_cpu_info *uci)
386 {
387         unsigned int val[2];
388         unsigned int family, model;
389         struct cpu_signature csig = { 0 };
390         unsigned int eax, ebx, ecx, edx;
391
392         memset(uci, 0, sizeof(*uci));
393
394         eax = 0x00000001;
395         ecx = 0;
396         native_cpuid(&eax, &ebx, &ecx, &edx);
397         csig.sig = eax;
398
399         family = x86_family(eax);
400         model  = x86_model(eax);
401
402         if ((model >= 5) || (family > 6)) {
403                 /* get processor flags from MSR 0x17 */
404                 native_rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
405                 csig.pf = 1 << ((val[1] >> 18) & 7);
406         }
407
408         csig.rev = intel_get_microcode_revision();
409
410         uci->cpu_sig = csig;
411         uci->valid = 1;
412
413         return 0;
414 }
415
416 static void show_saved_mc(void)
417 {
418 #ifdef DEBUG
419         int i = 0, j;
420         unsigned int sig, pf, rev, total_size, data_size, date;
421         struct ucode_cpu_info uci;
422         struct ucode_patch *p;
423
424         if (list_empty(&microcode_cache)) {
425                 pr_debug("no microcode data saved.\n");
426                 return;
427         }
428
429         collect_cpu_info_early(&uci);
430
431         sig     = uci.cpu_sig.sig;
432         pf      = uci.cpu_sig.pf;
433         rev     = uci.cpu_sig.rev;
434         pr_debug("CPU: sig=0x%x, pf=0x%x, rev=0x%x\n", sig, pf, rev);
435
436         list_for_each_entry(p, &microcode_cache, plist) {
437                 struct microcode_header_intel *mc_saved_header;
438                 struct extended_sigtable *ext_header;
439                 struct extended_signature *ext_sig;
440                 int ext_sigcount;
441
442                 mc_saved_header = (struct microcode_header_intel *)p->data;
443
444                 sig     = mc_saved_header->sig;
445                 pf      = mc_saved_header->pf;
446                 rev     = mc_saved_header->rev;
447                 date    = mc_saved_header->date;
448
449                 total_size      = get_totalsize(mc_saved_header);
450                 data_size       = get_datasize(mc_saved_header);
451
452                 pr_debug("mc_saved[%d]: sig=0x%x, pf=0x%x, rev=0x%x, total size=0x%x, date = %04x-%02x-%02x\n",
453                          i++, sig, pf, rev, total_size,
454                          date & 0xffff,
455                          date >> 24,
456                          (date >> 16) & 0xff);
457
458                 /* Look for ext. headers: */
459                 if (total_size <= data_size + MC_HEADER_SIZE)
460                         continue;
461
462                 ext_header = (void *)mc_saved_header + data_size + MC_HEADER_SIZE;
463                 ext_sigcount = ext_header->count;
464                 ext_sig = (void *)ext_header + EXT_HEADER_SIZE;
465
466                 for (j = 0; j < ext_sigcount; j++) {
467                         sig = ext_sig->sig;
468                         pf = ext_sig->pf;
469
470                         pr_debug("\tExtended[%d]: sig=0x%x, pf=0x%x\n",
471                                  j, sig, pf);
472
473                         ext_sig++;
474                 }
475         }
476 #endif
477 }
478
479 /*
480  * Save this microcode patch. It will be loaded early when a CPU is
481  * hot-added or resumes.
482  */
483 static void save_mc_for_early(u8 *mc, unsigned int size)
484 {
485 #ifdef CONFIG_HOTPLUG_CPU
486         /* Synchronization during CPU hotplug. */
487         static DEFINE_MUTEX(x86_cpu_microcode_mutex);
488
489         mutex_lock(&x86_cpu_microcode_mutex);
490
491         save_microcode_patch(mc, size);
492         show_saved_mc();
493
494         mutex_unlock(&x86_cpu_microcode_mutex);
495 #endif
496 }
497
498 static bool load_builtin_intel_microcode(struct cpio_data *cp)
499 {
500         unsigned int eax = 1, ebx, ecx = 0, edx;
501         char name[30];
502
503         if (IS_ENABLED(CONFIG_X86_32))
504                 return false;
505
506         native_cpuid(&eax, &ebx, &ecx, &edx);
507
508         sprintf(name, "intel-ucode/%02x-%02x-%02x",
509                       x86_family(eax), x86_model(eax), x86_stepping(eax));
510
511         return get_builtin_firmware(cp, name);
512 }
513
514 /*
515  * Print ucode update info.
516  */
517 static void
518 print_ucode_info(struct ucode_cpu_info *uci, unsigned int date)
519 {
520         pr_info_once("microcode updated early to revision 0x%x, date = %04x-%02x-%02x\n",
521                      uci->cpu_sig.rev,
522                      date & 0xffff,
523                      date >> 24,
524                      (date >> 16) & 0xff);
525 }
526
527 #ifdef CONFIG_X86_32
528
529 static int delay_ucode_info;
530 static int current_mc_date;
531
532 /*
533  * Print early updated ucode info after printk works. This is delayed info dump.
534  */
535 void show_ucode_info_early(void)
536 {
537         struct ucode_cpu_info uci;
538
539         if (delay_ucode_info) {
540                 collect_cpu_info_early(&uci);
541                 print_ucode_info(&uci, current_mc_date);
542                 delay_ucode_info = 0;
543         }
544 }
545
546 /*
547  * At this point, we can not call printk() yet. Delay printing microcode info in
548  * show_ucode_info_early() until printk() works.
549  */
550 static void print_ucode(struct ucode_cpu_info *uci)
551 {
552         struct microcode_intel *mc;
553         int *delay_ucode_info_p;
554         int *current_mc_date_p;
555
556         mc = uci->mc;
557         if (!mc)
558                 return;
559
560         delay_ucode_info_p = (int *)__pa_nodebug(&delay_ucode_info);
561         current_mc_date_p = (int *)__pa_nodebug(&current_mc_date);
562
563         *delay_ucode_info_p = 1;
564         *current_mc_date_p = mc->hdr.date;
565 }
566 #else
567
568 /*
569  * Flush global tlb. We only do this in x86_64 where paging has been enabled
570  * already and PGE should be enabled as well.
571  */
572 static inline void flush_tlb_early(void)
573 {
574         __native_flush_tlb_global_irq_disabled();
575 }
576
577 static inline void print_ucode(struct ucode_cpu_info *uci)
578 {
579         struct microcode_intel *mc;
580
581         mc = uci->mc;
582         if (!mc)
583                 return;
584
585         print_ucode_info(uci, mc->hdr.date);
586 }
587 #endif
588
589 static int apply_microcode_early(struct ucode_cpu_info *uci, bool early)
590 {
591         struct microcode_intel *mc;
592         u32 rev;
593
594         mc = uci->mc;
595         if (!mc)
596                 return 0;
597
598         /* write microcode via MSR 0x79 */
599         native_wrmsrl(MSR_IA32_UCODE_WRITE, (unsigned long)mc->bits);
600
601         rev = intel_get_microcode_revision();
602         if (rev != mc->hdr.rev)
603                 return -1;
604
605 #ifdef CONFIG_X86_64
606         /* Flush global tlb. This is precaution. */
607         flush_tlb_early();
608 #endif
609         uci->cpu_sig.rev = rev;
610
611         if (early)
612                 print_ucode(uci);
613         else
614                 print_ucode_info(uci, mc->hdr.date);
615
616         return 0;
617 }
618
619 int __init save_microcode_in_initrd_intel(void)
620 {
621         struct ucode_cpu_info uci;
622         struct cpio_data cp;
623
624         /*
625          * initrd is going away, clear patch ptr. We will scan the microcode one
626          * last time before jettisoning and save a patch, if found. Then we will
627          * update that pointer too, with a stable patch address to use when
628          * resuming the cores.
629          */
630         intel_ucode_patch = NULL;
631
632         if (!load_builtin_intel_microcode(&cp))
633                 cp = find_microcode_in_initrd(ucode_path, false);
634
635         if (!(cp.data && cp.size))
636                 return 0;
637
638         collect_cpu_info_early(&uci);
639
640         scan_microcode(cp.data, cp.size, &uci, true);
641
642         show_saved_mc();
643
644         return 0;
645 }
646
647 /*
648  * @res_patch, output: a pointer to the patch we found.
649  */
650 static struct microcode_intel *__load_ucode_intel(struct ucode_cpu_info *uci)
651 {
652         static const char *path;
653         struct cpio_data cp;
654         bool use_pa;
655
656         if (IS_ENABLED(CONFIG_X86_32)) {
657                 path      = (const char *)__pa_nodebug(ucode_path);
658                 use_pa    = true;
659         } else {
660                 path      = ucode_path;
661                 use_pa    = false;
662         }
663
664         /* try built-in microcode first */
665         if (!load_builtin_intel_microcode(&cp))
666                 cp = find_microcode_in_initrd(path, use_pa);
667
668         if (!(cp.data && cp.size))
669                 return NULL;
670
671         collect_cpu_info_early(uci);
672
673         return scan_microcode(cp.data, cp.size, uci, false);
674 }
675
676 void __init load_ucode_intel_bsp(void)
677 {
678         struct microcode_intel *patch;
679         struct ucode_cpu_info uci;
680
681         patch = __load_ucode_intel(&uci);
682         if (!patch)
683                 return;
684
685         uci.mc = patch;
686
687         apply_microcode_early(&uci, true);
688 }
689
690 void load_ucode_intel_ap(void)
691 {
692         struct microcode_intel *patch, **iup;
693         struct ucode_cpu_info uci;
694
695         if (IS_ENABLED(CONFIG_X86_32))
696                 iup = (struct microcode_intel **) __pa_nodebug(&intel_ucode_patch);
697         else
698                 iup = &intel_ucode_patch;
699
700 reget:
701         if (!*iup) {
702                 patch = __load_ucode_intel(&uci);
703                 if (!patch)
704                         return;
705
706                 *iup = patch;
707         }
708
709         uci.mc = *iup;
710
711         if (apply_microcode_early(&uci, true)) {
712                 /* Mixed-silicon system? Try to refetch the proper patch: */
713                 *iup = NULL;
714
715                 goto reget;
716         }
717 }
718
719 static struct microcode_intel *find_patch(struct ucode_cpu_info *uci)
720 {
721         struct microcode_header_intel *phdr;
722         struct ucode_patch *iter, *tmp;
723
724         list_for_each_entry_safe(iter, tmp, &microcode_cache, plist) {
725
726                 phdr = (struct microcode_header_intel *)iter->data;
727
728                 if (phdr->rev <= uci->cpu_sig.rev)
729                         continue;
730
731                 if (!find_matching_signature(phdr,
732                                              uci->cpu_sig.sig,
733                                              uci->cpu_sig.pf))
734                         continue;
735
736                 return iter->data;
737         }
738         return NULL;
739 }
740
741 void reload_ucode_intel(void)
742 {
743         struct microcode_intel *p;
744         struct ucode_cpu_info uci;
745
746         collect_cpu_info_early(&uci);
747
748         p = find_patch(&uci);
749         if (!p)
750                 return;
751
752         uci.mc = p;
753
754         apply_microcode_early(&uci, false);
755 }
756
757 static int collect_cpu_info(int cpu_num, struct cpu_signature *csig)
758 {
759         static struct cpu_signature prev;
760         struct cpuinfo_x86 *c = &cpu_data(cpu_num);
761         unsigned int val[2];
762
763         memset(csig, 0, sizeof(*csig));
764
765         csig->sig = cpuid_eax(0x00000001);
766
767         if ((c->x86_model >= 5) || (c->x86 > 6)) {
768                 /* get processor flags from MSR 0x17 */
769                 rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
770                 csig->pf = 1 << ((val[1] >> 18) & 7);
771         }
772
773         csig->rev = c->microcode;
774
775         /* No extra locking on prev, races are harmless. */
776         if (csig->sig != prev.sig || csig->pf != prev.pf || csig->rev != prev.rev) {
777                 pr_info("sig=0x%x, pf=0x%x, revision=0x%x\n",
778                         csig->sig, csig->pf, csig->rev);
779                 prev = *csig;
780         }
781
782         return 0;
783 }
784
785 static int apply_microcode_intel(int cpu)
786 {
787         struct microcode_intel *mc;
788         struct ucode_cpu_info *uci;
789         struct cpuinfo_x86 *c;
790         static int prev_rev;
791         u32 rev;
792
793         /* We should bind the task to the CPU */
794         if (WARN_ON(raw_smp_processor_id() != cpu))
795                 return -1;
796
797         uci = ucode_cpu_info + cpu;
798         mc = uci->mc;
799         if (!mc) {
800                 /* Look for a newer patch in our cache: */
801                 mc = find_patch(uci);
802                 if (!mc)
803                         return 0;
804         }
805
806         /* write microcode via MSR 0x79 */
807         wrmsrl(MSR_IA32_UCODE_WRITE, (unsigned long)mc->bits);
808
809         rev = intel_get_microcode_revision();
810
811         if (rev != mc->hdr.rev) {
812                 pr_err("CPU%d update to revision 0x%x failed\n",
813                        cpu, mc->hdr.rev);
814                 return -1;
815         }
816
817         if (rev != prev_rev) {
818                 pr_info("updated to revision 0x%x, date = %04x-%02x-%02x\n",
819                         rev,
820                         mc->hdr.date & 0xffff,
821                         mc->hdr.date >> 24,
822                         (mc->hdr.date >> 16) & 0xff);
823                 prev_rev = rev;
824         }
825
826         c = &cpu_data(cpu);
827
828         uci->cpu_sig.rev = rev;
829         c->microcode = rev;
830
831         return 0;
832 }
833
834 static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size,
835                                 int (*get_ucode_data)(void *, const void *, size_t))
836 {
837         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
838         u8 *ucode_ptr = data, *new_mc = NULL, *mc = NULL;
839         int new_rev = uci->cpu_sig.rev;
840         unsigned int leftover = size;
841         unsigned int curr_mc_size = 0, new_mc_size = 0;
842         unsigned int csig, cpf;
843
844         while (leftover) {
845                 struct microcode_header_intel mc_header;
846                 unsigned int mc_size;
847
848                 if (leftover < sizeof(mc_header)) {
849                         pr_err("error! Truncated header in microcode data file\n");
850                         break;
851                 }
852
853                 if (get_ucode_data(&mc_header, ucode_ptr, sizeof(mc_header)))
854                         break;
855
856                 mc_size = get_totalsize(&mc_header);
857                 if (!mc_size || mc_size > leftover) {
858                         pr_err("error! Bad data in microcode data file\n");
859                         break;
860                 }
861
862                 /* For performance reasons, reuse mc area when possible */
863                 if (!mc || mc_size > curr_mc_size) {
864                         vfree(mc);
865                         mc = vmalloc(mc_size);
866                         if (!mc)
867                                 break;
868                         curr_mc_size = mc_size;
869                 }
870
871                 if (get_ucode_data(mc, ucode_ptr, mc_size) ||
872                     microcode_sanity_check(mc, 1) < 0) {
873                         break;
874                 }
875
876                 csig = uci->cpu_sig.sig;
877                 cpf = uci->cpu_sig.pf;
878                 if (has_newer_microcode(mc, csig, cpf, new_rev)) {
879                         vfree(new_mc);
880                         new_rev = mc_header.rev;
881                         new_mc  = mc;
882                         new_mc_size = mc_size;
883                         mc = NULL;      /* trigger new vmalloc */
884                 }
885
886                 ucode_ptr += mc_size;
887                 leftover  -= mc_size;
888         }
889
890         vfree(mc);
891
892         if (leftover) {
893                 vfree(new_mc);
894                 return UCODE_ERROR;
895         }
896
897         if (!new_mc)
898                 return UCODE_NFOUND;
899
900         vfree(uci->mc);
901         uci->mc = (struct microcode_intel *)new_mc;
902
903         /*
904          * If early loading microcode is supported, save this mc into
905          * permanent memory. So it will be loaded early when a CPU is hot added
906          * or resumes.
907          */
908         save_mc_for_early(new_mc, new_mc_size);
909
910         pr_debug("CPU%d found a matching microcode update with version 0x%x (current=0x%x)\n",
911                  cpu, new_rev, uci->cpu_sig.rev);
912
913         return UCODE_OK;
914 }
915
916 static int get_ucode_fw(void *to, const void *from, size_t n)
917 {
918         memcpy(to, from, n);
919         return 0;
920 }
921
922 static bool is_blacklisted(unsigned int cpu)
923 {
924         struct cpuinfo_x86 *c = &cpu_data(cpu);
925
926         if (c->x86 == 6 && c->x86_model == INTEL_FAM6_BROADWELL_X) {
927                 pr_err_once("late loading on model 79 is disabled.\n");
928                 return true;
929         }
930
931         return false;
932 }
933
934 static enum ucode_state request_microcode_fw(int cpu, struct device *device,
935                                              bool refresh_fw)
936 {
937         char name[30];
938         struct cpuinfo_x86 *c = &cpu_data(cpu);
939         const struct firmware *firmware;
940         enum ucode_state ret;
941
942         if (is_blacklisted(cpu))
943                 return UCODE_NFOUND;
944
945         sprintf(name, "intel-ucode/%02x-%02x-%02x",
946                 c->x86, c->x86_model, c->x86_mask);
947
948         if (request_firmware_direct(&firmware, name, device)) {
949                 pr_debug("data file %s load failed\n", name);
950                 return UCODE_NFOUND;
951         }
952
953         ret = generic_load_microcode(cpu, (void *)firmware->data,
954                                      firmware->size, &get_ucode_fw);
955
956         release_firmware(firmware);
957
958         return ret;
959 }
960
961 static int get_ucode_user(void *to, const void *from, size_t n)
962 {
963         return copy_from_user(to, from, n);
964 }
965
966 static enum ucode_state
967 request_microcode_user(int cpu, const void __user *buf, size_t size)
968 {
969         if (is_blacklisted(cpu))
970                 return UCODE_NFOUND;
971
972         return generic_load_microcode(cpu, (void *)buf, size, &get_ucode_user);
973 }
974
975 static struct microcode_ops microcode_intel_ops = {
976         .request_microcode_user           = request_microcode_user,
977         .request_microcode_fw             = request_microcode_fw,
978         .collect_cpu_info                 = collect_cpu_info,
979         .apply_microcode                  = apply_microcode_intel,
980 };
981
982 struct microcode_ops * __init init_intel_microcode(void)
983 {
984         struct cpuinfo_x86 *c = &boot_cpu_data;
985
986         if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
987             cpu_has(c, X86_FEATURE_IA64)) {
988                 pr_err("Intel CPU family 0x%x not supported\n", c->x86);
989                 return NULL;
990         }
991
992         return &microcode_intel_ops;
993 }