x86: code split to two parts

Split off existing code into two seperate files. One file holds general code, the other file vendor specific parts. No functional changes, only refactoring. Temporarily Introduced a new module name 'ucode' for result, due to already taken name 'microcode'. Signed-off-by: Peter Oruba <peter.oruba@amd.com> Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk> Signed-off-by: Ingo Molnar <mingo@elte.hu>

x86: code split to two parts
Split off existing code into two seperate files. One file holds general code, the other file vendor specific parts. No functional changes, only refactoring. Temporarily Introduced a new module name 'ucode' for result, due to already taken name 'microcode'. Signed-off-by: Peter Oruba <peter.oruba@amd.com> Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk> Signed-off-by: Ingo Molnar <mingo@elte.hu>
Peter Oruba · Ingo Molnar
1 parent 1abae31096
Showing 3 changed files with 488 additions and 365 deletions Side-by-side Diff
arch/x86/kernel/Makefile
arch/x86/kernel/microcode.c
arch/x86/kernel/microcode_intel.c
@@ -51,7 +51,8 @@
 obj-$(CONFIG_MCA)		+= mca_32.o
 obj-$(CONFIG_X86_MSR)		+= msr.o
 obj-$(CONFIG_X86_CPUID)		+= cpuid.o
-obj-$(CONFIG_MICROCODE)		+= microcode_intel.o
+obj-$(CONFIG_MICROCODE)		+= ucode.o
+ucode-objs                      := microcode.o microcode_intel.o
 obj-$(CONFIG_PCI)		+= early-quirks.o
 apm-y				:= apm_32.o
 obj-$(CONFIG_APM)		+= apm.o
