lkml.org 
[lkml]   [2008]   [Apr]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 36/36] SCSI: convert struct class_device to struct device
    Date
    From: Tony Jones <tonyj@suse.de>

    It's big, but there doesn't seem to be a way to split it up smaller...

    Signed-off-by: Tony Jones <tonyj@suse.de>
    Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
    Cc: Roland Dreier <rolandd@cisco.com>
    Cc: Sean Hefty <sean.hefty@intel.com>
    Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
    Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
    ---
    block/bsg.c | 11 +-
    drivers/ata/ahci.c | 4 +-
    drivers/ata/libata-scsi.c | 15 +-
    drivers/base/attribute_container.c | 77 +++---
    drivers/base/transport_class.c | 14 +-
    drivers/infiniband/ulp/srp/ib_srp.c | 132 +++++----
    drivers/infiniband/ulp/srp/ib_srp.h | 2 +-
    drivers/message/fusion/mptscsih.c | 122 +++++----
    drivers/message/fusion/mptscsih.h | 2 +-
    drivers/misc/enclosure.c | 118 +++++----
    drivers/scsi/3w-9xxx.c | 9 +-
    drivers/scsi/3w-xxxx.c | 9 +-
    drivers/scsi/aacraid/aachba.c | 2 +-
    drivers/scsi/aacraid/aacraid.h | 4 +-
    drivers/scsi/aacraid/linit.c | 93 ++++---
    drivers/scsi/arcmsr/arcmsr.h | 4 +-
    drivers/scsi/arcmsr/arcmsr_attr.c | 163 +++++++-----
    drivers/scsi/ch.c | 13 +-
    drivers/scsi/hosts.c | 34 ++--
    drivers/scsi/hptiop.c | 14 +-
    drivers/scsi/ibmvscsi/ibmvscsi.c | 44 ++--
    drivers/scsi/ibmvscsi/ibmvstgt.c | 25 +-
    drivers/scsi/ipr.c | 140 +++++-----
    drivers/scsi/lpfc/lpfc_attr.c | 484 +++++++++++++++++---------------
    drivers/scsi/lpfc/lpfc_crtn.h | 4 +-
    drivers/scsi/megaraid/megaraid_mbox.c | 13 +-
    drivers/scsi/ncr53c8xx.c | 7 +-
    drivers/scsi/osst.c | 76 +++---
    drivers/scsi/pcmcia/sym53c500_cs.c | 14 +-
    drivers/scsi/qla2xxx/qla_attr.c | 177 +++++++------
    drivers/scsi/qla2xxx/qla_gbl.h | 4 +-
    drivers/scsi/raid_class.c | 73 +++---
    drivers/scsi/scsi_sas_internal.h | 24 +-
    drivers/scsi/scsi_sysfs.c | 150 ++++++-----
    drivers/scsi/scsi_transport_fc.c | 385 ++++++++++++++------------
    drivers/scsi/scsi_transport_iscsi.c | 107 ++++----
    drivers/scsi/scsi_transport_sas.c | 157 ++++++-----
    drivers/scsi/scsi_transport_spi.c | 185 +++++++------
    drivers/scsi/scsi_transport_srp.c | 26 +-
    drivers/scsi/sd.c | 78 +++---
    drivers/scsi/ses.c | 28 +-
    drivers/scsi/sg.c | 36 ++--
    drivers/scsi/st.c | 82 +++---
    include/linux/attribute_container.h | 28 +-
    include/linux/bsg.h | 2 +-
    include/linux/enclosure.h | 11 +-
    include/linux/libata.h | 2 +-
    include/linux/raid_class.h | 12 +-
    include/linux/transport_class.h | 6 +-
    include/scsi/scsi_device.h | 10 +-
    include/scsi/scsi_host.h | 7 +-
    include/scsi/scsi_transport.h | 2 +-
    include/scsi/scsi_transport_fc.h | 14 +-
    include/scsi/scsi_transport_sas.h | 12 +-
    include/scsi/sd.h | 4 +-
    55 files changed, 1761 insertions(+), 1510 deletions(-)

    diff --git a/block/bsg.c b/block/bsg.c
    index 302ac1f..f51172e 100644
    --- a/block/bsg.c
    +++ b/block/bsg.c
    @@ -758,7 +758,7 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
    mutex_lock(&bsg_mutex);
    hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));

    - strncpy(bd->name, rq->bsg_dev.class_dev->class_id, sizeof(bd->name) - 1);
    + strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);
    dprintk("bound to <%s>, max queue %d\n",
    format_dev_t(buf, inode->i_rdev), bd->max_queue);

    @@ -946,7 +946,7 @@ void bsg_unregister_queue(struct request_queue *q)
    mutex_lock(&bsg_mutex);
    idr_remove(&bsg_minor_idr, bcd->minor);
    sysfs_remove_link(&q->kobj, "bsg");
    - class_device_unregister(bcd->class_dev);
    + device_unregister(bcd->class_dev);
    put_device(bcd->dev);
    bcd->class_dev = NULL;
    mutex_unlock(&bsg_mutex);
    @@ -959,7 +959,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
    struct bsg_class_device *bcd;
    dev_t dev;
    int ret, minor;
    - struct class_device *class_dev = NULL;
    + struct device *class_dev = NULL;
    const char *devname;

    if (name)
    @@ -998,8 +998,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
    bcd->queue = q;
    bcd->dev = get_device(gdev);
    dev = MKDEV(bsg_major, bcd->minor);
    - class_dev = class_device_create(bsg_class, NULL, dev, gdev, "%s",
    - devname);
    + class_dev = device_create(bsg_class, gdev, dev, "%s", devname);
    if (IS_ERR(class_dev)) {
    ret = PTR_ERR(class_dev);
    goto put_dev;
    @@ -1016,7 +1015,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
    return 0;

    unregister_class_dev:
    - class_device_unregister(class_dev);
    + device_unregister(class_dev);
    put_dev:
    put_device(gdev);
    remove_idr:
    diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
    index 739ba3f..986e332 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 f3c69a8..a34f324 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 3b43e8a..f57652d 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/transport_class.c b/drivers/base/transport_class.c
    index cabd0ed..84997ef 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/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
    index 99a1106..4351457 100644
    --- a/drivers/infiniband/ulp/srp/ib_srp.c
    +++ b/drivers/infiniband/ulp/srp/ib_srp.c
    @@ -1458,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)
    @@ -1470,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)
    @@ -1482,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)
    @@ -1494,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)
    @@ -1505,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)
    @@ -1524,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)
    @@ -1543,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)
    @@ -1554,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->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
    };

    @@ -1639,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
    };

    /*
    @@ -1837,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;
    @@ -1929,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->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)
    {
    @@ -1965,24 +1975,24 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
    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);
    @@ -2087,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 67e17c3..63d2ae7 100644
    --- a/drivers/infiniband/ulp/srp/ib_srp.h
    +++ b/drivers/infiniband/ulp/srp/ib_srp.h
    @@ -99,7 +99,7 @@ struct srp_device {
    struct srp_host {
    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/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
    index 89c6314..b109bd8 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 d289e97..7ea7da0 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 6fcb0e9..fafb57f 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/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
    index 51c3ebf..b31faec 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 adb98a2..8c22329 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 369fcf7..439fd81 100644
    --- a/drivers/scsi/aacraid/aachba.c
    +++ b/drivers/scsi/aacraid/aachba.c
    @@ -1316,7 +1316,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 ace0b75..113ca9c 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 ae5f74f..c639183 100644
    --- a/drivers/scsi/aacraid/linit.c
    +++ b/drivers/scsi/aacraid/linit.c
    @@ -755,10 +755,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]) {
    @@ -774,10 +774,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]) {
    @@ -793,10 +793,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");
    @@ -812,10 +813,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);
    @@ -825,10 +827,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);
    @@ -838,10 +841,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);
    @@ -851,9 +855,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)
    @@ -869,35 +874,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);
    @@ -907,70 +916,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,
    @@ -979,7 +988,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,
    @@ -993,6 +1002,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 3288be2..ab646e5 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 7d7b0a5..69f8346 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 92d1cb1..75c84d7 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 1592640..c264a8c 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 beecda9..5b7be1e 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 78d46a9..4a922c5 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 e5881e9..3b9514c 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 65dc18d..de5ae6a 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 74c9fc2..a9fbb3f 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 0819f5f..7c9f831 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 9f04192..820f91f 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 c5ebf01..d892894 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 abef704..31f7aec 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 3454a57..0be232b 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 413d8cd..d61df03 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 a9571c2..76eb4fe 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 52182a7..913a931 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 e1edab4..998cb5b 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 ed83cdb..67bb20e 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 b1119da..6b092a6 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 ca7bb6f..65d1737 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 43a964d..27ec625 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 1fb6031..bc12b5d 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 2445c98..8a7af95 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 5fe7aae..3cea17d 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 a6d9669..45df83b 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 e5156aa..2029422 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 df83bea..a860c3a 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/include/linux/attribute_container.h b/include/linux/attribute_container.h
    index 574b201..794ad74 100644
    --- a/include/linux/attribute_container.h
    +++ b/include/linux/attribute_container.h
    @@ -1,5 +1,5 @@
    /*
    - * class_container.h - a generic container for all classes
    + * attribute_container.h - a generic container for all classes
    *
    * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
    *
    @@ -18,7 +18,7 @@ struct attribute_container {
    struct klist containers;
    struct class *class;
    struct attribute_group *grp;
    - struct class_device_attribute **attrs;
    + struct device_attribute **attrs;
    int (*match)(struct attribute_container *, struct device *);
    #define ATTRIBUTE_CONTAINER_NO_CLASSDEVS 0x01
    unsigned long flags;
    @@ -41,31 +41,31 @@ int __must_check attribute_container_unregister(struct attribute_container *cont
    void attribute_container_create_device(struct device *dev,
    int (*fn)(struct attribute_container *,
    struct device *,
    - struct class_device *));
    + struct device *));
    void attribute_container_add_device(struct device *dev,
    int (*fn)(struct attribute_container *,
    struct device *,
    - struct class_device *));
    + struct device *));
    void attribute_container_remove_device(struct device *dev,
    void (*fn)(struct attribute_container *,
    struct device *,
    - struct class_device *));
    + struct device *));
    void attribute_container_device_trigger(struct device *dev,
    int (*fn)(struct attribute_container *,
    struct device *,
    - struct class_device *));
    + struct device *));
    void attribute_container_trigger(struct device *dev,
    int (*fn)(struct attribute_container *,
    struct device *));
    -int attribute_container_add_attrs(struct class_device *classdev);
    -int attribute_container_add_class_device(struct class_device *classdev);
    +int attribute_container_add_attrs(struct device *classdev);
    +int attribute_container_add_class_device(struct device *classdev);
    int attribute_container_add_class_device_adapter(struct attribute_container *cont,
    struct device *dev,
    - struct class_device *classdev);
    -void attribute_container_remove_attrs(struct class_device *classdev);
    -void attribute_container_class_device_del(struct class_device *classdev);
    -struct attribute_container *attribute_container_classdev_to_container(struct class_device *);
    -struct class_device *attribute_container_find_class_device(struct attribute_container *, struct device *);
    -struct class_device_attribute **attribute_container_classdev_to_attrs(const struct class_device *classdev);
    + struct device *classdev);
    +void attribute_container_remove_attrs(struct device *classdev);
    +void attribute_container_class_device_del(struct device *classdev);
    +struct attribute_container *attribute_container_classdev_to_container(struct device *);
    +struct device *attribute_container_find_class_device(struct attribute_container *, struct device *);
    +struct device_attribute **attribute_container_classdev_to_attrs(const struct device *classdev);

    #endif
    diff --git a/include/linux/bsg.h b/include/linux/bsg.h
    index 60e377b..e8406c5 100644
    --- a/include/linux/bsg.h
    +++ b/include/linux/bsg.h
    @@ -55,7 +55,7 @@ struct sg_io_v4 {

    #if defined(CONFIG_BLK_DEV_BSG)
    struct bsg_class_device {
    - struct class_device *class_dev;
    + struct device *class_dev;
    struct device *dev;
    int minor;
    struct request_queue *queue;
    diff --git a/include/linux/enclosure.h b/include/linux/enclosure.h
    index a5978f1..4332442 100644
    --- a/include/linux/enclosure.h
    +++ b/include/linux/enclosure.h
    @@ -82,7 +82,8 @@ struct enclosure_component_callbacks {

    struct enclosure_component {
    void *scratch;
    - struct class_device cdev;
    + struct device cdev;
    + struct device *dev;
    enum enclosure_component_type type;
    int number;
    int fault;
    @@ -94,20 +95,20 @@ struct enclosure_component {
    struct enclosure_device {
    void *scratch;
    struct list_head node;
    - struct class_device cdev;
    + struct device edev;
    struct enclosure_component_callbacks *cb;
    int components;
    struct enclosure_component component[0];
    };

    static inline struct enclosure_device *
    -to_enclosure_device(struct class_device *dev)
    +to_enclosure_device(struct device *dev)
    {
    - return container_of(dev, struct enclosure_device, cdev);
    + return container_of(dev, struct enclosure_device, edev);
    }

    static inline struct enclosure_component *
    -to_enclosure_component(struct class_device *dev)
    +to_enclosure_component(struct device *dev)
    {
    return container_of(dev, struct enclosure_component, cdev);
    }
    diff --git a/include/linux/libata.h b/include/linux/libata.h
    index 165734a..07ed56f 100644
    --- a/include/linux/libata.h
    +++ b/include/linux/libata.h
    @@ -443,7 +443,7 @@ enum link_pm {
    MAX_PERFORMANCE,
    MEDIUM_POWER,
    };
    -extern struct class_device_attribute class_device_attr_link_power_management_policy;
    +extern struct device_attribute dev_attr_link_power_management_policy;

    #ifdef CONFIG_ATA_SFF
    struct ata_ioports {
    diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
    index d22ad39..6b537f1 100644
    --- a/include/linux/raid_class.h
    +++ b/include/linux/raid_class.h
    @@ -53,20 +53,20 @@ struct raid_data {
    #define DEFINE_RAID_ATTRIBUTE(type, attr) \
    static inline void \
    raid_set_##attr(struct raid_template *r, struct device *dev, type value) { \
    - struct class_device *cdev = \
    + struct device *device = \
    attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
    struct raid_data *rd; \
    - BUG_ON(!cdev); \
    - rd = class_get_devdata(cdev); \
    + BUG_ON(!device); \
    + rd = dev_get_drvdata(device); \
    rd->attr = value; \
    } \
    static inline type \
    raid_get_##attr(struct raid_template *r, struct device *dev) { \
    - struct class_device *cdev = \
    + struct device *device = \
    attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
    struct raid_data *rd; \
    - BUG_ON(!cdev); \
    - rd = class_get_devdata(cdev); \
    + BUG_ON(!device); \
    + rd = dev_get_drvdata(device); \
    return rd->attr; \
    }

    diff --git a/include/linux/transport_class.h b/include/linux/transport_class.h
    index 6696cf7..eaec1ea 100644
    --- a/include/linux/transport_class.h
    +++ b/include/linux/transport_class.h
    @@ -17,11 +17,11 @@ struct transport_container;
    struct transport_class {
    struct class class;
    int (*setup)(struct transport_container *, struct device *,
    - struct class_device *);
    + struct device *);
    int (*configure)(struct transport_container *, struct device *,
    - struct class_device *);
    + struct device *);
    int (*remove)(struct transport_container *, struct device *,
    - struct class_device *);
    + struct device *);
    };

    #define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg) \
    diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
    index ab7acbe..b8b19e2 100644
    --- a/include/scsi/scsi_device.h
    +++ b/include/scsi/scsi_device.h
    @@ -156,8 +156,8 @@ struct scsi_device {

    int timeout;

    - struct device sdev_gendev;
    - struct class_device sdev_classdev;
    + struct device sdev_gendev,
    + sdev_dev;

    struct execute_work ew; /* used to get process context on put */

    @@ -167,9 +167,9 @@ struct scsi_device {
    #define to_scsi_device(d) \
    container_of(d, struct scsi_device, sdev_gendev)
    #define class_to_sdev(d) \
    - container_of(d, struct scsi_device, sdev_classdev)
    + container_of(d, struct scsi_device, sdev_dev)
    #define transport_class_to_sdev(class_dev) \
    - to_scsi_device(class_dev->dev)
    + to_scsi_device(class_dev->parent)

    #define sdev_printk(prefix, sdev, fmt, a...) \
    dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
    @@ -220,7 +220,7 @@ static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
    return to_scsi_target(sdev->sdev_gendev.parent);
    }
    #define transport_class_to_starget(class_dev) \
    - to_scsi_target(class_dev->dev)
    + to_scsi_target(class_dev->parent)

    #define starget_printk(prefix, starget, fmt, a...) \
    dev_printk(prefix, &(starget)->dev, fmt, ##a)
    diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
    index 4913286..d967d6d 100644
    --- a/include/scsi/scsi_host.h
    +++ b/include/scsi/scsi_host.h
    @@ -470,7 +470,7 @@ struct scsi_host_template {
    /*
    * Pointer to the sysfs class properties for this host, NULL terminated.
    */
    - struct class_device_attribute **shost_attrs;
    + struct device_attribute **shost_attrs;

    /*
    * Pointer to the SCSI device properties for this host, NULL terminated.
    @@ -655,8 +655,7 @@ struct Scsi_Host {
    enum scsi_host_state shost_state;

    /* ldm bits */
    - struct device shost_gendev;
    - struct class_device shost_classdev;
    + struct device shost_gendev, shost_dev;

    /*
    * List of hosts per template.
    @@ -683,7 +682,7 @@ struct Scsi_Host {
    };

    #define class_to_shost(d) \
    - container_of(d, struct Scsi_Host, shost_classdev)
    + container_of(d, struct Scsi_Host, shost_dev)

    #define shost_printk(prefix, shost, fmt, a...) \
    dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
    diff --git a/include/scsi/scsi_transport.h b/include/scsi/scsi_transport.h
    index 0dfef75..490bd13 100644
    --- a/include/scsi/scsi_transport.h
    +++ b/include/scsi/scsi_transport.h
    @@ -80,7 +80,7 @@ struct scsi_transport_template {
    };

    #define transport_class_to_shost(tc) \
    - dev_to_shost((tc)->dev)
    + dev_to_shost((tc)->parent)


    /* Private area maintenance. The driver requested allocations come
    diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
    index 4769efd..06f72ba 100644
    --- a/include/scsi/scsi_transport_fc.h
    +++ b/include/scsi/scsi_transport_fc.h
    @@ -163,8 +163,8 @@ enum fc_tgtid_binding_type {


    /* Macro for use in defining Virtual Port attributes */
    -#define FC_VPORT_ATTR(_name,_mode,_show,_store) \
    -struct class_device_attribute class_device_attr_vport_##_name = \
    +#define FC_VPORT_ATTR(_name,_mode,_show,_store) \
    +struct device_attribute dev_attr_vport_##_name = \
    __ATTR(_name,_mode,_show,_store)


    @@ -234,8 +234,8 @@ struct fc_vport {

    #define dev_to_vport(d) \
    container_of(d, struct fc_vport, dev)
    -#define transport_class_to_vport(classdev) \
    - dev_to_vport(classdev->dev)
    +#define transport_class_to_vport(dev) \
    + dev_to_vport(dev->parent)
    #define vport_to_shost(v) \
    (v->shost)
    #define vport_to_shost_channel(v) \
    @@ -271,7 +271,7 @@ struct fc_rport_identifiers {

    /* Macro for use in defining Remote Port attributes */
    #define FC_RPORT_ATTR(_name,_mode,_show,_store) \
    -struct class_device_attribute class_device_attr_rport_##_name = \
    +struct device_attribute dev_attr_rport_##_name = \
    __ATTR(_name,_mode,_show,_store)


    @@ -341,8 +341,8 @@ struct fc_rport { /* aka fc_starget_attrs */

    #define dev_to_rport(d) \
    container_of(d, struct fc_rport, dev)
    -#define transport_class_to_rport(classdev) \
    - dev_to_rport(classdev->dev)
    +#define transport_class_to_rport(dev) \
    + dev_to_rport(dev->parent)
    #define rport_to_shost(r) \
    dev_to_shost(r->dev.parent)

    diff --git a/include/scsi/scsi_transport_sas.h b/include/scsi/scsi_transport_sas.h
    index 09125fa..61ad359 100644
    --- a/include/scsi/scsi_transport_sas.h
    +++ b/include/scsi/scsi_transport_sas.h
    @@ -80,8 +80,8 @@ struct sas_phy {

    #define dev_to_phy(d) \
    container_of((d), struct sas_phy, dev)
    -#define transport_class_to_phy(cdev) \
    - dev_to_phy((cdev)->dev)
    +#define transport_class_to_phy(dev) \
    + dev_to_phy((dev)->parent)
    #define phy_to_shost(phy) \
    dev_to_shost((phy)->dev.parent)

    @@ -96,8 +96,8 @@ struct sas_rphy {

    #define dev_to_rphy(d) \
    container_of((d), struct sas_rphy, dev)
    -#define transport_class_to_rphy(cdev) \
    - dev_to_rphy((cdev)->dev)
    +#define transport_class_to_rphy(dev) \
    + dev_to_rphy((dev)->parent)
    #define rphy_to_shost(rphy) \
    dev_to_shost((rphy)->dev.parent)
    #define target_to_rphy(targ) \
    @@ -152,8 +152,8 @@ struct sas_port {

    #define dev_to_sas_port(d) \
    container_of((d), struct sas_port, dev)
    -#define transport_class_to_sas_port(cdev) \
    - dev_to_sas_port((cdev)->dev)
    +#define transport_class_to_sas_port(dev) \
    + dev_to_sas_port((dev)->parent)

    struct sas_phy_linkrates {
    enum sas_linkrate maximum_linkrate;
    diff --git a/include/scsi/sd.h b/include/scsi/sd.h
    index 8ea9f73..4f032d4 100644
    --- a/include/scsi/sd.h
    +++ b/include/scsi/sd.h
    @@ -34,7 +34,7 @@
    struct scsi_disk {
    struct scsi_driver *driver; /* always &sd_template */
    struct scsi_device *device;
    - struct class_device cdev;
    + struct device dev;
    struct gendisk *disk;
    unsigned int openers; /* protected by BKL for now, yuck */
    sector_t capacity; /* size in 512-byte sectors */
    @@ -46,7 +46,7 @@ struct scsi_disk {
    unsigned RCD : 1; /* state of disk RCD bit, unused */
    unsigned DPOFUA : 1; /* state of disk DPOFUA bit */
    };
    -#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,cdev)
    +#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)

    #define sd_printk(prefix, sdsk, fmt, a...) \
    (sdsk)->disk ? \
    --
    1.5.4.5


    \
     
     \ /
      Last update: 2008-04-20 12:55    [W:0.580 / U:2.796 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site