update CPU patch to include all architectures

not compiled, not tested!

1 files changed, 2441 insertions, 20 deletions

diff --git a/09-cpu.patch b/09-cpu.patch
index 4ac4f79..b9cd902 100644
--- a/09-cpu.patch
+++ b/09-cpu.patch
@@ -13,27 +13,2419 @@ from sysdev devices, which are made available with this conversion.
 
 Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
 ---
- arch/x86/include/asm/mce.h                |    2 
- arch/x86/kernel/cpu/intel_cacheinfo.c     |   25 ++---
- arch/x86/kernel/cpu/mcheck/mce-internal.h |    4 
- arch/x86/kernel/cpu/mcheck/mce.c          |  130 +++++++++++++-------------
- arch/x86/kernel/cpu/mcheck/mce_amd.c      |   11 +-
- arch/x86/kernel/cpu/mcheck/therm_throt.c  |   63 ++++++------
- arch/x86/kernel/microcode_core.c          |   64 ++++++-------
- drivers/acpi/processor_driver.c           |    6 -
- drivers/acpi/processor_thermal.c          |    1 
- drivers/base/cpu.c                        |  146 +++++++++++++++---------------
- drivers/base/node.c                       |    8 -
- drivers/base/topology.c                   |   51 +++++-----
- drivers/cpufreq/cpufreq.c                 |   79 ++++++++--------
- drivers/cpufreq/cpufreq_stats.c           |    1 
- drivers/cpuidle/cpuidle.c                 |   12 +-
- drivers/cpuidle/cpuidle.h                 |   10 +-
- drivers/cpuidle/sysfs.c                   |   78 +++++++---------
- include/linux/cpu.h                       |   18 +--
- kernel/sched.c                            |   40 +++-----
- 19 files changed, 374 insertions(+), 375 deletions(-)
+ arch/avr32/kernel/cpu.c                         |   74 +++---
+ arch/ia64/kernel/err_inject.c                   |   52 ++--
+ arch/ia64/kernel/topology.c                     |   10 
+ arch/powerpc/include/asm/spu.h                  |   12 -
+ arch/powerpc/include/asm/topology.h             |   10 
+ arch/powerpc/kernel/cacheinfo.c                 |   10 
+ arch/powerpc/kernel/smp.c                       |    2 
+ arch/powerpc/kernel/sysfs.c                     |  257 +++++++++++-------------
+ arch/powerpc/mm/numa.c                          |    8 
+ arch/powerpc/platforms/cell/cbe_thermal.c       |  162 +++++++--------
+ arch/powerpc/platforms/cell/spu_base.c          |   61 ++---
+ arch/powerpc/platforms/pseries/pseries_energy.c |   67 ++----
+ arch/powerpc/sysdev/ppc4xx_cpm.c                |    6 
+ arch/s390/kernel/smp.c                          |   76 +++----
+ arch/s390/kernel/topology.c                     |    6 
+ arch/sh/kernel/cpu/sh4/sq.c                     |   24 +-
+ arch/sparc/kernel/sysfs.c                       |  122 +++++------
+ arch/tile/kernel/sysfs.c                        |   61 ++---
+ arch/x86/include/asm/mce.h                      |    2 
+ arch/x86/kernel/cpu/intel_cacheinfo.c           |   25 +-
+ arch/x86/kernel/cpu/mcheck/mce-internal.h       |    4 
+ arch/x86/kernel/cpu/mcheck/mce.c                |  130 ++++++------
+ arch/x86/kernel/cpu/mcheck/mce_amd.c            |   11 -
+ arch/x86/kernel/cpu/mcheck/therm_throt.c        |   63 ++---
+ arch/x86/kernel/microcode_core.c                |   64 +++--
+ drivers/acpi/processor_driver.c                 |    6 
+ drivers/acpi/processor_thermal.c                |    1 
+ drivers/base/cpu.c                              |  146 +++++++------
+ drivers/base/node.c                             |    8 
+ drivers/base/topology.c                         |   51 ++--
+ drivers/cpufreq/cpufreq.c                       |   79 +++----
+ drivers/cpufreq/cpufreq_stats.c                 |    1 
+ drivers/cpuidle/cpuidle.c                       |   12 -
+ drivers/cpuidle/cpuidle.h                       |   10 
+ drivers/cpuidle/sysfs.c                         |   78 +++----
+ drivers/s390/char/sclp_config.c                 |    8 
+ include/linux/cpu.h                             |   18 -
+ kernel/sched.c                                  |   40 +--
+ 38 files changed, 887 insertions(+), 890 deletions(-)
 
