x86/microcode: Use nonseekable_open()
[linux-irmos:linux-irmos.git] / arch / x86 / kernel / microcode_core.c
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  *
15  *      http://developer.intel.com/design/pentium4/manuals/253668.htm
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>,
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
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  */
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
86 #include <asm/microcode.h>
87 #include <asm/processor.h>
88
89 MODULE_DESCRIPTION("Microcode Update Driver");
90 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
91 MODULE_LICENSE("GPL");
92
93 #define MICROCODE_VERSION       "2.00"
94
95 static struct microcode_ops     *microcode_ops;
96
97 /*
98  * Synchronization.
99  *
100  * All non cpu-hotplug-callback call sites use:
101  *
102  * - microcode_mutex to synchronize with each other;
103  * - get/put_online_cpus() to synchronize with
104  *   the cpu-hotplug-callback call sites.
105  *
106  * We guarantee that only a single cpu is being
107  * updated at any particular moment of time.
108  */
109 static DEFINE_MUTEX(microcode_mutex);
110
111 struct ucode_cpu_info           ucode_cpu_info[NR_CPUS];
112 EXPORT_SYMBOL_GPL(ucode_cpu_info);
113
114 /*
115  * Operations that are run on a target cpu:
116  */
117
118 struct cpu_info_ctx {
119         struct cpu_signature    *cpu_sig;
120         int                     err;
121 };
122
123 static void collect_cpu_info_local(void *arg)
124 {
125         struct cpu_info_ctx *ctx = arg;
126
127         ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
128                                                    ctx->cpu_sig);
129 }
130
131 static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
132 {
133         struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
134         int ret;
135
136         ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
137         if (!ret)
138                 ret = ctx.err;
139
140         return ret;
141 }
142
143 static int collect_cpu_info(int cpu)
144 {
145         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
146         int ret;
147
148         memset(uci, 0, sizeof(*uci));
149
150         ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
151         if (!ret)
152                 uci->valid = 1;
153
154         return ret;
155 }
156
157 struct apply_microcode_ctx {
158         int err;
159 };
160
161 static void apply_microcode_local(void *arg)
162 {
163         struct apply_microcode_ctx *ctx = arg;
164
165         ctx->err = microcode_ops->apply_microcode(smp_processor_id());
166 }
167
168 static int apply_microcode_on_target(int cpu)
169 {
170         struct apply_microcode_ctx ctx = { .err = 0 };
171         int ret;
172
173         ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1);
174         if (!ret)
175                 ret = ctx.err;
176
177         return ret;
178 }
179
180 #ifdef CONFIG_MICROCODE_OLD_INTERFACE
181 static int do_microcode_update(const void __user *buf, size_t size)
182 {
183         int error = 0;
184         int cpu;
185
186         for_each_online_cpu(cpu) {
187                 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
188                 enum ucode_state ustate;
189
190                 if (!uci->valid)
191                         continue;
192
193                 ustate = microcode_ops->request_microcode_user(cpu, buf, size);
194                 if (ustate == UCODE_ERROR) {
195                         error = -1;
196                         break;
197                 } else if (ustate == UCODE_OK)
198                         apply_microcode_on_target(cpu);
199         }
200
201         return error;
202 }
203
204 static int microcode_open(struct inode *inode, struct file *file)
205 {
206         return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM;
207 }
208
209 static ssize_t microcode_write(struct file *file, const char __user *buf,
210                                size_t len, loff_t *ppos)
211 {
212         ssize_t ret = -EINVAL;
213
214         if ((len >> PAGE_SHIFT) > totalram_pages) {
215                 pr_err("too much data (max %ld pages)\n", totalram_pages);
216                 return ret;
217         }
218
219         get_online_cpus();
220         mutex_lock(&microcode_mutex);
221
222         if (do_microcode_update(buf, len) == 0)
223                 ret = (ssize_t)len;
224
225         mutex_unlock(&microcode_mutex);
226         put_online_cpus();
227
228         return ret;
229 }
230
231 static const struct file_operations microcode_fops = {
232         .owner                  = THIS_MODULE,
233         .write                  = microcode_write,
234         .open                   = microcode_open,
235 };
236
237 static struct miscdevice microcode_dev = {
238         .minor                  = MICROCODE_MINOR,
239         .name                   = "microcode",
240         .nodename               = "cpu/microcode",
241         .fops                   = &microcode_fops,
242 };
243
244 static int __init microcode_dev_init(void)
245 {
246         int error;
247
248         error = misc_register(&microcode_dev);
249         if (error) {
250                 pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR);
251                 return error;
252         }
253
254         return 0;
255 }
256
257 static void microcode_dev_exit(void)
258 {
259         misc_deregister(&microcode_dev);
260 }
261
262 MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
263 #else
264 #define microcode_dev_init()    0
265 #define microcode_dev_exit()    do { } while (0)
266 #endif
267
268 /* fake device for request_firmware */
269 static struct platform_device   *microcode_pdev;
270
271 static int reload_for_cpu(int cpu)
272 {
273         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
274         int err = 0;
275
276         mutex_lock(&microcode_mutex);
277         if (uci->valid) {
278                 enum ucode_state ustate;
279
280                 ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);
281                 if (ustate == UCODE_OK)
282                         apply_microcode_on_target(cpu);
283                 else
284                         if (ustate == UCODE_ERROR)
285                                 err = -EINVAL;
286         }
287         mutex_unlock(&microcode_mutex);
288
289         return err;
290 }
291
292 static ssize_t reload_store(struct sys_device *dev,
293                             struct sysdev_attribute *attr,
294                             const char *buf, size_t size)
295 {
296         unsigned long val;
297         int cpu = dev->id;
298         int ret = 0;
299         char *end;
300
301         val = simple_strtoul(buf, &end, 0);
302         if (end == buf)
303                 return -EINVAL;
304
305         if (val == 1) {
306                 get_online_cpus();
307                 if (cpu_online(cpu))
308                         ret = reload_for_cpu(cpu);
309                 put_online_cpus();
310         }
311
312         if (!ret)
313                 ret = size;
314
315         return ret;
316 }
317
318 static ssize_t version_show(struct sys_device *dev,
319                         struct sysdev_attribute *attr, char *buf)
320 {
321         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
322
323         return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
324 }
325
326 static ssize_t pf_show(struct sys_device *dev,
327                         struct sysdev_attribute *attr, char *buf)
328 {
329         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
330
331         return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
332 }
333
334 static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
335 static SYSDEV_ATTR(version, 0400, version_show, NULL);
336 static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
337
338 static struct attribute *mc_default_attrs[] = {
339         &attr_reload.attr,
340         &attr_version.attr,
341         &attr_processor_flags.attr,
342         NULL
343 };
344
345 static struct attribute_group mc_attr_group = {
346         .attrs                  = mc_default_attrs,
347         .name                   = "microcode",
348 };
349
350 static void microcode_fini_cpu(int cpu)
351 {
352         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
353
354         microcode_ops->microcode_fini_cpu(cpu);
355         uci->valid = 0;
356 }
357
358 static enum ucode_state microcode_resume_cpu(int cpu)
359 {
360         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
361
362         if (!uci->mc)
363                 return UCODE_NFOUND;
364
365         pr_debug("CPU%d updated upon resume\n", cpu);
366         apply_microcode_on_target(cpu);
367
368         return UCODE_OK;
369 }
370
371 static enum ucode_state microcode_init_cpu(int cpu)
372 {
373         enum ucode_state ustate;
374
375         if (collect_cpu_info(cpu))
376                 return UCODE_ERROR;
377
378         /* --dimm. Trigger a delayed update? */
379         if (system_state != SYSTEM_RUNNING)
380                 return UCODE_NFOUND;
381
382         ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);
383
384         if (ustate == UCODE_OK) {
385                 pr_debug("CPU%d updated upon init\n", cpu);
386                 apply_microcode_on_target(cpu);
387         }
388
389         return ustate;
390 }
391
392 static enum ucode_state microcode_update_cpu(int cpu)
393 {
394         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
395         enum ucode_state ustate;
396
397         if (uci->valid)
398                 ustate = microcode_resume_cpu(cpu);
399         else
400                 ustate = microcode_init_cpu(cpu);
401
402         return ustate;
403 }
404
405 static int mc_sysdev_add(struct sys_device *sys_dev)
406 {
407         int err, cpu = sys_dev->id;
408
409         if (!cpu_online(cpu))
410                 return 0;
411
412         pr_debug("CPU%d added\n", cpu);
413
414         err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
415         if (err)
416                 return err;
417
418         if (microcode_init_cpu(cpu) == UCODE_ERROR)
419                 err = -EINVAL;
420
421         return err;
422 }
423
424 static int mc_sysdev_remove(struct sys_device *sys_dev)
425 {
426         int cpu = sys_dev->id;
427
428         if (!cpu_online(cpu))
429                 return 0;
430
431         pr_debug("CPU%d removed\n", cpu);
432         microcode_fini_cpu(cpu);
433         sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
434         return 0;
435 }
436
437 static int mc_sysdev_resume(struct sys_device *dev)
438 {
439         int cpu = dev->id;
440         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
441
442         if (!cpu_online(cpu))
443                 return 0;
444
445         /*
446          * All non-bootup cpus are still disabled,
447          * so only CPU 0 will apply ucode here.
448          *
449          * Moreover, there can be no concurrent
450          * updates from any other places at this point.
451          */
452         WARN_ON(cpu != 0);
453
454         if (uci->valid && uci->mc)
455                 microcode_ops->apply_microcode(cpu);
456
457         return 0;
458 }
459
460 static struct sysdev_driver mc_sysdev_driver = {
461         .add                    = mc_sysdev_add,
462         .remove                 = mc_sysdev_remove,
463         .resume                 = mc_sysdev_resume,
464 };
465
466 static __cpuinit int
467 mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
468 {
469         unsigned int cpu = (unsigned long)hcpu;
470         struct sys_device *sys_dev;
471
472         sys_dev = get_cpu_sysdev(cpu);
473         switch (action) {
474         case CPU_ONLINE:
475         case CPU_ONLINE_FROZEN:
476                 microcode_update_cpu(cpu);
477         case CPU_DOWN_FAILED:
478         case CPU_DOWN_FAILED_FROZEN:
479                 pr_debug("CPU%d added\n", cpu);
480                 if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
481                         pr_err("Failed to create group for CPU%d\n", cpu);
482                 break;
483         case CPU_DOWN_PREPARE:
484         case CPU_DOWN_PREPARE_FROZEN:
485                 /* Suspend is in progress, only remove the interface */
486                 sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
487                 pr_debug("CPU%d removed\n", cpu);
488                 break;
489         case CPU_DEAD:
490         case CPU_UP_CANCELED_FROZEN:
491                 /* The CPU refused to come up during a system resume */
492                 microcode_fini_cpu(cpu);
493                 break;
494         }
495         return NOTIFY_OK;
496 }
497
498 static struct notifier_block __refdata mc_cpu_notifier = {
499         .notifier_call  = mc_cpu_callback,
500 };
501
502 static int __init microcode_init(void)
503 {
504         struct cpuinfo_x86 *c = &cpu_data(0);
505         int error;
506
507         if (c->x86_vendor == X86_VENDOR_INTEL)
508                 microcode_ops = init_intel_microcode();
509         else if (c->x86_vendor == X86_VENDOR_AMD)
510                 microcode_ops = init_amd_microcode();
511
512         if (!microcode_ops) {
513                 pr_err("no support for this CPU vendor\n");
514                 return -ENODEV;
515         }
516
517         microcode_pdev = platform_device_register_simple("microcode", -1,
518                                                          NULL, 0);
519         if (IS_ERR(microcode_pdev)) {
520                 microcode_dev_exit();
521                 return PTR_ERR(microcode_pdev);
522         }
523
524         get_online_cpus();
525         mutex_lock(&microcode_mutex);
526
527         error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
528
529         mutex_unlock(&microcode_mutex);
530         put_online_cpus();
531
532         if (error) {
533                 platform_device_unregister(microcode_pdev);
534                 return error;
535         }
536
537         error = microcode_dev_init();
538         if (error)
539                 return error;
540
541         register_hotcpu_notifier(&mc_cpu_notifier);
542
543         pr_info("Microcode Update Driver: v" MICROCODE_VERSION
544                 " <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n");
545
546         return 0;
547 }
548 module_init(microcode_init);
549
550 static void __exit microcode_exit(void)
551 {
552         microcode_dev_exit();
553
554         unregister_hotcpu_notifier(&mc_cpu_notifier);
555
556         get_online_cpus();
557         mutex_lock(&microcode_mutex);
558
559         sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
560
561         mutex_unlock(&microcode_mutex);
562         put_online_cpus();
563
564         platform_device_unregister(microcode_pdev);
565
566         microcode_ops = NULL;
567
568         pr_info("Microcode Update Driver: v" MICROCODE_VERSION " removed.\n");
569 }
570 module_exit(microcode_exit);