[SCSI] SAS transport class
The SAS transport class contains common code to deal with SAS HBAs, an aproximated representation of SAS topologies in the driver model, and various sysfs attributes to expose these topologies and managment interfaces to userspace. In addition to the basic SCSI core objects this transport class introduces two additional intermediate objects: The SAS PHY as represented by struct sas_phy defines an "outgoing" PHY on a SAS HBA or Expander, and the SAS remote PHY represented by struct sas_rphy defines an "incoming" PHY on a SAS Expander or end device. Note that this is purely a software concept, the underlying hardware for a PHY and a remote PHY is the exactly the same. There is no concept of a SAS port in this code, users can see what PHYs form a wide port based on the port_identifier attribute, which is the same for all PHYs in a port. This submission doesn't handle hot-plug addition or removal of SAS devices and thus doesn't do scanning in a workqueue yet, that will be added in phase2 after this submission. In a third phase I will add additional managment infrastructure. I think this submission is ready for 2.6.14, but additional comments are of course very welcome. I'd like to thanks James Smart a lot for his very useful input on the design. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
This commit is contained in:
Christoph Hellwig
James Bottomley
parent
942fc2fb73
commit
c7ebbbce36
@ -235,6 +235,13 @@ config SCSI_ISCSI_ATTRS
|
||||
each attached iSCSI device to sysfs, say Y.
|
||||
Otherwise, say N.
|
||||
|
||||
config SCSI_SAS_ATTRS
|
||||
tristate "SAS Transport Attributes"
|
||||
depends on SCSI
|
||||
help
|
||||
If you wish to export transport-specific information about
|
||||
each attached SAS device to sysfs, say Y.
|
||||
|
||||
endmenu
|
||||
|
||||
menu "SCSI low-level drivers"
|
||||
|
||||
@ -31,6 +31,7 @@ obj-$(CONFIG_RAID_ATTRS) += raid_class.o
|
||||
obj-$(CONFIG_SCSI_SPI_ATTRS) += scsi_transport_spi.o
|
||||
obj-$(CONFIG_SCSI_FC_ATTRS) += scsi_transport_fc.o
|
||||
obj-$(CONFIG_SCSI_ISCSI_ATTRS) += scsi_transport_iscsi.o
|
||||
obj-$(CONFIG_SCSI_SAS_ATTRS) += scsi_transport_sas.o
|
||||
|
||||
obj-$(CONFIG_SCSI_AMIGA7XX) += amiga7xx.o 53c7xx.o
|
||||
obj-$(CONFIG_A3000_SCSI) += a3000.o wd33c93.o
|
||||
|
||||
819
drivers/scsi/scsi_transport_sas.c
Normal file
819
drivers/scsi/scsi_transport_sas.c
Normal file
@ -0,0 +1,819 @@
|
||||
/*
|
||||
* Copyright (C) 2005 Dell Inc.
|
||||
* Released under GPL v2.
|
||||
*
|
||||
* Serial Attached SCSI (SAS) transport class.
|
||||
*
|
||||
* The SAS transport class contains common code to deal with SAS HBAs,
|
||||
* an aproximated representation of SAS topologies in the driver model,
|
||||
* and various sysfs attributes to expose these topologies and managment
|
||||
* interfaces to userspace.
|
||||
*
|
||||
* In addition to the basic SCSI core objects this transport class
|
||||
* introduces two additional intermediate objects: The SAS PHY
|
||||
* as represented by struct sas_phy defines an "outgoing" PHY on
|
||||
* a SAS HBA or Expander, and the SAS remote PHY represented by
|
||||
* struct sas_rphy defines an "incoming" PHY on a SAS Expander or
|
||||
* end device. Note that this is purely a software concept, the
|
||||
* underlying hardware for a PHY and a remote PHY is the exactly
|
||||
* the same.
|
||||
*
|
||||
* There is no concept of a SAS port in this code, users can see
|
||||
* what PHYs form a wide port based on the port_identifier attribute,
|
||||
* which is the same for all PHYs in a port.
|
||||
*/
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/err.h>
|
||||
|
||||
#include <scsi/scsi_device.h>
|
||||
#include <scsi/scsi_host.h>
|
||||
#include <scsi/scsi_transport.h>
|
||||
#include <scsi/scsi_transport_sas.h>
|
||||
|
||||
|
||||
#define SAS_HOST_ATTRS 0
|
||||
#define SAS_PORT_ATTRS 11
|
||||
#define SAS_RPORT_ATTRS 5
|
||||
|
||||
struct sas_internal {
|
||||
struct scsi_transport_template t;
|
||||
struct sas_function_template *f;
|
||||
|
||||
struct class_device_attribute private_host_attrs[SAS_HOST_ATTRS];
|
||||
struct class_device_attribute private_phy_attrs[SAS_PORT_ATTRS];
|
||||
struct class_device_attribute private_rphy_attrs[SAS_RPORT_ATTRS];
|
||||
|
||||
struct transport_container phy_attr_cont;
|
||||
struct transport_container rphy_attr_cont;
|
||||
|
||||
/*
|
||||
* The array of null terminated pointers to attributes
|
||||
* needed by scsi_sysfs.c
|
||||
*/
|
||||
struct class_device_attribute *host_attrs[SAS_HOST_ATTRS + 1];
|
||||
struct class_device_attribute *phy_attrs[SAS_PORT_ATTRS + 1];
|
||||
struct class_device_attribute *rphy_attrs[SAS_RPORT_ATTRS + 1];
|
||||
};
|
||||
#define to_sas_internal(tmpl) container_of(tmpl, struct sas_internal, t)
|
||||
|
||||
struct sas_host_attrs {
|
||||
struct list_head rphy_list;
|
||||
spinlock_t lock;
|
||||
u32 next_target_id;
|
||||
};
|
||||
#define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
|
||||
|
||||
|
||||
/*
|
||||
* Hack to allow attributes of the same name in different objects.
|
||||
*/
|
||||
#define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
|
||||
struct class_device_attribute class_device_attr_##_prefix##_##_name = \
|
||||
__ATTR(_name,_mode,_show,_store)
|
||||
|
||||
|
||||
/*
|
||||
* Pretty printing helpers
|
||||
*/
|
||||
|
||||
#define sas_bitfield_name_match(title, table) \
|
||||
static ssize_t \
|
||||
get_sas_##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; \
|
||||
}
|
||||
|
||||
#define sas_bitfield_name_search(title, table) \
|
||||
static ssize_t \
|
||||
get_sas_##title##_names(u32 table_key, char *buf) \
|
||||
{ \
|
||||
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", \
|
||||
table[i].name); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
len += sprintf(buf + len, "\n"); \
|
||||
return len; \
|
||||
}
|
||||
|
||||
static struct {
|
||||
u32 value;
|
||||
char *name;
|
||||
} sas_device_type_names[] = {
|
||||
{ SAS_PHY_UNUSED, "unused" },
|
||||
{ SAS_END_DEVICE, "end device" },
|
||||
{ SAS_EDGE_EXPANDER_DEVICE, "edge expander" },
|
||||
{ SAS_FANOUT_EXPANDER_DEVICE, "fanout expander" },
|
||||
};
|
||||
sas_bitfield_name_search(device_type, sas_device_type_names)
|
||||
|
||||
|
||||
static struct {
|
||||
u32 value;
|
||||
char *name;
|
||||
} sas_protocol_names[] = {
|
||||
{ SAS_PROTOCOL_SATA, "sata" },
|
||||
{ SAS_PROTOCOL_SMP, "smp" },
|
||||
{ SAS_PROTOCOL_STP, "stp" },
|
||||
{ SAS_PROTOCOL_SSP, "ssp" },
|
||||
};
|
||||
sas_bitfield_name_match(protocol, sas_protocol_names)
|
||||
|
||||
static struct {
|
||||
u32 value;
|
||||
char *name;
|
||||
} sas_linkspeed_names[] = {
|
||||
{ SAS_LINK_RATE_UNKNOWN, "Unknown" },
|
||||
{ SAS_PHY_DISABLED, "Phy disabled" },
|
||||
{ SAS_LINK_RATE_FAILED, "Link Rate failed" },
|
||||
{ SAS_SATA_SPINUP_HOLD, "Spin-up hold" },
|
||||
{ SAS_LINK_RATE_1_5_GBPS, "1.5 Gbit" },
|
||||
{ SAS_LINK_RATE_3_0_GBPS, "3.0 Gbit" },
|
||||
};
|
||||
sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
|
||||
|
||||
|
||||
/*
|
||||
* SAS host attributes
|
||||
*/
|
||||
|
||||
static int sas_host_setup(struct device *dev)
|
||||
{
|
||||
struct Scsi_Host *shost = dev_to_shost(dev);
|
||||
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
|
||||
|
||||
INIT_LIST_HEAD(&sas_host->rphy_list);
|
||||
spin_lock_init(&sas_host->lock);
|
||||
sas_host->next_target_id = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static DECLARE_TRANSPORT_CLASS(sas_host_class,
|
||||
"sas_host", sas_host_setup, NULL, NULL);
|
||||
|
||||
static int sas_host_match(struct attribute_container *cont,
|
||||
struct device *dev)
|
||||
{
|
||||
struct Scsi_Host *shost;
|
||||
struct sas_internal *i;
|
||||
|
||||
if (!scsi_is_host_device(dev))
|
||||
return 0;
|
||||
shost = dev_to_shost(dev);
|
||||
|
||||
if (!shost->transportt)
|
||||
return 0;
|
||||
if (shost->transportt->host_attrs.ac.class !=
|
||||
&sas_host_class.class)
|
||||
return 0;
|
||||
|
||||
i = to_sas_internal(shost->transportt);
|
||||
return &i->t.host_attrs.ac == cont;
|
||||
}
|
||||
|
||||
static int do_sas_phy_delete(struct device *dev, void *data)
|
||||
{
|
||||
if (scsi_is_sas_phy(dev))
|
||||
sas_phy_delete(dev_to_phy(dev));
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* sas_remove_host -- tear down a Scsi_Host's SAS data structures
|
||||
* @shost: Scsi Host that is torn down
|
||||
*
|
||||
* Removes all SAS PHYs and remote PHYs for a given Scsi_Host.
|
||||
* Must be called just before scsi_remove_host for SAS HBAs.
|
||||
*/
|
||||
void sas_remove_host(struct Scsi_Host *shost)
|
||||
{
|
||||
device_for_each_child(&shost->shost_gendev, NULL, do_sas_phy_delete);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_remove_host);
|
||||
|
||||
|
||||
/*
|
||||
* SAS Port attributes
|
||||
*/
|
||||
|
||||
#define sas_phy_show_simple(field, name, format_string, cast) \
|
||||
static ssize_t \
|
||||
show_sas_phy_##name(struct class_device *cdev, char *buf) \
|
||||
{ \
|
||||
struct sas_phy *phy = transport_class_to_phy(cdev); \
|
||||
\
|
||||
return snprintf(buf, 20, format_string, cast phy->field); \
|
||||
}
|
||||
|
||||
#define sas_phy_simple_attr(field, name, format_string, type) \
|
||||
sas_phy_show_simple(field, name, format_string, (type)) \
|
||||
static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
|
||||
|
||||
#define sas_phy_show_protocol(field, name) \
|
||||
static ssize_t \
|
||||
show_sas_phy_##name(struct class_device *cdev, char *buf) \
|
||||
{ \
|
||||
struct sas_phy *phy = transport_class_to_phy(cdev); \
|
||||
\
|
||||
if (!phy->field) \
|
||||
return snprintf(buf, 20, "none\n"); \
|
||||
return get_sas_protocol_names(phy->field, buf); \
|
||||
}
|
||||
|
||||
#define sas_phy_protocol_attr(field, name) \
|
||||
sas_phy_show_protocol(field, name) \
|
||||
static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
|
||||
|
||||
#define sas_phy_show_linkspeed(field) \
|
||||
static ssize_t \
|
||||
show_sas_phy_##field(struct class_device *cdev, char *buf) \
|
||||
{ \
|
||||
struct sas_phy *phy = transport_class_to_phy(cdev); \
|
||||
\
|
||||
return get_sas_linkspeed_names(phy->field, buf); \
|
||||
}
|
||||
|
||||
#define sas_phy_linkspeed_attr(field) \
|
||||
sas_phy_show_linkspeed(field) \
|
||||
static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
|
||||
|
||||
static ssize_t
|
||||
show_sas_device_type(struct class_device *cdev, char *buf)
|
||||
{
|
||||
struct sas_phy *phy = transport_class_to_phy(cdev);
|
||||
|
||||
if (!phy->identify.device_type)
|
||||
return snprintf(buf, 20, "none\n");
|
||||
return get_sas_device_type_names(phy->identify.device_type, buf);
|
||||
}
|
||||
|
||||
static CLASS_DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
|
||||
|
||||
sas_phy_protocol_attr(identify.initiator_port_protocols,
|
||||
initiator_port_protocols);
|
||||
sas_phy_protocol_attr(identify.target_port_protocols,
|
||||
target_port_protocols);
|
||||
sas_phy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
|
||||
unsigned long long);
|
||||
sas_phy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
|
||||
sas_phy_simple_attr(port_identifier, port_identifier, "%d\n", u8);
|
||||
sas_phy_linkspeed_attr(negotiated_linkrate);
|
||||
sas_phy_linkspeed_attr(minimum_linkrate_hw);
|
||||
sas_phy_linkspeed_attr(minimum_linkrate);
|
||||
sas_phy_linkspeed_attr(maximum_linkrate_hw);
|
||||
sas_phy_linkspeed_attr(maximum_linkrate);
|
||||
|
||||
|
||||
static DECLARE_TRANSPORT_CLASS(sas_phy_class,
|
||||
"sas_phy", NULL, NULL, NULL);
|
||||
|
||||
static int sas_phy_match(struct attribute_container *cont, struct device *dev)
|
||||
{
|
||||
struct Scsi_Host *shost;
|
||||
struct sas_internal *i;
|
||||
|
||||
if (!scsi_is_sas_phy(dev))
|
||||
return 0;
|
||||
shost = dev_to_shost(dev->parent);
|
||||
|
||||
if (!shost->transportt)
|
||||
return 0;
|
||||
if (shost->transportt->host_attrs.ac.class !=
|
||||
&sas_host_class.class)
|
||||
return 0;
|
||||
|
||||
i = to_sas_internal(shost->transportt);
|
||||
return &i->phy_attr_cont.ac == cont;
|
||||
}
|
||||
|
||||
static void sas_phy_release(struct device *dev)
|
||||
{
|
||||
struct sas_phy *phy = dev_to_phy(dev);
|
||||
|
||||
put_device(dev->parent);
|
||||
kfree(phy);
|
||||
}
|
||||
|
||||
/**
|
||||
* sas_phy_alloc -- allocates and initialize a SAS PHY structure
|
||||
* @parent: Parent device
|
||||
* @number: Port number
|
||||
*
|
||||
* Allocates an SAS PHY structure. It will be added in the device tree
|
||||
* below the device specified by @parent, which has to be either a Scsi_Host
|
||||
* or sas_rphy.
|
||||
*
|
||||
* Returns:
|
||||
* SAS PHY allocated or %NULL if the allocation failed.
|
||||
*/
|
||||
struct sas_phy *sas_phy_alloc(struct device *parent, int number)
|
||||
{
|
||||
struct Scsi_Host *shost = dev_to_shost(parent);
|
||||
struct sas_phy *phy;
|
||||
|
||||
phy = kmalloc(sizeof(*phy), GFP_KERNEL);
|
||||
if (!phy)
|
||||
return NULL;
|
||||
memset(phy, 0, sizeof(*phy));
|
||||
|
||||
get_device(parent);
|
||||
|
||||
phy->number = number;
|
||||
|
||||
device_initialize(&phy->dev);
|
||||
phy->dev.parent = get_device(parent);
|
||||
phy->dev.release = sas_phy_release;
|
||||
sprintf(phy->dev.bus_id, "phy-%d:%d", shost->host_no, number);
|
||||
|
||||
transport_setup_device(&phy->dev);
|
||||
|
||||
return phy;
|
||||
}
|
||||
EXPORT_SYMBOL(sas_phy_alloc);
|
||||
|
||||
/**
|
||||
* sas_phy_add -- add a SAS PHY to the device hierachy
|
||||
* @phy: The PHY to be added
|
||||
*
|
||||
* Publishes a SAS PHY to the rest of the system.
|
||||
*/
|
||||
int sas_phy_add(struct sas_phy *phy)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = device_add(&phy->dev);
|
||||
if (!error) {
|
||||
transport_add_device(&phy->dev);
|
||||
transport_configure_device(&phy->dev);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
EXPORT_SYMBOL(sas_phy_add);
|
||||
|
||||
/**
|
||||
* sas_phy_free -- free a SAS PHY
|
||||
* @phy: SAS PHY to free
|
||||
*
|
||||
* Frees the specified SAS PHY.
|
||||
*
|
||||
* Note:
|
||||
* This function must only be called on a PHY that has not
|
||||
* sucessfully been added using sas_phy_add().
|
||||
*/
|
||||
void sas_phy_free(struct sas_phy *phy)
|
||||
{
|
||||
transport_destroy_device(&phy->dev);
|
||||
put_device(phy->dev.parent);
|
||||
put_device(phy->dev.parent);
|
||||
put_device(phy->dev.parent);
|
||||
kfree(phy);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_phy_free);
|
||||
|
||||
/**
|
||||
* sas_phy_delete -- remove SAS PHY
|
||||
* @phy: SAS PHY to remove
|
||||
*
|
||||
* Removes the specified SAS PHY. If the SAS PHY has an
|
||||
* associated remote PHY it is removed before.
|
||||
*/
|
||||
void
|
||||
sas_phy_delete(struct sas_phy *phy)
|
||||
{
|
||||
struct device *dev = &phy->dev;
|
||||
|
||||
if (phy->rphy)
|
||||
sas_rphy_delete(phy->rphy);
|
||||
|
||||
transport_remove_device(dev);
|
||||
device_del(dev);
|
||||
transport_destroy_device(dev);
|
||||
put_device(dev->parent);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_phy_delete);
|
||||
|
||||
/**
|
||||
* scsi_is_sas_phy -- check if a struct device represents a SAS PHY
|
||||
* @dev: device to check
|
||||
*
|
||||
* Returns:
|
||||
* %1 if the device represents a SAS PHY, %0 else
|
||||
*/
|
||||
int scsi_is_sas_phy(const struct device *dev)
|
||||
{
|
||||
return dev->release == sas_phy_release;
|
||||
}
|
||||
EXPORT_SYMBOL(scsi_is_sas_phy);
|
||||
|
||||
/*
|
||||
* SAS remote PHY attributes.
|
||||
*/
|
||||
|
||||
#define sas_rphy_show_simple(field, name, format_string, cast) \
|
||||
static ssize_t \
|
||||
show_sas_rphy_##name(struct class_device *cdev, char *buf) \
|
||||
{ \
|
||||
struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
|
||||
\
|
||||
return snprintf(buf, 20, format_string, cast rphy->field); \
|
||||
}
|
||||
|
||||
#define sas_rphy_simple_attr(field, name, format_string, type) \
|
||||
sas_rphy_show_simple(field, name, format_string, (type)) \
|
||||
static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
|
||||
show_sas_rphy_##name, NULL)
|
||||
|
||||
#define sas_rphy_show_protocol(field, name) \
|
||||
static ssize_t \
|
||||
show_sas_rphy_##name(struct class_device *cdev, char *buf) \
|
||||
{ \
|
||||
struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
|
||||
\
|
||||
if (!rphy->field) \
|
||||
return snprintf(buf, 20, "none\n"); \
|
||||
return get_sas_protocol_names(rphy->field, buf); \
|
||||
}
|
||||
|
||||
#define sas_rphy_protocol_attr(field, name) \
|
||||
sas_rphy_show_protocol(field, name) \
|
||||
static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
|
||||
show_sas_rphy_##name, NULL)
|
||||
|
||||
static ssize_t
|
||||
show_sas_rphy_device_type(struct class_device *cdev, char *buf)
|
||||
{
|
||||
struct sas_rphy *rphy = transport_class_to_rphy(cdev);
|
||||
|
||||
if (!rphy->identify.device_type)
|
||||
return snprintf(buf, 20, "none\n");
|
||||
return get_sas_device_type_names(
|
||||
rphy->identify.device_type, buf);
|
||||
}
|
||||
|
||||
static SAS_CLASS_DEVICE_ATTR(rphy, device_type, S_IRUGO,
|
||||
show_sas_rphy_device_type, NULL);
|
||||
|
||||
sas_rphy_protocol_attr(identify.initiator_port_protocols,
|
||||
initiator_port_protocols);
|
||||
sas_rphy_protocol_attr(identify.target_port_protocols, target_port_protocols);
|
||||
sas_rphy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
|
||||
unsigned long long);
|
||||
sas_rphy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
|
||||
|
||||
static DECLARE_TRANSPORT_CLASS(sas_rphy_class,
|
||||
"sas_rphy", NULL, NULL, NULL);
|
||||
|
||||
static int sas_rphy_match(struct attribute_container *cont, struct device *dev)
|
||||
{
|
||||
struct Scsi_Host *shost;
|
||||
struct sas_internal *i;
|
||||
|
||||
if (!scsi_is_sas_rphy(dev))
|
||||
return 0;
|
||||
shost = dev_to_shost(dev->parent->parent);
|
||||
|
||||
if (!shost->transportt)
|
||||
return 0;
|
||||
if (shost->transportt->host_attrs.ac.class !=
|
||||
&sas_host_class.class)
|
||||
return 0;
|
||||
|
||||
i = to_sas_internal(shost->transportt);
|
||||
return &i->rphy_attr_cont.ac == cont;
|
||||
}
|
||||
|
||||
static void sas_rphy_release(struct device *dev)
|
||||
{
|
||||
struct sas_rphy *rphy = dev_to_rphy(dev);
|
||||
|
||||
put_device(dev->parent);
|
||||
kfree(rphy);
|
||||
}
|
||||
|
||||
/**
|
||||
* sas_rphy_alloc -- allocates and initialize a SAS remote PHY structure
|
||||
* @parent: SAS PHY this remote PHY is conneted to
|
||||
*
|
||||
* Allocates an SAS remote PHY structure, connected to @parent.
|
||||
*
|
||||
* Returns:
|
||||
* SAS PHY allocated or %NULL if the allocation failed.
|
||||
*/
|
||||
struct sas_rphy *sas_rphy_alloc(struct sas_phy *parent)
|
||||
{
|
||||
struct Scsi_Host *shost = dev_to_shost(&parent->dev);
|
||||
struct sas_rphy *rphy;
|
||||
|
||||
rphy = kmalloc(sizeof(*rphy), GFP_KERNEL);
|
||||
if (!rphy) {
|
||||
put_device(&parent->dev);
|
||||
return NULL;
|
||||
}
|
||||
memset(rphy, 0, sizeof(*rphy));
|
||||
|
||||
device_initialize(&rphy->dev);
|
||||
rphy->dev.parent = get_device(&parent->dev);
|
||||
rphy->dev.release = sas_rphy_release;
|
||||
sprintf(rphy->dev.bus_id, "rphy-%d:%d",
|
||||
shost->host_no, parent->number);
|
||||
transport_setup_device(&rphy->dev);
|
||||
|
||||
return rphy;
|
||||
}
|
||||
EXPORT_SYMBOL(sas_rphy_alloc);
|
||||
|
||||
/**
|
||||
* sas_rphy_add -- add a SAS remote PHY to the device hierachy
|
||||
* @rphy: The remote PHY to be added
|
||||
*
|
||||
* Publishes a SAS remote PHY to the rest of the system.
|
||||
*/
|
||||
int sas_rphy_add(struct sas_rphy *rphy)
|
||||
{
|
||||
struct sas_phy *parent = dev_to_phy(rphy->dev.parent);
|
||||
struct Scsi_Host *shost = dev_to_shost(parent->dev.parent);
|
||||
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
|
||||
struct sas_identify *identify = &rphy->identify;
|
||||
int error;
|
||||
|
||||
if (parent->rphy)
|
||||
return -ENXIO;
|
||||
parent->rphy = rphy;
|
||||
|
||||
error = device_add(&rphy->dev);
|
||||
if (error)
|
||||
return error;
|
||||
transport_add_device(&rphy->dev);
|
||||
transport_configure_device(&rphy->dev);
|
||||
|
||||
spin_lock(&sas_host->lock);
|
||||
list_add_tail(&rphy->list, &sas_host->rphy_list);
|
||||
if (identify->device_type == SAS_END_DEVICE &&
|
||||
(identify->target_port_protocols &
|
||||
(SAS_PROTOCOL_SSP|SAS_PROTOCOL_STP|SAS_PROTOCOL_SATA)))
|
||||
rphy->scsi_target_id = sas_host->next_target_id++;
|
||||
else
|
||||
rphy->scsi_target_id = -1;
|
||||
spin_unlock(&sas_host->lock);
|
||||
|
||||
if (rphy->scsi_target_id != -1) {
|
||||
scsi_scan_target(&rphy->dev, parent->number,
|
||||
rphy->scsi_target_id, ~0, 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(sas_rphy_add);
|
||||
|
||||
/**
|
||||
* sas_rphy_free -- free a SAS remote PHY
|
||||
* @rphy SAS remote PHY to free
|
||||
*
|
||||
* Frees the specified SAS remote PHY.
|
||||
*
|
||||
* Note:
|
||||
* This function must only be called on a remote
|
||||
* PHY that has not sucessfully been added using
|
||||
* sas_rphy_add().
|
||||
*/
|
||||
void sas_rphy_free(struct sas_rphy *rphy)
|
||||
{
|
||||
struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
|
||||
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
|
||||
|
||||
spin_lock(&sas_host->lock);
|
||||
list_del(&rphy->list);
|
||||
spin_unlock(&sas_host->lock);
|
||||
|
||||
transport_destroy_device(&rphy->dev);
|
||||
put_device(rphy->dev.parent);
|
||||
put_device(rphy->dev.parent);
|
||||
put_device(rphy->dev.parent);
|
||||
kfree(rphy);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_rphy_free);
|
||||
|
||||
/**
|
||||
* sas_rphy_delete -- remove SAS remote PHY
|
||||
* @rphy: SAS remote PHY to remove
|
||||
*
|
||||
* Removes the specified SAS remote PHY.
|
||||
*/
|
||||
void
|
||||
sas_rphy_delete(struct sas_rphy *rphy)
|
||||
{
|
||||
struct device *dev = &rphy->dev;
|
||||
struct sas_phy *parent = dev_to_phy(dev->parent);
|
||||
struct Scsi_Host *shost = dev_to_shost(parent->dev.parent);
|
||||
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
|
||||
|
||||
transport_destroy_device(&rphy->dev);
|
||||
|
||||
scsi_remove_target(&rphy->dev);
|
||||
|
||||
spin_lock(&sas_host->lock);
|
||||
list_del(&rphy->list);
|
||||
spin_unlock(&sas_host->lock);
|
||||
|
||||
transport_remove_device(dev);
|
||||
device_del(dev);
|
||||
transport_destroy_device(dev);
|
||||
put_device(&parent->dev);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_rphy_delete);
|
||||
|
||||
/**
|
||||
* scsi_is_sas_rphy -- check if a struct device represents a SAS remote PHY
|
||||
* @dev: device to check
|
||||
*
|
||||
* Returns:
|
||||
* %1 if the device represents a SAS remote PHY, %0 else
|
||||
*/
|
||||
int scsi_is_sas_rphy(const struct device *dev)
|
||||
{
|
||||
return dev->release == sas_rphy_release;
|
||||
}
|
||||
EXPORT_SYMBOL(scsi_is_sas_rphy);
|
||||
|
||||
|
||||
/*
|
||||
* SCSI scan helper
|
||||
*/
|
||||
|
||||
static struct device *sas_target_parent(struct Scsi_Host *shost,
|
||||
int channel, uint id)
|
||||
{
|
||||
struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
|
||||
struct sas_rphy *rphy;
|
||||
struct device *dev = NULL;
|
||||
|
||||
spin_lock(&sas_host->lock);
|
||||
list_for_each_entry(rphy, &sas_host->rphy_list, list) {
|
||||
struct sas_phy *parent = dev_to_phy(rphy->dev.parent);
|
||||
if (parent->number == channel &&
|
||||
rphy->scsi_target_id == id)
|
||||
dev = &rphy->dev;
|
||||
}
|
||||
spin_unlock(&sas_host->lock);
|
||||
|
||||
return dev;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Setup / Teardown code
|
||||
*/
|
||||
|
||||
#define SETUP_RPORT_ATTRIBUTE(field) \
|
||||
i->private_rphy_attrs[count] = class_device_attr_##field; \
|
||||
i->private_rphy_attrs[count].attr.mode = S_IRUGO; \
|
||||
i->private_rphy_attrs[count].store = NULL; \
|
||||
i->rphy_attrs[count] = &i->private_rphy_attrs[count]; \
|
||||
count++
|
||||
|
||||
#define SETUP_PORT_ATTRIBUTE(field) \
|
||||
i->private_phy_attrs[count] = class_device_attr_##field; \
|
||||
i->private_phy_attrs[count].attr.mode = S_IRUGO; \
|
||||
i->private_phy_attrs[count].store = NULL; \
|
||||
i->phy_attrs[count] = &i->private_phy_attrs[count]; \
|
||||
count++
|
||||
|
||||
|
||||
/**
|
||||
* sas_attach_transport -- instantiate SAS transport template
|
||||
* @ft: SAS transport class function template
|
||||
*/
|
||||
struct scsi_transport_template *
|
||||
sas_attach_transport(struct sas_function_template *ft)
|
||||
{
|
||||
struct sas_internal *i;
|
||||
int count;
|
||||
|
||||
i = kmalloc(sizeof(struct sas_internal), GFP_KERNEL);
|
||||
if (!i)
|
||||
return NULL;
|
||||
memset(i, 0, sizeof(struct sas_internal));
|
||||
|
||||
i->t.target_parent = sas_target_parent;
|
||||
|
||||
i->t.host_attrs.ac.attrs = &i->host_attrs[0];
|
||||
i->t.host_attrs.ac.class = &sas_host_class.class;
|
||||
i->t.host_attrs.ac.match = sas_host_match;
|
||||
transport_container_register(&i->t.host_attrs);
|
||||
i->t.host_size = sizeof(struct sas_host_attrs);
|
||||
|
||||
i->phy_attr_cont.ac.class = &sas_phy_class.class;
|
||||
i->phy_attr_cont.ac.attrs = &i->phy_attrs[0];
|
||||
i->phy_attr_cont.ac.match = sas_phy_match;
|
||||
transport_container_register(&i->phy_attr_cont);
|
||||
|
||||
i->rphy_attr_cont.ac.class = &sas_rphy_class.class;
|
||||
i->rphy_attr_cont.ac.attrs = &i->rphy_attrs[0];
|
||||
i->rphy_attr_cont.ac.match = sas_rphy_match;
|
||||
transport_container_register(&i->rphy_attr_cont);
|
||||
|
||||
i->f = ft;
|
||||
|
||||
count = 0;
|
||||
i->host_attrs[count] = NULL;
|
||||
|
||||
count = 0;
|
||||
SETUP_PORT_ATTRIBUTE(initiator_port_protocols);
|
||||
SETUP_PORT_ATTRIBUTE(target_port_protocols);
|
||||
SETUP_PORT_ATTRIBUTE(device_type);
|
||||
SETUP_PORT_ATTRIBUTE(sas_address);
|
||||
SETUP_PORT_ATTRIBUTE(phy_identifier);
|
||||
SETUP_PORT_ATTRIBUTE(port_identifier);
|
||||
SETUP_PORT_ATTRIBUTE(negotiated_linkrate);
|
||||
SETUP_PORT_ATTRIBUTE(minimum_linkrate_hw);
|
||||
SETUP_PORT_ATTRIBUTE(minimum_linkrate);
|
||||
SETUP_PORT_ATTRIBUTE(maximum_linkrate_hw);
|
||||
SETUP_PORT_ATTRIBUTE(maximum_linkrate);
|
||||
i->phy_attrs[count] = NULL;
|
||||
|
||||
count = 0;
|
||||
SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols);
|
||||
SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols);
|
||||
SETUP_RPORT_ATTRIBUTE(rphy_device_type);
|
||||
SETUP_RPORT_ATTRIBUTE(rphy_sas_address);
|
||||
SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier);
|
||||
i->rphy_attrs[count] = NULL;
|
||||
|
||||
return &i->t;
|
||||
}
|
||||
EXPORT_SYMBOL(sas_attach_transport);
|
||||
|
||||
/**
|
||||
* sas_release_transport -- release SAS transport template instance
|
||||
* @t: transport template instance
|
||||
*/
|
||||
void sas_release_transport(struct scsi_transport_template *t)
|
||||
{
|
||||
struct sas_internal *i = to_sas_internal(t);
|
||||
|
||||
transport_container_unregister(&i->t.host_attrs);
|
||||
transport_container_unregister(&i->phy_attr_cont);
|
||||
transport_container_unregister(&i->rphy_attr_cont);
|
||||
|
||||
kfree(i);
|
||||
}
|
||||
EXPORT_SYMBOL(sas_release_transport);
|
||||
|
||||
static __init int sas_transport_init(void)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = transport_class_register(&sas_host_class);
|
||||
if (error)
|
||||
goto out;
|
||||
error = transport_class_register(&sas_phy_class);
|
||||
if (error)
|
||||
goto out_unregister_transport;
|
||||
error = transport_class_register(&sas_rphy_class);
|
||||
if (error)
|
||||
goto out_unregister_phy;
|
||||
|
||||
return 0;
|
||||
|
||||
out_unregister_phy:
|
||||
transport_class_unregister(&sas_phy_class);
|
||||
out_unregister_transport:
|
||||
transport_class_unregister(&sas_host_class);
|
||||
out:
|
||||
return error;
|
||||
|
||||
}
|
||||
|
||||
static void __exit sas_transport_exit(void)
|
||||
{
|
||||
transport_class_unregister(&sas_host_class);
|
||||
transport_class_unregister(&sas_phy_class);
|
||||
transport_class_unregister(&sas_rphy_class);
|
||||
}
|
||||
|
||||
MODULE_AUTHOR("Christoph Hellwig");
|
||||
MODULE_DESCRIPTION("SAS Transphy Attributes");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
module_init(sas_transport_init);
|
||||
module_exit(sas_transport_exit);
|
||||
100
include/scsi/scsi_transport_sas.h
Normal file
100
include/scsi/scsi_transport_sas.h
Normal file
@ -0,0 +1,100 @@
|
||||
#ifndef SCSI_TRANSPORT_SAS_H
|
||||
#define SCSI_TRANSPORT_SAS_H
|
||||
|
||||
#include <linux/transport_class.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
struct scsi_transport_template;
|
||||
struct sas_rphy;
|
||||
|
||||
|
||||
enum sas_device_type {
|
||||
SAS_PHY_UNUSED,
|
||||
SAS_END_DEVICE,
|
||||
SAS_EDGE_EXPANDER_DEVICE,
|
||||
SAS_FANOUT_EXPANDER_DEVICE,
|
||||
};
|
||||
|
||||
enum sas_protocol {
|
||||
SAS_PROTOCOL_SATA = 0x01,
|
||||
SAS_PROTOCOL_SMP = 0x02,
|
||||
SAS_PROTOCOL_STP = 0x04,
|
||||
SAS_PROTOCOL_SSP = 0x08,
|
||||
};
|
||||
|
||||
enum sas_linkrate {
|
||||
SAS_LINK_RATE_UNKNOWN,
|
||||
SAS_PHY_DISABLED,
|
||||
SAS_LINK_RATE_FAILED,
|
||||
SAS_SATA_SPINUP_HOLD,
|
||||
SAS_SATA_PORT_SELECTOR,
|
||||
SAS_LINK_RATE_1_5_GBPS,
|
||||
SAS_LINK_RATE_3_0_GBPS,
|
||||
SAS_LINK_VIRTUAL,
|
||||
};
|
||||
|
||||
struct sas_identify {
|
||||
enum sas_device_type device_type;
|
||||
enum sas_protocol initiator_port_protocols;
|
||||
enum sas_protocol target_port_protocols;
|
||||
u64 sas_address;
|
||||
u8 phy_identifier;
|
||||
};
|
||||
|
||||
/* The functions by which the transport class and the driver communicate */
|
||||
struct sas_function_template {
|
||||
};
|
||||
|
||||
struct sas_phy {
|
||||
struct device dev;
|
||||
int number;
|
||||
struct sas_identify identify;
|
||||
enum sas_linkrate negotiated_linkrate;
|
||||
enum sas_linkrate minimum_linkrate_hw;
|
||||
enum sas_linkrate minimum_linkrate;
|
||||
enum sas_linkrate maximum_linkrate_hw;
|
||||
enum sas_linkrate maximum_linkrate;
|
||||
u8 port_identifier;
|
||||
struct sas_rphy *rphy;
|
||||
};
|
||||
|
||||
#define dev_to_phy(d) \
|
||||
container_of((d), struct sas_phy, dev)
|
||||
#define transport_class_to_phy(cdev) \
|
||||
dev_to_phy((cdev)->dev)
|
||||
#define phy_to_shost(phy) \
|
||||
dev_to_shost((phy)->dev.parent)
|
||||
|
||||
struct sas_rphy {
|
||||
struct device dev;
|
||||
struct sas_identify identify;
|
||||
struct list_head list;
|
||||
u32 scsi_target_id;
|
||||
};
|
||||
|
||||
#define dev_to_rphy(d) \
|
||||
container_of((d), struct sas_rphy, dev)
|
||||
#define transport_class_to_rphy(cdev) \
|
||||
dev_to_rphy((cdev)->dev)
|
||||
#define rphy_to_shost(rphy) \
|
||||
dev_to_shost((rphy)->dev.parent)
|
||||
|
||||
extern void sas_remove_host(struct Scsi_Host *);
|
||||
|
||||
extern struct sas_phy *sas_phy_alloc(struct device *, int);
|
||||
extern void sas_phy_free(struct sas_phy *);
|
||||
extern int sas_phy_add(struct sas_phy *);
|
||||
extern void sas_phy_delete(struct sas_phy *);
|
||||
extern int scsi_is_sas_phy(const struct device *);
|
||||
|
||||
extern struct sas_rphy *sas_rphy_alloc(struct sas_phy *);
|
||||
void sas_rphy_free(struct sas_rphy *);
|
||||
extern int sas_rphy_add(struct sas_rphy *);
|
||||
extern void sas_rphy_delete(struct sas_rphy *);
|
||||
extern int scsi_is_sas_rphy(const struct device *);
|
||||
|
||||
extern struct scsi_transport_template *
|
||||
sas_attach_transport(struct sas_function_template *);
|
||||
extern void sas_release_transport(struct scsi_transport_template *);
|
||||
|
||||
#endif /* SCSI_TRANSPORT_SAS_H */
|
||||
Loading…
Reference in New Issue
Block a user