Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit d0a7e574007fd547d72ec693bfa35778623d0738

Authored by James Bottomley 2005-08-15 06:09:01 +0800

Committed by James Bottomley 2005-08-15 06:21:27 +0800

Exists in master and in 7 other branches

[SCSI] correct transport class abstraction to work outside SCSI

I recently tried to construct a totally generic transport class and
found there were certain features missing from the current abstract
transport class.  Most notable is that you have to hang the data on the
class_device but most of the API is framed in terms of the generic
device, not the class_device.

These changes are two fold

- Provide the class_device to all of the setup and configure APIs
- Provide and extra API to take the device and the attribute class and
  return the corresponding class_device

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

Showing 6 changed files with 72 additions and 20 deletions Inline Diff

drivers/base/attribute_container.c
drivers/base/transport_class.c
drivers/scsi/scsi_transport_fc.c
drivers/scsi/scsi_transport_spi.c
include/linux/attribute_container.h
include/linux/transport_class.h

drivers/base/attribute_container.c

Diff comments View file @ d0a7e57

 /*
  * attribute_container.c - implementation of a simple container for classes
  *
  * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
  *
  * This file is licensed under GPLv2
  *
  * The basic idea here is to enable a device to be attached to an
  * aritrary numer of classes without having to allocate storage for them.
  * Instead, the contained classes select the devices they need to attach
  * to via a matching function.
  */
 #include <linux/attribute_container.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/module.h>
 /* This is a private structure used to tie the classdev and the
  * container .. it should never be visible outside this file */
 struct internal_container {
 	struct list_head node;
 	struct attribute_container *cont;
 	struct class_device classdev;
 };
 /**
  * attribute_container_classdev_to_container - given a classdev, return the container
  *
  * @classdev: the class device created by attribute_container_add_device.
  *
  * Returns the container associated with this classdev.
  */
 struct attribute_container *
 attribute_container_classdev_to_container(struct class_device *classdev)
 {
 	struct internal_container *ic =
 		container_of(classdev, struct internal_container, classdev);
 	return ic->cont;
 }
 EXPORT_SYMBOL_GPL(attribute_container_classdev_to_container);
 static struct list_head attribute_container_list;
 static DECLARE_MUTEX(attribute_container_mutex);
 /**
  * attribute_container_register - register an attribute container
  *
  * @cont: The container to register.  This must be allocated by the
  *        callee and should also be zeroed by it.
  */
 int
 attribute_container_register(struct attribute_container *cont)
 {
 	INIT_LIST_HEAD(&cont->node);
 	INIT_LIST_HEAD(&cont->containers);
+	spin_lock_init(&cont->containers_lock);
 	down(&attribute_container_mutex);
 	list_add_tail(&cont->node, &attribute_container_list);
 	up(&attribute_container_mutex);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(attribute_container_register);
 /**
  * attribute_container_unregister - remove a container registration
  *
  * @cont: previously registered container to remove
  */
 int
 attribute_container_unregister(struct attribute_container *cont)
 {
 	int retval = -EBUSY;
 	down(&attribute_container_mutex);
+	spin_lock(&cont->containers_lock);
 	if (!list_empty(&cont->containers))
 		goto out;
 	retval = 0;
 	list_del(&cont->node);
  out:
+	spin_unlock(&cont->containers_lock);
 	up(&attribute_container_mutex);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(attribute_container_unregister);
 /* private function used as class release */
 static void attribute_container_release(struct class_device *classdev)
 {
 	struct internal_container *ic
 		= container_of(classdev, struct internal_container, classdev);
 	struct device *dev = classdev->dev;
 	kfree(ic);
 	put_device(dev);
 }
 /**
  * attribute_container_add_device - see if any container is interested in dev
  *
  * @dev: device to add attributes to
  * @fn:	 function to trigger addition of class device.
  *
  * This function allocates storage for the class device(s) to be
  * attached to dev (one for each matching attribute_container).  If no
  * fn is provided, the code will simply register the class device via
  * class_device_add.  If a function is provided, it is expected to add
  * the class device at the appropriate time.  One of the things that
  * might be necessary is to allocate and initialise the classdev and
  * then add it a later time.  To do this, call this routine for
  * allocation and initialisation and then use
  * attribute_container_device_trigger() to call class_device_add() on
  * it.  Note: after this, the class device contains a reference to dev
  * which is not relinquished until the release of the classdev.
  */
 void
 attribute_container_add_device(struct device *dev,
 			       int (*fn)(struct attribute_container *,
 					 struct device *,
 					 struct class_device *))
 {
 	struct attribute_container *cont;
 	down(&attribute_container_mutex);
 	list_for_each_entry(cont, &attribute_container_list, node) {
 		struct internal_container *ic;
 		if (attribute_container_no_classdevs(cont))
 			continue;
 		if (!cont->match(cont, dev))
 			continue;
 		ic = kmalloc(sizeof(struct internal_container), GFP_KERNEL);
 		if (!ic) {
 			dev_printk(KERN_ERR, dev, "failed to allocate class container\n");
 			continue;
 		}
 		memset(ic, 0, sizeof(struct internal_container));
 		INIT_LIST_HEAD(&ic->node);
 		ic->cont = cont;
 		class_device_initialize(&ic->classdev);
 		ic->classdev.dev = get_device(dev);
 		ic->classdev.class = cont->class;
 		cont->class->release = attribute_container_release;
 		strcpy(ic->classdev.class_id, dev->bus_id);
 		if (fn)
 			fn(cont, dev, &ic->classdev);
 		else
 			attribute_container_add_class_device(&ic->classdev);
+		spin_lock(&cont->containers_lock);
 		list_add_tail(&ic->node, &cont->containers);
+		spin_unlock(&cont->containers_lock);
 	}
 	up(&attribute_container_mutex);
 }
 /**
  * attribute_container_remove_device - make device eligible for removal.
  *
  * @dev:  The generic device
  * @fn:	  A function to call to remove the device
  *
  * This routine triggers device removal.  If fn is NULL, then it is
  * simply done via class_device_unregister (note that if something
  * still has a reference to the classdev, then the memory occupied
  * will not be freed until the classdev is released).  If you want a
  * two phase release: remove from visibility and then delete the
  * device, then you should use this routine with a fn that calls
  * class_device_del() and then use
  * attribute_container_device_trigger() to do the final put on the
  * classdev.
  */
 void
 attribute_container_remove_device(struct device *dev,
 				  void (*fn)(struct attribute_container *,
 					     struct device *,
 					     struct class_device *))
 {
 	struct attribute_container *cont;
 	down(&attribute_container_mutex);
 	list_for_each_entry(cont, &attribute_container_list, node) {
 		struct internal_container *ic, *tmp;
 		if (attribute_container_no_classdevs(cont))
 			continue;
 		if (!cont->match(cont, dev))
 			continue;
+		spin_lock(&cont->containers_lock);
 		list_for_each_entry_safe(ic, tmp, &cont->containers, node) {
 			if (dev != ic->classdev.dev)
 				continue;
 			list_del(&ic->node);
 			if (fn)
 				fn(cont, dev, &ic->classdev);
 			else {
 				attribute_container_remove_attrs(&ic->classdev);
 				class_device_unregister(&ic->classdev);
 			}
 		}
+		spin_unlock(&cont->containers_lock);
 	}
 	up(&attribute_container_mutex);
 }
 EXPORT_SYMBOL_GPL(attribute_container_remove_device);
 /**
  * attribute_container_device_trigger - execute a trigger for each matching classdev
  *
  * @dev:  The generic device to run the trigger for
  * @fn	  the function to execute for each classdev.
  *
  * This funcion is for executing a trigger when you need to know both
  * the container and the classdev.  If you only care about the
  * container, then use attribute_container_trigger() instead.
  */
 void
 attribute_container_device_trigger(struct device *dev,
 				   int (*fn)(struct attribute_container *,
 					     struct device *,
 					     struct class_device *))
 {
 	struct attribute_container *cont;
 	down(&attribute_container_mutex);
 	list_for_each_entry(cont, &attribute_container_list, node) {
 		struct internal_container *ic, *tmp;
 		if (!cont->match(cont, dev))
 			continue;
+		spin_lock(&cont->containers_lock);
 		list_for_each_entry_safe(ic, tmp, &cont->containers, node) {
 			if (dev == ic->classdev.dev)
 				fn(cont, dev, &ic->classdev);
 		}
+		spin_unlock(&cont->containers_lock);
 	}
 	up(&attribute_container_mutex);
 }
 EXPORT_SYMBOL_GPL(attribute_container_device_trigger);
 /**
  * attribute_container_trigger - trigger a function for each matching container
  *
  * @dev:  The generic device to activate the trigger for
  * @fn:	  the function to trigger
  *
  * This routine triggers a function that only needs to know the
  * matching containers (not the classdev) associated with a device.
  * It is more lightweight than attribute_container_device_trigger, so
  * should be used in preference unless the triggering function
  * actually needs to know the classdev.
  */
 void
 attribute_container_trigger(struct device *dev,
 			    int (*fn)(struct attribute_container *,
 				      struct device *))
 {
 	struct attribute_container *cont;
 	down(&attribute_container_mutex);
 	list_for_each_entry(cont, &attribute_container_list, node) {
 		if (cont->match(cont, dev))
 			fn(cont, dev);
 	}
 	up(&attribute_container_mutex);
 }
 EXPORT_SYMBOL_GPL(attribute_container_trigger);
 /**
  * attribute_container_add_attrs - add attributes
  *
  * @classdev: The class device
  *
  * This simply creates all the class device sysfs files from the
  * attributes listed in the container
  */
 int
 attribute_container_add_attrs(struct class_device *classdev)
 {
 	struct attribute_container *cont =
 		attribute_container_classdev_to_container(classdev);
 	struct class_device_attribute **attrs =	cont->attrs;
 	int i, error;
 	if (!attrs)
 		return 0;
 	for (i = 0; attrs[i]; i++) {
 		error = class_device_create_file(classdev, attrs[i]);
 		if (error)
 			return error;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(attribute_container_add_attrs);
 /**
  * attribute_container_add_class_device - same function as class_device_add
  *
  * @classdev:	the class device to add
  *
  * This performs essentially the same function as class_device_add except for
  * attribute containers, namely add the classdev to the system and then
  * create the attribute files
  */
 int
 attribute_container_add_class_device(struct class_device *classdev)
 {
 	int error = class_device_add(classdev);
 	if (error)
 		return error;
 	return attribute_container_add_attrs(classdev);
 }
 EXPORT_SYMBOL_GPL(attribute_container_add_class_device);
 /**
  * attribute_container_add_class_device_adapter - simple adapter for triggers
  *
  * This function is identical to attribute_container_add_class_device except
  * that it is designed to be called from the triggers
  */
 int
 attribute_container_add_class_device_adapter(struct attribute_container *cont,
 					     struct device *dev,
 					     struct class_device *classdev)
 {
 	return attribute_container_add_class_device(classdev);
 }
 EXPORT_SYMBOL_GPL(attribute_container_add_class_device_adapter);
 /**
  * attribute_container_remove_attrs - remove any attribute files
  *
  * @classdev: The class device to remove the files from
  *
  */
 void
 attribute_container_remove_attrs(struct class_device *classdev)
 {
 	struct attribute_container *cont =
 		attribute_container_classdev_to_container(classdev);
 	struct class_device_attribute **attrs =	cont->attrs;
 	int i;
 	if (!attrs)
 		return;
 	for (i = 0; attrs[i]; i++)
 		class_device_remove_file(classdev, attrs[i]);
 }
 EXPORT_SYMBOL_GPL(attribute_container_remove_attrs);
 /**
  * attribute_container_class_device_del - equivalent of class_device_del
  *
  * @classdev: the class device
  *
  * This function simply removes all the attribute files and then calls
  * class_device_del.
  */
 void
 attribute_container_class_device_del(struct class_device *classdev)
 {
 	attribute_container_remove_attrs(classdev);
 	class_device_del(classdev);
 }
 EXPORT_SYMBOL_GPL(attribute_container_class_device_del);
+/**
+ * attribute_container_find_class_device - find the corresponding class_device
+ *
+ * @cont:	the container
+ * @dev:	the generic device
+ *
+ * Looks up the device in the container's list of class devices and returns
+ * the corresponding class_device.
+ */
+struct class_device *
+attribute_container_find_class_device(struct attribute_container *cont,
+				      struct device *dev)
+{
+	struct class_device *cdev = NULL;
+	struct internal_container *ic;
+	spin_lock(&cont->containers_lock);
+	list_for_each_entry(ic, &cont->containers, node) {
+		if (ic->classdev.dev == dev) {
+			cdev = &ic->classdev;
+			break;
+		}
+	}
+	spin_unlock(&cont->containers_lock);
+	return cdev;
+}
+EXPORT_SYMBOL_GPL(attribute_container_find_class_device);
 int __init
 attribute_container_init(void)
 {
 	INIT_LIST_HEAD(&attribute_container_list);
 	return 0;
 }

drivers/base/transport_class.c

Diff comments View file @ d0a7e57

 /*
  * transport_class.c - implementation of generic transport classes
  *                     using attribute_containers
  *
  * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
  *
  * This file is licensed under GPLv2
  *
  * The basic idea here is to allow any "device controller" (which
  * would most often be a Host Bus Adapter" to use the services of one
  * or more tranport classes for performing transport specific
  * services.  Transport specific services are things that the generic
  * command layer doesn't want to know about (speed settings, line
  * condidtioning, etc), but which the user might be interested in.
  * Thus, the HBA's use the routines exported by the transport classes
  * to perform these functions.  The transport classes export certain
  * values to the user via sysfs using attribute containers.
  *
  * Note: because not every HBA will care about every transport
  * attribute, there's a many to one relationship that goes like this:
  *
  * transport class<-----attribute container<----class device
  *
  * Usually the attribute container is per-HBA, but the design doesn't
  * mandate that.  Although most of the services will be specific to
  * the actual external storage connection used by the HBA, the generic
  * transport class is framed entirely in terms of generic devices to
  * allow it to be used by any physical HBA in the system.
  */
 #include <linux/attribute_container.h>
 #include <linux/transport_class.h>
 /**
  * transport_class_register - register an initial transport class
  *
  * @tclass:	a pointer to the transport class structure to be initialised
  *
  * The transport class contains an embedded class which is used to
  * identify it.  The caller should initialise this structure with
  * zeros and then generic class must have been initialised with the
  * actual transport class unique name.  There's a macro
  * DECLARE_TRANSPORT_CLASS() to do this (declared classes still must
  * be registered).
  *
  * Returns 0 on success or error on failure.
  */
 int transport_class_register(struct transport_class *tclass)
 {
 	return class_register(&tclass->class);
 }
 EXPORT_SYMBOL_GPL(transport_class_register);
 /**
  * transport_class_unregister - unregister a previously registered class
  *
  * @tclass: The transport class to unregister
  *
  * Must be called prior to deallocating the memory for the transport
  * class.
  */
 void transport_class_unregister(struct transport_class *tclass)
 {
 	class_unregister(&tclass->class);
 }
 EXPORT_SYMBOL_GPL(transport_class_unregister);
-static int anon_transport_dummy_function(struct device *dev)
+static int anon_transport_dummy_function(struct transport_container *tc,
+					 struct device *dev,
+					 struct class_device *cdev)
 {
 	/* do nothing */
 	return 0;
 }
 /**
  * anon_transport_class_register - register an anonymous class
  *
  * @atc: The anon transport class to register
  *
  * The anonymous transport class contains both a transport class and a
  * container.  The idea of an anonymous class is that it never
  * actually has any device attributes associated with it (and thus
  * saves on container storage).  So it can only be used for triggering
  * events.  Use prezero and then use DECLARE_ANON_TRANSPORT_CLASS() to
  * initialise the anon transport class storage.
  */
 int anon_transport_class_register(struct anon_transport_class *atc)
 {
 	int error;
 	atc->container.class = &atc->tclass.class;
 	attribute_container_set_no_classdevs(&atc->container);
 	error = attribute_container_register(&atc->container);
 	if (error)
 		return error;
 	atc->tclass.setup = anon_transport_dummy_function;
 	atc->tclass.remove = anon_transport_dummy_function;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(anon_transport_class_register);
 /**
  * anon_transport_class_unregister - unregister an anon class
  *
  * @atc: Pointer to the anon transport class to unregister
  *
  * Must be called prior to deallocating the memory for the anon
  * transport class.
  */
 void anon_transport_class_unregister(struct anon_transport_class *atc)
 {
 	attribute_container_unregister(&atc->container);
 }
 EXPORT_SYMBOL_GPL(anon_transport_class_unregister);
 static int transport_setup_classdev(struct attribute_container *cont,
 				    struct device *dev,
 				    struct class_device *classdev)
 {
 	struct transport_class *tclass = class_to_transport_class(cont->class);
+	struct transport_container *tcont = attribute_container_to_transport_container(cont);
 	if (tclass->setup)
-		tclass->setup(dev);
+		tclass->setup(tcont, dev, classdev);
 	return 0;
 }
 /**
  * transport_setup_device - declare a new dev for transport class association
  *			    but don't make it visible yet.
  *
  * @dev: the generic device representing the entity being added
  *
  * Usually, dev represents some component in the HBA system (either
  * the HBA itself or a device remote across the HBA bus).  This
  * routine is simply a trigger point to see if any set of transport
  * classes wishes to associate with the added device.  This allocates
  * storage for the class device and initialises it, but does not yet
  * add it to the system or add attributes to it (you do this with
  * transport_add_device).  If you have no need for a separate setup
  * and add operations, use transport_register_device (see
  * transport_class.h).
  */
 void transport_setup_device(struct device *dev)
 {
 	attribute_container_add_device(dev, transport_setup_classdev);
 }
 EXPORT_SYMBOL_GPL(transport_setup_device);
 static int transport_add_class_device(struct attribute_container *cont,
 				      struct device *dev,
 				      struct class_device *classdev)
 {
 	int error = attribute_container_add_class_device(classdev);
 	struct transport_container *tcont =
 		attribute_container_to_transport_container(cont);
 	if (!error && tcont->statistics)
 		error = sysfs_create_group(&classdev->kobj, tcont->statistics);
 	return error;
 }
 /**
  * transport_add_device - declare a new dev for transport class association
  *
  * @dev: the generic device representing the entity being added
  *
  * Usually, dev represents some component in the HBA system (either
  * the HBA itself or a device remote across the HBA bus).  This
  * routine is simply a trigger point used to add the device to the
  * system and register attributes for it.
  */
 void transport_add_device(struct device *dev)
 {
 	attribute_container_device_trigger(dev, transport_add_class_device);
 }
 EXPORT_SYMBOL_GPL(transport_add_device);
 static int transport_configure(struct attribute_container *cont,
-			       struct device *dev)
+			       struct device *dev,
+			       struct class_device *cdev)
 {
 	struct transport_class *tclass = class_to_transport_class(cont->class);
+	struct transport_container *tcont = attribute_container_to_transport_container(cont);
 	if (tclass->configure)
-		tclass->configure(dev);
+		tclass->configure(tcont, dev, cdev);
 	return 0;
 }
 /**
  * transport_configure_device - configure an already set up device
  *
  * @dev: generic device representing device to be configured
  *
  * The idea of configure is simply to provide a point within the setup
  * process to allow the transport class to extract information from a
  * device after it has been setup.  This is used in SCSI because we
  * have to have a setup device to begin using the HBA, but after we
  * send the initial inquiry, we use configure to extract the device
  * parameters.  The device need not have been added to be configured.
  */
 void transport_configure_device(struct device *dev)
 {
-	attribute_container_trigger(dev, transport_configure);
+	attribute_container_device_trigger(dev, transport_configure);
 }
 EXPORT_SYMBOL_GPL(transport_configure_device);
 static int transport_remove_classdev(struct attribute_container *cont,
 				     struct device *dev,
 				     struct class_device *classdev)
 {
 	struct transport_container *tcont =
 		attribute_container_to_transport_container(cont);
 	struct transport_class *tclass = class_to_transport_class(cont->class);
 	if (tclass->remove)
-		tclass->remove(dev);
+		tclass->remove(tcont, dev, classdev);
 	if (tclass->remove != anon_transport_dummy_function) {
 		if (tcont->statistics)
 			sysfs_remove_group(&classdev->kobj, tcont->statistics);
 		attribute_container_class_device_del(classdev);
 	}
 	return 0;
 }
 /**
  * transport_remove_device - remove the visibility of a device
  *
  * @dev: generic device to remove
  *
  * This call removes the visibility of the device (to the user from
  * sysfs), but does not destroy it.  To eliminate a device entirely
  * you must also call transport_destroy_device.  If you don't need to
  * do remove and destroy as separate operations, use
  * transport_unregister_device() (see transport_class.h) which will
  * perform both calls for you.
  */
 void transport_remove_device(struct device *dev)
 {
 	attribute_container_device_trigger(dev, transport_remove_classdev);
 }
 EXPORT_SYMBOL_GPL(transport_remove_device);
 static void transport_destroy_classdev(struct attribute_container *cont,
 				      struct device *dev,
 				      struct class_device *classdev)
 {
 	struct transport_class *tclass = class_to_transport_class(cont->class);
 	if (tclass->remove != anon_transport_dummy_function)
 		class_device_put(classdev);
 }
 /**
  * transport_destroy_device - destroy a removed device
  *
  * @dev: device to eliminate from the transport class.
  *
  * This call triggers the elimination of storage associated with the
  * transport classdev.  Note: all it really does is relinquish a
  * reference to the classdev.  The memory will not be freed until the
  * last reference goes to zero.  Note also that the classdev retains a
  * reference count on dev, so dev too will remain for as long as the
  * transport class device remains around.
  */
 void transport_destroy_device(struct device *dev)
 {
 	attribute_container_remove_device(dev, transport_destroy_classdev);
 }
 EXPORT_SYMBOL_GPL(transport_destroy_device);

drivers/scsi/scsi_transport_fc.c

Diff comments View file @ d0a7e57

 /*
  *  FiberChannel transport specific attributes exported to sysfs.
  *
  *  Copyright (c) 2003 Silicon Graphics, Inc.  All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  *  ========
  *
  *  Copyright (C) 2004-2005   James Smart, Emulex Corporation
  *    Rewrite for host, target, device, and remote port attributes,
  *    statistics, and service functions...
  *
  */
 #include <linux/module.h>
 #include <linux/init.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_fc.h>
 #include "scsi_priv.h"
 #define FC_PRINTK(x, l, f, a...)	printk(l "scsi(%d:%d:%d:%d): " f, (x)->host->host_no, (x)->channel, (x)->id, (x)->lun , ##a)
 /*
  * Redefine so that we can have same named attributes in the
  * sdev/starget/host objects.
  */
 #define FC_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store)		\
 struct class_device_attribute class_device_attr_##_prefix##_##_name = 	\
 	__ATTR(_name,_mode,_show,_store)
 #define fc_enum_name_search(title, table_type, table)			\
 static const char *get_fc_##title##_name(enum table_type table_key)	\
 {									\
 	int i;								\
 	char *name = NULL;						\
 									\
 	for (i = 0; i < sizeof(table)/sizeof(table[0]); i++) {		\
 		if (table[i].value == table_key) {			\
 			name = table[i].name;				\
 			break;						\
 		}							\
 	}								\
 	return name;							\
 }
 #define fc_enum_name_match(title, table_type, table)			\
 static int get_fc_##title##_match(const char *table_key,		\
 		enum table_type *value)					\
 {									\
 	int i;								\
 									\
 	for (i = 0; i < sizeof(table)/sizeof(table[0]); i++) {		\
 		if (strncmp(table_key, table[i].name,			\
 				table[i].matchlen) == 0) {		\
 			*value = table[i].value;			\
 			return 0; /* success */				\
 		}							\
 	}								\
 	return 1; /* failure */						\
 }
 /* Convert fc_port_type values to ascii string name */
 static struct {
 	enum fc_port_type	value;
 	char			*name;
 } fc_port_type_names[] = {
 	{ FC_PORTTYPE_UNKNOWN,		"Unknown" },
 	{ FC_PORTTYPE_OTHER,		"Other" },
 	{ FC_PORTTYPE_NOTPRESENT,	"Not Present" },
 	{ FC_PORTTYPE_NPORT,	"NPort (fabric via point-to-point)" },
 	{ FC_PORTTYPE_NLPORT,	"NLPort (fabric via loop)" },
 	{ FC_PORTTYPE_LPORT,	"LPort (private loop)" },
 	{ FC_PORTTYPE_PTP,	"Point-To-Point (direct nport connection" },
 };
 fc_enum_name_search(port_type, fc_port_type, fc_port_type_names)
 #define FC_PORTTYPE_MAX_NAMELEN		50
 /* Convert fc_port_state values to ascii string name */
 static struct {
 	enum fc_port_state	value;
 	char			*name;
 } fc_port_state_names[] = {
 	{ FC_PORTSTATE_UNKNOWN,		"Unknown" },
 	{ FC_PORTSTATE_NOTPRESENT,	"Not Present" },
 	{ FC_PORTSTATE_ONLINE,		"Online" },
 	{ FC_PORTSTATE_OFFLINE,		"Offline" },
 	{ FC_PORTSTATE_BLOCKED,		"Blocked" },
 	{ FC_PORTSTATE_BYPASSED,	"Bypassed" },
 	{ FC_PORTSTATE_DIAGNOSTICS,	"Diagnostics" },
 	{ FC_PORTSTATE_LINKDOWN,	"Linkdown" },
 	{ FC_PORTSTATE_ERROR,		"Error" },
 	{ FC_PORTSTATE_LOOPBACK,	"Loopback" },
 };
 fc_enum_name_search(port_state, fc_port_state, fc_port_state_names)
 #define FC_PORTSTATE_MAX_NAMELEN	20
 /* Convert fc_tgtid_binding_type values to ascii string name */
 static struct {
 	enum fc_tgtid_binding_type	value;
 	char				*name;
 	int				matchlen;
 } fc_tgtid_binding_type_names[] = {
 	{ FC_TGTID_BIND_NONE, "none", 4 },
 	{ FC_TGTID_BIND_BY_WWPN, "wwpn (World Wide Port Name)", 4 },
 	{ FC_TGTID_BIND_BY_WWNN, "wwnn (World Wide Node Name)", 4 },
 	{ FC_TGTID_BIND_BY_ID, "port_id (FC Address)", 7 },
 };
 fc_enum_name_search(tgtid_bind_type, fc_tgtid_binding_type,
 		fc_tgtid_binding_type_names)
 fc_enum_name_match(tgtid_bind_type, fc_tgtid_binding_type,
 		fc_tgtid_binding_type_names)
 #define FC_BINDTYPE_MAX_NAMELEN	30
 #define fc_bitfield_name_search(title, table)			\
 static ssize_t							\
 get_fc_##title##_names(u32 table_key, char *buf)		\
 {								\
 	char *prefix = "";					\
 	ssize_t len = 0;					\
 	int i;							\
 								\
 	for (i = 0; i < sizeof(table)/sizeof(table[0]); i++) {	\
 		if (table[i].value & table_key) {		\
 			len += sprintf(buf + len, "%s%s",	\
 				prefix, table[i].name);		\
 			prefix = ", ";				\
 		}						\
 	}							\
 	len += sprintf(buf + len, "\n");			\
 	return len;						\
 }
 /* Convert FC_COS bit values to ascii string name */
 static struct {
 	u32 			value;
 	char			*name;
 } fc_cos_names[] = {
 	{ FC_COS_CLASS1,	"Class 1" },
 	{ FC_COS_CLASS2,	"Class 2" },
 	{ FC_COS_CLASS3,	"Class 3" },
 	{ FC_COS_CLASS4,	"Class 4" },
 	{ FC_COS_CLASS6,	"Class 6" },
 };
 fc_bitfield_name_search(cos, fc_cos_names)
 /* Convert FC_PORTSPEED bit values to ascii string name */
 static struct {
 	u32 			value;
 	char			*name;
 } fc_port_speed_names[] = {
 	{ FC_PORTSPEED_1GBIT,		"1 Gbit" },
 	{ FC_PORTSPEED_2GBIT,		"2 Gbit" },
 	{ FC_PORTSPEED_4GBIT,		"4 Gbit" },
 	{ FC_PORTSPEED_10GBIT,		"10 Gbit" },
 	{ FC_PORTSPEED_NOT_NEGOTIATED,	"Not Negotiated" },
 };
 fc_bitfield_name_search(port_speed, fc_port_speed_names)
 static int
 show_fc_fc4s (char *buf, u8 *fc4_list)
 {
 	int i, len=0;
 	for (i = 0; i < FC_FC4_LIST_SIZE; i++, fc4_list++)
 		len += sprintf(buf + len , "0x%02x ", *fc4_list);
 	len += sprintf(buf + len, "\n");
 	return len;
 }
 /* Convert FC_RPORT_ROLE bit values to ascii string name */
 static struct {
 	u32 			value;
 	char			*name;
 } fc_remote_port_role_names[] = {
 	{ FC_RPORT_ROLE_FCP_TARGET,	"FCP Target" },
 	{ FC_RPORT_ROLE_FCP_INITIATOR,	"FCP Initiator" },
 	{ FC_RPORT_ROLE_IP_PORT,	"IP Port" },
 };
 fc_bitfield_name_search(remote_port_roles, fc_remote_port_role_names)
 /*
  * Define roles that are specific to port_id. Values are relative to ROLE_MASK.
  */
 #define FC_WELLKNOWN_PORTID_MASK	0xfffff0
 #define FC_WELLKNOWN_ROLE_MASK  	0x00000f
 #define FC_FPORT_PORTID			0x00000e
 #define FC_FABCTLR_PORTID		0x00000d
 #define FC_DIRSRVR_PORTID		0x00000c
 #define FC_TIMESRVR_PORTID		0x00000b
 #define FC_MGMTSRVR_PORTID		0x00000a
 static void fc_timeout_blocked_rport(void *data);
 static void fc_scsi_scan_rport(void *data);
 static void fc_rport_terminate(struct fc_rport  *rport);
 /*
  * Attribute counts pre object type...
  * Increase these values if you add attributes
  */
 #define FC_STARGET_NUM_ATTRS 	3
 #define FC_RPORT_NUM_ATTRS	9
 #define FC_HOST_NUM_ATTRS	15
 struct fc_internal {
 	struct scsi_transport_template t;
 	struct fc_function_template *f;
 	/*
 	 * For attributes : each object has :
 	 *   An array of the actual attributes structures
 	 *   An array of null-terminated pointers to the attribute
 	 *     structures - used for mid-layer interaction.
 	 *
 	 * The attribute containers for the starget and host are are
 	 * part of the midlayer. As the remote port is specific to the
 	 * fc transport, we must provide the attribute container.
 	 */
 	struct class_device_attribute private_starget_attrs[
 							FC_STARGET_NUM_ATTRS];
 	struct class_device_attribute *starget_attrs[FC_STARGET_NUM_ATTRS + 1];
 	struct class_device_attribute private_host_attrs[FC_HOST_NUM_ATTRS];
 	struct class_device_attribute *host_attrs[FC_HOST_NUM_ATTRS + 1];
 	struct transport_container rport_attr_cont;
 	struct class_device_attribute private_rport_attrs[FC_RPORT_NUM_ATTRS];
 	struct class_device_attribute *rport_attrs[FC_RPORT_NUM_ATTRS + 1];
 };
 #define to_fc_internal(tmpl)	container_of(tmpl, struct fc_internal, t)
-static int fc_target_setup(struct device *dev)
+static int fc_target_setup(struct transport_container *tc, struct device *dev,
+			   struct class_device *cdev)
 {
 	struct scsi_target *starget = to_scsi_target(dev);
 	struct fc_rport *rport = starget_to_rport(starget);
 	/*
 	 * if parent is remote port, use values from remote port.
 	 * Otherwise, this host uses the fc_transport, but not the
 	 * remote port interface. As such, initialize to known non-values.
 	 */
 	if (rport) {
 		fc_starget_node_name(starget) = rport->node_name;
 		fc_starget_port_name(starget) = rport->port_name;
 		fc_starget_port_id(starget) = rport->port_id;
 	} else {
 		fc_starget_node_name(starget) = -1;
 		fc_starget_port_name(starget) = -1;
 		fc_starget_port_id(starget) = -1;
 	}
 	return 0;
 }
 static DECLARE_TRANSPORT_CLASS(fc_transport_class,
 			       "fc_transport",
 			       fc_target_setup,
 			       NULL,
 			       NULL);
-static int fc_host_setup(struct device *dev)
+static int fc_host_setup(struct transport_container *tc, struct device *dev,
+			 struct class_device *cdev)
 {
 	struct Scsi_Host *shost = dev_to_shost(dev);
 	/*
 	 * Set default values easily detected by the midlayer as
 	 * failure cases.  The scsi lldd is responsible for initializing
 	 * all transport attributes to valid values per host.
 	 */
 	fc_host_node_name(shost) = -1;
 	fc_host_port_name(shost) = -1;
 	fc_host_supported_classes(shost) = FC_COS_UNSPECIFIED;
 	memset(fc_host_supported_fc4s(shost), 0,
 		sizeof(fc_host_supported_fc4s(shost)));
 	memset(fc_host_symbolic_name(shost), 0,
 		sizeof(fc_host_symbolic_name(shost)));
 	fc_host_supported_speeds(shost) = FC_PORTSPEED_UNKNOWN;
 	fc_host_maxframe_size(shost) = -1;
 	memset(fc_host_serial_number(shost), 0,
 		sizeof(fc_host_serial_number(shost)));
 	fc_host_port_id(shost) = -1;
 	fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
 	fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
 	memset(fc_host_active_fc4s(shost), 0,
 		sizeof(fc_host_active_fc4s(shost)));
 	fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
 	fc_host_fabric_name(shost) = -1;
 	fc_host_tgtid_bind_type(shost) = FC_TGTID_BIND_BY_WWPN;
 	INIT_LIST_HEAD(&fc_host_rports(shost));
 	INIT_LIST_HEAD(&fc_host_rport_bindings(shost));
 	fc_host_next_rport_number(shost) = 0;
 	fc_host_next_target_id(shost) = 0;
 	return 0;
 }
 static DECLARE_TRANSPORT_CLASS(fc_host_class,
 			       "fc_host",
 			       fc_host_setup,
 			       NULL,
 			       NULL);
 /*
  * Setup and Remove actions for remote ports are handled
  * in the service functions below.
  */
 static DECLARE_TRANSPORT_CLASS(fc_rport_class,
 			       "fc_remote_ports",
 			       NULL,
 			       NULL,
 			       NULL);
 /*
  * Module Parameters
  */
 /*
  * dev_loss_tmo: the default number of seconds that the FC transport
  *   should insulate the loss of a remote port.
  *   The maximum will be capped by the value of SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
  */
 static unsigned int fc_dev_loss_tmo = SCSI_DEVICE_BLOCK_MAX_TIMEOUT;
 module_param_named(dev_loss_tmo, fc_dev_loss_tmo, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(dev_loss_tmo,
 		 "Maximum number of seconds that the FC transport should"
 		 " insulate the loss of a remote port. Once this value is"
 		 " exceeded, the scsi target is removed. Value should be"
 		 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT.");
 static __init int fc_transport_init(void)
 {
 	int error = transport_class_register(&fc_host_class);
 	if (error)
 		return error;
 	error = transport_class_register(&fc_rport_class);
 	if (error)
 		return error;
 	return transport_class_register(&fc_transport_class);
 }
 static void __exit fc_transport_exit(void)
 {
 	transport_class_unregister(&fc_transport_class);
 	transport_class_unregister(&fc_rport_class);
 	transport_class_unregister(&fc_host_class);
 }
 /*
  * FC Remote Port Attribute Management
  */
 #define fc_rport_show_function(field, format_string, sz, cast)		\
 static ssize_t								\
 show_fc_rport_##field (struct class_device *cdev, char *buf)		\
 {									\
 	struct fc_rport *rport = transport_class_to_rport(cdev);	\
 	struct Scsi_Host *shost = rport_to_shost(rport);		\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 	if (i->f->get_rport_##field)					\
 		i->f->get_rport_##field(rport);				\
 	return snprintf(buf, sz, format_string, cast rport->field); 	\
 }
 #define fc_rport_store_function(field)					\
 static ssize_t								\
 store_fc_rport_##field(struct class_device *cdev, const char *buf,	\
 			   size_t count)				\
 {									\
 	int val;							\
 	struct fc_rport *rport = transport_class_to_rport(cdev);	\
 	struct Scsi_Host *shost = rport_to_shost(rport);		\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 	val = simple_strtoul(buf, NULL, 0);				\
 	i->f->set_rport_##field(rport, val);				\
 	return count;							\
 }
 #define fc_rport_rd_attr(field, format_string, sz)			\
 	fc_rport_show_function(field, format_string, sz, )		\
 static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,			\
 			 show_fc_rport_##field, NULL)
 #define fc_rport_rd_attr_cast(field, format_string, sz, cast)		\
 	fc_rport_show_function(field, format_string, sz, (cast))	\
 static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,			\
 			  show_fc_rport_##field, NULL)
 #define fc_rport_rw_attr(field, format_string, sz)			\
 	fc_rport_show_function(field, format_string, sz, )		\
 	fc_rport_store_function(field)					\
 static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO | S_IWUSR,		\
 			show_fc_rport_##field,				\
 			store_fc_rport_##field)
 #define fc_private_rport_show_function(field, format_string, sz, cast)	\
 static ssize_t								\
 show_fc_rport_##field (struct class_device *cdev, char *buf)		\
 {									\
 	struct fc_rport *rport = transport_class_to_rport(cdev);	\
 	return snprintf(buf, sz, format_string, cast rport->field); 	\
 }
 #define fc_private_rport_rd_attr(field, format_string, sz)		\
 	fc_private_rport_show_function(field, format_string, sz, )	\
 static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,			\
 			 show_fc_rport_##field, NULL)
 #define fc_private_rport_rd_attr_cast(field, format_string, sz, cast)	\
 	fc_private_rport_show_function(field, format_string, sz, (cast)) \
 static FC_CLASS_DEVICE_ATTR(rport, field, S_IRUGO,			\
 			  show_fc_rport_##field, NULL)
 #define fc_private_rport_rd_enum_attr(title, maxlen)			\
 static ssize_t								\
 show_fc_rport_##title (struct class_device *cdev, char *buf)		\
 {									\
 	struct fc_rport *rport = transport_class_to_rport(cdev);	\
 	const char *name;						\
 	name = get_fc_##title##_name(rport->title);			\
 	if (!name)							\
 		return -EINVAL;						\
 	return snprintf(buf, maxlen, "%s\n", name);			\
 }									\
 static FC_CLASS_DEVICE_ATTR(rport, title, S_IRUGO,			\
 			show_fc_rport_##title, NULL)
 #define SETUP_RPORT_ATTRIBUTE_RD(field)					\
 	i->private_rport_attrs[count] = class_device_attr_rport_##field; \
 	i->private_rport_attrs[count].attr.mode = S_IRUGO;		\
 	i->private_rport_attrs[count].store = NULL;			\
 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
 	if (i->f->show_rport_##field)					\
 		count++
 #define SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(field)				\
 	i->private_rport_attrs[count] = class_device_attr_rport_##field; \
 	i->private_rport_attrs[count].attr.mode = S_IRUGO;		\
 	i->private_rport_attrs[count].store = NULL;			\
 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
 	count++
 #define SETUP_RPORT_ATTRIBUTE_RW(field)					\
 	i->private_rport_attrs[count] = class_device_attr_rport_##field; \
 	if (!i->f->set_rport_##field) {					\
 		i->private_rport_attrs[count].attr.mode = S_IRUGO;	\
 		i->private_rport_attrs[count].store = NULL;		\
 	}								\
 	i->rport_attrs[count] = &i->private_rport_attrs[count];		\
 	if (i->f->show_rport_##field)					\
 		count++
 /* The FC Transport Remote Port Attributes: */
 /* Fixed Remote Port Attributes */
 fc_private_rport_rd_attr(maxframe_size, "%u bytes\n", 20);
 static ssize_t
 show_fc_rport_supported_classes (struct class_device *cdev, char *buf)
 {
 	struct fc_rport *rport = transport_class_to_rport(cdev);
 	if (rport->supported_classes == FC_COS_UNSPECIFIED)
 		return snprintf(buf, 20, "unspecified\n");
 	return get_fc_cos_names(rport->supported_classes, buf);
 }
 static FC_CLASS_DEVICE_ATTR(rport, supported_classes, S_IRUGO,
 		show_fc_rport_supported_classes, NULL);
 /* Dynamic Remote Port Attributes */
 fc_rport_rw_attr(dev_loss_tmo, "%d\n", 20);
 /* Private Remote Port Attributes */
 fc_private_rport_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
 fc_private_rport_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
 fc_private_rport_rd_attr(port_id, "0x%06x\n", 20);
 static ssize_t
 show_fc_rport_roles (struct class_device *cdev, char *buf)
 {
 	struct fc_rport *rport = transport_class_to_rport(cdev);
 	/* identify any roles that are port_id specific */
 	if ((rport->port_id != -1) &&
 	    (rport->port_id & FC_WELLKNOWN_PORTID_MASK) ==
 					FC_WELLKNOWN_PORTID_MASK) {
 		switch (rport->port_id & FC_WELLKNOWN_ROLE_MASK) {
 		case FC_FPORT_PORTID:
 			return snprintf(buf, 30, "Fabric Port\n");
 		case FC_FABCTLR_PORTID:
 			return snprintf(buf, 30, "Fabric Controller\n");
 		case FC_DIRSRVR_PORTID:
 			return snprintf(buf, 30, "Directory Server\n");
 		case FC_TIMESRVR_PORTID:
 			return snprintf(buf, 30, "Time Server\n");
 		case FC_MGMTSRVR_PORTID:
 			return snprintf(buf, 30, "Management Server\n");
 		default:
 			return snprintf(buf, 30, "Unknown Fabric Entity\n");
 		}
 	} else {
 		if (rport->roles == FC_RPORT_ROLE_UNKNOWN)
 			return snprintf(buf, 20, "unknown\n");
 		return get_fc_remote_port_roles_names(rport->roles, buf);
 	}
 }
 static FC_CLASS_DEVICE_ATTR(rport, roles, S_IRUGO,
 		show_fc_rport_roles, NULL);
 fc_private_rport_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
 fc_private_rport_rd_attr(scsi_target_id, "%d\n", 20);
 /*
  * FC SCSI Target Attribute Management
  */
 /*
  * Note: in the target show function we recognize when the remote
  *  port is in the heirarchy and do not allow the driver to get
  *  involved in sysfs functions. The driver only gets involved if
  *  it's the "old" style that doesn't use rports.
  */
 #define fc_starget_show_function(field, format_string, sz, cast)	\
 static ssize_t								\
 show_fc_starget_##field (struct class_device *cdev, char *buf)		\
 {									\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);	\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 	struct fc_rport *rport = starget_to_rport(starget);		\
 	if (rport)							\
 		fc_starget_##field(starget) = rport->field;		\
 	else if (i->f->get_starget_##field)				\
 		i->f->get_starget_##field(starget);			\
 	return snprintf(buf, sz, format_string, 			\
 		cast fc_starget_##field(starget)); 			\
 }
 #define fc_starget_rd_attr(field, format_string, sz)			\
 	fc_starget_show_function(field, format_string, sz, )		\
 static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO,			\
 			 show_fc_starget_##field, NULL)
 #define fc_starget_rd_attr_cast(field, format_string, sz, cast)		\
 	fc_starget_show_function(field, format_string, sz, (cast))	\
 static FC_CLASS_DEVICE_ATTR(starget, field, S_IRUGO,			\
 			  show_fc_starget_##field, NULL)
 #define SETUP_STARGET_ATTRIBUTE_RD(field)				\
 	i->private_starget_attrs[count] = class_device_attr_starget_##field; \
 	i->private_starget_attrs[count].attr.mode = S_IRUGO;		\
 	i->private_starget_attrs[count].store = NULL;			\
 	i->starget_attrs[count] = &i->private_starget_attrs[count];	\
 	if (i->f->show_starget_##field)					\
 		count++
 #define SETUP_STARGET_ATTRIBUTE_RW(field)				\
 	i->private_starget_attrs[count] = class_device_attr_starget_##field; \
 	if (!i->f->set_starget_##field) {				\
 		i->private_starget_attrs[count].attr.mode = S_IRUGO;	\
 		i->private_starget_attrs[count].store = NULL;		\
 	}								\
 	i->starget_attrs[count] = &i->private_starget_attrs[count];	\
 	if (i->f->show_starget_##field)					\
 		count++
 /* The FC Transport SCSI Target Attributes: */
 fc_starget_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
 fc_starget_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
 fc_starget_rd_attr(port_id, "0x%06x\n", 20);
 /*
  * Host Attribute Management
  */
 #define fc_host_show_function(field, format_string, sz, cast)		\
 static ssize_t								\
 show_fc_host_##field (struct class_device *cdev, char *buf)		\
 {									\
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 	if (i->f->get_host_##field)					\
 		i->f->get_host_##field(shost);				\
 	return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
 }
 #define fc_host_store_function(field)					\
 static ssize_t								\
 store_fc_host_##field(struct class_device *cdev, const char *buf,	\
 			   size_t count)				\
 {									\
 	int val;							\
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 									\
 	val = simple_strtoul(buf, NULL, 0);				\
 	i->f->set_host_##field(shost, val);				\
 	return count;							\
 }
 #define fc_host_rd_attr(field, format_string, sz)			\
 	fc_host_show_function(field, format_string, sz, )		\
 static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 			 show_fc_host_##field, NULL)
 #define fc_host_rd_attr_cast(field, format_string, sz, cast)		\
 	fc_host_show_function(field, format_string, sz, (cast))		\
 static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 			  show_fc_host_##field, NULL)
 #define fc_host_rw_attr(field, format_string, sz)			\
 	fc_host_show_function(field, format_string, sz, )		\
 	fc_host_store_function(field)					\
 static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO | S_IWUSR,		\
 			show_fc_host_##field,				\
 			store_fc_host_##field)
 #define fc_host_rd_enum_attr(title, maxlen)				\
 static ssize_t								\
 show_fc_host_##title (struct class_device *cdev, char *buf)		\
 {									\
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
 	struct fc_internal *i = to_fc_internal(shost->transportt);	\
 	const char *name;						\
 	if (i->f->get_host_##title)					\
 		i->f->get_host_##title(shost);				\
 	name = get_fc_##title##_name(fc_host_##title(shost));		\
 	if (!name)							\
 		return -EINVAL;						\
 	return snprintf(buf, maxlen, "%s\n", name);			\
 }									\
 static FC_CLASS_DEVICE_ATTR(host, title, S_IRUGO, show_fc_host_##title, NULL)
 #define SETUP_HOST_ATTRIBUTE_RD(field)					\
 	i->private_host_attrs[count] = class_device_attr_host_##field;	\
 	i->private_host_attrs[count].attr.mode = S_IRUGO;		\
 	i->private_host_attrs[count].store = NULL;			\
 	i->host_attrs[count] = &i->private_host_attrs[count];		\
 	if (i->f->show_host_##field)					\
 		count++
 #define SETUP_HOST_ATTRIBUTE_RW(field)					\
 	i->private_host_attrs[count] = class_device_attr_host_##field;	\
 	if (!i->f->set_host_##field) {					\
 		i->private_host_attrs[count].attr.mode = S_IRUGO;	\
 		i->private_host_attrs[count].store = NULL;		\
 	}								\
 	i->host_attrs[count] = &i->private_host_attrs[count];		\
 	if (i->f->show_host_##field)					\
 		count++
 #define fc_private_host_show_function(field, format_string, sz, cast)	\
 static ssize_t								\
 show_fc_host_##field (struct class_device *cdev, char *buf)		\
 {									\
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
 	return snprintf(buf, sz, format_string, cast fc_host_##field(shost)); \
 }
 #define fc_private_host_rd_attr(field, format_string, sz)		\
 	fc_private_host_show_function(field, format_string, sz, )	\
 static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 			 show_fc_host_##field, NULL)
 #define fc_private_host_rd_attr_cast(field, format_string, sz, cast)	\
 	fc_private_host_show_function(field, format_string, sz, (cast)) \
 static FC_CLASS_DEVICE_ATTR(host, field, S_IRUGO,			\
 			  show_fc_host_##field, NULL)
 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RD(field)			\
 	i->private_host_attrs[count] = class_device_attr_host_##field;	\
 	i->private_host_attrs[count].attr.mode = S_IRUGO;		\
 	i->private_host_attrs[count].store = NULL;			\
 	i->host_attrs[count] = &i->private_host_attrs[count];		\
 	count++
 #define SETUP_PRIVATE_HOST_ATTRIBUTE_RW(field)			\
 	i->private_host_attrs[count] = class_device_attr_host_##field;	\
 	i->host_attrs[count] = &i->private_host_attrs[count];		\
 	count++
 /* Fixed Host Attributes */
 static ssize_t
 show_fc_host_supported_classes (struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	if (fc_host_supported_classes(shost) == FC_COS_UNSPECIFIED)
 		return snprintf(buf, 20, "unspecified\n");
 	return get_fc_cos_names(fc_host_supported_classes(shost), buf);
 }
 static FC_CLASS_DEVICE_ATTR(host, supported_classes, S_IRUGO,
 		show_fc_host_supported_classes, NULL);
 static ssize_t
 show_fc_host_supported_fc4s (struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	return (ssize_t)show_fc_fc4s(buf, fc_host_supported_fc4s(shost));
 }
 static FC_CLASS_DEVICE_ATTR(host, supported_fc4s, S_IRUGO,
 		show_fc_host_supported_fc4s, NULL);
 static ssize_t
 show_fc_host_supported_speeds (struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	if (fc_host_supported_speeds(shost) == FC_PORTSPEED_UNKNOWN)
 		return snprintf(buf, 20, "unknown\n");
 	return get_fc_port_speed_names(fc_host_supported_speeds(shost), buf);
 }
 static FC_CLASS_DEVICE_ATTR(host, supported_speeds, S_IRUGO,
 		show_fc_host_supported_speeds, NULL);
 fc_private_host_rd_attr_cast(node_name, "0x%llx\n", 20, unsigned long long);
 fc_private_host_rd_attr_cast(port_name, "0x%llx\n", 20, unsigned long long);
 fc_private_host_rd_attr(symbolic_name, "%s\n", (FC_SYMBOLIC_NAME_SIZE +1));
 fc_private_host_rd_attr(maxframe_size, "%u bytes\n", 20);
 fc_private_host_rd_attr(serial_number, "%s\n", (FC_SERIAL_NUMBER_SIZE +1));
 /* Dynamic Host Attributes */
 static ssize_t
 show_fc_host_active_fc4s (struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct fc_internal *i = to_fc_internal(shost->transportt);
 	if (i->f->get_host_active_fc4s)
 		i->f->get_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,
 		show_fc_host_active_fc4s, NULL);
 static ssize_t
 show_fc_host_speed (struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct fc_internal *i = to_fc_internal(shost->transportt);
 	if (i->f->get_host_speed)
 		i->f->get_host_speed(shost);
 	if (fc_host_speed(shost) == FC_PORTSPEED_UNKNOWN)
 		return snprintf(buf, 20, "unknown\n");
 	return get_fc_port_speed_names(fc_host_speed(shost), buf);
 }
 static FC_CLASS_DEVICE_ATTR(host, speed, S_IRUGO,
 		show_fc_host_speed, NULL);
 fc_host_rd_attr(port_id, "0x%06x\n", 20);
 fc_host_rd_enum_attr(port_type, FC_PORTTYPE_MAX_NAMELEN);
 fc_host_rd_enum_attr(port_state, FC_PORTSTATE_MAX_NAMELEN);
 fc_host_rd_attr_cast(fabric_name, "0x%llx\n", 20, unsigned long long);
 /* Private Host Attributes */
 static ssize_t
 show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	const char *name;
 	name = get_fc_tgtid_bind_type_name(fc_host_tgtid_bind_type(shost));
 	if (!name)
 		return -EINVAL;
 	return snprintf(buf, FC_BINDTYPE_MAX_NAMELEN, "%s\n", name);
 }
 static ssize_t
 store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
 	const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct fc_rport *rport, *next_rport;
  	enum fc_tgtid_binding_type val;
 	unsigned long flags;
 	if (get_fc_tgtid_bind_type_match(buf, &val))
 		return -EINVAL;
 	/* if changing bind type, purge all unused consistent bindings */
 	if (val != fc_host_tgtid_bind_type(shost)) {
 		spin_lock_irqsave(shost->host_lock, flags);
 		list_for_each_entry_safe(rport, next_rport,
 				&fc_host_rport_bindings(shost), peers)
 			fc_rport_terminate(rport);
 		spin_unlock_irqrestore(shost->host_lock, flags);
 	}
 	fc_host_tgtid_bind_type(shost) = val;
 	return count;
 }
 static FC_CLASS_DEVICE_ATTR(host, tgtid_bind_type, S_IRUGO | S_IWUSR,
 			show_fc_private_host_tgtid_bind_type,
 			store_fc_private_host_tgtid_bind_type);
 /*
  * Host Statistics Management
  */
 /* Show a given an attribute in the statistics group */
 static ssize_t
 fc_stat_show(const struct class_device *cdev, char *buf, unsigned long offset)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct fc_internal *i = to_fc_internal(shost->transportt);
 	struct fc_host_statistics *stats;
 	ssize_t ret = -ENOENT;
 	if (offset > sizeof(struct fc_host_statistics) ||
 	    offset % sizeof(u64) != 0)
 		WARN_ON(1);
 	if (i->f->get_fc_host_stats) {
 		stats = (i->f->get_fc_host_stats)(shost);
 		if (stats)
 			ret = snprintf(buf, 20, "0x%llx\n",
 			      (unsigned long long)*(u64 *)(((u8 *) stats) + offset));
 	}
 	return ret;
 }
 /* generate a read-only statistics attribute */
 #define fc_host_statistic(name)						\
 static ssize_t show_fcstat_##name(struct class_device *cd, char *buf) 	\
 {									\
 	return fc_stat_show(cd, buf, 					\
 			    offsetof(struct fc_host_statistics, name));	\
 }									\
 static FC_CLASS_DEVICE_ATTR(host, name, S_IRUGO, show_fcstat_##name, NULL)
 fc_host_statistic(seconds_since_last_reset);
 fc_host_statistic(tx_frames);
 fc_host_statistic(tx_words);
 fc_host_statistic(rx_frames);
 fc_host_statistic(rx_words);
 fc_host_statistic(lip_count);
 fc_host_statistic(nos_count);
 fc_host_statistic(error_frames);
 fc_host_statistic(dumped_frames);
 fc_host_statistic(link_failure_count);
 fc_host_statistic(loss_of_sync_count);
 fc_host_statistic(loss_of_signal_count);
 fc_host_statistic(prim_seq_protocol_err_count);
 fc_host_statistic(invalid_tx_word_count);
 fc_host_statistic(invalid_crc_count);
 fc_host_statistic(fcp_input_requests);
 fc_host_statistic(fcp_output_requests);
 fc_host_statistic(fcp_control_requests);
 fc_host_statistic(fcp_input_megabytes);
 fc_host_statistic(fcp_output_megabytes);
 static ssize_t
 fc_reset_statistics(struct class_device *cdev, const char *buf,
 			   size_t count)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct fc_internal *i = to_fc_internal(shost->transportt);
 	/* ignore any data value written to the attribute */
 	if (i->f->reset_fc_host_stats) {
 		i->f->reset_fc_host_stats(shost);
 		return count;
 	}
 	return -ENOENT;
 }
 static FC_CLASS_DEVICE_ATTR(host, reset_statistics, S_IWUSR, NULL,
 				fc_reset_statistics);
 static struct attribute *fc_statistics_attrs[] = {
 	&class_device_attr_host_seconds_since_last_reset.attr,
 	&class_device_attr_host_tx_frames.attr,
 	&class_device_attr_host_tx_words.attr,
 	&class_device_attr_host_rx_frames.attr,
 	&class_device_attr_host_rx_words.attr,
 	&class_device_attr_host_lip_count.attr,
 	&class_device_attr_host_nos_count.attr,
 	&class_device_attr_host_error_frames.attr,
 	&class_device_attr_host_dumped_frames.attr,
 	&class_device_attr_host_link_failure_count.attr,
 	&class_device_attr_host_loss_of_sync_count.attr,
 	&class_device_attr_host_loss_of_signal_count.attr,
 	&class_device_attr_host_prim_seq_protocol_err_count.attr,
 	&class_device_attr_host_invalid_tx_word_count.attr,
 	&class_device_attr_host_invalid_crc_count.attr,
 	&class_device_attr_host_fcp_input_requests.attr,
 	&class_device_attr_host_fcp_output_requests.attr,
 	&class_device_attr_host_fcp_control_requests.attr,
 	&class_device_attr_host_fcp_input_megabytes.attr,
 	&class_device_attr_host_fcp_output_megabytes.attr,
 	&class_device_attr_host_reset_statistics.attr,
 	NULL
 };
 static struct attribute_group fc_statistics_group = {
 	.name = "statistics",
 	.attrs = fc_statistics_attrs,
 };
 static int fc_host_match(struct attribute_container *cont,
 			  struct device *dev)
 {
 	struct Scsi_Host *shost;
 	struct fc_internal *i;
 	if (!scsi_is_host_device(dev))
 		return 0;
 	shost = dev_to_shost(dev);
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &fc_host_class.class)
 		return 0;
 	i = to_fc_internal(shost->transportt);
 	return &i->t.host_attrs.ac == cont;
 }
 static int fc_target_match(struct attribute_container *cont,
 			    struct device *dev)
 {
 	struct Scsi_Host *shost;
 	struct fc_internal *i;
 	if (!scsi_is_target_device(dev))
 		return 0;
 	shost = dev_to_shost(dev->parent);
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &fc_host_class.class)
 		return 0;
 	i = to_fc_internal(shost->transportt);
 	return &i->t.target_attrs.ac == cont;
 }
 static void fc_rport_dev_release(struct device *dev)
 {
 	struct fc_rport *rport = dev_to_rport(dev);
 	put_device(dev->parent);
 	kfree(rport);
 }
 int scsi_is_fc_rport(const struct device *dev)
 {
 	return dev->release == fc_rport_dev_release;
 }
 EXPORT_SYMBOL(scsi_is_fc_rport);
 static int fc_rport_match(struct attribute_container *cont,
 			    struct device *dev)
 {
 	struct Scsi_Host *shost;
 	struct fc_internal *i;
 	if (!scsi_is_fc_rport(dev))
 		return 0;
 	shost = dev_to_shost(dev->parent);
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &fc_host_class.class)
 		return 0;
 	i = to_fc_internal(shost->transportt);
 	return &i->rport_attr_cont.ac == cont;
 }
 struct scsi_transport_template *
 fc_attach_transport(struct fc_function_template *ft)
 {
 	struct fc_internal *i = kmalloc(sizeof(struct fc_internal),
 					GFP_KERNEL);
 	int count;
 	if (unlikely(!i))
 		return NULL;
 	memset(i, 0, sizeof(struct fc_internal));
 	i->t.target_attrs.ac.attrs = &i->starget_attrs[0];
 	i->t.target_attrs.ac.class = &fc_transport_class.class;
 	i->t.target_attrs.ac.match = fc_target_match;
 	i->t.target_size = sizeof(struct fc_starget_attrs);
 	transport_container_register(&i->t.target_attrs);
 	i->t.host_attrs.ac.attrs = &i->host_attrs[0];
 	i->t.host_attrs.ac.class = &fc_host_class.class;
 	i->t.host_attrs.ac.match = fc_host_match;
 	i->t.host_size = sizeof(struct fc_host_attrs);
 	if (ft->get_fc_host_stats)
 		i->t.host_attrs.statistics = &fc_statistics_group;
 	transport_container_register(&i->t.host_attrs);
 	i->rport_attr_cont.ac.attrs = &i->rport_attrs[0];
 	i->rport_attr_cont.ac.class = &fc_rport_class.class;
 	i->rport_attr_cont.ac.match = fc_rport_match;
 	transport_container_register(&i->rport_attr_cont);
 	i->f = ft;
 	/* Transport uses the shost workq for scsi scanning */
 	i->t.create_work_queue = 1;
 	/*
 	 * Setup SCSI Target Attributes.
 	 */
 	count = 0;
 	SETUP_STARGET_ATTRIBUTE_RD(node_name);
 	SETUP_STARGET_ATTRIBUTE_RD(port_name);
 	SETUP_STARGET_ATTRIBUTE_RD(port_id);
 	BUG_ON(count > FC_STARGET_NUM_ATTRS);
 	i->starget_attrs[count] = NULL;
 	/*
 	 * Setup SCSI Host Attributes.
 	 */
 	count=0;
 	SETUP_HOST_ATTRIBUTE_RD(node_name);
 	SETUP_HOST_ATTRIBUTE_RD(port_name);
 	SETUP_HOST_ATTRIBUTE_RD(supported_classes);
 	SETUP_HOST_ATTRIBUTE_RD(supported_fc4s);
 	SETUP_HOST_ATTRIBUTE_RD(symbolic_name);
 	SETUP_HOST_ATTRIBUTE_RD(supported_speeds);
 	SETUP_HOST_ATTRIBUTE_RD(maxframe_size);
 	SETUP_HOST_ATTRIBUTE_RD(serial_number);
 	SETUP_HOST_ATTRIBUTE_RD(port_id);
 	SETUP_HOST_ATTRIBUTE_RD(port_type);
 	SETUP_HOST_ATTRIBUTE_RD(port_state);
 	SETUP_HOST_ATTRIBUTE_RD(active_fc4s);
 	SETUP_HOST_ATTRIBUTE_RD(speed);
 	SETUP_HOST_ATTRIBUTE_RD(fabric_name);
 	/* Transport-managed attributes */
 	SETUP_PRIVATE_HOST_ATTRIBUTE_RW(tgtid_bind_type);
 	BUG_ON(count > FC_HOST_NUM_ATTRS);
 	i->host_attrs[count] = NULL;
 	/*
 	 * Setup Remote Port Attributes.
 	 */
 	count=0;
 	SETUP_RPORT_ATTRIBUTE_RD(maxframe_size);
 	SETUP_RPORT_ATTRIBUTE_RD(supported_classes);
 	SETUP_RPORT_ATTRIBUTE_RW(dev_loss_tmo);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(node_name);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_name);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_id);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(roles);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(port_state);
 	SETUP_PRIVATE_RPORT_ATTRIBUTE_RD(scsi_target_id);
 	BUG_ON(count > FC_RPORT_NUM_ATTRS);
 	i->rport_attrs[count] = NULL;
 	return &i->t;
 }
 EXPORT_SYMBOL(fc_attach_transport);
 void fc_release_transport(struct scsi_transport_template *t)
 {
 	struct fc_internal *i = to_fc_internal(t);
 	transport_container_unregister(&i->t.target_attrs);
 	transport_container_unregister(&i->t.host_attrs);
 	transport_container_unregister(&i->rport_attr_cont);
 	kfree(i);
 }
 EXPORT_SYMBOL(fc_release_transport);
 /**
  * fc_remove_host - called to terminate any fc_transport-related elements
  *                  for a scsi host.
  * @rport:	remote port to be unblocked.
  *
  * This routine is expected to be called immediately preceeding the
  * a driver's call to scsi_remove_host().
  *
  * WARNING: A driver utilizing the fc_transport, which fails to call
  *   this routine prior to scsi_remote_host(), will leave dangling
  *   objects in /sys/class/fc_remote_ports. Access to any of these
  *   objects can result in a system crash !!!
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
 void
 fc_remove_host(struct Scsi_Host *shost)
 {
 	struct fc_rport *rport, *next_rport;
 	/* Remove any remote ports */
 	list_for_each_entry_safe(rport, next_rport,
 			&fc_host_rports(shost), peers)
 		fc_rport_terminate(rport);
 	list_for_each_entry_safe(rport, next_rport,
 			&fc_host_rport_bindings(shost), peers)
 		fc_rport_terminate(rport);
 }
 EXPORT_SYMBOL(fc_remove_host);
 /**
  * fc_rport_create - allocates and creates a remote FC port.
  * @shost:	scsi host the remote port is connected to.
  * @channel:	Channel on shost port connected to.
  * @ids:	The world wide names, fc address, and FC4 port
  *		roles for the remote port.
  *
  * Allocates and creates the remoter port structure, including the
  * class and sysfs creation.
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
 struct fc_rport *
 fc_rport_create(struct Scsi_Host *shost, int channel,
 	struct fc_rport_identifiers  *ids)
 {
 	struct fc_host_attrs *fc_host =
 			(struct fc_host_attrs *)shost->shost_data;
 	struct fc_internal *fci = to_fc_internal(shost->transportt);
 	struct fc_rport *rport;
 	struct device *dev;
 	unsigned long flags;
 	int error;
 	size_t size;
 	size = (sizeof(struct fc_rport) + fci->f->dd_fcrport_size);
 	rport = kmalloc(size, GFP_KERNEL);
 	if (unlikely(!rport)) {
 		printk(KERN_ERR "%s: allocation failure\n", __FUNCTION__);
 		return NULL;
 	}
 	memset(rport, 0, size);
 	rport->maxframe_size = -1;
 	rport->supported_classes = FC_COS_UNSPECIFIED;
 	rport->dev_loss_tmo = fc_dev_loss_tmo;
 	memcpy(&rport->node_name, &ids->node_name, sizeof(rport->node_name));
 	memcpy(&rport->port_name, &ids->port_name, sizeof(rport->port_name));
 	rport->port_id = ids->port_id;
 	rport->roles = ids->roles;
 	rport->port_state = FC_PORTSTATE_ONLINE;
 	if (fci->f->dd_fcrport_size)
 		rport->dd_data = &rport[1];
 	rport->channel = channel;
 	INIT_WORK(&rport->dev_loss_work, fc_timeout_blocked_rport, rport);
 	INIT_WORK(&rport->scan_work, fc_scsi_scan_rport, rport);
 	spin_lock_irqsave(shost->host_lock, flags);
 	rport->number = fc_host->next_rport_number++;
 	if (rport->roles & FC_RPORT_ROLE_FCP_TARGET)
 		rport->scsi_target_id = fc_host->next_target_id++;
 	else
 		rport->scsi_target_id = -1;
 	list_add_tail(&rport->peers, &fc_host_rports(shost));
 	get_device(&shost->shost_gendev);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	dev = &rport->dev;
 	device_initialize(dev);
 	dev->parent = get_device(&shost->shost_gendev);
 	dev->release = fc_rport_dev_release;
 	sprintf(dev->bus_id, "rport-%d:%d-%d",
 		shost->host_no, channel, rport->number);
 	transport_setup_device(dev);
 	error = device_add(dev);
 	if (error) {
 		printk(KERN_ERR "FC Remote Port device_add failed\n");
 		goto delete_rport;
 	}
 	transport_add_device(dev);
 	transport_configure_device(dev);
 	if (rport->roles & FC_RPORT_ROLE_FCP_TARGET)
 		/* initiate a scan of the target */
 		scsi_queue_work(shost, &rport->scan_work);
 	return rport;
 delete_rport:
 	transport_destroy_device(dev);
 	put_device(dev->parent);
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_del(&rport->peers);
 	put_device(&shost->shost_gendev);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	put_device(dev->parent);
 	kfree(rport);
 	return NULL;
 }
 /**
  * fc_remote_port_add - notifies the fc transport of the existence
  *		of a remote FC port.
  * @shost:	scsi host the remote port is connected to.
  * @channel:	Channel on shost port connected to.
  * @ids:	The world wide names, fc address, and FC4 port
  *		roles for the remote port.
  *
  * The LLDD calls this routine to notify the transport of the existence
  * of a remote port. The LLDD provides the unique identifiers (wwpn,wwn)
  * of the port, it's FC address (port_id), and the FC4 roles that are
  * active for the port.
  *
  * For ports that are FCP targets (aka scsi targets), the FC transport
  * maintains consistent target id bindings on behalf of the LLDD.
  * A consistent target id binding is an assignment of a target id to
  * a remote port identifier, which persists while the scsi host is
  * attached. The remote port can disappear, then later reappear, and
  * it's target id assignment remains the same. This allows for shifts
  * in FC addressing (if binding by wwpn or wwnn) with no apparent
  * changes to the scsi subsystem which is based on scsi host number and
  * target id values.  Bindings are only valid during the attachment of
  * the scsi host. If the host detaches, then later re-attaches, target
  * id bindings may change.
  *
  * This routine is responsible for returning a remote port structure.
  * The routine will search the list of remote ports it maintains
  * internally on behalf of consistent target id mappings. If found, the
  * remote port structure will be reused. Otherwise, a new remote port
  * structure will be allocated.
  *
  * Whenever a remote port is allocated, a new fc_remote_port class
  * device is created.
  *
  * Should not be called from interrupt context.
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
 struct fc_rport *
 fc_remote_port_add(struct Scsi_Host *shost, int channel,
 	struct fc_rport_identifiers  *ids)
 {
 	struct fc_rport *rport;
 	unsigned long flags;
 	int match = 0;
 	if (likely((ids->roles & FC_RPORT_ROLE_FCP_TARGET) &&
 		(fc_host_tgtid_bind_type(shost) != FC_TGTID_BIND_NONE))) {
 		/* search for a matching consistent binding */
 		spin_lock_irqsave(shost->host_lock, flags);
 		list_for_each_entry(rport, &fc_host_rport_bindings(shost),
 					peers) {
 			if (rport->channel != channel)
 				continue;
 			switch (fc_host_tgtid_bind_type(shost)) {
 			case FC_TGTID_BIND_BY_WWPN:
 				if (rport->port_name == ids->port_name)
 					match = 1;
 				break;
 			case FC_TGTID_BIND_BY_WWNN:
 				if (rport->node_name == ids->node_name)
 					match = 1;
 				break;
 			case FC_TGTID_BIND_BY_ID:
 				if (rport->port_id == ids->port_id)
 					match = 1;
 				break;
 			case FC_TGTID_BIND_NONE: /* to keep compiler happy */
 				break;
 			}
 			if (match) {
 				list_move_tail(&rport->peers,
 					&fc_host_rports(shost));
 				break;
 			}
 		}
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		if (match) {
 			memcpy(&rport->node_name, &ids->node_name,
 				sizeof(rport->node_name));
 			memcpy(&rport->port_name, &ids->port_name,
 				sizeof(rport->port_name));
 			rport->port_id = ids->port_id;
 			rport->roles = ids->roles;
 			rport->port_state = FC_PORTSTATE_ONLINE;
 			if (rport->roles & FC_RPORT_ROLE_FCP_TARGET)
 				/* initiate a scan of the target */
 				scsi_queue_work(shost, &rport->scan_work);
 			return rport;
 		}
 	}
 	/* No consistent binding found - create new remote port entry */
 	rport = fc_rport_create(shost, channel, ids);
 	return rport;
 }
 EXPORT_SYMBOL(fc_remote_port_add);
 /*
  * fc_rport_tgt_remove - Removes the scsi target on the remote port
  * @rport:	The remote port to be operated on
  */
 static void
 fc_rport_tgt_remove(struct fc_rport *rport)
 {
 	struct Scsi_Host *shost = rport_to_shost(rport);
 	scsi_target_unblock(&rport->dev);
 	/* Stop anything on the workq */
 	if (!cancel_delayed_work(&rport->dev_loss_work))
 		flush_scheduled_work();
 	scsi_flush_work(shost);
 	scsi_remove_target(&rport->dev);
 }
 /*
  * fc_rport_terminate - this routine tears down and deallocates a remote port.
  * @rport:	The remote port to be terminated
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  */
 static void
 fc_rport_terminate(struct fc_rport  *rport)
 {
 	struct Scsi_Host *shost = rport_to_shost(rport);
 	struct device *dev = &rport->dev;
 	unsigned long flags;
 	fc_rport_tgt_remove(rport);
 	transport_remove_device(dev);
 	device_del(dev);
 	transport_destroy_device(dev);
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_del(&rport->peers);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	put_device(&shost->shost_gendev);
 }
 /**
  * fc_remote_port_delete - notifies the fc transport that a remote
  *		port is no longer in existence.
  * @rport:	The remote port that no longer exists
  *
  * The LLDD calls this routine to notify the transport that a remote
  * port is no longer part of the topology. Note: Although a port
  * may no longer be part of the topology, it may persist in the remote
  * ports displayed by the fc_host. This is done so that target id
  * mappings (managed via the remote port structures), are always visible
  * as long as the mapping is valid, regardless of port state,
  *
  * If the remote port is not an FCP Target, it will be fully torn down
  * and deallocated, including the fc_remote_port class device.
  *
  * If the remote port is an FCP Target, the port structure will be
  * marked as Not Present, but will remain as long as there is a valid
  * SCSI target id mapping associated with the port structure. Validity
  * is determined by the binding type. If binding by wwpn, then the port
  * structure is always valid and will not be deallocated until the host
  * is removed.  If binding by wwnn, then the port structure is valid
  * until another port with the same node name is found in the topology.
  * If binding by port id (fc address), then the port structure is valid
  * valid until another port with the same address is identified.
  *
  * Called from interrupt or normal process context.
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
 void
 fc_remote_port_delete(struct fc_rport  *rport)
 {
 	struct Scsi_Host *shost = rport_to_shost(rport);
 	unsigned long flags;
 	/* If no scsi target id mapping or consistent binding type, delete it */
 	if ((rport->scsi_target_id == -1) ||
 	    (fc_host_tgtid_bind_type(shost) == FC_TGTID_BIND_NONE)) {
 		fc_rport_terminate(rport);
 		return;
 	}
 	fc_rport_tgt_remove(rport);
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_move_tail(&rport->peers, &fc_host_rport_bindings(shost));
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	/*
 	 * Note: We do not remove or clear the hostdata area. This allows
 	 *   host-specific target data to persist along with the
 	 *   scsi_target_id. It's up to the host to manage it's hostdata area.
 	 */
 	/*
 	 * Reinitialize port attributes that may change if the port comes back.
 	 */
 	rport->maxframe_size = -1;
 	rport->supported_classes = FC_COS_UNSPECIFIED;
 	rport->roles = FC_RPORT_ROLE_UNKNOWN;
 	rport->port_state = FC_PORTSTATE_NOTPRESENT;
 	/* remove the identifiers that aren't used in the consisting binding */
 	switch (fc_host_tgtid_bind_type(shost)) {
 	case FC_TGTID_BIND_BY_WWPN:
 		rport->node_name = -1;
 		rport->port_id = -1;
 		break;
 	case FC_TGTID_BIND_BY_WWNN:
 		rport->port_name = -1;
 		rport->port_id = -1;
 		break;
 	case FC_TGTID_BIND_BY_ID:
 		rport->node_name = -1;
 		rport->port_name = -1;
 		break;
 	case FC_TGTID_BIND_NONE:	/* to keep compiler happy */
 		break;
 	}
 }
 EXPORT_SYMBOL(fc_remote_port_delete);
 /**
  * fc_remote_port_rolechg - notifies the fc transport that the roles
  *		on a remote may have changed.
  * @rport:	The remote port that changed.
  *
  * The LLDD calls this routine to notify the transport that the roles
  * on a remote port may have changed. The largest effect of this is
  * if a port now becomes a FCP Target, it must be allocated a
  * scsi target id.  If the port is no longer a FCP target, any
  * scsi target id value assigned to it will persist in case the
  * role changes back to include FCP Target. No changes in the scsi
  * midlayer will be invoked if the role changes (in the expectation
  * that the role will be resumed. If it doesn't normal error processing
  * will take place).
  *
  * Should not be called from interrupt context.
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
 void
 fc_remote_port_rolechg(struct fc_rport  *rport, u32 roles)
 {
 	struct Scsi_Host *shost = rport_to_shost(rport);
 	struct fc_host_attrs *fc_host =
 			(struct fc_host_attrs *)shost->shost_data;
 	unsigned long flags;
 	int create = 0;
 	rport->roles = roles;
 	spin_lock_irqsave(shost->host_lock, flags);
 	if ((rport->scsi_target_id == -1) &&
 	    (rport->roles & FC_RPORT_ROLE_FCP_TARGET)) {
 		rport->scsi_target_id = fc_host->next_target_id++;
 		create = 1;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	if (create)
 		/* initiate a scan of the target */
 		scsi_queue_work(shost, &rport->scan_work);
 }
 EXPORT_SYMBOL(fc_remote_port_rolechg);
 /**
  * fc_timeout_blocked_rport - Timeout handler for blocked remote port
  *                       that fails to return in the alloted time.
  * @data:	scsi target that failed to reappear in the alloted time.
  **/
 static void
 fc_timeout_blocked_rport(void  *data)
 {
 	struct fc_rport *rport = (struct fc_rport *)data;
 	rport->port_state = FC_PORTSTATE_OFFLINE;
 	dev_printk(KERN_ERR, &rport->dev,
 		"blocked FC remote port time out: removing target\n");
 	/*
 	 * As this only occurs if the remote port (scsi target)
 	 * went away and didn't come back - we'll remove
 	 * all attached scsi devices.
 	 */
 	scsi_target_unblock(&rport->dev);
 	scsi_remove_target(&rport->dev);
 }
 /**
  * fc_remote_port_block - temporarily block any scsi traffic to a remote port.
  * @rport:	remote port to be blocked.
  *
  * scsi lldd's with a FC transport call this routine to temporarily stop
  * all scsi traffic to a remote port. If the port is not a SCSI target,
  * no action is taken. If the port is a SCSI target, all attached devices
  * are placed into a SDEV_BLOCK state and a timer is started. The timer is
  * represents the maximum amount of time the port may be blocked. If the
  * timer expires, the port is considered non-existent and the attached
  * scsi devices will be removed.
  *
  * Called from interrupt or normal process context.
  *
  * Returns zero if successful or error if not
  *
  * Notes:
  *      This routine assumes no locks are held on entry.
  *
  *	The timeout and timer types are extracted from the fc transport
  *	attributes from the caller's rport pointer.
  **/
 int
 fc_remote_port_block(struct fc_rport *rport)
 {
 	int timeout = rport->dev_loss_tmo;
 	struct work_struct *work = &rport->dev_loss_work;
 	if (timeout < 0 || timeout > SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
 		return -EINVAL;
 	scsi_target_block(&rport->dev);
 	/* cap the length the devices can be blocked */
 	schedule_delayed_work(work, timeout * HZ);
 	rport->port_state = FC_PORTSTATE_BLOCKED;
 	return 0;
 }
 EXPORT_SYMBOL(fc_remote_port_block);
 /**
  * fc_remote_port_unblock - restart any blocked scsi traffic to a remote port.
  * @rport:	remote port to be unblocked.
  *
  * scsi lld's with a FC transport call this routine to restart IO to all
  * devices associated with the caller's scsi target following a fc_target_block
  * request.  Called from interrupt or normal process context.
  *
  * Notes:
  *	This routine assumes no locks are held on entry.
  **/
  void
 fc_remote_port_unblock(struct fc_rport *rport)
 {
 	struct work_struct *work = &rport->dev_loss_work;
 	struct Scsi_Host *shost = rport_to_shost(rport);
 	/*
 	 * Stop the target timer first. Take no action on the del_timer
 	 * failure as the state machine state change will validate the
 	 * transaction.
 	 */
 	if (!cancel_delayed_work(work))
 		flush_scheduled_work();
 	if (rport->port_state == FC_PORTSTATE_OFFLINE)
 		/*
 		 * initiate a scan of the target as the target has
 		 * been torn down.
 		 */
 		scsi_queue_work(shost, &rport->scan_work);
 	else
 		scsi_target_unblock(&rport->dev);
 	rport->port_state = FC_PORTSTATE_ONLINE;
 }
 EXPORT_SYMBOL(fc_remote_port_unblock);
 /**
  * fc_scsi_scan_rport - called to perform a scsi scan on a remote port.
  * @data:	remote port to be scanned.
  **/
 static void
 fc_scsi_scan_rport(void *data)
 {
 	struct fc_rport *rport = (struct fc_rport *)data;
 	scsi_scan_target(&rport->dev, rport->channel, rport->scsi_target_id,
 			SCAN_WILD_CARD, 1);
 }
 MODULE_AUTHOR("Martin Hicks");
 MODULE_DESCRIPTION("FC Transport Attributes");
 MODULE_LICENSE("GPL");
 module_init(fc_transport_init);
 module_exit(fc_transport_exit);

drivers/scsi/scsi_transport_spi.c

Diff comments View file @ d0a7e57

 /*
  *  Parallel SCSI (SPI) transport specific attributes exported to sysfs.
  *
  *  Copyright (c) 2003 Silicon Graphics, Inc.  All rights reserved.
  *  Copyright (c) 2004, 2005 James Bottomley <James.Bottomley@SteelEye.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
 #include <asm/semaphore.h>
 #include <scsi/scsi.h>
 #include "scsi_priv.h"
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_request.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_spi.h>
 #define SPI_PRINTK(x, l, f, a...)	dev_printk(l, &(x)->dev, f , ##a)
 #define SPI_NUM_ATTRS 14	/* increase this if you add attributes */
 #define SPI_OTHER_ATTRS 1	/* Increase this if you add "always
 				 * on" attributes */
 #define SPI_HOST_ATTRS	1
 #define SPI_MAX_ECHO_BUFFER_SIZE	4096
 #define DV_LOOPS	3
 #define DV_TIMEOUT	(10*HZ)
 #define DV_RETRIES	3	/* should only need at most
 				 * two cc/ua clears */
 /* Private data accessors (keep these out of the header file) */
 #define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
 #define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
 struct spi_internal {
 	struct scsi_transport_template t;
 	struct spi_function_template *f;
 	/* The actual attributes */
 	struct class_device_attribute private_attrs[SPI_NUM_ATTRS];
 	/* The array of null terminated pointers to attributes
 	 * needed by scsi_sysfs.c */
 	struct class_device_attribute *attrs[SPI_NUM_ATTRS + SPI_OTHER_ATTRS + 1];
 	struct class_device_attribute private_host_attrs[SPI_HOST_ATTRS];
 	struct class_device_attribute *host_attrs[SPI_HOST_ATTRS + 1];
 };
 #define to_spi_internal(tmpl)	container_of(tmpl, struct spi_internal, t)
 static const int ppr_to_ps[] = {
 	/* The PPR values 0-6 are reserved, fill them in when
 	 * the committee defines them */
 	-1,			/* 0x00 */
 	-1,			/* 0x01 */
 	-1,			/* 0x02 */
 	-1,			/* 0x03 */
 	-1,			/* 0x04 */
 	-1,			/* 0x05 */
 	-1,			/* 0x06 */
 	 3125,			/* 0x07 */
 	 6250,			/* 0x08 */
 	12500,			/* 0x09 */
 	25000,			/* 0x0a */
 	30300,			/* 0x0b */
 	50000,			/* 0x0c */
 };
 /* The PPR values at which you calculate the period in ns by multiplying
  * by 4 */
 #define SPI_STATIC_PPR	0x0c
 static int sprint_frac(char *dest, int value, int denom)
 {
 	int frac = value % denom;
 	int result = sprintf(dest, "%d", value / denom);
 	if (frac == 0)
 		return result;
 	dest[result++] = '.';
 	do {
 		denom /= 10;
 		sprintf(dest + result, "%d", frac / denom);
 		result++;
 		frac %= denom;
 	} while (frac);
 	dest[result++] = '\0';
 	return result;
 }
 /* Modification of scsi_wait_req that will clear UNIT ATTENTION conditions
  * resulting from (likely) bus and device resets */
 static void spi_wait_req(struct scsi_request *sreq, const void *cmd,
 			 void *buffer, unsigned bufflen)
 {
 	int i;
 	for(i = 0; i < DV_RETRIES; i++) {
 		sreq->sr_request->flags |= REQ_FAILFAST;
 		scsi_wait_req(sreq, cmd, buffer, bufflen,
 			      DV_TIMEOUT, /* retries */ 1);
 		if (sreq->sr_result & DRIVER_SENSE) {
 			struct scsi_sense_hdr sshdr;
 			if (scsi_request_normalize_sense(sreq, &sshdr)
 			    && sshdr.sense_key == UNIT_ATTENTION)
 				continue;
 		}
 		break;
 	}
 }
 static struct {
 	enum spi_signal_type	value;
 	char			*name;
 } signal_types[] = {
 	{ SPI_SIGNAL_UNKNOWN, "unknown" },
 	{ SPI_SIGNAL_SE, "SE" },
 	{ SPI_SIGNAL_LVD, "LVD" },
 	{ SPI_SIGNAL_HVD, "HVD" },
 };
 static inline const char *spi_signal_to_string(enum spi_signal_type type)
 {
 	int i;
 	for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
 		if (type == signal_types[i].value)
 			return signal_types[i].name;
 	}
 	return NULL;
 }
 static inline enum spi_signal_type spi_signal_to_value(const char *name)
 {
 	int i, len;
 	for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
 		len =  strlen(signal_types[i].name);
 		if (strncmp(name, signal_types[i].name, len) == 0 &&
 		    (name[len] == '\n' || name[len] == '\0'))
 			return signal_types[i].value;
 	}
 	return SPI_SIGNAL_UNKNOWN;
 }
-static int spi_host_setup(struct device *dev)
+static int spi_host_setup(struct transport_container *tc, struct device *dev,
+			  struct class_device *cdev)
 {
 	struct Scsi_Host *shost = dev_to_shost(dev);
 	spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
 	return 0;
 }
 static DECLARE_TRANSPORT_CLASS(spi_host_class,
 			       "spi_host",
 			       spi_host_setup,
 			       NULL,
 			       NULL);
 static int spi_host_match(struct attribute_container *cont,
 			  struct device *dev)
 {
 	struct Scsi_Host *shost;
 	struct spi_internal *i;
 	if (!scsi_is_host_device(dev))
 		return 0;
 	shost = dev_to_shost(dev);
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &spi_host_class.class)
 		return 0;
 	i = to_spi_internal(shost->transportt);
 	return &i->t.host_attrs.ac == cont;
 }
-static int spi_device_configure(struct device *dev)
+static int spi_device_configure(struct transport_container *tc,
+				struct device *dev,
+				struct class_device *cdev)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	struct scsi_target *starget = sdev->sdev_target;
 	/* Populate the target capability fields with the values
 	 * gleaned from the device inquiry */
 	spi_support_sync(starget) = scsi_device_sync(sdev);
 	spi_support_wide(starget) = scsi_device_wide(sdev);
 	spi_support_dt(starget) = scsi_device_dt(sdev);
 	spi_support_dt_only(starget) = scsi_device_dt_only(sdev);
 	spi_support_ius(starget) = scsi_device_ius(sdev);
 	spi_support_qas(starget) = scsi_device_qas(sdev);
 	return 0;
 }
-static int spi_setup_transport_attrs(struct device *dev)
+static int spi_setup_transport_attrs(struct transport_container *tc,
+				     struct device *dev,
+				     struct class_device *cdev)
 {
 	struct scsi_target *starget = to_scsi_target(dev);
 	spi_period(starget) = -1;	/* illegal value */
 	spi_min_period(starget) = 0;
 	spi_offset(starget) = 0;	/* async */
 	spi_max_offset(starget) = 255;
 	spi_width(starget) = 0;	/* narrow */
 	spi_max_width(starget) = 1;
 	spi_iu(starget) = 0;	/* no IU */
 	spi_dt(starget) = 0;	/* ST */
 	spi_qas(starget) = 0;
 	spi_wr_flow(starget) = 0;
 	spi_rd_strm(starget) = 0;
 	spi_rti(starget) = 0;
 	spi_pcomp_en(starget) = 0;
 	spi_hold_mcs(starget) = 0;
 	spi_dv_pending(starget) = 0;
 	spi_initial_dv(starget) = 0;
 	init_MUTEX(&spi_dv_sem(starget));
 	return 0;
 }
 #define spi_transport_show_simple(field, format_string)			\
 									\
 static ssize_t								\
 show_spi_transport_##field(struct class_device *cdev, char *buf)	\
 {									\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct spi_transport_attrs *tp;					\
 									\
 	tp = (struct spi_transport_attrs *)&starget->starget_data;	\
 	return snprintf(buf, 20, format_string, tp->field);		\
 }
 #define spi_transport_store_simple(field, format_string)		\
 									\
 static ssize_t								\
 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 			    size_t count)				\
 {									\
 	int val;							\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct spi_transport_attrs *tp;					\
 									\
 	tp = (struct spi_transport_attrs *)&starget->starget_data;	\
 	val = simple_strtoul(buf, NULL, 0);				\
 	tp->field = val;						\
 	return count;							\
 }
 #define spi_transport_show_function(field, format_string)		\
 									\
 static ssize_t								\
 show_spi_transport_##field(struct class_device *cdev, char *buf)	\
 {									\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);	\
 	struct spi_transport_attrs *tp;					\
 	struct spi_internal *i = to_spi_internal(shost->transportt);	\
 	tp = (struct spi_transport_attrs *)&starget->starget_data;	\
 	if (i->f->get_##field)						\
 		i->f->get_##field(starget);				\
 	return snprintf(buf, 20, format_string, tp->field);		\
 }
 #define spi_transport_store_function(field, format_string)		\
 static ssize_t								\
 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 			    size_t count)				\
 {									\
 	int val;							\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);	\
 	struct spi_internal *i = to_spi_internal(shost->transportt);	\
 									\
 	val = simple_strtoul(buf, NULL, 0);				\
 	i->f->set_##field(starget, val);			\
 	return count;							\
 }
 #define spi_transport_store_max(field, format_string)			\
 static ssize_t								\
 store_spi_transport_##field(struct class_device *cdev, const char *buf, \
 			    size_t count)				\
 {									\
 	int val;							\
 	struct scsi_target *starget = transport_class_to_starget(cdev);	\
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);	\
 	struct spi_internal *i = to_spi_internal(shost->transportt);	\
 	struct spi_transport_attrs *tp					\
 		= (struct spi_transport_attrs *)&starget->starget_data;	\
 									\
 	val = simple_strtoul(buf, NULL, 0);				\
 	if (val > tp->max_##field)					\
 		val = tp->max_##field;					\
 	i->f->set_##field(starget, val);				\
 	return count;							\
 }
 #define spi_transport_rd_attr(field, format_string)			\
 	spi_transport_show_function(field, format_string)		\
 	spi_transport_store_function(field, format_string)		\
 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR,			\
 			 show_spi_transport_##field,			\
 			 store_spi_transport_##field);
 #define spi_transport_simple_attr(field, format_string)			\
 	spi_transport_show_simple(field, format_string)			\
 	spi_transport_store_simple(field, format_string)		\
 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR,			\
 			 show_spi_transport_##field,			\
 			 store_spi_transport_##field);
 #define spi_transport_max_attr(field, format_string)			\
 	spi_transport_show_function(field, format_string)		\
 	spi_transport_store_max(field, format_string)			\
 	spi_transport_simple_attr(max_##field, format_string)		\
 static CLASS_DEVICE_ATTR(field, S_IRUGO | S_IWUSR,			\
 			 show_spi_transport_##field,			\
 			 store_spi_transport_##field);
 /* The Parallel SCSI Tranport Attributes: */
 spi_transport_max_attr(offset, "%d\n");
 spi_transport_max_attr(width, "%d\n");
 spi_transport_rd_attr(iu, "%d\n");
 spi_transport_rd_attr(dt, "%d\n");
 spi_transport_rd_attr(qas, "%d\n");
 spi_transport_rd_attr(wr_flow, "%d\n");
 spi_transport_rd_attr(rd_strm, "%d\n");
 spi_transport_rd_attr(rti, "%d\n");
 spi_transport_rd_attr(pcomp_en, "%d\n");
 spi_transport_rd_attr(hold_mcs, "%d\n");
 /* we only care about the first child device so we return 1 */
 static int child_iter(struct device *dev, void *data)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	spi_dv_device(sdev);
 	return 1;
 }
 static ssize_t
 store_spi_revalidate(struct class_device *cdev, const char *buf, size_t count)
 {
 	struct scsi_target *starget = transport_class_to_starget(cdev);
 	device_for_each_child(&starget->dev, NULL, child_iter);
 	return count;
 }
 static CLASS_DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate);
 /* Translate the period into ns according to the current spec
  * for SDTR/PPR messages */
 static ssize_t
 show_spi_transport_period_helper(struct class_device *cdev, char *buf,
 				 int period)
 {
 	int len, picosec;
 	if (period < 0 || period > 0xff) {
 		picosec = -1;
 	} else if (period <= SPI_STATIC_PPR) {
 		picosec = ppr_to_ps[period];
 	} else {
 		picosec = period * 4000;
 	}
 	if (picosec == -1) {
 		len = sprintf(buf, "reserved");
 	} else {
 		len = sprint_frac(buf, picosec, 1000);
 	}
 	buf[len++] = '\n';
 	buf[len] = '\0';
 	return len;
 }
 static ssize_t
 store_spi_transport_period_helper(struct class_device *cdev, const char *buf,
 				  size_t count, int *periodp)
 {
 	int j, picosec, period = -1;
 	char *endp;
 	picosec = simple_strtoul(buf, &endp, 10) * 1000;
 	if (*endp == '.') {
 		int mult = 100;
 		do {
 			endp++;
 			if (!isdigit(*endp))
 				break;
 			picosec += (*endp - '0') * mult;
 			mult /= 10;
 		} while (mult > 0);
 	}
 	for (j = 0; j <= SPI_STATIC_PPR; j++) {
 		if (ppr_to_ps[j] < picosec)
 			continue;
 		period = j;
 		break;
 	}
 	if (period == -1)
 		period = picosec / 4000;
 	if (period > 0xff)
 		period = 0xff;
 	*periodp = period;
 	return count;
 }
 static ssize_t
 show_spi_transport_period(struct class_device *cdev, char *buf)
 {
 	struct scsi_target *starget = transport_class_to_starget(cdev);
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	struct spi_internal *i = to_spi_internal(shost->transportt);
 	struct spi_transport_attrs *tp =
 		(struct spi_transport_attrs *)&starget->starget_data;
 	if (i->f->get_period)
 		i->f->get_period(starget);
 	return show_spi_transport_period_helper(cdev, buf, tp->period);
 }
 static ssize_t
 store_spi_transport_period(struct class_device *cdev, const char *buf,
 			    size_t count)
 {
 	struct scsi_target *starget = transport_class_to_starget(cdev);
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	struct spi_internal *i = to_spi_internal(shost->transportt);
 	struct spi_transport_attrs *tp =
 		(struct spi_transport_attrs *)&starget->starget_data;
 	int period, retval;
 	retval = store_spi_transport_period_helper(cdev, buf, count, &period);
 	if (period < tp->min_period)
 		period = tp->min_period;
 	i->f->set_period(starget, period);
 	return retval;
 }
 static CLASS_DEVICE_ATTR(period, S_IRUGO | S_IWUSR,
 			 show_spi_transport_period,
 			 store_spi_transport_period);
 static ssize_t
 show_spi_transport_min_period(struct class_device *cdev, char *buf)
 {
 	struct scsi_target *starget = transport_class_to_starget(cdev);
 	struct spi_transport_attrs *tp =
 		(struct spi_transport_attrs *)&starget->starget_data;
 	return show_spi_transport_period_helper(cdev, buf, tp->min_period);
 }
 static ssize_t
 store_spi_transport_min_period(struct class_device *cdev, const char *buf,
 			    size_t count)
 {
 	struct scsi_target *starget = transport_class_to_starget(cdev);
 	struct spi_transport_attrs *tp =
 		(struct spi_transport_attrs *)&starget->starget_data;
 	return store_spi_transport_period_helper(cdev, buf, count,
 						 &tp->min_period);
 }
 static CLASS_DEVICE_ATTR(min_period, S_IRUGO | S_IWUSR,
 			 show_spi_transport_min_period,
 			 store_spi_transport_min_period);
 static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct spi_internal *i = to_spi_internal(shost->transportt);
 	if (i->f->get_signalling)
 		i->f->get_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,
 					 const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = transport_class_to_shost(cdev);
 	struct spi_internal *i = to_spi_internal(shost->transportt);
 	enum spi_signal_type type = spi_signal_to_value(buf);
 	if (type != SPI_SIGNAL_UNKNOWN)
 		i->f->set_signalling(shost, type);
 	return count;
 }
 static CLASS_DEVICE_ATTR(signalling, S_IRUGO | S_IWUSR,
 			 show_spi_host_signalling,
 			 store_spi_host_signalling);
 #define DV_SET(x, y)			\
 	if(i->f->set_##x)		\
 		i->f->set_##x(sdev->sdev_target, y)
 enum spi_compare_returns {
 	SPI_COMPARE_SUCCESS,
 	SPI_COMPARE_FAILURE,
 	SPI_COMPARE_SKIP_TEST,
 };
 /* This is for read/write Domain Validation:  If the device supports
  * an echo buffer, we do read/write tests to it */
 static enum spi_compare_returns
 spi_dv_device_echo_buffer(struct scsi_request *sreq, u8 *buffer,
 			  u8 *ptr, const int retries)
 {
 	struct scsi_device *sdev = sreq->sr_device;
 	int len = ptr - buffer;
 	int j, k, r;
 	unsigned int pattern = 0x0000ffff;
 	const char spi_write_buffer[] = {
 		WRITE_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0
 	};
 	const char spi_read_buffer[] = {
 		READ_BUFFER, 0x0a, 0, 0, 0, 0, 0, len >> 8, len & 0xff, 0
 	};
 	/* set up the pattern buffer.  Doesn't matter if we spill
 	 * slightly beyond since that's where the read buffer is */
 	for (j = 0; j < len; ) {
 		/* fill the buffer with counting (test a) */
 		for ( ; j < min(len, 32); j++)
 			buffer[j] = j;
 		k = j;
 		/* fill the buffer with alternating words of 0x0 and
 		 * 0xffff (test b) */
 		for ( ; j < min(len, k + 32); j += 2) {
 			u16 *word = (u16 *)&buffer[j];
 			*word = (j & 0x02) ? 0x0000 : 0xffff;
 		}
 		k = j;
 		/* fill with crosstalk (alternating 0x5555 0xaaa)
                  * (test c) */
 		for ( ; j < min(len, k + 32); j += 2) {
 			u16 *word = (u16 *)&buffer[j];
 			*word = (j & 0x02) ? 0x5555 : 0xaaaa;
 		}
 		k = j;
 		/* fill with shifting bits (test d) */
 		for ( ; j < min(len, k + 32); j += 4) {
 			u32 *word = (unsigned int *)&buffer[j];
 			u32 roll = (pattern & 0x80000000) ? 1 : 0;
 			*word = pattern;
 			pattern = (pattern << 1) | roll;
 		}
 		/* don't bother with random data (test e) */
 	}
 	for (r = 0; r < retries; r++) {
 		sreq->sr_cmd_len = 0;	/* wait_req to fill in */
 		sreq->sr_data_direction = DMA_TO_DEVICE;
 		spi_wait_req(sreq, spi_write_buffer, buffer, len);
 		if(sreq->sr_result || !scsi_device_online(sdev)) {
 			struct scsi_sense_hdr sshdr;
 			scsi_device_set_state(sdev, SDEV_QUIESCE);
 			if (scsi_request_normalize_sense(sreq, &sshdr)
 			    && sshdr.sense_key == ILLEGAL_REQUEST
 			    /* INVALID FIELD IN CDB */
 			    && sshdr.asc == 0x24 && sshdr.ascq == 0x00)
 				/* This would mean that the drive lied
 				 * to us about supporting an echo
 				 * buffer (unfortunately some Western
 				 * Digital drives do precisely this)
 				 */
 				return SPI_COMPARE_SKIP_TEST;
 			SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Write Buffer failure %x\n", sreq->sr_result);
 			return SPI_COMPARE_FAILURE;
 		}
 		memset(ptr, 0, len);
 		sreq->sr_cmd_len = 0;	/* wait_req to fill in */
 		sreq->sr_data_direction = DMA_FROM_DEVICE;
 		spi_wait_req(sreq, spi_read_buffer, ptr, len);
 		scsi_device_set_state(sdev, SDEV_QUIESCE);
 		if (memcmp(buffer, ptr, len) != 0)
 			return SPI_COMPARE_FAILURE;
 	}
 	return SPI_COMPARE_SUCCESS;
 }
 /* This is for the simplest form of Domain Validation: a read test
  * on the inquiry data from the device */
 static enum spi_compare_returns
 spi_dv_device_compare_inquiry(struct scsi_request *sreq, u8 *buffer,
 			      u8 *ptr, const int retries)
 {
 	int r;
 	const int len = sreq->sr_device->inquiry_len;
 	struct scsi_device *sdev = sreq->sr_device;
 	const char spi_inquiry[] = {
 		INQUIRY, 0, 0, 0, len, 0
 	};
 	for (r = 0; r < retries; r++) {
 		sreq->sr_cmd_len = 0;	/* wait_req to fill in */
 		sreq->sr_data_direction = DMA_FROM_DEVICE;
 		memset(ptr, 0, len);
 		spi_wait_req(sreq, spi_inquiry, ptr, len);
 		if(sreq->sr_result || !scsi_device_online(sdev)) {
 			scsi_device_set_state(sdev, SDEV_QUIESCE);
 			return SPI_COMPARE_FAILURE;
 		}
 		/* If we don't have the inquiry data already, the
 		 * first read gets it */
 		if (ptr == buffer) {
 			ptr += len;
 			--r;
 			continue;
 		}
 		if (memcmp(buffer, ptr, len) != 0)
 			/* failure */
 			return SPI_COMPARE_FAILURE;
 	}
 	return SPI_COMPARE_SUCCESS;
 }
 static enum spi_compare_returns
 spi_dv_retrain(struct scsi_request *sreq, u8 *buffer, u8 *ptr,
 	       enum spi_compare_returns
 	       (*compare_fn)(struct scsi_request *, u8 *, u8 *, int))
 {
 	struct spi_internal *i = to_spi_internal(sreq->sr_host->transportt);
 	struct scsi_device *sdev = sreq->sr_device;
 	struct scsi_target *starget = sdev->sdev_target;
 	int period = 0, prevperiod = 0;
 	enum spi_compare_returns retval;
 	for (;;) {
 		int newperiod;
 		retval = compare_fn(sreq, buffer, ptr, DV_LOOPS);
 		if (retval == SPI_COMPARE_SUCCESS
 		    || retval == SPI_COMPARE_SKIP_TEST)
 			break;
 		/* OK, retrain, fallback */
 		if (i->f->get_iu)
 			i->f->get_iu(starget);
 		if (i->f->get_qas)
 			i->f->get_qas(starget);
 		if (i->f->get_period)
 			i->f->get_period(sdev->sdev_target);
 		/* Here's the fallback sequence; first try turning off
 		 * IU, then QAS (if we can control them), then finally
 		 * fall down the periods */
 		if (i->f->set_iu && spi_iu(starget)) {
 			SPI_PRINTK(starget, KERN_ERR, "Domain Validation Disabing Information Units\n");
 			DV_SET(iu, 0);
 		} else if (i->f->set_qas && spi_qas(starget)) {
 			SPI_PRINTK(starget, KERN_ERR, "Domain Validation Disabing Quick Arbitration and Selection\n");
 			DV_SET(qas, 0);
 		} else {
 			newperiod = spi_period(starget);
 			period = newperiod > period ? newperiod : period;
 			if (period < 0x0d)
 				period++;
 			else
 				period += period >> 1;
 			if (unlikely(period > 0xff || period == prevperiod)) {
 				/* Total failure; set to async and return */
 				SPI_PRINTK(starget, KERN_ERR, "Domain Validation Failure, dropping back to Asynchronous\n");
 				DV_SET(offset, 0);
 				return SPI_COMPARE_FAILURE;
 			}
 			SPI_PRINTK(starget, KERN_ERR, "Domain Validation detected failure, dropping back\n");
 			DV_SET(period, period);
 			prevperiod = period;
 		}
 	}
 	return retval;
 }
 static int
 spi_dv_device_get_echo_buffer(struct scsi_request *sreq, u8 *buffer)
 {
 	int l;
 	/* first off do a test unit ready.  This can error out
 	 * because of reservations or some other reason.  If it
 	 * fails, the device won't let us write to the echo buffer
 	 * so just return failure */
 	const char spi_test_unit_ready[] = {
 		TEST_UNIT_READY, 0, 0, 0, 0, 0
 	};
 	const char spi_read_buffer_descriptor[] = {
 		READ_BUFFER, 0x0b, 0, 0, 0, 0, 0, 0, 4, 0
 	};
 	sreq->sr_cmd_len = 0;
 	sreq->sr_data_direction = DMA_NONE;
 	/* We send a set of three TURs to clear any outstanding
 	 * unit attention conditions if they exist (Otherwise the
 	 * buffer tests won't be happy).  If the TUR still fails
 	 * (reservation conflict, device not ready, etc) just
 	 * skip the write tests */
 	for (l = 0; ; l++) {
 		spi_wait_req(sreq, spi_test_unit_ready, NULL, 0);
 		if(sreq->sr_result) {
 			if(l >= 3)
 				return 0;
 		} else {
 			/* TUR succeeded */
 			break;
 		}
 	}
 	sreq->sr_cmd_len = 0;
 	sreq->sr_data_direction = DMA_FROM_DEVICE;
 	spi_wait_req(sreq, spi_read_buffer_descriptor, buffer, 4);
 	if (sreq->sr_result)
 		/* Device has no echo buffer */
 		return 0;
 	return buffer[3] + ((buffer[2] & 0x1f) << 8);
 }
 static void
 spi_dv_device_internal(struct scsi_request *sreq, u8 *buffer)
 {
 	struct spi_internal *i = to_spi_internal(sreq->sr_host->transportt);
 	struct scsi_device *sdev = sreq->sr_device;
 	struct scsi_target *starget = sdev->sdev_target;
 	int len = sdev->inquiry_len;
 	/* first set us up for narrow async */
 	DV_SET(offset, 0);
 	DV_SET(width, 0);
 	if (spi_dv_device_compare_inquiry(sreq, buffer, buffer, DV_LOOPS)
 	    != SPI_COMPARE_SUCCESS) {
 		SPI_PRINTK(starget, KERN_ERR, "Domain Validation Initial Inquiry Failed\n");
 		/* FIXME: should probably offline the device here? */
 		return;
 	}
 	/* test width */
 	if (i->f->set_width && spi_max_width(starget) &&
 	    scsi_device_wide(sdev)) {
 		i->f->set_width(starget, 1);
 		if (spi_dv_device_compare_inquiry(sreq, buffer,
 						   buffer + len,
 						   DV_LOOPS)
 		    != SPI_COMPARE_SUCCESS) {
 			SPI_PRINTK(starget, KERN_ERR, "Wide Transfers Fail\n");
 			i->f->set_width(starget, 0);
 		}
 	}
 	if (!i->f->set_period)
 		return;
 	/* device can't handle synchronous */
 	if (!scsi_device_sync(sdev) && !scsi_device_dt(sdev))
 		return;
 	/* see if the device has an echo buffer.  If it does we can
 	 * do the SPI pattern write tests */
 	len = 0;
 	if (scsi_device_dt(sdev))
 		len = spi_dv_device_get_echo_buffer(sreq, buffer);
  retry:
 	/* now set up to the maximum */
 	DV_SET(offset, spi_max_offset(starget));
 	DV_SET(period, spi_min_period(starget));
 	/* try QAS requests; this should be harmless to set if the
 	 * target supports it */
 	if (scsi_device_qas(sdev))
 		DV_SET(qas, 1);
 	/* Also try IU transfers */
 	if (scsi_device_ius(sdev))
 		DV_SET(iu, 1);
 	if (spi_min_period(starget) < 9) {
 		/* This u320 (or u640). Ignore the coupled parameters
 		 * like DT and IU, but set the optional ones */
 		DV_SET(rd_strm, 1);
 		DV_SET(wr_flow, 1);
 		DV_SET(rti, 1);
 		if (spi_min_period(starget) == 8)
 			DV_SET(pcomp_en, 1);
 	}
 	if (len == 0) {
 		SPI_PRINTK(starget, KERN_INFO, "Domain Validation skipping write tests\n");
 		spi_dv_retrain(sreq, buffer, buffer + len,
 			       spi_dv_device_compare_inquiry);
 		return;
 	}
 	if (len > SPI_MAX_ECHO_BUFFER_SIZE) {
 		SPI_PRINTK(starget, KERN_WARNING, "Echo buffer size %d is too big, trimming to %d\n", len, SPI_MAX_ECHO_BUFFER_SIZE);
 		len = SPI_MAX_ECHO_BUFFER_SIZE;
 	}
 	if (spi_dv_retrain(sreq, buffer, buffer + len,
 			   spi_dv_device_echo_buffer)
 	    == SPI_COMPARE_SKIP_TEST) {
 		/* OK, the stupid drive can't do a write echo buffer
 		 * test after all, fall back to the read tests */
 		len = 0;
 		goto retry;
 	}
 }
 /**	spi_dv_device - Do Domain Validation on the device
  *	@sdev:		scsi device to validate
  *
  *	Performs the domain validation on the given device in the
  *	current execution thread.  Since DV operations may sleep,
  *	the current thread must have user context.  Also no SCSI
  *	related locks that would deadlock I/O issued by the DV may
  *	be held.
  */
 void
 spi_dv_device(struct scsi_device *sdev)
 {
 	struct scsi_request *sreq = scsi_allocate_request(sdev, GFP_KERNEL);
 	struct scsi_target *starget = sdev->sdev_target;
 	u8 *buffer;
 	const int len = SPI_MAX_ECHO_BUFFER_SIZE*2;
 	if (unlikely(!sreq))
 		return;
 	if (unlikely(scsi_device_get(sdev)))
 		goto out_free_req;
 	buffer = kmalloc(len, GFP_KERNEL);
 	if (unlikely(!buffer))
 		goto out_put;
 	memset(buffer, 0, len);
 	/* We need to verify that the actual device will quiesce; the
 	 * later target quiesce is just a nice to have */
 	if (unlikely(scsi_device_quiesce(sdev)))
 		goto out_free;
 	scsi_target_quiesce(starget);
 	spi_dv_pending(starget) = 1;
 	down(&spi_dv_sem(starget));
 	SPI_PRINTK(starget, KERN_INFO, "Beginning Domain Validation\n");
 	spi_dv_device_internal(sreq, buffer);
 	SPI_PRINTK(starget, KERN_INFO, "Ending Domain Validation\n");
 	up(&spi_dv_sem(starget));
 	spi_dv_pending(starget) = 0;
 	scsi_target_resume(starget);
 	spi_initial_dv(starget) = 1;
  out_free:
 	kfree(buffer);
  out_put:
 	scsi_device_put(sdev);
  out_free_req:
 	scsi_release_request(sreq);
 }
 EXPORT_SYMBOL(spi_dv_device);
 struct work_queue_wrapper {
 	struct work_struct	work;
 	struct scsi_device	*sdev;
 };
 static void
 spi_dv_device_work_wrapper(void *data)
 {
 	struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
 	struct scsi_device *sdev = wqw->sdev;
 	kfree(wqw);
 	spi_dv_device(sdev);
 	spi_dv_pending(sdev->sdev_target) = 0;
 	scsi_device_put(sdev);
 }
 /**
  *	spi_schedule_dv_device - schedule domain validation to occur on the device
  *	@sdev:	The device to validate
  *
  *	Identical to spi_dv_device() above, except that the DV will be
  *	scheduled to occur in a workqueue later.  All memory allocations
  *	are atomic, so may be called from any context including those holding
  *	SCSI locks.
  */
 void
 spi_schedule_dv_device(struct scsi_device *sdev)
 {
 	struct work_queue_wrapper *wqw =
 		kmalloc(sizeof(struct work_queue_wrapper), GFP_ATOMIC);
 	if (unlikely(!wqw))
 		return;
 	if (unlikely(spi_dv_pending(sdev->sdev_target))) {
 		kfree(wqw);
 		return;
 	}
 	/* Set pending early (dv_device doesn't check it, only sets it) */
 	spi_dv_pending(sdev->sdev_target) = 1;
 	if (unlikely(scsi_device_get(sdev))) {
 		kfree(wqw);
 		spi_dv_pending(sdev->sdev_target) = 0;
 		return;
 	}
 	INIT_WORK(&wqw->work, spi_dv_device_work_wrapper, wqw);
 	wqw->sdev = sdev;
 	schedule_work(&wqw->work);
 }
 EXPORT_SYMBOL(spi_schedule_dv_device);
 /**
  * spi_display_xfer_agreement - Print the current target transfer agreement
  * @starget: The target for which to display the agreement
  *
  * Each SPI port is required to maintain a transfer agreement for each
  * other port on the bus.  This function prints a one-line summary of
  * the current agreement; more detailed information is available in sysfs.
  */
 void spi_display_xfer_agreement(struct scsi_target *starget)
 {
 	struct spi_transport_attrs *tp;
 	tp = (struct spi_transport_attrs *)&starget->starget_data;
 	if (tp->offset > 0 && tp->period > 0) {
 		unsigned int picosec, kb100;
 		char *scsi = "FAST-?";
 		char tmp[8];
 		if (tp->period <= SPI_STATIC_PPR) {
 			picosec = ppr_to_ps[tp->period];
 			switch (tp->period) {
 				case  7: scsi = "FAST-320"; break;
 				case  8: scsi = "FAST-160"; break;
 				case  9: scsi = "FAST-80"; break;
 				case 10:
 				case 11: scsi = "FAST-40"; break;
 				case 12: scsi = "FAST-20"; break;
 			}
 		} else {
 			picosec = tp->period * 4000;
 			if (tp->period < 25)
 				scsi = "FAST-20";
 			else if (tp->period < 50)
 				scsi = "FAST-10";
 			else
 				scsi = "FAST-5";
 		}
 		kb100 = (10000000 + picosec / 2) / picosec;
 		if (tp->width)
 			kb100 *= 2;
 		sprint_frac(tmp, picosec, 1000);
 		dev_info(&starget->dev,
 			 "%s %sSCSI %d.%d MB/s %s%s%s%s%s%s%s%s (%s ns, offset %d)\n",
 			 scsi, tp->width ? "WIDE " : "", kb100/10, kb100 % 10,
 			 tp->dt ? "DT" : "ST",
 			 tp->iu ? " IU" : "",
 			 tp->qas  ? " QAS" : "",
 			 tp->rd_strm ? " RDSTRM" : "",
 			 tp->rti ? " RTI" : "",
 			 tp->wr_flow ? " WRFLOW" : "",
 			 tp->pcomp_en ? " PCOMP" : "",
 			 tp->hold_mcs ? " HMCS" : "",
 			 tmp, tp->offset);
 	} else {
 		dev_info(&starget->dev, "%sasynchronous.\n",
 				tp->width ? "wide " : "");
 	}
 }
 EXPORT_SYMBOL(spi_display_xfer_agreement);
 #define SETUP_ATTRIBUTE(field)						\
 	i->private_attrs[count] = class_device_attr_##field;		\
 	if (!i->f->set_##field) {					\
 		i->private_attrs[count].attr.mode = S_IRUGO;		\
 		i->private_attrs[count].store = NULL;			\
 	}								\
 	i->attrs[count] = &i->private_attrs[count];			\
 	if (i->f->show_##field)						\
 		count++
 #define SETUP_RELATED_ATTRIBUTE(field, rel_field)			\
 	i->private_attrs[count] = class_device_attr_##field;		\
 	if (!i->f->set_##rel_field) {					\
 		i->private_attrs[count].attr.mode = S_IRUGO;		\
 		i->private_attrs[count].store = NULL;			\
 	}								\
 	i->attrs[count] = &i->private_attrs[count];			\
 	if (i->f->show_##rel_field)					\
 		count++
 #define SETUP_HOST_ATTRIBUTE(field)					\
 	i->private_host_attrs[count] = class_device_attr_##field;	\
 	if (!i->f->set_##field) {					\
 		i->private_host_attrs[count].attr.mode = S_IRUGO;	\
 		i->private_host_attrs[count].store = NULL;		\
 	}								\
 	i->host_attrs[count] = &i->private_host_attrs[count];		\
 	count++
 static int spi_device_match(struct attribute_container *cont,
 			    struct device *dev)
 {
 	struct scsi_device *sdev;
 	struct Scsi_Host *shost;
 	struct spi_internal *i;
 	if (!scsi_is_sdev_device(dev))
 		return 0;
 	sdev = to_scsi_device(dev);
 	shost = sdev->host;
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &spi_host_class.class)
 		return 0;
 	/* Note: this class has no device attributes, so it has
 	 * no per-HBA allocation and thus we don't need to distinguish
 	 * the attribute containers for the device */
 	i = to_spi_internal(shost->transportt);
 	if (i->f->deny_binding && i->f->deny_binding(sdev->sdev_target))
 		return 0;
 	return 1;
 }
 static int spi_target_match(struct attribute_container *cont,
 			    struct device *dev)
 {
 	struct Scsi_Host *shost;
 	struct scsi_target *starget;
 	struct spi_internal *i;
 	if (!scsi_is_target_device(dev))
 		return 0;
 	shost = dev_to_shost(dev->parent);
 	if (!shost->transportt  || shost->transportt->host_attrs.ac.class
 	    != &spi_host_class.class)
 		return 0;
 	i = to_spi_internal(shost->transportt);
 	starget = to_scsi_target(dev);
 	if (i->f->deny_binding && i->f->deny_binding(starget))
 		return 0;
 	return &i->t.target_attrs.ac == cont;
 }
 static DECLARE_TRANSPORT_CLASS(spi_transport_class,
 			       "spi_transport",
 			       spi_setup_transport_attrs,
 			       NULL,
 			       NULL);
 static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
 				    spi_device_match,
 				    spi_device_configure);
 struct scsi_transport_template *
 spi_attach_transport(struct spi_function_template *ft)
 {
 	struct spi_internal *i = kmalloc(sizeof(struct spi_internal),
 					 GFP_KERNEL);
 	int count = 0;
 	if (unlikely(!i))
 		return NULL;
 	memset(i, 0, sizeof(struct spi_internal));
 	i->t.target_attrs.ac.class = &spi_transport_class.class;
 	i->t.target_attrs.ac.attrs = &i->attrs[0];
 	i->t.target_attrs.ac.match = spi_target_match;
 	transport_container_register(&i->t.target_attrs);
 	i->t.target_size = sizeof(struct spi_transport_attrs);
 	i->t.host_attrs.ac.class = &spi_host_class.class;
 	i->t.host_attrs.ac.attrs = &i->host_attrs[0];
 	i->t.host_attrs.ac.match = spi_host_match;
 	transport_container_register(&i->t.host_attrs);
 	i->t.host_size = sizeof(struct spi_host_attrs);
 	i->f = ft;
 	SETUP_ATTRIBUTE(period);
 	SETUP_RELATED_ATTRIBUTE(min_period, period);
 	SETUP_ATTRIBUTE(offset);
 	SETUP_RELATED_ATTRIBUTE(max_offset, offset);
 	SETUP_ATTRIBUTE(width);
 	SETUP_RELATED_ATTRIBUTE(max_width, width);
 	SETUP_ATTRIBUTE(iu);
 	SETUP_ATTRIBUTE(dt);
 	SETUP_ATTRIBUTE(qas);
 	SETUP_ATTRIBUTE(wr_flow);
 	SETUP_ATTRIBUTE(rd_strm);
 	SETUP_ATTRIBUTE(rti);
 	SETUP_ATTRIBUTE(pcomp_en);
 	SETUP_ATTRIBUTE(hold_mcs);
 	/* if you add an attribute but forget to increase SPI_NUM_ATTRS
 	 * this bug will trigger */
 	BUG_ON(count > SPI_NUM_ATTRS);
 	i->attrs[count++] = &class_device_attr_revalidate;
 	i->attrs[count] = NULL;
 	count = 0;
 	SETUP_HOST_ATTRIBUTE(signalling);
 	BUG_ON(count > SPI_HOST_ATTRS);
 	i->host_attrs[count] = NULL;
 	return &i->t;
 }
 EXPORT_SYMBOL(spi_attach_transport);
 void spi_release_transport(struct scsi_transport_template *t)
 {
 	struct spi_internal *i = to_spi_internal(t);
 	transport_container_unregister(&i->t.target_attrs);
 	transport_container_unregister(&i->t.host_attrs);
 	kfree(i);
 }
 EXPORT_SYMBOL(spi_release_transport);
 static __init int spi_transport_init(void)
 {
 	int error = transport_class_register(&spi_transport_class);
 	if (error)
 		return error;
 	error = anon_transport_class_register(&spi_device_class);
 	return transport_class_register(&spi_host_class);
 }
 static void __exit spi_transport_exit(void)
 {
 	transport_class_unregister(&spi_transport_class);
 	anon_transport_class_unregister(&spi_device_class);
 	transport_class_unregister(&spi_host_class);
 }
 MODULE_AUTHOR("Martin Hicks");
 MODULE_DESCRIPTION("SPI Transport Attributes");
 MODULE_LICENSE("GPL");
 module_init(spi_transport_init);
 module_exit(spi_transport_exit);

include/linux/attribute_container.h

Diff comments View file @ d0a7e57

1	/*	1	/*
2	* class_container.h - a generic container for all classes	2	* class_container.h - a generic container for all classes
3	*	3	*
4	* Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>	4	* Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
5	*	5	*
6	* This file is licensed under GPLv2	6	* This file is licensed under GPLv2
7	*/	7	*/
8		8
9	#ifndef _ATTRIBUTE_CONTAINER_H_	9	#ifndef _ATTRIBUTE_CONTAINER_H_
10	#define _ATTRIBUTE_CONTAINER_H_	10	#define _ATTRIBUTE_CONTAINER_H_
11		11
12	#include <linux/device.h>	12	#include <linux/device.h>
13	#include <linux/list.h>	13	#include <linux/list.h>
		14	#include <linux/spinlock.h>
14		15
15	struct attribute_container {	16	struct attribute_container {
16	struct list_head node;	17	struct list_head node;
17	struct list_head containers;	18	struct list_head containers;
		19	spinlock_t containers_lock;
18	struct class *class;	20	struct class *class;
19	struct class_device_attribute **attrs;	21	struct class_device_attribute **attrs;
20	int (match)(struct attribute_container , struct device *);	22	int (match)(struct attribute_container , struct device *);
21	#define ATTRIBUTE_CONTAINER_NO_CLASSDEVS 0x01	23	#define ATTRIBUTE_CONTAINER_NO_CLASSDEVS 0x01
22	unsigned long flags;	24	unsigned long flags;
23	};	25	};
24		26
25	static inline int	27	static inline int
26	attribute_container_no_classdevs(struct attribute_container *atc)	28	attribute_container_no_classdevs(struct attribute_container *atc)
27	{	29	{
28	return atc->flags & ATTRIBUTE_CONTAINER_NO_CLASSDEVS;	30	return atc->flags & ATTRIBUTE_CONTAINER_NO_CLASSDEVS;
29	}	31	}
30		32
31	static inline void	33	static inline void
32	attribute_container_set_no_classdevs(struct attribute_container *atc)	34	attribute_container_set_no_classdevs(struct attribute_container *atc)
33	{	35	{
34	atc->flags \|= ATTRIBUTE_CONTAINER_NO_CLASSDEVS;	36	atc->flags \|= ATTRIBUTE_CONTAINER_NO_CLASSDEVS;
35	}	37	}
36		38
37	int attribute_container_register(struct attribute_container *cont);	39	int attribute_container_register(struct attribute_container *cont);
38	int attribute_container_unregister(struct attribute_container *cont);	40	int attribute_container_unregister(struct attribute_container *cont);
39	void attribute_container_create_device(struct device *dev,	41	void attribute_container_create_device(struct device *dev,
40	int (fn)(struct attribute_container ,	42	int (fn)(struct attribute_container ,
41	struct device *,	43	struct device *,
42	struct class_device *));	44	struct class_device *));
43	void attribute_container_add_device(struct device *dev,	45	void attribute_container_add_device(struct device *dev,
44	int (fn)(struct attribute_container ,	46	int (fn)(struct attribute_container ,
45	struct device *,	47	struct device *,
46	struct class_device *));	48	struct class_device *));
47	void attribute_container_remove_device(struct device *dev,	49	void attribute_container_remove_device(struct device *dev,
48	void (fn)(struct attribute_container ,	50	void (fn)(struct attribute_container ,
49	struct device *,	51	struct device *,
50	struct class_device *));	52	struct class_device *));
51	void attribute_container_device_trigger(struct device *dev,	53	void attribute_container_device_trigger(struct device *dev,
52	int (fn)(struct attribute_container ,	54	int (fn)(struct attribute_container ,
53	struct device *,	55	struct device *,
54	struct class_device *));	56	struct class_device *));
55	void attribute_container_trigger(struct device *dev,	57	void attribute_container_trigger(struct device *dev,
56	int (fn)(struct attribute_container ,	58	int (fn)(struct attribute_container ,
57	struct device *));	59	struct device *));
58	int attribute_container_add_attrs(struct class_device *classdev);	60	int attribute_container_add_attrs(struct class_device *classdev);
59	int attribute_container_add_class_device(struct class_device *classdev);	61	int attribute_container_add_class_device(struct class_device *classdev);
60	int attribute_container_add_class_device_adapter(struct attribute_container *cont,	62	int attribute_container_add_class_device_adapter(struct attribute_container *cont,
61	struct device *dev,	63	struct device *dev,
62	struct class_device *classdev);	64	struct class_device *classdev);
63	void attribute_container_remove_attrs(struct class_device *classdev);	65	void attribute_container_remove_attrs(struct class_device *classdev);
64	void attribute_container_class_device_del(struct class_device *classdev);	66	void attribute_container_class_device_del(struct class_device *classdev);
65		67	struct class_device attribute_container_find_class_device(struct attribute_container , struct device *);
66
67
68
69
70
71	struct class_device_attribute *attribute_container_classdev_to_attrs(const struct class_device classdev);	68	struct class_device_attribute *attribute_container_classdev_to_attrs(const struct class_device classdev);
72		69

include/linux/transport_class.h

Diff comments View file @ d0a7e57

 /*
  * transport_class.h - a generic container for all transport classes
  *
  * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
  *
  * This file is licensed under GPLv2
  */
 #ifndef _TRANSPORT_CLASS_H_
 #define _TRANSPORT_CLASS_H_
 #include <linux/device.h>
 #include <linux/attribute_container.h>
+struct transport_container;
 struct transport_class {
 	struct class class;
-	int (*setup)(struct device *);
+	int (*setup)(struct transport_container *, struct device *,
-	int (*configure)(struct device *);
+		     struct class_device *);
-	int (*remove)(struct device *);
+	int (*configure)(struct transport_container *, struct device *,
+			 struct class_device *);
+	int (*remove)(struct transport_container *, struct device *,
+		      struct class_device *);
 };
 #define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg)			\
 struct transport_class cls = {						\
 	.class = {							\
 		.name = nm,						\
 	},								\
 	.setup = su,							\
 	.remove = rm,							\
 	.configure = cfg,						\
 }
 struct anon_transport_class {
 	struct transport_class tclass;
 	struct attribute_container container;
 };
 #define DECLARE_ANON_TRANSPORT_CLASS(cls, mtch, cfg)		\
 struct anon_transport_class cls = {				\
 	.tclass = {						\
 		.configure = cfg,				\
 	},							\
 	. container = {						\
 		.match = mtch,					\
 	},							\
 }
 #define class_to_transport_class(x) \
 	container_of(x, struct transport_class, class)
 struct transport_container {
 	struct attribute_container ac;
 	struct attribute_group *statistics;
 };
 #define attribute_container_to_transport_container(x) \
 	container_of(x, struct transport_container, ac)
 void transport_remove_device(struct device *);
 void transport_add_device(struct device *);
 void transport_setup_device(struct device *);
 void transport_configure_device(struct device *);
 void transport_destroy_device(struct device *);
 static inline void
 transport_register_device(struct device *dev)
 {
 	transport_setup_device(dev);
 	transport_add_device(dev);
 }
 static inline void
 transport_unregister_device(struct device *dev)
 {
 	transport_remove_device(dev);
 	transport_destroy_device(dev);
 }
 static inline int transport_container_register(struct transport_container *tc)
 {
 	return attribute_container_register(&tc->ac);
 }
 static inline int transport_container_unregister(struct transport_container *tc)
 {
 	return attribute_container_unregister(&tc->ac);
 }
 int transport_class_register(struct transport_class *);
 int anon_transport_class_register(struct anon_transport_class *);
 void transport_class_unregister(struct transport_class *);
 void anon_transport_class_unregister(struct anon_transport_class *);
 #endif