nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

SCSI: convert struct class_device to struct device

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

Signed-off-by: Tony Jones <tonyj@suse.de>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Cc: Roland Dreier <rolandd@cisco.com>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Tony Jones 2008-02-22 00:13:36 +01:00 committed by Greg Kroah-Hartman
parent 56d110e852
commit ee959b00c3
55 changed files with 1756 additions and 1505 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

11
block/bsg.c
View file

@ -758,7 +758,7 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
mutex_lock(&bsg_mutex); mutex_lock(&bsg_mutex);
hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode))); hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
strncpy(bd->name, rq->bsg_dev.class_dev->class_id, sizeof(bd->name) - 1); strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);
dprintk("bound to <%s>, max queue %d\n", dprintk("bound to <%s>, max queue %d\n",
format_dev_t(buf, inode->i_rdev), bd->max_queue); format_dev_t(buf, inode->i_rdev), bd->max_queue);
@ -946,7 +946,7 @@ void bsg_unregister_queue(struct request_queue *q)
mutex_lock(&bsg_mutex); mutex_lock(&bsg_mutex);
idr_remove(&bsg_minor_idr, bcd->minor); idr_remove(&bsg_minor_idr, bcd->minor);
sysfs_remove_link(&q->kobj, "bsg"); sysfs_remove_link(&q->kobj, "bsg");
class_device_unregister(bcd->class_dev); device_unregister(bcd->class_dev);
put_device(bcd->dev); put_device(bcd->dev);
bcd->class_dev = NULL; bcd->class_dev = NULL;
mutex_unlock(&bsg_mutex); mutex_unlock(&bsg_mutex);
@ -959,7 +959,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
struct bsg_class_device *bcd; struct bsg_class_device *bcd;
dev_t dev; dev_t dev;
int ret, minor; int ret, minor;
struct class_device *class_dev = NULL; struct device *class_dev = NULL;
const char *devname; const char *devname;
if (name) if (name)
@ -998,8 +998,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
bcd->queue = q; bcd->queue = q;
bcd->dev = get_device(gdev); bcd->dev = get_device(gdev);
dev = MKDEV(bsg_major, bcd->minor); dev = MKDEV(bsg_major, bcd->minor);
class_dev = class_device_create(bsg_class, NULL, dev, gdev, "%s", class_dev = device_create(bsg_class, gdev, dev, "%s", devname);
devname);
if (IS_ERR(class_dev)) { if (IS_ERR(class_dev)) {
ret = PTR_ERR(class_dev); ret = PTR_ERR(class_dev);
goto put_dev; goto put_dev;
@ -1016,7 +1015,7 @@ int bsg_register_queue(struct request_queue *q, struct device *gdev,
return 0; return 0;
unregister_class_dev: unregister_class_dev:
class_device_unregister(class_dev); device_unregister(class_dev);
put_dev: put_dev:
put_device(gdev); put_device(gdev);
remove_idr: remove_idr:

4
drivers/ata/ahci.c
View file

@ -273,8 +273,8 @@ static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
static int ahci_pci_device_resume(struct pci_dev *pdev); static int ahci_pci_device_resume(struct pci_dev *pdev);
#endif #endif
static struct class_device_attribute *ahci_shost_attrs[] = { static struct device_attribute *ahci_shost_attrs[] = {
&class_device_attr_link_power_management_policy, &dev_attr_link_power_management_policy,
NULL NULL
}; };

15
drivers/ata/libata-scsi.c
View file

@ -131,10 +131,11 @@ static const char *ata_scsi_lpm_get(enum link_pm policy)
return NULL; return NULL;
} }
static ssize_t ata_scsi_lpm_put(struct class_device *class_dev, static ssize_t ata_scsi_lpm_put(struct device *dev,
const char *buf, size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct Scsi_Host *shost = class_to_shost(class_dev); struct Scsi_Host *shost = class_to_shost(dev);
struct ata_port *ap = ata_shost_to_port(shost); struct ata_port *ap = ata_shost_to_port(shost);
enum link_pm policy = 0; enum link_pm policy = 0;
int i; int i;
@ -162,9 +163,9 @@ static ssize_t ata_scsi_lpm_put(struct class_device *class_dev,
} }
static ssize_t static ssize_t
ata_scsi_lpm_show(struct class_device *class_dev, char *buf) ata_scsi_lpm_show(struct device *dev, struct device_attribute *attr, char *buf)
{ {
struct Scsi_Host *shost = class_to_shost(class_dev); struct Scsi_Host *shost = class_to_shost(dev);
struct ata_port *ap = ata_shost_to_port(shost); struct ata_port *ap = ata_shost_to_port(shost);
const char *policy = const char *policy =
ata_scsi_lpm_get(ap->pm_policy); ata_scsi_lpm_get(ap->pm_policy);
@ -174,9 +175,9 @@ ata_scsi_lpm_show(struct class_device *class_dev, char *buf)
return snprintf(buf, 23, "%s\n", policy); return snprintf(buf, 23, "%s\n", policy);
} }
CLASS_DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR, DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
ata_scsi_lpm_show, ata_scsi_lpm_put); ata_scsi_lpm_show, ata_scsi_lpm_put);
EXPORT_SYMBOL_GPL(class_device_attr_link_power_management_policy); EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
static void ata_scsi_invalid_field(struct scsi_cmnd *cmd, static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *)) void (*done)(struct scsi_cmnd *))

77
drivers/base/attribute_container.c
View file

