diff options
Diffstat (limited to 'drivers/scsi')
33 files changed, 1441 insertions, 1223 deletions
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c index 51c3ebf1c7d1..b31faeccb9cd 100644 --- a/drivers/scsi/3w-9xxx.c +++ b/drivers/scsi/3w-9xxx.c @@ -140,9 +140,10 @@ static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id); /* Functions */ /* Show some statistics about the card */ -static ssize_t twa_show_stats(struct class_device *class_dev, char *buf) +static ssize_t twa_show_stats(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *host = class_to_shost(class_dev); + struct Scsi_Host *host = class_to_shost(dev); TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; unsigned long flags = 0; ssize_t len; @@ -184,7 +185,7 @@ static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth) } /* End twa_change_queue_depth() */ /* Create sysfs 'stats' entry */ -static struct class_device_attribute twa_host_stats_attr = { +static struct device_attribute twa_host_stats_attr = { .attr = { .name = "stats", .mode = S_IRUGO, @@ -193,7 +194,7 @@ static struct class_device_attribute twa_host_stats_attr = { }; /* Host attributes initializer */ -static struct class_device_attribute *twa_host_attrs[] = { +static struct device_attribute *twa_host_attrs[] = { &twa_host_stats_attr, NULL, }; diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c index adb98a297210..8c22329aa85e 100644 --- a/drivers/scsi/3w-xxxx.c +++ b/drivers/scsi/3w-xxxx.c @@ -484,9 +484,10 @@ static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id) } /* End tw_state_request_start() */ /* Show some statistics about the card */ -static ssize_t tw_show_stats(struct class_device *class_dev, char *buf) +static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *host = class_to_shost(class_dev); + struct Scsi_Host *host = class_to_shost(dev); TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; unsigned long flags = 0; ssize_t len; @@ -528,7 +529,7 @@ static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth) } /* End tw_change_queue_depth() */ /* Create sysfs 'stats' entry */ -static struct class_device_attribute tw_host_stats_attr = { +static struct device_attribute tw_host_stats_attr = { .attr = { .name = "stats", .mode = S_IRUGO, @@ -537,7 +538,7 @@ static struct class_device_attribute tw_host_stats_attr = { }; /* Host attributes initializer */ -static struct class_device_attribute *tw_host_attrs[] = { +static struct device_attribute *tw_host_attrs[] = { &tw_host_stats_attr, NULL, }; diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c index 369fcf78f396..439fd8146657 100644 --- a/drivers/scsi/aacraid/aachba.c +++ b/drivers/scsi/aacraid/aachba.c @@ -1316,7 +1316,7 @@ int aac_get_adapter_info(struct aac_dev* dev) tmp>>24,(tmp>>16)&0xff,tmp&0xff, le32_to_cpu(dev->adapter_info.biosbuild)); buffer[0] = '\0'; - if (aac_show_serial_number( + if (aac_get_serial_number( shost_to_class(dev->scsi_host_ptr), buffer)) printk(KERN_INFO "%s%d: serial %s", dev->name, dev->id, buffer); diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h index ace0b751c131..113ca9c8934c 100644 --- a/drivers/scsi/aacraid/aacraid.h +++ b/drivers/scsi/aacraid/aacraid.h @@ -1850,9 +1850,9 @@ int aac_get_containers(struct aac_dev *dev); int aac_scsi_cmd(struct scsi_cmnd *cmd); int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg); #ifndef shost_to_class -#define shost_to_class(shost) &shost->shost_classdev +#define shost_to_class(shost) &shost->shost_dev #endif -ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf); +ssize_t aac_get_serial_number(struct device *dev, char *buf); int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg); int aac_rx_init(struct aac_dev *dev); int aac_rkt_init(struct aac_dev *dev); diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c index ae5f74fb62d5..c6391838b2cd 100644 --- a/drivers/scsi/aacraid/linit.c +++ b/drivers/scsi/aacraid/linit.c @@ -755,10 +755,10 @@ static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long } #endif -static ssize_t aac_show_model(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_model(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { @@ -774,10 +774,10 @@ static ssize_t aac_show_model(struct class_device *class_dev, return len; } -static ssize_t aac_show_vendor(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_vendor(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { @@ -793,10 +793,11 @@ static ssize_t aac_show_vendor(struct class_device *class_dev, return len; } -static ssize_t aac_show_flags(struct class_device *class_dev, char *buf) +static ssize_t aac_show_flags(struct device *cdev, + struct device_attribute *attr, char *buf) { int len = 0; - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(cdev)->hostdata; if (nblank(dprintk(x))) len = snprintf(buf, PAGE_SIZE, "dprintk\n"); @@ -812,10 +813,11 @@ static ssize_t aac_show_flags(struct class_device *class_dev, char *buf) return len; } -static ssize_t aac_show_kernel_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_kernel_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.kernelrev); @@ -825,10 +827,11 @@ static ssize_t aac_show_kernel_version(struct class_device *class_dev, return len; } -static ssize_t aac_show_monitor_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_monitor_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.monitorrev); @@ -838,10 +841,11 @@ static ssize_t aac_show_monitor_version(struct class_device *class_dev, return len; } -static ssize_t aac_show_bios_version(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_bios_version(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.biosrev); @@ -851,9 +855,10 @@ static ssize_t aac_show_bios_version(struct class_device *class_dev, return len; } -ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf) +ssize_t aac_show_serial_number(struct device *device, + struct device_attribute *attr, char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len = 0; if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) @@ -869,35 +874,39 @@ ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf) return len; } -static ssize_t aac_show_max_channel(struct class_device *class_dev, char *buf) +static ssize_t aac_show_max_channel(struct device *device, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%d\n", - class_to_shost(class_dev)->max_channel); + class_to_shost(device)->max_channel); } -static ssize_t aac_show_max_id(struct class_device *class_dev, char *buf) +static ssize_t aac_show_max_id(struct device *device, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%d\n", - class_to_shost(class_dev)->max_id); + class_to_shost(device)->max_id); } -static ssize_t aac_store_reset_adapter(struct class_device *class_dev, - const char *buf, size_t count) +static ssize_t aac_store_reset_adapter(struct device *device, + struct device_attribute *attr, + const char *buf, size_t count) { int retval = -EACCES; if (!capable(CAP_SYS_ADMIN)) return retval; - retval = aac_reset_adapter((struct aac_dev*)class_to_shost(class_dev)->hostdata, buf[0] == '!'); + retval = aac_reset_adapter((struct aac_dev*)class_to_shost(device)->hostdata, buf[0] == '!'); if (retval >= 0) retval = count; return retval; } -static ssize_t aac_show_reset_adapter(struct class_device *class_dev, - char *buf) +static ssize_t aac_show_reset_adapter(struct device *device, + struct device_attribute *attr, + char *buf) { - struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata; + struct aac_dev *dev = (struct aac_dev*)class_to_shost(device)->hostdata; int len, tmp; tmp = aac_adapter_check_health(dev); @@ -907,70 +916,70 @@ static ssize_t aac_show_reset_adapter(struct class_device *class_dev, return len; } -static struct class_device_attribute aac_model = { +static struct device_attribute aac_model = { .attr = { .name = "model", .mode = S_IRUGO, }, .show = aac_show_model, }; -static struct class_device_attribute aac_vendor = { +static struct device_attribute aac_vendor = { .attr = { .name = "vendor", .mode = S_IRUGO, }, .show = aac_show_vendor, }; -static struct class_device_attribute aac_flags = { +static struct device_attribute aac_flags = { .attr = { .name = "flags", .mode = S_IRUGO, }, .show = aac_show_flags, }; -static struct class_device_attribute aac_kernel_version = { +static struct device_attribute aac_kernel_version = { .attr = { .name = "hba_kernel_version", .mode = S_IRUGO, }, .show = aac_show_kernel_version, }; -static struct class_device_attribute aac_monitor_version = { +static struct device_attribute aac_monitor_version = { .attr = { .name = "hba_monitor_version", .mode = S_IRUGO, }, .show = aac_show_monitor_version, }; -static struct class_device_attribute aac_bios_version = { +static struct device_attribute aac_bios_version = { .attr = { .name = "hba_bios_version", .mode = S_IRUGO, }, .show = aac_show_bios_version, }; -static struct class_device_attribute aac_serial_number = { +static struct device_attribute aac_serial_number = { .attr = { .name = "serial_number", .mode = S_IRUGO, }, .show = aac_show_serial_number, }; -static struct class_device_attribute aac_max_channel = { +static struct device_attribute aac_max_channel = { .attr = { .name = "max_channel", .mode = S_IRUGO, }, .show = aac_show_max_channel, }; -static struct class_device_attribute aac_max_id = { +static struct device_attribute aac_max_id = { .attr = { .name = "max_id", .mode = S_IRUGO, }, .show = aac_show_max_id, }; -static struct class_device_attribute aac_reset = { +static struct device_attribute aac_reset = { .attr = { .name = "reset_host", .mode = S_IWUSR|S_IRUGO, @@ -979,7 +988,7 @@ static struct class_device_attribute aac_reset = { .show = aac_show_reset_adapter, }; -static struct class_device_attribute *aac_attrs[] = { +static struct device_attribute *aac_attrs[] = { &aac_model, &aac_vendor, &aac_flags, @@ -993,6 +1002,10 @@ static struct class_device_attribute *aac_attrs[] = { NULL }; +ssize_t aac_get_serial_number(struct device *device, char *buf) +{ + return aac_show_serial_number(device, &aac_serial_number, buf); +} static const struct file_operations aac_cfg_fops = { .owner = THIS_MODULE, diff --git a/drivers/scsi/arcmsr/arcmsr.h b/drivers/scsi/arcmsr/arcmsr.h index 3288be2e49f8..ab646e580d64 100644 --- a/drivers/scsi/arcmsr/arcmsr.h +++ b/drivers/scsi/arcmsr/arcmsr.h @@ -44,7 +44,7 @@ */ #include <linux/interrupt.h> -struct class_device_attribute; +struct device_attribute; /*The limit of outstanding scsi command that firmware can handle*/ #define ARCMSR_MAX_OUTSTANDING_CMD 256 #define ARCMSR_MAX_FREECCB_NUM 320 @@ -556,6 +556,6 @@ struct SENSE_DATA extern void arcmsr_post_ioctldata2iop(struct AdapterControlBlock *); extern void arcmsr_iop_message_read(struct AdapterControlBlock *); extern struct QBUFFER __iomem *arcmsr_get_iop_rqbuffer(struct AdapterControlBlock *); -extern struct class_device_attribute *arcmsr_host_attrs[]; +extern struct device_attribute *arcmsr_host_attrs[]; extern int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *); void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb); diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c index 7d7b0a554276..69f8346aa288 100644 --- a/drivers/scsi/arcmsr/arcmsr_attr.c +++ b/drivers/scsi/arcmsr/arcmsr_attr.c @@ -57,15 +57,15 @@ #include <scsi/scsi_transport.h> #include "arcmsr.h" -struct class_device_attribute *arcmsr_host_attrs[]; +struct device_attribute *arcmsr_host_attrs[]; static ssize_t arcmsr_sysfs_iop_message_read(struct kobject *kobj, struct bin_attribute *bin, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); - struct Scsi_Host *host = class_to_shost(cdev); + struct device *dev = container_of(kobj,struct device,kobj); + struct Scsi_Host *host = class_to_shost(dev); struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; uint8_t *pQbuffer,*ptmpQbuffer; int32_t allxfer_len = 0; @@ -110,8 +110,8 @@ static ssize_t arcmsr_sysfs_iop_message_write(struct kobject *kobj, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); - struct Scsi_Host *host = class_to_shost(cdev); + struct device *dev = container_of(kobj,struct device,kobj); + struct Scsi_Host *host = class_to_shost(dev); struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex; uint8_t *pQbuffer, *ptmpuserbuffer; @@ -158,8 +158,8 @@ static ssize_t arcmsr_sysfs_iop_message_clear(struct kobject *kobj, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); - struct Scsi_Host *host = class_to_shost(cdev); + struct device *dev = container_of(kobj,struct device,kobj); + struct Scsi_Host *host = class_to_shost(dev); struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; uint8_t *pQbuffer; @@ -220,87 +220,104 @@ int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb) struct Scsi_Host *host = acb->host; int error; - error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr); + error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr); if (error) { printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n"); goto error_bin_file_message_read; } - error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr); + error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr); if (error) { printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n"); goto error_bin_file_message_write; } - error = sysfs_create_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_clear_attr); + error = sysfs_create_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_clear_attr); if (error) { printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n"); goto error_bin_file_message_clear; } return 0; error_bin_file_message_clear: - sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr); + sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr); error_bin_file_message_write: - sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr); + sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr); error_bin_file_message_read: return error; } -void -arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) { +void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) +{ struct Scsi_Host *host = acb->host; - sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_clear_attr); - sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_write_attr); - sysfs_remove_bin_file(&host->shost_classdev.kobj, &arcmsr_sysfs_message_read_attr); + sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_clear_attr); + sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_write_attr); + sysfs_remove_bin_file(&host->shost_dev.kobj, &arcmsr_sysfs_message_read_attr); } static ssize_t -arcmsr_attr_host_driver_version(struct class_device *cdev, char *buf) { +arcmsr_attr_host_driver_version(struct device *dev, + struct device_attribute *attr, char *buf) +{ return snprintf(buf, PAGE_SIZE, "%s\n", ARCMSR_DRIVER_VERSION); } static ssize_t -arcmsr_attr_host_driver_posted_cmd(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_driver_posted_cmd(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", atomic_read(&acb->ccboutstandingcount)); } static ssize_t -arcmsr_attr_host_driver_reset(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_driver_reset(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", acb->num_resets); } static ssize_t -arcmsr_attr_host_driver_abort(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_driver_abort(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", acb->num_aborts); } static ssize_t -arcmsr_attr_host_fw_model(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_model(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%s\n", acb->firm_model); } static ssize_t -arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_version(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%s\n", @@ -308,9 +325,12 @@ arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) { } static ssize_t -arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_request_len(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", @@ -318,9 +338,12 @@ arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) { } static ssize_t -arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_numbers_queue(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", @@ -328,9 +351,12 @@ arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) { } static ssize_t -arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_sdram_size(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", @@ -338,36 +364,39 @@ arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) { } static ssize_t -arcmsr_attr_host_fw_hd_channels(struct class_device *cdev, char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); - struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; +arcmsr_attr_host_fw_hd_channels(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct Scsi_Host *host = class_to_shost(dev); + struct AdapterControlBlock *acb = + (struct AdapterControlBlock *) host->hostdata; return snprintf(buf, PAGE_SIZE, "%4d\n", acb->firm_hd_channels); } -static CLASS_DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL); -static CLASS_DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL); -static CLASS_DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL); -static CLASS_DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL); -static CLASS_DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL); -static CLASS_DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL); -static CLASS_DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL); -static CLASS_DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL); -static CLASS_DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL); -static CLASS_DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL); - -struct class_device_attribute *arcmsr_host_attrs[] = { - &class_device_attr_host_driver_version, - &class_device_attr_host_driver_posted_cmd, - &class_device_attr_host_driver_reset, - &class_device_attr_host_driver_abort, - &class_device_attr_host_fw_model, - &class_device_attr_host_fw_version, - &class_device_attr_host_fw_request_len, - &class_device_attr_host_fw_numbers_queue, - &class_device_attr_host_fw_sdram_size, - &class_device_attr_host_fw_hd_channels, +static DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL); +static DEVICE_ATTR(host_driver_posted_cmd, S_IRUGO, arcmsr_attr_host_driver_posted_cmd, NULL); +static DEVICE_ATTR(host_driver_reset, S_IRUGO, arcmsr_attr_host_driver_reset, NULL); +static DEVICE_ATTR(host_driver_abort, S_IRUGO, arcmsr_attr_host_driver_abort, NULL); +static DEVICE_ATTR(host_fw_model, S_IRUGO, arcmsr_attr_host_fw_model, NULL); +static DEVICE_ATTR(host_fw_version, S_IRUGO, arcmsr_attr_host_fw_version, NULL); +static DEVICE_ATTR(host_fw_request_len, S_IRUGO, arcmsr_attr_host_fw_request_len, NULL); +static DEVICE_ATTR(host_fw_numbers_queue, S_IRUGO, arcmsr_attr_host_fw_numbers_queue, NULL); +static DEVICE_ATTR(host_fw_sdram_size, S_IRUGO, arcmsr_attr_host_fw_sdram_size, NULL); +static DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL); + +struct device_attribute *arcmsr_host_attrs[] = { + &dev_attr_host_driver_version, + &dev_attr_host_driver_posted_cmd, + &dev_attr_host_driver_reset, + &dev_attr_host_driver_abort, + &dev_attr_host_fw_model, + &dev_attr_host_fw_version, + &dev_attr_host_fw_request_len, + &dev_attr_host_fw_numbers_queue, + &dev_attr_host_fw_sdram_size, + &dev_attr_host_fw_hd_channels, NULL, }; diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c index 92d1cb1b21cb..75c84d7b9ce8 100644 --- a/drivers/scsi/ch.c +++ b/drivers/scsi/ch.c @@ -881,7 +881,7 @@ static long ch_ioctl_compat(struct file * file, static int ch_probe(struct device *dev) { struct scsi_device *sd = to_scsi_device(dev); - struct class_device *class_dev; + struct device *class_dev; int minor, ret = -ENOMEM; scsi_changer *ch; @@ -910,11 +910,11 @@ static int ch_probe(struct device *dev) ch->minor = minor; sprintf(ch->name,"ch%d",ch->minor); - class_dev = class_device_create(ch_sysfs_class, NULL, - MKDEV(SCSI_CHANGER_MAJOR, ch->minor), - dev, "s%s", ch->name); + class_dev = device_create(ch_sysfs_class, dev, + MKDEV(SCSI_CHANGER_MAJOR,ch->minor), + "s%s", ch->name); if (IS_ERR(class_dev)) { - printk(KERN_WARNING "ch%d: class_device_create failed\n", + printk(KERN_WARNING "ch%d: device_create failed\n", ch->minor); ret = PTR_ERR(class_dev); goto remove_idr; @@ -945,8 +945,7 @@ static int ch_remove(struct device *dev) idr_remove(&ch_index_idr, ch->minor); spin_unlock(&ch_index_lock); - class_device_destroy(ch_sysfs_class, - MKDEV(SCSI_CHANGER_MAJOR,ch->minor)); + device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor)); kfree(ch->dt); kfree(ch); return 0; diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c index 1592640a87b5..c264a8c5f01e 100644 --- a/drivers/scsi/hosts.c +++ b/drivers/scsi/hosts.c @@ -43,14 +43,14 @@ static int scsi_host_next_hn; /* host_no for next new host */ -static void scsi_host_cls_release(struct class_device *class_dev) +static void scsi_host_cls_release(struct device *dev) { - put_device(&class_to_shost(class_dev)->shost_gendev); + put_device(&class_to_shost(dev)->shost_gendev); } static struct class shost_class = { .name = "scsi_host", - .release = scsi_host_cls_release, + .dev_release = scsi_host_cls_release, }; /** @@ -174,7 +174,7 @@ void scsi_remove_host(struct Scsi_Host *shost) spin_unlock_irqrestore(shost->host_lock, flags); transport_unregister_device(&shost->shost_gendev); - class_device_unregister(&shost->shost_classdev); + device_unregister(&shost->shost_dev); device_del(&shost->shost_gendev); scsi_proc_hostdir_rm(shost->hostt); } @@ -212,7 +212,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev) scsi_host_set_state(shost, SHOST_RUNNING); get_device(shost->shost_gendev.parent); - error = class_device_add(&shost->shost_classdev); + error = device_add(&shost->shost_dev); if (error) goto out_del_gendev; @@ -223,7 +223,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev) GFP_KERNEL); if (shost->shost_data == NULL) { error = -ENOMEM; - goto out_del_classdev; + goto out_del_dev; } } @@ -250,8 +250,8 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev) destroy_workqueue(shost->work_q); out_free_shost_data: kfree(shost->shost_data); - out_del_classdev: - class_device_del(&shost->shost_classdev); + out_del_dev: + device_del(&shost->shost_dev); out_del_gendev: device_del(&shost->shost_gendev); out: @@ -385,11 +385,11 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize) shost->host_no); shost->shost_gendev.release = scsi_host_dev_release; - class_device_initialize(&shost->shost_classdev); - shost->shost_classdev.dev = &shost->shost_gendev; - shost->shost_classdev.class = &shost_class; - snprintf(shost->shost_classdev.class_id, BUS_ID_SIZE, "host%d", - shost->host_no); + device_initialize(&shost->shost_dev); + shost->shost_dev.parent = &shost->shost_gendev; + shost->shost_dev.class = &shost_class; + snprintf(shost->shost_dev.bus_id, BUS_ID_SIZE, "host%d", + shost->host_no); shost->ehandler = kthread_run(scsi_error_handler, shost, "scsi_eh_%d", shost->host_no); @@ -432,12 +432,12 @@ void scsi_unregister(struct Scsi_Host *shost) } EXPORT_SYMBOL(scsi_unregister); -static int __scsi_host_match(struct class_device *cdev, void *data) +static int __scsi_host_match(struct device *dev, void *data) { struct Scsi_Host *p; unsigned short *hostnum = (unsigned short *)data; - p = class_to_shost(cdev); + p = class_to_shost(dev); return p->host_no == *hostnum; } @@ -450,10 +450,10 @@ static int __scsi_host_match(struct class_device *cdev, void *data) **/ struct Scsi_Host *scsi_host_lookup(unsigned short hostnum) { - struct class_device *cdev; + struct device *cdev; struct Scsi_Host *shost = ERR_PTR(-ENXIO); - cdev = class_find_child(&shost_class, &hostnum, __scsi_host_match); + cdev = class_find_device(&shost_class, &hostnum, __scsi_host_match); if (cdev) shost = scsi_host_get(class_to_shost(cdev)); diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c index beecda991682..5b7be1e9841c 100644 --- a/drivers/scsi/hptiop.c +++ b/drivers/scsi/hptiop.c @@ -859,14 +859,16 @@ static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev, return queue_depth; } -static ssize_t hptiop_show_version(struct class_device *class_dev, char *buf) +static ssize_t hptiop_show_version(struct device *dev, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%s\n", driver_ver); } -static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf) +static ssize_t hptiop_show_fw_version(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *host = class_to_shost(class_dev); + struct Scsi_Host *host = class_to_shost(dev); struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n", @@ -876,7 +878,7 @@ static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf) hba->firmware_version & 0xff); } -static struct class_device_attribute hptiop_attr_version = { +static struct device_attribute hptiop_attr_version = { .attr = { .name = "driver-version", .mode = S_IRUGO, @@ -884,7 +886,7 @@ static struct class_device_attribute hptiop_attr_version = { .show = hptiop_show_version, }; -static struct class_device_attribute hptiop_attr_fw_version = { +static struct device_attribute hptiop_attr_fw_version = { .attr = { .name = "firmware-version", .mode = S_IRUGO, @@ -892,7 +894,7 @@ static struct class_device_attribute hptiop_attr_fw_version = { .show = hptiop_show_fw_version, }; -static struct class_device_attribute *hptiop_attrs[] = { +static struct device_attribute *hptiop_attrs[] = { &hptiop_attr_version, &hptiop_attr_fw_version, NULL diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c index 78d46a900bb5..4a922c57125e 100644 --- a/drivers/scsi/ibmvscsi/ibmvscsi.c +++ b/drivers/scsi/ibmvscsi/ibmvscsi.c @@ -1456,9 +1456,10 @@ static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth) /* ------------------------------------------------------------ * sysfs attributes */ -static ssize_t show_host_srp_version(struct class_device *class_dev, char *buf) +static ssize_t show_host_srp_version(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); int len; @@ -1467,7 +1468,7 @@ static ssize_t show_host_srp_version(struct class_device *class_dev, char *buf) return len; } -static struct class_device_attribute ibmvscsi_host_srp_version = { +static struct device_attribute ibmvscsi_host_srp_version = { .attr = { .name = "srp_version", .mode = S_IRUGO, @@ -1475,10 +1476,11 @@ static struct class_device_attribute ibmvscsi_host_srp_version = { .show = show_host_srp_version, }; -static ssize_t show_host_partition_name(struct class_device *class_dev, +static ssize_t show_host_partition_name(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); int len; @@ -1487,7 +1489,7 @@ static ssize_t show_host_partition_name(struct class_device *class_dev, return len; } -static struct class_device_attribute ibmvscsi_host_partition_name = { +static struct device_attribute ibmvscsi_host_partition_name = { .attr = { .name = "partition_name", .mode = S_IRUGO, @@ -1495,10 +1497,11 @@ static struct class_device_attribute ibmvscsi_host_partition_name = { .show = show_host_partition_name, }; -static ssize_t show_host_partition_number(struct class_device *class_dev, +static ssize_t show_host_partition_number(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); int len; @@ -1507,7 +1510,7 @@ static ssize_t show_host_partition_number(struct class_device *class_dev, return len; } -static struct class_device_attribute ibmvscsi_host_partition_number = { +static struct device_attribute ibmvscsi_host_partition_number = { .attr = { .name = "partition_number", .mode = S_IRUGO, @@ -1515,9 +1518,10 @@ static struct class_device_attribute ibmvscsi_host_partition_number = { .show = show_host_partition_number, }; -static ssize_t show_host_mad_version(struct class_device *class_dev, char *buf) +static ssize_t show_host_mad_version(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); int len; @@ -1526,7 +1530,7 @@ static ssize_t show_host_mad_version(struct class_device *class_dev, char *buf) return len; } -static struct class_device_attribute ibmvscsi_host_mad_version = { +static struct device_attribute ibmvscsi_host_mad_version = { .attr = { .name = "mad_version", .mode = S_IRUGO, @@ -1534,9 +1538,10 @@ static struct class_device_attribute ibmvscsi_host_mad_version = { .show = show_host_mad_version, }; -static ssize_t show_host_os_type(struct class_device *class_dev, char *buf) +static ssize_t show_host_os_type(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); int len; @@ -1544,7 +1549,7 @@ static ssize_t show_host_os_type(struct class_device *class_dev, char *buf) return len; } -static struct class_device_attribute ibmvscsi_host_os_type = { +static struct device_attribute ibmvscsi_host_os_type = { .attr = { .name = "os_type", .mode = S_IRUGO, @@ -1552,9 +1557,10 @@ static struct class_device_attribute ibmvscsi_host_os_type = { .show = show_host_os_type, }; -static ssize_t show_host_config(struct class_device *class_dev, char *buf) +static ssize_t show_host_config(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ibmvscsi_host_data *hostdata = shost_priv(shost); /* returns null-terminated host config data */ @@ -1564,7 +1570,7 @@ static ssize_t show_host_config(struct class_device *class_dev, char *buf) return 0; } -static struct class_device_attribute ibmvscsi_host_config = { +static struct device_attribute ibmvscsi_host_config = { .attr = { .name = "config", .mode = S_IRUGO, @@ -1572,7 +1578,7 @@ static struct class_device_attribute ibmvscsi_host_config = { .show = show_host_config, }; -static struct class_device_attribute *ibmvscsi_attrs[] = { +static struct device_attribute *ibmvscsi_attrs[] = { &ibmvscsi_host_srp_version, &ibmvscsi_host_partition_name, &ibmvscsi_host_partition_number, diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c index e5881e92d0fb..3b9514c8f1f1 100644 --- a/drivers/scsi/ibmvscsi/ibmvstgt.c +++ b/drivers/scsi/ibmvscsi/ibmvstgt.c @@ -780,32 +780,35 @@ static int ibmvstgt_it_nexus_response(struct Scsi_Host *shost, u64 itn_id, return 0; } -static ssize_t system_id_show(struct class_device *cdev, char *buf) +static ssize_t system_id_show(struct device *dev, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%s\n", system_id); } -static ssize_t partition_number_show(struct class_device *cdev, char *buf) +static ssize_t partition_number_show(struct device *dev, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%x\n", partition_number); } -static ssize_t unit_address_show(struct class_device *cdev, char *buf) +static ssize_t unit_address_show(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct srp_target *target = host_to_srp_target(shost); struct vio_port *vport = target_to_port(target); return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address); } -static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL); -static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL); -static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL); +static DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL); +static DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL); +static DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL); -static struct class_device_attribute *ibmvstgt_attrs[] = { - &class_device_attr_system_id, - &class_device_attr_partition_number, - &class_device_attr_unit_address, +static struct device_attribute *ibmvstgt_attrs[] = { + &dev_attr_system_id, + &dev_attr_partition_number, + &dev_attr_unit_address, NULL, }; diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c index 65dc18dea845..de5ae6a65029 100644 --- a/drivers/scsi/ipr.c +++ b/drivers/scsi/ipr.c @@ -2431,7 +2431,7 @@ restart: } spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); - kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE); + kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE); LEAVE; } @@ -2451,8 +2451,8 @@ static ssize_t ipr_read_trace(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); - struct Scsi_Host *shost = class_to_shost(cdev); + struct device *dev = container_of(kobj, struct device, kobj); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; int size = IPR_TRACE_SIZE; @@ -2492,15 +2492,16 @@ static const struct { /** * ipr_show_write_caching - Show the write caching attribute - * @class_dev: class device struct - * @buf: buffer + * @dev: device struct + * @buf: buffer * * Return value: * number of bytes printed to buffer **/ -static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf) +static ssize_t ipr_show_write_caching(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; int i, len = 0; @@ -2519,19 +2520,20 @@ static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf) /** * ipr_store_write_caching - Enable/disable adapter write cache - * @class_dev: class_device struct - * @buf: buffer - * @count: buffer size + * @dev: device struct + * @buf: buffer + * @count: buffer size * * This function will enable/disable adapter write cache. * * Return value: * count on success / other on failure **/ -static ssize_t ipr_store_write_caching(struct class_device *class_dev, - const char *buf, size_t count) +static ssize_t ipr_store_write_caching(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; enum ipr_cache_state new_state = CACHE_INVALID; @@ -2569,7 +2571,7 @@ static ssize_t ipr_store_write_caching(struct class_device *class_dev, return count; } -static struct class_device_attribute ipr_ioa_cache_attr = { +static struct device_attribute ipr_ioa_cache_attr = { .attr = { .name = "write_cache", .mode = S_IRUGO | S_IWUSR, @@ -2580,15 +2582,16 @@ static struct class_device_attribute ipr_ioa_cache_attr = { /** * ipr_show_fw_version - Show the firmware version - * @class_dev: class device struct - * @buf: buffer + * @dev: class device struct + * @buf: buffer * * Return value: * number of bytes printed to buffer **/ -static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf) +static ssize_t ipr_show_fw_version(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data; unsigned long lock_flags = 0; @@ -2603,7 +2606,7 @@ static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf) return len; } -static struct class_device_attribute ipr_fw_version_attr = { +static struct device_attribute ipr_fw_version_attr = { .attr = { .name = "fw_version", .mode = S_IRUGO, @@ -2613,15 +2616,16 @@ static struct class_device_attribute ipr_fw_version_attr = { /** * ipr_show_log_level - Show the adapter's error logging level - * @class_dev: class device struct - * @buf: buffer + * @dev: class device struct + * @buf: buffer * * Return value: * number of bytes printed to buffer **/ -static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf) +static ssize_t ipr_show_log_level(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; int len; @@ -2634,16 +2638,17 @@ static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf) /** * ipr_store_log_level - Change the adapter's error logging level - * @class_dev: class device struct - * @buf: buffer + * @dev: class device struct + * @buf: buffer * * Return value: * number of bytes printed to buffer **/ -static ssize_t ipr_store_log_level(struct class_device *class_dev, +static ssize_t ipr_store_log_level(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; @@ -2653,7 +2658,7 @@ static ssize_t ipr_store_log_level(struct class_device *class_dev, return strlen(buf); } -static struct class_device_attribute ipr_log_level_attr = { +static struct device_attribute ipr_log_level_attr = { .attr = { .name = "log_level", .mode = S_IRUGO | S_IWUSR, @@ -2664,9 +2669,9 @@ static struct class_device_attribute ipr_log_level_attr = { /** * ipr_store_diagnostics - IOA Diagnostics interface - * @class_dev: class_device struct - * @buf: buffer - * @count: buffer size + * @dev: device struct + * @buf: buffer + * @count: buffer size * * This function will reset the adapter and wait a reasonable * amount of time for any errors that the adapter might log. @@ -2674,10 +2679,11 @@ static struct class_device_attribute ipr_log_level_attr = { * Return value: * count on success / other on failure **/ -static ssize_t ipr_store_diagnostics(struct class_device *class_dev, +static ssize_t ipr_store_diagnostics(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; int rc = count; @@ -2714,7 +2720,7 @@ static ssize_t ipr_store_diagnostics(struct class_device *class_dev, return rc; } -static struct class_device_attribute ipr_diagnostics_attr = { +static struct device_attribute ipr_diagnostics_attr = { .attr = { .name = "run_diagnostics", .mode = S_IWUSR, @@ -2724,15 +2730,16 @@ static struct class_device_attribute ipr_diagnostics_attr = { /** * ipr_show_adapter_state - Show the adapter's state - * @class_dev: class device struct - * @buf: buffer + * @class_dev: device struct + * @buf: buffer * * Return value: * number of bytes printed to buffer **/ -static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf) +static ssize_t ipr_show_adapter_state(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags = 0; int len; @@ -2748,19 +2755,20 @@ static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf) /** * ipr_store_adapter_state - Change adapter state - * @class_dev: class_device struct - * @buf: buffer - * @count: buffer size + * @dev: device struct + * @buf: buffer + * @count: buffer size * * This function will change the adapter's state. * * Return value: * count on success / other on failure **/ -static ssize_t ipr_store_adapter_state(struct class_device *class_dev, +static ssize_t ipr_store_adapter_state(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags; int result = count; @@ -2781,7 +2789,7 @@ static ssize_t ipr_store_adapter_state(struct class_device *class_dev, return result; } -static struct class_device_attribute ipr_ioa_state_attr = { +static struct device_attribute ipr_ioa_state_attr = { .attr = { .name = "state", .mode = S_IRUGO | S_IWUSR, @@ -2792,19 +2800,20 @@ static struct class_device_attribute ipr_ioa_state_attr = { /** * ipr_store_reset_adapter - Reset the adapter - * @class_dev: class_device struct - * @buf: buffer - * @count: buffer size + * @dev: device struct + * @buf: buffer + * @count: buffer size * * This function will reset the adapter. * * Return value: * count on success / other on failure **/ -static ssize_t ipr_store_reset_adapter(struct class_device *class_dev, +static ssize_t ipr_store_reset_adapter(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; unsigned long lock_flags; int result = count; @@ -2821,7 +2830,7 @@ static ssize_t ipr_store_reset_adapter(struct class_device *class_dev, return result; } -static struct class_device_attribute ipr_ioa_reset_attr = { +static struct device_attribute ipr_ioa_reset_attr = { .attr = { .name = "reset_host", .mode = S_IWUSR, @@ -3054,19 +3063,20 @@ static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg, /** * ipr_store_update_fw - Update the firmware on the adapter - * @class_dev: class_device struct - * @buf: buffer - * @count: buffer size + * @class_dev: device struct + * @buf: buffer + * @count: buffer size * * This function will update the firmware on the adapter. * * Return value: * count on success / other on failure **/ -static ssize_t ipr_store_update_fw(struct class_device *class_dev, - const char *buf, size_t count) +static ssize_t ipr_store_update_fw(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_ucode_image_header *image_hdr; const struct firmware *fw_entry; @@ -3124,7 +3134,7 @@ out: return result; } -static struct class_device_attribute ipr_update_fw_attr = { +static struct device_attribute ipr_update_fw_attr = { .attr = { .name = "update_fw", .mode = S_IWUSR, @@ -3132,7 +3142,7 @@ static struct class_device_attribute ipr_update_fw_attr = { .store = ipr_store_update_fw }; -static struct class_device_attribute *ipr_ioa_attrs[] = { +static struct device_attribute *ipr_ioa_attrs[] = { &ipr_fw_version_attr, &ipr_log_level_attr, &ipr_diagnostics_attr, @@ -3159,7 +3169,7 @@ static ssize_t ipr_read_dump(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); + struct device *cdev = container_of(kobj, struct device, kobj); struct Scsi_Host *shost = class_to_shost(cdev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_dump *dump; @@ -3322,7 +3332,7 @@ static ssize_t ipr_write_dump(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj,struct class_device,kobj); + struct device *cdev = container_of(kobj, struct device, kobj); struct Scsi_Host *shost = class_to_shost(cdev); struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; int rc; @@ -7671,9 +7681,9 @@ static void ipr_remove(struct pci_dev *pdev) ENTER; - ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj, + ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj, &ipr_trace_attr); - ipr_remove_dump_file(&ioa_cfg->host->shost_classdev.kobj, + ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj, &ipr_dump_attr); scsi_remove_host(ioa_cfg->host); @@ -7714,7 +7724,7 @@ static int __devinit ipr_probe(struct pci_dev *pdev, return rc; } - rc = ipr_create_trace_file(&ioa_cfg->host->shost_classdev.kobj, + rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj, &ipr_trace_attr); if (rc) { @@ -7723,11 +7733,11 @@ static int __devinit ipr_probe(struct pci_dev *pdev, return rc; } - rc = ipr_create_dump_file(&ioa_cfg->host->shost_classdev.kobj, + rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj, &ipr_dump_attr); if (rc) { - ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj, + ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj, &ipr_trace_attr); scsi_remove_host(ioa_cfg->host); __ipr_remove(pdev); diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c index 74c9fc204211..a9fbb3f88659 100644 --- a/drivers/scsi/lpfc/lpfc_attr.c +++ b/drivers/scsi/lpfc/lpfc_attr.c @@ -66,23 +66,26 @@ lpfc_jedec_to_ascii(int incr, char hdw[]) } static ssize_t -lpfc_drvr_version_show(struct class_device *cdev, char *buf) +lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr, + char *buf) { return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n"); } static ssize_t -lpfc_info_show(struct class_device *cdev, char *buf) +lpfc_info_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *host = class_to_shost(cdev); + struct Scsi_Host *host = class_to_shost(dev); return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host)); } static ssize_t -lpfc_serialnum_show(struct class_device *cdev, char *buf) +lpfc_serialnum_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -90,18 +93,20 @@ lpfc_serialnum_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_temp_sensor_show(struct class_device *cdev, char *buf) +lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support); } static ssize_t -lpfc_modeldesc_show(struct class_device *cdev, char *buf) +lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -109,9 +114,10 @@ lpfc_modeldesc_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_modelname_show(struct class_device *cdev, char *buf) +lpfc_modelname_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -119,9 +125,10 @@ lpfc_modelname_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_programtype_show(struct class_device *cdev, char *buf) +lpfc_programtype_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -129,9 +136,10 @@ lpfc_programtype_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_vportnum_show(struct class_device *cdev, char *buf) +lpfc_vportnum_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -139,9 +147,10 @@ lpfc_vportnum_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_fwrev_show(struct class_device *cdev, char *buf) +lpfc_fwrev_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; char fwrev[32]; @@ -151,10 +160,10 @@ lpfc_fwrev_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_hdw_show(struct class_device *cdev, char *buf) +lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf) { char hdw[9]; - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; lpfc_vpd_t *vp = &phba->vpd; @@ -163,18 +172,20 @@ lpfc_hdw_show(struct class_device *cdev, char *buf) return snprintf(buf, PAGE_SIZE, "%s\n", hdw); } static ssize_t -lpfc_option_rom_version_show(struct class_device *cdev, char *buf) +lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion); } static ssize_t -lpfc_state_show(struct class_device *cdev, char *buf) +lpfc_state_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; int len = 0; @@ -243,9 +254,10 @@ lpfc_state_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_num_discovered_ports_show(struct class_device *cdev, char *buf) +lpfc_num_discovered_ports_show(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; return snprintf(buf, PAGE_SIZE, "%d\n", @@ -367,9 +379,10 @@ lpfc_selective_reset(struct lpfc_hba *phba) } static ssize_t -lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count) +lpfc_issue_reset(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -385,9 +398,10 @@ lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count) } static ssize_t -lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf) +lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -395,9 +409,10 @@ lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_board_mode_show(struct class_device *cdev, char *buf) +lpfc_board_mode_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; char * state; @@ -415,9 +430,10 @@ lpfc_board_mode_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_board_mode_store(struct class_device *cdev, const char *buf, size_t count) +lpfc_board_mode_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; struct completion online_compl; @@ -509,9 +525,10 @@ lpfc_get_hba_info(struct lpfc_hba *phba, } static ssize_t -lpfc_max_rpi_show(struct class_device *cdev, char *buf) +lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt; @@ -522,9 +539,10 @@ lpfc_max_rpi_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_used_rpi_show(struct class_device *cdev, char *buf) +lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt, acnt; @@ -535,9 +553,10 @@ lpfc_used_rpi_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_max_xri_show(struct class_device *cdev, char *buf) +lpfc_max_xri_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt; @@ -548,9 +567,10 @@ lpfc_max_xri_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_used_xri_show(struct class_device *cdev, char *buf) +lpfc_used_xri_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt, acnt; @@ -561,9 +581,10 @@ lpfc_used_xri_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_max_vpi_show(struct class_device *cdev, char *buf) +lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt; @@ -574,9 +595,10 @@ lpfc_max_vpi_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_used_vpi_show(struct class_device *cdev, char *buf) +lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t cnt, acnt; @@ -587,9 +609,10 @@ lpfc_used_vpi_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_npiv_info_show(struct class_device *cdev, char *buf) +lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -601,9 +624,10 @@ lpfc_npiv_info_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_poll_show(struct class_device *cdev, char *buf) +lpfc_poll_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -611,10 +635,10 @@ lpfc_poll_show(struct class_device *cdev, char *buf) } static ssize_t -lpfc_poll_store(struct class_device *cdev, const char *buf, - size_t count) +lpfc_poll_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; uint32_t creg_val; @@ -670,9 +694,10 @@ lpfc_poll_store(struct class_device *cdev, const char *buf, #define lpfc_param_show(attr) \ static ssize_t \ -lpfc_##attr##_show(struct class_device *cdev, char *buf) \ +lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ struct lpfc_hba *phba = vport->phba;\ int val = 0;\ @@ -683,9 +708,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \ #define lpfc_param_hex_show(attr) \ static ssize_t \ -lpfc_##attr##_show(struct class_device *cdev, char *buf) \ +lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ struct lpfc_hba *phba = vport->phba;\ int val = 0;\ @@ -725,9 +751,10 @@ lpfc_##attr##_set(struct lpfc_hba *phba, int val) \ #define lpfc_param_store(attr) \ static ssize_t \ -lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \ +lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ struct lpfc_hba *phba = vport->phba;\ int val=0;\ @@ -743,9 +770,10 @@ lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \ #define lpfc_vport_param_show(attr) \ static ssize_t \ -lpfc_##attr##_show(struct class_device *cdev, char *buf) \ +lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ int val = 0;\ val = vport->cfg_##attr;\ @@ -754,9 +782,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \ #define lpfc_vport_param_hex_show(attr) \ static ssize_t \ -lpfc_##attr##_show(struct class_device *cdev, char *buf) \ +lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ int val = 0;\ val = vport->cfg_##attr;\ @@ -794,9 +823,10 @@ lpfc_##attr##_set(struct lpfc_vport *vport, int val) \ #define lpfc_vport_param_store(attr) \ static ssize_t \ -lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \ +lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ - struct Scsi_Host *shost = class_to_shost(cdev);\ + struct Scsi_Host *shost = class_to_shost(dev);\ struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ int val=0;\ if (!isdigit(buf[0]))\ @@ -822,7 +852,7 @@ module_param(lpfc_##name, int, 0);\ MODULE_PARM_DESC(lpfc_##name, desc);\ lpfc_param_show(name)\ lpfc_param_init(name, defval, minval, maxval)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) +static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -832,8 +862,8 @@ lpfc_param_show(name)\ lpfc_param_init(name, defval, minval, maxval)\ lpfc_param_set(name, defval, minval, maxval)\ lpfc_param_store(name)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ - lpfc_##name##_show, lpfc_##name##_store) +static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ + lpfc_##name##_show, lpfc_##name##_store) #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -841,7 +871,7 @@ module_param(lpfc_##name, int, 0);\ MODULE_PARM_DESC(lpfc_##name, desc);\ lpfc_param_hex_show(name)\ lpfc_param_init(name, defval, minval, maxval)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) +static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -851,8 +881,8 @@ lpfc_param_hex_show(name)\ lpfc_param_init(name, defval, minval, maxval)\ lpfc_param_set(name, defval, minval, maxval)\ lpfc_param_store(name)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ - lpfc_##name##_show, lpfc_##name##_store) +static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ + lpfc_##name##_show, lpfc_##name##_store) #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -866,7 +896,7 @@ module_param(lpfc_##name, int, 0);\ MODULE_PARM_DESC(lpfc_##name, desc);\ lpfc_vport_param_show(name)\ lpfc_vport_param_init(name, defval, minval, maxval)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) +static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -876,8 +906,8 @@ lpfc_vport_param_show(name)\ lpfc_vport_param_init(name, defval, minval, maxval)\ lpfc_vport_param_set(name, defval, minval, maxval)\ lpfc_vport_param_store(name)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ - lpfc_##name##_show, lpfc_##name##_store) +static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ + lpfc_##name##_show, lpfc_##name##_store) #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -885,7 +915,7 @@ module_param(lpfc_##name, int, 0);\ MODULE_PARM_DESC(lpfc_##name, desc);\ lpfc_vport_param_hex_show(name)\ lpfc_vport_param_init(name, defval, minval, maxval)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) +static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ static int lpfc_##name = defval;\ @@ -895,46 +925,44 @@ lpfc_vport_param_hex_show(name)\ lpfc_vport_param_init(name, defval, minval, maxval)\ lpfc_vport_param_set(name, defval, minval, maxval)\ lpfc_vport_param_store(name)\ -static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ - lpfc_##name##_show, lpfc_##name##_store) - -static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL); -static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL); -static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL); -static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL); -static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL); -static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL); -static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL); -static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL); -static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL); -static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO, - lpfc_option_rom_version_show, NULL); -static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO, - lpfc_num_discovered_ports_show, NULL); -static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL); -static CLASS_DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, - NULL); -static CLASS_DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR, - lpfc_board_mode_show, lpfc_board_mode_store); -static CLASS_DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset); -static CLASS_DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL); -static CLASS_DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL); -static CLASS_DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL); -static CLASS_DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL); -static CLASS_DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL); -static CLASS_DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL); -static CLASS_DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL); -static CLASS_DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, - NULL); +static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ + lpfc_##name##_show, lpfc_##name##_store) + +static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL); +static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL); +static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL); +static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL); +static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL); +static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL); +static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL); +static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL); +static DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL); +static DEVICE_ATTR(option_rom_version, S_IRUGO, + lpfc_option_rom_version_show, NULL); +static DEVICE_ATTR(num_discovered_ports, S_IRUGO, + lpfc_num_discovered_ports_show, NULL); +static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL); +static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL); +static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR, + lpfc_board_mode_show, lpfc_board_mode_store); +static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset); +static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL); +static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL); +static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL); +static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL); +static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL); +static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL); +static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL); +static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL); static char *lpfc_soft_wwn_key = "C99G71SL8032A"; static ssize_t -lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf, - size_t count) +lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; unsigned int cnt = count; @@ -963,13 +991,14 @@ lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf, phba->soft_wwn_enable = 1; return count; } -static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL, - lpfc_soft_wwn_enable_store); +static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL, + lpfc_soft_wwn_enable_store); static ssize_t -lpfc_soft_wwpn_show(struct class_device *cdev, char *buf) +lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -979,9 +1008,10 @@ lpfc_soft_wwpn_show(struct class_device *cdev, char *buf) static ssize_t -lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count) +lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; struct completion online_compl; @@ -1047,13 +1077,14 @@ lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count) "reinit adapter - %d\n", stat2); return (stat1 || stat2) ? -EIO : count; } -static CLASS_DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\ - lpfc_soft_wwpn_show, lpfc_soft_wwpn_store); +static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\ + lpfc_soft_wwpn_show, lpfc_soft_wwpn_store); static ssize_t -lpfc_soft_wwnn_show(struct class_device *cdev, char *buf) +lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; return snprintf(buf, PAGE_SIZE, "0x%llx\n", (unsigned long long)phba->cfg_soft_wwnn); @@ -1061,9 +1092,10 @@ lpfc_soft_wwnn_show(struct class_device *cdev, char *buf) static ssize_t -lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count) +lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; unsigned int i, j, cnt=count; u8 wwnn[8]; @@ -1107,8 +1139,8 @@ lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count) return count; } -static CLASS_DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\ - lpfc_soft_wwnn_show, lpfc_soft_wwnn_store); +static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\ + lpfc_soft_wwnn_show, lpfc_soft_wwnn_store); static int lpfc_poll = 0; @@ -1118,8 +1150,8 @@ MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:" " 1 - poll with interrupts enabled" " 3 - poll and disable FCP ring interrupts"); -static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, - lpfc_poll_show, lpfc_poll_store); +static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, + lpfc_poll_show, lpfc_poll_store); int lpfc_sli_mode = 0; module_param(lpfc_sli_mode, int, 0); @@ -1133,7 +1165,7 @@ module_param(lpfc_enable_npiv, int, 0); MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality"); lpfc_param_show(enable_npiv); lpfc_param_init(enable_npiv, 0, 0, 1); -static CLASS_DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, +static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL); /* @@ -1147,9 +1179,10 @@ MODULE_PARM_DESC(lpfc_nodev_tmo, "Seconds driver will hold I/O waiting " "for a device to come back"); static ssize_t -lpfc_nodev_tmo_show(struct class_device *cdev, char *buf) +lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; int val = 0; val = vport->cfg_devloss_tmo; @@ -1221,8 +1254,8 @@ lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val) lpfc_vport_param_store(nodev_tmo) -static CLASS_DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, - lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); +static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, + lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); /* # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that @@ -1255,8 +1288,8 @@ lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val) } lpfc_vport_param_store(devloss_tmo) -static CLASS_DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, - lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); +static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, + lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); /* # lpfc_log_verbose: Only turn this flag on if you are willing to risk being @@ -1374,8 +1407,8 @@ lpfc_restrict_login_set(struct lpfc_vport *vport, int val) return 0; } lpfc_vport_param_store(restrict_login); -static CLASS_DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, - lpfc_restrict_login_show, lpfc_restrict_login_store); +static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, + lpfc_restrict_login_show, lpfc_restrict_login_store); /* # Some disk devices have a "select ID" or "select Target" capability. @@ -1433,7 +1466,7 @@ MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology"); lpfc_param_show(topology) lpfc_param_init(topology, 0, 0, 6) lpfc_param_store(topology) -static CLASS_DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR, +static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR, lpfc_topology_show, lpfc_topology_store); /* @@ -1497,7 +1530,7 @@ lpfc_link_speed_init(struct lpfc_hba *phba, int val) } lpfc_param_store(link_speed) -static CLASS_DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR, +static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR, lpfc_link_speed_show, lpfc_link_speed_store); /* @@ -1623,82 +1656,81 @@ LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat."); LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count"); -struct class_device_attribute *lpfc_hba_attrs[] = { - &class_device_attr_info, - &class_device_attr_serialnum, - &class_device_attr_modeldesc, - &class_device_attr_modelname, - &class_device_attr_programtype, - &class_device_attr_portnum, - &class_device_attr_fwrev, - &class_device_attr_hdw, - &class_device_attr_option_rom_version, - &class_device_attr_state, - &class_device_attr_num_discovered_ports, - &class_device_attr_lpfc_drvr_version, - &class_device_attr_lpfc_temp_sensor, - &class_device_attr_lpfc_log_verbose, - &class_device_attr_lpfc_lun_queue_depth, - &class_device_attr_lpfc_hba_queue_depth, - &class_device_attr_lpfc_peer_port_login, - &class_device_attr_lpfc_nodev_tmo, - &class_device_attr_lpfc_devloss_tmo, - &class_device_attr_lpfc_fcp_class, - &class_device_attr_lpfc_use_adisc, - &class_device_attr_lpfc_ack0, - &class_device_attr_lpfc_topology, - &class_device_attr_lpfc_scan_down, - &class_device_attr_lpfc_link_speed, - &class_device_attr_lpfc_cr_delay, - &class_device_attr_lpfc_cr_count, - &class_device_attr_lpfc_multi_ring_support, - &class_device_attr_lpfc_multi_ring_rctl, - &class_device_attr_lpfc_multi_ring_type, - &class_device_attr_lpfc_fdmi_on, - &class_device_attr_lpfc_max_luns, - &class_device_attr_lpfc_enable_npiv, - &class_device_attr_nport_evt_cnt, - &class_device_attr_board_mode, - &class_device_attr_max_vpi, - &class_device_attr_used_vpi, - &class_device_attr_max_rpi, - &class_device_attr_used_rpi, - &class_device_attr_max_xri, - &class_device_attr_used_xri, - &class_device_attr_npiv_info, - &class_device_attr_issue_reset, - &class_device_attr_lpfc_poll, - &class_device_attr_lpfc_poll_tmo, - &class_device_attr_lpfc_use_msi, - &class_device_attr_lpfc_soft_wwnn, - &class_device_attr_lpfc_soft_wwpn, - &class_device_attr_lpfc_soft_wwn_enable, - &class_device_attr_lpfc_enable_hba_reset, - &class_device_attr_lpfc_enable_hba_heartbeat, - &class_device_attr_lpfc_sg_seg_cnt, +struct device_attribute *lpfc_hba_attrs[] = { + &dev_attr_info, + &dev_attr_serialnum, + &dev_attr_modeldesc, + &dev_attr_modelname, + &dev_attr_programtype, + &dev_attr_portnum, + &dev_attr_fwrev, + &dev_attr_hdw, + &dev_attr_option_rom_version, + &dev_attr_state, + &dev_attr_num_discovered_ports, + &dev_attr_lpfc_drvr_version, + &dev_attr_lpfc_temp_sensor, + &dev_attr_lpfc_log_verbose, + &dev_attr_lpfc_lun_queue_depth, + &dev_attr_lpfc_hba_queue_depth, + &dev_attr_lpfc_peer_port_login, + &dev_attr_lpfc_nodev_tmo, + &dev_attr_lpfc_devloss_tmo, + &dev_attr_lpfc_fcp_class, + &dev_attr_lpfc_use_adisc, + &dev_attr_lpfc_ack0, + &dev_attr_lpfc_topology, + &dev_attr_lpfc_scan_down, + &dev_attr_lpfc_link_speed, + &dev_attr_lpfc_cr_delay, + &dev_attr_lpfc_cr_count, + &dev_attr_lpfc_multi_ring_support, + &dev_attr_lpfc_multi_ring_rctl, + &dev_attr_lpfc_multi_ring_type, + &dev_attr_lpfc_fdmi_on, + &dev_attr_lpfc_max_luns, + &dev_attr_lpfc_enable_npiv, + &dev_attr_nport_evt_cnt, + &dev_attr_board_mode, + &dev_attr_max_vpi, + &dev_attr_used_vpi, + &dev_attr_max_rpi, + &dev_attr_used_rpi, + &dev_attr_max_xri, + &dev_attr_used_xri, + &dev_attr_npiv_info, + &dev_attr_issue_reset, + &dev_attr_lpfc_poll, + &dev_attr_lpfc_poll_tmo, + &dev_attr_lpfc_use_msi, + &dev_attr_lpfc_soft_wwnn, + &dev_attr_lpfc_soft_wwpn, + &dev_attr_lpfc_soft_wwn_enable, + &dev_attr_lpfc_enable_hba_reset, + &dev_attr_lpfc_enable_hba_heartbeat, + &dev_attr_lpfc_sg_seg_cnt, NULL, }; -struct class_device_attribute *lpfc_vport_attrs[] = { - &class_device_attr_info, - &class_device_attr_state, - &class_device_attr_num_discovered_ports, - &class_device_attr_lpfc_drvr_version, - - &class_device_attr_lpfc_log_verbose, - &class_device_attr_lpfc_lun_queue_depth, - &class_device_attr_lpfc_nodev_tmo, - &class_device_attr_lpfc_devloss_tmo, - &class_device_attr_lpfc_hba_queue_depth, - &class_device_attr_lpfc_peer_port_login, - &class_device_attr_lpfc_restrict_login, - &class_device_attr_lpfc_fcp_class, - &class_device_attr_lpfc_use_adisc, - &class_device_attr_lpfc_fdmi_on, - &class_device_attr_lpfc_max_luns, - &class_device_attr_nport_evt_cnt, - &class_device_attr_npiv_info, - &class_device_attr_lpfc_enable_da_id, +struct device_attribute *lpfc_vport_attrs[] = { + &dev_attr_info, + &dev_attr_state, + &dev_attr_num_discovered_ports, + &dev_attr_lpfc_drvr_version, + &dev_attr_lpfc_log_verbose, + &dev_attr_lpfc_lun_queue_depth, + &dev_attr_lpfc_nodev_tmo, + &dev_attr_lpfc_devloss_tmo, + &dev_attr_lpfc_hba_queue_depth, + &dev_attr_lpfc_peer_port_login, + &dev_attr_lpfc_restrict_login, + &dev_attr_lpfc_fcp_class, + &dev_attr_lpfc_use_adisc, + &dev_attr_lpfc_fdmi_on, + &dev_attr_lpfc_max_luns, + &dev_attr_nport_evt_cnt, + &dev_attr_npiv_info, + &dev_attr_lpfc_enable_da_id, NULL, }; @@ -1707,9 +1739,8 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { size_t buf_off; - struct class_device *cdev = container_of(kobj, struct class_device, - kobj); - struct Scsi_Host *shost = class_to_shost(cdev); + struct device *dev = container_of(kobj, struct device, kobj); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -1741,9 +1772,8 @@ sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr, { size_t buf_off; uint32_t * tmp_ptr; - struct class_device *cdev = container_of(kobj, struct class_device, - kobj); - struct Scsi_Host *shost = class_to_shost(cdev); + struct device *dev = container_of(kobj, struct device, kobj); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; @@ -1798,9 +1828,8 @@ static ssize_t sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj, struct class_device, - kobj); - struct Scsi_Host *shost = class_to_shost(cdev); + struct device *dev = container_of(kobj, struct device, kobj); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; struct lpfcMboxq *mbox = NULL; @@ -1853,9 +1882,8 @@ static ssize_t sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { - struct class_device *cdev = container_of(kobj, struct class_device, - kobj); - struct Scsi_Host *shost = class_to_shost(cdev); + struct device *dev = container_of(kobj, struct device, kobj); + struct Scsi_Host *shost = class_to_shost(dev); struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_hba *phba = vport->phba; int rc; @@ -2038,19 +2066,19 @@ lpfc_alloc_sysfs_attr(struct lpfc_vport *vport) struct Scsi_Host *shost = lpfc_shost_from_vport(vport); int error; - error = sysfs_create_bin_file(&shost->shost_classdev.kobj, + error = sysfs_create_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); if (error) goto out; - error = sysfs_create_bin_file(&shost->shost_classdev.kobj, + error = sysfs_create_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr); if (error) goto out_remove_ctlreg_attr; return 0; out_remove_ctlreg_attr: - sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); + sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); out: return error; } @@ -2060,8 +2088,8 @@ lpfc_free_sysfs_attr(struct lpfc_vport *vport) { struct Scsi_Host *shost = lpfc_shost_from_vport(vport); - sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr); - sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); + sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr); + sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); } @@ -2443,9 +2471,11 @@ lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) #define lpfc_rport_show_function(field, format_string, sz, cast) \ static ssize_t \ -lpfc_show_rport_##field (struct class_device *cdev, char *buf) \ +lpfc_show_rport_##field (struct device *dev, \ + struct device_attribute *attr, \ + char *buf) \ { \ - struct fc_rport *rport = transport_class_to_rport(cdev); \ + struct fc_rport *rport = transport_class_to_rport(dev); \ struct lpfc_rport_data *rdata = rport->hostdata; \ return snprintf(buf, sz, format_string, \ (rdata->target) ? cast rdata->target->field : 0); \ diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h index 0819f5f39de5..7c9f8317d972 100644 --- a/drivers/scsi/lpfc/lpfc_crtn.h +++ b/drivers/scsi/lpfc/lpfc_crtn.h @@ -253,8 +253,8 @@ void lpfc_get_cfgparam(struct lpfc_hba *); void lpfc_get_vport_cfgparam(struct lpfc_vport *); int lpfc_alloc_sysfs_attr(struct lpfc_vport *); void lpfc_free_sysfs_attr(struct lpfc_vport *); -extern struct class_device_attribute *lpfc_hba_attrs[]; -extern struct class_device_attribute *lpfc_vport_attrs[]; +extern struct device_attribute *lpfc_hba_attrs[]; +extern struct device_attribute *lpfc_vport_attrs[]; extern struct scsi_host_template lpfc_template; extern struct scsi_host_template lpfc_vport_template; extern struct fc_function_template lpfc_transport_functions; diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c index 9f041929aca5..820f91fb63ba 100644 --- a/drivers/scsi/megaraid/megaraid_mbox.c +++ b/drivers/scsi/megaraid/megaraid_mbox.c @@ -125,7 +125,7 @@ static irqreturn_t megaraid_isr(int, void *); static void megaraid_mbox_dpc(unsigned long); -static ssize_t megaraid_sysfs_show_app_hndl(struct class_device *, char *); +static ssize_t megaraid_sysfs_show_app_hndl(struct device *, struct device_attribute *attr, char *); static ssize_t megaraid_sysfs_show_ldnum(struct device *, struct device_attribute *attr, char *); static int megaraid_cmm_register(adapter_t *); @@ -313,12 +313,12 @@ static struct pci_driver megaraid_pci_driver = { // definitions for the device attributes for exporting logical drive number // for a scsi address (Host, Channel, Id, Lun) -CLASS_DEVICE_ATTR(megaraid_mbox_app_hndl, S_IRUSR, megaraid_sysfs_show_app_hndl, +DEVICE_ATTR(megaraid_mbox_app_hndl, S_IRUSR, megaraid_sysfs_show_app_hndl, NULL); // Host template initializer for megaraid mbox sysfs device attributes -static struct class_device_attribute *megaraid_shost_attrs[] = { - &class_device_attr_megaraid_mbox_app_hndl, +static struct device_attribute *megaraid_shost_attrs[] = { + &dev_attr_megaraid_mbox_app_hndl, NULL, }; @@ -4063,9 +4063,10 @@ megaraid_sysfs_get_ldmap(adapter_t *adapter) * handle, since we do not interface with applications directly. */ static ssize_t -megaraid_sysfs_show_app_hndl(struct class_device *cdev, char *buf) +megaraid_sysfs_show_app_hndl(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(cdev); + struct Scsi_Host *shost = class_to_shost(dev); adapter_t *adapter = (adapter_t *)SCSIHOST2ADAP(shost); uint32_t app_hndl; diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c index c5ebf018b378..d89289400425 100644 --- a/drivers/scsi/ncr53c8xx.c +++ b/drivers/scsi/ncr53c8xx.c @@ -8243,7 +8243,8 @@ static void process_waiting_list(struct ncb *np, int sts) #undef next_wcmd -static ssize_t show_ncr53c8xx_revision(struct class_device *dev, char *buf) +static ssize_t show_ncr53c8xx_revision(struct device *dev, + struct device_attribute *attr, char *buf) { struct Scsi_Host *host = class_to_shost(dev); struct host_data *host_data = (struct host_data *)host->hostdata; @@ -8251,12 +8252,12 @@ static ssize_t show_ncr53c8xx_revision(struct class_device *dev, char *buf) return snprintf(buf, 20, "0x%x\n", host_data->ncb->revision_id); } -static struct class_device_attribute ncr53c8xx_revision_attr = { +static struct device_attribute ncr53c8xx_revision_attr = { .attr = { .name = "revision", .mode = S_IRUGO, }, .show = show_ncr53c8xx_revision, }; -static struct class_device_attribute *ncr53c8xx_host_attrs[] = { +static struct device_attribute *ncr53c8xx_host_attrs[] = { &ncr53c8xx_revision_attr, NULL }; diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c index abef7048f25b..31f7aec44d90 100644 --- a/drivers/scsi/osst.c +++ b/drivers/scsi/osst.c @@ -5591,9 +5591,10 @@ static void osst_remove_sysfs_files(struct device_driver *sysfs) * sysfs support for accessing ADR header information */ -static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf) +static ssize_t osst_adr_rev_show(struct device *dev, + struct device_attribute *attr, char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5601,11 +5602,13 @@ static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf) return l; } -CLASS_DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL); +DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL); -static ssize_t osst_linux_media_version_show(struct class_device *class_dev, char *buf) +static ssize_t osst_linux_media_version_show(struct device *dev, + struct device_attribute *attr, + char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5613,11 +5616,12 @@ static ssize_t osst_linux_media_version_show(struct class_device *class_dev, cha return l; } -CLASS_DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL); +DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL); -static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf) +static ssize_t osst_capacity_show(struct device *dev, + struct device_attribute *attr, char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5625,11 +5629,13 @@ static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf) return l; } -CLASS_DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL); +DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL); -static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *buf) +static ssize_t osst_first_data_ppos_show(struct device *dev, + struct device_attribute *attr, + char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5637,11 +5643,13 @@ static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *b return l; } -CLASS_DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL); +DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL); -static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *buf) +static ssize_t osst_eod_frame_ppos_show(struct device *dev, + struct device_attribute *attr, + char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5649,11 +5657,12 @@ static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *bu return l; } -CLASS_DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL); +DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL); -static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf) +static ssize_t osst_filemark_cnt_show(struct device *dev, + struct device_attribute *attr, char *buf) { - struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev); + struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); ssize_t l = 0; if (STp && STp->header_ok && STp->linux_media) @@ -5661,7 +5670,7 @@ static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf) return l; } -CLASS_DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL); +DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL); static struct class *osst_sysfs_class; @@ -5678,44 +5687,37 @@ static int osst_sysfs_init(void) static void osst_sysfs_destroy(dev_t dev) { - class_device_destroy(osst_sysfs_class, dev); + device_destroy(osst_sysfs_class, dev); } static int osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name) { - struct class_device *osst_class_member; + struct device *osst_member; int err; - osst_class_member = class_device_create(osst_sysfs_class, NULL, dev, - device, "%s", name); - if (IS_ERR(osst_class_member)) { + osst_member = device_create(osst_sysfs_class, device, dev, "%s", name); + if (IS_ERR(osst_member)) { printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name); - return PTR_ERR(osst_class_member); + return PTR_ERR(osst_member); } - class_set_devdata(osst_class_member, STp); - err = class_device_create_file(osst_class_member, - &class_device_attr_ADR_rev); + dev_set_drvdata(osst_member, STp); + err = device_create_file(osst_member, &dev_attr_ADR_rev); if (err) goto err_out; - err = class_device_create_file(osst_class_member, - &class_device_attr_media_version); + err = device_create_file(osst_member, &dev_attr_media_version); if (err) goto err_out; - err = class_device_create_file(osst_class_member, - &class_device_attr_capacity); + err = device_create_file(osst_member, &dev_attr_capacity); if (err) goto err_out; - err = class_device_create_file(osst_class_member, - &class_device_attr_BOT_frame); + err = device_create_file(osst_member, &dev_attr_BOT_frame); if (err) goto err_out; - err = class_device_create_file(osst_class_member, - &class_device_attr_EOD_frame); + err = device_create_file(osst_member, &dev_attr_EOD_frame); if (err) goto err_out; - err = class_device_create_file(osst_class_member, - &class_device_attr_file_count); + err = device_create_file(osst_member, &dev_attr_file_count); if (err) goto err_out; diff --git a/drivers/scsi/pcmcia/sym53c500_cs.c b/drivers/scsi/pcmcia/sym53c500_cs.c index 3454a5714749..0be232b58ffb 100644 --- a/drivers/scsi/pcmcia/sym53c500_cs.c +++ b/drivers/scsi/pcmcia/sym53c500_cs.c @@ -632,9 +632,10 @@ SYM53C500_biosparm(struct scsi_device *disk, } static ssize_t -SYM53C500_show_pio(struct class_device *cdev, char *buf) +SYM53C500_show_pio(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *SHp = class_to_shost(cdev); + struct Scsi_Host *SHp = class_to_shost(dev); struct sym53c500_data *data = (struct sym53c500_data *)SHp->hostdata; @@ -642,10 +643,11 @@ SYM53C500_show_pio(struct class_device *cdev, char *buf) } static ssize_t -SYM53C500_store_pio(struct class_device *cdev, const char *buf, size_t count) +SYM53C500_store_pio(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int pio; - struct Scsi_Host *SHp = class_to_shost(cdev); + struct Scsi_Host *SHp = class_to_shost(dev); struct sym53c500_data *data = (struct sym53c500_data *)SHp->hostdata; @@ -662,7 +664,7 @@ SYM53C500_store_pio(struct class_device *cdev, const char *buf, size_t count) * SCSI HBA device attributes we want to * make available via sysfs. */ -static struct class_device_attribute SYM53C500_pio_attr = { +static struct device_attribute SYM53C500_pio_attr = { .attr = { .name = "fast_pio", .mode = (S_IRUGO | S_IWUSR), @@ -671,7 +673,7 @@ static struct class_device_attribute SYM53C500_pio_attr = { .store = SYM53C500_store_pio, }; -static struct class_device_attribute *SYM53C500_shost_attrs[] = { +static struct device_attribute *SYM53C500_shost_attrs[] = { &SYM53C500_pio_attr, NULL, }; diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c index 413d8cd6a324..d61df036910c 100644 --- a/drivers/scsi/qla2xxx/qla_attr.c +++ b/drivers/scsi/qla2xxx/qla_attr.c @@ -530,15 +530,17 @@ qla2x00_free_sysfs_attr(scsi_qla_host_t *ha) /* Scsi_Host attributes. */ static ssize_t -qla2x00_drvr_version_show(struct class_device *cdev, char *buf) +qla2x00_drvr_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str); } static ssize_t -qla2x00_fw_version_show(struct class_device *cdev, char *buf) +qla2x00_fw_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); char fw_str[30]; return snprintf(buf, PAGE_SIZE, "%s\n", @@ -546,9 +548,10 @@ qla2x00_fw_version_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_serial_num_show(struct class_device *cdev, char *buf) +qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); uint32_t sn; if (IS_FWI2_CAPABLE(ha)) @@ -560,40 +563,45 @@ qla2x00_serial_num_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_isp_name_show(struct class_device *cdev, char *buf) +qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device); } static ssize_t -qla2x00_isp_id_show(struct class_device *cdev, char *buf) +qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n", ha->product_id[0], ha->product_id[1], ha->product_id[2], ha->product_id[3]); } static ssize_t -qla2x00_model_name_show(struct class_device *cdev, char *buf) +qla2x00_model_name_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number); } static ssize_t -qla2x00_model_desc_show(struct class_device *cdev, char *buf) +qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_desc ? ha->model_desc: ""); } static ssize_t -qla2x00_pci_info_show(struct class_device *cdev, char *buf) +qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); char pci_info[30]; return snprintf(buf, PAGE_SIZE, "%s\n", @@ -601,9 +609,10 @@ qla2x00_pci_info_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_state_show(struct class_device *cdev, char *buf) +qla2x00_state_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int len = 0; if (atomic_read(&ha->loop_state) == LOOP_DOWN || @@ -639,9 +648,10 @@ qla2x00_state_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_zio_show(struct class_device *cdev, char *buf) +qla2x00_zio_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int len = 0; switch (ha->zio_mode) { @@ -656,9 +666,10 @@ qla2x00_zio_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count) +qla2x00_zio_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int val = 0; uint16_t zio_mode; @@ -682,18 +693,19 @@ qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count) } static ssize_t -qla2x00_zio_timer_show(struct class_device *cdev, char *buf) +qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100); } static ssize_t -qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, - size_t count) +qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int val = 0; uint16_t zio_timer; @@ -709,9 +721,10 @@ qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, } static ssize_t -qla2x00_beacon_show(struct class_device *cdev, char *buf) +qla2x00_beacon_show(struct device *dev, struct device_attribute *attr, + char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int len = 0; if (ha->beacon_blink_led) @@ -722,10 +735,10 @@ qla2x00_beacon_show(struct class_device *cdev, char *buf) } static ssize_t -qla2x00_beacon_store(struct class_device *cdev, const char *buf, - size_t count) +qla2x00_beacon_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); int val = 0; int rval; @@ -753,84 +766,86 @@ qla2x00_beacon_store(struct class_device *cdev, const char *buf, } static ssize_t -qla2x00_optrom_bios_version_show(struct class_device *cdev, char *buf) +qla2x00_optrom_bios_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1], ha->bios_revision[0]); } static ssize_t -qla2x00_optrom_efi_version_show(struct class_device *cdev, char *buf) +qla2x00_optrom_efi_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1], ha->efi_revision[0]); } static ssize_t -qla2x00_optrom_fcode_version_show(struct class_device *cdev, char *buf) +qla2x00_optrom_fcode_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1], ha->fcode_revision[0]); } static ssize_t -qla2x00_optrom_fw_version_show(struct class_device *cdev, char *buf) +qla2x00_optrom_fw_version_show(struct device *dev, + struct device_attribute *attr, char *buf) { - scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); + scsi_qla_host_t *ha = shost_priv(class_to_shost(dev)); return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n", ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2], ha->fw_revision[3]); } -static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, - NULL); -static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); -static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); -static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); -static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); -static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); -static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); -static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); -static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); -static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, - qla2x00_zio_store); -static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, - qla2x00_zio_timer_store); -static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, - qla2x00_beacon_store); -static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO, - qla2x00_optrom_bios_version_show, NULL); -static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO, - qla2x00_optrom_efi_version_show, NULL); -static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO, - qla2x00_optrom_fcode_version_show, NULL); -static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO, - qla2x00_optrom_fw_version_show, NULL); - -struct class_device_attribute *qla2x00_host_attrs[] = { - &class_device_attr_driver_version, - &class_device_attr_fw_version, - &class_device_attr_serial_num, - &class_device_attr_isp_name, - &class_device_attr_isp_id, - &class_device_attr_model_name, - &class_device_attr_model_desc, - &class_device_attr_pci_info, - &class_device_attr_state, - &class_device_attr_zio, - &class_device_attr_zio_timer, - &class_device_attr_beacon, - &class_device_attr_optrom_bios_version, - &class_device_attr_optrom_efi_version, - &class_device_attr_optrom_fcode_version, - &class_device_attr_optrom_fw_version, +static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL); +static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); +static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); +static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); +static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); +static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); +static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); +static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); +static DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); +static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store); +static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, + qla2x00_zio_timer_store); +static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, + qla2x00_beacon_store); +static DEVICE_ATTR(optrom_bios_version, S_IRUGO, + qla2x00_optrom_bios_version_show, NULL); +static DEVICE_ATTR(optrom_efi_version, S_IRUGO, + qla2x00_optrom_efi_version_show, NULL); +static DEVICE_ATTR(optrom_fcode_version, S_IRUGO, + qla2x00_optrom_fcode_version_show, NULL); +static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show, + NULL); + +struct device_attribute *qla2x00_host_attrs[] = { + &dev_attr_driver_version, + &dev_attr_fw_version, + &dev_attr_serial_num, + &dev_attr_isp_name, + &dev_attr_isp_id, + &dev_attr_model_name, + &dev_attr_model_desc, + &dev_attr_pci_info, + &dev_attr_state, + &dev_attr_zio, + &dev_attr_zio_timer, + &dev_attr_beacon, + &dev_attr_optrom_bios_version, + &dev_attr_optrom_efi_version, + &dev_attr_optrom_fcode_version, + &dev_attr_optrom_fw_version, NULL, }; diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h index a9571c214a9e..76eb4fecce65 100644 --- a/drivers/scsi/qla2xxx/qla_gbl.h +++ b/drivers/scsi/qla2xxx/qla_gbl.h @@ -347,8 +347,8 @@ extern void qla2x00_get_sym_node_name(scsi_qla_host_t *, uint8_t *); /* * Global Function Prototypes in qla_attr.c source file. */ -struct class_device_attribute; -extern struct class_device_attribute *qla2x00_host_attrs[]; +struct device_attribute; +extern struct device_attribute *qla2x00_host_attrs[]; struct fc_function_template; extern struct fc_function_template qla2xxx_transport_functions; extern struct fc_function_template qla2xxx_transport_vport_functions; diff --git a/drivers/scsi/raid_class.c b/drivers/scsi/raid_class.c index 52182a744ba6..913a931176ef 100644 --- a/drivers/scsi/raid_class.c +++ b/drivers/scsi/raid_class.c @@ -24,15 +24,15 @@ struct raid_internal { struct raid_template r; struct raid_function_template *f; /* The actual attributes */ - struct class_device_attribute private_attrs[RAID_NUM_ATTRS]; + struct device_attribute private_attrs[RAID_NUM_ATTRS]; /* The array of null terminated pointers to attributes * needed by scsi_sysfs.c */ - struct class_device_attribute *attrs[RAID_NUM_ATTRS + 1]; + struct device_attribute *attrs[RAID_NUM_ATTRS + 1]; }; struct raid_component { struct list_head node; - struct class_device cdev; + struct device dev; int num; }; @@ -50,9 +50,9 @@ struct raid_component { tc_to_raid_internal(tc); \ }) -#define class_device_to_raid_internal(cdev) ({ \ +#define device_to_raid_internal(dev) ({ \ struct attribute_container *ac = \ - attribute_container_classdev_to_container(cdev); \ + attribute_container_classdev_to_container(dev); \ ac_to_raid_internal(ac); \ }) @@ -76,33 +76,33 @@ static int raid_match(struct attribute_container *cont, struct device *dev) } static int raid_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct raid_data *rd; - BUG_ON(class_get_devdata(cdev)); + BUG_ON(dev_get_drvdata(cdev)); rd = kzalloc(sizeof(*rd), GFP_KERNEL); if (!rd) return -ENOMEM; INIT_LIST_HEAD(&rd->component_list); - class_set_devdata(cdev, rd); + dev_set_drvdata(cdev, rd); return 0; } static int raid_remove(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { - struct raid_data *rd = class_get_devdata(cdev); + struct raid_data *rd = dev_get_drvdata(cdev); struct raid_component *rc, *next; dev_printk(KERN_ERR, dev, "RAID REMOVE\n"); - class_set_devdata(cdev, NULL); + dev_set_drvdata(cdev, NULL); list_for_each_entry_safe(rc, next, &rd->component_list, node) { list_del(&rc->node); - dev_printk(KERN_ERR, rc->cdev.dev, "RAID COMPONENT REMOVE\n"); - class_device_unregister(&rc->cdev); + dev_printk(KERN_ERR, rc->dev.parent, "RAID COMPONENT REMOVE\n"); + device_unregister(&rc->dev); } dev_printk(KERN_ERR, dev, "RAID REMOVE DONE\n"); kfree(rd); @@ -171,9 +171,11 @@ static const char *raid_level_name(enum raid_level level) } #define raid_attr_show_internal(attr, fmt, var, code) \ -static ssize_t raid_show_##attr(struct class_device *cdev, char *buf) \ +static ssize_t raid_show_##attr(struct device *dev, \ + struct device_attribute *attr, \ + char *buf) \ { \ - struct raid_data *rd = class_get_devdata(cdev); \ + struct raid_data *rd = dev_get_drvdata(dev); \ code \ return snprintf(buf, 20, #fmt "\n", var); \ } @@ -184,17 +186,17 @@ raid_attr_show_internal(attr, %s, name, \ code \ name = raid_##states##_name(rd->attr); \ ) \ -static CLASS_DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL) +static DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL) #define raid_attr_ro_internal(attr, code) \ raid_attr_show_internal(attr, %d, rd->attr, code) \ -static CLASS_DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL) +static DEVICE_ATTR(attr, S_IRUGO, raid_show_##attr, NULL) #define ATTR_CODE(attr) \ - struct raid_internal *i = class_device_to_raid_internal(cdev); \ + struct raid_internal *i = device_to_raid_internal(dev); \ if (i->f->get_##attr) \ - i->f->get_##attr(cdev->dev); + i->f->get_##attr(dev->parent); #define raid_attr_ro(attr) raid_attr_ro_internal(attr, ) #define raid_attr_ro_fn(attr) raid_attr_ro_internal(attr, ATTR_CODE(attr)) @@ -206,23 +208,23 @@ raid_attr_ro_state(level); raid_attr_ro_fn(resync); raid_attr_ro_state_fn(state); -static void raid_component_release(struct class_device *cdev) +static void raid_component_release(struct device *dev) { - struct raid_component *rc = container_of(cdev, struct raid_component, - cdev); - dev_printk(KERN_ERR, rc->cdev.dev, "COMPONENT RELEASE\n"); - put_device(rc->cdev.dev); + struct raid_component *rc = + container_of(dev, struct raid_component, dev); + dev_printk(KERN_ERR, rc->dev.parent, "COMPONENT RELEASE\n"); + put_device(rc->dev.parent); kfree(rc); } int raid_component_add(struct raid_template *r,struct device *raid_dev, struct device *component_dev) { - struct class_device *cdev = + struct device *cdev = attribute_container_find_class_device(&r->raid_attrs.ac, raid_dev); struct raid_component *rc; - struct raid_data *rd = class_get_devdata(cdev); + struct raid_data *rd = dev_get_drvdata(cdev); int err; rc = kzalloc(sizeof(*rc), GFP_KERNEL); @@ -230,17 +232,16 @@ int raid_component_add(struct raid_template *r,struct device *raid_dev, return -ENOMEM; INIT_LIST_HEAD(&rc->node); - class_device_initialize(&rc->cdev); - rc->cdev.release = raid_component_release; - rc->cdev.dev = get_device(component_dev); + device_initialize(&rc->dev); + rc->dev.release = raid_component_release; + rc->dev.parent = get_device(component_dev); rc->num = rd->component_count++; - snprintf(rc->cdev.class_id, sizeof(rc->cdev.class_id), + snprintf(rc->dev.bus_id, sizeof(rc->dev.bus_id), "component-%d", rc->num); list_add_tail(&rc->node, &rd->component_list); - rc->cdev.parent = cdev; - rc->cdev.class = &raid_class.class; - err = class_device_add(&rc->cdev); + rc->dev.class = &raid_class.class; + err = device_add(&rc->dev); if (err) goto err_out; @@ -273,9 +274,9 @@ raid_class_attach(struct raid_function_template *ft) attribute_container_register(&i->r.raid_attrs.ac); - i->attrs[count++] = &class_device_attr_level; - i->attrs[count++] = &class_device_attr_resync; - i->attrs[count++] = &class_device_attr_state; + i->attrs[count++] = &dev_attr_level; + i->attrs[count++] = &dev_attr_resync; + i->attrs[count++] = &dev_attr_state; i->attrs[count] = NULL; BUG_ON(count > RAID_NUM_ATTRS); diff --git a/drivers/scsi/scsi_sas_internal.h b/drivers/scsi/scsi_sas_internal.h index e1edab45a37b..998cb5be6833 100644 --- a/drivers/scsi/scsi_sas_internal.h +++ b/drivers/scsi/scsi_sas_internal.h @@ -13,12 +13,12 @@ struct sas_internal { struct sas_function_template *f; struct sas_domain_function_template *dft; - struct class_device_attribute private_host_attrs[SAS_HOST_ATTRS]; - struct class_device_attribute private_phy_attrs[SAS_PHY_ATTRS]; - struct class_device_attribute private_port_attrs[SAS_PORT_ATTRS]; - struct class_device_attribute private_rphy_attrs[SAS_RPORT_ATTRS]; - struct class_device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS]; - struct class_device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS]; + struct device_attribute private_host_attrs[SAS_HOST_ATTRS]; + struct device_attribute private_phy_attrs[SAS_PHY_ATTRS]; + struct device_attribute private_port_attrs[SAS_PORT_ATTRS]; + struct device_attribute private_rphy_attrs[SAS_RPORT_ATTRS]; + struct device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS]; + struct device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS]; struct transport_container phy_attr_cont; struct transport_container port_attr_cont; @@ -30,12 +30,12 @@ struct sas_internal { * The array of null terminated pointers to attributes * needed by scsi_sysfs.c */ - struct class_device_attribute *host_attrs[SAS_HOST_ATTRS + 1]; - struct class_device_attribute *phy_attrs[SAS_PHY_ATTRS + 1]; - struct class_device_attribute *port_attrs[SAS_PORT_ATTRS + 1]; - struct class_device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1]; - struct class_device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1]; - struct class_device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1]; + struct device_attribute *host_attrs[SAS_HOST_ATTRS + 1]; + struct device_attribute *phy_attrs[SAS_PHY_ATTRS + 1]; + struct device_attribute *port_attrs[SAS_PORT_ATTRS + 1]; + struct device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1]; + struct device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1]; + struct device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1]; }; #define to_sas_internal(tmpl) container_of(tmpl, struct sas_internal, t) diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c index ed83cdb6e67d..67bb20ed45d2 100644 --- a/drivers/scsi/scsi_sysfs.c +++ b/drivers/scsi/scsi_sysfs.c @@ -119,9 +119,10 @@ static int scsi_scan(struct Scsi_Host *shost, const char *str) */ #define shost_show_function(name, field, format_string) \ static ssize_t \ -show_##name (struct class_device *class_dev, char *buf) \ +show_##name (struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ - struct Scsi_Host *shost = class_to_shost(class_dev); \ + struct Scsi_Host *shost = class_to_shost(dev); \ return snprintf (buf, 20, format_string, shost->field); \ } @@ -131,7 +132,7 @@ show_##name (struct class_device *class_dev, char *buf) \ */ #define shost_rd_attr2(name, field, format_string) \ shost_show_function(name, field, format_string) \ -static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL); +static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL); #define shost_rd_attr(field, format_string) \ shost_rd_attr2(field, field, format_string) @@ -140,10 +141,11 @@ shost_rd_attr2(field, field, format_string) * Create the actual show/store functions and data structures. */ -static ssize_t store_scan(struct class_device *class_dev, const char *buf, - size_t count) +static ssize_t +store_scan(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); int res; res = scsi_scan(shost, buf); @@ -151,13 +153,14 @@ static ssize_t store_scan(struct class_device *class_dev, const char *buf, res = count; return res; }; -static CLASS_DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan); +static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan); static ssize_t -store_shost_state(struct class_device *class_dev, const char *buf, size_t count) +store_shost_state(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int i; - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); enum scsi_host_state state = 0; for (i = 0; i < ARRAY_SIZE(shost_states); i++) { @@ -177,9 +180,9 @@ store_shost_state(struct class_device *class_dev, const char *buf, size_t count) } static ssize_t -show_shost_state(struct class_device *class_dev, char *buf) +show_shost_state(struct device *dev, struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); const char *name = scsi_host_state_name(shost->shost_state); if (!name) @@ -188,7 +191,9 @@ show_shost_state(struct class_device *class_dev, char *buf) return snprintf(buf, 20, "%s\n", name); } -static CLASS_DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state); +/* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */ +struct device_attribute dev_attr_hstate = + __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state); static ssize_t show_shost_mode(unsigned int mode, char *buf) @@ -206,9 +211,11 @@ show_shost_mode(unsigned int mode, char *buf) return len; } -static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *buf) +static ssize_t +show_shost_supported_mode(struct device *dev, struct device_attribute *attr, + char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); unsigned int supported_mode = shost->hostt->supported_mode; if (supported_mode == MODE_UNKNOWN) @@ -218,11 +225,13 @@ static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *b return show_shost_mode(supported_mode, buf); } -static CLASS_DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL); +static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL); -static ssize_t show_shost_active_mode(struct class_device *class_dev, char *buf) +static ssize_t +show_shost_active_mode(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = class_to_shost(class_dev); + struct Scsi_Host *shost = class_to_shost(dev); if (shost->active_mode == MODE_UNKNOWN) return snprintf(buf, 20, "unknown\n"); @@ -230,7 +239,7 @@ static ssize_t show_shost_active_mode(struct class_device *class_dev, char *buf) return show_shost_mode(shost->active_mode, buf); } -static CLASS_DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL); +static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL); shost_rd_attr(unique_id, "%u\n"); shost_rd_attr(host_busy, "%hu\n"); @@ -240,22 +249,22 @@ shost_rd_attr(sg_tablesize, "%hu\n"); shost_rd_attr(unchecked_isa_dma, "%d\n"); shost_rd_attr2(proc_name, hostt->proc_name, "%s\n"); -static struct class_device_attribute *scsi_sysfs_shost_attrs[] = { - &class_device_attr_unique_id, - &class_device_attr_host_busy, - &class_device_attr_cmd_per_lun, - &class_device_attr_can_queue, - &class_device_attr_sg_tablesize, - &class_device_attr_unchecked_isa_dma, - &class_device_attr_proc_name, - &class_device_attr_scan, - &class_device_attr_state, - &class_device_attr_supported_mode, - &class_device_attr_active_mode, +static struct device_attribute *scsi_sysfs_shost_attrs[] = { + &dev_attr_unique_id, + &dev_attr_host_busy, + &dev_attr_cmd_per_lun, + &dev_attr_can_queue, + &dev_attr_sg_tablesize, + &dev_attr_unchecked_isa_dma, + &dev_attr_proc_name, + &dev_attr_scan, + &dev_attr_hstate, + &dev_attr_supported_mode, + &dev_attr_active_mode, NULL }; -static void scsi_device_cls_release(struct class_device *class_dev) +static void scsi_device_cls_release(struct device *class_dev) { struct scsi_device *sdev; @@ -320,7 +329,7 @@ static void scsi_device_dev_release(struct device *dev) static struct class sdev_class = { .name = "scsi_device", - .release = scsi_device_cls_release, + .dev_release = scsi_device_cls_release, }; /* all probing is done in the individual ->probe routines */ @@ -424,7 +433,8 @@ void scsi_sysfs_unregister(void) */ #define sdev_show_function(field, format_string) \ static ssize_t \ -sdev_show_##field (struct device *dev, struct device_attribute *attr, char *buf) \ +sdev_show_##field (struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ struct scsi_device *sdev; \ sdev = to_scsi_device(dev); \ @@ -448,7 +458,8 @@ static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL); sdev_show_function(field, format_string) \ \ static ssize_t \ -sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +sdev_store_##field (struct device *dev, struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ struct scsi_device *sdev; \ sdev = to_scsi_device(dev); \ @@ -468,7 +479,8 @@ static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##fie sdev_show_function(field, "%d\n") \ \ static ssize_t \ -sdev_store_##field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ +sdev_store_##field (struct device *dev, struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int ret; \ struct scsi_device *sdev; \ @@ -519,7 +531,8 @@ sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf) } static ssize_t -sdev_store_timeout (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) +sdev_store_timeout (struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { struct scsi_device *sdev; int timeout; @@ -531,7 +544,8 @@ sdev_store_timeout (struct device *dev, struct device_attribute *attr, const cha static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout); static ssize_t -store_rescan_field (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) +store_rescan_field (struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { scsi_rescan_device(dev); return count; @@ -543,8 +557,9 @@ static void sdev_store_delete_callback(struct device *dev) scsi_remove_device(to_scsi_device(dev)); } -static ssize_t sdev_store_delete(struct device *dev, struct device_attribute *attr, const char *buf, - size_t count) +static ssize_t +sdev_store_delete(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int rc; @@ -559,7 +574,8 @@ static ssize_t sdev_store_delete(struct device *dev, struct device_attribute *at static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete); static ssize_t -store_state_field(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) +store_state_field(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int i; struct scsi_device *sdev = to_scsi_device(dev); @@ -596,7 +612,8 @@ show_state_field(struct device *dev, struct device_attribute *attr, char *buf) static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field); static ssize_t -show_queue_type_field(struct device *dev, struct device_attribute *attr, char *buf) +show_queue_type_field(struct device *dev, struct device_attribute *attr, + char *buf) { struct scsi_device *sdev = to_scsi_device(dev); const char *name = "none"; @@ -612,7 +629,7 @@ show_queue_type_field(struct device *dev, struct device_attribute *attr, char *b static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL); static ssize_t -show_iostat_counterbits(struct device *dev, struct device_attribute *attr, char *buf) +show_iostat_counterbits(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8); } @@ -621,7 +638,8 @@ static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL); #define show_sdev_iostat(field) \ static ssize_t \ -show_iostat_##field(struct device *dev, struct device_attribute *attr, char *buf) \ +show_iostat_##field(struct device *dev, struct device_attribute *attr, \ + char *buf) \ { \ struct scsi_device *sdev = to_scsi_device(dev); \ unsigned long long count = atomic_read(&sdev->field); \ @@ -645,7 +663,7 @@ static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL); #define DECLARE_EVT_SHOW(name, Cap_name) \ static ssize_t \ sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \ - char *buf) \ + char *buf) \ { \ struct scsi_device *sdev = to_scsi_device(dev); \ int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\ @@ -654,7 +672,7 @@ sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \ #define DECLARE_EVT_STORE(name, Cap_name) \ static ssize_t \ -sdev_store_evt_##name(struct device *dev, struct device_attribute *attr, \ +sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\ const char *buf, size_t count) \ { \ struct scsi_device *sdev = to_scsi_device(dev); \ @@ -707,8 +725,9 @@ static struct attribute_group *scsi_sdev_attr_groups[] = { NULL }; -static ssize_t sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr, const char *buf, - size_t count) +static ssize_t +sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int depth, retval; struct scsi_device *sdev = to_scsi_device(dev); @@ -733,8 +752,9 @@ static struct device_attribute sdev_attr_queue_depth_rw = __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth, sdev_store_queue_depth_rw); -static ssize_t sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr, const char *buf, - size_t count) +static ssize_t +sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { struct scsi_device *sdev = to_scsi_device(dev); struct scsi_host_template *sht = sdev->host->hostt; @@ -786,13 +806,13 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev) printk(KERN_INFO "error 1\n"); return error; } - error = class_device_add(&sdev->sdev_classdev); + error = device_add(&sdev->sdev_dev); if (error) { printk(KERN_INFO "error 2\n"); goto clean_device; } - /* take a reference for the sdev_classdev; this is + /* take a reference for the sdev_dev; this is * released by the sdev_class .release */ get_device(&sdev->sdev_gendev); @@ -858,7 +878,7 @@ void __scsi_remove_device(struct scsi_device *sdev) return; bsg_unregister_queue(sdev->request_queue); - class_device_unregister(&sdev->sdev_classdev); + device_unregister(&sdev->sdev_dev); transport_remove_device(dev); device_del(dev); scsi_device_set_state(sdev, SDEV_DEL); @@ -952,9 +972,9 @@ int scsi_register_interface(struct class_interface *intf) EXPORT_SYMBOL(scsi_register_interface); -static struct class_device_attribute *class_attr_overridden( - struct class_device_attribute **attrs, - struct class_device_attribute *attr) +static struct device_attribute *class_attr_overridden( + struct device_attribute **attrs, + struct device_attribute *attr) { int i; @@ -966,10 +986,10 @@ static struct class_device_attribute *class_attr_overridden( return NULL; } -static int class_attr_add(struct class_device *classdev, - struct class_device_attribute *attr) +static int class_attr_add(struct device *classdev, + struct device_attribute *attr) { - struct class_device_attribute *base_attr; + struct device_attribute *base_attr; /* * Spare the caller from having to copy things it's not interested in. @@ -986,7 +1006,7 @@ static int class_attr_add(struct class_device *classdev, attr->store = base_attr->store; } - return class_device_create_file(classdev, attr); + return device_create_file(classdev, attr); } /** @@ -1000,7 +1020,7 @@ int scsi_sysfs_add_host(struct Scsi_Host *shost) if (shost->hostt->shost_attrs) { for (i = 0; shost->hostt->shost_attrs[i]; i++) { - error = class_attr_add(&shost->shost_classdev, + error = class_attr_add(&shost->shost_dev, shost->hostt->shost_attrs[i]); if (error) return error; @@ -1010,7 +1030,7 @@ int scsi_sysfs_add_host(struct Scsi_Host *shost) for (i = 0; scsi_sysfs_shost_attrs[i]; i++) { if (!class_attr_overridden(shost->hostt->shost_attrs, scsi_sysfs_shost_attrs[i])) { - error = class_device_create_file(&shost->shost_classdev, + error = device_create_file(&shost->shost_dev, scsi_sysfs_shost_attrs[i]); if (error) return error; @@ -1041,10 +1061,10 @@ void scsi_sysfs_device_initialize(struct scsi_device *sdev) sdev->host->host_no, sdev->channel, sdev->id, sdev->lun); - class_device_initialize(&sdev->sdev_classdev); - sdev->sdev_classdev.dev = &sdev->sdev_gendev; - sdev->sdev_classdev.class = &sdev_class; - snprintf(sdev->sdev_classdev.class_id, BUS_ID_SIZE, + device_initialize(&sdev->sdev_dev); + sdev->sdev_dev.parent = &sdev->sdev_gendev; + sdev->sdev_dev.class = &sdev_class; + snprintf(sdev->sdev_dev.bus_id, BUS_ID_SIZE, "%d:%d:%d:%d", sdev->host->host_no, sdev->channel, sdev->id, sdev->lun); sdev->scsi_level = starget->scsi_level; diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c index b1119da6e88c..6b092a6c295d 100644 --- a/drivers/scsi/scsi_transport_fc.c +++ b/drivers/scsi/scsi_transport_fc.c @@ -72,8 +72,8 @@ static int fc_vport_create(struct Scsi_Host *shost, int channel, * Redefine so that we can have same named attributes in the * sdev/starget/host objects. */ -#define FC_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ -struct class_device_attribute class_device_attr_##_prefix##_##_name = \ +#define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ +struct device_attribute device_attr_##_prefix##_##_name = \ __ATTR(_name,_mode,_show,_store) #define fc_enum_name_search(title, table_type, table) \ @@ -326,26 +326,26 @@ struct fc_internal { * part of the midlayer. As the remote port is specific to the * fc transport, we must provide the attribute container. */ - struct class_device_attribute private_starget_attrs[ + struct device_attribute private_starget_attrs[ FC_STARGET_NUM_ATTRS]; - struct class_device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1]; + struct device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1]; - struct class_device_attribute private_host_attrs[FC_HOST_NUM_ATTRS]; - struct class_device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1]; + struct device_attribute private_host_attrs[FC_HOST_NUM_ATTRS]; + struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1]; struct transport_container rport_attr_cont; - struct class_device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS]; - struct class_device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1]; + struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS]; + struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1]; struct transport_container vport_attr_cont; - struct class_device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS]; - struct class_device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1]; + struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS]; + struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1]; }; #define to_fc_internal(tmpl) container_of(tmpl, struct fc_internal, t) static int fc_target_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct scsi_target *starget = to_scsi_target(dev); struct fc_rport *rport = starget_to_rport(starget); @@ -375,7 +375,7 @@ static DECLARE_TRANSPORT_CLASS(fc_transport_class, NULL); static int fc_host_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); struct fc_host_attrs *fc_host = shost_to_fc_host(shost); @@ -682,9 +682,10 @@ static void __exit fc_transport_exit(void) #define fc_rport_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_rport_##field (struct class_device *cdev, char *buf) \ +show_fc_rport_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct fc_rport *rport = transport_class_to_rport(cdev); \ + struct fc_rport *rport = transport_class_to_rport(dev); \ struct Scsi_Host *shost = rport_to_shost(rport); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ if ((i->f->get_rport_##field) && \ @@ -697,11 +698,12 @@ show_fc_rport_##field (struct class_device *cdev, char *buf) \ #define fc_rport_store_function(field) \ static ssize_t \ -store_fc_rport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_rport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct fc_rport *rport = transport_class_to_rport(cdev); \ + struct fc_rport *rport = transport_class_to_rport(dev); \ struct Scsi_Host *shost = rport_to_shost(rport); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ char *cp; \ @@ -718,58 +720,60 @@ store_fc_rport_##field(struct class_device *cdev, const char *buf, \ #define fc_rport_rd_attr(field, format_string, sz) \ fc_rport_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(rport, field, S_IRUGO, \ show_fc_rport_##field, NULL) #define fc_rport_rd_attr_cast(field, format_string, sz, cast) \ fc_rport_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(rport, field, S_IRUGO, \ show_fc_rport_##field, NULL) #define fc_rport_rw_attr(field, format_string, sz) \ fc_rport_show_function(field, format_string, sz, ) \ fc_rport_store_function(field) \ -static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR, \ +static FC_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR, \ show_fc_rport_##field, \ store_fc_rport_##field) #define fc_private_rport_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_rport_##field (struct class_device *cdev, char *buf) \ +show_fc_rport_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct fc_rport *rport = transport_class_to_rport(cdev); \ + struct fc_rport *rport = transport_class_to_rport(dev); \ return snprintf(buf, sz, format_string, cast rport->field); \ } #define fc_private_rport_rd_attr(field, format_string, sz) \ fc_private_rport_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(rport, field, S_IRUGO, \ show_fc_rport_##field, NULL) #define fc_private_rport_rd_attr_cast(field, format_string, sz, cast) \ fc_private_rport_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(rport, field, S_IRUGO, \ show_fc_rport_##field, NULL) #define fc_private_rport_rd_enum_attr(title, maxlen) \ static ssize_t \ -show_fc_rport_##title (struct class_device *cdev, char *buf) \ +show_fc_rport_##title (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct fc_rport *rport = transport_class_to_rport(cdev); \ + struct fc_rport *rport = transport_class_to_rport(dev); \ const char *name; \ name = get_fc_##title##_name(rport->title); \ if (!name) \ return -EINVAL; \ return snprintf(buf, maxlen, "%s\n", name); \ } \ -static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO, \ +static FC_DEVICE_ATTR(rport, title, S_IRUGO, \ show_fc_rport_##title, NULL) #define SETUP_RPORT_ATTRIBUTE_RD(field) \ - i->private_rport_attrs[count] = class_device_attr_rport_##field; \ + i->private_rport_attrs[count] = device_attr_rport_##field; \ i->private_rport_attrs[count].attr.mode = S_IRUGO; \ i->private_rport_attrs[count].store = NULL; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \ @@ -777,14 +781,14 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO, \ count++ #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field) \ - i->private_rport_attrs[count] = class_device_attr_rport_##field; \ + i->private_rport_attrs[count] = device_attr_rport_##field; \ i->private_rport_attrs[count].attr.mode = S_IRUGO; \ i->private_rport_attrs[count].store = NULL; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \ count++ #define SETUP_RPORT_ATTRIBUTE_RW(field) \ - i->private_rport_attrs[count] = class_device_attr_rport_##field; \ + i->private_rport_attrs[count] = device_attr_rport_##field; \ if (!i->f->set_rport_##field) { \ i->private_rport_attrs[count].attr.mode = S_IRUGO; \ i->private_rport_attrs[count].store = NULL; \ @@ -795,7 +799,7 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO, \ #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RW(field) \ { \ - i->private_rport_attrs[count] = class_device_attr_rport_##field; \ + i->private_rport_attrs[count] = device_attr_rport_##field; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \ count++; \ } @@ -808,14 +812,15 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO, \ fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20); static ssize_t -show_fc_rport_supported_classes (struct class_device *cdev, char *buf) +show_fc_rport_supported_classes (struct device *dev, + struct device_attribute *attr, char *buf) { - struct fc_rport *rport = transport_class_to_rport(cdev); + struct fc_rport *rport = transport_class_to_rport(dev); if (rport->supported_classes == FC_COS_UNSPECIFIED) return snprintf(buf, 20, "unspecified\n"); return get_fc_cos_names(rport->supported_classes, buf); } -static FC_CLASS_DEVICE_ATTR(rport, supported_classes, S_IRUGO, +static FC_DEVICE_ATTR(rport, supported_classes, S_IRUGO, show_fc_rport_supported_classes, NULL); /* Dynamic Remote Port Attributes */ @@ -825,11 +830,11 @@ static FC_CLASS_DEVICE_ATTR(rport, supported_classes, S_IRUGO, */ fc_rport_show_function(dev_loss_tmo, "%d\n", 20, ) static ssize_t -store_fc_rport_dev_loss_tmo(struct class_device *cdev, const char *buf, - size_t count) +store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int val; - struct fc_rport *rport = transport_class_to_rport(cdev); + struct fc_rport *rport = transport_class_to_rport(dev); struct Scsi_Host *shost = rport_to_shost(rport); struct fc_internal *i = to_fc_internal(shost->transportt); char *cp; @@ -844,7 +849,7 @@ store_fc_rport_dev_loss_tmo(struct class_device *cdev, const char *buf, i->f->set_rport_dev_loss_tmo(rport, val); return count; } -static FC_CLASS_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR, +static FC_DEVICE_ATTR(rport, dev_loss_tmo, S_IRUGO | S_IWUSR, show_fc_rport_dev_loss_tmo, store_fc_rport_dev_loss_tmo); @@ -855,9 +860,10 @@ fc_private_rport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long); fc_private_rport_rd_attr(port_id, "0x%06x\n", 20); static ssize_t -show_fc_rport_roles (struct class_device *cdev, char *buf) +show_fc_rport_roles (struct device *dev, struct device_attribute *attr, + char *buf) { - struct fc_rport *rport = transport_class_to_rport(cdev); + struct fc_rport *rport = transport_class_to_rport(dev); /* identify any roles that are port_id specific */ if ((rport->port_id != -1) && @@ -883,7 +889,7 @@ show_fc_rport_roles (struct class_device *cdev, char *buf) return get_fc_port_roles_names(rport->roles, buf); } } -static FC_CLASS_DEVICE_ATTR(rport, roles, S_IRUGO, +static FC_DEVICE_ATTR(rport, roles, S_IRUGO, show_fc_rport_roles, NULL); fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN); @@ -893,9 +899,10 @@ fc_private_rport_rd_attr(scsi_target_id, "%d\n", 20); * fast_io_fail_tmo attribute */ static ssize_t -show_fc_rport_fast_io_fail_tmo (struct class_device *cdev, char *buf) +show_fc_rport_fast_io_fail_tmo (struct device *dev, + struct device_attribute *attr, char *buf) { - struct fc_rport *rport = transport_class_to_rport(cdev); + struct fc_rport *rport = transport_class_to_rport(dev); if (rport->fast_io_fail_tmo == -1) return snprintf(buf, 5, "off\n"); @@ -903,12 +910,13 @@ show_fc_rport_fast_io_fail_tmo (struct class_device *cdev, char *buf) } static ssize_t -store_fc_rport_fast_io_fail_tmo(struct class_device *cdev, const char *buf, - size_t count) +store_fc_rport_fast_io_fail_tmo(struct device *dev, + struct device_attribute *attr, const char *buf, + size_t count) { int val; char *cp; - struct fc_rport *rport = transport_class_to_rport(cdev); + struct fc_rport *rport = transport_class_to_rport(dev); if ((rport->port_state == FC_PORTSTATE_BLOCKED) || (rport->port_state == FC_PORTSTATE_DELETED) || @@ -925,7 +933,7 @@ store_fc_rport_fast_io_fail_tmo(struct class_device *cdev, const char *buf, } return count; } -static FC_CLASS_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR, +static FC_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR, show_fc_rport_fast_io_fail_tmo, store_fc_rport_fast_io_fail_tmo); @@ -941,9 +949,10 @@ static FC_CLASS_DEVICE_ATTR(rport, fast_io_fail_tmo, S_IRUGO | S_IWUSR, */ #define fc_starget_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_starget_##field (struct class_device *cdev, char *buf) \ +show_fc_starget_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_rport *rport = starget_to_rport(starget); \ @@ -957,16 +966,16 @@ show_fc_starget_##field (struct class_device *cdev, char *buf) \ #define fc_starget_rd_attr(field, format_string, sz) \ fc_starget_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO, \ +static FC_DEVICE_ATTR(starget, field, S_IRUGO, \ show_fc_starget_##field, NULL) #define fc_starget_rd_attr_cast(field, format_string, sz, cast) \ fc_starget_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO, \ +static FC_DEVICE_ATTR(starget, field, S_IRUGO, \ show_fc_starget_##field, NULL) #define SETUP_STARGET_ATTRIBUTE_RD(field) \ - i->private_starget_attrs[count] = class_device_attr_starget_##field; \ + i->private_starget_attrs[count] = device_attr_starget_##field; \ i->private_starget_attrs[count].attr.mode = S_IRUGO; \ i->private_starget_attrs[count].store = NULL; \ i->starget_attrs[count] = &i->private_starget_attrs[count]; \ @@ -974,7 +983,7 @@ static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO, \ count++ #define SETUP_STARGET_ATTRIBUTE_RW(field) \ - i->private_starget_attrs[count] = class_device_attr_starget_##field; \ + i->private_starget_attrs[count] = device_attr_starget_##field; \ if (!i->f->set_starget_##field) { \ i->private_starget_attrs[count].attr.mode = S_IRUGO; \ i->private_starget_attrs[count].store = NULL; \ @@ -995,9 +1004,10 @@ fc_starget_rd_attr(port_id, "0x%06x\n", 20); #define fc_vport_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_vport_##field (struct class_device *cdev, char *buf) \ +show_fc_vport_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ struct Scsi_Host *shost = vport_to_shost(vport); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ if ((i->f->get_vport_##field) && \ @@ -1008,11 +1018,12 @@ show_fc_vport_##field (struct class_device *cdev, char *buf) \ #define fc_vport_store_function(field) \ static ssize_t \ -store_fc_vport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_vport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ struct Scsi_Host *shost = vport_to_shost(vport); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ char *cp; \ @@ -1027,10 +1038,11 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf, \ #define fc_vport_store_str_function(field, slen) \ static ssize_t \ -store_fc_vport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_vport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ struct Scsi_Host *shost = vport_to_shost(vport); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ unsigned int cnt=count; \ @@ -1047,36 +1059,38 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf, \ #define fc_vport_rd_attr(field, format_string, sz) \ fc_vport_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO, \ show_fc_vport_##field, NULL) #define fc_vport_rd_attr_cast(field, format_string, sz, cast) \ fc_vport_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO, \ show_fc_vport_##field, NULL) #define fc_vport_rw_attr(field, format_string, sz) \ fc_vport_show_function(field, format_string, sz, ) \ fc_vport_store_function(field) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \ show_fc_vport_##field, \ store_fc_vport_##field) #define fc_private_vport_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_vport_##field (struct class_device *cdev, char *buf) \ +show_fc_vport_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ return snprintf(buf, sz, format_string, cast vport->field); \ } #define fc_private_vport_store_u32_function(field) \ static ssize_t \ -store_fc_vport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_vport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ u32 val; \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ char *cp; \ if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) \ return -EBUSY; \ @@ -1090,39 +1104,41 @@ store_fc_vport_##field(struct class_device *cdev, const char *buf, \ #define fc_private_vport_rd_attr(field, format_string, sz) \ fc_private_vport_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO, \ show_fc_vport_##field, NULL) #define fc_private_vport_rd_attr_cast(field, format_string, sz, cast) \ fc_private_vport_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO, \ show_fc_vport_##field, NULL) #define fc_private_vport_rw_u32_attr(field, format_string, sz) \ fc_private_vport_show_function(field, format_string, sz, ) \ fc_private_vport_store_u32_function(field) \ -static FC_CLASS_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \ +static FC_DEVICE_ATTR(vport, field, S_IRUGO | S_IWUSR, \ show_fc_vport_##field, \ store_fc_vport_##field) #define fc_private_vport_rd_enum_attr(title, maxlen) \ static ssize_t \ -show_fc_vport_##title (struct class_device *cdev, char *buf) \ +show_fc_vport_##title (struct device *dev, \ + struct device_attribute *attr, \ + char *buf) \ { \ - struct fc_vport *vport = transport_class_to_vport(cdev); \ + struct fc_vport *vport = transport_class_to_vport(dev); \ const char *name; \ name = get_fc_##title##_name(vport->title); \ if (!name) \ return -EINVAL; \ return snprintf(buf, maxlen, "%s\n", name); \ } \ -static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO, \ +static FC_DEVICE_ATTR(vport, title, S_IRUGO, \ show_fc_vport_##title, NULL) #define SETUP_VPORT_ATTRIBUTE_RD(field) \ - i->private_vport_attrs[count] = class_device_attr_vport_##field; \ + i->private_vport_attrs[count] = device_attr_vport_##field; \ i->private_vport_attrs[count].attr.mode = S_IRUGO; \ i->private_vport_attrs[count].store = NULL; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \ @@ -1131,21 +1147,21 @@ static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO, \ /* NOTE: Above MACRO differs: checks function not show bit */ #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(field) \ - i->private_vport_attrs[count] = class_device_attr_vport_##field; \ + i->private_vport_attrs[count] = device_attr_vport_##field; \ i->private_vport_attrs[count].attr.mode = S_IRUGO; \ i->private_vport_attrs[count].store = NULL; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \ count++ #define SETUP_VPORT_ATTRIBUTE_WR(field) \ - i->private_vport_attrs[count] = class_device_attr_vport_##field; \ + i->private_vport_attrs[count] = device_attr_vport_##field; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \ if (i->f->field) \ count++ /* NOTE: Above MACRO differs: checks function */ #define SETUP_VPORT_ATTRIBUTE_RW(field) \ - i->private_vport_attrs[count] = class_device_attr_vport_##field; \ + i->private_vport_attrs[count] = device_attr_vport_##field; \ if (!i->f->set_vport_##field) { \ i->private_vport_attrs[count].attr.mode = S_IRUGO; \ i->private_vport_attrs[count].store = NULL; \ @@ -1156,7 +1172,7 @@ static FC_CLASS_DEVICE_ATTR(vport, title, S_IRUGO, \ #define SETUP_PRIVATE_VPORT_ATTRIBUTE_RW(field) \ { \ - i->private_vport_attrs[count] = class_device_attr_vport_##field; \ + i->private_vport_attrs[count] = device_attr_vport_##field; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \ count++; \ } @@ -1176,35 +1192,36 @@ fc_private_vport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long); fc_private_vport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long); static ssize_t -show_fc_vport_roles (struct class_device *cdev, char *buf) +show_fc_vport_roles (struct device *dev, struct device_attribute *attr, + char *buf) { - struct fc_vport *vport = transport_class_to_vport(cdev); + struct fc_vport *vport = transport_class_to_vport(dev); if (vport->roles == FC_PORT_ROLE_UNKNOWN) return snprintf(buf, 20, "unknown\n"); return get_fc_port_roles_names(vport->roles, buf); } -static FC_CLASS_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL); +static FC_DEVICE_ATTR(vport, roles, S_IRUGO, show_fc_vport_roles, NULL); fc_private_vport_rd_enum_attr(vport_type, FC_PORTTYPE_MAX_NAMELEN); fc_private_vport_show_function(symbolic_name, "%s\n", FC_VPORT_SYMBOLIC_NAMELEN + 1, ) fc_vport_store_str_function(symbolic_name, FC_VPORT_SYMBOLIC_NAMELEN) -static FC_CLASS_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR, +static FC_DEVICE_ATTR(vport, symbolic_name, S_IRUGO | S_IWUSR, show_fc_vport_symbolic_name, store_fc_vport_symbolic_name); static ssize_t -store_fc_vport_delete(struct class_device *cdev, const char *buf, - size_t count) +store_fc_vport_delete(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct fc_vport *vport = transport_class_to_vport(cdev); + struct fc_vport *vport = transport_class_to_vport(dev); struct Scsi_Host *shost = vport_to_shost(vport); fc_queue_work(shost, &vport->vport_delete_work); return count; } -static FC_CLASS_DEVICE_ATTR(vport, vport_delete, S_IWUSR, +static FC_DEVICE_ATTR(vport, vport_delete, S_IWUSR, NULL, store_fc_vport_delete); @@ -1213,10 +1230,11 @@ static FC_CLASS_DEVICE_ATTR(vport, vport_delete, S_IWUSR, * Write "1" to disable, write "0" to enable */ static ssize_t -store_fc_vport_disable(struct class_device *cdev, const char *buf, +store_fc_vport_disable(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct fc_vport *vport = transport_class_to_vport(cdev); + struct fc_vport *vport = transport_class_to_vport(dev); struct Scsi_Host *shost = vport_to_shost(vport); struct fc_internal *i = to_fc_internal(shost->transportt); int stat; @@ -1236,7 +1254,7 @@ store_fc_vport_disable(struct class_device *cdev, const char *buf, stat = i->f->vport_disable(vport, ((*buf == '0') ? false : true)); return stat ? stat : count; } -static FC_CLASS_DEVICE_ATTR(vport, vport_disable, S_IWUSR, +static FC_DEVICE_ATTR(vport, vport_disable, S_IWUSR, NULL, store_fc_vport_disable); @@ -1246,9 +1264,10 @@ static FC_CLASS_DEVICE_ATTR(vport, vport_disable, S_IWUSR, #define fc_host_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_host_##field (struct class_device *cdev, char *buf) \ +show_fc_host_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ if (i->f->get_host_##field) \ i->f->get_host_##field(shost); \ @@ -1257,11 +1276,12 @@ show_fc_host_##field (struct class_device *cdev, char *buf) \ #define fc_host_store_function(field) \ static ssize_t \ -store_fc_host_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_host_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ char *cp; \ \ @@ -1274,10 +1294,11 @@ store_fc_host_##field(struct class_device *cdev, const char *buf, \ #define fc_host_store_str_function(field, slen) \ static ssize_t \ -store_fc_host_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_fc_host_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ unsigned int cnt=count; \ \ @@ -1293,26 +1314,27 @@ store_fc_host_##field(struct class_device *cdev, const char *buf, \ #define fc_host_rd_attr(field, format_string, sz) \ fc_host_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ +static FC_DEVICE_ATTR(host, field, S_IRUGO, \ show_fc_host_##field, NULL) #define fc_host_rd_attr_cast(field, format_string, sz, cast) \ fc_host_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ +static FC_DEVICE_ATTR(host, field, S_IRUGO, \ show_fc_host_##field, NULL) #define fc_host_rw_attr(field, format_string, sz) \ fc_host_show_function(field, format_string, sz, ) \ fc_host_store_function(field) \ -static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR, \ +static FC_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR, \ show_fc_host_##field, \ store_fc_host_##field) #define fc_host_rd_enum_attr(title, maxlen) \ static ssize_t \ -show_fc_host_##title (struct class_device *cdev, char *buf) \ +show_fc_host_##title (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ struct fc_internal *i = to_fc_internal(shost->transportt); \ const char *name; \ if (i->f->get_host_##title) \ @@ -1322,10 +1344,10 @@ show_fc_host_##title (struct class_device *cdev, char *buf) \ return -EINVAL; \ return snprintf(buf, maxlen, "%s\n", name); \ } \ -static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL) +static FC_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL) #define SETUP_HOST_ATTRIBUTE_RD(field) \ - i->private_host_attrs[count] = class_device_attr_host_##field; \ + i->private_host_attrs[count] = device_attr_host_##field; \ i->private_host_attrs[count].attr.mode = S_IRUGO; \ i->private_host_attrs[count].store = NULL; \ i->host_attrs[count] = &i->private_host_attrs[count]; \ @@ -1333,14 +1355,14 @@ static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL) count++ #define SETUP_HOST_ATTRIBUTE_RD_NS(field) \ - i->private_host_attrs[count] = class_device_attr_host_##field; \ + i->private_host_attrs[count] = device_attr_host_##field; \ i->private_host_attrs[count].attr.mode = S_IRUGO; \ i->private_host_attrs[count].store = NULL; \ i->host_attrs[count] = &i->private_host_attrs[count]; \ count++ #define SETUP_HOST_ATTRIBUTE_RW(field) \ - i->private_host_attrs[count] = class_device_attr_host_##field; \ + i->private_host_attrs[count] = device_attr_host_##field; \ if (!i->f->set_host_##field) { \ i->private_host_attrs[count].attr.mode = S_IRUGO; \ i->private_host_attrs[count].store = NULL; \ @@ -1352,24 +1374,25 @@ static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL) #define fc_private_host_show_function(field, format_string, sz, cast) \ static ssize_t \ -show_fc_host_##field (struct class_device *cdev, char *buf) \ +show_fc_host_##field (struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \ } #define fc_private_host_rd_attr(field, format_string, sz) \ fc_private_host_show_function(field, format_string, sz, ) \ -static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ +static FC_DEVICE_ATTR(host, field, S_IRUGO, \ show_fc_host_##field, NULL) #define fc_private_host_rd_attr_cast(field, format_string, sz, cast) \ fc_private_host_show_function(field, format_string, sz, (cast)) \ -static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ +static FC_DEVICE_ATTR(host, field, S_IRUGO, \ show_fc_host_##field, NULL) #define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field) \ - i->private_host_attrs[count] = class_device_attr_host_##field; \ + i->private_host_attrs[count] = device_attr_host_##field; \ i->private_host_attrs[count].attr.mode = S_IRUGO; \ i->private_host_attrs[count].store = NULL; \ i->host_attrs[count] = &i->private_host_attrs[count]; \ @@ -1377,7 +1400,7 @@ static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ #define SETUP_PRIVATE_HOST_ATTRIBUTE_RW(field) \ { \ - i->private_host_attrs[count] = class_device_attr_host_##field; \ + i->private_host_attrs[count] = device_attr_host_##field; \ i->host_attrs[count] = &i->private_host_attrs[count]; \ count++; \ } @@ -1386,38 +1409,41 @@ static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \ /* Fixed Host Attributes */ static ssize_t -show_fc_host_supported_classes (struct class_device *cdev, char *buf) +show_fc_host_supported_classes (struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED) return snprintf(buf, 20, "unspecified\n"); return get_fc_cos_names(fc_host_supported_classes(shost), buf); } -static FC_CLASS_DEVICE_ATTR(host, supported_classes, S_IRUGO, +static FC_DEVICE_ATTR(host, supported_classes, S_IRUGO, show_fc_host_supported_classes, NULL); static ssize_t -show_fc_host_supported_fc4s (struct class_device *cdev, char *buf) +show_fc_host_supported_fc4s (struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); return (ssize_t)show_fc_fc4s(buf, fc_host_supported_fc4s(shost)); } -static FC_CLASS_DEVICE_ATTR(host, supported_fc4s, S_IRUGO, +static FC_DEVICE_ATTR(host, supported_fc4s, S_IRUGO, show_fc_host_supported_fc4s, NULL); static ssize_t -show_fc_host_supported_speeds (struct class_device *cdev, char *buf) +show_fc_host_supported_speeds (struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN) return snprintf(buf, 20, "unknown\n"); return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf); } -static FC_CLASS_DEVICE_ATTR(host, supported_speeds, S_IRUGO, +static FC_DEVICE_ATTR(host, supported_speeds, S_IRUGO, show_fc_host_supported_speeds, NULL); @@ -1433,9 +1459,10 @@ fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1)); /* Dynamic Host Attributes */ static ssize_t -show_fc_host_active_fc4s (struct class_device *cdev, char *buf) +show_fc_host_active_fc4s (struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_internal *i = to_fc_internal(shost->transportt); if (i->f->get_host_active_fc4s) @@ -1443,13 +1470,14 @@ show_fc_host_active_fc4s (struct class_device *cdev, char *buf) return (ssize_t)show_fc_fc4s(buf, fc_host_active_fc4s(shost)); } -static FC_CLASS_DEVICE_ATTR(host, active_fc4s, S_IRUGO, +static FC_DEVICE_ATTR(host, active_fc4s, S_IRUGO, show_fc_host_active_fc4s, NULL); static ssize_t -show_fc_host_speed (struct class_device *cdev, char *buf) +show_fc_host_speed (struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_internal *i = to_fc_internal(shost->transportt); if (i->f->get_host_speed) @@ -1460,7 +1488,7 @@ show_fc_host_speed (struct class_device *cdev, char *buf) return get_fc_port_speed_names(fc_host_speed(shost), buf); } -static FC_CLASS_DEVICE_ATTR(host, speed, S_IRUGO, +static FC_DEVICE_ATTR(host, speed, S_IRUGO, show_fc_host_speed, NULL); @@ -1473,16 +1501,17 @@ fc_host_rd_attr(symbolic_name, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1); fc_private_host_show_function(system_hostname, "%s\n", FC_SYMBOLIC_NAME_SIZE + 1, ) fc_host_store_str_function(system_hostname, FC_SYMBOLIC_NAME_SIZE) -static FC_CLASS_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR, +static FC_DEVICE_ATTR(host, system_hostname, S_IRUGO | S_IWUSR, show_fc_host_system_hostname, store_fc_host_system_hostname); /* Private Host Attributes */ static ssize_t -show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf) +show_fc_private_host_tgtid_bind_type(struct device *dev, + struct device_attribute *attr, char *buf) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); const char *name; name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost)); @@ -1495,10 +1524,10 @@ show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf) pos = list_entry((head)->next, typeof(*pos), member) static ssize_t -store_fc_private_host_tgtid_bind_type(struct class_device *cdev, - const char *buf, size_t count) +store_fc_private_host_tgtid_bind_type(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_rport *rport; enum fc_tgtid_binding_type val; unsigned long flags; @@ -1523,15 +1552,15 @@ store_fc_private_host_tgtid_bind_type(struct class_device *cdev, return count; } -static FC_CLASS_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR, +static FC_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR, show_fc_private_host_tgtid_bind_type, store_fc_private_host_tgtid_bind_type); static ssize_t -store_fc_private_host_issue_lip(struct class_device *cdev, - const char *buf, size_t count) +store_fc_private_host_issue_lip(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_internal *i = to_fc_internal(shost->transportt); int ret; @@ -1544,7 +1573,7 @@ store_fc_private_host_issue_lip(struct class_device *cdev, return -ENOENT; } -static FC_CLASS_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL, +static FC_DEVICE_ATTR(host, issue_lip, S_IWUSR, NULL, store_fc_private_host_issue_lip); fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20); @@ -1556,9 +1585,9 @@ fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20); /* Show a given an attribute in the statistics group */ static ssize_t -fc_stat_show(const struct class_device *cdev, char *buf, unsigned long offset) +fc_stat_show(const struct device *dev, char *buf, unsigned long offset) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_internal *i = to_fc_internal(shost->transportt); struct fc_host_statistics *stats; ssize_t ret = -ENOENT; @@ -1579,12 +1608,14 @@ fc_stat_show(const struct class_device *cdev, char *buf, unsigned long offset) /* generate a read-only statistics attribute */ #define fc_host_statistic(name) \ -static ssize_t show_fcstat_##name(struct class_device *cd, char *buf) \ +static ssize_t show_fcstat_##name(struct device *cd, \ + struct device_attribute *attr, \ + char *buf) \ { \ return fc_stat_show(cd, buf, \ offsetof(struct fc_host_statistics, name)); \ } \ -static FC_CLASS_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL) +static FC_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL) fc_host_statistic(seconds_since_last_reset); fc_host_statistic(tx_frames); @@ -1608,10 +1639,10 @@ fc_host_statistic(fcp_input_megabytes); fc_host_statistic(fcp_output_megabytes); static ssize_t -fc_reset_statistics(struct class_device *cdev, const char *buf, - size_t count) +fc_reset_statistics(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_internal *i = to_fc_internal(shost->transportt); /* ignore any data value written to the attribute */ @@ -1622,31 +1653,31 @@ fc_reset_statistics(struct class_device *cdev, const char *buf, return -ENOENT; } -static FC_CLASS_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL, +static FC_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL, fc_reset_statistics); static struct attribute *fc_statistics_attrs[] = { - &class_device_attr_host_seconds_since_last_reset.attr, - &class_device_attr_host_tx_frames.attr, - &class_device_attr_host_tx_words.attr, - &class_device_attr_host_rx_frames.attr, - &class_device_attr_host_rx_words.attr, - &class_device_attr_host_lip_count.attr, - &class_device_attr_host_nos_count.attr, - &class_device_attr_host_error_frames.attr, - &class_device_attr_host_dumped_frames.attr, - &class_device_attr_host_link_failure_count.attr, - &class_device_attr_host_loss_of_sync_count.attr, - &class_device_attr_host_loss_of_signal_count.attr, - &class_device_attr_host_prim_seq_protocol_err_count.attr, - &class_device_attr_host_invalid_tx_word_count.attr, - &class_device_attr_host_invalid_crc_count.attr, - &class_device_attr_host_fcp_input_requests.attr, - &class_device_attr_host_fcp_output_requests.attr, - &class_device_attr_host_fcp_control_requests.attr, - &class_device_attr_host_fcp_input_megabytes.attr, - &class_device_attr_host_fcp_output_megabytes.attr, - &class_device_attr_host_reset_statistics.attr, + &device_attr_host_seconds_since_last_reset.attr, + &device_attr_host_tx_frames.attr, + &device_attr_host_tx_words.attr, + &device_attr_host_rx_frames.attr, + &device_attr_host_rx_words.attr, + &device_attr_host_lip_count.attr, + &device_attr_host_nos_count.attr, + &device_attr_host_error_frames.attr, + &device_attr_host_dumped_frames.attr, + &device_attr_host_link_failure_count.attr, + &device_attr_host_loss_of_sync_count.attr, + &device_attr_host_loss_of_signal_count.attr, + &device_attr_host_prim_seq_protocol_err_count.attr, + &device_attr_host_invalid_tx_word_count.attr, + &device_attr_host_invalid_crc_count.attr, + &device_attr_host_fcp_input_requests.attr, + &device_attr_host_fcp_output_requests.attr, + &device_attr_host_fcp_control_requests.attr, + &device_attr_host_fcp_input_megabytes.attr, + &device_attr_host_fcp_output_megabytes.attr, + &device_attr_host_reset_statistics.attr, NULL }; @@ -1695,10 +1726,10 @@ fc_parse_wwn(const char *ns, u64 *nm) * as hex characters, and may *not* contain any prefixes (e.g. 0x, x, etc) */ static ssize_t -store_fc_host_vport_create(struct class_device *cdev, const char *buf, - size_t count) +store_fc_host_vport_create(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_vport_identifiers vid; struct fc_vport *vport; unsigned int cnt=count; @@ -1731,7 +1762,7 @@ store_fc_host_vport_create(struct class_device *cdev, const char *buf, stat = fc_vport_create(shost, 0, &shost->shost_gendev, &vid, &vport); return stat ? stat : count; } -static FC_CLASS_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL, +static FC_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL, store_fc_host_vport_create); @@ -1742,10 +1773,10 @@ static FC_CLASS_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL, * any prefixes (e.g. 0x, x, etc) */ static ssize_t -store_fc_host_vport_delete(struct class_device *cdev, const char *buf, - size_t count) +store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct fc_host_attrs *fc_host = shost_to_fc_host(shost); struct fc_vport *vport; u64 wwpn, wwnn; @@ -1787,7 +1818,7 @@ store_fc_host_vport_delete(struct class_device *cdev, const char *buf, stat = fc_vport_terminate(vport); return stat ? stat : count; } -static FC_CLASS_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL, +static FC_DEVICE_ATTR(host, vport_delete, S_IWUSR, NULL, store_fc_host_vport_delete); diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c index ca7bb6f63bde..65d1737eb664 100644 --- a/drivers/scsi/scsi_transport_iscsi.c +++ b/drivers/scsi/scsi_transport_iscsi.c @@ -40,13 +40,13 @@ struct iscsi_internal { struct scsi_transport_template t; struct iscsi_transport *iscsi_transport; struct list_head list; - struct class_device cdev; + struct device dev; - struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1]; + struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1]; struct transport_container conn_cont; - struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1]; + struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1]; struct transport_container session_cont; - struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1]; + struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1]; }; static atomic_t iscsi_session_nr; /* sysfs session id for next new session */ @@ -63,12 +63,12 @@ static DEFINE_SPINLOCK(iscsi_transport_lock); #define to_iscsi_internal(tmpl) \ container_of(tmpl, struct iscsi_internal, t) -#define cdev_to_iscsi_internal(_cdev) \ - container_of(_cdev, struct iscsi_internal, cdev) +#define dev_to_iscsi_internal(_dev) \ + container_of(_dev, struct iscsi_internal, dev) -static void iscsi_transport_release(struct class_device *cdev) +static void iscsi_transport_release(struct device *dev) { - struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); + struct iscsi_internal *priv = dev_to_iscsi_internal(dev); kfree(priv); } @@ -78,25 +78,27 @@ static void iscsi_transport_release(struct class_device *cdev) */ static struct class iscsi_transport_class = { .name = "iscsi_transport", - .release = iscsi_transport_release, + .dev_release = iscsi_transport_release, }; static ssize_t -show_transport_handle(struct class_device *cdev, char *buf) +show_transport_handle(struct device *dev, struct device_attribute *attr, + char *buf) { - struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); + struct iscsi_internal *priv = dev_to_iscsi_internal(dev); return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport)); } -static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL); +static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL); #define show_transport_attr(name, format) \ static ssize_t \ -show_transport_##name(struct class_device *cdev, char *buf) \ +show_transport_##name(struct device *dev, \ + struct device_attribute *attr,char *buf) \ { \ - struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); \ + struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \ return sprintf(buf, format"\n", priv->iscsi_transport->name); \ } \ -static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL); +static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL); show_transport_attr(caps, "0x%x"); show_transport_attr(max_lun, "%d"); @@ -104,11 +106,11 @@ show_transport_attr(max_conn, "%d"); show_transport_attr(max_cmd_len, "%d"); static struct attribute *iscsi_transport_attrs[] = { - &class_device_attr_handle.attr, - &class_device_attr_caps.attr, - &class_device_attr_max_lun.attr, - &class_device_attr_max_conn.attr, - &class_device_attr_max_cmd_len.attr, + &dev_attr_handle.attr, + &dev_attr_caps.attr, + &dev_attr_max_lun.attr, + &dev_attr_max_conn.attr, + &dev_attr_max_cmd_len.attr, NULL, }; @@ -119,7 +121,7 @@ static struct attribute_group iscsi_transport_group = { static int iscsi_setup_host(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); struct iscsi_host *ihost = shost->shost_data; @@ -139,7 +141,7 @@ static int iscsi_setup_host(struct transport_container *tc, struct device *dev, } static int iscsi_remove_host(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); struct iscsi_host *ihost = shost->shost_data; @@ -1337,11 +1339,8 @@ iscsi_if_rx(struct sk_buff *skb) mutex_unlock(&rx_queue_mutex); } -#define iscsi_cdev_to_conn(_cdev) \ - iscsi_dev_to_conn(_cdev->dev) - #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \ -struct class_device_attribute class_device_attr_##_prefix##_##_name = \ +struct device_attribute dev_attr_##_prefix##_##_name = \ __ATTR(_name,_mode,_show,_store) /* @@ -1349,9 +1348,10 @@ struct class_device_attribute class_device_attr_##_prefix##_##_name = \ */ #define iscsi_conn_attr_show(param) \ static ssize_t \ -show_conn_param_##param(struct class_device *cdev, char *buf) \ +show_conn_param_##param(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev); \ + struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \ struct iscsi_transport *t = conn->transport; \ return t->get_conn_param(conn, param, buf); \ } @@ -1375,17 +1375,16 @@ iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS); iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO); iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO); -#define iscsi_cdev_to_session(_cdev) \ - iscsi_dev_to_session(_cdev->dev) - /* * iSCSI session attrs */ #define iscsi_session_attr_show(param, perm) \ static ssize_t \ -show_session_param_##param(struct class_device *cdev, char *buf) \ +show_session_param_##param(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \ + struct iscsi_cls_session *session = \ + iscsi_dev_to_session(dev->parent); \ struct iscsi_transport *t = session->transport; \ \ if (perm && !capable(CAP_SYS_ADMIN)) \ @@ -1417,9 +1416,10 @@ iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0); iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0); static ssize_t -show_priv_session_state(struct class_device *cdev, char *buf) +show_priv_session_state(struct device *dev, struct device_attribute *attr, + char *buf) { - struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); + struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); return sprintf(buf, "%s\n", iscsi_session_state_name(session->state)); } static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state, @@ -1427,9 +1427,11 @@ static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state, #define iscsi_priv_session_attr_show(field, format) \ static ssize_t \ -show_priv_session_##field(struct class_device *cdev, char *buf) \ +show_priv_session_##field(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\ + struct iscsi_cls_session *session = \ + iscsi_dev_to_session(dev->parent); \ return sprintf(buf, format"\n", session->field); \ } @@ -1444,9 +1446,10 @@ iscsi_priv_session_attr(recovery_tmo, "%d"); */ #define iscsi_host_attr_show(param) \ static ssize_t \ -show_host_param_##param(struct class_device *cdev, char *buf) \ +show_host_param_##param(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct Scsi_Host *shost = transport_class_to_shost(cdev); \ + struct Scsi_Host *shost = transport_class_to_shost(dev); \ struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \ return priv->iscsi_transport->get_host_param(shost, param, buf); \ } @@ -1463,7 +1466,7 @@ iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME); #define SETUP_PRIV_SESSION_RD_ATTR(field) \ do { \ - priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \ + priv->session_attrs[count] = &dev_attr_priv_sess_##field; \ count++; \ } while (0) @@ -1471,7 +1474,7 @@ do { \ #define SETUP_SESSION_RD_ATTR(field, param_flag) \ do { \ if (tt->param_mask & param_flag) { \ - priv->session_attrs[count] = &class_device_attr_sess_##field; \ + priv->session_attrs[count] = &dev_attr_sess_##field; \ count++; \ } \ } while (0) @@ -1479,7 +1482,7 @@ do { \ #define SETUP_CONN_RD_ATTR(field, param_flag) \ do { \ if (tt->param_mask & param_flag) { \ - priv->conn_attrs[count] = &class_device_attr_conn_##field; \ + priv->conn_attrs[count] = &dev_attr_conn_##field; \ count++; \ } \ } while (0) @@ -1487,7 +1490,7 @@ do { \ #define SETUP_HOST_RD_ATTR(field, param_flag) \ do { \ if (tt->host_param_mask & param_flag) { \ - priv->host_attrs[count] = &class_device_attr_host_##field; \ + priv->host_attrs[count] = &dev_attr_host_##field; \ count++; \ } \ } while (0) @@ -1578,15 +1581,15 @@ iscsi_register_transport(struct iscsi_transport *tt) priv->iscsi_transport = tt; priv->t.user_scan = iscsi_user_scan; - priv->cdev.class = &iscsi_transport_class; - snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name); - err = class_device_register(&priv->cdev); + priv->dev.class = &iscsi_transport_class; + snprintf(priv->dev.bus_id, BUS_ID_SIZE, "%s", tt->name); + err = device_register(&priv->dev); if (err) goto free_priv; - err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group); + err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group); if (err) - goto unregister_cdev; + goto unregister_dev; /* host parameters */ priv->t.host_attrs.ac.attrs = &priv->host_attrs[0]; @@ -1663,8 +1666,8 @@ iscsi_register_transport(struct iscsi_transport *tt) printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name); return &priv->t; -unregister_cdev: - class_device_unregister(&priv->cdev); +unregister_dev: + device_unregister(&priv->dev); free_priv: kfree(priv); return NULL; @@ -1691,8 +1694,8 @@ int iscsi_unregister_transport(struct iscsi_transport *tt) transport_container_unregister(&priv->session_cont); transport_container_unregister(&priv->t.host_attrs); - sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group); - class_device_unregister(&priv->cdev); + sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group); + device_unregister(&priv->dev); mutex_unlock(&rx_queue_mutex); return 0; diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c index 43a964d635b4..27ec625ab771 100644 --- a/drivers/scsi/scsi_transport_sas.c +++ b/drivers/scsi/scsi_transport_sas.c @@ -53,8 +53,8 @@ struct sas_host_attrs { /* * Hack to allow attributes of the same name in different objects. */ -#define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ - struct class_device_attribute class_device_attr_##_prefix##_##_name = \ +#define SAS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ + struct device_attribute dev_attr_##_prefix##_##_name = \ __ATTR(_name,_mode,_show,_store) @@ -261,7 +261,7 @@ static void sas_bsg_remove(struct Scsi_Host *shost, struct sas_rphy *rphy) */ static int sas_host_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); struct sas_host_attrs *sas_host = to_sas_host_attrs(shost); @@ -280,7 +280,7 @@ static int sas_host_setup(struct transport_container *tc, struct device *dev, } static int sas_host_remove(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); @@ -356,22 +356,24 @@ EXPORT_SYMBOL(sas_remove_host); #define sas_phy_show_simple(field, name, format_string, cast) \ static ssize_t \ -show_sas_phy_##name(struct class_device *cdev, char *buf) \ +show_sas_phy_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_phy *phy = transport_class_to_phy(cdev); \ + struct sas_phy *phy = transport_class_to_phy(dev); \ \ return snprintf(buf, 20, format_string, cast phy->field); \ } #define sas_phy_simple_attr(field, name, format_string, type) \ sas_phy_show_simple(field, name, format_string, (type)) \ -static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL) +static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL) #define sas_phy_show_protocol(field, name) \ static ssize_t \ -show_sas_phy_##name(struct class_device *cdev, char *buf) \ +show_sas_phy_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_phy *phy = transport_class_to_phy(cdev); \ + struct sas_phy *phy = transport_class_to_phy(dev); \ \ if (!phy->field) \ return snprintf(buf, 20, "none\n"); \ @@ -380,13 +382,14 @@ show_sas_phy_##name(struct class_device *cdev, char *buf) \ #define sas_phy_protocol_attr(field, name) \ sas_phy_show_protocol(field, name) \ -static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL) +static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL) #define sas_phy_show_linkspeed(field) \ static ssize_t \ -show_sas_phy_##field(struct class_device *cdev, char *buf) \ +show_sas_phy_##field(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_phy *phy = transport_class_to_phy(cdev); \ + struct sas_phy *phy = transport_class_to_phy(dev); \ \ return get_sas_linkspeed_names(phy->field, buf); \ } @@ -394,10 +397,11 @@ show_sas_phy_##field(struct class_device *cdev, char *buf) \ /* Fudge to tell if we're minimum or maximum */ #define sas_phy_store_linkspeed(field) \ static ssize_t \ -store_sas_phy_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_sas_phy_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ - struct sas_phy *phy = transport_class_to_phy(cdev); \ + struct sas_phy *phy = transport_class_to_phy(dev); \ struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \ struct sas_internal *i = to_sas_internal(shost->transportt); \ u32 value; \ @@ -416,19 +420,20 @@ store_sas_phy_##field(struct class_device *cdev, const char *buf, \ #define sas_phy_linkspeed_rw_attr(field) \ sas_phy_show_linkspeed(field) \ sas_phy_store_linkspeed(field) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, \ +static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, \ store_sas_phy_##field) #define sas_phy_linkspeed_attr(field) \ sas_phy_show_linkspeed(field) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL) +static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL) #define sas_phy_show_linkerror(field) \ static ssize_t \ -show_sas_phy_##field(struct class_device *cdev, char *buf) \ +show_sas_phy_##field(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_phy *phy = transport_class_to_phy(cdev); \ + struct sas_phy *phy = transport_class_to_phy(dev); \ struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \ struct sas_internal *i = to_sas_internal(shost->transportt); \ int error; \ @@ -441,24 +446,25 @@ show_sas_phy_##field(struct class_device *cdev, char *buf) \ #define sas_phy_linkerror_attr(field) \ sas_phy_show_linkerror(field) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL) +static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL) static ssize_t -show_sas_device_type(struct class_device *cdev, char *buf) +show_sas_device_type(struct device *dev, + struct device_attribute *attr, char *buf) { - struct sas_phy *phy = transport_class_to_phy(cdev); + struct sas_phy *phy = transport_class_to_phy(dev); if (!phy->identify.device_type) return snprintf(buf, 20, "none\n"); return get_sas_device_type_names(phy->identify.device_type, buf); } -static CLASS_DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL); +static DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL); -static ssize_t do_sas_phy_enable(struct class_device *cdev, +static ssize_t do_sas_phy_enable(struct device *dev, size_t count, int enable) { - struct sas_phy *phy = transport_class_to_phy(cdev); + struct sas_phy *phy = transport_class_to_phy(dev); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct sas_internal *i = to_sas_internal(shost->transportt); int error; @@ -470,18 +476,19 @@ static ssize_t do_sas_phy_enable(struct class_device *cdev, return count; }; -static ssize_t store_sas_phy_enable(struct class_device *cdev, - const char *buf, size_t count) +static ssize_t +store_sas_phy_enable(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { if (count < 1) return -EINVAL; switch (buf[0]) { case '0': - do_sas_phy_enable(cdev, count, 0); + do_sas_phy_enable(dev, count, 0); break; case '1': - do_sas_phy_enable(cdev, count, 1); + do_sas_phy_enable(dev, count, 1); break; default: return -EINVAL; @@ -490,20 +497,22 @@ static ssize_t store_sas_phy_enable(struct class_device *cdev, return count; } -static ssize_t show_sas_phy_enable(struct class_device *cdev, char *buf) +static ssize_t +show_sas_phy_enable(struct device *dev, struct device_attribute *attr, + char *buf) { - struct sas_phy *phy = transport_class_to_phy(cdev); + struct sas_phy *phy = transport_class_to_phy(dev); return snprintf(buf, 20, "%d", phy->enabled); } -static CLASS_DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable, +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable, store_sas_phy_enable); -static ssize_t do_sas_phy_reset(struct class_device *cdev, - size_t count, int hard_reset) +static ssize_t +do_sas_phy_reset(struct device *dev, size_t count, int hard_reset) { - struct sas_phy *phy = transport_class_to_phy(cdev); + struct sas_phy *phy = transport_class_to_phy(dev); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct sas_internal *i = to_sas_internal(shost->transportt); int error; @@ -514,19 +523,21 @@ static ssize_t do_sas_phy_reset(struct class_device *cdev, return count; }; -static ssize_t store_sas_link_reset(struct class_device *cdev, - const char *buf, size_t count) +static ssize_t +store_sas_link_reset(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - return do_sas_phy_reset(cdev, count, 0); + return do_sas_phy_reset(dev, count, 0); } -static CLASS_DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset); +static DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset); -static ssize_t store_sas_hard_reset(struct class_device *cdev, - const char *buf, size_t count) +static ssize_t +store_sas_hard_reset(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - return do_sas_phy_reset(cdev, count, 1); + return do_sas_phy_reset(dev, count, 1); } -static CLASS_DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset); +static DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset); sas_phy_protocol_attr(identify.initiator_port_protocols, initiator_port_protocols); @@ -695,16 +706,17 @@ EXPORT_SYMBOL(scsi_is_sas_phy); */ #define sas_port_show_simple(field, name, format_string, cast) \ static ssize_t \ -show_sas_port_##name(struct class_device *cdev, char *buf) \ +show_sas_port_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_port *port = transport_class_to_sas_port(cdev); \ + struct sas_port *port = transport_class_to_sas_port(dev); \ \ return snprintf(buf, 20, format_string, cast port->field); \ } #define sas_port_simple_attr(field, name, format_string, type) \ sas_port_show_simple(field, name, format_string, (type)) \ -static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL) +static DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL) sas_port_simple_attr(num_phys, num_phys, "%d\n", int); @@ -1017,23 +1029,25 @@ EXPORT_SYMBOL(sas_port_mark_backlink); #define sas_rphy_show_simple(field, name, format_string, cast) \ static ssize_t \ -show_sas_rphy_##name(struct class_device *cdev, char *buf) \ +show_sas_rphy_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_rphy *rphy = transport_class_to_rphy(cdev); \ + struct sas_rphy *rphy = transport_class_to_rphy(dev); \ \ return snprintf(buf, 20, format_string, cast rphy->field); \ } #define sas_rphy_simple_attr(field, name, format_string, type) \ sas_rphy_show_simple(field, name, format_string, (type)) \ -static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \ +static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \ show_sas_rphy_##name, NULL) #define sas_rphy_show_protocol(field, name) \ static ssize_t \ -show_sas_rphy_##name(struct class_device *cdev, char *buf) \ +show_sas_rphy_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_rphy *rphy = transport_class_to_rphy(cdev); \ + struct sas_rphy *rphy = transport_class_to_rphy(dev); \ \ if (!rphy->field) \ return snprintf(buf, 20, "none\n"); \ @@ -1042,13 +1056,14 @@ show_sas_rphy_##name(struct class_device *cdev, char *buf) \ #define sas_rphy_protocol_attr(field, name) \ sas_rphy_show_protocol(field, name) \ -static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \ +static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \ show_sas_rphy_##name, NULL) static ssize_t -show_sas_rphy_device_type(struct class_device *cdev, char *buf) +show_sas_rphy_device_type(struct device *dev, + struct device_attribute *attr, char *buf) { - struct sas_rphy *rphy = transport_class_to_rphy(cdev); + struct sas_rphy *rphy = transport_class_to_rphy(dev); if (!rphy->identify.device_type) return snprintf(buf, 20, "none\n"); @@ -1056,13 +1071,14 @@ show_sas_rphy_device_type(struct class_device *cdev, char *buf) rphy->identify.device_type, buf); } -static SAS_CLASS_DEVICE_ATTR(rphy, device_type, S_IRUGO, +static SAS_DEVICE_ATTR(rphy, device_type, S_IRUGO, show_sas_rphy_device_type, NULL); static ssize_t -show_sas_rphy_enclosure_identifier(struct class_device *cdev, char *buf) +show_sas_rphy_enclosure_identifier(struct device *dev, + struct device_attribute *attr, char *buf) { - struct sas_rphy *rphy = transport_class_to_rphy(cdev); + struct sas_rphy *rphy = transport_class_to_rphy(dev); struct sas_phy *phy = dev_to_phy(rphy->dev.parent); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct sas_internal *i = to_sas_internal(shost->transportt); @@ -1082,13 +1098,14 @@ show_sas_rphy_enclosure_identifier(struct class_device *cdev, char *buf) return sprintf(buf, "0x%llx\n", (unsigned long long)identifier); } -static SAS_CLASS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO, +static SAS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO, show_sas_rphy_enclosure_identifier, NULL); static ssize_t -show_sas_rphy_bay_identifier(struct class_device *cdev, char *buf) +show_sas_rphy_bay_identifier(struct device *dev, + struct device_attribute *attr, char *buf) { - struct sas_rphy *rphy = transport_class_to_rphy(cdev); + struct sas_rphy *rphy = transport_class_to_rphy(dev); struct sas_phy *phy = dev_to_phy(rphy->dev.parent); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct sas_internal *i = to_sas_internal(shost->transportt); @@ -1103,7 +1120,7 @@ show_sas_rphy_bay_identifier(struct class_device *cdev, char *buf) return sprintf(buf, "%d\n", val); } -static SAS_CLASS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO, +static SAS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO, show_sas_rphy_bay_identifier, NULL); sas_rphy_protocol_attr(identify.initiator_port_protocols, @@ -1161,9 +1178,10 @@ static DECLARE_TRANSPORT_CLASS(sas_end_dev_class, #define sas_end_dev_show_simple(field, name, format_string, cast) \ static ssize_t \ -show_sas_end_dev_##name(struct class_device *cdev, char *buf) \ +show_sas_end_dev_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_rphy *rphy = transport_class_to_rphy(cdev); \ + struct sas_rphy *rphy = transport_class_to_rphy(dev); \ struct sas_end_device *rdev = rphy_to_end_device(rphy); \ \ return snprintf(buf, 20, format_string, cast rdev->field); \ @@ -1171,7 +1189,7 @@ show_sas_end_dev_##name(struct class_device *cdev, char *buf) \ #define sas_end_dev_simple_attr(field, name, format_string, type) \ sas_end_dev_show_simple(field, name, format_string, (type)) \ -static SAS_CLASS_DEVICE_ATTR(end_dev, name, S_IRUGO, \ +static SAS_DEVICE_ATTR(end_dev, name, S_IRUGO, \ show_sas_end_dev_##name, NULL) sas_end_dev_simple_attr(ready_led_meaning, ready_led_meaning, "%d\n", int); @@ -1185,9 +1203,10 @@ static DECLARE_TRANSPORT_CLASS(sas_expander_class, #define sas_expander_show_simple(field, name, format_string, cast) \ static ssize_t \ -show_sas_expander_##name(struct class_device *cdev, char *buf) \ +show_sas_expander_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct sas_rphy *rphy = transport_class_to_rphy(cdev); \ + struct sas_rphy *rphy = transport_class_to_rphy(dev); \ struct sas_expander_device *edev = rphy_to_expander_device(rphy); \ \ return snprintf(buf, 20, format_string, cast edev->field); \ @@ -1195,7 +1214,7 @@ show_sas_expander_##name(struct class_device *cdev, char *buf) \ #define sas_expander_simple_attr(field, name, format_string, type) \ sas_expander_show_simple(field, name, format_string, (type)) \ -static SAS_CLASS_DEVICE_ATTR(expander, name, S_IRUGO, \ +static SAS_DEVICE_ATTR(expander, name, S_IRUGO, \ show_sas_expander_##name, NULL) sas_expander_simple_attr(vendor_id, vendor_id, "%s\n", char *); @@ -1554,14 +1573,14 @@ static int sas_user_scan(struct Scsi_Host *shost, uint channel, */ #define SETUP_TEMPLATE(attrb, field, perm, test) \ - i->private_##attrb[count] = class_device_attr_##field; \ + i->private_##attrb[count] = dev_attr_##field; \ i->private_##attrb[count].attr.mode = perm; \ i->attrb[count] = &i->private_##attrb[count]; \ if (test) \ count++ #define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \ - i->private_##attrb[count] = class_device_attr_##field; \ + i->private_##attrb[count] = dev_attr_##field; \ i->private_##attrb[count].attr.mode = perm; \ if (ro_test) { \ i->private_##attrb[count].attr.mode = ro_perm; \ diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c index 1fb60313a516..bc12b5d5d676 100644 --- a/drivers/scsi/scsi_transport_spi.c +++ b/drivers/scsi/scsi_transport_spi.c @@ -158,7 +158,7 @@ static inline enum spi_signal_type spi_signal_to_value(const char *name) } static int spi_host_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); @@ -169,7 +169,7 @@ static int spi_host_setup(struct transport_container *tc, struct device *dev, static int spi_host_configure(struct transport_container *tc, struct device *dev, - struct class_device *cdev); + struct device *cdev); static DECLARE_TRANSPORT_CLASS(spi_host_class, "spi_host", @@ -195,11 +195,11 @@ static int spi_host_match(struct attribute_container *cont, static int spi_target_configure(struct transport_container *tc, struct device *dev, - struct class_device *cdev); + struct device *cdev); static int spi_device_configure(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct scsi_device *sdev = to_scsi_device(dev); struct scsi_target *starget = sdev->sdev_target; @@ -219,7 +219,7 @@ static int spi_device_configure(struct transport_container *tc, static int spi_setup_transport_attrs(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct scsi_target *starget = to_scsi_target(dev); @@ -248,9 +248,10 @@ static int spi_setup_transport_attrs(struct transport_container *tc, #define spi_transport_show_simple(field, format_string) \ \ static ssize_t \ -show_spi_transport_##field(struct class_device *cdev, char *buf) \ +show_spi_transport_##field(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct spi_transport_attrs *tp; \ \ tp = (struct spi_transport_attrs *)&starget->starget_data; \ @@ -260,11 +261,12 @@ show_spi_transport_##field(struct class_device *cdev, char *buf) \ #define spi_transport_store_simple(field, format_string) \ \ static ssize_t \ -store_spi_transport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_spi_transport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct spi_transport_attrs *tp; \ \ tp = (struct spi_transport_attrs *)&starget->starget_data; \ @@ -276,9 +278,10 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \ #define spi_transport_show_function(field, format_string) \ \ static ssize_t \ -show_spi_transport_##field(struct class_device *cdev, char *buf) \ +show_spi_transport_##field(struct device *dev, \ + struct device_attribute *attr, char *buf) \ { \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ struct spi_transport_attrs *tp; \ struct spi_internal *i = to_spi_internal(shost->transportt); \ @@ -290,11 +293,12 @@ show_spi_transport_##field(struct class_device *cdev, char *buf) \ #define spi_transport_store_function(field, format_string) \ static ssize_t \ -store_spi_transport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_spi_transport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ struct spi_internal *i = to_spi_internal(shost->transportt); \ \ @@ -307,11 +311,12 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \ #define spi_transport_store_max(field, format_string) \ static ssize_t \ -store_spi_transport_##field(struct class_device *cdev, const char *buf, \ - size_t count) \ +store_spi_transport_##field(struct device *dev, \ + struct device_attribute *attr, \ + const char *buf, size_t count) \ { \ int val; \ - struct scsi_target *starget = transport_class_to_starget(cdev); \ + struct scsi_target *starget = transport_class_to_starget(dev); \ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \ struct spi_internal *i = to_spi_internal(shost->transportt); \ struct spi_transport_attrs *tp \ @@ -329,24 +334,24 @@ store_spi_transport_##field(struct class_device *cdev, const char *buf, \ #define spi_transport_rd_attr(field, format_string) \ spi_transport_show_function(field, format_string) \ spi_transport_store_function(field, format_string) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, \ - show_spi_transport_##field, \ - store_spi_transport_##field); +static DEVICE_ATTR(field, S_IRUGO, \ + show_spi_transport_##field, \ + store_spi_transport_##field); #define spi_transport_simple_attr(field, format_string) \ spi_transport_show_simple(field, format_string) \ spi_transport_store_simple(field, format_string) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, \ - show_spi_transport_##field, \ - store_spi_transport_##field); +static DEVICE_ATTR(field, S_IRUGO, \ + show_spi_transport_##field, \ + store_spi_transport_##field); #define spi_transport_max_attr(field, format_string) \ spi_transport_show_function(field, format_string) \ spi_transport_store_max(field, format_string) \ spi_transport_simple_attr(max_##field, format_string) \ -static CLASS_DEVICE_ATTR(field, S_IRUGO, \ - show_spi_transport_##field, \ - store_spi_transport_##field); +static DEVICE_ATTR(field, S_IRUGO, \ + show_spi_transport_##field, \ + store_spi_transport_##field); /* The Parallel SCSI Tranport Attributes: */ spi_transport_max_attr(offset, "%d\n"); @@ -370,14 +375,15 @@ static int child_iter(struct device *dev, void *data) } static ssize_t -store_spi_revalidate(struct class_device *cdev, const char *buf, size_t count) +store_spi_revalidate(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct scsi_target *starget = transport_class_to_starget(cdev); + struct scsi_target *starget = transport_class_to_starget(dev); device_for_each_child(&starget->dev, NULL, child_iter); return count; } -static CLASS_DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate); +static DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate); /* Translate the period into ns according to the current spec * for SDTR/PPR messages */ @@ -412,7 +418,7 @@ show_spi_transport_period_helper(char *buf, int period) } static ssize_t -store_spi_transport_period_helper(struct class_device *cdev, const char *buf, +store_spi_transport_period_helper(struct device *dev, const char *buf, size_t count, int *periodp) { int j, picosec, period = -1; @@ -449,9 +455,10 @@ store_spi_transport_period_helper(struct class_device *cdev, const char *buf, } static ssize_t -show_spi_transport_period(struct class_device *cdev, char *buf) +show_spi_transport_period(struct device *dev, + struct device_attribute *attr, char *buf) { - struct scsi_target *starget = transport_class_to_starget(cdev); + struct scsi_target *starget = transport_class_to_starget(dev); struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); struct spi_internal *i = to_spi_internal(shost->transportt); struct spi_transport_attrs *tp = @@ -464,8 +471,8 @@ show_spi_transport_period(struct class_device *cdev, char *buf) } static ssize_t -store_spi_transport_period(struct class_device *cdev, const char *buf, - size_t count) +store_spi_transport_period(struct device *cdev, struct device_attribute *attr, + const char *buf, size_t count) { struct scsi_target *starget = transport_class_to_starget(cdev); struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); @@ -487,12 +494,13 @@ store_spi_transport_period(struct class_device *cdev, const char *buf, return retval; } -static CLASS_DEVICE_ATTR(period, S_IRUGO, - show_spi_transport_period, - store_spi_transport_period); +static DEVICE_ATTR(period, S_IRUGO, + show_spi_transport_period, + store_spi_transport_period); static ssize_t -show_spi_transport_min_period(struct class_device *cdev, char *buf) +show_spi_transport_min_period(struct device *cdev, + struct device_attribute *attr, char *buf) { struct scsi_target *starget = transport_class_to_starget(cdev); struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); @@ -507,8 +515,9 @@ show_spi_transport_min_period(struct class_device *cdev, char *buf) } static ssize_t -store_spi_transport_min_period(struct class_device *cdev, const char *buf, - size_t count) +store_spi_transport_min_period(struct device *cdev, + struct device_attribute *attr, + const char *buf, size_t count) { struct scsi_target *starget = transport_class_to_starget(cdev); struct spi_transport_attrs *tp = @@ -519,12 +528,14 @@ store_spi_transport_min_period(struct class_device *cdev, const char *buf, } -static CLASS_DEVICE_ATTR(min_period, S_IRUGO, - show_spi_transport_min_period, - store_spi_transport_min_period); +static DEVICE_ATTR(min_period, S_IRUGO, + show_spi_transport_min_period, + store_spi_transport_min_period); -static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf) +static ssize_t show_spi_host_signalling(struct device *cdev, + struct device_attribute *attr, + char *buf) { struct Scsi_Host *shost = transport_class_to_shost(cdev); struct spi_internal *i = to_spi_internal(shost->transportt); @@ -534,10 +545,11 @@ static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf) return sprintf(buf, "%s\n", spi_signal_to_string(spi_signalling(shost))); } -static ssize_t store_spi_host_signalling(struct class_device *cdev, +static ssize_t store_spi_host_signalling(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) { - struct Scsi_Host *shost = transport_class_to_shost(cdev); + struct Scsi_Host *shost = transport_class_to_shost(dev); struct spi_internal *i = to_spi_internal(shost->transportt); enum spi_signal_type type = spi_signal_to_value(buf); @@ -549,9 +561,9 @@ static ssize_t store_spi_host_signalling(struct class_device *cdev, return count; } -static CLASS_DEVICE_ATTR(signalling, S_IRUGO, - show_spi_host_signalling, - store_spi_host_signalling); +static DEVICE_ATTR(signalling, S_IRUGO, + show_spi_host_signalling, + store_spi_host_signalling); #define DV_SET(x, y) \ if(i->f->set_##x) \ @@ -1334,7 +1346,7 @@ static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class, spi_device_configure); static struct attribute *host_attributes[] = { - &class_device_attr_signalling.attr, + &dev_attr_signalling.attr, NULL }; @@ -1344,12 +1356,12 @@ static struct attribute_group host_attribute_group = { static int spi_host_configure(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct kobject *kobj = &cdev->kobj; struct Scsi_Host *shost = transport_class_to_shost(cdev); struct spi_internal *si = to_spi_internal(shost->transportt); - struct attribute *attr = &class_device_attr_signalling.attr; + struct attribute *attr = &dev_attr_signalling.attr; int rc = 0; if (si->f->set_signalling) @@ -1368,76 +1380,75 @@ static int spi_host_configure(struct transport_container *tc, static int target_attribute_is_visible(struct kobject *kobj, struct attribute *attr, int i) { - struct class_device *cdev = - container_of(kobj, struct class_device, kobj); + struct device *cdev = container_of(kobj, struct device, kobj); struct scsi_target *starget = transport_class_to_starget(cdev); struct Scsi_Host *shost = transport_class_to_shost(cdev); struct spi_internal *si = to_spi_internal(shost->transportt); - if (attr == &class_device_attr_period.attr && + if (attr == &dev_attr_period.attr && spi_support_sync(starget)) return TARGET_ATTRIBUTE_HELPER(period); - else if (attr == &class_device_attr_min_period.attr && + else if (attr == &dev_attr_min_period.attr && spi_support_sync(starget)) return TARGET_ATTRIBUTE_HELPER(period); - else if (attr == &class_device_attr_offset.attr && + else if (attr == &dev_attr_offset.attr && spi_support_sync(starget)) return TARGET_ATTRIBUTE_HELPER(offset); - else if (attr == &class_device_attr_max_offset.attr && + else if (attr == &dev_attr_max_offset.attr && spi_support_sync(starget)) return TARGET_ATTRIBUTE_HELPER(offset); - else if (attr == &class_device_attr_width.attr && + else if (attr == &dev_attr_width.attr && spi_support_wide(starget)) return TARGET_ATTRIBUTE_HELPER(width); - else if (attr == &class_device_attr_max_width.attr && + else if (attr == &dev_attr_max_width.attr && spi_support_wide(starget)) return TARGET_ATTRIBUTE_HELPER(width); - else if (attr == &class_device_attr_iu.attr && + else if (attr == &dev_attr_iu.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(iu); - else if (attr == &class_device_attr_dt.attr && + else if (attr == &dev_attr_dt.attr && spi_support_dt(starget)) return TARGET_ATTRIBUTE_HELPER(dt); - else if (attr == &class_device_attr_qas.attr && + else if (attr == &dev_attr_qas.attr && spi_support_qas(starget)) return TARGET_ATTRIBUTE_HELPER(qas); - else if (attr == &class_device_attr_wr_flow.attr && + else if (attr == &dev_attr_wr_flow.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(wr_flow); - else if (attr == &class_device_attr_rd_strm.attr && + else if (attr == &dev_attr_rd_strm.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(rd_strm); - else if (attr == &class_device_attr_rti.attr && + else if (attr == &dev_attr_rti.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(rti); - else if (attr == &class_device_attr_pcomp_en.attr && + else if (attr == &dev_attr_pcomp_en.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(pcomp_en); - else if (attr == &class_device_attr_hold_mcs.attr && + else if (attr == &dev_attr_hold_mcs.attr && spi_support_ius(starget)) return TARGET_ATTRIBUTE_HELPER(hold_mcs); - else if (attr == &class_device_attr_revalidate.attr) + else if (attr == &dev_attr_revalidate.attr) return 1; return 0; } static struct attribute *target_attributes[] = { - &class_device_attr_period.attr, - &class_device_attr_min_period.attr, - &class_device_attr_offset.attr, - &class_device_attr_max_offset.attr, - &class_device_attr_width.attr, - &class_device_attr_max_width.attr, - &class_device_attr_iu.attr, - &class_device_attr_dt.attr, - &class_device_attr_qas.attr, - &class_device_attr_wr_flow.attr, - &class_device_attr_rd_strm.attr, - &class_device_attr_rti.attr, - &class_device_attr_pcomp_en.attr, - &class_device_attr_hold_mcs.attr, - &class_device_attr_revalidate.attr, + &dev_attr_period.attr, + &dev_attr_min_period.attr, + &dev_attr_offset.attr, + &dev_attr_max_offset.attr, + &dev_attr_width.attr, + &dev_attr_max_width.attr, + &dev_attr_iu.attr, + &dev_attr_dt.attr, + &dev_attr_qas.attr, + &dev_attr_wr_flow.attr, + &dev_attr_rd_strm.attr, + &dev_attr_rti.attr, + &dev_attr_pcomp_en.attr, + &dev_attr_hold_mcs.attr, + &dev_attr_revalidate.attr, NULL }; @@ -1448,7 +1459,7 @@ static struct attribute_group target_attribute_group = { static int spi_target_configure(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct kobject *kobj = &cdev->kobj; int i; @@ -1462,7 +1473,7 @@ static int spi_target_configure(struct transport_container *tc, * to ignore, sysfs also does a WARN_ON and dumps a trace, * which is bad, so temporarily, skip attributes that are * already visible (the revalidate one) */ - if (j && attr != &class_device_attr_revalidate.attr) + if (j && attr != &dev_attr_revalidate.attr) rc = sysfs_add_file_to_group(kobj, attr, target_attribute_group.name); /* and make the attribute writeable if we have a set diff --git a/drivers/scsi/scsi_transport_srp.c b/drivers/scsi/scsi_transport_srp.c index 2445c98ae95e..8a7af951d98a 100644 --- a/drivers/scsi/scsi_transport_srp.c +++ b/drivers/scsi/scsi_transport_srp.c @@ -44,20 +44,20 @@ struct srp_internal { struct scsi_transport_template t; struct srp_function_template *f; - struct class_device_attribute *host_attrs[SRP_HOST_ATTRS + 1]; + struct device_attribute *host_attrs[SRP_HOST_ATTRS + 1]; - struct class_device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1]; - struct class_device_attribute private_rport_attrs[SRP_RPORT_ATTRS]; + struct device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1]; + struct device_attribute private_rport_attrs[SRP_RPORT_ATTRS]; struct transport_container rport_attr_cont; }; #define to_srp_internal(tmpl) container_of(tmpl, struct srp_internal, t) #define dev_to_rport(d) container_of(d, struct srp_rport, dev) -#define transport_class_to_srp_rport(cdev) dev_to_rport((cdev)->dev) +#define transport_class_to_srp_rport(dev) dev_to_rport((dev)->parent) static int srp_host_setup(struct transport_container *tc, struct device *dev, - struct class_device *cdev) + struct device *cdev) { struct Scsi_Host *shost = dev_to_shost(dev); struct srp_host_attrs *srp_host = to_srp_host_attrs(shost); @@ -73,7 +73,7 @@ static DECLARE_TRANSPORT_CLASS(srp_rport_class, "srp_remote_ports", NULL, NULL, NULL); #define SETUP_TEMPLATE(attrb, field, perm, test, ro_test, ro_perm) \ - i->private_##attrb[count] = class_device_attr_##field; \ + i->private_##attrb[count] = dev_attr_##field; \ i->private_##attrb[count].attr.mode = perm; \ if (ro_test) { \ i->private_##attrb[count].attr.mode = ro_perm; \ @@ -100,13 +100,14 @@ static DECLARE_TRANSPORT_CLASS(srp_rport_class, "srp_remote_ports", "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x" static ssize_t -show_srp_rport_id(struct class_device *cdev, char *buf) +show_srp_rport_id(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_rport *rport = transport_class_to_srp_rport(cdev); + struct srp_rport *rport = transport_class_to_srp_rport(dev); return sprintf(buf, SRP_PID_FMT "\n", SRP_PID(rport)); } -static CLASS_DEVICE_ATTR(port_id, S_IRUGO, show_srp_rport_id, NULL); +static DEVICE_ATTR(port_id, S_IRUGO, show_srp_rport_id, NULL); static const struct { u32 value; @@ -117,9 +118,10 @@ static const struct { }; static ssize_t -show_srp_rport_roles(struct class_device *cdev, char *buf) +show_srp_rport_roles(struct device *dev, struct device_attribute *attr, + char *buf) { - struct srp_rport *rport = transport_class_to_srp_rport(cdev); + struct srp_rport *rport = transport_class_to_srp_rport(dev); int i; char *name = NULL; @@ -131,7 +133,7 @@ show_srp_rport_roles(struct class_device *cdev, char *buf) return sprintf(buf, "%s\n", name ? : "unknown"); } -static CLASS_DEVICE_ATTR(roles, S_IRUGO, show_srp_rport_roles, NULL); +static DEVICE_ATTR(roles, S_IRUGO, show_srp_rport_roles, NULL); static void srp_rport_release(struct device *dev) { diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 5fe7aaed904c..3cea17dd5dba 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -95,7 +95,7 @@ static int sd_resume(struct device *); static void sd_rescan(struct device *); static int sd_done(struct scsi_cmnd *); static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer); -static void scsi_disk_release(struct class_device *cdev); +static void scsi_disk_release(struct device *cdev); static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *); static void sd_print_result(struct scsi_disk *, int); @@ -112,11 +112,12 @@ static const char *sd_cache_types[] = { "write back, no read (daft)" }; -static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf, - size_t count) +static ssize_t +sd_store_cache_type(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { int i, ct = -1, rcd, wce, sp; - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); struct scsi_device *sdp = sdkp->device; char buffer[64]; char *buffer_data; @@ -163,10 +164,11 @@ static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf, return count; } -static ssize_t sd_store_manage_start_stop(struct class_device *cdev, - const char *buf, size_t count) +static ssize_t +sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); struct scsi_device *sdp = sdkp->device; if (!capable(CAP_SYS_ADMIN)) @@ -177,10 +179,11 @@ static ssize_t sd_store_manage_start_stop(struct class_device *cdev, return count; } -static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf, - size_t count) +static ssize_t +sd_store_allow_restart(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); struct scsi_device *sdp = sdkp->device; if (!capable(CAP_SYS_ADMIN)) @@ -194,37 +197,44 @@ static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf return count; } -static ssize_t sd_show_cache_type(struct class_device *cdev, char *buf) +static ssize_t +sd_show_cache_type(struct device *dev, struct device_attribute *attr, + char *buf) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); int ct = sdkp->RCD + 2*sdkp->WCE; return snprintf(buf, 40, "%s\n", sd_cache_types[ct]); } -static ssize_t sd_show_fua(struct class_device *cdev, char *buf) +static ssize_t +sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%u\n", sdkp->DPOFUA); } -static ssize_t sd_show_manage_start_stop(struct class_device *cdev, char *buf) +static ssize_t +sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr, + char *buf) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); struct scsi_device *sdp = sdkp->device; return snprintf(buf, 20, "%u\n", sdp->manage_start_stop); } -static ssize_t sd_show_allow_restart(struct class_device *cdev, char *buf) +static ssize_t +sd_show_allow_restart(struct device *dev, struct device_attribute *attr, + char *buf) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart); } -static struct class_device_attribute sd_disk_attrs[] = { +static struct device_attribute sd_disk_attrs[] = { __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type, sd_store_cache_type), __ATTR(FUA, S_IRUGO, sd_show_fua, NULL), @@ -238,8 +248,8 @@ static struct class_device_attribute sd_disk_attrs[] = { static struct class sd_disk_class = { .name = "scsi_disk", .owner = THIS_MODULE, - .release = scsi_disk_release, - .class_dev_attrs = sd_disk_attrs, + .dev_release = scsi_disk_release, + .dev_attrs = sd_disk_attrs, }; static struct scsi_driver sd_template = { @@ -297,7 +307,7 @@ static struct scsi_disk *__scsi_disk_get(struct gendisk *disk) if (disk->private_data) { sdkp = scsi_disk(disk); if (scsi_device_get(sdkp->device) == 0) - class_device_get(&sdkp->cdev); + get_device(&sdkp->dev); else sdkp = NULL; } @@ -331,7 +341,7 @@ static void scsi_disk_put(struct scsi_disk *sdkp) struct scsi_device *sdev = sdkp->device; mutex_lock(&sd_ref_mutex); - class_device_put(&sdkp->cdev); + put_device(&sdkp->dev); scsi_device_put(sdev); mutex_unlock(&sd_ref_mutex); } @@ -1663,12 +1673,12 @@ static int sd_probe(struct device *dev) sdp->timeout = SD_MOD_TIMEOUT; } - class_device_initialize(&sdkp->cdev); - sdkp->cdev.dev = &sdp->sdev_gendev; - sdkp->cdev.class = &sd_disk_class; - strncpy(sdkp->cdev.class_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE); + device_initialize(&sdkp->dev); + sdkp->dev.parent = &sdp->sdev_gendev; + sdkp->dev.class = &sd_disk_class; + strncpy(sdkp->dev.bus_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE); - if (class_device_add(&sdkp->cdev)) + if (device_add(&sdkp->dev)) goto out_put; get_device(&sdp->sdev_gendev); @@ -1734,13 +1744,13 @@ static int sd_remove(struct device *dev) { struct scsi_disk *sdkp = dev_get_drvdata(dev); - class_device_del(&sdkp->cdev); + device_del(&sdkp->dev); del_gendisk(sdkp->disk); sd_shutdown(dev); mutex_lock(&sd_ref_mutex); dev_set_drvdata(dev, NULL); - class_device_put(&sdkp->cdev); + put_device(&sdkp->dev); mutex_unlock(&sd_ref_mutex); return 0; @@ -1748,16 +1758,16 @@ static int sd_remove(struct device *dev) /** * scsi_disk_release - Called to free the scsi_disk structure - * @cdev: pointer to embedded class device + * @dev: pointer to embedded class device * * sd_ref_mutex must be held entering this routine. Because it is * called on last put, you should always use the scsi_disk_get() * scsi_disk_put() helpers which manipulate the semaphore directly - * and never do a direct class_device_put(). + * and never do a direct put_device. **/ -static void scsi_disk_release(struct class_device *cdev) +static void scsi_disk_release(struct device *dev) { - struct scsi_disk *sdkp = to_scsi_disk(cdev); + struct scsi_disk *sdkp = to_scsi_disk(dev); struct gendisk *disk = sdkp->disk; spin_lock(&sd_index_lock); diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c index a6d96694d0a5..45df83b9d847 100644 --- a/drivers/scsi/ses.c +++ b/drivers/scsi/ses.c @@ -107,7 +107,7 @@ static int ses_set_page2_descriptor(struct enclosure_device *edev, unsigned char *desc) { int i, j, count = 0, descriptor = ecomp->number; - struct scsi_device *sdev = to_scsi_device(edev->cdev.dev); + struct scsi_device *sdev = to_scsi_device(edev->edev.parent); struct ses_device *ses_dev = edev->scratch; unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11]; unsigned char *desc_ptr = ses_dev->page2 + 8; @@ -137,7 +137,7 @@ static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev, struct enclosure_component *ecomp) { int i, j, count = 0, descriptor = ecomp->number; - struct scsi_device *sdev = to_scsi_device(edev->cdev.dev); + struct scsi_device *sdev = to_scsi_device(edev->edev.parent); struct ses_device *ses_dev = edev->scratch; unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11]; unsigned char *desc_ptr = ses_dev->page2 + 8; @@ -269,10 +269,10 @@ int ses_match_host(struct enclosure_device *edev, void *data) struct ses_host_edev *sed = data; struct scsi_device *sdev; - if (!scsi_is_sdev_device(edev->cdev.dev)) + if (!scsi_is_sdev_device(edev->edev.parent)) return 0; - sdev = to_scsi_device(edev->cdev.dev); + sdev = to_scsi_device(edev->edev.parent); if (sdev->host != sed->shost) return 0; @@ -407,10 +407,10 @@ static void ses_match_to_enclosure(struct enclosure_device *edev, #define INIT_ALLOC_SIZE 32 -static int ses_intf_add(struct class_device *cdev, +static int ses_intf_add(struct device *cdev, struct class_interface *intf) { - struct scsi_device *sdev = to_scsi_device(cdev->dev); + struct scsi_device *sdev = to_scsi_device(cdev->parent); struct scsi_device *tmp_sdev; unsigned char *buf = NULL, *hdr_buf, *type_ptr, *desc_ptr = NULL, *addl_desc_ptr = NULL; @@ -426,7 +426,7 @@ static int ses_intf_add(struct class_device *cdev, edev = enclosure_find(&sdev->host->shost_gendev); if (edev) { ses_match_to_enclosure(edev, sdev); - class_device_put(&edev->cdev); + put_device(&edev->edev); } return -ENODEV; } @@ -515,7 +515,7 @@ static int ses_intf_add(struct class_device *cdev, if (!scomp) goto err_free; - edev = enclosure_register(cdev->dev, sdev->sdev_gendev.bus_id, + edev = enclosure_register(cdev->parent, sdev->sdev_gendev.bus_id, components, &ses_enclosure_callbacks); if (IS_ERR(edev)) { err = PTR_ERR(edev); @@ -625,17 +625,17 @@ static int ses_remove(struct device *dev) return 0; } -static void ses_intf_remove(struct class_device *cdev, +static void ses_intf_remove(struct device *cdev, struct class_interface *intf) { - struct scsi_device *sdev = to_scsi_device(cdev->dev); + struct scsi_device *sdev = to_scsi_device(cdev->parent); struct enclosure_device *edev; struct ses_device *ses_dev; if (!scsi_device_enclosure(sdev)) return; - edev = enclosure_find(cdev->dev); + edev = enclosure_find(cdev->parent); if (!edev) return; @@ -649,13 +649,13 @@ static void ses_intf_remove(struct class_device *cdev, kfree(edev->component[0].scratch); - class_device_put(&edev->cdev); + put_device(&edev->edev); enclosure_unregister(edev); } static struct class_interface ses_interface = { - .add = ses_intf_add, - .remove = ses_intf_remove, + .add_dev = ses_intf_add, + .remove_dev = ses_intf_remove, }; static struct scsi_driver ses_template = { diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c index e5156aa6dd20..2029422bc04d 100644 --- a/drivers/scsi/sg.c +++ b/drivers/scsi/sg.c @@ -101,16 +101,16 @@ static int scatter_elem_sz_prev = SG_SCATTER_SZ; #define SG_SECTOR_SZ 512 #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1) -static int sg_add(struct class_device *, struct class_interface *); -static void sg_remove(struct class_device *, struct class_interface *); +static int sg_add(struct device *, struct class_interface *); +static void sg_remove(struct device *, struct class_interface *); static DEFINE_IDR(sg_index_idr); static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock file descriptor list for device */ static struct class_interface sg_interface = { - .add = sg_add, - .remove = sg_remove, + .add_dev = sg_add, + .remove_dev = sg_remove, }; typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */ @@ -1401,9 +1401,9 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp) } static int -sg_add(struct class_device *cl_dev, struct class_interface *cl_intf) +sg_add(struct device *cl_dev, struct class_interface *cl_intf) { - struct scsi_device *scsidp = to_scsi_device(cl_dev->dev); + struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); struct gendisk *disk; Sg_device *sdp = NULL; struct cdev * cdev = NULL; @@ -1439,19 +1439,19 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf) sdp->cdev = cdev; if (sg_sysfs_valid) { - struct class_device * sg_class_member; + struct device *sg_class_member; - sg_class_member = class_device_create(sg_sysfs_class, NULL, - MKDEV(SCSI_GENERIC_MAJOR, sdp->index), - cl_dev->dev, "%s", - disk->disk_name); + sg_class_member = device_create(sg_sysfs_class, cl_dev->parent, + MKDEV(SCSI_GENERIC_MAJOR, + sdp->index), + "%s", disk->disk_name); if (IS_ERR(sg_class_member)) { printk(KERN_ERR "sg_add: " - "class_device_create failed\n"); + "device_create failed\n"); error = PTR_ERR(sg_class_member); goto cdev_add_err; } - class_set_devdata(sg_class_member, sdp); + dev_set_drvdata(sg_class_member, sdp); error = sysfs_create_link(&scsidp->sdev_gendev.kobj, &sg_class_member->kobj, "generic"); if (error) @@ -1464,7 +1464,7 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf) "Attached scsi generic sg%d type %d\n", sdp->index, scsidp->type); - class_set_devdata(cl_dev, sdp); + dev_set_drvdata(cl_dev, sdp); return 0; @@ -1482,10 +1482,10 @@ out: } static void -sg_remove(struct class_device *cl_dev, struct class_interface *cl_intf) +sg_remove(struct device *cl_dev, struct class_interface *cl_intf) { - struct scsi_device *scsidp = to_scsi_device(cl_dev->dev); - Sg_device *sdp = class_get_devdata(cl_dev); + struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); + Sg_device *sdp = dev_get_drvdata(cl_dev); unsigned long iflags; Sg_fd *sfp; Sg_fd *tsfp; @@ -1528,7 +1528,7 @@ sg_remove(struct class_device *cl_dev, struct class_interface *cl_intf) write_unlock_irqrestore(&sg_index_lock, iflags); sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic"); - class_device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index)); + device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index)); cdev_del(sdp->cdev); sdp->cdev = NULL; put_disk(sdp->disk); diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c index df83bea2c620..a860c3a9ae99 100644 --- a/drivers/scsi/st.c +++ b/drivers/scsi/st.c @@ -4108,9 +4108,9 @@ out_free_tape: if (STm->cdevs[j]) { if (cdev == STm->cdevs[j]) cdev = NULL; - class_device_destroy(st_sysfs_class, - MKDEV(SCSI_TAPE_MAJOR, - TAPE_MINOR(i, mode, j))); + device_destroy(st_sysfs_class, + MKDEV(SCSI_TAPE_MAJOR, + TAPE_MINOR(i, mode, j))); cdev_del(STm->cdevs[j]); } } @@ -4148,9 +4148,9 @@ static int st_remove(struct device *dev) "tape"); for (mode = 0; mode < ST_NBR_MODES; ++mode) { for (j=0; j < 2; j++) { - class_device_destroy(st_sysfs_class, - MKDEV(SCSI_TAPE_MAJOR, - TAPE_MINOR(i, mode, j))); + device_destroy(st_sysfs_class, + MKDEV(SCSI_TAPE_MAJOR, + TAPE_MINOR(i, mode, j))); cdev_del(tpnt->modes[mode].cdevs[j]); tpnt->modes[mode].cdevs[j] = NULL; } @@ -4319,31 +4319,34 @@ static void do_remove_sysfs_files(void) /* The sysfs simple class interface */ -static ssize_t st_defined_show(struct class_device *class_dev, char *buf) +static ssize_t +st_defined_show(struct device *dev, struct device_attribute *attr, char *buf) { - struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); + struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev); ssize_t l = 0; l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); return l; } -CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL); +DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL); -static ssize_t st_defblk_show(struct class_device *class_dev, char *buf) +static ssize_t +st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf) { - struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); + struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev); ssize_t l = 0; l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); return l; } -CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL); +DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL); -static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf) +static ssize_t +st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf) { - struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); + struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev); ssize_t l = 0; char *fmt; @@ -4352,22 +4355,25 @@ static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf) return l; } -CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL); +DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL); -static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf) +static ssize_t +st_defcompression_show(struct device *dev, struct device_attribute *attr, + char *buf) { - struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); + struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev); ssize_t l = 0; l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); return l; } -CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL); +DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL); -static ssize_t st_options_show(struct class_device *class_dev, char *buf) +static ssize_t +st_options_show(struct device *dev, struct device_attribute *attr, char *buf) { - struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev); + struct st_modedef *STm = (struct st_modedef *)dev_get_drvdata(dev); struct scsi_tape *STp; int i, j, options; ssize_t l = 0; @@ -4403,13 +4409,13 @@ static ssize_t st_options_show(struct class_device *class_dev, char *buf) return l; } -CLASS_DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL); +DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL); static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) { int i, rew, error; char name[10]; - struct class_device *st_class_member; + struct device *st_class_member; for (rew=0; rew < 2; rew++) { /* Make sure that the minor numbers corresponding to the four @@ -4418,32 +4424,32 @@ static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) snprintf(name, 10, "%s%s%s", rew ? "n" : "", STp->disk->disk_name, st_formats[i]); st_class_member = - class_device_create(st_sysfs_class, NULL, - MKDEV(SCSI_TAPE_MAJOR, - TAPE_MINOR(dev_num, mode, rew)), - &STp->device->sdev_gendev, "%s", name); + device_create(st_sysfs_class, &STp->device->sdev_gendev, + MKDEV(SCSI_TAPE_MAJOR, + TAPE_MINOR(dev_num, mode, rew)), + "%s", name); if (IS_ERR(st_class_member)) { - printk(KERN_WARNING "st%d: class_device_create failed\n", + printk(KERN_WARNING "st%d: device_create failed\n", dev_num); error = PTR_ERR(st_class_member); goto out; } - class_set_devdata(st_class_member, &STp->modes[mode]); + dev_set_drvdata(st_class_member, &STp->modes[mode]); - error = class_device_create_file(st_class_member, - &class_device_attr_defined); + error = device_create_file(st_class_member, + &dev_attr_defined); if (error) goto out; - error = class_device_create_file(st_class_member, - &class_device_attr_default_blksize); + error = device_create_file(st_class_member, + &dev_attr_default_blksize); if (error) goto out; - error = class_device_create_file(st_class_member, - &class_device_attr_default_density); + error = device_create_file(st_class_member, + &dev_attr_default_density); if (error) goto out; - error = class_device_create_file(st_class_member, - &class_device_attr_default_compression); + error = device_create_file(st_class_member, + &dev_attr_default_compression); if (error) goto out; - error = class_device_create_file(st_class_member, - &class_device_attr_options); + error = device_create_file(st_class_member, + &dev_attr_options); if (error) goto out; if (mode == 0 && rew == 0) { |