2 * Copyright (C) 2005-2006 Dell Inc.
3 * Released under GPL v2.
5 * Serial Attached SCSI (SAS) transport class.
7 * The SAS transport class contains common code to deal with SAS HBAs,
8 * an aproximated representation of SAS topologies in the driver model,
9 * and various sysfs attributes to expose these topologies and managment
10 * interfaces to userspace.
12 * In addition to the basic SCSI core objects this transport class
13 * introduces two additional intermediate objects: The SAS PHY
14 * as represented by struct sas_phy defines an "outgoing" PHY on
15 * a SAS HBA or Expander, and the SAS remote PHY represented by
16 * struct sas_rphy defines an "incoming" PHY on a SAS Expander or
17 * end device. Note that this is purely a software concept, the
18 * underlying hardware for a PHY and a remote PHY is the exactly
21 * There is no concept of a SAS port in this code, users can see
22 * what PHYs form a wide port based on the port_identifier attribute,
23 * which is the same for all PHYs in a port.
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/jiffies.h>
29 #include <linux/err.h>
30 #include <linux/slab.h>
31 #include <linux/string.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_transport.h>
37 #include <scsi/scsi_transport_sas.h>
39 #include "scsi_sas_internal.h"
40 struct sas_host_attrs
{
41 struct list_head rphy_list
;
47 #define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
51 * Hack to allow attributes of the same name in different objects.
53 #define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
54 struct class_device_attribute class_device_attr_##_prefix##_##_name = \
55 __ATTR(_name,_mode,_show,_store)
59 * Pretty printing helpers
62 #define sas_bitfield_name_match(title, table) \
64 get_sas_##title##_names(u32 table_key, char *buf) \
70 for (i = 0; i < ARRAY_SIZE(table); i++) { \
71 if (table[i].value & table_key) { \
72 len += sprintf(buf + len, "%s%s", \
73 prefix, table[i].name); \
77 len += sprintf(buf + len, "\n"); \
81 #define sas_bitfield_name_set(title, table) \
83 set_sas_##title##_names(u32 *table_key, const char *buf) \
88 for (i = 0; i < ARRAY_SIZE(table); i++) { \
89 len = strlen(table[i].name); \
90 if (strncmp(buf, table[i].name, len) == 0 && \
91 (buf[len] == '\n' || buf[len] == '\0')) { \
92 *table_key = table[i].value; \
99 #define sas_bitfield_name_search(title, table) \
101 get_sas_##title##_names(u32 table_key, char *buf) \
106 for (i = 0; i < ARRAY_SIZE(table); i++) { \
107 if (table[i].value == table_key) { \
108 len += sprintf(buf + len, "%s", \
113 len += sprintf(buf + len, "\n"); \
120 } sas_device_type_names
[] = {
121 { SAS_PHY_UNUSED
, "unused" },
122 { SAS_END_DEVICE
, "end device" },
123 { SAS_EDGE_EXPANDER_DEVICE
, "edge expander" },
124 { SAS_FANOUT_EXPANDER_DEVICE
, "fanout expander" },
126 sas_bitfield_name_search(device_type
, sas_device_type_names
)
132 } sas_protocol_names
[] = {
133 { SAS_PROTOCOL_SATA
, "sata" },
134 { SAS_PROTOCOL_SMP
, "smp" },
135 { SAS_PROTOCOL_STP
, "stp" },
136 { SAS_PROTOCOL_SSP
, "ssp" },
138 sas_bitfield_name_match(protocol
, sas_protocol_names
)
143 } sas_linkspeed_names
[] = {
144 { SAS_LINK_RATE_UNKNOWN
, "Unknown" },
145 { SAS_PHY_DISABLED
, "Phy disabled" },
146 { SAS_LINK_RATE_FAILED
, "Link Rate failed" },
147 { SAS_SATA_SPINUP_HOLD
, "Spin-up hold" },
148 { SAS_LINK_RATE_1_5_GBPS
, "1.5 Gbit" },
149 { SAS_LINK_RATE_3_0_GBPS
, "3.0 Gbit" },
150 { SAS_LINK_RATE_6_0_GBPS
, "6.0 Gbit" },
152 sas_bitfield_name_search(linkspeed
, sas_linkspeed_names
)
153 sas_bitfield_name_set(linkspeed
, sas_linkspeed_names
)
156 * SAS host attributes
159 static int sas_host_setup(struct transport_container
*tc
, struct device
*dev
,
160 struct class_device
*cdev
)
162 struct Scsi_Host
*shost
= dev_to_shost(dev
);
163 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
165 INIT_LIST_HEAD(&sas_host
->rphy_list
);
166 mutex_init(&sas_host
->lock
);
167 sas_host
->next_target_id
= 0;
168 sas_host
->next_expander_id
= 0;
169 sas_host
->next_port_id
= 0;
173 static DECLARE_TRANSPORT_CLASS(sas_host_class
,
174 "sas_host", sas_host_setup
, NULL
, NULL
);
176 static int sas_host_match(struct attribute_container
*cont
,
179 struct Scsi_Host
*shost
;
180 struct sas_internal
*i
;
182 if (!scsi_is_host_device(dev
))
184 shost
= dev_to_shost(dev
);
186 if (!shost
->transportt
)
188 if (shost
->transportt
->host_attrs
.ac
.class !=
189 &sas_host_class
.class)
192 i
= to_sas_internal(shost
->transportt
);
193 return &i
->t
.host_attrs
.ac
== cont
;
196 static int do_sas_phy_delete(struct device
*dev
, void *data
)
198 int pass
= (int)(unsigned long)data
;
200 if (pass
== 0 && scsi_is_sas_port(dev
))
201 sas_port_delete(dev_to_sas_port(dev
));
202 else if (pass
== 1 && scsi_is_sas_phy(dev
))
203 sas_phy_delete(dev_to_phy(dev
));
208 * sas_remove_children -- tear down a devices SAS data structures
209 * @dev: device belonging to the sas object
211 * Removes all SAS PHYs and remote PHYs for a given object
213 void sas_remove_children(struct device
*dev
)
215 device_for_each_child(dev
, (void *)0, do_sas_phy_delete
);
216 device_for_each_child(dev
, (void *)1, do_sas_phy_delete
);
218 EXPORT_SYMBOL(sas_remove_children
);
221 * sas_remove_host -- tear down a Scsi_Host's SAS data structures
222 * @shost: Scsi Host that is torn down
224 * Removes all SAS PHYs and remote PHYs for a given Scsi_Host.
225 * Must be called just before scsi_remove_host for SAS HBAs.
227 void sas_remove_host(struct Scsi_Host
*shost
)
229 sas_remove_children(&shost
->shost_gendev
);
231 EXPORT_SYMBOL(sas_remove_host
);
238 #define sas_phy_show_simple(field, name, format_string, cast) \
240 show_sas_phy_##name(struct class_device *cdev, char *buf) \
242 struct sas_phy *phy = transport_class_to_phy(cdev); \
244 return snprintf(buf, 20, format_string, cast phy->field); \
247 #define sas_phy_simple_attr(field, name, format_string, type) \
248 sas_phy_show_simple(field, name, format_string, (type)) \
249 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
251 #define sas_phy_show_protocol(field, name) \
253 show_sas_phy_##name(struct class_device *cdev, char *buf) \
255 struct sas_phy *phy = transport_class_to_phy(cdev); \
258 return snprintf(buf, 20, "none\n"); \
259 return get_sas_protocol_names(phy->field, buf); \
262 #define sas_phy_protocol_attr(field, name) \
263 sas_phy_show_protocol(field, name) \
264 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
266 #define sas_phy_show_linkspeed(field) \
268 show_sas_phy_##field(struct class_device *cdev, char *buf) \
270 struct sas_phy *phy = transport_class_to_phy(cdev); \
272 return get_sas_linkspeed_names(phy->field, buf); \
275 /* Fudge to tell if we're minimum or maximum */
276 #define sas_phy_store_linkspeed(field) \
278 store_sas_phy_##field(struct class_device *cdev, const char *buf, \
281 struct sas_phy *phy = transport_class_to_phy(cdev); \
282 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
283 struct sas_internal *i = to_sas_internal(shost->transportt); \
285 struct sas_phy_linkrates rates = {0}; \
288 error = set_sas_linkspeed_names(&value, buf); \
291 rates.field = value; \
292 error = i->f->set_phy_speed(phy, &rates); \
294 return error ? error : count; \
297 #define sas_phy_linkspeed_rw_attr(field) \
298 sas_phy_show_linkspeed(field) \
299 sas_phy_store_linkspeed(field) \
300 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, \
301 store_sas_phy_##field)
303 #define sas_phy_linkspeed_attr(field) \
304 sas_phy_show_linkspeed(field) \
305 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
308 #define sas_phy_show_linkerror(field) \
310 show_sas_phy_##field(struct class_device *cdev, char *buf) \
312 struct sas_phy *phy = transport_class_to_phy(cdev); \
313 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
314 struct sas_internal *i = to_sas_internal(shost->transportt); \
317 error = i->f->get_linkerrors ? i->f->get_linkerrors(phy) : 0; \
320 return snprintf(buf, 20, "%u\n", phy->field); \
323 #define sas_phy_linkerror_attr(field) \
324 sas_phy_show_linkerror(field) \
325 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
329 show_sas_device_type(struct class_device
*cdev
, char *buf
)
331 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
333 if (!phy
->identify
.device_type
)
334 return snprintf(buf
, 20, "none\n");
335 return get_sas_device_type_names(phy
->identify
.device_type
, buf
);
337 static CLASS_DEVICE_ATTR(device_type
, S_IRUGO
, show_sas_device_type
, NULL
);
339 static ssize_t
do_sas_phy_enable(struct class_device
*cdev
,
340 size_t count
, int enable
)
342 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
343 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
344 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
347 error
= i
->f
->phy_enable(phy
, enable
);
350 phy
->enabled
= enable
;
354 static ssize_t
store_sas_phy_enable(struct class_device
*cdev
,
355 const char *buf
, size_t count
)
362 do_sas_phy_enable(cdev
, count
, 0);
365 do_sas_phy_enable(cdev
, count
, 1);
374 static ssize_t
show_sas_phy_enable(struct class_device
*cdev
, char *buf
)
376 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
378 return snprintf(buf
, 20, "%d", phy
->enabled
);
381 static CLASS_DEVICE_ATTR(enable
, S_IRUGO
| S_IWUSR
, show_sas_phy_enable
,
382 store_sas_phy_enable
);
384 static ssize_t
do_sas_phy_reset(struct class_device
*cdev
,
385 size_t count
, int hard_reset
)
387 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
388 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
389 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
392 error
= i
->f
->phy_reset(phy
, hard_reset
);
398 static ssize_t
store_sas_link_reset(struct class_device
*cdev
,
399 const char *buf
, size_t count
)
401 return do_sas_phy_reset(cdev
, count
, 0);
403 static CLASS_DEVICE_ATTR(link_reset
, S_IWUSR
, NULL
, store_sas_link_reset
);
405 static ssize_t
store_sas_hard_reset(struct class_device
*cdev
,
406 const char *buf
, size_t count
)
408 return do_sas_phy_reset(cdev
, count
, 1);
410 static CLASS_DEVICE_ATTR(hard_reset
, S_IWUSR
, NULL
, store_sas_hard_reset
);
412 sas_phy_protocol_attr(identify
.initiator_port_protocols
,
413 initiator_port_protocols
);
414 sas_phy_protocol_attr(identify
.target_port_protocols
,
415 target_port_protocols
);
416 sas_phy_simple_attr(identify
.sas_address
, sas_address
, "0x%016llx\n",
418 sas_phy_simple_attr(identify
.phy_identifier
, phy_identifier
, "%d\n", u8
);
419 //sas_phy_simple_attr(port_identifier, port_identifier, "%d\n", int);
420 sas_phy_linkspeed_attr(negotiated_linkrate
);
421 sas_phy_linkspeed_attr(minimum_linkrate_hw
);
422 sas_phy_linkspeed_rw_attr(minimum_linkrate
);
423 sas_phy_linkspeed_attr(maximum_linkrate_hw
);
424 sas_phy_linkspeed_rw_attr(maximum_linkrate
);
425 sas_phy_linkerror_attr(invalid_dword_count
);
426 sas_phy_linkerror_attr(running_disparity_error_count
);
427 sas_phy_linkerror_attr(loss_of_dword_sync_count
);
428 sas_phy_linkerror_attr(phy_reset_problem_count
);
431 static DECLARE_TRANSPORT_CLASS(sas_phy_class
,
432 "sas_phy", NULL
, NULL
, NULL
);
434 static int sas_phy_match(struct attribute_container
*cont
, struct device
*dev
)
436 struct Scsi_Host
*shost
;
437 struct sas_internal
*i
;
439 if (!scsi_is_sas_phy(dev
))
441 shost
= dev_to_shost(dev
->parent
);
443 if (!shost
->transportt
)
445 if (shost
->transportt
->host_attrs
.ac
.class !=
446 &sas_host_class
.class)
449 i
= to_sas_internal(shost
->transportt
);
450 return &i
->phy_attr_cont
.ac
== cont
;
453 static void sas_phy_release(struct device
*dev
)
455 struct sas_phy
*phy
= dev_to_phy(dev
);
457 put_device(dev
->parent
);
462 * sas_phy_alloc -- allocates and initialize a SAS PHY structure
463 * @parent: Parent device
466 * Allocates an SAS PHY structure. It will be added in the device tree
467 * below the device specified by @parent, which has to be either a Scsi_Host
471 * SAS PHY allocated or %NULL if the allocation failed.
473 struct sas_phy
*sas_phy_alloc(struct device
*parent
, int number
)
475 struct Scsi_Host
*shost
= dev_to_shost(parent
);
478 phy
= kzalloc(sizeof(*phy
), GFP_KERNEL
);
482 phy
->number
= number
;
485 device_initialize(&phy
->dev
);
486 phy
->dev
.parent
= get_device(parent
);
487 phy
->dev
.release
= sas_phy_release
;
488 INIT_LIST_HEAD(&phy
->port_siblings
);
489 if (scsi_is_sas_expander_device(parent
)) {
490 struct sas_rphy
*rphy
= dev_to_rphy(parent
);
491 sprintf(phy
->dev
.bus_id
, "phy-%d:%d:%d", shost
->host_no
,
492 rphy
->scsi_target_id
, number
);
494 sprintf(phy
->dev
.bus_id
, "phy-%d:%d", shost
->host_no
, number
);
496 transport_setup_device(&phy
->dev
);
500 EXPORT_SYMBOL(sas_phy_alloc
);
503 * sas_phy_add -- add a SAS PHY to the device hierachy
504 * @phy: The PHY to be added
506 * Publishes a SAS PHY to the rest of the system.
508 int sas_phy_add(struct sas_phy
*phy
)
512 error
= device_add(&phy
->dev
);
514 transport_add_device(&phy
->dev
);
515 transport_configure_device(&phy
->dev
);
520 EXPORT_SYMBOL(sas_phy_add
);
523 * sas_phy_free -- free a SAS PHY
524 * @phy: SAS PHY to free
526 * Frees the specified SAS PHY.
529 * This function must only be called on a PHY that has not
530 * sucessfully been added using sas_phy_add().
532 void sas_phy_free(struct sas_phy
*phy
)
534 transport_destroy_device(&phy
->dev
);
535 put_device(&phy
->dev
);
537 EXPORT_SYMBOL(sas_phy_free
);
540 * sas_phy_delete -- remove SAS PHY
541 * @phy: SAS PHY to remove
543 * Removes the specified SAS PHY. If the SAS PHY has an
544 * associated remote PHY it is removed before.
547 sas_phy_delete(struct sas_phy
*phy
)
549 struct device
*dev
= &phy
->dev
;
551 /* this happens if the phy is still part of a port when deleted */
552 BUG_ON(!list_empty(&phy
->port_siblings
));
554 transport_remove_device(dev
);
556 transport_destroy_device(dev
);
559 EXPORT_SYMBOL(sas_phy_delete
);
562 * scsi_is_sas_phy -- check if a struct device represents a SAS PHY
563 * @dev: device to check
566 * %1 if the device represents a SAS PHY, %0 else
568 int scsi_is_sas_phy(const struct device
*dev
)
570 return dev
->release
== sas_phy_release
;
572 EXPORT_SYMBOL(scsi_is_sas_phy
);
575 * SAS Port attributes
577 #define sas_port_show_simple(field, name, format_string, cast) \
579 show_sas_port_##name(struct class_device *cdev, char *buf) \
581 struct sas_port *port = transport_class_to_sas_port(cdev); \
583 return snprintf(buf, 20, format_string, cast port->field); \
586 #define sas_port_simple_attr(field, name, format_string, type) \
587 sas_port_show_simple(field, name, format_string, (type)) \
588 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
590 sas_port_simple_attr(num_phys
, num_phys
, "%d\n", int);
592 static DECLARE_TRANSPORT_CLASS(sas_port_class
,
593 "sas_port", NULL
, NULL
, NULL
);
595 static int sas_port_match(struct attribute_container
*cont
, struct device
*dev
)
597 struct Scsi_Host
*shost
;
598 struct sas_internal
*i
;
600 if (!scsi_is_sas_port(dev
))
602 shost
= dev_to_shost(dev
->parent
);
604 if (!shost
->transportt
)
606 if (shost
->transportt
->host_attrs
.ac
.class !=
607 &sas_host_class
.class)
610 i
= to_sas_internal(shost
->transportt
);
611 return &i
->port_attr_cont
.ac
== cont
;
615 static void sas_port_release(struct device
*dev
)
617 struct sas_port
*port
= dev_to_sas_port(dev
);
619 BUG_ON(!list_empty(&port
->phy_list
));
621 put_device(dev
->parent
);
625 static void sas_port_create_link(struct sas_port
*port
,
628 sysfs_create_link(&port
->dev
.kobj
, &phy
->dev
.kobj
, phy
->dev
.bus_id
);
629 sysfs_create_link(&phy
->dev
.kobj
, &port
->dev
.kobj
, "port");
632 static void sas_port_delete_link(struct sas_port
*port
,
635 sysfs_remove_link(&port
->dev
.kobj
, phy
->dev
.bus_id
);
636 sysfs_remove_link(&phy
->dev
.kobj
, "port");
639 /** sas_port_alloc - allocate and initialize a SAS port structure
641 * @parent: parent device
642 * @port_id: port number
644 * Allocates a SAS port structure. It will be added to the device tree
645 * below the device specified by @parent which must be either a Scsi_Host
646 * or a sas_expander_device.
648 * Returns %NULL on error
650 struct sas_port
*sas_port_alloc(struct device
*parent
, int port_id
)
652 struct Scsi_Host
*shost
= dev_to_shost(parent
);
653 struct sas_port
*port
;
655 port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
659 port
->port_identifier
= port_id
;
661 device_initialize(&port
->dev
);
663 port
->dev
.parent
= get_device(parent
);
664 port
->dev
.release
= sas_port_release
;
666 mutex_init(&port
->phy_list_mutex
);
667 INIT_LIST_HEAD(&port
->phy_list
);
669 if (scsi_is_sas_expander_device(parent
)) {
670 struct sas_rphy
*rphy
= dev_to_rphy(parent
);
671 sprintf(port
->dev
.bus_id
, "port-%d:%d:%d", shost
->host_no
,
672 rphy
->scsi_target_id
, port
->port_identifier
);
674 sprintf(port
->dev
.bus_id
, "port-%d:%d", shost
->host_no
,
675 port
->port_identifier
);
677 transport_setup_device(&port
->dev
);
681 EXPORT_SYMBOL(sas_port_alloc
);
683 /** sas_port_alloc_num - allocate and initialize a SAS port structure
685 * @parent: parent device
687 * Allocates a SAS port structure and a number to go with it. This
688 * interface is really for adapters where the port number has no
689 * meansing, so the sas class should manage them. It will be added to
690 * the device tree below the device specified by @parent which must be
691 * either a Scsi_Host or a sas_expander_device.
693 * Returns %NULL on error
695 struct sas_port
*sas_port_alloc_num(struct device
*parent
)
698 struct Scsi_Host
*shost
= dev_to_shost(parent
);
699 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
701 /* FIXME: use idr for this eventually */
702 mutex_lock(&sas_host
->lock
);
703 if (scsi_is_sas_expander_device(parent
)) {
704 struct sas_rphy
*rphy
= dev_to_rphy(parent
);
705 struct sas_expander_device
*exp
= rphy_to_expander_device(rphy
);
707 index
= exp
->next_port_id
++;
709 index
= sas_host
->next_port_id
++;
710 mutex_unlock(&sas_host
->lock
);
711 return sas_port_alloc(parent
, index
);
713 EXPORT_SYMBOL(sas_port_alloc_num
);
716 * sas_port_add - add a SAS port to the device hierarchy
718 * @port: port to be added
720 * publishes a port to the rest of the system
722 int sas_port_add(struct sas_port
*port
)
726 /* No phys should be added until this is made visible */
727 BUG_ON(!list_empty(&port
->phy_list
));
729 error
= device_add(&port
->dev
);
734 transport_add_device(&port
->dev
);
735 transport_configure_device(&port
->dev
);
739 EXPORT_SYMBOL(sas_port_add
);
742 * sas_port_free -- free a SAS PORT
743 * @port: SAS PORT to free
745 * Frees the specified SAS PORT.
748 * This function must only be called on a PORT that has not
749 * sucessfully been added using sas_port_add().
751 void sas_port_free(struct sas_port
*port
)
753 transport_destroy_device(&port
->dev
);
754 put_device(&port
->dev
);
756 EXPORT_SYMBOL(sas_port_free
);
759 * sas_port_delete -- remove SAS PORT
760 * @port: SAS PORT to remove
762 * Removes the specified SAS PORT. If the SAS PORT has an
763 * associated phys, unlink them from the port as well.
765 void sas_port_delete(struct sas_port
*port
)
767 struct device
*dev
= &port
->dev
;
768 struct sas_phy
*phy
, *tmp_phy
;
771 sas_rphy_delete(port
->rphy
);
775 mutex_lock(&port
->phy_list_mutex
);
776 list_for_each_entry_safe(phy
, tmp_phy
, &port
->phy_list
,
778 sas_port_delete_link(port
, phy
);
779 list_del_init(&phy
->port_siblings
);
781 mutex_unlock(&port
->phy_list_mutex
);
783 if (port
->is_backlink
) {
784 struct device
*parent
= port
->dev
.parent
;
786 sysfs_remove_link(&port
->dev
.kobj
, parent
->bus_id
);
787 port
->is_backlink
= 0;
790 transport_remove_device(dev
);
792 transport_destroy_device(dev
);
795 EXPORT_SYMBOL(sas_port_delete
);
798 * scsi_is_sas_port -- check if a struct device represents a SAS port
799 * @dev: device to check
802 * %1 if the device represents a SAS Port, %0 else
804 int scsi_is_sas_port(const struct device
*dev
)
806 return dev
->release
== sas_port_release
;
808 EXPORT_SYMBOL(scsi_is_sas_port
);
811 * sas_port_add_phy - add another phy to a port to form a wide port
812 * @port: port to add the phy to
815 * When a port is initially created, it is empty (has no phys). All
816 * ports must have at least one phy to operated, and all wide ports
817 * must have at least two. The current code makes no difference
818 * between ports and wide ports, but the only object that can be
819 * connected to a remote device is a port, so ports must be formed on
820 * all devices with phys if they're connected to anything.
822 void sas_port_add_phy(struct sas_port
*port
, struct sas_phy
*phy
)
824 mutex_lock(&port
->phy_list_mutex
);
825 if (unlikely(!list_empty(&phy
->port_siblings
))) {
826 /* make sure we're already on this port */
829 list_for_each_entry(tmp
, &port
->phy_list
, port_siblings
)
832 /* If this trips, you added a phy that was already
833 * part of a different port */
834 if (unlikely(tmp
!= phy
)) {
835 dev_printk(KERN_ERR
, &port
->dev
, "trying to add phy %s fails: it's already part of another port\n", phy
->dev
.bus_id
);
839 sas_port_create_link(port
, phy
);
840 list_add_tail(&phy
->port_siblings
, &port
->phy_list
);
843 mutex_unlock(&port
->phy_list_mutex
);
845 EXPORT_SYMBOL(sas_port_add_phy
);
848 * sas_port_delete_phy - remove a phy from a port or wide port
849 * @port: port to remove the phy from
850 * @phy: phy to remove
852 * This operation is used for tearing down ports again. It must be
853 * done to every port or wide port before calling sas_port_delete.
855 void sas_port_delete_phy(struct sas_port
*port
, struct sas_phy
*phy
)
857 mutex_lock(&port
->phy_list_mutex
);
858 sas_port_delete_link(port
, phy
);
859 list_del_init(&phy
->port_siblings
);
861 mutex_unlock(&port
->phy_list_mutex
);
863 EXPORT_SYMBOL(sas_port_delete_phy
);
865 void sas_port_mark_backlink(struct sas_port
*port
)
867 struct device
*parent
= port
->dev
.parent
->parent
->parent
;
869 if (port
->is_backlink
)
871 port
->is_backlink
= 1;
872 sysfs_create_link(&port
->dev
.kobj
, &parent
->kobj
,
876 EXPORT_SYMBOL(sas_port_mark_backlink
);
879 * SAS remote PHY attributes.
882 #define sas_rphy_show_simple(field, name, format_string, cast) \
884 show_sas_rphy_##name(struct class_device *cdev, char *buf) \
886 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
888 return snprintf(buf, 20, format_string, cast rphy->field); \
891 #define sas_rphy_simple_attr(field, name, format_string, type) \
892 sas_rphy_show_simple(field, name, format_string, (type)) \
893 static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
894 show_sas_rphy_##name, NULL)
896 #define sas_rphy_show_protocol(field, name) \
898 show_sas_rphy_##name(struct class_device *cdev, char *buf) \
900 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
903 return snprintf(buf, 20, "none\n"); \
904 return get_sas_protocol_names(rphy->field, buf); \
907 #define sas_rphy_protocol_attr(field, name) \
908 sas_rphy_show_protocol(field, name) \
909 static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
910 show_sas_rphy_##name, NULL)
913 show_sas_rphy_device_type(struct class_device
*cdev
, char *buf
)
915 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
917 if (!rphy
->identify
.device_type
)
918 return snprintf(buf
, 20, "none\n");
919 return get_sas_device_type_names(
920 rphy
->identify
.device_type
, buf
);
923 static SAS_CLASS_DEVICE_ATTR(rphy
, device_type
, S_IRUGO
,
924 show_sas_rphy_device_type
, NULL
);
927 show_sas_rphy_enclosure_identifier(struct class_device
*cdev
, char *buf
)
929 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
930 struct sas_phy
*phy
= dev_to_phy(rphy
->dev
.parent
);
931 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
932 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
937 * Only devices behind an expander are supported, because the
938 * enclosure identifier is a SMP feature.
940 if (scsi_is_sas_phy_local(phy
))
943 error
= i
->f
->get_enclosure_identifier(rphy
, &identifier
);
946 return sprintf(buf
, "0x%llx\n", (unsigned long long)identifier
);
949 static SAS_CLASS_DEVICE_ATTR(rphy
, enclosure_identifier
, S_IRUGO
,
950 show_sas_rphy_enclosure_identifier
, NULL
);
953 show_sas_rphy_bay_identifier(struct class_device
*cdev
, char *buf
)
955 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
956 struct sas_phy
*phy
= dev_to_phy(rphy
->dev
.parent
);
957 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
958 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
961 if (scsi_is_sas_phy_local(phy
))
964 val
= i
->f
->get_bay_identifier(rphy
);
967 return sprintf(buf
, "%d\n", val
);
970 static SAS_CLASS_DEVICE_ATTR(rphy
, bay_identifier
, S_IRUGO
,
971 show_sas_rphy_bay_identifier
, NULL
);
973 sas_rphy_protocol_attr(identify
.initiator_port_protocols
,
974 initiator_port_protocols
);
975 sas_rphy_protocol_attr(identify
.target_port_protocols
, target_port_protocols
);
976 sas_rphy_simple_attr(identify
.sas_address
, sas_address
, "0x%016llx\n",
978 sas_rphy_simple_attr(identify
.phy_identifier
, phy_identifier
, "%d\n", u8
);
980 /* only need 8 bytes of data plus header (4 or 8) */
983 int sas_read_port_mode_page(struct scsi_device
*sdev
)
985 char *buffer
= kzalloc(BUF_SIZE
, GFP_KERNEL
), *msdata
;
986 struct sas_rphy
*rphy
= target_to_rphy(sdev
->sdev_target
);
987 struct sas_end_device
*rdev
;
988 struct scsi_mode_data mode_data
;
991 BUG_ON(rphy
->identify
.device_type
!= SAS_END_DEVICE
);
993 rdev
= rphy_to_end_device(rphy
);
998 res
= scsi_mode_sense(sdev
, 1, 0x19, buffer
, BUF_SIZE
, 30*HZ
, 3,
1002 if (!scsi_status_is_good(res
))
1005 msdata
= buffer
+ mode_data
.header_length
+
1006 mode_data
.block_descriptor_length
;
1008 if (msdata
- buffer
> BUF_SIZE
- 8)
1013 rdev
->ready_led_meaning
= msdata
[2] & 0x10 ? 1 : 0;
1014 rdev
->I_T_nexus_loss_timeout
= (msdata
[4] << 8) + msdata
[5];
1015 rdev
->initiator_response_timeout
= (msdata
[6] << 8) + msdata
[7];
1021 EXPORT_SYMBOL(sas_read_port_mode_page
);
1023 static DECLARE_TRANSPORT_CLASS(sas_end_dev_class
,
1024 "sas_end_device", NULL
, NULL
, NULL
);
1026 #define sas_end_dev_show_simple(field, name, format_string, cast) \
1028 show_sas_end_dev_##name(struct class_device *cdev, char *buf) \
1030 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
1031 struct sas_end_device *rdev = rphy_to_end_device(rphy); \
1033 return snprintf(buf, 20, format_string, cast rdev->field); \
1036 #define sas_end_dev_simple_attr(field, name, format_string, type) \
1037 sas_end_dev_show_simple(field, name, format_string, (type)) \
1038 static SAS_CLASS_DEVICE_ATTR(end_dev, name, S_IRUGO, \
1039 show_sas_end_dev_##name, NULL)
1041 sas_end_dev_simple_attr(ready_led_meaning
, ready_led_meaning
, "%d\n", int);
1042 sas_end_dev_simple_attr(I_T_nexus_loss_timeout
, I_T_nexus_loss_timeout
,
1044 sas_end_dev_simple_attr(initiator_response_timeout
, initiator_response_timeout
,
1047 static DECLARE_TRANSPORT_CLASS(sas_expander_class
,
1048 "sas_expander", NULL
, NULL
, NULL
);
1050 #define sas_expander_show_simple(field, name, format_string, cast) \
1052 show_sas_expander_##name(struct class_device *cdev, char *buf) \
1054 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
1055 struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
1057 return snprintf(buf, 20, format_string, cast edev->field); \
1060 #define sas_expander_simple_attr(field, name, format_string, type) \
1061 sas_expander_show_simple(field, name, format_string, (type)) \
1062 static SAS_CLASS_DEVICE_ATTR(expander, name, S_IRUGO, \
1063 show_sas_expander_##name, NULL)
1065 sas_expander_simple_attr(vendor_id
, vendor_id
, "%s\n", char *);
1066 sas_expander_simple_attr(product_id
, product_id
, "%s\n", char *);
1067 sas_expander_simple_attr(product_rev
, product_rev
, "%s\n", char *);
1068 sas_expander_simple_attr(component_vendor_id
, component_vendor_id
,
1070 sas_expander_simple_attr(component_id
, component_id
, "%u\n", unsigned int);
1071 sas_expander_simple_attr(component_revision_id
, component_revision_id
, "%u\n",
1073 sas_expander_simple_attr(level
, level
, "%d\n", int);
1075 static DECLARE_TRANSPORT_CLASS(sas_rphy_class
,
1076 "sas_device", NULL
, NULL
, NULL
);
1078 static int sas_rphy_match(struct attribute_container
*cont
, struct device
*dev
)
1080 struct Scsi_Host
*shost
;
1081 struct sas_internal
*i
;
1083 if (!scsi_is_sas_rphy(dev
))
1085 shost
= dev_to_shost(dev
->parent
->parent
);
1087 if (!shost
->transportt
)
1089 if (shost
->transportt
->host_attrs
.ac
.class !=
1090 &sas_host_class
.class)
1093 i
= to_sas_internal(shost
->transportt
);
1094 return &i
->rphy_attr_cont
.ac
== cont
;
1097 static int sas_end_dev_match(struct attribute_container
*cont
,
1100 struct Scsi_Host
*shost
;
1101 struct sas_internal
*i
;
1102 struct sas_rphy
*rphy
;
1104 if (!scsi_is_sas_rphy(dev
))
1106 shost
= dev_to_shost(dev
->parent
->parent
);
1107 rphy
= dev_to_rphy(dev
);
1109 if (!shost
->transportt
)
1111 if (shost
->transportt
->host_attrs
.ac
.class !=
1112 &sas_host_class
.class)
1115 i
= to_sas_internal(shost
->transportt
);
1116 return &i
->end_dev_attr_cont
.ac
== cont
&&
1117 rphy
->identify
.device_type
== SAS_END_DEVICE
;
1120 static int sas_expander_match(struct attribute_container
*cont
,
1123 struct Scsi_Host
*shost
;
1124 struct sas_internal
*i
;
1125 struct sas_rphy
*rphy
;
1127 if (!scsi_is_sas_rphy(dev
))
1129 shost
= dev_to_shost(dev
->parent
->parent
);
1130 rphy
= dev_to_rphy(dev
);
1132 if (!shost
->transportt
)
1134 if (shost
->transportt
->host_attrs
.ac
.class !=
1135 &sas_host_class
.class)
1138 i
= to_sas_internal(shost
->transportt
);
1139 return &i
->expander_attr_cont
.ac
== cont
&&
1140 (rphy
->identify
.device_type
== SAS_EDGE_EXPANDER_DEVICE
||
1141 rphy
->identify
.device_type
== SAS_FANOUT_EXPANDER_DEVICE
);
1144 static void sas_expander_release(struct device
*dev
)
1146 struct sas_rphy
*rphy
= dev_to_rphy(dev
);
1147 struct sas_expander_device
*edev
= rphy_to_expander_device(rphy
);
1149 put_device(dev
->parent
);
1153 static void sas_end_device_release(struct device
*dev
)
1155 struct sas_rphy
*rphy
= dev_to_rphy(dev
);
1156 struct sas_end_device
*edev
= rphy_to_end_device(rphy
);
1158 put_device(dev
->parent
);
1163 * sas_rphy_initialize - common rphy intialization
1164 * @rphy: rphy to initialise
1166 * Used by both sas_end_device_alloc() and sas_expander_alloc() to
1167 * initialise the common rphy component of each.
1169 static void sas_rphy_initialize(struct sas_rphy
*rphy
)
1171 INIT_LIST_HEAD(&rphy
->list
);
1175 * sas_end_device_alloc - allocate an rphy for an end device
1177 * Allocates an SAS remote PHY structure, connected to @parent.
1180 * SAS PHY allocated or %NULL if the allocation failed.
1182 struct sas_rphy
*sas_end_device_alloc(struct sas_port
*parent
)
1184 struct Scsi_Host
*shost
= dev_to_shost(&parent
->dev
);
1185 struct sas_end_device
*rdev
;
1187 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
1192 device_initialize(&rdev
->rphy
.dev
);
1193 rdev
->rphy
.dev
.parent
= get_device(&parent
->dev
);
1194 rdev
->rphy
.dev
.release
= sas_end_device_release
;
1195 if (scsi_is_sas_expander_device(parent
->dev
.parent
)) {
1196 struct sas_rphy
*rphy
= dev_to_rphy(parent
->dev
.parent
);
1197 sprintf(rdev
->rphy
.dev
.bus_id
, "end_device-%d:%d:%d",
1198 shost
->host_no
, rphy
->scsi_target_id
, parent
->port_identifier
);
1200 sprintf(rdev
->rphy
.dev
.bus_id
, "end_device-%d:%d",
1201 shost
->host_no
, parent
->port_identifier
);
1202 rdev
->rphy
.identify
.device_type
= SAS_END_DEVICE
;
1203 sas_rphy_initialize(&rdev
->rphy
);
1204 transport_setup_device(&rdev
->rphy
.dev
);
1208 EXPORT_SYMBOL(sas_end_device_alloc
);
1211 * sas_expander_alloc - allocate an rphy for an end device
1213 * Allocates an SAS remote PHY structure, connected to @parent.
1216 * SAS PHY allocated or %NULL if the allocation failed.
1218 struct sas_rphy
*sas_expander_alloc(struct sas_port
*parent
,
1219 enum sas_device_type type
)
1221 struct Scsi_Host
*shost
= dev_to_shost(&parent
->dev
);
1222 struct sas_expander_device
*rdev
;
1223 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1225 BUG_ON(type
!= SAS_EDGE_EXPANDER_DEVICE
&&
1226 type
!= SAS_FANOUT_EXPANDER_DEVICE
);
1228 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
1233 device_initialize(&rdev
->rphy
.dev
);
1234 rdev
->rphy
.dev
.parent
= get_device(&parent
->dev
);
1235 rdev
->rphy
.dev
.release
= sas_expander_release
;
1236 mutex_lock(&sas_host
->lock
);
1237 rdev
->rphy
.scsi_target_id
= sas_host
->next_expander_id
++;
1238 mutex_unlock(&sas_host
->lock
);
1239 sprintf(rdev
->rphy
.dev
.bus_id
, "expander-%d:%d",
1240 shost
->host_no
, rdev
->rphy
.scsi_target_id
);
1241 rdev
->rphy
.identify
.device_type
= type
;
1242 sas_rphy_initialize(&rdev
->rphy
);
1243 transport_setup_device(&rdev
->rphy
.dev
);
1247 EXPORT_SYMBOL(sas_expander_alloc
);
1250 * sas_rphy_add -- add a SAS remote PHY to the device hierachy
1251 * @rphy: The remote PHY to be added
1253 * Publishes a SAS remote PHY to the rest of the system.
1255 int sas_rphy_add(struct sas_rphy
*rphy
)
1257 struct sas_port
*parent
= dev_to_sas_port(rphy
->dev
.parent
);
1258 struct Scsi_Host
*shost
= dev_to_shost(parent
->dev
.parent
);
1259 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1260 struct sas_identify
*identify
= &rphy
->identify
;
1265 parent
->rphy
= rphy
;
1267 error
= device_add(&rphy
->dev
);
1270 transport_add_device(&rphy
->dev
);
1271 transport_configure_device(&rphy
->dev
);
1273 mutex_lock(&sas_host
->lock
);
1274 list_add_tail(&rphy
->list
, &sas_host
->rphy_list
);
1275 if (identify
->device_type
== SAS_END_DEVICE
&&
1276 (identify
->target_port_protocols
&
1277 (SAS_PROTOCOL_SSP
|SAS_PROTOCOL_STP
|SAS_PROTOCOL_SATA
)))
1278 rphy
->scsi_target_id
= sas_host
->next_target_id
++;
1279 else if (identify
->device_type
== SAS_END_DEVICE
)
1280 rphy
->scsi_target_id
= -1;
1281 mutex_unlock(&sas_host
->lock
);
1283 if (identify
->device_type
== SAS_END_DEVICE
&&
1284 rphy
->scsi_target_id
!= -1) {
1285 scsi_scan_target(&rphy
->dev
, 0,
1286 rphy
->scsi_target_id
, SCAN_WILD_CARD
, 0);
1291 EXPORT_SYMBOL(sas_rphy_add
);
1294 * sas_rphy_free -- free a SAS remote PHY
1295 * @rphy SAS remote PHY to free
1297 * Frees the specified SAS remote PHY.
1300 * This function must only be called on a remote
1301 * PHY that has not sucessfully been added using
1304 void sas_rphy_free(struct sas_rphy
*rphy
)
1306 struct device
*dev
= &rphy
->dev
;
1307 struct Scsi_Host
*shost
= dev_to_shost(rphy
->dev
.parent
->parent
);
1308 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1310 mutex_lock(&sas_host
->lock
);
1311 list_del(&rphy
->list
);
1312 mutex_unlock(&sas_host
->lock
);
1314 transport_destroy_device(dev
);
1318 EXPORT_SYMBOL(sas_rphy_free
);
1321 * sas_rphy_delete -- remove SAS remote PHY
1322 * @rphy: SAS remote PHY to remove
1324 * Removes the specified SAS remote PHY.
1327 sas_rphy_delete(struct sas_rphy
*rphy
)
1329 struct device
*dev
= &rphy
->dev
;
1330 struct sas_port
*parent
= dev_to_sas_port(dev
->parent
);
1331 struct Scsi_Host
*shost
= dev_to_shost(parent
->dev
.parent
);
1332 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1334 switch (rphy
->identify
.device_type
) {
1335 case SAS_END_DEVICE
:
1336 scsi_remove_target(dev
);
1338 case SAS_EDGE_EXPANDER_DEVICE
:
1339 case SAS_FANOUT_EXPANDER_DEVICE
:
1340 sas_remove_children(dev
);
1346 transport_remove_device(dev
);
1348 transport_destroy_device(dev
);
1350 mutex_lock(&sas_host
->lock
);
1351 list_del(&rphy
->list
);
1352 mutex_unlock(&sas_host
->lock
);
1354 parent
->rphy
= NULL
;
1358 EXPORT_SYMBOL(sas_rphy_delete
);
1361 * scsi_is_sas_rphy -- check if a struct device represents a SAS remote PHY
1362 * @dev: device to check
1365 * %1 if the device represents a SAS remote PHY, %0 else
1367 int scsi_is_sas_rphy(const struct device
*dev
)
1369 return dev
->release
== sas_end_device_release
||
1370 dev
->release
== sas_expander_release
;
1372 EXPORT_SYMBOL(scsi_is_sas_rphy
);
1379 static int sas_user_scan(struct Scsi_Host
*shost
, uint channel
,
1382 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1383 struct sas_rphy
*rphy
;
1385 mutex_lock(&sas_host
->lock
);
1386 list_for_each_entry(rphy
, &sas_host
->rphy_list
, list
) {
1387 if (rphy
->identify
.device_type
!= SAS_END_DEVICE
||
1388 rphy
->scsi_target_id
== -1)
1391 if ((channel
== SCAN_WILD_CARD
|| channel
== 0) &&
1392 (id
== SCAN_WILD_CARD
|| id
== rphy
->scsi_target_id
)) {
1393 scsi_scan_target(&rphy
->dev
, 0,
1394 rphy
->scsi_target_id
, lun
, 1);
1397 mutex_unlock(&sas_host
->lock
);
1404 * Setup / Teardown code
1407 #define SETUP_TEMPLATE(attrb, field, perm, test) \
1408 i->private_##attrb[count] = class_device_attr_##field; \
1409 i->private_##attrb[count].attr.mode = perm; \
1410 i->attrb[count] = &i->private_##attrb[count]; \
1414 #define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \
1415 i->private_##attrb[count] = class_device_attr_##field; \
1416 i->private_##attrb[count].attr.mode = perm; \
1418 i->private_##attrb[count].attr.mode = ro_perm; \
1419 i->private_##attrb[count].store = NULL; \
1421 i->attrb[count] = &i->private_##attrb[count]; \
1425 #define SETUP_RPORT_ATTRIBUTE(field) \
1426 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, 1)
1428 #define SETUP_OPTIONAL_RPORT_ATTRIBUTE(field, func) \
1429 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, i->f->func)
1431 #define SETUP_PHY_ATTRIBUTE(field) \
1432 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, 1)
1434 #define SETUP_PHY_ATTRIBUTE_RW(field) \
1435 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1436 !i->f->set_phy_speed, S_IRUGO)
1438 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(field, func) \
1439 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1440 !i->f->func, S_IRUGO)
1442 #define SETUP_PORT_ATTRIBUTE(field) \
1443 SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1)
1445 #define SETUP_OPTIONAL_PHY_ATTRIBUTE(field, func) \
1446 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, i->f->func)
1448 #define SETUP_PHY_ATTRIBUTE_WRONLY(field) \
1449 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, 1)
1451 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(field, func) \
1452 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, i->f->func)
1454 #define SETUP_END_DEV_ATTRIBUTE(field) \
1455 SETUP_TEMPLATE(end_dev_attrs, field, S_IRUGO, 1)
1457 #define SETUP_EXPANDER_ATTRIBUTE(field) \
1458 SETUP_TEMPLATE(expander_attrs, expander_##field, S_IRUGO, 1)
1461 * sas_attach_transport -- instantiate SAS transport template
1462 * @ft: SAS transport class function template
1464 struct scsi_transport_template
*
1465 sas_attach_transport(struct sas_function_template
*ft
)
1467 struct sas_internal
*i
;
1470 i
= kzalloc(sizeof(struct sas_internal
), GFP_KERNEL
);
1474 i
->t
.user_scan
= sas_user_scan
;
1476 i
->t
.host_attrs
.ac
.attrs
= &i
->host_attrs
[0];
1477 i
->t
.host_attrs
.ac
.class = &sas_host_class
.class;
1478 i
->t
.host_attrs
.ac
.match
= sas_host_match
;
1479 transport_container_register(&i
->t
.host_attrs
);
1480 i
->t
.host_size
= sizeof(struct sas_host_attrs
);
1482 i
->phy_attr_cont
.ac
.class = &sas_phy_class
.class;
1483 i
->phy_attr_cont
.ac
.attrs
= &i
->phy_attrs
[0];
1484 i
->phy_attr_cont
.ac
.match
= sas_phy_match
;
1485 transport_container_register(&i
->phy_attr_cont
);
1487 i
->port_attr_cont
.ac
.class = &sas_port_class
.class;
1488 i
->port_attr_cont
.ac
.attrs
= &i
->port_attrs
[0];
1489 i
->port_attr_cont
.ac
.match
= sas_port_match
;
1490 transport_container_register(&i
->port_attr_cont
);
1492 i
->rphy_attr_cont
.ac
.class = &sas_rphy_class
.class;
1493 i
->rphy_attr_cont
.ac
.attrs
= &i
->rphy_attrs
[0];
1494 i
->rphy_attr_cont
.ac
.match
= sas_rphy_match
;
1495 transport_container_register(&i
->rphy_attr_cont
);
1497 i
->end_dev_attr_cont
.ac
.class = &sas_end_dev_class
.class;
1498 i
->end_dev_attr_cont
.ac
.attrs
= &i
->end_dev_attrs
[0];
1499 i
->end_dev_attr_cont
.ac
.match
= sas_end_dev_match
;
1500 transport_container_register(&i
->end_dev_attr_cont
);
1502 i
->expander_attr_cont
.ac
.class = &sas_expander_class
.class;
1503 i
->expander_attr_cont
.ac
.attrs
= &i
->expander_attrs
[0];
1504 i
->expander_attr_cont
.ac
.match
= sas_expander_match
;
1505 transport_container_register(&i
->expander_attr_cont
);
1510 SETUP_PORT_ATTRIBUTE(num_phys
);
1511 i
->host_attrs
[count
] = NULL
;
1514 SETUP_PHY_ATTRIBUTE(initiator_port_protocols
);
1515 SETUP_PHY_ATTRIBUTE(target_port_protocols
);
1516 SETUP_PHY_ATTRIBUTE(device_type
);
1517 SETUP_PHY_ATTRIBUTE(sas_address
);
1518 SETUP_PHY_ATTRIBUTE(phy_identifier
);
1519 //SETUP_PHY_ATTRIBUTE(port_identifier);
1520 SETUP_PHY_ATTRIBUTE(negotiated_linkrate
);
1521 SETUP_PHY_ATTRIBUTE(minimum_linkrate_hw
);
1522 SETUP_PHY_ATTRIBUTE_RW(minimum_linkrate
);
1523 SETUP_PHY_ATTRIBUTE(maximum_linkrate_hw
);
1524 SETUP_PHY_ATTRIBUTE_RW(maximum_linkrate
);
1526 SETUP_PHY_ATTRIBUTE(invalid_dword_count
);
1527 SETUP_PHY_ATTRIBUTE(running_disparity_error_count
);
1528 SETUP_PHY_ATTRIBUTE(loss_of_dword_sync_count
);
1529 SETUP_PHY_ATTRIBUTE(phy_reset_problem_count
);
1530 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(link_reset
, phy_reset
);
1531 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(hard_reset
, phy_reset
);
1532 SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(enable
, phy_enable
);
1533 i
->phy_attrs
[count
] = NULL
;
1536 SETUP_PORT_ATTRIBUTE(num_phys
);
1537 i
->port_attrs
[count
] = NULL
;
1540 SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols
);
1541 SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols
);
1542 SETUP_RPORT_ATTRIBUTE(rphy_device_type
);
1543 SETUP_RPORT_ATTRIBUTE(rphy_sas_address
);
1544 SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier
);
1545 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_enclosure_identifier
,
1546 get_enclosure_identifier
);
1547 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_bay_identifier
,
1548 get_bay_identifier
);
1549 i
->rphy_attrs
[count
] = NULL
;
1552 SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning
);
1553 SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout
);
1554 SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout
);
1555 i
->end_dev_attrs
[count
] = NULL
;
1558 SETUP_EXPANDER_ATTRIBUTE(vendor_id
);
1559 SETUP_EXPANDER_ATTRIBUTE(product_id
);
1560 SETUP_EXPANDER_ATTRIBUTE(product_rev
);
1561 SETUP_EXPANDER_ATTRIBUTE(component_vendor_id
);
1562 SETUP_EXPANDER_ATTRIBUTE(component_id
);
1563 SETUP_EXPANDER_ATTRIBUTE(component_revision_id
);
1564 SETUP_EXPANDER_ATTRIBUTE(level
);
1565 i
->expander_attrs
[count
] = NULL
;
1569 EXPORT_SYMBOL(sas_attach_transport
);
1572 * sas_release_transport -- release SAS transport template instance
1573 * @t: transport template instance
1575 void sas_release_transport(struct scsi_transport_template
*t
)
1577 struct sas_internal
*i
= to_sas_internal(t
);
1579 transport_container_unregister(&i
->t
.host_attrs
);
1580 transport_container_unregister(&i
->phy_attr_cont
);
1581 transport_container_unregister(&i
->port_attr_cont
);
1582 transport_container_unregister(&i
->rphy_attr_cont
);
1583 transport_container_unregister(&i
->end_dev_attr_cont
);
1584 transport_container_unregister(&i
->expander_attr_cont
);
1588 EXPORT_SYMBOL(sas_release_transport
);
1590 static __init
int sas_transport_init(void)
1594 error
= transport_class_register(&sas_host_class
);
1597 error
= transport_class_register(&sas_phy_class
);
1599 goto out_unregister_transport
;
1600 error
= transport_class_register(&sas_port_class
);
1602 goto out_unregister_phy
;
1603 error
= transport_class_register(&sas_rphy_class
);
1605 goto out_unregister_port
;
1606 error
= transport_class_register(&sas_end_dev_class
);
1608 goto out_unregister_rphy
;
1609 error
= transport_class_register(&sas_expander_class
);
1611 goto out_unregister_end_dev
;
1615 out_unregister_end_dev
:
1616 transport_class_unregister(&sas_end_dev_class
);
1617 out_unregister_rphy
:
1618 transport_class_unregister(&sas_rphy_class
);
1619 out_unregister_port
:
1620 transport_class_unregister(&sas_port_class
);
1622 transport_class_unregister(&sas_phy_class
);
1623 out_unregister_transport
:
1624 transport_class_unregister(&sas_host_class
);
1630 static void __exit
sas_transport_exit(void)
1632 transport_class_unregister(&sas_host_class
);
1633 transport_class_unregister(&sas_phy_class
);
1634 transport_class_unregister(&sas_port_class
);
1635 transport_class_unregister(&sas_rphy_class
);
1636 transport_class_unregister(&sas_end_dev_class
);
1637 transport_class_unregister(&sas_expander_class
);
1640 MODULE_AUTHOR("Christoph Hellwig");
1641 MODULE_DESCRIPTION("SAS Transphy Attributes");
1642 MODULE_LICENSE("GPL");
1644 module_init(sas_transport_init
);
1645 module_exit(sas_transport_exit
);