@ -27,21 +27,21 @@
struct internal_container { struct internal_container {
struct klist_node node; struct klist_node node;
struct attribute_container *cont; struct attribute_container *cont;
struct class_device classdev; struct device classdev;
}; };
static void internal_container_klist_get(struct klist_node *n) static void internal_container_klist_get(struct klist_node *n)
{ {
struct internal_container *ic = struct internal_container *ic =
container_of(n, struct internal_container, node); container_of(n, struct internal_container, node);
class_device_get(&ic->classdev); get_device(&ic->classdev);
} }
static void internal_container_klist_put(struct klist_node *n) static void internal_container_klist_put(struct klist_node *n)
{ {
struct internal_container *ic = struct internal_container *ic =
container_of(n, struct internal_container, node); container_of(n, struct internal_container, node);
class_device_put(&ic->classdev); put_device(&ic->classdev);
} }
@ -53,7 +53,7 @@ static void internal_container_klist_put(struct klist_node *n)
* Returns the container associated with this classdev. * Returns the container associated with this classdev.
*/ */
struct attribute_container * struct attribute_container *
attribute_container_classdev_to_container(struct class_device *classdev) attribute_container_classdev_to_container(struct device *classdev)
{ {
struct internal_container *ic = struct internal_container *ic =
container_of(classdev, struct internal_container, classdev); container_of(classdev, struct internal_container, classdev);
@ -110,11 +110,11 @@ attribute_container_unregister(struct attribute_container *cont)
EXPORT_SYMBOL_GPL(attribute_container_unregister); EXPORT_SYMBOL_GPL(attribute_container_unregister);
/* private function used as class release */ /* private function used as class release */
static void attribute_container_release(struct class_device *classdev) static void attribute_container_release(struct device *classdev)
{ {
struct internal_container *ic struct internal_container *ic
= container_of(classdev, struct internal_container, classdev); = container_of(classdev, struct internal_container, classdev);
struct device *dev = classdev->dev; struct device *dev = classdev->parent;
kfree(ic); kfree(ic);
put_device(dev); put_device(dev);
@ -129,12 +129,12 @@ static void attribute_container_release(struct class_device *classdev)
* This function allocates storage for the class device(s) to be * This function allocates storage for the class device(s) to be
* attached to dev (one for each matching attribute_container). If no * attached to dev (one for each matching attribute_container). If no
* fn is provided, the code will simply register the class device via * fn is provided, the code will simply register the class device via
* class_device_add. If a function is provided, it is expected to add * device_add. If a function is provided, it is expected to add
* the class device at the appropriate time. One of the things that * the class device at the appropriate time. One of the things that
* might be necessary is to allocate and initialise the classdev and * might be necessary is to allocate and initialise the classdev and
* then add it a later time. To do this, call this routine for * then add it a later time. To do this, call this routine for
* allocation and initialisation and then use * allocation and initialisation and then use
* attribute_container_device_trigger() to call class_device_add() on * attribute_container_device_trigger() to call device_add() on
* it. Note: after this, the class device contains a reference to dev * it. Note: after this, the class device contains a reference to dev
* which is not relinquished until the release of the classdev. * which is not relinquished until the release of the classdev.
*/ */
@ -142,7 +142,7 @@ void
attribute_container_add_device(struct device *dev, attribute_container_add_device(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)) struct device *))
{ {
struct attribute_container *cont; struct attribute_container *cont;
@ -163,11 +163,11 @@ attribute_container_add_device(struct device *dev,
} }
ic->cont = cont; ic->cont = cont;
class_device_initialize(&ic->classdev); device_initialize(&ic->classdev);
ic->classdev.dev = get_device(dev); ic->classdev.parent = get_device(dev);
ic->classdev.class = cont->class; ic->classdev.class = cont->class;
cont->class->release = attribute_container_release; cont->class->dev_release = attribute_container_release;
strcpy(ic->classdev.class_id, dev->bus_id); strcpy(ic->classdev.bus_id, dev->bus_id);
if (fn) if (fn)
fn(cont, dev, &ic->classdev); fn(cont, dev, &ic->classdev);
else else
@ -195,20 +195,19 @@ attribute_container_add_device(struct device *dev,
* @fn: A function to call to remove the device * @fn: A function to call to remove the device
* *
* This routine triggers device removal. If fn is NULL, then it is * This routine triggers device removal. If fn is NULL, then it is
* simply done via class_device_unregister (note that if something * simply done via device_unregister (note that if something
* still has a reference to the classdev, then the memory occupied * still has a reference to the classdev, then the memory occupied
* will not be freed until the classdev is released). If you want a * will not be freed until the classdev is released). If you want a
* two phase release: remove from visibility and then delete the * two phase release: remove from visibility and then delete the
* device, then you should use this routine with a fn that calls * device, then you should use this routine with a fn that calls
* class_device_del() and then use * device_del() and then use attribute_container_device_trigger()
* attribute_container_device_trigger() to do the final put on the * to do the final put on the classdev.
* classdev.
*/ */
void void
attribute_container_remove_device(struct device *dev, attribute_container_remove_device(struct device *dev,
void (*fn)(struct attribute_container *, void (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)) struct device *))
{ {
struct attribute_container *cont; struct attribute_container *cont;
@ -224,14 +223,14 @@ attribute_container_remove_device(struct device *dev,
continue; continue;
klist_for_each_entry(ic, &cont->containers, node, &iter) { klist_for_each_entry(ic, &cont->containers, node, &iter) {
if (dev != ic->classdev.dev) if (dev != ic->classdev.parent)
continue; continue;
klist_del(&ic->node); klist_del(&ic->node);
if (fn) if (fn)
fn(cont, dev, &ic->classdev); fn(cont, dev, &ic->classdev);
else { else {
attribute_container_remove_attrs(&ic->classdev); attribute_container_remove_attrs(&ic->classdev);
class_device_unregister(&ic->classdev); device_unregister(&ic->classdev);
} }
} }
} }
@ -252,7 +251,7 @@ void
attribute_container_device_trigger(struct device *dev, attribute_container_device_trigger(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)) struct device *))
{ {
struct attribute_container *cont; struct attribute_container *cont;
@ -270,7 +269,7 @@ attribute_container_device_trigger(struct device *dev,
} }
klist_for_each_entry(ic, &cont->containers, node, &iter) { klist_for_each_entry(ic, &cont->containers, node, &iter) {
if (dev == ic->classdev.dev) if (dev == ic->classdev.parent)
fn(cont, dev, &ic->classdev); fn(cont, dev, &ic->classdev);
} }
} }
@ -313,11 +312,11 @@ attribute_container_trigger(struct device *dev,
* attributes listed in the container * attributes listed in the container
*/ */
int int
attribute_container_add_attrs(struct class_device *classdev) attribute_container_add_attrs(struct device *classdev)
{ {
struct attribute_container *cont = struct attribute_container *cont =
attribute_container_classdev_to_container(classdev); attribute_container_classdev_to_container(classdev);
struct class_device_attribute **attrs = cont->attrs; struct device_attribute **attrs = cont->attrs;
int i, error; int i, error;
BUG_ON(attrs && cont->grp); BUG_ON(attrs && cont->grp);
@ -329,7 +328,7 @@ attribute_container_add_attrs(struct class_device *classdev)
return sysfs_create_group(&classdev->kobj, cont->grp); return sysfs_create_group(&classdev->kobj, cont->grp);
for (i = 0; attrs[i]; i++) { for (i = 0; attrs[i]; i++) {
error = class_device_create_file(classdev, attrs[i]); error = device_create_file(classdev, attrs[i]);
if (error) if (error)
return error; return error;
} }
@ -338,18 +337,18 @@ attribute_container_add_attrs(struct class_device *classdev)
} }
/** /**
* attribute_container_add_class_device - same function as class_device_add * attribute_container_add_class_device - same function as device_add
* *
* @classdev: the class device to add * @classdev: the class device to add
* *
* This performs essentially the same function as class_device_add except for * This performs essentially the same function as device_add except for
* attribute containers, namely add the classdev to the system and then * attribute containers, namely add the classdev to the system and then
* create the attribute files * create the attribute files
*/ */
int int
attribute_container_add_class_device(struct class_device *classdev) attribute_container_add_class_device(struct device *classdev)
{ {
int error = class_device_add(classdev); int error = device_add(classdev);
if (error) if (error)
return error; return error;
return attribute_container_add_attrs(classdev); return attribute_container_add_attrs(classdev);
@ -364,7 +363,7 @@ attribute_container_add_class_device(struct class_device *classdev)
int int
attribute_container_add_class_device_adapter(struct attribute_container *cont, attribute_container_add_class_device_adapter(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev) struct device *classdev)
{ {
return attribute_container_add_class_device(classdev); return attribute_container_add_class_device(classdev);
} }
@ -376,11 +375,11 @@ attribute_container_add_class_device_adapter(struct attribute_container *cont,
* *
*/ */
void void
attribute_container_remove_attrs(struct class_device *classdev) attribute_container_remove_attrs(struct device *classdev)
{ {
struct attribute_container *cont = struct attribute_container *cont =
attribute_container_classdev_to_container(classdev); attribute_container_classdev_to_container(classdev);
struct class_device_attribute **attrs = cont->attrs; struct device_attribute **attrs = cont->attrs;
int i; int i;
if (!attrs && !cont->grp) if (!attrs && !cont->grp)
@ -392,7 +391,7 @@ attribute_container_remove_attrs(struct class_device *classdev)
} }
for (i = 0; attrs[i]; i++) for (i = 0; attrs[i]; i++)
class_device_remove_file(classdev, attrs[i]); device_remove_file(classdev, attrs[i]);
} }
/** /**
@ -401,13 +400,13 @@ attribute_container_remove_attrs(struct class_device *classdev)
* @classdev: the class device * @classdev: the class device
* *
* This function simply removes all the attribute files and then calls * This function simply removes all the attribute files and then calls
* class_device_del. * device_del.
*/ */
void void
attribute_container_class_device_del(struct class_device *classdev) attribute_container_class_device_del(struct device *classdev)
{ {
attribute_container_remove_attrs(classdev); attribute_container_remove_attrs(classdev);
class_device_del(classdev); device_del(classdev);
} }
/** /**
@ -419,16 +418,16 @@ attribute_container_class_device_del(struct class_device *classdev)
* Looks up the device in the container's list of class devices and returns * Looks up the device in the container's list of class devices and returns
* the corresponding class_device. * the corresponding class_device.
*/ */
struct class_device * struct device *
attribute_container_find_class_device(struct attribute_container *cont, attribute_container_find_class_device(struct attribute_container *cont,
struct device *dev) struct device *dev)
{ {
struct class_device *cdev = NULL; struct device *cdev = NULL;
struct internal_container *ic; struct internal_container *ic;
struct klist_iter iter; struct klist_iter iter;
klist_for_each_entry(ic, &cont->containers, node, &iter) { klist_for_each_entry(ic, &cont->containers, node, &iter) {
if (ic->classdev.dev == dev) { if (ic->classdev.parent == dev) {
cdev = &ic->classdev; cdev = &ic->classdev;
/* FIXME: must exit iterator then break */ /* FIXME: must exit iterator then break */
klist_iter_exit(&iter); klist_iter_exit(&iter);

14
drivers/base/transport_class.c
View file

@ -66,7 +66,7 @@ EXPORT_SYMBOL_GPL(transport_class_unregister);
static int anon_transport_dummy_function(struct transport_container *tc, static int anon_transport_dummy_function(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
/* do nothing */ /* do nothing */
return 0; return 0;
@ -115,7 +115,7 @@ EXPORT_SYMBOL_GPL(anon_transport_class_unregister);
static int transport_setup_classdev(struct attribute_container *cont, static int transport_setup_classdev(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev) struct device *classdev)
{ {
struct transport_class *tclass = class_to_transport_class(cont->class); struct transport_class *tclass = class_to_transport_class(cont->class);
struct transport_container *tcont = attribute_container_to_transport_container(cont); struct transport_container *tcont = attribute_container_to_transport_container(cont);
@ -149,7 +149,7 @@ EXPORT_SYMBOL_GPL(transport_setup_device);
static int transport_add_class_device(struct attribute_container *cont, static int transport_add_class_device(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev) struct device *classdev)
{ {
int error = attribute_container_add_class_device(classdev); int error = attribute_container_add_class_device(classdev);
struct transport_container *tcont = struct transport_container *tcont =
@ -181,7 +181,7 @@ EXPORT_SYMBOL_GPL(transport_add_device);
static int transport_configure(struct attribute_container *cont, static int transport_configure(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct transport_class *tclass = class_to_transport_class(cont->class); struct transport_class *tclass = class_to_transport_class(cont->class);
struct transport_container *tcont = attribute_container_to_transport_container(cont); struct transport_container *tcont = attribute_container_to_transport_container(cont);
@ -212,7 +212,7 @@ EXPORT_SYMBOL_GPL(transport_configure_device);
static int transport_remove_classdev(struct attribute_container *cont, static int transport_remove_classdev(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev) struct device *classdev)
{ {
struct transport_container *tcont = struct transport_container *tcont =
attribute_container_to_transport_container(cont); attribute_container_to_transport_container(cont);
@ -251,12 +251,12 @@ EXPORT_SYMBOL_GPL(transport_remove_device);
static void transport_destroy_classdev(struct attribute_container *cont, static void transport_destroy_classdev(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev) struct device *classdev)
{ {
struct transport_class *tclass = class_to_transport_class(cont->class); struct transport_class *tclass = class_to_transport_class(cont->class);
if (tclass->remove != anon_transport_dummy_function) if (tclass->remove != anon_transport_dummy_function)
class_device_put(classdev); put_device(classdev);
} }

130
drivers/infiniband/ulp/srp/ib_srp.c
View file

@ -1458,9 +1458,10 @@ static int srp_reset_host(struct scsi_cmnd *scmnd)
return ret; return ret;
} }
static ssize_t show_id_ext(struct class_device *cdev, char *buf) static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1470,9 +1471,10 @@ static ssize_t show_id_ext(struct class_device *cdev, char *buf)
(unsigned long long) be64_to_cpu(target->id_ext)); (unsigned long long) be64_to_cpu(target->id_ext));
} }
static ssize_t show_ioc_guid(struct class_device *cdev, char *buf) static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1482,9 +1484,10 @@ static ssize_t show_ioc_guid(struct class_device *cdev, char *buf)
(unsigned long long) be64_to_cpu(target->ioc_guid)); (unsigned long long) be64_to_cpu(target->ioc_guid));
} }
static ssize_t show_service_id(struct class_device *cdev, char *buf) static ssize_t show_service_id(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1494,9 +1497,10 @@ static ssize_t show_service_id(struct class_device *cdev, char *buf)
(unsigned long long) be64_to_cpu(target->service_id)); (unsigned long long) be64_to_cpu(target->service_id));
} }
static ssize_t show_pkey(struct class_device *cdev, char *buf) static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1505,9 +1509,10 @@ static ssize_t show_pkey(struct class_device *cdev, char *buf)
return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey)); return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
} }
static ssize_t show_dgid(struct class_device *cdev, char *buf) static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1524,9 +1529,10 @@ static ssize_t show_dgid(struct class_device *cdev, char *buf)
be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); be16_to_cpu(((__be16 *) target->path.dgid.raw)[7]));
} }
static ssize_t show_orig_dgid(struct class_device *cdev, char *buf) static ssize_t show_orig_dgid(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1543,9 +1549,10 @@ static ssize_t show_orig_dgid(struct class_device *cdev, char *buf)
be16_to_cpu(target->orig_dgid[7])); be16_to_cpu(target->orig_dgid[7]));
} }
static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf) static ssize_t show_zero_req_lim(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
if (target->state == SRP_TARGET_DEAD || if (target->state == SRP_TARGET_DEAD ||
target->state == SRP_TARGET_REMOVED) target->state == SRP_TARGET_REMOVED)
@ -1554,40 +1561,42 @@ static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf)
return sprintf(buf, "%d\n", target->zero_req_lim); return sprintf(buf, "%d\n", target->zero_req_lim);
} }
static ssize_t show_local_ib_port(struct class_device *cdev, char *buf) static ssize_t show_local_ib_port(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
return sprintf(buf, "%d\n", target->srp_host->port); return sprintf(buf, "%d\n", target->srp_host->port);
} }
static ssize_t show_local_ib_device(struct class_device *cdev, char *buf) static ssize_t show_local_ib_device(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct srp_target_port *target = host_to_target(class_to_shost(cdev)); struct srp_target_port *target = host_to_target(class_to_shost(dev));
return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name); return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
} }
static CLASS_DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL);
static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL);
static CLASS_DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL);
static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL);
static CLASS_DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL);
static CLASS_DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL);
static CLASS_DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL);
static CLASS_DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
static struct class_device_attribute *srp_host_attrs[] = { static struct device_attribute *srp_host_attrs[] = {
&class_device_attr_id_ext, &dev_attr_id_ext,
&class_device_attr_ioc_guid, &dev_attr_ioc_guid,
&class_device_attr_service_id, &dev_attr_service_id,
&class_device_attr_pkey, &dev_attr_pkey,
&class_device_attr_dgid, &dev_attr_dgid,
&class_device_attr_orig_dgid, &dev_attr_orig_dgid,
&class_device_attr_zero_req_lim, &dev_attr_zero_req_lim,
&class_device_attr_local_ib_port, &dev_attr_local_ib_port,
&class_device_attr_local_ib_device, &dev_attr_local_ib_device,
NULL NULL
}; };
@ -1639,17 +1648,17 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
return 0; return 0;
} }
static void srp_release_class_dev(struct class_device *class_dev) static void srp_release_dev(struct device *dev)
{ {
struct srp_host *host = struct srp_host *host =
container_of(class_dev, struct srp_host, class_dev); container_of(dev, struct srp_host, dev);
complete(&host->released); complete(&host->released);
} }
static struct class srp_class = { static struct class srp_class = {
.name = "infiniband_srp", .name = "infiniband_srp",
.release = srp_release_class_dev .dev_release = srp_release_dev
}; };
/* /*
@ -1837,11 +1846,12 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
return ret; return ret;
} }
static ssize_t srp_create_target(struct class_device *class_dev, static ssize_t srp_create_target(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count) const char *buf, size_t count)
{ {
struct srp_host *host = struct srp_host *host =
container_of(class_dev, struct srp_host, class_dev); container_of(dev, struct srp_host, dev);
struct Scsi_Host *target_host; struct Scsi_Host *target_host;
struct srp_target_port *target; struct srp_target_port *target;
int ret; int ret;
@ -1929,27 +1939,27 @@ static ssize_t srp_create_target(struct class_device *class_dev,
return ret; return ret;
} }
static CLASS_DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
static ssize_t show_ibdev(struct class_device *class_dev, char *buf) static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_host *host = struct srp_host *host = container_of(dev, struct srp_host, dev);
container_of(class_dev, struct srp_host, class_dev);
return sprintf(buf, "%s\n", host->srp_dev->dev->name); return sprintf(buf, "%s\n", host->srp_dev->dev->name);
} }
static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
static ssize_t show_port(struct class_device *class_dev, char *buf) static ssize_t show_port(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct srp_host *host = struct srp_host *host = container_of(dev, struct srp_host, dev);
container_of(class_dev, struct srp_host, class_dev);
return sprintf(buf, "%d\n", host->port); return sprintf(buf, "%d\n", host->port);
} }
static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
static struct srp_host *srp_add_port(struct srp_device *device, u8 port) static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
{ {
@ -1965,24 +1975,24 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
host->srp_dev = device; host->srp_dev = device;
host->port = port; host->port = port;
host->class_dev.class = &srp_class; host->dev.class = &srp_class;
host->class_dev.dev = device->dev->dma_device; host->dev.parent = device->dev->dma_device;
snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d", snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d",
device->dev->name, port); device->dev->name, port);
if (class_device_register(&host->class_dev)) if (device_register(&host->dev))
goto free_host; goto free_host;
if (class_device_create_file(&host->class_dev, &class_device_attr_add_target)) if (device_create_file(&host->dev, &dev_attr_add_target))
goto err_class; goto err_class;
if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev)) if (device_create_file(&host->dev, &dev_attr_ibdev))
goto err_class; goto err_class;
if (class_device_create_file(&host->class_dev, &class_device_attr_port)) if (device_create_file(&host->dev, &dev_attr_port))
goto err_class; goto err_class;
return host; return host;
err_class: err_class:
class_device_unregister(&host->class_dev); device_unregister(&host->dev);
free_host: free_host:
kfree(host); kfree(host);
@ -2087,7 +2097,7 @@ static void srp_remove_one(struct ib_device *device)
srp_dev = ib_get_client_data(device, &srp_client); srp_dev = ib_get_client_data(device, &srp_client);
list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
class_device_unregister(&host->class_dev); device_unregister(&host->dev);
/* /*
* Wait for the sysfs entry to go away, so that no new * Wait for the sysfs entry to go away, so that no new
* target ports can be created. * target ports can be created.

2
drivers/infiniband/ulp/srp/ib_srp.h
View file

@ -99,7 +99,7 @@ struct srp_device {
struct srp_host { struct srp_host {
struct srp_device *srp_dev; struct srp_device *srp_dev;
u8 port; u8 port;
struct class_device class_dev; struct device dev;
struct list_head target_list; struct list_head target_list;
spinlock_t target_lock; spinlock_t target_lock;
struct completion released; struct completion released;

120
drivers/message/fusion/mptscsih.c
View file

@ -3300,9 +3300,10 @@ mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
} }
static ssize_t static ssize_t
mptscsih_version_fw_show(struct class_device *cdev, char *buf) mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
@ -3312,12 +3313,13 @@ mptscsih_version_fw_show(struct class_device *cdev, char *buf)
(ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
ioc->facts.FWVersion.Word & 0x000000FF); ioc->facts.FWVersion.Word & 0x000000FF);
} }
static CLASS_DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL); static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
static ssize_t static ssize_t
mptscsih_version_bios_show(struct class_device *cdev, char *buf) mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
@ -3327,129 +3329,141 @@ mptscsih_version_bios_show(struct class_device *cdev, char *buf)
(ioc->biosVersion & 0x0000FF00) >> 8, (ioc->biosVersion & 0x0000FF00) >> 8,
ioc->biosVersion & 0x000000FF); ioc->biosVersion & 0x000000FF);
} }
static CLASS_DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL); static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
static ssize_t static ssize_t
mptscsih_version_mpi_show(struct class_device *cdev, char *buf) mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion); return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
} }
static CLASS_DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL); static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
static ssize_t static ssize_t
mptscsih_version_product_show(struct class_device *cdev, char *buf) mptscsih_version_product_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name); return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
} }
static CLASS_DEVICE_ATTR(version_product, S_IRUGO, static DEVICE_ATTR(version_product, S_IRUGO,
mptscsih_version_product_show, NULL); mptscsih_version_product_show, NULL);
static ssize_t static ssize_t
mptscsih_version_nvdata_persistent_show(struct class_device *cdev, char *buf) mptscsih_version_nvdata_persistent_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%02xh\n", return snprintf(buf, PAGE_SIZE, "%02xh\n",
ioc->nvdata_version_persistent); ioc->nvdata_version_persistent);
} }
static CLASS_DEVICE_ATTR(version_nvdata_persistent, S_IRUGO, static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
mptscsih_version_nvdata_persistent_show, NULL); mptscsih_version_nvdata_persistent_show, NULL);
static ssize_t static ssize_t
mptscsih_version_nvdata_default_show(struct class_device *cdev, char *buf) mptscsih_version_nvdata_default_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default); return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
} }
static CLASS_DEVICE_ATTR(version_nvdata_default, S_IRUGO, static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
mptscsih_version_nvdata_default_show, NULL); mptscsih_version_nvdata_default_show, NULL);
static ssize_t static ssize_t
mptscsih_board_name_show(struct class_device *cdev, char *buf) mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name); return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
} }
static CLASS_DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL); static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
static ssize_t static ssize_t
mptscsih_board_assembly_show(struct class_device *cdev, char *buf) mptscsih_board_assembly_show(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly); return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
} }
static CLASS_DEVICE_ATTR(board_assembly, S_IRUGO, static DEVICE_ATTR(board_assembly, S_IRUGO,
mptscsih_board_assembly_show, NULL); mptscsih_board_assembly_show, NULL);
static ssize_t static ssize_t
mptscsih_board_tracer_show(struct class_device *cdev, char *buf) mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer); return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
} }
static CLASS_DEVICE_ATTR(board_tracer, S_IRUGO, static DEVICE_ATTR(board_tracer, S_IRUGO,
mptscsih_board_tracer_show, NULL); mptscsih_board_tracer_show, NULL);
static ssize_t static ssize_t
mptscsih_io_delay_show(struct class_device *cdev, char *buf) mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
} }
static CLASS_DEVICE_ATTR(io_delay, S_IRUGO, static DEVICE_ATTR(io_delay, S_IRUGO,
mptscsih_io_delay_show, NULL); mptscsih_io_delay_show, NULL);
static ssize_t static ssize_t
mptscsih_device_delay_show(struct class_device *cdev, char *buf) mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
} }
static CLASS_DEVICE_ATTR(device_delay, S_IRUGO, static DEVICE_ATTR(device_delay, S_IRUGO,
mptscsih_device_delay_show, NULL); mptscsih_device_delay_show, NULL);
static ssize_t static ssize_t
mptscsih_debug_level_show(struct class_device *cdev, char *buf) mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level); return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
} }
static ssize_t static ssize_t
mptscsih_debug_level_store(struct class_device *cdev, const char *buf, mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
size_t count) const char *buf, size_t count)
{ {
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
MPT_SCSI_HOST *hd = shost_priv(host); MPT_SCSI_HOST *hd = shost_priv(host);
MPT_ADAPTER *ioc = hd->ioc; MPT_ADAPTER *ioc = hd->ioc;
int val = 0; int val = 0;
@ -3462,22 +3476,22 @@ mptscsih_debug_level_store(struct class_device *cdev, const char *buf,
ioc->name, ioc->debug_level); ioc->name, ioc->debug_level);
return strlen(buf); return strlen(buf);
} }
static CLASS_DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR, static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
mptscsih_debug_level_show, mptscsih_debug_level_store); mptscsih_debug_level_show, mptscsih_debug_level_store);
struct class_device_attribute *mptscsih_host_attrs[] = { struct device_attribute *mptscsih_host_attrs[] = {
&class_device_attr_version_fw, &dev_attr_version_fw,
&class_device_attr_version_bios, &dev_attr_version_bios,
&class_device_attr_version_mpi, &dev_attr_version_mpi,
&class_device_attr_version_product, &dev_attr_version_product,
&class_device_attr_version_nvdata_persistent, &dev_attr_version_nvdata_persistent,
&class_device_attr_version_nvdata_default, &dev_attr_version_nvdata_default,
&class_device_attr_board_name, &dev_attr_board_name,
&class_device_attr_board_assembly, &dev_attr_board_assembly,
&class_device_attr_board_tracer, &dev_attr_board_tracer,
&class_device_attr_io_delay, &dev_attr_io_delay,
&class_device_attr_device_delay, &dev_attr_device_delay,
&class_device_attr_debug_level, &dev_attr_debug_level,
NULL, NULL,
}; };
EXPORT_SYMBOL(mptscsih_host_attrs); EXPORT_SYMBOL(mptscsih_host_attrs);

2
drivers/message/fusion/mptscsih.h
View file

@ -129,4 +129,4 @@ extern void mptscsih_timer_expired(unsigned long data);
extern int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout); extern int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id); extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id); extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
extern struct class_device_attribute *mptscsih_host_attrs[]; extern struct device_attribute *mptscsih_host_attrs[];

118
drivers/misc/enclosure.c
View file

@ -40,16 +40,16 @@ static struct class enclosure_component_class;
* Looks through the list of registered enclosures to see * Looks through the list of registered enclosures to see
* if it can find a match for a device. Returns NULL if no * if it can find a match for a device. Returns NULL if no
* enclosure is found. Obtains a reference to the enclosure class * enclosure is found. Obtains a reference to the enclosure class
* device which must be released with class_device_put(). * device which must be released with device_put().
*/ */
struct enclosure_device *enclosure_find(struct device *dev) struct enclosure_device *enclosure_find(struct device *dev)
{ {
struct enclosure_device *edev = NULL; struct enclosure_device *edev;
mutex_lock(&container_list_lock); mutex_lock(&container_list_lock);
list_for_each_entry(edev, &container_list, node) { list_for_each_entry(edev, &container_list, node) {
if (edev->cdev.dev == dev) { if (edev->edev.parent == dev) {
class_device_get(&edev->cdev); get_device(&edev->edev);
mutex_unlock(&container_list_lock); mutex_unlock(&container_list_lock);
return edev; return edev;
} }
@ -117,11 +117,11 @@ enclosure_register(struct device *dev, const char *name, int components,
edev->components = components; edev->components = components;
edev->cdev.class = &enclosure_class; edev->edev.class = &enclosure_class;
edev->cdev.dev = get_device(dev); edev->edev.parent = get_device(dev);
edev->cb = cb; edev->cb = cb;
snprintf(edev->cdev.class_id, BUS_ID_SIZE, "%s", name); snprintf(edev->edev.bus_id, BUS_ID_SIZE, "%s", name);
err = class_device_register(&edev->cdev); err = device_register(&edev->edev);
if (err) if (err)
goto err; goto err;
@ -135,7 +135,7 @@ enclosure_register(struct device *dev, const char *name, int components,
return edev; return edev;
err: err:
put_device(edev->cdev.dev); put_device(edev->edev.parent);
kfree(edev); kfree(edev);
return ERR_PTR(err); return ERR_PTR(err);
} }
@ -158,27 +158,28 @@ void enclosure_unregister(struct enclosure_device *edev)
for (i = 0; i < edev->components; i++) for (i = 0; i < edev->components; i++)
if (edev->component[i].number != -1) if (edev->component[i].number != -1)
class_device_unregister(&edev->component[i].cdev); device_unregister(&edev->component[i].cdev);
/* prevent any callbacks into service user */ /* prevent any callbacks into service user */
edev->cb = &enclosure_null_callbacks; edev->cb = &enclosure_null_callbacks;
class_device_unregister(&edev->cdev); device_unregister(&edev->edev);
} }
EXPORT_SYMBOL_GPL(enclosure_unregister); EXPORT_SYMBOL_GPL(enclosure_unregister);
static void enclosure_release(struct class_device *cdev) static void enclosure_release(struct device *cdev)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev); struct enclosure_device *edev = to_enclosure_device(cdev);
put_device(cdev->dev); put_device(cdev->parent);
kfree(edev); kfree(edev);
} }
static void enclosure_component_release(struct class_device *cdev) static void enclosure_component_release(struct device *dev)
{ {
if (cdev->dev) struct enclosure_component *cdev = to_enclosure_component(dev);
put_device(cdev->dev);
class_device_put(cdev->parent); put_device(cdev->dev);
put_device(dev->parent);
} }
/** /**
@ -201,7 +202,7 @@ enclosure_component_register(struct enclosure_device *edev,
const char *name) const char *name)
{ {
struct enclosure_component *ecomp; struct enclosure_component *ecomp;
struct class_device *cdev; struct device *cdev;
int err; int err;
if (number >= edev->components) if (number >= edev->components)
@ -215,14 +216,14 @@ enclosure_component_register(struct enclosure_device *edev,
ecomp->type = type; ecomp->type = type;
ecomp->number = number; ecomp->number = number;
cdev = &ecomp->cdev; cdev = &ecomp->cdev;
cdev->parent = class_device_get(&edev->cdev); cdev->parent = get_device(&edev->edev);
cdev->class = &enclosure_component_class; cdev->class = &enclosure_component_class;
if (name) if (name)
snprintf(cdev->class_id, BUS_ID_SIZE, "%s", name); snprintf(cdev->bus_id, BUS_ID_SIZE, "%s", name);
else else
snprintf(cdev->class_id, BUS_ID_SIZE, "%u", number); snprintf(cdev->bus_id, BUS_ID_SIZE, "%u", number);
err = class_device_register(cdev); err = device_register(cdev);
if (err) if (err)
ERR_PTR(err); ERR_PTR(err);
@ -247,18 +248,17 @@ EXPORT_SYMBOL_GPL(enclosure_component_register);
int enclosure_add_device(struct enclosure_device *edev, int component, int enclosure_add_device(struct enclosure_device *edev, int component,
struct device *dev) struct device *dev)
{ {
struct class_device *cdev; struct enclosure_component *cdev;
if (!edev || component >= edev->components) if (!edev || component >= edev->components)
return -EINVAL; return -EINVAL;
cdev = &edev->component[component].cdev; cdev = &edev->component[component];
class_device_del(cdev); device_del(&cdev->cdev);
if (cdev->dev) put_device(cdev->dev);
put_device(cdev->dev);
cdev->dev = get_device(dev); cdev->dev = get_device(dev);
return class_device_add(cdev); return device_add(&cdev->cdev);
} }
EXPORT_SYMBOL_GPL(enclosure_add_device); EXPORT_SYMBOL_GPL(enclosure_add_device);
@ -272,18 +272,17 @@ EXPORT_SYMBOL_GPL(enclosure_add_device);
*/ */
int enclosure_remove_device(struct enclosure_device *edev, int component) int enclosure_remove_device(struct enclosure_device *edev, int component)
{ {
struct class_device *cdev; struct enclosure_component *cdev;
if (!edev || component >= edev->components) if (!edev || component >= edev->components)
return -EINVAL; return -EINVAL;
cdev = &edev->component[component].cdev; cdev = &edev->component[component];
class_device_del(cdev); device_del(&cdev->cdev);
if (cdev->dev) put_device(cdev->dev);
put_device(cdev->dev);
cdev->dev = NULL; cdev->dev = NULL;
return class_device_add(cdev); return device_add(&cdev->cdev);
} }
EXPORT_SYMBOL_GPL(enclosure_remove_device); EXPORT_SYMBOL_GPL(enclosure_remove_device);
@ -291,14 +290,16 @@ EXPORT_SYMBOL_GPL(enclosure_remove_device);
* sysfs pieces below * sysfs pieces below
*/ */
static ssize_t enclosure_show_components(struct class_device *cdev, char *buf) static ssize_t enclosure_show_components(struct device *cdev,
struct device_attribute *attr,
char *buf)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev); struct enclosure_device *edev = to_enclosure_device(cdev);
return snprintf(buf, 40, "%d\n", edev->components); return snprintf(buf, 40, "%d\n", edev->components);
} }
static struct class_device_attribute enclosure_attrs[] = { static struct device_attribute enclosure_attrs[] = {
__ATTR(components, S_IRUGO, enclosure_show_components, NULL), __ATTR(components, S_IRUGO, enclosure_show_components, NULL),
__ATTR_NULL __ATTR_NULL
}; };
@ -306,8 +307,8 @@ static struct class_device_attribute enclosure_attrs[] = {
static struct class enclosure_class = { static struct class enclosure_class = {
.name = "enclosure", .name = "enclosure",
.owner = THIS_MODULE, .owner = THIS_MODULE,
.release = enclosure_release, .dev_release = enclosure_release,
.class_dev_attrs = enclosure_attrs, .dev_attrs = enclosure_attrs,
}; };
static const char *const enclosure_status [] = { static const char *const enclosure_status [] = {
@ -326,7 +327,8 @@ static const char *const enclosure_type [] = {
[ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device", [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device",
}; };
static ssize_t get_component_fault(struct class_device *cdev, char *buf) static ssize_t get_component_fault(struct device *cdev,
struct device_attribute *attr, char *buf)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -336,8 +338,9 @@ static ssize_t get_component_fault(struct class_device *cdev, char *buf)
return snprintf(buf, 40, "%d\n", ecomp->fault); return snprintf(buf, 40, "%d\n", ecomp->fault);
} }
static ssize_t set_component_fault(struct class_device *cdev, const char *buf, static ssize_t set_component_fault(struct device *cdev,
size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -348,7 +351,8 @@ static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
return count; return count;
} }
static ssize_t get_component_status(struct class_device *cdev, char *buf) static ssize_t get_component_status(struct device *cdev,
struct device_attribute *attr,char *buf)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -358,8 +362,9 @@ static ssize_t get_component_status(struct class_device *cdev, char *buf)
return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]); return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]);
} }
static ssize_t set_component_status(struct class_device *cdev, const char *buf, static ssize_t set_component_status(struct device *cdev,
size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -380,7 +385,8 @@ static ssize_t set_component_status(struct class_device *cdev, const char *buf,
return -EINVAL; return -EINVAL;
} }
static ssize_t get_component_active(struct class_device *cdev, char *buf) static ssize_t get_component_active(struct device *cdev,
struct device_attribute *attr, char *buf)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -390,8 +396,9 @@ static ssize_t get_component_active(struct class_device *cdev, char *buf)
return snprintf(buf, 40, "%d\n", ecomp->active); return snprintf(buf, 40, "%d\n", ecomp->active);
} }
static ssize_t set_component_active(struct class_device *cdev, const char *buf, static ssize_t set_component_active(struct device *cdev,
size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -402,7 +409,8 @@ static ssize_t set_component_active(struct class_device *cdev, const char *buf,
return count; return count;
} }
static ssize_t get_component_locate(struct class_device *cdev, char *buf) static ssize_t get_component_locate(struct device *cdev,
struct device_attribute *attr, char *buf)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -412,8 +420,9 @@ static ssize_t get_component_locate(struct class_device *cdev, char *buf)
return snprintf(buf, 40, "%d\n", ecomp->locate); return snprintf(buf, 40, "%d\n", ecomp->locate);
} }
static ssize_t set_component_locate(struct class_device *cdev, const char *buf, static ssize_t set_component_locate(struct device *cdev,
size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct enclosure_device *edev = to_enclosure_device(cdev->parent); struct enclosure_device *edev = to_enclosure_device(cdev->parent);
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -424,7 +433,8 @@ static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
return count; return count;
} }
static ssize_t get_component_type(struct class_device *cdev, char *buf) static ssize_t get_component_type(struct device *cdev,
struct device_attribute *attr, char *buf)
{ {
struct enclosure_component *ecomp = to_enclosure_component(cdev); struct enclosure_component *ecomp = to_enclosure_component(cdev);
@ -432,7 +442,7 @@ static ssize_t get_component_type(struct class_device *cdev, char *buf)
} }
static struct class_device_attribute enclosure_component_attrs[] = { static struct device_attribute enclosure_component_attrs[] = {
__ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault, __ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
set_component_fault), set_component_fault),
__ATTR(status, S_IRUGO | S_IWUSR, get_component_status, __ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
@ -448,8 +458,8 @@ static struct class_device_attribute enclosure_component_attrs[] = {
static struct class enclosure_component_class = { static struct class enclosure_component_class = {
.name = "enclosure_component", .name = "enclosure_component",
.owner = THIS_MODULE, .owner = THIS_MODULE,
.class_dev_attrs = enclosure_component_attrs, .dev_attrs = enclosure_component_attrs,
.release = enclosure_component_release, .dev_release = enclosure_component_release,
}; };
static int __init enclosure_init(void) static int __init enclosure_init(void)

9
drivers/scsi/3w-9xxx.c
View file

@ -140,9 +140,10 @@ static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
/* Functions */ /* Functions */
/* Show some statistics about the card */ /* 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; TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
unsigned long flags = 0; unsigned long flags = 0;
ssize_t len; 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() */ } /* End twa_change_queue_depth() */
/* Create sysfs 'stats' entry */ /* Create sysfs 'stats' entry */
static struct class_device_attribute twa_host_stats_attr = { static struct device_attribute twa_host_stats_attr = {
.attr = { .attr = {
.name = "stats", .name = "stats",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -193,7 +194,7 @@ static struct class_device_attribute twa_host_stats_attr = {
}; };
/* Host attributes initializer */ /* Host attributes initializer */
static struct class_device_attribute *twa_host_attrs[] = { static struct device_attribute *twa_host_attrs[] = {
&twa_host_stats_attr, &twa_host_stats_attr,
NULL, NULL,
}; };

9
drivers/scsi/3w-xxxx.c
View file

@ -484,9 +484,10 @@ static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
} /* End tw_state_request_start() */ } /* End tw_state_request_start() */
/* Show some statistics about the card */ /* 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; TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
unsigned long flags = 0; unsigned long flags = 0;
ssize_t len; 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() */ } /* End tw_change_queue_depth() */
/* Create sysfs 'stats' entry */ /* Create sysfs 'stats' entry */
static struct class_device_attribute tw_host_stats_attr = { static struct device_attribute tw_host_stats_attr = {
.attr = { .attr = {
.name = "stats", .name = "stats",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -537,7 +538,7 @@ static struct class_device_attribute tw_host_stats_attr = {
}; };
/* Host attributes initializer */ /* Host attributes initializer */
static struct class_device_attribute *tw_host_attrs[] = { static struct device_attribute *tw_host_attrs[] = {
&tw_host_stats_attr, &tw_host_stats_attr,
NULL, NULL,
}; };

2
drivers/scsi/aacraid/aachba.c
View file

@ -1316,7 +1316,7 @@ int aac_get_adapter_info(struct aac_dev* dev)
tmp>>24,(tmp>>16)&0xff,tmp&0xff, tmp>>24,(tmp>>16)&0xff,tmp&0xff,
le32_to_cpu(dev->adapter_info.biosbuild)); le32_to_cpu(dev->adapter_info.biosbuild));
buffer[0] = '\0'; buffer[0] = '\0';
if (aac_show_serial_number( if (aac_get_serial_number(
shost_to_class(dev->scsi_host_ptr), buffer)) shost_to_class(dev->scsi_host_ptr), buffer))
printk(KERN_INFO "%s%d: serial %s", printk(KERN_INFO "%s%d: serial %s",
dev->name, dev->id, buffer); dev->name, dev->id, buffer);

4
drivers/scsi/aacraid/aacraid.h
View file

@ -1850,9 +1850,9 @@ int aac_get_containers(struct aac_dev *dev);
int aac_scsi_cmd(struct scsi_cmnd *cmd); int aac_scsi_cmd(struct scsi_cmnd *cmd);
int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg); int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg);
#ifndef shost_to_class #ifndef shost_to_class
#define shost_to_class(shost) &shost->shost_classdev #define shost_to_class(shost) &shost->shost_dev
#endif #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_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg);
int aac_rx_init(struct aac_dev *dev); int aac_rx_init(struct aac_dev *dev);
int aac_rkt_init(struct aac_dev *dev); int aac_rkt_init(struct aac_dev *dev);

93
drivers/scsi/aacraid/linit.c
View file

