Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Intel CPU Microcode Update Driver for Linux |
| 3 | * |
| 4 | * Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk> |
| 5 | * 2006 Shaohua Li <shaohua.li@intel.com> |
| 6 | * |
| 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. |
| 10 | * |
| 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: |
| 14 | * |
Justin P. Mattock | 50a23e6 | 2010-10-16 10:36:23 -0700 | [diff] [blame] | 15 | * http://developer.intel.com/Assets/PDF/manual/253668.pdf |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 16 | * |
| 17 | * For more information, go to http://www.urbanmyth.org/microcode |
| 18 | * |
| 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. |
| 23 | * |
| 24 | * 1.0 16 Feb 2000, Tigran Aivazian <tigran@sco.com> |
| 25 | * Initial release. |
| 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>, |
Peter Oruba | d33dcb9 | 2008-08-01 12:46:45 +0200 | [diff] [blame] | 58 | * Serialize updates as required on HT processors due to |
| 59 | * speculative nature of implementation. |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 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 |
| 68 | * in kernel memory. |
| 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. |
| 72 | */ |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 73 | |
| 74 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 75 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 76 | #include <linux/platform_device.h> |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 77 | #include <linux/miscdevice.h> |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 78 | #include <linux/capability.h> |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 79 | #include <linux/kernel.h> |
| 80 | #include <linux/module.h> |
| 81 | #include <linux/mutex.h> |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 82 | #include <linux/cpu.h> |
| 83 | #include <linux/fs.h> |
| 84 | #include <linux/mm.h> |
Rafael J. Wysocki | f3c6ea1 | 2011-03-23 22:15:54 +0100 | [diff] [blame] | 85 | #include <linux/syscore_ops.h> |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 86 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 87 | #include <asm/microcode.h> |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 88 | #include <asm/processor.h> |
Andi Kleen | 78ff123 | 2012-01-26 00:09:13 +0100 | [diff] [blame] | 89 | #include <asm/cpu_device_id.h> |
Peter Zijlstra | c93dc84 | 2012-06-08 14:50:50 +0200 | [diff] [blame] | 90 | #include <asm/perf_event.h> |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 91 | |
| 92 | MODULE_DESCRIPTION("Microcode Update Driver"); |
| 93 | MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>"); |
| 94 | MODULE_LICENSE("GPL"); |
| 95 | |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 96 | #define MICROCODE_VERSION "2.00" |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 97 | |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 98 | static struct microcode_ops *microcode_ops; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 99 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 100 | /* |
| 101 | * Synchronization. |
| 102 | * |
| 103 | * All non cpu-hotplug-callback call sites use: |
| 104 | * |
| 105 | * - microcode_mutex to synchronize with each other; |
| 106 | * - get/put_online_cpus() to synchronize with |
| 107 | * the cpu-hotplug-callback call sites. |
| 108 | * |
| 109 | * We guarantee that only a single cpu is being |
| 110 | * updated at any particular moment of time. |
| 111 | */ |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 112 | static DEFINE_MUTEX(microcode_mutex); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 113 | |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 114 | struct ucode_cpu_info ucode_cpu_info[NR_CPUS]; |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 115 | EXPORT_SYMBOL_GPL(ucode_cpu_info); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 116 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 117 | /* |
| 118 | * Operations that are run on a target cpu: |
| 119 | */ |
| 120 | |
| 121 | struct cpu_info_ctx { |
| 122 | struct cpu_signature *cpu_sig; |
| 123 | int err; |
| 124 | }; |
| 125 | |
| 126 | static 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 | |
| 134 | static 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 | |
| 146 | static 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 | |
| 160 | struct apply_microcode_ctx { |
| 161 | int err; |
| 162 | }; |
| 163 | |
| 164 | static 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 | |
| 171 | static 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 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 183 | #ifdef CONFIG_MICROCODE_OLD_INTERFACE |
Dmitry Adamushko | a0a29b6 | 2008-09-11 23:27:52 +0200 | [diff] [blame] | 184 | static int do_microcode_update(const void __user *buf, size_t size) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 185 | { |
Dmitry Adamushko | a0a29b6 | 2008-09-11 23:27:52 +0200 | [diff] [blame] | 186 | int error = 0; |
| 187 | int cpu; |
Hugh Dickins | 6f66cbc | 2009-04-14 19:25:42 +0100 | [diff] [blame] | 188 | |
Dmitry Adamushko | a0a29b6 | 2008-09-11 23:27:52 +0200 | [diff] [blame] | 189 | for_each_online_cpu(cpu) { |
| 190 | struct ucode_cpu_info *uci = ucode_cpu_info + cpu; |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 191 | enum ucode_state ustate; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 192 | |
Dmitry Adamushko | a0a29b6 | 2008-09-11 23:27:52 +0200 | [diff] [blame] | 193 | if (!uci->valid) |
| 194 | continue; |
Hugh Dickins | 6f66cbc | 2009-04-14 19:25:42 +0100 | [diff] [blame] | 195 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 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); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 202 | } |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 203 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 204 | return error; |
| 205 | } |
| 206 | |
Arnd Bergmann | 3f10940 | 2010-04-10 16:46:21 +0200 | [diff] [blame] | 207 | static int microcode_open(struct inode *inode, struct file *file) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 208 | { |
Arnd Bergmann | 3f10940 | 2010-04-10 16:46:21 +0200 | [diff] [blame] | 209 | return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 210 | } |
| 211 | |
Peter Oruba | d33dcb9 | 2008-08-01 12:46:45 +0200 | [diff] [blame] | 212 | static ssize_t microcode_write(struct file *file, const char __user *buf, |
| 213 | size_t len, loff_t *ppos) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 214 | { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 215 | ssize_t ret = -EINVAL; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 216 | |
Jan Beulich | 4481374 | 2009-09-21 17:03:05 -0700 | [diff] [blame] | 217 | if ((len >> PAGE_SHIFT) > totalram_pages) { |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 218 | pr_err("too much data (max %ld pages)\n", totalram_pages); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 219 | return ret; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 220 | } |
| 221 | |
| 222 | get_online_cpus(); |
| 223 | mutex_lock(µcode_mutex); |
| 224 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 225 | if (do_microcode_update(buf, len) == 0) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 226 | ret = (ssize_t)len; |
| 227 | |
Stephane Eranian | e3e45c0 | 2012-08-24 15:34:34 +0200 | [diff] [blame] | 228 | if (ret > 0) |
| 229 | perf_check_microcode(); |
| 230 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 231 | mutex_unlock(µcode_mutex); |
| 232 | put_online_cpus(); |
| 233 | |
| 234 | return ret; |
| 235 | } |
| 236 | |
| 237 | static const struct file_operations microcode_fops = { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 238 | .owner = THIS_MODULE, |
| 239 | .write = microcode_write, |
| 240 | .open = microcode_open, |
Arnd Bergmann | 6038f37 | 2010-08-15 18:52:59 +0200 | [diff] [blame] | 241 | .llseek = no_llseek, |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 242 | }; |
| 243 | |
| 244 | static struct miscdevice microcode_dev = { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 245 | .minor = MICROCODE_MINOR, |
| 246 | .name = "microcode", |
Kay Sievers | e454cea | 2009-09-18 23:01:12 +0200 | [diff] [blame] | 247 | .nodename = "cpu/microcode", |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 248 | .fops = µcode_fops, |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 249 | }; |
| 250 | |
Peter Oruba | d33dcb9 | 2008-08-01 12:46:45 +0200 | [diff] [blame] | 251 | static int __init microcode_dev_init(void) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 252 | { |
| 253 | int error; |
| 254 | |
| 255 | error = misc_register(µcode_dev); |
| 256 | if (error) { |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 257 | pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 258 | return error; |
| 259 | } |
| 260 | |
| 261 | return 0; |
| 262 | } |
| 263 | |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 264 | static void __exit microcode_dev_exit(void) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 265 | { |
| 266 | misc_deregister(µcode_dev); |
| 267 | } |
| 268 | |
| 269 | MODULE_ALIAS_MISCDEV(MICROCODE_MINOR); |
Kay Sievers | 578454f | 2010-05-20 18:07:20 +0200 | [diff] [blame] | 270 | MODULE_ALIAS("devname:cpu/microcode"); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 271 | #else |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 272 | #define microcode_dev_init() 0 |
| 273 | #define microcode_dev_exit() do { } while (0) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 274 | #endif |
| 275 | |
| 276 | /* fake device for request_firmware */ |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 277 | static struct platform_device *microcode_pdev; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 278 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 279 | static int reload_for_cpu(int cpu) |
Rusty Russell | af5c820 | 2009-03-11 16:32:36 +1030 | [diff] [blame] | 280 | { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 281 | struct ucode_cpu_info *uci = ucode_cpu_info + cpu; |
Borislav Petkov | 4dbf32c | 2012-07-23 19:05:53 +0200 | [diff] [blame] | 282 | enum ucode_state ustate; |
Rusty Russell | af5c820 | 2009-03-11 16:32:36 +1030 | [diff] [blame] | 283 | int err = 0; |
| 284 | |
Borislav Petkov | 4dbf32c | 2012-07-23 19:05:53 +0200 | [diff] [blame] | 285 | if (!uci->valid) |
| 286 | return err; |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 287 | |
Borislav Petkov | 48e3068 | 2012-07-26 15:51:00 +0200 | [diff] [blame] | 288 | ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, true); |
Borislav Petkov | 4dbf32c | 2012-07-23 19:05:53 +0200 | [diff] [blame] | 289 | if (ustate == UCODE_OK) |
| 290 | apply_microcode_on_target(cpu); |
| 291 | else |
| 292 | if (ustate == UCODE_ERROR) |
| 293 | err = -EINVAL; |
Rusty Russell | af5c820 | 2009-03-11 16:32:36 +1030 | [diff] [blame] | 294 | return err; |
| 295 | } |
| 296 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 297 | static ssize_t reload_store(struct device *dev, |
| 298 | struct device_attribute *attr, |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 299 | const char *buf, size_t size) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 300 | { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 301 | unsigned long val; |
Borislav Petkov | c9fc3f7 | 2012-06-21 14:07:16 +0200 | [diff] [blame] | 302 | int cpu; |
| 303 | ssize_t ret = 0, tmp_ret; |
| 304 | |
Shuah Khan | e826abd | 2012-05-06 11:11:04 -0600 | [diff] [blame] | 305 | ret = kstrtoul(buf, 0, &val); |
| 306 | if (ret) |
| 307 | return ret; |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 308 | |
Borislav Petkov | c9fc3f7 | 2012-06-21 14:07:16 +0200 | [diff] [blame] | 309 | if (val != 1) |
| 310 | return size; |
| 311 | |
| 312 | get_online_cpus(); |
Peter Zijlstra | c93dc84 | 2012-06-08 14:50:50 +0200 | [diff] [blame] | 313 | mutex_lock(µcode_mutex); |
Borislav Petkov | c9fc3f7 | 2012-06-21 14:07:16 +0200 | [diff] [blame] | 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 | /* save retval of the first encountered reload error */ |
| 320 | if (!ret) |
| 321 | ret = tmp_ret; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 322 | } |
Peter Zijlstra | c93dc84 | 2012-06-08 14:50:50 +0200 | [diff] [blame] | 323 | if (!ret) |
| 324 | perf_check_microcode(); |
| 325 | mutex_unlock(µcode_mutex); |
Borislav Petkov | c9fc3f7 | 2012-06-21 14:07:16 +0200 | [diff] [blame] | 326 | put_online_cpus(); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 327 | |
| 328 | if (!ret) |
| 329 | ret = size; |
| 330 | |
| 331 | return ret; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 332 | } |
| 333 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 334 | static ssize_t version_show(struct device *dev, |
| 335 | struct device_attribute *attr, char *buf) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 336 | { |
| 337 | struct ucode_cpu_info *uci = ucode_cpu_info + dev->id; |
| 338 | |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 339 | return sprintf(buf, "0x%x\n", uci->cpu_sig.rev); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 340 | } |
| 341 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 342 | static ssize_t pf_show(struct device *dev, |
| 343 | struct device_attribute *attr, char *buf) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 344 | { |
| 345 | struct ucode_cpu_info *uci = ucode_cpu_info + dev->id; |
| 346 | |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 347 | return sprintf(buf, "0x%x\n", uci->cpu_sig.pf); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 348 | } |
| 349 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 350 | static DEVICE_ATTR(reload, 0200, NULL, reload_store); |
| 351 | static DEVICE_ATTR(version, 0400, version_show, NULL); |
| 352 | static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 353 | |
| 354 | static struct attribute *mc_default_attrs[] = { |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 355 | &dev_attr_version.attr, |
| 356 | &dev_attr_processor_flags.attr, |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 357 | NULL |
| 358 | }; |
| 359 | |
| 360 | static struct attribute_group mc_attr_group = { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 361 | .attrs = mc_default_attrs, |
| 362 | .name = "microcode", |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 363 | }; |
| 364 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 365 | static void microcode_fini_cpu(int cpu) |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 366 | { |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 367 | microcode_ops->microcode_fini_cpu(cpu); |
Dmitry Adamushko | 280a9ca | 2008-12-20 00:15:24 +0100 | [diff] [blame] | 368 | } |
| 369 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 370 | static enum ucode_state microcode_resume_cpu(int cpu) |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 371 | { |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 372 | pr_debug("CPU%d updated upon resume\n", cpu); |
Borislav Petkov | bb9d3e4 | 2012-08-03 15:26:50 +0200 | [diff] [blame] | 373 | |
| 374 | if (apply_microcode_on_target(cpu)) |
| 375 | return UCODE_ERROR; |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 376 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 377 | return UCODE_OK; |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 378 | } |
| 379 | |
Borislav Petkov | 48e3068 | 2012-07-26 15:51:00 +0200 | [diff] [blame] | 380 | static enum ucode_state microcode_init_cpu(int cpu, bool refresh_fw) |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 381 | { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 382 | enum ucode_state ustate; |
Fenghua Yu | 9cd4d78 | 2012-12-20 23:44:22 -0800 | [diff] [blame] | 383 | struct ucode_cpu_info *uci = ucode_cpu_info + cpu; |
| 384 | |
| 385 | if (uci && uci->valid) |
| 386 | return UCODE_OK; |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 387 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 388 | if (collect_cpu_info(cpu)) |
| 389 | return UCODE_ERROR; |
| 390 | |
| 391 | /* --dimm. Trigger a delayed update? */ |
| 392 | if (system_state != SYSTEM_RUNNING) |
| 393 | return UCODE_NFOUND; |
| 394 | |
Borislav Petkov | 48e3068 | 2012-07-26 15:51:00 +0200 | [diff] [blame] | 395 | ustate = microcode_ops->request_microcode_fw(cpu, µcode_pdev->dev, |
| 396 | refresh_fw); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 397 | |
| 398 | if (ustate == UCODE_OK) { |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 399 | pr_debug("CPU%d updated upon init\n", cpu); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 400 | apply_microcode_on_target(cpu); |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 401 | } |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 402 | |
| 403 | return ustate; |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 404 | } |
| 405 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 406 | static enum ucode_state microcode_update_cpu(int cpu) |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 407 | { |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 408 | struct ucode_cpu_info *uci = ucode_cpu_info + cpu; |
Dmitry Adamushko | fd1452e | 2008-10-02 16:56:19 +0300 | [diff] [blame] | 409 | |
Linus Torvalds | 2f99f5c | 2009-12-23 15:04:53 -0800 | [diff] [blame] | 410 | if (uci->valid) |
Borislav Petkov | bb9d3e4 | 2012-08-03 15:26:50 +0200 | [diff] [blame] | 411 | return microcode_resume_cpu(cpu); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 412 | |
Borislav Petkov | 48e3068 | 2012-07-26 15:51:00 +0200 | [diff] [blame] | 413 | return microcode_init_cpu(cpu, false); |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 414 | } |
| 415 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 416 | static int mc_device_add(struct device *dev, struct subsys_interface *sif) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 417 | { |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 418 | int err, cpu = dev->id; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 419 | |
| 420 | if (!cpu_online(cpu)) |
| 421 | return 0; |
| 422 | |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 423 | pr_debug("CPU%d added\n", cpu); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 424 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 425 | err = sysfs_create_group(&dev->kobj, &mc_attr_group); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 426 | if (err) |
| 427 | return err; |
| 428 | |
Borislav Petkov | 48e3068 | 2012-07-26 15:51:00 +0200 | [diff] [blame] | 429 | if (microcode_init_cpu(cpu, true) == UCODE_ERROR) |
Borislav Petkov | 6c53cbf | 2011-01-06 16:56:51 +0100 | [diff] [blame] | 430 | return -EINVAL; |
Rusty Russell | af5c820 | 2009-03-11 16:32:36 +1030 | [diff] [blame] | 431 | |
| 432 | return err; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 433 | } |
| 434 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 435 | static int mc_device_remove(struct device *dev, struct subsys_interface *sif) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 436 | { |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 437 | int cpu = dev->id; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 438 | |
| 439 | if (!cpu_online(cpu)) |
| 440 | return 0; |
| 441 | |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 442 | pr_debug("CPU%d removed\n", cpu); |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 443 | microcode_fini_cpu(cpu); |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 444 | sysfs_remove_group(&dev->kobj, &mc_attr_group); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 445 | return 0; |
| 446 | } |
| 447 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 448 | static struct subsys_interface mc_cpu_interface = { |
| 449 | .name = "microcode", |
| 450 | .subsys = &cpu_subsys, |
| 451 | .add_dev = mc_device_add, |
| 452 | .remove_dev = mc_device_remove, |
Rafael J. Wysocki | f3c6ea1 | 2011-03-23 22:15:54 +0100 | [diff] [blame] | 453 | }; |
| 454 | |
| 455 | /** |
| 456 | * mc_bp_resume - Update boot CPU microcode during resume. |
| 457 | */ |
| 458 | static void mc_bp_resume(void) |
| 459 | { |
| 460 | int cpu = smp_processor_id(); |
| 461 | struct ucode_cpu_info *uci = ucode_cpu_info + cpu; |
| 462 | |
| 463 | if (uci->valid && uci->mc) |
| 464 | microcode_ops->apply_microcode(cpu); |
| 465 | } |
| 466 | |
| 467 | static struct syscore_ops mc_syscore_ops = { |
| 468 | .resume = mc_bp_resume, |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 469 | }; |
| 470 | |
Paul Gortmaker | 148f9bb | 2013-06-18 18:23:59 -0400 | [diff] [blame] | 471 | static int |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 472 | mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu) |
| 473 | { |
| 474 | unsigned int cpu = (unsigned long)hcpu; |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 475 | struct device *dev; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 476 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 477 | dev = get_cpu_device(cpu); |
Borislav Petkov | 09c3f0d | 2012-07-23 20:15:10 +0200 | [diff] [blame] | 478 | |
| 479 | switch (action & ~CPU_TASKS_FROZEN) { |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 480 | case CPU_ONLINE: |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 481 | microcode_update_cpu(cpu); |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 482 | pr_debug("CPU%d added\n", cpu); |
Borislav Petkov | 09c3f0d | 2012-07-23 20:15:10 +0200 | [diff] [blame] | 483 | /* |
| 484 | * "break" is missing on purpose here because we want to fall |
| 485 | * through in order to create the sysfs group. |
| 486 | */ |
| 487 | |
| 488 | case CPU_DOWN_FAILED: |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 489 | if (sysfs_create_group(&dev->kobj, &mc_attr_group)) |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 490 | pr_err("Failed to create group for CPU%d\n", cpu); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 491 | break; |
Borislav Petkov | 09c3f0d | 2012-07-23 20:15:10 +0200 | [diff] [blame] | 492 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 493 | case CPU_DOWN_PREPARE: |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 494 | /* Suspend is in progress, only remove the interface */ |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 495 | sysfs_remove_group(&dev->kobj, &mc_attr_group); |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 496 | pr_debug("CPU%d removed\n", cpu); |
Dmitry Adamushko | d45de40 | 2008-08-20 00:22:26 +0200 | [diff] [blame] | 497 | break; |
Srivatsa S. Bhat | 7098944 | 2011-10-09 15:42:00 -0400 | [diff] [blame] | 498 | |
| 499 | /* |
Borislav Petkov | 09c3f0d | 2012-07-23 20:15:10 +0200 | [diff] [blame] | 500 | * case CPU_DEAD: |
| 501 | * |
Srivatsa S. Bhat | 7098944 | 2011-10-09 15:42:00 -0400 | [diff] [blame] | 502 | * When a CPU goes offline, don't free up or invalidate the copy of |
| 503 | * the microcode in kernel memory, so that we can reuse it when the |
| 504 | * CPU comes back online without unnecessarily requesting the userspace |
| 505 | * for it again. |
| 506 | */ |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 507 | } |
Borislav Petkov | 09c3f0d | 2012-07-23 20:15:10 +0200 | [diff] [blame] | 508 | |
| 509 | /* The CPU refused to come up during a system resume */ |
| 510 | if (action == CPU_UP_CANCELED_FROZEN) |
| 511 | microcode_fini_cpu(cpu); |
| 512 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 513 | return NOTIFY_OK; |
| 514 | } |
| 515 | |
| 516 | static struct notifier_block __refdata mc_cpu_notifier = { |
Ingo Molnar | 4bae196 | 2009-03-11 11:19:46 +0100 | [diff] [blame] | 517 | .notifier_call = mc_cpu_callback, |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 518 | }; |
| 519 | |
Andi Kleen | 78ff123 | 2012-01-26 00:09:13 +0100 | [diff] [blame] | 520 | #ifdef MODULE |
| 521 | /* Autoload on Intel and AMD systems */ |
Jan Beulich | e1b6fc5 | 2012-06-18 11:28:45 +0100 | [diff] [blame] | 522 | static const struct x86_cpu_id __initconst microcode_id[] = { |
Andi Kleen | 78ff123 | 2012-01-26 00:09:13 +0100 | [diff] [blame] | 523 | #ifdef CONFIG_MICROCODE_INTEL |
| 524 | { X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, }, |
| 525 | #endif |
| 526 | #ifdef CONFIG_MICROCODE_AMD |
| 527 | { X86_VENDOR_AMD, X86_FAMILY_ANY, X86_MODEL_ANY, }, |
| 528 | #endif |
| 529 | {} |
| 530 | }; |
| 531 | MODULE_DEVICE_TABLE(x86cpu, microcode_id); |
| 532 | #endif |
| 533 | |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 534 | static struct attribute *cpu_root_microcode_attrs[] = { |
| 535 | &dev_attr_reload.attr, |
| 536 | NULL |
| 537 | }; |
| 538 | |
| 539 | static struct attribute_group cpu_root_microcode_group = { |
| 540 | .name = "microcode", |
| 541 | .attrs = cpu_root_microcode_attrs, |
| 542 | }; |
| 543 | |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 544 | static int __init microcode_init(void) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 545 | { |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 546 | struct cpuinfo_x86 *c = &cpu_data(0); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 547 | int error; |
| 548 | |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 549 | if (c->x86_vendor == X86_VENDOR_INTEL) |
| 550 | microcode_ops = init_intel_microcode(); |
Peter Oruba | 82b0786 | 2008-09-24 11:50:35 +0200 | [diff] [blame] | 551 | else if (c->x86_vendor == X86_VENDOR_AMD) |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 552 | microcode_ops = init_amd_microcode(); |
Andreas Herrmann | 283c1f2 | 2012-04-12 16:51:57 +0200 | [diff] [blame] | 553 | else |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 554 | pr_err("no support for this CPU vendor\n"); |
Andreas Herrmann | 283c1f2 | 2012-04-12 16:51:57 +0200 | [diff] [blame] | 555 | |
| 556 | if (!microcode_ops) |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 557 | return -ENODEV; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 558 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 559 | microcode_pdev = platform_device_register_simple("microcode", -1, |
| 560 | NULL, 0); |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 561 | if (IS_ERR(microcode_pdev)) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 562 | return PTR_ERR(microcode_pdev); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 563 | |
| 564 | get_online_cpus(); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 565 | mutex_lock(µcode_mutex); |
| 566 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 567 | error = subsys_interface_register(&mc_cpu_interface); |
Peter Zijlstra | c93dc84 | 2012-06-08 14:50:50 +0200 | [diff] [blame] | 568 | if (!error) |
| 569 | perf_check_microcode(); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 570 | mutex_unlock(µcode_mutex); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 571 | put_online_cpus(); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 572 | |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 573 | if (error) |
| 574 | goto out_pdev; |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 575 | |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 576 | error = sysfs_create_group(&cpu_subsys.dev_root->kobj, |
| 577 | &cpu_root_microcode_group); |
| 578 | |
| 579 | if (error) { |
| 580 | pr_err("Error creating microcode group!\n"); |
| 581 | goto out_driver; |
| 582 | } |
| 583 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 584 | error = microcode_dev_init(); |
| 585 | if (error) |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 586 | goto out_ucode_group; |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 587 | |
Rafael J. Wysocki | f3c6ea1 | 2011-03-23 22:15:54 +0100 | [diff] [blame] | 588 | register_syscore_ops(&mc_syscore_ops); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 589 | register_hotcpu_notifier(&mc_cpu_notifier); |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 590 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 591 | pr_info("Microcode Update Driver: v" MICROCODE_VERSION |
Joe Perches | f58e1f5 | 2009-12-08 22:30:50 -0800 | [diff] [blame] | 592 | " <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n"); |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 593 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 594 | return 0; |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 595 | |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 596 | out_ucode_group: |
| 597 | sysfs_remove_group(&cpu_subsys.dev_root->kobj, |
| 598 | &cpu_root_microcode_group); |
| 599 | |
| 600 | out_driver: |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 601 | get_online_cpus(); |
| 602 | mutex_lock(µcode_mutex); |
| 603 | |
Greg Kroah-Hartman | ff4b8a5 | 2012-01-06 11:42:52 -0800 | [diff] [blame] | 604 | subsys_interface_unregister(&mc_cpu_interface); |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 605 | |
| 606 | mutex_unlock(µcode_mutex); |
| 607 | put_online_cpus(); |
| 608 | |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 609 | out_pdev: |
Srivatsa S. Bhat | bd39906 | 2011-11-07 18:05:32 +0530 | [diff] [blame] | 610 | platform_device_unregister(microcode_pdev); |
| 611 | return error; |
| 612 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 613 | } |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 614 | module_init(microcode_init); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 615 | |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 616 | static void __exit microcode_exit(void) |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 617 | { |
Borislav Petkov | f72c1a5 | 2011-12-02 16:50:04 +0100 | [diff] [blame] | 618 | struct cpuinfo_x86 *c = &cpu_data(0); |
| 619 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 620 | microcode_dev_exit(); |
| 621 | |
| 622 | unregister_hotcpu_notifier(&mc_cpu_notifier); |
Xiaotian Feng | 4ac5fc6 | 2011-03-29 16:34:32 +0800 | [diff] [blame] | 623 | unregister_syscore_ops(&mc_syscore_ops); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 624 | |
Borislav Petkov | 3d8986b | 2012-06-21 14:07:17 +0200 | [diff] [blame] | 625 | sysfs_remove_group(&cpu_subsys.dev_root->kobj, |
| 626 | &cpu_root_microcode_group); |
| 627 | |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 628 | get_online_cpus(); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 629 | mutex_lock(µcode_mutex); |
| 630 | |
Kay Sievers | 8a25a2f | 2011-12-21 14:29:42 -0800 | [diff] [blame] | 631 | subsys_interface_unregister(&mc_cpu_interface); |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 632 | |
| 633 | mutex_unlock(µcode_mutex); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 634 | put_online_cpus(); |
| 635 | |
| 636 | platform_device_unregister(microcode_pdev); |
Peter Oruba | 3e135d8 | 2008-07-28 18:44:17 +0200 | [diff] [blame] | 637 | |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 638 | microcode_ops = NULL; |
| 639 | |
Borislav Petkov | f72c1a5 | 2011-12-02 16:50:04 +0100 | [diff] [blame] | 640 | if (c->x86_vendor == X86_VENDOR_AMD) |
| 641 | exit_amd_microcode(); |
| 642 | |
Dmitry Adamushko | 871b72d | 2009-05-11 23:48:27 +0200 | [diff] [blame] | 643 | pr_info("Microcode Update Driver: v" MICROCODE_VERSION " removed.\n"); |
Peter Oruba | 8d86f39 | 2008-07-28 18:44:21 +0200 | [diff] [blame] | 644 | } |
Dmitry Adamushko | 18dbc91 | 2008-09-23 12:08:44 +0200 | [diff] [blame] | 645 | module_exit(microcode_exit); |