+/*
+ *	Intel CPU Microcode Update Driver for Linux
+ *
+ *	Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
+ *		      2006	Shaohua Li <shaohua.li@intel.com>
+ *
+ *	This driver allows to upgrade microcode on Intel processors
+ *	belonging to IA-32 family - PentiumPro, Pentium II,
+ *	Pentium III, Xeon, Pentium 4, etc.
+ *
+ *	Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture
+ *	Software Developer's Manual
+ *	Order Number 253668 or free download from:
+ *
+ *	http://developer.intel.com/design/pentium4/manuals/253668.htm
+ *
+ *	For more information, go to http://www.urbanmyth.org/microcode
+ *
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License
+ *	as published by the Free Software Foundation; either version
+ *	2 of the License, or (at your option) any later version.
+ *
+ *	1.0	16 Feb 2000, Tigran Aivazian <tigran@sco.com>
+ *		Initial release.
+ *	1.01	18 Feb 2000, Tigran Aivazian <tigran@sco.com>
+ *		Added read() support + cleanups.
+ *	1.02	21 Feb 2000, Tigran Aivazian <tigran@sco.com>
+ *		Added 'device trimming' support. open(O_WRONLY) zeroes
+ *		and frees the saved copy of applied microcode.
+ *	1.03	29 Feb 2000, Tigran Aivazian <tigran@sco.com>
+ *		Made to use devfs (/dev/cpu/microcode) + cleanups.
+ *	1.04	06 Jun 2000, Simon Trimmer <simon@veritas.com>
+ *		Added misc device support (now uses both devfs and misc).
+ *		Added MICROCODE_IOCFREE ioctl to clear memory.
+ *	1.05	09 Jun 2000, Simon Trimmer <simon@veritas.com>
+ *		Messages for error cases (non Intel & no suitable microcode).
+ *	1.06	03 Aug 2000, Tigran Aivazian <tigran@veritas.com>
+ *		Removed ->release(). Removed exclusive open and status bitmap.
+ *		Added microcode_rwsem to serialize read()/write()/ioctl().
+ *		Removed global kernel lock usage.
+ *	1.07	07 Sep 2000, Tigran Aivazian <tigran@veritas.com>
+ *		Write 0 to 0x8B msr and then cpuid before reading revision,
+ *		so that it works even if there were no update done by the
+ *		BIOS. Otherwise, reading from 0x8B gives junk (which happened
+ *		to be 0 on my machine which is why it worked even when I
+ *		disabled update by the BIOS)
+ *		Thanks to Eric W. Biederman <ebiederman@lnxi.com> for the fix.
+ *	1.08	11 Dec 2000, Richard Schaal <richard.schaal@intel.com> and
+ *			     Tigran Aivazian <tigran@veritas.com>
+ *		Intel Pentium 4 processor support and bugfixes.
+ *	1.09	30 Oct 2001, Tigran Aivazian <tigran@veritas.com>
+ *		Bugfix for HT (Hyper-Threading) enabled processors
+ *		whereby processor resources are shared by all logical processors
+ *		in a single CPU package.
+ *	1.10	28 Feb 2002 Asit K Mallick <asit.k.mallick@intel.com> and
+ *		Tigran Aivazian <tigran@veritas.com>,
+ *		Serialize updates as required on HT processors due to speculative
+ *		nature of implementation.
+ *	1.11	22 Mar 2002 Tigran Aivazian <tigran@veritas.com>
+ *		Fix the panic when writing zero-length microcode chunk.
+ *	1.12	29 Sep 2003 Nitin Kamble <nitin.a.kamble@intel.com>,
+ *		Jun Nakajima <jun.nakajima@intel.com>
+ *		Support for the microcode updates in the new format.
+ *	1.13	10 Oct 2003 Tigran Aivazian <tigran@veritas.com>
+ *		Removed ->read() method and obsoleted MICROCODE_IOCFREE ioctl
+ *		because we no longer hold a copy of applied microcode
+ *		in kernel memory.
+ *	1.14	25 Jun 2004 Tigran Aivazian <tigran@veritas.com>
+ *		Fix sigmatch() macro to handle old CPUs with pf == 0.
+ *		Thanks to Stuart Swales for pointing out this bug.
+ */
+
+//#define DEBUG /* pr_debug */
+#include <linux/capability.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/cpumask.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/mutex.h>
+#include <linux/cpu.h>
+#include <linux/firmware.h>
+#include <linux/platform_device.h>
+
+#include <asm/msr.h>
+#include <asm/uaccess.h>
+#include <asm/processor.h>
+#include <asm/microcode.h>
+
+MODULE_DESCRIPTION("Microcode Update Driver");
+MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
+MODULE_LICENSE("GPL");
+
+#define MICROCODE_VERSION 	"1.14a"
+
+/* no concurrent ->write()s are allowed on /dev/cpu/microcode */
+DEFINE_MUTEX(microcode_mutex);
+
+struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
+
+extern long get_next_ucode(void **mc, long offset);
+extern int microcode_sanity_check(void *mc);
+extern int get_matching_microcode(void *mc, int cpu);
+extern void collect_cpu_info(int cpu_num);
+extern int cpu_request_microcode(int cpu);
+extern void microcode_fini_cpu(int cpu);
+extern void apply_microcode(int cpu);
+extern int apply_microcode_check_cpu(int cpu);
+
+#ifdef CONFIG_MICROCODE_OLD_INTERFACE
+void __user *user_buffer;	/* user area microcode data buffer */
+unsigned int user_buffer_size;	/* it's size */
+
+static int do_microcode_update (void)
+{
+	long cursor = 0;
+	int error = 0;
+	void *new_mc = NULL;
+	int cpu;
+	cpumask_t old;
+	cpumask_of_cpu_ptr_declare(newmask);
+
+	old = current->cpus_allowed;
+
+	while ((cursor = get_next_ucode(&new_mc, cursor)) > 0) {
+		error = microcode_sanity_check(new_mc);
+		if (error)
+			goto out;
+		/*
+		 * It's possible the data file has multiple matching ucode,
+		 * lets keep searching till the latest version
+		 */
+		for_each_online_cpu(cpu) {
+			struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+			if (!uci->valid)
+				continue;
+			cpumask_of_cpu_ptr_next(newmask, cpu);
+			set_cpus_allowed_ptr(current, newmask);
+			error = get_maching_microcode(new_mc, cpu);
+			if (error < 0)
+				goto out;
+			if (error == 1)
+				apply_microcode(cpu);
+		}
+		vfree(new_mc);
+	}
+out:
+	if (cursor > 0)
+		vfree(new_mc);
+	if (cursor < 0)
+		error = cursor;
+	set_cpus_allowed_ptr(current, &old);
+	return error;
+}
+
+static int microcode_open (struct inode *unused1, struct file *unused2)
+{
+	cycle_kernel_lock();
+	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
+}
+
+static ssize_t microcode_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
+{
+	ssize_t ret;
+
+	if ((len >> PAGE_SHIFT) > num_physpages) {
+		printk(KERN_ERR "microcode: too much data (max %ld pages)\n", num_physpages);
+		return -EINVAL;
+	}
+
+	get_online_cpus();
+	mutex_lock(&microcode_mutex);
+
+	user_buffer = (void __user *) buf;
+	user_buffer_size = (int) len;
+
+	ret = do_microcode_update();
+	if (!ret)
+		ret = (ssize_t)len;
+
+	mutex_unlock(&microcode_mutex);
+	put_online_cpus();
+
+	return ret;
+}
+
+static const struct file_operations microcode_fops = {
+	.owner		= THIS_MODULE,
+	.write		= microcode_write,
+	.open		= microcode_open,
+};
+
+static struct miscdevice microcode_dev = {
+	.minor		= MICROCODE_MINOR,
+	.name		= "microcode",
+	.fops		= &microcode_fops,
+};
+
+static int __init microcode_dev_init (void)
+{
+	int error;
+
+	error = misc_register(&microcode_dev);
+	if (error) {
+		printk(KERN_ERR
+			"microcode: can't misc_register on minor=%d\n",
+			MICROCODE_MINOR);
+		return error;
+	}
+
+	return 0;
+}
+
+static void microcode_dev_exit (void)
+{
+	misc_deregister(&microcode_dev);
+}
+
+MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
+#else
+#define microcode_dev_init() 0
+#define microcode_dev_exit() do { } while(0)
+#endif
+
+/* fake device for request_firmware */
+struct platform_device *microcode_pdev;
+
+static void microcode_init_cpu(int cpu, int resume)
+{
+	cpumask_t old;
+	cpumask_of_cpu_ptr(newmask, cpu);
+	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+	old = current->cpus_allowed;
+
+	set_cpus_allowed_ptr(current, newmask);
+	mutex_lock(&microcode_mutex);
+	collect_cpu_info(cpu);
+	if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
+		cpu_request_microcode(cpu);
+	mutex_unlock(&microcode_mutex);
+	set_cpus_allowed_ptr(current, &old);
+}
+
+static ssize_t reload_store(struct sys_device *dev,
+			    struct sysdev_attribute *attr,
+			    const char *buf, size_t sz)
+{
+	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+	char *end;
+	unsigned long val = simple_strtoul(buf, &end, 0);
+	int err = 0;
+	int cpu = dev->id;
+
+	if (end == buf)
+		return -EINVAL;
+	if (val == 1) {
+		cpumask_t old;
+		cpumask_of_cpu_ptr(newmask, cpu);
+
+		old = current->cpus_allowed;
+
+		get_online_cpus();
+		set_cpus_allowed_ptr(current, newmask);
+
+		mutex_lock(&microcode_mutex);
+		if (uci->valid)
+			err = cpu_request_microcode(cpu);
+		mutex_unlock(&microcode_mutex);
+		put_online_cpus();
+		set_cpus_allowed_ptr(current, &old);
+	}
+	if (err)
+		return err;
+	return sz;
+}
+
+static ssize_t version_show(struct sys_device *dev,
+			struct sysdev_attribute *attr, char *buf)
+{
+	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+
+	return sprintf(buf, "0x%x\n", uci->rev);
+}
+
+static ssize_t pf_show(struct sys_device *dev,
+			struct sysdev_attribute *attr, char *buf)
+{
+	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+
+	return sprintf(buf, "0x%x\n", uci->pf);
+}
+
+static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
+static SYSDEV_ATTR(version, 0400, version_show, NULL);
+static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
+
+static struct attribute *mc_default_attrs[] = {
+	&attr_reload.attr,
+	&attr_version.attr,
+	&attr_processor_flags.attr,
+	NULL
+};
+
+static struct attribute_group mc_attr_group = {
+	.attrs = mc_default_attrs,
+	.name = "microcode",
+};
+
+static int __mc_sysdev_add(struct sys_device *sys_dev, int resume)
+{
+	int err, cpu = sys_dev->id;
+	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+	if (!cpu_online(cpu))
+		return 0;
+
+	pr_debug("microcode: CPU%d added\n", cpu);
+	memset(uci, 0, sizeof(*uci));
+
+	err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
+	if (err)
+		return err;
+
+	microcode_init_cpu(cpu, resume);
+
+	return 0;
+}
+
+static int mc_sysdev_add(struct sys_device *sys_dev)
+{
+	return __mc_sysdev_add(sys_dev, 0);
+}
+
+static int mc_sysdev_remove(struct sys_device *sys_dev)
+{
+	int cpu = sys_dev->id;
+
+	if (!cpu_online(cpu))
+		return 0;
+
+	pr_debug("microcode: CPU%d removed\n", cpu);
+	microcode_fini_cpu(cpu);
+	sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+	return 0;
+}
+
+static int mc_sysdev_resume(struct sys_device *dev)
+{
+	int cpu = dev->id;
+
+	if (!cpu_online(cpu))
+		return 0;
+	pr_debug("microcode: CPU%d resumed\n", cpu);
+	/* only CPU 0 will apply ucode here */
+	apply_microcode(0);
+	return 0;
+}
+
+static struct sysdev_driver mc_sysdev_driver = {
+	.add = mc_sysdev_add,
+	.remove = mc_sysdev_remove,
+	.resume = mc_sysdev_resume,
+};
+
+static __cpuinit int
+mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
+{
+	unsigned int cpu = (unsigned long)hcpu;
+	struct sys_device *sys_dev;
+
+	sys_dev = get_cpu_sysdev(cpu);
+	switch (action) {
+	case CPU_UP_CANCELED_FROZEN:
+		/* The CPU refused to come up during a system resume */
+		microcode_fini_cpu(cpu);
+		break;
+	case CPU_ONLINE:
+	case CPU_DOWN_FAILED:
+		mc_sysdev_add(sys_dev);
+		break;
+	case CPU_ONLINE_FROZEN:
+		/* System-wide resume is in progress, try to apply microcode */
+		if (apply_microcode_check_cpu(cpu)) {
+			/* The application of microcode failed */
+			microcode_fini_cpu(cpu);
+			__mc_sysdev_add(sys_dev, 1);
+			break;
+		}
+	case CPU_DOWN_FAILED_FROZEN:
+		if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
+			printk(KERN_ERR "microcode: Failed to create the sysfs "
+				"group for CPU%d\n", cpu);
+		break;
+	case CPU_DOWN_PREPARE:
+		mc_sysdev_remove(sys_dev);
+		break;
+	case CPU_DOWN_PREPARE_FROZEN:
+		/* Suspend is in progress, only remove the interface */
+		sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+		break;
+	}
+	return NOTIFY_OK;
+}
+
+static struct notifier_block __refdata mc_cpu_notifier = {
+	.notifier_call = mc_cpu_callback,
+};
+
+static int __init microcode_init (void)
+{
+	int error;
+
+	printk(KERN_INFO
+		"IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@aivazian.fsnet.co.uk>\n");
+
+	error = microcode_dev_init();
+	if (error)
+		return error;
+	microcode_pdev = platform_device_register_simple("microcode", -1,
+							 NULL, 0);
+	if (IS_ERR(microcode_pdev)) {
+		microcode_dev_exit();
+		return PTR_ERR(microcode_pdev);
+	}
+
+	get_online_cpus();
+	error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
+	put_online_cpus();
+	if (error) {
+		microcode_dev_exit();
+		platform_device_unregister(microcode_pdev);
+		return error;
+	}
+
+	register_hotcpu_notifier(&mc_cpu_notifier);
+	return 0;
+}
+
+static void __exit microcode_exit (void)
+{
+	microcode_dev_exit();
+
+	unregister_hotcpu_notifier(&mc_cpu_notifier);
+
+	get_online_cpus();
+	sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
+	put_online_cpus();
+
+	platform_device_unregister(microcode_pdev);
+}
+
+module_init(microcode_init)
+module_exit(microcode_exit)
@@ -95,18 +95,16 @@
 #include <asm/processor.h>
 #include <asm/microcode.h>
  