@ -755,10 +755,10 @@ static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long
} }
#endif #endif
static ssize_t aac_show_model(struct class_device *class_dev, static ssize_t aac_show_model(struct device *device,
char *buf) 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; int len;
if (dev->supplement_adapter_info.AdapterTypeText[0]) { if (dev->supplement_adapter_info.AdapterTypeText[0]) {
@ -774,10 +774,10 @@ static ssize_t aac_show_model(struct class_device *class_dev,
return len; return len;
} }
static ssize_t aac_show_vendor(struct class_device *class_dev, static ssize_t aac_show_vendor(struct device *device,
char *buf) 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; int len;
if (dev->supplement_adapter_info.AdapterTypeText[0]) { if (dev->supplement_adapter_info.AdapterTypeText[0]) {
@ -793,10 +793,11 @@ static ssize_t aac_show_vendor(struct class_device *class_dev,
return len; 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; 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))) if (nblank(dprintk(x)))
len = snprintf(buf, PAGE_SIZE, "dprintk\n"); 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; return len;
} }
static ssize_t aac_show_kernel_version(struct class_device *class_dev, static ssize_t aac_show_kernel_version(struct device *device,
char *buf) 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; int len, tmp;
tmp = le32_to_cpu(dev->adapter_info.kernelrev); 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; return len;
} }
static ssize_t aac_show_monitor_version(struct class_device *class_dev, static ssize_t aac_show_monitor_version(struct device *device,
char *buf) 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; int len, tmp;
tmp = le32_to_cpu(dev->adapter_info.monitorrev); 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; return len;
} }
static ssize_t aac_show_bios_version(struct class_device *class_dev, static ssize_t aac_show_bios_version(struct device *device,
char *buf) 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; int len, tmp;
tmp = le32_to_cpu(dev->adapter_info.biosrev); 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; 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; int len = 0;
if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) 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; 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", 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", 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, static ssize_t aac_store_reset_adapter(struct device *device,
const char *buf, size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
int retval = -EACCES; int retval = -EACCES;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return retval; 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) if (retval >= 0)
retval = count; retval = count;
return retval; return retval;
} }
static ssize_t aac_show_reset_adapter(struct class_device *class_dev, static ssize_t aac_show_reset_adapter(struct device *device,
char *buf) 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; int len, tmp;
tmp = aac_adapter_check_health(dev); tmp = aac_adapter_check_health(dev);
@ -907,70 +916,70 @@ static ssize_t aac_show_reset_adapter(struct class_device *class_dev,
return len; return len;
} }
static struct class_device_attribute aac_model = { static struct device_attribute aac_model = {
.attr = { .attr = {
.name = "model", .name = "model",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_model, .show = aac_show_model,
}; };
static struct class_device_attribute aac_vendor = { static struct device_attribute aac_vendor = {
.attr = { .attr = {
.name = "vendor", .name = "vendor",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_vendor, .show = aac_show_vendor,
}; };
static struct class_device_attribute aac_flags = { static struct device_attribute aac_flags = {
.attr = { .attr = {
.name = "flags", .name = "flags",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_flags, .show = aac_show_flags,
}; };
static struct class_device_attribute aac_kernel_version = { static struct device_attribute aac_kernel_version = {
.attr = { .attr = {
.name = "hba_kernel_version", .name = "hba_kernel_version",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_kernel_version, .show = aac_show_kernel_version,
}; };
static struct class_device_attribute aac_monitor_version = { static struct device_attribute aac_monitor_version = {
.attr = { .attr = {
.name = "hba_monitor_version", .name = "hba_monitor_version",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_monitor_version, .show = aac_show_monitor_version,
}; };
static struct class_device_attribute aac_bios_version = { static struct device_attribute aac_bios_version = {
.attr = { .attr = {
.name = "hba_bios_version", .name = "hba_bios_version",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_bios_version, .show = aac_show_bios_version,
}; };
static struct class_device_attribute aac_serial_number = { static struct device_attribute aac_serial_number = {
.attr = { .attr = {
.name = "serial_number", .name = "serial_number",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_serial_number, .show = aac_show_serial_number,
}; };
static struct class_device_attribute aac_max_channel = { static struct device_attribute aac_max_channel = {
.attr = { .attr = {
.name = "max_channel", .name = "max_channel",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_max_channel, .show = aac_show_max_channel,
}; };
static struct class_device_attribute aac_max_id = { static struct device_attribute aac_max_id = {
.attr = { .attr = {
.name = "max_id", .name = "max_id",
.mode = S_IRUGO, .mode = S_IRUGO,
}, },
.show = aac_show_max_id, .show = aac_show_max_id,
}; };
static struct class_device_attribute aac_reset = { static struct device_attribute aac_reset = {
.attr = { .attr = {
.name = "reset_host", .name = "reset_host",
.mode = S_IWUSR|S_IRUGO, .mode = S_IWUSR|S_IRUGO,
@ -979,7 +988,7 @@ static struct class_device_attribute aac_reset = {
.show = aac_show_reset_adapter, .show = aac_show_reset_adapter,
}; };
static struct class_device_attribute *aac_attrs[] = { static struct device_attribute *aac_attrs[] = {
&aac_model, &aac_model,
&aac_vendor, &aac_vendor,
&aac_flags, &aac_flags,
@ -993,6 +1002,10 @@ static struct class_device_attribute *aac_attrs[] = {
NULL 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 = { static const struct file_operations aac_cfg_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,

4
drivers/scsi/arcmsr/arcmsr.h
View file

@ -44,7 +44,7 @@
*/ */
#include <linux/interrupt.h> #include <linux/interrupt.h>
struct class_device_attribute; struct device_attribute;
/*The limit of outstanding scsi command that firmware can handle*/ /*The limit of outstanding scsi command that firmware can handle*/
#define ARCMSR_MAX_OUTSTANDING_CMD 256 #define ARCMSR_MAX_OUTSTANDING_CMD 256
#define ARCMSR_MAX_FREECCB_NUM 320 #define ARCMSR_MAX_FREECCB_NUM 320
@ -556,6 +556,6 @@ struct SENSE_DATA
extern void arcmsr_post_ioctldata2iop(struct AdapterControlBlock *); extern void arcmsr_post_ioctldata2iop(struct AdapterControlBlock *);
extern void arcmsr_iop_message_read(struct AdapterControlBlock *); extern void arcmsr_iop_message_read(struct AdapterControlBlock *);
extern struct QBUFFER __iomem *arcmsr_get_iop_rqbuffer(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 *); extern int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *);
void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb); void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb);

161
drivers/scsi/arcmsr/arcmsr_attr.c
View file

@ -57,15 +57,15 @@
#include <scsi/scsi_transport.h> #include <scsi/scsi_transport.h>
#include "arcmsr.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, static ssize_t arcmsr_sysfs_iop_message_read(struct kobject *kobj,
struct bin_attribute *bin, struct bin_attribute *bin,
char *buf, loff_t off, char *buf, loff_t off,
size_t count) size_t count)
{ {
struct class_device *cdev = container_of(kobj,struct class_device,kobj); struct device *dev = container_of(kobj,struct device,kobj);
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
uint8_t *pQbuffer,*ptmpQbuffer; uint8_t *pQbuffer,*ptmpQbuffer;
int32_t allxfer_len = 0; 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, char *buf, loff_t off,
size_t count) size_t count)
{ {
struct class_device *cdev = container_of(kobj,struct class_device,kobj); struct device *dev = container_of(kobj,struct device,kobj);
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex; int32_t my_empty_len, user_len, wqbuf_firstindex, wqbuf_lastindex;
uint8_t *pQbuffer, *ptmpuserbuffer; uint8_t *pQbuffer, *ptmpuserbuffer;
@ -158,8 +158,8 @@ static ssize_t arcmsr_sysfs_iop_message_clear(struct kobject *kobj,
char *buf, loff_t off, char *buf, loff_t off,
size_t count) size_t count)
{ {
struct class_device *cdev = container_of(kobj,struct class_device,kobj); struct device *dev = container_of(kobj,struct device,kobj);
struct Scsi_Host *host = class_to_shost(cdev); struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
uint8_t *pQbuffer; uint8_t *pQbuffer;
@ -220,87 +220,104 @@ int arcmsr_alloc_sysfs_attr(struct AdapterControlBlock *acb)
struct Scsi_Host *host = acb->host; struct Scsi_Host *host = acb->host;
int error; 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) { if (error) {
printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n"); printk(KERN_ERR "arcmsr: alloc sysfs mu_read failed\n");
goto error_bin_file_message_read; 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) { if (error) {
printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n"); printk(KERN_ERR "arcmsr: alloc sysfs mu_write failed\n");
goto error_bin_file_message_write; 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) { if (error) {
printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n"); printk(KERN_ERR "arcmsr: alloc sysfs mu_clear failed\n");
goto error_bin_file_message_clear; goto error_bin_file_message_clear;
} }
return 0; return 0;
error_bin_file_message_clear: 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: 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: error_bin_file_message_read:
return error; return error;
} }
void void arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb)
arcmsr_free_sysfs_attr(struct AdapterControlBlock *acb) { {
struct Scsi_Host *host = acb->host; 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_dev.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_dev.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_read_attr);
} }
static ssize_t 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, return snprintf(buf, PAGE_SIZE,
"%s\n", "%s\n",
ARCMSR_DRIVER_VERSION); ARCMSR_DRIVER_VERSION);
} }
static ssize_t static ssize_t
arcmsr_attr_host_driver_posted_cmd(struct class_device *cdev, char *buf) { arcmsr_attr_host_driver_posted_cmd(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
atomic_read(&acb->ccboutstandingcount)); atomic_read(&acb->ccboutstandingcount));
} }
static ssize_t static ssize_t
arcmsr_attr_host_driver_reset(struct class_device *cdev, char *buf) { arcmsr_attr_host_driver_reset(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
acb->num_resets); acb->num_resets);
} }
static ssize_t static ssize_t
arcmsr_attr_host_driver_abort(struct class_device *cdev, char *buf) { arcmsr_attr_host_driver_abort(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
acb->num_aborts); acb->num_aborts);
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_model(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_model(struct device *dev, struct device_attribute *attr,
struct Scsi_Host *host = class_to_shost(cdev); char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%s\n", "%s\n",
acb->firm_model); acb->firm_model);
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_version(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%s\n", "%s\n",
@ -308,9 +325,12 @@ arcmsr_attr_host_fw_version(struct class_device *cdev, char *buf) {
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_request_len(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
@ -318,9 +338,12 @@ arcmsr_attr_host_fw_request_len(struct class_device *cdev, char *buf) {
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_numbers_queue(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
@ -328,9 +351,12 @@ arcmsr_attr_host_fw_numbers_queue(struct class_device *cdev, char *buf) {
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_sdram_size(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
@ -338,36 +364,39 @@ arcmsr_attr_host_fw_sdram_size(struct class_device *cdev, char *buf) {
} }
static ssize_t static ssize_t
arcmsr_attr_host_fw_hd_channels(struct class_device *cdev, char *buf) { arcmsr_attr_host_fw_hd_channels(struct device *dev,
struct Scsi_Host *host = class_to_shost(cdev); struct device_attribute *attr, char *buf)
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata; {
struct Scsi_Host *host = class_to_shost(dev);
struct AdapterControlBlock *acb =
(struct AdapterControlBlock *) host->hostdata;
return snprintf(buf, PAGE_SIZE, return snprintf(buf, PAGE_SIZE,
"%4d\n", "%4d\n",
acb->firm_hd_channels); acb->firm_hd_channels);
} }
static CLASS_DEVICE_ATTR(host_driver_version, S_IRUGO, arcmsr_attr_host_driver_version, NULL); static 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 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 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 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 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 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 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 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 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); static DEVICE_ATTR(host_fw_hd_channels, S_IRUGO, arcmsr_attr_host_fw_hd_channels, NULL);
struct class_device_attribute *arcmsr_host_attrs[] = { struct device_attribute *arcmsr_host_attrs[] = {
&class_device_attr_host_driver_version, &dev_attr_host_driver_version,
&class_device_attr_host_driver_posted_cmd, &dev_attr_host_driver_posted_cmd,
&class_device_attr_host_driver_reset, &dev_attr_host_driver_reset,
&class_device_attr_host_driver_abort, &dev_attr_host_driver_abort,
&class_device_attr_host_fw_model, &dev_attr_host_fw_model,
&class_device_attr_host_fw_version, &dev_attr_host_fw_version,
&class_device_attr_host_fw_request_len, &dev_attr_host_fw_request_len,
&class_device_attr_host_fw_numbers_queue, &dev_attr_host_fw_numbers_queue,
&class_device_attr_host_fw_sdram_size, &dev_attr_host_fw_sdram_size,
&class_device_attr_host_fw_hd_channels, &dev_attr_host_fw_hd_channels,
NULL, NULL,
}; };

13
drivers/scsi/ch.c
View file

@ -881,7 +881,7 @@ static long ch_ioctl_compat(struct file * file,
static int ch_probe(struct device *dev) static int ch_probe(struct device *dev)
{ {
struct scsi_device *sd = to_scsi_device(dev); struct scsi_device *sd = to_scsi_device(dev);
struct class_device *class_dev; struct device *class_dev;
int minor, ret = -ENOMEM; int minor, ret = -ENOMEM;
scsi_changer *ch; scsi_changer *ch;
@ -910,11 +910,11 @@ static int ch_probe(struct device *dev)
ch->minor = minor; ch->minor = minor;
sprintf(ch->name,"ch%d",ch->minor); sprintf(ch->name,"ch%d",ch->minor);
class_dev = class_device_create(ch_sysfs_class, NULL, class_dev = device_create(ch_sysfs_class, dev,
MKDEV(SCSI_CHANGER_MAJOR, ch->minor), MKDEV(SCSI_CHANGER_MAJOR,ch->minor),
dev, "s%s", ch->name); "s%s", ch->name);
if (IS_ERR(class_dev)) { 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); ch->minor);
ret = PTR_ERR(class_dev); ret = PTR_ERR(class_dev);
goto remove_idr; goto remove_idr;
@ -945,8 +945,7 @@ static int ch_remove(struct device *dev)
idr_remove(&ch_index_idr, ch->minor); idr_remove(&ch_index_idr, ch->minor);
spin_unlock(&ch_index_lock); spin_unlock(&ch_index_lock);
class_device_destroy(ch_sysfs_class, device_destroy(ch_sysfs_class, MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
MKDEV(SCSI_CHANGER_MAJOR,ch->minor));
kfree(ch->dt); kfree(ch->dt);
kfree(ch); kfree(ch);
return 0; return 0;

34
drivers/scsi/hosts.c
View file

@ -43,14 +43,14 @@
static int scsi_host_next_hn; /* host_no for next new host */ 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 = { static struct class shost_class = {
.name = "scsi_host", .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); spin_unlock_irqrestore(shost->host_lock, flags);
transport_unregister_device(&shost->shost_gendev); transport_unregister_device(&shost->shost_gendev);
class_device_unregister(&shost->shost_classdev); device_unregister(&shost->shost_dev);
device_del(&shost->shost_gendev); device_del(&shost->shost_gendev);
scsi_proc_hostdir_rm(shost->hostt); 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); scsi_host_set_state(shost, SHOST_RUNNING);
get_device(shost->shost_gendev.parent); get_device(shost->shost_gendev.parent);
error = class_device_add(&shost->shost_classdev); error = device_add(&shost->shost_dev);
if (error) if (error)
goto out_del_gendev; goto out_del_gendev;
@ -223,7 +223,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
GFP_KERNEL); GFP_KERNEL);
if (shost->shost_data == NULL) { if (shost->shost_data == NULL) {
error = -ENOMEM; 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); destroy_workqueue(shost->work_q);
out_free_shost_data: out_free_shost_data:
kfree(shost->shost_data); kfree(shost->shost_data);
out_del_classdev: out_del_dev:
class_device_del(&shost->shost_classdev); device_del(&shost->shost_dev);
out_del_gendev: out_del_gendev:
device_del(&shost->shost_gendev); device_del(&shost->shost_gendev);
out: out:
@ -385,11 +385,11 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
shost->host_no); shost->host_no);
shost->shost_gendev.release = scsi_host_dev_release; shost->shost_gendev.release = scsi_host_dev_release;
class_device_initialize(&shost->shost_classdev); device_initialize(&shost->shost_dev);
shost->shost_classdev.dev = &shost->shost_gendev; shost->shost_dev.parent = &shost->shost_gendev;
shost->shost_classdev.class = &shost_class; shost->shost_dev.class = &shost_class;
snprintf(shost->shost_classdev.class_id, BUS_ID_SIZE, "host%d", snprintf(shost->shost_dev.bus_id, BUS_ID_SIZE, "host%d",
shost->host_no); shost->host_no);
shost->ehandler = kthread_run(scsi_error_handler, shost, shost->ehandler = kthread_run(scsi_error_handler, shost,
"scsi_eh_%d", shost->host_no); "scsi_eh_%d", shost->host_no);
@ -432,12 +432,12 @@ void scsi_unregister(struct Scsi_Host *shost)
} }
EXPORT_SYMBOL(scsi_unregister); 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; struct Scsi_Host *p;
unsigned short *hostnum = (unsigned short *)data; unsigned short *hostnum = (unsigned short *)data;
p = class_to_shost(cdev); p = class_to_shost(dev);
return p->host_no == *hostnum; 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 Scsi_Host *scsi_host_lookup(unsigned short hostnum)
{ {
struct class_device *cdev; struct device *cdev;
struct Scsi_Host *shost = ERR_PTR(-ENXIO); 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) if (cdev)
shost = scsi_host_get(class_to_shost(cdev)); shost = scsi_host_get(class_to_shost(cdev));

14
drivers/scsi/hptiop.c
View file

@ -859,14 +859,16 @@ static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
return queue_depth; 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); 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; struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n", 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); hba->firmware_version & 0xff);
} }
static struct class_device_attribute hptiop_attr_version = { static struct device_attribute hptiop_attr_version = {
.attr = { .attr = {
.name = "driver-version", .name = "driver-version",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -884,7 +886,7 @@ static struct class_device_attribute hptiop_attr_version = {
.show = hptiop_show_version, .show = hptiop_show_version,
}; };
static struct class_device_attribute hptiop_attr_fw_version = { static struct device_attribute hptiop_attr_fw_version = {
.attr = { .attr = {
.name = "firmware-version", .name = "firmware-version",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -892,7 +894,7 @@ static struct class_device_attribute hptiop_attr_fw_version = {
.show = hptiop_show_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_version,
&hptiop_attr_fw_version, &hptiop_attr_fw_version,
NULL NULL

44
drivers/scsi/ibmvscsi/ibmvscsi.c
View file

@ -1456,9 +1456,10 @@ static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
/* ------------------------------------------------------------ /* ------------------------------------------------------------
* sysfs attributes * 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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
int len; int len;
@ -1467,7 +1468,7 @@ static ssize_t show_host_srp_version(struct class_device *class_dev, char *buf)
return len; return len;
} }
static struct class_device_attribute ibmvscsi_host_srp_version = { static struct device_attribute ibmvscsi_host_srp_version = {
.attr = { .attr = {
.name = "srp_version", .name = "srp_version",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1475,10 +1476,11 @@ static struct class_device_attribute ibmvscsi_host_srp_version = {
.show = show_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) 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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
int len; int len;
@ -1487,7 +1489,7 @@ static ssize_t show_host_partition_name(struct class_device *class_dev,
return len; return len;
} }
static struct class_device_attribute ibmvscsi_host_partition_name = { static struct device_attribute ibmvscsi_host_partition_name = {
.attr = { .attr = {
.name = "partition_name", .name = "partition_name",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1495,10 +1497,11 @@ static struct class_device_attribute ibmvscsi_host_partition_name = {
.show = show_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) 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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
int len; int len;
@ -1507,7 +1510,7 @@ static ssize_t show_host_partition_number(struct class_device *class_dev,
return len; return len;
} }
static struct class_device_attribute ibmvscsi_host_partition_number = { static struct device_attribute ibmvscsi_host_partition_number = {
.attr = { .attr = {
.name = "partition_number", .name = "partition_number",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1515,9 +1518,10 @@ static struct class_device_attribute ibmvscsi_host_partition_number = {
.show = show_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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
int len; int len;
@ -1526,7 +1530,7 @@ static ssize_t show_host_mad_version(struct class_device *class_dev, char *buf)
return len; return len;
} }
static struct class_device_attribute ibmvscsi_host_mad_version = { static struct device_attribute ibmvscsi_host_mad_version = {
.attr = { .attr = {
.name = "mad_version", .name = "mad_version",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1534,9 +1538,10 @@ static struct class_device_attribute ibmvscsi_host_mad_version = {
.show = show_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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
int len; int len;
@ -1544,7 +1549,7 @@ static ssize_t show_host_os_type(struct class_device *class_dev, char *buf)
return len; return len;
} }
static struct class_device_attribute ibmvscsi_host_os_type = { static struct device_attribute ibmvscsi_host_os_type = {
.attr = { .attr = {
.name = "os_type", .name = "os_type",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1552,9 +1557,10 @@ static struct class_device_attribute ibmvscsi_host_os_type = {
.show = show_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); struct ibmvscsi_host_data *hostdata = shost_priv(shost);
/* returns null-terminated host config data */ /* 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; return 0;
} }
static struct class_device_attribute ibmvscsi_host_config = { static struct device_attribute ibmvscsi_host_config = {
.attr = { .attr = {
.name = "config", .name = "config",
.mode = S_IRUGO, .mode = S_IRUGO,
@ -1572,7 +1578,7 @@ static struct class_device_attribute ibmvscsi_host_config = {
.show = show_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_srp_version,
&ibmvscsi_host_partition_name, &ibmvscsi_host_partition_name,
&ibmvscsi_host_partition_number, &ibmvscsi_host_partition_number,

25
drivers/scsi/ibmvscsi/ibmvstgt.c
View file

@ -780,32 +780,35 @@ static int ibmvstgt_it_nexus_response(struct Scsi_Host *shost, u64 itn_id,
return 0; 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); 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); 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 srp_target *target = host_to_srp_target(shost);
struct vio_port *vport = target_to_port(target); struct vio_port *vport = target_to_port(target);
return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address); 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 DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL); static 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(unit_address, S_IRUGO, unit_address_show, NULL);
static struct class_device_attribute *ibmvstgt_attrs[] = { static struct device_attribute *ibmvstgt_attrs[] = {
&class_device_attr_system_id, &dev_attr_system_id,
&class_device_attr_partition_number, &dev_attr_partition_number,
&class_device_attr_unit_address, &dev_attr_unit_address,
NULL, NULL,
}; };

140
drivers/scsi/ipr.c
View file

@ -2431,7 +2431,7 @@ static void ipr_worker_thread(struct work_struct *work)
} }
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 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; LEAVE;
} }
@ -2451,8 +2451,8 @@ static ssize_t ipr_read_trace(struct kobject *kobj,
struct bin_attribute *bin_attr, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
struct class_device *cdev = container_of(kobj,struct class_device,kobj); struct device *dev = container_of(kobj, struct device, kobj);
struct Scsi_Host *shost = class_to_shost(cdev); struct Scsi_Host *shost = class_to_shost(dev);
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
int size = IPR_TRACE_SIZE; int size = IPR_TRACE_SIZE;
@ -2492,15 +2492,16 @@ static const struct {
/** /**
* ipr_show_write_caching - Show the write caching attribute * ipr_show_write_caching - Show the write caching attribute
* @class_dev: class device struct * @dev: device struct
* @buf: buffer * @buf: buffer
* *
* Return value: * Return value:
* number of bytes printed to buffer * 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; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
int i, len = 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 * ipr_store_write_caching - Enable/disable adapter write cache
* @class_dev: class_device struct * @dev: device struct
* @buf: buffer * @buf: buffer
* @count: buffer size * @count: buffer size
* *
* This function will enable/disable adapter write cache. * This function will enable/disable adapter write cache.
* *
* Return value: * Return value:
* count on success / other on failure * count on success / other on failure
**/ **/
static ssize_t ipr_store_write_caching(struct class_device *class_dev, static ssize_t ipr_store_write_caching(struct device *dev,
const char *buf, size_t count) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
enum ipr_cache_state new_state = CACHE_INVALID; 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; return count;
} }
static struct class_device_attribute ipr_ioa_cache_attr = { static struct device_attribute ipr_ioa_cache_attr = {
.attr = { .attr = {
.name = "write_cache", .name = "write_cache",
.mode = S_IRUGO | S_IWUSR, .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 * ipr_show_fw_version - Show the firmware version
* @class_dev: class device struct * @dev: class device struct
* @buf: buffer * @buf: buffer
* *
* Return value: * Return value:
* number of bytes printed to buffer * 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data; struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
unsigned long lock_flags = 0; 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; return len;
} }
static struct class_device_attribute ipr_fw_version_attr = { static struct device_attribute ipr_fw_version_attr = {
.attr = { .attr = {
.name = "fw_version", .name = "fw_version",
.mode = S_IRUGO, .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 * ipr_show_log_level - Show the adapter's error logging level
* @class_dev: class device struct * @dev: class device struct
* @buf: buffer * @buf: buffer
* *
* Return value: * Return value:
* number of bytes printed to buffer * 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; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
int len; 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 * ipr_store_log_level - Change the adapter's error logging level
* @class_dev: class device struct * @dev: class device struct
* @buf: buffer * @buf: buffer
* *
* Return value: * Return value:
* number of bytes printed to buffer * 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) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
@ -2653,7 +2658,7 @@ static ssize_t ipr_store_log_level(struct class_device *class_dev,
return strlen(buf); return strlen(buf);
} }
static struct class_device_attribute ipr_log_level_attr = { static struct device_attribute ipr_log_level_attr = {
.attr = { .attr = {
.name = "log_level", .name = "log_level",
.mode = S_IRUGO | S_IWUSR, .mode = S_IRUGO | S_IWUSR,
@ -2664,9 +2669,9 @@ static struct class_device_attribute ipr_log_level_attr = {
/** /**
* ipr_store_diagnostics - IOA Diagnostics interface * ipr_store_diagnostics - IOA Diagnostics interface
* @class_dev: class_device struct * @dev: device struct
* @buf: buffer * @buf: buffer
* @count: buffer size * @count: buffer size
* *
* This function will reset the adapter and wait a reasonable * This function will reset the adapter and wait a reasonable
* amount of time for any errors that the adapter might log. * 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: * Return value:
* count on success / other on failure * 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) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
int rc = count; int rc = count;
@ -2714,7 +2720,7 @@ static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
return rc; return rc;
} }
static struct class_device_attribute ipr_diagnostics_attr = { static struct device_attribute ipr_diagnostics_attr = {
.attr = { .attr = {
.name = "run_diagnostics", .name = "run_diagnostics",
.mode = S_IWUSR, .mode = S_IWUSR,
@ -2724,15 +2730,16 @@ static struct class_device_attribute ipr_diagnostics_attr = {
/** /**
* ipr_show_adapter_state - Show the adapter's state * ipr_show_adapter_state - Show the adapter's state
* @class_dev: class device struct * @class_dev: device struct
* @buf: buffer * @buf: buffer
* *
* Return value: * Return value:
* number of bytes printed to buffer * 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; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags = 0; unsigned long lock_flags = 0;
int len; 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 * ipr_store_adapter_state - Change adapter state
* @class_dev: class_device struct * @dev: device struct
* @buf: buffer * @buf: buffer
* @count: buffer size * @count: buffer size
* *
* This function will change the adapter's state. * This function will change the adapter's state.
* *
* Return value: * Return value:
* count on success / other on failure * 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) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags; unsigned long lock_flags;
int result = count; int result = count;
@ -2781,7 +2789,7 @@ static ssize_t ipr_store_adapter_state(struct class_device *class_dev,
return result; return result;
} }
static struct class_device_attribute ipr_ioa_state_attr = { static struct device_attribute ipr_ioa_state_attr = {
.attr = { .attr = {
.name = "state", .name = "state",
.mode = S_IRUGO | S_IWUSR, .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 * ipr_store_reset_adapter - Reset the adapter
* @class_dev: class_device struct * @dev: device struct
* @buf: buffer * @buf: buffer
* @count: buffer size * @count: buffer size
* *
* This function will reset the adapter. * This function will reset the adapter.
* *
* Return value: * Return value:
* count on success / other on failure * 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) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
unsigned long lock_flags; unsigned long lock_flags;
int result = count; int result = count;
@ -2821,7 +2830,7 @@ static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
return result; return result;
} }
static struct class_device_attribute ipr_ioa_reset_attr = { static struct device_attribute ipr_ioa_reset_attr = {
.attr = { .attr = {
.name = "reset_host", .name = "reset_host",
.mode = S_IWUSR, .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 * ipr_store_update_fw - Update the firmware on the adapter
* @class_dev: class_device struct * @class_dev: device struct
* @buf: buffer * @buf: buffer
* @count: buffer size * @count: buffer size
* *
* This function will update the firmware on the adapter. * This function will update the firmware on the adapter.
* *
* Return value: * Return value:
* count on success / other on failure * count on success / other on failure
**/ **/
static ssize_t ipr_store_update_fw(struct class_device *class_dev, static ssize_t ipr_store_update_fw(struct device *dev,
const char *buf, size_t count) 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_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
struct ipr_ucode_image_header *image_hdr; struct ipr_ucode_image_header *image_hdr;
const struct firmware *fw_entry; const struct firmware *fw_entry;
@ -3124,7 +3134,7 @@ static ssize_t ipr_store_update_fw(struct class_device *class_dev,
return result; return result;
} }
static struct class_device_attribute ipr_update_fw_attr = { static struct device_attribute ipr_update_fw_attr = {
.attr = { .attr = {
.name = "update_fw", .name = "update_fw",
.mode = S_IWUSR, .mode = S_IWUSR,
@ -3132,7 +3142,7 @@ static struct class_device_attribute ipr_update_fw_attr = {
.store = ipr_store_update_fw .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_fw_version_attr,
&ipr_log_level_attr, &ipr_log_level_attr,
&ipr_diagnostics_attr, &ipr_diagnostics_attr,
@ -3159,7 +3169,7 @@ static ssize_t ipr_read_dump(struct kobject *kobj,
struct bin_attribute *bin_attr, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) 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 Scsi_Host *shost = class_to_shost(cdev);
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
struct ipr_dump *dump; struct ipr_dump *dump;
@ -3322,7 +3332,7 @@ static ssize_t ipr_write_dump(struct kobject *kobj,
struct bin_attribute *bin_attr, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) 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 Scsi_Host *shost = class_to_shost(cdev);
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
int rc; int rc;
@ -7671,9 +7681,9 @@ static void ipr_remove(struct pci_dev *pdev)
ENTER; 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_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); &ipr_dump_attr);
scsi_remove_host(ioa_cfg->host); scsi_remove_host(ioa_cfg->host);
@ -7714,7 +7724,7 @@ static int __devinit ipr_probe(struct pci_dev *pdev,
return rc; 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); &ipr_trace_attr);
if (rc) { if (rc) {
@ -7723,11 +7733,11 @@ static int __devinit ipr_probe(struct pci_dev *pdev,
return rc; 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); &ipr_dump_attr);
if (rc) { 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); &ipr_trace_attr);
scsi_remove_host(ioa_cfg->host); scsi_remove_host(ioa_cfg->host);
__ipr_remove(pdev); __ipr_remove(pdev);

482
drivers/scsi/lpfc/lpfc_attr.c
View file

@ -66,23 +66,26 @@ lpfc_jedec_to_ascii(int incr, char hdw[])
} }
static ssize_t 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"); return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
} }
static ssize_t 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)); return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -90,18 +93,20 @@ lpfc_serialnum_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support); return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -109,9 +114,10 @@ lpfc_modeldesc_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -119,9 +125,10 @@ lpfc_modelname_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -129,9 +136,10 @@ lpfc_programtype_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -139,9 +147,10 @@ lpfc_vportnum_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
char fwrev[32]; char fwrev[32];
@ -151,10 +160,10 @@ lpfc_fwrev_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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]; 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
lpfc_vpd_t *vp = &phba->vpd; 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); return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion); return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
int len = 0; int len = 0;
@ -243,9 +254,10 @@ lpfc_state_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
@ -367,9 +379,10 @@ lpfc_selective_reset(struct lpfc_hba *phba)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; 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 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -395,9 +409,10 @@ lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
char * state; char * state;
@ -415,9 +430,10 @@ lpfc_board_mode_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
struct completion online_compl; struct completion online_compl;
@ -509,9 +525,10 @@ lpfc_get_hba_info(struct lpfc_hba *phba,
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt; uint32_t cnt;
@ -522,9 +539,10 @@ lpfc_max_rpi_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt, acnt; uint32_t cnt, acnt;
@ -535,9 +553,10 @@ lpfc_used_rpi_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt; uint32_t cnt;
@ -548,9 +567,10 @@ lpfc_max_xri_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt, acnt; uint32_t cnt, acnt;
@ -561,9 +581,10 @@ lpfc_used_xri_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt; uint32_t cnt;
@ -574,9 +595,10 @@ lpfc_max_vpi_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t cnt, acnt; uint32_t cnt, acnt;
@ -587,9 +609,10 @@ lpfc_used_vpi_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -601,9 +624,10 @@ lpfc_npiv_info_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -611,10 +635,10 @@ lpfc_poll_show(struct class_device *cdev, char *buf)
} }
static ssize_t static ssize_t
lpfc_poll_store(struct class_device *cdev, const char *buf, lpfc_poll_store(struct device *dev, struct device_attribute *attr,
size_t count) 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t creg_val; uint32_t creg_val;
@ -670,9 +694,10 @@ lpfc_poll_store(struct class_device *cdev, const char *buf,
#define lpfc_param_show(attr) \ #define lpfc_param_show(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
struct lpfc_hba *phba = vport->phba;\ struct lpfc_hba *phba = vport->phba;\
int val = 0;\ int val = 0;\
@ -683,9 +708,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \
#define lpfc_param_hex_show(attr) \ #define lpfc_param_hex_show(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
struct lpfc_hba *phba = vport->phba;\ struct lpfc_hba *phba = vport->phba;\
int val = 0;\ int val = 0;\
@ -725,9 +751,10 @@ lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
#define lpfc_param_store(attr) \ #define lpfc_param_store(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
struct lpfc_hba *phba = vport->phba;\ struct lpfc_hba *phba = vport->phba;\
int val=0;\ 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) \ #define lpfc_vport_param_show(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
int val = 0;\ int val = 0;\
val = vport->cfg_##attr;\ val = vport->cfg_##attr;\
@ -754,9 +782,10 @@ lpfc_##attr##_show(struct class_device *cdev, char *buf) \
#define lpfc_vport_param_hex_show(attr) \ #define lpfc_vport_param_hex_show(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
int val = 0;\ int val = 0;\
val = vport->cfg_##attr;\ val = vport->cfg_##attr;\
@ -794,9 +823,10 @@ lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
#define lpfc_vport_param_store(attr) \ #define lpfc_vport_param_store(attr) \
static ssize_t \ 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_vport *vport = (struct lpfc_vport *) shost->hostdata;\
int val=0;\ int val=0;\
if (!isdigit(buf[0]))\ if (!isdigit(buf[0]))\
@ -822,7 +852,7 @@ module_param(lpfc_##name, int, 0);\
MODULE_PARM_DESC(lpfc_##name, desc);\ MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_show(name)\ lpfc_param_show(name)\
lpfc_param_init(name, defval, minval, maxval)\ 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) \ #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ static int lpfc_##name = defval;\
@ -832,8 +862,8 @@ lpfc_param_show(name)\
lpfc_param_init(name, defval, minval, maxval)\ lpfc_param_init(name, defval, minval, maxval)\
lpfc_param_set(name, defval, minval, maxval)\ lpfc_param_set(name, defval, minval, maxval)\
lpfc_param_store(name)\ lpfc_param_store(name)\
static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
lpfc_##name##_show, lpfc_##name##_store) lpfc_##name##_show, lpfc_##name##_store)
#define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \ #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ static int lpfc_##name = defval;\
@ -841,7 +871,7 @@ module_param(lpfc_##name, int, 0);\
MODULE_PARM_DESC(lpfc_##name, desc);\ MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_param_hex_show(name)\ lpfc_param_hex_show(name)\
lpfc_param_init(name, defval, minval, maxval)\ 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) \ #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ static int lpfc_##name = defval;\
@ -851,8 +881,8 @@ lpfc_param_hex_show(name)\
lpfc_param_init(name, defval, minval, maxval)\ lpfc_param_init(name, defval, minval, maxval)\
lpfc_param_set(name, defval, minval, maxval)\ lpfc_param_set(name, defval, minval, maxval)\
lpfc_param_store(name)\ lpfc_param_store(name)\
static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
lpfc_##name##_show, lpfc_##name##_store) lpfc_##name##_show, lpfc_##name##_store)
#define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \ #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ static int lpfc_##name = defval;\
@ -866,7 +896,7 @@ module_param(lpfc_##name, int, 0);\
MODULE_PARM_DESC(lpfc_##name, desc);\ MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_show(name)\ lpfc_vport_param_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\ 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) \ #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ 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_init(name, defval, minval, maxval)\
lpfc_vport_param_set(name, defval, minval, maxval)\ lpfc_vport_param_set(name, defval, minval, maxval)\
lpfc_vport_param_store(name)\ lpfc_vport_param_store(name)\
static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
lpfc_##name##_show, lpfc_##name##_store) lpfc_##name##_show, lpfc_##name##_store)
#define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \ #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ static int lpfc_##name = defval;\
@ -885,7 +915,7 @@ module_param(lpfc_##name, int, 0);\
MODULE_PARM_DESC(lpfc_##name, desc);\ MODULE_PARM_DESC(lpfc_##name, desc);\
lpfc_vport_param_hex_show(name)\ lpfc_vport_param_hex_show(name)\
lpfc_vport_param_init(name, defval, minval, maxval)\ 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) \ #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
static int lpfc_##name = defval;\ 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_init(name, defval, minval, maxval)\
lpfc_vport_param_set(name, defval, minval, maxval)\ lpfc_vport_param_set(name, defval, minval, maxval)\
lpfc_vport_param_store(name)\ lpfc_vport_param_store(name)\
static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
lpfc_##name##_show, lpfc_##name##_store) lpfc_##name##_show, lpfc_##name##_store)
static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL); static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL); static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL); static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL); static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL); static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL); static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL); static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL); static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL); static DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO, static DEVICE_ATTR(option_rom_version, S_IRUGO,
lpfc_option_rom_version_show, NULL); lpfc_option_rom_version_show, NULL);
static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO, static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
lpfc_num_discovered_ports_show, NULL); lpfc_num_discovered_ports_show, NULL);
static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL); static 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, static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
NULL); static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
static CLASS_DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR, lpfc_board_mode_show, lpfc_board_mode_store);
lpfc_board_mode_show, lpfc_board_mode_store); static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
static CLASS_DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset); static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
static CLASS_DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL); static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
static CLASS_DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL); static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
static CLASS_DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL); static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
static CLASS_DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL); static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
static CLASS_DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL); static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
static CLASS_DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL); static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
static CLASS_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 CLASS_DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show,
NULL);
static char *lpfc_soft_wwn_key = "C99G71SL8032A"; static char *lpfc_soft_wwn_key = "C99G71SL8032A";
static ssize_t static ssize_t
lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf, lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
size_t count) 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
unsigned int cnt = count; 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; phba->soft_wwn_enable = 1;
return count; return count;
} }
static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL, static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
lpfc_soft_wwn_enable_store); lpfc_soft_wwn_enable_store);
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -979,9 +1008,10 @@ lpfc_soft_wwpn_show(struct class_device *cdev, char *buf)
static ssize_t 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_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
struct completion online_compl; 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); "reinit adapter - %d\n", stat2);
return (stat1 || stat2) ? -EIO : count; return (stat1 || stat2) ? -EIO : count;
} }
static CLASS_DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
lpfc_soft_wwpn_show, lpfc_soft_wwpn_store); lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
static ssize_t 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; struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
return snprintf(buf, PAGE_SIZE, "0x%llx\n", return snprintf(buf, PAGE_SIZE, "0x%llx\n",
(unsigned long long)phba->cfg_soft_wwnn); (unsigned long long)phba->cfg_soft_wwnn);
@ -1061,9 +1092,10 @@ lpfc_soft_wwnn_show(struct class_device *cdev, char *buf)
static ssize_t 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; struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
unsigned int i, j, cnt=count; unsigned int i, j, cnt=count;
u8 wwnn[8]; u8 wwnn[8];
@ -1107,8 +1139,8 @@ lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count)
return count; return count;
} }
static CLASS_DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\ static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
lpfc_soft_wwnn_show, lpfc_soft_wwnn_store); lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
static int lpfc_poll = 0; static int lpfc_poll = 0;
@ -1118,8 +1150,8 @@ MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
" 1 - poll with interrupts enabled" " 1 - poll with interrupts enabled"
" 3 - poll and disable FCP ring interrupts"); " 3 - poll and disable FCP ring interrupts");
static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
lpfc_poll_show, lpfc_poll_store); lpfc_poll_show, lpfc_poll_store);
int lpfc_sli_mode = 0; int lpfc_sli_mode = 0;
module_param(lpfc_sli_mode, int, 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"); MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
lpfc_param_show(enable_npiv); lpfc_param_show(enable_npiv);
lpfc_param_init(enable_npiv, 0, 0, 1); 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); lpfc_enable_npiv_show, NULL);
/* /*
@ -1147,9 +1179,10 @@ MODULE_PARM_DESC(lpfc_nodev_tmo,
"Seconds driver will hold I/O waiting " "Seconds driver will hold I/O waiting "
"for a device to come back"); "for a device to come back");
static ssize_t 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; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
int val = 0; int val = 0;
val = vport->cfg_devloss_tmo; 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) lpfc_vport_param_store(nodev_tmo)
static CLASS_DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
/* /*
# lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that # 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) lpfc_vport_param_store(devloss_tmo)
static CLASS_DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
/* /*
# lpfc_log_verbose: Only turn this flag on if you are willing to risk being # 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; return 0;
} }
lpfc_vport_param_store(restrict_login); lpfc_vport_param_store(restrict_login);
static CLASS_DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
lpfc_restrict_login_show, lpfc_restrict_login_store); lpfc_restrict_login_show, lpfc_restrict_login_store);
/* /*
# Some disk devices have a "select ID" or "select Target" capability. # 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_show(topology)
lpfc_param_init(topology, 0, 0, 6) lpfc_param_init(topology, 0, 0, 6)
lpfc_param_store(topology) 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); 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) 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); 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_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"); LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
struct class_device_attribute *lpfc_hba_attrs[] = { struct device_attribute *lpfc_hba_attrs[] = {
&class_device_attr_info, &dev_attr_info,
&class_device_attr_serialnum, &dev_attr_serialnum,
&class_device_attr_modeldesc, &dev_attr_modeldesc,
&class_device_attr_modelname, &dev_attr_modelname,
&class_device_attr_programtype, &dev_attr_programtype,
&class_device_attr_portnum, &dev_attr_portnum,
&class_device_attr_fwrev, &dev_attr_fwrev,
&class_device_attr_hdw, &dev_attr_hdw,
&class_device_attr_option_rom_version, &dev_attr_option_rom_version,
&class_device_attr_state, &dev_attr_state,
&class_device_attr_num_discovered_ports, &dev_attr_num_discovered_ports,
&class_device_attr_lpfc_drvr_version, &dev_attr_lpfc_drvr_version,
&class_device_attr_lpfc_temp_sensor, &dev_attr_lpfc_temp_sensor,
&class_device_attr_lpfc_log_verbose, &dev_attr_lpfc_log_verbose,
&class_device_attr_lpfc_lun_queue_depth, &dev_attr_lpfc_lun_queue_depth,
&class_device_attr_lpfc_hba_queue_depth, &dev_attr_lpfc_hba_queue_depth,
&class_device_attr_lpfc_peer_port_login, &dev_attr_lpfc_peer_port_login,
&class_device_attr_lpfc_nodev_tmo, &dev_attr_lpfc_nodev_tmo,
&class_device_attr_lpfc_devloss_tmo, &dev_attr_lpfc_devloss_tmo,
&class_device_attr_lpfc_fcp_class, &dev_attr_lpfc_fcp_class,
&class_device_attr_lpfc_use_adisc, &dev_attr_lpfc_use_adisc,
&class_device_attr_lpfc_ack0, &dev_attr_lpfc_ack0,
&class_device_attr_lpfc_topology, &dev_attr_lpfc_topology,
&class_device_attr_lpfc_scan_down, &dev_attr_lpfc_scan_down,
&class_device_attr_lpfc_link_speed, &dev_attr_lpfc_link_speed,
&class_device_attr_lpfc_cr_delay, &dev_attr_lpfc_cr_delay,
&class_device_attr_lpfc_cr_count, &dev_attr_lpfc_cr_count,
&class_device_attr_lpfc_multi_ring_support, &dev_attr_lpfc_multi_ring_support,
&class_device_attr_lpfc_multi_ring_rctl, &dev_attr_lpfc_multi_ring_rctl,
&class_device_attr_lpfc_multi_ring_type, &dev_attr_lpfc_multi_ring_type,
&class_device_attr_lpfc_fdmi_on, &dev_attr_lpfc_fdmi_on,
&class_device_attr_lpfc_max_luns, &dev_attr_lpfc_max_luns,
&class_device_attr_lpfc_enable_npiv, &dev_attr_lpfc_enable_npiv,
&class_device_attr_nport_evt_cnt, &dev_attr_nport_evt_cnt,
&class_device_attr_board_mode, &dev_attr_board_mode,
&class_device_attr_max_vpi, &dev_attr_max_vpi,
&class_device_attr_used_vpi, &dev_attr_used_vpi,
&class_device_attr_max_rpi, &dev_attr_max_rpi,
&class_device_attr_used_rpi, &dev_attr_used_rpi,
&class_device_attr_max_xri, &dev_attr_max_xri,
&class_device_attr_used_xri, &dev_attr_used_xri,
&class_device_attr_npiv_info, &dev_attr_npiv_info,
&class_device_attr_issue_reset, &dev_attr_issue_reset,
&class_device_attr_lpfc_poll, &dev_attr_lpfc_poll,
&class_device_attr_lpfc_poll_tmo, &dev_attr_lpfc_poll_tmo,
&class_device_attr_lpfc_use_msi, &dev_attr_lpfc_use_msi,
&class_device_attr_lpfc_soft_wwnn, &dev_attr_lpfc_soft_wwnn,
&class_device_attr_lpfc_soft_wwpn, &dev_attr_lpfc_soft_wwpn,
&class_device_attr_lpfc_soft_wwn_enable, &dev_attr_lpfc_soft_wwn_enable,
&class_device_attr_lpfc_enable_hba_reset, &dev_attr_lpfc_enable_hba_reset,
&class_device_attr_lpfc_enable_hba_heartbeat, &dev_attr_lpfc_enable_hba_heartbeat,
&class_device_attr_lpfc_sg_seg_cnt, &dev_attr_lpfc_sg_seg_cnt,
NULL, NULL,
}; };
struct class_device_attribute *lpfc_vport_attrs[] = { struct device_attribute *lpfc_vport_attrs[] = {
&class_device_attr_info, &dev_attr_info,
&class_device_attr_state, &dev_attr_state,
&class_device_attr_num_discovered_ports, &dev_attr_num_discovered_ports,
&class_device_attr_lpfc_drvr_version, &dev_attr_lpfc_drvr_version,
&dev_attr_lpfc_log_verbose,
&class_device_attr_lpfc_log_verbose, &dev_attr_lpfc_lun_queue_depth,
&class_device_attr_lpfc_lun_queue_depth, &dev_attr_lpfc_nodev_tmo,
&class_device_attr_lpfc_nodev_tmo, &dev_attr_lpfc_devloss_tmo,
&class_device_attr_lpfc_devloss_tmo, &dev_attr_lpfc_hba_queue_depth,
&class_device_attr_lpfc_hba_queue_depth, &dev_attr_lpfc_peer_port_login,
&class_device_attr_lpfc_peer_port_login, &dev_attr_lpfc_restrict_login,
&class_device_attr_lpfc_restrict_login, &dev_attr_lpfc_fcp_class,
&class_device_attr_lpfc_fcp_class, &dev_attr_lpfc_use_adisc,
&class_device_attr_lpfc_use_adisc, &dev_attr_lpfc_fdmi_on,
&class_device_attr_lpfc_fdmi_on, &dev_attr_lpfc_max_luns,
&class_device_attr_lpfc_max_luns, &dev_attr_nport_evt_cnt,
&class_device_attr_nport_evt_cnt, &dev_attr_npiv_info,
&class_device_attr_npiv_info, &dev_attr_lpfc_enable_da_id,
&class_device_attr_lpfc_enable_da_id,
NULL, NULL,
}; };
@ -1707,9 +1739,8 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
size_t buf_off; size_t buf_off;
struct class_device *cdev = container_of(kobj, struct class_device, struct device *dev = container_of(kobj, struct device, kobj);
kobj); struct Scsi_Host *shost = class_to_shost(dev);
struct Scsi_Host *shost = class_to_shost(cdev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; 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; size_t buf_off;
uint32_t * tmp_ptr; uint32_t * tmp_ptr;
struct class_device *cdev = container_of(kobj, struct class_device, struct device *dev = container_of(kobj, struct device, kobj);
kobj); struct Scsi_Host *shost = class_to_shost(dev);
struct Scsi_Host *shost = class_to_shost(cdev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
@ -1798,9 +1828,8 @@ static ssize_t
sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr, sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
struct class_device *cdev = container_of(kobj, struct class_device, struct device *dev = container_of(kobj, struct device, kobj);
kobj); struct Scsi_Host *shost = class_to_shost(dev);
struct Scsi_Host *shost = class_to_shost(cdev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
struct lpfcMboxq *mbox = NULL; struct lpfcMboxq *mbox = NULL;
@ -1853,9 +1882,8 @@ static ssize_t
sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr, sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
struct class_device *cdev = container_of(kobj, struct class_device, struct device *dev = container_of(kobj, struct device, kobj);
kobj); struct Scsi_Host *shost = class_to_shost(dev);
struct Scsi_Host *shost = class_to_shost(cdev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
int rc; int rc;
@ -2038,19 +2066,19 @@ lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
struct Scsi_Host *shost = lpfc_shost_from_vport(vport); struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
int error; int error;
error = sysfs_create_bin_file(&shost->shost_classdev.kobj, error = sysfs_create_bin_file(&shost->shost_dev.kobj,
&sysfs_ctlreg_attr); &sysfs_ctlreg_attr);
if (error) if (error)
goto out; goto out;
error = sysfs_create_bin_file(&shost->shost_classdev.kobj, error = sysfs_create_bin_file(&shost->shost_dev.kobj,
&sysfs_mbox_attr); &sysfs_mbox_attr);
if (error) if (error)
goto out_remove_ctlreg_attr; goto out_remove_ctlreg_attr;
return 0; return 0;
out_remove_ctlreg_attr: 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: out:
return error; return error;
} }
@ -2060,8 +2088,8 @@ lpfc_free_sysfs_attr(struct lpfc_vport *vport)
{ {
struct Scsi_Host *shost = lpfc_shost_from_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_dev.kobj, &sysfs_mbox_attr);
sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_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) \ #define lpfc_rport_show_function(field, format_string, sz, cast) \
static ssize_t \ 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; \ struct lpfc_rport_data *rdata = rport->hostdata; \
return snprintf(buf, sz, format_string, \ return snprintf(buf, sz, format_string, \
(rdata->target) ? cast rdata->target->field : 0); \ (rdata->target) ? cast rdata->target->field : 0); \

4
drivers/scsi/lpfc/lpfc_crtn.h
View file

@ -253,8 +253,8 @@ void lpfc_get_cfgparam(struct lpfc_hba *);
void lpfc_get_vport_cfgparam(struct lpfc_vport *); void lpfc_get_vport_cfgparam(struct lpfc_vport *);
int lpfc_alloc_sysfs_attr(struct lpfc_vport *); int lpfc_alloc_sysfs_attr(struct lpfc_vport *);
void lpfc_free_sysfs_attr(struct lpfc_vport *); void lpfc_free_sysfs_attr(struct lpfc_vport *);
extern struct class_device_attribute *lpfc_hba_attrs[]; extern struct device_attribute *lpfc_hba_attrs[];
extern struct class_device_attribute *lpfc_vport_attrs[]; extern struct device_attribute *lpfc_vport_attrs[];
extern struct scsi_host_template lpfc_template; extern struct scsi_host_template lpfc_template;
extern struct scsi_host_template lpfc_vport_template; extern struct scsi_host_template lpfc_vport_template;
extern struct fc_function_template lpfc_transport_functions; extern struct fc_function_template lpfc_transport_functions;

13
drivers/scsi/megaraid/megaraid_mbox.c
View file

@ -125,7 +125,7 @@ static irqreturn_t megaraid_isr(int, void *);
static void megaraid_mbox_dpc(unsigned long); 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 ssize_t megaraid_sysfs_show_ldnum(struct device *, struct device_attribute *attr, char *);
static int megaraid_cmm_register(adapter_t *); 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 // definitions for the device attributes for exporting logical drive number
// for a scsi address (Host, Channel, Id, Lun) // 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); NULL);
// Host template initializer for megaraid mbox sysfs device attributes // Host template initializer for megaraid mbox sysfs device attributes
static struct class_device_attribute *megaraid_shost_attrs[] = { static struct device_attribute *megaraid_shost_attrs[] = {
&class_device_attr_megaraid_mbox_app_hndl, &dev_attr_megaraid_mbox_app_hndl,
NULL, NULL,
}; };
@ -4063,9 +4063,10 @@ megaraid_sysfs_get_ldmap(adapter_t *adapter)
* handle, since we do not interface with applications directly. * handle, since we do not interface with applications directly.
*/ */
static ssize_t 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); adapter_t *adapter = (adapter_t *)SCSIHOST2ADAP(shost);
uint32_t app_hndl; uint32_t app_hndl;

