2 * Intel CPU Microcode Update Driver for Linux
4 * Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
5 * 2006 Shaohua Li <shaohua.li@intel.com>
7 * This driver allows to upgrade microcode on Intel processors
8 * belonging to IA-32 family - PentiumPro, Pentium II,
9 * Pentium III, Xeon, Pentium 4, etc.
11 * Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture
12 * Software Developer's Manual
13 * Order Number 253668 or free download from:
15 * http://developer.intel.com/Assets/PDF/manual/253668.pdf
17 * For more information, go to http://www.urbanmyth.org/microcode
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License
21 * as published by the Free Software Foundation; either version
22 * 2 of the License, or (at your option) any later version.
24 * 1.0 16 Feb 2000, Tigran Aivazian <tigran@sco.com>
26 * 1.01 18 Feb 2000, Tigran Aivazian <tigran@sco.com>
27 * Added read() support + cleanups.
28 * 1.02 21 Feb 2000, Tigran Aivazian <tigran@sco.com>
29 * Added 'device trimming' support. open(O_WRONLY) zeroes
30 * and frees the saved copy of applied microcode.
31 * 1.03 29 Feb 2000, Tigran Aivazian <tigran@sco.com>
32 * Made to use devfs (/dev/cpu/microcode) + cleanups.
33 * 1.04 06 Jun 2000, Simon Trimmer <simon@veritas.com>
34 * Added misc device support (now uses both devfs and misc).
35 * Added MICROCODE_IOCFREE ioctl to clear memory.
36 * 1.05 09 Jun 2000, Simon Trimmer <simon@veritas.com>
37 * Messages for error cases (non Intel & no suitable microcode).
38 * 1.06 03 Aug 2000, Tigran Aivazian <tigran@veritas.com>
39 * Removed ->release(). Removed exclusive open and status bitmap.
40 * Added microcode_rwsem to serialize read()/write()/ioctl().
41 * Removed global kernel lock usage.
42 * 1.07 07 Sep 2000, Tigran Aivazian <tigran@veritas.com>
43 * Write 0 to 0x8B msr and then cpuid before reading revision,
44 * so that it works even if there were no update done by the
45 * BIOS. Otherwise, reading from 0x8B gives junk (which happened
46 * to be 0 on my machine which is why it worked even when I
47 * disabled update by the BIOS)
48 * Thanks to Eric W. Biederman <ebiederman@lnxi.com> for the fix.
49 * 1.08 11 Dec 2000, Richard Schaal <richard.schaal@intel.com> and
50 * Tigran Aivazian <tigran@veritas.com>
51 * Intel Pentium 4 processor support and bugfixes.
52 * 1.09 30 Oct 2001, Tigran Aivazian <tigran@veritas.com>
53 * Bugfix for HT (Hyper-Threading) enabled processors
54 * whereby processor resources are shared by all logical processors
55 * in a single CPU package.
56 * 1.10 28 Feb 2002 Asit K Mallick <asit.k.mallick@intel.com> and
57 * Tigran Aivazian <tigran@veritas.com>,
58 * Serialize updates as required on HT processors due to
59 * speculative nature of implementation.
60 * 1.11 22 Mar 2002 Tigran Aivazian <tigran@veritas.com>
61 * Fix the panic when writing zero-length microcode chunk.
62 * 1.12 29 Sep 2003 Nitin Kamble <nitin.a.kamble@intel.com>,
63 * Jun Nakajima <jun.nakajima@intel.com>
64 * Support for the microcode updates in the new format.
65 * 1.13 10 Oct 2003 Tigran Aivazian <tigran@veritas.com>
66 * Removed ->read() method and obsoleted MICROCODE_IOCFREE ioctl
67 * because we no longer hold a copy of applied microcode
69 * 1.14 25 Jun 2004 Tigran Aivazian <tigran@veritas.com>
70 * Fix sigmatch() macro to handle old CPUs with pf == 0.
71 * Thanks to Stuart Swales for pointing out this bug.
74 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
85 #include <linux/syscore_ops.h>
87 #include <asm/microcode.h>
88 #include <asm/processor.h>
89 #include <asm/cpu_device_id.h>
90 #include <asm/perf_event.h>
92 MODULE_DESCRIPTION("Microcode Update Driver");
93 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
94 MODULE_LICENSE("GPL");
96 #define MICROCODE_VERSION "2.00"
98 static struct microcode_ops
*microcode_ops
;
103 * All non cpu-hotplug-callback call sites use:
105 * - microcode_mutex to synchronize with each other;
106 * - get/put_online_cpus() to synchronize with
107 * the cpu-hotplug-callback call sites.
109 * We guarantee that only a single cpu is being
110 * updated at any particular moment of time.
112 static DEFINE_MUTEX(microcode_mutex
);
114 struct ucode_cpu_info ucode_cpu_info
[NR_CPUS
];
115 EXPORT_SYMBOL_GPL(ucode_cpu_info
);
118 * Operations that are run on a target cpu:
121 struct cpu_info_ctx
{
122 struct cpu_signature
*cpu_sig
;
126 static void collect_cpu_info_local(void *arg
)
128 struct cpu_info_ctx
*ctx
= arg
;
130 ctx
->err
= microcode_ops
->collect_cpu_info(smp_processor_id(),
134 static int collect_cpu_info_on_target(int cpu
, struct cpu_signature
*cpu_sig
)
136 struct cpu_info_ctx ctx
= { .cpu_sig
= cpu_sig
, .err
= 0 };
139 ret
= smp_call_function_single(cpu
, collect_cpu_info_local
, &ctx
, 1);
146 static int collect_cpu_info(int cpu
)
148 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
151 memset(uci
, 0, sizeof(*uci
));
153 ret
= collect_cpu_info_on_target(cpu
, &uci
->cpu_sig
);
160 struct apply_microcode_ctx
{
164 static void apply_microcode_local(void *arg
)
166 struct apply_microcode_ctx
*ctx
= arg
;
168 ctx
->err
= microcode_ops
->apply_microcode(smp_processor_id());
171 static int apply_microcode_on_target(int cpu
)
173 struct apply_microcode_ctx ctx
= { .err
= 0 };
176 ret
= smp_call_function_single(cpu
, apply_microcode_local
, &ctx
, 1);
183 #ifdef CONFIG_MICROCODE_OLD_INTERFACE
184 static int do_microcode_update(const void __user
*buf
, size_t size
)
189 for_each_online_cpu(cpu
) {
190 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
191 enum ucode_state ustate
;
196 ustate
= microcode_ops
->request_microcode_user(cpu
, buf
, size
);
197 if (ustate
== UCODE_ERROR
) {
200 } else if (ustate
== UCODE_OK
)
201 apply_microcode_on_target(cpu
);
207 static int microcode_open(struct inode
*inode
, struct file
*file
)
209 return capable(CAP_SYS_RAWIO
) ? nonseekable_open(inode
, file
) : -EPERM
;
212 static ssize_t
microcode_write(struct file
*file
, const char __user
*buf
,
213 size_t len
, loff_t
*ppos
)
215 ssize_t ret
= -EINVAL
;
217 if ((len
>> PAGE_SHIFT
) > totalram_pages
) {
218 pr_err("too much data (max %ld pages)\n", totalram_pages
);
223 mutex_lock(µcode_mutex
);
225 if (do_microcode_update(buf
, len
) == 0)
228 mutex_unlock(µcode_mutex
);
234 static const struct file_operations microcode_fops
= {
235 .owner
= THIS_MODULE
,
236 .write
= microcode_write
,
237 .open
= microcode_open
,
241 static struct miscdevice microcode_dev
= {
242 .minor
= MICROCODE_MINOR
,
244 .nodename
= "cpu/microcode",
245 .fops
= µcode_fops
,
248 static int __init
microcode_dev_init(void)
252 error
= misc_register(µcode_dev
);
254 pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR
);
261 static void __exit
microcode_dev_exit(void)
263 misc_deregister(µcode_dev
);
266 MODULE_ALIAS_MISCDEV(MICROCODE_MINOR
);
267 MODULE_ALIAS("devname:cpu/microcode");
269 #define microcode_dev_init() 0
270 #define microcode_dev_exit() do { } while (0)
273 /* fake device for request_firmware */
274 static struct platform_device
*microcode_pdev
;
276 static int reload_for_cpu(int cpu
)
278 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
282 enum ucode_state ustate
;
284 ustate
= microcode_ops
->request_microcode_fw(cpu
, µcode_pdev
->dev
);
285 if (ustate
== UCODE_OK
)
286 apply_microcode_on_target(cpu
);
288 if (ustate
== UCODE_ERROR
)
295 static ssize_t
reload_store(struct device
*dev
,
296 struct device_attribute
*attr
,
297 const char *buf
, size_t size
)
301 ssize_t ret
= 0, tmp_ret
;
303 ret
= kstrtoul(buf
, 0, &val
);
311 mutex_lock(µcode_mutex
);
312 for_each_online_cpu(cpu
) {
313 tmp_ret
= reload_for_cpu(cpu
);
315 pr_warn("Error reloading microcode on CPU %d\n", cpu
);
317 /* save retval of the first encountered reload error */
322 perf_check_microcode();
323 mutex_unlock(µcode_mutex
);
332 static ssize_t
version_show(struct device
*dev
,
333 struct device_attribute
*attr
, char *buf
)
335 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ dev
->id
;
337 return sprintf(buf
, "0x%x\n", uci
->cpu_sig
.rev
);
340 static ssize_t
pf_show(struct device
*dev
,
341 struct device_attribute
*attr
, char *buf
)
343 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ dev
->id
;
345 return sprintf(buf
, "0x%x\n", uci
->cpu_sig
.pf
);
348 static DEVICE_ATTR(reload
, 0200, NULL
, reload_store
);
349 static DEVICE_ATTR(version
, 0400, version_show
, NULL
);
350 static DEVICE_ATTR(processor_flags
, 0400, pf_show
, NULL
);
352 static struct attribute
*mc_default_attrs
[] = {
353 &dev_attr_version
.attr
,
354 &dev_attr_processor_flags
.attr
,
358 static struct attribute_group mc_attr_group
= {
359 .attrs
= mc_default_attrs
,
363 static void microcode_fini_cpu(int cpu
)
365 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
367 microcode_ops
->microcode_fini_cpu(cpu
);
371 static enum ucode_state
microcode_resume_cpu(int cpu
)
373 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
378 pr_debug("CPU%d updated upon resume\n", cpu
);
379 apply_microcode_on_target(cpu
);
384 static enum ucode_state
microcode_init_cpu(int cpu
)
386 enum ucode_state ustate
;
388 if (collect_cpu_info(cpu
))
391 /* --dimm. Trigger a delayed update? */
392 if (system_state
!= SYSTEM_RUNNING
)
395 ustate
= microcode_ops
->request_microcode_fw(cpu
, µcode_pdev
->dev
);
397 if (ustate
== UCODE_OK
) {
398 pr_debug("CPU%d updated upon init\n", cpu
);
399 apply_microcode_on_target(cpu
);
405 static enum ucode_state
microcode_update_cpu(int cpu
)
407 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
408 enum ucode_state ustate
;
411 ustate
= microcode_resume_cpu(cpu
);
413 ustate
= microcode_init_cpu(cpu
);
418 static int mc_device_add(struct device
*dev
, struct subsys_interface
*sif
)
420 int err
, cpu
= dev
->id
;
422 if (!cpu_online(cpu
))
425 pr_debug("CPU%d added\n", cpu
);
427 err
= sysfs_create_group(&dev
->kobj
, &mc_attr_group
);
431 if (microcode_init_cpu(cpu
) == UCODE_ERROR
)
437 static int mc_device_remove(struct device
*dev
, struct subsys_interface
*sif
)
441 if (!cpu_online(cpu
))
444 pr_debug("CPU%d removed\n", cpu
);
445 microcode_fini_cpu(cpu
);
446 sysfs_remove_group(&dev
->kobj
, &mc_attr_group
);
450 static struct subsys_interface mc_cpu_interface
= {
452 .subsys
= &cpu_subsys
,
453 .add_dev
= mc_device_add
,
454 .remove_dev
= mc_device_remove
,
458 * mc_bp_resume - Update boot CPU microcode during resume.
460 static void mc_bp_resume(void)
462 int cpu
= smp_processor_id();
463 struct ucode_cpu_info
*uci
= ucode_cpu_info
+ cpu
;
465 if (uci
->valid
&& uci
->mc
)
466 microcode_ops
->apply_microcode(cpu
);
469 static struct syscore_ops mc_syscore_ops
= {
470 .resume
= mc_bp_resume
,
474 mc_cpu_callback(struct notifier_block
*nb
, unsigned long action
, void *hcpu
)
476 unsigned int cpu
= (unsigned long)hcpu
;
479 dev
= get_cpu_device(cpu
);
482 case CPU_ONLINE_FROZEN
:
483 microcode_update_cpu(cpu
);
484 case CPU_DOWN_FAILED
:
485 case CPU_DOWN_FAILED_FROZEN
:
486 pr_debug("CPU%d added\n", cpu
);
487 if (sysfs_create_group(&dev
->kobj
, &mc_attr_group
))
488 pr_err("Failed to create group for CPU%d\n", cpu
);
490 case CPU_DOWN_PREPARE
:
491 case CPU_DOWN_PREPARE_FROZEN
:
492 /* Suspend is in progress, only remove the interface */
493 sysfs_remove_group(&dev
->kobj
, &mc_attr_group
);
494 pr_debug("CPU%d removed\n", cpu
);
498 * When a CPU goes offline, don't free up or invalidate the copy of
499 * the microcode in kernel memory, so that we can reuse it when the
500 * CPU comes back online without unnecessarily requesting the userspace
503 case CPU_UP_CANCELED_FROZEN
:
504 /* The CPU refused to come up during a system resume */
505 microcode_fini_cpu(cpu
);
511 static struct notifier_block __refdata mc_cpu_notifier
= {
512 .notifier_call
= mc_cpu_callback
,
516 /* Autoload on Intel and AMD systems */
517 static const struct x86_cpu_id __initconst microcode_id
[] = {
518 #ifdef CONFIG_MICROCODE_INTEL
519 { X86_VENDOR_INTEL
, X86_FAMILY_ANY
, X86_MODEL_ANY
, },
521 #ifdef CONFIG_MICROCODE_AMD
522 { X86_VENDOR_AMD
, X86_FAMILY_ANY
, X86_MODEL_ANY
, },
526 MODULE_DEVICE_TABLE(x86cpu
, microcode_id
);
529 static struct attribute
*cpu_root_microcode_attrs
[] = {
530 &dev_attr_reload
.attr
,
534 static struct attribute_group cpu_root_microcode_group
= {
536 .attrs
= cpu_root_microcode_attrs
,
539 static int __init
microcode_init(void)
541 struct cpuinfo_x86
*c
= &cpu_data(0);
544 if (c
->x86_vendor
== X86_VENDOR_INTEL
)
545 microcode_ops
= init_intel_microcode();
546 else if (c
->x86_vendor
== X86_VENDOR_AMD
)
547 microcode_ops
= init_amd_microcode();
549 pr_err("no support for this CPU vendor\n");
554 microcode_pdev
= platform_device_register_simple("microcode", -1,
556 if (IS_ERR(microcode_pdev
))
557 return PTR_ERR(microcode_pdev
);
560 mutex_lock(µcode_mutex
);
562 error
= subsys_interface_register(&mc_cpu_interface
);
564 perf_check_microcode();
565 mutex_unlock(µcode_mutex
);
571 error
= sysfs_create_group(&cpu_subsys
.dev_root
->kobj
,
572 &cpu_root_microcode_group
);
575 pr_err("Error creating microcode group!\n");
579 error
= microcode_dev_init();
581 goto out_ucode_group
;
583 register_syscore_ops(&mc_syscore_ops
);
584 register_hotcpu_notifier(&mc_cpu_notifier
);
586 pr_info("Microcode Update Driver: v" MICROCODE_VERSION
587 " <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n");
592 sysfs_remove_group(&cpu_subsys
.dev_root
->kobj
,
593 &cpu_root_microcode_group
);
597 mutex_lock(µcode_mutex
);
599 subsys_interface_unregister(&mc_cpu_interface
);
601 mutex_unlock(µcode_mutex
);
605 platform_device_unregister(microcode_pdev
);
609 module_init(microcode_init
);
611 static void __exit
microcode_exit(void)
613 struct cpuinfo_x86
*c
= &cpu_data(0);
615 microcode_dev_exit();
617 unregister_hotcpu_notifier(&mc_cpu_notifier
);
618 unregister_syscore_ops(&mc_syscore_ops
);
620 sysfs_remove_group(&cpu_subsys
.dev_root
->kobj
,
621 &cpu_root_microcode_group
);
624 mutex_lock(µcode_mutex
);
626 subsys_interface_unregister(&mc_cpu_interface
);
628 mutex_unlock(µcode_mutex
);
631 platform_device_unregister(microcode_pdev
);
633 microcode_ops
= NULL
;
635 if (c
->x86_vendor
== X86_VENDOR_AMD
)
636 exit_amd_microcode();
638 pr_info("Microcode Update Driver: v" MICROCODE_VERSION
" removed.\n");
640 module_exit(microcode_exit
);