cpu: convert 'cpu' and 'machinecheck' sysdev_class to a regular subsystem

This moves the 'cpu sysdev_class' over to a regular 'cpu' subsystem
and converts the devices to regular devices. The sysdev drivers are
implemented as subsystem interfaces now.

After all sysdev classes are ported to regular driver core entities, the
sysdev implementation will be entirely removed from the kernel.

Userspace relies on events and generic sysfs subsystem infrastructure
from sysdev devices, which are made available with this conversion.

Cc: Haavard Skinnemoen <hskinnemoen@gmail.com>
Cc: Hans-Christian Egtvedt <egtvedt@samfundet.no>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Chris Metcalf <cmetcalf@tilera.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Borislav Petkov <bp@amd64.org>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Len Brown <lenb@kernel.org>
Cc: Zhang Rui <rui.zhang@intel.com>
Cc: Dave Jones <davej@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Russell King <rmk+kernel@arm.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: "Rafael J. Wysocki" <rjw@sisk.pl>
Cc: "Srivatsa S. Bhat" <srivatsa.bhat@linux.vnet.ibm.com>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

11 files changed, 199 insertions, 197 deletions

diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 9d7bc9f6b6cc..20a68ca386de 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -446,7 +446,7 @@ static int __cpuinit acpi_processor_add(struct acpi_device *device)
 {
         struct acpi_processor *pr = NULL;
         int result = 0;
-        struct sys_device *sysdev;
+        struct device *dev;
 
         pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
         if (!pr)
@@ -491,8 +491,8 @@ static int __cpuinit acpi_processor_add(struct acpi_device *device)
 
         per_cpu(processors, pr->id) = pr;
 
-        sysdev = get_cpu_sysdev(pr->id);
-        if (sysfs_create_link(&device->dev.kobj, &sysdev->kobj, "sysdev")) {
+        dev = get_cpu_device(pr->id);
+        if (sysfs_create_link(&device->dev.kobj, &dev->kobj, "sysdev")) {
                 result = -EFAULT;
                 goto err_free_cpumask;
         }
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index 870550d6a4bf..3b599abf2b40 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/cpufreq.h>
-#include <linux/sysdev.h>
 
 #include <asm/uaccess.h>
 
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 251acea3d359..5bb0298fbcc0 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -1,8 +1,7 @@
 /*
- * drivers/base/cpu.c - basic CPU class support
+ * CPU subsystem support
  */
 
-#include <linux/sysdev.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/sched.h>
@@ -14,40 +13,40 @@
 
 #include "base.h"
 
-static struct sysdev_class_attribute *cpu_sysdev_class_attrs[];
-
-struct sysdev_class cpu_sysdev_class = {
+struct bus_type cpu_subsys = {
         .name = "cpu",
-        .attrs = cpu_sysdev_class_attrs,
+        .dev_name = "cpu",
 };
-EXPORT_SYMBOL(cpu_sysdev_class);
+EXPORT_SYMBOL_GPL(cpu_subsys);
 
-static DEFINE_PER_CPU(struct sys_device *, cpu_sys_devices);
+static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
 
 #ifdef CONFIG_HOTPLUG_CPU
-static ssize_t show_online(struct sys_device *dev, struct sysdev_attribute *attr,
+static ssize_t show_online(struct device *dev,
+                           struct device_attribute *attr,
                            char *buf)
 {
-        struct cpu *cpu = container_of(dev, struct cpu, sysdev);
+        struct cpu *cpu = container_of(dev, struct cpu, dev);
 
-        return sprintf(buf, "%u\n", !!cpu_online(cpu->sysdev.id));
+        return sprintf(buf, "%u\n", !!cpu_online(cpu->dev.id));
 }
 
-static ssize_t __ref store_online(struct sys_device *dev, struct sysdev_attribute *attr,
-                                 const char *buf, size_t count)
+static ssize_t __ref store_online(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
 {
-        struct cpu *cpu = container_of(dev, struct cpu, sysdev);
+        struct cpu *cpu = container_of(dev, struct cpu, dev);
         ssize_t ret;
 
         cpu_hotplug_driver_lock();
         switch (buf[0]) {
         case '0':
-                ret = cpu_down(cpu->sysdev.id);
+                ret = cpu_down(cpu->dev.id);
                 if (!ret)
                         kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
                 break;
         case '1':
-                ret = cpu_up(cpu->sysdev.id);
+                ret = cpu_up(cpu->dev.id);
                 if (!ret)
                         kobject_uevent(&dev->kobj, KOBJ_ONLINE);
                 break;
@@ -60,44 +59,44 @@ static ssize_t __ref store_online(struct sys_device *dev, struct sysdev_attribut
                 ret = count;
         return ret;
 }
-static SYSDEV_ATTR(online, 0644, show_online, store_online);
+static DEVICE_ATTR(online, 0644, show_online, store_online);
 
 static void __cpuinit register_cpu_control(struct cpu *cpu)
 {
-        sysdev_create_file(&cpu->sysdev, &attr_online);
+        device_create_file(&cpu->dev, &dev_attr_online);
 }
 void unregister_cpu(struct cpu *cpu)
 {
-        int logical_cpu = cpu->sysdev.id;
+        int logical_cpu = cpu->dev.id;
 
         unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
 
-        sysdev_remove_file(&cpu->sysdev, &attr_online);
+        device_remove_file(&cpu->dev, &dev_attr_online);
 
-        sysdev_unregister(&cpu->sysdev);
+        device_unregister(&cpu->dev);
         per_cpu(cpu_sys_devices, logical_cpu) = NULL;
         return;
 }
 
 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
-static ssize_t cpu_probe_store(struct sysdev_class *class,
-                               struct sysdev_class_attribute *attr,
+static ssize_t cpu_probe_store(struct device *dev,
+                               struct device_attribute *attr,
                                const char *buf,
                                size_t count)
 {
         return arch_cpu_probe(buf, count);
 }
 
-static ssize_t cpu_release_store(struct sysdev_class *class,
-                                 struct sysdev_class_attribute *attr,
+static ssize_t cpu_release_store(struct device *dev,
+                                 struct device_attribute *attr,
                                  const char *buf,
                                  size_t count)
 {
         return arch_cpu_release(buf, count);
 }
 
-static SYSDEV_CLASS_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
-static SYSDEV_CLASS_ATTR(release, S_IWUSR, NULL, cpu_release_store);
+static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
+static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 
 #else /* ... !CONFIG_HOTPLUG_CPU */
@@ -109,15 +108,15 @@ static inline void register_cpu_control(struct cpu *cpu)
 #ifdef CONFIG_KEXEC
 #include <linux/kexec.h>
 
-static ssize_t show_crash_notes(struct sys_device *dev, struct sysdev_attribute *attr,
+static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
                                 char *buf)
 {
-        struct cpu *cpu = container_of(dev, struct cpu, sysdev);
+        struct cpu *cpu = container_of(dev, struct cpu, dev);
         ssize_t rc;
         unsigned long long addr;
         int cpunum;
 
-        cpunum = cpu->sysdev.id;
+        cpunum = cpu->dev.id;
 
         /*
          * Might be reading other cpu's data based on which cpu read thread
@@ -129,7 +128,7 @@ static ssize_t show_crash_notes(struct sys_device *dev, struct sysdev_attribute
         rc = sprintf(buf, "%Lx\n", addr);
         return rc;
 }
-static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
+static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 #endif
 
 /*
@@ -137,12 +136,12 @@ static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
  */
 
 struct cpu_attr {
-        struct sysdev_class_attribute attr;
+        struct device_attribute attr;
         const struct cpumask *const * const map;
 };
 
-static ssize_t show_cpus_attr(struct sysdev_class *class,
-                              struct sysdev_class_attribute *attr,
+static ssize_t show_cpus_attr(struct device *dev,
+                              struct device_attribute *attr,
                               char *buf)
 {
         struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
@@ -153,10 +152,10 @@ static ssize_t show_cpus_attr(struct sysdev_class *class,
         return n;
 }
 
-#define _CPU_ATTR(name, map)                                            \
-        { _SYSDEV_CLASS_ATTR(name, 0444, show_cpus_attr, NULL), map }
+#define _CPU_ATTR(name, map) \
+        { __ATTR(name, 0444, show_cpus_attr, NULL), map }
 
-/* Keep in sync with cpu_sysdev_class_attrs */
+/* Keep in sync with cpu_subsys_attrs */
 static struct cpu_attr cpu_attrs[] = {
         _CPU_ATTR(online, &cpu_online_mask),
         _CPU_ATTR(possible, &cpu_possible_mask),
@@ -166,19 +165,19 @@ static struct cpu_attr cpu_attrs[] = {
 /*
  * Print values for NR_CPUS and offlined cpus
  */
-static ssize_t print_cpus_kernel_max(struct sysdev_class *class,
-                                     struct sysdev_class_attribute *attr, char *buf)
+static ssize_t print_cpus_kernel_max(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
         int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
         return n;
 }
-static SYSDEV_CLASS_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
+static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
 
 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
 unsigned int total_cpus;
 
-static ssize_t print_cpus_offline(struct sysdev_class *class,
-                                  struct sysdev_class_attribute *attr, char *buf)
+static ssize_t print_cpus_offline(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
 {
         int n = 0, len = PAGE_SIZE-2;
         cpumask_var_t offline;
@@ -205,7 +204,7 @@ static ssize_t print_cpus_offline(struct sysdev_class *class,
         n += snprintf(&buf[n], len - n, "\n");
         return n;
 }
-static SYSDEV_CLASS_ATTR(offline, 0444, print_cpus_offline, NULL);
+static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
 
 /*
  * register_cpu - Setup a sysfs device for a CPU.
@@ -218,57 +217,66 @@ static SYSDEV_CLASS_ATTR(offline, 0444, print_cpus_offline, NULL);
 int __cpuinit register_cpu(struct cpu *cpu, int num)
 {
         int error;
-        cpu->node_id = cpu_to_node(num);
-        cpu->sysdev.id = num;
-        cpu->sysdev.cls = &cpu_sysdev_class;
-
-        error = sysdev_register(&cpu->sysdev);
 
+        cpu->node_id = cpu_to_node(num);
+        cpu->dev.id = num;
+        cpu->dev.bus = &cpu_subsys;
+        error = device_register(&cpu->dev);
         if (!error && cpu->hotpluggable)
                 register_cpu_control(cpu);
         if (!error)
-                per_cpu(cpu_sys_devices, num) = &cpu->sysdev;
+                per_cpu(cpu_sys_devices, num) = &cpu->dev;
         if (!error)
                 register_cpu_under_node(num, cpu_to_node(num));
 
 #ifdef CONFIG_KEXEC
         if (!error)
-                error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);
+                error = device_create_file(&cpu->dev, &dev_attr_crash_notes);
 #endif
         return error;
 }
 
-struct sys_device *get_cpu_sysdev(unsigned cpu)
+struct device *get_cpu_device(unsigned cpu)
 {
         if (cpu < nr_cpu_ids && cpu_possible(cpu))
                 return per_cpu(cpu_sys_devices, cpu);
         else
                 return NULL;
 }
-EXPORT_SYMBOL_GPL(get_cpu_sysdev);
+EXPORT_SYMBOL_GPL(get_cpu_device);
+
+static struct attribute *cpu_root_attrs[] = {
+#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
+        &dev_attr_probe.attr,
+        &dev_attr_release.attr,
+#endif
+        &cpu_attrs[0].attr.attr,
+        &cpu_attrs[1].attr.attr,
+        &cpu_attrs[2].attr.attr,
+        &dev_attr_kernel_max.attr,
+        &dev_attr_offline.attr,
+        NULL
+};
+
+static struct attribute_group cpu_root_attr_group = {
+        .attrs = cpu_root_attrs,
+};
+
+static const struct attribute_group *cpu_root_attr_groups[] = {
+        &cpu_root_attr_group,
+        NULL,
+};
 
 int __init cpu_dev_init(void)
 {
         int err;
 
-        err = sysdev_class_register(&cpu_sysdev_class);
+        err = subsys_system_register(&cpu_subsys, cpu_root_attr_groups);
+        if (err)
+                return err;
+
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
-        if (!err)
-                err = sched_create_sysfs_power_savings_entries(&cpu_sysdev_class);
+        err = sched_create_sysfs_power_savings_entries(cpu_subsys.dev_root);
 #endif
-
         return err;
 }
-
-static struct sysdev_class_attribute *cpu_sysdev_class_attrs[] = {
-#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
-        &attr_probe,
-        &attr_release,
-#endif
-        &cpu_attrs[0].attr,
-        &cpu_attrs[1].attr,
-        &cpu_attrs[2].attr,
-        &attr_kernel_max,
-        &attr_offline,
-        NULL
-};
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 793f796c4da3..6ce1501c7de5 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -315,12 +315,12 @@ struct node node_devices[MAX_NUMNODES];
 int register_cpu_under_node(unsigned int cpu, unsigned int nid)
 {
         int ret;
-        struct sys_device *obj;
+        struct device *obj;
 
         if (!node_online(nid))
                 return 0;
 
-        obj = get_cpu_sysdev(cpu);
+        obj = get_cpu_device(cpu);
         if (!obj)
                 return 0;
 
@@ -337,12 +337,12 @@ int register_cpu_under_node(unsigned int cpu, unsigned int nid)
 
 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
 {
-        struct sys_device *obj;
+        struct device *obj;
 
         if (!node_online(nid))
                 return 0;
 
-        obj = get_cpu_sysdev(cpu);
+        obj = get_cpu_device(cpu);
         if (!obj)
                 return 0;
 
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index f6f37a05a0c3..ae989c57cd5e 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -23,7 +23,6 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  */
-#include <linux/sysdev.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>
@@ -32,14 +31,14 @@
 #include <linux/topology.h>
 
 #define define_one_ro_named(_name, _func)                               \
-static SYSDEV_ATTR(_name, 0444, _func, NULL)
+        static DEVICE_ATTR(_name, 0444, _func, NULL)
 
 #define define_one_ro(_name)                            \
-static SYSDEV_ATTR(_name, 0444, show_##_name, NULL)
+        static DEVICE_ATTR(_name, 0444, show_##_name, NULL)
 
 #define define_id_show_func(name)                               \
-static ssize_t show_##name(struct sys_device *dev,              \
-                struct sysdev_attribute *attr, char *buf)       \
+static ssize_t show_##name(struct device *dev,                  \
+                struct device_attribute *attr, char *buf)       \
 {                                                               \
         unsigned int cpu = dev->id;                             \
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
@@ -65,16 +64,16 @@ static ssize_t show_cpumap(int type, const struct cpumask *mask, char *buf)
 
 #ifdef arch_provides_topology_pointers
 #define define_siblings_show_map(name)                                  \
-static ssize_t show_##name(struct sys_device *dev,                      \
-                           struct sysdev_attribute *attr, char *buf)    \
+static ssize_t show_##name(struct device *dev,                          \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
         return show_cpumap(0, topology_##name(cpu), buf);               \
 }
 
 #define define_siblings_show_list(name)                                 \
-static ssize_t show_##name##_list(struct sys_device *dev,               \
-                                  struct sysdev_attribute *attr,        \
+static ssize_t show_##name##_list(struct device *dev,                   \
+                                  struct device_attribute *attr,        \
                                   char *buf)                            \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
@@ -83,15 +82,15 @@ static ssize_t show_##name##_list(struct sys_device *dev,		\
 
 #else
 #define define_siblings_show_map(name)                                  \
-static ssize_t show_##name(struct sys_device *dev,                      \
-                           struct sysdev_attribute *attr, char *buf)    \
+static ssize_t show_##name(struct device *dev,                          \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
         return show_cpumap(0, topology_##name(dev->id), buf);           \
 }
 
 #define define_siblings_show_list(name)                                 \
-static ssize_t show_##name##_list(struct sys_device *dev,               \
-                                  struct sysdev_attribute *attr,        \
+static ssize_t show_##name##_list(struct device *dev,                   \
+                                  struct device_attribute *attr,        \
                                   char *buf)                            \
 {                                                                       \
         return show_cpumap(1, topology_##name(dev->id), buf);           \
@@ -124,16 +123,16 @@ define_one_ro_named(book_siblings_list, show_book_cpumask_list);
 #endif
 
 static struct attribute *default_attrs[] = {
-        &attr_physical_package_id.attr,
-        &attr_core_id.attr,
-        &attr_thread_siblings.attr,
-        &attr_thread_siblings_list.attr,
-        &attr_core_siblings.attr,
-        &attr_core_siblings_list.attr,
+        &dev_attr_physical_package_id.attr,
+        &dev_attr_core_id.attr,
+        &dev_attr_thread_siblings.attr,
+        &dev_attr_thread_siblings_list.attr,
+        &dev_attr_core_siblings.attr,
+        &dev_attr_core_siblings_list.attr,
 #ifdef CONFIG_SCHED_BOOK
-        &attr_book_id.attr,
-        &attr_book_siblings.attr,
-        &attr_book_siblings_list.attr,
+        &dev_attr_book_id.attr,
+        &dev_attr_book_siblings.attr,
+        &dev_attr_book_siblings_list.attr,
 #endif
         NULL
 };
@@ -146,16 +145,16 @@ static struct attribute_group topology_attr_group = {
 /* Add/Remove cpu_topology interface for CPU device */
 static int __cpuinit topology_add_dev(unsigned int cpu)
 {
-        struct sys_device *sys_dev = get_cpu_sysdev(cpu);
+        struct device *dev = get_cpu_device(cpu);
 
-        return sysfs_create_group(&sys_dev->kobj, &topology_attr_group);
+        return sysfs_create_group(&dev->kobj, &topology_attr_group);
 }
 
 static void __cpuinit topology_remove_dev(unsigned int cpu)
 {
-        struct sys_device *sys_dev = get_cpu_sysdev(cpu);
+        struct device *dev = get_cpu_device(cpu);
 
-        sysfs_remove_group(&sys_dev->kobj, &topology_attr_group);
+        sysfs_remove_group(&dev->kobj, &topology_attr_group);
 }
 
 static int __cpuinit topology_cpu_callback(struct notifier_block *nfb,
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 987a165ede26..8c2df3499da7 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -679,7 +679,7 @@ static struct kobj_type ktype_cpufreq = {
  */
 static int cpufreq_add_dev_policy(unsigned int cpu,
                                   struct cpufreq_policy *policy,
-                                  struct sys_device *sys_dev)
+                                  struct device *dev)
 {
         int ret = 0;
 #ifdef CONFIG_SMP
@@ -728,7 +728,7 @@ static int cpufreq_add_dev_policy(unsigned int cpu,
                         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
                         pr_debug("CPU already managed, adding link\n");
-                        ret = sysfs_create_link(&sys_dev->kobj,
+                        ret = sysfs_create_link(&dev->kobj,
                                                 &managed_policy->kobj,
                                                 "cpufreq");
                         if (ret)
@@ -761,7 +761,7 @@ static int cpufreq_add_dev_symlink(unsigned int cpu,
 
         for_each_cpu(j, policy->cpus) {
                 struct cpufreq_policy *managed_policy;
-                struct sys_device *cpu_sys_dev;
+                struct device *cpu_dev;
 
                 if (j == cpu)
                         continue;
@@ -770,8 +770,8 @@ static int cpufreq_add_dev_symlink(unsigned int cpu,
 
                 pr_debug("CPU %u already managed, adding link\n", j);
                 managed_policy = cpufreq_cpu_get(cpu);
-                cpu_sys_dev = get_cpu_sysdev(j);
-                ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
+                cpu_dev = get_cpu_device(j);
+                ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
                                         "cpufreq");
                 if (ret) {
                         cpufreq_cpu_put(managed_policy);
@@ -783,7 +783,7 @@ static int cpufreq_add_dev_symlink(unsigned int cpu,
 
 static int cpufreq_add_dev_interface(unsigned int cpu,
                                      struct cpufreq_policy *policy,
-                                     struct sys_device *sys_dev)
+                                     struct device *dev)
 {
         struct cpufreq_policy new_policy;
         struct freq_attr **drv_attr;
@@ -793,7 +793,7 @@ static int cpufreq_add_dev_interface(unsigned int cpu,
 
         /* prepare interface data */
         ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
-                                   &sys_dev->kobj, "cpufreq");
+                                   &dev->kobj, "cpufreq");
         if (ret)
                 return ret;
 
@@ -866,9 +866,9 @@ err_out_kobj_put:
  * with with cpu hotplugging and all hell will break loose. Tried to clean this
  * mess up, but more thorough testing is needed. - Mathieu
  */
-static int cpufreq_add_dev(struct sys_device *sys_dev)
+static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
 {
-        unsigned int cpu = sys_dev->id;
+        unsigned int cpu = dev->id;
         int ret = 0, found = 0;
         struct cpufreq_policy *policy;
         unsigned long flags;
@@ -947,7 +947,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
                                      CPUFREQ_START, policy);
 
-        ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
+        ret = cpufreq_add_dev_policy(cpu, policy, dev);
         if (ret) {
                 if (ret > 0)
                         /* This is a managed cpu, symlink created,
@@ -956,7 +956,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                 goto err_unlock_policy;
         }
 
-        ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
+        ret = cpufreq_add_dev_interface(cpu, policy, dev);
         if (ret)
                 goto err_out_unregister;
 
@@ -999,15 +999,15 @@ module_out:
  * Caller should already have policy_rwsem in write mode for this CPU.
  * This routine frees the rwsem before returning.
  */
-static int __cpufreq_remove_dev(struct sys_device *sys_dev)
+static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
 {
-        unsigned int cpu = sys_dev->id;
+        unsigned int cpu = dev->id;
         unsigned long flags;
         struct cpufreq_policy *data;
         struct kobject *kobj;
         struct completion *cmp;
 #ifdef CONFIG_SMP
-        struct sys_device *cpu_sys_dev;
+        struct device *cpu_dev;
         unsigned int j;
 #endif
 
@@ -1032,7 +1032,7 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
                 pr_debug("removing link\n");
                 cpumask_clear_cpu(cpu, data->cpus);
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
-                kobj = &sys_dev->kobj;
+                kobj = &dev->kobj;
                 cpufreq_cpu_put(data);
                 unlock_policy_rwsem_write(cpu);
                 sysfs_remove_link(kobj, "cpufreq");
@@ -1071,8 +1071,8 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
                         strncpy(per_cpu(cpufreq_cpu_governor, j),
                                 data->governor->name, CPUFREQ_NAME_LEN);
 #endif
-                        cpu_sys_dev = get_cpu_sysdev(j);
-                        kobj = &cpu_sys_dev->kobj;
+                        cpu_dev = get_cpu_device(j);
+                        kobj = &cpu_dev->kobj;
                         unlock_policy_rwsem_write(cpu);
                         sysfs_remove_link(kobj, "cpufreq");
                         lock_policy_rwsem_write(cpu);
@@ -1112,11 +1112,11 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         if (unlikely(cpumask_weight(data->cpus) > 1)) {
                 /* first sibling now owns the new sysfs dir */
                 cpumask_clear_cpu(cpu, data->cpus);
-                cpufreq_add_dev(get_cpu_sysdev(cpumask_first(data->cpus)));
+                cpufreq_add_dev(get_cpu_device(cpumask_first(data->cpus)), NULL);
 
                 /* finally remove our own symlink */
                 lock_policy_rwsem_write(cpu);
-                __cpufreq_remove_dev(sys_dev);
+                __cpufreq_remove_dev(dev, sif);
         }
 #endif
 
@@ -1128,9 +1128,9 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
 }
 
 
-static int cpufreq_remove_dev(struct sys_device *sys_dev)
+static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
 {
-        unsigned int cpu = sys_dev->id;
+        unsigned int cpu = dev->id;
         int retval;
 
         if (cpu_is_offline(cpu))
@@ -1139,7 +1139,7 @@ static int cpufreq_remove_dev(struct sys_device *sys_dev)
         if (unlikely(lock_policy_rwsem_write(cpu)))
                 BUG();
 
-        retval = __cpufreq_remove_dev(sys_dev);
+        retval = __cpufreq_remove_dev(dev, sif);
         return retval;
 }
 
@@ -1271,9 +1271,11 @@ out:
 }
 EXPORT_SYMBOL(cpufreq_get);
 
-static struct sysdev_driver cpufreq_sysdev_driver = {
-        .add            = cpufreq_add_dev,
-        .remove         = cpufreq_remove_dev,
+static struct subsys_interface cpufreq_interface = {
+        .name           = "cpufreq",
+        .subsys         = &cpu_subsys,
+        .add_dev        = cpufreq_add_dev,
+        .remove_dev     = cpufreq_remove_dev,
 };
 
 
@@ -1765,25 +1767,25 @@ static int __cpuinit cpufreq_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);
-        if (sys_dev) {
+        dev = get_cpu_device(cpu);
+        if (dev) {
                 switch (action) {
                 case CPU_ONLINE:
                 case CPU_ONLINE_FROZEN:
-                        cpufreq_add_dev(sys_dev);
+                        cpufreq_add_dev(dev, NULL);
                         break;
                 case CPU_DOWN_PREPARE:
                 case CPU_DOWN_PREPARE_FROZEN:
                         if (unlikely(lock_policy_rwsem_write(cpu)))
                                 BUG();
 
-                        __cpufreq_remove_dev(sys_dev);
+                        __cpufreq_remove_dev(dev, NULL);
                         break;
                 case CPU_DOWN_FAILED:
                 case CPU_DOWN_FAILED_FROZEN:
-                        cpufreq_add_dev(sys_dev);
+                        cpufreq_add_dev(dev, NULL);
                         break;
                 }
         }
@@ -1830,8 +1832,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
         cpufreq_driver = driver_data;
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        ret = sysdev_driver_register(&cpu_sysdev_class,
-                                        &cpufreq_sysdev_driver);
+        ret = subsys_interface_register(&cpufreq_interface);
         if (ret)
                 goto err_null_driver;
 
@@ -1850,7 +1851,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
                 if (ret) {
                         pr_debug("no CPU initialized for driver %s\n",
                                                         driver_data->name);
-                        goto err_sysdev_unreg;
+                        goto err_if_unreg;
                 }
         }
 
@@ -1858,9 +1859,8 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
         pr_debug("driver %s up and running\n", driver_data->name);
 
         return 0;
-err_sysdev_unreg:
-        sysdev_driver_unregister(&cpu_sysdev_class,
-                        &cpufreq_sysdev_driver);
+err_if_unreg:
+        subsys_interface_unregister(&cpufreq_interface);
 err_null_driver:
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
         cpufreq_driver = NULL;
@@ -1887,7 +1887,7 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver)
 
         pr_debug("unregistering driver %s\n", driver->name);
 
-        sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
+        subsys_interface_unregister(&cpufreq_interface);
         unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
@@ -1907,8 +1907,7 @@ static int __init cpufreq_core_init(void)
                 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
         }
 
-        cpufreq_global_kobject = kobject_create_and_add("cpufreq",
-                                                &cpu_sysdev_class.kset.kobj);
+        cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
         BUG_ON(!cpufreq_global_kobject);
         register_syscore_ops(&cpufreq_syscore_ops);
 
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index c5072a91e848..390380a8cfc9 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -11,7 +11,6 @@
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/sysdev.h>
 #include <linux/cpu.h>
 #include <linux/sysfs.h>
 #include <linux/cpufreq.h>
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 06ce2680d00d..59f4261c753a 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -291,10 +291,10 @@ EXPORT_SYMBOL_GPL(cpuidle_disable_device);
 static int __cpuidle_register_device(struct cpuidle_device *dev)
 {
         int ret;
-        struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+        struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
         struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
 
-        if (!sys_dev)
+        if (!dev)
                 return -EINVAL;
         if (!try_module_get(cpuidle_driver->owner))
                 return -EINVAL;
@@ -303,7 +303,7 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
 
         per_cpu(cpuidle_devices, dev->cpu) = dev;
         list_add(&dev->device_list, &cpuidle_detected_devices);
-        if ((ret = cpuidle_add_sysfs(sys_dev))) {
+        if ((ret = cpuidle_add_sysfs(cpu_dev))) {
                 module_put(cpuidle_driver->owner);
                 return ret;
         }
@@ -344,7 +344,7 @@ EXPORT_SYMBOL_GPL(cpuidle_register_device);
  */
 void cpuidle_unregister_device(struct cpuidle_device *dev)
 {
-        struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+        struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
         struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
 
         if (dev->registered == 0)
@@ -354,7 +354,7 @@ void cpuidle_unregister_device(struct cpuidle_device *dev)
 
         cpuidle_disable_device(dev);
 
-        cpuidle_remove_sysfs(sys_dev);
+        cpuidle_remove_sysfs(cpu_dev);
         list_del(&dev->device_list);
         wait_for_completion(&dev->kobj_unregister);
         per_cpu(cpuidle_devices, dev->cpu) = NULL;
@@ -411,7 +411,7 @@ static int __init cpuidle_init(void)
         if (cpuidle_disabled())
                 return -ENODEV;
 
-        ret = cpuidle_add_class_sysfs(&cpu_sysdev_class);
+        ret = cpuidle_add_interface(cpu_subsys.dev_root);
         if (ret)
                 return ret;
 
diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h
index 38c3fd8b9d76..7db186685c27 100644
--- a/drivers/cpuidle/cpuidle.h
+++ b/drivers/cpuidle/cpuidle.h
@@ -5,7 +5,7 @@
 #ifndef __DRIVER_CPUIDLE_H
 #define __DRIVER_CPUIDLE_H
 
-#include <linux/sysdev.h>
+#include <linux/device.h>
 
 /* For internal use only */
 extern struct cpuidle_governor *cpuidle_curr_governor;
@@ -23,11 +23,11 @@ extern void cpuidle_uninstall_idle_handler(void);
 extern int cpuidle_switch_governor(struct cpuidle_governor *gov);
 
 /* sysfs */
-extern int cpuidle_add_class_sysfs(struct sysdev_class *cls);
-extern void cpuidle_remove_class_sysfs(struct sysdev_class *cls);
+extern int cpuidle_add_interface(struct device *dev);
+extern void cpuidle_remove_interface(struct device *dev);
 extern int cpuidle_add_state_sysfs(struct cpuidle_device *device);
 extern void cpuidle_remove_state_sysfs(struct cpuidle_device *device);
-extern int cpuidle_add_sysfs(struct sys_device *sysdev);
-extern void cpuidle_remove_sysfs(struct sys_device *sysdev);
+extern int cpuidle_add_sysfs(struct device *dev);
+extern void cpuidle_remove_sysfs(struct device *dev);
 
 #endif /* __DRIVER_CPUIDLE_H */
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 1e756e160dca..3fe41fe4851a 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -22,8 +22,8 @@ static int __init cpuidle_sysfs_setup(char *unused)
 }
 __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
 
-static ssize_t show_available_governors(struct sysdev_class *class,
-                                        struct sysdev_class_attribute *attr,
+static ssize_t show_available_governors(struct device *dev,
+                                        struct device_attribute *attr,
                                         char *buf)
 {
         ssize_t i = 0;
@@ -42,8 +42,8 @@ out:
         return i;
 }
 
-static ssize_t show_current_driver(struct sysdev_class *class,
-                                   struct sysdev_class_attribute *attr,
+static ssize_t show_current_driver(struct device *dev,
+                                   struct device_attribute *attr,
                                    char *buf)
 {
         ssize_t ret;
@@ -59,8 +59,8 @@ static ssize_t show_current_driver(struct sysdev_class *class,
         return ret;
 }
 
-static ssize_t show_current_governor(struct sysdev_class *class,
-                                     struct sysdev_class_attribute *attr,
+static ssize_t show_current_governor(struct device *dev,
+                                     struct device_attribute *attr,
                                      char *buf)
 {
         ssize_t ret;
@@ -75,8 +75,8 @@ static ssize_t show_current_governor(struct sysdev_class *class,
         return ret;
 }
 
-static ssize_t store_current_governor(struct sysdev_class *class,
-                                      struct sysdev_class_attribute *attr,
+static ssize_t store_current_governor(struct device *dev,
+                                      struct device_attribute *attr,
                                       const char *buf, size_t count)
 {
         char gov_name[CPUIDLE_NAME_LEN];
@@ -109,50 +109,48 @@ static ssize_t store_current_governor(struct sysdev_class *class,
                 return count;
 }
 
-static SYSDEV_CLASS_ATTR(current_driver, 0444, show_current_driver, NULL);
-static SYSDEV_CLASS_ATTR(current_governor_ro, 0444, show_current_governor,
-                         NULL);
+static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
+static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
 
-static struct attribute *cpuclass_default_attrs[] = {
-        &attr_current_driver.attr,
-        &attr_current_governor_ro.attr,
+static struct attribute *cpuidle_default_attrs[] = {
+        &dev_attr_current_driver.attr,
+        &dev_attr_current_governor_ro.attr,
         NULL
 };
 
-static SYSDEV_CLASS_ATTR(available_governors, 0444, show_available_governors,
-                         NULL);
-static SYSDEV_CLASS_ATTR(current_governor, 0644, show_current_governor,
-                         store_current_governor);
+static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);
+static DEVICE_ATTR(current_governor, 0644, show_current_governor,
+                   store_current_governor);
 
-static struct attribute *cpuclass_switch_attrs[] = {
-        &attr_available_governors.attr,
-        &attr_current_driver.attr,
-        &attr_current_governor.attr,
+static struct attribute *cpuidle_switch_attrs[] = {
+        &dev_attr_available_governors.attr,
+        &dev_attr_current_driver.attr,
+        &dev_attr_current_governor.attr,
         NULL
 };
 
-static struct attribute_group cpuclass_attr_group = {
-        .attrs = cpuclass_default_attrs,
+static struct attribute_group cpuidle_attr_group = {
+        .attrs = cpuidle_default_attrs,
         .name = "cpuidle",
 };
 
 /**
- * cpuidle_add_class_sysfs - add CPU global sysfs attributes
+ * cpuidle_add_interface - add CPU global sysfs attributes
  */
-int cpuidle_add_class_sysfs(struct sysdev_class *cls)
+int cpuidle_add_interface(struct device *dev)
 {
         if (sysfs_switch)
-                cpuclass_attr_group.attrs = cpuclass_switch_attrs;
+                cpuidle_attr_group.attrs = cpuidle_switch_attrs;
 
-        return sysfs_create_group(&cls->kset.kobj, &cpuclass_attr_group);
+        return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
 }
 
 /**
- * cpuidle_remove_class_sysfs - remove CPU global sysfs attributes
+ * cpuidle_remove_interface - remove CPU global sysfs attributes
  */
-void cpuidle_remove_class_sysfs(struct sysdev_class *cls)
+void cpuidle_remove_interface(struct device *dev)
 {
-        sysfs_remove_group(&cls->kset.kobj, &cpuclass_attr_group);
+        sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
 }
 
 struct cpuidle_attr {
@@ -365,16 +363,16 @@ void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
 
 /**
  * cpuidle_add_sysfs - creates a sysfs instance for the target device
- * @sysdev: the target device
+ * @dev: the target device
  */
-int cpuidle_add_sysfs(struct sys_device *sysdev)
+int cpuidle_add_sysfs(struct device *cpu_dev)
 {
-        int cpu = sysdev->id;
+        int cpu = cpu_dev->id;
         struct cpuidle_device *dev;
         int error;
 
         dev = per_cpu(cpuidle_devices, cpu);
-        error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &sysdev->kobj,
+        error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
                                      "cpuidle");
         if (!error)
                 kobject_uevent(&dev->kobj, KOBJ_ADD);
@@ -383,11 +381,11 @@ int cpuidle_add_sysfs(struct sys_device *sysdev)
 
 /**
  * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
- * @sysdev: the target device
+ * @dev: the target device
  */
-void cpuidle_remove_sysfs(struct sys_device *sysdev)
+void cpuidle_remove_sysfs(struct device *cpu_dev)
 {
-        int cpu = sysdev->id;
+        int cpu = cpu_dev->id;
         struct cpuidle_device *dev;
 
         dev = per_cpu(cpuidle_devices, cpu);
diff --git a/drivers/s390/char/sclp_config.c b/drivers/s390/char/sclp_config.c
index 95b909ac2b73..3c03c1060be6 100644
--- a/drivers/s390/char/sclp_config.c
+++ b/drivers/s390/char/sclp_config.c
@@ -11,7 +11,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/cpu.h>
-#include <linux/sysdev.h>
+#include <linux/device.h>
 #include <linux/workqueue.h>
 #include <asm/smp.h>
 
@@ -31,14 +31,14 @@ static struct work_struct sclp_cpu_change_work;
 static void sclp_cpu_capability_notify(struct work_struct *work)
 {
         int cpu;
-        struct sys_device *sysdev;
+        struct device *dev;
 
         s390_adjust_jiffies();
         pr_warning("cpu capability changed.\n");
         get_online_cpus();
         for_each_online_cpu(cpu) {
-                sysdev = get_cpu_sysdev(cpu);
-                kobject_uevent(&sysdev->kobj, KOBJ_CHANGE);
+                dev = get_cpu_device(cpu);
+                kobject_uevent(&dev->kobj, KOBJ_CHANGE);
         }
         put_online_cpus();
 }