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

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