Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6: (36 commits)
  SCSI: convert struct class_device to struct device
  DRM: remove unused dev_class
  IB: rename "dev" to "srp_dev" in srp_host structure
  IB: convert struct class_device to struct device
  memstick: convert struct class_device to struct device
  driver core: replace remaining __FUNCTION__ occurrences
  sysfs: refill attribute buffer when reading from offset 0
  PM: Remove destroy_suspended_device()
  Firmware: add iSCSI iBFT Support
  PM: Remove legacy PM (fix)
  Kobject: Replace list_for_each() with list_for_each_entry().
  SYSFS: Explicitly include required header file slab.h.
  Driver core: make device_is_registered() work for class devices
  PM: Convert wakeup flag accessors to inline functions
  PM: Make wakeup flags available whenever CONFIG_PM is set
  PM: Fix misuse of wakeup flag accessors in serial core
  Driver core: Call device_pm_add() after bus_add_device() in device_add()
  PM: Handle device registrations during suspend/resume
  block: send disk "change" event for rescan_partitions()
  sysdev: detect multiple driver registrations
  ...

Fixed trivial conflict in include/linux/memory.h due to semaphore header
file change (made irrelevant by the change to mutex).

86 files changed, 3497 insertions, 2071 deletions

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>");