diff options
Diffstat (limited to 'drivers')
86 files changed, 3497 insertions, 2071 deletions
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/bus.c b/drivers/base/bus.c index 2d207ad..be1cc51 100644 --- a/drivers/base/bus.c +++ b/drivers/base/bus.c @@ -79,7 +79,7 @@ static void driver_release(struct kobject *kobj) { struct driver_private *drv_priv = to_driver(kobj); - pr_debug("driver: '%s': %s\n", kobject_name(kobj), __FUNCTION__); + pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__); kfree(drv_priv); } @@ -505,14 +505,11 @@ void bus_attach_device(struct device *dev) int ret = 0; if (bus) { - dev->is_registered = 1; if (bus->p->drivers_autoprobe) ret = device_attach(dev); WARN_ON(ret < 0); if (ret >= 0) klist_add_tail(&dev->knode_bus, &bus->p->klist_devices); - else - dev->is_registered = 0; } } @@ -533,10 +530,8 @@ void bus_remove_device(struct device *dev) sysfs_remove_link(&dev->bus->p->devices_kset->kobj, dev->bus_id); device_remove_attrs(dev->bus, dev); - if (dev->is_registered) { - dev->is_registered = 0; - klist_del(&dev->knode_bus); - } + klist_del(&dev->knode_bus); + pr_debug("bus: '%s': remove device %s\n", dev->bus->name, dev->bus_id); device_release_driver(dev); @@ -682,19 +677,19 @@ int bus_add_driver(struct device_driver *drv) error = driver_create_file(drv, &driver_attr_uevent); if (error) { printk(KERN_ERR "%s: uevent attr (%s) failed\n", - __FUNCTION__, drv->name); + __func__, drv->name); } error = driver_add_attrs(bus, drv); if (error) { /* How the hell do we get out of this pickle? Give up */ printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", - __FUNCTION__, drv->name); + __func__, drv->name); } error = add_bind_files(drv); if (error) { /* Ditto */ printk(KERN_ERR "%s: add_bind_files(%s) failed\n", - __FUNCTION__, drv->name); + __func__, drv->name); } kobject_uevent(&priv->kobj, KOBJ_ADD); diff --git a/drivers/base/class.c b/drivers/base/class.c index 9d91537..b490179 100644 --- a/drivers/base/class.c +++ b/drivers/base/class.c @@ -175,13 +175,13 @@ void class_unregister(struct class *cls) static void class_create_release(struct class *cls) { - pr_debug("%s called for %s\n", __FUNCTION__, cls->name); + pr_debug("%s called for %s\n", __func__, cls->name); kfree(cls); } static void class_device_create_release(struct class_device *class_dev) { - pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id); + pr_debug("%s called for %s\n", __func__, class_dev->class_id); kfree(class_dev); } @@ -189,7 +189,7 @@ static void class_device_create_release(struct class_device *class_dev) static int class_device_create_uevent(struct class_device *class_dev, struct kobj_uevent_env *env) { - pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id); + pr_debug("%s called for %s\n", __func__, class_dev->class_id); return 0; } @@ -415,7 +415,7 @@ static int class_uevent(struct kset *kset, struct kobject *kobj, struct device *dev = class_dev->dev; int retval = 0; - pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id); + pr_debug("%s - name = %s\n", __func__, class_dev->class_id); if (MAJOR(class_dev->devt)) { add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt)); diff --git a/drivers/base/core.c b/drivers/base/core.c index 7c4b36c..9248e09 100644 --- a/drivers/base/core.c +++ b/drivers/base/core.c @@ -207,7 +207,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, retval = dev->bus->uevent(dev, env); if (retval) pr_debug("device: '%s': %s: bus uevent() returned %d\n", - dev->bus_id, __FUNCTION__, retval); + dev->bus_id, __func__, retval); } /* have the class specific function add its stuff */ @@ -216,7 +216,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, if (retval) pr_debug("device: '%s': %s: class uevent() " "returned %d\n", dev->bus_id, - __FUNCTION__, retval); + __func__, retval); } /* have the device type specific fuction add its stuff */ @@ -225,7 +225,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, if (retval) pr_debug("device: '%s': %s: dev_type uevent() " "returned %d\n", dev->bus_id, - __FUNCTION__, retval); + __func__, retval); } return retval; @@ -782,7 +782,7 @@ int device_add(struct device *dev) goto Done; } - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); parent = get_device(dev->parent); setup_parent(dev, parent); @@ -817,13 +817,12 @@ int device_add(struct device *dev) error = device_add_attrs(dev); if (error) goto AttrsError; - error = dpm_sysfs_add(dev); - if (error) - goto PMError; - device_pm_add(dev); error = bus_add_device(dev); if (error) goto BusError; + error = device_pm_add(dev); + if (error) + goto PMError; kobject_uevent(&dev->kobj, KOBJ_ADD); bus_attach_device(dev); if (parent) @@ -843,9 +842,9 @@ int device_add(struct device *dev) Done: put_device(dev); return error; - BusError: - device_pm_remove(dev); PMError: + bus_remove_device(dev); + BusError: if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DEL_DEVICE, dev); @@ -981,7 +980,7 @@ void device_del(struct device *dev) */ void device_unregister(struct device *dev) { - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); device_del(dev); put_device(dev); } @@ -1076,7 +1075,7 @@ EXPORT_SYMBOL_GPL(device_remove_file); static void device_create_release(struct device *dev) { - pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__); + pr_debug("device: '%s': %s\n", dev->bus_id, __func__); kfree(dev); } @@ -1164,35 +1163,6 @@ void device_destroy(struct class *class, dev_t devt) } EXPORT_SYMBOL_GPL(device_destroy); -#ifdef CONFIG_PM_SLEEP -/** - * destroy_suspended_device - asks the PM core to remove a suspended device - * @class: pointer to the struct class that this device was registered with - * @devt: the dev_t of the device that was previously registered - * - * This call notifies the PM core of the necessity to unregister a suspended - * device created with a call to device_create() (devices cannot be - * unregistered directly while suspended, since the PM core holds their - * semaphores at that time). - * - * It can only be called within the scope of a system sleep transition. In - * practice this means it has to be directly or indirectly invoked either by - * a suspend or resume method, or by the PM core (e.g. via - * disable_nonboot_cpus() or enable_nonboot_cpus()). - */ -void destroy_suspended_device(struct class *class, dev_t devt) -{ - struct device *dev; - - dev = class_find_device(class, &devt, __match_devt); - if (dev) { - device_pm_schedule_removal(dev); - put_device(dev); - } -} -EXPORT_SYMBOL_GPL(destroy_suspended_device); -#endif /* CONFIG_PM_SLEEP */ - /** * device_rename - renames a device * @dev: the pointer to the struct device to be renamed @@ -1210,7 +1180,7 @@ int device_rename(struct device *dev, char *new_name) return -EINVAL; pr_debug("device: '%s': %s: renaming to '%s'\n", dev->bus_id, - __FUNCTION__, new_name); + __func__, new_name); #ifdef CONFIG_SYSFS_DEPRECATED if ((dev->class) && (dev->parent)) @@ -1249,7 +1219,7 @@ int device_rename(struct device *dev, char *new_name) dev->bus_id); if (error) { dev_err(dev, "%s: sysfs_create_symlink failed (%d)\n", - __FUNCTION__, error); + __func__, error); } } #endif @@ -1325,7 +1295,7 @@ int device_move(struct device *dev, struct device *new_parent) new_parent_kobj = get_device_parent(dev, new_parent); pr_debug("device: '%s': %s: moving to '%s'\n", dev->bus_id, - __FUNCTION__, new_parent ? new_parent->bus_id : "<NULL>"); + __func__, new_parent ? new_parent->bus_id : "<NULL>"); error = kobject_move(&dev->kobj, new_parent_kobj); if (error) { cleanup_glue_dir(dev, new_parent_kobj); diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c index 2c76aff..6fe4174 100644 --- a/drivers/base/cpu.c +++ b/drivers/base/cpu.c @@ -28,7 +28,7 @@ static ssize_t show_online(struct sys_device *dev, char *buf) return sprintf(buf, "%u\n", !!cpu_online(cpu->sysdev.id)); } -static ssize_t store_online(struct sys_device *dev, const char *buf, +static ssize_t __ref store_online(struct sys_device *dev, const char *buf, size_t count) { struct cpu *cpu = container_of(dev, struct cpu, sysdev); @@ -55,7 +55,7 @@ static ssize_t store_online(struct sys_device *dev, const char *buf, } static SYSDEV_ATTR(online, 0644, show_online, store_online); -static void __devinit register_cpu_control(struct cpu *cpu) +static void __cpuinit register_cpu_control(struct cpu *cpu) { sysdev_create_file(&cpu->sysdev, &attr_online); } diff --git a/drivers/base/dd.c b/drivers/base/dd.c index a5cde94..3ac443b 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -30,12 +30,12 @@ static void driver_bound(struct device *dev) { if (klist_node_attached(&dev->knode_driver)) { printk(KERN_WARNING "%s: device %s already bound\n", - __FUNCTION__, kobject_name(&dev->kobj)); + __func__, kobject_name(&dev->kobj)); return; } pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->bus_id, - __FUNCTION__, dev->driver->name); + __func__, dev->driver->name); if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, @@ -104,13 +104,13 @@ static int really_probe(struct device *dev, struct device_driver *drv) atomic_inc(&probe_count); pr_debug("bus: '%s': %s: probing driver %s with device %s\n", - drv->bus->name, __FUNCTION__, drv->name, dev->bus_id); + drv->bus->name, __func__, drv->name, dev->bus_id); WARN_ON(!list_empty(&dev->devres_head)); dev->driver = drv; if (driver_sysfs_add(dev)) { printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", - __FUNCTION__, dev->bus_id); + __func__, dev->bus_id); goto probe_failed; } @@ -127,7 +127,7 @@ static int really_probe(struct device *dev, struct device_driver *drv) driver_bound(dev); ret = 1; pr_debug("bus: '%s': %s: bound device %s to driver %s\n", - drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); + drv->bus->name, __func__, dev->bus_id, drv->name); goto done; probe_failed: @@ -160,7 +160,7 @@ done: */ int driver_probe_done(void) { - pr_debug("%s: probe_count = %d\n", __FUNCTION__, + pr_debug("%s: probe_count = %d\n", __func__, atomic_read(&probe_count)); if (atomic_read(&probe_count)) return -EBUSY; @@ -194,7 +194,7 @@ int driver_probe_device(struct device_driver *drv, struct device *dev) goto done; pr_debug("bus: '%s': %s: matched device %s with driver %s\n", - drv->bus->name, __FUNCTION__, dev->bus_id, drv->name); + drv->bus->name, __func__, dev->bus_id, drv->name); ret = really_probe(dev, drv); diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c index 4a1b9bf..1fef7df 100644 --- a/drivers/base/firmware_class.c +++ b/drivers/base/firmware_class.c @@ -156,7 +156,7 @@ static ssize_t firmware_loading_store(struct device *dev, } /* fallthrough */ default: - printk(KERN_ERR "%s: unexpected value (%d)\n", __FUNCTION__, + printk(KERN_ERR "%s: unexpected value (%d)\n", __func__, loading); /* fallthrough */ case -1: @@ -209,7 +209,7 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size) new_size = ALIGN(min_size, PAGE_SIZE); new_data = vmalloc(new_size); if (!new_data) { - printk(KERN_ERR "%s: unable to alloc buffer\n", __FUNCTION__); + printk(KERN_ERR "%s: unable to alloc buffer\n", __func__); /* Make sure that we don't keep incomplete data */ fw_load_abort(fw_priv); return -ENOMEM; @@ -307,7 +307,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name, *dev_p = NULL; if (!fw_priv || !f_dev) { - printk(KERN_ERR "%s: kmalloc failed\n", __FUNCTION__); + printk(KERN_ERR "%s: kmalloc failed\n", __func__); retval = -ENOMEM; goto error_kfree; } @@ -328,7 +328,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name, retval = device_register(f_dev); if (retval) { printk(KERN_ERR "%s: device_register failed\n", - __FUNCTION__); + __func__); goto error_kfree; } *dev_p = f_dev; @@ -362,14 +362,14 @@ static int fw_setup_device(struct firmware *fw, struct device **dev_p, retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data); if (retval) { printk(KERN_ERR "%s: sysfs_create_bin_file failed\n", - __FUNCTION__); + __func__); goto error_unreg; } retval = device_create_file(f_dev, &dev_attr_loading); if (retval) { printk(KERN_ERR "%s: device_create_file failed\n", - __FUNCTION__); + __func__); goto error_unreg; } @@ -399,7 +399,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name, *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL); if (!firmware) { printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n", - __FUNCTION__); + __func__); retval = -ENOMEM; goto out; } @@ -570,13 +570,13 @@ firmware_class_init(void) int error; error = class_register(&firmware_class); if (error) { - printk(KERN_ERR "%s: class_register failed\n", __FUNCTION__); + printk(KERN_ERR "%s: class_register failed\n", __func__); return error; } error = class_create_file(&firmware_class, &class_attr_timeout); if (error) { printk(KERN_ERR "%s: class_create_file failed\n", - __FUNCTION__); + __func__); class_unregister(&firmware_class); } return error; diff --git a/drivers/base/memory.c b/drivers/base/memory.c index 7ae413f..8ce6de5 100644 --- a/drivers/base/memory.c +++ b/drivers/base/memory.c @@ -20,6 +20,7 @@ #include <linux/kobject.h> #include <linux/memory_hotplug.h> #include <linux/mm.h> +#include <linux/mutex.h> #include <asm/atomic.h> #include <asm/uaccess.h> @@ -61,8 +62,8 @@ void unregister_memory_notifier(struct notifier_block *nb) /* * register_memory - Setup a sysfs device for a memory block */ -int register_memory(struct memory_block *memory, struct mem_section *section, - struct node *root) +static +int register_memory(struct memory_block *memory, struct mem_section *section) { int error; @@ -70,26 +71,18 @@ int register_memory(struct memory_block *memory, struct mem_section *section, memory->sysdev.id = __section_nr(section); error = sysdev_register(&memory->sysdev); - - if (root && !error) - error = sysfs_create_link(&root->sysdev.kobj, - &memory->sysdev.kobj, - kobject_name(&memory->sysdev.kobj)); - return error; } static void -unregister_memory(struct memory_block *memory, struct mem_section *section, - struct node *root) +unregister_memory(struct memory_block *memory, struct mem_section *section) { BUG_ON(memory->sysdev.cls != &memory_sysdev_class); BUG_ON(memory->sysdev.id != __section_nr(section)); + /* drop the ref. we got in remove_memory_block() */ + kobject_put(&memory->sysdev.kobj); sysdev_unregister(&memory->sysdev); - if (root) - sysfs_remove_link(&root->sysdev.kobj, - kobject_name(&memory->sysdev.kobj)); } /* @@ -193,7 +186,7 @@ memory_block_action(struct memory_block *mem, unsigned long action) break; default: printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n", - __FUNCTION__, mem, action, action); + __func__, mem, action, action); WARN_ON(1); ret = -EINVAL; } @@ -205,7 +198,7 @@ static int memory_block_change_state(struct memory_block *mem, unsigned long to_state, unsigned long from_state_req) { int ret = 0; - down(&mem->state_sem); + mutex_lock(&mem->state_mutex); if (mem->state != from_state_req) { ret = -EINVAL; @@ -217,7 +210,7 @@ static int memory_block_change_state(struct memory_block *mem, mem->state = to_state; out: - up(&mem->state_sem); + mutex_unlock(&mem->state_mutex); return ret; } @@ -341,10 +334,10 @@ static int add_memory_block(unsigned long node_id, struct mem_section *section, mem->phys_index = __section_nr(section); mem->state = state; - init_MUTEX(&mem->state_sem); + mutex_init(&mem->state_mutex); mem->phys_device = phys_device; - ret = register_memory(mem, section, NULL); + ret = register_memory(mem, section); if (!ret) ret = mem_create_simple_file(mem, phys_index); if (!ret) @@ -395,7 +388,7 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section, mem_remove_simple_file(mem, phys_index); mem_remove_simple_file(mem, state); mem_remove_simple_file(mem, phys_device); - unregister_memory(mem, section, NULL); + unregister_memory(mem, section); return 0; } @@ -451,6 +444,6 @@ int __init memory_dev_init(void) ret = err; out: if (ret) - printk(KERN_ERR "%s() failed: %d\n", __FUNCTION__, ret); + printk(KERN_ERR "%s() failed: %d\n", __func__, ret); return ret; } diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c index d887d5c..c4568b8 100644 --- a/drivers/base/power/main.c +++ b/drivers/base/power/main.c @@ -50,26 +50,40 @@ LIST_HEAD(dpm_active); static LIST_HEAD(dpm_off); static LIST_HEAD(dpm_off_irq); -static LIST_HEAD(dpm_destroy); static DEFINE_MUTEX(dpm_list_mtx); -static DECLARE_RWSEM(pm_sleep_rwsem); - -int (*platform_enable_wakeup)(struct device *dev, int is_on); +/* 'true' if all devices have been suspended, protected by dpm_list_mtx */ +static bool all_sleeping; /** * device_pm_add - add a device to the list of active devices * @dev: Device to be added to the list */ -void device_pm_add(struct device *dev) +int device_pm_add(struct device *dev) { + int error = 0; + pr_debug("PM: Adding info for %s:%s\n", dev->bus ? dev->bus->name : "No Bus", kobject_name(&dev->kobj)); mutex_lock(&dpm_list_mtx); - list_add_tail(&dev->power.entry, &dpm_active); + if ((dev->parent && dev->parent->power.sleeping) || all_sleeping) { + if (dev->parent->power.sleeping) + dev_warn(dev, + "parent %s is sleeping, will not add\n", + dev->parent->bus_id); + else + dev_warn(dev, "devices are sleeping, will not add\n"); + WARN_ON(true); + error = -EBUSY; + } else { + error = dpm_sysfs_add(dev); + if (!error) + list_add_tail(&dev->power.entry, &dpm_active); + } mutex_unlock(&dpm_list_mtx); + return error; } /** @@ -89,50 +103,6 @@ void device_pm_remove(struct device *dev) mutex_unlock(&dpm_list_mtx); } -/** - * device_pm_schedule_removal - schedule the removal of a suspended device - * @dev: Device to destroy - * - * Moves the device to the dpm_destroy list for further processing by - * unregister_dropped_devices(). - */ -void device_pm_schedule_removal(struct device *dev) -{ - pr_debug("PM: Preparing for removal: %s:%s\n", - dev->bus ? dev->bus->name : "No Bus", - kobject_name(&dev->kobj)); - mutex_lock(&dpm_list_mtx); - list_move_tail(&dev->power.entry, &dpm_destroy); - mutex_unlock(&dpm_list_mtx); -} -EXPORT_SYMBOL_GPL(device_pm_schedule_removal); - -/** - * pm_sleep_lock - mutual exclusion for registration and suspend - * - * Returns 0 if no suspend is underway and device registration - * may proceed, otherwise -EBUSY. - */ -int pm_sleep_lock(void) -{ - if (down_read_trylock(&pm_sleep_rwsem)) - return 0; - - return -EBUSY; -} - -/** - * pm_sleep_unlock - mutual exclusion for registration and suspend - * - * This routine undoes the effect of device_pm_add_lock - * when a device's registration is complete. - */ -void pm_sleep_unlock(void) -{ - up_read(&pm_sleep_rwsem); -} - - /*------------------------- Resume routines -------------------------*/ /** @@ -242,11 +212,13 @@ static int resume_device(struct device *dev) static void dpm_resume(void) { mutex_lock(&dpm_list_mtx); + all_sleeping = false; while(!list_empty(&dpm_off)) { struct list_head *entry = dpm_off.next; struct device *dev = to_device(entry); list_move_tail(entry, &dpm_active); + dev->power.sleeping = false; mutex_unlock(&dpm_list_mtx); resume_device(dev); mutex_lock(&dpm_list_mtx); @@ -255,26 +227,6 @@ static void dpm_resume(void) } /** - * unregister_dropped_devices - Unregister devices scheduled for removal - * - * Unregister all devices on the dpm_destroy list. - */ -static void unregister_dropped_devices(void) -{ - mutex_lock(&dpm_list_mtx); - while (!list_empty(&dpm_destroy)) { - struct list_head *entry = dpm_destroy.next; - struct device *dev = to_device(entry); - - mutex_unlock(&dpm_list_mtx); - /* This also removes the device from the list */ - device_unregister(dev); - mutex_lock(&dpm_list_mtx); - } - mutex_unlock(&dpm_list_mtx); -} - -/** * device_resume - Restore state of each device in system. * * Resume all the devices, unlock them all, and allow new @@ -284,8 +236,6 @@ void device_resume(void) { might_sleep(); dpm_resume(); - unregister_dropped_devices(); - up_write(&pm_sleep_rwsem); } EXPORT_SYMBOL_GPL(device_resume); @@ -377,11 +327,6 @@ static int suspend_device(struct device *dev, pm_message_t state) down(&dev->sem); - if (dev->power.power_state.event) { - dev_dbg(dev, "PM: suspend %d-->%d\n", - dev->power.power_state.event, state.event); - } - if (dev->class && dev->class->suspend) { suspend_device_dbg(dev, state, "class "); error = dev->class->suspend(dev, state); @@ -426,6 +371,9 @@ static int dpm_suspend(pm_message_t state) struct list_head *entry = dpm_active.prev; struct device *dev = to_device(entry); + WARN_ON(dev->parent && dev->parent->power.sleeping); + + dev->power.sleeping = true; mutex_unlock(&dpm_list_mtx); error = suspend_device(dev, state); mutex_lock(&dpm_list_mtx); @@ -437,11 +385,14 @@ static int dpm_suspend(pm_message_t state) (error == -EAGAIN ? " (please convert to suspend_late)" : "")); + dev->power.sleeping = false; break; } if (!list_empty(&dev->power.entry)) list_move(&dev->power.entry, &dpm_off); } + if (!error) + all_sleeping = true; mutex_unlock(&dpm_list_mtx); return error; @@ -459,7 +410,6 @@ int device_suspend(pm_message_t state) int error; might_sleep(); - down_write(&pm_sleep_rwsem); error = dpm_suspend(state); if (error) device_resume(); diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h index e32d3bd..a6894f2 100644 --- a/drivers/base/power/power.h +++ b/drivers/base/power/power.h @@ -11,30 +11,13 @@ static inline struct device *to_device(struct list_head *entry) return container_of(entry, struct device, power.entry); } -extern void device_pm_add(struct device *); +extern int device_pm_add(struct device *); extern void device_pm_remove(struct device *); -extern int pm_sleep_lock(void); -extern void pm_sleep_unlock(void); #else /* CONFIG_PM_SLEEP */ - -static inline void device_pm_add(struct device *dev) -{ -} - -static inline void device_pm_remove(struct device *dev) -{ -} - -static inline int pm_sleep_lock(void) -{ - return 0; -} - -static inline void pm_sleep_unlock(void) -{ -} +static inline int device_pm_add(struct device *dev) { return 0; } +static inline void device_pm_remove(struct device *dev) {} #endif diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c index f2ed179..d11f74b 100644 --- a/drivers/base/power/sysfs.c +++ b/drivers/base/power/sysfs.c @@ -6,6 +6,8 @@ #include <linux/string.h> #include "power.h" +int (*platform_enable_wakeup)(struct device *dev, int is_on); + /* * wakeup - Report/change current wakeup option for device diff --git a/drivers/base/sys.c b/drivers/base/sys.c index 8e13fd9..4fbb56b 100644 --- a/drivers/base/sys.c +++ b/drivers/base/sys.c @@ -167,6 +167,22 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv) { int err = 0; + if (!cls) { + printk(KERN_WARNING "sysdev: invalid class passed to " + "sysdev_driver_register!\n"); + WARN_ON(1); + return -EINVAL; + } + + /* Check whether this driver has already been added to a class. */ + if ((drv->entry.next != drv->entry.prev) || + (drv->entry.next != NULL)) { + printk(KERN_WARNING "sysdev: class %s: driver (%p) has already" + " been registered to a class, something is wrong, but " + "will forge on!\n", cls->name, drv); + WARN_ON(1); + } + mutex_lock(&sysdev_drivers_lock); if (cls && kset_get(&cls->kset)) { list_add_tail(&drv->entry, &cls->drivers); @@ -179,7 +195,7 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv) } } else { err = -EINVAL; - printk(KERN_ERR "%s: invalid device class\n", __FUNCTION__); + printk(KERN_ERR "%s: invalid device class\n", __func__); WARN_ON(1); } mutex_unlock(&sysdev_drivers_lock); diff --git a/drivers/base/transport_class.c b/drivers/base/transport_class.c index 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/char/drm/drmP.h b/drivers/char/drm/drmP.h index 8ea9dd1..6540948 100644 --- a/drivers/char/drm/drmP.h +++ b/drivers/char/drm/drmP.h @@ -640,7 +640,6 @@ struct drm_head { struct drm_device *dev; struct proc_dir_entry *dev_root; /**< proc directory entry */ dev_t device; /**< Device number for mknod */ - struct class_device *dev_class; }; /** diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c index 349b6ed..662d60e 100644 --- a/drivers/char/hw_random/core.c +++ b/drivers/char/hw_random/core.c @@ -238,11 +238,11 @@ static DEVICE_ATTR(rng_available, S_IRUGO, NULL); -static void unregister_miscdev(bool suspended) +static void unregister_miscdev(void) { device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available); device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current); - __misc_deregister(&rng_miscdev, suspended); + misc_deregister(&rng_miscdev); } static int register_miscdev(void) @@ -317,7 +317,7 @@ out: } EXPORT_SYMBOL_GPL(hwrng_register); -void __hwrng_unregister(struct hwrng *rng, bool suspended) +void hwrng_unregister(struct hwrng *rng) { int err; @@ -336,11 +336,11 @@ void __hwrng_unregister(struct hwrng *rng, bool suspended) } } if (list_empty(&rng_list)) - unregister_miscdev(suspended); + unregister_miscdev(); mutex_unlock(&rng_mutex); } -EXPORT_SYMBOL_GPL(__hwrng_unregister); +EXPORT_SYMBOL_GPL(hwrng_unregister); MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver"); diff --git a/drivers/char/misc.c b/drivers/char/misc.c index a39101f..4d058da 100644 --- a/drivers/char/misc.c +++ b/drivers/char/misc.c @@ -232,9 +232,8 @@ int misc_register(struct miscdevice * misc) } /** - * __misc_deregister - unregister a miscellaneous device + * misc_deregister - unregister a miscellaneous device * @misc: device to unregister - * @suspended: to be set if the function is used during suspend/resume * * Unregister a miscellaneous device that was previously * successfully registered with misc_register(). Success @@ -242,7 +241,7 @@ int misc_register(struct miscdevice * misc) * indicates an error. */ -int __misc_deregister(struct miscdevice *misc, bool suspended) +int misc_deregister(struct miscdevice *misc) { int i = misc->minor; @@ -251,11 +250,7 @@ int __misc_deregister(struct miscdevice *misc, bool suspended) mutex_lock(&misc_mtx); list_del(&misc->list); - if (suspended) - destroy_suspended_device(misc_class, - MKDEV(MISC_MAJOR, misc->minor)); - else - device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); + device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); if (i < DYNAMIC_MINORS && i>0) { misc_minors[i>>3] &= ~(1 << (misc->minor & 7)); } @@ -264,7 +259,7 @@ int __misc_deregister(struct miscdevice *misc, bool suspended) } EXPORT_SYMBOL(misc_register); -EXPORT_SYMBOL(__misc_deregister); +EXPORT_SYMBOL(misc_deregister); static int __init misc_init(void) { diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index 05f02a3..40ffd76 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -93,4 +93,24 @@ config DMIID information from userspace through /sys/class/dmi/id/ or if you want DMI-based module auto-loading. +config ISCSI_IBFT_FIND + bool "iSCSI Boot Firmware Table Attributes" + depends on X86 + default n + help + This option enables the kernel to find the region of memory + in which the ISCSI Boot Firmware Table (iBFT) resides. This + is necessary for iSCSI Boot Firmware Table Attributes module to work + properly. + +config ISCSI_IBFT + tristate "iSCSI Boot Firmware Table Attributes module" + depends on ISCSI_IBFT_FIND + default n + help + This option enables support for detection and exposing of iSCSI + Boot Firmware Table (iBFT) via sysfs to userspace. If you wish to + detect iSCSI boot parameters dynamically during system boot, say Y. + Otherwise, say N. + endmenu diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile index 8d4ebc8..4c91471 100644 --- a/drivers/firmware/Makefile +++ b/drivers/firmware/Makefile @@ -8,3 +8,5 @@ obj-$(CONFIG_EFI_PCDP) += pcdp.o obj-$(CONFIG_DELL_RBU) += dell_rbu.o obj-$(CONFIG_DCDBAS) += dcdbas.o obj-$(CONFIG_DMIID) += dmi-id.o +obj-$(CONFIG_ISCSI_IBFT_FIND) += iscsi_ibft_find.o +obj-$(CONFIG_ISCSI_IBFT) += iscsi_ibft.o diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c new file mode 100644 index 0000000..8024e3b --- /dev/null +++ b/drivers/firmware/iscsi_ibft.c @@ -0,0 +1,982 @@ +/* + * Copyright 2007 Red Hat, Inc. + * by Peter Jones <pjones@redhat.com> + * Copyright 2008 IBM, Inc. + * by Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Copyright 2008 + * by Konrad Rzeszutek <ketuzsezr@darnok.org> + * + * This code exposes the iSCSI Boot Format Table to userland via sysfs. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License v2.0 as published by + * the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Changelog: + * + * 14 Mar 2008 - Konrad Rzeszutek <ketuzsezr@darnok.org> + * Updated comments and copyrights. (v0.4.9) + * + * 11 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Converted to using ibft_addr. (v0.4.8) + * + * 8 Feb 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Combined two functions in one: reserve_ibft_region. (v0.4.7) + * + * 30 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added logic to handle IPv6 addresses. (v0.4.6) + * + * 25 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added logic to handle badly not-to-spec iBFT. (v0.4.5) + * + * 4 Jan 2008 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added __init to function declarations. (v0.4.4) + * + * 21 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Updated kobject registration, combined unregister functions in one + * and code and style cleanup. (v0.4.3) + * + * 5 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added end-markers to enums and re-organized kobject registration. (v0.4.2) + * + * 4 Dec 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Created 'device' sysfs link to the NIC and style cleanup. (v0.4.1) + * + * 28 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added sysfs-ibft documentation, moved 'find_ibft' function to + * in its own file and added text attributes for every struct field. (v0.4) + * + * 21 Nov 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added text attributes emulating OpenFirmware /proc/device-tree naming. + * Removed binary /sysfs interface (v0.3) + * + * 29 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Added functionality in setup.c to reserve iBFT region. (v0.2) + * + * 27 Aug 2007 - Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * First version exposing iBFT data via a binary /sysfs. (v0.1) + * + */ + + +#include <linux/blkdev.h> +#include <linux/capability.h> +#include <linux/ctype.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/init.h> +#include <linux/iscsi_ibft.h> +#include <linux/limits.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/slab.h> +#include <linux/stat.h> +#include <linux/string.h> +#include <linux/types.h> + +#define IBFT_ISCSI_VERSION "0.4.9" +#define IBFT_ISCSI_DATE "2008-Mar-14" + +MODULE_AUTHOR("Peter Jones <pjones@redhat.com> and \ +Konrad Rzeszutek <ketuzsezr@darnok.org>"); +MODULE_DESCRIPTION("sysfs interface to BIOS iBFT information"); +MODULE_LICENSE("GPL"); +MODULE_VERSION(IBFT_ISCSI_VERSION); + +struct ibft_hdr { + u8 id; + u8 version; + u16 length; + u8 index; + u8 flags; +} __attribute__((__packed__)); + +struct ibft_control { + struct ibft_hdr hdr; + u16 extensions; + u16 initiator_off; + u16 nic0_off; + u16 tgt0_off; + u16 nic1_off; + u16 tgt1_off; +} __attribute__((__packed__)); + +struct ibft_initiator { + struct ibft_hdr hdr; + char isns_server[16]; + char slp_server[16]; + char pri_radius_server[16]; + char sec_radius_server[16]; + u16 initiator_name_len; + u16 initiator_name_off; +} __attribute__((__packed__)); + +struct ibft_nic { + struct ibft_hdr hdr; + char ip_addr[16]; + u8 subnet_mask_prefix; + u8 origin; + char gateway[16]; + char primary_dns[16]; + char secondary_dns[16]; + char dhcp[16]; + u16 vlan; + char mac[6]; + u16 pci_bdf; + u16 hostname_len; + u16 hostname_off; +} __attribute__((__packed__)); + +struct ibft_tgt { + struct ibft_hdr hdr; + char ip_addr[16]; + u16 port; + char lun[8]; + u8 chap_type; + u8 nic_assoc; + u16 tgt_name_len; + u16 tgt_name_off; + u16 chap_name_len; + u16 chap_name_off; + u16 chap_secret_len; + u16 chap_secret_off; + u16 rev_chap_name_len; + u16 rev_chap_name_off; + u16 rev_chap_secret_len; + u16 rev_chap_secret_off; +} __attribute__((__packed__)); + +/* + * The kobject different types and its names. + * +*/ +enum ibft_id { + id_reserved = 0, /* We don't support. */ + id_control = 1, /* Should show up only once and is not exported. */ + id_initiator = 2, + id_nic = 3, + id_target = 4, + id_extensions = 5, /* We don't support. */ + id_end_marker, +}; + +/* + * We do not support the other types, hence the usage of NULL. + * This maps to the enum ibft_id. + */ +static const char *ibft_id_names[] = + {NULL, NULL, "initiator", "ethernet%d", "target%d", NULL, NULL}; + +/* + * The text attributes names for each of the kobjects. +*/ +enum ibft_eth_properties_enum { + ibft_eth_index, + ibft_eth_flags, + ibft_eth_ip_addr, + ibft_eth_subnet_mask, + ibft_eth_origin, + ibft_eth_gateway, + ibft_eth_primary_dns, + ibft_eth_secondary_dns, + ibft_eth_dhcp, + ibft_eth_vlan, + ibft_eth_mac, + /* ibft_eth_pci_bdf - this is replaced by link to the device itself. */ + ibft_eth_hostname, + ibft_eth_end_marker, +}; + +static const char *ibft_eth_properties[] = + {"index", "flags", "ip-addr", "subnet-mask", "origin", "gateway", + "primary-dns", "secondary-dns", "dhcp", "vlan", "mac", "hostname", + NULL}; + +enum ibft_tgt_properties_enum { + ibft_tgt_index, + ibft_tgt_flags, + ibft_tgt_ip_addr, + ibft_tgt_port, + ibft_tgt_lun, + ibft_tgt_chap_type, + ibft_tgt_nic_assoc, + ibft_tgt_name, + ibft_tgt_chap_name, + ibft_tgt_chap_secret, + ibft_tgt_rev_chap_name, + ibft_tgt_rev_chap_secret, + ibft_tgt_end_marker, +}; + +static const char *ibft_tgt_properties[] = + {"index", "flags", "ip-addr", "port", "lun", "chap-type", "nic-assoc", + "target-name", "chap-name", "chap-secret", "rev-chap-name", + "rev-chap-name-secret", NULL}; + +enum ibft_initiator_properties_enum { + ibft_init_index, + ibft_init_flags, + ibft_init_isns_server, + ibft_init_slp_server, + ibft_init_pri_radius_server, + ibft_init_sec_radius_server, + ibft_init_initiator_name, + ibft_init_end_marker, +}; + +static const char *ibft_initiator_properties[] = + {"index", "flags", "isns-server", "slp-server", "pri-radius-server", + "sec-radius-server", "initiator-name", NULL}; + +/* + * The kobject and attribute structures. + */ + +struct ibft_kobject { + struct ibft_table_header *header; + union { + struct ibft_initiator *initiator; + struct ibft_nic *nic; + struct ibft_tgt *tgt; + struct ibft_hdr *hdr; + }; + struct kobject kobj; + struct list_head node; +}; + +struct ibft_attribute { + struct attribute attr; + ssize_t (*show) (struct ibft_kobject *entry, + struct ibft_attribute *attr, char *buf); + union { + struct ibft_initiator *initiator; + struct ibft_nic *nic; + struct ibft_tgt *tgt; + struct ibft_hdr *hdr; + }; + struct kobject *kobj; + int type; /* The enum of the type. This can be any value of: + ibft_eth_properties_enum, ibft_tgt_properties_enum, + or ibft_initiator_properties_enum. */ + struct list_head node; +}; + +static LIST_HEAD(ibft_attr_list); +static LIST_HEAD(ibft_kobject_list); + +static const char nulls[16]; + +/* + * Helper functions to parse data properly. + */ +static ssize_t sprintf_ipaddr(char *buf, u8 *ip) +{ + char *str = buf; + + if (ip[0] == 0 && ip[1] == 0 && ip[2] == 0 && ip[3] == 0 && + ip[4] == 0 && ip[5] == 0 && ip[6] == 0 && ip[7] == 0 && + ip[8] == 0 && ip[9] == 0 && ip[10] == 0xff && ip[11] == 0xff) { + /* + * IPV4 + */ + str += sprintf(buf, NIPQUAD_FMT, ip[12], + ip[13], ip[14], ip[15]); + } else { + /* + * IPv6 + */ + str += sprintf(str, NIP6_FMT, ntohs(ip[0]), ntohs(ip[1]), + ntohs(ip[2]), ntohs(ip[3]), ntohs(ip[4]), + ntohs(ip[5]), ntohs(ip[6]), ntohs(ip[7])); + } + str += sprintf(str, "\n"); + return str - buf; +} + +static ssize_t sprintf_string(char *str, int len, char *buf) +{ + return sprintf(str, "%.*s\n", len, buf); +} + +/* + * Helper function to verify the IBFT header. + */ +static int ibft_verify_hdr(char *t, struct ibft_hdr *hdr, int id, int length) +{ + if (hdr->id != id) { + printk(KERN_ERR "iBFT error: We expected the " \ + "field header.id to have %d but " \ + "found %d instead!\n", id, hdr->id); + return -ENODEV; + } + if (hdr->length != length) { + printk(KERN_ERR "iBFT error: We expected the " \ + "field header.length to have %d but " \ + "found %d instead!\n", length, hdr->length); + return -ENODEV; + } + + return 0; +} + +static void ibft_release(struct kobject *kobj) +{ + struct ibft_kobject *ibft = + container_of(kobj, struct ibft_kobject, kobj); + kfree(ibft); +} + +/* + * Routines for parsing the iBFT data to be human readable. + */ +ssize_t ibft_attr_show_initiator(struct ibft_kobject *entry, + struct ibft_attribute *attr, + char *buf) +{ + struct ibft_initiator *initiator = entry->initiator; + void *ibft_loc = entry->header; + char *str = buf; + + if (!initiator) + return 0; + + switch (attr->type) { + case ibft_init_index: + str += sprintf(str, "%d\n", initiator->hdr.index); + break; + case ibft_init_flags: + str += sprintf(str, "%d\n", initiator->hdr.flags); + break; + case ibft_init_isns_server: + str += sprintf_ipaddr(str, initiator->isns_server); + break; + case ibft_init_slp_server: + str += sprintf_ipaddr(str, initiator->slp_server); + break; + case ibft_init_pri_radius_server: + str += sprintf_ipaddr(str, initiator->pri_radius_server); + break; + case ibft_init_sec_radius_server: + str += sprintf_ipaddr(str, initiator->sec_radius_server); + break; + case ibft_init_initiator_name: + str += sprintf_string(str, initiator->initiator_name_len, + (char *)ibft_loc + + initiator->initiator_name_off); + break; + default: + break; + } + + return str - buf; +} + +ssize_t ibft_attr_show_nic(struct ibft_kobject *entry, + struct ibft_attribute *attr, + char *buf) +{ + struct ibft_nic *nic = entry->nic; + void *ibft_loc = entry->header; + char *str = buf; + char *mac; + int val; + + if (!nic) + return 0; + + switch (attr->type) { + case ibft_eth_index: + str += sprintf(str, "%d\n", nic->hdr.index); + break; + case ibft_eth_flags: + str += sprintf(str, "%d\n", nic->hdr.flags); + break; + case ibft_eth_ip_addr: + str += sprintf_ipaddr(str, nic->ip_addr); + break; + case ibft_eth_subnet_mask: + val = ~((1 << (32-nic->subnet_mask_prefix))-1); + str += sprintf(str, NIPQUAD_FMT, + (u8)(val >> 24), (u8)(val >> 16), + (u8)(val >> 8), (u8)(val)); + break; + case ibft_eth_origin: + str += sprintf(str, "%d\n", nic->origin); + break; + case ibft_eth_gateway: + str += sprintf_ipaddr(str, nic->gateway); + break; + case ibft_eth_primary_dns: + str += sprintf_ipaddr(str, nic->primary_dns); + break; + case ibft_eth_secondary_dns: + str += sprintf_ipaddr(str, nic->secondary_dns); + break; + case ibft_eth_dhcp: + str += sprintf_ipaddr(str, nic->dhcp); + break; + case ibft_eth_vlan: + str += sprintf(str, "%d\n", nic->vlan); + break; + case ibft_eth_mac: + mac = nic->mac; + str += sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x\n", + (u8)mac[0], (u8)mac[1], (u8)mac[2], + (u8)mac[3], (u8)mac[4], (u8)mac[5]); + break; + case ibft_eth_hostname: + str += sprintf_string(str, nic->hostname_len, + (char *)ibft_loc + nic->hostname_off); + break; + default: + break; + } + + return str - buf; +}; + +ssize_t ibft_attr_show_target(struct ibft_kobject *entry, + struct ibft_attribute *attr, + char *buf) +{ + struct ibft_tgt *tgt = entry->tgt; + void *ibft_loc = entry->header; + char *str = buf; + int i; + + if (!tgt) + return 0; + + switch (attr->type) { + case ibft_tgt_index: + str += sprintf(str, "%d\n", tgt->hdr.index); + break; + case ibft_tgt_flags: + str += sprintf(str, "%d\n", tgt->hdr.flags); + break; + case ibft_tgt_ip_addr: + str += sprintf_ipaddr(str, tgt->ip_addr); + break; + case ibft_tgt_port: + str += sprintf(str, "%d\n", tgt->port); + break; + case ibft_tgt_lun: + for (i = 0; i < 8; i++) + str += sprintf(str, "%x", (u8)tgt->lun[i]); + str += sprintf(str, "\n"); + break; + case ibft_tgt_nic_assoc: + str += sprintf(str, "%d\n", tgt->nic_assoc); + break; + case ibft_tgt_chap_type: + str += sprintf(str, "%d\n", tgt->chap_type); + break; + case ibft_tgt_name: + str += sprintf_string(str, tgt->tgt_name_len, + (char *)ibft_loc + tgt->tgt_name_off); + break; + case ibft_tgt_chap_name: + str += sprintf_string(str, tgt->chap_name_len, + (char *)ibft_loc + tgt->chap_name_off); + break; + case ibft_tgt_chap_secret: + str += sprintf_string(str, tgt->chap_secret_len, + (char *)ibft_loc + tgt->chap_secret_off); + break; + case ibft_tgt_rev_chap_name: + str += sprintf_string(str, tgt->rev_chap_name_len, + (char *)ibft_loc + + tgt->rev_chap_name_off); + break; + case ibft_tgt_rev_chap_secret: + str += sprintf_string(str, tgt->rev_chap_secret_len, + (char *)ibft_loc + + tgt->rev_chap_secret_off); + break; + default: + break; + } + + return str - buf; +} + +/* + * The routine called for all sysfs attributes. + */ +static ssize_t ibft_show_attribute(struct kobject *kobj, + struct attribute *attr, + char *buf) +{ + struct ibft_kobject *dev = + container_of(kobj, struct ibft_kobject, kobj); + struct ibft_attribute *ibft_attr = + container_of(attr, struct ibft_attribute, attr); + ssize_t ret = -EIO; + char *str = buf; + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + if (ibft_attr->show) + ret = ibft_attr->show(dev, ibft_attr, str); + + return ret; +} + +static struct sysfs_ops ibft_attr_ops = { + .show = ibft_show_attribute, +}; + +static struct kobj_type ibft_ktype = { + .release = ibft_release, + .sysfs_ops = &ibft_attr_ops, +}; + +static struct kset *ibft_kset; + +static int __init ibft_check_device(void) +{ + int len; + u8 *pos; + u8 csum = 0; + + len = ibft_addr->length; + + /* Sanity checking of iBFT. */ + if (ibft_addr->revision != 1) { + printk(KERN_ERR "iBFT module supports only revision 1, " \ + "while this is %d.\n", ibft_addr->revision); + return -ENOENT; + } + for (pos = (u8 *)ibft_addr; pos < (u8 *)ibft_addr + len; pos++) + csum += *pos; + + if (csum) { + printk(KERN_ERR "iBFT has incorrect checksum (0x%x)!\n", csum); + return -ENOENT; + } + + return 0; +} + +/* + * Helper function for ibft_register_kobjects. + */ +static int __init ibft_create_kobject(struct ibft_table_header *header, + struct ibft_hdr *hdr, + struct list_head *list) +{ + struct ibft_kobject *ibft_kobj = NULL; + struct ibft_nic *nic = (struct ibft_nic *)hdr; + struct pci_dev *pci_dev; + int rc = 0; + + ibft_kobj = kzalloc(sizeof(*ibft_kobj), GFP_KERNEL); + if (!ibft_kobj) + return -ENOMEM; + + ibft_kobj->header = header; + ibft_kobj->hdr = hdr; + + switch (hdr->id) { + case id_initiator: + rc = ibft_verify_hdr("initiator", hdr, id_initiator, + sizeof(*ibft_kobj->initiator)); + break; + case id_nic: + rc = ibft_verify_hdr("ethernet", hdr, id_nic, + sizeof(*ibft_kobj->nic)); + break; + case id_target: + rc = ibft_verify_hdr("target", hdr, id_target, + sizeof(*ibft_kobj->tgt)); + break; + case id_reserved: + case id_control: + case id_extensions: + /* Fields which we don't support. Ignore them */ + rc = 1; + break; + default: + printk(KERN_ERR "iBFT has unknown structure type (%d). " \ + "Report this bug to %.6s!\n", hdr->id, + header->oem_id); + rc = 1; + break; + } + + if (rc) { + /* Skip adding this kobject, but exit with non-fatal error. */ + kfree(ibft_kobj); + goto out_invalid_struct; + } + + ibft_kobj->kobj.kset = ibft_kset; + + rc = kobject_init_and_add(&ibft_kobj->kobj, &ibft_ktype, + NULL, ibft_id_names[hdr->id], hdr->index); + + if (rc) { + kfree(ibft_kobj); + goto out; + } + + kobject_uevent(&ibft_kobj->kobj, KOBJ_ADD); + + if (hdr->id == id_nic) { + /* + * We don't search for the device in other domains than + * zero. This is because on x86 platforms the BIOS + * executes only devices which are in domain 0. Furthermore, the + * iBFT spec doesn't have a domain id field :-( + */ + pci_dev = pci_get_bus_and_slot((nic->pci_bdf & 0xff00) >> 8, + (nic->pci_bdf & 0xff)); + if (pci_dev) { + rc = sysfs_create_link(&ibft_kobj->kobj, + &pci_dev->dev.kobj, "device"); + pci_dev_put(pci_dev); + } + } + + /* Nothing broke so lets add it to the list. */ + list_add_tail(&ibft_kobj->node, list); +out: + return rc; +out_invalid_struct: + /* Unsupported structs are skipped. */ + return 0; +} + +/* + * Scan the IBFT table structure for the NIC and Target fields. When + * found add them on the passed-in list. We do not support the other + * fields at this point, so they are skipped. + */ +static int __init ibft_register_kobjects(struct ibft_table_header *header, + struct list_head *list) +{ + struct ibft_control *control = NULL; + void *ptr, *end; + int rc = 0; + u16 offset; + u16 eot_offset; + + control = (void *)header + sizeof(*header); + end = (void *)control + control->hdr.length; + eot_offset = (void *)header + header->length - + (void *)control - sizeof(*header); + rc = ibft_verify_hdr("control", (struct ibft_hdr *)control, id_control, + sizeof(*control)); + + /* iBFT table safety checking */ + rc |= ((control->hdr.index) ? -ENODEV : 0); + if (rc) { + printk(KERN_ERR "iBFT error: Control header is invalid!\n"); + return rc; + } + for (ptr = &control->initiator_off; ptr < end; ptr += sizeof(u16)) { + offset = *(u16 *)ptr; + if (offset && offset < header->length && offset < eot_offset) { + rc = ibft_create_kobject(header, + (void *)header + offset, + list); + if (rc) + break; + } + } + + return rc; +} + +static void ibft_unregister(struct list_head *attr_list, + struct list_head *kobj_list) +{ + struct ibft_kobject *data = NULL, *n; + struct ibft_attribute *attr = NULL, *m; + + list_for_each_entry_safe(attr, m, attr_list, node) { + sysfs_remove_file(attr->kobj, &attr->attr); + list_del(&attr->node); + kfree(attr); + }; + list_del_init(attr_list); + + list_for_each_entry_safe(data, n, kobj_list, node) { + list_del(&data->node); + if (data->hdr->id == id_nic) + sysfs_remove_link(&data->kobj, "device"); + kobject_put(&data->kobj); + }; + list_del_init(kobj_list); +} + +static int __init ibft_create_attribute(struct ibft_kobject *kobj_data, + int type, + const char *name, + ssize_t (*show)(struct ibft_kobject *, + struct ibft_attribute*, + char *buf), + struct list_head *list) +{ + struct ibft_attribute *attr = NULL; + struct ibft_hdr *hdr = kobj_data->hdr; + + attr = kmalloc(sizeof(*attr), GFP_KERNEL); + if (!attr) + return -ENOMEM; + + attr->attr.name = name; + attr->attr.mode = S_IRUSR; + attr->attr.owner = THIS_MODULE; + + attr->hdr = hdr; + attr->show = show; + attr->kobj = &kobj_data->kobj; + attr->type = type; + + list_add_tail(&attr->node, list); + + return 0; +} + +/* + * Helper routiners to check to determine if the entry is valid + * in the proper iBFT structure. + */ +static int __init ibft_check_nic_for(struct ibft_nic *nic, int entry) +{ + int rc = 0; + + switch (entry) { + case ibft_eth_index: + case ibft_eth_flags: + rc = 1; + break; + case ibft_eth_ip_addr: + if (!memcmp(nic->dhcp, nulls, sizeof(nic->dhcp))) + rc = 1; + break; + case ibft_eth_subnet_mask: + if (!memcmp(nic->dhcp, nulls, sizeof(nic->dhcp))) + rc = 1; + break; + case ibft_eth_origin: + rc = 1; + break; + case ibft_eth_gateway: + if (memcmp(nic->gateway, nulls, sizeof(nic->gateway))) + rc = 1; + break; + case ibft_eth_primary_dns: + if (memcmp(nic->primary_dns, nulls, + sizeof(nic->primary_dns))) + rc = 1; + break; + case ibft_eth_secondary_dns: + if (memcmp(nic->secondary_dns, nulls, + sizeof(nic->secondary_dns))) + rc = 1; + break; + case ibft_eth_dhcp: + if (memcmp(nic->dhcp, nulls, sizeof(nic->dhcp))) + rc = 1; + break; + case ibft_eth_vlan: + case ibft_eth_mac: + rc = 1; + break; + case ibft_eth_hostname: + if (nic->hostname_off) + rc = 1; + break; + default: + break; + } + + return rc; +} + +static int __init ibft_check_tgt_for(struct ibft_tgt *tgt, int entry) +{ + int rc = 0; + + switch (entry) { + case ibft_tgt_index: + case ibft_tgt_flags: + case ibft_tgt_ip_addr: + case ibft_tgt_port: + case ibft_tgt_lun: + case ibft_tgt_nic_assoc: + case ibft_tgt_chap_type: + rc = 1; + case ibft_tgt_name: + if (tgt->tgt_name_len) + rc = 1; + break; + case ibft_tgt_chap_name: + case ibft_tgt_chap_secret: + if (tgt->chap_name_len) + rc = 1; + break; + case ibft_tgt_rev_chap_name: + case ibft_tgt_rev_chap_secret: + if (tgt->rev_chap_name_len) + rc = 1; + break; + default: + break; + } + + return rc; +} + +static int __init ibft_check_initiator_for(struct ibft_initiator *init, + int entry) +{ + int rc = 0; + + switch (entry) { + case ibft_init_index: + case ibft_init_flags: + rc = 1; + break; + case ibft_init_isns_server: + if (memcmp(init->isns_server, nulls, + sizeof(init->isns_server))) + rc = 1; + break; + case ibft_init_slp_server: + if (memcmp(init->slp_server, nulls, + sizeof(init->slp_server))) + rc = 1; + break; + case ibft_init_pri_radius_server: + if (memcmp(init->pri_radius_server, nulls, + sizeof(init->pri_radius_server))) + rc = 1; + break; + case ibft_init_sec_radius_server: + if (memcmp(init->sec_radius_server, nulls, + sizeof(init->sec_radius_server))) + rc = 1; + break; + case ibft_init_initiator_name: + if (init->initiator_name_len) + rc = 1; + break; + default: + break; + } + + return rc; +} + +/* + * Register the attributes for all of the kobjects. + */ +static int __init ibft_register_attributes(struct list_head *kobject_list, + struct list_head *attr_list) +{ + int rc = 0, i = 0; + struct ibft_kobject *data = NULL; + struct ibft_attribute *attr = NULL, *m; + + list_for_each_entry(data, kobject_list, node) { + switch (data->hdr->id) { + case id_nic: + for (i = 0; i < ibft_eth_end_marker && !rc; i++) + if (ibft_check_nic_for(data->nic, i)) + rc = ibft_create_attribute(data, i, + ibft_eth_properties[i], + ibft_attr_show_nic, attr_list); + break; + case id_target: + for (i = 0; i < ibft_tgt_end_marker && !rc; i++) + if (ibft_check_tgt_for(data->tgt, i)) + rc = ibft_create_attribute(data, i, + ibft_tgt_properties[i], + ibft_attr_show_target, + attr_list); + break; + case id_initiator: + for (i = 0; i < ibft_init_end_marker && !rc; i++) + if (ibft_check_initiator_for( + data->initiator, i)) + rc = ibft_create_attribute(data, i, + ibft_initiator_properties[i], + ibft_attr_show_initiator, + attr_list); + break; + default: + break; + } + if (rc) + break; + } + list_for_each_entry_safe(attr, m, attr_list, node) { + rc = sysfs_create_file(attr->kobj, &attr->attr); + if (rc) { + list_del(&attr->node); + kfree(attr); + break; + } + } + + return rc; +} + +/* + * ibft_init() - creates sysfs tree entries for the iBFT data. + */ +static int __init ibft_init(void) +{ + int rc = 0; + + ibft_kset = kset_create_and_add("ibft", NULL, firmware_kobj); + if (!ibft_kset) + return -ENOMEM; + + if (ibft_addr) { + printk(KERN_INFO "iBFT detected at 0x%lx.\n", + virt_to_phys((void *)ibft_addr)); + + rc = ibft_check_device(); + if (rc) + goto out_firmware_unregister; + + /* Scan the IBFT for data and register the kobjects. */ + rc = ibft_register_kobjects(ibft_addr, &ibft_kobject_list); + if (rc) + goto out_free; + + /* Register the attributes */ + rc = ibft_register_attributes(&ibft_kobject_list, + &ibft_attr_list); + if (rc) + goto out_free; + } else + printk(KERN_INFO "No iBFT detected.\n"); + + return 0; + +out_free: + ibft_unregister(&ibft_attr_list, &ibft_kobject_list); +out_firmware_unregister: + kset_unregister(ibft_kset); + return rc; +} + +static void __exit ibft_exit(void) +{ + ibft_unregister(&ibft_attr_list, &ibft_kobject_list); + kset_unregister(ibft_kset); +} + +module_init(ibft_init); +module_exit(ibft_exit); diff --git a/drivers/firmware/iscsi_ibft_find.c b/drivers/firmware/iscsi_ibft_find.c new file mode 100644 index 0000000..d0e5fa4 --- /dev/null +++ b/drivers/firmware/iscsi_ibft_find.c @@ -0,0 +1,84 @@ +/* + * Copyright 2007 Red Hat, Inc. + * by Peter Jones <pjones@redhat.com> + * Copyright 2007 IBM, Inc. + * by Konrad Rzeszutek <konradr@linux.vnet.ibm.com> + * Copyright 2008 + * by Konrad Rzeszutek <ketuzsezr@darnok.org> + * + * This code finds the iSCSI Boot Format Table. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License v2.0 as published by + * the Free Software Foundation + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <linux/bootmem.h> +#include <linux/blkdev.h> +#include <linux/ctype.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/init.h> +#include <linux/limits.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/slab.h> +#include <linux/stat.h> +#include <linux/string.h> +#include <linux/types.h> + +#include <asm/mmzone.h> + +/* + * Physical location of iSCSI Boot Format Table. + */ +struct ibft_table_header *ibft_addr; +EXPORT_SYMBOL_GPL(ibft_addr); + +#define IBFT_SIGN "iBFT" +#define IBFT_SIGN_LEN 4 +#define IBFT_START 0x80000 /* 512kB */ +#define IBFT_END 0x100000 /* 1MB */ +#define VGA_MEM 0xA0000 /* VGA buffer */ +#define VGA_SIZE 0x20000 /* 128kB */ + + +/* + * Routine used to find the iSCSI Boot Format Table. The logical + * kernel address is set in the ibft_addr global variable. + */ +void __init reserve_ibft_region(void) +{ + unsigned long pos; + unsigned int len = 0; + void *virt; + + ibft_addr = 0; + + for (pos = IBFT_START; pos < IBFT_END; pos += 16) { + /* The table can't be inside the VGA BIOS reserved space, + * so skip that area */ + if (pos == VGA_MEM) + pos += VGA_SIZE; + virt = phys_to_virt(pos); + if (memcmp(virt, IBFT_SIGN, IBFT_SIGN_LEN) == 0) { + unsigned long *addr = + (unsigned long *)phys_to_virt(pos + 4); + len = *addr; + /* if the length of the table extends past 1M, + * the table cannot be valid. */ + if (pos + len <= (IBFT_END-1)) { + ibft_addr = (struct ibft_table_header *)virt; + break; + } + } + } + if (ibft_addr) + reserve_bootmem(pos, PAGE_ALIGN(len), BOOTMEM_DEFAULT); +} +EXPORT_SYMBOL_GPL(reserve_ibft_region); diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c index 5a4b2e6..9575655 100644 --- a/drivers/infiniband/core/sysfs.c +++ b/drivers/infiniband/core/sysfs.c @@ -427,17 +427,17 @@ static struct kobj_type port_type = { .default_attrs = port_default_attrs }; -static void ib_device_release(struct class_device *cdev) +static void ib_device_release(struct device *device) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); kfree(dev); } -static int ib_device_uevent(struct class_device *cdev, +static int ib_device_uevent(struct device *device, struct kobj_uevent_env *env) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); if (add_uevent_var(env, "NAME=%s", dev->name)) return -ENOMEM; @@ -567,9 +567,10 @@ err_put: return ret; } -static ssize_t show_node_type(struct class_device *cdev, char *buf) +static ssize_t show_node_type(struct device *device, + struct device_attribute *attr, char *buf) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); if (!ibdev_is_alive(dev)) return -ENODEV; @@ -583,9 +584,10 @@ static ssize_t show_node_type(struct class_device *cdev, char *buf) } } -static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf) +static ssize_t show_sys_image_guid(struct device *device, + struct device_attribute *dev_attr, char *buf) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); struct ib_device_attr attr; ssize_t ret; @@ -603,9 +605,10 @@ static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf) be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3])); } -static ssize_t show_node_guid(struct class_device *cdev, char *buf) +static ssize_t show_node_guid(struct device *device, + struct device_attribute *attr, char *buf) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); if (!ibdev_is_alive(dev)) return -ENODEV; @@ -617,17 +620,19 @@ static ssize_t show_node_guid(struct class_device *cdev, char *buf) be16_to_cpu(((__be16 *) &dev->node_guid)[3])); } -static ssize_t show_node_desc(struct class_device *cdev, char *buf) +static ssize_t show_node_desc(struct device *device, + struct device_attribute *attr, char *buf) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); return sprintf(buf, "%.64s\n", dev->node_desc); } -static ssize_t set_node_desc(struct class_device *cdev, const char *buf, - size_t count) +static ssize_t set_node_desc(struct device *device, + struct device_attribute *attr, + const char *buf, size_t count) { - struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device *dev = container_of(device, struct ib_device, dev); struct ib_device_modify desc = {}; int ret; @@ -642,44 +647,43 @@ static ssize_t set_node_desc(struct class_device *cdev, const char *buf, return count; } -static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL); -static CLASS_DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL); -static CLASS_DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL); -static CLASS_DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, - set_node_desc); - -static struct class_device_attribute *ib_class_attributes[] = { - &class_device_attr_node_type, - &class_device_attr_sys_image_guid, - &class_device_attr_node_guid, - &class_device_attr_node_desc +static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL); +static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL); +static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL); +static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc); + +static struct device_attribute *ib_class_attributes[] = { + &dev_attr_node_type, + &dev_attr_sys_image_guid, + &dev_attr_node_guid, + &dev_attr_node_desc }; static struct class ib_class = { .name = "infiniband", - .release = ib_device_release, - .uevent = ib_device_uevent, + .dev_release = ib_device_release, + .dev_uevent = ib_device_uevent, }; int ib_device_register_sysfs(struct ib_device *device) { - struct class_device *class_dev = &device->class_dev; + struct device *class_dev = &device->dev; int ret; int i; class_dev->class = &ib_class; - class_dev->class_data = device; - class_dev->dev = device->dma_device; - strlcpy(class_dev->class_id, device->name, BUS_ID_SIZE); + class_dev->driver_data = device; + class_dev->parent = device->dma_device; + strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE); INIT_LIST_HEAD(&device->port_list); - ret = class_device_register(class_dev); + ret = device_register(class_dev); if (ret) goto err; for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) { - ret = class_device_create_file(class_dev, ib_class_attributes[i]); + ret = device_create_file(class_dev, ib_class_attributes[i]); if (ret) goto err_unregister; } @@ -723,7 +727,7 @@ err_put: kobject_put(&class_dev->kobj); err_unregister: - class_device_unregister(class_dev); + device_unregister(class_dev); err: return ret; @@ -744,7 +748,7 @@ void ib_device_unregister_sysfs(struct ib_device *device) } kobject_put(device->ports_parent); - class_device_unregister(&device->class_dev); + device_unregister(&device->dev); } int ib_sysfs_setup(void) diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c index 4291ab4..d7a6881 100644 --- a/drivers/infiniband/core/ucm.c +++ b/drivers/infiniband/core/ucm.c @@ -58,8 +58,8 @@ MODULE_LICENSE("Dual BSD/GPL"); struct ib_ucm_device { int devnum; - struct cdev dev; - struct class_device class_dev; + struct cdev cdev; + struct device dev; struct ib_device *ib_dev; }; @@ -1171,7 +1171,7 @@ static int ib_ucm_open(struct inode *inode, struct file *filp) filp->private_data = file; file->filp = filp; - file->device = container_of(inode->i_cdev, struct ib_ucm_device, dev); + file->device = container_of(inode->i_cdev, struct ib_ucm_device, cdev); return 0; } @@ -1202,14 +1202,14 @@ static int ib_ucm_close(struct inode *inode, struct file *filp) return 0; } -static void ucm_release_class_dev(struct class_device *class_dev) +static void ib_ucm_release_dev(struct device *dev) { - struct ib_ucm_device *dev; + struct ib_ucm_device *ucm_dev; - dev = container_of(class_dev, struct ib_ucm_device, class_dev); - cdev_del(&dev->dev); - clear_bit(dev->devnum, dev_map); - kfree(dev); + ucm_dev = container_of(dev, struct ib_ucm_device, dev); + cdev_del(&ucm_dev->cdev); + clear_bit(ucm_dev->devnum, dev_map); + kfree(ucm_dev); } static const struct file_operations ucm_fops = { @@ -1220,14 +1220,15 @@ static const struct file_operations ucm_fops = { .poll = ib_ucm_poll, }; -static ssize_t show_ibdev(struct class_device *class_dev, char *buf) +static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, + char *buf) { - struct ib_ucm_device *dev; + struct ib_ucm_device *ucm_dev; - dev = container_of(class_dev, struct ib_ucm_device, class_dev); - return sprintf(buf, "%s\n", dev->ib_dev->name); + ucm_dev = container_of(dev, struct ib_ucm_device, dev); + return sprintf(buf, "%s\n", ucm_dev->ib_dev->name); } -static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); +static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); static void ib_ucm_add_one(struct ib_device *device) { @@ -1249,32 +1250,31 @@ static void ib_ucm_add_one(struct ib_device *device) set_bit(ucm_dev->devnum, dev_map); - cdev_init(&ucm_dev->dev, &ucm_fops); - ucm_dev->dev.owner = THIS_MODULE; - kobject_set_name(&ucm_dev->dev.kobj, "ucm%d", ucm_dev->devnum); - if (cdev_add(&ucm_dev->dev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1)) + cdev_init(&ucm_dev->cdev, &ucm_fops); + ucm_dev->cdev.owner = THIS_MODULE; + kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum); + if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1)) goto err; - ucm_dev->class_dev.class = &cm_class; - ucm_dev->class_dev.dev = device->dma_device; - ucm_dev->class_dev.devt = ucm_dev->dev.dev; - ucm_dev->class_dev.release = ucm_release_class_dev; - snprintf(ucm_dev->class_dev.class_id, BUS_ID_SIZE, "ucm%d", + ucm_dev->dev.class = &cm_class; + ucm_dev->dev.parent = device->dma_device; + ucm_dev->dev.devt = ucm_dev->cdev.dev; + ucm_dev->dev.release = ib_ucm_release_dev; + snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d", ucm_dev->devnum); - if (class_device_register(&ucm_dev->class_dev)) + if (device_register(&ucm_dev->dev)) goto err_cdev; - if (class_device_create_file(&ucm_dev->class_dev, - &class_device_attr_ibdev)) - goto err_class; + if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev)) + goto err_dev; ib_set_client_data(device, &ucm_client, ucm_dev); return; -err_class: - class_device_unregister(&ucm_dev->class_dev); +err_dev: + device_unregister(&ucm_dev->dev); err_cdev: - cdev_del(&ucm_dev->dev); + cdev_del(&ucm_dev->cdev); clear_bit(ucm_dev->devnum, dev_map); err: kfree(ucm_dev); @@ -1288,7 +1288,7 @@ static void ib_ucm_remove_one(struct ib_device *device) if (!ucm_dev) return; - class_device_unregister(&ucm_dev->class_dev); + device_unregister(&ucm_dev->dev); } static ssize_t show_abi_version(struct class *class, char *buf) diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c index be953e8..3aa2db5 100644 --- a/drivers/infiniband/core/user_mad.c +++ b/drivers/infiniband/core/user_mad.c @@ -88,11 +88,11 @@ enum { */ struct ib_umad_port { - struct cdev *dev; - struct class_device *class_dev; + struct cdev *cdev; + struct device *dev; - struct cdev *sm_dev; - struct class_device *sm_class_dev; + struct cdev *sm_cdev; + struct device *sm_dev; struct semaphore sm_sem; struct mutex file_mutex; @@ -948,27 +948,29 @@ static struct ib_client umad_client = { .remove = ib_umad_remove_one }; -static ssize_t show_ibdev(struct class_device *class_dev, char *buf) +static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, + char *buf) { - struct ib_umad_port *port = class_get_devdata(class_dev); + struct ib_umad_port *port = dev_get_drvdata(dev); if (!port) return -ENODEV; return sprintf(buf, "%s\n", port->ib_dev->name); } -static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); +static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); -static ssize_t show_port(struct class_device *class_dev, char *buf) +static ssize_t show_port(struct device *dev, struct device_attribute *attr, + char *buf) { - struct ib_umad_port *port = class_get_devdata(class_dev); + struct ib_umad_port *port = dev_get_drvdata(dev); if (!port) return -ENODEV; return sprintf(buf, "%d\n", port->port_num); } -static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); +static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); static ssize_t show_abi_version(struct class *class, char *buf) { @@ -994,48 +996,47 @@ static int ib_umad_init_port(struct ib_device *device, int port_num, mutex_init(&port->file_mutex); INIT_LIST_HEAD(&port->file_list); - port->dev = cdev_alloc(); - if (!port->dev) + port->cdev = cdev_alloc(); + if (!port->cdev) return -1; - port->dev->owner = THIS_MODULE; - port->dev->ops = &umad_fops; - kobject_set_name(&port->dev->kobj, "umad%d", port->dev_num); - if (cdev_add(port->dev, base_dev + port->dev_num, 1)) + port->cdev->owner = THIS_MODULE; + port->cdev->ops = &umad_fops; + kobject_set_name(&port->cdev->kobj, "umad%d", port->dev_num); + if (cdev_add(port->cdev, base_dev + port->dev_num, 1)) goto err_cdev; - port->class_dev = class_device_create(umad_class, NULL, port->dev->dev, - device->dma_device, - "umad%d", port->dev_num); - if (IS_ERR(port->class_dev)) + port->dev = device_create(umad_class, device->dma_device, + port->cdev->dev, "umad%d", port->dev_num); + if (IS_ERR(port->dev)) goto err_cdev; - if (class_device_create_file(port->class_dev, &class_device_attr_ibdev)) - goto err_class; - if (class_device_create_file(port->class_dev, &class_device_attr_port)) - goto err_class; - - port->sm_dev = cdev_alloc(); - if (!port->sm_dev) - goto err_class; - port->sm_dev->owner = THIS_MODULE; - port->sm_dev->ops = &umad_sm_fops; - kobject_set_name(&port->sm_dev->kobj, "issm%d", port->dev_num); - if (cdev_add(port->sm_dev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1)) + if (device_create_file(port->dev, &dev_attr_ibdev)) + goto err_dev; + if (device_create_file(port->dev, &dev_attr_port)) + goto err_dev; + + port->sm_cdev = cdev_alloc(); + if (!port->sm_cdev) + goto err_dev; + port->sm_cdev->owner = THIS_MODULE; + port->sm_cdev->ops = &umad_sm_fops; + kobject_set_name(&port->sm_cdev->kobj, "issm%d", port->dev_num); + if (cdev_add(port->sm_cdev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1)) goto err_sm_cdev; - port->sm_class_dev = class_device_create(umad_class, NULL, port->sm_dev->dev, - device->dma_device, - "issm%d", port->dev_num); - if (IS_ERR(port->sm_class_dev)) + port->sm_dev = device_create(umad_class, device->dma_device, + port->sm_cdev->dev, + "issm%d", port->dev_num); + if (IS_ERR(port->sm_dev)) goto err_sm_cdev; - class_set_devdata(port->class_dev, port); - class_set_devdata(port->sm_class_dev, port); + dev_set_drvdata(port->dev, port); + dev_set_drvdata(port->sm_dev, port); - if (class_device_create_file(port->sm_class_dev, &class_device_attr_ibdev)) - goto err_sm_class; - if (class_device_create_file(port->sm_class_dev, &class_device_attr_port)) - goto err_sm_class; + if (device_create_file(port->sm_dev, &dev_attr_ibdev)) + goto err_sm_dev; + if (device_create_file(port->sm_dev, &dev_attr_port)) + goto err_sm_dev; spin_lock(&port_lock); umad_port[port->dev_num] = port; @@ -1043,17 +1044,17 @@ static int ib_umad_init_port(struct ib_device *device, int port_num, return 0; -err_sm_class: - class_device_destroy(umad_class, port->sm_dev->dev); +err_sm_dev: + device_destroy(umad_class, port->sm_cdev->dev); err_sm_cdev: - cdev_del(port->sm_dev); + cdev_del(port->sm_cdev); -err_class: - class_device_destroy(umad_class, port->dev->dev); +err_dev: + device_destroy(umad_class, port->cdev->dev); err_cdev: - cdev_del(port->dev); + cdev_del(port->cdev); clear_bit(port->dev_num, dev_map); return -1; @@ -1065,14 +1066,14 @@ static void ib_umad_kill_port(struct ib_umad_port *port) int already_dead; int id; - class_set_devdata(port->class_dev, NULL); - class_set_devdata(port->sm_class_dev, NULL); + dev_set_drvdata(port->dev, NULL); + dev_set_drvdata(port->sm_dev, NULL); - class_device_destroy(umad_class, port->dev->dev); - class_device_destroy(umad_class, port->sm_dev->dev); + device_destroy(umad_class, port->cdev->dev); + device_destroy(umad_class, port->sm_cdev->dev); - cdev_del(port->dev); - cdev_del(port->sm_dev); + cdev_del(port->cdev); + cdev_del(port->sm_cdev); spin_lock(&port_lock); umad_port[port->dev_num] = NULL; diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h index 2cad8b4..376a57c 100644 --- a/drivers/infiniband/core/uverbs.h +++ b/drivers/infiniband/core/uverbs.h @@ -73,8 +73,8 @@ struct ib_uverbs_device { struct kref ref; struct completion comp; int devnum; - struct cdev *dev; - struct class_device *class_dev; + struct cdev *cdev; + struct device *dev; struct ib_device *ib_dev; int num_comp_vectors; }; diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c index f49f946..cc1afa2 100644 --- a/drivers/infiniband/core/uverbs_main.c +++ b/drivers/infiniband/core/uverbs_main.c @@ -690,27 +690,29 @@ static struct ib_client uverbs_client = { .remove = ib_uverbs_remove_one }; -static ssize_t show_ibdev(struct class_device *class_dev, char *buf) +static ssize_t show_ibdev(struct device *device, struct device_attribute *attr, + char *buf) { - struct ib_uverbs_device *dev = class_get_devdata(class_dev); + struct ib_uverbs_device *dev = dev_get_drvdata(device); if (!dev) return -ENODEV; return sprintf(buf, "%s\n", dev->ib_dev->name); } -static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); +static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); -static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf) +static ssize_t show_dev_abi_version(struct device *device, + struct device_attribute *attr, char *buf) { - struct ib_uverbs_device *dev = class_get_devdata(class_dev); + struct ib_uverbs_device *dev = dev_get_drvdata(device); if (!dev) return -ENODEV; return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver); } -static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL); +static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL); static ssize_t show_abi_version(struct class *class, char *buf) { @@ -744,27 +746,26 @@ static void ib_uverbs_add_one(struct ib_device *device) uverbs_dev->ib_dev = device; uverbs_dev->num_comp_vectors = device->num_comp_vectors; - uverbs_dev->dev = cdev_alloc(); - if (!uverbs_dev->dev) + uverbs_dev->cdev = cdev_alloc(); + if (!uverbs_dev->cdev) goto err; - uverbs_dev->dev->owner = THIS_MODULE; - uverbs_dev->dev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops; - kobject_set_name(&uverbs_dev->dev->kobj, "uverbs%d", uverbs_dev->devnum); - if (cdev_add(uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1)) + uverbs_dev->cdev->owner = THIS_MODULE; + uverbs_dev->cdev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops; + kobject_set_name(&uverbs_dev->cdev->kobj, "uverbs%d", uverbs_dev->devnum); + if (cdev_add(uverbs_dev->cdev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1)) goto err_cdev; - uverbs_dev->class_dev = class_device_create(uverbs_class, NULL, - uverbs_dev->dev->dev, - device->dma_device, - "uverbs%d", uverbs_dev->devnum); - if (IS_ERR(uverbs_dev->class_dev)) + uverbs_dev->dev = device_create(uverbs_class, device->dma_device, + uverbs_dev->cdev->dev, + "uverbs%d", uverbs_dev->devnum); + if (IS_ERR(uverbs_dev->dev)) goto err_cdev; - class_set_devdata(uverbs_dev->class_dev, uverbs_dev); + dev_set_drvdata(uverbs_dev->dev, uverbs_dev); - if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_ibdev)) + if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev)) goto err_class; - if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_abi_version)) + if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version)) goto err_class; spin_lock(&map_lock); @@ -776,10 +777,10 @@ static void ib_uverbs_add_one(struct ib_device *device) return; err_class: - class_device_destroy(uverbs_class, uverbs_dev->dev->dev); + device_destroy(uverbs_class, uverbs_dev->cdev->dev); err_cdev: - cdev_del(uverbs_dev->dev); + cdev_del(uverbs_dev->cdev); clear_bit(uverbs_dev->devnum, dev_map); err: @@ -796,9 +797,9 @@ static void ib_uverbs_remove_one(struct ib_device *device) if (!uverbs_dev) return; - class_set_devdata(uverbs_dev->class_dev, NULL); - class_device_destroy(uverbs_class, uverbs_dev->dev->dev); - cdev_del(uverbs_dev->dev); + dev_set_drvdata(uverbs_dev->dev, NULL); + device_destroy(uverbs_class, uverbs_dev->cdev->dev); + cdev_del(uverbs_dev->cdev); spin_lock(&map_lock); dev_table[uverbs_dev->devnum] = NULL; diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c index e10d27a..6af2c0f 100644 --- a/drivers/infiniband/hw/amso1100/c2_provider.c +++ b/drivers/infiniband/hw/amso1100/c2_provider.c @@ -523,45 +523,49 @@ static int c2_dereg_mr(struct ib_mr *ib_mr) return err; } -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *dev, struct device_attribute *attr, + char *buf) { - struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev); + struct c2_dev *c2dev = container_of(dev, struct c2_dev, ibdev.dev); pr_debug("%s:%u\n", __func__, __LINE__); - return sprintf(buf, "%x\n", dev->props.hw_ver); + return sprintf(buf, "%x\n", c2dev->props.hw_ver); } -static ssize_t show_fw_ver(struct class_device *cdev, char *buf) +static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, + char *buf) { - struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev); + struct c2_dev *c2dev = container_of(dev, struct c2_dev, ibdev.dev); pr_debug("%s:%u\n", __func__, __LINE__); return sprintf(buf, "%x.%x.%x\n", - (int) (dev->props.fw_ver >> 32), - (int) (dev->props.fw_ver >> 16) & 0xffff, - (int) (dev->props.fw_ver & 0xffff)); + (int) (c2dev->props.fw_ver >> 32), + (int) (c2dev->props.fw_ver >> 16) & 0xffff, + (int) (c2dev->props.fw_ver & 0xffff)); } -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *dev, struct device_attribute *attr, + char *buf) { pr_debug("%s:%u\n", __func__, __LINE__); return sprintf(buf, "AMSO1100\n"); } -static ssize_t show_board(struct class_device *cdev, char *buf) +static ssize_t show_board(struct device *dev, struct device_attribute *attr, + char *buf) { pr_debug("%s:%u\n", __func__, __LINE__); return sprintf(buf, "%.*s\n", 32, "AMSO1100 Board ID"); } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); -static struct class_device_attribute *c2_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_fw_ver, - &class_device_attr_hca_type, - &class_device_attr_board_id +static struct device_attribute *c2_dev_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_fw_ver, + &dev_attr_hca_type, + &dev_attr_board_id }; static int c2_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, @@ -861,9 +865,9 @@ int c2_register_device(struct c2_dev *dev) if (ret) goto out1; - for (i = 0; i < ARRAY_SIZE(c2_class_attributes); ++i) { - ret = class_device_create_file(&dev->ibdev.class_dev, - c2_class_attributes[i]); + for (i = 0; i < ARRAY_SIZE(c2_dev_attributes); ++i) { + ret = device_create_file(&dev->ibdev.dev, + c2_dev_attributes[i]); if (ret) goto out0; } diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c index ca72654..ab4695c 100644 --- a/drivers/infiniband/hw/cxgb3/iwch_provider.c +++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c @@ -1041,61 +1041,60 @@ static int iwch_query_port(struct ib_device *ibdev, return 0; } -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *dev, struct device_attribute *attr, + char *buf) { - struct iwch_dev *dev = container_of(cdev, struct iwch_dev, - ibdev.class_dev); - PDBG("%s class dev 0x%p\n", __func__, cdev); - return sprintf(buf, "%d\n", dev->rdev.t3cdev_p->type); + struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, + ibdev.dev); + PDBG("%s dev 0x%p\n", __func__, dev); + return sprintf(buf, "%d\n", iwch_dev->rdev.t3cdev_p->type); } -static ssize_t show_fw_ver(struct class_device *cdev, char *buf) +static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, char *buf) { - struct iwch_dev *dev = container_of(cdev, struct iwch_dev, - ibdev.class_dev); + struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, + ibdev.dev); struct ethtool_drvinfo info; - struct net_device *lldev = dev->rdev.t3cdev_p->lldev; + struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev; - PDBG("%s class dev 0x%p\n", __func__, cdev); - rtnl_lock(); + PDBG("%s dev 0x%p\n", __func__, dev); lldev->ethtool_ops->get_drvinfo(lldev, &info); - rtnl_unlock(); return sprintf(buf, "%s\n", info.fw_version); } -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *dev, struct device_attribute *attr, + char *buf) { - struct iwch_dev *dev = container_of(cdev, struct iwch_dev, - ibdev.class_dev); + struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, + ibdev.dev); struct ethtool_drvinfo info; - struct net_device *lldev = dev->rdev.t3cdev_p->lldev; + struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev; - PDBG("%s class dev 0x%p\n", __func__, cdev); - rtnl_lock(); + PDBG("%s dev 0x%p\n", __func__, dev); lldev->ethtool_ops->get_drvinfo(lldev, &info); - rtnl_unlock(); return sprintf(buf, "%s\n", info.driver); } -static ssize_t show_board(struct class_device *cdev, char *buf) +static ssize_t show_board(struct device *dev, struct device_attribute *attr, + char *buf) { - struct iwch_dev *dev = container_of(cdev, struct iwch_dev, - ibdev.class_dev); - PDBG("%s class dev 0x%p\n", __func__, dev); - return sprintf(buf, "%x.%x\n", dev->rdev.rnic_info.pdev->vendor, - dev->rdev.rnic_info.pdev->device); + struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, + ibdev.dev); + PDBG("%s dev 0x%p\n", __func__, dev); + return sprintf(buf, "%x.%x\n", iwch_dev->rdev.rnic_info.pdev->vendor, + iwch_dev->rdev.rnic_info.pdev->device); } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); -static struct class_device_attribute *iwch_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_fw_ver, - &class_device_attr_hca_type, - &class_device_attr_board_id +static struct device_attribute *iwch_class_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_fw_ver, + &dev_attr_hca_type, + &dev_attr_board_id }; int iwch_register_device(struct iwch_dev *dev) @@ -1189,8 +1188,8 @@ int iwch_register_device(struct iwch_dev *dev) goto bail1; for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i) { - ret = class_device_create_file(&dev->ibdev.class_dev, - iwch_class_attributes[i]); + ret = device_create_file(&dev->ibdev.dev, + iwch_class_attributes[i]); if (ret) { goto bail2; } @@ -1208,8 +1207,8 @@ void iwch_unregister_device(struct iwch_dev *dev) PDBG("%s iwch_dev %p\n", __func__, dev); for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i) - class_device_remove_file(&dev->ibdev.class_dev, - iwch_class_attributes[i]); + device_remove_file(&dev->ibdev.dev, + iwch_class_attributes[i]); ib_unregister_device(&dev->ibdev); return; } diff --git a/drivers/infiniband/hw/ipath/ipath_diag.c b/drivers/infiniband/hw/ipath/ipath_diag.c index 6d49d2f..d4ce8b6 100644 --- a/drivers/infiniband/hw/ipath/ipath_diag.c +++ b/drivers/infiniband/hw/ipath/ipath_diag.c @@ -79,7 +79,7 @@ static const struct file_operations diagpkt_file_ops = { static atomic_t diagpkt_count = ATOMIC_INIT(0); static struct cdev *diagpkt_cdev; -static struct class_device *diagpkt_class_dev; +static struct device *diagpkt_dev; int ipath_diag_add(struct ipath_devdata *dd) { @@ -89,7 +89,7 @@ int ipath_diag_add(struct ipath_devdata *dd) if (atomic_inc_return(&diagpkt_count) == 1) { ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR, "ipath_diagpkt", &diagpkt_file_ops, - &diagpkt_cdev, &diagpkt_class_dev); + &diagpkt_cdev, &diagpkt_dev); if (ret) { ipath_dev_err(dd, "Couldn't create ipath_diagpkt " @@ -102,7 +102,7 @@ int ipath_diag_add(struct ipath_devdata *dd) ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name, &diag_file_ops, &dd->diag_cdev, - &dd->diag_class_dev); + &dd->diag_dev); if (ret) ipath_dev_err(dd, "Couldn't create %s device: %d", name, ret); @@ -114,9 +114,9 @@ done: void ipath_diag_remove(struct ipath_devdata *dd) { if (atomic_dec_and_test(&diagpkt_count)) - ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev); + ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev); - ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev); + ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev); } /** diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c index 1e627aa..8b17522 100644 --- a/drivers/infiniband/hw/ipath/ipath_file_ops.c +++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c @@ -2434,11 +2434,11 @@ static ssize_t ipath_writev(struct kiocb *iocb, const struct iovec *iov, static struct class *ipath_class; static int init_cdev(int minor, char *name, const struct file_operations *fops, - struct cdev **cdevp, struct class_device **class_devp) + struct cdev **cdevp, struct device **devp) { const dev_t dev = MKDEV(IPATH_MAJOR, minor); struct cdev *cdev = NULL; - struct class_device *class_dev = NULL; + struct device *device = NULL; int ret; cdev = cdev_alloc(); @@ -2462,12 +2462,12 @@ static int init_cdev(int minor, char *name, const struct file_operations *fops, goto err_cdev; } - class_dev = class_device_create(ipath_class, NULL, dev, NULL, name); + device = device_create(ipath_class, NULL, dev, name); - if (IS_ERR(class_dev)) { - ret = PTR_ERR(class_dev); + if (IS_ERR(device)) { + ret = PTR_ERR(device); printk(KERN_ERR IPATH_DRV_NAME ": Could not create " - "class_dev for minor %d, %s (err %d)\n", + "device for minor %d, %s (err %d)\n", minor, name, -ret); goto err_cdev; } @@ -2481,29 +2481,29 @@ err_cdev: done: if (ret >= 0) { *cdevp = cdev; - *class_devp = class_dev; + *devp = device; } else { *cdevp = NULL; - *class_devp = NULL; + *devp = NULL; } return ret; } int ipath_cdev_init(int minor, char *name, const struct file_operations *fops, - struct cdev **cdevp, struct class_device **class_devp) + struct cdev **cdevp, struct device **devp) { - return init_cdev(minor, name, fops, cdevp, class_devp); + return init_cdev(minor, name, fops, cdevp, devp); } static void cleanup_cdev(struct cdev **cdevp, - struct class_device **class_devp) + struct device **devp) { - struct class_device *class_dev = *class_devp; + struct device *dev = *devp; - if (class_dev) { - class_device_unregister(class_dev); - *class_devp = NULL; + if (dev) { + device_unregister(dev); + *devp = NULL; } if (*cdevp) { @@ -2513,13 +2513,13 @@ static void cleanup_cdev(struct cdev **cdevp, } void ipath_cdev_cleanup(struct cdev **cdevp, - struct class_device **class_devp) + struct device **devp) { - cleanup_cdev(cdevp, class_devp); + cleanup_cdev(cdevp, devp); } static struct cdev *wildcard_cdev; -static struct class_device *wildcard_class_dev; +static struct device *wildcard_dev; static const dev_t dev = MKDEV(IPATH_MAJOR, 0); @@ -2576,7 +2576,7 @@ int ipath_user_add(struct ipath_devdata *dd) goto bail; } ret = init_cdev(0, "ipath", &ipath_file_ops, &wildcard_cdev, - &wildcard_class_dev); + &wildcard_dev); if (ret < 0) { ipath_dev_err(dd, "Could not create wildcard " "minor: error %d\n", -ret); @@ -2589,7 +2589,7 @@ int ipath_user_add(struct ipath_devdata *dd) snprintf(name, sizeof(name), "ipath%d", dd->ipath_unit); ret = init_cdev(dd->ipath_unit + 1, name, &ipath_file_ops, - &dd->user_cdev, &dd->user_class_dev); + &dd->user_cdev, &dd->user_dev); if (ret < 0) ipath_dev_err(dd, "Could not create user minor %d, %s\n", dd->ipath_unit + 1, name); @@ -2604,13 +2604,13 @@ bail: void ipath_user_remove(struct ipath_devdata *dd) { - cleanup_cdev(&dd->user_cdev, &dd->user_class_dev); + cleanup_cdev(&dd->user_cdev, &dd->user_dev); if (atomic_dec_return(&user_count) == 0) { if (atomic_read(&user_setup) == 0) goto bail; - cleanup_cdev(&wildcard_cdev, &wildcard_class_dev); + cleanup_cdev(&wildcard_cdev, &wildcard_dev); user_cleanup(); atomic_set(&user_setup, 0); diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h index 5863cbe..202337a 100644 --- a/drivers/infiniband/hw/ipath/ipath_kernel.h +++ b/drivers/infiniband/hw/ipath/ipath_kernel.h @@ -466,8 +466,8 @@ struct ipath_devdata { struct pci_dev *pcidev; struct cdev *user_cdev; struct cdev *diag_cdev; - struct class_device *user_class_dev; - struct class_device *diag_class_dev; + struct device *user_dev; + struct device *diag_dev; /* timer used to prevent stats overflow, error throttling, etc. */ struct timer_list ipath_stats_timer; /* timer to verify interrupts work, and fallback if possible */ @@ -854,9 +854,9 @@ void ipath_clear_freeze(struct ipath_devdata *); struct file_operations; int ipath_cdev_init(int minor, char *name, const struct file_operations *fops, - struct cdev **cdevp, struct class_device **class_devp); + struct cdev **cdevp, struct device **devp); void ipath_cdev_cleanup(struct cdev **cdevp, - struct class_device **class_devp); + struct device **devp); int ipath_diag_add(struct ipath_devdata *); void ipath_diag_remove(struct ipath_devdata *); diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c index 320a6d0..c38f9aa 100644 --- a/drivers/infiniband/hw/ipath/ipath_verbs.c +++ b/drivers/infiniband/hw/ipath/ipath_verbs.c @@ -2172,18 +2172,20 @@ void ipath_unregister_ib_device(struct ipath_ibdev *dev) ib_dealloc_device(ibdev); } -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *device, struct device_attribute *attr, + char *buf) { struct ipath_ibdev *dev = - container_of(cdev, struct ipath_ibdev, ibdev.class_dev); + container_of(device, struct ipath_ibdev, ibdev.dev); return sprintf(buf, "%x\n", dev->dd->ipath_pcirev); } -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *device, struct device_attribute *attr, + char *buf) { struct ipath_ibdev *dev = - container_of(cdev, struct ipath_ibdev, ibdev.class_dev); + container_of(device, struct ipath_ibdev, ibdev.dev); int ret; ret = dev->dd->ipath_f_get_boardname(dev->dd, buf, 128); @@ -2196,10 +2198,11 @@ bail: return ret; } -static ssize_t show_stats(struct class_device *cdev, char *buf) +static ssize_t show_stats(struct device *device, struct device_attribute *attr, + char *buf) { struct ipath_ibdev *dev = - container_of(cdev, struct ipath_ibdev, ibdev.class_dev); + container_of(device, struct ipath_ibdev, ibdev.dev); int i; int len; @@ -2237,16 +2240,16 @@ static ssize_t show_stats(struct class_device *cdev, char *buf) return len; } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL); -static struct class_device_attribute *ipath_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_hca_type, - &class_device_attr_board_id, - &class_device_attr_stats +static struct device_attribute *ipath_class_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_hca_type, + &dev_attr_board_id, + &dev_attr_stats }; static int ipath_verbs_register_sysfs(struct ib_device *dev) @@ -2255,8 +2258,8 @@ static int ipath_verbs_register_sysfs(struct ib_device *dev) int ret; for (i = 0; i < ARRAY_SIZE(ipath_class_attributes); ++i) - if (class_device_create_file(&dev->class_dev, - ipath_class_attributes[i])) { + if (device_create_file(&dev->dev, + ipath_class_attributes[i])) { ret = 1; goto bail; } diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c index 136c76c..4d9b5ac 100644 --- a/drivers/infiniband/hw/mlx4/main.c +++ b/drivers/infiniband/hw/mlx4/main.c @@ -481,42 +481,51 @@ out: return err; } -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *device, struct device_attribute *attr, + char *buf) { - struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + struct mlx4_ib_dev *dev = + container_of(device, struct mlx4_ib_dev, ib_dev.dev); return sprintf(buf, "MT%d\n", dev->dev->pdev->device); } -static ssize_t show_fw_ver(struct class_device *cdev, char *buf) +static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr, + char *buf) { - struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + struct mlx4_ib_dev *dev = + container_of(device, struct mlx4_ib_dev, ib_dev.dev); return sprintf(buf, "%d.%d.%d\n", (int) (dev->dev->caps.fw_ver >> 32), (int) (dev->dev->caps.fw_ver >> 16) & 0xffff, (int) dev->dev->caps.fw_ver & 0xffff); } -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *device, struct device_attribute *attr, + char *buf) { - struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + struct mlx4_ib_dev *dev = + container_of(device, struct mlx4_ib_dev, ib_dev.dev); return sprintf(buf, "%x\n", dev->dev->rev_id); } -static ssize_t show_board(struct class_device *cdev, char *buf) +static ssize_t show_board(struct device *device, struct device_attribute *attr, + char *buf) { - struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); - return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN, dev->dev->board_id); + struct mlx4_ib_dev *dev = + container_of(device, struct mlx4_ib_dev, ib_dev.dev); + return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN, + dev->dev->board_id); } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); -static struct class_device_attribute *mlx4_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_fw_ver, - &class_device_attr_hca_type, - &class_device_attr_board_id +static struct device_attribute *mlx4_class_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_fw_ver, + &dev_attr_hca_type, + &dev_attr_board_id }; static void *mlx4_ib_add(struct mlx4_dev *dev) @@ -640,8 +649,8 @@ static void *mlx4_ib_add(struct mlx4_dev *dev) goto err_reg; for (i = 0; i < ARRAY_SIZE(mlx4_class_attributes); ++i) { - if (class_device_create_file(&ibdev->ib_dev.class_dev, - mlx4_class_attributes[i])) + if (device_create_file(&ibdev->ib_dev.dev, + mlx4_class_attributes[i])) goto err_reg; } diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c index 81b257e..696e1f3 100644 --- a/drivers/infiniband/hw/mthca/mthca_provider.c +++ b/drivers/infiniband/hw/mthca/mthca_provider.c @@ -1170,23 +1170,29 @@ static int mthca_unmap_fmr(struct list_head *fmr_list) return 0; } -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *device, struct device_attribute *attr, + char *buf) { - struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + struct mthca_dev *dev = + container_of(device, struct mthca_dev, ib_dev.dev); return sprintf(buf, "%x\n", dev->rev_id); } -static ssize_t show_fw_ver(struct class_device *cdev, char *buf) +static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr, + char *buf) { - struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + struct mthca_dev *dev = + container_of(device, struct mthca_dev, ib_dev.dev); return sprintf(buf, "%d.%d.%d\n", (int) (dev->fw_ver >> 32), (int) (dev->fw_ver >> 16) & 0xffff, (int) dev->fw_ver & 0xffff); } -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *device, struct device_attribute *attr, + char *buf) { - struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + struct mthca_dev *dev = + container_of(device, struct mthca_dev, ib_dev.dev); switch (dev->pdev->device) { case PCI_DEVICE_ID_MELLANOX_TAVOR: return sprintf(buf, "MT23108\n"); @@ -1202,22 +1208,24 @@ static ssize_t show_hca(struct class_device *cdev, char *buf) } } -static ssize_t show_board(struct class_device *cdev, char *buf) +static ssize_t show_board(struct device *device, struct device_attribute *attr, + char *buf) { - struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + struct mthca_dev *dev = + container_of(device, struct mthca_dev, ib_dev.dev); return sprintf(buf, "%.*s\n", MTHCA_BOARD_ID_LEN, dev->board_id); } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); -static struct class_device_attribute *mthca_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_fw_ver, - &class_device_attr_hca_type, - &class_device_attr_board_id +static struct device_attribute *mthca_dev_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_fw_ver, + &dev_attr_hca_type, + &dev_attr_board_id }; static int mthca_init_node_data(struct mthca_dev *dev) @@ -1379,9 +1387,9 @@ int mthca_register_device(struct mthca_dev *dev) if (ret) return ret; - for (i = 0; i < ARRAY_SIZE(mthca_class_attributes); ++i) { - ret = class_device_create_file(&dev->ib_dev.class_dev, - mthca_class_attributes[i]); + for (i = 0; i < ARRAY_SIZE(mthca_dev_attributes); ++i) { + ret = device_create_file(&dev->ib_dev.dev, + mthca_dev_attributes[i]); if (ret) { ib_unregister_device(&dev->ib_dev); return ret; diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c index 7c27420..f9a5d43 100644 --- a/drivers/infiniband/hw/nes/nes_verbs.c +++ b/drivers/infiniband/hw/nes/nes_verbs.c @@ -2800,10 +2800,11 @@ static int nes_dereg_mr(struct ib_mr *ib_mr) /** * show_rev */ -static ssize_t show_rev(struct class_device *cdev, char *buf) +static ssize_t show_rev(struct device *dev, struct device_attribute *attr, + char *buf) { struct nes_ib_device *nesibdev = - container_of(cdev, struct nes_ib_device, ibdev.class_dev); + container_of(dev, struct nes_ib_device, ibdev.dev); struct nes_vnic *nesvnic = nesibdev->nesvnic; nes_debug(NES_DBG_INIT, "\n"); @@ -2814,10 +2815,11 @@ static ssize_t show_rev(struct class_device *cdev, char *buf) /** * show_fw_ver */ -static ssize_t show_fw_ver(struct class_device *cdev, char *buf) +static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, + char *buf) { struct nes_ib_device *nesibdev = - container_of(cdev, struct nes_ib_device, ibdev.class_dev); + container_of(dev, struct nes_ib_device, ibdev.dev); struct nes_vnic *nesvnic = nesibdev->nesvnic; nes_debug(NES_DBG_INIT, "\n"); @@ -2831,7 +2833,8 @@ static ssize_t show_fw_ver(struct class_device *cdev, char *buf) /** * show_hca */ -static ssize_t show_hca(struct class_device *cdev, char *buf) +static ssize_t show_hca(struct device *dev, struct device_attribute *attr, + char *buf) { nes_debug(NES_DBG_INIT, "\n"); return sprintf(buf, "NES020\n"); @@ -2841,23 +2844,24 @@ static ssize_t show_hca(struct class_device *cdev, char *buf) /** * show_board */ -static ssize_t show_board(struct class_device *cdev, char *buf) +static ssize_t show_board(struct device *dev, struct device_attribute *attr, + char *buf) { nes_debug(NES_DBG_INIT, "\n"); return sprintf(buf, "%.*s\n", 32, "NES020 Board ID"); } -static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); -static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); -static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); -static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); -static struct class_device_attribute *nes_class_attributes[] = { - &class_device_attr_hw_rev, - &class_device_attr_fw_ver, - &class_device_attr_hca_type, - &class_device_attr_board_id +static struct device_attribute *nes_dev_attributes[] = { + &dev_attr_hw_rev, + &dev_attr_fw_ver, + &dev_attr_hca_type, + &dev_attr_board_id }; @@ -3782,7 +3786,7 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev) nesibdev->ibdev.phys_port_cnt = 1; nesibdev->ibdev.num_comp_vectors = 1; nesibdev->ibdev.dma_device = &nesdev->pcidev->dev; - nesibdev->ibdev.class_dev.dev = &nesdev->pcidev->dev; + nesibdev->ibdev.dev.parent = &nesdev->pcidev->dev; nesibdev->ibdev.query_device = nes_query_device; nesibdev->ibdev.query_port = nes_query_port; nesibdev->ibdev.modify_port = nes_modify_port; @@ -3877,13 +3881,13 @@ int nes_register_ofa_device(struct nes_ib_device *nesibdev) nesibdev->max_qp = (nesadapter->max_qp-NES_FIRST_QPN) / nesadapter->port_count; nesibdev->max_pd = nesadapter->max_pd / nesadapter->port_count; - for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) { - ret = class_device_create_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]); + for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) { + ret = device_create_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]); if (ret) { while (i > 0) { i--; - class_device_remove_file(&nesibdev->ibdev.class_dev, - nes_class_attributes[i]); + device_remove_file(&nesibdev->ibdev.dev, + nes_dev_attributes[i]); } ib_unregister_device(&nesibdev->ibdev); return ret; @@ -3904,8 +3908,8 @@ static void nes_unregister_ofa_device(struct nes_ib_device *nesibdev) struct nes_vnic *nesvnic = nesibdev->nesvnic; int i; - for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) { - class_device_remove_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]); + for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) { + device_remove_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]); } if (nesvnic->of_device_registered) { diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c index 125765a..4351457 100644 --- a/drivers/infiniband/ulp/srp/ib_srp.c +++ b/drivers/infiniband/ulp/srp/ib_srp.c @@ -139,8 +139,9 @@ static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size, if (!iu->buf) goto out_free_iu; - iu->dma = ib_dma_map_single(host->dev->dev, iu->buf, size, direction); - if (ib_dma_mapping_error(host->dev->dev, iu->dma)) + iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size, + direction); + if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma)) goto out_free_buf; iu->size = size; @@ -161,7 +162,8 @@ static void srp_free_iu(struct srp_host *host, struct srp_iu *iu) if (!iu) return; - ib_dma_unmap_single(host->dev->dev, iu->dma, iu->size, iu->direction); + ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size, + iu->direction); kfree(iu->buf); kfree(iu); } @@ -181,7 +183,7 @@ static int srp_init_qp(struct srp_target_port *target, if (!attr) return -ENOMEM; - ret = ib_find_cached_pkey(target->srp_host->dev->dev, + ret = ib_find_cached_pkey(target->srp_host->srp_dev->dev, target->srp_host->port, be16_to_cpu(target->path.pkey), &attr->pkey_index); @@ -208,7 +210,7 @@ static int srp_new_cm_id(struct srp_target_port *target) { struct ib_cm_id *new_cm_id; - new_cm_id = ib_create_cm_id(target->srp_host->dev->dev, + new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev, srp_cm_handler, target); if (IS_ERR(new_cm_id)) return PTR_ERR(new_cm_id); @@ -229,8 +231,8 @@ static int srp_create_target_ib(struct srp_target_port *target) if (!init_attr) return -ENOMEM; - target->cq = ib_create_cq(target->srp_host->dev->dev, srp_completion, - NULL, target, SRP_CQ_SIZE, 0); + target->cq = ib_create_cq(target->srp_host->srp_dev->dev, + srp_completion, NULL, target, SRP_CQ_SIZE, 0); if (IS_ERR(target->cq)) { ret = PTR_ERR(target->cq); goto out; @@ -248,7 +250,7 @@ static int srp_create_target_ib(struct srp_target_port *target) init_attr->send_cq = target->cq; init_attr->recv_cq = target->cq; - target->qp = ib_create_qp(target->srp_host->dev->pd, init_attr); + target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr); if (IS_ERR(target->qp)) { ret = PTR_ERR(target->qp); ib_destroy_cq(target->cq); @@ -302,7 +304,7 @@ static int srp_lookup_path(struct srp_target_port *target) init_completion(&target->done); target->path_query_id = ib_sa_path_rec_get(&srp_sa_client, - target->srp_host->dev->dev, + target->srp_host->srp_dev->dev, target->srp_host->port, &target->path, IB_SA_PATH_REC_SERVICE_ID | @@ -403,7 +405,7 @@ static int srp_send_req(struct srp_target_port *target) (unsigned long long) be64_to_cpu(target->ioc_guid)); memset(req->priv.initiator_port_id, 0, 8); memcpy(req->priv.initiator_port_id + 8, - &target->srp_host->dev->dev->node_guid, 8); + &target->srp_host->srp_dev->dev->node_guid, 8); } status = ib_send_cm_req(target->cm_id, &req->param); @@ -520,7 +522,7 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd, req->fmr = NULL; } - ib_dma_unmap_sg(target->srp_host->dev->dev, scsi_sglist(scmnd), + ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd), scsi_sg_count(scmnd), scmnd->sc_data_direction); } @@ -628,7 +630,7 @@ static int srp_map_fmr(struct srp_target_port *target, struct scatterlist *scat, int page_cnt; int i, j; int ret; - struct srp_device *dev = target->srp_host->dev; + struct srp_device *dev = target->srp_host->srp_dev; struct ib_device *ibdev = dev->dev; struct scatterlist *sg; @@ -723,7 +725,7 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, nents = scsi_sg_count(scmnd); scat = scsi_sglist(scmnd); - dev = target->srp_host->dev; + dev = target->srp_host->srp_dev; ibdev = dev->dev; count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction); @@ -779,7 +781,7 @@ static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, buf->table_desc.va = cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf); buf->table_desc.key = - cpu_to_be32(target->srp_host->dev->mr->rkey); + cpu_to_be32(target->srp_host->srp_dev->mr->rkey); buf->table_desc.len = cpu_to_be32(count * sizeof (struct srp_direct_buf)); @@ -855,7 +857,7 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc) iu = target->rx_ring[wc->wr_id & ~SRP_OP_RECV]; - dev = target->srp_host->dev->dev; + dev = target->srp_host->srp_dev->dev; ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len, DMA_FROM_DEVICE); @@ -937,7 +939,7 @@ static int __srp_post_recv(struct srp_target_port *target) list.addr = iu->dma; list.length = iu->size; - list.lkey = target->srp_host->dev->mr->lkey; + list.lkey = target->srp_host->srp_dev->mr->lkey; wr.next = NULL; wr.sg_list = &list; @@ -996,7 +998,7 @@ static int __srp_post_send(struct srp_target_port *target, list.addr = iu->dma; list.length = len; - list.lkey = target->srp_host->dev->mr->lkey; + list.lkey = target->srp_host->srp_dev->mr->lkey; wr.next = NULL; wr.wr_id = target->tx_head & SRP_SQ_SIZE; @@ -1039,7 +1041,7 @@ static int srp_queuecommand(struct scsi_cmnd *scmnd, if (!iu) goto err; - dev = target->srp_host->dev->dev; + dev = target->srp_host->srp_dev->dev; ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len, DMA_TO_DEVICE); @@ -1456,9 +1458,10 @@ static int srp_reset_host(struct scsi_cmnd *scmnd) return ret; } -static ssize_t show_id_ext(struct class_device *cdev, char *buf) +static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1468,9 +1471,10 @@ static ssize_t show_id_ext(struct class_device *cdev, char *buf) (unsigned long long) be64_to_cpu(target->id_ext)); } -static ssize_t show_ioc_guid(struct class_device *cdev, char *buf) +static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1480,9 +1484,10 @@ static ssize_t show_ioc_guid(struct class_device *cdev, char *buf) (unsigned long long) be64_to_cpu(target->ioc_guid)); } -static ssize_t show_service_id(struct class_device *cdev, char *buf) +static ssize_t show_service_id(struct device *dev, + struct device_attribute *attr, char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1492,9 +1497,10 @@ static ssize_t show_service_id(struct class_device *cdev, char *buf) (unsigned long long) be64_to_cpu(target->service_id)); } -static ssize_t show_pkey(struct class_device *cdev, char *buf) +static ssize_t show_pkey(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1503,9 +1509,10 @@ static ssize_t show_pkey(struct class_device *cdev, char *buf) return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey)); } -static ssize_t show_dgid(struct class_device *cdev, char *buf) +static ssize_t show_dgid(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1522,9 +1529,10 @@ static ssize_t show_dgid(struct class_device *cdev, char *buf) be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); } -static ssize_t show_orig_dgid(struct class_device *cdev, char *buf) +static ssize_t show_orig_dgid(struct device *dev, + struct device_attribute *attr, char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1541,9 +1549,10 @@ static ssize_t show_orig_dgid(struct class_device *cdev, char *buf) be16_to_cpu(target->orig_dgid[7])); } -static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf) +static ssize_t show_zero_req_lim(struct device *dev, + struct device_attribute *attr, char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); if (target->state == SRP_TARGET_DEAD || target->state == SRP_TARGET_REMOVED) @@ -1552,40 +1561,42 @@ static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf) return sprintf(buf, "%d\n", target->zero_req_lim); } -static ssize_t show_local_ib_port(struct class_device *cdev, char *buf) +static ssize_t show_local_ib_port(struct device *dev, + struct device_attribute *attr, char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); return sprintf(buf, "%d\n", target->srp_host->port); } -static ssize_t show_local_ib_device(struct class_device *cdev, char *buf) +static ssize_t show_local_ib_device(struct device *dev, + struct device_attribute *attr, char *buf) { - struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + struct srp_target_port *target = host_to_target(class_to_shost(dev)); - return sprintf(buf, "%s\n", target->srp_host->dev->dev->name); + return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name); } -static CLASS_DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); -static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); -static CLASS_DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); -static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); -static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); -static CLASS_DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); -static CLASS_DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); -static CLASS_DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); -static CLASS_DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); - -static struct class_device_attribute *srp_host_attrs[] = { - &class_device_attr_id_ext, - &class_device_attr_ioc_guid, - &class_device_attr_service_id, - &class_device_attr_pkey, - &class_device_attr_dgid, - &class_device_attr_orig_dgid, - &class_device_attr_zero_req_lim, - &class_device_attr_local_ib_port, - &class_device_attr_local_ib_device, +static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); +static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); +static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); +static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); +static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); +static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); +static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); +static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); +static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); + +static struct device_attribute *srp_host_attrs[] = { + &dev_attr_id_ext, + &dev_attr_ioc_guid, + &dev_attr_service_id, + &dev_attr_pkey, + &dev_attr_dgid, + &dev_attr_orig_dgid, + &dev_attr_zero_req_lim, + &dev_attr_local_ib_port, + &dev_attr_local_ib_device, NULL }; @@ -1613,7 +1624,7 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target) sprintf(target->target_name, "SRP.T10:%016llX", (unsigned long long) be64_to_cpu(target->id_ext)); - if (scsi_add_host(target->scsi_host, host->dev->dev->dma_device)) + if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device)) return -ENODEV; memcpy(ids.port_id, &target->id_ext, 8); @@ -1637,17 +1648,17 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target) return 0; } -static void srp_release_class_dev(struct class_device *class_dev) +static void srp_release_dev(struct device *dev) { struct srp_host *host = - container_of(class_dev, struct srp_host, class_dev); + container_of(dev, struct srp_host, dev); complete(&host->released); } static struct class srp_class = { .name = "infiniband_srp", - .release = srp_release_class_dev + .dev_release = srp_release_dev }; /* @@ -1835,11 +1846,12 @@ out: return ret; } -static ssize_t srp_create_target(struct class_device *class_dev, +static ssize_t srp_create_target(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { struct srp_host *host = - container_of(class_dev, struct srp_host, class_dev); + container_of(dev, struct srp_host, dev); struct Scsi_Host *target_host; struct srp_target_port *target; int ret; @@ -1871,7 +1883,8 @@ static ssize_t srp_create_target(struct class_device *class_dev, if (ret) goto err; - ib_get_cached_gid(host->dev->dev, host->port, 0, &target->path.sgid); + ib_get_cached_gid(host->srp_dev->dev, host->port, 0, + &target->path.sgid); shost_printk(KERN_DEBUG, target->scsi_host, PFX "new target: id_ext %016llx ioc_guid %016llx pkey %04x " @@ -1926,27 +1939,27 @@ err: return ret; } -static CLASS_DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); +static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); -static ssize_t show_ibdev(struct class_device *class_dev, char *buf) +static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_host *host = - container_of(class_dev, struct srp_host, class_dev); + struct srp_host *host = container_of(dev, struct srp_host, dev); - return sprintf(buf, "%s\n", host->dev->dev->name); + return sprintf(buf, "%s\n", host->srp_dev->dev->name); } -static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); +static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); -static ssize_t show_port(struct class_device *class_dev, char *buf) +static ssize_t show_port(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_host *host = - container_of(class_dev, struct srp_host, class_dev); + struct srp_host *host = container_of(dev, struct srp_host, dev); return sprintf(buf, "%d\n", host->port); } -static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); +static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); static struct srp_host *srp_add_port(struct srp_device *device, u8 port) { @@ -1959,27 +1972,27 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port) INIT_LIST_HEAD(&host->target_list); spin_lock_init(&host->target_lock); init_completion(&host->released); - host->dev = device; + host->srp_dev = device; host->port = port; - host->class_dev.class = &srp_class; - host->class_dev.dev = device->dev->dma_device; - snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d", + host->dev.class = &srp_class; + host->dev.parent = device->dev->dma_device; + snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d", device->dev->name, port); - if (class_device_register(&host->class_dev)) + if (device_register(&host->dev)) goto free_host; - if (class_device_create_file(&host->class_dev, &class_device_attr_add_target)) + if (device_create_file(&host->dev, &dev_attr_add_target)) goto err_class; - if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev)) + if (device_create_file(&host->dev, &dev_attr_ibdev)) goto err_class; - if (class_device_create_file(&host->class_dev, &class_device_attr_port)) + if (device_create_file(&host->dev, &dev_attr_port)) goto err_class; return host; err_class: - class_device_unregister(&host->class_dev); + device_unregister(&host->dev); free_host: kfree(host); @@ -2084,7 +2097,7 @@ static void srp_remove_one(struct ib_device *device) srp_dev = ib_get_client_data(device, &srp_client); list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { - class_device_unregister(&host->class_dev); + device_unregister(&host->dev); /* * Wait for the sysfs entry to go away, so that no new * target ports can be created. diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h index cb6eb81..63d2ae7 100644 --- a/drivers/infiniband/ulp/srp/ib_srp.h +++ b/drivers/infiniband/ulp/srp/ib_srp.h @@ -97,9 +97,9 @@ struct srp_device { }; struct srp_host { - struct srp_device *dev; + struct srp_device *srp_dev; u8 port; - struct class_device class_dev; + struct device dev; struct list_head target_list; spinlock_t target_lock; struct completion released; diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c index 4a93878..63aad90 100644 --- a/drivers/leds/led-class.c +++ b/drivers/leds/led-class.c @@ -139,12 +139,10 @@ EXPORT_SYMBOL_GPL(led_classdev_register); /** * __led_classdev_unregister - unregisters a object of led_properties class. * @led_cdev: the led device to unregister - * @suspended: indicates whether system-wide suspend or resume is in progress * * Unregisters a previously registered via led_classdev_register object. */ -void __led_classdev_unregister(struct led_classdev *led_cdev, - bool suspended) +void led_classdev_unregister(struct led_classdev *led_cdev) { device_remove_file(led_cdev->dev, &dev_attr_brightness); #ifdef CONFIG_LEDS_TRIGGERS @@ -155,16 +153,13 @@ void __led_classdev_unregister(struct led_classdev *led_cdev, up_write(&led_cdev->trigger_lock); #endif - if (suspended) - device_pm_schedule_removal(led_cdev->dev); - else - device_unregister(led_cdev->dev); + device_unregister(led_cdev->dev); down_write(&leds_list_lock); list_del(&led_cdev->node); up_write(&leds_list_lock); } -EXPORT_SYMBOL_GPL(__led_classdev_unregister); +EXPORT_SYMBOL_GPL(led_classdev_unregister); static int __init leds_init(void) { diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c index 946e3d3..61b98c3 100644 --- a/drivers/memstick/core/memstick.c +++ b/drivers/memstick/core/memstick.c @@ -177,16 +177,16 @@ static struct bus_type memstick_bus_type = { .resume = memstick_device_resume }; -static void memstick_free(struct class_device *cdev) +static void memstick_free(struct device *dev) { - struct memstick_host *host = container_of(cdev, struct memstick_host, - cdev); + struct memstick_host *host = container_of(dev, struct memstick_host, + dev); kfree(host); } static struct class memstick_host_class = { .name = "memstick_host", - .release = memstick_free + .dev_release = memstick_free }; static void memstick_free_card(struct device *dev) @@ -383,8 +383,8 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host) if (card) { card->host = host; snprintf(card->dev.bus_id, sizeof(card->dev.bus_id), - "%s", host->cdev.class_id); - card->dev.parent = host->cdev.dev; + "%s", host->dev.bus_id); + card->dev.parent = &host->dev; card->dev.bus = &memstick_bus_type; card->dev.release = memstick_free_card; card->check = memstick_dummy_check; @@ -427,7 +427,7 @@ static void memstick_check(struct work_struct *work) media_checker); struct memstick_dev *card; - dev_dbg(host->cdev.dev, "memstick_check started\n"); + dev_dbg(&host->dev, "memstick_check started\n"); mutex_lock(&host->lock); if (!host->card) memstick_power_on(host); @@ -440,7 +440,7 @@ static void memstick_check(struct work_struct *work) host->card = NULL; } } else { - dev_dbg(host->cdev.dev, "new card %02x, %02x, %02x\n", + dev_dbg(&host->dev, "new card %02x, %02x, %02x\n", card->id.type, card->id.category, card->id.class); if (host->card) { if (memstick_set_rw_addr(host->card) @@ -465,7 +465,7 @@ static void memstick_check(struct work_struct *work) host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); mutex_unlock(&host->lock); - dev_dbg(host->cdev.dev, "memstick_check finished\n"); + dev_dbg(&host->dev, "memstick_check finished\n"); } /** @@ -482,9 +482,9 @@ struct memstick_host *memstick_alloc_host(unsigned int extra, if (host) { mutex_init(&host->lock); INIT_WORK(&host->media_checker, memstick_check); - host->cdev.class = &memstick_host_class; - host->cdev.dev = dev; - class_device_initialize(&host->cdev); + host->dev.class = &memstick_host_class; + host->dev.parent = dev; + device_initialize(&host->dev); } return host; } @@ -507,10 +507,9 @@ int memstick_add_host(struct memstick_host *host) if (rc) return rc; - snprintf(host->cdev.class_id, BUS_ID_SIZE, - "memstick%u", host->id); + snprintf(host->dev.bus_id, BUS_ID_SIZE, "memstick%u", host->id); - rc = class_device_add(&host->cdev); + rc = device_add(&host->dev); if (rc) { spin_lock(&memstick_host_lock); idr_remove(&memstick_host_idr, host->id); @@ -541,7 +540,7 @@ void memstick_remove_host(struct memstick_host *host) spin_lock(&memstick_host_lock); idr_remove(&memstick_host_idr, host->id); spin_unlock(&memstick_host_lock); - class_device_del(&host->cdev); + device_del(&host->dev); } EXPORT_SYMBOL(memstick_remove_host); @@ -552,7 +551,7 @@ EXPORT_SYMBOL(memstick_remove_host); void memstick_free_host(struct memstick_host *host) { mutex_destroy(&host->lock); - class_device_put(&host->cdev); + put_device(&host->dev); } EXPORT_SYMBOL(memstick_free_host); diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c index 557dbbb..477d0fb 100644 --- a/drivers/memstick/core/mspro_block.c +++ b/drivers/memstick/core/mspro_block.c @@ -1127,8 +1127,8 @@ static int mspro_block_init_disk(struct memstick_dev *card) u64 limit = BLK_BOUNCE_HIGH; unsigned long capacity; - if (host->cdev.dev->dma_mask && *(host->cdev.dev->dma_mask)) - limit = *(host->cdev.dev->dma_mask); + if (host->dev.dma_mask && *(host->dev.dma_mask)) + limit = *(host->dev.dma_mask); for (rc = 0; msb->attr_group.attrs[rc]; ++rc) { s_attr = mspro_from_sysfs_attr(msb->attr_group.attrs[rc]); diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c index 8770a5f..a054668 100644 --- a/drivers/memstick/host/jmb38x_ms.c +++ b/drivers/memstick/host/jmb38x_ms.c @@ -361,15 +361,15 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh) unsigned int data_len, cmd, t_val; if (!(STATUS_HAS_MEDIA & readl(host->addr + STATUS))) { - dev_dbg(msh->cdev.dev, "no media status\n"); + dev_dbg(&msh->dev, "no media status\n"); host->req->error = -ETIME; return host->req->error; } - dev_dbg(msh->cdev.dev, "control %08x\n", + dev_dbg(&msh->dev, "control %08x\n", readl(host->addr + HOST_CONTROL)); - dev_dbg(msh->cdev.dev, "status %08x\n", readl(host->addr + INT_STATUS)); - dev_dbg(msh->cdev.dev, "hstatus %08x\n", readl(host->addr + STATUS)); + dev_dbg(&msh->dev, "status %08x\n", readl(host->addr + INT_STATUS)); + dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS)); host->cmd_flags = 0; host->block_pos = 0; @@ -448,7 +448,7 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh) host->req->error = 0; writel(cmd, host->addr + TPC); - dev_dbg(msh->cdev.dev, "executing TPC %08x, len %x\n", cmd, data_len); + dev_dbg(&msh->dev, "executing TPC %08x, len %x\n", cmd, data_len); return 0; } @@ -461,11 +461,11 @@ static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last) del_timer(&host->timer); - dev_dbg(msh->cdev.dev, "c control %08x\n", + dev_dbg(&msh->dev, "c control %08x\n", readl(host->addr + HOST_CONTROL)); - dev_dbg(msh->cdev.dev, "c status %08x\n", + dev_dbg(&msh->dev, "c status %08x\n", readl(host->addr + INT_STATUS)); - dev_dbg(msh->cdev.dev, "c hstatus %08x\n", readl(host->addr + STATUS)); + dev_dbg(&msh->dev, "c hstatus %08x\n", readl(host->addr + STATUS)); host->req->int_reg = readl(host->addr + STATUS) & 0xff; diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c index 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/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c index 0aac1ff..36a9c42 100644 --- a/drivers/net/wireless/b43/leds.c +++ b/drivers/net/wireless/b43/leds.c @@ -116,10 +116,7 @@ static void b43_unregister_led(struct b43_led *led) { if (!led->dev) return; - if (led->dev->suspend_in_progress) - led_classdev_unregister_suspended(&led->led_dev); - else - led_classdev_unregister(&led->led_dev); + led_classdev_unregister(&led->led_dev); b43_led_turn_off(led->dev, led->index, led->activelow); led->dev = NULL; } diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c index cf5c046..943cc85 100644 --- a/drivers/net/wireless/b43/main.c +++ b/drivers/net/wireless/b43/main.c @@ -2804,10 +2804,10 @@ static int b43_rng_read(struct hwrng *rng, u32 * data) return (sizeof(u16)); } -static void b43_rng_exit(struct b43_wl *wl, bool suspended) +static void b43_rng_exit(struct b43_wl *wl) { if (wl->rng_initialized) - __hwrng_unregister(&wl->rng, suspended); + hwrng_unregister(&wl->rng); } static int b43_rng_init(struct b43_wl *wl) @@ -3824,7 +3824,7 @@ static void b43_wireless_core_exit(struct b43_wldev *dev) if (!dev->suspend_in_progress) { b43_leds_exit(dev); - b43_rng_exit(dev->wl, false); + b43_rng_exit(dev->wl); } b43_dma_free(dev); b43_pio_free(dev); @@ -4589,7 +4589,7 @@ static int b43_resume(struct ssb_device *dev) err = b43_wireless_core_start(wldev); if (err) { b43_leds_exit(wldev); - b43_rng_exit(wldev->wl, true); + b43_rng_exit(wldev->wl); b43_wireless_core_exit(wldev); b43err(wl, "Resume failed at core start\n"); goto out; diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c index 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 f1504be..460d402 100644 --- a/drivers/scsi/aacraid/aachba.c +++ b/drivers/scsi/aacraid/aachba.c @@ -1315,7 +1315,7 @@ int aac_get_adapter_info(struct aac_dev* dev) tmp>>24,(tmp>>16)&0xff,tmp&0xff, le32_to_cpu(dev->adapter_info.biosbuild)); buffer[0] = '\0'; - if (aac_show_serial_number( + if (aac_get_serial_number( shost_to_class(dev->scsi_host_ptr), buffer)) printk(KERN_INFO "%s%d: serial %s", dev->name, dev->id, buffer); diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h index 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 8372bf6..c109f63 100644 --- a/drivers/scsi/aacraid/linit.c +++ b/drivers/scsi/aacraid/linit.c @@ -754,10 +754,10 @@ static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long } #endif -static ssize_t aac_show_model(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_model(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { @@ -773,10 +773,10 @@ static ssize_t aac_show_model(struct class_device *class_dev, return len; } -static ssize_t aac_show_vendor(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_vendor(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { @@ -792,10 +792,11 @@ static ssize_t aac_show_vendor(struct class_device *class_dev, return len; } -static ssize_t aac_show_flags(struct class_device *class_dev, char *buf) +static ssize_t aac_show_flags(struct device *cdev, + struct device_attribute *attr, char *buf) { int len = 0; - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(cdev)->hostdata; if (nblank(dprintk(x))) len = snprintf(buf, PAGE_SIZE, "dprintk\n"); @@ -811,10 +812,11 @@ static ssize_t aac_show_flags(struct class_device *class_dev, char *buf) return len; } -static ssize_t aac_show_kernel_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_kernel_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.kernelrev); @@ -824,10 +826,11 @@ static ssize_t aac_show_kernel_version(struct class_device *class_dev, return len; } -static ssize_t aac_show_monitor_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_monitor_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.monitorrev); @@ -837,10 +840,11 @@ static ssize_t aac_show_monitor_version(struct class_device *class_dev, return len; } -static ssize_t aac_show_bios_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_bios_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.biosrev); @@ -850,9 +854,10 @@ static ssize_t aac_show_bios_version(struct class_device *class_dev, return len; } -ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf) +ssize_t aac_show_serial_number(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len = 0; if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) @@ -868,35 +873,39 @@ ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf) return len; } -static ssize_t aac_show_max_channel(struct class_device *class_dev, char *buf) +static ssize_t aac_show_max_channel(struct device *device, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%d\n", - class_to_shost(class_dev)->max_channel); + class_to_shost(device)->max_channel); } -static ssize_t aac_show_max_id(struct class_device *class_dev, char *buf) +static ssize_t aac_show_max_id(struct device *device, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%d\n", - class_to_shost(class_dev)->max_id); + class_to_shost(device)->max_id); } -static ssize_t aac_store_reset_adapter(struct class_device *class_dev, - const char *buf, size_t count) +static ssize_t aac_store_reset_adapter(struct device *device, + struct device_attribute *attr, + const char *buf, size_t count) { int retval = -EACCES; if (!capable(CAP_SYS_ADMIN)) return retval; - retval = aac_reset_adapter((struct aac_dev*)class_to_shost(class_dev)->hostdata, buf[0] == '!'); + retval = aac_reset_adapter((struct aac_dev*)class_to_shost(device)->hostdata, buf[0] == '!'); if (retval >= 0) retval = count; return retval; } -static ssize_t aac_show_reset_adapter(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_reset_adapter(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = aac_adapter_check_health(dev); @@ -906,70 +915,70 @@ static ssize_t aac_show_reset_adapter(struct class_device *class_dev, return len; } -static struct class_device_attribute aac_model = { +static struct device_attribute aac_model = { .attr = { .name = "model", .mode = S_IRUGO, }, .show = aac_show_model, }; -static struct class_device_attribute aac_vendor = { +static struct device_attribute aac_vendor = { .attr = { .name = "vendor", .mode = S_IRUGO, }, .show = aac_show_vendor, }; -static struct class_device_attribute aac_flags = { +static struct device_attribute aac_flags = { .attr = { .name = "flags", .mode = S_IRUGO, }, .show = aac_show_flags, }; -static struct class_device_attribute aac_kernel_version = { +static struct device_attribute aac_kernel_version = { .attr = { .name = "hba_kernel_version", .mode = S_IRUGO, }, .show = aac_show_kernel_version, }; -static struct class_device_attribute aac_monitor_version = { +static struct device_attribute aac_monitor_version = { .attr = { .name = "hba_monitor_version", .mode = S_IRUGO, }, .show = aac_show_monitor_version, }; -static struct class_device_attribute aac_bios_version = { +static struct device_attribute aac_bios_version = { .attr = { .name = "hba_bios_version", .mode = S_IRUGO, }, .show = aac_show_bios_version, }; -static struct class_device_attribute aac_serial_number = { +static struct device_attribute aac_serial_number = { .attr = { .name = "serial_number", .mode = S_IRUGO, }, .show = aac_show_serial_number, }; -static struct class_device_attribute aac_max_channel = { +static struct device_attribute aac_max_channel = { .attr = { .name = "max_channel", .mode = S_IRUGO, }, .show = aac_show_max_channel, }; -static struct class_device_attribute aac_max_id = { +static struct device_attribute aac_max_id = { .attr = { .name = "max_id", .mode = S_IRUGO, }, .show = aac_show_max_id, }; -static struct class_device_attribute aac_reset = { +static struct device_attribute aac_reset = { .attr = { .name = "reset_host", .mode = S_IWUSR|S_IRUGO, @@ -978,7 +987,7 @@ static struct class_device_attribute aac_reset = { .show = aac_show_reset_adapter, }; -static struct class_device_attribute *aac_attrs[] = { +static struct device_attribute *aac_attrs[] = { &aac_model, &aac_vendor, &aac_flags, @@ -992,6 +1001,10 @@ static struct class_device_attribute *aac_attrs[] = { NULL }; +ssize_t aac_get_serial_number(struct device *device, char *buf) +{ + return aac_show_serial_number(device, &aac_serial_number, buf); +} static const struct file_operations aac_cfg_fops = { .owner = THIS_MODULE, diff --git a/drivers/scsi/arcmsr/arcmsr.h b/drivers/scsi/arcmsr/arcmsr.h index 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/drivers/serial/serial_core.c b/drivers/serial/serial_core.c index c32c1ca..a9ca03e 100644 --- a/drivers/serial/serial_core.c +++ b/drivers/serial/serial_core.c @@ -2422,7 +2422,7 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port) */ tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev); if (likely(!IS_ERR(tty_dev))) { - device_can_wakeup(tty_dev) = 1; + device_init_wakeup(tty_dev, 1); device_set_wakeup_enable(tty_dev, 0); } else printk(KERN_ERR "Cannot register tty device on line %d\n", diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig index b778ed7..a4aaab9 100644 --- a/drivers/uio/Kconfig +++ b/drivers/uio/Kconfig @@ -1,8 +1,6 @@ -menu "Userspace I/O" - depends on !S390 - -config UIO +menuconfig UIO tristate "Userspace I/O drivers" + depends on !S390 default n help Enable this to allow the userspace driver core code to be @@ -13,6 +11,8 @@ config UIO If you don't know what to do here, say N. +if UIO + config UIO_CIF tristate "generic Hilscher CIF Card driver" depends on UIO && PCI @@ -26,4 +26,17 @@ config UIO_CIF To compile this driver as a module, choose M here: the module will be called uio_cif. -endmenu +config UIO_SMX + tristate "SMX cryptengine UIO interface" + depends on UIO + default n + help + Userspace IO interface to the Cryptography engine found on the + Nias Digital SMX boards. These will be available from Q4 2008 + from http://www.niasdigital.com. The userspace part of this + driver will be released under the GPL at the same time as the + hardware and will be able to be downloaded from the same site. + + If you compile this as a module, it will be called uio_smx. + +endif diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile index 7fecfb4..18c4566 100644 --- a/drivers/uio/Makefile +++ b/drivers/uio/Makefile @@ -1,2 +1,3 @@ obj-$(CONFIG_UIO) += uio.o obj-$(CONFIG_UIO_CIF) += uio_cif.o +obj-$(CONFIG_UIO_SMX) += uio_smx.o diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c index 1175908..55cc7b8 100644 --- a/drivers/uio/uio.c +++ b/drivers/uio/uio.c @@ -301,23 +301,33 @@ static int uio_open(struct inode *inode, struct file *filep) if (!idev) return -ENODEV; + if (!try_module_get(idev->owner)) + return -ENODEV; + listener = kmalloc(sizeof(*listener), GFP_KERNEL); - if (!listener) - return -ENOMEM; + if (!listener) { + ret = -ENOMEM; + goto err_alloc_listener; + } listener->dev = idev; listener->event_count = atomic_read(&idev->event); filep->private_data = listener; if (idev->info->open) { - if (!try_module_get(idev->owner)) - return -ENODEV; ret = idev->info->open(idev->info, inode); - module_put(idev->owner); + if (ret) + goto err_infoopen; } - if (ret) - kfree(listener); + return 0; + +err_infoopen: + + kfree(listener); +err_alloc_listener: + + module_put(idev->owner); return ret; } @@ -336,12 +346,11 @@ static int uio_release(struct inode *inode, struct file *filep) struct uio_listener *listener = filep->private_data; struct uio_device *idev = listener->dev; - if (idev->info->release) { - if (!try_module_get(idev->owner)) - return -ENODEV; + if (idev->info->release) ret = idev->info->release(idev->info, inode); - module_put(idev->owner); - } + + module_put(idev->owner); + if (filep->f_flags & FASYNC) ret = uio_fasync(-1, filep, 0); kfree(listener); @@ -510,10 +519,7 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma) return -EINVAL; if (idev->info->mmap) { - if (!try_module_get(idev->owner)) - return -ENODEV; ret = idev->info->mmap(idev->info, vma); - module_put(idev->owner); return ret; } diff --git a/drivers/uio/uio_cif.c b/drivers/uio/uio_cif.c index 838bae4..5737606 100644 --- a/drivers/uio/uio_cif.c +++ b/drivers/uio/uio_cif.c @@ -15,10 +15,6 @@ #include <asm/io.h> -#ifndef PCI_DEVICE_ID_PLX_9030 -#define PCI_DEVICE_ID_PLX_9030 0x9030 -#endif - #define PLX9030_INTCSR 0x4C #define INTSCR_INT1_ENABLE 0x01 #define INTSCR_INT1_STATUS 0x04 @@ -116,7 +112,7 @@ static void hilscher_pci_remove(struct pci_dev *dev) kfree (info); } -static struct pci_device_id hilscher_pci_ids[] = { +static struct pci_device_id hilscher_pci_ids[] __devinitdata = { { .vendor = PCI_VENDOR_ID_PLX, .device = PCI_DEVICE_ID_PLX_9030, diff --git a/drivers/uio/uio_smx.c b/drivers/uio/uio_smx.c new file mode 100644 index 0000000..44054a6 --- /dev/null +++ b/drivers/uio/uio_smx.c @@ -0,0 +1,140 @@ +/* + * UIO SMX Cryptengine driver. + * + * (C) 2008 Nias Digital P/L <bn@niasdigital.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include <linux/device.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/uio_driver.h> +#include <linux/io.h> + +#define DRV_NAME "smx-ce" +#define DRV_VERSION "0.03" + +#define SMX_CSR 0x00000000 +#define SMX_EnD 0x00000001 +#define SMX_RUN 0x00000002 +#define SMX_DRDY 0x00000004 +#define SMX_ERR 0x00000008 + +static irqreturn_t smx_handler(int irq, struct uio_info *dev_info) +{ + void __iomem *csr = dev_info->mem[0].internal_addr + SMX_CSR; + + u32 status = ioread32(csr); + + if (!(status & SMX_DRDY)) + return IRQ_NONE; + + /* Disable interrupt */ + iowrite32(status & ~SMX_DRDY, csr); + return IRQ_HANDLED; +} + +static int __devinit smx_ce_probe(struct platform_device *dev) +{ + + int ret = -ENODEV; + struct uio_info *info; + struct resource *regs; + + info = kzalloc(sizeof(struct uio_info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + regs = platform_get_resource(dev, IORESOURCE_MEM, 0); + if (!regs) { + dev_err(&dev->dev, "No memory resource specified\n"); + goto out_free; + } + + info->mem[0].addr = regs->start; + if (!info->mem[0].addr) { + dev_err(&dev->dev, "Invalid memory resource\n"); + goto out_free; + } + + info->mem[0].size = regs->end - regs->start + 1; + info->mem[0].internal_addr = ioremap(regs->start, info->mem[0].size); + + if (!info->mem[0].internal_addr) { + dev_err(&dev->dev, "Can't remap memory address range\n"); + goto out_free; + } + + info->mem[0].memtype = UIO_MEM_PHYS; + + info->name = "smx-ce"; + info->version = "0.03"; + + info->irq = platform_get_irq(dev, 0); + if (info->irq < 0) { + ret = info->irq; + dev_err(&dev->dev, "No (or invalid) IRQ resource specified\n"); + goto out_unmap; + } + + info->irq_flags = IRQF_SHARED; + info->handler = smx_handler; + + platform_set_drvdata(dev, info); + + ret = uio_register_device(&dev->dev, info); + + if (ret) + goto out_unmap; + + return 0; + +out_unmap: + iounmap(info->mem[0].internal_addr); +out_free: + kfree(info); + + return ret; +} + +static int __devexit smx_ce_remove(struct platform_device *dev) +{ + struct uio_info *info = platform_get_drvdata(dev); + + uio_unregister_device(info); + platform_set_drvdata(dev, NULL); + iounmap(info->mem[0].internal_addr); + + kfree(info); + + return 0; +} + +static struct platform_driver smx_ce_driver = { + .probe = smx_ce_probe, + .remove = __devexit_p(smx_ce_remove), + .driver = { + .name = DRV_NAME, + .owner = THIS_MODULE, + }, +}; + +static int __init smx_ce_init_module(void) +{ + return platform_driver_register(&smx_ce_driver); +} +module_init(smx_ce_init_module); + +static void __exit smx_ce_exit_module(void) +{ + platform_driver_unregister(&smx_ce_driver); +} +module_exit(smx_ce_exit_module); + +MODULE_LICENSE("GPL v2"); +MODULE_VERSION(DRV_VERSION); +MODULE_AUTHOR("Ben Nizette <bn@niasdigital.com>"); |