Merge branch 'driver-core-next' into Linux 3.2

This resolves the conflict in the arch/arm/mach-s3c64xx/s3c6400.c file,
and it fixes the build error in the arch/x86/kernel/microcode_core.c
file, that the merge did not catch.

The microcode_core.c patch was provided by Stephen Rothwell
<sfr@canb.auug.org.au> who was invaluable in the merge issues involved
with the large sysdev removal process in the driver-core tree.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

10 files changed, 150 insertions, 152 deletions

diff --git a/arch/x86/include/asm/mce.h b/arch/x86/include/asm/mce.h
index 0e8ae57d3656..7f06a19718a4 100644
--- a/arch/x86/include/asm/mce.h
+++ b/arch/x86/include/asm/mce.h
@@ -149,7 +149,7 @@ static inline void enable_p5_mce(void) {}
 
 void mce_setup(struct mce *m);
 void mce_log(struct mce *m);
-DECLARE_PER_CPU(struct sys_device, mce_sysdev);
+DECLARE_PER_CPU(struct device, mce_device);
 
 /*
  * Maximum banks number.
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index a3b0811693c9..6b45e5e7a901 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -844,8 +844,7 @@ static int __cpuinit detect_cache_attributes(unsigned int cpu)
 
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
-
-extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
+#include <linux/cpu.h>
 
 /* pointer to kobject for cpuX/cache */
 static DEFINE_PER_CPU(struct kobject *, ici_cache_kobject);
@@ -1073,9 +1072,9 @@ err_out:
 static DECLARE_BITMAP(cache_dev_map, NR_CPUS);
 
 /* Add/Remove cache interface for CPU device */
-static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
+static int __cpuinit cache_add_dev(struct device *dev)
 {
-        unsigned int cpu = sys_dev->id;
+        unsigned int cpu = dev->id;
         unsigned long i, j;
         struct _index_kobject *this_object;
         struct _cpuid4_info   *this_leaf;
@@ -1087,7 +1086,7 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
 
         retval = kobject_init_and_add(per_cpu(ici_cache_kobject, cpu),
                                       &ktype_percpu_entry,
-                                      &sys_dev->kobj, "%s", "cache");
+                                      &dev->kobj, "%s", "cache");
         if (retval < 0) {
                 cpuid4_cache_sysfs_exit(cpu);
                 return retval;
@@ -1124,9 +1123,9 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
         return 0;
 }
 