7
drivers/scsi/ncr53c8xx.c
View file

@ -8243,7 +8243,8 @@ static void process_waiting_list(struct ncb *np, int sts)
#undef next_wcmd #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 Scsi_Host *host = class_to_shost(dev);
struct host_data *host_data = (struct host_data *)host->hostdata; 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); 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, }, .attr = { .name = "revision", .mode = S_IRUGO, },
.show = show_ncr53c8xx_revision, .show = show_ncr53c8xx_revision,
}; };
static struct class_device_attribute *ncr53c8xx_host_attrs[] = { static struct device_attribute *ncr53c8xx_host_attrs[] = {
&ncr53c8xx_revision_attr, &ncr53c8xx_revision_attr,
NULL NULL
}; };

76
drivers/scsi/osst.c
View file

@ -5591,9 +5591,10 @@ static void osst_remove_sysfs_files(struct device_driver *sysfs)
* sysfs support for accessing ADR header information * 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; ssize_t l = 0;
if (STp && STp->header_ok && STp->linux_media) 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; 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; static struct class *osst_sysfs_class;
@ -5678,44 +5687,37 @@ static int osst_sysfs_init(void)
static void osst_sysfs_destroy(dev_t dev) 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) 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; int err;
osst_class_member = class_device_create(osst_sysfs_class, NULL, dev, osst_member = device_create(osst_sysfs_class, device, dev, "%s", name);
device, "%s", name); if (IS_ERR(osst_member)) {
if (IS_ERR(osst_class_member)) {
printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name); 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); dev_set_drvdata(osst_member, STp);
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_ADR_rev);
&class_device_attr_ADR_rev);
if (err) if (err)
goto err_out; goto err_out;
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_media_version);
&class_device_attr_media_version);
if (err) if (err)
goto err_out; goto err_out;
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_capacity);
&class_device_attr_capacity);
if (err) if (err)
goto err_out; goto err_out;
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_BOT_frame);
&class_device_attr_BOT_frame);
if (err) if (err)
goto err_out; goto err_out;
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_EOD_frame);
&class_device_attr_EOD_frame);
if (err) if (err)
goto err_out; goto err_out;
err = class_device_create_file(osst_class_member, err = device_create_file(osst_member, &dev_attr_file_count);
&class_device_attr_file_count);
if (err) if (err)
goto err_out; goto err_out;

14
drivers/scsi/pcmcia/sym53c500_cs.c
View file

