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
74#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
75
76#include <linux/platform_device.h>
77#include <linux/miscdevice.h>
78#include <linux/capability.h>
79#include <linux/kernel.h>
80#include <linux/module.h>
81#include <linux/mutex.h>
82#include <linux/cpu.h>
83#include <linux/fs.h>
84#include <linux/mm.h>
85#include <linux/syscore_ops.h>
86
87#include <asm/microcode.h>
88#include <asm/processor.h>
89#include <asm/cpu_device_id.h>
90#include <asm/perf_event.h>
91
92MODULE_DESCRIPTION("Microcode Update Driver");
93MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
94MODULE_LICENSE("GPL");
95
96#define MICROCODE_VERSION "2.00"
97
98static struct microcode_ops *microcode_ops;
99
100
101
102
103
104
105
106
107
108
109
110
111
112static DEFINE_MUTEX(microcode_mutex);
113
114struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
115EXPORT_SYMBOL_GPL(ucode_cpu_info);
116
117
118
119
120
121struct cpu_info_ctx {
122 struct cpu_signature *cpu_sig;
123 int err;
124};
125
126static void collect_cpu_info_local(void *arg)
127{
128 struct cpu_info_ctx *ctx = arg;
129
130 ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
131 ctx->cpu_sig);
132}
133
134static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
135{
136 struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
137 int ret;
138
139 ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
140 if (!ret)
141 ret = ctx.err;
142
143 return ret;
144}
145
146static int collect_cpu_info(int cpu)
147{
148 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
149 int ret;
150
151 memset(uci, 0, sizeof(*uci));
152
153 ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
154 if (!ret)
155 uci->valid = 1;
156
157 return ret;
158}
159
160struct apply_microcode_ctx {
161 int err;
162};
163
164static void apply_microcode_local(void *arg)
165{
166 struct apply_microcode_ctx *ctx = arg;
167
168 ctx->err = microcode_ops->apply_microcode(smp_processor_id());
169}
170
171static int apply_microcode_on_target(int cpu)
172{
173 struct apply_microcode_ctx ctx = { .err = 0 };
174 int ret;
175
176 ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1);
177 if (!ret)
178 ret = ctx.err;
179
180 return ret;
181}
182
183#ifdef CONFIG_MICROCODE_OLD_INTERFACE
184static int do_microcode_update(const void __user *buf, size_t size)
185{
186 int error = 0;
187 int cpu;
188
189 for_each_online_cpu(cpu) {
190 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
191 enum ucode_state ustate;
192
193 if (!uci->valid)
194 continue;
195
196 ustate = microcode_ops->request_microcode_user(cpu, buf, size);
197 if (ustate == UCODE_ERROR) {
198 error = -1;
199 break;
200 } else if (ustate == UCODE_OK)
201 apply_microcode_on_target(cpu);
202 }
203
204 return error;
205}
206
207static int microcode_open(struct inode *inode, struct file *file)
208{
209 return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM;
210}
211
212static ssize_t microcode_write(struct file *file, const char __user *buf,
213 size_t len, loff_t *ppos)
214{
215 ssize_t ret = -EINVAL;
216
217 if ((len >> PAGE_SHIFT) > totalram_pages) {
218 pr_err("too much data (max %ld pages)\n", totalram_pages);
219 return ret;
220 }
221
222 get_online_cpus();
223 mutex_lock(µcode_mutex);
224
225 if (do_microcode_update(buf, len) == 0)
226 ret = (ssize_t)len;
227
228 if (ret > 0)
229 perf_check_microcode();
230
231 mutex_unlock(µcode_mutex);
232 put_online_cpus();
233
234 return ret;
235}
236
237static const struct file_operations microcode_fops = {
238 .owner = THIS_MODULE,
239 .write = microcode_write,
240 .open = microcode_open,
241 .llseek = no_llseek,
242};
243
244static struct miscdevice microcode_dev = {
245 .minor = MICROCODE_MINOR,
246 .name = "microcode",
247 .nodename = "cpu/microcode",
248 .fops = µcode_fops,
249};
250
251static int __init microcode_dev_init(void)
252{
253 int error;
254
255 error = misc_register(µcode_dev);
256 if (error) {
257 pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR);
258 return error;
259 }
260
261 return 0;
262}
263
264static void __exit microcode_dev_exit(void)
265{
266 misc_deregister(µcode_dev);
267}
268
269MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
270MODULE_ALIAS("devname:cpu/microcode");
271#else
272#define microcode_dev_init() 0
273#define microcode_dev_exit() do { } while (0)
274#endif
275
276
277static struct platform_device *microcode_pdev;
278
279static int reload_for_cpu(int cpu)
280{
281 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
282 enum ucode_state ustate;
283 int err = 0;
284
285 if (!uci->valid)
286 return err;
287
288 ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, true);
289 if (ustate == UCODE_OK)
290 apply_microcode_on_target(cpu);
291 else
292 if (ustate == UCODE_ERROR)
293 err = -EINVAL;
294 return err;
295}
296
297static ssize_t reload_store(struct device *dev,
298 struct device_attribute *attr,
299 const char *buf, size_t size)
300{
301 unsigned long val;
302 int cpu;
303 ssize_t ret = 0, tmp_ret;
304
305 ret = kstrtoul(buf, 0, &val);
306 if (ret)
307 return ret;
308
309 if (val != 1)
310 return size;
311
312 get_online_cpus();
313 mutex_lock(µcode_mutex);
314 for_each_online_cpu(cpu) {
315 tmp_ret = reload_for_cpu(cpu);
316 if (tmp_ret != 0)
317 pr_warn("Error reloading microcode on CPU %d\n", cpu);
318
319
320 if (!ret)
321 ret = tmp_ret;
322 }
323 if (!ret)
324 perf_check_microcode();
325 mutex_unlock(µcode_mutex);
326 put_online_cpus();
327
328 if (!ret)
329 ret = size;
330
331 return ret;
332}
333
334static ssize_t version_show(struct device *dev,
335 struct device_attribute *attr, char *buf)
336{
337 struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
338
339 return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
340}
341
342static ssize_t pf_show(struct device *dev,
343 struct device_attribute *attr, char *buf)
344{
345 struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
346
347 return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
348}
349
350static DEVICE_ATTR(reload, 0200, NULL, reload_store);
351static DEVICE_ATTR(version, 0400, version_show, NULL);
352static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL);
353
354static struct attribute *mc_default_attrs[] = {
355 &dev_attr_version.attr,
356 &dev_attr_processor_flags.attr,
357 NULL
358};
359
360static struct attribute_group mc_attr_group = {
361 .attrs = mc_default_attrs,
362 .name = "microcode",
363};
364
365static void microcode_fini_cpu(int cpu)
366{
367 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
368
369 microcode_ops->microcode_fini_cpu(cpu);
370 uci->valid = 0;
371}
372
373static enum ucode_state microcode_resume_cpu(int cpu)
374{
375 pr_debug("CPU%d updated upon resume\n", cpu);
376
377 if (apply_microcode_on_target(cpu))
378 return UCODE_ERROR;
379
380 return UCODE_OK;
381}
382
383static enum ucode_state microcode_init_cpu(int cpu, bool refresh_fw)
384{
385 enum ucode_state ustate;
386
387 if (collect_cpu_info(cpu))
388 return UCODE_ERROR;
389
390
391 if (system_state != SYSTEM_RUNNING)
392 return UCODE_NFOUND;
393
394 ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev,
395 refresh_fw);
396
397 if (ustate == UCODE_OK) {
398 pr_debug("CPU%d updated upon init\n", cpu);
399 apply_microcode_on_target(cpu);
400 }
401
402 return ustate;
403}
404
405static enum ucode_state microcode_update_cpu(int cpu)
406{
407 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
408
409 if (uci->valid)
410 return microcode_resume_cpu(cpu);
411
412 return microcode_init_cpu(cpu, false);
413}
414
415static int mc_device_add(struct device *dev, struct subsys_interface *sif)
416{
417 int err, cpu = dev->id;
418
419 if (!cpu_online(cpu))
420 return 0;
421
422 pr_debug("CPU%d added\n", cpu);
423
424 err = sysfs_create_group(&dev->kobj, &mc_attr_group);
425 if (err)
426 return err;
427
428 if (microcode_init_cpu(cpu, true) == UCODE_ERROR)
429 return -EINVAL;
430
431 return err;
432}
433
434static int mc_device_remove(struct device *dev, struct subsys_interface *sif)
435{
436 int cpu = dev->id;
437
438 if (!cpu_online(cpu))
439 return 0;
440
441 pr_debug("CPU%d removed\n", cpu);
442 microcode_fini_cpu(cpu);
443 sysfs_remove_group(&dev->kobj, &mc_attr_group);
444 return 0;
445}
446
447static struct subsys_interface mc_cpu_interface = {
448 .name = "microcode",
449 .subsys = &cpu_subsys,
450 .add_dev = mc_device_add,
451 .remove_dev = mc_device_remove,
452};
453
454
455
456
457static void mc_bp_resume(void)
458{
459 int cpu = smp_processor_id();
460 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
461
462 if (uci->valid && uci->mc)
463 microcode_ops->apply_microcode(cpu);
464}
465
466static struct syscore_ops mc_syscore_ops = {
467 .resume = mc_bp_resume,
468};
469
470static __cpuinit int
471mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
472{
473 unsigned int cpu = (unsigned long)hcpu;
474 struct device *dev;
475
476 dev = get_cpu_device(cpu);
477
478 switch (action & ~CPU_TASKS_FROZEN) {
479 case CPU_ONLINE:
480 microcode_update_cpu(cpu);
481 pr_debug("CPU%d added\n", cpu);
482
483
484
485
486
487 case CPU_DOWN_FAILED:
488 if (sysfs_create_group(&dev->kobj, &mc_attr_group))
489 pr_err("Failed to create group for CPU%d\n", cpu);
490 break;
491
492 case CPU_DOWN_PREPARE:
493
494 sysfs_remove_group(&dev->kobj, &mc_attr_group);
495 pr_debug("CPU%d removed\n", cpu);
496 break;
497
498
499
500
501
502
503
504
505
506 }
507
508
509 if (action == CPU_UP_CANCELED_FROZEN)
510 microcode_fini_cpu(cpu);
511
512 return NOTIFY_OK;
513}
514
515static struct notifier_block __refdata mc_cpu_notifier = {
516 .notifier_call = mc_cpu_callback,
517};
518
519#ifdef MODULE
520
521static const struct x86_cpu_id __initconst microcode_id[] = {
522#ifdef CONFIG_MICROCODE_INTEL
523 { X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, },
524#endif
525#ifdef CONFIG_MICROCODE_AMD
526 { X86_VENDOR_AMD, X86_FAMILY_ANY, X86_MODEL_ANY, },
527#endif
528 {}
529};
530MODULE_DEVICE_TABLE(x86cpu, microcode_id);
531#endif
532
533static struct attribute *cpu_root_microcode_attrs[] = {
534 &dev_attr_reload.attr,
535 NULL
536};
537
538static struct attribute_group cpu_root_microcode_group = {
539 .name = "microcode",
540 .attrs = cpu_root_microcode_attrs,
541};
542
543static int __init microcode_init(void)
544{
545 struct cpuinfo_x86 *c = &cpu_data(0);
546 int error;
547
548 if (c->x86_vendor == X86_VENDOR_INTEL)
549 microcode_ops = init_intel_microcode();
550 else if (c->x86_vendor == X86_VENDOR_AMD)
551 microcode_ops = init_amd_microcode();
552 else
553 pr_err("no support for this CPU vendor\n");
554
555 if (!microcode_ops)
556 return -ENODEV;
557
558 microcode_pdev = platform_device_register_simple("microcode", -1,
559 NULL, 0);
560 if (IS_ERR(microcode_pdev))
561 return PTR_ERR(microcode_pdev);
562
563 get_online_cpus();
564 mutex_lock(µcode_mutex);
565
566 error = subsys_interface_register(&mc_cpu_interface);
567 if (!error)
568 perf_check_microcode();
569 mutex_unlock(µcode_mutex);
570 put_online_cpus();
571
572 if (error)
573 goto out_pdev;
574
575 error = sysfs_create_group(&cpu_subsys.dev_root->kobj,
576 &cpu_root_microcode_group);
577
578 if (error) {
579 pr_err("Error creating microcode group!\n");
580 goto out_driver;
581 }
582
583 error = microcode_dev_init();
584 if (error)
585 goto out_ucode_group;
586
587 register_syscore_ops(&mc_syscore_ops);
588 register_hotcpu_notifier(&mc_cpu_notifier);
589
590 pr_info("Microcode Update Driver: v" MICROCODE_VERSION
591 " <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n");
592
593 return 0;
594
595 out_ucode_group:
596 sysfs_remove_group(&cpu_subsys.dev_root->kobj,
597 &cpu_root_microcode_group);
598
599 out_driver:
600 get_online_cpus();
601 mutex_lock(µcode_mutex);
602
603 subsys_interface_unregister(&mc_cpu_interface);
604
605 mutex_unlock(µcode_mutex);
606 put_online_cpus();
607
608 out_pdev:
609 platform_device_unregister(microcode_pdev);
610 return error;
611
612}
613module_init(microcode_init);
614
615static void __exit microcode_exit(void)
616{
617 struct cpuinfo_x86 *c = &cpu_data(0);
618
619 microcode_dev_exit();
620
621 unregister_hotcpu_notifier(&mc_cpu_notifier);
622 unregister_syscore_ops(&mc_syscore_ops);
623
624 sysfs_remove_group(&cpu_subsys.dev_root->kobj,
625 &cpu_root_microcode_group);
626
627 get_online_cpus();
628 mutex_lock(µcode_mutex);
629
630 subsys_interface_unregister(&mc_cpu_interface);
631
632 mutex_unlock(µcode_mutex);
633 put_online_cpus();
634
635 platform_device_unregister(microcode_pdev);
636
637 microcode_ops = NULL;
638
639 if (c->x86_vendor == X86_VENDOR_AMD)
640 exit_amd_microcode();
641
642 pr_info("Microcode Update Driver: v" MICROCODE_VERSION " removed.\n");
643}
644module_exit(microcode_exit);
645