129 files changed, 3879 insertions, 2322 deletions

diff --git a/Documentation/ABI/testing/sysfs-ibft b/Documentation/ABI/testing/sysfs-ibft
new file mode 100644
index 000000000000..c2b7d1154bec
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-ibft
@@ -0,0 +1,23 @@
+What:           /sys/firmware/ibft/initiator
+Date:           November 2007
+Contact:        Konrad Rzeszutek <ketuzsezr@darnok.org>
+Description:    The /sys/firmware/ibft/initiator directory will contain
+                files that expose the iSCSI Boot Firmware Table initiator data.
+                Usually this contains the Initiator name.
+
+What:           /sys/firmware/ibft/targetX
+Date:           November 2007
+Contact:        Konrad Rzeszutek <ketuzsezr@darnok.org>
+Description:    The /sys/firmware/ibft/targetX directory will contain
+                files that expose the iSCSI Boot Firmware Table target data.
+                Usually this contains the target's IP address, boot LUN,
+                target name, and what NIC it is associated with. It can also
+                contain the CHAP name (and password), the reverse CHAP
+                name (and password)
+
+What:           /sys/firmware/ibft/ethernetX
+Date:           November 2007
+Contact:        Konrad Rzeszutek <ketuzsezr@darnok.org>
+Description:    The /sys/firmware/ibft/ethernetX directory will contain
+                files that expose the iSCSI Boot Firmware Table NIC data.
+                This can this can the IP address, MAC, and gateway of the NIC.
diff --git a/Documentation/DocBook/kernel-api.tmpl b/Documentation/DocBook/kernel-api.tmpl
index dc0f30c3e571..488dd4a4945b 100644
--- a/Documentation/DocBook/kernel-api.tmpl
+++ b/Documentation/DocBook/kernel-api.tmpl
@@ -297,11 +297,6 @@ X!Earch/x86/kernel/mca_32.c
 !Ikernel/acct.c
   </chapter>
 
-  <chapter id="pmfuncs">
-     <title>Power Management</title>
-!Ekernel/power/pm.c
-  </chapter>
-
   <chapter id="devdrivers">
      <title>Device drivers infrastructure</title>
      <sect1><title>Device Drivers Base</title>
diff --git a/Documentation/filesystems/sysfs.txt b/Documentation/filesystems/sysfs.txt
index 4598ef7b622b..7f27b8f840d0 100644
--- a/Documentation/filesystems/sysfs.txt
+++ b/Documentation/filesystems/sysfs.txt
@@ -176,8 +176,10 @@ implementations:
   Recall that an attribute should only be exporting one value, or an
   array of similar values, so this shouldn't be that expensive. 
 
-  This allows userspace to do partial reads and seeks arbitrarily over
-  the entire file at will. 
+  This allows userspace to do partial reads and forward seeks
+  arbitrarily over the entire file at will. If userspace seeks back to
+  zero or does a pread(2) with an offset of '0' the show() method will
+  be called again, rearmed, to fill the buffer.
 
 - On write(2), sysfs expects the entire buffer to be passed during the
   first write. Sysfs then passes the entire buffer to the store()
@@ -192,6 +194,9 @@ implementations:
 
 Other notes:
 
+- Writing causes the show() method to be rearmed regardless of current
+  file position.
+
 - The buffer will always be PAGE_SIZE bytes in length. On i386, this
   is 4096. 
 
diff --git a/Documentation/power/devices.txt b/Documentation/power/devices.txt
index 461e4f1dbec4..421e7d00ffd0 100644
--- a/Documentation/power/devices.txt
+++ b/Documentation/power/devices.txt
@@ -196,6 +196,11 @@ its parent; and can't be removed or suspended after that parent.
 
 The policy is that the device tree should match hardware bus topology.
 (Or at least the control bus, for devices which use multiple busses.)
+In particular, this means that a device registration may fail if the parent of
+the device is suspending (ie. has been chosen by the PM core as the next
+device to suspend) or has already suspended, as well as after all of the other
+devices have been suspended.  Device drivers must be prepared to cope with such
+situations.
 
 
 Suspending Devices
diff --git a/MAINTAINERS b/MAINTAINERS
index 2b67bb057180..a46ec689f0ac 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3610,6 +3610,11 @@ M:	mhoffman@lightlink.com
 L:      lm-sensors@lm-sensors.org
 S:      Maintained
 
+SMX UIO Interface
+P:      Ben Nizette
+M:      bn@niasdigital.com
+S:      Maintained
+
 SOFTWARE RAID (Multiple Disks) SUPPORT
 P:      Ingo Molnar
 M:      mingo@redhat.com
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index a34cc03e727f..d8d253285a94 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -1192,6 +1192,8 @@ source "drivers/dma/Kconfig"
 
 source "drivers/dca/Kconfig"
 
+source "drivers/uio/Kconfig"
+
 endmenu
 
 source "fs/Kconfig"
diff --git a/arch/x86/kernel/cpuid.c b/arch/x86/kernel/cpuid.c
index 288e7a6598ac..daff52a62248 100644
--- a/arch/x86/kernel/cpuid.c
+++ b/arch/x86/kernel/cpuid.c
@@ -154,12 +154,10 @@ static int __cpuinit cpuid_class_cpu_callback(struct notifier_block *nfb,
                 err = cpuid_device_create(cpu);
                 break;
         case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
                 cpuid_device_destroy(cpu);
                 break;
-        case CPU_UP_CANCELED_FROZEN:
-                destroy_suspended_device(cpuid_class, MKDEV(CPUID_MAJOR, cpu));
-                break;
         }
         return err ? NOTIFY_BAD : NOTIFY_OK;
 }
diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c
index 4dfb40530057..1f3abe048e93 100644
--- a/arch/x86/kernel/msr.c
+++ b/arch/x86/kernel/msr.c
@@ -162,12 +162,10 @@ static int __cpuinit msr_class_cpu_callback(struct notifier_block *nfb,
                 err = msr_device_create(cpu);
                 break;
         case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
                 msr_device_destroy(cpu);
                 break;
-        case CPU_UP_CANCELED_FROZEN:
-                destroy_suspended_device(msr_class, MKDEV(MSR_MAJOR, cpu));
-                break;
         }
         return err ? NOTIFY_BAD : NOTIFY_OK;
 }
diff --git a/arch/x86/kernel/setup_32.c b/arch/x86/kernel/setup_32.c
index 1c4799e68718..78828b0f604f 100644
--- a/arch/x86/kernel/setup_32.c
+++ b/arch/x86/kernel/setup_32.c
@@ -39,6 +39,7 @@
 #include <linux/efi.h>
 #include <linux/init.h>
 #include <linux/edd.h>
+#include <linux/iscsi_ibft.h>
 #include <linux/nodemask.h>
 #include <linux/kexec.h>
 #include <linux/crash_dump.h>
@@ -689,6 +690,8 @@ void __init setup_bootmem_allocator(void)
 #endif
         numa_kva_reserve();
         reserve_crashkernel();
+
+        reserve_ibft_region();
 }
 
 /*
diff --git a/arch/x86/kernel/setup_64.c b/arch/x86/kernel/setup_64.c
index 6b8e11f0c15d..c2ec3dcb6b99 100644
--- a/arch/x86/kernel/setup_64.c
+++ b/arch/x86/kernel/setup_64.c
@@ -33,6 +33,7 @@
 #include <linux/acpi.h>
 #include <linux/kallsyms.h>
 #include <linux/edd.h>
+#include <linux/iscsi_ibft.h>
 #include <linux/mmzone.h>
 #include <linux/kexec.h>
 #include <linux/cpufreq.h>
@@ -439,6 +440,9 @@ void __init setup_arch(char **cmdline_p)
         }
 #endif
         reserve_crashkernel();
+
+        reserve_ibft_region();
+
         paging_init();
         map_vsyscall();
 
diff --git a/block/bsg.c b/block/bsg.c
index 302ac1f5af39..f51172ed27c2 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -758,7 +758,7 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
         mutex_lock(&bsg_mutex);
         hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
 
-        strncpy(bd->name, rq->bsg_dev.class_dev->class_id, sizeof(bd->name) - 1);
+        strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);
         dprintk("bound to <%s>, max queue %d\n",
                 format_dev_t(buf, inode->i_rdev), bd->max_queue);
 
@@ -946,7 +946,7 @@ void bsg_unregister_queue(struct request_queue *q)
         mutex_lock(&bsg_mutex);
         idr_remove(&bsg_minor_idr, bcd->minor);
         sysfs_remove_link(&q->kobj, "bsg");
-        class_device_unregister(bcd->class_dev);
+        device_unregister(bcd->class_dev);
         put_device(bcd->dev);
         bcd->class_dev = NULL;
         mutex_unlock(&bsg_mutex);
@@ -959,7 +959,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
         struct bsg_class_device *bcd;
         dev_t dev;
         int ret, minor;
-        struct class_device *class_dev = NULL;
+        struct device *class_dev = NULL;
         const char *devname;
 
         if (name)
@@ -998,8 +998,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
         bcd->queue = q;
         bcd->dev = get_device(gdev);
         dev = MKDEV(bsg_major, bcd->minor);
-        class_dev = class_device_create(bsg_class, NULL, dev, gdev, "%s",
-                                        devname);
+        class_dev = device_create(bsg_class, gdev, dev, "%s", devname);
         if (IS_ERR(class_dev)) {
                 ret = PTR_ERR(class_dev);
                 goto put_dev;
@@ -1016,7 +1015,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
         return 0;
 
 unregister_class_dev:
-        class_device_unregister(class_dev);
+        device_unregister(class_dev);
 put_dev:
         put_device(gdev);
 remove_idr:
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 739ba3f222e8..986e3324e302 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -273,8 +273,8 @@ static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
 static int ahci_pci_device_resume(struct pci_dev *pdev);
 #endif
 
-static struct class_device_attribute *ahci_shost_attrs[] = {
-        &class_device_attr_link_power_management_policy,
+static struct device_attribute *ahci_shost_attrs[] = {
+        &dev_attr_link_power_management_policy,
         NULL
 };
 
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index f3c69a8c1103..a34f32442edf 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -131,10 +131,11 @@ static const char *ata_scsi_lpm_get(enum link_pm policy)
         return NULL;
 }
 
-static ssize_t ata_scsi_lpm_put(struct class_device *class_dev,
-        const char *buf, size_t count)
+static ssize_t ata_scsi_lpm_put(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ata_port *ap = ata_shost_to_port(shost);
         enum link_pm policy = 0;
         int i;
@@ -162,9 +163,9 @@ static ssize_t ata_scsi_lpm_put(struct class_device *class_dev,
 }
 
 static ssize_t
-ata_scsi_lpm_show(struct class_device *class_dev, char *buf)
+ata_scsi_lpm_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ata_port *ap = ata_shost_to_port(shost);
         const char *policy =
                 ata_scsi_lpm_get(ap->pm_policy);
@@ -174,9 +175,9 @@ ata_scsi_lpm_show(struct class_device *class_dev, char *buf)
 
         return snprintf(buf, 23, "%s\n", policy);
 }
-CLASS_DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
+DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
                 ata_scsi_lpm_show, ata_scsi_lpm_put);
-EXPORT_SYMBOL_GPL(class_device_attr_link_power_management_policy);
+EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
 
 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
                                    void (*done)(struct scsi_cmnd *))
diff --git a/drivers/base/attribute_container.c b/drivers/base/attribute_container.c
index 3b43e8a9f87e..f57652db0a2a 100644
--- a/drivers/base/attribute_container.c
+++ b/drivers/base/attribute_container.c
@@ -27,21 +27,21 @@
 struct internal_container {
         struct klist_node node;
         struct attribute_container *cont;
-        struct class_device classdev;
+        struct device classdev;
 };
 
 static void internal_container_klist_get(struct klist_node *n)
 {
         struct internal_container *ic =
                 container_of(n, struct internal_container, node);
-        class_device_get(&ic->classdev);
+        get_device(&ic->classdev);
 }
 
 static void internal_container_klist_put(struct klist_node *n)
 {
         struct internal_container *ic =
                 container_of(n, struct internal_container, node);
-        class_device_put(&ic->classdev);
+        put_device(&ic->classdev);
 }
 
 
@@ -53,7 +53,7 @@ static void internal_container_klist_put(struct klist_node *n)
  * Returns the container associated with this classdev.
  */
 struct attribute_container *
-attribute_container_classdev_to_container(struct class_device *classdev)
+attribute_container_classdev_to_container(struct device *classdev)
 {
         struct internal_container *ic =
                 container_of(classdev, struct internal_container, classdev);
@@ -110,11 +110,11 @@ attribute_container_unregister(struct attribute_container *cont)
 EXPORT_SYMBOL_GPL(attribute_container_unregister);
 
 /* private function used as class release */
-static void attribute_container_release(struct class_device *classdev)
+static void attribute_container_release(struct device *classdev)
 {
         struct internal_container *ic 
                 = container_of(classdev, struct internal_container, classdev);
-        struct device *dev = classdev->dev;
+        struct device *dev = classdev->parent;
 
         kfree(ic);
         put_device(dev);
@@ -129,12 +129,12 @@ static void attribute_container_release(struct class_device *classdev)
  * This function allocates storage for the class device(s) to be
  * attached to dev (one for each matching attribute_container).  If no
  * fn is provided, the code will simply register the class device via
- * class_device_add.  If a function is provided, it is expected to add
+ * device_add.  If a function is provided, it is expected to add
  * the class device at the appropriate time.  One of the things that
  * might be necessary is to allocate and initialise the classdev and
  * then add it a later time.  To do this, call this routine for
  * allocation and initialisation and then use
- * attribute_container_device_trigger() to call class_device_add() on
+ * attribute_container_device_trigger() to call device_add() on
  * it.  Note: after this, the class device contains a reference to dev
  * which is not relinquished until the release of the classdev.
  */
@@ -142,7 +142,7 @@ void
 attribute_container_add_device(struct device *dev,
                                int (*fn)(struct attribute_container *,
                                          struct device *,
-                                         struct class_device *))
+                                         struct device *))
 {
         struct attribute_container *cont;
 
@@ -163,11 +163,11 @@ attribute_container_add_device(struct device *dev,
                 }
 
                 ic->cont = cont;
-                class_device_initialize(&ic->classdev);
-                ic->classdev.dev = get_device(dev);
+                device_initialize(&ic->classdev);
+                ic->classdev.parent = get_device(dev);
                 ic->classdev.class = cont->class;
-                cont->class->release = attribute_container_release;
-                strcpy(ic->classdev.class_id, dev->bus_id);
+                cont->class->dev_release = attribute_container_release;
+                strcpy(ic->classdev.bus_id, dev->bus_id);
                 if (fn)
                         fn(cont, dev, &ic->classdev);
                 else
@@ -195,20 +195,19 @@ attribute_container_add_device(struct device *dev,
  * @fn:   A function to call to remove the device
  *
  * This routine triggers device removal.  If fn is NULL, then it is
- * simply done via class_device_unregister (note that if something
+ * simply done via device_unregister (note that if something
  * still has a reference to the classdev, then the memory occupied
  * will not be freed until the classdev is released).  If you want a
  * two phase release: remove from visibility and then delete the
  * device, then you should use this routine with a fn that calls
- * class_device_del() and then use
- * attribute_container_device_trigger() to do the final put on the
- * classdev.
+ * device_del() and then use attribute_container_device_trigger()
+ * to do the final put on the classdev.
  */
 void
 attribute_container_remove_device(struct device *dev,
                                   void (*fn)(struct attribute_container *,
                                              struct device *,
-                                             struct class_device *))
+                                             struct device *))
 {
         struct attribute_container *cont;
 
@@ -224,14 +223,14 @@ attribute_container_remove_device(struct device *dev,
                         continue;
 
                 klist_for_each_entry(ic, &cont->containers, node, &iter) {
-                        if (dev != ic->classdev.dev)
+                        if (dev != ic->classdev.parent)
                                 continue;
                         klist_del(&ic->node);
                         if (fn)
                                 fn(cont, dev, &ic->classdev);
                         else {
                                 attribute_container_remove_attrs(&ic->classdev);
-                                class_device_unregister(&ic->classdev);
+                                device_unregister(&ic->classdev);
                         }
                 }
         }
@@ -252,7 +251,7 @@ void
 attribute_container_device_trigger(struct device *dev, 
                                    int (*fn)(struct attribute_container *,
                                              struct device *,
-                                             struct class_device *))
+                                             struct device *))
 {
         struct attribute_container *cont;
 
@@ -270,7 +269,7 @@ attribute_container_device_trigger(struct device *dev,
                 }
 
                 klist_for_each_entry(ic, &cont->containers, node, &iter) {
-                        if (dev == ic->classdev.dev)
+                        if (dev == ic->classdev.parent)
                                 fn(cont, dev, &ic->classdev);
                 }
         }
@@ -313,11 +312,11 @@ attribute_container_trigger(struct device *dev,
  * attributes listed in the container
  */
 int
-attribute_container_add_attrs(struct class_device *classdev)
+attribute_container_add_attrs(struct device *classdev)
 {
         struct attribute_container *cont =
                 attribute_container_classdev_to_container(classdev);
-        struct class_device_attribute **attrs = cont->attrs;
+        struct device_attribute **attrs = cont->attrs;
         int i, error;
 
         BUG_ON(attrs && cont->grp);
@@ -329,7 +328,7 @@ attribute_container_add_attrs(struct class_device *classdev)
                 return sysfs_create_group(&classdev->kobj, cont->grp);
 
         for (i = 0; attrs[i]; i++) {
-                error = class_device_create_file(classdev, attrs[i]);
+                error = device_create_file(classdev, attrs[i]);
                 if (error)
                         return error;
         }
@@ -338,18 +337,18 @@ attribute_container_add_attrs(struct class_device *classdev)
 }
 
 /**
- * attribute_container_add_class_device - same function as class_device_add
+ * attribute_container_add_class_device - same function as device_add
  *
  * @classdev:   the class device to add
  *
- * This performs essentially the same function as class_device_add except for
+ * This performs essentially the same function as device_add except for
  * attribute containers, namely add the classdev to the system and then
  * create the attribute files
  */
 int
-attribute_container_add_class_device(struct class_device *classdev)
+attribute_container_add_class_device(struct device *classdev)
 {
-        int error = class_device_add(classdev);
+        int error = device_add(classdev);
         if (error)
                 return error;
         return attribute_container_add_attrs(classdev);
@@ -364,7 +363,7 @@ attribute_container_add_class_device(struct class_device *classdev)
 int
 attribute_container_add_class_device_adapter(struct attribute_container *cont,
                                              struct device *dev,
-                                             struct class_device *classdev)
+                                             struct device *classdev)
 {
         return attribute_container_add_class_device(classdev);
 }
@@ -376,11 +375,11 @@ attribute_container_add_class_device_adapter(struct attribute_container *cont,
  *
  */
 void
-attribute_container_remove_attrs(struct class_device *classdev)
+attribute_container_remove_attrs(struct device *classdev)
 {
         struct attribute_container *cont =
                 attribute_container_classdev_to_container(classdev);
-        struct class_device_attribute **attrs = cont->attrs;
+        struct device_attribute **attrs = cont->attrs;
         int i;
 
         if (!attrs && !cont->grp)
@@ -392,7 +391,7 @@ attribute_container_remove_attrs(struct class_device *classdev)
         }
 
         for (i = 0; attrs[i]; i++)
-                class_device_remove_file(classdev, attrs[i]);
+                device_remove_file(classdev, attrs[i]);
 }
 
 /**
@@ -401,13 +400,13 @@ attribute_container_remove_attrs(struct class_device *classdev)
  * @classdev: the class device
  *
  * This function simply removes all the attribute files and then calls
- * class_device_del.
+ * device_del.
  */
 void
-attribute_container_class_device_del(struct class_device *classdev)
+attribute_container_class_device_del(struct device *classdev)
 {
         attribute_container_remove_attrs(classdev);
-        class_device_del(classdev);
+        device_del(classdev);
 }
 
 /**
@@ -419,16 +418,16 @@ attribute_container_class_device_del(struct class_device *classdev)
  * Looks up the device in the container's list of class devices and returns
  * the corresponding class_device.
  */
-struct class_device *
+struct device *
 attribute_container_find_class_device(struct attribute_container *cont,
                                       struct device *dev)
 {
-        struct class_device *cdev = NULL;
+        struct device *cdev = NULL;
         struct internal_container *ic;
         struct klist_iter iter;
 
         klist_for_each_entry(ic, &cont->containers, node, &iter) {
-                if (ic->classdev.dev == dev) {
+                if (ic->classdev.parent == dev) {
                         cdev = &ic->classdev;
                         /* FIXME: must exit iterator then break */
                         klist_iter_exit(&iter);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 2d207ad30336..be1cc5143354 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -79,7 +79,7 @@ static void driver_release(struct kobject *kobj)
 {
         struct driver_private *drv_priv = to_driver(kobj);
 
-        pr_debug("driver: '%s': %s\n", kobject_name(kobj), __FUNCTION__);
+        pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
         kfree(drv_priv);
 }
 
@@ -505,14 +505,11 @@ void bus_attach_device(struct device *dev)
         int ret = 0;
 
         if (bus) {
-                dev->is_registered = 1;
                 if (bus->p->drivers_autoprobe)
                         ret = device_attach(dev);
                 WARN_ON(ret < 0);
                 if (ret >= 0)
                         klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
-                else
-                        dev->is_registered = 0;
         }
 }
 
@@ -533,10 +530,8 @@ void bus_remove_device(struct device *dev)
                 sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
                                   dev->bus_id);
                 device_remove_attrs(dev->bus, dev);
-                if (dev->is_registered) {
-                        dev->is_registered = 0;
-                        klist_del(&dev->knode_bus);
-                }
+                klist_del(&dev->knode_bus);
+
                 pr_debug("bus: '%s': remove device %s\n",
                          dev->bus->name, dev->bus_id);
                 device_release_driver(dev);
@@ -682,19 +677,19 @@ int bus_add_driver(struct device_driver *drv)
         error = driver_create_file(drv, &driver_attr_uevent);
         if (error) {
                 printk(KERN_ERR "%s: uevent attr (%s) failed\n",
-                        __FUNCTION__, drv->name);
+                        __func__, drv->name);
         }
         error = driver_add_attrs(bus, drv);
         if (error) {
                 /* How the hell do we get out of this pickle? Give up */
                 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
-                        __FUNCTION__, drv->name);
+                        __func__, drv->name);
         }
         error = add_bind_files(drv);
         if (error) {
                 /* Ditto */
                 printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
-                        __FUNCTION__, drv->name);
+                        __func__, drv->name);
         }
 
         kobject_uevent(&priv->kobj, KOBJ_ADD);
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 9d915376c313..b4901799308b 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -175,13 +175,13 @@ void class_unregister(struct class *cls)
 
 static void class_create_release(struct class *cls)
 {
-        pr_debug("%s called for %s\n", __FUNCTION__, cls->name);
+        pr_debug("%s called for %s\n", __func__, cls->name);
         kfree(cls);
 }
 
 static void class_device_create_release(struct class_device *class_dev)
 {
-        pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
+        pr_debug("%s called for %s\n", __func__, class_dev->class_id);
         kfree(class_dev);
 }
 
@@ -189,7 +189,7 @@ static void class_device_create_release(struct class_device *class_dev)
 static int class_device_create_uevent(struct class_device *class_dev,
                                       struct kobj_uevent_env *env)
 {
-        pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
+        pr_debug("%s called for %s\n", __func__, class_dev->class_id);
         return 0;
 }
 
@@ -415,7 +415,7 @@ static int class_uevent(struct kset *kset, struct kobject *kobj,
         struct device *dev = class_dev->dev;
         int retval = 0;
 
-        pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
+        pr_debug("%s - name = %s\n", __func__, class_dev->class_id);
 
         if (MAJOR(class_dev->devt)) {
                 add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 7c4b36ccb1a0..9248e0927d08 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -207,7 +207,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                 retval = dev->bus->uevent(dev, env);
                 if (retval)
                         pr_debug("device: '%s': %s: bus uevent() returned %d\n",
-                                 dev->bus_id, __FUNCTION__, retval);
+                                 dev->bus_id, __func__, retval);
         }
 
         /* have the class specific function add its stuff */
@@ -216,7 +216,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                 if (retval)
                         pr_debug("device: '%s': %s: class uevent() "
                                  "returned %d\n", dev->bus_id,
-                                 __FUNCTION__, retval);
+                                 __func__, retval);
         }
 
         /* have the device type specific fuction add its stuff */
@@ -225,7 +225,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                 if (retval)
                         pr_debug("device: '%s': %s: dev_type uevent() "
                                  "returned %d\n", dev->bus_id,
-                                 __FUNCTION__, retval);
+                                 __func__, retval);
         }
 
         return retval;
@@ -782,7 +782,7 @@ int device_add(struct device *dev)
                 goto Done;
         }
 
-        pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__);
+        pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
 
         parent = get_device(dev->parent);
         setup_parent(dev, parent);
@@ -817,13 +817,12 @@ int device_add(struct device *dev)
         error = device_add_attrs(dev);
         if (error)
                 goto AttrsError;
-        error = dpm_sysfs_add(dev);
-        if (error)
-                goto PMError;
-        device_pm_add(dev);
         error = bus_add_device(dev);
         if (error)
                 goto BusError;
+        error = device_pm_add(dev);
+        if (error)
+                goto PMError;
         kobject_uevent(&dev->kobj, KOBJ_ADD);
         bus_attach_device(dev);
         if (parent)
@@ -843,9 +842,9 @@ int device_add(struct device *dev)
  Done:
         put_device(dev);
         return error;
- BusError:
-        device_pm_remove(dev);
  PMError:
+        bus_remove_device(dev);
+ BusError:
         if (dev->bus)
                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                              BUS_NOTIFY_DEL_DEVICE, dev);
@@ -981,7 +980,7 @@ void device_del(struct device *dev)
  */
 void device_unregister(struct device *dev)
 {
-        pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__);
+        pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
         device_del(dev);
         put_device(dev);
 }
@@ -1076,7 +1075,7 @@ EXPORT_SYMBOL_GPL(device_remove_file);
 
 static void device_create_release(struct device *dev)
 {
-        pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__);
+        pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
         kfree(dev);
 }
 
@@ -1164,35 +1163,6 @@ void device_destroy(struct class *class, dev_t devt)
 }
 EXPORT_SYMBOL_GPL(device_destroy);
 
-#ifdef CONFIG_PM_SLEEP
-/**
- * destroy_suspended_device - asks the PM core to remove a suspended device
- * @class: pointer to the struct class that this device was registered with
- * @devt: the dev_t of the device that was previously registered
- *
- * This call notifies the PM core of the necessity to unregister a suspended
- * device created with a call to device_create() (devices cannot be
- * unregistered directly while suspended, since the PM core holds their
- * semaphores at that time).
- *
- * It can only be called within the scope of a system sleep transition.  In
- * practice this means it has to be directly or indirectly invoked either by
- * a suspend or resume method, or by the PM core (e.g. via
- * disable_nonboot_cpus() or enable_nonboot_cpus()).
- */
-void destroy_suspended_device(struct class *class, dev_t devt)
-{
-        struct device *dev;
-
-        dev = class_find_device(class, &devt, __match_devt);
-        if (dev) {
-                device_pm_schedule_removal(dev);
-                put_device(dev);
-        }
-}
-EXPORT_SYMBOL_GPL(destroy_suspended_device);
-#endif /* CONFIG_PM_SLEEP */
-
 /**
  * device_rename - renames a device
  * @dev: the pointer to the struct device to be renamed
@@ -1210,7 +1180,7 @@ int device_rename(struct device *dev, char *new_name)
                 return -EINVAL;
 
         pr_debug("device: '%s': %s: renaming to '%s'\n", dev->bus_id,
-                 __FUNCTION__, new_name);
+                 __func__, new_name);
 
 #ifdef CONFIG_SYSFS_DEPRECATED
         if ((dev->class) && (dev->parent))
@@ -1249,7 +1219,7 @@ int device_rename(struct device *dev, char *new_name)
                                           dev->bus_id);
                 if (error) {
                         dev_err(dev, "%s: sysfs_create_symlink failed (%d)\n",
-                                __FUNCTION__, error);
+                                __func__, error);
                 }
         }
 #endif
@@ -1325,7 +1295,7 @@ int device_move(struct device *dev, struct device *new_parent)
         new_parent_kobj = get_device_parent(dev, new_parent);
 
         pr_debug("device: '%s': %s: moving to '%s'\n", dev->bus_id,
-                 __FUNCTION__, new_parent ? new_parent->bus_id : "<NULL>");
+                 __func__, new_parent ? new_parent->bus_id : "<NULL>");
         error = kobject_move(&dev->kobj, new_parent_kobj);
         if (error) {
                 cleanup_glue_dir(dev, new_parent_kobj);
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 2c76afff3b15..6fe417429977 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -28,7 +28,7 @@ static ssize_t show_online(struct sys_device *dev, char *buf)
         return sprintf(buf, "%u\n", !!cpu_online(cpu->sysdev.id));
 }
 
-static ssize_t store_online(struct sys_device *dev, const char *buf,
+static ssize_t __ref store_online(struct sys_device *dev, const char *buf,
                             size_t count)
 {
         struct cpu *cpu = container_of(dev, struct cpu, sysdev);
@@ -55,7 +55,7 @@ static ssize_t store_online(struct sys_device *dev, const char *buf,
 }
 static SYSDEV_ATTR(online, 0644, show_online, store_online);
 
-static void __devinit register_cpu_control(struct cpu *cpu)
+static void __cpuinit register_cpu_control(struct cpu *cpu)
 {
         sysdev_create_file(&cpu->sysdev, &attr_online);
 }
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index a5cde94bb982..3ac443b2ac08 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -30,12 +30,12 @@ static void driver_bound(struct device *dev)
 {
         if (klist_node_attached(&dev->knode_driver)) {
                 printk(KERN_WARNING "%s: device %s already bound\n",
-                        __FUNCTION__, kobject_name(&dev->kobj));
+                        __func__, kobject_name(&dev->kobj));
                 return;
         }
 
         pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->bus_id,
-                 __FUNCTION__, dev->driver->name);
+                 __func__, dev->driver->name);
 
         if (dev->bus)
                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
@@ -104,13 +104,13 @@ static int really_probe(struct device *dev, struct device_driver *drv)
 
         atomic_inc(&probe_count);
         pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
-                 drv->bus->name, __FUNCTION__, drv->name, dev->bus_id);
+                 drv->bus->name, __func__, drv->name, dev->bus_id);
         WARN_ON(!list_empty(&dev->devres_head));
 
         dev->driver = drv;
         if (driver_sysfs_add(dev)) {
                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
-                        __FUNCTION__, dev->bus_id);
+                        __func__, dev->bus_id);
                 goto probe_failed;
         }
 
@@ -127,7 +127,7 @@ static int really_probe(struct device *dev, struct device_driver *drv)
         driver_bound(dev);
         ret = 1;
         pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
-                 drv->bus->name, __FUNCTION__, dev->bus_id, drv->name);
+                 drv->bus->name, __func__, dev->bus_id, drv->name);
         goto done;
 
 probe_failed:
@@ -160,7 +160,7 @@ done:
  */
 int driver_probe_done(void)
 {
-        pr_debug("%s: probe_count = %d\n", __FUNCTION__,
+        pr_debug("%s: probe_count = %d\n", __func__,
                  atomic_read(&probe_count));
         if (atomic_read(&probe_count))
                 return -EBUSY;
@@ -194,7 +194,7 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
                 goto done;
 
         pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
-                 drv->bus->name, __FUNCTION__, dev->bus_id, drv->name);
+                 drv->bus->name, __func__, dev->bus_id, drv->name);
 
         ret = really_probe(dev, drv);
 
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 4a1b9bfc5471..1fef7df8c9d6 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -156,7 +156,7 @@ static ssize_t firmware_loading_store(struct device *dev,
                 }
                 /* fallthrough */
         default:
-                printk(KERN_ERR "%s: unexpected value (%d)\n", __FUNCTION__,
+                printk(KERN_ERR "%s: unexpected value (%d)\n", __func__,
                        loading);
                 /* fallthrough */
         case -1:
@@ -209,7 +209,7 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
         new_size = ALIGN(min_size, PAGE_SIZE);
         new_data = vmalloc(new_size);
         if (!new_data) {
-                printk(KERN_ERR "%s: unable to alloc buffer\n", __FUNCTION__);
+                printk(KERN_ERR "%s: unable to alloc buffer\n", __func__);
                 /* Make sure that we don't keep incomplete data */
                 fw_load_abort(fw_priv);
                 return -ENOMEM;
@@ -307,7 +307,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
         *dev_p = NULL;
 
         if (!fw_priv || !f_dev) {
-                printk(KERN_ERR "%s: kmalloc failed\n", __FUNCTION__);
+                printk(KERN_ERR "%s: kmalloc failed\n", __func__);
                 retval = -ENOMEM;
                 goto error_kfree;
         }
@@ -328,7 +328,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
         retval = device_register(f_dev);
         if (retval) {
                 printk(KERN_ERR "%s: device_register failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_kfree;
         }
         *dev_p = f_dev;
@@ -362,14 +362,14 @@ static int fw_setup_device(struct firmware *fw, struct device **dev_p,
         retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
         if (retval) {
                 printk(KERN_ERR "%s: sysfs_create_bin_file failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_unreg;
         }
 
         retval = device_create_file(f_dev, &dev_attr_loading);
         if (retval) {
                 printk(KERN_ERR "%s: device_create_file failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_unreg;
         }
 
@@ -399,7 +399,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
         if (!firmware) {
                 printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n",
-                       __FUNCTION__);
+                       __func__);
                 retval = -ENOMEM;
                 goto out;
         }
@@ -570,13 +570,13 @@ firmware_class_init(void)
         int error;
         error = class_register(&firmware_class);
         if (error) {
-                printk(KERN_ERR "%s: class_register failed\n", __FUNCTION__);
+                printk(KERN_ERR "%s: class_register failed\n", __func__);
                 return error;
         }
         error = class_create_file(&firmware_class, &class_attr_timeout);
         if (error) {
                 printk(KERN_ERR "%s: class_create_file failed\n",
-                       __FUNCTION__);
+                       __func__);
                 class_unregister(&firmware_class);
         }
         return error;
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 7ae413fdd5fc..8ce6de5a7e28 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -20,6 +20,7 @@
 #include <linux/kobject.h>
 #include <linux/memory_hotplug.h>
 #include <linux/mm.h>
+#include <linux/mutex.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
 
@@ -61,8 +62,8 @@ void unregister_memory_notifier(struct notifier_block *nb)
 /*
  * register_memory - Setup a sysfs device for a memory block
  */
-int register_memory(struct memory_block *memory, struct mem_section *section,
-                struct node *root)
+static
+int register_memory(struct memory_block *memory, struct mem_section *section)
 {
         int error;
 
@@ -70,26 +71,18 @@ int register_memory(struct memory_block *memory, struct mem_section *section,
         memory->sysdev.id = __section_nr(section);
 
         error = sysdev_register(&memory->sysdev);
-
-        if (root && !error)
-                error = sysfs_create_link(&root->sysdev.kobj,
-                                          &memory->sysdev.kobj,
-                                          kobject_name(&memory->sysdev.kobj));
-
         return error;
 }
 
 static void
-unregister_memory(struct memory_block *memory, struct mem_section *section,
-                struct node *root)
+unregister_memory(struct memory_block *memory, struct mem_section *section)
 {
         BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
         BUG_ON(memory->sysdev.id != __section_nr(section));
 
+        /* drop the ref. we got in remove_memory_block() */
+        kobject_put(&memory->sysdev.kobj);
         sysdev_unregister(&memory->sysdev);
-        if (root)
-                sysfs_remove_link(&root->sysdev.kobj,
-                                  kobject_name(&memory->sysdev.kobj));
 }
 
 /*
@@ -193,7 +186,7 @@ memory_block_action(struct memory_block *mem, unsigned long action)
                         break;
                 default:
                         printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
-                                        __FUNCTION__, mem, action, action);
+                                        __func__, mem, action, action);
                         WARN_ON(1);
                         ret = -EINVAL;
         }
@@ -205,7 +198,7 @@ static int memory_block_change_state(struct memory_block *mem,
                 unsigned long to_state, unsigned long from_state_req)
 {
         int ret = 0;
-        down(&mem->state_sem);
+        mutex_lock(&mem->state_mutex);
 
         if (mem->state != from_state_req) {
                 ret = -EINVAL;
@@ -217,7 +210,7 @@ static int memory_block_change_state(struct memory_block *mem,
                 mem->state = to_state;
 
 out:
-        up(&mem->state_sem);
+        mutex_unlock(&mem->state_mutex);
         return ret;
 }
 
@@ -341,10 +334,10 @@ static int add_memory_block(unsigned long node_id, struct mem_section *section,
 
         mem->phys_index = __section_nr(section);
         mem->state = state;
-        init_MUTEX(&mem->state_sem);
+        mutex_init(&mem->state_mutex);
         mem->phys_device = phys_device;
 
-        ret = register_memory(mem, section, NULL);
+        ret = register_memory(mem, section);
         if (!ret)
                 ret = mem_create_simple_file(mem, phys_index);
         if (!ret)
@@ -395,7 +388,7 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
         mem_remove_simple_file(mem, phys_index);
         mem_remove_simple_file(mem, state);
         mem_remove_simple_file(mem, phys_device);
-        unregister_memory(mem, section, NULL);
+        unregister_memory(mem, section);
 
         return 0;
 }
@@ -451,6 +444,6 @@ int __init memory_dev_init(void)
                 ret = err;
 out:
         if (ret)
-                printk(KERN_ERR "%s() failed: %d\n", __FUNCTION__, ret);
+                printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
         return ret;
 }
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index d887d5cb5bef..c4568b82875b 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -50,26 +50,40 @@
 LIST_HEAD(dpm_active);
 static LIST_HEAD(dpm_off);
 static LIST_HEAD(dpm_off_irq);
-static LIST_HEAD(dpm_destroy);
 
 static DEFINE_MUTEX(dpm_list_mtx);
 
-static DECLARE_RWSEM(pm_sleep_rwsem);
-
-int (*platform_enable_wakeup)(struct device *dev, int is_on);
+/* 'true' if all devices have been suspended, protected by dpm_list_mtx */
+static bool all_sleeping;
 
 /**
  *      device_pm_add - add a device to the list of active devices
  *      @dev:   Device to be added to the list
  */
-void device_pm_add(struct device *dev)
+int device_pm_add(struct device *dev)
 {
+        int error = 0;
+
         pr_debug("PM: Adding info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus",
                  kobject_name(&dev->kobj));
         mutex_lock(&dpm_list_mtx);
-        list_add_tail(&dev->power.entry, &dpm_active);
+        if ((dev->parent && dev->parent->power.sleeping) || all_sleeping) {
+                if (dev->parent->power.sleeping)
+                        dev_warn(dev,
+                                "parent %s is sleeping, will not add\n",
+                                dev->parent->bus_id);
+                else
+                        dev_warn(dev, "devices are sleeping, will not add\n");
+                WARN_ON(true);
+                error = -EBUSY;
+        } else {
+                error = dpm_sysfs_add(dev);
+                if (!error)
+                        list_add_tail(&dev->power.entry, &dpm_active);
+        }
         mutex_unlock(&dpm_list_mtx);
+        return error;
 }
 
 /**
@@ -89,50 +103,6 @@ void device_pm_remove(struct device *dev)
         mutex_unlock(&dpm_list_mtx);
 }
 
-/**
- *      device_pm_schedule_removal - schedule the removal of a suspended device
- *      @dev:   Device to destroy
- *
- *      Moves the device to the dpm_destroy list for further processing by
- *      unregister_dropped_devices().
- */
-void device_pm_schedule_removal(struct device *dev)
-{
-        pr_debug("PM: Preparing for removal: %s:%s\n",
-                dev->bus ? dev->bus->name : "No Bus",
-                kobject_name(&dev->kobj));
-        mutex_lock(&dpm_list_mtx);
-        list_move_tail(&dev->power.entry, &dpm_destroy);
-        mutex_unlock(&dpm_list_mtx);
-}
-EXPORT_SYMBOL_GPL(device_pm_schedule_removal);
-
-/**
- *      pm_sleep_lock - mutual exclusion for registration and suspend
- *
- *      Returns 0 if no suspend is underway and device registration
- *      may proceed, otherwise -EBUSY.
- */
-int pm_sleep_lock(void)
-{
-        if (down_read_trylock(&pm_sleep_rwsem))
-                return 0;
-
-        return -EBUSY;
-}
-
-/**
- *      pm_sleep_unlock - mutual exclusion for registration and suspend
- *
- *      This routine undoes the effect of device_pm_add_lock
- *      when a device's registration is complete.
- */
-void pm_sleep_unlock(void)
-{
-        up_read(&pm_sleep_rwsem);
-}
-
-
 /*------------------------- Resume routines -------------------------*/
 
 /**
@@ -242,11 +212,13 @@ static int resume_device(struct device *dev)
 static void dpm_resume(void)
 {
         mutex_lock(&dpm_list_mtx);
+        all_sleeping = false;
         while(!list_empty(&dpm_off)) {
                 struct list_head *entry = dpm_off.next;
                 struct device *dev = to_device(entry);
 
                 list_move_tail(entry, &dpm_active);
+                dev->power.sleeping = false;
                 mutex_unlock(&dpm_list_mtx);
                 resume_device(dev);
                 mutex_lock(&dpm_list_mtx);
@@ -255,26 +227,6 @@ static void dpm_resume(void)
 }
 
 /**
- *      unregister_dropped_devices - Unregister devices scheduled for removal
- *
- *      Unregister all devices on the dpm_destroy list.
- */
-static void unregister_dropped_devices(void)
-{
-        mutex_lock(&dpm_list_mtx);
-        while (!list_empty(&dpm_destroy)) {
-                struct list_head *entry = dpm_destroy.next;
-                struct device *dev = to_device(entry);
-
-                mutex_unlock(&dpm_list_mtx);
-                /* This also removes the device from the list */
-                device_unregister(dev);
-                mutex_lock(&dpm_list_mtx);
-        }
-        mutex_unlock(&dpm_list_mtx);
-}
-
-/**
  *      device_resume - Restore state of each device in system.
  *
  *      Resume all the devices, unlock them all, and allow new
@@ -284,8 +236,6 @@ void device_resume(void)
 {
         might_sleep();
         dpm_resume();
-        unregister_dropped_devices();
-        up_write(&pm_sleep_rwsem);
 }
 EXPORT_SYMBOL_GPL(device_resume);
 
@@ -377,11 +327,6 @@ static int suspend_device(struct device *dev, pm_message_t state)
 
         down(&dev->sem);
 
-        if (dev->power.power_state.event) {
-                dev_dbg(dev, "PM: suspend %d-->%d\n",
-                        dev->power.power_state.event, state.event);
-        }
-
         if (dev->class && dev->class->suspend) {
                 suspend_device_dbg(dev, state, "class ");
                 error = dev->class->suspend(dev, state);
@@ -426,6 +371,9 @@ static int dpm_suspend(pm_message_t state)
                 struct list_head *entry = dpm_active.prev;
                 struct device *dev = to_device(entry);
 
+                WARN_ON(dev->parent && dev->parent->power.sleeping);
+
+                dev->power.sleeping = true;
                 mutex_unlock(&dpm_list_mtx);
                 error = suspend_device(dev, state);
                 mutex_lock(&dpm_list_mtx);
@@ -437,11 +385,14 @@ static int dpm_suspend(pm_message_t state)
                                         (error == -EAGAIN ?
                                         " (please convert to suspend_late)" :
                                         ""));
+                        dev->power.sleeping = false;
                         break;
                 }
                 if (!list_empty(&dev->power.entry))
                         list_move(&dev->power.entry, &dpm_off);
         }
+        if (!error)
+                all_sleeping = true;
         mutex_unlock(&dpm_list_mtx);
 
         return error;
@@ -459,7 +410,6 @@ int device_suspend(pm_message_t state)
         int error;
 
         might_sleep();
-        down_write(&pm_sleep_rwsem);
         error = dpm_suspend(state);
         if (error)
                 device_resume();
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index e32d3bdb92c1..a6894f2a4b99 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -11,30 +11,13 @@ static inline struct device *to_device(struct list_head *entry)
         return container_of(entry, struct device, power.entry);
 }
 
-extern void device_pm_add(struct device *);
+extern int device_pm_add(struct device *);
 extern void device_pm_remove(struct device *);
-extern int pm_sleep_lock(void);
-extern void pm_sleep_unlock(void);
 
 #else /* CONFIG_PM_SLEEP */
 
-
-static inline void device_pm_add(struct device *dev)
-{
-}
-
-static inline void device_pm_remove(struct device *dev)
-{
-}
-
-static inline int pm_sleep_lock(void)
-{
-        return 0;
-}
-
-static inline void pm_sleep_unlock(void)
-{
-}
+static inline int device_pm_add(struct device *dev) { return 0; }
+static inline void device_pm_remove(struct device *dev) {}
 
 #endif
 
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index f2ed179cd695..d11f74b038db 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -6,6 +6,8 @@
 #include <linux/string.h>
 #include "power.h"
 
+int (*platform_enable_wakeup)(struct device *dev, int is_on);
+
 
 /*
  *      wakeup - Report/change current wakeup option for device
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 8e13fd942163..4fbb56bcb1ee 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -167,6 +167,22 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 {
         int err = 0;
 
+        if (!cls) {
+                printk(KERN_WARNING "sysdev: invalid class passed to "
+                        "sysdev_driver_register!\n");
+                WARN_ON(1);
+                return -EINVAL;
+        }
+
+        /* Check whether this driver has already been added to a class. */
+        if ((drv->entry.next != drv->entry.prev) ||
+            (drv->entry.next != NULL)) {
+                printk(KERN_WARNING "sysdev: class %s: driver (%p) has already"
+                        " been registered to a class, something is wrong, but "
+                        "will forge on!\n", cls->name, drv);
+                WARN_ON(1);
+        }
+
         mutex_lock(&sysdev_drivers_lock);
         if (cls && kset_get(&cls->kset)) {
                 list_add_tail(&drv->entry, &cls->drivers);
@@ -179,7 +195,7 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
                 }
         } else {
                 err = -EINVAL;
-                printk(KERN_ERR "%s: invalid device class\n", __FUNCTION__);
+                printk(KERN_ERR "%s: invalid device class\n", __func__);
                 WARN_ON(1);
         }
         mutex_unlock(&sysdev_drivers_lock);
diff --git a/drivers/base/transport_class.c b/drivers/base/transport_class.c
index cabd0edf2156..84997efdb23d 100644
--- a/drivers/base/transport_class.c
+++ b/drivers/base/transport_class.c
@@ -66,7 +66,7 @@ EXPORT_SYMBOL_GPL(transport_class_unregister);
 
 static int anon_transport_dummy_function(struct transport_container *tc,
                                          struct device *dev,
-                                         struct class_device *cdev)
+                                         struct device *cdev)
 {
         /* do nothing */
         return 0;
@@ -115,7 +115,7 @@ EXPORT_SYMBOL_GPL(anon_transport_class_unregister);
 
 static int transport_setup_classdev(struct attribute_container *cont,
                                     struct device *dev,
-                                    struct class_device *classdev)
+                                    struct device *classdev)
 {
         struct transport_class *tclass = class_to_transport_class(cont->class);
         struct transport_container *tcont = attribute_container_to_transport_container(cont);
@@ -149,7 +149,7 @@ EXPORT_SYMBOL_GPL(transport_setup_device);
 
 static int transport_add_class_device(struct attribute_container *cont,
                                       struct device *dev,
-                                      struct class_device *classdev)
+                                      struct device *classdev)
 {
         int error = attribute_container_add_class_device(classdev);
         struct transport_container *tcont = 
@@ -181,7 +181,7 @@ EXPORT_SYMBOL_GPL(transport_add_device);
 
 static int transport_configure(struct attribute_container *cont,
                                struct device *dev,
-                               struct class_device *cdev)
+                               struct device *cdev)
 {
         struct transport_class *tclass = class_to_transport_class(cont->class);
         struct transport_container *tcont = attribute_container_to_transport_container(cont);
@@ -212,7 +212,7 @@ EXPORT_SYMBOL_GPL(transport_configure_device);
 
 static int transport_remove_classdev(struct attribute_container *cont,
                                      struct device *dev,
-                                     struct class_device *classdev)
+                                     struct device *classdev)
 {
         struct transport_container *tcont = 
                 attribute_container_to_transport_container(cont);
@@ -251,12 +251,12 @@ EXPORT_SYMBOL_GPL(transport_remove_device);
 
 static void transport_destroy_classdev(struct attribute_container *cont,
                                       struct device *dev,
-                                      struct class_device *classdev)
+                                      struct device *classdev)
 {
         struct transport_class *tclass = class_to_transport_class(cont->class);
 
         if (tclass->remove != anon_transport_dummy_function)
-                class_device_put(classdev);
+                put_device(classdev);
 }
 
 
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index 8ea9dd1717a9..6540948d5176 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -640,7 +640,6 @@ struct drm_head {
         struct drm_device *dev;
         struct proc_dir_entry *dev_root;  /**< proc directory entry */
         dev_t device;                   /**< Device number for mknod */
-        struct class_device *dev_class;
 };
 
 /**
diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c
index 349b6edc5794..662d60e44e9a 100644
--- a/drivers/char/hw_random/core.c
+++ b/drivers/char/hw_random/core.c
@@ -238,11 +238,11 @@ static DEVICE_ATTR(rng_available, S_IRUGO,
                    NULL);
 
 
-static void unregister_miscdev(bool suspended)
+static void unregister_miscdev(void)
 {
         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
-        __misc_deregister(&rng_miscdev, suspended);
+        misc_deregister(&rng_miscdev);
 }
 
 static int register_miscdev(void)
@@ -317,7 +317,7 @@ out:
 }
 EXPORT_SYMBOL_GPL(hwrng_register);
 
-void __hwrng_unregister(struct hwrng *rng, bool suspended)
+void hwrng_unregister(struct hwrng *rng)
 {
         int err;
 
@@ -336,11 +336,11 @@ void __hwrng_unregister(struct hwrng *rng, bool suspended)
                 }
         }
         if (list_empty(&rng_list))
-                unregister_miscdev(suspended);
+                unregister_miscdev();
 
         mutex_unlock(&rng_mutex);
 }
-EXPORT_SYMBOL_GPL(__hwrng_unregister);
+EXPORT_SYMBOL_GPL(hwrng_unregister);
 
 
 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index a39101feb2ed..4d058dadbfcc 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -232,9 +232,8 @@ int misc_register(struct miscdevice * misc)
 }
 
 /**
- *      __misc_deregister - unregister a miscellaneous device
+ *      misc_deregister - unregister a miscellaneous device
  *      @misc: device to unregister
- *      @suspended: to be set if the function is used during suspend/resume
  *
  *      Unregister a miscellaneous device that was previously
  *      successfully registered with misc_register(). Success
@@ -242,7 +241,7 @@ int misc_register(struct miscdevice * misc)
  *      indicates an error.
  */
 
-int __misc_deregister(struct miscdevice *misc, bool suspended)
+int misc_deregister(struct miscdevice *misc)
 {
         int i = misc->minor;
 
@@ -251,11 +250,7 @@ int __misc_deregister(struct miscdevice *misc, bool suspended)
 
         mutex_lock(&misc_mtx);
         list_del(&misc->list);
-        if (suspended)
-                destroy_suspended_device(misc_class,
-                                        MKDEV(MISC_MAJOR, misc->minor));
-        else
-                device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
+        device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
         if (i < DYNAMIC_MINORS && i>0) {
                 misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
         }
@@ -264,7 +259,7 @@ int __misc_deregister(struct miscdevice *misc, bool suspended)
 }
 
 EXPORT_SYMBOL(misc_register);
-EXPORT_SYMBOL(__misc_deregister);
+EXPORT_SYMBOL(misc_deregister);
 
 static int __init misc_init(void)
 {
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 05f02a326f1c..40ffd767647d 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -93,4 +93,24 @@ config DMIID
           information from userspace through /sys/class/dmi/id/ or if you want
           DMI-based module auto-loading.
 
+config ISCSI_IBFT_FIND
+        bool "iSCSI Boot Firmware Table Attributes"
+        depends on X86
+        default n
+        help
+          This option enables the kernel to find the region of memory
+          in which the ISCSI Boot Firmware Table (iBFT) resides. This
+          is necessary for iSCSI Boot Firmware Table Attributes module to work
+          properly.
+
+config ISCSI_IBFT
+        tristate "iSCSI Boot Firmware Table Attributes module"
+        depends on ISCSI_IBFT_FIND
+        default n
+        help
+          This option enables support for detection and exposing of iSCSI
+          Boot Firmware Table (iBFT) via sysfs to userspace. If you wish to
+          detect iSCSI boot parameters dynamically during system boot, say Y.
+          Otherwise, say N.
+
 endmenu
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 8d4ebc805a50..4c9147154df8 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -8,3 +8,5 @@ obj-$(CONFIG_EFI_PCDP)		+= pcdp.o
 obj-$(CONFIG_DELL_RBU)          += dell_rbu.o
 obj-$(CONFIG_DCDBAS)            += dcdbas.o
 obj-$(CONFIG_DMIID)             += dmi-id.o
+obj-$(CONFIG_ISCSI_IBFT_FIND)   += iscsi_ibft_find.o
+obj-$(CONFIG_ISCSI_IBFT)        += iscsi_ibft.o
diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c
new file mode 100644
index 000000000000..8024e3bfd877
--- /dev/null
+++ b/drivers/firmware/iscsi_ibft.c
@@ -0,0 +1,982 @@
+/*
+ *  Copyright 2007 Red Hat, Inc.
+ *  by Peter Jones <pjones@redhat.com>
+ *  Copyright 2008 IBM, Inc.
+ *  by Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *  Copyright 2008
+ *  by Konrad Rzeszutek <ketuzsezr@darnok.org>
+ *
+ * This code exposes the iSCSI Boot Format Table to userland via sysfs.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 as published by
+ * the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Changelog:
+ *
+ *  14 Mar 2008 - Konrad Rzeszutek <ketuzsezr@darnok.org>
+ *    Updated comments and copyrights. (v0.4.9)
+ *
+ *  11 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *    Converted to using ibft_addr. (v0.4.8)
+ *
+ *   8 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *    Combined two functions in one: reserve_ibft_region. (v0.4.7)
+ *
+ *  30 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added logic to handle IPv6 addresses. (v0.4.6)
+ *
+ *  25 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added logic to handle badly not-to-spec iBFT. (v0.4.5)
+ *
+ *   4 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added __init to function declarations. (v0.4.4)
+ *
+ *  21 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Updated kobject registration, combined unregister functions in one
+ *   and code and style cleanup. (v0.4.3)
+ *
+ *   5 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added end-markers to enums and re-organized kobject registration. (v0.4.2)
+ *
+ *   4 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Created 'device' sysfs link to the NIC and style cleanup. (v0.4.1)
+ *
+ *  28 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added sysfs-ibft documentation, moved 'find_ibft' function to
+ *   in its own file and added text attributes for every struct field.  (v0.4)
+ *
+ *  21 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added text attributes emulating OpenFirmware /proc/device-tree naming.
+ *   Removed binary /sysfs interface (v0.3)
+ *
+ *  29 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   Added functionality in setup.c to reserve iBFT region. (v0.2)
+ *
+ *  27 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *   First version exposing iBFT data via a binary /sysfs. (v0.1)
+ *
+ */
+
+
+#include <linux/blkdev.h>
+#include <linux/capability.h>
+#include <linux/ctype.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/iscsi_ibft.h>
+#include <linux/limits.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/stat.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#define IBFT_ISCSI_VERSION "0.4.9"
+#define IBFT_ISCSI_DATE "2008-Mar-14"
+
+MODULE_AUTHOR("Peter Jones <pjones@redhat.com> and \
+Konrad Rzeszutek <ketuzsezr@darnok.org>");
+MODULE_DESCRIPTION("sysfs interface to BIOS iBFT information");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(IBFT_ISCSI_VERSION);
+
+struct ibft_hdr {
+        u8 id;
+        u8 version;
+        u16 length;
+        u8 index;
+        u8 flags;
+} __attribute__((__packed__));
+
+struct ibft_control {
+        struct ibft_hdr hdr;
+        u16 extensions;
+        u16 initiator_off;
+        u16 nic0_off;
+        u16 tgt0_off;
+        u16 nic1_off;
+        u16 tgt1_off;
+} __attribute__((__packed__));
+
+struct ibft_initiator {
+        struct ibft_hdr hdr;
+        char isns_server[16];
+        char slp_server[16];
+        char pri_radius_server[16];
+        char sec_radius_server[16];
+        u16 initiator_name_len;
+        u16 initiator_name_off;
+} __attribute__((__packed__));
+
+struct ibft_nic {
+        struct ibft_hdr hdr;
+        char ip_addr[16];
+        u8 subnet_mask_prefix;
+        u8 origin;
+        char gateway[16];
+        char primary_dns[16];
+        char secondary_dns[16];
+        char dhcp[16];
+        u16 vlan;
+        char mac[6];
+        u16 pci_bdf;
+        u16 hostname_len;
+        u16 hostname_off;
+} __attribute__((__packed__));
+
+struct ibft_tgt {
+        struct ibft_hdr hdr;
+        char ip_addr[16];
+        u16 port;
+        char lun[8];
+        u8 chap_type;
+        u8 nic_assoc;
+        u16 tgt_name_len;
+        u16 tgt_name_off;
+        u16 chap_name_len;
+        u16 chap_name_off;
+        u16 chap_secret_len;
+        u16 chap_secret_off;
+        u16 rev_chap_name_len;
+        u16 rev_chap_name_off;
+        u16 rev_chap_secret_len;
+        u16 rev_chap_secret_off;
+} __attribute__((__packed__));
+
+/*
+ * The kobject different types and its names.
+ *
+*/
+enum ibft_id {
+        id_reserved = 0, /* We don't support. */
+        id_control = 1, /* Should show up only once and is not exported. */
+        id_initiator = 2,
+        id_nic = 3,
+        id_target = 4,
+        id_extensions = 5, /* We don't support. */
+        id_end_marker,
+};
+
+/*
+ * We do not support the other types, hence the usage of NULL.
+ * This maps to the enum ibft_id.
+ */
+static const char *ibft_id_names[] =
+        {NULL, NULL, "initiator", "ethernet%d", "target%d", NULL, NULL};
+
+/*
+ * The text attributes names for each of the kobjects.
+*/
+enum ibft_eth_properties_enum {
+        ibft_eth_index,
+        ibft_eth_flags,
+        ibft_eth_ip_addr,
+        ibft_eth_subnet_mask,
+        ibft_eth_origin,
+        ibft_eth_gateway,
+        ibft_eth_primary_dns,
+        ibft_eth_secondary_dns,
+        ibft_eth_dhcp,
+        ibft_eth_vlan,
+        ibft_eth_mac,
+        /* ibft_eth_pci_bdf - this is replaced by link to the device itself. */
+        ibft_eth_hostname,
+        ibft_eth_end_marker,
+};
+
+static const char *ibft_eth_properties[] =
+        {"index", "flags", "ip-addr", "subnet-mask", "origin", "gateway",
+        "primary-dns", "secondary-dns", "dhcp", "vlan", "mac", "hostname",
+        NULL};
+
+enum ibft_tgt_properties_enum {
+        ibft_tgt_index,
+        ibft_tgt_flags,
+        ibft_tgt_ip_addr,
+        ibft_tgt_port,
+        ibft_tgt_lun,
+        ibft_tgt_chap_type,
+        ibft_tgt_nic_assoc,
+        ibft_tgt_name,
+        ibft_tgt_chap_name,
+        ibft_tgt_chap_secret,
+        ibft_tgt_rev_chap_name,
+        ibft_tgt_rev_chap_secret,
+        ibft_tgt_end_marker,
+};
+
+static const char *ibft_tgt_properties[] =
+        {"index", "flags", "ip-addr", "port", "lun", "chap-type", "nic-assoc",
+        "target-name", "chap-name", "chap-secret", "rev-chap-name",
+        "rev-chap-name-secret", NULL};
+
+enum ibft_initiator_properties_enum {
+        ibft_init_index,
+        ibft_init_flags,
+        ibft_init_isns_server,
+        ibft_init_slp_server,
+        ibft_init_pri_radius_server,
+        ibft_init_sec_radius_server,
+        ibft_init_initiator_name,
+        ibft_init_end_marker,
+};
+
+static const char *ibft_initiator_properties[] =
+        {"index", "flags", "isns-server", "slp-server", "pri-radius-server",
+        "sec-radius-server", "initiator-name", NULL};
+
+/*
+ * The kobject and attribute structures.
+ */
+
+struct ibft_kobject {
+        struct ibft_table_header *header;
+        union {
+                struct ibft_initiator *initiator;
+                struct ibft_nic *nic;
+                struct ibft_tgt *tgt;
+                struct ibft_hdr *hdr;
+        };
+        struct kobject kobj;
+        struct list_head node;
+};
+
+struct ibft_attribute {
+        struct attribute attr;
+        ssize_t (*show) (struct  ibft_kobject *entry,
+                         struct ibft_attribute *attr, char *buf);
+        union {
+                struct ibft_initiator *initiator;
+                struct ibft_nic *nic;
+                struct ibft_tgt *tgt;
+                struct ibft_hdr *hdr;
+        };
+        struct kobject *kobj;
+        int type; /* The enum of the type. This can be any value of:
+                ibft_eth_properties_enum, ibft_tgt_properties_enum,
+                or ibft_initiator_properties_enum. */
+        struct list_head node;
+};
+
+static LIST_HEAD(ibft_attr_list);
+static LIST_HEAD(ibft_kobject_list);
+
+static const char nulls[16];
+
+/*
+ * Helper functions to parse data properly.
+ */
+static ssize_t sprintf_ipaddr(char *buf, u8 *ip)
+{
+        char *str = buf;
+
+        if (ip[0] == 0 && ip[1] == 0 && ip[2] == 0 && ip[3] == 0 &&
+            ip[4] == 0 && ip[5] == 0 && ip[6] == 0 && ip[7] == 0 &&
+            ip[8] == 0 && ip[9] == 0 && ip[10] == 0xff && ip[11] == 0xff) {
+                /*
+                 * IPV4
+                 */
+                str += sprintf(buf, NIPQUAD_FMT, ip[12],
+                               ip[13], ip[14], ip[15]);
+        } else {
+                /*
+                 * IPv6
+                 */
+                str += sprintf(str, NIP6_FMT, ntohs(ip[0]), ntohs(ip[1]),
+                               ntohs(ip[2]), ntohs(ip[3]), ntohs(ip[4]),
+                               ntohs(ip[5]), ntohs(ip[6]), ntohs(ip[7]));
+        }
+        str += sprintf(str, "\n");
+        return str - buf;
+}
+
+static ssize_t sprintf_string(char *str, int len, char *buf)
+{
+        return sprintf(str, "%.*s\n", len, buf);
+}
+
+/*
+ * Helper function to verify the IBFT header.
+ */
+static int ibft_verify_hdr(char *t, struct ibft_hdr *hdr, int id, int length)
+{
+        if (hdr->id != id) {
+                printk(KERN_ERR "iBFT error: We expected the " \
+                                "field header.id to have %d but " \
+                                "found %d instead!\n", id, hdr->id);
+                return -ENODEV;
+        }
+        if (hdr->length != length) {
+                printk(KERN_ERR "iBFT error: We expected the " \
+                                "field header.length to have %d but " \
+                                "found %d instead!\n", length, hdr->length);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void ibft_release(struct kobject *kobj)
+{
+        struct ibft_kobject *ibft =
+                container_of(kobj, struct ibft_kobject, kobj);
+        kfree(ibft);
+}
+
+/*
+ *  Routines for parsing the iBFT data to be human readable.
+ */
+ssize_t ibft_attr_show_initiator(struct ibft_kobject *entry,
+                                  struct ibft_attribute *attr,
+                                  char *buf)
+{
+        struct ibft_initiator *initiator = entry->initiator;
+        void *ibft_loc = entry->header;
+        char *str = buf;
+
+        if (!initiator)
+                return 0;
+
+        switch (attr->type) {
+        case ibft_init_index:
+                str += sprintf(str, "%d\n", initiator->hdr.index);
+                break;
+        case ibft_init_flags:
+                str += sprintf(str, "%d\n", initiator->hdr.flags);
+                break;
+        case ibft_init_isns_server:
+                str += sprintf_ipaddr(str, initiator->isns_server);
+                break;
+        case ibft_init_slp_server:
+                str += sprintf_ipaddr(str, initiator->slp_server);
+                break;
+        case ibft_init_pri_radius_server:
+                str += sprintf_ipaddr(str, initiator->pri_radius_server);
+                break;
+        case ibft_init_sec_radius_server:
+                str += sprintf_ipaddr(str, initiator->sec_radius_server);
+                break;
+        case ibft_init_initiator_name:
+                str += sprintf_string(str, initiator->initiator_name_len,
+                                      (char *)ibft_loc +
+                                      initiator->initiator_name_off);
+                break;
+        default:
+                break;
+        }
+
+        return str - buf;
+}
+
+ssize_t ibft_attr_show_nic(struct ibft_kobject *entry,
+                            struct ibft_attribute *attr,
+                            char *buf)
+{
+        struct ibft_nic *nic = entry->nic;
+        void *ibft_loc = entry->header;
+        char *str = buf;
+        char *mac;
+        int val;
+
+        if (!nic)
+                return 0;
+
+        switch (attr->type) {
+        case ibft_eth_index:
+                str += sprintf(str, "%d\n", nic->hdr.index);
+                break;
+        case ibft_eth_flags:
+                str += sprintf(str, "%d\n", nic->hdr.flags);
+                break;
+        case ibft_eth_ip_addr:
+                str += sprintf_ipaddr(str, nic->ip_addr);
+                break;
+        case ibft_eth_subnet_mask:
+                val = ~((1 << (32-nic->subnet_mask_prefix))-1);
+                str += sprintf(str, NIPQUAD_FMT,
+                               (u8)(val >> 24), (u8)(val >> 16),
+                               (u8)(val >> 8), (u8)(val));
+                break;
+        case ibft_eth_origin:
+                str += sprintf(str, "%d\n", nic->origin);
+                break;
+        case ibft_eth_gateway:
+                str += sprintf_ipaddr(str, nic->gateway);
+                break;
+        case ibft_eth_primary_dns:
+                str += sprintf_ipaddr(str, nic->primary_dns);
+                break;
+        case ibft_eth_secondary_dns:
+                str += sprintf_ipaddr(str, nic->secondary_dns);
+                break;
+        case ibft_eth_dhcp:
+                str += sprintf_ipaddr(str, nic->dhcp);
+                break;
+        case ibft_eth_vlan:
+                str += sprintf(str, "%d\n", nic->vlan);
+                break;
+        case ibft_eth_mac:
+                mac = nic->mac;
+                str += sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x\n",
+                               (u8)mac[0], (u8)mac[1], (u8)mac[2],
+                               (u8)mac[3], (u8)mac[4], (u8)mac[5]);
+                break;
+        case ibft_eth_hostname:
+                str += sprintf_string(str, nic->hostname_len,
+                                      (char *)ibft_loc + nic->hostname_off);
+                break;
+        default:
+                break;
+        }
+
+        return str - buf;
+};
+
+ssize_t ibft_attr_show_target(struct ibft_kobject *entry,
+                               struct ibft_attribute *attr,
+                               char *buf)
+{
+        struct ibft_tgt *tgt = entry->tgt;
+        void *ibft_loc = entry->header;
+        char *str = buf;
+        int i;
+
+        if (!tgt)
+                return 0;
+
+        switch (attr->type) {
+        case ibft_tgt_index:
+                str += sprintf(str, "%d\n", tgt->hdr.index);
+                break;
+        case ibft_tgt_flags:
+                str += sprintf(str, "%d\n", tgt->hdr.flags);
+                break;
+        case ibft_tgt_ip_addr:
+                str += sprintf_ipaddr(str, tgt->ip_addr);
+                break;
+        case ibft_tgt_port:
+                str += sprintf(str, "%d\n", tgt->port);
+                break;
+        case ibft_tgt_lun:
+                for (i = 0; i < 8; i++)
+                        str += sprintf(str, "%x", (u8)tgt->lun[i]);
+                str += sprintf(str, "\n");
+                break;
+        case ibft_tgt_nic_assoc:
+                str += sprintf(str, "%d\n", tgt->nic_assoc);
+                break;
+        case ibft_tgt_chap_type:
+                str += sprintf(str, "%d\n", tgt->chap_type);
+                break;
+        case ibft_tgt_name:
+                str += sprintf_string(str, tgt->tgt_name_len,
+                                      (char *)ibft_loc + tgt->tgt_name_off);
+                break;
+        case ibft_tgt_chap_name:
+                str += sprintf_string(str, tgt->chap_name_len,
+                                      (char *)ibft_loc + tgt->chap_name_off);
+                break;
+        case ibft_tgt_chap_secret:
+                str += sprintf_string(str, tgt->chap_secret_len,
+                                      (char *)ibft_loc + tgt->chap_secret_off);
+                break;
+        case ibft_tgt_rev_chap_name:
+                str += sprintf_string(str, tgt->rev_chap_name_len,
+                                      (char *)ibft_loc +
+                                      tgt->rev_chap_name_off);
+                break;
+        case ibft_tgt_rev_chap_secret:
+                str += sprintf_string(str, tgt->rev_chap_secret_len,
+                                      (char *)ibft_loc +
+                                      tgt->rev_chap_secret_off);
+                break;
+        default:
+                break;
+        }
+
+        return str - buf;
+}
+
+/*
+ * The routine called for all sysfs attributes.
+ */
+static ssize_t ibft_show_attribute(struct kobject *kobj,
+                                    struct attribute *attr,
+                                    char *buf)
+{
+        struct ibft_kobject *dev =
+                container_of(kobj, struct ibft_kobject, kobj);
+        struct ibft_attribute *ibft_attr =
+                container_of(attr, struct ibft_attribute, attr);
+        ssize_t ret = -EIO;
+        char *str = buf;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (ibft_attr->show)
+                ret = ibft_attr->show(dev, ibft_attr, str);
+
+        return ret;
+}
+
+static struct sysfs_ops ibft_attr_ops = {
+        .show = ibft_show_attribute,
+};
+
+static struct kobj_type ibft_ktype = {
+        .release = ibft_release,
+        .sysfs_ops = &ibft_attr_ops,
+};
+
+static struct kset *ibft_kset;
+
+static int __init ibft_check_device(void)
+{
+        int len;
+        u8 *pos;
+        u8 csum = 0;
+
+        len = ibft_addr->length;
+
+        /* Sanity checking of iBFT. */
+        if (ibft_addr->revision != 1) {
+                printk(KERN_ERR "iBFT module supports only revision 1, " \
+                                "while this is %d.\n", ibft_addr->revision);
+                return -ENOENT;
+        }
+        for (pos = (u8 *)ibft_addr; pos < (u8 *)ibft_addr + len; pos++)
+                csum += *pos;
+
+        if (csum) {
+                printk(KERN_ERR "iBFT has incorrect checksum (0x%x)!\n", csum);
+                return -ENOENT;
+        }
+
+        return 0;
+}
+
+/*
+ * Helper function for ibft_register_kobjects.
+ */
+static int __init ibft_create_kobject(struct ibft_table_header *header,
+                                       struct ibft_hdr *hdr,
+                                       struct list_head *list)
+{
+        struct ibft_kobject *ibft_kobj = NULL;
+        struct ibft_nic *nic = (struct ibft_nic *)hdr;
+        struct pci_dev *pci_dev;
+        int rc = 0;
+
+        ibft_kobj = kzalloc(sizeof(*ibft_kobj), GFP_KERNEL);
+        if (!ibft_kobj)
+                return -ENOMEM;
+
+        ibft_kobj->header = header;
+        ibft_kobj->hdr = hdr;
+
+        switch (hdr->id) {
+        case id_initiator:
+                rc = ibft_verify_hdr("initiator", hdr, id_initiator,
+                                     sizeof(*ibft_kobj->initiator));
+                break;
+        case id_nic:
+                rc = ibft_verify_hdr("ethernet", hdr, id_nic,
+                                     sizeof(*ibft_kobj->nic));
+                break;
+        case id_target:
+                rc = ibft_verify_hdr("target", hdr, id_target,
+                                     sizeof(*ibft_kobj->tgt));
+                break;
+        case id_reserved:
+        case id_control:
+        case id_extensions:
+                /* Fields which we don't support. Ignore them */
+                rc = 1;
+                break;
+        default:
+                printk(KERN_ERR "iBFT has unknown structure type (%d). " \
+                                "Report this bug to %.6s!\n", hdr->id,
+                                header->oem_id);
+                rc = 1;
+                break;
+        }
+
+        if (rc) {
+                /* Skip adding this kobject, but exit with non-fatal error. */
+                kfree(ibft_kobj);
+                goto out_invalid_struct;
+        }
+
+        ibft_kobj->kobj.kset = ibft_kset;
+
+        rc = kobject_init_and_add(&ibft_kobj->kobj, &ibft_ktype,
+                                  NULL, ibft_id_names[hdr->id], hdr->index);
+
+        if (rc) {
+                kfree(ibft_kobj);
+                goto out;
+        }
+
+        kobject_uevent(&ibft_kobj->kobj, KOBJ_ADD);
+
+        if (hdr->id == id_nic) {
+                /*
+                * We don't search for the device in other domains than
+                * zero. This is because on x86 platforms the BIOS
+                * executes only devices which are in domain 0. Furthermore, the
+                * iBFT spec doesn't have a domain id field :-(
+                */
+                pci_dev = pci_get_bus_and_slot((nic->pci_bdf & 0xff00) >> 8,
+                                               (nic->pci_bdf & 0xff));
+                if (pci_dev) {
+                        rc = sysfs_create_link(&ibft_kobj->kobj,
+                                               &pci_dev->dev.kobj, "device");
+                        pci_dev_put(pci_dev);
+                }
+        }
+
+        /* Nothing broke so lets add it to the list. */
+        list_add_tail(&ibft_kobj->node, list);
+out:
+        return rc;
+out_invalid_struct:
+        /* Unsupported structs are skipped. */
+        return 0;
+}
+
+/*
+ * Scan the IBFT table structure for the NIC and Target fields. When
+ * found add them on the passed-in list. We do not support the other
+ * fields at this point, so they are skipped.
+ */
+static int __init ibft_register_kobjects(struct ibft_table_header *header,
+                                          struct list_head *list)
+{
+        struct ibft_control *control = NULL;
+        void *ptr, *end;
+        int rc = 0;
+        u16 offset;
+        u16 eot_offset;
+
+        control = (void *)header + sizeof(*header);
+        end = (void *)control + control->hdr.length;
+        eot_offset = (void *)header + header->length -
+                     (void *)control - sizeof(*header);
+        rc = ibft_verify_hdr("control", (struct ibft_hdr *)control, id_control,
+                             sizeof(*control));
+
+        /* iBFT table safety checking */
+        rc |= ((control->hdr.index) ? -ENODEV : 0);
+        if (rc) {
+                printk(KERN_ERR "iBFT error: Control header is invalid!\n");
+                return rc;
+        }
+        for (ptr = &control->initiator_off; ptr < end; ptr += sizeof(u16)) {
+                offset = *(u16 *)ptr;
+                if (offset && offset < header->length && offset < eot_offset) {
+                        rc = ibft_create_kobject(header,
+                                                 (void *)header + offset,
+                                                 list);
+                        if (rc)
+                                break;
+                }
+        }
+
+        return rc;
+}
+
+static void ibft_unregister(struct list_head *attr_list,
+                             struct list_head *kobj_list)
+{
+        struct ibft_kobject *data = NULL, *n;
+        struct ibft_attribute *attr = NULL, *m;
+
+        list_for_each_entry_safe(attr, m, attr_list, node) {
+                sysfs_remove_file(attr->kobj, &attr->attr);
+                list_del(&attr->node);
+                kfree(attr);
+        };
+        list_del_init(attr_list);
+
+        list_for_each_entry_safe(data, n, kobj_list, node) {
+                list_del(&data->node);
+                if (data->hdr->id == id_nic)
+                        sysfs_remove_link(&data->kobj, "device");
+                kobject_put(&data->kobj);
+        };
+        list_del_init(kobj_list);
+}
+
+static int __init ibft_create_attribute(struct ibft_kobject *kobj_data,
+                                         int type,
+                                         const char *name,
+                                         ssize_t (*show)(struct ibft_kobject *,
+                                                         struct ibft_attribute*,
+                                                         char *buf),
+                                         struct list_head *list)
+{
+        struct ibft_attribute *attr = NULL;
+        struct ibft_hdr *hdr = kobj_data->hdr;
+
+        attr = kmalloc(sizeof(*attr), GFP_KERNEL);
+        if (!attr)
+                return -ENOMEM;
+
+        attr->attr.name = name;
+        attr->attr.mode = S_IRUSR;
+        attr->attr.owner = THIS_MODULE;
+
+        attr->hdr = hdr;
+        attr->show = show;
+        attr->kobj = &kobj_data->kobj;
+        attr->type = type;
+
+        list_add_tail(&attr->node, list);
+
+        return 0;
+}
+
+/*
+ * Helper routiners to check to determine if the entry is valid
+ * in the proper iBFT structure.
+ */
+static int __init ibft_check_nic_for(struct ibft_nic *nic, int entry)
+{
+        int rc = 0;
+
+        switch (entry) {
+        case ibft_eth_index:
+        case ibft_eth_flags:
+                rc = 1;
+                break;
+        case ibft_eth_ip_addr:
+                if (!memcmp(nic->dhcp, nulls, sizeof(nic->dhcp)))
+                        rc = 1;
+                break;
+        case ibft_eth_subnet_mask:
+                if (!memcmp(nic->dhcp, nulls, sizeof(nic->dhcp)))
+                        rc = 1;
+                break;
+        case ibft_eth_origin:
+                rc = 1;
+                break;
+        case ibft_eth_gateway:
+                if (memcmp(nic->gateway, nulls, sizeof(nic->gateway)))
+                        rc = 1;
+                break;
+        case ibft_eth_primary_dns:
+                if (memcmp(nic->primary_dns, nulls,
+                           sizeof(nic->primary_dns)))
+                        rc = 1;
+                break;
+        case ibft_eth_secondary_dns:
+                if (memcmp(nic->secondary_dns, nulls,
+                           sizeof(nic->secondary_dns)))
+                        rc = 1;
+                break;
+        case ibft_eth_dhcp:
+                if (memcmp(nic->dhcp, nulls, sizeof(nic->dhcp)))
+                        rc = 1;
+                break;
+        case ibft_eth_vlan:
+        case ibft_eth_mac:
+                rc = 1;
+                break;
+        case ibft_eth_hostname:
+                if (nic->hostname_off)
+                        rc = 1;
+                break;
+        default:
+                break;
+        }
+
+        return rc;
+}
+
+static int __init ibft_check_tgt_for(struct ibft_tgt *tgt, int entry)
+{
+        int rc = 0;
+
+        switch (entry) {
+        case ibft_tgt_index:
+        case ibft_tgt_flags:
+        case ibft_tgt_ip_addr:
+        case ibft_tgt_port:
+        case ibft_tgt_lun:
+        case ibft_tgt_nic_assoc:
+        case ibft_tgt_chap_type:
+                rc = 1;
+        case ibft_tgt_name:
+                if (tgt->tgt_name_len)
+                        rc = 1;
+                break;
+        case ibft_tgt_chap_name:
+        case ibft_tgt_chap_secret:
+                if (tgt->chap_name_len)
+                        rc = 1;
+                break;
+        case ibft_tgt_rev_chap_name:
+        case ibft_tgt_rev_chap_secret:
+                if (tgt->rev_chap_name_len)
+                        rc = 1;
+                break;
+        default:
+                break;
+        }
+
+        return rc;
+}
+
+static int __init ibft_check_initiator_for(struct ibft_initiator *init,
+                                            int entry)
+{
+        int rc = 0;
+
+        switch (entry) {
+        case ibft_init_index:
+        case ibft_init_flags:
+                rc = 1;
+                break;
+        case ibft_init_isns_server:
+                if (memcmp(init->isns_server, nulls,
+                           sizeof(init->isns_server)))
+                        rc = 1;
+                break;
+        case ibft_init_slp_server:
+                if (memcmp(init->slp_server, nulls,
+                           sizeof(init->slp_server)))
+                        rc = 1;
+                break;
+        case ibft_init_pri_radius_server:
+                if (memcmp(init->pri_radius_server, nulls,
+                           sizeof(init->pri_radius_server)))
+                        rc = 1;
+                break;
+        case ibft_init_sec_radius_server:
+                if (memcmp(init->sec_radius_server, nulls,
+                           sizeof(init->sec_radius_server)))
+                        rc = 1;
+                break;
+        case ibft_init_initiator_name:
+                if (init->initiator_name_len)
+                        rc = 1;
+                break;
+        default:
+                break;
+        }
+
+        return rc;
+}
+
+/*
+ *  Register the attributes for all of the kobjects.
+ */
+static int __init ibft_register_attributes(struct list_head *kobject_list,
+                                            struct list_head *attr_list)
+{
+        int rc = 0, i = 0;
+        struct ibft_kobject *data = NULL;
+        struct ibft_attribute *attr = NULL, *m;
+
+        list_for_each_entry(data, kobject_list, node) {
+                switch (data->hdr->id) {
+                case id_nic:
+                        for (i = 0; i < ibft_eth_end_marker && !rc; i++)
+                                if (ibft_check_nic_for(data->nic, i))
+                                        rc = ibft_create_attribute(data, i,
+                                                ibft_eth_properties[i],
+                                                ibft_attr_show_nic, attr_list);
+                        break;
+                case id_target:
+                        for (i = 0; i < ibft_tgt_end_marker && !rc; i++)
+                                if (ibft_check_tgt_for(data->tgt, i))
+                                        rc = ibft_create_attribute(data, i,
+                                                ibft_tgt_properties[i],
+                                                ibft_attr_show_target,
+                                                attr_list);
+                        break;
+                case id_initiator:
+                        for (i = 0; i < ibft_init_end_marker && !rc; i++)
+                                if (ibft_check_initiator_for(
+                                        data->initiator, i))
+                                        rc = ibft_create_attribute(data, i,
+                                                ibft_initiator_properties[i],
+                                                ibft_attr_show_initiator,
+                                                attr_list);
+                        break;
+                default:
+                        break;
+                }
+                if (rc)
+                        break;
+        }
+        list_for_each_entry_safe(attr, m, attr_list, node) {
+                rc = sysfs_create_file(attr->kobj, &attr->attr);
+                if (rc) {
+                        list_del(&attr->node);
+                        kfree(attr);
+                        break;
+                }
+        }
+
+        return rc;
+}
+
+/*
+ * ibft_init() - creates sysfs tree entries for the iBFT data.
+ */
+static int __init ibft_init(void)
+{
+        int rc = 0;
+
+        ibft_kset = kset_create_and_add("ibft", NULL, firmware_kobj);
+        if (!ibft_kset)
+                return -ENOMEM;
+
+        if (ibft_addr) {
+                printk(KERN_INFO "iBFT detected at 0x%lx.\n",
+                       virt_to_phys((void *)ibft_addr));
+
+                rc = ibft_check_device();
+                if (rc)
+                        goto out_firmware_unregister;
+
+                /* Scan the IBFT for data and register the kobjects. */
+                rc = ibft_register_kobjects(ibft_addr, &ibft_kobject_list);
+                if (rc)
+                        goto out_free;
+
+                /* Register the attributes */
+                rc = ibft_register_attributes(&ibft_kobject_list,
+                                              &ibft_attr_list);
+                if (rc)
+                        goto out_free;
+        } else
+                printk(KERN_INFO "No iBFT detected.\n");
+
+        return 0;
+
+out_free:
+        ibft_unregister(&ibft_attr_list, &ibft_kobject_list);
+out_firmware_unregister:
+        kset_unregister(ibft_kset);
+        return rc;
+}
+
+static void __exit ibft_exit(void)
+{
+        ibft_unregister(&ibft_attr_list, &ibft_kobject_list);
+        kset_unregister(ibft_kset);
+}
+
+module_init(ibft_init);
+module_exit(ibft_exit);
diff --git a/drivers/firmware/iscsi_ibft_find.c b/drivers/firmware/iscsi_ibft_find.c
new file mode 100644
index 000000000000..d0e5fa4ea51b
--- /dev/null
+++ b/drivers/firmware/iscsi_ibft_find.c
@@ -0,0 +1,84 @@
+/*
+ *  Copyright 2007 Red Hat, Inc.
+ *  by Peter Jones <pjones@redhat.com>
+ *  Copyright 2007 IBM, Inc.
+ *  by Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *  Copyright 2008
+ *  by Konrad Rzeszutek <ketuzsezr@darnok.org>
+ *
+ * This code finds the iSCSI Boot Format Table.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 as published by
+ * the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/bootmem.h>
+#include <linux/blkdev.h>
+#include <linux/ctype.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/limits.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/stat.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#include <asm/mmzone.h>
+
+/*
+ * Physical location of iSCSI Boot Format Table.
+ */
+struct ibft_table_header *ibft_addr;
+EXPORT_SYMBOL_GPL(ibft_addr);
+
+#define IBFT_SIGN "iBFT"
+#define IBFT_SIGN_LEN 4
+#define IBFT_START 0x80000 /* 512kB */
+#define IBFT_END 0x100000 /* 1MB */
+#define VGA_MEM 0xA0000 /* VGA buffer */
+#define VGA_SIZE 0x20000 /* 128kB */
+
+
+/*
+ * Routine used to find the iSCSI Boot Format Table. The logical
+ * kernel address is set in the ibft_addr global variable.
+ */
+void __init reserve_ibft_region(void)
+{
+        unsigned long pos;
+        unsigned int len = 0;
+        void *virt;
+
+        ibft_addr = 0;
+
+        for (pos = IBFT_START; pos < IBFT_END; pos += 16) {
+                /* The table can't be inside the VGA BIOS reserved space,
+                 * so skip that area */
+                if (pos == VGA_MEM)
+                        pos += VGA_SIZE;
+                virt = phys_to_virt(pos);
+                if (memcmp(virt, IBFT_SIGN, IBFT_SIGN_LEN) == 0) {
+                        unsigned long *addr =
+                            (unsigned long *)phys_to_virt(pos + 4);
+                        len = *addr;
+                        /* if the length of the table extends past 1M,
+                         * the table cannot be valid. */
+                        if (pos + len <= (IBFT_END-1)) {
+                                ibft_addr = (struct ibft_table_header *)virt;
+                                break;
+                        }
+                }
+        }
+        if (ibft_addr)
+                reserve_bootmem(pos, PAGE_ALIGN(len), BOOTMEM_DEFAULT);
+}
+EXPORT_SYMBOL_GPL(reserve_ibft_region);
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index 5a4b2e65534b..95756551cf7c 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -427,17 +427,17 @@ static struct kobj_type port_type = {
         .default_attrs = port_default_attrs
 };
 
-static void ib_device_release(struct class_device *cdev)
+static void ib_device_release(struct device *device)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
 
         kfree(dev);
 }
 
-static int ib_device_uevent(struct class_device *cdev,
+static int ib_device_uevent(struct device *device,
                             struct kobj_uevent_env *env)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
 
         if (add_uevent_var(env, "NAME=%s", dev->name))
                 return -ENOMEM;
@@ -567,9 +567,10 @@ err_put:
         return ret;
 }
 
-static ssize_t show_node_type(struct class_device *cdev, char *buf)
+static ssize_t show_node_type(struct device *device,
+                              struct device_attribute *attr, char *buf)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
 
         if (!ibdev_is_alive(dev))
                 return -ENODEV;
@@ -583,9 +584,10 @@ static ssize_t show_node_type(struct class_device *cdev, char *buf)
         }
 }
 
-static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf)
+static ssize_t show_sys_image_guid(struct device *device,
+                                   struct device_attribute *dev_attr, char *buf)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
         struct ib_device_attr attr;
         ssize_t ret;
 
@@ -603,9 +605,10 @@ static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf)
                        be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3]));
 }
 
-static ssize_t show_node_guid(struct class_device *cdev, char *buf)
+static ssize_t show_node_guid(struct device *device,
+                              struct device_attribute *attr, char *buf)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
 
         if (!ibdev_is_alive(dev))
                 return -ENODEV;
@@ -617,17 +620,19 @@ static ssize_t show_node_guid(struct class_device *cdev, char *buf)
                        be16_to_cpu(((__be16 *) &dev->node_guid)[3]));
 }
 
-static ssize_t show_node_desc(struct class_device *cdev, char *buf)
+static ssize_t show_node_desc(struct device *device,
+                              struct device_attribute *attr, char *buf)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
 
         return sprintf(buf, "%.64s\n", dev->node_desc);
 }
 
-static ssize_t set_node_desc(struct class_device *cdev, const char *buf,
-                              size_t count)
+static ssize_t set_node_desc(struct device *device,
+                             struct device_attribute *attr,
+                             const char *buf, size_t count)
 {
-        struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);
+        struct ib_device *dev = container_of(device, struct ib_device, dev);
         struct ib_device_modify desc = {};
         int ret;
 
@@ -642,44 +647,43 @@ static ssize_t set_node_desc(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
-static CLASS_DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);
-static CLASS_DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);
-static CLASS_DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc,
-                         set_node_desc);
-
-static struct class_device_attribute *ib_class_attributes[] = {
-        &class_device_attr_node_type,
-        &class_device_attr_sys_image_guid,
-        &class_device_attr_node_guid,
-        &class_device_attr_node_desc
+static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
+static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);
+static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);
+static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc);
+
+static struct device_attribute *ib_class_attributes[] = {
+        &dev_attr_node_type,
+        &dev_attr_sys_image_guid,
+        &dev_attr_node_guid,
+        &dev_attr_node_desc
 };
 
 static struct class ib_class = {
         .name    = "infiniband",
-        .release = ib_device_release,
-        .uevent = ib_device_uevent,
+        .dev_release = ib_device_release,
+        .dev_uevent = ib_device_uevent,
 };
 
 int ib_device_register_sysfs(struct ib_device *device)
 {
-        struct class_device *class_dev = &device->class_dev;
+        struct device *class_dev = &device->dev;
         int ret;
         int i;
 
         class_dev->class      = &ib_class;
-        class_dev->class_data = device;
-        class_dev->dev        = device->dma_device;
-        strlcpy(class_dev->class_id, device->name, BUS_ID_SIZE);
+        class_dev->driver_data = device;
+        class_dev->parent     = device->dma_device;
+        strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE);
 
         INIT_LIST_HEAD(&device->port_list);
 
-        ret = class_device_register(class_dev);
+        ret = device_register(class_dev);
         if (ret)
                 goto err;
 
         for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {
-                ret = class_device_create_file(class_dev, ib_class_attributes[i]);
+                ret = device_create_file(class_dev, ib_class_attributes[i]);
                 if (ret)
                         goto err_unregister;
         }
@@ -723,7 +727,7 @@ err_put:
         kobject_put(&class_dev->kobj);
 
 err_unregister:
-        class_device_unregister(class_dev);
+        device_unregister(class_dev);
 
 err:
         return ret;
@@ -744,7 +748,7 @@ void ib_device_unregister_sysfs(struct ib_device *device)
         }
 
         kobject_put(device->ports_parent);
-        class_device_unregister(&device->class_dev);
+        device_unregister(&device->dev);
 }
 
 int ib_sysfs_setup(void)
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 4291ab42a5b9..d7a6881b571d 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -58,8 +58,8 @@ MODULE_LICENSE("Dual BSD/GPL");
 
 struct ib_ucm_device {
         int                     devnum;
-        struct cdev             dev;
-        struct class_device     class_dev;
+        struct cdev             cdev;
+        struct device           dev;
         struct ib_device        *ib_dev;
 };
 
@@ -1171,7 +1171,7 @@ static int ib_ucm_open(struct inode *inode, struct file *filp)
 
         filp->private_data = file;
         file->filp = filp;
-        file->device = container_of(inode->i_cdev, struct ib_ucm_device, dev);
+        file->device = container_of(inode->i_cdev, struct ib_ucm_device, cdev);
 
         return 0;
 }
@@ -1202,14 +1202,14 @@ static int ib_ucm_close(struct inode *inode, struct file *filp)
         return 0;
 }
 
-static void ucm_release_class_dev(struct class_device *class_dev)
+static void ib_ucm_release_dev(struct device *dev)
 {
-        struct ib_ucm_device *dev;
+        struct ib_ucm_device *ucm_dev;
 
-        dev = container_of(class_dev, struct ib_ucm_device, class_dev);
-        cdev_del(&dev->dev);
-        clear_bit(dev->devnum, dev_map);
-        kfree(dev);
+        ucm_dev = container_of(dev, struct ib_ucm_device, dev);
+        cdev_del(&ucm_dev->cdev);
+        clear_bit(ucm_dev->devnum, dev_map);
+        kfree(ucm_dev);
 }
 
 static const struct file_operations ucm_fops = {
@@ -1220,14 +1220,15 @@ static const struct file_operations ucm_fops = {
         .poll    = ib_ucm_poll,
 };
 
-static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
+static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct ib_ucm_device *dev;
+        struct ib_ucm_device *ucm_dev;
 
-        dev = container_of(class_dev, struct ib_ucm_device, class_dev);
-        return sprintf(buf, "%s\n", dev->ib_dev->name);
+        ucm_dev = container_of(dev, struct ib_ucm_device, dev);
+        return sprintf(buf, "%s\n", ucm_dev->ib_dev->name);
 }
-static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
+static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
 static void ib_ucm_add_one(struct ib_device *device)
 {
@@ -1249,32 +1250,31 @@ static void ib_ucm_add_one(struct ib_device *device)
 
         set_bit(ucm_dev->devnum, dev_map);
 
-        cdev_init(&ucm_dev->dev, &ucm_fops);
-        ucm_dev->dev.owner = THIS_MODULE;
-        kobject_set_name(&ucm_dev->dev.kobj, "ucm%d", ucm_dev->devnum);
-        if (cdev_add(&ucm_dev->dev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1))
+        cdev_init(&ucm_dev->cdev, &ucm_fops);
+        ucm_dev->cdev.owner = THIS_MODULE;
+        kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum);
+        if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1))
                 goto err;
 
-        ucm_dev->class_dev.class = &cm_class;
-        ucm_dev->class_dev.dev = device->dma_device;
-        ucm_dev->class_dev.devt = ucm_dev->dev.dev;
-        ucm_dev->class_dev.release = ucm_release_class_dev;
-        snprintf(ucm_dev->class_dev.class_id, BUS_ID_SIZE, "ucm%d",
+        ucm_dev->dev.class = &cm_class;
+        ucm_dev->dev.parent = device->dma_device;
+        ucm_dev->dev.devt = ucm_dev->cdev.dev;
+        ucm_dev->dev.release = ib_ucm_release_dev;
+        snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d",
                  ucm_dev->devnum);
-        if (class_device_register(&ucm_dev->class_dev))
+        if (device_register(&ucm_dev->dev))
                 goto err_cdev;
 
-        if (class_device_create_file(&ucm_dev->class_dev,
-                                     &class_device_attr_ibdev))
-                goto err_class;
+        if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev))
+                goto err_dev;
 
         ib_set_client_data(device, &ucm_client, ucm_dev);
         return;
 
-err_class:
-        class_device_unregister(&ucm_dev->class_dev);
+err_dev:
+        device_unregister(&ucm_dev->dev);
 err_cdev:
-        cdev_del(&ucm_dev->dev);
+        cdev_del(&ucm_dev->cdev);
         clear_bit(ucm_dev->devnum, dev_map);
 err:
         kfree(ucm_dev);
@@ -1288,7 +1288,7 @@ static void ib_ucm_remove_one(struct ib_device *device)
         if (!ucm_dev)
                 return;
 
-        class_device_unregister(&ucm_dev->class_dev);
+        device_unregister(&ucm_dev->dev);
 }
 
 static ssize_t show_abi_version(struct class *class, char *buf)
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
index be953e87bf93..3aa2db54eae4 100644
--- a/drivers/infiniband/core/user_mad.c
+++ b/drivers/infiniband/core/user_mad.c
@@ -88,11 +88,11 @@ enum {
  */
 
 struct ib_umad_port {
-        struct cdev           *dev;
-        struct class_device   *class_dev;
+        struct cdev           *cdev;
+        struct device         *dev;
 
-        struct cdev           *sm_dev;
-        struct class_device   *sm_class_dev;
+        struct cdev           *sm_cdev;
+        struct device         *sm_dev;
         struct semaphore       sm_sem;
 
         struct mutex           file_mutex;
@@ -948,27 +948,29 @@ static struct ib_client umad_client = {
         .remove = ib_umad_remove_one
 };
 
-static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
+static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct ib_umad_port *port = class_get_devdata(class_dev);
+        struct ib_umad_port *port = dev_get_drvdata(dev);
 
         if (!port)
                 return -ENODEV;
 
         return sprintf(buf, "%s\n", port->ib_dev->name);
 }
-static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
+static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
-static ssize_t show_port(struct class_device *class_dev, char *buf)
+static ssize_t show_port(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct ib_umad_port *port = class_get_devdata(class_dev);
+        struct ib_umad_port *port = dev_get_drvdata(dev);
 
         if (!port)
                 return -ENODEV;
 
         return sprintf(buf, "%d\n", port->port_num);
 }
-static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
+static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 
 static ssize_t show_abi_version(struct class *class, char *buf)
 {
@@ -994,48 +996,47 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
         mutex_init(&port->file_mutex);
         INIT_LIST_HEAD(&port->file_list);
 
-        port->dev = cdev_alloc();
-        if (!port->dev)
+        port->cdev = cdev_alloc();
+        if (!port->cdev)
                 return -1;
-        port->dev->owner = THIS_MODULE;
-        port->dev->ops   = &umad_fops;
-        kobject_set_name(&port->dev->kobj, "umad%d", port->dev_num);
-        if (cdev_add(port->dev, base_dev + port->dev_num, 1))
+        port->cdev->owner = THIS_MODULE;
+        port->cdev->ops   = &umad_fops;
+        kobject_set_name(&port->cdev->kobj, "umad%d", port->dev_num);
+        if (cdev_add(port->cdev, base_dev + port->dev_num, 1))
                 goto err_cdev;
 
-        port->class_dev = class_device_create(umad_class, NULL, port->dev->dev,
-                                              device->dma_device,
-                                              "umad%d", port->dev_num);
-        if (IS_ERR(port->class_dev))
+        port->dev = device_create(umad_class, device->dma_device,
+                                  port->cdev->dev, "umad%d", port->dev_num);
+        if (IS_ERR(port->dev))
                 goto err_cdev;
 
-        if (class_device_create_file(port->class_dev, &class_device_attr_ibdev))
-                goto err_class;
-        if (class_device_create_file(port->class_dev, &class_device_attr_port))
-                goto err_class;
-
-        port->sm_dev = cdev_alloc();
-        if (!port->sm_dev)
-                goto err_class;
-        port->sm_dev->owner = THIS_MODULE;
-        port->sm_dev->ops   = &umad_sm_fops;
-        kobject_set_name(&port->sm_dev->kobj, "issm%d", port->dev_num);
-        if (cdev_add(port->sm_dev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))
+        if (device_create_file(port->dev, &dev_attr_ibdev))
+                goto err_dev;
+        if (device_create_file(port->dev, &dev_attr_port))
+                goto err_dev;
+
+        port->sm_cdev = cdev_alloc();
+        if (!port->sm_cdev)
+                goto err_dev;
+        port->sm_cdev->owner = THIS_MODULE;
+        port->sm_cdev->ops   = &umad_sm_fops;
+        kobject_set_name(&port->sm_cdev->kobj, "issm%d", port->dev_num);
+        if (cdev_add(port->sm_cdev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))
                 goto err_sm_cdev;
 
-        port->sm_class_dev = class_device_create(umad_class, NULL, port->sm_dev->dev,
-                                                 device->dma_device,
-                                                 "issm%d", port->dev_num);
-        if (IS_ERR(port->sm_class_dev))
+        port->sm_dev = device_create(umad_class, device->dma_device,
+                                     port->sm_cdev->dev,
+                                     "issm%d", port->dev_num);
+        if (IS_ERR(port->sm_dev))
                 goto err_sm_cdev;
 
-        class_set_devdata(port->class_dev,    port);
-        class_set_devdata(port->sm_class_dev, port);
+        dev_set_drvdata(port->dev,    port);
+        dev_set_drvdata(port->sm_dev, port);
 
-        if (class_device_create_file(port->sm_class_dev, &class_device_attr_ibdev))
-                goto err_sm_class;
-        if (class_device_create_file(port->sm_class_dev, &class_device_attr_port))
-                goto err_sm_class;
+        if (device_create_file(port->sm_dev, &dev_attr_ibdev))
+                goto err_sm_dev;
+        if (device_create_file(port->sm_dev, &dev_attr_port))
+                goto err_sm_dev;
 
         spin_lock(&port_lock);
         umad_port[port->dev_num] = port;
@@ -1043,17 +1044,17 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
 
         return 0;
 
-err_sm_class:
-        class_device_destroy(umad_class, port->sm_dev->dev);
+err_sm_dev:
+        device_destroy(umad_class, port->sm_cdev->dev);
 
 err_sm_cdev:
-        cdev_del(port->sm_dev);
+        cdev_del(port->sm_cdev);
 
-err_class:
-        class_device_destroy(umad_class, port->dev->dev);
+err_dev:
+        device_destroy(umad_class, port->cdev->dev);
 
 err_cdev:
-        cdev_del(port->dev);
+        cdev_del(port->cdev);
         clear_bit(port->dev_num, dev_map);
 
         return -1;
@@ -1065,14 +1066,14 @@ static void ib_umad_kill_port(struct ib_umad_port *port)
         int already_dead;
         int id;
 
-        class_set_devdata(port->class_dev,    NULL);
-        class_set_devdata(port->sm_class_dev, NULL);
+        dev_set_drvdata(port->dev,    NULL);
+        dev_set_drvdata(port->sm_dev, NULL);
 
-        class_device_destroy(umad_class, port->dev->dev);
-        class_device_destroy(umad_class, port->sm_dev->dev);
+        device_destroy(umad_class, port->cdev->dev);
+        device_destroy(umad_class, port->sm_cdev->dev);
 
-        cdev_del(port->dev);
-        cdev_del(port->sm_dev);
+        cdev_del(port->cdev);
+        cdev_del(port->sm_cdev);
 
         spin_lock(&port_lock);
         umad_port[port->dev_num] = NULL;
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index 2cad8b4b5292..376a57ce1b40 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -73,8 +73,8 @@ struct ib_uverbs_device {
         struct kref                             ref;
         struct completion                       comp;
         int                                     devnum;
-        struct cdev                            *dev;
-        struct class_device                    *class_dev;
+        struct cdev                            *cdev;
+        struct device                          *dev;
         struct ib_device                       *ib_dev;
         int                                     num_comp_vectors;
 };
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index f49f94653a96..cc1afa28c181 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -690,27 +690,29 @@ static struct ib_client uverbs_client = {
         .remove = ib_uverbs_remove_one
 };
 
-static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
+static ssize_t show_ibdev(struct device *device, struct device_attribute *attr,
+                          char *buf)
 {
-        struct ib_uverbs_device *dev = class_get_devdata(class_dev);
+        struct ib_uverbs_device *dev = dev_get_drvdata(device);
 
         if (!dev)
                 return -ENODEV;
 
         return sprintf(buf, "%s\n", dev->ib_dev->name);
 }
-static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
+static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
-static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf)
+static ssize_t show_dev_abi_version(struct device *device,
+                                    struct device_attribute *attr, char *buf)
 {
-        struct ib_uverbs_device *dev = class_get_devdata(class_dev);
+        struct ib_uverbs_device *dev = dev_get_drvdata(device);
 
         if (!dev)
                 return -ENODEV;
 
         return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver);
 }
-static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);
+static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);
 
 static ssize_t show_abi_version(struct class *class, char *buf)
 {
@@ -744,27 +746,26 @@ static void ib_uverbs_add_one(struct ib_device *device)
         uverbs_dev->ib_dev           = device;
         uverbs_dev->num_comp_vectors = device->num_comp_vectors;
 
-        uverbs_dev->dev = cdev_alloc();
-        if (!uverbs_dev->dev)
+        uverbs_dev->cdev = cdev_alloc();
+        if (!uverbs_dev->cdev)
                 goto err;
-        uverbs_dev->dev->owner = THIS_MODULE;
-        uverbs_dev->dev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops;
-        kobject_set_name(&uverbs_dev->dev->kobj, "uverbs%d", uverbs_dev->devnum);
-        if (cdev_add(uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))
+        uverbs_dev->cdev->owner = THIS_MODULE;
+        uverbs_dev->cdev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops;
+        kobject_set_name(&uverbs_dev->cdev->kobj, "uverbs%d", uverbs_dev->devnum);
+        if (cdev_add(uverbs_dev->cdev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))
                 goto err_cdev;
 
-        uverbs_dev->class_dev = class_device_create(uverbs_class, NULL,
-                                                    uverbs_dev->dev->dev,
-                                                    device->dma_device,
-                                                    "uverbs%d", uverbs_dev->devnum);
-        if (IS_ERR(uverbs_dev->class_dev))
+        uverbs_dev->dev = device_create(uverbs_class, device->dma_device,
+                                        uverbs_dev->cdev->dev,
+                                        "uverbs%d", uverbs_dev->devnum);
+        if (IS_ERR(uverbs_dev->dev))
                 goto err_cdev;
 
-        class_set_devdata(uverbs_dev->class_dev, uverbs_dev);
+        dev_set_drvdata(uverbs_dev->dev, uverbs_dev);
 
-        if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_ibdev))
+        if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev))
                 goto err_class;
-        if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_abi_version))
+        if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version))
                 goto err_class;
 
         spin_lock(&map_lock);
@@ -776,10 +777,10 @@ static void ib_uverbs_add_one(struct ib_device *device)
         return;
 
 err_class:
-        class_device_destroy(uverbs_class, uverbs_dev->dev->dev);
+        device_destroy(uverbs_class, uverbs_dev->cdev->dev);
 
 err_cdev:
-        cdev_del(uverbs_dev->dev);
+        cdev_del(uverbs_dev->cdev);
         clear_bit(uverbs_dev->devnum, dev_map);
 
 err:
@@ -796,9 +797,9 @@ static void ib_uverbs_remove_one(struct ib_device *device)
         if (!uverbs_dev)
                 return;
 
-        class_set_devdata(uverbs_dev->class_dev, NULL);
-        class_device_destroy(uverbs_class, uverbs_dev->dev->dev);
-        cdev_del(uverbs_dev->dev);
+        dev_set_drvdata(uverbs_dev->dev, NULL);
+        device_destroy(uverbs_class, uverbs_dev->cdev->dev);
+        cdev_del(uverbs_dev->cdev);
 
         spin_lock(&map_lock);
         dev_table[uverbs_dev->devnum] = NULL;
diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c
index e10d27a6e145..6af2c0f79a67 100644
--- a/drivers/infiniband/hw/amso1100/c2_provider.c
+++ b/drivers/infiniband/hw/amso1100/c2_provider.c
@@ -523,45 +523,49 @@ static int c2_dereg_mr(struct ib_mr *ib_mr)
         return err;
 }
 
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
+        struct c2_dev *c2dev = container_of(dev, struct c2_dev, ibdev.dev);
         pr_debug("%s:%u\n", __func__, __LINE__);
-        return sprintf(buf, "%x\n", dev->props.hw_ver);
+        return sprintf(buf, "%x\n", c2dev->props.hw_ver);
 }
 
-static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
+static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
-        struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
+        struct c2_dev *c2dev = container_of(dev, struct c2_dev, ibdev.dev);
         pr_debug("%s:%u\n", __func__, __LINE__);
         return sprintf(buf, "%x.%x.%x\n",
-                       (int) (dev->props.fw_ver >> 32),
-                       (int) (dev->props.fw_ver >> 16) & 0xffff,
-                       (int) (dev->props.fw_ver & 0xffff));
+                       (int) (c2dev->props.fw_ver >> 32),
+                       (int) (c2dev->props.fw_ver >> 16) & 0xffff,
+                       (int) (c2dev->props.fw_ver & 0xffff));
 }
 
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
         pr_debug("%s:%u\n", __func__, __LINE__);
         return sprintf(buf, "AMSO1100\n");
 }
 
-static ssize_t show_board(struct class_device *cdev, char *buf)
+static ssize_t show_board(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         pr_debug("%s:%u\n", __func__, __LINE__);
         return sprintf(buf, "%.*s\n", 32, "AMSO1100 Board ID");
 }
 
-static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
-static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
+static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
+static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
 
-static struct class_device_attribute *c2_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_fw_ver,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id
+static struct device_attribute *c2_dev_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_fw_ver,
+        &dev_attr_hca_type,
+        &dev_attr_board_id
 };
 
 static int c2_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
@@ -861,9 +865,9 @@ int c2_register_device(struct c2_dev *dev)
         if (ret)
                 goto out1;
 
-        for (i = 0; i < ARRAY_SIZE(c2_class_attributes); ++i) {
-                ret = class_device_create_file(&dev->ibdev.class_dev,
-                                               c2_class_attributes[i]);
+        for (i = 0; i < ARRAY_SIZE(c2_dev_attributes); ++i) {
+                ret = device_create_file(&dev->ibdev.dev,
+                                               c2_dev_attributes[i]);
                 if (ret)
                         goto out0;
         }
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index ca7265443c05..ab4695c1dd56 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -1041,61 +1041,60 @@ static int iwch_query_port(struct ib_device *ibdev,
         return 0;
 }
 
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
-                                            ibdev.class_dev);
-        PDBG("%s class dev 0x%p\n", __func__, cdev);
-        return sprintf(buf, "%d\n", dev->rdev.t3cdev_p->type);
+        struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev,
+                                                 ibdev.dev);
+        PDBG("%s dev 0x%p\n", __func__, dev);
+        return sprintf(buf, "%d\n", iwch_dev->rdev.t3cdev_p->type);
 }
 
-static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
+static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
-                                            ibdev.class_dev);
+        struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev,
+                                                 ibdev.dev);
         struct ethtool_drvinfo info;
-        struct net_device *lldev = dev->rdev.t3cdev_p->lldev;
+        struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev;
 
-        PDBG("%s class dev 0x%p\n", __func__, cdev);
-        rtnl_lock();
+        PDBG("%s dev 0x%p\n", __func__, dev);
         lldev->ethtool_ops->get_drvinfo(lldev, &info);
-        rtnl_unlock();
         return sprintf(buf, "%s\n", info.fw_version);
 }
 
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
-                                            ibdev.class_dev);
+        struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev,
+                                                 ibdev.dev);
         struct ethtool_drvinfo info;
-        struct net_device *lldev = dev->rdev.t3cdev_p->lldev;
+        struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev;
 
-        PDBG("%s class dev 0x%p\n", __func__, cdev);
-        rtnl_lock();
+        PDBG("%s dev 0x%p\n", __func__, dev);
         lldev->ethtool_ops->get_drvinfo(lldev, &info);
-        rtnl_unlock();
         return sprintf(buf, "%s\n", info.driver);
 }
 
-static ssize_t show_board(struct class_device *cdev, char *buf)
+static ssize_t show_board(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
-                                            ibdev.class_dev);
-        PDBG("%s class dev 0x%p\n", __func__, dev);
-        return sprintf(buf, "%x.%x\n", dev->rdev.rnic_info.pdev->vendor,
-                                       dev->rdev.rnic_info.pdev->device);
+        struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev,
+                                                 ibdev.dev);
+        PDBG("%s dev 0x%p\n", __func__, dev);
+        return sprintf(buf, "%x.%x\n", iwch_dev->rdev.rnic_info.pdev->vendor,
+                       iwch_dev->rdev.rnic_info.pdev->device);
 }
 
-static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
-static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
+static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
+static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
 
-static struct class_device_attribute *iwch_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_fw_ver,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id
+static struct device_attribute *iwch_class_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_fw_ver,
+        &dev_attr_hca_type,
+        &dev_attr_board_id
 };
 
 int iwch_register_device(struct iwch_dev *dev)
@@ -1189,8 +1188,8 @@ int iwch_register_device(struct iwch_dev *dev)
                 goto bail1;
 
         for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i) {
-                ret = class_device_create_file(&dev->ibdev.class_dev,
-                                               iwch_class_attributes[i]);
+                ret = device_create_file(&dev->ibdev.dev,
+                                         iwch_class_attributes[i]);
                 if (ret) {
                         goto bail2;
                 }
@@ -1208,8 +1207,8 @@ void iwch_unregister_device(struct iwch_dev *dev)
 
         PDBG("%s iwch_dev %p\n", __func__, dev);
         for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i)
-                class_device_remove_file(&dev->ibdev.class_dev,
-                                         iwch_class_attributes[i]);
+                device_remove_file(&dev->ibdev.dev,
+                                   iwch_class_attributes[i]);
         ib_unregister_device(&dev->ibdev);
         return;
 }
diff --git a/drivers/infiniband/hw/ipath/ipath_diag.c b/drivers/infiniband/hw/ipath/ipath_diag.c
index 6d49d2f18a88..d4ce8b63e19e 100644
--- a/drivers/infiniband/hw/ipath/ipath_diag.c
+++ b/drivers/infiniband/hw/ipath/ipath_diag.c
@@ -79,7 +79,7 @@ static const struct file_operations diagpkt_file_ops = {
 
 static atomic_t diagpkt_count = ATOMIC_INIT(0);
 static struct cdev *diagpkt_cdev;
-static struct class_device *diagpkt_class_dev;
+static struct device *diagpkt_dev;
 
 int ipath_diag_add(struct ipath_devdata *dd)
 {
@@ -89,7 +89,7 @@ int ipath_diag_add(struct ipath_devdata *dd)
         if (atomic_inc_return(&diagpkt_count) == 1) {
                 ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
                                       "ipath_diagpkt", &diagpkt_file_ops,
-                                      &diagpkt_cdev, &diagpkt_class_dev);
+                                      &diagpkt_cdev, &diagpkt_dev);
 
                 if (ret) {
                         ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
@@ -102,7 +102,7 @@ int ipath_diag_add(struct ipath_devdata *dd)
 
         ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
                               &diag_file_ops, &dd->diag_cdev,
-                              &dd->diag_class_dev);
+                              &dd->diag_dev);
         if (ret)
                 ipath_dev_err(dd, "Couldn't create %s device: %d",
                               name, ret);
@@ -114,9 +114,9 @@ done:
 void ipath_diag_remove(struct ipath_devdata *dd)
 {
         if (atomic_dec_and_test(&diagpkt_count))
-                ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev);
+                ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev);
 
-        ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev);
+        ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev);
 }
 
 /**
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index 1e627aab18bf..8b1752202e78 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -2434,11 +2434,11 @@ static ssize_t ipath_writev(struct kiocb *iocb, const struct iovec *iov,
 static struct class *ipath_class;
 
 static int init_cdev(int minor, char *name, const struct file_operations *fops,
-                     struct cdev **cdevp, struct class_device **class_devp)
+                     struct cdev **cdevp, struct device **devp)
 {
         const dev_t dev = MKDEV(IPATH_MAJOR, minor);
         struct cdev *cdev = NULL;
-        struct class_device *class_dev = NULL;
+        struct device *device = NULL;
         int ret;
 
         cdev = cdev_alloc();
@@ -2462,12 +2462,12 @@ static int init_cdev(int minor, char *name, const struct file_operations *fops,
                 goto err_cdev;
         }
 
-        class_dev = class_device_create(ipath_class, NULL, dev, NULL, name);
+        device = device_create(ipath_class, NULL, dev, name);
 
-        if (IS_ERR(class_dev)) {
-                ret = PTR_ERR(class_dev);
+        if (IS_ERR(device)) {
+                ret = PTR_ERR(device);
                 printk(KERN_ERR IPATH_DRV_NAME ": Could not create "
-                       "class_dev for minor %d, %s (err %d)\n",
+                       "device for minor %d, %s (err %d)\n",
                        minor, name, -ret);
                 goto err_cdev;
         }
@@ -2481,29 +2481,29 @@ err_cdev:
 done:
         if (ret >= 0) {
                 *cdevp = cdev;
-                *class_devp = class_dev;
+                *devp = device;
         } else {
                 *cdevp = NULL;
-                *class_devp = NULL;
+                *devp = NULL;
         }
 
         return ret;
 }
 
 int ipath_cdev_init(int minor, char *name, const struct file_operations *fops,
-                    struct cdev **cdevp, struct class_device **class_devp)
+                    struct cdev **cdevp, struct device **devp)
 {
-        return init_cdev(minor, name, fops, cdevp, class_devp);
+        return init_cdev(minor, name, fops, cdevp, devp);
 }
 
 static void cleanup_cdev(struct cdev **cdevp,
-                         struct class_device **class_devp)
+                         struct device **devp)
 {
-        struct class_device *class_dev = *class_devp;
+        struct device *dev = *devp;
 
-        if (class_dev) {
-                class_device_unregister(class_dev);
-                *class_devp = NULL;
+        if (dev) {
+                device_unregister(dev);
+                *devp = NULL;
         }
 
         if (*cdevp) {
@@ -2513,13 +2513,13 @@ static void cleanup_cdev(struct cdev **cdevp,
 }
 
 void ipath_cdev_cleanup(struct cdev **cdevp,
-                        struct class_device **class_devp)
+                        struct device **devp)
 {
-        cleanup_cdev(cdevp, class_devp);
+        cleanup_cdev(cdevp, devp);
 }
 
 static struct cdev *wildcard_cdev;
-static struct class_device *wildcard_class_dev;
+static struct device *wildcard_dev;
 
 static const dev_t dev = MKDEV(IPATH_MAJOR, 0);
 
@@ -2576,7 +2576,7 @@ int ipath_user_add(struct ipath_devdata *dd)
                         goto bail;
                 }
                 ret = init_cdev(0, "ipath", &ipath_file_ops, &wildcard_cdev,
-                                &wildcard_class_dev);
+                                &wildcard_dev);
                 if (ret < 0) {
                         ipath_dev_err(dd, "Could not create wildcard "
                                       "minor: error %d\n", -ret);
@@ -2589,7 +2589,7 @@ int ipath_user_add(struct ipath_devdata *dd)
         snprintf(name, sizeof(name), "ipath%d", dd->ipath_unit);
 
         ret = init_cdev(dd->ipath_unit + 1, name, &ipath_file_ops,
-                        &dd->user_cdev, &dd->user_class_dev);
+                        &dd->user_cdev, &dd->user_dev);
         if (ret < 0)
                 ipath_dev_err(dd, "Could not create user minor %d, %s\n",
                               dd->ipath_unit + 1, name);
@@ -2604,13 +2604,13 @@ bail:
 
 void ipath_user_remove(struct ipath_devdata *dd)
 {
-        cleanup_cdev(&dd->user_cdev, &dd->user_class_dev);
+        cleanup_cdev(&dd->user_cdev, &dd->user_dev);
 
         if (atomic_dec_return(&user_count) == 0) {
                 if (atomic_read(&user_setup) == 0)
                         goto bail;
 
-                cleanup_cdev(&wildcard_cdev, &wildcard_class_dev);
+                cleanup_cdev(&wildcard_cdev, &wildcard_dev);
                 user_cleanup();
 
                 atomic_set(&user_setup, 0);
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index 5863cbe99303..202337ae90dc 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -466,8 +466,8 @@ struct ipath_devdata {
         struct pci_dev *pcidev;
         struct cdev *user_cdev;
         struct cdev *diag_cdev;
-        struct class_device *user_class_dev;
-        struct class_device *diag_class_dev;
+        struct device *user_dev;
+        struct device *diag_dev;
         /* timer used to prevent stats overflow, error throttling, etc. */
         struct timer_list ipath_stats_timer;
         /* timer to verify interrupts work, and fallback if possible */
@@ -854,9 +854,9 @@ void ipath_clear_freeze(struct ipath_devdata *);
 
 struct file_operations;
 int ipath_cdev_init(int minor, char *name, const struct file_operations *fops,
-                    struct cdev **cdevp, struct class_device **class_devp);
+                    struct cdev **cdevp, struct device **devp);
 void ipath_cdev_cleanup(struct cdev **cdevp,
-                        struct class_device **class_devp);
+                        struct device **devp);
 
 int ipath_diag_add(struct ipath_devdata *);
 void ipath_diag_remove(struct ipath_devdata *);
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index 320a6d018de7..c38f9aa8be8d 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -2172,18 +2172,20 @@ void ipath_unregister_ib_device(struct ipath_ibdev *dev)
         ib_dealloc_device(ibdev);
 }
 
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
         struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+                container_of(device, struct ipath_ibdev, ibdev.dev);
 
         return sprintf(buf, "%x\n", dev->dd->ipath_pcirev);
 }
 
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
         struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+                container_of(device, struct ipath_ibdev, ibdev.dev);
         int ret;
 
         ret = dev->dd->ipath_f_get_boardname(dev->dd, buf, 128);
@@ -2196,10 +2198,11 @@ bail:
         return ret;
 }
 
-static ssize_t show_stats(struct class_device *cdev, char *buf)
+static ssize_t show_stats(struct device *device, struct device_attribute *attr,
+                          char *buf)
 {
         struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+                container_of(device, struct ipath_ibdev, ibdev.dev);
         int i;
         int len;
 
@@ -2237,16 +2240,16 @@ static ssize_t show_stats(struct class_device *cdev, char *buf)
         return len;
 }
 
-static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL);
-static CLASS_DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
+static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL);
+static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
 
-static struct class_device_attribute *ipath_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id,
-        &class_device_attr_stats
+static struct device_attribute *ipath_class_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_hca_type,
+        &dev_attr_board_id,
+        &dev_attr_stats
 };
 
 static int ipath_verbs_register_sysfs(struct ib_device *dev)
@@ -2255,8 +2258,8 @@ static int ipath_verbs_register_sysfs(struct ib_device *dev)
         int ret;
 
         for (i = 0; i < ARRAY_SIZE(ipath_class_attributes); ++i)
-                if (class_device_create_file(&dev->class_dev,
-                                             ipath_class_attributes[i])) {
+                if (device_create_file(&dev->dev,
+                                       ipath_class_attributes[i])) {
                         ret = 1;
                         goto bail;
                 }
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 136c76c7b4e7..4d9b5ac42202 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -481,42 +481,51 @@ out:
         return err;
 }
 
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
-        struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev);
+        struct mlx4_ib_dev *dev =
+                container_of(device, struct mlx4_ib_dev, ib_dev.dev);
         return sprintf(buf, "MT%d\n", dev->dev->pdev->device);
 }
 
-static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
+static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
+                           char *buf)
 {
-        struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev);
+        struct mlx4_ib_dev *dev =
+                container_of(device, struct mlx4_ib_dev, ib_dev.dev);
         return sprintf(buf, "%d.%d.%d\n", (int) (dev->dev->caps.fw_ver >> 32),
                        (int) (dev->dev->caps.fw_ver >> 16) & 0xffff,
                        (int) dev->dev->caps.fw_ver & 0xffff);
 }
 
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
-        struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev);
+        struct mlx4_ib_dev *dev =
+                container_of(device, struct mlx4_ib_dev, ib_dev.dev);
         return sprintf(buf, "%x\n", dev->dev->rev_id);
 }
 
-static ssize_t show_board(struct class_device *cdev, char *buf)
+static ssize_t show_board(struct device *device, struct device_attribute *attr,
+                          char *buf)
 {
-        struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev);
-        return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN, dev->dev->board_id);
+        struct mlx4_ib_dev *dev =
+                container_of(device, struct mlx4_ib_dev, ib_dev.dev);
+        return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN,
+                       dev->dev->board_id);
 }
 
-static CLASS_DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
-static CLASS_DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
+static DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
+static DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
 
-static struct class_device_attribute *mlx4_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_fw_ver,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id
+static struct device_attribute *mlx4_class_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_fw_ver,
+        &dev_attr_hca_type,
+        &dev_attr_board_id
 };
 
 static void *mlx4_ib_add(struct mlx4_dev *dev)
@@ -640,8 +649,8 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
                 goto err_reg;
 
         for (i = 0; i < ARRAY_SIZE(mlx4_class_attributes); ++i) {
-                if (class_device_create_file(&ibdev->ib_dev.class_dev,
-                                               mlx4_class_attributes[i]))
+                if (device_create_file(&ibdev->ib_dev.dev,
+                                       mlx4_class_attributes[i]))
                         goto err_reg;
         }
 
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 81b257e18bb6..696e1f302332 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -1170,23 +1170,29 @@ static int mthca_unmap_fmr(struct list_head *fmr_list)
         return 0;
 }
 
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
-        struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
+        struct mthca_dev *dev =
+                container_of(device, struct mthca_dev, ib_dev.dev);
         return sprintf(buf, "%x\n", dev->rev_id);
 }
 
-static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
+static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
+                           char *buf)
 {
-        struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
+        struct mthca_dev *dev =
+                container_of(device, struct mthca_dev, ib_dev.dev);
         return sprintf(buf, "%d.%d.%d\n", (int) (dev->fw_ver >> 32),
                        (int) (dev->fw_ver >> 16) & 0xffff,
                        (int) dev->fw_ver & 0xffff);
 }
 
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *device, struct device_attribute *attr,
+                        char *buf)
 {
-        struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
+        struct mthca_dev *dev =
+                container_of(device, struct mthca_dev, ib_dev.dev);
         switch (dev->pdev->device) {
         case PCI_DEVICE_ID_MELLANOX_TAVOR:
                 return sprintf(buf, "MT23108\n");
@@ -1202,22 +1208,24 @@ static ssize_t show_hca(struct class_device *cdev, char *buf)
         }
 }
 
-static ssize_t show_board(struct class_device *cdev, char *buf)
+static ssize_t show_board(struct device *device, struct device_attribute *attr,
+                          char *buf)
 {
-        struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
+        struct mthca_dev *dev =
+                container_of(device, struct mthca_dev, ib_dev.dev);
         return sprintf(buf, "%.*s\n", MTHCA_BOARD_ID_LEN, dev->board_id);
 }
 
-static CLASS_DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
-static CLASS_DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
+static DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
+static DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
 
-static struct class_device_attribute *mthca_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_fw_ver,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id
+static struct device_attribute *mthca_dev_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_fw_ver,
+        &dev_attr_hca_type,
+        &dev_attr_board_id
 };
 
 static int mthca_init_node_data(struct mthca_dev *dev)
@@ -1379,9 +1387,9 @@ int mthca_register_device(struct mthca_dev *dev)
         if (ret)
                 return ret;
 
-        for (i = 0; i < ARRAY_SIZE(mthca_class_attributes); ++i) {
-                ret = class_device_create_file(&dev->ib_dev.class_dev,
-                                               mthca_class_attributes[i]);
+        for (i = 0; i < ARRAY_SIZE(mthca_dev_attributes); ++i) {
+                ret = device_create_file(&dev->ib_dev.dev,
+                                         mthca_dev_attributes[i]);
                 if (ret) {
                         ib_unregister_device(&dev->ib_dev);
                         return ret;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index 7c27420c2240..f9a5d4390892 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -2800,10 +2800,11 @@ static int nes_dereg_mr(struct ib_mr *ib_mr)
 /**
  * show_rev
  */
-static ssize_t show_rev(struct class_device *cdev, char *buf)
+static ssize_t show_rev(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
         struct nes_ib_device *nesibdev =
-                        container_of(cdev, struct nes_ib_device, ibdev.class_dev);
+                        container_of(dev, struct nes_ib_device, ibdev.dev);
         struct nes_vnic *nesvnic = nesibdev->nesvnic;
 
         nes_debug(NES_DBG_INIT, "\n");
@@ -2814,10 +2815,11 @@ static ssize_t show_rev(struct class_device *cdev, char *buf)
 /**
  * show_fw_ver
  */
-static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
+static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
         struct nes_ib_device *nesibdev =
-                        container_of(cdev, struct nes_ib_device, ibdev.class_dev);
+                        container_of(dev, struct nes_ib_device, ibdev.dev);
         struct nes_vnic *nesvnic = nesibdev->nesvnic;
 
         nes_debug(NES_DBG_INIT, "\n");
@@ -2831,7 +2833,8 @@ static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
 /**
  * show_hca
  */
-static ssize_t show_hca(struct class_device *cdev, char *buf)
+static ssize_t show_hca(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
         nes_debug(NES_DBG_INIT, "\n");
         return sprintf(buf, "NES020\n");
@@ -2841,23 +2844,24 @@ static ssize_t show_hca(struct class_device *cdev, char *buf)
 /**
  * show_board
  */
-static ssize_t show_board(struct class_device *cdev, char *buf)
+static ssize_t show_board(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         nes_debug(NES_DBG_INIT, "\n");
         return sprintf(buf, "%.*s\n", 32, "NES020 Board ID");
 }
 
 
-static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
-static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
-static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
-static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
+static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
+static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
+static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
+static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
 
-static struct class_device_attribute *nes_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_fw_ver,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id
+static struct device_attribute *nes_dev_attributes[] = {
+        &dev_attr_hw_rev,
+        &dev_attr_fw_ver,
+        &dev_attr_hca_type,
+        &dev_attr_board_id
 };
 
 
@@ -3782,7 +3786,7 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
         nesibdev->ibdev.phys_port_cnt = 1;
         nesibdev->ibdev.num_comp_vectors = 1;
         nesibdev->ibdev.dma_device = &nesdev->pcidev->dev;
-        nesibdev->ibdev.class_dev.dev = &nesdev->pcidev->dev;
+        nesibdev->ibdev.dev.parent = &nesdev->pcidev->dev;
         nesibdev->ibdev.query_device = nes_query_device;
         nesibdev->ibdev.query_port = nes_query_port;
         nesibdev->ibdev.modify_port = nes_modify_port;
@@ -3877,13 +3881,13 @@ int nes_register_ofa_device(struct nes_ib_device *nesibdev)
         nesibdev->max_qp = (nesadapter->max_qp-NES_FIRST_QPN) / nesadapter->port_count;
         nesibdev->max_pd = nesadapter->max_pd / nesadapter->port_count;
 
-        for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) {
-                ret = class_device_create_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]);
+        for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) {
+                ret = device_create_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]);
                 if (ret) {
                         while (i > 0) {
                                 i--;
-                                class_device_remove_file(&nesibdev->ibdev.class_dev,
-                                                nes_class_attributes[i]);
+                                device_remove_file(&nesibdev->ibdev.dev,
+                                                   nes_dev_attributes[i]);
                         }
                         ib_unregister_device(&nesibdev->ibdev);
                         return ret;
@@ -3904,8 +3908,8 @@ static void nes_unregister_ofa_device(struct nes_ib_device *nesibdev)
         struct nes_vnic *nesvnic = nesibdev->nesvnic;
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) {
-                class_device_remove_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]);
+        for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) {
+                device_remove_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]);
         }
 
         if (nesvnic->of_device_registered) {
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 125765aa9d59..435145709dd6 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -139,8 +139,9 @@ static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size,
         if (!iu->buf)
                 goto out_free_iu;
 
-        iu->dma = ib_dma_map_single(host->dev->dev, iu->buf, size, direction);
-        if (ib_dma_mapping_error(host->dev->dev, iu->dma))
+        iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size,
+                                    direction);
+        if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
                 goto out_free_buf;
 
         iu->size      = size;
@@ -161,7 +162,8 @@ static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
         if (!iu)
                 return;
 
-        ib_dma_unmap_single(host->dev->dev, iu->dma, iu->size, iu->direction);
+        ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
+                            iu->direction);
         kfree(iu->buf);
         kfree(iu);
 }
@@ -181,7 +183,7 @@ static int srp_init_qp(struct srp_target_port *target,
         if (!attr)
                 return -ENOMEM;
 
-        ret = ib_find_cached_pkey(target->srp_host->dev->dev,
+        ret = ib_find_cached_pkey(target->srp_host->srp_dev->dev,
                                   target->srp_host->port,
                                   be16_to_cpu(target->path.pkey),
                                   &attr->pkey_index);
@@ -208,7 +210,7 @@ static int srp_new_cm_id(struct srp_target_port *target)
 {
         struct ib_cm_id *new_cm_id;
 
-        new_cm_id = ib_create_cm_id(target->srp_host->dev->dev,
+        new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
                                     srp_cm_handler, target);
         if (IS_ERR(new_cm_id))
                 return PTR_ERR(new_cm_id);
@@ -229,8 +231,8 @@ static int srp_create_target_ib(struct srp_target_port *target)
         if (!init_attr)
                 return -ENOMEM;
 
-        target->cq = ib_create_cq(target->srp_host->dev->dev, srp_completion,
-                                  NULL, target, SRP_CQ_SIZE, 0);
+        target->cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                  srp_completion, NULL, target, SRP_CQ_SIZE, 0);
         if (IS_ERR(target->cq)) {
                 ret = PTR_ERR(target->cq);
                 goto out;
@@ -248,7 +250,7 @@ static int srp_create_target_ib(struct srp_target_port *target)
         init_attr->send_cq             = target->cq;
         init_attr->recv_cq             = target->cq;
 
-        target->qp = ib_create_qp(target->srp_host->dev->pd, init_attr);
+        target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
         if (IS_ERR(target->qp)) {
                 ret = PTR_ERR(target->qp);
                 ib_destroy_cq(target->cq);
@@ -302,7 +304,7 @@ static int srp_lookup_path(struct srp_target_port *target)
         init_completion(&target->done);
 
         target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
-                                                   target->srp_host->dev->dev,
+                                                   target->srp_host->srp_dev->dev,
                                                    target->srp_host->port,
                                                    &target->path,
                                                    IB_SA_PATH_REC_SERVICE_ID    |
@@ -403,7 +405,7 @@ static int srp_send_req(struct srp_target_port *target)
                              (unsigned long long) be64_to_cpu(target->ioc_guid));
                 memset(req->priv.initiator_port_id, 0, 8);
                 memcpy(req->priv.initiator_port_id + 8,
-                       &target->srp_host->dev->dev->node_guid, 8);
+                       &target->srp_host->srp_dev->dev->node_guid, 8);
         }
 
         status = ib_send_cm_req(target->cm_id, &req->param);
@@ -520,7 +522,7 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
                 req->fmr = NULL;
         }
 
-        ib_dma_unmap_sg(target->srp_host->dev->dev, scsi_sglist(scmnd),
+        ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd),
                         scsi_sg_count(scmnd), scmnd->sc_data_direction);
 }
 
@@ -628,7 +630,7 @@ static int srp_map_fmr(struct srp_target_port *target, struct scatterlist *scat,
         int page_cnt;
         int i, j;
         int ret;
-        struct srp_device *dev = target->srp_host->dev;
+        struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_device *ibdev = dev->dev;
         struct scatterlist *sg;
 
@@ -723,7 +725,7 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
         nents = scsi_sg_count(scmnd);
         scat  = scsi_sglist(scmnd);
 
-        dev = target->srp_host->dev;
+        dev = target->srp_host->srp_dev;
         ibdev = dev->dev;
 
         count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
@@ -779,7 +781,7 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
                 buf->table_desc.va  =
                         cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf);
                 buf->table_desc.key =
-                        cpu_to_be32(target->srp_host->dev->mr->rkey);
+                        cpu_to_be32(target->srp_host->srp_dev->mr->rkey);
                 buf->table_desc.len =
                         cpu_to_be32(count * sizeof (struct srp_direct_buf));
 
@@ -855,7 +857,7 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
 
         iu = target->rx_ring[wc->wr_id & ~SRP_OP_RECV];
 
-        dev = target->srp_host->dev->dev;
+        dev = target->srp_host->srp_dev->dev;
         ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
                                    DMA_FROM_DEVICE);
 
@@ -937,7 +939,7 @@ static int __srp_post_recv(struct srp_target_port *target)
 
         list.addr   = iu->dma;
         list.length = iu->size;
-        list.lkey   = target->srp_host->dev->mr->lkey;
+        list.lkey   = target->srp_host->srp_dev->mr->lkey;
 
         wr.next     = NULL;
         wr.sg_list  = &list;
@@ -996,7 +998,7 @@ static int __srp_post_send(struct srp_target_port *target,
 
         list.addr   = iu->dma;
         list.length = len;
-        list.lkey   = target->srp_host->dev->mr->lkey;
+        list.lkey   = target->srp_host->srp_dev->mr->lkey;
 
         wr.next       = NULL;
         wr.wr_id      = target->tx_head & SRP_SQ_SIZE;
@@ -1039,7 +1041,7 @@ static int srp_queuecommand(struct scsi_cmnd *scmnd,
         if (!iu)
                 goto err;
 
-        dev = target->srp_host->dev->dev;
+        dev = target->srp_host->srp_dev->dev;
         ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len,
                                    DMA_TO_DEVICE);
 
@@ -1456,9 +1458,10 @@ static int srp_reset_host(struct scsi_cmnd *scmnd)
         return ret;
 }
 
-static ssize_t show_id_ext(struct class_device *cdev, char *buf)
+static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1468,9 +1471,10 @@ static ssize_t show_id_ext(struct class_device *cdev, char *buf)
                        (unsigned long long) be64_to_cpu(target->id_ext));
 }
 
-static ssize_t show_ioc_guid(struct class_device *cdev, char *buf)
+static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1480,9 +1484,10 @@ static ssize_t show_ioc_guid(struct class_device *cdev, char *buf)
                        (unsigned long long) be64_to_cpu(target->ioc_guid));
 }
 
-static ssize_t show_service_id(struct class_device *cdev, char *buf)
+static ssize_t show_service_id(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1492,9 +1497,10 @@ static ssize_t show_service_id(struct class_device *cdev, char *buf)
                        (unsigned long long) be64_to_cpu(target->service_id));
 }
 
-static ssize_t show_pkey(struct class_device *cdev, char *buf)
+static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1503,9 +1509,10 @@ static ssize_t show_pkey(struct class_device *cdev, char *buf)
         return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
 }
 
-static ssize_t show_dgid(struct class_device *cdev, char *buf)
+static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1522,9 +1529,10 @@ static ssize_t show_dgid(struct class_device *cdev, char *buf)
                        be16_to_cpu(((__be16 *) target->path.dgid.raw)[7]));
 }
 
-static ssize_t show_orig_dgid(struct class_device *cdev, char *buf)
+static ssize_t show_orig_dgid(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1541,9 +1549,10 @@ static ssize_t show_orig_dgid(struct class_device *cdev, char *buf)
                        be16_to_cpu(target->orig_dgid[7]));
 }
 
-static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf)
+static ssize_t show_zero_req_lim(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         if (target->state == SRP_TARGET_DEAD ||
             target->state == SRP_TARGET_REMOVED)
@@ -1552,40 +1561,42 @@ static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf)
         return sprintf(buf, "%d\n", target->zero_req_lim);
 }
 
-static ssize_t show_local_ib_port(struct class_device *cdev, char *buf)
+static ssize_t show_local_ib_port(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
         return sprintf(buf, "%d\n", target->srp_host->port);
 }
 
-static ssize_t show_local_ib_device(struct class_device *cdev, char *buf)
+static ssize_t show_local_ib_device(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
 {
-        struct srp_target_port *target = host_to_target(class_to_shost(cdev));
+        struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "%s\n", target->srp_host->dev->dev->name);
+        return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
 }
 
-static CLASS_DEVICE_ATTR(id_ext,          S_IRUGO, show_id_ext,          NULL);
-static CLASS_DEVICE_ATTR(ioc_guid,        S_IRUGO, show_ioc_guid,        NULL);
-static CLASS_DEVICE_ATTR(service_id,      S_IRUGO, show_service_id,      NULL);
-static CLASS_DEVICE_ATTR(pkey,            S_IRUGO, show_pkey,            NULL);
-static CLASS_DEVICE_ATTR(dgid,            S_IRUGO, show_dgid,            NULL);
-static CLASS_DEVICE_ATTR(orig_dgid,       S_IRUGO, show_orig_dgid,       NULL);
-static CLASS_DEVICE_ATTR(zero_req_lim,    S_IRUGO, show_zero_req_lim,    NULL);
-static CLASS_DEVICE_ATTR(local_ib_port,   S_IRUGO, show_local_ib_port,   NULL);
-static CLASS_DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
-
-static struct class_device_attribute *srp_host_attrs[] = {
-        &class_device_attr_id_ext,
-        &class_device_attr_ioc_guid,
-        &class_device_attr_service_id,
-        &class_device_attr_pkey,
-        &class_device_attr_dgid,
-        &class_device_attr_orig_dgid,
-        &class_device_attr_zero_req_lim,
-        &class_device_attr_local_ib_port,
-        &class_device_attr_local_ib_device,
+static DEVICE_ATTR(id_ext,          S_IRUGO, show_id_ext,          NULL);
+static DEVICE_ATTR(ioc_guid,        S_IRUGO, show_ioc_guid,        NULL);
+static DEVICE_ATTR(service_id,      S_IRUGO, show_service_id,      NULL);
+static DEVICE_ATTR(pkey,            S_IRUGO, show_pkey,            NULL);
+static DEVICE_ATTR(dgid,            S_IRUGO, show_dgid,            NULL);
+static DEVICE_ATTR(orig_dgid,       S_IRUGO, show_orig_dgid,       NULL);
+static DEVICE_ATTR(zero_req_lim,    S_IRUGO, show_zero_req_lim,    NULL);
+static DEVICE_ATTR(local_ib_port,   S_IRUGO, show_local_ib_port,   NULL);
+static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
+
+static struct device_attribute *srp_host_attrs[] = {
+        &dev_attr_id_ext,
+        &dev_attr_ioc_guid,
+        &dev_attr_service_id,
+        &dev_attr_pkey,
+        &dev_attr_dgid,
+        &dev_attr_orig_dgid,
+        &dev_attr_zero_req_lim,
+        &dev_attr_local_ib_port,
+        &dev_attr_local_ib_device,
         NULL
 };
 
@@ -1613,7 +1624,7 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
         sprintf(target->target_name, "SRP.T10:%016llX",
                  (unsigned long long) be64_to_cpu(target->id_ext));
 
-        if (scsi_add_host(target->scsi_host, host->dev->dev->dma_device))
+        if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
                 return -ENODEV;
 
         memcpy(ids.port_id, &target->id_ext, 8);
@@ -1637,17 +1648,17 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
         return 0;
 }
 
-static void srp_release_class_dev(struct class_device *class_dev)
+static void srp_release_dev(struct device *dev)
 {
         struct srp_host *host =
-                container_of(class_dev, struct srp_host, class_dev);
+                container_of(dev, struct srp_host, dev);
 
         complete(&host->released);
 }
 
 static struct class srp_class = {
         .name    = "infiniband_srp",
-        .release = srp_release_class_dev
+        .dev_release = srp_release_dev
 };
 
 /*
@@ -1835,11 +1846,12 @@ out:
         return ret;
 }
 
-static ssize_t srp_create_target(struct class_device *class_dev,
+static ssize_t srp_create_target(struct device *dev,
+                                 struct device_attribute *attr,
                                  const char *buf, size_t count)
 {
         struct srp_host *host =
-                container_of(class_dev, struct srp_host, class_dev);
+                container_of(dev, struct srp_host, dev);
         struct Scsi_Host *target_host;
         struct srp_target_port *target;
         int ret;
@@ -1871,7 +1883,8 @@ static ssize_t srp_create_target(struct class_device *class_dev,
         if (ret)
                 goto err;
 
-        ib_get_cached_gid(host->dev->dev, host->port, 0, &target->path.sgid);
+        ib_get_cached_gid(host->srp_dev->dev, host->port, 0,
+                          &target->path.sgid);
 
         shost_printk(KERN_DEBUG, target->scsi_host, PFX
                      "new target: id_ext %016llx ioc_guid %016llx pkey %04x "
@@ -1926,27 +1939,27 @@ err:
         return ret;
 }
 
-static CLASS_DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
+static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
 
-static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
+static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct srp_host *host =
-                container_of(class_dev, struct srp_host, class_dev);
+        struct srp_host *host = container_of(dev, struct srp_host, dev);
 
-        return sprintf(buf, "%s\n", host->dev->dev->name);
+        return sprintf(buf, "%s\n", host->srp_dev->dev->name);
 }
 
-static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
+static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
-static ssize_t show_port(struct class_device *class_dev, char *buf)
+static ssize_t show_port(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct srp_host *host =
-                container_of(class_dev, struct srp_host, class_dev);
+        struct srp_host *host = container_of(dev, struct srp_host, dev);
 
         return sprintf(buf, "%d\n", host->port);
 }
 
-static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
+static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 
 static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
 {
@@ -1959,27 +1972,27 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
         INIT_LIST_HEAD(&host->target_list);
         spin_lock_init(&host->target_lock);
         init_completion(&host->released);
-        host->dev  = device;
+        host->srp_dev = device;
         host->port = port;
 
-        host->class_dev.class = &srp_class;
-        host->class_dev.dev   = device->dev->dma_device;
-        snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d",
+        host->dev.class = &srp_class;
+        host->dev.parent = device->dev->dma_device;
+        snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d",
                  device->dev->name, port);
 
-        if (class_device_register(&host->class_dev))
+        if (device_register(&host->dev))
                 goto free_host;
-        if (class_device_create_file(&host->class_dev, &class_device_attr_add_target))
+        if (device_create_file(&host->dev, &dev_attr_add_target))
                 goto err_class;
-        if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev))
+        if (device_create_file(&host->dev, &dev_attr_ibdev))
                 goto err_class;
-        if (class_device_create_file(&host->class_dev, &class_device_attr_port))
+        if (device_create_file(&host->dev, &dev_attr_port))
                 goto err_class;
 
         return host;
 
 err_class:
-        class_device_unregister(&host->class_dev);
+        device_unregister(&host->dev);
 
 free_host:
         kfree(host);
@@ -2084,7 +2097,7 @@ static void srp_remove_one(struct ib_device *device)
         srp_dev = ib_get_client_data(device, &srp_client);
 
         list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
-                class_device_unregister(&host->class_dev);
+                device_unregister(&host->dev);
                 /*
                  * Wait for the sysfs entry to go away, so that no new
                  * target ports can be created.
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index cb6eb816024a..63d2ae724061 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -97,9 +97,9 @@ struct srp_device {
 };
 
 struct srp_host {
-        struct srp_device      *dev;
+        struct srp_device      *srp_dev;
         u8                      port;
-        struct class_device     class_dev;
+        struct device           dev;
         struct list_head        target_list;
         spinlock_t              target_lock;
         struct completion       released;
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index 4a938780dfc3..63aad90247c4 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -139,12 +139,10 @@ EXPORT_SYMBOL_GPL(led_classdev_register);
 /**
  * __led_classdev_unregister - unregisters a object of led_properties class.
  * @led_cdev: the led device to unregister
- * @suspended: indicates whether system-wide suspend or resume is in progress
  *
  * Unregisters a previously registered via led_classdev_register object.
  */
-void __led_classdev_unregister(struct led_classdev *led_cdev,
-                                      bool suspended)
+void led_classdev_unregister(struct led_classdev *led_cdev)
 {
         device_remove_file(led_cdev->dev, &dev_attr_brightness);
 #ifdef CONFIG_LEDS_TRIGGERS
@@ -155,16 +153,13 @@ void __led_classdev_unregister(struct led_classdev *led_cdev,
         up_write(&led_cdev->trigger_lock);
 #endif
 
-        if (suspended)
-                device_pm_schedule_removal(led_cdev->dev);
-        else
-                device_unregister(led_cdev->dev);
+        device_unregister(led_cdev->dev);
 
         down_write(&leds_list_lock);
         list_del(&led_cdev->node);
         up_write(&leds_list_lock);
 }
-EXPORT_SYMBOL_GPL(__led_classdev_unregister);
+EXPORT_SYMBOL_GPL(led_classdev_unregister);
 
 static int __init leds_init(void)
 {
diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
index 946e3d3506ac..61b98c333cb0 100644
--- a/drivers/memstick/core/memstick.c
+++ b/drivers/memstick/core/memstick.c
@@ -177,16 +177,16 @@ static struct bus_type memstick_bus_type = {
         .resume         = memstick_device_resume
 };
 
-static void memstick_free(struct class_device *cdev)
+static void memstick_free(struct device *dev)
 {
-        struct memstick_host *host = container_of(cdev, struct memstick_host,
-                                                  cdev);
+        struct memstick_host *host = container_of(dev, struct memstick_host,
+                                                  dev);
         kfree(host);
 }
 
 static struct class memstick_host_class = {
         .name       = "memstick_host",
-        .release    = memstick_free
+        .dev_release = memstick_free
 };
 
 static void memstick_free_card(struct device *dev)
@@ -383,8 +383,8 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
         if (card) {
                 card->host = host;
                 snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
-                         "%s", host->cdev.class_id);
-                card->dev.parent = host->cdev.dev;
+                         "%s", host->dev.bus_id);
+                card->dev.parent = &host->dev;
                 card->dev.bus = &memstick_bus_type;
                 card->dev.release = memstick_free_card;
                 card->check = memstick_dummy_check;
@@ -427,7 +427,7 @@ static void memstick_check(struct work_struct *work)
                                                   media_checker);
         struct memstick_dev *card;
 
-        dev_dbg(host->cdev.dev, "memstick_check started\n");
+        dev_dbg(&host->dev, "memstick_check started\n");
         mutex_lock(&host->lock);
         if (!host->card)
                 memstick_power_on(host);
@@ -440,7 +440,7 @@ static void memstick_check(struct work_struct *work)
                         host->card = NULL;
                 }
         } else {
-                dev_dbg(host->cdev.dev, "new card %02x, %02x, %02x\n",
+                dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
                         card->id.type, card->id.category, card->id.class);
                 if (host->card) {
                         if (memstick_set_rw_addr(host->card)
@@ -465,7 +465,7 @@ static void memstick_check(struct work_struct *work)
                 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 
         mutex_unlock(&host->lock);
-        dev_dbg(host->cdev.dev, "memstick_check finished\n");
+        dev_dbg(&host->dev, "memstick_check finished\n");
 }
 
 /**
@@ -482,9 +482,9 @@ struct memstick_host *memstick_alloc_host(unsigned int extra,
         if (host) {
                 mutex_init(&host->lock);
                 INIT_WORK(&host->media_checker, memstick_check);
-                host->cdev.class = &memstick_host_class;
-                host->cdev.dev = dev;
-                class_device_initialize(&host->cdev);
+                host->dev.class = &memstick_host_class;
+                host->dev.parent = dev;
+                device_initialize(&host->dev);
         }
         return host;
 }
@@ -507,10 +507,9 @@ int memstick_add_host(struct memstick_host *host)
         if (rc)
                 return rc;
 
-        snprintf(host->cdev.class_id, BUS_ID_SIZE,
-                 "memstick%u", host->id);
+        snprintf(host->dev.bus_id, BUS_ID_SIZE, "memstick%u", host->id);
 
-        rc = class_device_add(&host->cdev);
+        rc = device_add(&host->dev);
         if (rc) {
                 spin_lock(&memstick_host_lock);
                 idr_remove(&memstick_host_idr, host->id);
@@ -541,7 +540,7 @@ void memstick_remove_host(struct memstick_host *host)
         spin_lock(&memstick_host_lock);
         idr_remove(&memstick_host_idr, host->id);
         spin_unlock(&memstick_host_lock);
-        class_device_del(&host->cdev);
+        device_del(&host->dev);
 }
 EXPORT_SYMBOL(memstick_remove_host);
 
@@ -552,7 +551,7 @@ EXPORT_SYMBOL(memstick_remove_host);
 void memstick_free_host(struct memstick_host *host)
 {
         mutex_destroy(&host->lock);
-        class_device_put(&host->cdev);
+        put_device(&host->dev);
 }
 EXPORT_SYMBOL(memstick_free_host);
 
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 557dbbba5cb2..477d0fb6e588 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1127,8 +1127,8 @@ static int mspro_block_init_disk(struct memstick_dev *card)
         u64 limit = BLK_BOUNCE_HIGH;
         unsigned long capacity;
 
-        if (host->cdev.dev->dma_mask && *(host->cdev.dev->dma_mask))
-                limit = *(host->cdev.dev->dma_mask);
+        if (host->dev.dma_mask && *(host->dev.dma_mask))
+                limit = *(host->dev.dma_mask);
 
         for (rc = 0; msb->attr_group.attrs[rc]; ++rc) {
                 s_attr = mspro_from_sysfs_attr(msb->attr_group.attrs[rc]);
diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c
index 8770a5fac3b6..a054668eda16 100644
--- a/drivers/memstick/host/jmb38x_ms.c
+++ b/drivers/memstick/host/jmb38x_ms.c
@@ -361,15 +361,15 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
         unsigned int data_len, cmd, t_val;
 
         if (!(STATUS_HAS_MEDIA & readl(host->addr + STATUS))) {
-                dev_dbg(msh->cdev.dev, "no media status\n");
+                dev_dbg(&msh->dev, "no media status\n");
                 host->req->error = -ETIME;
                 return host->req->error;
         }
 
-        dev_dbg(msh->cdev.dev, "control %08x\n",
+        dev_dbg(&msh->dev, "control %08x\n",
                 readl(host->addr + HOST_CONTROL));
-        dev_dbg(msh->cdev.dev, "status %08x\n", readl(host->addr + INT_STATUS));
-        dev_dbg(msh->cdev.dev, "hstatus %08x\n", readl(host->addr + STATUS));
+        dev_dbg(&msh->dev, "status %08x\n", readl(host->addr + INT_STATUS));
+        dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS));
 
         host->cmd_flags = 0;
         host->block_pos = 0;
@@ -448,7 +448,7 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
         host->req->error = 0;
 
         writel(cmd, host->addr + TPC);
-        dev_dbg(msh->cdev.dev, "executing TPC %08x, len %x\n", cmd, data_len);
+        dev_dbg(&msh->dev, "executing TPC %08x, len %x\n", cmd, data_len);
 
         return 0;
 }
@@ -461,11 +461,11 @@ static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last)
 
         del_timer(&host->timer);
 
-        dev_dbg(msh->cdev.dev, "c control %08x\n",
+        dev_dbg(&msh->dev, "c control %08x\n",
                 readl(host->addr + HOST_CONTROL));
-        dev_dbg(msh->cdev.dev, "c status %08x\n",
+        dev_dbg(&msh->dev, "c status %08x\n",
                 readl(host->addr + INT_STATUS));
-        dev_dbg(msh->cdev.dev, "c hstatus %08x\n", readl(host->addr + STATUS));
+        dev_dbg(&msh->dev, "c hstatus %08x\n", readl(host->addr + STATUS));
 
         host->req->int_reg = readl(host->addr + STATUS) & 0xff;
 
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index 89c63147a15d..b109bd8a4d19 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -3300,9 +3300,10 @@ mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
 }
 
 static ssize_t
-mptscsih_version_fw_show(struct class_device *cdev, char *buf)
+mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
@@ -3312,12 +3313,13 @@ mptscsih_version_fw_show(struct class_device *cdev, char *buf)
             (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
             ioc->facts.FWVersion.Word & 0x000000FF);
 }
-static CLASS_DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
+static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
 
 static ssize_t
-mptscsih_version_bios_show(struct class_device *cdev, char *buf)
+mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
@@ -3327,129 +3329,141 @@ mptscsih_version_bios_show(struct class_device *cdev, char *buf)
             (ioc->biosVersion & 0x0000FF00) >> 8,
             ioc->biosVersion & 0x000000FF);
 }
-static CLASS_DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
+static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
 
 static ssize_t
-mptscsih_version_mpi_show(struct class_device *cdev, char *buf)
+mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
 }
-static CLASS_DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
+static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
 
 static ssize_t
-mptscsih_version_product_show(struct class_device *cdev, char *buf)
+mptscsih_version_product_show(struct device *dev,
+                              struct device_attribute *attr,
+char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
 }
-static CLASS_DEVICE_ATTR(version_product, S_IRUGO,
+static DEVICE_ATTR(version_product, S_IRUGO,
     mptscsih_version_product_show, NULL);
 
 static ssize_t
-mptscsih_version_nvdata_persistent_show(struct class_device *cdev, char *buf)
+mptscsih_version_nvdata_persistent_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%02xh\n",
             ioc->nvdata_version_persistent);
 }
-static CLASS_DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
+static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
     mptscsih_version_nvdata_persistent_show, NULL);
 
 static ssize_t
-mptscsih_version_nvdata_default_show(struct class_device *cdev, char *buf)
+mptscsih_version_nvdata_default_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
 }
-static CLASS_DEVICE_ATTR(version_nvdata_default, S_IRUGO,
+static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
     mptscsih_version_nvdata_default_show, NULL);
 
 static ssize_t
-mptscsih_board_name_show(struct class_device *cdev, char *buf)
+mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
 }
-static CLASS_DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
+static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
 
 static ssize_t
-mptscsih_board_assembly_show(struct class_device *cdev, char *buf)
+mptscsih_board_assembly_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
 }
-static CLASS_DEVICE_ATTR(board_assembly, S_IRUGO,
+static DEVICE_ATTR(board_assembly, S_IRUGO,
     mptscsih_board_assembly_show, NULL);
 
 static ssize_t
-mptscsih_board_tracer_show(struct class_device *cdev, char *buf)
+mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
 }
-static CLASS_DEVICE_ATTR(board_tracer, S_IRUGO,
+static DEVICE_ATTR(board_tracer, S_IRUGO,
     mptscsih_board_tracer_show, NULL);
 
 static ssize_t
-mptscsih_io_delay_show(struct class_device *cdev, char *buf)
+mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
+                       char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
 }
-static CLASS_DEVICE_ATTR(io_delay, S_IRUGO,
+static DEVICE_ATTR(io_delay, S_IRUGO,
     mptscsih_io_delay_show, NULL);
 
 static ssize_t
-mptscsih_device_delay_show(struct class_device *cdev, char *buf)
+mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
+                           char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
 }
-static CLASS_DEVICE_ATTR(device_delay, S_IRUGO,
+static DEVICE_ATTR(device_delay, S_IRUGO,
     mptscsih_device_delay_show, NULL);
 
 static ssize_t
-mptscsih_debug_level_show(struct class_device *cdev, char *buf)
+mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
 
         return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
 }
 static ssize_t
-mptscsih_debug_level_store(struct class_device *cdev, const char *buf,
-                                                                size_t count)
+mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
         MPT_SCSI_HOST   *hd = shost_priv(host);
         MPT_ADAPTER *ioc = hd->ioc;
         int val = 0;
@@ -3462,22 +3476,22 @@ mptscsih_debug_level_store(struct class_device *cdev, const char *buf,
                                 ioc->name, ioc->debug_level);
         return strlen(buf);
 }
-static CLASS_DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
-    mptscsih_debug_level_show, mptscsih_debug_level_store);
-
-struct class_device_attribute *mptscsih_host_attrs[] = {
-        &class_device_attr_version_fw,
-        &class_device_attr_version_bios,
-        &class_device_attr_version_mpi,
-        &class_device_attr_version_product,
-        &class_device_attr_version_nvdata_persistent,
-        &class_device_attr_version_nvdata_default,
-        &class_device_attr_board_name,
-        &class_device_attr_board_assembly,
-        &class_device_attr_board_tracer,
-        &class_device_attr_io_delay,
-        &class_device_attr_device_delay,
-        &class_device_attr_debug_level,
+static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
+        mptscsih_debug_level_show, mptscsih_debug_level_store);
+
+struct device_attribute *mptscsih_host_attrs[] = {
+        &dev_attr_version_fw,
+        &dev_attr_version_bios,
+        &dev_attr_version_mpi,
+        &dev_attr_version_product,
+        &dev_attr_version_nvdata_persistent,
+        &dev_attr_version_nvdata_default,
+        &dev_attr_board_name,
+        &dev_attr_board_assembly,
+        &dev_attr_board_tracer,
+        &dev_attr_io_delay,
+        &dev_attr_device_delay,
+        &dev_attr_debug_level,
         NULL,
 };
 EXPORT_SYMBOL(mptscsih_host_attrs);
diff --git a/drivers/message/fusion/mptscsih.h b/drivers/message/fusion/mptscsih.h
index d289e97cfe8b..7ea7da0e090c 100644
--- a/drivers/message/fusion/mptscsih.h
+++ b/drivers/message/fusion/mptscsih.h
@@ -129,4 +129,4 @@ extern void mptscsih_timer_expired(unsigned long data);
 extern int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
 extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
 extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
-extern struct class_device_attribute *mptscsih_host_attrs[];
+extern struct device_attribute *mptscsih_host_attrs[];
diff --git a/drivers/misc/enclosure.c b/drivers/misc/enclosure.c
index 6fcb0e96adf4..fafb57fed761 100644
--- a/drivers/misc/enclosure.c
+++ b/drivers/misc/enclosure.c
@@ -40,16 +40,16 @@ static struct class enclosure_component_class;
  * Looks through the list of registered enclosures to see
  * if it can find a match for a device.  Returns NULL if no
  * enclosure is found. Obtains a reference to the enclosure class
- * device which must be released with class_device_put().
+ * device which must be released with device_put().
  */
 struct enclosure_device *enclosure_find(struct device *dev)
 {
-        struct enclosure_device *edev = NULL;
+        struct enclosure_device *edev;
 
         mutex_lock(&container_list_lock);
         list_for_each_entry(edev, &container_list, node) {
-                if (edev->cdev.dev == dev) {
-                        class_device_get(&edev->cdev);
+                if (edev->edev.parent == dev) {
+                        get_device(&edev->edev);
                         mutex_unlock(&container_list_lock);
                         return edev;
                 }
@@ -117,11 +117,11 @@ enclosure_register(struct device *dev, const char *name, int components,
 
         edev->components = components;
 
-        edev->cdev.class = &enclosure_class;
-        edev->cdev.dev = get_device(dev);
+        edev->edev.class = &enclosure_class;
+        edev->edev.parent = get_device(dev);
         edev->cb = cb;
-        snprintf(edev->cdev.class_id, BUS_ID_SIZE, "%s", name);
-        err = class_device_register(&edev->cdev);
+        snprintf(edev->edev.bus_id, BUS_ID_SIZE, "%s", name);
+        err = device_register(&edev->edev);
         if (err)
                 goto err;
 
@@ -135,7 +135,7 @@ enclosure_register(struct device *dev, const char *name, int components,
         return edev;
 
  err:
-        put_device(edev->cdev.dev);
+        put_device(edev->edev.parent);
         kfree(edev);
         return ERR_PTR(err);
 }
@@ -158,27 +158,28 @@ void enclosure_unregister(struct enclosure_device *edev)
 
         for (i = 0; i < edev->components; i++)
                 if (edev->component[i].number != -1)
-                        class_device_unregister(&edev->component[i].cdev);
+                        device_unregister(&edev->component[i].cdev);
 
         /* prevent any callbacks into service user */
         edev->cb = &enclosure_null_callbacks;
-        class_device_unregister(&edev->cdev);
+        device_unregister(&edev->edev);
 }
 EXPORT_SYMBOL_GPL(enclosure_unregister);
 
-static void enclosure_release(struct class_device *cdev)
+static void enclosure_release(struct device *cdev)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev);
 
-        put_device(cdev->dev);
+        put_device(cdev->parent);
         kfree(edev);
 }
 
-static void enclosure_component_release(struct class_device *cdev)
+static void enclosure_component_release(struct device *dev)
 {
-        if (cdev->dev)
-                put_device(cdev->dev);
-        class_device_put(cdev->parent);
+        struct enclosure_component *cdev = to_enclosure_component(dev);
+
+        put_device(cdev->dev);
+        put_device(dev->parent);
 }
 
 /**
@@ -201,7 +202,7 @@ enclosure_component_register(struct enclosure_device *edev,
                              const char *name)
 {
         struct enclosure_component *ecomp;
-        struct class_device *cdev;
+        struct device *cdev;
         int err;
 
         if (number >= edev->components)
@@ -215,14 +216,14 @@ enclosure_component_register(struct enclosure_device *edev,
         ecomp->type = type;
         ecomp->number = number;
         cdev = &ecomp->cdev;
-        cdev->parent = class_device_get(&edev->cdev);
+        cdev->parent = get_device(&edev->edev);
         cdev->class = &enclosure_component_class;
         if (name)
-                snprintf(cdev->class_id, BUS_ID_SIZE, "%s", name);
+                snprintf(cdev->bus_id, BUS_ID_SIZE, "%s", name);
         else
-                snprintf(cdev->class_id, BUS_ID_SIZE, "%u", number);
+                snprintf(cdev->bus_id, BUS_ID_SIZE, "%u", number);
 
-        err = class_device_register(cdev);
+        err = device_register(cdev);
         if (err)
                 ERR_PTR(err);
 
@@ -247,18 +248,17 @@ EXPORT_SYMBOL_GPL(enclosure_component_register);
 int enclosure_add_device(struct enclosure_device *edev, int component,
                          struct device *dev)
 {
-        struct class_device *cdev;
+        struct enclosure_component *cdev;
 
         if (!edev || component >= edev->components)
                 return -EINVAL;
 
-        cdev = &edev->component[component].cdev;
+        cdev = &edev->component[component];
 
-        class_device_del(cdev);
-        if (cdev->dev)
-                put_device(cdev->dev);
+        device_del(&cdev->cdev);
+        put_device(cdev->dev);
         cdev->dev = get_device(dev);
-        return class_device_add(cdev);
+        return device_add(&cdev->cdev);
 }
 EXPORT_SYMBOL_GPL(enclosure_add_device);
 
@@ -272,18 +272,17 @@ EXPORT_SYMBOL_GPL(enclosure_add_device);
  */
 int enclosure_remove_device(struct enclosure_device *edev, int component)
 {
-        struct class_device *cdev;
+        struct enclosure_component *cdev;
 
         if (!edev || component >= edev->components)
                 return -EINVAL;
 
-        cdev = &edev->component[component].cdev;
+        cdev = &edev->component[component];
 
-        class_device_del(cdev);
-        if (cdev->dev)
-                put_device(cdev->dev);
+        device_del(&cdev->cdev);
+        put_device(cdev->dev);
         cdev->dev = NULL;
-        return class_device_add(cdev);
+        return device_add(&cdev->cdev);
 }
 EXPORT_SYMBOL_GPL(enclosure_remove_device);
 
@@ -291,14 +290,16 @@ EXPORT_SYMBOL_GPL(enclosure_remove_device);
  * sysfs pieces below
  */
 
-static ssize_t enclosure_show_components(struct class_device *cdev, char *buf)
+static ssize_t enclosure_show_components(struct device *cdev,
+                                         struct device_attribute *attr,
+                                         char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev);
 
         return snprintf(buf, 40, "%d\n", edev->components);
 }
 
-static struct class_device_attribute enclosure_attrs[] = {
+static struct device_attribute enclosure_attrs[] = {
         __ATTR(components, S_IRUGO, enclosure_show_components, NULL),
         __ATTR_NULL
 };
@@ -306,8 +307,8 @@ static struct class_device_attribute enclosure_attrs[] = {
 static struct class enclosure_class = {
         .name                   = "enclosure",
         .owner                  = THIS_MODULE,
-        .release                = enclosure_release,
-        .class_dev_attrs        = enclosure_attrs,
+        .dev_release            = enclosure_release,
+        .dev_attrs              = enclosure_attrs,
 };
 
 static const char *const enclosure_status [] = {
@@ -326,7 +327,8 @@ static const char *const enclosure_type [] = {
         [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device",
 };
 
-static ssize_t get_component_fault(struct class_device *cdev, char *buf)
+static ssize_t get_component_fault(struct device *cdev,
+                                   struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -336,8 +338,9 @@ static ssize_t get_component_fault(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->fault);
 }
 
-static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_fault(struct device *cdev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -348,7 +351,8 @@ static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_status(struct class_device *cdev, char *buf)
+static ssize_t get_component_status(struct device *cdev,
+                                    struct device_attribute *attr,char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -358,8 +362,9 @@ static ssize_t get_component_status(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]);
 }
 
-static ssize_t set_component_status(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_status(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -380,7 +385,8 @@ static ssize_t set_component_status(struct class_device *cdev, const char *buf,
                 return -EINVAL;
 }
 
-static ssize_t get_component_active(struct class_device *cdev, char *buf)
+static ssize_t get_component_active(struct device *cdev,
+                                    struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -390,8 +396,9 @@ static ssize_t get_component_active(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->active);
 }
 
-static ssize_t set_component_active(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_active(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -402,7 +409,8 @@ static ssize_t set_component_active(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_locate(struct class_device *cdev, char *buf)
+static ssize_t get_component_locate(struct device *cdev,
+                                    struct device_attribute *attr, char *buf)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -412,8 +420,9 @@ static ssize_t get_component_locate(struct class_device *cdev, char *buf)
         return snprintf(buf, 40, "%d\n", ecomp->locate);
 }
 
-static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t set_component_locate(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
@@ -424,7 +433,8 @@ static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t get_component_type(struct class_device *cdev, char *buf)
+static ssize_t get_component_type(struct device *cdev,
+                                  struct device_attribute *attr, char *buf)
 {
         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 
@@ -432,7 +442,7 @@ static ssize_t get_component_type(struct class_device *cdev, char *buf)
 }
 
 
-static struct class_device_attribute enclosure_component_attrs[] = {
+static struct device_attribute enclosure_component_attrs[] = {
         __ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
                set_component_fault),
         __ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
@@ -448,8 +458,8 @@ static struct class_device_attribute enclosure_component_attrs[] = {
 static struct class enclosure_component_class =  {
         .name                   = "enclosure_component",
         .owner                  = THIS_MODULE,
-        .class_dev_attrs        = enclosure_component_attrs,
-        .release                = enclosure_component_release,
+        .dev_attrs      = enclosure_component_attrs,
+        .dev_release            = enclosure_component_release,
 };
 
 static int __init enclosure_init(void)
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 0aac1ff511df..36a9c42df835 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -116,10 +116,7 @@ static void b43_unregister_led(struct b43_led *led)
 {
         if (!led->dev)
                 return;
-        if (led->dev->suspend_in_progress)
-                led_classdev_unregister_suspended(&led->led_dev);
-        else
-                led_classdev_unregister(&led->led_dev);
+        led_classdev_unregister(&led->led_dev);
         b43_led_turn_off(led->dev, led->index, led->activelow);
         led->dev = NULL;
 }
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index cf5c046c9fa8..943cc851c504 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2804,10 +2804,10 @@ static int b43_rng_read(struct hwrng *rng, u32 * data)
         return (sizeof(u16));
 }
 
-static void b43_rng_exit(struct b43_wl *wl, bool suspended)
+static void b43_rng_exit(struct b43_wl *wl)
 {
         if (wl->rng_initialized)
-                __hwrng_unregister(&wl->rng, suspended);
+                hwrng_unregister(&wl->rng);
 }
 
 static int b43_rng_init(struct b43_wl *wl)
@@ -3824,7 +3824,7 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
 
         if (!dev->suspend_in_progress) {
                 b43_leds_exit(dev);
-                b43_rng_exit(dev->wl, false);
+                b43_rng_exit(dev->wl);
         }
         b43_dma_free(dev);
         b43_pio_free(dev);
@@ -4589,7 +4589,7 @@ static int b43_resume(struct ssb_device *dev)
                 err = b43_wireless_core_start(wldev);
                 if (err) {
                         b43_leds_exit(wldev);
-                        b43_rng_exit(wldev->wl, true);
+                        b43_rng_exit(wldev->wl);
                         b43_wireless_core_exit(wldev);
                         b43err(wl, "Resume failed at core start\n");
                         goto out;
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 51c3ebf1c7d1..b31faeccb9cd 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -140,9 +140,10 @@ static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
 /* Functions */
 
 /* Show some statistics about the card */
-static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
+static ssize_t twa_show_stats(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(class_dev);
+        struct Scsi_Host *host = class_to_shost(dev);
         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
         unsigned long flags = 0;
         ssize_t len;
@@ -184,7 +185,7 @@ static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 } /* End twa_change_queue_depth() */
 
 /* Create sysfs 'stats' entry */
-static struct class_device_attribute twa_host_stats_attr = {
+static struct device_attribute twa_host_stats_attr = {
         .attr = {
                 .name =         "stats",
                 .mode =         S_IRUGO,
@@ -193,7 +194,7 @@ static struct class_device_attribute twa_host_stats_attr = {
 };
 
 /* Host attributes initializer */
-static struct class_device_attribute *twa_host_attrs[] = {
+static struct device_attribute *twa_host_attrs[] = {
         &twa_host_stats_attr,
         NULL,
 };
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index adb98a297210..8c22329aa85e 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -484,9 +484,10 @@ static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
 } /* End tw_state_request_start() */
 
 /* Show some statistics about the card */
-static ssize_t tw_show_stats(struct class_device *class_dev, char *buf)
+static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(class_dev);
+        struct Scsi_Host *host = class_to_shost(dev);
         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
         unsigned long flags = 0;
         ssize_t len;
@@ -528,7 +529,7 @@ static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 } /* End tw_change_queue_depth() */
 
 /* Create sysfs 'stats' entry */
-static struct class_device_attribute tw_host_stats_attr = {
+static struct device_attribute tw_host_stats_attr = {
         .attr = {
                 .name =         "stats",
                 .mode =         S_IRUGO,
@@ -537,7 +538,7 @@ static struct class_device_attribute tw_host_stats_attr = {
 };
 
 /* Host attributes initializer */
-static struct class_device_attribute *tw_host_attrs[] = {
+static struct device_attribute *tw_host_attrs[] = {
         &tw_host_stats_attr,
         NULL,
 };
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index f1504beb2788..460d4024c46c 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -1315,7 +1315,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
                         tmp>>24,(tmp>>16)&0xff,tmp&0xff,
                         le32_to_cpu(dev->adapter_info.biosbuild));
                 buffer[0] = '\0';
-                if (aac_show_serial_number(
+                if (aac_get_serial_number(
                   shost_to_class(dev->scsi_host_ptr), buffer))
                         printk(KERN_INFO "%s%d: serial %s",
                           dev->name, dev->id, buffer);
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index ace0b751c131..113ca9c8934c 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -1850,9 +1850,9 @@ int aac_get_containers(struct aac_dev *dev);
 int aac_scsi_cmd(struct scsi_cmnd *cmd);
 int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg);
 #ifndef shost_to_class
-#define shost_to_class(shost) &shost->shost_classdev
+#define shost_to_class(shost) &shost->shost_dev
 #endif
-ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf);
+ssize_t aac_get_serial_number(struct device *dev, char *buf);
 int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg);
 int aac_rx_init(struct aac_dev *dev);
 int aac_rkt_init(struct aac_dev *dev);
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 8372bf6ed482..c109f63f8279 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -754,10 +754,10 @@ static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long
 }
 #endif
 
-static ssize_t aac_show_model(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_model(struct device *device,
+                              struct device_attribute *attr, char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len;
 
         if (dev->supplement_adapter_info.AdapterTypeText[0]) {
@@ -773,10 +773,10 @@ static ssize_t aac_show_model(struct class_device *class_dev,
         return len;
 }
 
-static ssize_t aac_show_vendor(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_vendor(struct device *device,
+                               struct device_attribute *attr, char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len;
 
         if (dev->supplement_adapter_info.AdapterTypeText[0]) {
@@ -792,10 +792,11 @@ static ssize_t aac_show_vendor(struct class_device *class_dev,
         return len;
 }
 
-static ssize_t aac_show_flags(struct class_device *class_dev, char *buf)
+static ssize_t aac_show_flags(struct device *cdev,
+                              struct device_attribute *attr, char *buf)
 {
         int len = 0;
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(cdev)->hostdata;
 
         if (nblank(dprintk(x)))
                 len = snprintf(buf, PAGE_SIZE, "dprintk\n");
@@ -811,10 +812,11 @@ static ssize_t aac_show_flags(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static ssize_t aac_show_kernel_version(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_kernel_version(struct device *device,
+                                       struct device_attribute *attr,
+                                       char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len, tmp;
 
         tmp = le32_to_cpu(dev->adapter_info.kernelrev);
@@ -824,10 +826,11 @@ static ssize_t aac_show_kernel_version(struct class_device *class_dev,
         return len;
 }
 
-static ssize_t aac_show_monitor_version(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_monitor_version(struct device *device,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len, tmp;
 
         tmp = le32_to_cpu(dev->adapter_info.monitorrev);
@@ -837,10 +840,11 @@ static ssize_t aac_show_monitor_version(struct class_device *class_dev,
         return len;
 }
 
-static ssize_t aac_show_bios_version(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_bios_version(struct device *device,
+                                     struct device_attribute *attr,
+                                     char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len, tmp;
 
         tmp = le32_to_cpu(dev->adapter_info.biosrev);
@@ -850,9 +854,10 @@ static ssize_t aac_show_bios_version(struct class_device *class_dev,
         return len;
 }
 
-ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf)
+ssize_t aac_show_serial_number(struct device *device,
+                               struct device_attribute *attr, char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len = 0;
 
         if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0)
@@ -868,35 +873,39 @@ ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static ssize_t aac_show_max_channel(struct class_device *class_dev, char *buf)
+static ssize_t aac_show_max_channel(struct device *device,
+                                    struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%d\n",
-          class_to_shost(class_dev)->max_channel);
+          class_to_shost(device)->max_channel);
 }
 
-static ssize_t aac_show_max_id(struct class_device *class_dev, char *buf)
+static ssize_t aac_show_max_id(struct device *device,
+                               struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%d\n",
-          class_to_shost(class_dev)->max_id);
+          class_to_shost(device)->max_id);
 }
 
-static ssize_t aac_store_reset_adapter(struct class_device *class_dev,
-                const char *buf, size_t count)
+static ssize_t aac_store_reset_adapter(struct device *device,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
 {
         int retval = -EACCES;
 
         if (!capable(CAP_SYS_ADMIN))
                 return retval;
-        retval = aac_reset_adapter((struct aac_dev*)class_to_shost(class_dev)->hostdata, buf[0] == '!');
+        retval = aac_reset_adapter((struct aac_dev*)class_to_shost(device)->hostdata, buf[0] == '!');
         if (retval >= 0)
                 retval = count;
         return retval;
 }
 
-static ssize_t aac_show_reset_adapter(struct class_device *class_dev,
-                char *buf)
+static ssize_t aac_show_reset_adapter(struct device *device,
+                                      struct device_attribute *attr,
+                                      char *buf)
 {
-        struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+        struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata;
         int len, tmp;
 
         tmp = aac_adapter_check_health(dev);
@@ -906,70 +915,70 @@ static ssize_t aac_show_reset_adapter(struct class_device *class_dev,
         return len;
 }
 
-static struct class_device_attribute aac_model = {
+static struct device_attribute aac_model = {
         .attr = {
                 .name = "model",
                 .mode = S_IRUGO,
         },
         .show = aac_show_model,
 };
-static struct class_device_attribute aac_vendor = {
+static struct device_attribute aac_vendor = {
         .attr = {
                 .name = "vendor",
                 .mode = S_IRUGO,
         },
         .show = aac_show_vendor,
 };
-static struct class_device_attribute aac_flags = {
+static struct device_attribute aac_flags = {
         .attr = {
                 .name = "flags",
                 .mode = S_IRUGO,
         },
         .show = aac_show_flags,
 };
-static struct class_device_attribute aac_kernel_version = {
+static struct device_attribute aac_kernel_version = {
         .attr = {
                 .name = "hba_kernel_version",
                 .mode = S_IRUGO,
         },
         .show = aac_show_kernel_version,
 };
-static struct class_device_attribute aac_monitor_version = {
+static struct device_attribute aac_monitor_version = {
         .attr = {
                 .name = "hba_monitor_version",
                 .mode = S_IRUGO,
         },
         .show = aac_show_monitor_version,
 };
-static struct class_device_attribute aac_bios_version = {
+static struct device_attribute aac_bios_version = {
         .attr = {
                 .name = "hba_bios_version",
                 .mode = S_IRUGO,
         },
         .show = aac_show_bios_version,
 };
-static struct class_device_attribute aac_serial_number = {
+static struct device_attribute aac_serial_number = {
         .attr = {
                 .name = "serial_number",
                 .mode = S_IRUGO,
         },
         .show = aac_show_serial_number,
 };
-static struct class_device_attribute aac_max_channel = {
+static struct device_attribute aac_max_channel = {
         .attr = {
                 .name = "max_channel",
                 .mode = S_IRUGO,
         },
         .show = aac_show_max_channel,
 };
-static struct class_device_attribute aac_max_id = {
+static struct device_attribute aac_max_id = {
         .attr = {
                 .name = "max_id",
                 .mode = S_IRUGO,
         },
         .show = aac_show_max_id,
 };
-static struct class_device_attribute aac_reset = {
+static struct device_attribute aac_reset = {
         .attr = {
                 .name = "reset_host",
                 .mode = S_IWUSR|S_IRUGO,
@@ -978,7 +987,7 @@ static struct class_device_attribute aac_reset = {
         .show = aac_show_reset_adapter,
 };
 
-static struct class_device_attribute *aac_attrs[] = {
+static struct device_attribute *aac_attrs[] = {
         &aac_model,
         &aac_vendor,
         &aac_flags,
@@ -992,6 +1001,10 @@ static struct class_device_attribute *aac_attrs[] = {
         NULL
 };
 
+ssize_t aac_get_serial_number(struct device *device, char *buf)
+{
+        return aac_show_serial_number(device, &aac_serial_number, buf);
+}
 
 static const struct file_operations aac_cfg_fops = {
         .owner          = THIS_MODULE,
diff --git a/drivers/scsi/arcmsr/arcmsr.h b/drivers/scsi/arcmsr/arcmsr.h
index 3288be2e49f8..ab646e580d64 100644
--- a/drivers/scsi/arcmsr/arcmsr.h
+++ b/drivers/scsi/arcmsr/arcmsr.h
@@ -44,7 +44,7 @@
 */
 #include <linux/interrupt.h>
 
-struct class_device_attribute;
+struct device_attribute;
 /*The limit of outstanding scsi command that firmware can handle*/
 #define ARCMSR_MAX_OUTSTANDING_CMD                                              256
 #define ARCMSR_MAX_FREECCB_NUM                                                  320
@@ -556,6 +556,6 @@ struct SENSE_DATA
 extern void arcmsr_post_ioctldata2iop(struct AdapterControlBlock *);
 extern void arcmsr_iop_message_read(struct AdapterControlBlock *);
 extern struct QBUFFER __iomem *arcmsr_get_iop_rqbuffer(struct AdapterControlBlock *);
-extern struct class_device_attribute *arcmsr_host_attrs[];
+extern struct device_attribute *arcmsr_host_attrs[];
 extern int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *);
 void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb);
diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c
index 7d7b0a554276..69f8346aa288 100644
--- a/drivers/scsi/arcmsr/arcmsr_attr.c
+++ b/drivers/scsi/arcmsr/arcmsr_attr.c
@@ -57,15 +57,15 @@
 #include <scsi/scsi_transport.h>
 #include "arcmsr.h"
 
-struct class_device_attribute *arcmsr_host_attrs[];
+struct device_attribute *arcmsr_host_attrs[];
 
 static ssize_t arcmsr_sysfs_iop_message_read(struct kobject *kobj,
                                              struct bin_attribute *bin,
                                              char *buf, loff_t off,
                                              size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct device *dev = container_of(kobj,struct device,kobj);
+        struct Scsi_Host *host = class_to_shost(dev);
         struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
         uint8_t *pQbuffer,*ptmpQbuffer;
         int32_t allxfer_len = 0;
@@ -110,8 +110,8 @@ static ssize_t arcmsr_sysfs_iop_message_write(struct kobject *kobj,
                                               char *buf, loff_t off,
                                               size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct device *dev = container_of(kobj,struct device,kobj);
+        struct Scsi_Host *host = class_to_shost(dev);
         struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
         int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex;
         uint8_t *pQbuffer, *ptmpuserbuffer;
@@ -158,8 +158,8 @@ static ssize_t arcmsr_sysfs_iop_message_clear(struct kobject *kobj,
                                               char *buf, loff_t off,
                                               size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct device *dev = container_of(kobj,struct device,kobj);
+        struct Scsi_Host *host = class_to_shost(dev);
         struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
         uint8_t *pQbuffer;
 
@@ -220,87 +220,104 @@ int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb)
         struct Scsi_Host *host = acb->host;
         int error;
 
-        error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr);
+        error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr);
         if (error) {
                 printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n");
                 goto error_bin_file_message_read;
         }
-        error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr);
+        error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr);
         if (error) {
                 printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n");
                 goto error_bin_file_message_write;
         }
-        error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_clear_attr);
+        error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_clear_attr);
         if (error) {
                 printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n");
                 goto error_bin_file_message_clear;
         }
         return 0;
 error_bin_file_message_clear:
-        sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr);
 error_bin_file_message_write:
-        sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr);
 error_bin_file_message_read:
         return error;
 }
 
-void
-arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) {
+void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb)
+{
         struct Scsi_Host *host = acb->host;
 
-        sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_clear_attr);
-        sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr);
-        sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_clear_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr);
 }
 
 
 static ssize_t
-arcmsr_attr_host_driver_version(struct class_device *cdev, char *buf) {
+arcmsr_attr_host_driver_version(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
         return snprintf(buf, PAGE_SIZE,
                         "%s\n",
                         ARCMSR_DRIVER_VERSION);
 }
 
 static ssize_t
-arcmsr_attr_host_driver_posted_cmd(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_driver_posted_cmd(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
                         atomic_read(&acb->ccboutstandingcount));
 }
 
 static ssize_t
-arcmsr_attr_host_driver_reset(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_driver_reset(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
                         acb->num_resets);
 }
 
 static ssize_t
-arcmsr_attr_host_driver_abort(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_driver_abort(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
                         acb->num_aborts);
 }
 
 static ssize_t
-arcmsr_attr_host_fw_model(struct class_device *cdev, char *buf) {
-    struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_model(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
         return snprintf(buf, PAGE_SIZE,
                         "%s\n",
                         acb->firm_model);
 }
 
 static ssize_t
-arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_version(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                        (struct AdapterControlBlock *) host->hostdata;
 
         return snprintf(buf, PAGE_SIZE,
                         "%s\n",
@@ -308,9 +325,12 @@ arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) {
 }
 
 static ssize_t
-arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_request_len(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
 
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
@@ -318,9 +338,12 @@ arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) {
 }
 
 static ssize_t
-arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_numbers_queue(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
 
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
@@ -328,9 +351,12 @@ arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) {
 }
 
 static ssize_t
-arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_sdram_size(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
 
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
@@ -338,36 +364,39 @@ arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) {
 }
 
 static ssize_t
-arcmsr_attr_host_fw_hd_channels(struct class_device *cdev, char *buf) {
-        struct Scsi_Host *host = class_to_shost(cdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+arcmsr_attr_host_fw_hd_channels(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        struct AdapterControlBlock *acb =
+                (struct AdapterControlBlock *) host->hostdata;
 
         return snprintf(buf, PAGE_SIZE,
                         "%4d\n",
                         acb->firm_hd_channels);
 }
 
-static CLASS_DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL);
-static CLASS_DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL);
-static CLASS_DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL);
-static CLASS_DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL);
-static CLASS_DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL);
-static CLASS_DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL);
-static CLASS_DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL);
-static CLASS_DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL);
-static CLASS_DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL);
-static CLASS_DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL);
-
-struct class_device_attribute *arcmsr_host_attrs[] = {
-        &class_device_attr_host_driver_version,
-        &class_device_attr_host_driver_posted_cmd,
-        &class_device_attr_host_driver_reset,
-        &class_device_attr_host_driver_abort,
-        &class_device_attr_host_fw_model,
-        &class_device_attr_host_fw_version,
-        &class_device_attr_host_fw_request_len,
-        &class_device_attr_host_fw_numbers_queue,
-        &class_device_attr_host_fw_sdram_size,
-        &class_device_attr_host_fw_hd_channels,
+static DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL);
+static DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL);
+static DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL);
+static DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL);
+static DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL);
+static DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL);
+static DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL);
+static DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL);
+static DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL);
+static DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL);
+
+struct device_attribute *arcmsr_host_attrs[] = {
+        &dev_attr_host_driver_version,
+        &dev_attr_host_driver_posted_cmd,
+        &dev_attr_host_driver_reset,
+        &dev_attr_host_driver_abort,
+        &dev_attr_host_fw_model,
+        &dev_attr_host_fw_version,
+        &dev_attr_host_fw_request_len,
+        &dev_attr_host_fw_numbers_queue,
+        &dev_attr_host_fw_sdram_size,
+        &dev_attr_host_fw_hd_channels,
         NULL,
 };
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 92d1cb1b21cb..75c84d7b9ce8 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -881,7 +881,7 @@ static long ch_ioctl_compat(struct file * file,
 static int ch_probe(struct device *dev)
 {
         struct scsi_device *sd = to_scsi_device(dev);
-        struct class_device *class_dev;
+        struct device *class_dev;
         int minor, ret = -ENOMEM;
         scsi_changer *ch;
 
@@ -910,11 +910,11 @@ static int ch_probe(struct device *dev)
         ch->minor = minor;
         sprintf(ch->name,"ch%d",ch->minor);
 
-        class_dev = class_device_create(ch_sysfs_class, NULL,
-                                        MKDEV(SCSI_CHANGER_MAJOR, ch->minor),
-                                        dev, "s%s", ch->name);
+        class_dev = device_create(ch_sysfs_class, dev,
+                                  MKDEV(SCSI_CHANGER_MAJOR,ch->minor),
+                                  "s%s", ch->name);
         if (IS_ERR(class_dev)) {
-                printk(KERN_WARNING "ch%d: class_device_create failed\n",
+                printk(KERN_WARNING "ch%d: device_create failed\n",
                        ch->minor);
                 ret = PTR_ERR(class_dev);
                 goto remove_idr;
@@ -945,8 +945,7 @@ static int ch_remove(struct device *dev)
         idr_remove(&ch_index_idr, ch->minor);
         spin_unlock(&ch_index_lock);
 
-        class_device_destroy(ch_sysfs_class,
-                             MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
+        device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
         kfree(ch->dt);
         kfree(ch);
         return 0;
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 1592640a87b5..c264a8c5f01e 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -43,14 +43,14 @@
 static int scsi_host_next_hn;           /* host_no for next new host */
 
 
-static void scsi_host_cls_release(struct class_device *class_dev)
+static void scsi_host_cls_release(struct device *dev)
 {
-        put_device(&class_to_shost(class_dev)->shost_gendev);
+        put_device(&class_to_shost(dev)->shost_gendev);
 }
 
 static struct class shost_class = {
         .name           = "scsi_host",
-        .release        = scsi_host_cls_release,
+        .dev_release    = scsi_host_cls_release,
 };
 
 /**
@@ -174,7 +174,7 @@ void scsi_remove_host(struct Scsi_Host *shost)
         spin_unlock_irqrestore(shost->host_lock, flags);
 
         transport_unregister_device(&shost->shost_gendev);
-        class_device_unregister(&shost->shost_classdev);
+        device_unregister(&shost->shost_dev);
         device_del(&shost->shost_gendev);
         scsi_proc_hostdir_rm(shost->hostt);
 }
@@ -212,7 +212,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
         scsi_host_set_state(shost, SHOST_RUNNING);
         get_device(shost->shost_gendev.parent);
 
-        error = class_device_add(&shost->shost_classdev);
+        error = device_add(&shost->shost_dev);
         if (error)
                 goto out_del_gendev;
 
@@ -223,7 +223,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
                                          GFP_KERNEL);
                 if (shost->shost_data == NULL) {
                         error = -ENOMEM;
-                        goto out_del_classdev;
+                        goto out_del_dev;
                 }
         }
 
@@ -250,8 +250,8 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
                 destroy_workqueue(shost->work_q);
  out_free_shost_data:
         kfree(shost->shost_data);
- out_del_classdev:
-        class_device_del(&shost->shost_classdev);
+ out_del_dev:
+        device_del(&shost->shost_dev);
  out_del_gendev:
         device_del(&shost->shost_gendev);
  out:
@@ -385,11 +385,11 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
                 shost->host_no);
         shost->shost_gendev.release = scsi_host_dev_release;
 
-        class_device_initialize(&shost->shost_classdev);
-        shost->shost_classdev.dev = &shost->shost_gendev;
-        shost->shost_classdev.class = &shost_class;
-        snprintf(shost->shost_classdev.class_id, BUS_ID_SIZE, "host%d",
-                  shost->host_no);
+        device_initialize(&shost->shost_dev);
+        shost->shost_dev.parent = &shost->shost_gendev;
+        shost->shost_dev.class = &shost_class;
+        snprintf(shost->shost_dev.bus_id, BUS_ID_SIZE, "host%d",
+                 shost->host_no);
 
         shost->ehandler = kthread_run(scsi_error_handler, shost,
                         "scsi_eh_%d", shost->host_no);
@@ -432,12 +432,12 @@ void scsi_unregister(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(scsi_unregister);
 
-static int __scsi_host_match(struct class_device *cdev, void *data)
+static int __scsi_host_match(struct device *dev, void *data)
 {
         struct Scsi_Host *p;
         unsigned short *hostnum = (unsigned short *)data;
 
-        p = class_to_shost(cdev);
+        p = class_to_shost(dev);
         return p->host_no == *hostnum;
 }
 
@@ -450,10 +450,10 @@ static int __scsi_host_match(struct class_device *cdev, void *data)
  **/
 struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
 {
-        struct class_device *cdev;
+        struct device *cdev;
         struct Scsi_Host *shost = ERR_PTR(-ENXIO);
 
-        cdev = class_find_child(&shost_class, &hostnum, __scsi_host_match);
+        cdev = class_find_device(&shost_class, &hostnum, __scsi_host_match);
         if (cdev)
                 shost = scsi_host_get(class_to_shost(cdev));
 
diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index beecda991682..5b7be1e9841c 100644
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -859,14 +859,16 @@ static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
         return queue_depth;
 }
 
-static ssize_t hptiop_show_version(struct class_device *class_dev, char *buf)
+static ssize_t hptiop_show_version(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%s\n", driver_ver);
 }
 
-static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf)
+static ssize_t hptiop_show_fw_version(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(class_dev);
+        struct Scsi_Host *host = class_to_shost(dev);
         struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
 
         return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n",
@@ -876,7 +878,7 @@ static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf)
                                 hba->firmware_version & 0xff);
 }
 
-static struct class_device_attribute hptiop_attr_version = {
+static struct device_attribute hptiop_attr_version = {
         .attr = {
                 .name = "driver-version",
                 .mode = S_IRUGO,
@@ -884,7 +886,7 @@ static struct class_device_attribute hptiop_attr_version = {
         .show = hptiop_show_version,
 };
 
-static struct class_device_attribute hptiop_attr_fw_version = {
+static struct device_attribute hptiop_attr_fw_version = {
         .attr = {
                 .name = "firmware-version",
                 .mode = S_IRUGO,
@@ -892,7 +894,7 @@ static struct class_device_attribute hptiop_attr_fw_version = {
         .show = hptiop_show_fw_version,
 };
 
-static struct class_device_attribute *hptiop_attrs[] = {
+static struct device_attribute *hptiop_attrs[] = {
         &hptiop_attr_version,
         &hptiop_attr_fw_version,
         NULL
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 78d46a900bb5..4a922c57125e 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1456,9 +1456,10 @@ static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
 /* ------------------------------------------------------------
  * sysfs attributes
  */
-static ssize_t show_host_srp_version(struct class_device *class_dev, char *buf)
+static ssize_t show_host_srp_version(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
         int len;
 
@@ -1467,7 +1468,7 @@ static ssize_t show_host_srp_version(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static struct class_device_attribute ibmvscsi_host_srp_version = {
+static struct device_attribute ibmvscsi_host_srp_version = {
         .attr = {
                  .name = "srp_version",
                  .mode = S_IRUGO,
@@ -1475,10 +1476,11 @@ static struct class_device_attribute ibmvscsi_host_srp_version = {
         .show = show_host_srp_version,
 };
 
-static ssize_t show_host_partition_name(struct class_device *class_dev,
+static ssize_t show_host_partition_name(struct device *dev,
+                                        struct device_attribute *attr,
                                         char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
         int len;
 
@@ -1487,7 +1489,7 @@ static ssize_t show_host_partition_name(struct class_device *class_dev,
         return len;
 }
 
-static struct class_device_attribute ibmvscsi_host_partition_name = {
+static struct device_attribute ibmvscsi_host_partition_name = {
         .attr = {
                  .name = "partition_name",
                  .mode = S_IRUGO,
@@ -1495,10 +1497,11 @@ static struct class_device_attribute ibmvscsi_host_partition_name = {
         .show = show_host_partition_name,
 };
 
-static ssize_t show_host_partition_number(struct class_device *class_dev,
+static ssize_t show_host_partition_number(struct device *dev,
+                                          struct device_attribute *attr,
                                           char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
         int len;
 
@@ -1507,7 +1510,7 @@ static ssize_t show_host_partition_number(struct class_device *class_dev,
         return len;
 }
 
-static struct class_device_attribute ibmvscsi_host_partition_number = {
+static struct device_attribute ibmvscsi_host_partition_number = {
         .attr = {
                  .name = "partition_number",
                  .mode = S_IRUGO,
@@ -1515,9 +1518,10 @@ static struct class_device_attribute ibmvscsi_host_partition_number = {
         .show = show_host_partition_number,
 };
 
-static ssize_t show_host_mad_version(struct class_device *class_dev, char *buf)
+static ssize_t show_host_mad_version(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
         int len;
 
@@ -1526,7 +1530,7 @@ static ssize_t show_host_mad_version(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static struct class_device_attribute ibmvscsi_host_mad_version = {
+static struct device_attribute ibmvscsi_host_mad_version = {
         .attr = {
                  .name = "mad_version",
                  .mode = S_IRUGO,
@@ -1534,9 +1538,10 @@ static struct class_device_attribute ibmvscsi_host_mad_version = {
         .show = show_host_mad_version,
 };
 
-static ssize_t show_host_os_type(struct class_device *class_dev, char *buf)
+static ssize_t show_host_os_type(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
         int len;
 
@@ -1544,7 +1549,7 @@ static ssize_t show_host_os_type(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static struct class_device_attribute ibmvscsi_host_os_type = {
+static struct device_attribute ibmvscsi_host_os_type = {
         .attr = {
                  .name = "os_type",
                  .mode = S_IRUGO,
@@ -1552,9 +1557,10 @@ static struct class_device_attribute ibmvscsi_host_os_type = {
         .show = show_host_os_type,
 };
 
-static ssize_t show_host_config(struct class_device *class_dev, char *buf)
+static ssize_t show_host_config(struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ibmvscsi_host_data *hostdata = shost_priv(shost);
 
         /* returns null-terminated host config data */
@@ -1564,7 +1570,7 @@ static ssize_t show_host_config(struct class_device *class_dev, char *buf)
                 return 0;
 }
 
-static struct class_device_attribute ibmvscsi_host_config = {
+static struct device_attribute ibmvscsi_host_config = {
         .attr = {
                  .name = "config",
                  .mode = S_IRUGO,
@@ -1572,7 +1578,7 @@ static struct class_device_attribute ibmvscsi_host_config = {
         .show = show_host_config,
 };
 
-static struct class_device_attribute *ibmvscsi_attrs[] = {
+static struct device_attribute *ibmvscsi_attrs[] = {
         &ibmvscsi_host_srp_version,
         &ibmvscsi_host_partition_name,
         &ibmvscsi_host_partition_number,
diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c
index e5881e92d0fb..3b9514c8f1f1 100644
--- a/drivers/scsi/ibmvscsi/ibmvstgt.c
+++ b/drivers/scsi/ibmvscsi/ibmvstgt.c
@@ -780,32 +780,35 @@ static int ibmvstgt_it_nexus_response(struct Scsi_Host *shost, u64 itn_id,
         return 0;
 }
 
-static ssize_t system_id_show(struct class_device *cdev, char *buf)
+static ssize_t system_id_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
 }
 
-static ssize_t partition_number_show(struct class_device *cdev, char *buf)
+static ssize_t partition_number_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
 }
 
-static ssize_t unit_address_show(struct class_device *cdev, char *buf)
+static ssize_t unit_address_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct srp_target *target = host_to_srp_target(shost);
         struct vio_port *vport = target_to_port(target);
         return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address);
 }
 
-static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
-static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
-static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
+static DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
+static DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
+static DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
 
-static struct class_device_attribute *ibmvstgt_attrs[] = {
-        &class_device_attr_system_id,
-        &class_device_attr_partition_number,
-        &class_device_attr_unit_address,
+static struct device_attribute *ibmvstgt_attrs[] = {
+        &dev_attr_system_id,
+        &dev_attr_partition_number,
+        &dev_attr_unit_address,
         NULL,
 };
 
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 65dc18dea845..de5ae6a65029 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -2431,7 +2431,7 @@ restart:
         }
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-        kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE);
+        kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
         LEAVE;
 }
 
@@ -2451,8 +2451,8 @@ static ssize_t ipr_read_trace(struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         int size = IPR_TRACE_SIZE;
@@ -2492,15 +2492,16 @@ static const struct {
 
 /**
  * ipr_show_write_caching - Show the write caching attribute
- * @class_dev:  class device struct
- * @buf:                buffer
+ * @dev:        device struct
+ * @buf:        buffer
  *
  * Return value:
  *      number of bytes printed to buffer
  **/
-static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf)
+static ssize_t ipr_show_write_caching(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         int i, len = 0;
@@ -2519,19 +2520,20 @@ static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf)
 
 /**
  * ipr_store_write_caching - Enable/disable adapter write cache
- * @class_dev:  class_device struct
- * @buf:                buffer
- * @count:              buffer size
+ * @dev:        device struct
+ * @buf:        buffer
+ * @count:      buffer size
  *
  * This function will enable/disable adapter write cache.
  *
  * Return value:
  *      count on success / other on failure
  **/
-static ssize_t ipr_store_write_caching(struct class_device *class_dev,
-                                        const char *buf, size_t count)
+static ssize_t ipr_store_write_caching(struct device *dev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         enum ipr_cache_state new_state = CACHE_INVALID;
@@ -2569,7 +2571,7 @@ static ssize_t ipr_store_write_caching(struct class_device *class_dev,
         return count;
 }
 
-static struct class_device_attribute ipr_ioa_cache_attr = {
+static struct device_attribute ipr_ioa_cache_attr = {
         .attr = {
                 .name =         "write_cache",
                 .mode =         S_IRUGO | S_IWUSR,
@@ -2580,15 +2582,16 @@ static struct class_device_attribute ipr_ioa_cache_attr = {
 
 /**
  * ipr_show_fw_version - Show the firmware version
- * @class_dev:  class device struct
- * @buf:                buffer
+ * @dev:        class device struct
+ * @buf:        buffer
  *
  * Return value:
  *      number of bytes printed to buffer
  **/
-static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf)
+static ssize_t ipr_show_fw_version(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
         unsigned long lock_flags = 0;
@@ -2603,7 +2606,7 @@ static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf)
         return len;
 }
 
-static struct class_device_attribute ipr_fw_version_attr = {
+static struct device_attribute ipr_fw_version_attr = {
         .attr = {
                 .name =         "fw_version",
                 .mode =         S_IRUGO,
@@ -2613,15 +2616,16 @@ static struct class_device_attribute ipr_fw_version_attr = {
 
 /**
  * ipr_show_log_level - Show the adapter's error logging level
- * @class_dev:  class device struct
- * @buf:                buffer
+ * @dev:        class device struct
+ * @buf:        buffer
  *
  * Return value:
  *      number of bytes printed to buffer
  **/
-static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf)
+static ssize_t ipr_show_log_level(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         int len;
@@ -2634,16 +2638,17 @@ static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf)
 
 /**
  * ipr_store_log_level - Change the adapter's error logging level
- * @class_dev:  class device struct
- * @buf:                buffer
+ * @dev:        class device struct
+ * @buf:        buffer
  *
  * Return value:
  *      number of bytes printed to buffer
  **/
-static ssize_t ipr_store_log_level(struct class_device *class_dev,
+static ssize_t ipr_store_log_level(struct device *dev,
+                                   struct device_attribute *attr,
                                    const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
 
@@ -2653,7 +2658,7 @@ static ssize_t ipr_store_log_level(struct class_device *class_dev,
         return strlen(buf);
 }
 
-static struct class_device_attribute ipr_log_level_attr = {
+static struct device_attribute ipr_log_level_attr = {
         .attr = {
                 .name =         "log_level",
                 .mode =         S_IRUGO | S_IWUSR,
@@ -2664,9 +2669,9 @@ static struct class_device_attribute ipr_log_level_attr = {
 
 /**
  * ipr_store_diagnostics - IOA Diagnostics interface
- * @class_dev:  class_device struct
- * @buf:                buffer
- * @count:              buffer size
+ * @dev:        device struct
+ * @buf:        buffer
+ * @count:      buffer size
  *
  * This function will reset the adapter and wait a reasonable
  * amount of time for any errors that the adapter might log.
@@ -2674,10 +2679,11 @@ static struct class_device_attribute ipr_log_level_attr = {
  * Return value:
  *      count on success / other on failure
  **/
-static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
+static ssize_t ipr_store_diagnostics(struct device *dev,
+                                     struct device_attribute *attr,
                                      const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         int rc = count;
@@ -2714,7 +2720,7 @@ static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
         return rc;
 }
 
-static struct class_device_attribute ipr_diagnostics_attr = {
+static struct device_attribute ipr_diagnostics_attr = {
         .attr = {
                 .name =         "run_diagnostics",
                 .mode =         S_IWUSR,
@@ -2724,15 +2730,16 @@ static struct class_device_attribute ipr_diagnostics_attr = {
 
 /**
  * ipr_show_adapter_state - Show the adapter's state
- * @class_dev:  class device struct
- * @buf:                buffer
+ * @class_dev:  device struct
+ * @buf:        buffer
  *
  * Return value:
  *      number of bytes printed to buffer
  **/
-static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf)
+static ssize_t ipr_show_adapter_state(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags = 0;
         int len;
@@ -2748,19 +2755,20 @@ static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf)
 
 /**
  * ipr_store_adapter_state - Change adapter state
- * @class_dev:  class_device struct
- * @buf:                buffer
- * @count:              buffer size
+ * @dev:        device struct
+ * @buf:        buffer
+ * @count:      buffer size
  *
  * This function will change the adapter's state.
  *
  * Return value:
  *      count on success / other on failure
  **/
-static ssize_t ipr_store_adapter_state(struct class_device *class_dev,
+static ssize_t ipr_store_adapter_state(struct device *dev,
+                                       struct device_attribute *attr,
                                        const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags;
         int result = count;
@@ -2781,7 +2789,7 @@ static ssize_t ipr_store_adapter_state(struct class_device *class_dev,
         return result;
 }
 
-static struct class_device_attribute ipr_ioa_state_attr = {
+static struct device_attribute ipr_ioa_state_attr = {
         .attr = {
                 .name =         "state",
                 .mode =         S_IRUGO | S_IWUSR,
@@ -2792,19 +2800,20 @@ static struct class_device_attribute ipr_ioa_state_attr = {
 
 /**
  * ipr_store_reset_adapter - Reset the adapter
- * @class_dev:  class_device struct
- * @buf:                buffer
- * @count:              buffer size
+ * @dev:        device struct
+ * @buf:        buffer
+ * @count:      buffer size
  *
  * This function will reset the adapter.
  *
  * Return value:
  *      count on success / other on failure
  **/
-static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
+static ssize_t ipr_store_reset_adapter(struct device *dev,
+                                       struct device_attribute *attr,
                                        const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         unsigned long lock_flags;
         int result = count;
@@ -2821,7 +2830,7 @@ static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
         return result;
 }
 
-static struct class_device_attribute ipr_ioa_reset_attr = {
+static struct device_attribute ipr_ioa_reset_attr = {
         .attr = {
                 .name =         "reset_host",
                 .mode =         S_IWUSR,
@@ -3054,19 +3063,20 @@ static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
 
 /**
  * ipr_store_update_fw - Update the firmware on the adapter
- * @class_dev:  class_device struct
- * @buf:                buffer
- * @count:              buffer size
+ * @class_dev:  device struct
+ * @buf:        buffer
+ * @count:      buffer size
  *
  * This function will update the firmware on the adapter.
  *
  * Return value:
  *      count on success / other on failure
  **/
-static ssize_t ipr_store_update_fw(struct class_device *class_dev,
-                                       const char *buf, size_t count)
+static ssize_t ipr_store_update_fw(struct device *dev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         struct ipr_ucode_image_header *image_hdr;
         const struct firmware *fw_entry;
@@ -3124,7 +3134,7 @@ out:
         return result;
 }
 
-static struct class_device_attribute ipr_update_fw_attr = {
+static struct device_attribute ipr_update_fw_attr = {
         .attr = {
                 .name =         "update_fw",
                 .mode =         S_IWUSR,
@@ -3132,7 +3142,7 @@ static struct class_device_attribute ipr_update_fw_attr = {
         .store = ipr_store_update_fw
 };
 
-static struct class_device_attribute *ipr_ioa_attrs[] = {
+static struct device_attribute *ipr_ioa_attrs[] = {
         &ipr_fw_version_attr,
         &ipr_log_level_attr,
         &ipr_diagnostics_attr,
@@ -3159,7 +3169,7 @@ static ssize_t ipr_read_dump(struct kobject *kobj,
                              struct bin_attribute *bin_attr,
                              char *buf, loff_t off, size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
+        struct device *cdev = container_of(kobj, struct device, kobj);
         struct Scsi_Host *shost = class_to_shost(cdev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         struct ipr_dump *dump;
@@ -3322,7 +3332,7 @@ static ssize_t ipr_write_dump(struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
 {
-        struct class_device *cdev = container_of(kobj,struct class_device,kobj);
+        struct device *cdev = container_of(kobj, struct device, kobj);
         struct Scsi_Host *shost = class_to_shost(cdev);
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
         int rc;
@@ -7671,9 +7681,9 @@ static void ipr_remove(struct pci_dev *pdev)
 
         ENTER;
 
-        ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
+        ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
                               &ipr_trace_attr);
-        ipr_remove_dump_file(&ioa_cfg->host->shost_classdev.kobj,
+        ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
                              &ipr_dump_attr);
         scsi_remove_host(ioa_cfg->host);
 
@@ -7714,7 +7724,7 @@ static int __devinit ipr_probe(struct pci_dev *pdev,
                 return rc;
         }
 
-        rc = ipr_create_trace_file(&ioa_cfg->host->shost_classdev.kobj,
+        rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
                                    &ipr_trace_attr);
 
         if (rc) {
@@ -7723,11 +7733,11 @@ static int __devinit ipr_probe(struct pci_dev *pdev,
                 return rc;
         }
 
-        rc = ipr_create_dump_file(&ioa_cfg->host->shost_classdev.kobj,
+        rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
                                    &ipr_dump_attr);
 
         if (rc) {
-                ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
+                ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
                                       &ipr_trace_attr);
                 scsi_remove_host(ioa_cfg->host);
                 __ipr_remove(pdev);
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 74c9fc204211..a9fbb3f88659 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -66,23 +66,26 @@ lpfc_jedec_to_ascii(int incr, char hdw[])
 }
 
 static ssize_t
-lpfc_drvr_version_show(struct class_device *cdev, char *buf)
+lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
+                       char *buf)
 {
         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
 }
 
 static ssize_t
-lpfc_info_show(struct class_device *cdev, char *buf)
+lpfc_info_show(struct device *dev, struct device_attribute *attr,
+               char *buf)
 {
-        struct Scsi_Host *host = class_to_shost(cdev);
+        struct Scsi_Host *host = class_to_shost(dev);
 
         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
 }
 
 static ssize_t
-lpfc_serialnum_show(struct class_device *cdev, char *buf)
+lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -90,18 +93,20 @@ lpfc_serialnum_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_temp_sensor_show(struct class_device *cdev, char *buf)
+lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
 }
 
 static ssize_t
-lpfc_modeldesc_show(struct class_device *cdev, char *buf)
+lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -109,9 +114,10 @@ lpfc_modeldesc_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_modelname_show(struct class_device *cdev, char *buf)
+lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -119,9 +125,10 @@ lpfc_modelname_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_programtype_show(struct class_device *cdev, char *buf)
+lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -129,9 +136,10 @@ lpfc_programtype_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_vportnum_show(struct class_device *cdev, char *buf)
+lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -139,9 +147,10 @@ lpfc_vportnum_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_fwrev_show(struct class_device *cdev, char *buf)
+lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         char fwrev[32];
@@ -151,10 +160,10 @@ lpfc_fwrev_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_hdw_show(struct class_device *cdev, char *buf)
+lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
         char hdw[9];
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         lpfc_vpd_t *vp = &phba->vpd;
@@ -163,18 +172,20 @@ lpfc_hdw_show(struct class_device *cdev, char *buf)
         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
 }
 static ssize_t
-lpfc_option_rom_version_show(struct class_device *cdev, char *buf)
+lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
 }
 static ssize_t
-lpfc_state_show(struct class_device *cdev, char *buf)
+lpfc_state_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         int  len = 0;
@@ -243,9 +254,10 @@ lpfc_state_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_num_discovered_ports_show(struct class_device *cdev, char *buf)
+lpfc_num_discovered_ports_show(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 
         return snprintf(buf, PAGE_SIZE, "%d\n",
@@ -367,9 +379,10 @@ lpfc_selective_reset(struct lpfc_hba *phba)
 }
 
 static ssize_t
-lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count)
+lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
+                 const char *buf, size_t count)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -385,9 +398,10 @@ lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count)
 }
 
 static ssize_t
-lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf)
+lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -395,9 +409,10 @@ lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_board_mode_show(struct class_device *cdev, char *buf)
+lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
+                     char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         char  * state;
@@ -415,9 +430,10 @@ lpfc_board_mode_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_board_mode_store(struct class_device *cdev, const char *buf, size_t count)
+lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
+                      const char *buf, size_t count)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         struct completion online_compl;
@@ -509,9 +525,10 @@ lpfc_get_hba_info(struct lpfc_hba *phba,
 }
 
 static ssize_t
-lpfc_max_rpi_show(struct class_device *cdev, char *buf)
+lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
+                  char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt;
@@ -522,9 +539,10 @@ lpfc_max_rpi_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_used_rpi_show(struct class_device *cdev, char *buf)
+lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt, acnt;
@@ -535,9 +553,10 @@ lpfc_used_rpi_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_max_xri_show(struct class_device *cdev, char *buf)
+lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
+                  char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt;
@@ -548,9 +567,10 @@ lpfc_max_xri_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_used_xri_show(struct class_device *cdev, char *buf)
+lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt, acnt;
@@ -561,9 +581,10 @@ lpfc_used_xri_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_max_vpi_show(struct class_device *cdev, char *buf)
+lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
+                  char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt;
@@ -574,9 +595,10 @@ lpfc_max_vpi_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_used_vpi_show(struct class_device *cdev, char *buf)
+lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t cnt, acnt;
@@ -587,9 +609,10 @@ lpfc_used_vpi_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_npiv_info_show(struct class_device *cdev, char *buf)
+lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -601,9 +624,10 @@ lpfc_npiv_info_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_poll_show(struct class_device *cdev, char *buf)
+lpfc_poll_show(struct device *dev, struct device_attribute *attr,
+               char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -611,10 +635,10 @@ lpfc_poll_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-lpfc_poll_store(struct class_device *cdev, const char *buf,
-                size_t count)
+lpfc_poll_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         uint32_t creg_val;
@@ -670,9 +694,10 @@ lpfc_poll_store(struct class_device *cdev, const char *buf,
 
 #define lpfc_param_show(attr)   \
 static ssize_t \
-lpfc_##attr##_show(struct class_device *cdev, char *buf) \
+lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
+                   char *buf) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
         int val = 0;\
@@ -683,9 +708,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 
 #define lpfc_param_hex_show(attr)       \
 static ssize_t \
-lpfc_##attr##_show(struct class_device *cdev, char *buf) \
+lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
+                   char *buf) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
         int val = 0;\
@@ -725,9 +751,10 @@ lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
 
 #define lpfc_param_store(attr)  \
 static ssize_t \
-lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
+lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
+                    const char *buf, size_t count) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
         int val=0;\
@@ -743,9 +770,10 @@ lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
 
 #define lpfc_vport_param_show(attr)     \
 static ssize_t \
-lpfc_##attr##_show(struct class_device *cdev, char *buf) \
+lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
+                   char *buf) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         int val = 0;\
         val = vport->cfg_##attr;\
@@ -754,9 +782,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 
 #define lpfc_vport_param_hex_show(attr) \
 static ssize_t \
-lpfc_##attr##_show(struct class_device *cdev, char *buf) \
+lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
+                   char *buf) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         int val = 0;\
         val = vport->cfg_##attr;\
@@ -794,9 +823,10 @@ lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
 
 #define lpfc_vport_param_store(attr)    \
 static ssize_t \
-lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
+lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
+                    const char *buf, size_t count) \
 { \
-        struct Scsi_Host  *shost = class_to_shost(cdev);\
+        struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         int val=0;\
         if (!isdigit(buf[0]))\
@@ -822,7 +852,7 @@ module_param(lpfc_##name, int, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -832,8 +862,8 @@ lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 lpfc_param_set(name, defval, minval, maxval)\
 lpfc_param_store(name)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
-                         lpfc_##name##_show, lpfc_##name##_store)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
+                   lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -841,7 +871,7 @@ module_param(lpfc_##name, int, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -851,8 +881,8 @@ lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 lpfc_param_set(name, defval, minval, maxval)\
 lpfc_param_store(name)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
-                         lpfc_##name##_show, lpfc_##name##_store)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
+                   lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -866,7 +896,7 @@ module_param(lpfc_##name, int, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -876,8 +906,8 @@ lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 lpfc_vport_param_set(name, defval, minval, maxval)\
 lpfc_vport_param_store(name)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
-                         lpfc_##name##_show, lpfc_##name##_store)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
+                   lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -885,7 +915,7 @@ module_param(lpfc_##name, int, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
+static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
 static int lpfc_##name = defval;\
@@ -895,46 +925,44 @@ lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 lpfc_vport_param_set(name, defval, minval, maxval)\
 lpfc_vport_param_store(name)\
-static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
-                         lpfc_##name##_show, lpfc_##name##_store)
-
-static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
-static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
-static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
-static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
-static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
-static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
-static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
-static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
-static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
-static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO,
-                                        lpfc_option_rom_version_show, NULL);
-static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO,
-                                        lpfc_num_discovered_ports_show, NULL);
-static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
-static CLASS_DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show,
-                         NULL);
-static CLASS_DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
-                         lpfc_board_mode_show, lpfc_board_mode_store);
-static CLASS_DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
-static CLASS_DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
-static CLASS_DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
-static CLASS_DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
-static CLASS_DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
-static CLASS_DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
-static CLASS_DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
-static CLASS_DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
-static CLASS_DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show,
-                         NULL);
+static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
+                   lpfc_##name##_show, lpfc_##name##_store)
+
+static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
+static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
+static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
+static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
+static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
+static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
+static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
+static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
+static DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
+static DEVICE_ATTR(option_rom_version, S_IRUGO,
+                   lpfc_option_rom_version_show, NULL);
+static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
+                   lpfc_num_discovered_ports_show, NULL);
+static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
+static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
+static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
+                   lpfc_board_mode_show, lpfc_board_mode_store);
+static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
+static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
+static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
+static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
+static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
+static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
+static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
+static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
+static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
 
 
 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
 
 static ssize_t
-lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf,
-                                size_t count)
+lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         unsigned int cnt = count;
@@ -963,13 +991,14 @@ lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf,
         phba->soft_wwn_enable = 1;
         return count;
 }
-static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
-                                lpfc_soft_wwn_enable_store);
+static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
+                   lpfc_soft_wwn_enable_store);
 
 static ssize_t
-lpfc_soft_wwpn_show(struct class_device *cdev, char *buf)
+lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -979,9 +1008,10 @@ lpfc_soft_wwpn_show(struct class_device *cdev, char *buf)
 
 
 static ssize_t
-lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count)
+lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         struct completion online_compl;
@@ -1047,13 +1077,14 @@ lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count)
                                 "reinit adapter - %d\n", stat2);
         return (stat1 || stat2) ? -EIO : count;
 }
-static CLASS_DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
-                         lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
+static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
+                   lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
 
 static ssize_t
-lpfc_soft_wwnn_show(struct class_device *cdev, char *buf)
+lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
                         (unsigned long long)phba->cfg_soft_wwnn);
@@ -1061,9 +1092,10 @@ lpfc_soft_wwnn_show(struct class_device *cdev, char *buf)
 
 
 static ssize_t
-lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count)
+lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
         unsigned int i, j, cnt=count;
         u8 wwnn[8];
@@ -1107,8 +1139,8 @@ lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count)
 
         return count;
 }
-static CLASS_DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
-                         lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
+static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
+                   lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
 
 
 static int lpfc_poll = 0;
@@ -1118,8 +1150,8 @@ MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
                  " 1 - poll with interrupts enabled"
                  " 3 - poll and disable FCP ring interrupts");
 
-static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
-                         lpfc_poll_show, lpfc_poll_store);
+static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
+                   lpfc_poll_show, lpfc_poll_store);
 
 int  lpfc_sli_mode = 0;
 module_param(lpfc_sli_mode, int, 0);
@@ -1133,7 +1165,7 @@ module_param(lpfc_enable_npiv, int, 0);
 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
 lpfc_param_show(enable_npiv);
 lpfc_param_init(enable_npiv, 0, 0, 1);
-static CLASS_DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
+static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
                          lpfc_enable_npiv_show, NULL);
 
 /*
@@ -1147,9 +1179,10 @@ MODULE_PARM_DESC(lpfc_nodev_tmo,
                  "Seconds driver will hold I/O waiting "
                  "for a device to come back");
 static ssize_t
-lpfc_nodev_tmo_show(struct class_device *cdev, char *buf)
+lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         int val = 0;
         val = vport->cfg_devloss_tmo;
@@ -1221,8 +1254,8 @@ lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
 
 lpfc_vport_param_store(nodev_tmo)
 
-static CLASS_DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
-                         lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
+static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
+                   lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
 
 /*
 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
@@ -1255,8 +1288,8 @@ lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
 }
 
 lpfc_vport_param_store(devloss_tmo)
-static CLASS_DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
-        lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
+static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
+                   lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
 
 /*
 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
@@ -1374,8 +1407,8 @@ lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
         return 0;
 }
 lpfc_vport_param_store(restrict_login);
-static CLASS_DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
-                         lpfc_restrict_login_show, lpfc_restrict_login_store);
+static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
+                   lpfc_restrict_login_show, lpfc_restrict_login_store);
 
 /*
 # Some disk devices have a "select ID" or "select Target" capability.
@@ -1433,7 +1466,7 @@ MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
 lpfc_param_show(topology)
 lpfc_param_init(topology, 0, 0, 6)
 lpfc_param_store(topology)
-static CLASS_DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
                 lpfc_topology_show, lpfc_topology_store);
 
 /*
@@ -1497,7 +1530,7 @@ lpfc_link_speed_init(struct lpfc_hba *phba, int val)
 }
 
 lpfc_param_store(link_speed)
-static CLASS_DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
                 lpfc_link_speed_show, lpfc_link_speed_store);
 
 /*
@@ -1623,82 +1656,81 @@ LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
 
-struct class_device_attribute *lpfc_hba_attrs[] = {
-        &class_device_attr_info,
-        &class_device_attr_serialnum,
-        &class_device_attr_modeldesc,
-        &class_device_attr_modelname,
-        &class_device_attr_programtype,
-        &class_device_attr_portnum,
-        &class_device_attr_fwrev,
-        &class_device_attr_hdw,
-        &class_device_attr_option_rom_version,
-        &class_device_attr_state,
-        &class_device_attr_num_discovered_ports,
-        &class_device_attr_lpfc_drvr_version,
-        &class_device_attr_lpfc_temp_sensor,
-        &class_device_attr_lpfc_log_verbose,
-        &class_device_attr_lpfc_lun_queue_depth,
-        &class_device_attr_lpfc_hba_queue_depth,
-        &class_device_attr_lpfc_peer_port_login,
-        &class_device_attr_lpfc_nodev_tmo,
-        &class_device_attr_lpfc_devloss_tmo,
-        &class_device_attr_lpfc_fcp_class,
-        &class_device_attr_lpfc_use_adisc,
-        &class_device_attr_lpfc_ack0,
-        &class_device_attr_lpfc_topology,
-        &class_device_attr_lpfc_scan_down,
-        &class_device_attr_lpfc_link_speed,
-        &class_device_attr_lpfc_cr_delay,
-        &class_device_attr_lpfc_cr_count,
-        &class_device_attr_lpfc_multi_ring_support,
-        &class_device_attr_lpfc_multi_ring_rctl,
-        &class_device_attr_lpfc_multi_ring_type,
-        &class_device_attr_lpfc_fdmi_on,
-        &class_device_attr_lpfc_max_luns,
-        &class_device_attr_lpfc_enable_npiv,
-        &class_device_attr_nport_evt_cnt,
-        &class_device_attr_board_mode,
-        &class_device_attr_max_vpi,
-        &class_device_attr_used_vpi,
-        &class_device_attr_max_rpi,
-        &class_device_attr_used_rpi,
-        &class_device_attr_max_xri,
-        &class_device_attr_used_xri,
-        &class_device_attr_npiv_info,
-        &class_device_attr_issue_reset,
-        &class_device_attr_lpfc_poll,
-        &class_device_attr_lpfc_poll_tmo,
-        &class_device_attr_lpfc_use_msi,
-        &class_device_attr_lpfc_soft_wwnn,
-        &class_device_attr_lpfc_soft_wwpn,
-        &class_device_attr_lpfc_soft_wwn_enable,
-        &class_device_attr_lpfc_enable_hba_reset,
-        &class_device_attr_lpfc_enable_hba_heartbeat,
-        &class_device_attr_lpfc_sg_seg_cnt,
+struct device_attribute *lpfc_hba_attrs[] = {
+        &dev_attr_info,
+        &dev_attr_serialnum,
+        &dev_attr_modeldesc,
+        &dev_attr_modelname,
+        &dev_attr_programtype,
+        &dev_attr_portnum,
+        &dev_attr_fwrev,
+        &dev_attr_hdw,
+        &dev_attr_option_rom_version,
+        &dev_attr_state,
+        &dev_attr_num_discovered_ports,
+        &dev_attr_lpfc_drvr_version,
+        &dev_attr_lpfc_temp_sensor,
+        &dev_attr_lpfc_log_verbose,
+        &dev_attr_lpfc_lun_queue_depth,
+        &dev_attr_lpfc_hba_queue_depth,
+        &dev_attr_lpfc_peer_port_login,
+        &dev_attr_lpfc_nodev_tmo,
+        &dev_attr_lpfc_devloss_tmo,
+        &dev_attr_lpfc_fcp_class,
+        &dev_attr_lpfc_use_adisc,
+        &dev_attr_lpfc_ack0,
+        &dev_attr_lpfc_topology,
+        &dev_attr_lpfc_scan_down,
+        &dev_attr_lpfc_link_speed,
+        &dev_attr_lpfc_cr_delay,
+        &dev_attr_lpfc_cr_count,
+        &dev_attr_lpfc_multi_ring_support,
+        &dev_attr_lpfc_multi_ring_rctl,
+        &dev_attr_lpfc_multi_ring_type,
+        &dev_attr_lpfc_fdmi_on,
+        &dev_attr_lpfc_max_luns,
+        &dev_attr_lpfc_enable_npiv,
+        &dev_attr_nport_evt_cnt,
+        &dev_attr_board_mode,
+        &dev_attr_max_vpi,
+        &dev_attr_used_vpi,
+        &dev_attr_max_rpi,
+        &dev_attr_used_rpi,
+        &dev_attr_max_xri,
+        &dev_attr_used_xri,
+        &dev_attr_npiv_info,
+        &dev_attr_issue_reset,
+        &dev_attr_lpfc_poll,
+        &dev_attr_lpfc_poll_tmo,
+        &dev_attr_lpfc_use_msi,
+        &dev_attr_lpfc_soft_wwnn,
+        &dev_attr_lpfc_soft_wwpn,
+        &dev_attr_lpfc_soft_wwn_enable,
+        &dev_attr_lpfc_enable_hba_reset,
+        &dev_attr_lpfc_enable_hba_heartbeat,
+        &dev_attr_lpfc_sg_seg_cnt,
         NULL,
 };
 
-struct class_device_attribute *lpfc_vport_attrs[] = {
-        &class_device_attr_info,
-        &class_device_attr_state,
-        &class_device_attr_num_discovered_ports,
-        &class_device_attr_lpfc_drvr_version,
-
-        &class_device_attr_lpfc_log_verbose,
-        &class_device_attr_lpfc_lun_queue_depth,
-        &class_device_attr_lpfc_nodev_tmo,
-        &class_device_attr_lpfc_devloss_tmo,
-        &class_device_attr_lpfc_hba_queue_depth,
-        &class_device_attr_lpfc_peer_port_login,
-        &class_device_attr_lpfc_restrict_login,
-        &class_device_attr_lpfc_fcp_class,
-        &class_device_attr_lpfc_use_adisc,
-        &class_device_attr_lpfc_fdmi_on,
-        &class_device_attr_lpfc_max_luns,
-        &class_device_attr_nport_evt_cnt,
-        &class_device_attr_npiv_info,
-        &class_device_attr_lpfc_enable_da_id,
+struct device_attribute *lpfc_vport_attrs[] = {
+        &dev_attr_info,
+        &dev_attr_state,
+        &dev_attr_num_discovered_ports,
+        &dev_attr_lpfc_drvr_version,
+        &dev_attr_lpfc_log_verbose,
+        &dev_attr_lpfc_lun_queue_depth,
+        &dev_attr_lpfc_nodev_tmo,
+        &dev_attr_lpfc_devloss_tmo,
+        &dev_attr_lpfc_hba_queue_depth,
+        &dev_attr_lpfc_peer_port_login,
+        &dev_attr_lpfc_restrict_login,
+        &dev_attr_lpfc_fcp_class,
+        &dev_attr_lpfc_use_adisc,
+        &dev_attr_lpfc_fdmi_on,
+        &dev_attr_lpfc_max_luns,
+        &dev_attr_nport_evt_cnt,
+        &dev_attr_npiv_info,
+        &dev_attr_lpfc_enable_da_id,
         NULL,
 };
 
@@ -1707,9 +1739,8 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
                    char *buf, loff_t off, size_t count)
 {
         size_t buf_off;
-        struct class_device *cdev = container_of(kobj, struct class_device,
-                                                 kobj);
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -1741,9 +1772,8 @@ sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
 {
         size_t buf_off;
         uint32_t * tmp_ptr;
-        struct class_device *cdev = container_of(kobj, struct class_device,
-                                                 kobj);
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
@@ -1798,9 +1828,8 @@ static ssize_t
 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
                  char *buf, loff_t off, size_t count)
 {
-        struct class_device *cdev = container_of(kobj, struct class_device,
-                                                 kobj);
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         struct lpfcMboxq  *mbox = NULL;
@@ -1853,9 +1882,8 @@ static ssize_t
 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
                 char *buf, loff_t off, size_t count)
 {
-        struct class_device *cdev = container_of(kobj, struct class_device,
-                                                 kobj);
-        struct Scsi_Host  *shost = class_to_shost(cdev);
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         int rc;
@@ -2038,19 +2066,19 @@ lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
         int error;
 
-        error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
+        error = sysfs_create_bin_file(&shost->shost_dev.kobj,
                                       &sysfs_ctlreg_attr);
         if (error)
                 goto out;
 
-        error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
+        error = sysfs_create_bin_file(&shost->shost_dev.kobj,
                                       &sysfs_mbox_attr);
         if (error)
                 goto out_remove_ctlreg_attr;
 
         return 0;
 out_remove_ctlreg_attr:
-        sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
+        sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
 out:
         return error;
 }
@@ -2060,8 +2088,8 @@ lpfc_free_sysfs_attr(struct lpfc_vport *vport)
 {
         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
-        sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr);
-        sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
+        sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
+        sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
 }
 
 
@@ -2443,9 +2471,11 @@ lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 
 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
 static ssize_t                                                          \
-lpfc_show_rport_##field (struct class_device *cdev, char *buf)          \
+lpfc_show_rport_##field (struct device *dev,                            \
+                         struct device_attribute *attr,                 \
+                         char *buf)                                     \
 {                                                                       \
-        struct fc_rport *rport = transport_class_to_rport(cdev);        \
+        struct fc_rport *rport = transport_class_to_rport(dev);         \
         struct lpfc_rport_data *rdata = rport->hostdata;                \
         return snprintf(buf, sz, format_string,                         \
                 (rdata->target) ? cast rdata->target->field : 0);       \
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 0819f5f39de5..7c9f8317d972 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -253,8 +253,8 @@ void lpfc_get_cfgparam(struct lpfc_hba *);
 void lpfc_get_vport_cfgparam(struct lpfc_vport *);
 int lpfc_alloc_sysfs_attr(struct lpfc_vport *);
 void lpfc_free_sysfs_attr(struct lpfc_vport *);
-extern struct class_device_attribute *lpfc_hba_attrs[];
-extern struct class_device_attribute *lpfc_vport_attrs[];
+extern struct device_attribute *lpfc_hba_attrs[];
+extern struct device_attribute *lpfc_vport_attrs[];
 extern struct scsi_host_template lpfc_template;
 extern struct scsi_host_template lpfc_vport_template;
 extern struct fc_function_template lpfc_transport_functions;
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 9f041929aca5..820f91fb63ba 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -125,7 +125,7 @@ static irqreturn_t megaraid_isr(int, void *);
 
 static void megaraid_mbox_dpc(unsigned long);
 
-static ssize_t megaraid_sysfs_show_app_hndl(struct class_device *, char *);
+static ssize_t megaraid_sysfs_show_app_hndl(struct device *, struct device_attribute *attr, char *);
 static ssize_t megaraid_sysfs_show_ldnum(struct device *, struct device_attribute *attr, char *);
 
 static int megaraid_cmm_register(adapter_t *);
@@ -313,12 +313,12 @@ static struct pci_driver megaraid_pci_driver = {
 // definitions for the device attributes for exporting logical drive number
 // for a scsi address (Host, Channel, Id, Lun)
 
-CLASS_DEVICE_ATTR(megaraid_mbox_app_hndl, S_IRUSR, megaraid_sysfs_show_app_hndl,
+DEVICE_ATTR(megaraid_mbox_app_hndl, S_IRUSR, megaraid_sysfs_show_app_hndl,
                 NULL);
 
 // Host template initializer for megaraid mbox sysfs device attributes
-static struct class_device_attribute *megaraid_shost_attrs[] = {
-        &class_device_attr_megaraid_mbox_app_hndl,
+static struct device_attribute *megaraid_shost_attrs[] = {
+        &dev_attr_megaraid_mbox_app_hndl,
         NULL,
 };
 
@@ -4063,9 +4063,10 @@ megaraid_sysfs_get_ldmap(adapter_t *adapter)
  * handle, since we do not interface with applications directly.
  */
 static ssize_t
-megaraid_sysfs_show_app_hndl(struct class_device *cdev, char *buf)
+megaraid_sysfs_show_app_hndl(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         adapter_t       *adapter = (adapter_t *)SCSIHOST2ADAP(shost);
         uint32_t        app_hndl;
 
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index c5ebf018b378..d89289400425 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -8243,7 +8243,8 @@ static void process_waiting_list(struct ncb *np, int sts)
 
 #undef next_wcmd
 
-static ssize_t show_ncr53c8xx_revision(struct class_device *dev, char *buf)
+static ssize_t show_ncr53c8xx_revision(struct device *dev,
+                                       struct device_attribute *attr, char *buf)
 {
         struct Scsi_Host *host = class_to_shost(dev);
         struct host_data *host_data = (struct host_data *)host->hostdata;
@@ -8251,12 +8252,12 @@ static ssize_t show_ncr53c8xx_revision(struct class_device *dev, char *buf)
         return snprintf(buf, 20, "0x%x\n", host_data->ncb->revision_id);
 }
   
-static struct class_device_attribute ncr53c8xx_revision_attr = {
+static struct device_attribute ncr53c8xx_revision_attr = {
         .attr   = { .name = "revision", .mode = S_IRUGO, },
         .show   = show_ncr53c8xx_revision,
 };
   
-static struct class_device_attribute *ncr53c8xx_host_attrs[] = {
+static struct device_attribute *ncr53c8xx_host_attrs[] = {
         &ncr53c8xx_revision_attr,
         NULL
 };
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index abef7048f25b..31f7aec44d90 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -5591,9 +5591,10 @@ static void osst_remove_sysfs_files(struct device_driver *sysfs)
  * sysfs support for accessing ADR header information
  */
 
-static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_adr_rev_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5601,11 +5602,13 @@ static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf)
         return l;
 }
 
-CLASS_DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL);
+DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL);
 
-static ssize_t osst_linux_media_version_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_linux_media_version_show(struct device *dev,
+                                             struct device_attribute *attr,
+                                             char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5613,11 +5616,12 @@ static ssize_t osst_linux_media_version_show(struct class_device *class_dev, cha
         return l;
 }
 
-CLASS_DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL);
+DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL);
 
-static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_capacity_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5625,11 +5629,13 @@ static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf)
         return l;
 }
 
-CLASS_DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL);
+DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL);
 
-static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_first_data_ppos_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5637,11 +5643,13 @@ static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *b
         return l;
 }
 
-CLASS_DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL);
+DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL);
 
-static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_eod_frame_ppos_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5649,11 +5657,12 @@ static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *bu
         return l;
 }
 
-CLASS_DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL);
+DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL);
 
-static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf)
+static ssize_t osst_filemark_cnt_show(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
 {
-        struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
+        struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
         ssize_t l = 0;
 
         if (STp && STp->header_ok && STp->linux_media)
@@ -5661,7 +5670,7 @@ static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf)
         return l;
 }
 
-CLASS_DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL);
+DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL);
 
 static struct class *osst_sysfs_class;
 
@@ -5678,44 +5687,37 @@ static int osst_sysfs_init(void)
 
 static void osst_sysfs_destroy(dev_t dev)
 {
-        class_device_destroy(osst_sysfs_class, dev);
+        device_destroy(osst_sysfs_class, dev);
 }
 
 static int osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name)
 {
-        struct class_device *osst_class_member;
+        struct device *osst_member;
         int err;
 
-        osst_class_member = class_device_create(osst_sysfs_class, NULL, dev,
-                                                device, "%s", name);
-        if (IS_ERR(osst_class_member)) {
+        osst_member = device_create(osst_sysfs_class, device, dev, "%s", name);
+        if (IS_ERR(osst_member)) {
                 printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name);
-                return PTR_ERR(osst_class_member);
+                return PTR_ERR(osst_member);
         }
 
-        class_set_devdata(osst_class_member, STp);
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_ADR_rev);
+        dev_set_drvdata(osst_member, STp);
+        err = device_create_file(osst_member, &dev_attr_ADR_rev);
         if (err)
                 goto err_out;
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_media_version);
+        err = device_create_file(osst_member, &dev_attr_media_version);
         if (err)
                 goto err_out;
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_capacity);
+        err = device_create_file(osst_member, &dev_attr_capacity);
         if (err)
                 goto err_out;
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_BOT_frame);
+        err = device_create_file(osst_member, &dev_attr_BOT_frame);
         if (err)
                 goto err_out;
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_EOD_frame);
+        err = device_create_file(osst_member, &dev_attr_EOD_frame);
         if (err)
                 goto err_out;
-        err = class_device_create_file(osst_class_member,
-                                       &class_device_attr_file_count);
+        err = device_create_file(osst_member, &dev_attr_file_count);
         if (err)
                 goto err_out;
 
diff --git a/drivers/scsi/pcmcia/sym53c500_cs.c b/drivers/scsi/pcmcia/sym53c500_cs.c
index 3454a5714749..0be232b58ffb 100644
--- a/drivers/scsi/pcmcia/sym53c500_cs.c
+++ b/drivers/scsi/pcmcia/sym53c500_cs.c
@@ -632,9 +632,10 @@ SYM53C500_biosparm(struct scsi_device *disk,
 }
 
 static ssize_t
-SYM53C500_show_pio(struct class_device *cdev, char *buf)
+SYM53C500_show_pio(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct Scsi_Host *SHp = class_to_shost(cdev);
+        struct Scsi_Host *SHp = class_to_shost(dev);
         struct sym53c500_data *data =
             (struct sym53c500_data *)SHp->hostdata;
 
@@ -642,10 +643,11 @@ SYM53C500_show_pio(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-SYM53C500_store_pio(struct class_device *cdev, const char *buf, size_t count)
+SYM53C500_store_pio(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
 {
         int pio;
-        struct Scsi_Host *SHp = class_to_shost(cdev);
+        struct Scsi_Host *SHp = class_to_shost(dev);
         struct sym53c500_data *data =
             (struct sym53c500_data *)SHp->hostdata;
 
@@ -662,7 +664,7 @@ SYM53C500_store_pio(struct class_device *cdev, const char *buf, size_t count)
 *  SCSI HBA device attributes we want to
 *  make available via sysfs.
 */
-static struct class_device_attribute SYM53C500_pio_attr = {
+static struct device_attribute SYM53C500_pio_attr = {
         .attr = {
                 .name = "fast_pio",
                 .mode = (S_IRUGO | S_IWUSR),
@@ -671,7 +673,7 @@ static struct class_device_attribute SYM53C500_pio_attr = {
         .store = SYM53C500_store_pio,
 };
 
-static struct class_device_attribute *SYM53C500_shost_attrs[] = {
+static struct device_attribute *SYM53C500_shost_attrs[] = {
         &SYM53C500_pio_attr,
         NULL,
 };
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 413d8cd6a324..d61df036910c 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -530,15 +530,17 @@ qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
 /* Scsi_Host attributes. */
 
 static ssize_t
-qla2x00_drvr_version_show(struct class_device *cdev, char *buf)
+qla2x00_drvr_version_show(struct device *dev,
+                          struct device_attribute *attr, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
 }
 
 static ssize_t
-qla2x00_fw_version_show(struct class_device *cdev, char *buf)
+qla2x00_fw_version_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         char fw_str[30];
 
         return snprintf(buf, PAGE_SIZE, "%s\n",
@@ -546,9 +548,10 @@ qla2x00_fw_version_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_serial_num_show(struct class_device *cdev, char *buf)
+qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         uint32_t sn;
 
         if (IS_FWI2_CAPABLE(ha))
@@ -560,40 +563,45 @@ qla2x00_serial_num_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_isp_name_show(struct class_device *cdev, char *buf)
+qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
 }
 
 static ssize_t
-qla2x00_isp_id_show(struct class_device *cdev, char *buf)
+qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
             ha->product_id[0], ha->product_id[1], ha->product_id[2],
             ha->product_id[3]);
 }
 
 static ssize_t
-qla2x00_model_name_show(struct class_device *cdev, char *buf)
+qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
 }
 
 static ssize_t
-qla2x00_model_desc_show(struct class_device *cdev, char *buf)
+qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         return snprintf(buf, PAGE_SIZE, "%s\n",
             ha->model_desc ? ha->model_desc: "");
 }
 
 static ssize_t
-qla2x00_pci_info_show(struct class_device *cdev, char *buf)
+qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         char pci_info[30];
 
         return snprintf(buf, PAGE_SIZE, "%s\n",
@@ -601,9 +609,10 @@ qla2x00_pci_info_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_state_show(struct class_device *cdev, char *buf)
+qla2x00_state_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int len = 0;
 
         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
@@ -639,9 +648,10 @@ qla2x00_state_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_zio_show(struct class_device *cdev, char *buf)
+qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
+                 char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int len = 0;
 
         switch (ha->zio_mode) {
@@ -656,9 +666,10 @@ qla2x00_zio_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
+qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
+                  const char *buf, size_t count)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int val = 0;
         uint16_t zio_mode;
 
@@ -682,18 +693,19 @@ qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
 }
 
 static ssize_t
-qla2x00_zio_timer_show(struct class_device *cdev, char *buf)
+qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
+                       char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
 
         return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
 }
 
 static ssize_t
-qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
-    size_t count)
+qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int val = 0;
         uint16_t zio_timer;
 
@@ -709,9 +721,10 @@ qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
 }
 
 static ssize_t
-qla2x00_beacon_show(struct class_device *cdev, char *buf)
+qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int len = 0;
 
         if (ha->beacon_blink_led)
@@ -722,10 +735,10 @@ qla2x00_beacon_show(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-qla2x00_beacon_store(struct class_device *cdev, const char *buf,
-    size_t count)
+qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
         int val = 0;
         int rval;
 
@@ -753,84 +766,86 @@ qla2x00_beacon_store(struct class_device *cdev, const char *buf,
 }
 
 static ssize_t
-qla2x00_optrom_bios_version_show(struct class_device *cdev, char *buf)
+qla2x00_optrom_bios_version_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
 
         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
             ha->bios_revision[0]);
 }
 
 static ssize_t
-qla2x00_optrom_efi_version_show(struct class_device *cdev, char *buf)
+qla2x00_optrom_efi_version_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
 
         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
             ha->efi_revision[0]);
 }
 
 static ssize_t
-qla2x00_optrom_fcode_version_show(struct class_device *cdev, char *buf)
+qla2x00_optrom_fcode_version_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
 
         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
             ha->fcode_revision[0]);
 }
 
 static ssize_t
-qla2x00_optrom_fw_version_show(struct class_device *cdev, char *buf)
+qla2x00_optrom_fw_version_show(struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
-        scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
+        scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
 
         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
             ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
             ha->fw_revision[3]);
 }
 
-static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show,
-        NULL);
-static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
-static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
-static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
-static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
-static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
-static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
-static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
-static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
-static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show,
-    qla2x00_zio_store);
-static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
-    qla2x00_zio_timer_store);
-static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
-    qla2x00_beacon_store);
-static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO,
-    qla2x00_optrom_bios_version_show, NULL);
-static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO,
-    qla2x00_optrom_efi_version_show, NULL);
-static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
-    qla2x00_optrom_fcode_version_show, NULL);
-static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO,
-    qla2x00_optrom_fw_version_show, NULL);
-
-struct class_device_attribute *qla2x00_host_attrs[] = {
-        &class_device_attr_driver_version,
-        &class_device_attr_fw_version,
-        &class_device_attr_serial_num,
-        &class_device_attr_isp_name,
-        &class_device_attr_isp_id,
-        &class_device_attr_model_name,
-        &class_device_attr_model_desc,
-        &class_device_attr_pci_info,
-        &class_device_attr_state,
-        &class_device_attr_zio,
-        &class_device_attr_zio_timer,
-        &class_device_attr_beacon,
-        &class_device_attr_optrom_bios_version,
-        &class_device_attr_optrom_efi_version,
-        &class_device_attr_optrom_fcode_version,
-        &class_device_attr_optrom_fw_version,
+static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
+static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
+static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
+static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
+static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
+static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
+static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
+static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
+static DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
+static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
+static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
+                   qla2x00_zio_timer_store);
+static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
+                   qla2x00_beacon_store);
+static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
+                   qla2x00_optrom_bios_version_show, NULL);
+static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
+                   qla2x00_optrom_efi_version_show, NULL);
+static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
+                   qla2x00_optrom_fcode_version_show, NULL);
+static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
+                   NULL);
+
+struct device_attribute *qla2x00_host_attrs[] = {
+        &dev_attr_driver_version,
+        &dev_attr_fw_version,
+        &dev_attr_serial_num,
+        &dev_attr_isp_name,
+        &dev_attr_isp_id,
+        &dev_attr_model_name,
+        &dev_attr_model_desc,
+        &dev_attr_pci_info,
+        &dev_attr_state,
+        &dev_attr_zio,
+        &dev_attr_zio_timer,
+        &dev_attr_beacon,
+        &dev_attr_optrom_bios_version,
+        &dev_attr_optrom_efi_version,
+        &dev_attr_optrom_fcode_version,
+        &dev_attr_optrom_fw_version,
         NULL,
 };
 
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index a9571c214a9e..76eb4fecce65 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -347,8 +347,8 @@ extern void qla2x00_get_sym_node_name(scsi_qla_host_t *, uint8_t *);
 /*
  * Global Function Prototypes in qla_attr.c source file.
  */
-struct class_device_attribute;
-extern struct class_device_attribute *qla2x00_host_attrs[];
+struct device_attribute;
+extern struct device_attribute *qla2x00_host_attrs[];
 struct fc_function_template;
 extern struct fc_function_template qla2xxx_transport_functions;
 extern struct fc_function_template qla2xxx_transport_vport_functions;
diff --git a/drivers/scsi/raid_class.c b/drivers/scsi/raid_class.c
index 52182a744ba6..913a931176ef 100644
--- a/drivers/scsi/raid_class.c
+++ b/drivers/scsi/raid_class.c
@@ -24,15 +24,15 @@ struct raid_internal {
         struct raid_template r;
         struct raid_function_template *f;
         /* The actual attributes */
-        struct class_device_attribute private_attrs[RAID_NUM_ATTRS];
+        struct device_attribute private_attrs[RAID_NUM_ATTRS];
         /* The array of null terminated pointers to attributes 
          * needed by scsi_sysfs.c */
-        struct class_device_attribute *attrs[RAID_NUM_ATTRS + 1];
+        struct device_attribute *attrs[RAID_NUM_ATTRS + 1];
 };
 
 struct raid_component {
         struct list_head node;
-        struct class_device cdev;
+        struct device dev;
         int num;
 };
 
@@ -50,9 +50,9 @@ struct raid_component {
         tc_to_raid_internal(tc);                                        \
 })
 
-#define class_device_to_raid_internal(cdev) ({                          \
+#define device_to_raid_internal(dev) ({                         \
         struct attribute_container *ac =                                \
-                attribute_container_classdev_to_container(cdev);        \
+                attribute_container_classdev_to_container(dev); \
         ac_to_raid_internal(ac);                                        \
 })
         
@@ -76,33 +76,33 @@ static int raid_match(struct attribute_container *cont, struct device *dev)
 }
 
 static int raid_setup(struct transport_container *tc, struct device *dev,
-                       struct class_device *cdev)
+                       struct device *cdev)
 {
         struct raid_data *rd;
 
-        BUG_ON(class_get_devdata(cdev));
+        BUG_ON(dev_get_drvdata(cdev));
 
         rd = kzalloc(sizeof(*rd), GFP_KERNEL);
         if (!rd)
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&rd->component_list);
-        class_set_devdata(cdev, rd);
+        dev_set_drvdata(cdev, rd);
                 
         return 0;
 }
 
 static int raid_remove(struct transport_container *tc, struct device *dev,
-                       struct class_device *cdev)
+                       struct device *cdev)
 {
-        struct raid_data *rd = class_get_devdata(cdev);
+        struct raid_data *rd = dev_get_drvdata(cdev);
         struct raid_component *rc, *next;
         dev_printk(KERN_ERR, dev, "RAID REMOVE\n");
-        class_set_devdata(cdev, NULL);
+        dev_set_drvdata(cdev, NULL);
         list_for_each_entry_safe(rc, next, &rd->component_list, node) {
                 list_del(&rc->node);
-                dev_printk(KERN_ERR, rc->cdev.dev, "RAID COMPONENT REMOVE\n");
-                class_device_unregister(&rc->cdev);
+                dev_printk(KERN_ERR, rc->dev.parent, "RAID COMPONENT REMOVE\n");
+                device_unregister(&rc->dev);
         }
         dev_printk(KERN_ERR, dev, "RAID REMOVE DONE\n");
         kfree(rd);
@@ -171,9 +171,11 @@ static const char *raid_level_name(enum raid_level level)
 }
 
 #define raid_attr_show_internal(attr, fmt, var, code)                   \
-static ssize_t raid_show_##attr(struct class_device *cdev, char *buf)   \
+static ssize_t raid_show_##attr(struct device *dev,                     \
+                                struct device_attribute *attr,          \
+                                char *buf)                              \
 {                                                                       \
-        struct raid_data *rd = class_get_devdata(cdev);                 \
+        struct raid_data *rd = dev_get_drvdata(dev);                    \
         code                                                            \
         return snprintf(buf, 20, #fmt "\n", var);                       \
 }
@@ -184,17 +186,17 @@ raid_attr_show_internal(attr, %s, name,					\
         code                                                            \
         name = raid_##states##_name(rd->attr);                          \
 )                                                                       \
-static CLASS_DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL)
+static DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL)
 
 
 #define raid_attr_ro_internal(attr, code)                               \
 raid_attr_show_internal(attr, %d, rd->attr, code)                       \
-static CLASS_DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL)
+static DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL)
 
 #define ATTR_CODE(attr)                                                 \
-        struct raid_internal *i = class_device_to_raid_internal(cdev);  \
+        struct raid_internal *i = device_to_raid_internal(dev);         \
         if (i->f->get_##attr)                                           \
-                i->f->get_##attr(cdev->dev);
+                i->f->get_##attr(dev->parent);
 
 #define raid_attr_ro(attr)      raid_attr_ro_internal(attr, )
 #define raid_attr_ro_fn(attr)   raid_attr_ro_internal(attr, ATTR_CODE(attr))
@@ -206,23 +208,23 @@ raid_attr_ro_state(level);
 raid_attr_ro_fn(resync);
 raid_attr_ro_state_fn(state);
 
-static void raid_component_release(struct class_device *cdev)
+static void raid_component_release(struct device *dev)
 {
-        struct raid_component *rc = container_of(cdev, struct raid_component,
-                                                 cdev);
-        dev_printk(KERN_ERR, rc->cdev.dev, "COMPONENT RELEASE\n");
-        put_device(rc->cdev.dev);
+        struct raid_component *rc =
+                container_of(dev, struct raid_component, dev);
+        dev_printk(KERN_ERR, rc->dev.parent, "COMPONENT RELEASE\n");
+        put_device(rc->dev.parent);
         kfree(rc);
 }
 
 int raid_component_add(struct raid_template *r,struct device *raid_dev,
                        struct device *component_dev)
 {
-        struct class_device *cdev =
+        struct device *cdev =
                 attribute_container_find_class_device(&r->raid_attrs.ac,
                                                       raid_dev);
         struct raid_component *rc;
-        struct raid_data *rd = class_get_devdata(cdev);
+        struct raid_data *rd = dev_get_drvdata(cdev);
         int err;
 
         rc = kzalloc(sizeof(*rc), GFP_KERNEL);
@@ -230,17 +232,16 @@ int raid_component_add(struct raid_template *r,struct device *raid_dev,
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&rc->node);
-        class_device_initialize(&rc->cdev);
-        rc->cdev.release = raid_component_release;
-        rc->cdev.dev = get_device(component_dev);
+        device_initialize(&rc->dev);
+        rc->dev.release = raid_component_release;
+        rc->dev.parent = get_device(component_dev);
         rc->num = rd->component_count++;
 
-        snprintf(rc->cdev.class_id, sizeof(rc->cdev.class_id),
+        snprintf(rc->dev.bus_id, sizeof(rc->dev.bus_id),
                  "component-%d", rc->num);
         list_add_tail(&rc->node, &rd->component_list);
-        rc->cdev.parent = cdev;
-        rc->cdev.class = &raid_class.class;
-        err = class_device_add(&rc->cdev);
+        rc->dev.class = &raid_class.class;
+        err = device_add(&rc->dev);
         if (err)
                 goto err_out;
 
@@ -273,9 +274,9 @@ raid_class_attach(struct raid_function_template *ft)
 
         attribute_container_register(&i->r.raid_attrs.ac);
 
-        i->attrs[count++] = &class_device_attr_level;
-        i->attrs[count++] = &class_device_attr_resync;
-        i->attrs[count++] = &class_device_attr_state;
+        i->attrs[count++] = &dev_attr_level;
+        i->attrs[count++] = &dev_attr_resync;
+        i->attrs[count++] = &dev_attr_state;
 
         i->attrs[count] = NULL;
         BUG_ON(count > RAID_NUM_ATTRS);
diff --git a/drivers/scsi/scsi_sas_internal.h b/drivers/scsi/scsi_sas_internal.h
index e1edab45a37b..998cb5be6833 100644
--- a/drivers/scsi/scsi_sas_internal.h
+++ b/drivers/scsi/scsi_sas_internal.h
@@ -13,12 +13,12 @@ struct sas_internal {
         struct sas_function_template *f;
         struct sas_domain_function_template *dft;
 
-        struct class_device_attribute private_host_attrs[SAS_HOST_ATTRS];
-        struct class_device_attribute private_phy_attrs[SAS_PHY_ATTRS];
-        struct class_device_attribute private_port_attrs[SAS_PORT_ATTRS];
-        struct class_device_attribute private_rphy_attrs[SAS_RPORT_ATTRS];
-        struct class_device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS];
-        struct class_device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS];
+        struct device_attribute private_host_attrs[SAS_HOST_ATTRS];
+        struct device_attribute private_phy_attrs[SAS_PHY_ATTRS];
+        struct device_attribute private_port_attrs[SAS_PORT_ATTRS];
+        struct device_attribute private_rphy_attrs[SAS_RPORT_ATTRS];
+        struct device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS];
+        struct device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS];
 
         struct transport_container phy_attr_cont;
         struct transport_container port_attr_cont;
@@ -30,12 +30,12 @@ struct sas_internal {
          * The array of null terminated pointers to attributes
          * needed by scsi_sysfs.c
          */
-        struct class_device_attribute *host_attrs[SAS_HOST_ATTRS + 1];
-        struct class_device_attribute *phy_attrs[SAS_PHY_ATTRS + 1];
-        struct class_device_attribute *port_attrs[SAS_PORT_ATTRS + 1];
-        struct class_device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1];
-        struct class_device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1];
-        struct class_device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1];
+        struct device_attribute *host_attrs[SAS_HOST_ATTRS + 1];
+        struct device_attribute *phy_attrs[SAS_PHY_ATTRS + 1];
+        struct device_attribute *port_attrs[SAS_PORT_ATTRS + 1];
+        struct device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1];
+        struct device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1];
+        struct device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1];
 };
 #define to_sas_internal(tmpl)   container_of(tmpl, struct sas_internal, t)
 
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index ed83cdb6e67d..67bb20ed45d2 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -119,9 +119,10 @@ static int scsi_scan(struct Scsi_Host *shost, const char *str)
  */
 #define shost_show_function(name, field, format_string)                 \
 static ssize_t                                                          \
-show_##name (struct class_device *class_dev, char *buf)                 \
+show_##name (struct device *dev, struct device_attribute *attr,         \
+             char *buf)                                                 \
 {                                                                       \
-        struct Scsi_Host *shost = class_to_shost(class_dev);            \
+        struct Scsi_Host *shost = class_to_shost(dev);                  \
         return snprintf (buf, 20, format_string, shost->field);         \
 }
 
@@ -131,7 +132,7 @@ show_##name (struct class_device *class_dev, char *buf)			\
  */
 #define shost_rd_attr2(name, field, format_string)                      \
         shost_show_function(name, field, format_string)                 \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
+static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 
 #define shost_rd_attr(field, format_string) \
 shost_rd_attr2(field, field, format_string)
@@ -140,10 +141,11 @@ shost_rd_attr2(field, field, format_string)
  * Create the actual show/store functions and data structures.
  */
 
-static ssize_t store_scan(struct class_device *class_dev, const char *buf,
-                          size_t count)
+static ssize_t
+store_scan(struct device *dev, struct device_attribute *attr,
+           const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         int res;
 
         res = scsi_scan(shost, buf);
@@ -151,13 +153,14 @@ static ssize_t store_scan(struct class_device *class_dev, const char *buf,
                 res = count;
         return res;
 };
-static CLASS_DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
+static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
 
 static ssize_t
-store_shost_state(struct class_device *class_dev, const char *buf, size_t count)
+store_shost_state(struct device *dev, struct device_attribute *attr,
+                  const char *buf, size_t count)
 {
         int i;
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         enum scsi_host_state state = 0;
 
         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
@@ -177,9 +180,9 @@ store_shost_state(struct class_device *class_dev, const char *buf, size_t count)
 }
 
 static ssize_t
-show_shost_state(struct class_device *class_dev, char *buf)
+show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         const char *name = scsi_host_state_name(shost->shost_state);
 
         if (!name)
@@ -188,7 +191,9 @@ show_shost_state(struct class_device *class_dev, char *buf)
         return snprintf(buf, 20, "%s\n", name);
 }
 
-static CLASS_DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
+/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
+struct device_attribute dev_attr_hstate =
+        __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
 
 static ssize_t
 show_shost_mode(unsigned int mode, char *buf)
@@ -206,9 +211,11 @@ show_shost_mode(unsigned int mode, char *buf)
         return len;
 }
 
-static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *buf)
+static ssize_t
+show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
         unsigned int supported_mode = shost->hostt->supported_mode;
 
         if (supported_mode == MODE_UNKNOWN)
@@ -218,11 +225,13 @@ static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *b
         return show_shost_mode(supported_mode, buf);
 }
 
-static CLASS_DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
+static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
 
-static ssize_t show_shost_active_mode(struct class_device *class_dev, char *buf)
+static ssize_t
+show_shost_active_mode(struct device *dev,
+                       struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = class_to_shost(class_dev);
+        struct Scsi_Host *shost = class_to_shost(dev);
 
         if (shost->active_mode == MODE_UNKNOWN)
                 return snprintf(buf, 20, "unknown\n");
@@ -230,7 +239,7 @@ static ssize_t show_shost_active_mode(struct class_device *class_dev, char *buf)
                 return show_shost_mode(shost->active_mode, buf);
 }
 
-static CLASS_DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
+static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
 
 shost_rd_attr(unique_id, "%u\n");
 shost_rd_attr(host_busy, "%hu\n");
@@ -240,22 +249,22 @@ shost_rd_attr(sg_tablesize, "%hu\n");
 shost_rd_attr(unchecked_isa_dma, "%d\n");
 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
 
-static struct class_device_attribute *scsi_sysfs_shost_attrs[] = {
-        &class_device_attr_unique_id,
-        &class_device_attr_host_busy,
-        &class_device_attr_cmd_per_lun,
-        &class_device_attr_can_queue,
-        &class_device_attr_sg_tablesize,
-        &class_device_attr_unchecked_isa_dma,
-        &class_device_attr_proc_name,
-        &class_device_attr_scan,
-        &class_device_attr_state,
-        &class_device_attr_supported_mode,
-        &class_device_attr_active_mode,
+static struct device_attribute *scsi_sysfs_shost_attrs[] = {
+        &dev_attr_unique_id,
+        &dev_attr_host_busy,
+        &dev_attr_cmd_per_lun,
+        &dev_attr_can_queue,
+        &dev_attr_sg_tablesize,
+        &dev_attr_unchecked_isa_dma,
+        &dev_attr_proc_name,
+        &dev_attr_scan,
+        &dev_attr_hstate,
+        &dev_attr_supported_mode,
+        &dev_attr_active_mode,
         NULL
 };
 
-static void scsi_device_cls_release(struct class_device *class_dev)
+static void scsi_device_cls_release(struct device *class_dev)
 {
         struct scsi_device *sdev;
 
@@ -320,7 +329,7 @@ static void scsi_device_dev_release(struct device *dev)
 
 static struct class sdev_class = {
         .name           = "scsi_device",
-        .release        = scsi_device_cls_release,
+        .dev_release    = scsi_device_cls_release,
 };
 
 /* all probing is done in the individual ->probe routines */
@@ -424,7 +433,8 @@ void scsi_sysfs_unregister(void)
  */
 #define sdev_show_function(field, format_string)                                \
 static ssize_t                                                          \
-sdev_show_##field (struct device *dev, struct device_attribute *attr, char *buf)                                \
+sdev_show_##field (struct device *dev, struct device_attribute *attr,   \
+                   char *buf)                                           \
 {                                                                       \
         struct scsi_device *sdev;                                       \
         sdev = to_scsi_device(dev);                                     \
@@ -448,7 +458,8 @@ static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
         sdev_show_function(field, format_string)                                \
                                                                         \
 static ssize_t                                                          \
-sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)   \
+sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
+                    const char *buf, size_t count)                      \
 {                                                                       \
         struct scsi_device *sdev;                                       \
         sdev = to_scsi_device(dev);                                     \
@@ -468,7 +479,8 @@ static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##fie
         sdev_show_function(field, "%d\n")                                       \
                                                                         \
 static ssize_t                                                          \
-sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)   \
+sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
+                    const char *buf, size_t count)                      \
 {                                                                       \
         int ret;                                                        \
         struct scsi_device *sdev;                                       \
@@ -519,7 +531,8 @@ sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
 }
 
 static ssize_t
-sdev_store_timeout (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+sdev_store_timeout (struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
 {
         struct scsi_device *sdev;
         int timeout;
@@ -531,7 +544,8 @@ sdev_store_timeout (struct device *dev, struct device_attribute *attr, const cha
 static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
 
 static ssize_t
-store_rescan_field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+store_rescan_field (struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
 {
         scsi_rescan_device(dev);
         return count;
@@ -543,8 +557,9 @@ static void sdev_store_delete_callback(struct device *dev)
         scsi_remove_device(to_scsi_device(dev));
 }
 
-static ssize_t sdev_store_delete(struct device *dev, struct device_attribute *attr, const char *buf,
-                                 size_t count)
+static ssize_t
+sdev_store_delete(struct device *dev, struct device_attribute *attr,
+                  const char *buf, size_t count)
 {
         int rc;
 
@@ -559,7 +574,8 @@ static ssize_t sdev_store_delete(struct device *dev, struct device_attribute *at
 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
 
 static ssize_t
-store_state_field(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+store_state_field(struct device *dev, struct device_attribute *attr,
+                  const char *buf, size_t count)
 {
         int i;
         struct scsi_device *sdev = to_scsi_device(dev);
@@ -596,7 +612,8 @@ show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
 
 static ssize_t
-show_queue_type_field(struct device *dev, struct device_attribute *attr, char *buf)
+show_queue_type_field(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
         const char *name = "none";
@@ -612,7 +629,7 @@ show_queue_type_field(struct device *dev, struct device_attribute *attr, char *b
 static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
 
 static ssize_t
-show_iostat_counterbits(struct device *dev, struct device_attribute *attr, char *buf)
+show_iostat_counterbits(struct device *dev, struct device_attribute *attr,                              char *buf)
 {
         return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
 }
@@ -621,7 +638,8 @@ static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
 
 #define show_sdev_iostat(field)                                         \
 static ssize_t                                                          \
-show_iostat_##field(struct device *dev, struct device_attribute *attr, char *buf)                       \
+show_iostat_##field(struct device *dev, struct device_attribute *attr,  \
+                    char *buf)                                          \
 {                                                                       \
         struct scsi_device *sdev = to_scsi_device(dev);                 \
         unsigned long long count = atomic_read(&sdev->field);           \
@@ -645,7 +663,7 @@ static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
 #define DECLARE_EVT_SHOW(name, Cap_name)                                \
 static ssize_t                                                          \
 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
-                                char *buf)                              \
+                     char *buf)                                         \
 {                                                                       \
         struct scsi_device *sdev = to_scsi_device(dev);                 \
         int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
@@ -654,7 +672,7 @@ sdev_show_evt_##name(struct device *dev, struct device_attribute *attr,	\
 
 #define DECLARE_EVT_STORE(name, Cap_name)                               \
 static ssize_t                                                          \
-sdev_store_evt_##name(struct device *dev, struct device_attribute *attr, \
+sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
                       const char *buf, size_t count)                    \
 {                                                                       \
         struct scsi_device *sdev = to_scsi_device(dev);                 \
@@ -707,8 +725,9 @@ static struct attribute_group *scsi_sdev_attr_groups[] = {
         NULL
 };
 
-static ssize_t sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr, const char *buf,
-                                         size_t count)
+static ssize_t
+sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
 {
         int depth, retval;
         struct scsi_device *sdev = to_scsi_device(dev);
@@ -733,8 +752,9 @@ static struct device_attribute sdev_attr_queue_depth_rw =
         __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
                sdev_store_queue_depth_rw);
 
-static ssize_t sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr, const char *buf,
-                                        size_t count)
+static ssize_t
+sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
+                         const char *buf, size_t count)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
         struct scsi_host_template *sht = sdev->host->hostt;
@@ -786,13 +806,13 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
                 printk(KERN_INFO "error 1\n");
                 return error;
         }
-        error = class_device_add(&sdev->sdev_classdev);
+        error = device_add(&sdev->sdev_dev);
         if (error) {
                 printk(KERN_INFO "error 2\n");
                 goto clean_device;
         }
 
-        /* take a reference for the sdev_classdev; this is
+        /* take a reference for the sdev_dev; this is
          * released by the sdev_class .release */
         get_device(&sdev->sdev_gendev);
 
@@ -858,7 +878,7 @@ void __scsi_remove_device(struct scsi_device *sdev)
                 return;
 
         bsg_unregister_queue(sdev->request_queue);
-        class_device_unregister(&sdev->sdev_classdev);
+        device_unregister(&sdev->sdev_dev);
         transport_remove_device(dev);
         device_del(dev);
         scsi_device_set_state(sdev, SDEV_DEL);
@@ -952,9 +972,9 @@ int scsi_register_interface(struct class_interface *intf)
 EXPORT_SYMBOL(scsi_register_interface);
 
 
-static struct class_device_attribute *class_attr_overridden(
-                struct class_device_attribute **attrs,
-                struct class_device_attribute *attr)
+static struct device_attribute *class_attr_overridden(
+                struct device_attribute **attrs,
+                struct device_attribute *attr)
 {
         int i;
 
@@ -966,10 +986,10 @@ static struct class_device_attribute *class_attr_overridden(
         return NULL;
 }
 
-static int class_attr_add(struct class_device *classdev,
-                struct class_device_attribute *attr)
+static int class_attr_add(struct device *classdev,
+                struct device_attribute *attr)
 {
-        struct class_device_attribute *base_attr;
+        struct device_attribute *base_attr;
 
         /*
          * Spare the caller from having to copy things it's not interested in.
@@ -986,7 +1006,7 @@ static int class_attr_add(struct class_device *classdev,
                         attr->store = base_attr->store;
         }
 
-        return class_device_create_file(classdev, attr);
+        return device_create_file(classdev, attr);
 }
 
 /**
@@ -1000,7 +1020,7 @@ int scsi_sysfs_add_host(struct Scsi_Host *shost)
 
         if (shost->hostt->shost_attrs) {
                 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
-                        error = class_attr_add(&shost->shost_classdev,
+                        error = class_attr_add(&shost->shost_dev,
                                         shost->hostt->shost_attrs[i]);
                         if (error)
                                 return error;
@@ -1010,7 +1030,7 @@ int scsi_sysfs_add_host(struct Scsi_Host *shost)
         for (i = 0; scsi_sysfs_shost_attrs[i]; i++) {
                 if (!class_attr_overridden(shost->hostt->shost_attrs,
                                         scsi_sysfs_shost_attrs[i])) {
-                        error = class_device_create_file(&shost->shost_classdev,
+                        error = device_create_file(&shost->shost_dev,
                                         scsi_sysfs_shost_attrs[i]);
                         if (error)
                                 return error;
@@ -1041,10 +1061,10 @@ void scsi_sysfs_device_initialize(struct scsi_device *sdev)
                 sdev->host->host_no, sdev->channel, sdev->id,
                 sdev->lun);
         
-        class_device_initialize(&sdev->sdev_classdev);
-        sdev->sdev_classdev.dev = &sdev->sdev_gendev;
-        sdev->sdev_classdev.class = &sdev_class;
-        snprintf(sdev->sdev_classdev.class_id, BUS_ID_SIZE,
+        device_initialize(&sdev->sdev_dev);
+        sdev->sdev_dev.parent = &sdev->sdev_gendev;
+        sdev->sdev_dev.class = &sdev_class;
+        snprintf(sdev->sdev_dev.bus_id, BUS_ID_SIZE,
                  "%d:%d:%d:%d", sdev->host->host_no,
                  sdev->channel, sdev->id, sdev->lun);
         sdev->scsi_level = starget->scsi_level;
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index b1119da6e88c..6b092a6c295d 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -72,8 +72,8 @@ static int fc_vport_create(struct Scsi_Host *shost, int channel,
  * Redefine so that we can have same named attributes in the
  * sdev/starget/host objects.
  */
-#define FC_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store)          \
-struct class_device_attribute class_device_attr_##_prefix##_##_name =   \
+#define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store)                \
+struct device_attribute device_attr_##_prefix##_##_name =       \
         __ATTR(_name,_mode,_show,_store)
 
 #define fc_enum_name_search(title, table_type, table)                   \
@@ -326,26 +326,26 @@ struct fc_internal {
          * part of the midlayer. As the remote port is specific to the
          * fc transport, we must provide the attribute container.
          */
-        struct class_device_attribute private_starget_attrs[
+        struct device_attribute private_starget_attrs[
                                                         FC_STARGET_NUM_ATTRS];
-        struct class_device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
+        struct device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
 
-        struct class_device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
-        struct class_device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
+        struct device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
+        struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
 
         struct transport_container rport_attr_cont;
-        struct class_device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
-        struct class_device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
+        struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
+        struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
 
         struct transport_container vport_attr_cont;
-        struct class_device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
-        struct class_device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
+        struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
+        struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
 };
 
 #define to_fc_internal(tmpl)    container_of(tmpl, struct fc_internal, t)
 
 static int fc_target_setup(struct transport_container *tc, struct device *dev,
-                           struct class_device *cdev)
+                           struct device *cdev)
 {
         struct scsi_target *starget = to_scsi_target(dev);
         struct fc_rport *rport = starget_to_rport(starget);
@@ -375,7 +375,7 @@ static DECLARE_TRANSPORT_CLASS(fc_transport_class,
                                NULL);
 
 static int fc_host_setup(struct transport_container *tc, struct device *dev,
-                         struct class_device *cdev)
+                         struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
         struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
@@ -682,9 +682,10 @@ static void __exit fc_transport_exit(void)
 
 #define fc_rport_show_function(field, format_string, sz, cast)          \
 static ssize_t                                                          \
-show_fc_rport_##field (struct class_device *cdev, char *buf)            \
+show_fc_rport_##field (struct device *dev,                              \
+                       struct device_attribute *attr, char *buf)        \
 {                                                                       \
-        struct fc_rport *rport = transport_class_to_rport(cdev);        \
+        struct fc_rport *rport = transport_class_to_rport(dev);         \
         struct Scsi_Host *shost = rport_to_shost(rport);                \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         if ((i->f->get_rport_##field) &&                                \
@@ -697,11 +698,12 @@ show_fc_rport_##field (struct class_device *cdev, char *buf)		\
 
 #define fc_rport_store_function(field)                                  \
 static ssize_t                                                          \
-store_fc_rport_##field(struct class_device *cdev, const char *buf,      \
-                           size_t count)                                \
+store_fc_rport_##field(struct device *dev,                              \
+                       struct device_attribute *attr,                   \
+                       const char *buf, size_t count)                   \
 {                                                                       \
         int val;                                                        \
-        struct fc_rport *rport = transport_class_to_rport(cdev);        \
+        struct fc_rport *rport = transport_class_to_rport(dev);         \
         struct Scsi_Host *shost = rport_to_shost(rport);                \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         char *cp;                                                       \
@@ -718,58 +720,60 @@ store_fc_rport_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_rport_rd_attr(field, format_string, sz)                      \
         fc_rport_show_function(field, format_string, sz, )              \
-static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(rport, field, S_IRUGO,                    \
                          show_fc_rport_##field, NULL)
 
 #define fc_rport_rd_attr_cast(field, format_string, sz, cast)           \
         fc_rport_show_function(field, format_string, sz, (cast))        \
-static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(rport, field, S_IRUGO,                    \
                           show_fc_rport_##field, NULL)
 
 #define fc_rport_rw_attr(field, format_string, sz)                      \
         fc_rport_show_function(field, format_string, sz, )              \
         fc_rport_store_function(field)                                  \
-static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR,            \
+static FC_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR,          \
                         show_fc_rport_##field,                          \
                         store_fc_rport_##field)
 
 
 #define fc_private_rport_show_function(field, format_string, sz, cast)  \
 static ssize_t                                                          \
-show_fc_rport_##field (struct class_device *cdev, char *buf)            \
+show_fc_rport_##field (struct device *dev,                              \
+                       struct device_attribute *attr, char *buf)        \
 {                                                                       \
-        struct fc_rport *rport = transport_class_to_rport(cdev);        \
+        struct fc_rport *rport = transport_class_to_rport(dev);         \
         return snprintf(buf, sz, format_string, cast rport->field);     \
 }
 
 #define fc_private_rport_rd_attr(field, format_string, sz)              \
         fc_private_rport_show_function(field, format_string, sz, )      \
-static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(rport, field, S_IRUGO,                    \
                          show_fc_rport_##field, NULL)
 
 #define fc_private_rport_rd_attr_cast(field, format_string, sz, cast)   \
         fc_private_rport_show_function(field, format_string, sz, (cast)) \
-static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(rport, field, S_IRUGO,                    \
                           show_fc_rport_##field, NULL)
 
 
 #define fc_private_rport_rd_enum_attr(title, maxlen)                    \
 static ssize_t                                                          \
-show_fc_rport_##title (struct class_device *cdev, char *buf)            \
+show_fc_rport_##title (struct device *dev,                              \
+                       struct device_attribute *attr, char *buf)        \
 {                                                                       \
-        struct fc_rport *rport = transport_class_to_rport(cdev);        \
+        struct fc_rport *rport = transport_class_to_rport(dev);         \
         const char *name;                                               \
         name = get_fc_##title##_name(rport->title);                     \
         if (!name)                                                      \
                 return -EINVAL;                                         \
         return snprintf(buf, maxlen, "%s\n", name);                     \
 }                                                                       \
-static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO,                      \
+static FC_DEVICE_ATTR(rport, title, S_IRUGO,                    \
                         show_fc_rport_##title, NULL)
 
 
 #define SETUP_RPORT_ATTRIBUTE_RD(field)                                 \
-        i->private_rport_attrs[count] = class_device_attr_rport_##field; \
+        i->private_rport_attrs[count] = device_attr_rport_##field; \
         i->private_rport_attrs[count].attr.mode = S_IRUGO;              \
         i->private_rport_attrs[count].store = NULL;                     \
         i->rport_attrs[count] = &i->private_rport_attrs[count];         \
@@ -777,14 +781,14 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO,			\
                 count++
 
 #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field)                         \
-        i->private_rport_attrs[count] = class_device_attr_rport_##field; \
+        i->private_rport_attrs[count] = device_attr_rport_##field; \
         i->private_rport_attrs[count].attr.mode = S_IRUGO;              \
         i->private_rport_attrs[count].store = NULL;                     \
         i->rport_attrs[count] = &i->private_rport_attrs[count];         \
         count++
 
 #define SETUP_RPORT_ATTRIBUTE_RW(field)                                 \
-        i->private_rport_attrs[count] = class_device_attr_rport_##field; \
+        i->private_rport_attrs[count] = device_attr_rport_##field; \
         if (!i->f->set_rport_##field) {                                 \
                 i->private_rport_attrs[count].attr.mode = S_IRUGO;      \
                 i->private_rport_attrs[count].store = NULL;             \
@@ -795,7 +799,7 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO,			\
 
 #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(field)                         \
 {                                                                       \
-        i->private_rport_attrs[count] = class_device_attr_rport_##field; \
+        i->private_rport_attrs[count] = device_attr_rport_##field; \
         i->rport_attrs[count] = &i->private_rport_attrs[count];         \
         count++;                                                        \
 }
@@ -808,14 +812,15 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO,			\
 fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20);
 
 static ssize_t
-show_fc_rport_supported_classes (struct class_device *cdev, char *buf)
+show_fc_rport_supported_classes (struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
-        struct fc_rport *rport = transport_class_to_rport(cdev);
+        struct fc_rport *rport = transport_class_to_rport(dev);
         if (rport->supported_classes == FC_COS_UNSPECIFIED)
                 return snprintf(buf, 20, "unspecified\n");
         return get_fc_cos_names(rport->supported_classes, buf);
 }
-static FC_CLASS_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
+static FC_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
                 show_fc_rport_supported_classes, NULL);
 
 /* Dynamic Remote Port Attributes */
@@ -825,11 +830,11 @@ static FC_CLASS_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
  */
 fc_rport_show_function(dev_loss_tmo, "%d\n", 20, )
 static ssize_t
-store_fc_rport_dev_loss_tmo(struct class_device *cdev, const char *buf,
-                           size_t count)
+store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
 {
         int val;
-        struct fc_rport *rport = transport_class_to_rport(cdev);
+        struct fc_rport *rport = transport_class_to_rport(dev);
         struct Scsi_Host *shost = rport_to_shost(rport);
         struct fc_internal *i = to_fc_internal(shost->transportt);
         char *cp;
@@ -844,7 +849,7 @@ store_fc_rport_dev_loss_tmo(struct class_device *cdev, const char *buf,
         i->f->set_rport_dev_loss_tmo(rport, val);
         return count;
 }
-static FC_CLASS_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR,
+static FC_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR,
                 show_fc_rport_dev_loss_tmo, store_fc_rport_dev_loss_tmo);
 
 
@@ -855,9 +860,10 @@ fc_private_rport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
 fc_private_rport_rd_attr(port_id, "0x%06x\n", 20);
 
 static ssize_t
-show_fc_rport_roles (struct class_device *cdev, char *buf)
+show_fc_rport_roles (struct device *dev, struct device_attribute *attr,
+                     char *buf)
 {
-        struct fc_rport *rport = transport_class_to_rport(cdev);
+        struct fc_rport *rport = transport_class_to_rport(dev);
 
         /* identify any roles that are port_id specific */
         if ((rport->port_id != -1) &&
@@ -883,7 +889,7 @@ show_fc_rport_roles (struct class_device *cdev, char *buf)
                 return get_fc_port_roles_names(rport->roles, buf);
         }
 }
-static FC_CLASS_DEVICE_ATTR(rport, roles, S_IRUGO,
+static FC_DEVICE_ATTR(rport, roles, S_IRUGO,
                 show_fc_rport_roles, NULL);
 
 fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
@@ -893,9 +899,10 @@ fc_private_rport_rd_attr(scsi_target_id, "%d\n", 20);
  * fast_io_fail_tmo attribute
  */
 static ssize_t
-show_fc_rport_fast_io_fail_tmo (struct class_device *cdev, char *buf)
+show_fc_rport_fast_io_fail_tmo (struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        struct fc_rport *rport = transport_class_to_rport(cdev);
+        struct fc_rport *rport = transport_class_to_rport(dev);
 
         if (rport->fast_io_fail_tmo == -1)
                 return snprintf(buf, 5, "off\n");
@@ -903,12 +910,13 @@ show_fc_rport_fast_io_fail_tmo (struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-store_fc_rport_fast_io_fail_tmo(struct class_device *cdev, const char *buf,
-                           size_t count)
+store_fc_rport_fast_io_fail_tmo(struct device *dev,
+                                struct device_attribute *attr, const char *buf,
+                                size_t count)
 {
         int val;
         char *cp;
-        struct fc_rport *rport = transport_class_to_rport(cdev);
+        struct fc_rport *rport = transport_class_to_rport(dev);
 
         if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
             (rport->port_state == FC_PORTSTATE_DELETED) ||
@@ -925,7 +933,7 @@ store_fc_rport_fast_io_fail_tmo(struct class_device *cdev, const char *buf,
         }
         return count;
 }
-static FC_CLASS_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR,
+static FC_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR,
         show_fc_rport_fast_io_fail_tmo, store_fc_rport_fast_io_fail_tmo);
 
 
@@ -941,9 +949,10 @@ static FC_CLASS_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR,
  */
 #define fc_starget_show_function(field, format_string, sz, cast)        \
 static ssize_t                                                          \
-show_fc_starget_##field (struct class_device *cdev, char *buf)          \
+show_fc_starget_##field (struct device *dev,                            \
+                         struct device_attribute *attr, char *buf)      \
 {                                                                       \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         struct fc_rport *rport = starget_to_rport(starget);             \
@@ -957,16 +966,16 @@ show_fc_starget_##field (struct class_device *cdev, char *buf)		\
 
 #define fc_starget_rd_attr(field, format_string, sz)                    \
         fc_starget_show_function(field, format_string, sz, )            \
-static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO,                    \
+static FC_DEVICE_ATTR(starget, field, S_IRUGO,                  \
                          show_fc_starget_##field, NULL)
 
 #define fc_starget_rd_attr_cast(field, format_string, sz, cast)         \
         fc_starget_show_function(field, format_string, sz, (cast))      \
-static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO,                    \
+static FC_DEVICE_ATTR(starget, field, S_IRUGO,                  \
                           show_fc_starget_##field, NULL)
 
 #define SETUP_STARGET_ATTRIBUTE_RD(field)                               \
-        i->private_starget_attrs[count] = class_device_attr_starget_##field; \
+        i->private_starget_attrs[count] = device_attr_starget_##field; \
         i->private_starget_attrs[count].attr.mode = S_IRUGO;            \
         i->private_starget_attrs[count].store = NULL;                   \
         i->starget_attrs[count] = &i->private_starget_attrs[count];     \
@@ -974,7 +983,7 @@ static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO,			\
                 count++
 
 #define SETUP_STARGET_ATTRIBUTE_RW(field)                               \
-        i->private_starget_attrs[count] = class_device_attr_starget_##field; \
+        i->private_starget_attrs[count] = device_attr_starget_##field; \
         if (!i->f->set_starget_##field) {                               \
                 i->private_starget_attrs[count].attr.mode = S_IRUGO;    \
                 i->private_starget_attrs[count].store = NULL;           \
@@ -995,9 +1004,10 @@ fc_starget_rd_attr(port_id, "0x%06x\n", 20);
 
 #define fc_vport_show_function(field, format_string, sz, cast)          \
 static ssize_t                                                          \
-show_fc_vport_##field (struct class_device *cdev, char *buf)            \
+show_fc_vport_##field (struct device *dev,                              \
+                       struct device_attribute *attr, char *buf)        \
 {                                                                       \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         struct Scsi_Host *shost = vport_to_shost(vport);                \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         if ((i->f->get_vport_##field) &&                                \
@@ -1008,11 +1018,12 @@ show_fc_vport_##field (struct class_device *cdev, char *buf)		\
 
 #define fc_vport_store_function(field)                                  \
 static ssize_t                                                          \
-store_fc_vport_##field(struct class_device *cdev, const char *buf,      \
-                           size_t count)                                \
+store_fc_vport_##field(struct device *dev,                              \
+                       struct device_attribute *attr,                   \
+                       const char *buf, size_t count)                   \
 {                                                                       \
         int val;                                                        \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         struct Scsi_Host *shost = vport_to_shost(vport);                \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         char *cp;                                                       \
@@ -1027,10 +1038,11 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_vport_store_str_function(field, slen)                        \
 static ssize_t                                                          \
-store_fc_vport_##field(struct class_device *cdev, const char *buf,      \
-                           size_t count)                                \
+store_fc_vport_##field(struct device *dev,                              \
+                       struct device_attribute *attr,                   \
+                       const char *buf, size_t count)                   \
 {                                                                       \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         struct Scsi_Host *shost = vport_to_shost(vport);                \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         unsigned int cnt=count;                                         \
@@ -1047,36 +1059,38 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_vport_rd_attr(field, format_string, sz)                      \
         fc_vport_show_function(field, format_string, sz, )              \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO,                    \
                          show_fc_vport_##field, NULL)
 
 #define fc_vport_rd_attr_cast(field, format_string, sz, cast)           \
         fc_vport_show_function(field, format_string, sz, (cast))        \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO,                    \
                           show_fc_vport_##field, NULL)
 
 #define fc_vport_rw_attr(field, format_string, sz)                      \
         fc_vport_show_function(field, format_string, sz, )              \
         fc_vport_store_function(field)                                  \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,            \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,          \
                         show_fc_vport_##field,                          \
                         store_fc_vport_##field)
 
 #define fc_private_vport_show_function(field, format_string, sz, cast)  \
 static ssize_t                                                          \
-show_fc_vport_##field (struct class_device *cdev, char *buf)            \
+show_fc_vport_##field (struct device *dev,                              \
+                       struct device_attribute *attr, char *buf)        \
 {                                                                       \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         return snprintf(buf, sz, format_string, cast vport->field);     \
 }
 
 #define fc_private_vport_store_u32_function(field)                      \
 static ssize_t                                                          \
-store_fc_vport_##field(struct class_device *cdev, const char *buf,      \
-                           size_t count)                                \
+store_fc_vport_##field(struct device *dev,                              \
+                       struct device_attribute *attr,                   \
+                       const char *buf, size_t count)                   \
 {                                                                       \
         u32 val;                                                        \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         char *cp;                                                       \
         if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))          \
                 return -EBUSY;                                          \
@@ -1090,39 +1104,41 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_private_vport_rd_attr(field, format_string, sz)              \
         fc_private_vport_show_function(field, format_string, sz, )      \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO,                    \
                          show_fc_vport_##field, NULL)
 
 #define fc_private_vport_rd_attr_cast(field, format_string, sz, cast)   \
         fc_private_vport_show_function(field, format_string, sz, (cast)) \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO,                      \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO,                    \
                           show_fc_vport_##field, NULL)
 
 #define fc_private_vport_rw_u32_attr(field, format_string, sz)          \
         fc_private_vport_show_function(field, format_string, sz, )      \
         fc_private_vport_store_u32_function(field)                      \
-static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,            \
+static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR,          \
                         show_fc_vport_##field,                          \
                         store_fc_vport_##field)
 
 
 #define fc_private_vport_rd_enum_attr(title, maxlen)                    \
 static ssize_t                                                          \
-show_fc_vport_##title (struct class_device *cdev, char *buf)            \
+show_fc_vport_##title (struct device *dev,                              \
+                       struct device_attribute *attr,                   \
+                       char *buf)                                       \
 {                                                                       \
-        struct fc_vport *vport = transport_class_to_vport(cdev);        \
+        struct fc_vport *vport = transport_class_to_vport(dev);         \
         const char *name;                                               \
         name = get_fc_##title##_name(vport->title);                     \
         if (!name)                                                      \
                 return -EINVAL;                                         \
         return snprintf(buf, maxlen, "%s\n", name);                     \
 }                                                                       \
-static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO,                      \
+static FC_DEVICE_ATTR(vport, title, S_IRUGO,                    \
                         show_fc_vport_##title, NULL)
 
 
 #define SETUP_VPORT_ATTRIBUTE_RD(field)                                 \
-        i->private_vport_attrs[count] = class_device_attr_vport_##field; \
+        i->private_vport_attrs[count] = device_attr_vport_##field; \
         i->private_vport_attrs[count].attr.mode = S_IRUGO;              \
         i->private_vport_attrs[count].store = NULL;                     \
         i->vport_attrs[count] = &i->private_vport_attrs[count];         \
@@ -1131,21 +1147,21 @@ static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO,			\
         /* NOTE: Above MACRO differs: checks function not show bit */
 
 #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(field)                         \
-        i->private_vport_attrs[count] = class_device_attr_vport_##field; \
+        i->private_vport_attrs[count] = device_attr_vport_##field; \
         i->private_vport_attrs[count].attr.mode = S_IRUGO;              \
         i->private_vport_attrs[count].store = NULL;                     \
         i->vport_attrs[count] = &i->private_vport_attrs[count];         \
         count++
 
 #define SETUP_VPORT_ATTRIBUTE_WR(field)                                 \
-        i->private_vport_attrs[count] = class_device_attr_vport_##field; \
+        i->private_vport_attrs[count] = device_attr_vport_##field; \
         i->vport_attrs[count] = &i->private_vport_attrs[count];         \
         if (i->f->field)                                                \
                 count++
         /* NOTE: Above MACRO differs: checks function */
 
 #define SETUP_VPORT_ATTRIBUTE_RW(field)                                 \
-        i->private_vport_attrs[count] = class_device_attr_vport_##field; \
+        i->private_vport_attrs[count] = device_attr_vport_##field; \
         if (!i->f->set_vport_##field) {                                 \
                 i->private_vport_attrs[count].attr.mode = S_IRUGO;      \
                 i->private_vport_attrs[count].store = NULL;             \
@@ -1156,7 +1172,7 @@ static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO,			\
 
 #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RW(field)                         \
 {                                                                       \
-        i->private_vport_attrs[count] = class_device_attr_vport_##field; \
+        i->private_vport_attrs[count] = device_attr_vport_##field; \
         i->vport_attrs[count] = &i->private_vport_attrs[count];         \
         count++;                                                        \
 }
@@ -1176,35 +1192,36 @@ fc_private_vport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
 fc_private_vport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
 
 static ssize_t
-show_fc_vport_roles (struct class_device *cdev, char *buf)
+show_fc_vport_roles (struct device *dev, struct device_attribute *attr,
+                     char *buf)
 {
-        struct fc_vport *vport = transport_class_to_vport(cdev);
+        struct fc_vport *vport = transport_class_to_vport(dev);
 
         if (vport->roles == FC_PORT_ROLE_UNKNOWN)
                 return snprintf(buf, 20, "unknown\n");
         return get_fc_port_roles_names(vport->roles, buf);
 }
-static FC_CLASS_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL);
+static FC_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL);
 
 fc_private_vport_rd_enum_attr(vport_type, FC_PORTTYPE_MAX_NAMELEN);
 
 fc_private_vport_show_function(symbolic_name, "%s\n",
                 FC_VPORT_SYMBOLIC_NAMELEN + 1, )
 fc_vport_store_str_function(symbolic_name, FC_VPORT_SYMBOLIC_NAMELEN)
-static FC_CLASS_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR,
+static FC_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR,
                 show_fc_vport_symbolic_name, store_fc_vport_symbolic_name);
 
 static ssize_t
-store_fc_vport_delete(struct class_device *cdev, const char *buf,
-                           size_t count)
+store_fc_vport_delete(struct device *dev, struct device_attribute *attr,
+                      const char *buf, size_t count)
 {
-        struct fc_vport *vport = transport_class_to_vport(cdev);
+        struct fc_vport *vport = transport_class_to_vport(dev);
         struct Scsi_Host *shost = vport_to_shost(vport);
 
         fc_queue_work(shost, &vport->vport_delete_work);
         return count;
 }
-static FC_CLASS_DEVICE_ATTR(vport, vport_delete, S_IWUSR,
+static FC_DEVICE_ATTR(vport, vport_delete, S_IWUSR,
                         NULL, store_fc_vport_delete);
 
 
@@ -1213,10 +1230,11 @@ static FC_CLASS_DEVICE_ATTR(vport, vport_delete, S_IWUSR,
  *  Write "1" to disable, write "0" to enable
  */
 static ssize_t
-store_fc_vport_disable(struct class_device *cdev, const char *buf,
+store_fc_vport_disable(struct device *dev, struct device_attribute *attr,
+                       const char *buf,
                            size_t count)
 {
-        struct fc_vport *vport = transport_class_to_vport(cdev);
+        struct fc_vport *vport = transport_class_to_vport(dev);
         struct Scsi_Host *shost = vport_to_shost(vport);
         struct fc_internal *i = to_fc_internal(shost->transportt);
         int stat;
@@ -1236,7 +1254,7 @@ store_fc_vport_disable(struct class_device *cdev, const char *buf,
         stat = i->f->vport_disable(vport, ((*buf == '0') ? false : true));
         return stat ? stat : count;
 }
-static FC_CLASS_DEVICE_ATTR(vport, vport_disable, S_IWUSR,
+static FC_DEVICE_ATTR(vport, vport_disable, S_IWUSR,
                         NULL, store_fc_vport_disable);
 
 
@@ -1246,9 +1264,10 @@ static FC_CLASS_DEVICE_ATTR(vport, vport_disable, S_IWUSR,
 
 #define fc_host_show_function(field, format_string, sz, cast)           \
 static ssize_t                                                          \
-show_fc_host_##field (struct class_device *cdev, char *buf)             \
+show_fc_host_##field (struct device *dev,                               \
+                      struct device_attribute *attr, char *buf)         \
 {                                                                       \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         if (i->f->get_host_##field)                                     \
                 i->f->get_host_##field(shost);                          \
@@ -1257,11 +1276,12 @@ show_fc_host_##field (struct class_device *cdev, char *buf)		\
 
 #define fc_host_store_function(field)                                   \
 static ssize_t                                                          \
-store_fc_host_##field(struct class_device *cdev, const char *buf,       \
-                           size_t count)                                \
+store_fc_host_##field(struct device *dev,                               \
+                      struct device_attribute *attr,                    \
+                      const char *buf,  size_t count)                   \
 {                                                                       \
         int val;                                                        \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         char *cp;                                                       \
                                                                         \
@@ -1274,10 +1294,11 @@ store_fc_host_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_host_store_str_function(field, slen)                         \
 static ssize_t                                                          \
-store_fc_host_##field(struct class_device *cdev, const char *buf,       \
-                           size_t count)                                \
+store_fc_host_##field(struct device *dev,                               \
+                      struct device_attribute *attr,                    \
+                      const char *buf, size_t count)                    \
 {                                                                       \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         unsigned int cnt=count;                                         \
                                                                         \
@@ -1293,26 +1314,27 @@ store_fc_host_##field(struct class_device *cdev, const char *buf,	\
 
 #define fc_host_rd_attr(field, format_string, sz)                       \
         fc_host_show_function(field, format_string, sz, )               \
-static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,                       \
+static FC_DEVICE_ATTR(host, field, S_IRUGO,                     \
                          show_fc_host_##field, NULL)
 
 #define fc_host_rd_attr_cast(field, format_string, sz, cast)            \
         fc_host_show_function(field, format_string, sz, (cast))         \
-static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,                       \
+static FC_DEVICE_ATTR(host, field, S_IRUGO,                     \
                           show_fc_host_##field, NULL)
 
 #define fc_host_rw_attr(field, format_string, sz)                       \
         fc_host_show_function(field, format_string, sz, )               \
         fc_host_store_function(field)                                   \
-static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR,             \
+static FC_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR,           \
                         show_fc_host_##field,                           \
                         store_fc_host_##field)
 
 #define fc_host_rd_enum_attr(title, maxlen)                             \
 static ssize_t                                                          \
-show_fc_host_##title (struct class_device *cdev, char *buf)             \
+show_fc_host_##title (struct device *dev,                               \
+                      struct device_attribute *attr, char *buf)         \
 {                                                                       \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         struct fc_internal *i = to_fc_internal(shost->transportt);      \
         const char *name;                                               \
         if (i->f->get_host_##title)                                     \
@@ -1322,10 +1344,10 @@ show_fc_host_##title (struct class_device *cdev, char *buf)		\
                 return -EINVAL;                                         \
         return snprintf(buf, maxlen, "%s\n", name);                     \
 }                                                                       \
-static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
+static FC_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
 
 #define SETUP_HOST_ATTRIBUTE_RD(field)                                  \
-        i->private_host_attrs[count] = class_device_attr_host_##field;  \
+        i->private_host_attrs[count] = device_attr_host_##field;        \
         i->private_host_attrs[count].attr.mode = S_IRUGO;               \
         i->private_host_attrs[count].store = NULL;                      \
         i->host_attrs[count] = &i->private_host_attrs[count];           \
@@ -1333,14 +1355,14 @@ static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
                 count++
 
 #define SETUP_HOST_ATTRIBUTE_RD_NS(field)                               \
-        i->private_host_attrs[count] = class_device_attr_host_##field;  \
+        i->private_host_attrs[count] = device_attr_host_##field;        \
         i->private_host_attrs[count].attr.mode = S_IRUGO;               \
         i->private_host_attrs[count].store = NULL;                      \
         i->host_attrs[count] = &i->private_host_attrs[count];           \
         count++
 
 #define SETUP_HOST_ATTRIBUTE_RW(field)                                  \
-        i->private_host_attrs[count] = class_device_attr_host_##field;  \
+        i->private_host_attrs[count] = device_attr_host_##field;        \
         if (!i->f->set_host_##field) {                                  \
                 i->private_host_attrs[count].attr.mode = S_IRUGO;       \
                 i->private_host_attrs[count].store = NULL;              \
@@ -1352,24 +1374,25 @@ static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
 
 #define fc_private_host_show_function(field, format_string, sz, cast)   \
 static ssize_t                                                          \
-show_fc_host_##field (struct class_device *cdev, char *buf)             \
+show_fc_host_##field (struct device *dev,                               \
+                      struct device_attribute *attr, char *buf)         \
 {                                                                       \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
 }
 
 #define fc_private_host_rd_attr(field, format_string, sz)               \
         fc_private_host_show_function(field, format_string, sz, )       \
-static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,                       \
+static FC_DEVICE_ATTR(host, field, S_IRUGO,                     \
                          show_fc_host_##field, NULL)
 
 #define fc_private_host_rd_attr_cast(field, format_string, sz, cast)    \
         fc_private_host_show_function(field, format_string, sz, (cast)) \
-static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,                       \
+static FC_DEVICE_ATTR(host, field, S_IRUGO,                     \
                           show_fc_host_##field, NULL)
 
 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field)                  \
-        i->private_host_attrs[count] = class_device_attr_host_##field;  \
+        i->private_host_attrs[count] = device_attr_host_##field;        \
         i->private_host_attrs[count].attr.mode = S_IRUGO;               \
         i->private_host_attrs[count].store = NULL;                      \
         i->host_attrs[count] = &i->private_host_attrs[count];           \
@@ -1377,7 +1400,7 @@ static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 
 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RW(field)                  \
 {                                                                       \
-        i->private_host_attrs[count] = class_device_attr_host_##field;  \
+        i->private_host_attrs[count] = device_attr_host_##field;        \
         i->host_attrs[count] = &i->private_host_attrs[count];           \
         count++;                                                        \
 }
@@ -1386,38 +1409,41 @@ static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 /* Fixed Host Attributes */
 
 static ssize_t
-show_fc_host_supported_classes (struct class_device *cdev, char *buf)
+show_fc_host_supported_classes (struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
 
         if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED)
                 return snprintf(buf, 20, "unspecified\n");
 
         return get_fc_cos_names(fc_host_supported_classes(shost), buf);
 }
-static FC_CLASS_DEVICE_ATTR(host, supported_classes, S_IRUGO,
+static FC_DEVICE_ATTR(host, supported_classes, S_IRUGO,
                 show_fc_host_supported_classes, NULL);
 
 static ssize_t
-show_fc_host_supported_fc4s (struct class_device *cdev, char *buf)
+show_fc_host_supported_fc4s (struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         return (ssize_t)show_fc_fc4s(buf, fc_host_supported_fc4s(shost));
 }
-static FC_CLASS_DEVICE_ATTR(host, supported_fc4s, S_IRUGO,
+static FC_DEVICE_ATTR(host, supported_fc4s, S_IRUGO,
                 show_fc_host_supported_fc4s, NULL);
 
 static ssize_t
-show_fc_host_supported_speeds (struct class_device *cdev, char *buf)
+show_fc_host_supported_speeds (struct device *dev,
+                               struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
 
         if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN)
                 return snprintf(buf, 20, "unknown\n");
 
         return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf);
 }
-static FC_CLASS_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
+static FC_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
                 show_fc_host_supported_speeds, NULL);
 
 
@@ -1433,9 +1459,10 @@ fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1));
 /* Dynamic Host Attributes */
 
 static ssize_t
-show_fc_host_active_fc4s (struct class_device *cdev, char *buf)
+show_fc_host_active_fc4s (struct device *dev,
+                          struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_internal *i = to_fc_internal(shost->transportt);
 
         if (i->f->get_host_active_fc4s)
@@ -1443,13 +1470,14 @@ show_fc_host_active_fc4s (struct class_device *cdev, char *buf)
 
         return (ssize_t)show_fc_fc4s(buf, fc_host_active_fc4s(shost));
 }
-static FC_CLASS_DEVICE_ATTR(host, active_fc4s, S_IRUGO,
+static FC_DEVICE_ATTR(host, active_fc4s, S_IRUGO,
                 show_fc_host_active_fc4s, NULL);
 
 static ssize_t
-show_fc_host_speed (struct class_device *cdev, char *buf)
+show_fc_host_speed (struct device *dev,
+                    struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_internal *i = to_fc_internal(shost->transportt);
 
         if (i->f->get_host_speed)
@@ -1460,7 +1488,7 @@ show_fc_host_speed (struct class_device *cdev, char *buf)
 
         return get_fc_port_speed_names(fc_host_speed(shost), buf);
 }
-static FC_CLASS_DEVICE_ATTR(host, speed, S_IRUGO,
+static FC_DEVICE_ATTR(host, speed, S_IRUGO,
                 show_fc_host_speed, NULL);
 
 
@@ -1473,16 +1501,17 @@ fc_host_rd_attr(symbolic_name, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1);
 fc_private_host_show_function(system_hostname, "%s\n",
                 FC_SYMBOLIC_NAME_SIZE + 1, )
 fc_host_store_str_function(system_hostname, FC_SYMBOLIC_NAME_SIZE)
-static FC_CLASS_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR,
+static FC_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR,
                 show_fc_host_system_hostname, store_fc_host_system_hostname);
 
 
 /* Private Host Attributes */
 
 static ssize_t
-show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf)
+show_fc_private_host_tgtid_bind_type(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         const char *name;
 
         name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost));
@@ -1495,10 +1524,10 @@ show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf)
         pos = list_entry((head)->next, typeof(*pos), member)
 
 static ssize_t
-store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
-        const char *buf, size_t count)
+store_fc_private_host_tgtid_bind_type(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_rport *rport;
         enum fc_tgtid_binding_type val;
         unsigned long flags;
@@ -1523,15 +1552,15 @@ store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
         return count;
 }
 
-static FC_CLASS_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR,
+static FC_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR,
                         show_fc_private_host_tgtid_bind_type,
                         store_fc_private_host_tgtid_bind_type);
 
 static ssize_t
-store_fc_private_host_issue_lip(struct class_device *cdev,
-        const char *buf, size_t count)
+store_fc_private_host_issue_lip(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_internal *i = to_fc_internal(shost->transportt);
         int ret;
 
@@ -1544,7 +1573,7 @@ store_fc_private_host_issue_lip(struct class_device *cdev,
         return -ENOENT;
 }
 
-static FC_CLASS_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL,
+static FC_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL,
                         store_fc_private_host_issue_lip);
 
 fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20);
@@ -1556,9 +1585,9 @@ fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20);
 
 /* Show a given an attribute in the statistics group */
 static ssize_t
-fc_stat_show(const struct class_device *cdev, char *buf, unsigned long offset)
+fc_stat_show(const struct device *dev, char *buf, unsigned long offset)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_internal *i = to_fc_internal(shost->transportt);
         struct fc_host_statistics *stats;
         ssize_t ret = -ENOENT;
@@ -1579,12 +1608,14 @@ fc_stat_show(const struct class_device *cdev, char *buf, unsigned long offset)
 
 /* generate a read-only statistics attribute */
 #define fc_host_statistic(name)                                         \
-static ssize_t show_fcstat_##name(struct class_device *cd, char *buf)   \
+static ssize_t show_fcstat_##name(struct device *cd,                    \
+                                  struct device_attribute *attr,        \
+                                  char *buf)                            \
 {                                                                       \
         return fc_stat_show(cd, buf,                                    \
                             offsetof(struct fc_host_statistics, name)); \
 }                                                                       \
-static FC_CLASS_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL)
+static FC_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL)
 
 fc_host_statistic(seconds_since_last_reset);
 fc_host_statistic(tx_frames);
@@ -1608,10 +1639,10 @@ fc_host_statistic(fcp_input_megabytes);
 fc_host_statistic(fcp_output_megabytes);
 
 static ssize_t
-fc_reset_statistics(struct class_device *cdev, const char *buf,
-                           size_t count)
+fc_reset_statistics(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_internal *i = to_fc_internal(shost->transportt);
 
         /* ignore any data value written to the attribute */
@@ -1622,31 +1653,31 @@ fc_reset_statistics(struct class_device *cdev, const char *buf,
 
         return -ENOENT;
 }
-static FC_CLASS_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL,
+static FC_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL,
                                 fc_reset_statistics);
 
 static struct attribute *fc_statistics_attrs[] = {
-        &class_device_attr_host_seconds_since_last_reset.attr,
-        &class_device_attr_host_tx_frames.attr,
-        &class_device_attr_host_tx_words.attr,
-        &class_device_attr_host_rx_frames.attr,
-        &class_device_attr_host_rx_words.attr,
-        &class_device_attr_host_lip_count.attr,
-        &class_device_attr_host_nos_count.attr,
-        &class_device_attr_host_error_frames.attr,
-        &class_device_attr_host_dumped_frames.attr,
-        &class_device_attr_host_link_failure_count.attr,
-        &class_device_attr_host_loss_of_sync_count.attr,
-        &class_device_attr_host_loss_of_signal_count.attr,
-        &class_device_attr_host_prim_seq_protocol_err_count.attr,
-        &class_device_attr_host_invalid_tx_word_count.attr,
-        &class_device_attr_host_invalid_crc_count.attr,
-        &class_device_attr_host_fcp_input_requests.attr,
-        &class_device_attr_host_fcp_output_requests.attr,
-        &class_device_attr_host_fcp_control_requests.attr,
-        &class_device_attr_host_fcp_input_megabytes.attr,
-        &class_device_attr_host_fcp_output_megabytes.attr,
-        &class_device_attr_host_reset_statistics.attr,
+        &device_attr_host_seconds_since_last_reset.attr,
+        &device_attr_host_tx_frames.attr,
+        &device_attr_host_tx_words.attr,
+        &device_attr_host_rx_frames.attr,
+        &device_attr_host_rx_words.attr,
+        &device_attr_host_lip_count.attr,
+        &device_attr_host_nos_count.attr,
+        &device_attr_host_error_frames.attr,
+        &device_attr_host_dumped_frames.attr,
+        &device_attr_host_link_failure_count.attr,
+        &device_attr_host_loss_of_sync_count.attr,
+        &device_attr_host_loss_of_signal_count.attr,
+        &device_attr_host_prim_seq_protocol_err_count.attr,
+        &device_attr_host_invalid_tx_word_count.attr,
+        &device_attr_host_invalid_crc_count.attr,
+        &device_attr_host_fcp_input_requests.attr,
+        &device_attr_host_fcp_output_requests.attr,
+        &device_attr_host_fcp_control_requests.attr,
+        &device_attr_host_fcp_input_megabytes.attr,
+        &device_attr_host_fcp_output_megabytes.attr,
+        &device_attr_host_reset_statistics.attr,
         NULL
 };
 
@@ -1695,10 +1726,10 @@ fc_parse_wwn(const char *ns, u64 *nm)
  * as hex characters, and may *not* contain any prefixes (e.g. 0x, x, etc)
  */
 static ssize_t
-store_fc_host_vport_create(struct class_device *cdev, const char *buf,
-                           size_t count)
+store_fc_host_vport_create(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_vport_identifiers vid;
         struct fc_vport *vport;
         unsigned int cnt=count;
@@ -1731,7 +1762,7 @@ store_fc_host_vport_create(struct class_device *cdev, const char *buf,
         stat = fc_vport_create(shost, 0, &shost->shost_gendev, &vid, &vport);
         return stat ? stat : count;
 }
-static FC_CLASS_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL,
+static FC_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL,
                         store_fc_host_vport_create);
 
 
@@ -1742,10 +1773,10 @@ static FC_CLASS_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL,
  * any prefixes (e.g. 0x, x, etc)
  */
 static ssize_t
-store_fc_host_vport_delete(struct class_device *cdev, const char *buf,
-                           size_t count)
+store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
         struct fc_vport *vport;
         u64 wwpn, wwnn;
@@ -1787,7 +1818,7 @@ store_fc_host_vport_delete(struct class_device *cdev, const char *buf,
         stat = fc_vport_terminate(vport);
         return stat ? stat : count;
 }
-static FC_CLASS_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL,
+static FC_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL,
                         store_fc_host_vport_delete);
 
 
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index ca7bb6f63bde..65d1737eb664 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -40,13 +40,13 @@ struct iscsi_internal {
         struct scsi_transport_template t;
         struct iscsi_transport *iscsi_transport;
         struct list_head list;
-        struct class_device cdev;
+        struct device dev;
 
-        struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
+        struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
         struct transport_container conn_cont;
-        struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
+        struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
         struct transport_container session_cont;
-        struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
+        struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
 };
 
 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
@@ -63,12 +63,12 @@ static DEFINE_SPINLOCK(iscsi_transport_lock);
 #define to_iscsi_internal(tmpl) \
         container_of(tmpl, struct iscsi_internal, t)
 
-#define cdev_to_iscsi_internal(_cdev) \
-        container_of(_cdev, struct iscsi_internal, cdev)
+#define dev_to_iscsi_internal(_dev) \
+        container_of(_dev, struct iscsi_internal, dev)
 
-static void iscsi_transport_release(struct class_device *cdev)
+static void iscsi_transport_release(struct device *dev)
 {
-        struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
+        struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
         kfree(priv);
 }
 
@@ -78,25 +78,27 @@ static void iscsi_transport_release(struct class_device *cdev)
  */
 static struct class iscsi_transport_class = {
         .name = "iscsi_transport",
-        .release = iscsi_transport_release,
+        .dev_release = iscsi_transport_release,
 };
 
 static ssize_t
-show_transport_handle(struct class_device *cdev, char *buf)
+show_transport_handle(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
+        struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
         return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
 }
-static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
+static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
 
 #define show_transport_attr(name, format)                               \
 static ssize_t                                                          \
-show_transport_##name(struct class_device *cdev, char *buf)             \
+show_transport_##name(struct device *dev,                               \
+                      struct device_attribute *attr,char *buf)          \
 {                                                                       \
-        struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);     \
+        struct iscsi_internal *priv = dev_to_iscsi_internal(dev);       \
         return sprintf(buf, format"\n", priv->iscsi_transport->name);   \
 }                                                                       \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
+static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
 
 show_transport_attr(caps, "0x%x");
 show_transport_attr(max_lun, "%d");
@@ -104,11 +106,11 @@ show_transport_attr(max_conn, "%d");
 show_transport_attr(max_cmd_len, "%d");
 
 static struct attribute *iscsi_transport_attrs[] = {
-        &class_device_attr_handle.attr,
-        &class_device_attr_caps.attr,
-        &class_device_attr_max_lun.attr,
-        &class_device_attr_max_conn.attr,
-        &class_device_attr_max_cmd_len.attr,
+        &dev_attr_handle.attr,
+        &dev_attr_caps.attr,
+        &dev_attr_max_lun.attr,
+        &dev_attr_max_conn.attr,
+        &dev_attr_max_cmd_len.attr,
         NULL,
 };
 
@@ -119,7 +121,7 @@ static struct attribute_group iscsi_transport_group = {
 
 
 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
-                            struct class_device *cdev)
+                            struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
         struct iscsi_host *ihost = shost->shost_data;
@@ -139,7 +141,7 @@ static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
 }
 
 static int iscsi_remove_host(struct transport_container *tc, struct device *dev,
-                             struct class_device *cdev)
+                             struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
         struct iscsi_host *ihost = shost->shost_data;
@@ -1337,11 +1339,8 @@ iscsi_if_rx(struct sk_buff *skb)
         mutex_unlock(&rx_queue_mutex);
 }
 
-#define iscsi_cdev_to_conn(_cdev) \
-        iscsi_dev_to_conn(_cdev->dev)
-
 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)              \
-struct class_device_attribute class_device_attr_##_prefix##_##_name =   \
+struct device_attribute dev_attr_##_prefix##_##_name =  \
         __ATTR(_name,_mode,_show,_store)
 
 /*
@@ -1349,9 +1348,10 @@ struct class_device_attribute class_device_attr_##_prefix##_##_name =	\
  */
 #define iscsi_conn_attr_show(param)                                     \
 static ssize_t                                                          \
-show_conn_param_##param(struct class_device *cdev, char *buf)           \
+show_conn_param_##param(struct device *dev,                             \
+                        struct device_attribute *attr, char *buf)       \
 {                                                                       \
-        struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev);         \
+        struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);   \
         struct iscsi_transport *t = conn->transport;                    \
         return t->get_conn_param(conn, param, buf);                     \
 }
@@ -1375,17 +1375,16 @@ iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
 
-#define iscsi_cdev_to_session(_cdev) \
-        iscsi_dev_to_session(_cdev->dev)
-
 /*
  * iSCSI session attrs
  */
 #define iscsi_session_attr_show(param, perm)                            \
 static ssize_t                                                          \
-show_session_param_##param(struct class_device *cdev, char *buf)        \
+show_session_param_##param(struct device *dev,                          \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
-        struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \
+        struct iscsi_cls_session *session =                             \
+                iscsi_dev_to_session(dev->parent);                      \
         struct iscsi_transport *t = session->transport;                 \
                                                                         \
         if (perm && !capable(CAP_SYS_ADMIN))                            \
@@ -1417,9 +1416,10 @@ iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
 
 static ssize_t
-show_priv_session_state(struct class_device *cdev, char *buf)
+show_priv_session_state(struct device *dev, struct device_attribute *attr,
+                        char *buf)
 {
-        struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);
+        struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
         return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
 }
 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
@@ -1427,9 +1427,11 @@ static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
 
 #define iscsi_priv_session_attr_show(field, format)                     \
 static ssize_t                                                          \
-show_priv_session_##field(struct class_device *cdev, char *buf)         \
+show_priv_session_##field(struct device *dev,                           \
+                          struct device_attribute *attr, char *buf)     \
 {                                                                       \
-        struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\
+        struct iscsi_cls_session *session =                             \
+                        iscsi_dev_to_session(dev->parent);              \
         return sprintf(buf, format"\n", session->field);                \
 }
 
@@ -1444,9 +1446,10 @@ iscsi_priv_session_attr(recovery_tmo, "%d");
  */
 #define iscsi_host_attr_show(param)                                     \
 static ssize_t                                                          \
-show_host_param_##param(struct class_device *cdev, char *buf)           \
+show_host_param_##param(struct device *dev,                             \
+                        struct device_attribute *attr, char *buf)       \
 {                                                                       \
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct Scsi_Host *shost = transport_class_to_shost(dev);        \
         struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
         return priv->iscsi_transport->get_host_param(shost, param, buf); \
 }
@@ -1463,7 +1466,7 @@ iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
 
 #define SETUP_PRIV_SESSION_RD_ATTR(field)                               \
 do {                                                                    \
-        priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
+        priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
         count++;                                                        \
 } while (0)
 
@@ -1471,7 +1474,7 @@ do {									\
 #define SETUP_SESSION_RD_ATTR(field, param_flag)                        \
 do {                                                                    \
         if (tt->param_mask & param_flag) {                              \
-                priv->session_attrs[count] = &class_device_attr_sess_##field; \
+                priv->session_attrs[count] = &dev_attr_sess_##field; \
                 count++;                                                \
         }                                                               \
 } while (0)
@@ -1479,7 +1482,7 @@ do {									\
 #define SETUP_CONN_RD_ATTR(field, param_flag)                           \
 do {                                                                    \
         if (tt->param_mask & param_flag) {                              \
-                priv->conn_attrs[count] = &class_device_attr_conn_##field; \
+                priv->conn_attrs[count] = &dev_attr_conn_##field; \
                 count++;                                                \
         }                                                               \
 } while (0)
@@ -1487,7 +1490,7 @@ do {									\
 #define SETUP_HOST_RD_ATTR(field, param_flag)                           \
 do {                                                                    \
         if (tt->host_param_mask & param_flag) {                         \
-                priv->host_attrs[count] = &class_device_attr_host_##field; \
+                priv->host_attrs[count] = &dev_attr_host_##field; \
                 count++;                                                \
         }                                                               \
 } while (0)
@@ -1578,15 +1581,15 @@ iscsi_register_transport(struct iscsi_transport *tt)
         priv->iscsi_transport = tt;
         priv->t.user_scan = iscsi_user_scan;
 
-        priv->cdev.class = &iscsi_transport_class;
-        snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
-        err = class_device_register(&priv->cdev);
+        priv->dev.class = &iscsi_transport_class;
+        snprintf(priv->dev.bus_id, BUS_ID_SIZE, "%s", tt->name);
+        err = device_register(&priv->dev);
         if (err)
                 goto free_priv;
 
-        err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
+        err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
         if (err)
-                goto unregister_cdev;
+                goto unregister_dev;
 
         /* host parameters */
         priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
@@ -1663,8 +1666,8 @@ iscsi_register_transport(struct iscsi_transport *tt)
         printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
         return &priv->t;
 
-unregister_cdev:
-        class_device_unregister(&priv->cdev);
+unregister_dev:
+        device_unregister(&priv->dev);
 free_priv:
         kfree(priv);
         return NULL;
@@ -1691,8 +1694,8 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
         transport_container_unregister(&priv->session_cont);
         transport_container_unregister(&priv->t.host_attrs);
 
-        sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
-        class_device_unregister(&priv->cdev);
+        sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
+        device_unregister(&priv->dev);
         mutex_unlock(&rx_queue_mutex);
 
         return 0;
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 43a964d635b4..27ec625ab771 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -53,8 +53,8 @@ struct sas_host_attrs {
 /*
  * Hack to allow attributes of the same name in different objects.
  */
-#define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
-        struct class_device_attribute class_device_attr_##_prefix##_##_name = \
+#define SAS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
+        struct device_attribute dev_attr_##_prefix##_##_name = \
         __ATTR(_name,_mode,_show,_store)
 
 
@@ -261,7 +261,7 @@ static void sas_bsg_remove(struct Scsi_Host *shost, struct sas_rphy *rphy)
  */
 
 static int sas_host_setup(struct transport_container *tc, struct device *dev,
-                          struct class_device *cdev)
+                          struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
         struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
@@ -280,7 +280,7 @@ static int sas_host_setup(struct transport_container *tc, struct device *dev,
 }
 
 static int sas_host_remove(struct transport_container *tc, struct device *dev,
-                           struct class_device *cdev)
+                           struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
 
@@ -356,22 +356,24 @@ EXPORT_SYMBOL(sas_remove_host);
 
 #define sas_phy_show_simple(field, name, format_string, cast)           \
 static ssize_t                                                          \
-show_sas_phy_##name(struct class_device *cdev, char *buf)               \
+show_sas_phy_##name(struct device *dev,                                 \
+                    struct device_attribute *attr, char *buf)           \
 {                                                                       \
-        struct sas_phy *phy = transport_class_to_phy(cdev);             \
+        struct sas_phy *phy = transport_class_to_phy(dev);              \
                                                                         \
         return snprintf(buf, 20, format_string, cast phy->field);       \
 }
 
 #define sas_phy_simple_attr(field, name, format_string, type)           \
         sas_phy_show_simple(field, name, format_string, (type)) \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
 
 #define sas_phy_show_protocol(field, name)                              \
 static ssize_t                                                          \
-show_sas_phy_##name(struct class_device *cdev, char *buf)               \
+show_sas_phy_##name(struct device *dev,                                 \
+                    struct device_attribute *attr, char *buf)           \
 {                                                                       \
-        struct sas_phy *phy = transport_class_to_phy(cdev);             \
+        struct sas_phy *phy = transport_class_to_phy(dev);              \
                                                                         \
         if (!phy->field)                                                \
                 return snprintf(buf, 20, "none\n");                     \
@@ -380,13 +382,14 @@ show_sas_phy_##name(struct class_device *cdev, char *buf)		\
 
 #define sas_phy_protocol_attr(field, name)                              \
         sas_phy_show_protocol(field, name)                              \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
 
 #define sas_phy_show_linkspeed(field)                                   \
 static ssize_t                                                          \
-show_sas_phy_##field(struct class_device *cdev, char *buf)              \
+show_sas_phy_##field(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
 {                                                                       \
-        struct sas_phy *phy = transport_class_to_phy(cdev);             \
+        struct sas_phy *phy = transport_class_to_phy(dev);              \
                                                                         \
         return get_sas_linkspeed_names(phy->field, buf);                \
 }
@@ -394,10 +397,11 @@ show_sas_phy_##field(struct class_device *cdev, char *buf)		\
 /* Fudge to tell if we're minimum or maximum */
 #define sas_phy_store_linkspeed(field)                                  \
 static ssize_t                                                          \
-store_sas_phy_##field(struct class_device *cdev, const char *buf,       \
-                      size_t count)                                     \
+store_sas_phy_##field(struct device *dev,                               \
+                      struct device_attribute *attr,                    \
+                      const char *buf,  size_t count)                   \
 {                                                                       \
-        struct sas_phy *phy = transport_class_to_phy(cdev);             \
+        struct sas_phy *phy = transport_class_to_phy(dev);              \
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);        \
         struct sas_internal *i = to_sas_internal(shost->transportt);    \
         u32 value;                                                      \
@@ -416,19 +420,20 @@ store_sas_phy_##field(struct class_device *cdev, const char *buf,	\
 #define sas_phy_linkspeed_rw_attr(field)                                \
         sas_phy_show_linkspeed(field)                                   \
         sas_phy_store_linkspeed(field)                                  \
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field,          \
+static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field,                \
         store_sas_phy_##field)
 
 #define sas_phy_linkspeed_attr(field)                                   \
         sas_phy_show_linkspeed(field)                                   \
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
+static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
 
 
 #define sas_phy_show_linkerror(field)                                   \
 static ssize_t                                                          \
-show_sas_phy_##field(struct class_device *cdev, char *buf)              \
+show_sas_phy_##field(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
 {                                                                       \
-        struct sas_phy *phy = transport_class_to_phy(cdev);             \
+        struct sas_phy *phy = transport_class_to_phy(dev);              \
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);        \
         struct sas_internal *i = to_sas_internal(shost->transportt);    \
         int error;                                                      \
@@ -441,24 +446,25 @@ show_sas_phy_##field(struct class_device *cdev, char *buf)		\
 
 #define sas_phy_linkerror_attr(field)                                   \
         sas_phy_show_linkerror(field)                                   \
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
+static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
 
 
 static ssize_t
-show_sas_device_type(struct class_device *cdev, char *buf)
+show_sas_device_type(struct device *dev,
+                     struct device_attribute *attr, char *buf)
 {
-        struct sas_phy *phy = transport_class_to_phy(cdev);
+        struct sas_phy *phy = transport_class_to_phy(dev);
 
         if (!phy->identify.device_type)
                 return snprintf(buf, 20, "none\n");
         return get_sas_device_type_names(phy->identify.device_type, buf);
 }
-static CLASS_DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
+static DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
 
-static ssize_t do_sas_phy_enable(struct class_device *cdev,
+static ssize_t do_sas_phy_enable(struct device *dev,
                 size_t count, int enable)
 {
-        struct sas_phy *phy = transport_class_to_phy(cdev);
+        struct sas_phy *phy = transport_class_to_phy(dev);
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
         struct sas_internal *i = to_sas_internal(shost->transportt);
         int error;
@@ -470,18 +476,19 @@ static ssize_t do_sas_phy_enable(struct class_device *cdev,
         return count;
 };
 
-static ssize_t store_sas_phy_enable(struct class_device *cdev,
-                const char *buf, size_t count)
+static ssize_t
+store_sas_phy_enable(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
         if (count < 1)
                 return -EINVAL;
 
         switch (buf[0]) {
         case '0':
-                do_sas_phy_enable(cdev, count, 0);
+                do_sas_phy_enable(dev, count, 0);
                 break;
         case '1':
-                do_sas_phy_enable(cdev, count, 1);
+                do_sas_phy_enable(dev, count, 1);
                 break;
         default:
                 return -EINVAL;
@@ -490,20 +497,22 @@ static ssize_t store_sas_phy_enable(struct class_device *cdev,
         return count;
 }
 
-static ssize_t show_sas_phy_enable(struct class_device *cdev, char *buf)
+static ssize_t
+show_sas_phy_enable(struct device *dev, struct device_attribute *attr,
+                    char *buf)
 {
-        struct sas_phy *phy = transport_class_to_phy(cdev);
+        struct sas_phy *phy = transport_class_to_phy(dev);
 
         return snprintf(buf, 20, "%d", phy->enabled);
 }
 
-static CLASS_DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable,
+static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable,
                          store_sas_phy_enable);
 
-static ssize_t do_sas_phy_reset(struct class_device *cdev,
-                size_t count, int hard_reset)
+static ssize_t
+do_sas_phy_reset(struct device *dev, size_t count, int hard_reset)
 {
-        struct sas_phy *phy = transport_class_to_phy(cdev);
+        struct sas_phy *phy = transport_class_to_phy(dev);
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
         struct sas_internal *i = to_sas_internal(shost->transportt);
         int error;
@@ -514,19 +523,21 @@ static ssize_t do_sas_phy_reset(struct class_device *cdev,
         return count;
 };
 
-static ssize_t store_sas_link_reset(struct class_device *cdev,
-                const char *buf, size_t count)
+static ssize_t
+store_sas_link_reset(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        return do_sas_phy_reset(cdev, count, 0);
+        return do_sas_phy_reset(dev, count, 0);
 }
-static CLASS_DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset);
+static DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset);
 
-static ssize_t store_sas_hard_reset(struct class_device *cdev,
-                const char *buf, size_t count)
+static ssize_t
+store_sas_hard_reset(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        return do_sas_phy_reset(cdev, count, 1);
+        return do_sas_phy_reset(dev, count, 1);
 }
-static CLASS_DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset);
+static DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset);
 
 sas_phy_protocol_attr(identify.initiator_port_protocols,
                 initiator_port_protocols);
@@ -695,16 +706,17 @@ EXPORT_SYMBOL(scsi_is_sas_phy);
  */
 #define sas_port_show_simple(field, name, format_string, cast)          \
 static ssize_t                                                          \
-show_sas_port_##name(struct class_device *cdev, char *buf)              \
+show_sas_port_##name(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
 {                                                                       \
-        struct sas_port *port = transport_class_to_sas_port(cdev);      \
+        struct sas_port *port = transport_class_to_sas_port(dev);       \
                                                                         \
         return snprintf(buf, 20, format_string, cast port->field);      \
 }
 
 #define sas_port_simple_attr(field, name, format_string, type)          \
         sas_port_show_simple(field, name, format_string, (type))        \
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
+static DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
 
 sas_port_simple_attr(num_phys, num_phys, "%d\n", int);
 
@@ -1017,23 +1029,25 @@ EXPORT_SYMBOL(sas_port_mark_backlink);
 
 #define sas_rphy_show_simple(field, name, format_string, cast)          \
 static ssize_t                                                          \
-show_sas_rphy_##name(struct class_device *cdev, char *buf)              \
+show_sas_rphy_##name(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
 {                                                                       \
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);  \
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);           \
                                                                         \
         return snprintf(buf, 20, format_string, cast rphy->field);      \
 }
 
 #define sas_rphy_simple_attr(field, name, format_string, type)          \
         sas_rphy_show_simple(field, name, format_string, (type))        \
-static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO,                       \
+static SAS_DEVICE_ATTR(rphy, name, S_IRUGO,                     \
                 show_sas_rphy_##name, NULL)
 
 #define sas_rphy_show_protocol(field, name)                             \
 static ssize_t                                                          \
-show_sas_rphy_##name(struct class_device *cdev, char *buf)              \
+show_sas_rphy_##name(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
 {                                                                       \
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);  \
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);           \
                                                                         \
         if (!rphy->field)                                       \
                 return snprintf(buf, 20, "none\n");                     \
@@ -1042,13 +1056,14 @@ show_sas_rphy_##name(struct class_device *cdev, char *buf)		\
 
 #define sas_rphy_protocol_attr(field, name)                             \
         sas_rphy_show_protocol(field, name)                             \
-static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO,                       \
+static SAS_DEVICE_ATTR(rphy, name, S_IRUGO,                     \
                 show_sas_rphy_##name, NULL)
 
 static ssize_t
-show_sas_rphy_device_type(struct class_device *cdev, char *buf)
+show_sas_rphy_device_type(struct device *dev,
+                          struct device_attribute *attr, char *buf)
 {
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);
 
         if (!rphy->identify.device_type)
                 return snprintf(buf, 20, "none\n");
@@ -1056,13 +1071,14 @@ show_sas_rphy_device_type(struct class_device *cdev, char *buf)
                         rphy->identify.device_type, buf);
 }
 
-static SAS_CLASS_DEVICE_ATTR(rphy, device_type, S_IRUGO,
+static SAS_DEVICE_ATTR(rphy, device_type, S_IRUGO,
                 show_sas_rphy_device_type, NULL);
 
 static ssize_t
-show_sas_rphy_enclosure_identifier(struct class_device *cdev, char *buf)
+show_sas_rphy_enclosure_identifier(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
 {
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);
         struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
         struct sas_internal *i = to_sas_internal(shost->transportt);
@@ -1082,13 +1098,14 @@ show_sas_rphy_enclosure_identifier(struct class_device *cdev, char *buf)
         return sprintf(buf, "0x%llx\n", (unsigned long long)identifier);
 }
 
-static SAS_CLASS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO,
+static SAS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO,
                 show_sas_rphy_enclosure_identifier, NULL);
 
 static ssize_t
-show_sas_rphy_bay_identifier(struct class_device *cdev, char *buf)
+show_sas_rphy_bay_identifier(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);
         struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
         struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
         struct sas_internal *i = to_sas_internal(shost->transportt);
@@ -1103,7 +1120,7 @@ show_sas_rphy_bay_identifier(struct class_device *cdev, char *buf)
         return sprintf(buf, "%d\n", val);
 }
 
-static SAS_CLASS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO,
+static SAS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO,
                 show_sas_rphy_bay_identifier, NULL);
 
 sas_rphy_protocol_attr(identify.initiator_port_protocols,
@@ -1161,9 +1178,10 @@ static DECLARE_TRANSPORT_CLASS(sas_end_dev_class,
 
 #define sas_end_dev_show_simple(field, name, format_string, cast)       \
 static ssize_t                                                          \
-show_sas_end_dev_##name(struct class_device *cdev, char *buf)           \
+show_sas_end_dev_##name(struct device *dev,                             \
+                        struct device_attribute *attr, char *buf)       \
 {                                                                       \
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);          \
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);           \
         struct sas_end_device *rdev = rphy_to_end_device(rphy);         \
                                                                         \
         return snprintf(buf, 20, format_string, cast rdev->field);      \
@@ -1171,7 +1189,7 @@ show_sas_end_dev_##name(struct class_device *cdev, char *buf)		\
 
 #define sas_end_dev_simple_attr(field, name, format_string, type)       \
         sas_end_dev_show_simple(field, name, format_string, (type))     \
-static SAS_CLASS_DEVICE_ATTR(end_dev, name, S_IRUGO,                    \
+static SAS_DEVICE_ATTR(end_dev, name, S_IRUGO,                  \
                 show_sas_end_dev_##name, NULL)
 
 sas_end_dev_simple_attr(ready_led_meaning, ready_led_meaning, "%d\n", int);
@@ -1185,9 +1203,10 @@ static DECLARE_TRANSPORT_CLASS(sas_expander_class,
 
 #define sas_expander_show_simple(field, name, format_string, cast)      \
 static ssize_t                                                          \
-show_sas_expander_##name(struct class_device *cdev, char *buf)          \
+show_sas_expander_##name(struct device *dev,                            \
+                         struct device_attribute *attr, char *buf)      \
 {                                                                       \
-        struct sas_rphy *rphy = transport_class_to_rphy(cdev);          \
+        struct sas_rphy *rphy = transport_class_to_rphy(dev);           \
         struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
                                                                         \
         return snprintf(buf, 20, format_string, cast edev->field);      \
@@ -1195,7 +1214,7 @@ show_sas_expander_##name(struct class_device *cdev, char *buf)		\
 
 #define sas_expander_simple_attr(field, name, format_string, type)      \
         sas_expander_show_simple(field, name, format_string, (type))    \
-static SAS_CLASS_DEVICE_ATTR(expander, name, S_IRUGO,                   \
+static SAS_DEVICE_ATTR(expander, name, S_IRUGO,                         \
                 show_sas_expander_##name, NULL)
 
 sas_expander_simple_attr(vendor_id, vendor_id, "%s\n", char *);
@@ -1554,14 +1573,14 @@ static int sas_user_scan(struct Scsi_Host *shost, uint channel,
  */
 
 #define SETUP_TEMPLATE(attrb, field, perm, test)                        \
-        i->private_##attrb[count] = class_device_attr_##field;          \
+        i->private_##attrb[count] = dev_attr_##field;           \
         i->private_##attrb[count].attr.mode = perm;                     \
         i->attrb[count] = &i->private_##attrb[count];                   \
         if (test)                                                       \
                 count++
 
 #define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm)   \
-        i->private_##attrb[count] = class_device_attr_##field;          \
+        i->private_##attrb[count] = dev_attr_##field;           \
         i->private_##attrb[count].attr.mode = perm;                     \
         if (ro_test) {                                                  \
                 i->private_##attrb[count].attr.mode = ro_perm;          \
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 1fb60313a516..bc12b5d5d676 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -158,7 +158,7 @@ static inline enum spi_signal_type spi_signal_to_value(const char *name)
 }
 
 static int spi_host_setup(struct transport_container *tc, struct device *dev,
-                          struct class_device *cdev)
+                          struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
 
@@ -169,7 +169,7 @@ static int spi_host_setup(struct transport_container *tc, struct device *dev,
 
 static int spi_host_configure(struct transport_container *tc,
                               struct device *dev,
-                              struct class_device *cdev);
+                              struct device *cdev);
 
 static DECLARE_TRANSPORT_CLASS(spi_host_class,
                                "spi_host",
@@ -195,11 +195,11 @@ static int spi_host_match(struct attribute_container *cont,
 
 static int spi_target_configure(struct transport_container *tc,
                                 struct device *dev,
-                                struct class_device *cdev);
+                                struct device *cdev);
 
 static int spi_device_configure(struct transport_container *tc,
                                 struct device *dev,
-                                struct class_device *cdev)
+                                struct device *cdev)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
         struct scsi_target *starget = sdev->sdev_target;
@@ -219,7 +219,7 @@ static int spi_device_configure(struct transport_container *tc,
 
 static int spi_setup_transport_attrs(struct transport_container *tc,
                                      struct device *dev,
-                                     struct class_device *cdev)
+                                     struct device *cdev)
 {
         struct scsi_target *starget = to_scsi_target(dev);
 
@@ -248,9 +248,10 @@ static int spi_setup_transport_attrs(struct transport_container *tc,
 #define spi_transport_show_simple(field, format_string)                 \
                                                                         \
 static ssize_t                                                          \
-show_spi_transport_##field(struct class_device *cdev, char *buf)        \
+show_spi_transport_##field(struct device *dev,                  \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct spi_transport_attrs *tp;                                 \
                                                                         \
         tp = (struct spi_transport_attrs *)&starget->starget_data;      \
@@ -260,11 +261,12 @@ show_spi_transport_##field(struct class_device *cdev, char *buf)	\
 #define spi_transport_store_simple(field, format_string)                \
                                                                         \
 static ssize_t                                                          \
-store_spi_transport_##field(struct class_device *cdev, const char *buf, \
-                            size_t count)                               \
+store_spi_transport_##field(struct device *dev,                         \
+                            struct device_attribute *attr,              \
+                            const char *buf, size_t count)              \
 {                                                                       \
         int val;                                                        \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct spi_transport_attrs *tp;                                 \
                                                                         \
         tp = (struct spi_transport_attrs *)&starget->starget_data;      \
@@ -276,9 +278,10 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 #define spi_transport_show_function(field, format_string)               \
                                                                         \
 static ssize_t                                                          \
-show_spi_transport_##field(struct class_device *cdev, char *buf)        \
+show_spi_transport_##field(struct device *dev,                  \
+                           struct device_attribute *attr, char *buf)    \
 {                                                                       \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
         struct spi_transport_attrs *tp;                                 \
         struct spi_internal *i = to_spi_internal(shost->transportt);    \
@@ -290,11 +293,12 @@ show_spi_transport_##field(struct class_device *cdev, char *buf)	\
 
 #define spi_transport_store_function(field, format_string)              \
 static ssize_t                                                          \
-store_spi_transport_##field(struct class_device *cdev, const char *buf, \
-                            size_t count)                               \
+store_spi_transport_##field(struct device *dev,                         \
+                            struct device_attribute *attr,              \
+                            const char *buf, size_t count)              \
 {                                                                       \
         int val;                                                        \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
         struct spi_internal *i = to_spi_internal(shost->transportt);    \
                                                                         \
@@ -307,11 +311,12 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 
 #define spi_transport_store_max(field, format_string)                   \
 static ssize_t                                                          \
-store_spi_transport_##field(struct class_device *cdev, const char *buf, \
-                            size_t count)                               \
+store_spi_transport_##field(struct device *dev,                         \
+                            struct device_attribute *attr,              \
+                            const char *buf, size_t count)              \
 {                                                                       \
         int val;                                                        \
-        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct scsi_target *starget = transport_class_to_starget(dev);  \
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
         struct spi_internal *i = to_spi_internal(shost->transportt);    \
         struct spi_transport_attrs *tp                                  \
@@ -329,24 +334,24 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 #define spi_transport_rd_attr(field, format_string)                     \
         spi_transport_show_function(field, format_string)               \
         spi_transport_store_function(field, format_string)              \
-static CLASS_DEVICE_ATTR(field, S_IRUGO,                                \
-                         show_spi_transport_##field,                    \
-                         store_spi_transport_##field);
+static DEVICE_ATTR(field, S_IRUGO,                              \
+                   show_spi_transport_##field,                  \
+                   store_spi_transport_##field);
 
 #define spi_transport_simple_attr(field, format_string)                 \
         spi_transport_show_simple(field, format_string)                 \
         spi_transport_store_simple(field, format_string)                \
-static CLASS_DEVICE_ATTR(field, S_IRUGO,                                \
-                         show_spi_transport_##field,                    \
-                         store_spi_transport_##field);
+static DEVICE_ATTR(field, S_IRUGO,                              \
+                   show_spi_transport_##field,                  \
+                   store_spi_transport_##field);
 
 #define spi_transport_max_attr(field, format_string)                    \
         spi_transport_show_function(field, format_string)               \
         spi_transport_store_max(field, format_string)                   \
         spi_transport_simple_attr(max_##field, format_string)           \
-static CLASS_DEVICE_ATTR(field, S_IRUGO,                                \
-                         show_spi_transport_##field,                    \
-                         store_spi_transport_##field);
+static DEVICE_ATTR(field, S_IRUGO,                              \
+                   show_spi_transport_##field,                  \
+                   store_spi_transport_##field);
 
 /* The Parallel SCSI Tranport Attributes: */
 spi_transport_max_attr(offset, "%d\n");
@@ -370,14 +375,15 @@ static int child_iter(struct device *dev, void *data)
 }
 
 static ssize_t
-store_spi_revalidate(struct class_device *cdev, const char *buf, size_t count)
+store_spi_revalidate(struct device *dev, struct device_attribute *attr,
+                     const char *buf, size_t count)
 {
-        struct scsi_target *starget = transport_class_to_starget(cdev);
+        struct scsi_target *starget = transport_class_to_starget(dev);
 
         device_for_each_child(&starget->dev, NULL, child_iter);
         return count;
 }
-static CLASS_DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate);
+static DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate);
 
 /* Translate the period into ns according to the current spec
  * for SDTR/PPR messages */
@@ -412,7 +418,7 @@ show_spi_transport_period_helper(char *buf, int period)
 }
 
 static ssize_t
-store_spi_transport_period_helper(struct class_device *cdev, const char *buf,
+store_spi_transport_period_helper(struct device *dev, const char *buf,
                                   size_t count, int *periodp)
 {
         int j, picosec, period = -1;
@@ -449,9 +455,10 @@ store_spi_transport_period_helper(struct class_device *cdev, const char *buf,
 }
 
 static ssize_t
-show_spi_transport_period(struct class_device *cdev, char *buf)
+show_spi_transport_period(struct device *dev,
+                          struct device_attribute *attr, char *buf)
 {
-        struct scsi_target *starget = transport_class_to_starget(cdev);
+        struct scsi_target *starget = transport_class_to_starget(dev);
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
         struct spi_internal *i = to_spi_internal(shost->transportt);
         struct spi_transport_attrs *tp =
@@ -464,8 +471,8 @@ show_spi_transport_period(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-store_spi_transport_period(struct class_device *cdev, const char *buf,
-                            size_t count)
+store_spi_transport_period(struct device *cdev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
         struct scsi_target *starget = transport_class_to_starget(cdev);
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -487,12 +494,13 @@ store_spi_transport_period(struct class_device *cdev, const char *buf,
         return retval;
 }
 
-static CLASS_DEVICE_ATTR(period, S_IRUGO,
-                         show_spi_transport_period,
-                         store_spi_transport_period);
+static DEVICE_ATTR(period, S_IRUGO,
+                   show_spi_transport_period,
+                   store_spi_transport_period);
 
 static ssize_t
-show_spi_transport_min_period(struct class_device *cdev, char *buf)
+show_spi_transport_min_period(struct device *cdev,
+                              struct device_attribute *attr, char *buf)
 {
         struct scsi_target *starget = transport_class_to_starget(cdev);
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -507,8 +515,9 @@ show_spi_transport_min_period(struct class_device *cdev, char *buf)
 }
 
 static ssize_t
-store_spi_transport_min_period(struct class_device *cdev, const char *buf,
-                            size_t count)
+store_spi_transport_min_period(struct device *cdev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
 {
         struct scsi_target *starget = transport_class_to_starget(cdev);
         struct spi_transport_attrs *tp =
@@ -519,12 +528,14 @@ store_spi_transport_min_period(struct class_device *cdev, const char *buf,
 }
 
 
-static CLASS_DEVICE_ATTR(min_period, S_IRUGO,
-                         show_spi_transport_min_period,
-                         store_spi_transport_min_period);
+static DEVICE_ATTR(min_period, S_IRUGO,
+                   show_spi_transport_min_period,
+                   store_spi_transport_min_period);
 
 
-static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf)
+static ssize_t show_spi_host_signalling(struct device *cdev,
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
         struct Scsi_Host *shost = transport_class_to_shost(cdev);
         struct spi_internal *i = to_spi_internal(shost->transportt);
@@ -534,10 +545,11 @@ static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf)
 
         return sprintf(buf, "%s\n", spi_signal_to_string(spi_signalling(shost)));
 }
-static ssize_t store_spi_host_signalling(struct class_device *cdev,
+static ssize_t store_spi_host_signalling(struct device *dev,
+                                         struct device_attribute *attr,
                                          const char *buf, size_t count)
 {
-        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+        struct Scsi_Host *shost = transport_class_to_shost(dev);
         struct spi_internal *i = to_spi_internal(shost->transportt);
         enum spi_signal_type type = spi_signal_to_value(buf);
 
@@ -549,9 +561,9 @@ static ssize_t store_spi_host_signalling(struct class_device *cdev,
 
         return count;
 }
-static CLASS_DEVICE_ATTR(signalling, S_IRUGO,
-                         show_spi_host_signalling,
-                         store_spi_host_signalling);
+static DEVICE_ATTR(signalling, S_IRUGO,
+                   show_spi_host_signalling,
+                   store_spi_host_signalling);
 
 #define DV_SET(x, y)                    \
         if(i->f->set_##x)               \
@@ -1334,7 +1346,7 @@ static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
                                     spi_device_configure);
 
 static struct attribute *host_attributes[] = {
-        &class_device_attr_signalling.attr,
+        &dev_attr_signalling.attr,
         NULL
 };
 
@@ -1344,12 +1356,12 @@ static struct attribute_group host_attribute_group = {
 
 static int spi_host_configure(struct transport_container *tc,
                               struct device *dev,
-                              struct class_device *cdev)
+                              struct device *cdev)
 {
         struct kobject *kobj = &cdev->kobj;
         struct Scsi_Host *shost = transport_class_to_shost(cdev);
         struct spi_internal *si = to_spi_internal(shost->transportt);
-        struct attribute *attr = &class_device_attr_signalling.attr;
+        struct attribute *attr = &dev_attr_signalling.attr;
         int rc = 0;
 
         if (si->f->set_signalling)
@@ -1368,76 +1380,75 @@ static int spi_host_configure(struct transport_container *tc,
 static int target_attribute_is_visible(struct kobject *kobj,
                                        struct attribute *attr, int i)
 {
-        struct class_device *cdev =
-                container_of(kobj, struct class_device, kobj);
+        struct device *cdev = container_of(kobj, struct device, kobj);
         struct scsi_target *starget = transport_class_to_starget(cdev);
         struct Scsi_Host *shost = transport_class_to_shost(cdev);
         struct spi_internal *si = to_spi_internal(shost->transportt);
 
-        if (attr == &class_device_attr_period.attr &&
+        if (attr == &dev_attr_period.attr &&
             spi_support_sync(starget))
                 return TARGET_ATTRIBUTE_HELPER(period);
-        else if (attr == &class_device_attr_min_period.attr &&
+        else if (attr == &dev_attr_min_period.attr &&
                  spi_support_sync(starget))
                 return TARGET_ATTRIBUTE_HELPER(period);
-        else if (attr == &class_device_attr_offset.attr &&
+        else if (attr == &dev_attr_offset.attr &&
                  spi_support_sync(starget))
                 return TARGET_ATTRIBUTE_HELPER(offset);
-        else if (attr == &class_device_attr_max_offset.attr &&
+        else if (attr == &dev_attr_max_offset.attr &&
                  spi_support_sync(starget))
                 return TARGET_ATTRIBUTE_HELPER(offset);
-        else if (attr == &class_device_attr_width.attr &&
+        else if (attr == &dev_attr_width.attr &&
                  spi_support_wide(starget))
                 return TARGET_ATTRIBUTE_HELPER(width);
-        else if (attr == &class_device_attr_max_width.attr &&
+        else if (attr == &dev_attr_max_width.attr &&
                  spi_support_wide(starget))
                 return TARGET_ATTRIBUTE_HELPER(width);
-        else if (attr == &class_device_attr_iu.attr &&
+        else if (attr == &dev_attr_iu.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(iu);
-        else if (attr == &class_device_attr_dt.attr &&
+        else if (attr == &dev_attr_dt.attr &&
                  spi_support_dt(starget))
                 return TARGET_ATTRIBUTE_HELPER(dt);
-        else if (attr == &class_device_attr_qas.attr &&
+        else if (attr == &dev_attr_qas.attr &&
                  spi_support_qas(starget))
                 return TARGET_ATTRIBUTE_HELPER(qas);
-        else if (attr == &class_device_attr_wr_flow.attr &&
+        else if (attr == &dev_attr_wr_flow.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(wr_flow);
-        else if (attr == &class_device_attr_rd_strm.attr &&
+        else if (attr == &dev_attr_rd_strm.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(rd_strm);
-        else if (attr == &class_device_attr_rti.attr &&
+        else if (attr == &dev_attr_rti.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(rti);
-        else if (attr == &class_device_attr_pcomp_en.attr &&
+        else if (attr == &dev_attr_pcomp_en.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(pcomp_en);
-        else if (attr == &class_device_attr_hold_mcs.attr &&
+        else if (attr == &dev_attr_hold_mcs.attr &&
                  spi_support_ius(starget))
                 return TARGET_ATTRIBUTE_HELPER(hold_mcs);
-        else if (attr == &class_device_attr_revalidate.attr)
+        else if (attr == &dev_attr_revalidate.attr)
                 return 1;
 
         return 0;
 }
 
 static struct attribute *target_attributes[] = {
-        &class_device_attr_period.attr,
-        &class_device_attr_min_period.attr,
-        &class_device_attr_offset.attr,
-        &class_device_attr_max_offset.attr,
-        &class_device_attr_width.attr,
-        &class_device_attr_max_width.attr,
-        &class_device_attr_iu.attr,
-        &class_device_attr_dt.attr,
-        &class_device_attr_qas.attr,
-        &class_device_attr_wr_flow.attr,
-        &class_device_attr_rd_strm.attr,
-        &class_device_attr_rti.attr,
-        &class_device_attr_pcomp_en.attr,
-        &class_device_attr_hold_mcs.attr,
-        &class_device_attr_revalidate.attr,
+        &dev_attr_period.attr,
+        &dev_attr_min_period.attr,
+        &dev_attr_offset.attr,
+        &dev_attr_max_offset.attr,
+        &dev_attr_width.attr,
+        &dev_attr_max_width.attr,
+        &dev_attr_iu.attr,
+        &dev_attr_dt.attr,
+        &dev_attr_qas.attr,
+        &dev_attr_wr_flow.attr,
+        &dev_attr_rd_strm.attr,
+        &dev_attr_rti.attr,
+        &dev_attr_pcomp_en.attr,
+        &dev_attr_hold_mcs.attr,
+        &dev_attr_revalidate.attr,
         NULL
 };
 
@@ -1448,7 +1459,7 @@ static struct attribute_group target_attribute_group = {
 
 static int spi_target_configure(struct transport_container *tc,
                                 struct device *dev,
-                                struct class_device *cdev)
+                                struct device *cdev)
 {
         struct kobject *kobj = &cdev->kobj;
         int i;
@@ -1462,7 +1473,7 @@ static int spi_target_configure(struct transport_container *tc,
                  * to ignore, sysfs also does a WARN_ON and dumps a trace,
                  * which is bad, so temporarily, skip attributes that are
                  * already visible (the revalidate one) */
-                if (j && attr != &class_device_attr_revalidate.attr)
+                if (j && attr != &dev_attr_revalidate.attr)
                         rc = sysfs_add_file_to_group(kobj, attr,
                                                 target_attribute_group.name);
                 /* and make the attribute writeable if we have a set
diff --git a/drivers/scsi/scsi_transport_srp.c b/drivers/scsi/scsi_transport_srp.c
index 2445c98ae95e..8a7af951d98a 100644
--- a/drivers/scsi/scsi_transport_srp.c
+++ b/drivers/scsi/scsi_transport_srp.c
@@ -44,20 +44,20 @@ struct srp_internal {
         struct scsi_transport_template t;
         struct srp_function_template *f;
 
-        struct class_device_attribute *host_attrs[SRP_HOST_ATTRS + 1];
+        struct device_attribute *host_attrs[SRP_HOST_ATTRS + 1];
 
-        struct class_device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1];
-        struct class_device_attribute private_rport_attrs[SRP_RPORT_ATTRS];
+        struct device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1];
+        struct device_attribute private_rport_attrs[SRP_RPORT_ATTRS];
         struct transport_container rport_attr_cont;
 };
 
 #define to_srp_internal(tmpl) container_of(tmpl, struct srp_internal, t)
 
 #define dev_to_rport(d) container_of(d, struct srp_rport, dev)
-#define transport_class_to_srp_rport(cdev) dev_to_rport((cdev)->dev)
+#define transport_class_to_srp_rport(dev) dev_to_rport((dev)->parent)
 
 static int srp_host_setup(struct transport_container *tc, struct device *dev,
-                          struct class_device *cdev)
+                          struct device *cdev)
 {
         struct Scsi_Host *shost = dev_to_shost(dev);
         struct srp_host_attrs *srp_host = to_srp_host_attrs(shost);
@@ -73,7 +73,7 @@ static DECLARE_TRANSPORT_CLASS(srp_rport_class, "srp_remote_ports",
                                NULL, NULL, NULL);
 
 #define SETUP_TEMPLATE(attrb, field, perm, test, ro_test, ro_perm)      \
-        i->private_##attrb[count] = class_device_attr_##field;          \
+        i->private_##attrb[count] = dev_attr_##field;           \
         i->private_##attrb[count].attr.mode = perm;                     \
         if (ro_test) {                                                  \
                 i->private_##attrb[count].attr.mode = ro_perm;          \
@@ -100,13 +100,14 @@ static DECLARE_TRANSPORT_CLASS(srp_rport_class, "srp_remote_ports",
         "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x"
 
 static ssize_t
-show_srp_rport_id(struct class_device *cdev, char *buf)
+show_srp_rport_id(struct device *dev, struct device_attribute *attr,
+                  char *buf)
 {
-        struct srp_rport *rport = transport_class_to_srp_rport(cdev);
+        struct srp_rport *rport = transport_class_to_srp_rport(dev);
         return sprintf(buf, SRP_PID_FMT "\n", SRP_PID(rport));
 }
 
-static CLASS_DEVICE_ATTR(port_id, S_IRUGO, show_srp_rport_id, NULL);
+static DEVICE_ATTR(port_id, S_IRUGO, show_srp_rport_id, NULL);
 
 static const struct {
         u32 value;
@@ -117,9 +118,10 @@ static const struct {
 };
 
 static ssize_t
-show_srp_rport_roles(struct class_device *cdev, char *buf)
+show_srp_rport_roles(struct device *dev, struct device_attribute *attr,
+                     char *buf)
 {
-        struct srp_rport *rport = transport_class_to_srp_rport(cdev);
+        struct srp_rport *rport = transport_class_to_srp_rport(dev);
         int i;
         char *name = NULL;
 
@@ -131,7 +133,7 @@ show_srp_rport_roles(struct class_device *cdev, char *buf)
         return sprintf(buf, "%s\n", name ? : "unknown");
 }
 
-static CLASS_DEVICE_ATTR(roles, S_IRUGO, show_srp_rport_roles, NULL);
+static DEVICE_ATTR(roles, S_IRUGO, show_srp_rport_roles, NULL);
 
 static void srp_rport_release(struct device *dev)
 {
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 5fe7aaed904c..3cea17dd5dba 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -95,7 +95,7 @@ static int sd_resume(struct device *);
 static void sd_rescan(struct device *);
 static int sd_done(struct scsi_cmnd *);
 static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
-static void scsi_disk_release(struct class_device *cdev);
+static void scsi_disk_release(struct device *cdev);
 static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
 static void sd_print_result(struct scsi_disk *, int);
 
@@ -112,11 +112,12 @@ static const char *sd_cache_types[] = {
         "write back, no read (daft)"
 };
 
-static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf,
-                                   size_t count)
+static ssize_t
+sd_store_cache_type(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
 {
         int i, ct = -1, rcd, wce, sp;
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         struct scsi_device *sdp = sdkp->device;
         char buffer[64];
         char *buffer_data;
@@ -163,10 +164,11 @@ static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf,
         return count;
 }
 
-static ssize_t sd_store_manage_start_stop(struct class_device *cdev,
-                                          const char *buf, size_t count)
+static ssize_t
+sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         struct scsi_device *sdp = sdkp->device;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -177,10 +179,11 @@ static ssize_t sd_store_manage_start_stop(struct class_device *cdev,
         return count;
 }
 
-static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf,
-                                      size_t count)
+static ssize_t
+sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         struct scsi_device *sdp = sdkp->device;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -194,37 +197,44 @@ static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf
         return count;
 }
 
-static ssize_t sd_show_cache_type(struct class_device *cdev, char *buf)
+static ssize_t
+sd_show_cache_type(struct device *dev, struct device_attribute *attr,
+                   char *buf)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         int ct = sdkp->RCD + 2*sdkp->WCE;
 
         return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
 }
 
-static ssize_t sd_show_fua(struct class_device *cdev, char *buf)
+static ssize_t
+sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
         return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
 }
 
-static ssize_t sd_show_manage_start_stop(struct class_device *cdev, char *buf)
+static ssize_t
+sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         struct scsi_device *sdp = sdkp->device;
 
         return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
 }
 
-static ssize_t sd_show_allow_restart(struct class_device *cdev, char *buf)
+static ssize_t
+sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
+                      char *buf)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
         return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
 }
 
-static struct class_device_attribute sd_disk_attrs[] = {
+static struct device_attribute sd_disk_attrs[] = {
         __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
                sd_store_cache_type),
         __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
@@ -238,8 +248,8 @@ static struct class_device_attribute sd_disk_attrs[] = {
 static struct class sd_disk_class = {
         .name           = "scsi_disk",
         .owner          = THIS_MODULE,
-        .release        = scsi_disk_release,
-        .class_dev_attrs = sd_disk_attrs,
+        .dev_release    = scsi_disk_release,
+        .dev_attrs      = sd_disk_attrs,
 };
 
 static struct scsi_driver sd_template = {
@@ -297,7 +307,7 @@ static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
         if (disk->private_data) {
                 sdkp = scsi_disk(disk);
                 if (scsi_device_get(sdkp->device) == 0)
-                        class_device_get(&sdkp->cdev);
+                        get_device(&sdkp->dev);
                 else
                         sdkp = NULL;
         }
@@ -331,7 +341,7 @@ static void scsi_disk_put(struct scsi_disk *sdkp)
         struct scsi_device *sdev = sdkp->device;
 
         mutex_lock(&sd_ref_mutex);
-        class_device_put(&sdkp->cdev);
+        put_device(&sdkp->dev);
         scsi_device_put(sdev);
         mutex_unlock(&sd_ref_mutex);
 }
@@ -1663,12 +1673,12 @@ static int sd_probe(struct device *dev)
                         sdp->timeout = SD_MOD_TIMEOUT;
         }
 
-        class_device_initialize(&sdkp->cdev);
-        sdkp->cdev.dev = &sdp->sdev_gendev;
-        sdkp->cdev.class = &sd_disk_class;
-        strncpy(sdkp->cdev.class_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE);
+        device_initialize(&sdkp->dev);
+        sdkp->dev.parent = &sdp->sdev_gendev;
+        sdkp->dev.class = &sd_disk_class;
+        strncpy(sdkp->dev.bus_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE);
 
-        if (class_device_add(&sdkp->cdev))
+        if (device_add(&sdkp->dev))
                 goto out_put;
 
         get_device(&sdp->sdev_gendev);
@@ -1734,13 +1744,13 @@ static int sd_remove(struct device *dev)
 {
         struct scsi_disk *sdkp = dev_get_drvdata(dev);
 
-        class_device_del(&sdkp->cdev);
+        device_del(&sdkp->dev);
         del_gendisk(sdkp->disk);
         sd_shutdown(dev);
 
         mutex_lock(&sd_ref_mutex);
         dev_set_drvdata(dev, NULL);
-        class_device_put(&sdkp->cdev);
+        put_device(&sdkp->dev);
         mutex_unlock(&sd_ref_mutex);
 
         return 0;
@@ -1748,16 +1758,16 @@ static int sd_remove(struct device *dev)
 
 /**
  *      scsi_disk_release - Called to free the scsi_disk structure
- *      @cdev: pointer to embedded class device
+ *      @dev: pointer to embedded class device
  *
  *      sd_ref_mutex must be held entering this routine.  Because it is
  *      called on last put, you should always use the scsi_disk_get()
  *      scsi_disk_put() helpers which manipulate the semaphore directly
- *      and never do a direct class_device_put().
+ *      and never do a direct put_device.
  **/
-static void scsi_disk_release(struct class_device *cdev)
+static void scsi_disk_release(struct device *dev)
 {
-        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
         struct gendisk *disk = sdkp->disk;
         
         spin_lock(&sd_index_lock);
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index a6d96694d0a5..45df83b9d847 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -107,7 +107,7 @@ static int ses_set_page2_descriptor(struct enclosure_device *edev,
                                       unsigned char *desc)
 {
         int i, j, count = 0, descriptor = ecomp->number;
-        struct scsi_device *sdev = to_scsi_device(edev->cdev.dev);
+        struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
         struct ses_device *ses_dev = edev->scratch;
         unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11];
         unsigned char *desc_ptr = ses_dev->page2 + 8;
@@ -137,7 +137,7 @@ static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev,
                                       struct enclosure_component *ecomp)
 {
         int i, j, count = 0, descriptor = ecomp->number;
-        struct scsi_device *sdev = to_scsi_device(edev->cdev.dev);
+        struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
         struct ses_device *ses_dev = edev->scratch;
         unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11];
         unsigned char *desc_ptr = ses_dev->page2 + 8;
@@ -269,10 +269,10 @@ int ses_match_host(struct enclosure_device *edev, void *data)
         struct ses_host_edev *sed = data;
         struct scsi_device *sdev;
 
-        if (!scsi_is_sdev_device(edev->cdev.dev))
+        if (!scsi_is_sdev_device(edev->edev.parent))
                 return 0;
 
-        sdev = to_scsi_device(edev->cdev.dev);
+        sdev = to_scsi_device(edev->edev.parent);
 
         if (sdev->host != sed->shost)
                 return 0;
@@ -407,10 +407,10 @@ static void ses_match_to_enclosure(struct enclosure_device *edev,
 
 #define INIT_ALLOC_SIZE 32
 
-static int ses_intf_add(struct class_device *cdev,
+static int ses_intf_add(struct device *cdev,
                         struct class_interface *intf)
 {
-        struct scsi_device *sdev = to_scsi_device(cdev->dev);
+        struct scsi_device *sdev = to_scsi_device(cdev->parent);
         struct scsi_device *tmp_sdev;
         unsigned char *buf = NULL, *hdr_buf, *type_ptr, *desc_ptr = NULL,
                 *addl_desc_ptr = NULL;
@@ -426,7 +426,7 @@ static int ses_intf_add(struct class_device *cdev,
                 edev = enclosure_find(&sdev->host->shost_gendev);
                 if (edev) {
                         ses_match_to_enclosure(edev, sdev);
-                        class_device_put(&edev->cdev);
+                        put_device(&edev->edev);
                 }
                 return -ENODEV;
         }
@@ -515,7 +515,7 @@ static int ses_intf_add(struct class_device *cdev,
         if (!scomp)
                 goto err_free;
 
-        edev = enclosure_register(cdev->dev, sdev->sdev_gendev.bus_id,
+        edev = enclosure_register(cdev->parent, sdev->sdev_gendev.bus_id,
                                   components, &ses_enclosure_callbacks);
         if (IS_ERR(edev)) {
                 err = PTR_ERR(edev);
@@ -625,17 +625,17 @@ static int ses_remove(struct device *dev)
         return 0;
 }
 
-static void ses_intf_remove(struct class_device *cdev,
+static void ses_intf_remove(struct device *cdev,
                             struct class_interface *intf)
 {
-        struct scsi_device *sdev = to_scsi_device(cdev->dev);
+        struct scsi_device *sdev = to_scsi_device(cdev->parent);
         struct enclosure_device *edev;
         struct ses_device *ses_dev;
 
         if (!scsi_device_enclosure(sdev))
                 return;
 
-        edev = enclosure_find(cdev->dev);
+        edev = enclosure_find(cdev->parent);
         if (!edev)
                 return;
 
@@ -649,13 +649,13 @@ static void ses_intf_remove(struct class_device *cdev,
 
         kfree(edev->component[0].scratch);
 
-        class_device_put(&edev->cdev);
+        put_device(&edev->edev);
         enclosure_unregister(edev);
 }
 
 static struct class_interface ses_interface = {
-        .add    = ses_intf_add,
-        .remove = ses_intf_remove,
+        .add_dev        = ses_intf_add,
+        .remove_dev     = ses_intf_remove,
 };
 
 static struct scsi_driver ses_template = {
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index e5156aa6dd20..2029422bc04d 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -101,16 +101,16 @@ static int scatter_elem_sz_prev = SG_SCATTER_SZ;
 #define SG_SECTOR_SZ 512
 #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1)
 
-static int sg_add(struct class_device *, struct class_interface *);
-static void sg_remove(struct class_device *, struct class_interface *);
+static int sg_add(struct device *, struct class_interface *);
+static void sg_remove(struct device *, struct class_interface *);
 
 static DEFINE_IDR(sg_index_idr);
 static DEFINE_RWLOCK(sg_index_lock);    /* Also used to lock
                                                            file descriptor list for device */
 
 static struct class_interface sg_interface = {
-        .add            = sg_add,
-        .remove         = sg_remove,
+        .add_dev        = sg_add,
+        .remove_dev     = sg_remove,
 };
 
 typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
@@ -1401,9 +1401,9 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
 }
 
 static int
-sg_add(struct class_device *cl_dev, struct class_interface *cl_intf)
+sg_add(struct device *cl_dev, struct class_interface *cl_intf)
 {
-        struct scsi_device *scsidp = to_scsi_device(cl_dev->dev);
+        struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
         struct gendisk *disk;
         Sg_device *sdp = NULL;
         struct cdev * cdev = NULL;
@@ -1439,19 +1439,19 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf)
 
         sdp->cdev = cdev;
         if (sg_sysfs_valid) {
-                struct class_device * sg_class_member;
+                struct device *sg_class_member;
 
-                sg_class_member = class_device_create(sg_sysfs_class, NULL,
-                                MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
-                                cl_dev->dev, "%s",
-                                disk->disk_name);
+                sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
+                                                MKDEV(SCSI_GENERIC_MAJOR,
+                                                      sdp->index),
+                                                "%s", disk->disk_name);
                 if (IS_ERR(sg_class_member)) {
                         printk(KERN_ERR "sg_add: "
-                               "class_device_create failed\n");
+                               "device_create failed\n");
                         error = PTR_ERR(sg_class_member);
                         goto cdev_add_err;
                 }
-                class_set_devdata(sg_class_member, sdp);
+                dev_set_drvdata(sg_class_member, sdp);
                 error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
                                           &sg_class_member->kobj, "generic");
                 if (error)
@@ -1464,7 +1464,7 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf)
                     "Attached scsi generic sg%d type %d\n", sdp->index,
                     scsidp->type);
 
-        class_set_devdata(cl_dev, sdp);
+        dev_set_drvdata(cl_dev, sdp);
 
         return 0;
 
@@ -1482,10 +1482,10 @@ out:
 }
 
 static void
-sg_remove(struct class_device *cl_dev, struct class_interface *cl_intf)
+sg_remove(struct device *cl_dev, struct class_interface *cl_intf)
 {
-        struct scsi_device *scsidp = to_scsi_device(cl_dev->dev);
-        Sg_device *sdp = class_get_devdata(cl_dev);
+        struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
+        Sg_device *sdp = dev_get_drvdata(cl_dev);
         unsigned long iflags;
         Sg_fd *sfp;
         Sg_fd *tsfp;
@@ -1528,7 +1528,7 @@ sg_remove(struct class_device *cl_dev, struct class_interface *cl_intf)
         write_unlock_irqrestore(&sg_index_lock, iflags);
 
         sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
-        class_device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
+        device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
         cdev_del(sdp->cdev);
         sdp->cdev = NULL;
         put_disk(sdp->disk);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index df83bea2c620..a860c3a9ae99 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -4108,9 +4108,9 @@ out_free_tape:
                         if (STm->cdevs[j]) {
                                 if (cdev == STm->cdevs[j])
                                         cdev = NULL;
-                                class_device_destroy(st_sysfs_class,
-                                                     MKDEV(SCSI_TAPE_MAJOR,
-                                                           TAPE_MINOR(i, mode, j)));
+                                        device_destroy(st_sysfs_class,
+                                                       MKDEV(SCSI_TAPE_MAJOR,
+                                                             TAPE_MINOR(i, mode, j)));
                                 cdev_del(STm->cdevs[j]);
                         }
                 }
@@ -4148,9 +4148,9 @@ static int st_remove(struct device *dev)
                                           "tape");
                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
                                 for (j=0; j < 2; j++) {
-                                        class_device_destroy(st_sysfs_class,
-                                                             MKDEV(SCSI_TAPE_MAJOR,
-                                                                   TAPE_MINOR(i, mode, j)));
+                                        device_destroy(st_sysfs_class,
+                                                       MKDEV(SCSI_TAPE_MAJOR,
+                                                             TAPE_MINOR(i, mode, j)));
                                         cdev_del(tpnt->modes[mode].cdevs[j]);
                                         tpnt->modes[mode].cdevs[j] = NULL;
                                 }
@@ -4319,31 +4319,34 @@ static void do_remove_sysfs_files(void)
 
 
 /* The sysfs simple class interface */
-static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
+static ssize_t
+st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
+        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
         return l;
 }
 
-CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
+DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
 
-static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
+static ssize_t
+st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
+        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
         return l;
 }
 
-CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
+DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
 
-static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
+static ssize_t
+st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
+        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
         ssize_t l = 0;
         char *fmt;
 
@@ -4352,22 +4355,25 @@ static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
         return l;
 }
 
-CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
+DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
 
-static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
+static ssize_t
+st_defcompression_show(struct device *dev, struct device_attribute *attr,
+                       char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
+        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
         ssize_t l = 0;
 
         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
         return l;
 }
 
-CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
+DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
 
-static ssize_t st_options_show(struct class_device *class_dev, char *buf)
+static ssize_t
+st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
+        struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev);
         struct scsi_tape *STp;
         int i, j, options;
         ssize_t l = 0;
@@ -4403,13 +4409,13 @@ static ssize_t st_options_show(struct class_device *class_dev, char *buf)
         return l;
 }
 
-CLASS_DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
+DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
 
 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
 {
         int i, rew, error;
         char name[10];
-        struct class_device *st_class_member;
+        struct device *st_class_member;
 
         for (rew=0; rew < 2; rew++) {
                 /* Make sure that the minor numbers corresponding to the four
@@ -4418,32 +4424,32 @@ static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
                          STp->disk->disk_name, st_formats[i]);
                 st_class_member =
-                        class_device_create(st_sysfs_class, NULL,
-                                            MKDEV(SCSI_TAPE_MAJOR,
-                                                  TAPE_MINOR(dev_num, mode, rew)),
-                                            &STp->device->sdev_gendev, "%s", name);
+                        device_create(st_sysfs_class, &STp->device->sdev_gendev,
+                                      MKDEV(SCSI_TAPE_MAJOR,
+                                                TAPE_MINOR(dev_num, mode, rew)),
+                                      "%s", name);
                 if (IS_ERR(st_class_member)) {
-                        printk(KERN_WARNING "st%d: class_device_create failed\n",
+                        printk(KERN_WARNING "st%d: device_create failed\n",
                                dev_num);
                         error = PTR_ERR(st_class_member);
                         goto out;
                 }
-                class_set_devdata(st_class_member, &STp->modes[mode]);
+                dev_set_drvdata(st_class_member, &STp->modes[mode]);
 
-                error = class_device_create_file(st_class_member,
-                                               &class_device_attr_defined);
+                error = device_create_file(st_class_member,
+                                           &dev_attr_defined);
                 if (error) goto out;
-                error = class_device_create_file(st_class_member,
-                                            &class_device_attr_default_blksize);
+                error = device_create_file(st_class_member,
+                                           &dev_attr_default_blksize);
                 if (error) goto out;
-                error = class_device_create_file(st_class_member,
-                                            &class_device_attr_default_density);
+                error = device_create_file(st_class_member,
+                                           &dev_attr_default_density);
                 if (error) goto out;
-                error = class_device_create_file(st_class_member,
-                                        &class_device_attr_default_compression);
+                error = device_create_file(st_class_member,
+                                           &dev_attr_default_compression);
                 if (error) goto out;
-                error = class_device_create_file(st_class_member,
-                                        &class_device_attr_options);
+                error = device_create_file(st_class_member,
+                                           &dev_attr_options);
                 if (error) goto out;
 
                 if (mode == 0 && rew == 0) {
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index c32c1ca75f63..a9ca03ead3e5 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -2422,7 +2422,7 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
          */
         tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);
         if (likely(!IS_ERR(tty_dev))) {
-                device_can_wakeup(tty_dev) = 1;
+                device_init_wakeup(tty_dev, 1);
                 device_set_wakeup_enable(tty_dev, 0);
         } else
                 printk(KERN_ERR "Cannot register tty device on line %d\n",
diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index b778ed71f636..a4aaab9c7ddc 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -1,8 +1,6 @@
-menu "Userspace I/O"
-        depends on !S390
-
-config UIO
+menuconfig UIO
         tristate "Userspace I/O drivers"
+        depends on !S390
         default n
         help
           Enable this to allow the userspace driver core code to be
@@ -13,6 +11,8 @@ config UIO
 
           If you don't know what to do here, say N.
 
+if UIO
+
 config UIO_CIF
         tristate "generic Hilscher CIF Card driver"
         depends on UIO && PCI
@@ -26,4 +26,17 @@ config UIO_CIF
           To compile this driver as a module, choose M here: the module
           will be called uio_cif.
 
-endmenu
+config UIO_SMX
+        tristate "SMX cryptengine UIO interface"
+        depends on UIO
+        default n
+        help
+          Userspace IO interface to the Cryptography engine found on the
+          Nias Digital SMX boards.  These will be available from Q4 2008
+          from http://www.niasdigital.com.  The userspace part of this
+          driver will be released under the GPL at the same time as the
+          hardware and will be able to be downloaded from the same site.
+
+          If you compile this as a module, it will be called uio_smx.
+
+endif
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index 7fecfb459da5..18c45662431e 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -1,2 +1,3 @@
 obj-$(CONFIG_UIO)       += uio.o
 obj-$(CONFIG_UIO_CIF)   += uio_cif.o
+obj-$(CONFIG_UIO_SMX)   += uio_smx.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 11759080ca54..55cc7b80422a 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -301,23 +301,33 @@ static int uio_open(struct inode *inode, struct file *filep)
         if (!idev)
                 return -ENODEV;
 
+        if (!try_module_get(idev->owner))
+                return -ENODEV;
+
         listener = kmalloc(sizeof(*listener), GFP_KERNEL);
-        if (!listener)
-                return -ENOMEM;
+        if (!listener) {
+                ret = -ENOMEM;
+                goto err_alloc_listener;
+        }
 
         listener->dev = idev;
         listener->event_count = atomic_read(&idev->event);
         filep->private_data = listener;
 
         if (idev->info->open) {
-                if (!try_module_get(idev->owner))
-                        return -ENODEV;
                 ret = idev->info->open(idev->info, inode);
-                module_put(idev->owner);
+                if (ret)
+                        goto err_infoopen;
         }
 
-        if (ret)
-                kfree(listener);
+        return 0;
+
+err_infoopen:
+
+        kfree(listener);
+err_alloc_listener:
+
+        module_put(idev->owner);
 
         return ret;
 }
@@ -336,12 +346,11 @@ static int uio_release(struct inode *inode, struct file *filep)
         struct uio_listener *listener = filep->private_data;
         struct uio_device *idev = listener->dev;
 
-        if (idev->info->release) {
-                if (!try_module_get(idev->owner))
-                        return -ENODEV;
+        if (idev->info->release)
                 ret = idev->info->release(idev->info, inode);
-                module_put(idev->owner);
-        }
+
+        module_put(idev->owner);
+
         if (filep->f_flags & FASYNC)
                 ret = uio_fasync(-1, filep, 0);
         kfree(listener);
@@ -510,10 +519,7 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
                 return -EINVAL;
 
         if (idev->info->mmap) {
-                if (!try_module_get(idev->owner))
-                        return -ENODEV;
                 ret = idev->info->mmap(idev->info, vma);
-                module_put(idev->owner);
                 return ret;
         }
 
diff --git a/drivers/uio/uio_cif.c b/drivers/uio/uio_cif.c
index 838bae460831..57376060b978 100644
--- a/drivers/uio/uio_cif.c
+++ b/drivers/uio/uio_cif.c
@@ -15,10 +15,6 @@
 
 #include <asm/io.h>
 
-#ifndef PCI_DEVICE_ID_PLX_9030
-#define PCI_DEVICE_ID_PLX_9030  0x9030
-#endif
-
 #define PLX9030_INTCSR          0x4C
 #define INTSCR_INT1_ENABLE      0x01
 #define INTSCR_INT1_STATUS      0x04
@@ -116,7 +112,7 @@ static void hilscher_pci_remove(struct pci_dev *dev)
         kfree (info);
 }
 
-static struct pci_device_id hilscher_pci_ids[] = {
+static struct pci_device_id hilscher_pci_ids[] __devinitdata = {
         {
                 .vendor =       PCI_VENDOR_ID_PLX,
                 .device =       PCI_DEVICE_ID_PLX_9030,
diff --git a/drivers/uio/uio_smx.c b/drivers/uio/uio_smx.c
new file mode 100644
index 000000000000..44054a650a8a
--- /dev/null
+++ b/drivers/uio/uio_smx.c
@@ -0,0 +1,140 @@
+/*
+ * UIO SMX Cryptengine driver.
+ *
+ * (C) 2008 Nias Digital P/L <bn@niasdigital.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/uio_driver.h>
+#include <linux/io.h>
+
+#define DRV_NAME "smx-ce"
+#define DRV_VERSION "0.03"
+
+#define SMX_CSR  0x00000000
+#define SMX_EnD  0x00000001
+#define SMX_RUN  0x00000002
+#define SMX_DRDY 0x00000004
+#define SMX_ERR  0x00000008
+
+static irqreturn_t smx_handler(int irq, struct uio_info *dev_info)
+{
+        void __iomem *csr = dev_info->mem[0].internal_addr + SMX_CSR;
+
+        u32 status = ioread32(csr);
+
+        if (!(status & SMX_DRDY))
+                return IRQ_NONE;
+
+        /* Disable interrupt */
+        iowrite32(status & ~SMX_DRDY, csr);
+        return IRQ_HANDLED;
+}
+
+static int __devinit smx_ce_probe(struct platform_device *dev)
+{
+
+        int ret = -ENODEV;
+        struct uio_info *info;
+        struct resource *regs;
+
+        info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        regs = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!regs) {
+                dev_err(&dev->dev, "No memory resource specified\n");
+                goto out_free;
+        }
+
+        info->mem[0].addr = regs->start;
+        if (!info->mem[0].addr) {
+                dev_err(&dev->dev, "Invalid memory resource\n");
+                goto out_free;
+        }
+
+        info->mem[0].size = regs->end - regs->start + 1;
+        info->mem[0].internal_addr = ioremap(regs->start, info->mem[0].size);
+
+        if (!info->mem[0].internal_addr) {
+                dev_err(&dev->dev, "Can't remap memory address range\n");
+                goto out_free;
+        }
+
+        info->mem[0].memtype = UIO_MEM_PHYS;
+
+        info->name = "smx-ce";
+        info->version = "0.03";
+
+        info->irq = platform_get_irq(dev, 0);
+        if (info->irq < 0) {
+                ret = info->irq;
+                dev_err(&dev->dev, "No (or invalid) IRQ resource specified\n");
+                goto out_unmap;
+        }
+
+        info->irq_flags = IRQF_SHARED;
+        info->handler = smx_handler;
+
+        platform_set_drvdata(dev, info);
+
+        ret = uio_register_device(&dev->dev, info);
+
+        if (ret)
+                goto out_unmap;
+
+        return 0;
+
+out_unmap:
+        iounmap(info->mem[0].internal_addr);
+out_free:
+        kfree(info);
+
+        return ret;
+}
+
+static int __devexit smx_ce_remove(struct platform_device *dev)
+{
+        struct uio_info *info = platform_get_drvdata(dev);
+
+        uio_unregister_device(info);
+        platform_set_drvdata(dev, NULL);
+        iounmap(info->mem[0].internal_addr);
+
+        kfree(info);
+
+        return 0;
+}
+
+static struct platform_driver smx_ce_driver = {
+        .probe          = smx_ce_probe,
+        .remove         = __devexit_p(smx_ce_remove),
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init smx_ce_init_module(void)
+{
+        return platform_driver_register(&smx_ce_driver);
+}
+module_init(smx_ce_init_module);
+
+static void __exit smx_ce_exit_module(void)
+{
+        platform_driver_unregister(&smx_ce_driver);
+}
+module_exit(smx_ce_exit_module);
+
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("Ben Nizette <bn@niasdigital.com>");
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 03f808c5b79d..6149e4b58c88 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -473,6 +473,10 @@ int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
                 return 0;
         if (IS_ERR(state))      /* I/O error reading the partition table */
                 return -EIO;
+
+        /* tell userspace that the media / partition table may have changed */
+        kobject_uevent(&disk->dev.kobj, KOBJ_CHANGE);
+
         for (p = 1; p < state->limit; p++) {
                 sector_t size = state->parts[p].size;
                 sector_t from = state->parts[p].from;
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 4948d9bc405d..a1c3a1fab7f0 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -20,6 +20,7 @@
 #include <linux/idr.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include "sysfs.h"
 
 DEFINE_MUTEX(sysfs_mutex);
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index baa663e69388..ade9a7e6a757 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/kallsyms.h>
+#include <linux/slab.h>
 #include <linux/namei.h>
 #include <linux/poll.h>
 #include <linux/list.h>
@@ -128,7 +129,7 @@ sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         ssize_t retval = 0;
 
         mutex_lock(&buffer->mutex);
-        if (buffer->needs_read_fill) {
+        if (buffer->needs_read_fill || *ppos == 0) {
                 retval = fill_read_buffer(file->f_path.dentry,buffer);
                 if (retval)
                         goto out;
@@ -409,8 +410,7 @@ static int sysfs_release(struct inode *inode, struct file *filp)
  * return POLLERR|POLLPRI, and select will return the fd whether
  * it is waiting for read, write, or exceptions.
  * Once poll/select indicates that the value has changed, you
- * need to close and re-open the file, as simply seeking and reading
- * again will not get new data, or reset the state of 'poll'.
+ * need to close and re-open the file, or seek to 0 and read again.
  * Reminder: this only works for attributes which actively support
  * it, and it is not possible to test an attribute from userspace
  * to see if it supports poll (Neither 'poll' nor 'select' return
diff --git a/include/linux/attribute_container.h b/include/linux/attribute_container.h
index 574b201b99d8..794ad74b1d61 100644
--- a/include/linux/attribute_container.h
+++ b/include/linux/attribute_container.h
@@ -1,5 +1,5 @@
 /*
- * class_container.h - a generic container for all classes
+ * attribute_container.h - a generic container for all classes
  *
  * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
  *
@@ -18,7 +18,7 @@ struct attribute_container {
         struct klist            containers;
         struct class            *class;
         struct attribute_group  *grp;
-        struct class_device_attribute **attrs;
+        struct device_attribute **attrs;
         int (*match)(struct attribute_container *, struct device *);
 #define ATTRIBUTE_CONTAINER_NO_CLASSDEVS        0x01
         unsigned long           flags;
@@ -41,31 +41,31 @@ int __must_check attribute_container_unregister(struct attribute_container *cont
 void attribute_container_create_device(struct device *dev,
                                        int (*fn)(struct attribute_container *,
                                                  struct device *,
-                                                 struct class_device *));
+                                                 struct device *));
 void attribute_container_add_device(struct device *dev,
                                     int (*fn)(struct attribute_container *,
                                               struct device *,
-                                              struct class_device *));
+                                              struct device *));
 void attribute_container_remove_device(struct device *dev,
                                        void (*fn)(struct attribute_container *,
                                                   struct device *,
-                                                  struct class_device *));
+                                                  struct device *));
 void attribute_container_device_trigger(struct device *dev, 
                                         int (*fn)(struct attribute_container *,
                                                   struct device *,
-                                                  struct class_device *));
+                                                  struct device *));
 void attribute_container_trigger(struct device *dev, 
                                  int (*fn)(struct attribute_container *,
                                            struct device *));
-int attribute_container_add_attrs(struct class_device *classdev);
-int attribute_container_add_class_device(struct class_device *classdev);
+int attribute_container_add_attrs(struct device *classdev);
+int attribute_container_add_class_device(struct device *classdev);
 int attribute_container_add_class_device_adapter(struct attribute_container *cont,
                                                  struct device *dev,
-                                                 struct class_device *classdev);
-void attribute_container_remove_attrs(struct class_device *classdev);
-void attribute_container_class_device_del(struct class_device *classdev);
-struct attribute_container *attribute_container_classdev_to_container(struct class_device *);
-struct class_device *attribute_container_find_class_device(struct attribute_container *, struct device *);
-struct class_device_attribute **attribute_container_classdev_to_attrs(const struct class_device *classdev);
+                                                 struct device *classdev);
+void attribute_container_remove_attrs(struct device *classdev);
+void attribute_container_class_device_del(struct device *classdev);
+struct attribute_container *attribute_container_classdev_to_container(struct device *);
+struct device *attribute_container_find_class_device(struct attribute_container *, struct device *);
+struct device_attribute **attribute_container_classdev_to_attrs(const struct device *classdev);
 
 #endif
diff --git a/include/linux/bsg.h b/include/linux/bsg.h
index 60e377b520f8..e8406c55c6d3 100644
--- a/include/linux/bsg.h
+++ b/include/linux/bsg.h
@@ -55,7 +55,7 @@ struct sg_io_v4 {
 
 #if defined(CONFIG_BLK_DEV_BSG)
 struct bsg_class_device {
-        struct class_device *class_dev;
+        struct device *class_dev;
         struct device *dev;
         int minor;
         struct request_queue *queue;
diff --git a/include/linux/device.h b/include/linux/device.h
index c79b93e56fa0..1a060265acea 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -429,7 +429,6 @@ struct device {
         struct kobject kobj;
         char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
         struct device_type      *type;
-        unsigned                is_registered:1;
         unsigned                uevent_suppress:1;
 
         struct semaphore        sem;    /* semaphore to synchronize calls to
@@ -475,6 +474,9 @@ struct device {
         void    (*release)(struct device *dev);
 };
 
+/* Get the wakeup routines, which depend on struct device */
+#include <linux/pm_wakeup.h>
+
 #ifdef CONFIG_NUMA
 static inline int dev_to_node(struct device *dev)
 {
@@ -506,7 +508,7 @@ static inline void dev_set_drvdata(struct device *dev, void *data)
 
 static inline int device_is_registered(struct device *dev)
 {
-        return dev->is_registered;
+        return dev->kobj.state_in_sysfs;
 }
 
 void driver_init(void);
@@ -543,20 +545,6 @@ extern struct device *device_create(struct class *cls, struct device *parent,
                                     dev_t devt, const char *fmt, ...)
                                     __attribute__((format(printf, 4, 5)));
 extern void device_destroy(struct class *cls, dev_t devt);
-#ifdef CONFIG_PM_SLEEP
-extern void destroy_suspended_device(struct class *cls, dev_t devt);
-extern void device_pm_schedule_removal(struct device *);
-#else /* !CONFIG_PM_SLEEP */
-static inline void destroy_suspended_device(struct class *cls, dev_t devt)
-{
-        device_destroy(cls, devt);
-}
-
-static inline void device_pm_schedule_removal(struct device *dev)
-{
-        device_unregister(dev);
-}
-#endif /* !CONFIG_PM_SLEEP */
 
 /*
  * Platform "fixup" functions - allow the platform to have their say
@@ -608,21 +596,16 @@ extern const char *dev_driver_string(struct device *dev);
 #define dev_dbg(dev, format, arg...)            \
         dev_printk(KERN_DEBUG , dev , format , ## arg)
 #else
-static inline int __attribute__ ((format (printf, 2, 3)))
-dev_dbg(struct device *dev, const char *fmt, ...)
-{
-        return 0;
-}
+#define dev_dbg(dev, format, arg...)            \
+        ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
 #endif
 
 #ifdef VERBOSE_DEBUG
 #define dev_vdbg        dev_dbg
 #else
-static inline int __attribute__ ((format (printf, 2, 3)))
-dev_vdbg(struct device *dev, const char *fmt, ...)
-{
-        return 0;
-}
+
+#define dev_vdbg(dev, format, arg...)           \
+        ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
 #endif
 
 /* Create alias, so I can be autoloaded. */
diff --git a/include/linux/enclosure.h b/include/linux/enclosure.h
index a5978f18ca40..4332442b1b57 100644
--- a/include/linux/enclosure.h
+++ b/include/linux/enclosure.h
@@ -82,7 +82,8 @@ struct enclosure_component_callbacks {
 
 struct enclosure_component {
         void *scratch;
-        struct class_device cdev;
+        struct device cdev;
+        struct device *dev;
         enum enclosure_component_type type;
         int number;
         int fault;
@@ -94,20 +95,20 @@ struct enclosure_component {
 struct enclosure_device {
         void *scratch;
         struct list_head node;
-        struct class_device cdev;
+        struct device edev;
         struct enclosure_component_callbacks *cb;
         int components;
         struct enclosure_component component[0];
 };
 
 static inline struct enclosure_device *
-to_enclosure_device(struct class_device *dev)
+to_enclosure_device(struct device *dev)
 {
-        return container_of(dev, struct enclosure_device, cdev);
+        return container_of(dev, struct enclosure_device, edev);
 }
 
 static inline struct enclosure_component *
-to_enclosure_component(struct class_device *dev)
+to_enclosure_component(struct device *dev)
 {
         return container_of(dev, struct enclosure_component, cdev);
 }
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 42131820bb89..85d11916e9ea 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -44,15 +44,7 @@ struct hwrng {
 /** Register a new Hardware Random Number Generator driver. */
 extern int hwrng_register(struct hwrng *rng);
 /** Unregister a Hardware Random Number Generator driver. */
-extern void __hwrng_unregister(struct hwrng *rng, bool suspended);
-static inline void hwrng_unregister(struct hwrng *rng)
-{
-        __hwrng_unregister(rng, false);
-}
-static inline void hwrng_unregister_suspended(struct hwrng *rng)
-{
-        __hwrng_unregister(rng, true);
-}
+extern void hwrng_unregister(struct hwrng *rng);
 
 #endif /* __KERNEL__ */
 #endif /* LINUX_HWRANDOM_H_ */
diff --git a/include/linux/iscsi_ibft.h b/include/linux/iscsi_ibft.h
new file mode 100644
index 000000000000..6092487e2950
--- /dev/null
+++ b/include/linux/iscsi_ibft.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2007 Red Hat, Inc.
+ *  by Peter Jones <pjones@redhat.com>
+ *  Copyright 2007 IBM, Inc.
+ *  by Konrad Rzeszutek <konradr@linux.vnet.ibm.com>
+ *  Copyright 2008
+ *  by Konrad Rzeszutek <ketuzsezr@darnok.org>
+ *
+ * This code exposes the iSCSI Boot Format Table to userland via sysfs.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 as published by
+ * the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef ISCSI_IBFT_H
+#define ISCSI_IBFT_H
+
+struct ibft_table_header {
+        char signature[4];
+        u32 length;
+        u8 revision;
+        u8 checksum;
+        char oem_id[6];
+        char oem_table_id[8];
+        char reserved[24];
+} __attribute__((__packed__));
+
+/*
+ * Logical location of iSCSI Boot Format Table.
+ * If the value is NULL there is no iBFT on the machine.
+ */
+extern struct ibft_table_header *ibft_addr;
+
+/*
+ * Routine used to find and reserve the iSCSI Boot Format Table. The
+ * mapped address is set in the ibft_addr variable.
+ */
+#ifdef CONFIG_ISCSI_IBFT_FIND
+extern void __init reserve_ibft_region(void);
+#else
+static inline void reserve_ibft_region(void) { }
+#endif
+
+#endif /* ISCSI_IBFT_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 2df44e773270..cd6d02cf854d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -293,10 +293,8 @@ extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
 #define pr_debug(fmt, arg...) \
         printk(KERN_DEBUG fmt, ##arg)
 #else
-static inline int __attribute__ ((format (printf, 1, 2))) pr_debug(const char * fmt, ...)
-{
-        return 0;
-}
+#define pr_debug(fmt, arg...) \
+        ({ if (0) printk(KERN_DEBUG fmt, ##arg); 0; })
 #endif
 
 /*
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 0201f6f51cea..b07e3d400bd6 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -59,15 +59,7 @@ struct led_classdev {
 
 extern int led_classdev_register(struct device *parent,
                                  struct led_classdev *led_cdev);
-extern void __led_classdev_unregister(struct led_classdev *led_cdev, bool sus);
-static inline void led_classdev_unregister(struct led_classdev *lcd)
-{
-        __led_classdev_unregister(lcd, false);
-}
-static inline void led_classdev_unregister_suspended(struct led_classdev *lcd)
-{
-        __led_classdev_unregister(lcd, true);
-}
+extern void led_classdev_unregister(struct led_classdev *lcd);
 extern void led_classdev_suspend(struct led_classdev *led_cdev);
 extern void led_classdev_resume(struct led_classdev *led_cdev);
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 165734a2dd47..07ed56f7a767 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -443,7 +443,7 @@ enum link_pm {
         MAX_PERFORMANCE,
         MEDIUM_POWER,
 };
-extern struct class_device_attribute class_device_attr_link_power_management_policy;
+extern struct device_attribute dev_attr_link_power_management_policy;
 
 #ifdef CONFIG_ATA_SFF
 struct ata_ioports {
diff --git a/include/linux/memory.h b/include/linux/memory.h
index 54d7866d9c0e..f80e0e331cb7 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -18,7 +18,7 @@
 #include <linux/sysdev.h>
 #include <linux/node.h>
 #include <linux/compiler.h>
-#include <linux/semaphore.h>
+#include <linux/mutex.h>
 
 struct memory_block {
         unsigned long phys_index;
@@ -29,7 +29,7 @@ struct memory_block {
          * created long after the critical areas during
          * initialization.
          */
-        struct semaphore state_sem;
+        struct mutex state_mutex;
         int phys_device;                /* to which fru does this belong? */
         void *hw;                       /* optional pointer to fw/hw data */
         int (*phys_callback)(struct memory_block *);
diff --git a/include/linux/memstick.h b/include/linux/memstick.h
index 3e686ec6a967..37a5cdb03918 100644
--- a/include/linux/memstick.h
+++ b/include/linux/memstick.h
@@ -276,7 +276,7 @@ struct memstick_host {
 #define MEMSTICK_CAP_PAR8          4
 
         struct work_struct  media_checker;
-        struct class_device cdev;
+        struct device       dev;
 
         struct memstick_dev *card;
         unsigned int        retries;
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 24b30b9b4f8a..26433ec520b3 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -43,15 +43,7 @@ struct miscdevice  {
 };
 
 extern int misc_register(struct miscdevice * misc);
-extern int __misc_deregister(struct miscdevice *misc, bool suspended);
-static inline int misc_deregister(struct miscdevice *misc)
-{
-        return __misc_deregister(misc, false);
-}
-static inline int misc_deregister_suspended(struct miscdevice *misc)
-{
-        return __misc_deregister(misc, true);
-}
+extern int misc_deregister(struct miscdevice *misc);
 
 #define MODULE_ALIAS_MISCDEV(minor)                             \
         MODULE_ALIAS("char-major-" __stringify(MISC_MAJOR)      \
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 015b735811b4..1de72cbbe0d1 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -183,8 +183,9 @@ typedef struct pm_message {
 struct dev_pm_info {
         pm_message_t            power_state;
         unsigned                can_wakeup:1;
-#ifdef  CONFIG_PM_SLEEP
         unsigned                should_wakeup:1;
+        bool                    sleeping:1;     /* Owned by the PM core */
+#ifdef  CONFIG_PM_SLEEP
         struct list_head        entry;
 #endif
 };
@@ -197,11 +198,6 @@ extern void device_resume(void);
 extern int device_suspend(pm_message_t state);
 extern int device_prepare_suspend(pm_message_t state);
 
-#define device_set_wakeup_enable(dev,val) \
-        ((dev)->power.should_wakeup = !!(val))
-#define device_may_wakeup(dev) \
-        (device_can_wakeup(dev) && (dev)->power.should_wakeup)
-
 extern void __suspend_report_result(const char *function, void *fn, int ret);
 
 #define suspend_report_result(fn, ret)                                  \
@@ -209,20 +205,6 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
                 __suspend_report_result(__FUNCTION__, fn, ret);         \
         } while (0)
 
-/*
- * Platform hook to activate device wakeup capability, if that's not already
- * handled by enable_irq_wake() etc.
- * Returns zero on success, else negative errno
- */
-extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
-
-static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
-{
-        if (platform_enable_wakeup)
-                return (*platform_enable_wakeup)(dev, is_on);
-        return 0;
-}
-
 #else /* !CONFIG_PM_SLEEP */
 
 static inline int device_suspend(pm_message_t state)
@@ -230,29 +212,10 @@ static inline int device_suspend(pm_message_t state)
         return 0;
 }
 
-#define device_set_wakeup_enable(dev,val)       do{}while(0)
-#define device_may_wakeup(dev)                  (0)
-
-#define suspend_report_result(fn, ret) do { } while (0)
-
-static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
-{
-        return 0;
-}
+#define suspend_report_result(fn, ret)          do {} while (0)
 
 #endif /* !CONFIG_PM_SLEEP */
 
-/* changes to device_may_wakeup take effect on the next pm state change.
- * by default, devices should wakeup if they can.
- */
-#define device_can_wakeup(dev) \
-        ((dev)->power.can_wakeup)
-#define device_init_wakeup(dev,val) \
-        do { \
-                device_can_wakeup(dev) = !!(val); \
-                device_set_wakeup_enable(dev,val); \
-        } while(0)
-
 /*
  * Global Power Management flags
  * Used to keep APM and ACPI from both being active
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
new file mode 100644
index 000000000000..f0d0b2cb8d20
--- /dev/null
+++ b/include/linux/pm_wakeup.h
@@ -0,0 +1,90 @@
+/*
+ *  pm_wakeup.h - Power management wakeup interface
+ *
+ *  Copyright (C) 2008 Alan Stern
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_PM_WAKEUP_H
+#define _LINUX_PM_WAKEUP_H
+
+#ifndef _DEVICE_H_
+# error "please don't include this file directly"
+#endif
+
+#ifdef CONFIG_PM
+
+/* changes to device_may_wakeup take effect on the next pm state change.
+ * by default, devices should wakeup if they can.
+ */
+static inline void device_init_wakeup(struct device *dev, int val)
+{
+        dev->power.can_wakeup = dev->power.should_wakeup = !!val;
+}
+
+static inline int device_can_wakeup(struct device *dev)
+{
+        return dev->power.can_wakeup;
+}
+
+static inline void device_set_wakeup_enable(struct device *dev, int val)
+{
+        dev->power.should_wakeup = !!val;
+}
+
+static inline int device_may_wakeup(struct device *dev)
+{
+        return dev->power.can_wakeup & dev->power.should_wakeup;
+}
+
+/*
+ * Platform hook to activate device wakeup capability, if that's not already
+ * handled by enable_irq_wake() etc.
+ * Returns zero on success, else negative errno
+ */
+extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
+
+static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
+{
+        if (platform_enable_wakeup)
+                return (*platform_enable_wakeup)(dev, is_on);
+        return 0;
+}
+
+#else /* !CONFIG_PM */
+
+/* For some reason the next two routines work even without CONFIG_PM */
+static inline void device_init_wakeup(struct device *dev, int val)
+{
+        dev->power.can_wakeup = !!val;
+}
+
+static inline int device_can_wakeup(struct device *dev)
+{
+        return dev->power.can_wakeup;
+}
+
+#define device_set_wakeup_enable(dev, val)      do {} while (0)
+#define device_may_wakeup(dev)                  0
+
+static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
+{
+        return 0;
+}
+
+#endif /* !CONFIG_PM */
+
+#endif /* _LINUX_PM_WAKEUP_H */
diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
index d22ad392242a..6b537f1ac96c 100644
--- a/include/linux/raid_class.h
+++ b/include/linux/raid_class.h
@@ -53,20 +53,20 @@ struct raid_data {
 #define DEFINE_RAID_ATTRIBUTE(type, attr)                                     \
 static inline void                                                            \
 raid_set_##attr(struct raid_template *r, struct device *dev, type value) {    \
-        struct class_device *cdev =                                           \
+        struct device *device =                                               \
                 attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
         struct raid_data *rd;                                                 \
-        BUG_ON(!cdev);                                                        \
-        rd = class_get_devdata(cdev);                                         \
+        BUG_ON(!device);                                                      \
+        rd = dev_get_drvdata(device);                                         \
         rd->attr = value;                                                     \
 }                                                                             \
 static inline type                                                            \
 raid_get_##attr(struct raid_template *r, struct device *dev) {                \
-        struct class_device *cdev =                                           \
+        struct device *device =                                               \
                 attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
         struct raid_data *rd;                                                 \
-        BUG_ON(!cdev);                                                        \
-        rd = class_get_devdata(cdev);                                         \
+        BUG_ON(!device);                                                      \
+        rd = dev_get_drvdata(device);                                         \
         return rd->attr;                                                      \
 }
 
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 802710438a9e..03378e3515b3 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -131,7 +131,6 @@ static inline int sysfs_create_dir(struct kobject *kobj)
 
 static inline void sysfs_remove_dir(struct kobject *kobj)
 {
-        ;
 }
 
 static inline int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
@@ -160,7 +159,6 @@ static inline int sysfs_chmod_file(struct kobject *kobj,
 static inline void sysfs_remove_file(struct kobject *kobj,
                                      const struct attribute *attr)
 {
-        ;
 }
 
 static inline int sysfs_create_bin_file(struct kobject *kobj,
@@ -169,10 +167,9 @@ static inline int sysfs_create_bin_file(struct kobject *kobj,
         return 0;
 }
 
-static inline int sysfs_remove_bin_file(struct kobject *kobj,
-                                        struct bin_attribute *attr)
+static inline void sysfs_remove_bin_file(struct kobject *kobj,
+                                         struct bin_attribute *attr)
 {
-        return 0;
 }
 
 static inline int sysfs_create_link(struct kobject *kobj,
@@ -183,7 +180,6 @@ static inline int sysfs_create_link(struct kobject *kobj,
 
 static inline void sysfs_remove_link(struct kobject *kobj, const char *name)
 {
-        ;
 }
 
 static inline int sysfs_create_group(struct kobject *kobj,
@@ -195,7 +191,6 @@ static inline int sysfs_create_group(struct kobject *kobj,
 static inline void sysfs_remove_group(struct kobject *kobj,
                                       const struct attribute_group *grp)
 {
-        ;
 }
 
 static inline int sysfs_add_file_to_group(struct kobject *kobj,
diff --git a/include/linux/transport_class.h b/include/linux/transport_class.h
index 6696cf79c4f7..eaec1ea9558e 100644
--- a/include/linux/transport_class.h
+++ b/include/linux/transport_class.h
@@ -17,11 +17,11 @@ struct transport_container;
 struct transport_class {
         struct class class;
         int (*setup)(struct transport_container *, struct device *,
-                     struct class_device *);
+                     struct device *);
         int (*configure)(struct transport_container *, struct device *,
-                         struct class_device *);
+                         struct device *);
         int (*remove)(struct transport_container *, struct device *,
-                      struct class_device *);
+                      struct device *);
 };
 
 #define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg)                   \
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 95bf4bac44cb..2dcbecce3f61 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -1051,7 +1051,7 @@ struct ib_device {
         struct ib_dma_mapping_ops   *dma_ops;
 
         struct module               *owner;
-        struct class_device          class_dev;
+        struct device                dev;
         struct kobject               *ports_parent;
         struct list_head             port_list;
 
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index ab7acbe80960..b8b19e2f57bb 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -156,8 +156,8 @@ struct scsi_device {
 
         int timeout;
 
-        struct device           sdev_gendev;
-        struct class_device     sdev_classdev;
+        struct device           sdev_gendev,
+                                sdev_dev;
 
         struct execute_work     ew; /* used to get process context on put */
 
@@ -167,9 +167,9 @@ struct scsi_device {
 #define to_scsi_device(d)       \
         container_of(d, struct scsi_device, sdev_gendev)
 #define class_to_sdev(d)        \
-        container_of(d, struct scsi_device, sdev_classdev)
+        container_of(d, struct scsi_device, sdev_dev)
 #define transport_class_to_sdev(class_dev) \
-        to_scsi_device(class_dev->dev)
+        to_scsi_device(class_dev->parent)
 
 #define sdev_printk(prefix, sdev, fmt, a...)    \
         dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
@@ -220,7 +220,7 @@ static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
         return to_scsi_target(sdev->sdev_gendev.parent);
 }
 #define transport_class_to_starget(class_dev) \
-        to_scsi_target(class_dev->dev)
+        to_scsi_target(class_dev->parent)
 
 #define starget_printk(prefix, starget, fmt, a...)      \
         dev_printk(prefix, &(starget)->dev, fmt, ##a)
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 49132862bfaa..d967d6dc7a28 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -470,7 +470,7 @@ struct scsi_host_template {
         /*
          * Pointer to the sysfs class properties for this host, NULL terminated.
          */
-        struct class_device_attribute **shost_attrs;
+        struct device_attribute **shost_attrs;
 
         /*
          * Pointer to the SCSI device properties for this host, NULL terminated.
@@ -655,8 +655,7 @@ struct Scsi_Host {
         enum scsi_host_state shost_state;
 
         /* ldm bits */
-        struct device           shost_gendev;
-        struct class_device     shost_classdev;
+        struct device           shost_gendev, shost_dev;
 
         /*
          * List of hosts per template.
@@ -683,7 +682,7 @@ struct Scsi_Host {
 };
 
 #define         class_to_shost(d)       \
-        container_of(d, struct Scsi_Host, shost_classdev)
+        container_of(d, struct Scsi_Host, shost_dev)
 
 #define shost_printk(prefix, shost, fmt, a...)  \
         dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
diff --git a/include/scsi/scsi_transport.h b/include/scsi/scsi_transport.h
index 0dfef752f0e2..490bd13a634c 100644
--- a/include/scsi/scsi_transport.h
+++ b/include/scsi/scsi_transport.h
@@ -80,7 +80,7 @@ struct scsi_transport_template {
 };
 
 #define transport_class_to_shost(tc) \
-        dev_to_shost((tc)->dev)
+        dev_to_shost((tc)->parent)
 
 
 /* Private area maintenance. The driver requested allocations come
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 4769efd4db24..06f72bab9df0 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -163,8 +163,8 @@ enum fc_tgtid_binding_type  {
 
 
 /* Macro for use in defining Virtual Port attributes */
-#define FC_VPORT_ATTR(_name,_mode,_show,_store)                         \
-struct class_device_attribute class_device_attr_vport_##_name =         \
+#define FC_VPORT_ATTR(_name,_mode,_show,_store)         \
+struct device_attribute dev_attr_vport_##_name =        \
         __ATTR(_name,_mode,_show,_store)
 
 
@@ -234,8 +234,8 @@ struct fc_vport {
 
 #define dev_to_vport(d)                         \
         container_of(d, struct fc_vport, dev)
-#define transport_class_to_vport(classdev)      \
-        dev_to_vport(classdev->dev)
+#define transport_class_to_vport(dev)           \
+        dev_to_vport(dev->parent)
 #define vport_to_shost(v)                       \
         (v->shost)
 #define vport_to_shost_channel(v)               \
@@ -271,7 +271,7 @@ struct fc_rport_identifiers {
 
 /* Macro for use in defining Remote Port attributes */
 #define FC_RPORT_ATTR(_name,_mode,_show,_store)                         \
-struct class_device_attribute class_device_attr_rport_##_name =         \
+struct device_attribute dev_attr_rport_##_name =        \
         __ATTR(_name,_mode,_show,_store)
 
 
@@ -341,8 +341,8 @@ struct fc_rport {	/* aka fc_starget_attrs */
 
 #define dev_to_rport(d)                         \
         container_of(d, struct fc_rport, dev)
-#define transport_class_to_rport(classdev)      \
-        dev_to_rport(classdev->dev)
+#define transport_class_to_rport(dev)   \
+        dev_to_rport(dev->parent)
 #define rport_to_shost(r)                       \
         dev_to_shost(r->dev.parent)
 
diff --git a/include/scsi/scsi_transport_sas.h b/include/scsi/scsi_transport_sas.h
index 09125fa95b93..61ad3594aad6 100644
--- a/include/scsi/scsi_transport_sas.h
+++ b/include/scsi/scsi_transport_sas.h
@@ -80,8 +80,8 @@ struct sas_phy {
 
 #define dev_to_phy(d) \
         container_of((d), struct sas_phy, dev)
-#define transport_class_to_phy(cdev) \
-        dev_to_phy((cdev)->dev)
+#define transport_class_to_phy(dev) \
+        dev_to_phy((dev)->parent)
 #define phy_to_shost(phy) \
         dev_to_shost((phy)->dev.parent)
 
@@ -96,8 +96,8 @@ struct sas_rphy {
 
 #define dev_to_rphy(d) \
         container_of((d), struct sas_rphy, dev)
-#define transport_class_to_rphy(cdev) \
-        dev_to_rphy((cdev)->dev)
+#define transport_class_to_rphy(dev) \
+        dev_to_rphy((dev)->parent)
 #define rphy_to_shost(rphy) \
         dev_to_shost((rphy)->dev.parent)
 #define target_to_rphy(targ) \
@@ -152,8 +152,8 @@ struct sas_port {
 
 #define dev_to_sas_port(d) \
         container_of((d), struct sas_port, dev)
-#define transport_class_to_sas_port(cdev) \
-        dev_to_sas_port((cdev)->dev)
+#define transport_class_to_sas_port(dev) \
+        dev_to_sas_port((dev)->parent)
 
 struct sas_phy_linkrates {
         enum sas_linkrate maximum_linkrate;
diff --git a/include/scsi/sd.h b/include/scsi/sd.h
index 8ea9f7358ac1..4f032d48cb6e 100644
--- a/include/scsi/sd.h
+++ b/include/scsi/sd.h
@@ -34,7 +34,7 @@
 struct scsi_disk {
         struct scsi_driver *driver;     /* always &sd_template */
         struct scsi_device *device;
-        struct class_device cdev;
+        struct device   dev;
         struct gendisk  *disk;
         unsigned int    openers;        /* protected by BKL for now, yuck */
         sector_t        capacity;       /* size in 512-byte sectors */
@@ -46,7 +46,7 @@ struct scsi_disk {
         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
 };
-#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,cdev)
+#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
 
 #define sd_printk(prefix, sdsk, fmt, a...)                              \
         (sdsk)->disk ?                                                  \
diff --git a/lib/kobject.c b/lib/kobject.c
index 0d03252f87a8..2c6490370922 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -58,11 +58,6 @@ static int create_dir(struct kobject *kobj)
         return error;
 }
 
-static inline struct kobject *to_kobj(struct list_head *entry)
-{
-        return container_of(entry, struct kobject, entry);
-}
-
 static int get_kobj_path_length(struct kobject *kobj)
 {
         int length = 1;
@@ -592,8 +587,15 @@ static void kobject_release(struct kref *kref)
  */
 void kobject_put(struct kobject *kobj)
 {
-        if (kobj)
+        if (kobj) {
+                if (!kobj->state_initialized) {
+                        printk(KERN_WARNING "kobject: '%s' (%p): is not "
+                               "initialized, yet kobject_put() is being "
+                               "called.\n", kobject_name(kobj), kobj);
+                        WARN_ON(1);
+                }
                 kref_put(&kobj->kref, kobject_release);
+        }
 }
 
 static void dynamic_kobj_release(struct kobject *kobj)
@@ -745,12 +747,11 @@ void kset_unregister(struct kset *k)
  */
 struct kobject *kset_find_obj(struct kset *kset, const char *name)
 {
-        struct list_head *entry;
+        struct kobject *k;
         struct kobject *ret = NULL;
 
         spin_lock(&kset->list_lock);
-        list_for_each(entry, &kset->list) {
-                struct kobject *k = to_kobj(entry);
+        list_for_each_entry(k, &kset->list, entry) {
                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
                         ret = kobject_get(k);
                         break;
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 7469c503580d..0fb330271271 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -208,7 +208,7 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
         /*
          * This doesn't need a lock to do pfn_to_page().
          * The section can't be removed here because of the
-         * memory_block->state_sem.
+         * memory_block->state_mutex.
          */
         zone = page_zone(pfn_to_page(pfn));
         pgdat_resize_lock(zone->zone_pgdat, &flags);
diff --git a/Documentation/firmware_class/firmware_sample_driver.c b/samples/firmware_class/firmware_sample_driver.c
index 6865cbe075ec..165cff98032e 100644
--- a/Documentation/firmware_class/firmware_sample_driver.c
+++ b/samples/firmware_class/firmware_sample_driver.c
@@ -12,8 +12,7 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/string.h>
-
-#include "linux/firmware.h"
+#include <linux/firmware.h>
 
 static struct device ghost_device = {
         .bus_id    = "ghost0",
@@ -31,38 +30,44 @@ static void sample_firmware_load(char *firmware, int size)
 static void sample_probe_default(void)
 {
         /* uses the default method to get the firmware */
-        const struct firmware *fw_entry;
-        printk(KERN_INFO "firmware_sample_driver: a ghost device got inserted :)\n");
+        const struct firmware *fw_entry;
+        int retval;
+
+        printk(KERN_INFO "firmware_sample_driver: "
+                "a ghost device got inserted :)\n");
 
-        if(request_firmware(&fw_entry, "sample_driver_fw", &ghost_device)!=0)
-        {
+        retval = request_firmware(&fw_entry, "sample_driver_fw", &ghost_device);
+        if (retval) {
                 printk(KERN_ERR
                        "firmware_sample_driver: Firmware not available\n");
                 return;
         }
-        
+
         sample_firmware_load(fw_entry->data, fw_entry->size);
 
         release_firmware(fw_entry);
 
         /* finish setting up the device */
 }
+
 static void sample_probe_specific(void)
 {
+        int retval;
         /* Uses some specific hotplug support to get the firmware from
          * userspace  directly into the hardware, or via some sysfs file */
 
         /* NOTE: This currently doesn't work */
 
-        printk(KERN_INFO "firmware_sample_driver: a ghost device got inserted :)\n");
+        printk(KERN_INFO "firmware_sample_driver: "
+                "a ghost device got inserted :)\n");
 
-        if(request_firmware(NULL, "sample_driver_fw", &ghost_device)!=0)
-        {
+        retval = request_firmware(NULL, "sample_driver_fw", &ghost_device);
+        if (retval) {
                 printk(KERN_ERR
                        "firmware_sample_driver: Firmware load failed\n");
                 return;
         }
-        
+
         /* request_firmware blocks until userspace finished, so at
          * this point the firmware should be already in the device */
 
@@ -70,7 +75,7 @@ static void sample_probe_specific(void)
 }
 static void sample_probe_async_cont(const struct firmware *fw, void *context)
 {
-        if(!fw){
+        if (!fw) {
                 printk(KERN_ERR
                        "firmware_sample_driver: firmware load failed\n");
                 return;
@@ -80,19 +85,18 @@ static void sample_probe_async_cont(const struct firmware *fw, void *context)
                (char *)context);
         sample_firmware_load(fw->data, fw->size);
 }
+
 static void sample_probe_async(void)
 {
         /* Let's say that I can't sleep */
         int error;
-        error = request_firmware_nowait (THIS_MODULE, FW_ACTION_NOHOTPLUG,
-                                         "sample_driver_fw", &ghost_device,
-                                         "my device pointer",
-                                         sample_probe_async_cont);
-        if(error){
-                printk(KERN_ERR 
-                       "firmware_sample_driver:"
+        error = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
+                                        "sample_driver_fw", &ghost_device,
+                                        "my device pointer",
+                                        sample_probe_async_cont);
+        if (error)
+                printk(KERN_ERR "firmware_sample_driver:"
                        " request_firmware_nowait failed\n");
-        }
 }
 
 static int sample_init(void)
@@ -105,11 +109,12 @@ static int sample_init(void)
         sample_probe_async();
         return 0;
 }
+
 static void __exit sample_exit(void)
 {
 }
 
-module_init (sample_init);
-module_exit (sample_exit);
+module_init(sample_init);
+module_exit(sample_exit);
 
 MODULE_LICENSE("GPL");
diff --git a/Documentation/firmware_class/firmware_sample_firmware_class.c b/samples/firmware_class/firmware_sample_firmware_class.c
index 2de62854f0e5..9392116e47b0 100644
--- a/Documentation/firmware_class/firmware_sample_firmware_class.c
+++ b/samples/firmware_class/firmware_sample_firmware_class.c
@@ -25,30 +25,27 @@ MODULE_LICENSE("GPL");
 
 static inline struct class_device *to_class_dev(struct kobject *obj)
 {
-        return container_of(obj,struct class_device,kobj);
+        return container_of(obj, struct class_device, kobj);
 }
+
 static inline
 struct class_device_attribute *to_class_dev_attr(struct attribute *_attr)
 {
-        return container_of(_attr,struct class_device_attribute,attr);
+        return container_of(_attr, struct class_device_attribute, attr);
 }
 
-int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr);
-int sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr);
-
 struct firmware_priv {
         char fw_id[FIRMWARE_NAME_MAX];
         s32 loading:2;
         u32 abort:1;
 };
 
-extern struct class firmware_class;
-
 static ssize_t firmware_loading_show(struct class_device *class_dev, char *buf)
 {
         struct firmware_priv *fw_priv = class_get_devdata(class_dev);
         return sprintf(buf, "%d\n", fw_priv->loading);
 }
+
 static ssize_t firmware_loading_store(struct class_device *class_dev,
                                       const char *buf, size_t count)
 {
@@ -56,8 +53,8 @@ static ssize_t firmware_loading_store(struct class_device *class_dev,
         int prev_loading = fw_priv->loading;
 
         fw_priv->loading = simple_strtol(buf, NULL, 10);
-        
-        switch(fw_priv->loading){
+
+        switch (fw_priv->loading) {
         case -1:
                 /* abort load an panic */
                 break;
@@ -65,7 +62,7 @@ static ssize_t firmware_loading_store(struct class_device *class_dev,
                 /* setup load */
                 break;
         case 0:
-                if(prev_loading==1){
+                if (prev_loading == 1) {
                         /* finish load and get the device back to working
                          * state */
                 }
@@ -130,29 +127,29 @@ static int fw_setup_class_device(struct class_device *class_dev,
         class_dev->class = &firmware_class,
         class_set_devdata(class_dev, fw_priv);
         retval = class_device_register(class_dev);
-        if (retval){
+        if (retval) {
                 printk(KERN_ERR "%s: class_device_register failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_free_fw_priv;
         }
 
         retval = sysfs_create_bin_file(&class_dev->kobj, &firmware_attr_data);
-        if (retval){
+        if (retval) {
                 printk(KERN_ERR "%s: sysfs_create_bin_file failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_unreg_class_dev;
         }
 
         retval = class_device_create_file(class_dev,
                                           &class_device_attr_loading);
-        if (retval){
+        if (retval) {
                 printk(KERN_ERR "%s: class_device_create_file failed\n",
-                       __FUNCTION__);
+                       __func__);
                 goto error_remove_data;
         }
 
         goto out;
-        
+
 error_remove_data:
         sysfs_remove_bin_file(&class_dev->kobj, &firmware_attr_data);
 error_unreg_class_dev:
@@ -183,16 +180,16 @@ static int __init firmware_sample_init(void)
 
         device_initialize(&my_device);
         class_dev = kmalloc(sizeof(struct class_device), GFP_KERNEL);
-        if(!class_dev)
+        if (!class_dev)
                 return -ENOMEM;
 
         error = fw_setup_class_device(class_dev, "my_firmware_image",
                                       &my_device);
-        if(error){
+        if (error) {
                 kfree(class_dev);
                 return error;
         }
-        return 0;
+        return 0;
 
 }
 static void __exit firmware_sample_exit(void)
@@ -202,6 +199,6 @@ static void __exit firmware_sample_exit(void)
         kfree(fw_priv);
         kfree(class_dev);
 }
+
 module_init(firmware_sample_init);
 module_exit(firmware_sample_exit);
-
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index 348d8687b7c9..769b69db89c1 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -328,19 +328,52 @@ static int do_pnp_entry(const char *filename,
         return 1;
 }
 
-/* looks like: "pnp:cCdD..." */
-static int do_pnp_card_entry(const char *filename,
-                        struct pnp_card_device_id *id, char *alias)
+/* looks like: "pnp:dD" for every device of the card */
+static void do_pnp_card_entries(void *symval, unsigned long size,
+                                struct module *mod)
 {
-        int i;
+        const unsigned long id_size = sizeof(struct pnp_card_device_id);
+        const unsigned int count = (size / id_size)-1;
+        const struct pnp_card_device_id *cards = symval;
+        unsigned int i;
 
-        sprintf(alias, "pnp:c%s", id->id);
-        for (i = 0; i < PNP_MAX_DEVICES; i++) {
-                if (! *id->devs[i].id)
-                        break;
-                sprintf(alias + strlen(alias), "d%s", id->devs[i].id);
+        device_id_check(mod->name, "pnp", size, id_size, symval);
+
+        for (i = 0; i < count; i++) {
+                unsigned int j;
+                const struct pnp_card_device_id *card = &cards[i];
+
+                for (j = 0; j < PNP_MAX_DEVICES; j++) {
+                        const char *id = (char *)card->devs[j].id;
+                        int i2, j2;
+                        int dup = 0;
+
+                        if (!id[0])
+                                break;
+
+                        /* find duplicate, already added value */
+                        for (i2 = 0; i2 < i && !dup; i2++) {
+                                const struct pnp_card_device_id *card2 = &cards[i2];
+
+                                for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) {
+                                        const char *id2 = (char *)card2->devs[j2].id;
+
+                                        if (!id2[0])
+                                                break;
+
+                                        if (!strcmp(id, id2)) {
+                                                dup = 1;
+                                                break;
+                                        }
+                                }
+                        }
+
+                        /* add an individual alias for every device entry */
+                        if (!dup)
+                                buf_printf(&mod->dev_table_buf,
+                                           "MODULE_ALIAS(\"pnp:d%s*\");\n", id);
+                }
         }
-        return 1;
 }
 
 /* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */
@@ -634,9 +667,7 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
                          sizeof(struct pnp_device_id), "pnp",
                          do_pnp_entry, mod);
         else if (sym_is(symname, "__mod_pnp_card_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct pnp_card_device_id), "pnp_card",
-                         do_pnp_card_entry, mod);
+                do_pnp_card_entries(symval, sym->st_size, mod);
         else if (sym_is(symname, "__mod_pcmcia_device_table"))
                 do_table(symval, sym->st_size,
                          sizeof(struct pcmcia_device_id), "pcmcia",