@ -632,9 +632,10 @@ SYM53C500_biosparm(struct scsi_device *disk,
} }
static ssize_t 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 *data =
(struct sym53c500_data *)SHp->hostdata; (struct sym53c500_data *)SHp->hostdata;
@ -642,10 +643,11 @@ SYM53C500_show_pio(struct class_device *cdev, char *buf)
} }
static ssize_t 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; 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 *data =
(struct sym53c500_data *)SHp->hostdata; (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 * SCSI HBA device attributes we want to
* make available via sysfs. * make available via sysfs.
*/ */
static struct class_device_attribute SYM53C500_pio_attr = { static struct device_attribute SYM53C500_pio_attr = {
.attr = { .attr = {
.name = "fast_pio", .name = "fast_pio",
.mode = (S_IRUGO | S_IWUSR), .mode = (S_IRUGO | S_IWUSR),
@ -671,7 +673,7 @@ static struct class_device_attribute SYM53C500_pio_attr = {
.store = SYM53C500_store_pio, .store = SYM53C500_store_pio,
}; };
static struct class_device_attribute *SYM53C500_shost_attrs[] = { static struct device_attribute *SYM53C500_shost_attrs[] = {
&SYM53C500_pio_attr, &SYM53C500_pio_attr,
NULL, NULL,
}; };

175
drivers/scsi/qla2xxx/qla_attr.c
View file

@ -530,15 +530,17 @@ qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
/* Scsi_Host attributes. */ /* Scsi_Host attributes. */
static ssize_t 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); return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
} }
static ssize_t 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]; char fw_str[30];
return snprintf(buf, PAGE_SIZE, "%s\n", return snprintf(buf, PAGE_SIZE, "%s\n",
@ -546,9 +548,10 @@ qla2x00_fw_version_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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; uint32_t sn;
if (IS_FWI2_CAPABLE(ha)) if (IS_FWI2_CAPABLE(ha))
@ -560,40 +563,45 @@ qla2x00_serial_num_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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); return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
} }
static ssize_t 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", 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[0], ha->product_id[1], ha->product_id[2],
ha->product_id[3]); ha->product_id[3]);
} }
static ssize_t 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); return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
} }
static ssize_t 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", return snprintf(buf, PAGE_SIZE, "%s\n",
ha->model_desc ? ha->model_desc: ""); ha->model_desc ? ha->model_desc: "");
} }
static ssize_t 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]; char pci_info[30];
return snprintf(buf, PAGE_SIZE, "%s\n", return snprintf(buf, PAGE_SIZE, "%s\n",
@ -601,9 +609,10 @@ qla2x00_pci_info_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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; int len = 0;
if (atomic_read(&ha->loop_state) == LOOP_DOWN || if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
@ -639,9 +648,10 @@ qla2x00_state_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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; int len = 0;
switch (ha->zio_mode) { switch (ha->zio_mode) {
@ -656,9 +666,10 @@ qla2x00_zio_show(struct class_device *cdev, char *buf)
} }
static ssize_t 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; int val = 0;
uint16_t zio_mode; uint16_t zio_mode;
@ -682,18 +693,19 @@ qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
} }
static ssize_t 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); return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
} }
static ssize_t static ssize_t
qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
size_t count) 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 val = 0;
uint16_t zio_timer; uint16_t zio_timer;
@ -709,9 +721,10 @@ qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
} }
static ssize_t 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; int len = 0;
if (ha->beacon_blink_led) if (ha->beacon_blink_led)
@ -722,10 +735,10 @@ qla2x00_beacon_show(struct class_device *cdev, char *buf)
} }
static ssize_t static ssize_t
qla2x00_beacon_store(struct class_device *cdev, const char *buf, qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
size_t count) 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 val = 0;
int rval; int rval;
@ -753,84 +766,86 @@ qla2x00_beacon_store(struct class_device *cdev, const char *buf,
} }
static ssize_t 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], return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
ha->bios_revision[0]); ha->bios_revision[0]);
} }
static ssize_t 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], return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
ha->efi_revision[0]); ha->efi_revision[0]);
} }
static ssize_t 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], return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
ha->fcode_revision[0]); ha->fcode_revision[0]);
} }
static ssize_t 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", 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[0], ha->fw_revision[1], ha->fw_revision[2],
ha->fw_revision[3]); ha->fw_revision[3]);
} }
static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
NULL); static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); static DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
qla2x00_zio_store); qla2x00_zio_timer_store);
static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
qla2x00_zio_timer_store); qla2x00_beacon_store);
static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
qla2x00_beacon_store); qla2x00_optrom_bios_version_show, NULL);
static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO, static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
qla2x00_optrom_bios_version_show, NULL); qla2x00_optrom_efi_version_show, NULL);
static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO, static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
qla2x00_optrom_efi_version_show, NULL); qla2x00_optrom_fcode_version_show, NULL);
static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO, static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
qla2x00_optrom_fcode_version_show, NULL); NULL);
static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO,
qla2x00_optrom_fw_version_show, NULL);
struct class_device_attribute *qla2x00_host_attrs[] = { struct device_attribute *qla2x00_host_attrs[] = {
&class_device_attr_driver_version, &dev_attr_driver_version,
&class_device_attr_fw_version, &dev_attr_fw_version,
&class_device_attr_serial_num, &dev_attr_serial_num,
&class_device_attr_isp_name, &dev_attr_isp_name,
&class_device_attr_isp_id, &dev_attr_isp_id,
&class_device_attr_model_name, &dev_attr_model_name,
&class_device_attr_model_desc, &dev_attr_model_desc,
&class_device_attr_pci_info, &dev_attr_pci_info,
&class_device_attr_state, &dev_attr_state,
&class_device_attr_zio, &dev_attr_zio,
&class_device_attr_zio_timer, &dev_attr_zio_timer,
&class_device_attr_beacon, &dev_attr_beacon,
&class_device_attr_optrom_bios_version, &dev_attr_optrom_bios_version,
&class_device_attr_optrom_efi_version, &dev_attr_optrom_efi_version,
&class_device_attr_optrom_fcode_version, &dev_attr_optrom_fcode_version,
&class_device_attr_optrom_fw_version, &dev_attr_optrom_fw_version,
NULL, NULL,
}; };

4
drivers/scsi/qla2xxx/qla_gbl.h
View file

@ -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. * Global Function Prototypes in qla_attr.c source file.
*/ */
struct class_device_attribute; struct device_attribute;
extern struct class_device_attribute *qla2x00_host_attrs[]; extern struct device_attribute *qla2x00_host_attrs[];
struct fc_function_template; struct fc_function_template;
extern struct fc_function_template qla2xxx_transport_functions; extern struct fc_function_template qla2xxx_transport_functions;
extern struct fc_function_template qla2xxx_transport_vport_functions; extern struct fc_function_template qla2xxx_transport_vport_functions;

73
drivers/scsi/raid_class.c
View file

@ -24,15 +24,15 @@ struct raid_internal {
struct raid_template r; struct raid_template r;
struct raid_function_template *f; struct raid_function_template *f;
/* The actual attributes */ /* 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 /* The array of null terminated pointers to attributes
* needed by scsi_sysfs.c */ * 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 raid_component {
struct list_head node; struct list_head node;
struct class_device cdev; struct device dev;
int num; int num;
}; };
@ -50,9 +50,9 @@ struct raid_component {
tc_to_raid_internal(tc); \ tc_to_raid_internal(tc); \
}) })
#define class_device_to_raid_internal(cdev) ({ \ #define device_to_raid_internal(dev) ({ \
struct attribute_container *ac = \ struct attribute_container *ac = \
attribute_container_classdev_to_container(cdev); \ attribute_container_classdev_to_container(dev); \
ac_to_raid_internal(ac); \ 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, static int raid_setup(struct transport_container *tc, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct raid_data *rd; struct raid_data *rd;
BUG_ON(class_get_devdata(cdev)); BUG_ON(dev_get_drvdata(cdev));
rd = kzalloc(sizeof(*rd), GFP_KERNEL); rd = kzalloc(sizeof(*rd), GFP_KERNEL);
if (!rd) if (!rd)
return -ENOMEM; return -ENOMEM;
INIT_LIST_HEAD(&rd->component_list); INIT_LIST_HEAD(&rd->component_list);
class_set_devdata(cdev, rd); dev_set_drvdata(cdev, rd);
return 0; return 0;
} }
static int raid_remove(struct transport_container *tc, struct device *dev, 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; struct raid_component *rc, *next;
dev_printk(KERN_ERR, dev, "RAID REMOVE\n"); 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_for_each_entry_safe(rc, next, &rd->component_list, node) {
list_del(&rc->node); list_del(&rc->node);
dev_printk(KERN_ERR, rc->cdev.dev, "RAID COMPONENT REMOVE\n"); dev_printk(KERN_ERR, rc->dev.parent, "RAID COMPONENT REMOVE\n");
class_device_unregister(&rc->cdev); device_unregister(&rc->dev);
} }
dev_printk(KERN_ERR, dev, "RAID REMOVE DONE\n"); dev_printk(KERN_ERR, dev, "RAID REMOVE DONE\n");
kfree(rd); 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) \ #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 \ code \
return snprintf(buf, 20, #fmt "\n", var); \ return snprintf(buf, 20, #fmt "\n", var); \
} }
@ -184,17 +186,17 @@ raid_attr_show_internal(attr, %s, name, \
code \ code \
name = raid_##states##_name(rd->attr); \ 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) \ #define raid_attr_ro_internal(attr, code) \
raid_attr_show_internal(attr, %d, rd->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) \ #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) \ 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(attr) raid_attr_ro_internal(attr, )
#define raid_attr_ro_fn(attr) raid_attr_ro_internal(attr, ATTR_CODE(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_fn(resync);
raid_attr_ro_state_fn(state); 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, struct raid_component *rc =
cdev); container_of(dev, struct raid_component, dev);
dev_printk(KERN_ERR, rc->cdev.dev, "COMPONENT RELEASE\n"); dev_printk(KERN_ERR, rc->dev.parent, "COMPONENT RELEASE\n");
put_device(rc->cdev.dev); put_device(rc->dev.parent);
kfree(rc); kfree(rc);
} }
int raid_component_add(struct raid_template *r,struct device *raid_dev, int raid_component_add(struct raid_template *r,struct device *raid_dev,
struct device *component_dev) struct device *component_dev)
{ {
struct class_device *cdev = struct device *cdev =
attribute_container_find_class_device(&r->raid_attrs.ac, attribute_container_find_class_device(&r->raid_attrs.ac,
raid_dev); raid_dev);
struct raid_component *rc; struct raid_component *rc;
struct raid_data *rd = class_get_devdata(cdev); struct raid_data *rd = dev_get_drvdata(cdev);
int err; int err;
rc = kzalloc(sizeof(*rc), GFP_KERNEL); rc = kzalloc(sizeof(*rc), GFP_KERNEL);
@ -230,17 +232,16 @@ int raid_component_add(struct raid_template *r,struct device *raid_dev,
return -ENOMEM; return -ENOMEM;
INIT_LIST_HEAD(&rc->node); INIT_LIST_HEAD(&rc->node);
class_device_initialize(&rc->cdev); device_initialize(&rc->dev);
rc->cdev.release = raid_component_release; rc->dev.release = raid_component_release;
rc->cdev.dev = get_device(component_dev); rc->dev.parent = get_device(component_dev);
rc->num = rd->component_count++; 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); "component-%d", rc->num);
list_add_tail(&rc->node, &rd->component_list); list_add_tail(&rc->node, &rd->component_list);
rc->cdev.parent = cdev; rc->dev.class = &raid_class.class;
rc->cdev.class = &raid_class.class; err = device_add(&rc->dev);
err = class_device_add(&rc->cdev);
if (err) if (err)
goto err_out; goto err_out;
@ -273,9 +274,9 @@ raid_class_attach(struct raid_function_template *ft)
attribute_container_register(&i->r.raid_attrs.ac); attribute_container_register(&i->r.raid_attrs.ac);
i->attrs[count++] = &class_device_attr_level; i->attrs[count++] = &dev_attr_level;
i->attrs[count++] = &class_device_attr_resync; i->attrs[count++] = &dev_attr_resync;
i->attrs[count++] = &class_device_attr_state; i->attrs[count++] = &dev_attr_state;
i->attrs[count] = NULL; i->attrs[count] = NULL;
BUG_ON(count > RAID_NUM_ATTRS); BUG_ON(count > RAID_NUM_ATTRS);

24
drivers/scsi/scsi_sas_internal.h
View file

@ -13,12 +13,12 @@ struct sas_internal {
struct sas_function_template *f; struct sas_function_template *f;
struct sas_domain_function_template *dft; struct sas_domain_function_template *dft;
struct class_device_attribute private_host_attrs[SAS_HOST_ATTRS]; struct device_attribute private_host_attrs[SAS_HOST_ATTRS];
struct class_device_attribute private_phy_attrs[SAS_PHY_ATTRS]; struct device_attribute private_phy_attrs[SAS_PHY_ATTRS];
struct class_device_attribute private_port_attrs[SAS_PORT_ATTRS]; struct device_attribute private_port_attrs[SAS_PORT_ATTRS];
struct class_device_attribute private_rphy_attrs[SAS_RPORT_ATTRS]; struct device_attribute private_rphy_attrs[SAS_RPORT_ATTRS];
struct class_device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS]; struct device_attribute private_end_dev_attrs[SAS_END_DEV_ATTRS];
struct class_device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS]; struct device_attribute private_expander_attrs[SAS_EXPANDER_ATTRS];
struct transport_container phy_attr_cont; struct transport_container phy_attr_cont;
struct transport_container port_attr_cont; struct transport_container port_attr_cont;
@ -30,12 +30,12 @@ struct sas_internal {
* The array of null terminated pointers to attributes * The array of null terminated pointers to attributes
* needed by scsi_sysfs.c * needed by scsi_sysfs.c
*/ */
struct class_device_attribute *host_attrs[SAS_HOST_ATTRS + 1]; struct device_attribute *host_attrs[SAS_HOST_ATTRS + 1];
struct class_device_attribute *phy_attrs[SAS_PHY_ATTRS + 1]; struct device_attribute *phy_attrs[SAS_PHY_ATTRS + 1];
struct class_device_attribute *port_attrs[SAS_PORT_ATTRS + 1]; struct device_attribute *port_attrs[SAS_PORT_ATTRS + 1];
struct class_device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1]; struct device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1];
struct class_device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1]; struct device_attribute *end_dev_attrs[SAS_END_DEV_ATTRS + 1];
struct class_device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1]; struct device_attribute *expander_attrs[SAS_EXPANDER_ATTRS + 1];
}; };
#define to_sas_internal(tmpl) container_of(tmpl, struct sas_internal, t) #define to_sas_internal(tmpl) container_of(tmpl, struct sas_internal, t)

150
drivers/scsi/scsi_sysfs.c
View file