-MODULE_DESCRIPTION("Intel CPU (IA-32) Microcode Update Driver");
+MODULE_DESCRIPTION("Microcode Update Driver");
 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
 MODULE_LICENSE("GPL");
  
-#define MICROCODE_VERSION 	"1.14a"
-
 #define DEFAULT_UCODE_DATASIZE 	(2000) 	  /* 2000 bytes */
-#define MC_HEADER_SIZE		(sizeof (struct microcode_header))  	  /* 48 bytes */
+#define MC_HEADER_SIZE		(sizeof(struct microcode_header))  	  /* 48 bytes */
 #define DEFAULT_UCODE_TOTALSIZE (DEFAULT_UCODE_DATASIZE + MC_HEADER_SIZE) /* 2048 bytes */
-#define EXT_HEADER_SIZE		(sizeof (struct extended_sigtable)) /* 20 bytes */
-#define EXT_SIGNATURE_SIZE	(sizeof (struct extended_signature)) /* 12 bytes */
-#define DWSIZE			(sizeof (u32))
+#define EXT_HEADER_SIZE		(sizeof(struct extended_sigtable)) /* 20 bytes */
+#define EXT_SIGNATURE_SIZE	(sizeof(struct extended_signature)) /* 12 bytes */
+#define DWSIZE			(sizeof(u32))
 #define get_totalsize(mc) \
 	(((struct microcode *)mc)->hdr.totalsize ? \
 	 ((struct microcode *)mc)->hdr.totalsize : DEFAULT_UCODE_TOTALSIZE)
  
  
@@ -123,11 +121,11 @@
 static DEFINE_SPINLOCK(microcode_update_lock);
  
 /* no concurrent ->write()s are allowed on /dev/cpu/microcode */
-static DEFINE_MUTEX(microcode_mutex);
+extern struct mutex microcode_mutex;
  
-static struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
+extern struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
  
-static void collect_cpu_info(int cpu_num)
+void collect_cpu_info(int cpu_num)
 {
 	struct cpuinfo_x86 *c = &cpu_data(cpu_num);
 	struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
@@ -140,7 +138,7 @@
 	uci->valid = 1;
  
 	if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
-	    	cpu_has(c, X86_FEATURE_IA64)) {
+	    cpu_has(c, X86_FEATURE_IA64)) {
 		printk(KERN_ERR "microcode: CPU%d not a capable Intel "
 			"processor\n", cpu_num);
 		uci->valid = 0;
@@ -175,7 +173,7 @@
 	return 1;
 }
  
-static int microcode_sanity_check(void *mc)
+int microcode_sanity_check(void *mc)
 {
 	struct microcode_header *mc_header = mc;
 	struct extended_sigtable *ext_header = NULL;
@@ -259,7 +257,7 @@
  * return 1 - found update
  * return < 0 - error
  */
-static int get_maching_microcode(void *mc, int cpu)
+int get_matching_microcode(void *mc, int cpu)
 {
 	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 	struct microcode_header *mc_header = mc;
@@ -288,7 +286,7 @@
 	return 0;
 find:
 	pr_debug("microcode: CPU%d found a matching microcode update with"
-		" version 0x%x (current=0x%x)\n", cpu, mc_header->rev,uci->rev);
+		 " version 0x%x (current=0x%x)\n", cpu, mc_header->rev, uci->rev);
 	new_mc = vmalloc(total_size);
 	if (!new_mc) {
 		printk(KERN_ERR "microcode: error! Can not allocate memory\n");
@@ -303,7 +301,7 @@
 	return 1;
 }
  
-static void apply_microcode(int cpu)
+void apply_microcode(int cpu)
 {
 	unsigned long flags;
 	unsigned int val[2];
  
@@ -344,10 +342,10 @@
 }
  
 #ifdef CONFIG_MICROCODE_OLD_INTERFACE
-static void __user *user_buffer;	/* user area microcode data buffer */
-static unsigned int user_buffer_size;	/* it's size */
+extern void __user *user_buffer;        /* user area microcode data buffer */
+extern unsigned int user_buffer_size;   /* it's size */
  
-static long get_next_ucode(void **mc, long offset)
+long get_next_ucode(void **mc, long offset)
 {
 	struct microcode_header mc_header;
 	unsigned long total_size;
@@ -375,117 +373,6 @@
 	}
 	return offset + total_size;
 }
-
-static int do_microcode_update (void)
-{
-	long cursor = 0;
-	int error = 0;
-	void *new_mc = NULL;
-	int cpu;
-	cpumask_t old;
-	cpumask_of_cpu_ptr_declare(newmask);
-
-	old = current->cpus_allowed;
-
-	while ((cursor = get_next_ucode(&new_mc, cursor)) > 0) {
-		error = microcode_sanity_check(new_mc);
-		if (error)
-			goto out;
-		/*
-		 * It's possible the data file has multiple matching ucode,
-		 * lets keep searching till the latest version
-		 */
-		for_each_online_cpu(cpu) {
-			struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
-
-			if (!uci->valid)
-				continue;
-			cpumask_of_cpu_ptr_next(newmask, cpu);
-			set_cpus_allowed_ptr(current, newmask);
-			error = get_maching_microcode(new_mc, cpu);
-			if (error < 0)
-				goto out;
-			if (error == 1)
-				apply_microcode(cpu);
-		}
-		vfree(new_mc);
-	}
-out:
-	if (cursor > 0)
-		vfree(new_mc);
-	if (cursor < 0)
-		error = cursor;
-	set_cpus_allowed_ptr(current, &old);
-	return error;
-}
-
-static int microcode_open (struct inode *unused1, struct file *unused2)
-{
-	cycle_kernel_lock();
-	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
-}
-
-static ssize_t microcode_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
-{
-	ssize_t ret;
-
-	if ((len >> PAGE_SHIFT) > num_physpages) {
-		printk(KERN_ERR "microcode: too much data (max %ld pages)\n", num_physpages);
-		return -EINVAL;
-	}
-
-	get_online_cpus();
-	mutex_lock(&microcode_mutex);
-
-	user_buffer = (void __user *) buf;
-	user_buffer_size = (int) len;
-
-	ret = do_microcode_update();
-	if (!ret)
-		ret = (ssize_t)len;
-
-	mutex_unlock(&microcode_mutex);
-	put_online_cpus();
-
-	return ret;
-}
-
-static const struct file_operations microcode_fops = {
-	.owner		= THIS_MODULE,
-	.write		= microcode_write,
-	.open		= microcode_open,
-};
-
-static struct miscdevice microcode_dev = {
-	.minor		= MICROCODE_MINOR,
-	.name		= "microcode",
-	.fops		= &microcode_fops,
-};
-
-static int __init microcode_dev_init (void)
-{
-	int error;
-
-	error = misc_register(&microcode_dev);
-	if (error) {
-		printk(KERN_ERR
-			"microcode: can't misc_register on minor=%d\n",
-			MICROCODE_MINOR);
-		return error;
-	}
-
-	return 0;
-}
-
-static void microcode_dev_exit (void)
-{
-	misc_deregister(&microcode_dev);
-}
-
-MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
-#else
-#define microcode_dev_init() 0
-#define microcode_dev_exit() do { } while(0)
 #endif
  
 static long get_next_ucode_from_buffer(void **mc, const u8 *buf,
  
@@ -515,9 +402,9 @@
 }
  
 /* fake device for request_firmware */
-static struct platform_device *microcode_pdev;
+extern struct platform_device *microcode_pdev;
  