-static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
+static void __cpuinit cache_remove_dev(struct device *dev)
 {
-        unsigned int cpu = sys_dev->id;
+        unsigned int cpu = dev->id;
         unsigned long i;
 
         if (per_cpu(ici_cpuid4_info, cpu) == NULL)
@@ -1145,17 +1144,17 @@ static int __cpuinit cacheinfo_cpu_callback(struct notifier_block *nfb,
                                         unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct sys_device *sys_dev;
+        struct device *dev;
 
-        sys_dev = get_cpu_sysdev(cpu);
+        dev = get_cpu_device(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-                cache_add_dev(sys_dev);
+                cache_add_dev(dev);
                 break;
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
-                cache_remove_dev(sys_dev);
+                cache_remove_dev(dev);
                 break;
         }
         return NOTIFY_OK;
@@ -1174,9 +1173,9 @@ static int __cpuinit cache_sysfs_init(void)
 
         for_each_online_cpu(i) {
                 int err;
-                struct sys_device *sys_dev = get_cpu_sysdev(i);
+                struct device *dev = get_cpu_device(i);
 
-                err = cache_add_dev(sys_dev);
+                err = cache_add_dev(dev);
                 if (err)
                         return err;
         }
diff --git a/arch/x86/kernel/cpu/mcheck/mce-internal.h b/arch/x86/kernel/cpu/mcheck/mce-internal.h
index fefcc69ee8b5..ed44c8a65858 100644
--- a/arch/x86/kernel/cpu/mcheck/mce-internal.h
+++ b/arch/x86/kernel/cpu/mcheck/mce-internal.h
@@ -1,4 +1,4 @@
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <asm/mce.h>
 
 enum severity_level {
@@ -17,7 +17,7 @@ enum severity_level {
 struct mce_bank {
         u64                     ctl;                    /* subevents to enable */
         unsigned char init;                             /* initialise bank? */
-        struct sysdev_attribute attr;                   /* sysdev attribute */
+        struct device_attribute attr;                   /* device attribute */
         char                    attrname[ATTR_LEN];     /* attribute name */
 };
 
diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c
index 2af127d4c3d1..c83e3736ce28 100644
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce.c
@@ -19,7 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/string.h>
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <linux/syscore_ops.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
@@ -1770,7 +1770,7 @@ static struct syscore_ops mce_syscore_ops = {
 };
 
 /*
- * mce_sysdev: Sysfs support
+ * mce_device: Sysfs support
  */
 
 static void mce_cpu_restart(void *data)
@@ -1806,27 +1806,28 @@ static void mce_enable_ce(void *all)
                 __mcheck_cpu_init_timer();
 }
 
-static struct sysdev_class mce_sysdev_class = {
+static struct bus_type mce_subsys = {
         .name           = "machinecheck",
+        .dev_name       = "machinecheck",
 };
 
-DEFINE_PER_CPU(struct sys_device, mce_sysdev);
+DEFINE_PER_CPU(struct device, mce_device);
 
 __cpuinitdata
 void (*threshold_cpu_callback)(unsigned long action, unsigned int cpu);
 
-static inline struct mce_bank *attr_to_bank(struct sysdev_attribute *attr)
+static inline struct mce_bank *attr_to_bank(struct device_attribute *attr)
 {
         return container_of(attr, struct mce_bank, attr);
 }
 
-static ssize_t show_bank(struct sys_device *s, struct sysdev_attribute *attr,
+static ssize_t show_bank(struct device *s, struct device_attribute *attr,
                          char *buf)
 {
         return sprintf(buf, "%llx\n", attr_to_bank(attr)->ctl);
 }
 
-static ssize_t set_bank(struct sys_device *s, struct sysdev_attribute *attr,
+static ssize_t set_bank(struct device *s, struct device_attribute *attr,
                         const char *buf, size_t size)
 {
         u64 new;
@@ -1841,14 +1842,14 @@ static ssize_t set_bank(struct sys_device *s, struct sysdev_attribute *attr,
 }
 
 static ssize_t
-show_trigger(struct sys_device *s, struct sysdev_attribute *attr, char *buf)
+show_trigger(struct device *s, struct device_attribute *attr, char *buf)
 {
         strcpy(buf, mce_helper);
         strcat(buf, "\n");
         return strlen(mce_helper) + 1;
 }
 
-static ssize_t set_trigger(struct sys_device *s, struct sysdev_attribute *attr,
+static ssize_t set_trigger(struct device *s, struct device_attribute *attr,
                                 const char *buf, size_t siz)
 {
         char *p;
@@ -1863,8 +1864,8 @@ static ssize_t set_trigger(struct sys_device *s, struct sysdev_attribute *attr,
         return strlen(mce_helper) + !!p;
 }
 
-static ssize_t set_ignore_ce(struct sys_device *s,
-                             struct sysdev_attribute *attr,
+static ssize_t set_ignore_ce(struct device *s,
+                             struct device_attribute *attr,
                              const char *buf, size_t size)
 {
         u64 new;
@@ -1887,8 +1888,8 @@ static ssize_t set_ignore_ce(struct sys_device *s,
         return size;
 }
 
-static ssize_t set_cmci_disabled(struct sys_device *s,
-                                 struct sysdev_attribute *attr,
+static ssize_t set_cmci_disabled(struct device *s,
+                                 struct device_attribute *attr,
                                  const char *buf, size_t size)
 {
         u64 new;
@@ -1910,108 +1911,107 @@ static ssize_t set_cmci_disabled(struct sys_device *s,
         return size;
 }
 
-static ssize_t store_int_with_restart(struct sys_device *s,
-                                      struct sysdev_attribute *attr,
+static ssize_t store_int_with_restart(struct device *s,
+                                      struct device_attribute *attr,
                                       const char *buf, size_t size)
 {
-        ssize_t ret = sysdev_store_int(s, attr, buf, size);
+        ssize_t ret = device_store_int(s, attr, buf, size);
         mce_restart();
         return ret;
 }
 
-static SYSDEV_ATTR(trigger, 0644, show_trigger, set_trigger);
-static SYSDEV_INT_ATTR(tolerant, 0644, tolerant);
-static SYSDEV_INT_ATTR(monarch_timeout, 0644, monarch_timeout);
-static SYSDEV_INT_ATTR(dont_log_ce, 0644, mce_dont_log_ce);
+static DEVICE_ATTR(trigger, 0644, show_trigger, set_trigger);
+static DEVICE_INT_ATTR(tolerant, 0644, tolerant);
+static DEVICE_INT_ATTR(monarch_timeout, 0644, monarch_timeout);
+static DEVICE_INT_ATTR(dont_log_ce, 0644, mce_dont_log_ce);
 
-static struct sysdev_ext_attribute attr_check_interval = {
-        _SYSDEV_ATTR(check_interval, 0644, sysdev_show_int,
-                     store_int_with_restart),
+static struct dev_ext_attribute dev_attr_check_interval = {
+        __ATTR(check_interval, 0644, device_show_int, store_int_with_restart),
         &check_interval
 };
 
-static struct sysdev_ext_attribute attr_ignore_ce = {
-        _SYSDEV_ATTR(ignore_ce, 0644, sysdev_show_int, set_ignore_ce),
+static struct dev_ext_attribute dev_attr_ignore_ce = {
+        __ATTR(ignore_ce, 0644, device_show_int, set_ignore_ce),
         &mce_ignore_ce
 };
 
-static struct sysdev_ext_attribute attr_cmci_disabled = {
-        _SYSDEV_ATTR(cmci_disabled, 0644, sysdev_show_int, set_cmci_disabled),
+static struct dev_ext_attribute dev_attr_cmci_disabled = {
+        __ATTR(cmci_disabled, 0644, device_show_int, set_cmci_disabled),
         &mce_cmci_disabled
 };
 
-static struct sysdev_attribute *mce_sysdev_attrs[] = {
-        &attr_tolerant.attr,
-        &attr_check_interval.attr,
-        &attr_trigger,
-        &attr_monarch_timeout.attr,
-        &attr_dont_log_ce.attr,
-        &attr_ignore_ce.attr,
-        &attr_cmci_disabled.attr,
+static struct device_attribute *mce_device_attrs[] = {
+        &dev_attr_tolerant.attr,
+        &dev_attr_check_interval.attr,
+        &dev_attr_trigger,
+        &dev_attr_monarch_timeout.attr,
+        &dev_attr_dont_log_ce.attr,
+        &dev_attr_ignore_ce.attr,
+        &dev_attr_cmci_disabled.attr,
         NULL
 };
 
-static cpumask_var_t mce_sysdev_initialized;
+static cpumask_var_t mce_device_initialized;
 
-/* Per cpu sysdev init. All of the cpus still share the same ctrl bank: */
-static __cpuinit int mce_sysdev_create(unsigned int cpu)
+/* Per cpu device init. All of the cpus still share the same ctrl bank: */
+static __cpuinit int mce_device_create(unsigned int cpu)
 {
-        struct sys_device *sysdev = &per_cpu(mce_sysdev, cpu);
+        struct device *dev = &per_cpu(mce_device, cpu);
         int err;
         int i, j;
 
         if (!mce_available(&boot_cpu_data))
                 return -EIO;
 
-        memset(&sysdev->kobj, 0, sizeof(struct kobject));
-        sysdev->id  = cpu;
-        sysdev->cls = &mce_sysdev_class;
+        memset(&dev->kobj, 0, sizeof(struct kobject));
+        dev->id  = cpu;
+        dev->bus = &mce_subsys;
 
-        err = sysdev_register(sysdev);
+        err = device_register(dev);
         if (err)
                 return err;
 
-        for (i = 0; mce_sysdev_attrs[i]; i++) {
-                err = sysdev_create_file(sysdev, mce_sysdev_attrs[i]);
+        for (i = 0; mce_device_attrs[i]; i++) {
+                err = device_create_file(dev, mce_device_attrs[i]);
                 if (err)
                         goto error;
         }
         for (j = 0; j < banks; j++) {
-                err = sysdev_create_file(sysdev, &mce_banks[j].attr);
+                err = device_create_file(dev, &mce_banks[j].attr);
                 if (err)
                         goto error2;
         }
-        cpumask_set_cpu(cpu, mce_sysdev_initialized);
+        cpumask_set_cpu(cpu, mce_device_initialized);
 
         return 0;
 error2:
         while (--j >= 0)
-                sysdev_remove_file(sysdev, &mce_banks[j].attr);
+                device_remove_file(dev, &mce_banks[j].attr);
 error:
         while (--i >= 0)
-                sysdev_remove_file(sysdev, mce_sysdev_attrs[i]);
+                device_remove_file(dev, mce_device_attrs[i]);
 
-        sysdev_unregister(sysdev);
+        device_unregister(dev);
 
         return err;
 }
 
-static __cpuinit void mce_sysdev_remove(unsigned int cpu)
+static __cpuinit void mce_device_remove(unsigned int cpu)
 {
-        struct sys_device *sysdev = &per_cpu(mce_sysdev, cpu);
+        struct device *dev = &per_cpu(mce_device, cpu);
         int i;
 
-        if (!cpumask_test_cpu(cpu, mce_sysdev_initialized))
+        if (!cpumask_test_cpu(cpu, mce_device_initialized))
                 return;
 
-        for (i = 0; mce_sysdev_attrs[i]; i++)
-                sysdev_remove_file(sysdev, mce_sysdev_attrs[i]);
+        for (i = 0; mce_device_attrs[i]; i++)
+                device_remove_file(dev, mce_device_attrs[i]);
 
         for (i = 0; i < banks; i++)
-                sysdev_remove_file(sysdev, &mce_banks[i].attr);
+                device_remove_file(dev, &mce_banks[i].attr);
 
-        sysdev_unregister(sysdev);
-        cpumask_clear_cpu(cpu, mce_sysdev_initialized);
+        device_unregister(dev);
+        cpumask_clear_cpu(cpu, mce_device_initialized);
 }
 
 /* Make sure there are no machine checks on offlined CPUs. */
@@ -2061,7 +2061,7 @@ mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-                mce_sysdev_create(cpu);
+                mce_device_create(cpu);
                 if (threshold_cpu_callback)
                         threshold_cpu_callback(action, cpu);
                 break;
@@ -2069,7 +2069,7 @@ mce_cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
         case CPU_DEAD_FROZEN:
                 if (threshold_cpu_callback)
                         threshold_cpu_callback(action, cpu);
-                mce_sysdev_remove(cpu);
+                mce_device_remove(cpu);
                 break;
         case CPU_DOWN_PREPARE:
         case CPU_DOWN_PREPARE_FROZEN:
@@ -2103,7 +2103,7 @@ static __init void mce_init_banks(void)
 
         for (i = 0; i < banks; i++) {
                 struct mce_bank *b = &mce_banks[i];
-                struct sysdev_attribute *a = &b->attr;
+                struct device_attribute *a = &b->attr;
 
                 sysfs_attr_init(&a->attr);
                 a->attr.name    = b->attrname;
@@ -2123,16 +2123,16 @@ static __init int mcheck_init_device(void)
         if (!mce_available(&boot_cpu_data))
                 return -EIO;
 
-        zalloc_cpumask_var(&mce_sysdev_initialized, GFP_KERNEL);
+        zalloc_cpumask_var(&mce_device_initialized, GFP_KERNEL);
 
         mce_init_banks();
 
-        err = sysdev_class_register(&mce_sysdev_class);
+        err = subsys_system_register(&mce_subsys, NULL);
         if (err)
                 return err;
 
         for_each_online_cpu(i) {
-                err = mce_sysdev_create(i);
+                err = mce_device_create(i);
                 if (err)
                         return err;
         }
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd.c b/arch/x86/kernel/cpu/mcheck/mce_amd.c
index f5474218cffe..56d2aa1acd55 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd.c
@@ -17,7 +17,6 @@
 #include <linux/notifier.h>
 #include <linux/kobject.h>
 #include <linux/percpu.h>
-#include <linux/sysdev.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/sysfs.h>
@@ -548,7 +547,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
                 if (!b)
                         goto out;
 
-                err = sysfs_create_link(&per_cpu(mce_sysdev, cpu).kobj,
+                err = sysfs_create_link(&per_cpu(mce_device, cpu).kobj,
                                         b->kobj, name);
                 if (err)
                         goto out;
@@ -571,7 +570,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
                 goto out;
         }
 
-        b->kobj = kobject_create_and_add(name, &per_cpu(mce_sysdev, cpu).kobj);
+        b->kobj = kobject_create_and_add(name, &per_cpu(mce_device, cpu).kobj);
         if (!b->kobj)
                 goto out_free;
 
@@ -591,7 +590,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
                 if (i == cpu)
                         continue;
 
-                err = sysfs_create_link(&per_cpu(mce_sysdev, i).kobj,
+                err = sysfs_create_link(&per_cpu(mce_device, i).kobj,
                                         b->kobj, name);
                 if (err)
                         goto out;
@@ -669,7 +668,7 @@ static void threshold_remove_bank(unsigned int cpu, int bank)
 #ifdef CONFIG_SMP
         /* sibling symlink */
         if (shared_bank[bank] && b->blocks->cpu != cpu) {
-                sysfs_remove_link(&per_cpu(mce_sysdev, cpu).kobj, name);
+                sysfs_remove_link(&per_cpu(mce_device, cpu).kobj, name);
                 per_cpu(threshold_banks, cpu)[bank] = NULL;
 
                 return;
@@ -681,7 +680,7 @@ static void threshold_remove_bank(unsigned int cpu, int bank)
                 if (i == cpu)
                         continue;
 
-                sysfs_remove_link(&per_cpu(mce_sysdev, i).kobj, name);
+                sysfs_remove_link(&per_cpu(mce_device, i).kobj, name);
                 per_cpu(threshold_banks, i)[bank] = NULL;
         }
 
diff --git a/arch/x86/kernel/cpu/mcheck/therm_throt.c b/arch/x86/kernel/cpu/mcheck/therm_throt.c
index 787e06c84ea6..59e3f6ed265f 100644
--- a/arch/x86/kernel/cpu/mcheck/therm_throt.c
+++ b/arch/x86/kernel/cpu/mcheck/therm_throt.c
@@ -19,7 +19,6 @@
 #include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/export.h>
-#include <linux/sysdev.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/smp.h>
@@ -69,16 +68,16 @@ static atomic_t therm_throt_en	= ATOMIC_INIT(0);
 static u32 lvtthmr_init __read_mostly;
 
 #ifdef CONFIG_SYSFS
-#define define_therm_throt_sysdev_one_ro(_name)                         \
-        static SYSDEV_ATTR(_name, 0444,                                 \
-                           therm_throt_sysdev_show_##_name,             \
+#define define_therm_throt_device_one_ro(_name)                         \
+        static DEVICE_ATTR(_name, 0444,                                 \
+                           therm_throt_device_show_##_name,             \
                                    NULL)                                \
 
-#define define_therm_throt_sysdev_show_func(event, name)                \
+#define define_therm_throt_device_show_func(event, name)                \
                                                                         \
-static ssize_t therm_throt_sysdev_show_##event##_##name(                \
-                        struct sys_device *dev,                         \
-                        struct sysdev_attribute *attr,                  \
+static ssize_t therm_throt_device_show_##event##_##name(                \
+                        struct device *dev,                             \
+                        struct device_attribute *attr,                  \
                         char *buf)                                      \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
@@ -95,20 +94,20 @@ static ssize_t therm_throt_sysdev_show_##event##_##name(		\
         return ret;                                                     \
 }
 
-define_therm_throt_sysdev_show_func(core_throttle, count);
-define_therm_throt_sysdev_one_ro(core_throttle_count);
+define_therm_throt_device_show_func(core_throttle, count);
+define_therm_throt_device_one_ro(core_throttle_count);
 
-define_therm_throt_sysdev_show_func(core_power_limit, count);
-define_therm_throt_sysdev_one_ro(core_power_limit_count);
+define_therm_throt_device_show_func(core_power_limit, count);
+define_therm_throt_device_one_ro(core_power_limit_count);
 
-define_therm_throt_sysdev_show_func(package_throttle, count);
-define_therm_throt_sysdev_one_ro(package_throttle_count);
+define_therm_throt_device_show_func(package_throttle, count);
+define_therm_throt_device_one_ro(package_throttle_count);
 
-define_therm_throt_sysdev_show_func(package_power_limit, count);
-define_therm_throt_sysdev_one_ro(package_power_limit_count);
+define_therm_throt_device_show_func(package_power_limit, count);
+define_therm_throt_device_one_ro(package_power_limit_count);
 
 static struct attribute *thermal_throttle_attrs[] = {
-        &attr_core_throttle_count.attr,
+        &dev_attr_core_throttle_count.attr,
         NULL
 };
 
@@ -223,36 +222,36 @@ static int thresh_event_valid(int event)
 
 #ifdef CONFIG_SYSFS
 /* Add/Remove thermal_throttle interface for CPU device: */
-static __cpuinit int thermal_throttle_add_dev(struct sys_device *sys_dev,
+static __cpuinit int thermal_throttle_add_dev(struct device *dev,
                                 unsigned int cpu)
 {
         int err;
         struct cpuinfo_x86 *c = &cpu_data(cpu);
 
-        err = sysfs_create_group(&sys_dev->kobj, &thermal_attr_group);
+        err = sysfs_create_group(&dev->kobj, &thermal_attr_group);
         if (err)
                 return err;
 
         if (cpu_has(c, X86_FEATURE_PLN))
-                err = sysfs_add_file_to_group(&sys_dev->kobj,
-                                              &attr_core_power_limit_count.attr,
+                err = sysfs_add_file_to_group(&dev->kobj,
+                                              &dev_attr_core_power_limit_count.attr,
                                               thermal_attr_group.name);
         if (cpu_has(c, X86_FEATURE_PTS)) {
-                err = sysfs_add_file_to_group(&sys_dev->kobj,
-                                              &attr_package_throttle_count.attr,
+                err = sysfs_add_file_to_group(&dev->kobj,
+                                              &dev_attr_package_throttle_count.attr,
                                               thermal_attr_group.name);
                 if (cpu_has(c, X86_FEATURE_PLN))
-                        err = sysfs_add_file_to_group(&sys_dev->kobj,
-                                        &attr_package_power_limit_count.attr,
+                        err = sysfs_add_file_to_group(&dev->kobj,
+                                        &dev_attr_package_power_limit_count.attr,
                                         thermal_attr_group.name);
         }
 
         return err;
 }
 
-static __cpuinit void thermal_throttle_remove_dev(struct sys_device *sys_dev)
+static __cpuinit void thermal_throttle_remove_dev(struct device *dev)
 {
-        sysfs_remove_group(&sys_dev->kobj, &thermal_attr_group);
+        sysfs_remove_group(&dev->kobj, &thermal_attr_group);
 }
 
 /* Mutex protecting device creation against CPU hotplug: */
@@ -265,16 +264,16 @@ thermal_throttle_cpu_callback(struct notifier_block *nfb,
                               void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct sys_device *sys_dev;
+        struct device *dev;
         int err = 0;
 
-        sys_dev = get_cpu_sysdev(cpu);
+        dev = get_cpu_device(cpu);
 
         switch (action) {
         case CPU_UP_PREPARE:
         case CPU_UP_PREPARE_FROZEN:
                 mutex_lock(&therm_cpu_lock);
-                err = thermal_throttle_add_dev(sys_dev, cpu);
+                err = thermal_throttle_add_dev(dev, cpu);
                 mutex_unlock(&therm_cpu_lock);
                 WARN_ON(err);
                 break;
@@ -283,7 +282,7 @@ thermal_throttle_cpu_callback(struct notifier_block *nfb,
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
                 mutex_lock(&therm_cpu_lock);
-                thermal_throttle_remove_dev(sys_dev);
+                thermal_throttle_remove_dev(dev);
                 mutex_unlock(&therm_cpu_lock);
                 break;
         }
@@ -310,7 +309,7 @@ static __init int thermal_throttle_init_device(void)
 #endif
         /* connect live CPUs to sysfs */
         for_each_online_cpu(cpu) {
-                err = thermal_throttle_add_dev(get_cpu_sysdev(cpu), cpu);
+                err = thermal_throttle_add_dev(get_cpu_device(cpu), cpu);
                 WARN_ON(err);
         }
 #ifdef CONFIG_HOTPLUG_CPU
diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c
index 1bb0bf4d92cd..56258f1c488e 100644
--- a/arch/x86/kernel/hpet.c
+++ b/arch/x86/kernel/hpet.c
@@ -2,7 +2,6 @@
 #include <linux/clockchips.h>
 #include <linux/interrupt.h>
 #include <linux/export.h>
-#include <linux/sysdev.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/i8253.h>
diff --git a/arch/x86/kernel/irqinit.c b/arch/x86/kernel/irqinit.c
index b3300e6bacef..313fb5cddbce 100644
--- a/arch/x86/kernel/irqinit.c
+++ b/arch/x86/kernel/irqinit.c
@@ -9,7 +9,7 @@
 #include <linux/kprobes.h>
 #include <linux/init.h>
 #include <linux/kernel_stat.h>
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <linux/bitops.h>
 #include <linux/acpi.h>
 #include <linux/io.h>
diff --git a/arch/x86/kernel/microcode_core.c b/arch/x86/kernel/microcode_core.c
index 9d46f5e43b51..c6aa7eb6cda4 100644
--- a/arch/x86/kernel/microcode_core.c
+++ b/arch/x86/kernel/microcode_core.c
@@ -292,8 +292,8 @@ static int reload_for_cpu(int cpu)
         return err;
 }
 
-static ssize_t reload_store(struct sys_device *dev,
-                            struct sysdev_attribute *attr,
+static ssize_t reload_store(struct device *dev,
+                            struct device_attribute *attr,
                             const char *buf, size_t size)
 {
         unsigned long val;
@@ -318,30 +318,30 @@ static ssize_t reload_store(struct sys_device *dev,
         return ret;
 }
 
-static ssize_t version_show(struct sys_device *dev,
-                        struct sysdev_attribute *attr, char *buf)
+static ssize_t version_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
 {
         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
 
         return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
 }
 
-static ssize_t pf_show(struct sys_device *dev,
-                        struct sysdev_attribute *attr, char *buf)
+static ssize_t pf_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
 {
         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
 
         return sprintf(buf, "0x%x\n", uci->cpu_sig.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 DEVICE_ATTR(reload, 0200, NULL, reload_store);
+static DEVICE_ATTR(version, 0400, version_show, NULL);
+static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL);
 
 static struct attribute *mc_default_attrs[] = {
-        &attr_reload.attr,
-        &attr_version.attr,
-        &attr_processor_flags.attr,
+        &dev_attr_reload.attr,
+        &dev_attr_version.attr,
+        &dev_attr_processor_flags.attr,
         NULL
 };
 
@@ -405,43 +405,45 @@ static enum ucode_state microcode_update_cpu(int cpu)
         return ustate;
 }
 
-static int mc_sysdev_add(struct sys_device *sys_dev)
+static int mc_device_add(struct device *dev, struct subsys_interface *sif)
 {
-        int err, cpu = sys_dev->id;
+        int err, cpu = dev->id;
 
         if (!cpu_online(cpu))
                 return 0;
 
         pr_debug("CPU%d added\n", cpu);
 
-        err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
+        err = sysfs_create_group(&dev->kobj, &mc_attr_group);
         if (err)
                 return err;
 
         if (microcode_init_cpu(cpu) == UCODE_ERROR) {
-                sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+                sysfs_remove_group(&dev->kobj, &mc_attr_group);
                 return -EINVAL;
         }
 
         return err;
 }
 
-static int mc_sysdev_remove(struct sys_device *sys_dev)
+static int mc_device_remove(struct device *dev, struct subsys_interface *sif)
 {
-        int cpu = sys_dev->id;
+        int cpu = dev->id;
 
         if (!cpu_online(cpu))
                 return 0;
 
         pr_debug("CPU%d removed\n", cpu);
         microcode_fini_cpu(cpu);
-        sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+        sysfs_remove_group(&dev->kobj, &mc_attr_group);
         return 0;
 }
 
-static struct sysdev_driver mc_sysdev_driver = {
-        .add                    = mc_sysdev_add,
-        .remove                 = mc_sysdev_remove,
+static struct subsys_interface mc_cpu_interface = {
+        .name                   = "microcode",
+        .subsys                 = &cpu_subsys,
+        .add_dev                = mc_device_add,
+        .remove_dev             = mc_device_remove,
 };
 
 /**
@@ -464,9 +466,9 @@ 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;
+        struct device *dev;
 
-        sys_dev = get_cpu_sysdev(cpu);
+        dev = get_cpu_device(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -474,13 +476,13 @@ mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
         case CPU_DOWN_FAILED:
         case CPU_DOWN_FAILED_FROZEN:
                 pr_debug("CPU%d added\n", cpu);
-                if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
+                if (sysfs_create_group(&dev->kobj, &mc_attr_group))
                         pr_err("Failed to create group for CPU%d\n", cpu);
                 break;
         case CPU_DOWN_PREPARE:
         case CPU_DOWN_PREPARE_FROZEN:
                 /* Suspend is in progress, only remove the interface */
-                sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+                sysfs_remove_group(&dev->kobj, &mc_attr_group);
                 pr_debug("CPU%d removed\n", cpu);
                 break;
 
@@ -525,7 +527,7 @@ static int __init microcode_init(void)
         get_online_cpus();
         mutex_lock(&microcode_mutex);
 
-        error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
+        error = subsys_interface_register(&mc_cpu_interface);
 
         mutex_unlock(&microcode_mutex);
         put_online_cpus();
@@ -535,7 +537,7 @@ static int __init microcode_init(void)
 
         error = microcode_dev_init();
         if (error)
-                goto out_sysdev_driver;
+                goto out_driver;
 
         register_syscore_ops(&mc_syscore_ops);
         register_hotcpu_notifier(&mc_cpu_notifier);
@@ -545,11 +547,11 @@ static int __init microcode_init(void)
 
         return 0;
 
-out_sysdev_driver:
+out_driver:
         get_online_cpus();
         mutex_lock(&microcode_mutex);
 
-        sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
+        subsys_interface_unregister(&mc_cpu_interface);
 
         mutex_unlock(&microcode_mutex);
         put_online_cpus();
@@ -571,7 +573,7 @@ static void __exit microcode_exit(void)
         get_online_cpus();
         mutex_lock(&microcode_mutex);
 
-        sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
+        subsys_interface_unregister(&mc_cpu_interface);
 
         mutex_unlock(&microcode_mutex);
         put_online_cpus();
diff --git a/arch/x86/platform/uv/uv_sysfs.c b/arch/x86/platform/uv/uv_sysfs.c
index 309c70fb7759..5d4ba301e776 100644
--- a/arch/x86/platform/uv/uv_sysfs.c
+++ b/arch/x86/platform/uv/uv_sysfs.c
@@ -19,7 +19,7 @@
  *  Copyright (c) Russ Anderson
  */
 
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <asm/uv/bios.h>
 #include <asm/uv/uv.h>