+--- a/arch/avr32/kernel/cpu.c
++++ b/arch/avr32/kernel/cpu.c
+@@ -6,7 +6,7 @@
+  * published by the Free Software Foundation.
+  */
+ #include <linux/init.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/seq_file.h>
+ #include <linux/cpu.h>
+ #include <linux/module.h>
+@@ -26,16 +26,16 @@ static DEFINE_PER_CPU(struct cpu, cpu_de
+  * XXX: If/when a SMP-capable implementation of AVR32 will ever be
+  * made, we must make sure that the code executes on the correct CPU.
+  */
+-static ssize_t show_pc0event(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pc0event(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pccr;
+ 
+ 	pccr = sysreg_read(PCCR);
+ 	return sprintf(buf, "0x%lx\n", (pccr >> 12) & 0x3f);
+ }
+-static ssize_t store_pc0event(struct sys_device *dev,
+-			struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_pc0event(struct device *dev,
++			struct device_attribute *attr, const char *buf,
+ 			      size_t count)
+ {
+ 	unsigned long val;
+@@ -48,16 +48,16 @@ static ssize_t store_pc0event(struct sys
+ 	sysreg_write(PCCR, val);
+ 	return count;
+ }
+-static ssize_t show_pc0count(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pc0count(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pcnt0;
+ 
+ 	pcnt0 = sysreg_read(PCNT0);
+ 	return sprintf(buf, "%lu\n", pcnt0);
+ }
+-static ssize_t store_pc0count(struct sys_device *dev,
+-				struct sysdev_attribute *attr,
++static ssize_t store_pc0count(struct device *dev,
++				struct device_attribute *attr,
+ 				const char *buf, size_t count)
+ {
+ 	unsigned long val;
+@@ -71,16 +71,16 @@ static ssize_t store_pc0count(struct sys
+ 	return count;
+ }
+ 
+-static ssize_t show_pc1event(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pc1event(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pccr;
+ 
+ 	pccr = sysreg_read(PCCR);
+ 	return sprintf(buf, "0x%lx\n", (pccr >> 18) & 0x3f);
+ }
+-static ssize_t store_pc1event(struct sys_device *dev,
+-			      struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_pc1event(struct device *dev,
++			      struct device_attribute *attr, const char *buf,
+ 			      size_t count)
+ {
+ 	unsigned long val;
+@@ -93,16 +93,16 @@ static ssize_t store_pc1event(struct sys
+ 	sysreg_write(PCCR, val);
+ 	return count;
+ }
+-static ssize_t show_pc1count(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pc1count(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pcnt1;
+ 
+ 	pcnt1 = sysreg_read(PCNT1);
+ 	return sprintf(buf, "%lu\n", pcnt1);
+ }
+-static ssize_t store_pc1count(struct sys_device *dev,
+-				struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_pc1count(struct device *dev,
++				struct device_attribute *attr, const char *buf,
+ 			      size_t count)
+ {
+ 	unsigned long val;
+@@ -116,16 +116,16 @@ static ssize_t store_pc1count(struct sys
+ 	return count;
+ }
+ 
+-static ssize_t show_pccycles(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pccycles(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pccnt;
+ 
+ 	pccnt = sysreg_read(PCCNT);
+ 	return sprintf(buf, "%lu\n", pccnt);
+ }
+-static ssize_t store_pccycles(struct sys_device *dev,
+-				struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_pccycles(struct device *dev,
++				struct device_attribute *attr, const char *buf,
+ 			      size_t count)
+ {
+ 	unsigned long val;
+@@ -139,16 +139,16 @@ static ssize_t store_pccycles(struct sys
+ 	return count;
+ }
+ 
+-static ssize_t show_pcenable(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t show_pcenable(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long pccr;
+ 
+ 	pccr = sysreg_read(PCCR);
+ 	return sprintf(buf, "%c\n", (pccr & 1)?'1':'0');
+ }
+-static ssize_t store_pcenable(struct sys_device *dev,
+-			      struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_pcenable(struct device *dev,
++			      struct device_attribute *attr, const char *buf,
+ 			      size_t count)
+ {
+ 	unsigned long pccr, val;
+@@ -167,12 +167,12 @@ static ssize_t store_pcenable(struct sys
+ 	return count;
+ }
+ 
+-static SYSDEV_ATTR(pc0event, 0600, show_pc0event, store_pc0event);
+-static SYSDEV_ATTR(pc0count, 0600, show_pc0count, store_pc0count);
+-static SYSDEV_ATTR(pc1event, 0600, show_pc1event, store_pc1event);
+-static SYSDEV_ATTR(pc1count, 0600, show_pc1count, store_pc1count);
+-static SYSDEV_ATTR(pccycles, 0600, show_pccycles, store_pccycles);
+-static SYSDEV_ATTR(pcenable, 0600, show_pcenable, store_pcenable);
++static DEVICE_ATTR(pc0event, 0600, show_pc0event, store_pc0event);
++static DEVICE_ATTR(pc0count, 0600, show_pc0count, store_pc0count);
++static DEVICE_ATTR(pc1event, 0600, show_pc1event, store_pc1event);
++static DEVICE_ATTR(pc1count, 0600, show_pc1count, store_pc1count);
++static DEVICE_ATTR(pccycles, 0600, show_pccycles, store_pccycles);
++static DEVICE_ATTR(pcenable, 0600, show_pcenable, store_pcenable);
+ 
+ #endif /* CONFIG_PERFORMANCE_COUNTERS */
+ 
+@@ -186,12 +186,12 @@ static int __init topology_init(void)
+ 		register_cpu(c, cpu);
+ 
+ #ifdef CONFIG_PERFORMANCE_COUNTERS
+-		sysdev_create_file(&c->sysdev, &attr_pc0event);
+-		sysdev_create_file(&c->sysdev, &attr_pc0count);
+-		sysdev_create_file(&c->sysdev, &attr_pc1event);
+-		sysdev_create_file(&c->sysdev, &attr_pc1count);
+-		sysdev_create_file(&c->sysdev, &attr_pccycles);
+-		sysdev_create_file(&c->sysdev, &attr_pcenable);
++		device_create_file(&c->dev, &dev_attr_pc0event);
++		device_create_file(&c->dev, &dev_attr_pc0count);
++		device_create_file(&c->dev, &dev_attr_pc1event);
++		device_create_file(&c->dev, &dev_attr_pc1count);
++		device_create_file(&c->dev, &dev_attr_pccycles);
++		device_create_file(&c->dev, &dev_attr_pcenable);
+ #endif
+ 	}
+ 
+--- a/arch/ia64/kernel/err_inject.c
++++ b/arch/ia64/kernel/err_inject.c
+@@ -24,7 +24,7 @@
+  * Copyright (C) 2006, Intel Corp.  All rights reserved.
+  *
+  */
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/init.h>
+ #include <linux/mm.h>
+ #include <linux/cpu.h>
+@@ -35,10 +35,10 @@
+ #define ERR_DATA_BUFFER_SIZE 3 		// Three 8-byte;
+ 
+ #define define_one_ro(name) 						\
+-static SYSDEV_ATTR(name, 0444, show_##name, NULL)
++static DEVICE_ATTR(name, 0444, show_##name, NULL)
+ 
+ #define define_one_rw(name) 						\
+-static SYSDEV_ATTR(name, 0644, show_##name, store_##name)
++static DEVICE_ATTR(name, 0644, show_##name, store_##name)
+ 
+ static u64 call_start[NR_CPUS];
+ static u64 phys_addr[NR_CPUS];
+@@ -55,7 +55,7 @@ static u64 resources[NR_CPUS];
+ 
+ #define show(name) 							\
+ static ssize_t 								\
+-show_##name(struct sys_device *dev, struct sysdev_attribute *attr,	\
++show_##name(struct device *dev, struct device_attribute *attr,	\
+ 		char *buf)						\
+ {									\
+ 	u32 cpu=dev->id;						\
+@@ -64,7 +64,7 @@ show_##name(struct sys_device *dev, stru
+ 
+ #define store(name)							\
+ static ssize_t 								\
+-store_##name(struct sys_device *dev, struct sysdev_attribute *attr,	\
++store_##name(struct device *dev, struct device_attribute *attr,	\
+ 					const char *buf, size_t size)	\
+ {									\
+ 	unsigned int cpu=dev->id;					\
+@@ -78,7 +78,7 @@ show(call_start)
+  * processor. The cpu number in driver is only used for storing data.
+  */
+ static ssize_t
+-store_call_start(struct sys_device *dev, struct sysdev_attribute *attr,
++store_call_start(struct device *dev, struct device_attribute *attr,
+ 		const char *buf, size_t size)
+ {
+ 	unsigned int cpu=dev->id;
+@@ -127,7 +127,7 @@ show(err_type_info)
+ store(err_type_info)
+ 
+ static ssize_t
+-show_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
++show_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+ 			char *buf)
+ {
+ 	unsigned int cpu=dev->id;
+@@ -135,7 +135,7 @@ show_virtual_to_phys(struct sys_device *
+ }
+ 
+ static ssize_t
+-store_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
++store_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+ 			const char *buf, size_t size)
+ {
+ 	unsigned int cpu=dev->id;
+@@ -159,8 +159,8 @@ show(err_struct_info)
+ store(err_struct_info)
+ 
+ static ssize_t
+-show_err_data_buffer(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *buf)
++show_err_data_buffer(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+ 	unsigned int cpu=dev->id;
+ 
+@@ -171,8 +171,8 @@ show_err_data_buffer(struct sys_device *
+ }
+ 
+ static ssize_t
+-store_err_data_buffer(struct sys_device *dev,
+-			struct sysdev_attribute *attr,
++store_err_data_buffer(struct device *dev,
++			struct device_attribute *attr,
+ 			const char *buf, size_t size)
+ {
+ 	unsigned int cpu=dev->id;
+@@ -209,14 +209,14 @@ define_one_ro(capabilities);
+ define_one_ro(resources);
+ 
+ static struct attribute *default_attrs[] = {
+-	&attr_call_start.attr,
+-	&attr_virtual_to_phys.attr,
+-	&attr_err_type_info.attr,
+-	&attr_err_struct_info.attr,
+-	&attr_err_data_buffer.attr,
+-	&attr_status.attr,
+-	&attr_capabilities.attr,
+-	&attr_resources.attr,
++	&dev_attr_call_start.attr,
++	&dev_attr_virtual_to_phys.attr,
++	&dev_attr_err_type_info.attr,
++	&dev_attr_err_struct_info.attr,
++	&dev_attr_err_data_buffer.attr,
++	&dev_attr_status.attr,
++	&dev_attr_capabilities.attr,
++	&dev_attr_resources.attr,
+ 	NULL
+ };
+ 
+@@ -225,12 +225,12 @@ static struct attribute_group err_inject
+ 	.name = "err_inject"
+ };
+ /* Add/Remove err_inject interface for CPU device */
+-static int __cpuinit err_inject_add_dev(struct sys_device * sys_dev)
++static int __cpuinit err_inject_add_dev(struct device * sys_dev)
+ {
+ 	return sysfs_create_group(&sys_dev->kobj, &err_inject_attr_group);
+ }
+ 
+-static int __cpuinit err_inject_remove_dev(struct sys_device * sys_dev)
++static int __cpuinit err_inject_remove_dev(struct device * sys_dev)
+ {
+ 	sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
+ 	return 0;
+@@ -239,9 +239,9 @@ static int __cpuinit err_inject_cpu_call
+ 		unsigned long action, void *hcpu)
+ {
+ 	unsigned int cpu = (unsigned long)hcpu;
+-	struct sys_device *sys_dev;
++	struct device *sys_dev;
+ 
+-	sys_dev = get_cpu_sysdev(cpu);
++	sys_dev = get_cpu_device(cpu);
+ 	switch (action) {
+ 	case CPU_ONLINE:
+ 	case CPU_ONLINE_FROZEN:
+@@ -283,13 +283,13 @@ static void __exit
+ err_inject_exit(void)
+ {
+ 	int i;
+-	struct sys_device *sys_dev;
++	struct device *sys_dev;
+ 
+ #ifdef ERR_INJ_DEBUG
+ 	printk(KERN_INFO "Exit error injection driver.\n");
+ #endif
+ 	for_each_online_cpu(i) {
+-		sys_dev = get_cpu_sysdev(i);
++		sys_dev = get_cpu_device(i);
+ 		sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
+ 	}
+ 	unregister_hotcpu_notifier(&err_inject_cpu_notifier);
+--- a/arch/ia64/kernel/topology.c
++++ b/arch/ia64/kernel/topology.c
+@@ -350,7 +350,7 @@ static int __cpuinit cpu_cache_sysfs_ini
+ }
+ 
+ /* Add cache interface for CPU device */
+-static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
++static int __cpuinit cache_add_dev(struct device * sys_dev)
+ {
+ 	unsigned int cpu = sys_dev->id;
+ 	unsigned long i, j;
+@@ -400,7 +400,7 @@ static int __cpuinit cache_add_dev(struc
+ }
+ 
+ /* Remove cache interface for CPU device */
+-static int __cpuinit cache_remove_dev(struct sys_device * sys_dev)
++static int __cpuinit cache_remove_dev(struct device * sys_dev)
+ {
+ 	unsigned int cpu = sys_dev->id;
+ 	unsigned long i;
+@@ -428,9 +428,9 @@ static int __cpuinit cache_cpu_callback(
+ 		unsigned long action, void *hcpu)
+ {
+ 	unsigned int cpu = (unsigned long)hcpu;
+-	struct sys_device *sys_dev;
++	struct device *sys_dev;
+ 
+-	sys_dev = get_cpu_sysdev(cpu);
++	sys_dev = get_cpu_device(cpu);
+ 	switch (action) {
+ 	case CPU_ONLINE:
+ 	case CPU_ONLINE_FROZEN:
+@@ -454,7 +454,7 @@ static int __init cache_sysfs_init(void)
+ 	int i;
+ 
+ 	for_each_online_cpu(i) {
+-		struct sys_device *sys_dev = get_cpu_sysdev((unsigned int)i);
++		struct device *sys_dev = get_cpu_device((unsigned int)i);
+ 		cache_add_dev(sys_dev);
+ 	}
+ 
+--- a/arch/powerpc/include/asm/spu.h
++++ b/arch/powerpc/include/asm/spu.h
+@@ -25,7 +25,7 @@
+ #ifdef __KERNEL__
+ 
+ #include <linux/workqueue.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/mutex.h>
+ 
+ #define LS_SIZE (256 * 1024)
+@@ -166,7 +166,7 @@ struct spu {
+ 	/* beat only */
+ 	u64 shadow_int_mask_RW[3];
+ 
+-	struct sys_device sysdev;
++	struct device dev;
+ 
+ 	int has_mem_affinity;
+ 	struct list_head aff_list;
+@@ -270,11 +270,11 @@ struct spufs_calls {
+ int register_spu_syscalls(struct spufs_calls *calls);
+ void unregister_spu_syscalls(struct spufs_calls *calls);
+ 
+-int spu_add_sysdev_attr(struct sysdev_attribute *attr);
+-void spu_remove_sysdev_attr(struct sysdev_attribute *attr);
++int spu_add_dev_attr(struct device_attribute *attr);
++void spu_remove_dev_attr(struct device_attribute *attr);
+ 
+-int spu_add_sysdev_attr_group(struct attribute_group *attrs);
+-void spu_remove_sysdev_attr_group(struct attribute_group *attrs);
++int spu_add_dev_attr_group(struct attribute_group *attrs);
++void spu_remove_dev_attr_group(struct attribute_group *attrs);
+ 
+ int spu_handle_mm_fault(struct mm_struct *mm, unsigned long ea,
+ 		unsigned long dsisr, unsigned *flt);
+--- a/arch/powerpc/include/asm/topology.h
++++ b/arch/powerpc/include/asm/topology.h
+@@ -3,7 +3,7 @@
+ #ifdef __KERNEL__
+ 
+ 
+-struct sys_device;
++struct device;
+ struct device_node;
+ 
+ #ifdef CONFIG_NUMA
+@@ -86,19 +86,19 @@ extern int __node_distance(int, int);
+ 
+ extern void __init dump_numa_cpu_topology(void);
+ 
+-extern int sysfs_add_device_to_node(struct sys_device *dev, int nid);
+-extern void sysfs_remove_device_from_node(struct sys_device *dev, int nid);
++extern int sysfs_add_device_to_node(struct device *dev, int nid);
++extern void sysfs_remove_device_from_node(struct device *dev, int nid);
+ 
+ #else
+ 
+ static inline void dump_numa_cpu_topology(void) {}
+ 
+-static inline int sysfs_add_device_to_node(struct sys_device *dev, int nid)
++static inline int sysfs_add_device_to_node(struct device *dev, int nid)
+ {
+ 	return 0;
+ }
+ 
+-static inline void sysfs_remove_device_from_node(struct sys_device *dev,
++static inline void sysfs_remove_device_from_node(struct device *dev,
+ 						int nid)
+ {
+ }
+--- a/arch/powerpc/kernel/cacheinfo.c
++++ b/arch/powerpc/kernel/cacheinfo.c
+@@ -451,15 +451,15 @@ out:
+ static struct cache_dir *__cpuinit cacheinfo_create_cache_dir(unsigned int cpu_id)
+ {
+ 	struct cache_dir *cache_dir;
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 	struct kobject *kobj = NULL;
+ 
+-	sysdev = get_cpu_sysdev(cpu_id);
+-	WARN_ONCE(!sysdev, "no sysdev for CPU %i\n", cpu_id);
+-	if (!sysdev)
++	dev = get_cpu_device(cpu_id);
++	WARN_ONCE(!dev, "no dev for CPU %i\n", cpu_id);
++	if (!dev)
+ 		goto err;
+ 
+-	kobj = kobject_create_and_add("cache", &sysdev->kobj);
++	kobj = kobject_create_and_add("cache", &dev->kobj);
+ 	if (!kobj)
+ 		goto err;
+ 
+--- a/arch/powerpc/kernel/smp.c
++++ b/arch/powerpc/kernel/smp.c
+@@ -27,7 +27,7 @@
+ #include <linux/spinlock.h>
+ #include <linux/cache.h>
+ #include <linux/err.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/cpu.h>
+ #include <linux/notifier.h>
+ #include <linux/topology.h>
+--- a/arch/powerpc/kernel/sysfs.c
++++ b/arch/powerpc/kernel/sysfs.c
+@@ -1,4 +1,4 @@
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/cpu.h>
+ #include <linux/smp.h>
+ #include <linux/percpu.h>
+@@ -37,12 +37,12 @@ static DEFINE_PER_CPU(struct cpu, cpu_de
+ /* Time in microseconds we delay before sleeping in the idle loop */
+ DEFINE_PER_CPU(long, smt_snooze_delay) = { 100 };
+ 
+-static ssize_t store_smt_snooze_delay(struct sys_device *dev,
+-				      struct sysdev_attribute *attr,
++static ssize_t store_smt_snooze_delay(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;
+ 	long snooze;
+ 
+@@ -50,21 +50,21 @@ static ssize_t store_smt_snooze_delay(st
+ 	if (ret != 1)
+ 		return -EINVAL;
+ 
+-	per_cpu(smt_snooze_delay, cpu->sysdev.id) = snooze;
++	per_cpu(smt_snooze_delay, cpu->dev.id) = snooze;
+ 
+ 	return count;
+ }
+ 
+-static ssize_t show_smt_snooze_delay(struct sys_device *dev,
+-				     struct sysdev_attribute *attr,
++static ssize_t show_smt_snooze_delay(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, "%ld\n", per_cpu(smt_snooze_delay, cpu->sysdev.id));
++	return sprintf(buf, "%ld\n", per_cpu(smt_snooze_delay, cpu->dev.id));
+ }
+ 
+-static SYSDEV_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay,
++static DEVICE_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay,
+ 		   store_smt_snooze_delay);
+ 
+ static int __init setup_smt_snooze_delay(char *str)
+@@ -117,25 +117,25 @@ static void write_##NAME(void *val) \
+ 	ppc_enable_pmcs(); \
+ 	mtspr(ADDRESS, *(unsigned long *)val);	\
+ } \
+-static ssize_t show_##NAME(struct sys_device *dev, \
+-			struct sysdev_attribute *attr, \
++static ssize_t show_##NAME(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); \
+ 	unsigned long val; \
+-	smp_call_function_single(cpu->sysdev.id, read_##NAME, &val, 1);	\
++	smp_call_function_single(cpu->dev.id, read_##NAME, &val, 1);	\
+ 	return sprintf(buf, "%lx\n", val); \
+ } \
+ static ssize_t __used \
+-	store_##NAME(struct sys_device *dev, struct sysdev_attribute *attr, \
++	store_##NAME(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); \
+ 	unsigned long val; \
+ 	int ret = sscanf(buf, "%lx", &val); \
+ 	if (ret != 1) \
+ 		return -EINVAL; \
+-	smp_call_function_single(cpu->sysdev.id, write_##NAME, &val, 1); \
++	smp_call_function_single(cpu->dev.id, write_##NAME, &val, 1); \
+ 	return count; \
+ }
+ 
+@@ -178,22 +178,22 @@ SYSFS_PMCSETUP(purr, SPRN_PURR);
+ SYSFS_PMCSETUP(spurr, SPRN_SPURR);
+ SYSFS_PMCSETUP(dscr, SPRN_DSCR);
+ 
+-static SYSDEV_ATTR(mmcra, 0600, show_mmcra, store_mmcra);
+-static SYSDEV_ATTR(spurr, 0600, show_spurr, NULL);
+-static SYSDEV_ATTR(dscr, 0600, show_dscr, store_dscr);
+-static SYSDEV_ATTR(purr, 0600, show_purr, store_purr);
++static DEVICE_ATTR(mmcra, 0600, show_mmcra, store_mmcra);
++static DEVICE_ATTR(spurr, 0600, show_spurr, NULL);
++static DEVICE_ATTR(dscr, 0600, show_dscr, store_dscr);
++static DEVICE_ATTR(purr, 0600, show_purr, store_purr);
+ 
+ unsigned long dscr_default = 0;
+ EXPORT_SYMBOL(dscr_default);
+ 
+-static ssize_t show_dscr_default(struct sysdev_class *class,
+-		struct sysdev_class_attribute *attr, char *buf)
++static ssize_t show_dscr_default(struct device *dev,
++		struct device_attribute *attr, char *buf)
+ {
+ 	return sprintf(buf, "%lx\n", dscr_default);
+ }
+ 
+-static ssize_t __used store_dscr_default(struct sysdev_class *class,
+-		struct sysdev_class_attribute *attr, const char *buf,
++static ssize_t __used store_dscr_default(struct device *dev,
++		struct device_attribute *attr, const char *buf,
+ 		size_t count)
+ {
+ 	unsigned long val;
+@@ -207,15 +207,14 @@ static ssize_t __used store_dscr_default
+ 	return count;
+ }
+ 
+-static SYSDEV_CLASS_ATTR(dscr_default, 0600,
++static DEVICE_ATTR(dscr_default, 0600,
+ 		show_dscr_default, store_dscr_default);
+ 
+ static void sysfs_create_dscr_default(void)
+ {
+ 	int err = 0;
+ 	if (cpu_has_feature(CPU_FTR_DSCR))
+-		err = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
+-			&attr_dscr_default.attr);
++		err = device_create_file(cpu_subsys.dev_root, &dev_attr_dscr_default);
+ }
+ #endif /* CONFIG_PPC64 */
+ 
+@@ -259,72 +258,72 @@ SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3);
+ #endif /* HAS_PPC_PMC_PA6T */
+ 
+ #ifdef HAS_PPC_PMC_IBM
+-static struct sysdev_attribute ibm_common_attrs[] = {
+-	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
+-	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
++static struct device_attribute ibm_common_attrs[] = {
++	__ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
++	__ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
+ };
+ #endif /* HAS_PPC_PMC_G4 */
+ 
+ #ifdef HAS_PPC_PMC_G4
+-static struct sysdev_attribute g4_common_attrs[] = {
+-	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
+-	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
+-	_SYSDEV_ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
++static struct device_attribute g4_common_attrs[] = {
++	__ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
++	__ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
++	__ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
+ };
+ #endif /* HAS_PPC_PMC_G4 */
+ 
+-static struct sysdev_attribute classic_pmc_attrs[] = {
+-	_SYSDEV_ATTR(pmc1, 0600, show_pmc1, store_pmc1),
+-	_SYSDEV_ATTR(pmc2, 0600, show_pmc2, store_pmc2),
+-	_SYSDEV_ATTR(pmc3, 0600, show_pmc3, store_pmc3),
+-	_SYSDEV_ATTR(pmc4, 0600, show_pmc4, store_pmc4),
+-	_SYSDEV_ATTR(pmc5, 0600, show_pmc5, store_pmc5),
+-	_SYSDEV_ATTR(pmc6, 0600, show_pmc6, store_pmc6),
++static struct device_attribute classic_pmc_attrs[] = {
++	__ATTR(pmc1, 0600, show_pmc1, store_pmc1),
++	__ATTR(pmc2, 0600, show_pmc2, store_pmc2),
++	__ATTR(pmc3, 0600, show_pmc3, store_pmc3),
++	__ATTR(pmc4, 0600, show_pmc4, store_pmc4),
++	__ATTR(pmc5, 0600, show_pmc5, store_pmc5),
++	__ATTR(pmc6, 0600, show_pmc6, store_pmc6),
+ #ifdef CONFIG_PPC64
+-	_SYSDEV_ATTR(pmc7, 0600, show_pmc7, store_pmc7),
+-	_SYSDEV_ATTR(pmc8, 0600, show_pmc8, store_pmc8),
++	__ATTR(pmc7, 0600, show_pmc7, store_pmc7),
++	__ATTR(pmc8, 0600, show_pmc8, store_pmc8),
+ #endif
+ };
+ 
+ #ifdef HAS_PPC_PMC_PA6T
+-static struct sysdev_attribute pa6t_attrs[] = {
+-	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
+-	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
+-	_SYSDEV_ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0),
+-	_SYSDEV_ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1),
+-	_SYSDEV_ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2),
+-	_SYSDEV_ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3),
+-	_SYSDEV_ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4),
+-	_SYSDEV_ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5),
++static struct device_attribute pa6t_attrs[] = {
++	__ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
++	__ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
++	__ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0),
++	__ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1),
++	__ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2),
++	__ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3),
++	__ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4),
++	__ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5),
+ #ifdef CONFIG_DEBUG_KERNEL
+-	_SYSDEV_ATTR(hid0, 0600, show_hid0, store_hid0),
+-	_SYSDEV_ATTR(hid1, 0600, show_hid1, store_hid1),
+-	_SYSDEV_ATTR(hid4, 0600, show_hid4, store_hid4),
+-	_SYSDEV_ATTR(hid5, 0600, show_hid5, store_hid5),
+-	_SYSDEV_ATTR(ima0, 0600, show_ima0, store_ima0),
+-	_SYSDEV_ATTR(ima1, 0600, show_ima1, store_ima1),
+-	_SYSDEV_ATTR(ima2, 0600, show_ima2, store_ima2),
+-	_SYSDEV_ATTR(ima3, 0600, show_ima3, store_ima3),
+-	_SYSDEV_ATTR(ima4, 0600, show_ima4, store_ima4),
+-	_SYSDEV_ATTR(ima5, 0600, show_ima5, store_ima5),
+-	_SYSDEV_ATTR(ima6, 0600, show_ima6, store_ima6),
+-	_SYSDEV_ATTR(ima7, 0600, show_ima7, store_ima7),
+-	_SYSDEV_ATTR(ima8, 0600, show_ima8, store_ima8),
+-	_SYSDEV_ATTR(ima9, 0600, show_ima9, store_ima9),
+-	_SYSDEV_ATTR(imaat, 0600, show_imaat, store_imaat),
+-	_SYSDEV_ATTR(btcr, 0600, show_btcr, store_btcr),
+-	_SYSDEV_ATTR(pccr, 0600, show_pccr, store_pccr),
+-	_SYSDEV_ATTR(rpccr, 0600, show_rpccr, store_rpccr),
+-	_SYSDEV_ATTR(der, 0600, show_der, store_der),
+-	_SYSDEV_ATTR(mer, 0600, show_mer, store_mer),
+-	_SYSDEV_ATTR(ber, 0600, show_ber, store_ber),
+-	_SYSDEV_ATTR(ier, 0600, show_ier, store_ier),
+-	_SYSDEV_ATTR(sier, 0600, show_sier, store_sier),
+-	_SYSDEV_ATTR(siar, 0600, show_siar, store_siar),
+-	_SYSDEV_ATTR(tsr0, 0600, show_tsr0, store_tsr0),
+-	_SYSDEV_ATTR(tsr1, 0600, show_tsr1, store_tsr1),
+-	_SYSDEV_ATTR(tsr2, 0600, show_tsr2, store_tsr2),
+-	_SYSDEV_ATTR(tsr3, 0600, show_tsr3, store_tsr3),
++	__ATTR(hid0, 0600, show_hid0, store_hid0),
++	__ATTR(hid1, 0600, show_hid1, store_hid1),
++	__ATTR(hid4, 0600, show_hid4, store_hid4),
++	__ATTR(hid5, 0600, show_hid5, store_hid5),
++	__ATTR(ima0, 0600, show_ima0, store_ima0),
++	__ATTR(ima1, 0600, show_ima1, store_ima1),
++	__ATTR(ima2, 0600, show_ima2, store_ima2),
++	__ATTR(ima3, 0600, show_ima3, store_ima3),
++	__ATTR(ima4, 0600, show_ima4, store_ima4),
++	__ATTR(ima5, 0600, show_ima5, store_ima5),
++	__ATTR(ima6, 0600, show_ima6, store_ima6),
++	__ATTR(ima7, 0600, show_ima7, store_ima7),
++	__ATTR(ima8, 0600, show_ima8, store_ima8),
++	__ATTR(ima9, 0600, show_ima9, store_ima9),
++	__ATTR(imaat, 0600, show_imaat, store_imaat),
++	__ATTR(btcr, 0600, show_btcr, store_btcr),
++	__ATTR(pccr, 0600, show_pccr, store_pccr),
++	__ATTR(rpccr, 0600, show_rpccr, store_rpccr),
++	__ATTR(der, 0600, show_der, store_der),
++	__ATTR(mer, 0600, show_mer, store_mer),
++	__ATTR(ber, 0600, show_ber, store_ber),
++	__ATTR(ier, 0600, show_ier, store_ier),
++	__ATTR(sier, 0600, show_sier, store_sier),
++	__ATTR(siar, 0600, show_siar, store_siar),
++	__ATTR(tsr0, 0600, show_tsr0, store_tsr0),
++	__ATTR(tsr1, 0600, show_tsr1, store_tsr1),
++	__ATTR(tsr2, 0600, show_tsr2, store_tsr2),
++	__ATTR(tsr3, 0600, show_tsr3, store_tsr3),
+ #endif /* CONFIG_DEBUG_KERNEL */
+ };
+ #endif /* HAS_PPC_PMC_PA6T */
+@@ -333,14 +332,14 @@ static struct sysdev_attribute pa6t_attr
+ static void __cpuinit register_cpu_online(unsigned int cpu)
+ {
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
+-	struct sysdev_attribute *attrs, *pmc_attrs;
++	struct device *s = &c->dev;
++	struct device_attribute *attrs, *pmc_attrs;
+ 	int i, nattrs;
+ 
+ #ifdef CONFIG_PPC64
+ 	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
+ 			cpu_has_feature(CPU_FTR_SMT))
+-		sysdev_create_file(s, &attr_smt_snooze_delay);
++		device_create_file(s, &dev_attr_smt_snooze_delay);
+ #endif
+ 
+ 	/* PMC stuff */
+@@ -348,14 +347,14 @@ static void __cpuinit register_cpu_onlin
+ #ifdef HAS_PPC_PMC_IBM
+ 	case PPC_PMC_IBM:
+ 		attrs = ibm_common_attrs;
+-		nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(ibm_common_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = classic_pmc_attrs;
+ 		break;
+ #endif /* HAS_PPC_PMC_IBM */
+ #ifdef HAS_PPC_PMC_G4
+ 	case PPC_PMC_G4:
+ 		attrs = g4_common_attrs;
+-		nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(g4_common_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = classic_pmc_attrs;
+ 		break;
+ #endif /* HAS_PPC_PMC_G4 */
+@@ -363,7 +362,7 @@ static void __cpuinit register_cpu_onlin
+ 	case PPC_PMC_PA6T:
+ 		/* PA Semi starts counting at PMC0 */
+ 		attrs = pa6t_attrs;
+-		nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(pa6t_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = NULL;
+ 		break;
+ #endif /* HAS_PPC_PMC_PA6T */
+@@ -374,24 +373,24 @@ static void __cpuinit register_cpu_onlin
+ 	}
+ 
+ 	for (i = 0; i < nattrs; i++)
+-		sysdev_create_file(s, &attrs[i]);
++		device_create_file(s, &attrs[i]);
+ 
+ 	if (pmc_attrs)
+ 		for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
+-			sysdev_create_file(s, &pmc_attrs[i]);
++			device_create_file(s, &pmc_attrs[i]);
+ 
+ #ifdef CONFIG_PPC64
+ 	if (cpu_has_feature(CPU_FTR_MMCRA))
+-		sysdev_create_file(s, &attr_mmcra);
++		device_create_file(s, &dev_attr_mmcra);
+ 
+ 	if (cpu_has_feature(CPU_FTR_PURR))
+-		sysdev_create_file(s, &attr_purr);
++		device_create_file(s, &dev_attr_purr);
+ 
+ 	if (cpu_has_feature(CPU_FTR_SPURR))
+-		sysdev_create_file(s, &attr_spurr);
++		device_create_file(s, &dev_attr_spurr);
+ 
+ 	if (cpu_has_feature(CPU_FTR_DSCR))
+-		sysdev_create_file(s, &attr_dscr);
++		device_create_file(s, &dev_attr_dscr);
+ #endif /* CONFIG_PPC64 */
+ 
+ 	cacheinfo_cpu_online(cpu);
+@@ -401,8 +400,8 @@ static void __cpuinit register_cpu_onlin
+ static void unregister_cpu_online(unsigned int cpu)
+ {
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
+-	struct sysdev_attribute *attrs, *pmc_attrs;
++	struct device *s = &c->dev;
++	struct device_attribute *attrs, *pmc_attrs;
+ 	int i, nattrs;
+ 
+ 	BUG_ON(!c->hotpluggable);
+@@ -410,7 +409,7 @@ static void unregister_cpu_online(unsign
+ #ifdef CONFIG_PPC64
+ 	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
+ 			cpu_has_feature(CPU_FTR_SMT))
+-		sysdev_remove_file(s, &attr_smt_snooze_delay);
++		device_remove_file(s, &dev_attr_smt_snooze_delay);
+ #endif
+ 
+ 	/* PMC stuff */
+@@ -418,14 +417,14 @@ static void unregister_cpu_online(unsign
+ #ifdef HAS_PPC_PMC_IBM
+ 	case PPC_PMC_IBM:
+ 		attrs = ibm_common_attrs;
+-		nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(ibm_common_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = classic_pmc_attrs;
+ 		break;
+ #endif /* HAS_PPC_PMC_IBM */
+ #ifdef HAS_PPC_PMC_G4
+ 	case PPC_PMC_G4:
+ 		attrs = g4_common_attrs;
+-		nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(g4_common_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = classic_pmc_attrs;
+ 		break;
+ #endif /* HAS_PPC_PMC_G4 */
+@@ -433,7 +432,7 @@ static void unregister_cpu_online(unsign
+ 	case PPC_PMC_PA6T:
+ 		/* PA Semi starts counting at PMC0 */
+ 		attrs = pa6t_attrs;
+-		nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
++		nattrs = sizeof(pa6t_attrs) / sizeof(struct device_attribute);
+ 		pmc_attrs = NULL;
+ 		break;
+ #endif /* HAS_PPC_PMC_PA6T */
+@@ -444,24 +443,24 @@ static void unregister_cpu_online(unsign
+ 	}
+ 
+ 	for (i = 0; i < nattrs; i++)
+-		sysdev_remove_file(s, &attrs[i]);
++		device_remove_file(s, &attrs[i]);
+ 
+ 	if (pmc_attrs)
+ 		for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
+-			sysdev_remove_file(s, &pmc_attrs[i]);
++			device_remove_file(s, &pmc_attrs[i]);
+ 
+ #ifdef CONFIG_PPC64
+ 	if (cpu_has_feature(CPU_FTR_MMCRA))
+-		sysdev_remove_file(s, &attr_mmcra);
++		device_remove_file(s, &dev_attr_mmcra);
+ 
+ 	if (cpu_has_feature(CPU_FTR_PURR))
+-		sysdev_remove_file(s, &attr_purr);
++		device_remove_file(s, &dev_attr_purr);
+ 
+ 	if (cpu_has_feature(CPU_FTR_SPURR))
+-		sysdev_remove_file(s, &attr_spurr);
++		device_remove_file(s, &dev_attr_spurr);
+ 
+ 	if (cpu_has_feature(CPU_FTR_DSCR))
+-		sysdev_remove_file(s, &attr_dscr);
++		device_remove_file(s, &dev_attr_dscr);
+ #endif /* CONFIG_PPC64 */
+ 
+ 	cacheinfo_cpu_offline(cpu);
+@@ -513,70 +512,70 @@ static struct notifier_block __cpuinitda
+ 
+ static DEFINE_MUTEX(cpu_mutex);
+ 
+-int cpu_add_sysdev_attr(struct sysdev_attribute *attr)
++int cpu_add_dev_attr(struct device_attribute *attr)
+ {
+ 	int cpu;
+ 
+ 	mutex_lock(&cpu_mutex);
+ 
+ 	for_each_possible_cpu(cpu) {
+-		sysdev_create_file(get_cpu_sysdev(cpu), attr);
++		device_create_file(get_cpu_device(cpu), attr);
+ 	}
+ 
+ 	mutex_unlock(&cpu_mutex);
+ 	return 0;
+ }
+-EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr);
++EXPORT_SYMBOL_GPL(cpu_add_dev_attr);
+ 
+-int cpu_add_sysdev_attr_group(struct attribute_group *attrs)
++int cpu_add_dev_attr_group(struct attribute_group *attrs)
+ {
+ 	int cpu;
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 	int ret;
+ 
+ 	mutex_lock(&cpu_mutex);
+ 
+ 	for_each_possible_cpu(cpu) {
+-		sysdev = get_cpu_sysdev(cpu);
+-		ret = sysfs_create_group(&sysdev->kobj, attrs);
++		dev = get_cpu_device(cpu);
++		ret = sysfs_create_group(&dev->kobj, attrs);
+ 		WARN_ON(ret != 0);
+ 	}
+ 
+ 	mutex_unlock(&cpu_mutex);
+ 	return 0;
+ }
+-EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group);
++EXPORT_SYMBOL_GPL(cpu_add_dev_attr_group);
+ 
+ 
+-void cpu_remove_sysdev_attr(struct sysdev_attribute *attr)
++void cpu_remove_dev_attr(struct device_attribute *attr)
+ {
+ 	int cpu;
+ 
+ 	mutex_lock(&cpu_mutex);
+ 
+ 	for_each_possible_cpu(cpu) {
+-		sysdev_remove_file(get_cpu_sysdev(cpu), attr);
++		device_remove_file(get_cpu_device(cpu), attr);
+ 	}
+ 
+ 	mutex_unlock(&cpu_mutex);
+ }
+-EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr);
++EXPORT_SYMBOL_GPL(cpu_remove_dev_attr);
+ 
+-void cpu_remove_sysdev_attr_group(struct attribute_group *attrs)
++void cpu_remove_dev_attr_group(struct attribute_group *attrs)
+ {
+ 	int cpu;
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 
+ 	mutex_lock(&cpu_mutex);
+ 
+ 	for_each_possible_cpu(cpu) {
+-		sysdev = get_cpu_sysdev(cpu);
+-		sysfs_remove_group(&sysdev->kobj, attrs);
++		dev = get_cpu_device(cpu);
++		sysfs_remove_group(&dev->kobj, attrs);
+ 	}
+ 
+ 	mutex_unlock(&cpu_mutex);
+ }
+-EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group);
++EXPORT_SYMBOL_GPL(cpu_remove_dev_attr_group);
+ 
+ 
+ /* NUMA stuff */
+@@ -590,7 +589,7 @@ static void register_nodes(void)
+ 		register_one_node(i);
+ }
+ 
+-int sysfs_add_device_to_node(struct sys_device *dev, int nid)
++int sysfs_add_device_to_node(struct device *dev, int nid)
+ {
+ 	struct node *node = &node_devices[nid];
+ 	return sysfs_create_link(&node->sysdev.kobj, &dev->kobj,
+@@ -598,7 +597,7 @@ int sysfs_add_device_to_node(struct sys_
+ }
+ EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);
+ 
+-void sysfs_remove_device_from_node(struct sys_device *dev, int nid)
++void sysfs_remove_device_from_node(struct device *dev, int nid)
+ {
+ 	struct node *node = &node_devices[nid];
+ 	sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj));
+@@ -614,14 +613,14 @@ static void register_nodes(void)
+ #endif
+ 
+ /* Only valid if CPU is present. */
+-static ssize_t show_physical_id(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_physical_id(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, "%d\n", get_hard_smp_processor_id(cpu->sysdev.id));
++	return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->dev.id));
+ }
+-static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL);
++static DEVICE_ATTR(physical_id, 0444, show_physical_id, NULL);
+ 
+ static int __init topology_init(void)
+ {
+@@ -646,7 +645,7 @@ static int __init topology_init(void)
+ 		if (cpu_online(cpu) || c->hotpluggable) {
+ 			register_cpu(c, cpu);
+ 
+-			sysdev_create_file(&c->sysdev, &attr_physical_id);
++			device_create_file(&c->dev, &dev_attr_physical_id);
+ 		}
+ 
+ 		if (cpu_online(cpu))
+--- a/arch/powerpc/mm/numa.c
++++ b/arch/powerpc/mm/numa.c
+@@ -1462,7 +1462,7 @@ int arch_update_cpu_topology(void)
+ {
+ 	int cpu, nid, old_nid;
+ 	unsigned int associativity[VPHN_ASSOC_BUFSIZE] = {0};
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 
+ 	for_each_cpu(cpu,&cpu_associativity_changes_mask) {
+ 		vphn_get_associativity(cpu, associativity);
+@@ -1483,9 +1483,9 @@ int arch_update_cpu_topology(void)
+ 		register_cpu_under_node(cpu, nid);
+ 		put_online_cpus();
+ 
+-		sysdev = get_cpu_sysdev(cpu);
+-		if (sysdev)
+-			kobject_uevent(&sysdev->kobj, KOBJ_CHANGE);
++		dev = get_cpu_device(cpu);
++		if (dev)
++			kobject_uevent(&dev->kobj, KOBJ_CHANGE);
+ 	}
+ 
+ 	return 1;
+--- a/arch/powerpc/platforms/cell/cbe_thermal.c
++++ b/arch/powerpc/platforms/cell/cbe_thermal.c
+@@ -46,7 +46,7 @@
+  */
+ 
+ #include <linux/module.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/kernel.h>
+ #include <linux/cpu.h>
+ #include <asm/spu.h>
+@@ -59,8 +59,8 @@
+ #define TEMP_MIN 65
+ #define TEMP_MAX 125
+ 
+-#define SYSDEV_PREFIX_ATTR(_prefix,_name,_mode)			\
+-struct sysdev_attribute attr_ ## _prefix ## _ ## _name = {	\
++#define DEVICE_PREFIX_ATTR(_prefix,_name,_mode)			\
++struct device_attribute attr_ ## _prefix ## _ ## _name = {	\
+ 	.attr = { .name = __stringify(_name), .mode = _mode },	\
+ 	.show	= _prefix ## _show_ ## _name,			\
+ 	.store	= _prefix ## _store_ ## _name,			\
+@@ -76,36 +76,36 @@ static inline u8 temp_to_reg(u8 temp)
+ 	return ((temp - TEMP_MIN) >> 1) & 0x3f;
+ }
+ 
+-static struct cbe_pmd_regs __iomem *get_pmd_regs(struct sys_device *sysdev)
++static struct cbe_pmd_regs __iomem *get_pmd_regs(struct device *dev)
+ {
+ 	struct spu *spu;
+ 
+-	spu = container_of(sysdev, struct spu, sysdev);
++	spu = container_of(dev, struct spu, dev);
+ 
+ 	return cbe_get_pmd_regs(spu_devnode(spu));
+ }
+ 
+ /* returns the value for a given spu in a given register */
+-static u8 spu_read_register_value(struct sys_device *sysdev, union spe_reg __iomem *reg)
++static u8 spu_read_register_value(struct device *dev, union spe_reg __iomem *reg)
+ {
+ 	union spe_reg value;
+ 	struct spu *spu;
+ 
+-	spu = container_of(sysdev, struct spu, sysdev);
++	spu = container_of(dev, struct spu, dev);
+ 	value.val = in_be64(&reg->val);
+ 
+ 	return value.spe[spu->spe_id];
+ }
+ 
+-static ssize_t spu_show_temp(struct sys_device *sysdev, struct sysdev_attribute *attr,
++static ssize_t spu_show_temp(struct device *dev, struct device_attribute *attr,
+ 			char *buf)
+ {
+ 	u8 value;
+ 	struct cbe_pmd_regs __iomem *pmd_regs;
+ 
+-	pmd_regs = get_pmd_regs(sysdev);
++	pmd_regs = get_pmd_regs(dev);
+ 
+-	value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);
++	value = spu_read_register_value(dev, &pmd_regs->ts_ctsr1);
+ 
+ 	return sprintf(buf, "%d\n", reg_to_temp(value));
+ }
+@@ -147,48 +147,48 @@ static ssize_t store_throttle(struct cbe
+ 	return size;
+ }
+ 
+-static ssize_t spu_show_throttle_end(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t spu_show_throttle_end(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(get_pmd_regs(sysdev), buf, 0);
++	return show_throttle(get_pmd_regs(dev), buf, 0);
+ }
+ 
+-static ssize_t spu_show_throttle_begin(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t spu_show_throttle_begin(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(get_pmd_regs(sysdev), buf, 8);
++	return show_throttle(get_pmd_regs(dev), buf, 8);
+ }
+ 
+-static ssize_t spu_show_throttle_full_stop(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t spu_show_throttle_full_stop(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(get_pmd_regs(sysdev), buf, 16);
++	return show_throttle(get_pmd_regs(dev), buf, 16);
+ }
+ 
+-static ssize_t spu_store_throttle_end(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t spu_store_throttle_end(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(get_pmd_regs(sysdev), buf, size, 0);
++	return store_throttle(get_pmd_regs(dev), buf, size, 0);
+ }
+ 
+-static ssize_t spu_store_throttle_begin(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t spu_store_throttle_begin(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(get_pmd_regs(sysdev), buf, size, 8);
++	return store_throttle(get_pmd_regs(dev), buf, size, 8);
+ }
+ 
+-static ssize_t spu_store_throttle_full_stop(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t spu_store_throttle_full_stop(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(get_pmd_regs(sysdev), buf, size, 16);
++	return store_throttle(get_pmd_regs(dev), buf, size, 16);
+ }
+ 
+-static ssize_t ppe_show_temp(struct sys_device *sysdev, char *buf, int pos)
++static ssize_t ppe_show_temp(struct device *dev, char *buf, int pos)
+ {
+ 	struct cbe_pmd_regs __iomem *pmd_regs;
+ 	u64 value;
+ 
+-	pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
++	pmd_regs = cbe_get_cpu_pmd_regs(dev->id);
+ 	value = in_be64(&pmd_regs->ts_ctsr2);
+ 
+ 	value = (value >> pos) & 0x3f;
+@@ -199,71 +199,71 @@ static ssize_t ppe_show_temp(struct sys_
+ 
+ /* shows the temperature of the DTS on the PPE,
+  * located near the linear thermal sensor */
+-static ssize_t ppe_show_temp0(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t ppe_show_temp0(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return ppe_show_temp(sysdev, buf, 32);
++	return ppe_show_temp(dev, buf, 32);
+ }
+ 
+ /* shows the temperature of the second DTS on the PPE */
+-static ssize_t ppe_show_temp1(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t ppe_show_temp1(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return ppe_show_temp(sysdev, buf, 0);
++	return ppe_show_temp(dev, buf, 0);
+ }
+ 
+-static ssize_t ppe_show_throttle_end(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t ppe_show_throttle_end(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 32);
++	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 32);
+ }
+ 
+-static ssize_t ppe_show_throttle_begin(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t ppe_show_throttle_begin(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 40);
++	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 40);
+ }
+ 
+-static ssize_t ppe_show_throttle_full_stop(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, char *buf)
++static ssize_t ppe_show_throttle_full_stop(struct device *dev,
++			struct device_attribute *attr, char *buf)
+ {
+-	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 48);
++	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 48);
+ }
+ 
+-static ssize_t ppe_store_throttle_end(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t ppe_store_throttle_end(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 32);
++	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 32);
+ }
+ 
+-static ssize_t ppe_store_throttle_begin(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t ppe_store_throttle_begin(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 40);
++	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 40);
+ }
+ 
+-static ssize_t ppe_store_throttle_full_stop(struct sys_device *sysdev,
+-			struct sysdev_attribute *attr, const char *buf, size_t size)
++static ssize_t ppe_store_throttle_full_stop(struct device *dev,
++			struct device_attribute *attr, const char *buf, size_t size)
+ {
+-	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 48);
++	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 48);
+ }
+ 
+ 
+-static struct sysdev_attribute attr_spu_temperature = {
++static struct device_attribute dev_attr_spu_temperature = {
+ 	.attr = {.name = "temperature", .mode = 0400 },
+ 	.show = spu_show_temp,
+ };
+ 
+-static SYSDEV_PREFIX_ATTR(spu, throttle_end, 0600);
+-static SYSDEV_PREFIX_ATTR(spu, throttle_begin, 0600);
+-static SYSDEV_PREFIX_ATTR(spu, throttle_full_stop, 0600);
++static DEVICE_PREFIX_ATTR(spu, throttle_end, 0600);
++static DEVICE_PREFIX_ATTR(spu, throttle_begin, 0600);
++static DEVICE_PREFIX_ATTR(spu, throttle_full_stop, 0600);
+ 
+ 
+ static struct attribute *spu_attributes[] = {
+-	&attr_spu_temperature.attr,
+-	&attr_spu_throttle_end.attr,
+-	&attr_spu_throttle_begin.attr,
+-	&attr_spu_throttle_full_stop.attr,
++	&dev_attr_spu_temperature.attr,
++	&dev_attr_spu_throttle_end.attr,
++	&dev_attr_spu_throttle_begin.attr,
++	&dev_attr_spu_throttle_full_stop.attr,
+ 	NULL,
+ };
+ 
+@@ -272,26 +272,26 @@ static struct attribute_group spu_attrib
+ 	.attrs	= spu_attributes,
+ };
+ 
+-static struct sysdev_attribute attr_ppe_temperature0 = {
++static struct device_attribute dev_attr_ppe_temperature0 = {
+ 	.attr = {.name = "temperature0", .mode = 0400 },
+ 	.show = ppe_show_temp0,
+ };
+ 
+-static struct sysdev_attribute attr_ppe_temperature1 = {
++static struct device_attribute dev_attr_ppe_temperature1 = {
+ 	.attr = {.name = "temperature1", .mode = 0400 },
+ 	.show = ppe_show_temp1,
+ };
+ 
+-static SYSDEV_PREFIX_ATTR(ppe, throttle_end, 0600);
+-static SYSDEV_PREFIX_ATTR(ppe, throttle_begin, 0600);
+-static SYSDEV_PREFIX_ATTR(ppe, throttle_full_stop, 0600);
++static DEVICE_PREFIX_ATTR(ppe, throttle_end, 0600);
++static DEVICE_PREFIX_ATTR(ppe, throttle_begin, 0600);
++static DEVICE_PREFIX_ATTR(ppe, throttle_full_stop, 0600);
+ 
+ static struct attribute *ppe_attributes[] = {
+-	&attr_ppe_temperature0.attr,
+-	&attr_ppe_temperature1.attr,
+-	&attr_ppe_throttle_end.attr,
+-	&attr_ppe_throttle_begin.attr,
+-	&attr_ppe_throttle_full_stop.attr,
++	&dev_attr_ppe_temperature0.attr,
++	&dev_attr_ppe_temperature1.attr,
++	&dev_attr_ppe_throttle_end.attr,
++	&dev_attr_ppe_throttle_begin.attr,
++	&dev_attr_ppe_throttle_full_stop.attr,
+ 	NULL,
+ };
+ 
+@@ -307,7 +307,7 @@ static int __init init_default_values(vo
+ {
+ 	int cpu;
+ 	struct cbe_pmd_regs __iomem *pmd_regs;
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 	union ppe_spe_reg tpr;
+ 	union spe_reg str1;
+ 	u64 str2;
+@@ -349,14 +349,14 @@ static int __init init_default_values(vo
+ 
+ 	for_each_possible_cpu (cpu) {
+ 		pr_debug("processing cpu %d\n", cpu);
+-		sysdev = get_cpu_sysdev(cpu);
++		dev = get_cpu_device(cpu);
+ 
+-		if (!sysdev) {
+-			pr_info("invalid sysdev pointer for cbe_thermal\n");
++		if (!dev) {
++			pr_info("invalid dev pointer for cbe_thermal\n");
+ 			return -EINVAL;
+ 		}
+ 
+-		pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
++		pmd_regs = cbe_get_cpu_pmd_regs(dev->id);
+ 
+ 		if (!pmd_regs) {
+ 			pr_info("invalid CBE regs pointer for cbe_thermal\n");
+@@ -379,8 +379,8 @@ static int __init thermal_init(void)
+ 	int rc = init_default_values();
+ 
+ 	if (rc == 0) {
+-		spu_add_sysdev_attr_group(&spu_attribute_group);
+-		cpu_add_sysdev_attr_group(&ppe_attribute_group);
++		spu_add_dev_attr_group(&spu_attribute_group);
++		cpu_add_dev_attr_group(&ppe_attribute_group);
+ 	}
+ 
+ 	return rc;
+@@ -389,8 +389,8 @@ module_init(thermal_init);
+ 
+ static void __exit thermal_exit(void)
+ {
+-	spu_remove_sysdev_attr_group(&spu_attribute_group);
+-	cpu_remove_sysdev_attr_group(&ppe_attribute_group);
++	spu_remove_dev_attr_group(&spu_attribute_group);
++	cpu_remove_dev_attr_group(&ppe_attribute_group);
+ }
+ module_exit(thermal_exit);
+ 
+--- a/arch/powerpc/platforms/cell/spu_base.c
++++ b/arch/powerpc/platforms/cell/spu_base.c
+@@ -519,31 +519,32 @@ void spu_init_channels(struct spu *spu)
+ }
+ EXPORT_SYMBOL_GPL(spu_init_channels);
+ 
+-static struct sysdev_class spu_sysdev_class = {
++static struct bus_type spu_subsys = {
+ 	.name = "spu",
++	.dev_name = "spu",
+ };
+ 
+-int spu_add_sysdev_attr(struct sysdev_attribute *attr)
++int spu_add_dev_attr(struct device_attribute *attr)
+ {
+ 	struct spu *spu;
+ 
+ 	mutex_lock(&spu_full_list_mutex);
+ 	list_for_each_entry(spu, &spu_full_list, full_list)
+-		sysdev_create_file(&spu->sysdev, attr);
++		device_create_file(&spu->dev, attr);
+ 	mutex_unlock(&spu_full_list_mutex);
+ 
+ 	return 0;
+ }
+-EXPORT_SYMBOL_GPL(spu_add_sysdev_attr);
++EXPORT_SYMBOL_GPL(spu_add_dev_attr);
+ 
+-int spu_add_sysdev_attr_group(struct attribute_group *attrs)
++int spu_add_dev_attr_group(struct attribute_group *attrs)
+ {
+ 	struct spu *spu;
+ 	int rc = 0;
+ 
+ 	mutex_lock(&spu_full_list_mutex);
+ 	list_for_each_entry(spu, &spu_full_list, full_list) {
+-		rc = sysfs_create_group(&spu->sysdev.kobj, attrs);
++		rc = sysfs_create_group(&spu->dev.kobj, attrs);
+ 
+ 		/* we're in trouble here, but try unwinding anyway */
+ 		if (rc) {
+@@ -552,7 +553,7 @@ int spu_add_sysdev_attr_group(struct att
+ 
+ 			list_for_each_entry_continue_reverse(spu,
+ 					&spu_full_list, full_list)
+-				sysfs_remove_group(&spu->sysdev.kobj, attrs);
++				sysfs_remove_group(&spu->dev.kobj, attrs);
+ 			break;
+ 		}
+ 	}
+@@ -561,45 +562,45 @@ int spu_add_sysdev_attr_group(struct att
+ 
+ 	return rc;
+ }
+-EXPORT_SYMBOL_GPL(spu_add_sysdev_attr_group);
++EXPORT_SYMBOL_GPL(spu_add_dev_attr_group);
+ 
+ 
+-void spu_remove_sysdev_attr(struct sysdev_attribute *attr)
++void spu_remove_dev_attr(struct device_attribute *attr)
+ {
+ 	struct spu *spu;
+ 
+ 	mutex_lock(&spu_full_list_mutex);
+ 	list_for_each_entry(spu, &spu_full_list, full_list)
+-		sysdev_remove_file(&spu->sysdev, attr);
++		device_remove_file(&spu->dev, attr);
+ 	mutex_unlock(&spu_full_list_mutex);
+ }
+-EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr);
++EXPORT_SYMBOL_GPL(spu_remove_dev_attr);
+ 
+-void spu_remove_sysdev_attr_group(struct attribute_group *attrs)
++void spu_remove_dev_attr_group(struct attribute_group *attrs)
+ {
+ 	struct spu *spu;
+ 
+ 	mutex_lock(&spu_full_list_mutex);
+ 	list_for_each_entry(spu, &spu_full_list, full_list)
+-		sysfs_remove_group(&spu->sysdev.kobj, attrs);
++		sysfs_remove_group(&spu->dev.kobj, attrs);
+ 	mutex_unlock(&spu_full_list_mutex);
+ }
+-EXPORT_SYMBOL_GPL(spu_remove_sysdev_attr_group);
++EXPORT_SYMBOL_GPL(spu_remove_dev_attr_group);
+ 
+-static int spu_create_sysdev(struct spu *spu)
++static int spu_create_dev(struct spu *spu)
+ {
+ 	int ret;
+ 
+-	spu->sysdev.id = spu->number;
+-	spu->sysdev.cls = &spu_sysdev_class;
+-	ret = sysdev_register(&spu->sysdev);
++	spu->dev.id = spu->number;
++	spu->dev.bus = &spu_subsys;
++	ret = device_register(&spu->dev);
+ 	if (ret) {
+ 		printk(KERN_ERR "Can't register SPU %d with sysfs\n",
+ 				spu->number);
+ 		return ret;
+ 	}
+ 
+-	sysfs_add_device_to_node(&spu->sysdev, spu->node);
++	sysfs_add_device_to_node(&spu->dev, spu->node);
+ 
+ 	return 0;
+ }
+@@ -635,7 +636,7 @@ static int __init create_spu(void *data)
+ 	if (ret)
+ 		goto out_destroy;
+ 
+-	ret = spu_create_sysdev(spu);
++	ret = spu_create_dev(spu);
+ 	if (ret)
+ 		goto out_free_irqs;
+ 
+@@ -692,10 +693,10 @@ static unsigned long long spu_acct_time(
+ }
+ 
+ 
+-static ssize_t spu_stat_show(struct sys_device *sysdev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t spu_stat_show(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+-	struct spu *spu = container_of(sysdev, struct spu, sysdev);
++	struct spu *spu = container_of(dev, struct spu, dev);
+ 
+ 	return sprintf(buf, "%s %llu %llu %llu %llu "
+ 		      "%llu %llu %llu %llu %llu %llu %llu %llu\n",
+@@ -714,7 +715,7 @@ static ssize_t spu_stat_show(struct sys_
+ 		spu->stats.libassist);
+ }
+ 
+-static SYSDEV_ATTR(stat, 0644, spu_stat_show, NULL);
++static DEVICE_ATTR(stat, 0644, spu_stat_show, NULL);
+ 
+ #ifdef CONFIG_KEXEC
+ 
+@@ -813,8 +814,8 @@ static int __init init_spu_base(void)
+ 	if (!spu_management_ops)
+ 		goto out;
+ 
+-	/* create sysdev class for spus */
+-	ret = sysdev_class_register(&spu_sysdev_class);
++	/* create system subsystem for spus */
++	ret = subsys_system_register(&spu_subsys, NULL);
+ 	if (ret)
+ 		goto out;
+ 
+@@ -823,7 +824,7 @@ static int __init init_spu_base(void)
+ 	if (ret < 0) {
+ 		printk(KERN_WARNING "%s: Error initializing spus\n",
+ 			__func__);
+-		goto out_unregister_sysdev_class;
++		goto out_unregister_subsys;
+ 	}
+ 
+ 	if (ret > 0)
+@@ -833,15 +834,15 @@ static int __init init_spu_base(void)
+ 	xmon_register_spus(&spu_full_list);
+ 	crash_register_spus(&spu_full_list);
+ 	mutex_unlock(&spu_full_list_mutex);
+-	spu_add_sysdev_attr(&attr_stat);
++	spu_add_dev_attr(&dev_attr_stat);
+ 	register_syscore_ops(&spu_syscore_ops);
+ 
+ 	spu_init_affinity();
+ 
+ 	return 0;
+ 
+- out_unregister_sysdev_class:
+-	sysdev_class_unregister(&spu_sysdev_class);
++ out_unregister_subsys:
++	bus_unregister(&spu_subsys);
+  out:
+ 	return ret;
+ }
+--- a/arch/powerpc/platforms/pseries/pseries_energy.c
++++ b/arch/powerpc/platforms/pseries/pseries_energy.c
+@@ -15,7 +15,7 @@
+ #include <linux/errno.h>
+ #include <linux/init.h>
+ #include <linux/seq_file.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/cpu.h>
+ #include <linux/of.h>
+ #include <asm/cputhreads.h>
+@@ -184,7 +184,7 @@ static ssize_t get_best_energy_list(char
+ 	return s-page;
+ }
+ 
+-static ssize_t get_best_energy_data(struct sys_device *dev,
++static ssize_t get_best_energy_data(struct device *dev,
+ 					char *page, int activate)
+ {
+ 	int rc;
+@@ -207,26 +207,26 @@ static ssize_t get_best_energy_data(stru
+ 
+ /* Wrapper functions */
+ 
+-static ssize_t cpu_activate_hint_list_show(struct sysdev_class *class,
+-			struct sysdev_class_attribute *attr, char *page)
++static ssize_t cpu_activate_hint_list_show(struct device *dev,
++			struct device_attribute *attr, char *page)
+ {
+ 	return get_best_energy_list(page, 1);
+ }
+ 
+-static ssize_t cpu_deactivate_hint_list_show(struct sysdev_class *class,
+-			struct sysdev_class_attribute *attr, char *page)
++static ssize_t cpu_deactivate_hint_list_show(struct device *dev,
++			struct device_attribute *attr, char *page)
+ {
+ 	return get_best_energy_list(page, 0);
+ }
+ 
+-static ssize_t percpu_activate_hint_show(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *page)
++static ssize_t percpu_activate_hint_show(struct device *dev,
++			struct device_attribute *attr, char *page)
+ {
+ 	return get_best_energy_data(dev, page, 1);
+ }
+ 
+-static ssize_t percpu_deactivate_hint_show(struct sys_device *dev,
+-			struct sysdev_attribute *attr, char *page)
++static ssize_t percpu_deactivate_hint_show(struct device *dev,
++			struct device_attribute *attr, char *page)
+ {
+ 	return get_best_energy_data(dev, page, 0);
+ }
+@@ -241,47 +241,47 @@ static ssize_t percpu_deactivate_hint_sh
+  *	Per-cpu value of the hint
+  */
+ 
+-struct sysdev_class_attribute attr_cpu_activate_hint_list =
+-		_SYSDEV_CLASS_ATTR(pseries_activate_hint_list, 0444,
++struct device_attribute attr_cpu_activate_hint_list =
++		__ATTR(pseries_activate_hint_list, 0444,
+ 		cpu_activate_hint_list_show, NULL);
+ 
+-struct sysdev_class_attribute attr_cpu_deactivate_hint_list =
+-		_SYSDEV_CLASS_ATTR(pseries_deactivate_hint_list, 0444,
++struct device_attribute attr_cpu_deactivate_hint_list =
++		__ATTR(pseries_deactivate_hint_list, 0444,
+ 		cpu_deactivate_hint_list_show, NULL);
+ 
+-struct sysdev_attribute attr_percpu_activate_hint =
+-		_SYSDEV_ATTR(pseries_activate_hint, 0444,
++struct device_attribute attr_percpu_activate_hint =
++		__ATTR(pseries_activate_hint, 0444,
+ 		percpu_activate_hint_show, NULL);
+ 
+-struct sysdev_attribute attr_percpu_deactivate_hint =
+-		_SYSDEV_ATTR(pseries_deactivate_hint, 0444,
++struct device_attribute attr_percpu_deactivate_hint =
++		__ATTR(pseries_deactivate_hint, 0444,
+ 		percpu_deactivate_hint_show, NULL);
+ 
+ static int __init pseries_energy_init(void)
+ {
+ 	int cpu, err;
+-	struct sys_device *cpu_sys_dev;
++	struct device *cpu_dev;
+ 
+ 	if (!check_for_h_best_energy()) {
+ 		printk(KERN_INFO "Hypercall H_BEST_ENERGY not supported\n");
+ 		return 0;
+ 	}
+ 	/* Create the sysfs files */
+-	err = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
+-				&attr_cpu_activate_hint_list.attr);
++	err = sysfs_create_file(cpu_subsys.dev_root,
++				&attr_cpu_activate_hint_list);
+ 	if (!err)
+-		err = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
+-				&attr_cpu_deactivate_hint_list.attr);
++		err = sysfs_create_file(cpu_subsys.dev_root,
++				&attr_cpu_deactivate_hint_list);
+ 
+ 	if (err)
+ 		return err;
+ 	for_each_possible_cpu(cpu) {
+-		cpu_sys_dev = get_cpu_sysdev(cpu);
+-		err = sysfs_create_file(&cpu_sys_dev->kobj,
++		cpu_dev = get_cpu_device(cpu);
++		err = sysfs_create_file(&cpu_dev->kobj,
+ 				&attr_percpu_activate_hint.attr);
+ 		if (err)
+ 			break;
+-		err = sysfs_create_file(&cpu_sys_dev->kobj,
++		err = sysfs_create_file(&cpu_dev->kobj,
+ 				&attr_percpu_deactivate_hint.attr);
+ 		if (err)
+ 			break;
+@@ -298,23 +298,20 @@ static int __init pseries_energy_init(vo
+ static void __exit pseries_energy_cleanup(void)
+ {
+ 	int cpu;
+-	struct sys_device *cpu_sys_dev;
++	struct device *cpu_dev;
+ 
+ 	if (!sysfs_entries)
+ 		return;
+ 
+ 	/* Remove the sysfs files */
+-	sysfs_remove_file(&cpu_sysdev_class.kset.kobj,
+-				&attr_cpu_activate_hint_list.attr);
+-
+-	sysfs_remove_file(&cpu_sysdev_class.kset.kobj,
+-				&attr_cpu_deactivate_hint_list.attr);
++	sysfs_remove_file(cpu_subsys.dev_root, &attr_cpu_activate_hint_list);
++	sysfs_remove_file(cpu_subsys.dev_root, &attr_cpu_deactivate_hint_list);
+ 
+ 	for_each_possible_cpu(cpu) {
+-		cpu_sys_dev = get_cpu_sysdev(cpu);
+-		sysfs_remove_file(&cpu_sys_dev->kobj,
++		cpu_dev = get_cpu_device(cpu);
++		sysfs_remove_file(&cpu_dev->kobj,
+ 				&attr_percpu_activate_hint.attr);
+-		sysfs_remove_file(&cpu_sys_dev->kobj,
++		sysfs_remove_file(&cpu_dev->kobj,
+ 				&attr_percpu_deactivate_hint.attr);
+ 	}
+ }
+--- a/arch/powerpc/sysdev/ppc4xx_cpm.c
++++ b/arch/powerpc/sysdev/ppc4xx_cpm.c
+@@ -179,12 +179,12 @@ static struct kobj_attribute cpm_idle_at
+ 
+ static void cpm_idle_config_sysfs(void)
+ {
+-	struct sys_device *sys_dev;
++	struct device *dev;
+ 	unsigned long ret;
+ 
+-	sys_dev = get_cpu_sysdev(0);
++	dev = get_cpu_device(0);
+ 
+-	ret = sysfs_create_file(&sys_dev->kobj,
++	ret = sysfs_create_file(&dev->kobj,
+ 				&cpm_idle_attr.attr);
+ 	if (ret)
+ 		printk(KERN_WARNING
+--- a/arch/s390/kernel/smp.c
++++ b/arch/s390/kernel/smp.c
+@@ -831,8 +831,8 @@ int setup_profiling_timer(unsigned int m
+ }
+ 
+ #ifdef CONFIG_HOTPLUG_CPU
+-static ssize_t cpu_configure_show(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t cpu_configure_show(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	ssize_t count;
+ 
+@@ -842,8 +842,8 @@ static ssize_t cpu_configure_show(struct
+ 	return count;
+ }
+ 
+-static ssize_t cpu_configure_store(struct sys_device *dev,
+-				  struct sysdev_attribute *attr,
++static ssize_t cpu_configure_store(struct device *dev,
++				  struct device_attribute *attr,
+ 				  const char *buf, size_t count)
+ {
+ 	int cpu = dev->id;
+@@ -889,11 +889,11 @@ out:
+ 	put_online_cpus();
+ 	return rc ? rc : count;
+ }
+-static SYSDEV_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store);
++static DEVICE_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store);
+ #endif /* CONFIG_HOTPLUG_CPU */
+ 
+-static ssize_t cpu_polarization_show(struct sys_device *dev,
+-				     struct sysdev_attribute *attr, char *buf)
++static ssize_t cpu_polarization_show(struct device *dev,
++				     struct device_attribute *attr, char *buf)
+ {
+ 	int cpu = dev->id;
+ 	ssize_t count;
+@@ -919,22 +919,22 @@ static ssize_t cpu_polarization_show(str
+ 	mutex_unlock(&smp_cpu_state_mutex);
+ 	return count;
+ }
+-static SYSDEV_ATTR(polarization, 0444, cpu_polarization_show, NULL);
++static DEVICE_ATTR(polarization, 0444, cpu_polarization_show, NULL);
+ 
+-static ssize_t show_cpu_address(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_cpu_address(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	return sprintf(buf, "%d\n", __cpu_logical_map[dev->id]);
+ }
+-static SYSDEV_ATTR(address, 0444, show_cpu_address, NULL);
++static DEVICE_ATTR(address, 0444, show_cpu_address, NULL);
+ 
+ 
+ static struct attribute *cpu_common_attrs[] = {
+ #ifdef CONFIG_HOTPLUG_CPU
+-	&attr_configure.attr,
++	&dev_attr_configure.attr,
+ #endif
+-	&attr_address.attr,
+-	&attr_polarization.attr,
++	&dev_attr_address.attr,
++	&dev_attr_polarization.attr,
+ 	NULL,
+ };
+ 
+@@ -942,8 +942,8 @@ static struct attribute_group cpu_common
+ 	.attrs = cpu_common_attrs,
+ };
+ 
+-static ssize_t show_capability(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_capability(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	unsigned int capability;
+ 	int rc;
+@@ -953,10 +953,10 @@ static ssize_t show_capability(struct sy
+ 		return rc;
+ 	return sprintf(buf, "%u\n", capability);
+ }
+-static SYSDEV_ATTR(capability, 0444, show_capability, NULL);
++static DEVICE_ATTR(capability, 0444, show_capability, NULL);
+ 
+-static ssize_t show_idle_count(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_idle_count(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	struct s390_idle_data *idle;
+ 	unsigned long long idle_count;
+@@ -976,10 +976,10 @@ repeat:
+ 		goto repeat;
+ 	return sprintf(buf, "%llu\n", idle_count);
+ }
+-static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL);
++static DEVICE_ATTR(idle_count, 0444, show_idle_count, NULL);
+ 
+-static ssize_t show_idle_time(struct sys_device *dev,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_idle_time(struct device *dev,
++				struct device_attribute *attr, char *buf)
+ {
+ 	struct s390_idle_data *idle;
+ 	unsigned long long now, idle_time, idle_enter;
+@@ -1001,12 +1001,12 @@ repeat:
+ 		goto repeat;
+ 	return sprintf(buf, "%llu\n", idle_time >> 12);
+ }
+-static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL);
++static DEVICE_ATTR(idle_time_us, 0444, show_idle_time, NULL);
+ 
+ static struct attribute *cpu_online_attrs[] = {
+-	&attr_capability.attr,
+-	&attr_idle_count.attr,
+-	&attr_idle_time_us.attr,
++	&dev_attr_capability.attr,
++	&dev_attr_idle_count.attr,
++	&dev_attr_idle_time_us.attr,
+ 	NULL,
+ };
+ 
+@@ -1019,7 +1019,7 @@ static int __cpuinit smp_cpu_notify(stru
+ {
+ 	unsigned int cpu = (unsigned int)(long)hcpu;
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
++	struct device *s = &c->dev;
+ 	struct s390_idle_data *idle;
+ 	int err = 0;
+ 
+@@ -1045,7 +1045,7 @@ static struct notifier_block __cpuinitda
+ static int __devinit smp_add_present_cpu(int cpu)
+ {
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
++	struct device *s = &c->dev;
+ 	int rc;
+ 
+ 	c->hotpluggable = 1;
+@@ -1098,8 +1098,8 @@ out:
+ 	return rc;
+ }
+ 
+-static ssize_t __ref rescan_store(struct sysdev_class *class,
+-				  struct sysdev_class_attribute *attr,
++static ssize_t __ref rescan_store(struct device *dev,
++				  struct device_attribute *attr,
+ 				  const char *buf,
+ 				  size_t count)
+ {
+@@ -1108,11 +1108,11 @@ static ssize_t __ref rescan_store(struct
+ 	rc = smp_rescan_cpus();
+ 	return rc ? rc : count;
+ }
+-static SYSDEV_CLASS_ATTR(rescan, 0200, NULL, rescan_store);
++static DEVICE_ATTR(rescan, 0200, NULL, rescan_store);
+ #endif /* CONFIG_HOTPLUG_CPU */
+ 
+-static ssize_t dispatching_show(struct sysdev_class *class,
+-				struct sysdev_class_attribute *attr,
++static ssize_t dispatching_show(struct device *dev,
++				struct device_attribute *attr,
+ 				char *buf)
+ {
+ 	ssize_t count;
+@@ -1123,8 +1123,8 @@ static ssize_t dispatching_show(struct s
+ 	return count;
+ }
+ 
+-static ssize_t dispatching_store(struct sysdev_class *dev,
+-				 struct sysdev_class_attribute *attr,
++static ssize_t dispatching_store(struct device *dev,
++				 struct device_attribute *attr,
+ 				 const char *buf,
+ 				 size_t count)
+ {
+@@ -1148,7 +1148,7 @@ out:
+ 	put_online_cpus();
+ 	return rc ? rc : count;
+ }
+-static SYSDEV_CLASS_ATTR(dispatching, 0644, dispatching_show,
++static DEVICE_ATTR(dispatching, 0644, dispatching_show,
+ 			 dispatching_store);
+ 
+ static int __init topology_init(void)
+@@ -1159,11 +1159,11 @@ static int __init topology_init(void)
+ 	register_cpu_notifier(&smp_cpu_nb);
+ 
+ #ifdef CONFIG_HOTPLUG_CPU
+-	rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_rescan);
++	rc = device_create_file(cpu_subsys.dev_root, &dev_attr_rescan);
+ 	if (rc)
+ 		return rc;
+ #endif
+-	rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_dispatching);
++	rc = device_create_file(cpu_subsys.dev_root, &dev_attr_dispatching);
+ 	if (rc)
+ 		return rc;
+ 	for_each_present_cpu(cpu) {
+--- a/arch/s390/kernel/topology.c
++++ b/arch/s390/kernel/topology.c
+@@ -261,7 +261,7 @@ void store_topology(struct sysinfo_15_1_
+ int arch_update_cpu_topology(void)
+ {
+ 	struct sysinfo_15_1_x *info = tl_info;
+-	struct sys_device *sysdev;
++	struct device *dev;
+ 	int cpu;
+ 
+ 	if (!MACHINE_HAS_TOPOLOGY) {
+@@ -273,8 +273,8 @@ int arch_update_cpu_topology(void)
+ 	tl_to_cores(info);
+ 	update_cpu_core_map();
+ 	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);
+ 	}
+ 	return 1;
+ }
+--- a/arch/sh/kernel/cpu/sh4/sq.c
++++ b/arch/sh/kernel/cpu/sh4/sq.c
+@@ -13,7 +13,7 @@
+ #include <linux/init.h>
+ #include <linux/cpu.h>
+ #include <linux/bitmap.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/slab.h>
+@@ -337,9 +337,9 @@ static struct kobj_type ktype_percpu_ent
+ 	.default_attrs	= sq_sysfs_attrs,
+ };
+ 
+-static int __devinit sq_sysdev_add(struct sys_device *sysdev)
++static int __devinit sq_dev_add(struct device *dev)
+ {
+-	unsigned int cpu = sysdev->id;
++	unsigned int cpu = dev->id;
+ 	struct kobject *kobj;
+ 	int error;
+ 
+@@ -348,25 +348,27 @@ static int __devinit sq_sysdev_add(struc
+ 		return -ENOMEM;
+ 
+ 	kobj = sq_kobject[cpu];
+-	error = kobject_init_and_add(kobj, &ktype_percpu_entry, &sysdev->kobj,
++	error = kobject_init_and_add(kobj, &ktype_percpu_entry, &dev->kobj,
+ 				     "%s", "sq");
+ 	if (!error)
+ 		kobject_uevent(kobj, KOBJ_ADD);
+ 	return error;
+ }
+ 
+-static int __devexit sq_sysdev_remove(struct sys_device *sysdev)
++static int __devexit sq_dev_remove(struct device *dev)
+ {
+-	unsigned int cpu = sysdev->id;
++	unsigned int cpu = dev->id;
+ 	struct kobject *kobj = sq_kobject[cpu];
+ 
+ 	kobject_put(kobj);
+ 	return 0;
+ }
+ 
+-static struct sysdev_driver sq_sysdev_driver = {
+-	.add		= sq_sysdev_add,
+-	.remove		= __devexit_p(sq_sysdev_remove),
++static struct subsys_interface sq_interface = {
++	.name		= "sq"
++	.subsys		= &cpu_subsys,
++	.add		= sq_dev_add,
++	.remove		= __devexit_p(sq_dev_remove),
+ };
+ 
+ static int __init sq_api_init(void)
+@@ -386,7 +388,7 @@ static int __init sq_api_init(void)
+ 	if (unlikely(!sq_bitmap))
+ 		goto out;
+ 
+-	ret = sysdev_driver_register(&cpu_sysdev_class, &sq_sysdev_driver);
++	ret = subsys_interface_register(&sq_interface);
+ 	if (unlikely(ret != 0))
+ 		goto out;
+ 
+@@ -401,7 +403,7 @@ out:
+ 
+ static void __exit sq_api_exit(void)
+ {
+-	sysdev_driver_unregister(&cpu_sysdev_class, &sq_sysdev_driver);
++	subsys_interface_unregister(&sq_interface);
+ 	kfree(sq_bitmap);
+ 	kmem_cache_destroy(sq_cache);
+ }
+--- a/arch/sparc/kernel/sysfs.c
++++ b/arch/sparc/kernel/sysfs.c
+@@ -3,7 +3,7 @@
+  * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
+  */
+ #include <linux/sched.h>
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/cpu.h>
+ #include <linux/smp.h>
+ #include <linux/percpu.h>
+@@ -16,13 +16,13 @@
+ static DEFINE_PER_CPU(struct hv_mmu_statistics, mmu_stats) __attribute__((aligned(64)));
+ 
+ #define SHOW_MMUSTAT_ULONG(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) \
+ { \
+ 	struct hv_mmu_statistics *p = &per_cpu(mmu_stats, dev->id); \
+ 	return sprintf(buf, "%lu\n", p->NAME); \
+ } \
+-static SYSDEV_ATTR(NAME, 0444, show_##NAME, NULL)
++static DEVICE_ATTR(NAME, 0444, show_##NAME, NULL)
+ 
+ SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctx0_8k_tte);
+ SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctx0_8k_tte);
+@@ -58,38 +58,38 @@ SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctxnon0
+ SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctxnon0_256mb_tte);
+ 
+ static struct attribute *mmu_stat_attrs[] = {
+-	&attr_immu_tsb_hits_ctx0_8k_tte.attr,
+-	&attr_immu_tsb_ticks_ctx0_8k_tte.attr,
+-	&attr_immu_tsb_hits_ctx0_64k_tte.attr,
+-	&attr_immu_tsb_ticks_ctx0_64k_tte.attr,
+-	&attr_immu_tsb_hits_ctx0_4mb_tte.attr,
+-	&attr_immu_tsb_ticks_ctx0_4mb_tte.attr,
+-	&attr_immu_tsb_hits_ctx0_256mb_tte.attr,
+-	&attr_immu_tsb_ticks_ctx0_256mb_tte.attr,
+-	&attr_immu_tsb_hits_ctxnon0_8k_tte.attr,
+-	&attr_immu_tsb_ticks_ctxnon0_8k_tte.attr,
+-	&attr_immu_tsb_hits_ctxnon0_64k_tte.attr,
+-	&attr_immu_tsb_ticks_ctxnon0_64k_tte.attr,
+-	&attr_immu_tsb_hits_ctxnon0_4mb_tte.attr,
+-	&attr_immu_tsb_ticks_ctxnon0_4mb_tte.attr,
+-	&attr_immu_tsb_hits_ctxnon0_256mb_tte.attr,
+-	&attr_immu_tsb_ticks_ctxnon0_256mb_tte.attr,
+-	&attr_dmmu_tsb_hits_ctx0_8k_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctx0_8k_tte.attr,
+-	&attr_dmmu_tsb_hits_ctx0_64k_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctx0_64k_tte.attr,
+-	&attr_dmmu_tsb_hits_ctx0_4mb_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctx0_4mb_tte.attr,
+-	&attr_dmmu_tsb_hits_ctx0_256mb_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctx0_256mb_tte.attr,
+-	&attr_dmmu_tsb_hits_ctxnon0_8k_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctxnon0_8k_tte.attr,
+-	&attr_dmmu_tsb_hits_ctxnon0_64k_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctxnon0_64k_tte.attr,
+-	&attr_dmmu_tsb_hits_ctxnon0_4mb_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctxnon0_4mb_tte.attr,
+-	&attr_dmmu_tsb_hits_ctxnon0_256mb_tte.attr,
+-	&attr_dmmu_tsb_ticks_ctxnon0_256mb_tte.attr,
++	&dev_attr_immu_tsb_hits_ctx0_8k_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctx0_8k_tte.attr,
++	&dev_attr_immu_tsb_hits_ctx0_64k_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctx0_64k_tte.attr,
++	&dev_attr_immu_tsb_hits_ctx0_4mb_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctx0_4mb_tte.attr,
++	&dev_attr_immu_tsb_hits_ctx0_256mb_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctx0_256mb_tte.attr,
++	&dev_attr_immu_tsb_hits_ctxnon0_8k_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctxnon0_8k_tte.attr,
++	&dev_attr_immu_tsb_hits_ctxnon0_64k_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctxnon0_64k_tte.attr,
++	&dev_attr_immu_tsb_hits_ctxnon0_4mb_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctxnon0_4mb_tte.attr,
++	&dev_attr_immu_tsb_hits_ctxnon0_256mb_tte.attr,
++	&dev_attr_immu_tsb_ticks_ctxnon0_256mb_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctx0_8k_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctx0_8k_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctx0_64k_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctx0_64k_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctx0_4mb_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctx0_4mb_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctx0_256mb_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctx0_256mb_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctxnon0_8k_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctxnon0_8k_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctxnon0_64k_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctxnon0_64k_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctxnon0_4mb_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctxnon0_4mb_tte.attr,
++	&dev_attr_dmmu_tsb_hits_ctxnon0_256mb_tte.attr,
++	&dev_attr_dmmu_tsb_ticks_ctxnon0_256mb_tte.attr,
+ 	NULL,
+ };
+ 
+@@ -139,15 +139,15 @@ static unsigned long write_mmustat_enabl
+ 	return sun4v_mmustat_conf(ra, &orig_ra);
+ }
+ 
+-static ssize_t show_mmustat_enable(struct sys_device *s,
+-				struct sysdev_attribute *attr, char *buf)
++static ssize_t show_mmustat_enable(struct device *s,
++				struct device_attribute *attr, char *buf)
+ {
+ 	unsigned long val = run_on_cpu(s->id, read_mmustat_enable, 0);
+ 	return sprintf(buf, "%lx\n", val);
+ }
+ 
+-static ssize_t store_mmustat_enable(struct sys_device *s,
+-			struct sysdev_attribute *attr, const char *buf,
++static ssize_t store_mmustat_enable(struct device *s,
++			struct device_attribute *attr, const char *buf,
+ 			size_t count)
+ {
+ 	unsigned long val, err;
+@@ -163,39 +163,39 @@ static ssize_t store_mmustat_enable(stru
+ 	return count;
+ }
+ 
+-static SYSDEV_ATTR(mmustat_enable, 0644, show_mmustat_enable, store_mmustat_enable);
++static DEVICE_ATTR(mmustat_enable, 0644, show_mmustat_enable, store_mmustat_enable);
+ 
+ static int mmu_stats_supported;
+ 
+-static int register_mmu_stats(struct sys_device *s)
++static int register_mmu_stats(struct device *s)
+ {
+ 	if (!mmu_stats_supported)
+ 		return 0;
+-	sysdev_create_file(s, &attr_mmustat_enable);
++	device_create_file(s, &dev_attr_mmustat_enable);
+ 	return sysfs_create_group(&s->kobj, &mmu_stat_group);
+ }
+ 
+ #ifdef CONFIG_HOTPLUG_CPU
+-static void unregister_mmu_stats(struct sys_device *s)
++static void unregister_mmu_stats(struct device *s)
+ {
+ 	if (!mmu_stats_supported)
+ 		return;
+ 	sysfs_remove_group(&s->kobj, &mmu_stat_group);
+-	sysdev_remove_file(s, &attr_mmustat_enable);
++	device_remove_file(s, &dev_attr_mmustat_enable);
+ }
+ #endif
+ 
+ #define SHOW_CPUDATA_ULONG_NAME(NAME, MEMBER) \
+-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) \
+ { \
+ 	cpuinfo_sparc *c = &cpu_data(dev->id); \
+ 	return sprintf(buf, "%lu\n", c->MEMBER); \
+ }
+ 
+ #define SHOW_CPUDATA_UINT_NAME(NAME, MEMBER) \
+-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) \
+ { \
+ 	cpuinfo_sparc *c = &cpu_data(dev->id); \
+ 	return sprintf(buf, "%u\n", c->MEMBER); \
+@@ -209,14 +209,14 @@ SHOW_CPUDATA_UINT_NAME(l1_icache_line_si
+ SHOW_CPUDATA_UINT_NAME(l2_cache_size, ecache_size);
+ SHOW_CPUDATA_UINT_NAME(l2_cache_line_size, ecache_line_size);
+ 
+-static struct sysdev_attribute cpu_core_attrs[] = {
+-	_SYSDEV_ATTR(clock_tick,          0444, show_clock_tick, NULL),
+-	_SYSDEV_ATTR(l1_dcache_size,      0444, show_l1_dcache_size, NULL),
+-	_SYSDEV_ATTR(l1_dcache_line_size, 0444, show_l1_dcache_line_size, NULL),
+-	_SYSDEV_ATTR(l1_icache_size,      0444, show_l1_icache_size, NULL),
+-	_SYSDEV_ATTR(l1_icache_line_size, 0444, show_l1_icache_line_size, NULL),
+-	_SYSDEV_ATTR(l2_cache_size,       0444, show_l2_cache_size, NULL),
+-	_SYSDEV_ATTR(l2_cache_line_size,  0444, show_l2_cache_line_size, NULL),
++static struct device_attribute cpu_core_attrs[] = {
++	__ATTR(clock_tick,          0444, show_clock_tick, NULL),
++	__ATTR(l1_dcache_size,      0444, show_l1_dcache_size, NULL),
++	__ATTR(l1_dcache_line_size, 0444, show_l1_dcache_line_size, NULL),
++	__ATTR(l1_icache_size,      0444, show_l1_icache_size, NULL),
++	__ATTR(l1_icache_line_size, 0444, show_l1_icache_line_size, NULL),
++	__ATTR(l2_cache_size,       0444, show_l2_cache_size, NULL),
++	__ATTR(l2_cache_line_size,  0444, show_l2_cache_line_size, NULL),
+ };
+ 
+ static DEFINE_PER_CPU(struct cpu, cpu_devices);
+@@ -224,11 +224,11 @@ static DEFINE_PER_CPU(struct cpu, cpu_de
+ static void register_cpu_online(unsigned int cpu)
+ {
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
++	struct device *s = &c->dev;
+ 	int i;
+ 
+ 	for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++)
+-		sysdev_create_file(s, &cpu_core_attrs[i]);
++		device_create_file(s, &cpu_core_attrs[i]);
+ 
+ 	register_mmu_stats(s);
+ }
+@@ -237,12 +237,12 @@ static void register_cpu_online(unsigned
+ static void unregister_cpu_online(unsigned int cpu)
+ {
+ 	struct cpu *c = &per_cpu(cpu_devices, cpu);
+-	struct sys_device *s = &c->sysdev;
++	struct device *s = &c->dev;
+ 	int i;
+ 
+ 	unregister_mmu_stats(s);
+ 	for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++)
+-		sysdev_remove_file(s, &cpu_core_attrs[i]);
++		device_remove_file(s, &cpu_core_attrs[i]);
+ }
+ #endif
+ 
+--- a/arch/tile/kernel/sysfs.c
++++ b/arch/tile/kernel/sysfs.c
+@@ -14,7 +14,7 @@
+  * /sys entry support.
+  */
+ 
+-#include <linux/sysdev.h>
++#include <linux/device.h>
+ #include <linux/cpu.h>
+ #include <linux/slab.h>
+ #include <linux/smp.h>
+@@ -32,55 +32,55 @@ static ssize_t get_hv_confstr(char *page
+ 	return n;
+ }
+ 
+-static ssize_t chip_width_show(struct sysdev_class *dev,
+-			       struct sysdev_class_attribute *attr,
++static ssize_t chip_width_show(struct device *dev,
++			       struct device_attribute *attr,
+ 			       char *page)
+ {
+ 	return sprintf(page, "%u\n", smp_width);
+ }
+-static SYSDEV_CLASS_ATTR(chip_width, 0444, chip_width_show, NULL);
++static DEVICE_ATTR(chip_width, 0444, chip_width_show, NULL);
+ 
+-static ssize_t chip_height_show(struct sysdev_class *dev,
+-				struct sysdev_class_attribute *attr,
++static ssize_t chip_height_show(struct device *dev,
++				struct device_attribute *attr,
+ 				char *page)
+ {
+ 	return sprintf(page, "%u\n", smp_height);
+ }
+-static SYSDEV_CLASS_ATTR(chip_height, 0444, chip_height_show, NULL);
++static DEVICE_ATTR(chip_height, 0444, chip_height_show, NULL);
+ 
+-static ssize_t chip_serial_show(struct sysdev_class *dev,
+-				struct sysdev_class_attribute *attr,
++static ssize_t chip_serial_show(struct device *dev,
++				struct device_attribute *attr,
+ 				char *page)
+ {
+ 	return get_hv_confstr(page, HV_CONFSTR_CHIP_SERIAL_NUM);
+ }
+-static SYSDEV_CLASS_ATTR(chip_serial, 0444, chip_serial_show, NULL);
++static DEVICE_ATTR(chip_serial, 0444, chip_serial_show, NULL);
+ 
+-static ssize_t chip_revision_show(struct sysdev_class *dev,
+-				  struct sysdev_class_attribute *attr,
++static ssize_t chip_revision_show(struct device *dev,
++				  struct device_attribute *attr,
+ 				  char *page)
+ {
+ 	return get_hv_confstr(page, HV_CONFSTR_CHIP_REV);
+ }
+-static SYSDEV_CLASS_ATTR(chip_revision, 0444, chip_revision_show, NULL);
++static DEVICE_ATTR(chip_revision, 0444, chip_revision_show, NULL);
+ 
+ 
+-static ssize_t type_show(struct sysdev_class *dev,
+-			    struct sysdev_class_attribute *attr,
++static ssize_t type_show(struct device *dev,
++			    struct device_attribute *attr,
+ 			    char *page)
+ {
+ 	return sprintf(page, "tilera\n");
+ }
+-static SYSDEV_CLASS_ATTR(type, 0444, type_show, NULL);
++static DEVICE_ATTR(type, 0444, type_show, NULL);
+ 
+ #define HV_CONF_ATTR(name, conf)					\
+-	static ssize_t name ## _show(struct sysdev_class *dev,		\
+-				     struct sysdev_class_attribute *attr, \
++	static ssize_t name ## _show(struct device *dev,		\
++				     struct device_attribute *attr, \
+ 				     char *page)			\
+ 	{								\
+ 		return get_hv_confstr(page, conf);			\
+ 	}								\
+-	static SYSDEV_CLASS_ATTR(name, 0444, name ## _show, NULL);
++	static DEVICE_ATTR(name, 0444, name ## _show, NULL);
+ 
+ HV_CONF_ATTR(version,		HV_CONFSTR_HV_SW_VER)
+ HV_CONF_ATTR(config_version,	HV_CONFSTR_HV_CONFIG_VER)
+@@ -96,15 +96,15 @@ HV_CONF_ATTR(mezz_description,	HV_CONFST
+ HV_CONF_ATTR(switch_control,	HV_CONFSTR_SWITCH_CONTROL)
+ 
+ static struct attribute *board_attrs[] = {
+-	&attr_board_part.attr,
+-	&attr_board_serial.attr,
+-	&attr_board_revision.attr,
+-	&attr_board_description.attr,
+-	&attr_mezz_part.attr,
+-	&attr_mezz_serial.attr,
+-	&attr_mezz_revision.attr,
+-	&attr_mezz_description.attr,
+-	&attr_switch_control.attr,
++	&dev_attr_board_part.attr,
++	&dev_attr_board_serial.attr,
++	&dev_attr_board_revision.attr,
++	&dev_attr_board_description.attr,
++	&dev_attr_mezz_part.attr,
++	&dev_attr_mezz_serial.attr,
++	&dev_attr_mezz_revision.attr,
++	&dev_attr_mezz_description.attr,
++	&dev_attr_switch_control.attr,
+ 	NULL
+ };
+ 
+@@ -151,12 +151,11 @@ hvconfig_bin_read(struct file *filp, str
+ 
+ static int __init create_sysfs_entries(void)
+ {
+-	struct sysdev_class *cls = &cpu_sysdev_class;
+ 	int err = 0;
+ 
+ #define create_cpu_attr(name)						\
+ 	if (!err)							\
+-		err = sysfs_create_file(&cls->kset.kobj, &attr_##name.attr);
++		err = device_create_file(cpu_subsys.dev_root, &dev_attr_##name);
+ 	create_cpu_attr(chip_width);
+ 	create_cpu_attr(chip_height);
+ 	create_cpu_attr(chip_serial);
+@@ -164,7 +163,7 @@ static int __init create_sysfs_entries(v
+ 
+ #define create_hv_attr(name)						\
+ 	if (!err)							\
+-		err = sysfs_create_file(hypervisor_kobj, &attr_##name.attr);
++		err = sysfs_create_file(hypervisor_kobj, &dev_attr_##name);
+ 	create_hv_attr(type);
+ 	create_hv_attr(version);
+ 	create_hv_attr(config_version);
 --- 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) {
@@ -1810,6 +4202,35 @@ Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
  	struct cpuidle_device *dev;
  
  	dev = per_cpu(cpuidle_devices, cpu);
+--- 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_chang
+ 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();
+ }
 --- a/include/linux/cpu.h
 +++ b/include/linux/cpu.h
 @@ -14,7 +14,7 @@