@ -119,9 +119,10 @@ static int scsi_scan(struct Scsi_Host *shost, const char *str)
*/ */
#define shost_show_function(name, field, format_string) \ #define shost_show_function(name, field, format_string) \
static ssize_t \ 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); \ 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) \ #define shost_rd_attr2(name, field, format_string) \
shost_show_function(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) \ #define shost_rd_attr(field, format_string) \
shost_rd_attr2(field, 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. * Create the actual show/store functions and data structures.
*/ */
static ssize_t store_scan(struct class_device *class_dev, const char *buf, static ssize_t
size_t count) 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; int res;
res = scsi_scan(shost, buf); res = scsi_scan(shost, buf);
@ -151,13 +153,14 @@ static ssize_t store_scan(struct class_device *class_dev, const char *buf,
res = count; res = count;
return res; return res;
}; };
static CLASS_DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan); static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
static ssize_t 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; 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; enum scsi_host_state state = 0;
for (i = 0; i < ARRAY_SIZE(shost_states); i++) { 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 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); const char *name = scsi_host_state_name(shost->shost_state);
if (!name) if (!name)
@ -188,7 +191,9 @@ show_shost_state(struct class_device *class_dev, char *buf)
return snprintf(buf, 20, "%s\n", name); 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 static ssize_t
show_shost_mode(unsigned int mode, char *buf) show_shost_mode(unsigned int mode, char *buf)
@ -206,9 +211,11 @@ show_shost_mode(unsigned int mode, char *buf)
return len; 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; unsigned int supported_mode = shost->hostt->supported_mode;
if (supported_mode == MODE_UNKNOWN) 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); 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) if (shost->active_mode == MODE_UNKNOWN)
return snprintf(buf, 20, "unknown\n"); 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); 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(unique_id, "%u\n");
shost_rd_attr(host_busy, "%hu\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_attr(unchecked_isa_dma, "%d\n");
shost_rd_attr2(proc_name, hostt->proc_name, "%s\n"); shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
static struct class_device_attribute *scsi_sysfs_shost_attrs[] = { static struct device_attribute *scsi_sysfs_shost_attrs[] = {
&class_device_attr_unique_id, &dev_attr_unique_id,
&class_device_attr_host_busy, &dev_attr_host_busy,
&class_device_attr_cmd_per_lun, &dev_attr_cmd_per_lun,
&class_device_attr_can_queue, &dev_attr_can_queue,
&class_device_attr_sg_tablesize, &dev_attr_sg_tablesize,
&class_device_attr_unchecked_isa_dma, &dev_attr_unchecked_isa_dma,
&class_device_attr_proc_name, &dev_attr_proc_name,
&class_device_attr_scan, &dev_attr_scan,
&class_device_attr_state, &dev_attr_hstate,
&class_device_attr_supported_mode, &dev_attr_supported_mode,
&class_device_attr_active_mode, &dev_attr_active_mode,
NULL 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; struct scsi_device *sdev;
@ -320,7 +329,7 @@ static void scsi_device_dev_release(struct device *dev)
static struct class sdev_class = { static struct class sdev_class = {
.name = "scsi_device", .name = "scsi_device",
.release = scsi_device_cls_release, .dev_release = scsi_device_cls_release,
}; };
/* all probing is done in the individual ->probe routines */ /* 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) \ #define sdev_show_function(field, format_string) \
static ssize_t \ 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; \ struct scsi_device *sdev; \
sdev = to_scsi_device(dev); \ 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) \ sdev_show_function(field, format_string) \
\ \
static ssize_t \ 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; \ struct scsi_device *sdev; \
sdev = to_scsi_device(dev); \ 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") \ sdev_show_function(field, "%d\n") \
\ \
static ssize_t \ 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; \ int ret; \
struct scsi_device *sdev; \ struct scsi_device *sdev; \
@ -519,7 +531,8 @@ sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
} }
static ssize_t 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; struct scsi_device *sdev;
int timeout; 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 DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
static ssize_t 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); scsi_rescan_device(dev);
return count; return count;
@ -543,8 +557,9 @@ static void sdev_store_delete_callback(struct device *dev)
scsi_remove_device(to_scsi_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, static ssize_t
size_t count) sdev_store_delete(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{ {
int rc; 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 DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
static ssize_t 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; int i;
struct scsi_device *sdev = to_scsi_device(dev); 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 DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
static ssize_t 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); struct scsi_device *sdev = to_scsi_device(dev);
const char *name = "none"; 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 DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
static ssize_t 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); 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) \ #define show_sdev_iostat(field) \
static ssize_t \ 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); \ struct scsi_device *sdev = to_scsi_device(dev); \
unsigned long long count = atomic_read(&sdev->field); \ 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) \ #define DECLARE_EVT_SHOW(name, Cap_name) \
static ssize_t \ static ssize_t \
sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \ sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
char *buf) \ char *buf) \
{ \ { \
struct scsi_device *sdev = to_scsi_device(dev); \ struct scsi_device *sdev = to_scsi_device(dev); \
int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\ 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) \ #define DECLARE_EVT_STORE(name, Cap_name) \
static ssize_t \ 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) \ const char *buf, size_t count) \
{ \ { \
struct scsi_device *sdev = to_scsi_device(dev); \ struct scsi_device *sdev = to_scsi_device(dev); \
@ -707,8 +725,9 @@ static struct attribute_group *scsi_sdev_attr_groups[] = {
NULL NULL
}; };
static ssize_t sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr, const char *buf, static ssize_t
size_t count) sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{ {
int depth, retval; int depth, retval;
struct scsi_device *sdev = to_scsi_device(dev); 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, __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
sdev_store_queue_depth_rw); sdev_store_queue_depth_rw);
static ssize_t sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr, const char *buf, static ssize_t
size_t count) 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_device *sdev = to_scsi_device(dev);
struct scsi_host_template *sht = sdev->host->hostt; 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"); printk(KERN_INFO "error 1\n");
return error; return error;
} }
error = class_device_add(&sdev->sdev_classdev); error = device_add(&sdev->sdev_dev);
if (error) { if (error) {
printk(KERN_INFO "error 2\n"); printk(KERN_INFO "error 2\n");
goto clean_device; 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 */ * released by the sdev_class .release */
get_device(&sdev->sdev_gendev); get_device(&sdev->sdev_gendev);
@ -858,7 +878,7 @@ void __scsi_remove_device(struct scsi_device *sdev)
return; return;
bsg_unregister_queue(sdev->request_queue); bsg_unregister_queue(sdev->request_queue);
class_device_unregister(&sdev->sdev_classdev); device_unregister(&sdev->sdev_dev);
transport_remove_device(dev); transport_remove_device(dev);
device_del(dev); device_del(dev);
scsi_device_set_state(sdev, SDEV_DEL); scsi_device_set_state(sdev, SDEV_DEL);
@ -952,9 +972,9 @@ int scsi_register_interface(struct class_interface *intf)
EXPORT_SYMBOL(scsi_register_interface); EXPORT_SYMBOL(scsi_register_interface);
static struct class_device_attribute *class_attr_overridden( static struct device_attribute *class_attr_overridden(
struct class_device_attribute **attrs, struct device_attribute **attrs,
struct class_device_attribute *attr) struct device_attribute *attr)
{ {
int i; int i;
@ -966,10 +986,10 @@ static struct class_device_attribute *class_attr_overridden(
return NULL; return NULL;
} }
static int class_attr_add(struct class_device *classdev, static int class_attr_add(struct device *classdev,
struct class_device_attribute *attr) 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. * 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; 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) { if (shost->hostt->shost_attrs) {
for (i = 0; shost->hostt->shost_attrs[i]; i++) { 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]); shost->hostt->shost_attrs[i]);
if (error) if (error)
return 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++) { for (i = 0; scsi_sysfs_shost_attrs[i]; i++) {
if (!class_attr_overridden(shost->hostt->shost_attrs, if (!class_attr_overridden(shost->hostt->shost_attrs,
scsi_sysfs_shost_attrs[i])) { 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]); scsi_sysfs_shost_attrs[i]);
if (error) if (error)
return 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->host->host_no, sdev->channel, sdev->id,
sdev->lun); sdev->lun);
class_device_initialize(&sdev->sdev_classdev); device_initialize(&sdev->sdev_dev);
sdev->sdev_classdev.dev = &sdev->sdev_gendev; sdev->sdev_dev.parent = &sdev->sdev_gendev;
sdev->sdev_classdev.class = &sdev_class; sdev->sdev_dev.class = &sdev_class;
snprintf(sdev->sdev_classdev.class_id, BUS_ID_SIZE, snprintf(sdev->sdev_dev.bus_id, BUS_ID_SIZE,
"%d:%d:%d:%d", sdev->host->host_no, "%d:%d:%d:%d", sdev->host->host_no,
sdev->channel, sdev->id, sdev->lun); sdev->channel, sdev->id, sdev->lun);
sdev->scsi_level = starget->scsi_level; sdev->scsi_level = starget->scsi_level;

385
drivers/scsi/scsi_transport_fc.c
View file

@ -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 * Redefine so that we can have same named attributes in the
* sdev/starget/host objects. * sdev/starget/host objects.
*/ */
#define FC_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ #define FC_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
struct class_device_attribute class_device_attr_##_prefix##_##_name = \ struct device_attribute device_attr_##_prefix##_##_name = \
__ATTR(_name,_mode,_show,_store) __ATTR(_name,_mode,_show,_store)
#define fc_enum_name_search(title, table_type, table) \ #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 * part of the midlayer. As the remote port is specific to the
* fc transport, we must provide the attribute container. * 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]; 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 device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
struct class_device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1]; struct device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
struct transport_container rport_attr_cont; struct transport_container rport_attr_cont;
struct class_device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS]; struct device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
struct class_device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1]; struct device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
struct transport_container vport_attr_cont; struct transport_container vport_attr_cont;
struct class_device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS]; struct device_attribute private_vport_attrs[FC_VPORT_NUM_ATTRS];
struct class_device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1]; struct device_attribute *vport_attrs[FC_VPORT_NUM_ATTRS + 1];
}; };
#define to_fc_internal(tmpl) container_of(tmpl, struct fc_internal, t) #define to_fc_internal(tmpl) container_of(tmpl, struct fc_internal, t)
static int fc_target_setup(struct transport_container *tc, struct device *dev, 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 scsi_target *starget = to_scsi_target(dev);
struct fc_rport *rport = starget_to_rport(starget); struct fc_rport *rport = starget_to_rport(starget);
@ -375,7 +375,7 @@ static DECLARE_TRANSPORT_CLASS(fc_transport_class,
NULL); NULL);
static int fc_host_setup(struct transport_container *tc, struct device *dev, 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 Scsi_Host *shost = dev_to_shost(dev);
struct fc_host_attrs *fc_host = shost_to_fc_host(shost); 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) \ #define fc_rport_show_function(field, format_string, sz, cast) \
static ssize_t \ 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 Scsi_Host *shost = rport_to_shost(rport); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
if ((i->f->get_rport_##field) && \ 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) \ #define fc_rport_store_function(field) \
static ssize_t \ static ssize_t \
store_fc_rport_##field(struct class_device *cdev, const char *buf, \ store_fc_rport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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 Scsi_Host *shost = rport_to_shost(rport); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
char *cp; \ 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) \ #define fc_rport_rd_attr(field, format_string, sz) \
fc_rport_show_function(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) show_fc_rport_##field, NULL)
#define fc_rport_rd_attr_cast(field, format_string, sz, cast) \ #define fc_rport_rd_attr_cast(field, format_string, sz, cast) \
fc_rport_show_function(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) show_fc_rport_##field, NULL)
#define fc_rport_rw_attr(field, format_string, sz) \ #define fc_rport_rw_attr(field, format_string, sz) \
fc_rport_show_function(field, format_string, sz, ) \ fc_rport_show_function(field, format_string, sz, ) \
fc_rport_store_function(field) \ 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, \ show_fc_rport_##field, \
store_fc_rport_##field) store_fc_rport_##field)
#define fc_private_rport_show_function(field, format_string, sz, cast) \ #define fc_private_rport_show_function(field, format_string, sz, cast) \
static ssize_t \ 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); \ return snprintf(buf, sz, format_string, cast rport->field); \
} }
#define fc_private_rport_rd_attr(field, format_string, sz) \ #define fc_private_rport_rd_attr(field, format_string, sz) \
fc_private_rport_show_function(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) show_fc_rport_##field, NULL)
#define fc_private_rport_rd_attr_cast(field, format_string, sz, cast) \ #define fc_private_rport_rd_attr_cast(field, format_string, sz, cast) \
fc_private_rport_show_function(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) show_fc_rport_##field, NULL)
#define fc_private_rport_rd_enum_attr(title, maxlen) \ #define fc_private_rport_rd_enum_attr(title, maxlen) \
static ssize_t \ 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; \ const char *name; \
name = get_fc_##title##_name(rport->title); \ name = get_fc_##title##_name(rport->title); \
if (!name) \ if (!name) \
return -EINVAL; \ return -EINVAL; \
return snprintf(buf, maxlen, "%s\n", name); \ 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) show_fc_rport_##title, NULL)
#define SETUP_RPORT_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_rport_attrs[count].store = NULL; \ i->private_rport_attrs[count].store = NULL; \
i->rport_attrs[count] = &i->private_rport_attrs[count]; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \
@ -777,14 +781,14 @@ static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO, \
count++ count++
#define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_rport_attrs[count].store = NULL; \ i->private_rport_attrs[count].store = NULL; \
i->rport_attrs[count] = &i->private_rport_attrs[count]; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \
count++ count++
#define SETUP_RPORT_ATTRIBUTE_RW(field) \ #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) { \ if (!i->f->set_rport_##field) { \
i->private_rport_attrs[count].attr.mode = S_IRUGO; \ i->private_rport_attrs[count].attr.mode = S_IRUGO; \
i->private_rport_attrs[count].store = NULL; \ 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) \ #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]; \ i->rport_attrs[count] = &i->private_rport_attrs[count]; \
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); fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20);
static ssize_t 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) if (rport->supported_classes == FC_COS_UNSPECIFIED)
return snprintf(buf, 20, "unspecified\n"); return snprintf(buf, 20, "unspecified\n");
return get_fc_cos_names(rport->supported_classes, buf); 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); show_fc_rport_supported_classes, NULL);
/* Dynamic Remote Port Attributes */ /* 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, ) fc_rport_show_function(dev_loss_tmo, "%d\n", 20, )
static ssize_t static ssize_t
store_fc_rport_dev_loss_tmo(struct class_device *cdev, const char *buf, store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
size_t count) const char *buf, size_t count)
{ {
int val; 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 Scsi_Host *shost = rport_to_shost(rport);
struct fc_internal *i = to_fc_internal(shost->transportt); struct fc_internal *i = to_fc_internal(shost->transportt);
char *cp; 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); i->f->set_rport_dev_loss_tmo(rport, val);
return count; 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); 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); fc_private_rport_rd_attr(port_id, "0x%06x\n", 20);
static ssize_t 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 */ /* identify any roles that are port_id specific */
if ((rport->port_id != -1) && 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); 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); show_fc_rport_roles, NULL);
fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN); 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 * fast_io_fail_tmo attribute
*/ */
static ssize_t 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) if (rport->fast_io_fail_tmo == -1)
return snprintf(buf, 5, "off\n"); 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 static ssize_t
store_fc_rport_fast_io_fail_tmo(struct class_device *cdev, const char *buf, store_fc_rport_fast_io_fail_tmo(struct device *dev,
size_t count) struct device_attribute *attr, const char *buf,
size_t count)
{ {
int val; int val;
char *cp; 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) || if ((rport->port_state == FC_PORTSTATE_BLOCKED) ||
(rport->port_state == FC_PORTSTATE_DELETED) || (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; 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); 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) \ #define fc_starget_show_function(field, format_string, sz, cast) \
static ssize_t \ 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 Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
struct fc_rport *rport = starget_to_rport(starget); \ 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) \ #define fc_starget_rd_attr(field, format_string, sz) \
fc_starget_show_function(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) show_fc_starget_##field, NULL)
#define fc_starget_rd_attr_cast(field, format_string, sz, cast) \ #define fc_starget_rd_attr_cast(field, format_string, sz, cast) \
fc_starget_show_function(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) show_fc_starget_##field, NULL)
#define SETUP_STARGET_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_starget_attrs[count].store = NULL; \ i->private_starget_attrs[count].store = NULL; \
i->starget_attrs[count] = &i->private_starget_attrs[count]; \ i->starget_attrs[count] = &i->private_starget_attrs[count]; \
@ -974,7 +983,7 @@ static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO, \
count++ count++
#define SETUP_STARGET_ATTRIBUTE_RW(field) \ #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) { \ if (!i->f->set_starget_##field) { \
i->private_starget_attrs[count].attr.mode = S_IRUGO; \ i->private_starget_attrs[count].attr.mode = S_IRUGO; \
i->private_starget_attrs[count].store = NULL; \ 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) \ #define fc_vport_show_function(field, format_string, sz, cast) \
static ssize_t \ 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 Scsi_Host *shost = vport_to_shost(vport); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
if ((i->f->get_vport_##field) && \ 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) \ #define fc_vport_store_function(field) \
static ssize_t \ static ssize_t \
store_fc_vport_##field(struct class_device *cdev, const char *buf, \ store_fc_vport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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 Scsi_Host *shost = vport_to_shost(vport); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
char *cp; \ 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) \ #define fc_vport_store_str_function(field, slen) \
static ssize_t \ static ssize_t \
store_fc_vport_##field(struct class_device *cdev, const char *buf, \ store_fc_vport_##field(struct device *dev, \
size_t count) \ 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 Scsi_Host *shost = vport_to_shost(vport); \
struct fc_internal *i = to_fc_internal(shost->transportt); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
unsigned int cnt=count; \ 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) \ #define fc_vport_rd_attr(field, format_string, sz) \
fc_vport_show_function(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) show_fc_vport_##field, NULL)
#define fc_vport_rd_attr_cast(field, format_string, sz, cast) \ #define fc_vport_rd_attr_cast(field, format_string, sz, cast) \
fc_vport_show_function(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) show_fc_vport_##field, NULL)
#define fc_vport_rw_attr(field, format_string, sz) \ #define fc_vport_rw_attr(field, format_string, sz) \
fc_vport_show_function(field, format_string, sz, ) \ fc_vport_show_function(field, format_string, sz, ) \
fc_vport_store_function(field) \ 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, \ show_fc_vport_##field, \
store_fc_vport_##field) store_fc_vport_##field)
#define fc_private_vport_show_function(field, format_string, sz, cast) \ #define fc_private_vport_show_function(field, format_string, sz, cast) \
static ssize_t \ 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); \ return snprintf(buf, sz, format_string, cast vport->field); \
} }
#define fc_private_vport_store_u32_function(field) \ #define fc_private_vport_store_u32_function(field) \
static ssize_t \ static ssize_t \
store_fc_vport_##field(struct class_device *cdev, const char *buf, \ store_fc_vport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
u32 val; \ u32 val; \
struct fc_vport *vport = transport_class_to_vport(cdev); \ struct fc_vport *vport = transport_class_to_vport(dev); \
char *cp; \ char *cp; \
if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) \ if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) \
return -EBUSY; \ 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) \ #define fc_private_vport_rd_attr(field, format_string, sz) \
fc_private_vport_show_function(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) show_fc_vport_##field, NULL)
#define fc_private_vport_rd_attr_cast(field, format_string, sz, cast) \ #define fc_private_vport_rd_attr_cast(field, format_string, sz, cast) \
fc_private_vport_show_function(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) show_fc_vport_##field, NULL)
#define fc_private_vport_rw_u32_attr(field, format_string, sz) \ #define fc_private_vport_rw_u32_attr(field, format_string, sz) \
fc_private_vport_show_function(field, format_string, sz, ) \ fc_private_vport_show_function(field, format_string, sz, ) \
fc_private_vport_store_u32_function(field) \ 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, \ show_fc_vport_##field, \
store_fc_vport_##field) store_fc_vport_##field)
#define fc_private_vport_rd_enum_attr(title, maxlen) \ #define fc_private_vport_rd_enum_attr(title, maxlen) \
static ssize_t \ 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; \ const char *name; \
name = get_fc_##title##_name(vport->title); \ name = get_fc_##title##_name(vport->title); \
if (!name) \ if (!name) \
return -EINVAL; \ return -EINVAL; \
return snprintf(buf, maxlen, "%s\n", name); \ 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) show_fc_vport_##title, NULL)
#define SETUP_VPORT_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_vport_attrs[count].store = NULL; \ i->private_vport_attrs[count].store = NULL; \
i->vport_attrs[count] = &i->private_vport_attrs[count]; \ 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 */ /* NOTE: Above MACRO differs: checks function not show bit */
#define SETUP_PRIVATE_VPORT_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_vport_attrs[count].store = NULL; \ i->private_vport_attrs[count].store = NULL; \
i->vport_attrs[count] = &i->private_vport_attrs[count]; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \
count++ count++
#define SETUP_VPORT_ATTRIBUTE_WR(field) \ #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]; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \
if (i->f->field) \ if (i->f->field) \
count++ count++
/* NOTE: Above MACRO differs: checks function */ /* NOTE: Above MACRO differs: checks function */
#define SETUP_VPORT_ATTRIBUTE_RW(field) \ #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) { \ if (!i->f->set_vport_##field) { \
i->private_vport_attrs[count].attr.mode = S_IRUGO; \ i->private_vport_attrs[count].attr.mode = S_IRUGO; \
i->private_vport_attrs[count].store = NULL; \ 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) \ #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]; \ i->vport_attrs[count] = &i->private_vport_attrs[count]; \
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); fc_private_vport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
static ssize_t 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) if (vport->roles == FC_PORT_ROLE_UNKNOWN)
return snprintf(buf, 20, "unknown\n"); return snprintf(buf, 20, "unknown\n");
return get_fc_port_roles_names(vport->roles, buf); 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_rd_enum_attr(vport_type, FC_PORTTYPE_MAX_NAMELEN);
fc_private_vport_show_function(symbolic_name, "%s\n", fc_private_vport_show_function(symbolic_name, "%s\n",
FC_VPORT_SYMBOLIC_NAMELEN + 1, ) FC_VPORT_SYMBOLIC_NAMELEN + 1, )
fc_vport_store_str_function(symbolic_name, FC_VPORT_SYMBOLIC_NAMELEN) 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); show_fc_vport_symbolic_name, store_fc_vport_symbolic_name);
static ssize_t static ssize_t
store_fc_vport_delete(struct class_device *cdev, const char *buf, store_fc_vport_delete(struct device *dev, struct device_attribute *attr,
size_t count) 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 Scsi_Host *shost = vport_to_shost(vport);
fc_queue_work(shost, &vport->vport_delete_work); fc_queue_work(shost, &vport->vport_delete_work);
return count; 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); 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 * Write "1" to disable, write "0" to enable
*/ */
static ssize_t 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) 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 Scsi_Host *shost = vport_to_shost(vport);
struct fc_internal *i = to_fc_internal(shost->transportt); struct fc_internal *i = to_fc_internal(shost->transportt);
int stat; 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)); stat = i->f->vport_disable(vport, ((*buf == '0') ? false : true));
return stat ? stat : count; 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); 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) \ #define fc_host_show_function(field, format_string, sz, cast) \
static ssize_t \ 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); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
if (i->f->get_host_##field) \ if (i->f->get_host_##field) \
i->f->get_host_##field(shost); \ 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) \ #define fc_host_store_function(field) \
static ssize_t \ static ssize_t \
store_fc_host_##field(struct class_device *cdev, const char *buf, \ store_fc_host_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
char *cp; \ 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) \ #define fc_host_store_str_function(field, slen) \
static ssize_t \ static ssize_t \
store_fc_host_##field(struct class_device *cdev, const char *buf, \ store_fc_host_##field(struct device *dev, \
size_t count) \ 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); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
unsigned int cnt=count; \ 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) \ #define fc_host_rd_attr(field, format_string, sz) \
fc_host_show_function(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) show_fc_host_##field, NULL)
#define fc_host_rd_attr_cast(field, format_string, sz, cast) \ #define fc_host_rd_attr_cast(field, format_string, sz, cast) \
fc_host_show_function(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) show_fc_host_##field, NULL)
#define fc_host_rw_attr(field, format_string, sz) \ #define fc_host_rw_attr(field, format_string, sz) \
fc_host_show_function(field, format_string, sz, ) \ fc_host_show_function(field, format_string, sz, ) \
fc_host_store_function(field) \ 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, \ show_fc_host_##field, \
store_fc_host_##field) store_fc_host_##field)
#define fc_host_rd_enum_attr(title, maxlen) \ #define fc_host_rd_enum_attr(title, maxlen) \
static ssize_t \ 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); \ struct fc_internal *i = to_fc_internal(shost->transportt); \
const char *name; \ const char *name; \
if (i->f->get_host_##title) \ if (i->f->get_host_##title) \
@ -1322,10 +1344,10 @@ show_fc_host_##title (struct class_device *cdev, char *buf) \
return -EINVAL; \ return -EINVAL; \
return snprintf(buf, maxlen, "%s\n", name); \ 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) \ #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].attr.mode = S_IRUGO; \
i->private_host_attrs[count].store = NULL; \ i->private_host_attrs[count].store = NULL; \
i->host_attrs[count] = &i->private_host_attrs[count]; \ 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++ count++
#define SETUP_HOST_ATTRIBUTE_RD_NS(field) \ #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].attr.mode = S_IRUGO; \
i->private_host_attrs[count].store = NULL; \ i->private_host_attrs[count].store = NULL; \
i->host_attrs[count] = &i->private_host_attrs[count]; \ i->host_attrs[count] = &i->private_host_attrs[count]; \
count++ count++
#define SETUP_HOST_ATTRIBUTE_RW(field) \ #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) { \ if (!i->f->set_host_##field) { \
i->private_host_attrs[count].attr.mode = S_IRUGO; \ i->private_host_attrs[count].attr.mode = S_IRUGO; \
i->private_host_attrs[count].store = NULL; \ 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) \ #define fc_private_host_show_function(field, format_string, sz, cast) \
static ssize_t \ 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)); \ return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
} }
#define fc_private_host_rd_attr(field, format_string, sz) \ #define fc_private_host_rd_attr(field, format_string, sz) \
fc_private_host_show_function(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) show_fc_host_##field, NULL)
#define fc_private_host_rd_attr_cast(field, format_string, sz, cast) \ #define fc_private_host_rd_attr_cast(field, format_string, sz, cast) \
fc_private_host_show_function(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) show_fc_host_##field, NULL)
#define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field) \ #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].attr.mode = S_IRUGO; \
i->private_host_attrs[count].store = NULL; \ i->private_host_attrs[count].store = NULL; \
i->host_attrs[count] = &i->private_host_attrs[count]; \ 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) \ #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]; \ i->host_attrs[count] = &i->private_host_attrs[count]; \
count++; \ count++; \
} }
@ -1386,38 +1409,41 @@ static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO, \
/* Fixed Host Attributes */ /* Fixed Host Attributes */
static ssize_t 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) if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED)
return snprintf(buf, 20, "unspecified\n"); return snprintf(buf, 20, "unspecified\n");
return get_fc_cos_names(fc_host_supported_classes(shost), buf); 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); show_fc_host_supported_classes, NULL);
static ssize_t 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)); 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); show_fc_host_supported_fc4s, NULL);
static ssize_t 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) if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN)
return snprintf(buf, 20, "unknown\n"); return snprintf(buf, 20, "unknown\n");
return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf); 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); 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 */ /* Dynamic Host Attributes */
static ssize_t 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); struct fc_internal *i = to_fc_internal(shost->transportt);
if (i->f->get_host_active_fc4s) 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)); 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); show_fc_host_active_fc4s, NULL);
static ssize_t 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); struct fc_internal *i = to_fc_internal(shost->transportt);
if (i->f->get_host_speed) 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); 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); 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_private_host_show_function(system_hostname, "%s\n",
FC_SYMBOLIC_NAME_SIZE + 1, ) FC_SYMBOLIC_NAME_SIZE + 1, )
fc_host_store_str_function(system_hostname, FC_SYMBOLIC_NAME_SIZE) 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); show_fc_host_system_hostname, store_fc_host_system_hostname);
/* Private Host Attributes */ /* Private Host Attributes */
static ssize_t 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; const char *name;
name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost)); 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) pos = list_entry((head)->next, typeof(*pos), member)
static ssize_t static ssize_t
store_fc_private_host_tgtid_bind_type(struct class_device *cdev, store_fc_private_host_tgtid_bind_type(struct device *dev,
const char *buf, size_t count) 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; struct fc_rport *rport;
enum fc_tgtid_binding_type val; enum fc_tgtid_binding_type val;
unsigned long flags; unsigned long flags;
@ -1523,15 +1552,15 @@ store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
return count; 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, show_fc_private_host_tgtid_bind_type,
store_fc_private_host_tgtid_bind_type); store_fc_private_host_tgtid_bind_type);
static ssize_t static ssize_t
store_fc_private_host_issue_lip(struct class_device *cdev, store_fc_private_host_issue_lip(struct device *dev,
const char *buf, size_t count) 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); struct fc_internal *i = to_fc_internal(shost->transportt);
int ret; int ret;
@ -1544,7 +1573,7 @@ store_fc_private_host_issue_lip(struct class_device *cdev,
return -ENOENT; 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); store_fc_private_host_issue_lip);
fc_private_host_rd_attr(npiv_vports_inuse, "%u\n", 20); 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 */ /* Show a given an attribute in the statistics group */
static ssize_t 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_internal *i = to_fc_internal(shost->transportt);
struct fc_host_statistics *stats; struct fc_host_statistics *stats;
ssize_t ret = -ENOENT; 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 */ /* generate a read-only statistics attribute */
#define fc_host_statistic(name) \ #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, \ return fc_stat_show(cd, buf, \
offsetof(struct fc_host_statistics, name)); \ 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(seconds_since_last_reset);
fc_host_statistic(tx_frames); fc_host_statistic(tx_frames);
@ -1608,10 +1639,10 @@ fc_host_statistic(fcp_input_megabytes);
fc_host_statistic(fcp_output_megabytes); fc_host_statistic(fcp_output_megabytes);
static ssize_t static ssize_t
fc_reset_statistics(struct class_device *cdev, const char *buf, fc_reset_statistics(struct device *dev, struct device_attribute *attr,
size_t count) 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); struct fc_internal *i = to_fc_internal(shost->transportt);
/* ignore any data value written to the attribute */ /* ignore any data value written to the attribute */
@ -1622,31 +1653,31 @@ fc_reset_statistics(struct class_device *cdev, const char *buf,
return -ENOENT; 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); fc_reset_statistics);
static struct attribute *fc_statistics_attrs[] = { static struct attribute *fc_statistics_attrs[] = {
&class_device_attr_host_seconds_since_last_reset.attr, &device_attr_host_seconds_since_last_reset.attr,
&class_device_attr_host_tx_frames.attr, &device_attr_host_tx_frames.attr,
&class_device_attr_host_tx_words.attr, &device_attr_host_tx_words.attr,
&class_device_attr_host_rx_frames.attr, &device_attr_host_rx_frames.attr,
&class_device_attr_host_rx_words.attr, &device_attr_host_rx_words.attr,
&class_device_attr_host_lip_count.attr, &device_attr_host_lip_count.attr,
&class_device_attr_host_nos_count.attr, &device_attr_host_nos_count.attr,
&class_device_attr_host_error_frames.attr, &device_attr_host_error_frames.attr,
&class_device_attr_host_dumped_frames.attr, &device_attr_host_dumped_frames.attr,
&class_device_attr_host_link_failure_count.attr, &device_attr_host_link_failure_count.attr,
&class_device_attr_host_loss_of_sync_count.attr, &device_attr_host_loss_of_sync_count.attr,
&class_device_attr_host_loss_of_signal_count.attr, &device_attr_host_loss_of_signal_count.attr,
&class_device_attr_host_prim_seq_protocol_err_count.attr, &device_attr_host_prim_seq_protocol_err_count.attr,
&class_device_attr_host_invalid_tx_word_count.attr, &device_attr_host_invalid_tx_word_count.attr,
&class_device_attr_host_invalid_crc_count.attr, &device_attr_host_invalid_crc_count.attr,
&class_device_attr_host_fcp_input_requests.attr, &device_attr_host_fcp_input_requests.attr,
&class_device_attr_host_fcp_output_requests.attr, &device_attr_host_fcp_output_requests.attr,
&class_device_attr_host_fcp_control_requests.attr, &device_attr_host_fcp_control_requests.attr,
&class_device_attr_host_fcp_input_megabytes.attr, &device_attr_host_fcp_input_megabytes.attr,
&class_device_attr_host_fcp_output_megabytes.attr, &device_attr_host_fcp_output_megabytes.attr,
&class_device_attr_host_reset_statistics.attr, &device_attr_host_reset_statistics.attr,
NULL 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) * as hex characters, and may *not* contain any prefixes (e.g. 0x, x, etc)
*/ */
static ssize_t static ssize_t
store_fc_host_vport_create(struct class_device *cdev, const char *buf, store_fc_host_vport_create(struct device *dev, struct device_attribute *attr,
size_t count) 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_identifiers vid;
struct fc_vport *vport; struct fc_vport *vport;
unsigned int cnt=count; 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); stat = fc_vport_create(shost, 0, &shost->shost_gendev, &vid, &vport);
return stat ? stat : count; 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); 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) * any prefixes (e.g. 0x, x, etc)
*/ */
static ssize_t static ssize_t
store_fc_host_vport_delete(struct class_device *cdev, const char *buf, store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr,
size_t count) 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_host_attrs *fc_host = shost_to_fc_host(shost);
struct fc_vport *vport; struct fc_vport *vport;
u64 wwpn, wwnn; u64 wwpn, wwnn;
@ -1787,7 +1818,7 @@ store_fc_host_vport_delete(struct class_device *cdev, const char *buf,
stat = fc_vport_terminate(vport); stat = fc_vport_terminate(vport);
return stat ? stat : count; 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); store_fc_host_vport_delete);

107
drivers/scsi/scsi_transport_iscsi.c
View file

@ -40,13 +40,13 @@ struct iscsi_internal {
struct scsi_transport_template t; struct scsi_transport_template t;
struct iscsi_transport *iscsi_transport; struct iscsi_transport *iscsi_transport;
struct list_head list; 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 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 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 */ 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) \ #define to_iscsi_internal(tmpl) \
container_of(tmpl, struct iscsi_internal, t) container_of(tmpl, struct iscsi_internal, t)
#define cdev_to_iscsi_internal(_cdev) \ #define dev_to_iscsi_internal(_dev) \
container_of(_cdev, struct iscsi_internal, cdev) 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); kfree(priv);
} }
@ -78,25 +78,27 @@ static void iscsi_transport_release(struct class_device *cdev)
*/ */
static struct class iscsi_transport_class = { static struct class iscsi_transport_class = {
.name = "iscsi_transport", .name = "iscsi_transport",
.release = iscsi_transport_release, .dev_release = iscsi_transport_release,
}; };
static ssize_t 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)); 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) \ #define show_transport_attr(name, format) \
static ssize_t \ 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); \ 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(caps, "0x%x");
show_transport_attr(max_lun, "%d"); show_transport_attr(max_lun, "%d");
@ -104,11 +106,11 @@ show_transport_attr(max_conn, "%d");
show_transport_attr(max_cmd_len, "%d"); show_transport_attr(max_cmd_len, "%d");
static struct attribute *iscsi_transport_attrs[] = { static struct attribute *iscsi_transport_attrs[] = {
&class_device_attr_handle.attr, &dev_attr_handle.attr,
&class_device_attr_caps.attr, &dev_attr_caps.attr,
&class_device_attr_max_lun.attr, &dev_attr_max_lun.attr,
&class_device_attr_max_conn.attr, &dev_attr_max_conn.attr,
&class_device_attr_max_cmd_len.attr, &dev_attr_max_cmd_len.attr,
NULL, NULL,
}; };
@ -119,7 +121,7 @@ static struct attribute_group iscsi_transport_group = {
static int iscsi_setup_host(struct transport_container *tc, struct device *dev, 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 Scsi_Host *shost = dev_to_shost(dev);
struct iscsi_host *ihost = shost->shost_data; 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, 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 Scsi_Host *shost = dev_to_shost(dev);
struct iscsi_host *ihost = shost->shost_data; struct iscsi_host *ihost = shost->shost_data;
@ -1337,11 +1339,8 @@ iscsi_if_rx(struct sk_buff *skb)
mutex_unlock(&rx_queue_mutex); 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) \ #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) __ATTR(_name,_mode,_show,_store)
/* /*
@ -1349,9 +1348,10 @@ struct class_device_attribute class_device_attr_##_prefix##_##_name = \
*/ */
#define iscsi_conn_attr_show(param) \ #define iscsi_conn_attr_show(param) \
static ssize_t \ 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; \ struct iscsi_transport *t = conn->transport; \
return t->get_conn_param(conn, param, buf); \ 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(ping_tmo, ISCSI_PARAM_PING_TMO);
iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_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 * iSCSI session attrs
*/ */
#define iscsi_session_attr_show(param, perm) \ #define iscsi_session_attr_show(param, perm) \
static ssize_t \ 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; \ struct iscsi_transport *t = session->transport; \
\ \
if (perm && !capable(CAP_SYS_ADMIN)) \ 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); iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
static ssize_t 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)); return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
} }
static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_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) \ #define iscsi_priv_session_attr_show(field, format) \
static ssize_t \ 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); \ return sprintf(buf, format"\n", session->field); \
} }
@ -1444,9 +1446,10 @@ iscsi_priv_session_attr(recovery_tmo, "%d");
*/ */
#define iscsi_host_attr_show(param) \ #define iscsi_host_attr_show(param) \
static ssize_t \ 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); \ struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
return priv->iscsi_transport->get_host_param(shost, param, buf); \ 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) \ #define SETUP_PRIV_SESSION_RD_ATTR(field) \
do { \ do { \
priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \ priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
count++; \ count++; \
} while (0) } while (0)
@ -1471,7 +1474,7 @@ do { \
#define SETUP_SESSION_RD_ATTR(field, param_flag) \ #define SETUP_SESSION_RD_ATTR(field, param_flag) \
do { \ do { \
if (tt->param_mask & param_flag) { \ if (tt->param_mask & param_flag) { \
priv->session_attrs[count] = &class_device_attr_sess_##field; \ priv->session_attrs[count] = &dev_attr_sess_##field; \
count++; \ count++; \
} \ } \
} while (0) } while (0)
@ -1479,7 +1482,7 @@ do { \
#define SETUP_CONN_RD_ATTR(field, param_flag) \ #define SETUP_CONN_RD_ATTR(field, param_flag) \
do { \ do { \
if (tt->param_mask & param_flag) { \ if (tt->param_mask & param_flag) { \
priv->conn_attrs[count] = &class_device_attr_conn_##field; \ priv->conn_attrs[count] = &dev_attr_conn_##field; \
count++; \ count++; \
} \ } \
} while (0) } while (0)
@ -1487,7 +1490,7 @@ do { \
#define SETUP_HOST_RD_ATTR(field, param_flag) \ #define SETUP_HOST_RD_ATTR(field, param_flag) \
do { \ do { \
if (tt->host_param_mask & param_flag) { \ 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++; \ count++; \
} \ } \
} while (0) } while (0)
@ -1578,15 +1581,15 @@ iscsi_register_transport(struct iscsi_transport *tt)
priv->iscsi_transport = tt; priv->iscsi_transport = tt;
priv->t.user_scan = iscsi_user_scan; priv->t.user_scan = iscsi_user_scan;
priv->cdev.class = &iscsi_transport_class; priv->dev.class = &iscsi_transport_class;
snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name); snprintf(priv->dev.bus_id, BUS_ID_SIZE, "%s", tt->name);
err = class_device_register(&priv->cdev); err = device_register(&priv->dev);
if (err) if (err)
goto free_priv; 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) if (err)
goto unregister_cdev; goto unregister_dev;
/* host parameters */ /* host parameters */
priv->t.host_attrs.ac.attrs = &priv->host_attrs[0]; 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); printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
return &priv->t; return &priv->t;
unregister_cdev: unregister_dev:
class_device_unregister(&priv->cdev); device_unregister(&priv->dev);
free_priv: free_priv:
kfree(priv); kfree(priv);
return NULL; return NULL;
@ -1691,8 +1694,8 @@ int iscsi_unregister_transport(struct iscsi_transport *tt)
transport_container_unregister(&priv->session_cont); transport_container_unregister(&priv->session_cont);
transport_container_unregister(&priv->t.host_attrs); transport_container_unregister(&priv->t.host_attrs);
sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group); sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
class_device_unregister(&priv->cdev); device_unregister(&priv->dev);
mutex_unlock(&rx_queue_mutex); mutex_unlock(&rx_queue_mutex);
return 0; return 0;