-static int cpu_request_microcode(int cpu)
+int cpu_request_microcode(int cpu)
 {
 	char name[30];
 	struct cpuinfo_x86 *c = &cpu_data(cpu);
@@ -530,7 +417,7 @@
  
 	/* We should bind the task to the CPU */
 	BUG_ON(cpu != raw_smp_processor_id());
-	sprintf(name,"intel-ucode/%02x-%02x-%02x",
+	sprintf(name, "intel-ucode/%02x-%02x-%02x",
 		c->x86, c->x86_model, c->x86_mask);
 	error = request_firmware(&firmware, name, &microcode_pdev->dev);
 	if (error) {
@@ -544,7 +431,7 @@
 		error = microcode_sanity_check(mc);
 		if (error)
 			break;
-		error = get_maching_microcode(mc, cpu);
+		error = get_matching_microcode(mc, cpu);
 		if (error < 0)
 			break;
 		/*
@@ -566,7 +453,7 @@
 	return error;
 }
  
-static int apply_microcode_check_cpu(int cpu)
+int apply_microcode_check_cpu(int cpu)
 {
 	struct cpuinfo_x86 *c = &cpu_data(cpu);
 	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
  
  
  
  
  
@@ -615,242 +502,14 @@
 	return err;
 }
  
-static void microcode_init_cpu(int cpu, int resume)
+void microcode_fini_cpu(int cpu)
 {
-	cpumask_t old;
-	cpumask_of_cpu_ptr(newmask, cpu);
 	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
  
-	old = current->cpus_allowed;
-
-	set_cpus_allowed_ptr(current, newmask);
 	mutex_lock(&microcode_mutex);
-	collect_cpu_info(cpu);
-	if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
-		cpu_request_microcode(cpu);
-	mutex_unlock(&microcode_mutex);
-	set_cpus_allowed_ptr(current, &old);
-}
-
-static void microcode_fini_cpu(int cpu)
-{
-	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
-
-	mutex_lock(&microcode_mutex);
 	uci->valid = 0;
-	vfree(uci->mc);
+	kfree(uci->mc);
 	uci->mc = NULL;
 	mutex_unlock(&microcode_mutex);
 }
-
-static ssize_t reload_store(struct sys_device *dev,
-			    struct sysdev_attribute *attr,
-			    const char *buf, size_t sz)
-{
-	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
-	char *end;
-	unsigned long val = simple_strtoul(buf, &end, 0);
-	int err = 0;
-	int cpu = dev->id;
-
-	if (end == buf)
-		return -EINVAL;
-	if (val == 1) {
-		cpumask_t old;
-		cpumask_of_cpu_ptr(newmask, cpu);
-
-		old = current->cpus_allowed;
-
-		get_online_cpus();
-		set_cpus_allowed_ptr(current, newmask);
-
-		mutex_lock(&microcode_mutex);
-		if (uci->valid)
-			err = cpu_request_microcode(cpu);
-		mutex_unlock(&microcode_mutex);
-		put_online_cpus();
-		set_cpus_allowed_ptr(current, &old);
-	}
-	if (err)
-		return err;
-	return sz;
-}
-
-static ssize_t version_show(struct sys_device *dev,
-			struct sysdev_attribute *attr, char *buf)
-{
-	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
-
-	return sprintf(buf, "0x%x\n", uci->rev);
-}
-
-static ssize_t pf_show(struct sys_device *dev,
-			struct sysdev_attribute *attr, char *buf)
-{
-	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
-
-	return sprintf(buf, "0x%x\n", uci->pf);
-}
-
-static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
-static SYSDEV_ATTR(version, 0400, version_show, NULL);
-static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
-
-static struct attribute *mc_default_attrs[] = {
-	&attr_reload.attr,
-	&attr_version.attr,
-	&attr_processor_flags.attr,
-	NULL
-};
-
-static struct attribute_group mc_attr_group = {
-	.attrs = mc_default_attrs,
-	.name = "microcode",
-};
-
-static int __mc_sysdev_add(struct sys_device *sys_dev, int resume)
-{
-	int err, cpu = sys_dev->id;
-	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
-
-	if (!cpu_online(cpu))
-		return 0;
-
-	pr_debug("microcode: CPU%d added\n", cpu);
-	memset(uci, 0, sizeof(*uci));
-
-	err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
-	if (err)
-		return err;
-
-	microcode_init_cpu(cpu, resume);
-
-	return 0;
-}
-
-static int mc_sysdev_add(struct sys_device *sys_dev)
-{
-	return __mc_sysdev_add(sys_dev, 0);
-}
-
-static int mc_sysdev_remove(struct sys_device *sys_dev)
-{
-	int cpu = sys_dev->id;
-
-	if (!cpu_online(cpu))
-		return 0;
-
-	pr_debug("microcode: CPU%d removed\n", cpu);
-	microcode_fini_cpu(cpu);
-	sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
-	return 0;
-}
-
-static int mc_sysdev_resume(struct sys_device *dev)
-{
-	int cpu = dev->id;
-
-	if (!cpu_online(cpu))
-		return 0;
-	pr_debug("microcode: CPU%d resumed\n", cpu);
-	/* only CPU 0 will apply ucode here */
-	apply_microcode(0);
-	return 0;
-}
-
-static struct sysdev_driver mc_sysdev_driver = {
-	.add = mc_sysdev_add,
-	.remove = mc_sysdev_remove,
-	.resume = mc_sysdev_resume,
-};
-
-static __cpuinit int
-mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
-{
-	unsigned int cpu = (unsigned long)hcpu;
-	struct sys_device *sys_dev;
-
-	sys_dev = get_cpu_sysdev(cpu);
-	switch (action) {
-	case CPU_UP_CANCELED_FROZEN:
-		/* The CPU refused to come up during a system resume */
-		microcode_fini_cpu(cpu);
-		break;
-	case CPU_ONLINE:
-	case CPU_DOWN_FAILED:
-		mc_sysdev_add(sys_dev);
-		break;
-	case CPU_ONLINE_FROZEN:
-		/* System-wide resume is in progress, try to apply microcode */
-		if (apply_microcode_check_cpu(cpu)) {
-			/* The application of microcode failed */
-			microcode_fini_cpu(cpu);
-			__mc_sysdev_add(sys_dev, 1);
-			break;
-		}
-	case CPU_DOWN_FAILED_FROZEN:
-		if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
-			printk(KERN_ERR "microcode: Failed to create the sysfs "
-				"group for CPU%d\n", cpu);
-		break;
-	case CPU_DOWN_PREPARE:
-		mc_sysdev_remove(sys_dev);
-		break;
-	case CPU_DOWN_PREPARE_FROZEN:
-		/* Suspend is in progress, only remove the interface */
-		sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
-		break;
-	}
-	return NOTIFY_OK;
-}
-
-static struct notifier_block __refdata mc_cpu_notifier = {
-	.notifier_call = mc_cpu_callback,
-};
-
-static int __init microcode_init (void)
-{
-	int error;
-
-	printk(KERN_INFO
-		"IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@aivazian.fsnet.co.uk>\n");
-
-	error = microcode_dev_init();
-	if (error)
-		return error;
-	microcode_pdev = platform_device_register_simple("microcode", -1,
-							 NULL, 0);
-	if (IS_ERR(microcode_pdev)) {
-		microcode_dev_exit();
-		return PTR_ERR(microcode_pdev);
-	}
-
-	get_online_cpus();
-	error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
-	put_online_cpus();
-	if (error) {
-		microcode_dev_exit();
-		platform_device_unregister(microcode_pdev);
-		return error;
-	}
-
-	register_hotcpu_notifier(&mc_cpu_notifier);
-	return 0;
-}
-
-static void __exit microcode_exit (void)
-{
-	microcode_dev_exit();
-
-	unregister_hotcpu_notifier(&mc_cpu_notifier);
-
-	get_online_cpus();
-	sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
-	put_online_cpus();
-
-	platform_device_unregister(microcode_pdev);
-}
-
-module_init(microcode_init)
-module_exit(microcode_exit)
...	...	@@ -51,7 +51,8 @@
51	51	obj-$(CONFIG_MCA) += mca_32.o
52	52	obj-$(CONFIG_X86_MSR) += msr.o
53	53	obj-$(CONFIG_X86_CPUID) += cpuid.o
54		-obj-$(CONFIG_MICROCODE) += microcode_intel.o
	54	+obj-$(CONFIG_MICROCODE) += ucode.o
	55	+ucode-objs := microcode.o microcode_intel.o
55	56	obj-$(CONFIG_PCI) += early-quirks.o
56	57	apm-y := apm_32.o
57	58	obj-$(CONFIG_APM) += apm.o
	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 speculative
	59	+ * 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 DEBUG /* pr_debug */
	75	+#include <linux/capability.h>
	76	+#include <linux/kernel.h>
	77	+#include <linux/init.h>
	78	+#include <linux/sched.h>
	79	+#include <linux/smp_lock.h>
	80	+#include <linux/cpumask.h>
	81	+#include <linux/module.h>
	82	+#include <linux/slab.h>
	83	+#include <linux/vmalloc.h>
	84	+#include <linux/miscdevice.h>
	85	+#include <linux/spinlock.h>
	86	+#include <linux/mm.h>
	87	+#include <linux/fs.h>
	88	+#include <linux/mutex.h>
	89	+#include <linux/cpu.h>
	90	+#include <linux/firmware.h>
	91	+#include <linux/platform_device.h>
	92	+
	93	+#include <asm/msr.h>
	94	+#include <asm/uaccess.h>
	95	+#include <asm/processor.h>
	96	+#include <asm/microcode.h>
	97	+
	98	+MODULE_DESCRIPTION("Microcode Update Driver");
	99	+MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
	100	+MODULE_LICENSE("GPL");
	101	+
	102	+#define MICROCODE_VERSION "1.14a"
	103	+
	104	+/* no concurrent ->write()s are allowed on /dev/cpu/microcode */
	105	+DEFINE_MUTEX(microcode_mutex);
	106	+
	107	+struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
	108	+
	109	+extern long get_next_ucode(void **mc, long offset);
	110	+extern int microcode_sanity_check(void *mc);
	111	+extern int get_matching_microcode(void *mc, int cpu);
	112	+extern void collect_cpu_info(int cpu_num);
	113	+extern int cpu_request_microcode(int cpu);
	114	+extern void microcode_fini_cpu(int cpu);
	115	+extern void apply_microcode(int cpu);
	116	+extern int apply_microcode_check_cpu(int cpu);
	117	+
	118	+#ifdef CONFIG_MICROCODE_OLD_INTERFACE
	119	+void __user user_buffer; / user area microcode data buffer */
	120	+unsigned int user_buffer_size; /* it's size */
	121	+
	122	+static int do_microcode_update (void)
	123	+{
	124	+ long cursor = 0;
	125	+ int error = 0;
	126	+ void *new_mc = NULL;
	127	+ int cpu;
	128	+ cpumask_t old;
	129	+ cpumask_of_cpu_ptr_declare(newmask);
	130	+
	131	+ old = current->cpus_allowed;
	132	+
	133	+ while ((cursor = get_next_ucode(&new_mc, cursor)) > 0) {
	134	+ error = microcode_sanity_check(new_mc);
	135	+ if (error)
	136	+ goto out;
	137	+ /*
	138	+ * It's possible the data file has multiple matching ucode,
	139	+ * lets keep searching till the latest version
	140	+ */
	141	+ for_each_online_cpu(cpu) {
	142	+ struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	143	+
	144	+ if (!uci->valid)
	145	+ continue;
	146	+ cpumask_of_cpu_ptr_next(newmask, cpu);
	147	+ set_cpus_allowed_ptr(current, newmask);
	148	+ error = get_maching_microcode(new_mc, cpu);
	149	+ if (error < 0)
	150	+ goto out;
	151	+ if (error == 1)
	152	+ apply_microcode(cpu);
	153	+ }
	154	+ vfree(new_mc);
	155	+ }
	156	+out:
	157	+ if (cursor > 0)
	158	+ vfree(new_mc);
	159	+ if (cursor < 0)
	160	+ error = cursor;
	161	+ set_cpus_allowed_ptr(current, &old);
	162	+ return error;
	163	+}
	164	+
	165	+static int microcode_open (struct inode unused1, struct file unused2)
	166	+{
	167	+ cycle_kernel_lock();
	168	+ return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
	169	+}
	170	+
	171	+static ssize_t microcode_write (struct file file, const char __user buf, size_t len, loff_t *ppos)
	172	+{
	173	+ ssize_t ret;
	174	+
	175	+ if ((len >> PAGE_SHIFT) > num_physpages) {
	176	+ printk(KERN_ERR "microcode: too much data (max %ld pages)\n", num_physpages);
	177	+ return -EINVAL;
	178	+ }
	179	+
	180	+ get_online_cpus();
	181	+ mutex_lock(&microcode_mutex);
	182	+
	183	+ user_buffer = (void __user *) buf;
	184	+ user_buffer_size = (int) len;
	185	+
	186	+ ret = do_microcode_update();
	187	+ if (!ret)
	188	+ ret = (ssize_t)len;
	189	+
	190	+ mutex_unlock(&microcode_mutex);
	191	+ put_online_cpus();
	192	+
	193	+ return ret;
	194	+}
	195	+
	196	+static const struct file_operations microcode_fops = {
	197	+ .owner = THIS_MODULE,
	198	+ .write = microcode_write,
	199	+ .open = microcode_open,
	200	+};
	201	+
	202	+static struct miscdevice microcode_dev = {
	203	+ .minor = MICROCODE_MINOR,
	204	+ .name = "microcode",
	205	+ .fops = &microcode_fops,
	206	+};
	207	+
	208	+static int __init microcode_dev_init (void)
	209	+{
	210	+ int error;
	211	+
	212	+ error = misc_register(&microcode_dev);
	213	+ if (error) {
	214	+ printk(KERN_ERR
	215	+ "microcode: can't misc_register on minor=%d\n",
	216	+ MICROCODE_MINOR);
	217	+ return error;
	218	+ }
	219	+
	220	+ return 0;
	221	+}
	222	+
	223	+static void microcode_dev_exit (void)
	224	+{
	225	+ misc_deregister(&microcode_dev);
	226	+}
	227	+
	228	+MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
	229	+#else
	230	+#define microcode_dev_init() 0
	231	+#define microcode_dev_exit() do { } while(0)
	232	+#endif
	233	+
	234	+/* fake device for request_firmware */
	235	+struct platform_device *microcode_pdev;
	236	+
	237	+static void microcode_init_cpu(int cpu, int resume)
	238	+{
	239	+ cpumask_t old;
	240	+ cpumask_of_cpu_ptr(newmask, cpu);
	241	+ struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	242	+
	243	+ old = current->cpus_allowed;
	244	+
	245	+ set_cpus_allowed_ptr(current, newmask);
	246	+ mutex_lock(&microcode_mutex);
	247	+ collect_cpu_info(cpu);
	248	+ if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
	249	+ cpu_request_microcode(cpu);
	250	+ mutex_unlock(&microcode_mutex);
	251	+ set_cpus_allowed_ptr(current, &old);
	252	+}
	253	+
	254	+static ssize_t reload_store(struct sys_device *dev,
	255	+ struct sysdev_attribute *attr,
	256	+ const char *buf, size_t sz)
	257	+{
	258	+ struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
	259	+ char *end;
	260	+ unsigned long val = simple_strtoul(buf, &end, 0);
	261	+ int err = 0;
	262	+ int cpu = dev->id;
	263	+
	264	+ if (end == buf)
	265	+ return -EINVAL;
	266	+ if (val == 1) {
	267	+ cpumask_t old;
	268	+ cpumask_of_cpu_ptr(newmask, cpu);
	269	+
	270	+ old = current->cpus_allowed;
	271	+
	272	+ get_online_cpus();
	273	+ set_cpus_allowed_ptr(current, newmask);
	274	+
	275	+ mutex_lock(&microcode_mutex);
	276	+ if (uci->valid)
	277	+ err = cpu_request_microcode(cpu);
	278	+ mutex_unlock(&microcode_mutex);
	279	+ put_online_cpus();
	280	+ set_cpus_allowed_ptr(current, &old);
	281	+ }
	282	+ if (err)
	283	+ return err;
	284	+ return sz;
	285	+}
	286	+
	287	+static ssize_t version_show(struct sys_device *dev,
	288	+ struct sysdev_attribute attr, char buf)
	289	+{
	290	+ struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
	291	+
	292	+ return sprintf(buf, "0x%x\n", uci->rev);
	293	+}
	294	+
	295	+static ssize_t pf_show(struct sys_device *dev,
	296	+ struct sysdev_attribute attr, char buf)
	297	+{
	298	+ struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
	299	+
	300	+ return sprintf(buf, "0x%x\n", uci->pf);
	301	+}
	302	+
	303	+static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
	304	+static SYSDEV_ATTR(version, 0400, version_show, NULL);
	305	+static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
	306	+
	307	+static struct attribute *mc_default_attrs[] = {
	308	+ &attr_reload.attr,
	309	+ &attr_version.attr,
	310	+ &attr_processor_flags.attr,
	311	+ NULL
	312	+};
	313	+
	314	+static struct attribute_group mc_attr_group = {
	315	+ .attrs = mc_default_attrs,
	316	+ .name = "microcode",
	317	+};
	318	+
	319	+static int __mc_sysdev_add(struct sys_device *sys_dev, int resume)
	320	+{
	321	+ int err, cpu = sys_dev->id;
	322	+ struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	323	+
	324	+ if (!cpu_online(cpu))
	325	+ return 0;
	326	+
	327	+ pr_debug("microcode: CPU%d added\n", cpu);
	328	+ memset(uci, 0, sizeof(*uci));
	329	+
	330	+ err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
	331	+ if (err)
	332	+ return err;
	333	+
	334	+ microcode_init_cpu(cpu, resume);
	335	+
	336	+ return 0;
	337	+}
	338	+
	339	+static int mc_sysdev_add(struct sys_device *sys_dev)
	340	+{
	341	+ return __mc_sysdev_add(sys_dev, 0);
	342	+}
	343	+
	344	+static int mc_sysdev_remove(struct sys_device *sys_dev)
	345	+{
	346	+ int cpu = sys_dev->id;
	347	+
	348	+ if (!cpu_online(cpu))
	349	+ return 0;
	350	+
	351	+ pr_debug("microcode: CPU%d removed\n", cpu);
	352	+ microcode_fini_cpu(cpu);
	353	+ sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
	354	+ return 0;
	355	+}
	356	+
	357	+static int mc_sysdev_resume(struct sys_device *dev)
	358	+{
	359	+ int cpu = dev->id;
	360	+
	361	+ if (!cpu_online(cpu))
	362	+ return 0;
	363	+ pr_debug("microcode: CPU%d resumed\n", cpu);
	364	+ /* only CPU 0 will apply ucode here */
	365	+ apply_microcode(0);
	366	+ return 0;
	367	+}
	368	+
	369	+static struct sysdev_driver mc_sysdev_driver = {
	370	+ .add = mc_sysdev_add,
	371	+ .remove = mc_sysdev_remove,
	372	+ .resume = mc_sysdev_resume,
	373	+};
	374	+
	375	+static __cpuinit int
	376	+mc_cpu_callback(struct notifier_block nb, unsigned long action, void hcpu)
	377	+{
	378	+ unsigned int cpu = (unsigned long)hcpu;
	379	+ struct sys_device *sys_dev;
	380	+
	381	+ sys_dev = get_cpu_sysdev(cpu);
	382	+ switch (action) {
	383	+ case CPU_UP_CANCELED_FROZEN:
	384	+ /* The CPU refused to come up during a system resume */
	385	+ microcode_fini_cpu(cpu);
	386	+ break;
	387	+ case CPU_ONLINE:
	388	+ case CPU_DOWN_FAILED:
	389	+ mc_sysdev_add(sys_dev);
	390	+ break;
	391	+ case CPU_ONLINE_FROZEN:
	392	+ /* System-wide resume is in progress, try to apply microcode */
	393	+ if (apply_microcode_check_cpu(cpu)) {
	394	+ /* The application of microcode failed */
	395	+ microcode_fini_cpu(cpu);
	396	+ __mc_sysdev_add(sys_dev, 1);
	397	+ break;
	398	+ }
	399	+ case CPU_DOWN_FAILED_FROZEN:
	400	+ if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
	401	+ printk(KERN_ERR "microcode: Failed to create the sysfs "
	402	+ "group for CPU%d\n", cpu);
	403	+ break;
	404	+ case CPU_DOWN_PREPARE:
	405	+ mc_sysdev_remove(sys_dev);
	406	+ break;
	407	+ case CPU_DOWN_PREPARE_FROZEN:
	408	+ /* Suspend is in progress, only remove the interface */
	409	+ sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
	410	+ break;
	411	+ }
	412	+ return NOTIFY_OK;
	413	+}
	414	+
	415	+static struct notifier_block __refdata mc_cpu_notifier = {
	416	+ .notifier_call = mc_cpu_callback,
	417	+};
	418	+
	419	+static int __init microcode_init (void)
	420	+{
	421	+ int error;
	422	+
	423	+ printk(KERN_INFO
	424	+ "IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@aivazian.fsnet.co.uk>\n");
	425	+
	426	+ error = microcode_dev_init();
	427	+ if (error)
	428	+ return error;
	429	+ microcode_pdev = platform_device_register_simple("microcode", -1,
	430	+ NULL, 0);
	431	+ if (IS_ERR(microcode_pdev)) {
	432	+ microcode_dev_exit();
	433	+ return PTR_ERR(microcode_pdev);
	434	+ }
	435	+
	436	+ get_online_cpus();
	437	+ error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
	438	+ put_online_cpus();
	439	+ if (error) {
	440	+ microcode_dev_exit();
	441	+ platform_device_unregister(microcode_pdev);
	442	+ return error;
	443	+ }
	444	+
	445	+ register_hotcpu_notifier(&mc_cpu_notifier);
	446	+ return 0;
	447	+}
	448	+
	449	+static void __exit microcode_exit (void)
	450	+{
	451	+ microcode_dev_exit();
	452	+
	453	+ unregister_hotcpu_notifier(&mc_cpu_notifier);
	454	+
	455	+ get_online_cpus();
	456	+ sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
	457	+ put_online_cpus();
	458	+
	459	+ platform_device_unregister(microcode_pdev);
	460	+}
	461	+
	462	+module_init(microcode_init)
	463	+module_exit(microcode_exit)
...	...	@@ -95,18 +95,16 @@
95	95	#include <asm/processor.h>
96	96	#include <asm/microcode.h>
97	97
98		-MODULE_DESCRIPTION("Intel CPU (IA-32) Microcode Update Driver");
	98	+MODULE_DESCRIPTION("Microcode Update Driver");
99	99	MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
100	100	MODULE_LICENSE("GPL");
101	101
102		-#define MICROCODE_VERSION "1.14a"
103		-
104	102	#define DEFAULT_UCODE_DATASIZE (2000) /* 2000 bytes */
105		-#define MC_HEADER_SIZE (sizeof (struct microcode_header)) /* 48 bytes */
	103	+#define MC_HEADER_SIZE (sizeof(struct microcode_header)) /* 48 bytes */
106	104	#define DEFAULT_UCODE_TOTALSIZE (DEFAULT_UCODE_DATASIZE + MC_HEADER_SIZE) /* 2048 bytes */
107		-#define EXT_HEADER_SIZE (sizeof (struct extended_sigtable)) /* 20 bytes */
108		-#define EXT_SIGNATURE_SIZE (sizeof (struct extended_signature)) /* 12 bytes */
109		-#define DWSIZE (sizeof (u32))
	105	+#define EXT_HEADER_SIZE (sizeof(struct extended_sigtable)) /* 20 bytes */
	106	+#define EXT_SIGNATURE_SIZE (sizeof(struct extended_signature)) /* 12 bytes */
	107	+#define DWSIZE (sizeof(u32))
110	108	#define get_totalsize(mc) \
111	109	(((struct microcode *)mc)->hdr.totalsize ? \
112	110	((struct microcode *)mc)->hdr.totalsize : DEFAULT_UCODE_TOTALSIZE)
113	111
114	112
...	...	@@ -123,11 +121,11 @@
123	121	static DEFINE_SPINLOCK(microcode_update_lock);
124	122
125	123	/* no concurrent ->write()s are allowed on /dev/cpu/microcode */
126		-static DEFINE_MUTEX(microcode_mutex);
	124	+extern struct mutex microcode_mutex;
127	125
128		-static struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
	126	+extern struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
129	127
130		-static void collect_cpu_info(int cpu_num)
	128	+void collect_cpu_info(int cpu_num)
131	129	{
132	130	struct cpuinfo_x86 *c = &cpu_data(cpu_num);
133	131	struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
...	...	@@ -140,7 +138,7 @@
140	138	uci->valid = 1;
141	139
142	140	if (c->x86_vendor != X86_VENDOR_INTEL \|\| c->x86 < 6 \|\|
143		- cpu_has(c, X86_FEATURE_IA64)) {
	141	+ cpu_has(c, X86_FEATURE_IA64)) {
144	142	printk(KERN_ERR "microcode: CPU%d not a capable Intel "
145	143	"processor\n", cpu_num);
146	144	uci->valid = 0;
...	...	@@ -175,7 +173,7 @@
175	173	return 1;
176	174	}
177	175
178		-static int microcode_sanity_check(void *mc)
	176	+int microcode_sanity_check(void *mc)
179	177	{
180	178	struct microcode_header *mc_header = mc;
181	179	struct extended_sigtable *ext_header = NULL;
...	...	@@ -259,7 +257,7 @@
259	257	* return 1 - found update
260	258	* return < 0 - error
261	259	*/
262		-static int get_maching_microcode(void *mc, int cpu)
	260	+int get_matching_microcode(void *mc, int cpu)
263	261	{
264	262	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
265	263	struct microcode_header *mc_header = mc;
...	...	@@ -288,7 +286,7 @@
288	286	return 0;
289	287	find:
290	288	pr_debug("microcode: CPU%d found a matching microcode update with"
291		- " version 0x%x (current=0x%x)\n", cpu, mc_header->rev,uci->rev);
	289	+ " version 0x%x (current=0x%x)\n", cpu, mc_header->rev, uci->rev);
292	290	new_mc = vmalloc(total_size);
293	291	if (!new_mc) {
294	292	printk(KERN_ERR "microcode: error! Can not allocate memory\n");
...	...	@@ -303,7 +301,7 @@
303	301	return 1;
304	302	}
305	303
306		-static void apply_microcode(int cpu)
	304	+void apply_microcode(int cpu)
307	305	{
308	306	unsigned long flags;
309	307	unsigned int val[2];
310	308
...	...	@@ -344,10 +342,10 @@
344	342	}
345	343
346	344	#ifdef CONFIG_MICROCODE_OLD_INTERFACE
347		-static void __user user_buffer; / user area microcode data buffer */
348		-static unsigned int user_buffer_size; /* it's size */
	345	+extern void __user user_buffer; / user area microcode data buffer */
	346	+extern unsigned int user_buffer_size; /* it's size */
349	347
350		-static long get_next_ucode(void **mc, long offset)
	348	+long get_next_ucode(void **mc, long offset)
351	349	{
352	350	struct microcode_header mc_header;
353	351	unsigned long total_size;
...	...	@@ -375,117 +373,6 @@
375	373	}
376	374	return offset + total_size;
377	375	}
378		-
379		-static int do_microcode_update (void)
380		-{
381		- long cursor = 0;
382		- int error = 0;
383		- void *new_mc = NULL;
384		- int cpu;
385		- cpumask_t old;
386		- cpumask_of_cpu_ptr_declare(newmask);
387		-
388		- old = current->cpus_allowed;
389		-
390		- while ((cursor = get_next_ucode(&new_mc, cursor)) > 0) {
391		- error = microcode_sanity_check(new_mc);
392		- if (error)
393		- goto out;
394		- /*
395		- * It's possible the data file has multiple matching ucode,
396		- * lets keep searching till the latest version
397		- */
398		- for_each_online_cpu(cpu) {
399		- struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
400		-
401		- if (!uci->valid)
402		- continue;
403		- cpumask_of_cpu_ptr_next(newmask, cpu);
404		- set_cpus_allowed_ptr(current, newmask);
405		- error = get_maching_microcode(new_mc, cpu);
406		- if (error < 0)
407		- goto out;
408		- if (error == 1)
409		- apply_microcode(cpu);
410		- }
411		- vfree(new_mc);
412		- }
413		-out:
414		- if (cursor > 0)
415		- vfree(new_mc);
416		- if (cursor < 0)
417		- error = cursor;
418		- set_cpus_allowed_ptr(current, &old);
419		- return error;
420		-}
421		-
422		-static int microcode_open (struct inode unused1, struct file unused2)
423		-{
424		- cycle_kernel_lock();
425		- return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
426		-}
427		-
428		-static ssize_t microcode_write (struct file file, const char __user buf, size_t len, loff_t *ppos)
429		-{
430		- ssize_t ret;
431		-
432		- if ((len >> PAGE_SHIFT) > num_physpages) {
433		- printk(KERN_ERR "microcode: too much data (max %ld pages)\n", num_physpages);
434		- return -EINVAL;
435		- }
436		-
437		- get_online_cpus();
438		- mutex_lock(&microcode_mutex);
439		-
440		- user_buffer = (void __user *) buf;
441		- user_buffer_size = (int) len;
442		-
443		- ret = do_microcode_update();
444		- if (!ret)
445		- ret = (ssize_t)len;
446		-
447		- mutex_unlock(&microcode_mutex);
448		- put_online_cpus();
449		-
450		- return ret;
451		-}
452		-
453		-static const struct file_operations microcode_fops = {
454		- .owner = THIS_MODULE,
455		- .write = microcode_write,
456		- .open = microcode_open,
457		-};
458		-
459		-static struct miscdevice microcode_dev = {
460		- .minor = MICROCODE_MINOR,
461		- .name = "microcode",
462		- .fops = &microcode_fops,
463		-};
464		-
465		-static int __init microcode_dev_init (void)
466		-{
467		- int error;
468		-
469		- error = misc_register(&microcode_dev);
470		- if (error) {
471		- printk(KERN_ERR
472		- "microcode: can't misc_register on minor=%d\n",
473		- MICROCODE_MINOR);
474		- return error;
475		- }
476		-
477		- return 0;
478		-}
479		-
480		-static void microcode_dev_exit (void)
481		-{
482		- misc_deregister(&microcode_dev);
483		-}
484		-
485		-MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
486		-#else
487		-#define microcode_dev_init() 0
488		-#define microcode_dev_exit() do { } while(0)
489	376	#endif
490	377
491	378	static long get_next_ucode_from_buffer(void *mc, const u8 buf,
492	379
...	...	@@ -515,9 +402,9 @@
515	402	}
516	403
517	404	/* fake device for request_firmware */
518		-static struct platform_device *microcode_pdev;
	405	+extern struct platform_device *microcode_pdev;
519	406
520		-static int cpu_request_microcode(int cpu)
	407	+int cpu_request_microcode(int cpu)
521	408	{
522	409	char name[30];
523	410	struct cpuinfo_x86 *c = &cpu_data(cpu);
...	...	@@ -530,7 +417,7 @@
530	417
531	418	/* We should bind the task to the CPU */
532	419	BUG_ON(cpu != raw_smp_processor_id());
533		- sprintf(name,"intel-ucode/%02x-%02x-%02x",
	420	+ sprintf(name, "intel-ucode/%02x-%02x-%02x",
534	421	c->x86, c->x86_model, c->x86_mask);
535	422	error = request_firmware(&firmware, name, &microcode_pdev->dev);
536	423	if (error) {
...	...	@@ -544,7 +431,7 @@
544	431	error = microcode_sanity_check(mc);
545	432	if (error)
546	433	break;
547		- error = get_maching_microcode(mc, cpu);
	434	+ error = get_matching_microcode(mc, cpu);
548	435	if (error < 0)
549	436	break;
550	437	/*
...	...	@@ -566,7 +453,7 @@
566	453	return error;
567	454	}
568	455
569		-static int apply_microcode_check_cpu(int cpu)
	456	+int apply_microcode_check_cpu(int cpu)
570	457	{
571	458	struct cpuinfo_x86 *c = &cpu_data(cpu);
572	459	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
573	460
574	461
575	462
576	463
577	464
...	...	@@ -615,242 +502,14 @@
615	502	return err;
616	503	}
617	504
618		-static void microcode_init_cpu(int cpu, int resume)
	505	+void microcode_fini_cpu(int cpu)
619	506	{
620		- cpumask_t old;
621		- cpumask_of_cpu_ptr(newmask, cpu);
622	507	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
623	508
624		- old = current->cpus_allowed;
625		-
626		- set_cpus_allowed_ptr(current, newmask);
627	509	mutex_lock(&microcode_mutex);
628		- collect_cpu_info(cpu);
629		- if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
630		- cpu_request_microcode(cpu);
631		- mutex_unlock(&microcode_mutex);
632		- set_cpus_allowed_ptr(current, &old);
633		-}
634		-
635		-static void microcode_fini_cpu(int cpu)
636		-{
637		- struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
638		-
639		- mutex_lock(&microcode_mutex);
640	510	uci->valid = 0;
641		- vfree(uci->mc);
	511	+ kfree(uci->mc);
642	512	uci->mc = NULL;
643	513	mutex_unlock(&microcode_mutex);
644	514	}
645		-
646		-static ssize_t reload_store(struct sys_device *dev,
647		- struct sysdev_attribute *attr,
648		- const char *buf, size_t sz)
649		-{
650		- struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
651		- char *end;
652		- unsigned long val = simple_strtoul(buf, &end, 0);
653		- int err = 0;
654		- int cpu = dev->id;
655		-
656		- if (end == buf)
657		- return -EINVAL;
658		- if (val == 1) {
659		- cpumask_t old;
660		- cpumask_of_cpu_ptr(newmask, cpu);
661		-
662		- old = current->cpus_allowed;
663		-
664		- get_online_cpus();
665		- set_cpus_allowed_ptr(current, newmask);
666		-
667		- mutex_lock(&microcode_mutex);
668		- if (uci->valid)
669		- err = cpu_request_microcode(cpu);
670		- mutex_unlock(&microcode_mutex);
671		- put_online_cpus();
672		- set_cpus_allowed_ptr(current, &old);
673		- }
674		- if (err)
675		- return err;
676		- return sz;
677		-}
678		-
679		-static ssize_t version_show(struct sys_device *dev,
680		- struct sysdev_attribute attr, char buf)
681		-{
682		- struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
683		-
684		- return sprintf(buf, "0x%x\n", uci->rev);
685		-}
686		-
687		-static ssize_t pf_show(struct sys_device *dev,
688		- struct sysdev_attribute attr, char buf)
689		-{
690		- struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
691		-
692		- return sprintf(buf, "0x%x\n", uci->pf);
693		-}
694		-
695		-static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
696		-static SYSDEV_ATTR(version, 0400, version_show, NULL);
697		-static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
698		-
699		-static struct attribute *mc_default_attrs[] = {
700		- &attr_reload.attr,
701		- &attr_version.attr,
702		- &attr_processor_flags.attr,
703		- NULL
704		-};
705		-
706		-static struct attribute_group mc_attr_group = {
707		- .attrs = mc_default_attrs,
708		- .name = "microcode",
709		-};
710		-
711		-static int __mc_sysdev_add(struct sys_device *sys_dev, int resume)
712		-{
713		- int err, cpu = sys_dev->id;
714		- struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
715		-
716		- if (!cpu_online(cpu))
717		- return 0;
718		-
719		- pr_debug("microcode: CPU%d added\n", cpu);
720		- memset(uci, 0, sizeof(*uci));
721		-
722		- err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
723		- if (err)
724		- return err;
725		-
726		- microcode_init_cpu(cpu, resume);
727		-
728		- return 0;
729		-}
730		-
731		-static int mc_sysdev_add(struct sys_device *sys_dev)
732		-{
733		- return __mc_sysdev_add(sys_dev, 0);
734		-}
735		-
736		-static int mc_sysdev_remove(struct sys_device *sys_dev)
737		-{
738		- int cpu = sys_dev->id;
739		-
740		- if (!cpu_online(cpu))
741		- return 0;
742		-
743		- pr_debug("microcode: CPU%d removed\n", cpu);
744		- microcode_fini_cpu(cpu);
745		- sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
746		- return 0;
747		-}
748		-
749		-static int mc_sysdev_resume(struct sys_device *dev)
750		-{
751		- int cpu = dev->id;
752		-
753		- if (!cpu_online(cpu))
754		- return 0;
755		- pr_debug("microcode: CPU%d resumed\n", cpu);
756		- /* only CPU 0 will apply ucode here */
757		- apply_microcode(0);
758		- return 0;
759		-}
760		-
761		-static struct sysdev_driver mc_sysdev_driver = {
762		- .add = mc_sysdev_add,
763		- .remove = mc_sysdev_remove,
764		- .resume = mc_sysdev_resume,
765		-};
766		-
767		-static __cpuinit int
768		-mc_cpu_callback(struct notifier_block nb, unsigned long action, void hcpu)
769		-{
770		- unsigned int cpu = (unsigned long)hcpu;
771		- struct sys_device *sys_dev;
772		-
773		- sys_dev = get_cpu_sysdev(cpu);
774		- switch (action) {
775		- case CPU_UP_CANCELED_FROZEN:
776		- /* The CPU refused to come up during a system resume */
777		- microcode_fini_cpu(cpu);
778		- break;
779		- case CPU_ONLINE:
780		- case CPU_DOWN_FAILED:
781		- mc_sysdev_add(sys_dev);
782		- break;
783		- case CPU_ONLINE_FROZEN:
784		- /* System-wide resume is in progress, try to apply microcode */
785		- if (apply_microcode_check_cpu(cpu)) {
786		- /* The application of microcode failed */
787		- microcode_fini_cpu(cpu);
788		- __mc_sysdev_add(sys_dev, 1);
789		- break;
790		- }
791		- case CPU_DOWN_FAILED_FROZEN:
792		- if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
793		- printk(KERN_ERR "microcode: Failed to create the sysfs "
794		- "group for CPU%d\n", cpu);
795		- break;
796		- case CPU_DOWN_PREPARE:
797		- mc_sysdev_remove(sys_dev);
798		- break;
799		- case CPU_DOWN_PREPARE_FROZEN:
800		- /* Suspend is in progress, only remove the interface */
801		- sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
802		- break;
803		- }
804		- return NOTIFY_OK;
805		-}
806		-
807		-static struct notifier_block __refdata mc_cpu_notifier = {
808		- .notifier_call = mc_cpu_callback,
809		-};
810		-
811		-static int __init microcode_init (void)
812		-{
813		- int error;
814		-
815		- printk(KERN_INFO
816		- "IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@aivazian.fsnet.co.uk>\n");
817		-
818		- error = microcode_dev_init();
819		- if (error)
820		- return error;
821		- microcode_pdev = platform_device_register_simple("microcode", -1,
822		- NULL, 0);
823		- if (IS_ERR(microcode_pdev)) {
824		- microcode_dev_exit();
825		- return PTR_ERR(microcode_pdev);
826		- }
827		-
828		- get_online_cpus();
829		- error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
830		- put_online_cpus();
831		- if (error) {
832		- microcode_dev_exit();
833		- platform_device_unregister(microcode_pdev);
834		- return error;
835		- }
836		-
837		- register_hotcpu_notifier(&mc_cpu_notifier);
838		- return 0;
839		-}
840		-
841		-static void __exit microcode_exit (void)
842		-{
843		- microcode_dev_exit();
844		-
845		- unregister_hotcpu_notifier(&mc_cpu_notifier);
846		-
847		- get_online_cpus();
848		- sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
849		- put_online_cpus();
850		-
851		- platform_device_unregister(microcode_pdev);
852		-}
853		-
854		-module_init(microcode_init)
855		-module_exit(microcode_exit)