157
drivers/scsi/scsi_transport_sas.c
View file

@ -53,8 +53,8 @@ struct sas_host_attrs {
/* /*
* Hack to allow attributes of the same name in different objects. * Hack to allow attributes of the same name in different objects.
*/ */
#define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ #define SAS_DEVICE_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) __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, 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 Scsi_Host *shost = dev_to_shost(dev);
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost); 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, 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); 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) \ #define sas_phy_show_simple(field, name, format_string, cast) \
static ssize_t \ 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); \ return snprintf(buf, 20, format_string, cast phy->field); \
} }
#define sas_phy_simple_attr(field, name, format_string, type) \ #define sas_phy_simple_attr(field, name, format_string, type) \
sas_phy_show_simple(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) \ #define sas_phy_show_protocol(field, name) \
static ssize_t \ 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) \ if (!phy->field) \
return snprintf(buf, 20, "none\n"); \ 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) \ #define sas_phy_protocol_attr(field, name) \
sas_phy_show_protocol(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) \ #define sas_phy_show_linkspeed(field) \
static ssize_t \ 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); \ 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 */ /* Fudge to tell if we're minimum or maximum */
#define sas_phy_store_linkspeed(field) \ #define sas_phy_store_linkspeed(field) \
static ssize_t \ static ssize_t \
store_sas_phy_##field(struct class_device *cdev, const char *buf, \ store_sas_phy_##field(struct device *dev, \
size_t count) \ 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 Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
struct sas_internal *i = to_sas_internal(shost->transportt); \ struct sas_internal *i = to_sas_internal(shost->transportt); \
u32 value; \ u32 value; \
@ -416,19 +420,20 @@ store_sas_phy_##field(struct class_device *cdev, const char *buf, \
#define sas_phy_linkspeed_rw_attr(field) \ #define sas_phy_linkspeed_rw_attr(field) \
sas_phy_show_linkspeed(field) \ sas_phy_show_linkspeed(field) \
sas_phy_store_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) store_sas_phy_##field)
#define sas_phy_linkspeed_attr(field) \ #define sas_phy_linkspeed_attr(field) \
sas_phy_show_linkspeed(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) \ #define sas_phy_show_linkerror(field) \
static ssize_t \ 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 Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
struct sas_internal *i = to_sas_internal(shost->transportt); \ struct sas_internal *i = to_sas_internal(shost->transportt); \
int error; \ int error; \
@ -441,24 +446,25 @@ show_sas_phy_##field(struct class_device *cdev, char *buf) \
#define sas_phy_linkerror_attr(field) \ #define sas_phy_linkerror_attr(field) \
sas_phy_show_linkerror(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 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) if (!phy->identify.device_type)
return snprintf(buf, 20, "none\n"); return snprintf(buf, 20, "none\n");
return get_sas_device_type_names(phy->identify.device_type, buf); 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) 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 Scsi_Host *shost = dev_to_shost(phy->dev.parent);
struct sas_internal *i = to_sas_internal(shost->transportt); struct sas_internal *i = to_sas_internal(shost->transportt);
int error; int error;
@ -470,18 +476,19 @@ static ssize_t do_sas_phy_enable(struct class_device *cdev,
return count; return count;
}; };
static ssize_t store_sas_phy_enable(struct class_device *cdev, static ssize_t
const char *buf, size_t count) store_sas_phy_enable(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{ {
if (count < 1) if (count < 1)
return -EINVAL; return -EINVAL;
switch (buf[0]) { switch (buf[0]) {
case '0': case '0':
do_sas_phy_enable(cdev, count, 0); do_sas_phy_enable(dev, count, 0);
break; break;
case '1': case '1':
do_sas_phy_enable(cdev, count, 1); do_sas_phy_enable(dev, count, 1);
break; break;
default: default:
return -EINVAL; return -EINVAL;
@ -490,20 +497,22 @@ static ssize_t store_sas_phy_enable(struct class_device *cdev,
return count; 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); 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); store_sas_phy_enable);
static ssize_t do_sas_phy_reset(struct class_device *cdev, static ssize_t
size_t count, int hard_reset) 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 Scsi_Host *shost = dev_to_shost(phy->dev.parent);
struct sas_internal *i = to_sas_internal(shost->transportt); struct sas_internal *i = to_sas_internal(shost->transportt);
int error; int error;
@ -514,19 +523,21 @@ static ssize_t do_sas_phy_reset(struct class_device *cdev,
return count; return count;
}; };
static ssize_t store_sas_link_reset(struct class_device *cdev, static ssize_t
const char *buf, size_t count) 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, static ssize_t
const char *buf, size_t count) 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, sas_phy_protocol_attr(identify.initiator_port_protocols,
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) \ #define sas_port_show_simple(field, name, format_string, cast) \
static ssize_t \ 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); \ return snprintf(buf, 20, format_string, cast port->field); \
} }
#define sas_port_simple_attr(field, name, format_string, type) \ #define sas_port_simple_attr(field, name, format_string, type) \
sas_port_show_simple(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); 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) \ #define sas_rphy_show_simple(field, name, format_string, cast) \
static ssize_t \ 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); \ return snprintf(buf, 20, format_string, cast rphy->field); \
} }
#define sas_rphy_simple_attr(field, name, format_string, type) \ #define sas_rphy_simple_attr(field, name, format_string, type) \
sas_rphy_show_simple(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) show_sas_rphy_##name, NULL)
#define sas_rphy_show_protocol(field, name) \ #define sas_rphy_show_protocol(field, name) \
static ssize_t \ 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) \ if (!rphy->field) \
return snprintf(buf, 20, "none\n"); \ 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) \ #define sas_rphy_protocol_attr(field, name) \
sas_rphy_show_protocol(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) show_sas_rphy_##name, NULL)
static ssize_t 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) if (!rphy->identify.device_type)
return snprintf(buf, 20, "none\n"); 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); 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); show_sas_rphy_device_type, NULL);
static ssize_t 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 sas_phy *phy = dev_to_phy(rphy->dev.parent);
struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
struct sas_internal *i = to_sas_internal(shost->transportt); 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); 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); show_sas_rphy_enclosure_identifier, NULL);
static ssize_t 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 sas_phy *phy = dev_to_phy(rphy->dev.parent);
struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
struct sas_internal *i = to_sas_internal(shost->transportt); 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); 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); show_sas_rphy_bay_identifier, NULL);
sas_rphy_protocol_attr(identify.initiator_port_protocols, 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) \ #define sas_end_dev_show_simple(field, name, format_string, cast) \
static ssize_t \ 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); \ struct sas_end_device *rdev = rphy_to_end_device(rphy); \
\ \
return snprintf(buf, 20, format_string, cast rdev->field); \ 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) \ #define sas_end_dev_simple_attr(field, name, format_string, type) \
sas_end_dev_show_simple(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) show_sas_end_dev_##name, NULL)
sas_end_dev_simple_attr(ready_led_meaning, ready_led_meaning, "%d\n", int); 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) \ #define sas_expander_show_simple(field, name, format_string, cast) \
static ssize_t \ 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); \ struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
\ \
return snprintf(buf, 20, format_string, cast edev->field); \ 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) \ #define sas_expander_simple_attr(field, name, format_string, type) \
sas_expander_show_simple(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) show_sas_expander_##name, NULL)
sas_expander_simple_attr(vendor_id, vendor_id, "%s\n", char *); 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) \ #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->private_##attrb[count].attr.mode = perm; \
i->attrb[count] = &i->private_##attrb[count]; \ i->attrb[count] = &i->private_##attrb[count]; \
if (test) \ if (test) \
count++ count++
#define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \ #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; \ i->private_##attrb[count].attr.mode = perm; \
if (ro_test) { \ if (ro_test) { \
i->private_##attrb[count].attr.mode = ro_perm; \ i->private_##attrb[count].attr.mode = ro_perm; \

185
drivers/scsi/scsi_transport_spi.c
View file

@ -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, 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); 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, static int spi_host_configure(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev); struct device *cdev);
static DECLARE_TRANSPORT_CLASS(spi_host_class, static DECLARE_TRANSPORT_CLASS(spi_host_class,
"spi_host", "spi_host",
@ -195,11 +195,11 @@ static int spi_host_match(struct attribute_container *cont,
static int spi_target_configure(struct transport_container *tc, static int spi_target_configure(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev); struct device *cdev);
static int spi_device_configure(struct transport_container *tc, static int spi_device_configure(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct scsi_device *sdev = to_scsi_device(dev); struct scsi_device *sdev = to_scsi_device(dev);
struct scsi_target *starget = sdev->sdev_target; 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, static int spi_setup_transport_attrs(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct scsi_target *starget = to_scsi_target(dev); 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) \ #define spi_transport_show_simple(field, format_string) \
\ \
static ssize_t \ 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; \ struct spi_transport_attrs *tp; \
\ \
tp = (struct spi_transport_attrs *)&starget->starget_data; \ 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) \ #define spi_transport_store_simple(field, format_string) \
\ \
static ssize_t \ static ssize_t \
store_spi_transport_##field(struct class_device *cdev, const char *buf, \ store_spi_transport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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; \ struct spi_transport_attrs *tp; \
\ \
tp = (struct spi_transport_attrs *)&starget->starget_data; \ 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) \ #define spi_transport_show_function(field, format_string) \
\ \
static ssize_t \ 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 Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
struct spi_transport_attrs *tp; \ struct spi_transport_attrs *tp; \
struct spi_internal *i = to_spi_internal(shost->transportt); \ 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) \ #define spi_transport_store_function(field, format_string) \
static ssize_t \ static ssize_t \
store_spi_transport_##field(struct class_device *cdev, const char *buf, \ store_spi_transport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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 Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
struct spi_internal *i = to_spi_internal(shost->transportt); \ 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) \ #define spi_transport_store_max(field, format_string) \
static ssize_t \ static ssize_t \
store_spi_transport_##field(struct class_device *cdev, const char *buf, \ store_spi_transport_##field(struct device *dev, \
size_t count) \ struct device_attribute *attr, \
const char *buf, size_t count) \
{ \ { \
int val; \ 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 Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
struct spi_internal *i = to_spi_internal(shost->transportt); \ struct spi_internal *i = to_spi_internal(shost->transportt); \
struct spi_transport_attrs *tp \ 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) \ #define spi_transport_rd_attr(field, format_string) \
spi_transport_show_function(field, format_string) \ spi_transport_show_function(field, format_string) \
spi_transport_store_function(field, format_string) \ spi_transport_store_function(field, format_string) \
static CLASS_DEVICE_ATTR(field, S_IRUGO, \ static DEVICE_ATTR(field, S_IRUGO, \
show_spi_transport_##field, \ show_spi_transport_##field, \
store_spi_transport_##field); store_spi_transport_##field);
#define spi_transport_simple_attr(field, format_string) \ #define spi_transport_simple_attr(field, format_string) \
spi_transport_show_simple(field, format_string) \ spi_transport_show_simple(field, format_string) \
spi_transport_store_simple(field, format_string) \ spi_transport_store_simple(field, format_string) \
static CLASS_DEVICE_ATTR(field, S_IRUGO, \ static DEVICE_ATTR(field, S_IRUGO, \
show_spi_transport_##field, \ show_spi_transport_##field, \
store_spi_transport_##field); store_spi_transport_##field);
#define spi_transport_max_attr(field, format_string) \ #define spi_transport_max_attr(field, format_string) \
spi_transport_show_function(field, format_string) \ spi_transport_show_function(field, format_string) \
spi_transport_store_max(field, format_string) \ spi_transport_store_max(field, format_string) \
spi_transport_simple_attr(max_##field, format_string) \ spi_transport_simple_attr(max_##field, format_string) \
static CLASS_DEVICE_ATTR(field, S_IRUGO, \ static DEVICE_ATTR(field, S_IRUGO, \
show_spi_transport_##field, \ show_spi_transport_##field, \
store_spi_transport_##field); store_spi_transport_##field);
/* The Parallel SCSI Tranport Attributes: */ /* The Parallel SCSI Tranport Attributes: */
spi_transport_max_attr(offset, "%d\n"); spi_transport_max_attr(offset, "%d\n");
@ -370,14 +375,15 @@ static int child_iter(struct device *dev, void *data)
} }
static ssize_t 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); device_for_each_child(&starget->dev, NULL, child_iter);
return count; 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 /* Translate the period into ns according to the current spec
* for SDTR/PPR messages */ * for SDTR/PPR messages */
@ -412,7 +418,7 @@ show_spi_transport_period_helper(char *buf, int period)
} }
static ssize_t 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) size_t count, int *periodp)
{ {
int j, picosec, period = -1; int j, picosec, period = -1;
@ -449,9 +455,10 @@ store_spi_transport_period_helper(struct class_device *cdev, const char *buf,
} }
static ssize_t 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 Scsi_Host *shost = dev_to_shost(starget->dev.parent);
struct spi_internal *i = to_spi_internal(shost->transportt); struct spi_internal *i = to_spi_internal(shost->transportt);
struct spi_transport_attrs *tp = struct spi_transport_attrs *tp =
@ -464,8 +471,8 @@ show_spi_transport_period(struct class_device *cdev, char *buf)
} }
static ssize_t static ssize_t
store_spi_transport_period(struct class_device *cdev, const char *buf, store_spi_transport_period(struct device *cdev, struct device_attribute *attr,
size_t count) const char *buf, size_t count)
{ {
struct scsi_target *starget = transport_class_to_starget(cdev); struct scsi_target *starget = transport_class_to_starget(cdev);
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 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; return retval;
} }
static CLASS_DEVICE_ATTR(period, S_IRUGO, static DEVICE_ATTR(period, S_IRUGO,
show_spi_transport_period, show_spi_transport_period,
store_spi_transport_period); store_spi_transport_period);
static ssize_t 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_target *starget = transport_class_to_starget(cdev);
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 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 static ssize_t
store_spi_transport_min_period(struct class_device *cdev, const char *buf, store_spi_transport_min_period(struct device *cdev,
size_t count) 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(cdev);
struct spi_transport_attrs *tp = 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, static DEVICE_ATTR(min_period, S_IRUGO,
show_spi_transport_min_period, show_spi_transport_min_period,
store_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 Scsi_Host *shost = transport_class_to_shost(cdev);
struct spi_internal *i = to_spi_internal(shost->transportt); 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))); 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) 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); struct spi_internal *i = to_spi_internal(shost->transportt);
enum spi_signal_type type = spi_signal_to_value(buf); 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; return count;
} }
static CLASS_DEVICE_ATTR(signalling, S_IRUGO, static DEVICE_ATTR(signalling, S_IRUGO,
show_spi_host_signalling, show_spi_host_signalling,
store_spi_host_signalling); store_spi_host_signalling);
#define DV_SET(x, y) \ #define DV_SET(x, y) \
if(i->f->set_##x) \ if(i->f->set_##x) \
@ -1334,7 +1346,7 @@ static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
spi_device_configure); spi_device_configure);
static struct attribute *host_attributes[] = { static struct attribute *host_attributes[] = {
&class_device_attr_signalling.attr, &dev_attr_signalling.attr,
NULL NULL
}; };
@ -1344,12 +1356,12 @@ static struct attribute_group host_attribute_group = {
static int spi_host_configure(struct transport_container *tc, static int spi_host_configure(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct kobject *kobj = &cdev->kobj; struct kobject *kobj = &cdev->kobj;
struct Scsi_Host *shost = transport_class_to_shost(cdev); struct Scsi_Host *shost = transport_class_to_shost(cdev);
struct spi_internal *si = to_spi_internal(shost->transportt); 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; int rc = 0;
if (si->f->set_signalling) 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, static int target_attribute_is_visible(struct kobject *kobj,
struct attribute *attr, int i) struct attribute *attr, int i)
{ {
struct class_device *cdev = struct device *cdev = container_of(kobj, struct device, kobj);
container_of(kobj, struct class_device, kobj);
struct scsi_target *starget = transport_class_to_starget(cdev); struct scsi_target *starget = transport_class_to_starget(cdev);
struct Scsi_Host *shost = transport_class_to_shost(cdev); struct Scsi_Host *shost = transport_class_to_shost(cdev);
struct spi_internal *si = to_spi_internal(shost->transportt); 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)) spi_support_sync(starget))
return TARGET_ATTRIBUTE_HELPER(period); 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)) spi_support_sync(starget))
return TARGET_ATTRIBUTE_HELPER(period); return TARGET_ATTRIBUTE_HELPER(period);
else if (attr == &class_device_attr_offset.attr && else if (attr == &dev_attr_offset.attr &&
spi_support_sync(starget)) spi_support_sync(starget))
return TARGET_ATTRIBUTE_HELPER(offset); 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)) spi_support_sync(starget))
return TARGET_ATTRIBUTE_HELPER(offset); return TARGET_ATTRIBUTE_HELPER(offset);
else if (attr == &class_device_attr_width.attr && else if (attr == &dev_attr_width.attr &&
spi_support_wide(starget)) spi_support_wide(starget))
return TARGET_ATTRIBUTE_HELPER(width); 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)) spi_support_wide(starget))
return TARGET_ATTRIBUTE_HELPER(width); return TARGET_ATTRIBUTE_HELPER(width);
else if (attr == &class_device_attr_iu.attr && else if (attr == &dev_attr_iu.attr &&
spi_support_ius(starget)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(iu); return TARGET_ATTRIBUTE_HELPER(iu);
else if (attr == &class_device_attr_dt.attr && else if (attr == &dev_attr_dt.attr &&
spi_support_dt(starget)) spi_support_dt(starget))
return TARGET_ATTRIBUTE_HELPER(dt); return TARGET_ATTRIBUTE_HELPER(dt);
else if (attr == &class_device_attr_qas.attr && else if (attr == &dev_attr_qas.attr &&
spi_support_qas(starget)) spi_support_qas(starget))
return TARGET_ATTRIBUTE_HELPER(qas); 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)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(wr_flow); 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)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(rd_strm); 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)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(rti); 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)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(pcomp_en); 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)) spi_support_ius(starget))
return TARGET_ATTRIBUTE_HELPER(hold_mcs); return TARGET_ATTRIBUTE_HELPER(hold_mcs);
else if (attr == &class_device_attr_revalidate.attr) else if (attr == &dev_attr_revalidate.attr)
return 1; return 1;
return 0; return 0;
} }
static struct attribute *target_attributes[] = { static struct attribute *target_attributes[] = {
&class_device_attr_period.attr, &dev_attr_period.attr,
&class_device_attr_min_period.attr, &dev_attr_min_period.attr,
&class_device_attr_offset.attr, &dev_attr_offset.attr,
&class_device_attr_max_offset.attr, &dev_attr_max_offset.attr,
&class_device_attr_width.attr, &dev_attr_width.attr,
&class_device_attr_max_width.attr, &dev_attr_max_width.attr,
&class_device_attr_iu.attr, &dev_attr_iu.attr,
&class_device_attr_dt.attr, &dev_attr_dt.attr,
&class_device_attr_qas.attr, &dev_attr_qas.attr,
&class_device_attr_wr_flow.attr, &dev_attr_wr_flow.attr,
&class_device_attr_rd_strm.attr, &dev_attr_rd_strm.attr,
&class_device_attr_rti.attr, &dev_attr_rti.attr,
&class_device_attr_pcomp_en.attr, &dev_attr_pcomp_en.attr,
&class_device_attr_hold_mcs.attr, &dev_attr_hold_mcs.attr,
&class_device_attr_revalidate.attr, &dev_attr_revalidate.attr,
NULL NULL
}; };
@ -1448,7 +1459,7 @@ static struct attribute_group target_attribute_group = {
static int spi_target_configure(struct transport_container *tc, static int spi_target_configure(struct transport_container *tc,
struct device *dev, struct device *dev,
struct class_device *cdev) struct device *cdev)
{ {
struct kobject *kobj = &cdev->kobj; struct kobject *kobj = &cdev->kobj;
int i; 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, * to ignore, sysfs also does a WARN_ON and dumps a trace,
* which is bad, so temporarily, skip attributes that are * which is bad, so temporarily, skip attributes that are
* already visible (the revalidate one) */ * 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, rc = sysfs_add_file_to_group(kobj, attr,
target_attribute_group.name); target_attribute_group.name);
/* and make the attribute writeable if we have a set /* and make the attribute writeable if we have a set

26
drivers/scsi/scsi_transport_srp.c
View file

@ -44,20 +44,20 @@ struct srp_internal {
struct scsi_transport_template t; struct scsi_transport_template t;
struct srp_function_template *f; 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 device_attribute *rport_attrs[SRP_RPORT_ATTRS + 1];
struct class_device_attribute private_rport_attrs[SRP_RPORT_ATTRS]; struct device_attribute private_rport_attrs[SRP_RPORT_ATTRS];
struct transport_container rport_attr_cont; struct transport_container rport_attr_cont;
}; };
#define to_srp_internal(tmpl) container_of(tmpl, struct srp_internal, t) #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 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, 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 Scsi_Host *shost = dev_to_shost(dev);
struct srp_host_attrs *srp_host = to_srp_host_attrs(shost); 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); NULL, NULL, NULL);
#define SETUP_TEMPLATE(attrb, field, perm, test, ro_test, ro_perm) \ #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; \ i->private_##attrb[count].attr.mode = perm; \
if (ro_test) { \ if (ro_test) { \
i->private_##attrb[count].attr.mode = ro_perm; \ 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" "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x"
static ssize_t 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)); 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 { static const struct {
u32 value; u32 value;
@ -117,9 +118,10 @@ static const struct {
}; };
static ssize_t 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; int i;
char *name = NULL; char *name = NULL;
@ -131,7 +133,7 @@ show_srp_rport_roles(struct class_device *cdev, char *buf)
return sprintf(buf, "%s\n", name ? : "unknown"); 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) static void srp_rport_release(struct device *dev)
{ {

78
drivers/scsi/sd.c
View file

@ -95,7 +95,7 @@ static int sd_resume(struct device *);
static void sd_rescan(struct device *); static void sd_rescan(struct device *);
static int sd_done(struct scsi_cmnd *); static int sd_done(struct scsi_cmnd *);
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer); 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_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
static void sd_print_result(struct scsi_disk *, int); static void sd_print_result(struct scsi_disk *, int);
@ -112,11 +112,12 @@ static const char *sd_cache_types[] = {
"write back, no read (daft)" "write back, no read (daft)"
}; };
static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf, static ssize_t
size_t count) sd_store_cache_type(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{ {
int i, ct = -1, rcd, wce, sp; 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; struct scsi_device *sdp = sdkp->device;
char buffer[64]; char buffer[64];
char *buffer_data; char *buffer_data;
@ -163,10 +164,11 @@ static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf,
return count; return count;
} }
static ssize_t sd_store_manage_start_stop(struct class_device *cdev, static ssize_t
const char *buf, size_t count) 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; struct scsi_device *sdp = sdkp->device;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
@ -177,10 +179,11 @@ static ssize_t sd_store_manage_start_stop(struct class_device *cdev,
return count; return count;
} }
static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf, static ssize_t
size_t count) 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; struct scsi_device *sdp = sdkp->device;
if (!capable(CAP_SYS_ADMIN)) 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; 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; int ct = sdkp->RCD + 2*sdkp->WCE;
return snprintf(buf, 40, "%s\n", sd_cache_types[ct]); 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); 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; struct scsi_device *sdp = sdkp->device;
return snprintf(buf, 20, "%u\n", sdp->manage_start_stop); 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); 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, __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
sd_store_cache_type), sd_store_cache_type),
__ATTR(FUA, S_IRUGO, sd_show_fua, NULL), __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 = { static struct class sd_disk_class = {
.name = "scsi_disk", .name = "scsi_disk",
.owner = THIS_MODULE, .owner = THIS_MODULE,
.release = scsi_disk_release, .dev_release = scsi_disk_release,
.class_dev_attrs = sd_disk_attrs, .dev_attrs = sd_disk_attrs,
}; };
static struct scsi_driver sd_template = { static struct scsi_driver sd_template = {
@ -297,7 +307,7 @@ static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
if (disk->private_data) { if (disk->private_data) {
sdkp = scsi_disk(disk); sdkp = scsi_disk(disk);
if (scsi_device_get(sdkp->device) == 0) if (scsi_device_get(sdkp->device) == 0)
class_device_get(&sdkp->cdev); get_device(&sdkp->dev);
else else
sdkp = NULL; sdkp = NULL;
} }
@ -331,7 +341,7 @@ static void scsi_disk_put(struct scsi_disk *sdkp)
struct scsi_device *sdev = sdkp->device; struct scsi_device *sdev = sdkp->device;
mutex_lock(&sd_ref_mutex); mutex_lock(&sd_ref_mutex);
class_device_put(&sdkp->cdev); put_device(&sdkp->dev);
scsi_device_put(sdev); scsi_device_put(sdev);
mutex_unlock(&sd_ref_mutex); mutex_unlock(&sd_ref_mutex);
} }
@ -1663,12 +1673,12 @@ static int sd_probe(struct device *dev)
sdp->timeout = SD_MOD_TIMEOUT; sdp->timeout = SD_MOD_TIMEOUT;
} }
class_device_initialize(&sdkp->cdev); device_initialize(&sdkp->dev);
sdkp->cdev.dev = &sdp->sdev_gendev; sdkp->dev.parent = &sdp->sdev_gendev;
sdkp->cdev.class = &sd_disk_class; sdkp->dev.class = &sd_disk_class;
strncpy(sdkp->cdev.class_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE); 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; goto out_put;
get_device(&sdp->sdev_gendev); get_device(&sdp->sdev_gendev);
@ -1734,13 +1744,13 @@ static int sd_remove(struct device *dev)
{ {
struct scsi_disk *sdkp = dev_get_drvdata(dev); struct scsi_disk *sdkp = dev_get_drvdata(dev);
class_device_del(&sdkp->cdev); device_del(&sdkp->dev);
del_gendisk(sdkp->disk); del_gendisk(sdkp->disk);
sd_shutdown(dev); sd_shutdown(dev);
mutex_lock(&sd_ref_mutex); mutex_lock(&sd_ref_mutex);
dev_set_drvdata(dev, NULL); dev_set_drvdata(dev, NULL);
class_device_put(&sdkp->cdev); put_device(&sdkp->dev);
mutex_unlock(&sd_ref_mutex); mutex_unlock(&sd_ref_mutex);
return 0; return 0;
@ -1748,16 +1758,16 @@ static int sd_remove(struct device *dev)
/** /**
* scsi_disk_release - Called to free the scsi_disk structure * 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 * sd_ref_mutex must be held entering this routine. Because it is
* called on last put, you should always use the scsi_disk_get() * called on last put, you should always use the scsi_disk_get()
* scsi_disk_put() helpers which manipulate the semaphore directly * 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; struct gendisk *disk = sdkp->disk;
spin_lock(&sd_index_lock); spin_lock(&sd_index_lock);

28
drivers/scsi/ses.c
View file

@ -107,7 +107,7 @@ static int ses_set_page2_descriptor(struct enclosure_device *edev,
unsigned char *desc) unsigned char *desc)
{ {
int i, j, count = 0, descriptor = ecomp->number; 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; struct ses_device *ses_dev = edev->scratch;
unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11]; unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11];
unsigned char *desc_ptr = ses_dev->page2 + 8; 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) struct enclosure_component *ecomp)
{ {
int i, j, count = 0, descriptor = ecomp->number; 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; struct ses_device *ses_dev = edev->scratch;
unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11]; unsigned char *type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11];
unsigned char *desc_ptr = ses_dev->page2 + 8; 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 ses_host_edev *sed = data;
struct scsi_device *sdev; struct scsi_device *sdev;
if (!scsi_is_sdev_device(edev->cdev.dev)) if (!scsi_is_sdev_device(edev->edev.parent))
return 0; return 0;
sdev = to_scsi_device(edev->cdev.dev); sdev = to_scsi_device(edev->edev.parent);
if (sdev->host != sed->shost) if (sdev->host != sed->shost)
return 0; return 0;
@ -407,10 +407,10 @@ static void ses_match_to_enclosure(struct enclosure_device *edev,
#define INIT_ALLOC_SIZE 32 #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 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; struct scsi_device *tmp_sdev;
unsigned char *buf = NULL, *hdr_buf, *type_ptr, *desc_ptr = NULL, unsigned char *buf = NULL, *hdr_buf, *type_ptr, *desc_ptr = NULL,
*addl_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); edev = enclosure_find(&sdev->host->shost_gendev);
if (edev) { if (edev) {
ses_match_to_enclosure(edev, sdev); ses_match_to_enclosure(edev, sdev);
class_device_put(&edev->cdev); put_device(&edev->edev);
} }
return -ENODEV; return -ENODEV;
} }
@ -515,7 +515,7 @@ static int ses_intf_add(struct class_device *cdev,
if (!scomp) if (!scomp)
goto err_free; 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); components, &ses_enclosure_callbacks);
if (IS_ERR(edev)) { if (IS_ERR(edev)) {
err = PTR_ERR(edev); err = PTR_ERR(edev);
@ -625,17 +625,17 @@ static int ses_remove(struct device *dev)
return 0; return 0;
} }
static void ses_intf_remove(struct class_device *cdev, static void ses_intf_remove(struct device *cdev,
struct class_interface *intf) 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 enclosure_device *edev;
struct ses_device *ses_dev; struct ses_device *ses_dev;
if (!scsi_device_enclosure(sdev)) if (!scsi_device_enclosure(sdev))
return; return;
edev = enclosure_find(cdev->dev); edev = enclosure_find(cdev->parent);
if (!edev) if (!edev)
return; return;
@ -649,13 +649,13 @@ static void ses_intf_remove(struct class_device *cdev,
kfree(edev->component[0].scratch); kfree(edev->component[0].scratch);
class_device_put(&edev->cdev); put_device(&edev->edev);
enclosure_unregister(edev); enclosure_unregister(edev);
} }
static struct class_interface ses_interface = { static struct class_interface ses_interface = {
.add = ses_intf_add, .add_dev = ses_intf_add,
.remove = ses_intf_remove, .remove_dev = ses_intf_remove,
}; };
static struct scsi_driver ses_template = { static struct scsi_driver ses_template = {

36
drivers/scsi/sg.c
View file

@ -101,16 +101,16 @@ static int scatter_elem_sz_prev = SG_SCATTER_SZ;
#define SG_SECTOR_SZ 512 #define SG_SECTOR_SZ 512
#define SG_SECTOR_MSK (SG_SECTOR_SZ - 1) #define SG_SECTOR_MSK (SG_SECTOR_SZ - 1)
static int sg_add(struct class_device *, struct class_interface *); static int sg_add(struct device *, struct class_interface *);
static void sg_remove(struct class_device *, struct class_interface *); static void sg_remove(struct device *, struct class_interface *);
static DEFINE_IDR(sg_index_idr); static DEFINE_IDR(sg_index_idr);
static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock
file descriptor list for device */ file descriptor list for device */
static struct class_interface sg_interface = { static struct class_interface sg_interface = {
.add = sg_add, .add_dev = sg_add,
.remove = sg_remove, .remove_dev = sg_remove,
}; };
typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */ 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 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; struct gendisk *disk;
Sg_device *sdp = NULL; Sg_device *sdp = NULL;
struct cdev * cdev = NULL; struct cdev * cdev = NULL;
@ -1439,19 +1439,19 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf)
sdp->cdev = cdev; sdp->cdev = cdev;
if (sg_sysfs_valid) { 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, sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
MKDEV(SCSI_GENERIC_MAJOR, sdp->index), MKDEV(SCSI_GENERIC_MAJOR,
cl_dev->dev, "%s", sdp->index),
disk->disk_name); "%s", disk->disk_name);
if (IS_ERR(sg_class_member)) { if (IS_ERR(sg_class_member)) {
printk(KERN_ERR "sg_add: " printk(KERN_ERR "sg_add: "
"class_device_create failed\n"); "device_create failed\n");
error = PTR_ERR(sg_class_member); error = PTR_ERR(sg_class_member);
goto cdev_add_err; 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, error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
&sg_class_member->kobj, "generic"); &sg_class_member->kobj, "generic");
if (error) 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, "Attached scsi generic sg%d type %d\n", sdp->index,
scsidp->type); scsidp->type);
class_set_devdata(cl_dev, sdp); dev_set_drvdata(cl_dev, sdp);
return 0; return 0;
@ -1482,10 +1482,10 @@ sg_add(struct class_device *cl_dev, struct class_interface *cl_intf)
} }
static void 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); struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
Sg_device *sdp = class_get_devdata(cl_dev); Sg_device *sdp = dev_get_drvdata(cl_dev);
unsigned long iflags; unsigned long iflags;
Sg_fd *sfp; Sg_fd *sfp;
Sg_fd *tsfp; 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); write_unlock_irqrestore(&sg_index_lock, iflags);
sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic"); 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); cdev_del(sdp->cdev);
sdp->cdev = NULL; sdp->cdev = NULL;
put_disk(sdp->disk); put_disk(sdp->disk);

82
drivers/scsi/st.c
View file

@ -4108,9 +4108,9 @@ static int st_probe(struct device *dev)
if (STm->cdevs[j]) { if (STm->cdevs[j]) {
if (cdev == STm->cdevs[j]) if (cdev == STm->cdevs[j])
cdev = NULL; cdev = NULL;
class_device_destroy(st_sysfs_class, device_destroy(st_sysfs_class,
MKDEV(SCSI_TAPE_MAJOR, MKDEV(SCSI_TAPE_MAJOR,
TAPE_MINOR(i, mode, j))); TAPE_MINOR(i, mode, j)));
cdev_del(STm->cdevs[j]); cdev_del(STm->cdevs[j]);
} }
} }
@ -4148,9 +4148,9 @@ static int st_remove(struct device *dev)
"tape"); "tape");
for (mode = 0; mode < ST_NBR_MODES; ++mode) { for (mode = 0; mode < ST_NBR_MODES; ++mode) {
for (j=0; j < 2; j++) { for (j=0; j < 2; j++) {
class_device_destroy(st_sysfs_class, device_destroy(st_sysfs_class,
MKDEV(SCSI_TAPE_MAJOR, MKDEV(SCSI_TAPE_MAJOR,
TAPE_MINOR(i, mode, j))); TAPE_MINOR(i, mode, j)));
cdev_del(tpnt->modes[mode].cdevs[j]); cdev_del(tpnt->modes[mode].cdevs[j]);
tpnt->modes[mode].cdevs[j] = NULL; tpnt->modes[mode].cdevs[j] = NULL;
} }
@ -4319,31 +4319,34 @@ static void do_remove_sysfs_files(void)
/* The sysfs simple class interface */ /* 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; ssize_t l = 0;
l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
return l; 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; ssize_t l = 0;
l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
return l; 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; ssize_t l = 0;
char *fmt; char *fmt;
@ -4352,22 +4355,25 @@ static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
return l; 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; ssize_t l = 0;
l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
return l; 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; struct scsi_tape *STp;
int i, j, options; int i, j, options;
ssize_t l = 0; ssize_t l = 0;
@ -4403,13 +4409,13 @@ static ssize_t st_options_show(struct class_device *class_dev, char *buf)
return l; 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) static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
{ {
int i, rew, error; int i, rew, error;
char name[10]; char name[10];
struct class_device *st_class_member; struct device *st_class_member;
for (rew=0; rew < 2; rew++) { for (rew=0; rew < 2; rew++) {
/* Make sure that the minor numbers corresponding to the four /* 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" : "", snprintf(name, 10, "%s%s%s", rew ? "n" : "",
STp->disk->disk_name, st_formats[i]); STp->disk->disk_name, st_formats[i]);
st_class_member = st_class_member =
class_device_create(st_sysfs_class, NULL, device_create(st_sysfs_class, &STp->device->sdev_gendev,
MKDEV(SCSI_TAPE_MAJOR, MKDEV(SCSI_TAPE_MAJOR,
TAPE_MINOR(dev_num, mode, rew)), TAPE_MINOR(dev_num, mode, rew)),
&STp->device->sdev_gendev, "%s", name); "%s", name);
if (IS_ERR(st_class_member)) { 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); dev_num);
error = PTR_ERR(st_class_member); error = PTR_ERR(st_class_member);
goto out; 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, error = device_create_file(st_class_member,
&class_device_attr_defined); &dev_attr_defined);
if (error) goto out; if (error) goto out;
error = class_device_create_file(st_class_member, error = device_create_file(st_class_member,
&class_device_attr_default_blksize); &dev_attr_default_blksize);
if (error) goto out; if (error) goto out;
error = class_device_create_file(st_class_member, error = device_create_file(st_class_member,
&class_device_attr_default_density); &dev_attr_default_density);
if (error) goto out; if (error) goto out;
error = class_device_create_file(st_class_member, error = device_create_file(st_class_member,
&class_device_attr_default_compression); &dev_attr_default_compression);
if (error) goto out; if (error) goto out;
error = class_device_create_file(st_class_member, error = device_create_file(st_class_member,
&class_device_attr_options); &dev_attr_options);
if (error) goto out; if (error) goto out;
if (mode == 0 && rew == 0) { if (mode == 0 && rew == 0) {

28
include/linux/attribute_container.h
View file

@ -1,5 +1,5 @@
/* /*
* class_container.h - a generic container for all classes * attribute_container.h - a generic container for all classes
* *
* Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com> * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
* *
@ -18,7 +18,7 @@ struct attribute_container {
struct klist containers; struct klist containers;
struct class *class; struct class *class;
struct attribute_group *grp; struct attribute_group *grp;
struct class_device_attribute **attrs; struct device_attribute **attrs;
int (*match)(struct attribute_container *, struct device *); int (*match)(struct attribute_container *, struct device *);
#define ATTRIBUTE_CONTAINER_NO_CLASSDEVS 0x01 #define ATTRIBUTE_CONTAINER_NO_CLASSDEVS 0x01
unsigned long flags; unsigned long flags;
@ -41,31 +41,31 @@ int __must_check attribute_container_unregister(struct attribute_container *cont
void attribute_container_create_device(struct device *dev, void attribute_container_create_device(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)); struct device *));
void attribute_container_add_device(struct device *dev, void attribute_container_add_device(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)); struct device *));
void attribute_container_remove_device(struct device *dev, void attribute_container_remove_device(struct device *dev,
void (*fn)(struct attribute_container *, void (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)); struct device *));
void attribute_container_device_trigger(struct device *dev, void attribute_container_device_trigger(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *, struct device *,
struct class_device *)); struct device *));
void attribute_container_trigger(struct device *dev, void attribute_container_trigger(struct device *dev,
int (*fn)(struct attribute_container *, int (*fn)(struct attribute_container *,
struct device *)); struct device *));
int attribute_container_add_attrs(struct class_device *classdev); int attribute_container_add_attrs(struct device *classdev);
int attribute_container_add_class_device(struct class_device *classdev); int attribute_container_add_class_device(struct device *classdev);
int attribute_container_add_class_device_adapter(struct attribute_container *cont, int attribute_container_add_class_device_adapter(struct attribute_container *cont,
struct device *dev, struct device *dev,
struct class_device *classdev); struct device *classdev);
void attribute_container_remove_attrs(struct class_device *classdev); void attribute_container_remove_attrs(struct device *classdev);
void attribute_container_class_device_del(struct class_device *classdev); void attribute_container_class_device_del(struct device *classdev);
struct attribute_container *attribute_container_classdev_to_container(struct class_device *); struct attribute_container *attribute_container_classdev_to_container(struct device *);
struct class_device *attribute_container_find_class_device(struct attribute_container *, struct device *); struct device *attribute_container_find_class_device(struct attribute_container *, struct device *);
struct class_device_attribute **attribute_container_classdev_to_attrs(const struct class_device *classdev); struct device_attribute **attribute_container_classdev_to_attrs(const struct device *classdev);
#endif #endif

2
include/linux/bsg.h
View file

@ -55,7 +55,7 @@ struct sg_io_v4 {
#if defined(CONFIG_BLK_DEV_BSG) #if defined(CONFIG_BLK_DEV_BSG)
struct bsg_class_device { struct bsg_class_device {
struct class_device *class_dev; struct device *class_dev;
struct device *dev; struct device *dev;
int minor; int minor;
struct request_queue *queue; struct request_queue *queue;

11
include/linux/enclosure.h
View file

@ -82,7 +82,8 @@ struct enclosure_component_callbacks {
struct enclosure_component { struct enclosure_component {
void *scratch; void *scratch;
struct class_device cdev; struct device cdev;
struct device *dev;
enum enclosure_component_type type; enum enclosure_component_type type;
int number; int number;
int fault; int fault;
@ -94,20 +95,20 @@ struct enclosure_component {
struct enclosure_device { struct enclosure_device {
void *scratch; void *scratch;
struct list_head node; struct list_head node;
struct class_device cdev; struct device edev;
struct enclosure_component_callbacks *cb; struct enclosure_component_callbacks *cb;
int components; int components;
struct enclosure_component component[0]; struct enclosure_component component[0];
}; };
static inline struct enclosure_device * static inline struct enclosure_device *
to_enclosure_device(struct class_device *dev) to_enclosure_device(struct device *dev)
{ {
return container_of(dev, struct enclosure_device, cdev); return container_of(dev, struct enclosure_device, edev);
} }
static inline struct enclosure_component * static inline struct enclosure_component *
to_enclosure_component(struct class_device *dev) to_enclosure_component(struct device *dev)
{ {
return container_of(dev, struct enclosure_component, cdev); return container_of(dev, struct enclosure_component, cdev);
} }

2
include/linux/libata.h
View file

@ -443,7 +443,7 @@ enum link_pm {
MAX_PERFORMANCE, MAX_PERFORMANCE,
MEDIUM_POWER, MEDIUM_POWER,
}; };
extern struct class_device_attribute class_device_attr_link_power_management_policy; extern struct device_attribute dev_attr_link_power_management_policy;
#ifdef CONFIG_ATA_SFF #ifdef CONFIG_ATA_SFF
struct ata_ioports { struct ata_ioports {

12
include/linux/raid_class.h
View file

@ -53,20 +53,20 @@ struct raid_data {
#define DEFINE_RAID_ATTRIBUTE(type, attr) \ #define DEFINE_RAID_ATTRIBUTE(type, attr) \
static inline void \ static inline void \
raid_set_##attr(struct raid_template *r, struct device *dev, type value) { \ raid_set_##attr(struct raid_template *r, struct device *dev, type value) { \
struct class_device *cdev = \ struct device *device = \
attribute_container_find_class_device(&r->raid_attrs.ac, dev);\ attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
struct raid_data *rd; \ struct raid_data *rd; \
BUG_ON(!cdev); \ BUG_ON(!device); \
rd = class_get_devdata(cdev); \ rd = dev_get_drvdata(device); \
rd->attr = value; \ rd->attr = value; \
} \ } \
static inline type \ static inline type \
raid_get_##attr(struct raid_template *r, struct device *dev) { \ raid_get_##attr(struct raid_template *r, struct device *dev) { \
struct class_device *cdev = \ struct device *device = \
attribute_container_find_class_device(&r->raid_attrs.ac, dev);\ attribute_container_find_class_device(&r->raid_attrs.ac, dev);\
struct raid_data *rd; \ struct raid_data *rd; \
BUG_ON(!cdev); \ BUG_ON(!device); \
rd = class_get_devdata(cdev); \ rd = dev_get_drvdata(device); \
return rd->attr; \ return rd->attr; \
} }

6
include/linux/transport_class.h
View file

@ -17,11 +17,11 @@ struct transport_container;
struct transport_class { struct transport_class {
struct class class; struct class class;
int (*setup)(struct transport_container *, struct device *, int (*setup)(struct transport_container *, struct device *,
struct class_device *); struct device *);
int (*configure)(struct transport_container *, struct device *, int (*configure)(struct transport_container *, struct device *,
struct class_device *); struct device *);
int (*remove)(struct transport_container *, struct device *, int (*remove)(struct transport_container *, struct device *,
struct class_device *); struct device *);
}; };
#define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg) \ #define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg) \

10
include/scsi/scsi_device.h
View file

@ -156,8 +156,8 @@ struct scsi_device {
int timeout; int timeout;
struct device sdev_gendev; struct device sdev_gendev,
struct class_device sdev_classdev; sdev_dev;
struct execute_work ew; /* used to get process context on put */ struct execute_work ew; /* used to get process context on put */
@ -167,9 +167,9 @@ struct scsi_device {
#define to_scsi_device(d) \ #define to_scsi_device(d) \
container_of(d, struct scsi_device, sdev_gendev) container_of(d, struct scsi_device, sdev_gendev)
#define class_to_sdev(d) \ #define class_to_sdev(d) \
container_of(d, struct scsi_device, sdev_classdev) container_of(d, struct scsi_device, sdev_dev)
#define transport_class_to_sdev(class_dev) \ #define transport_class_to_sdev(class_dev) \
to_scsi_device(class_dev->dev) to_scsi_device(class_dev->parent)
#define sdev_printk(prefix, sdev, fmt, a...) \ #define sdev_printk(prefix, sdev, fmt, a...) \
dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a) dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
@ -220,7 +220,7 @@ static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
return to_scsi_target(sdev->sdev_gendev.parent); return to_scsi_target(sdev->sdev_gendev.parent);
} }
#define transport_class_to_starget(class_dev) \ #define transport_class_to_starget(class_dev) \
to_scsi_target(class_dev->dev) to_scsi_target(class_dev->parent)
#define starget_printk(prefix, starget, fmt, a...) \ #define starget_printk(prefix, starget, fmt, a...) \
dev_printk(prefix, &(starget)->dev, fmt, ##a) dev_printk(prefix, &(starget)->dev, fmt, ##a)

7
include/scsi/scsi_host.h
View file

@ -470,7 +470,7 @@ struct scsi_host_template {
/* /*
* Pointer to the sysfs class properties for this host, NULL terminated. * Pointer to the sysfs class properties for this host, NULL terminated.
*/ */
struct class_device_attribute **shost_attrs; struct device_attribute **shost_attrs;
/* /*
* Pointer to the SCSI device properties for this host, NULL terminated. * Pointer to the SCSI device properties for this host, NULL terminated.
@ -655,8 +655,7 @@ struct Scsi_Host {
enum scsi_host_state shost_state; enum scsi_host_state shost_state;
/* ldm bits */ /* ldm bits */
struct device shost_gendev; struct device shost_gendev, shost_dev;
struct class_device shost_classdev;
/* /*
* List of hosts per template. * List of hosts per template.
@ -683,7 +682,7 @@ struct Scsi_Host {
}; };
#define class_to_shost(d) \ #define class_to_shost(d) \
container_of(d, struct Scsi_Host, shost_classdev) container_of(d, struct Scsi_Host, shost_dev)
#define shost_printk(prefix, shost, fmt, a...) \ #define shost_printk(prefix, shost, fmt, a...) \
dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a) dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)

2
include/scsi/scsi_transport.h
View file

@ -80,7 +80,7 @@ struct scsi_transport_template {
}; };
#define transport_class_to_shost(tc) \ #define transport_class_to_shost(tc) \
dev_to_shost((tc)->dev) dev_to_shost((tc)->parent)
/* Private area maintenance. The driver requested allocations come /* Private area maintenance. The driver requested allocations come

14
include/scsi/scsi_transport_fc.h
View file

@ -163,8 +163,8 @@ enum fc_tgtid_binding_type {
/* Macro for use in defining Virtual Port attributes */ /* Macro for use in defining Virtual Port attributes */
#define FC_VPORT_ATTR(_name,_mode,_show,_store) \ #define FC_VPORT_ATTR(_name,_mode,_show,_store) \
struct class_device_attribute class_device_attr_vport_##_name = \ struct device_attribute dev_attr_vport_##_name = \
__ATTR(_name,_mode,_show,_store) __ATTR(_name,_mode,_show,_store)
@ -234,8 +234,8 @@ struct fc_vport {
#define dev_to_vport(d) \ #define dev_to_vport(d) \
container_of(d, struct fc_vport, dev) container_of(d, struct fc_vport, dev)
#define transport_class_to_vport(classdev) \ #define transport_class_to_vport(dev) \
dev_to_vport(classdev->dev) dev_to_vport(dev->parent)
#define vport_to_shost(v) \ #define vport_to_shost(v) \
(v->shost) (v->shost)
#define vport_to_shost_channel(v) \ #define vport_to_shost_channel(v) \
@ -271,7 +271,7 @@ struct fc_rport_identifiers {
/* Macro for use in defining Remote Port attributes */ /* Macro for use in defining Remote Port attributes */
#define FC_RPORT_ATTR(_name,_mode,_show,_store) \ #define FC_RPORT_ATTR(_name,_mode,_show,_store) \
struct class_device_attribute class_device_attr_rport_##_name = \ struct device_attribute dev_attr_rport_##_name = \
__ATTR(_name,_mode,_show,_store) __ATTR(_name,_mode,_show,_store)
@ -341,8 +341,8 @@ struct fc_rport { /* aka fc_starget_attrs */
#define dev_to_rport(d) \ #define dev_to_rport(d) \
container_of(d, struct fc_rport, dev) container_of(d, struct fc_rport, dev)
#define transport_class_to_rport(classdev) \ #define transport_class_to_rport(dev) \
dev_to_rport(classdev->dev) dev_to_rport(dev->parent)
#define rport_to_shost(r) \ #define rport_to_shost(r) \
dev_to_shost(r->dev.parent) dev_to_shost(r->dev.parent)

12
include/scsi/scsi_transport_sas.h
View file

@ -80,8 +80,8 @@ struct sas_phy {
#define dev_to_phy(d) \ #define dev_to_phy(d) \
container_of((d), struct sas_phy, dev) container_of((d), struct sas_phy, dev)
#define transport_class_to_phy(cdev) \ #define transport_class_to_phy(dev) \
dev_to_phy((cdev)->dev) dev_to_phy((dev)->parent)
#define phy_to_shost(phy) \ #define phy_to_shost(phy) \
dev_to_shost((phy)->dev.parent) dev_to_shost((phy)->dev.parent)
@ -96,8 +96,8 @@ struct sas_rphy {
#define dev_to_rphy(d) \ #define dev_to_rphy(d) \
container_of((d), struct sas_rphy, dev) container_of((d), struct sas_rphy, dev)
#define transport_class_to_rphy(cdev) \ #define transport_class_to_rphy(dev) \
dev_to_rphy((cdev)->dev) dev_to_rphy((dev)->parent)
#define rphy_to_shost(rphy) \ #define rphy_to_shost(rphy) \
dev_to_shost((rphy)->dev.parent) dev_to_shost((rphy)->dev.parent)
#define target_to_rphy(targ) \ #define target_to_rphy(targ) \
@ -152,8 +152,8 @@ struct sas_port {
#define dev_to_sas_port(d) \ #define dev_to_sas_port(d) \
container_of((d), struct sas_port, dev) container_of((d), struct sas_port, dev)
#define transport_class_to_sas_port(cdev) \ #define transport_class_to_sas_port(dev) \
dev_to_sas_port((cdev)->dev) dev_to_sas_port((dev)->parent)
struct sas_phy_linkrates { struct sas_phy_linkrates {
enum sas_linkrate maximum_linkrate; enum sas_linkrate maximum_linkrate;

4
include/scsi/sd.h
View file

@ -34,7 +34,7 @@
struct scsi_disk { struct scsi_disk {
struct scsi_driver *driver; /* always &sd_template */ struct scsi_driver *driver; /* always &sd_template */
struct scsi_device *device; struct scsi_device *device;
struct class_device cdev; struct device dev;
struct gendisk *disk; struct gendisk *disk;
unsigned int openers; /* protected by BKL for now, yuck */ unsigned int openers; /* protected by BKL for now, yuck */
sector_t capacity; /* size in 512-byte sectors */ sector_t capacity; /* size in 512-byte sectors */
@ -46,7 +46,7 @@ struct scsi_disk {
unsigned RCD : 1; /* state of disk RCD bit, unused */ unsigned RCD : 1; /* state of disk RCD bit, unused */
unsigned DPOFUA : 1; /* state of disk DPOFUA bit */ unsigned DPOFUA : 1; /* state of disk DPOFUA bit */
}; };
#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,cdev) #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
#define sd_printk(prefix, sdsk, fmt, a...) \ #define sd_printk(prefix, sdsk, fmt, a...) \
(sdsk)->disk ? \ (sdsk)->disk ? \