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/err.h>
29 #include <linux/slab.h>
30 #include <linux/string.h>
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi_transport.h>
36 #include <scsi/scsi_transport_sas.h>
39 #define SAS_HOST_ATTRS 0
40 #define SAS_PORT_ATTRS 17
41 #define SAS_RPORT_ATTRS 7
42 #define SAS_END_DEV_ATTRS 3
43 #define SAS_EXPANDER_ATTRS 7
46 struct scsi_transport_template t
;
47 struct sas_function_template
*f
;
49 struct class_device_attribute private_host_attrs
[SAS_HOST_ATTRS
];
50 struct class_device_attribute private_phy_attrs
[SAS_PORT_ATTRS
];
51 struct class_device_attribute private_rphy_attrs
[SAS_RPORT_ATTRS
];
52 struct class_device_attribute private_end_dev_attrs
[SAS_END_DEV_ATTRS
];
53 struct class_device_attribute private_expander_attrs
[SAS_EXPANDER_ATTRS
];
55 struct transport_container phy_attr_cont
;
56 struct transport_container rphy_attr_cont
;
57 struct transport_container end_dev_attr_cont
;
58 struct transport_container expander_attr_cont
;
61 * The array of null terminated pointers to attributes
62 * needed by scsi_sysfs.c
64 struct class_device_attribute
*host_attrs
[SAS_HOST_ATTRS
+ 1];
65 struct class_device_attribute
*phy_attrs
[SAS_PORT_ATTRS
+ 1];
66 struct class_device_attribute
*rphy_attrs
[SAS_RPORT_ATTRS
+ 1];
67 struct class_device_attribute
*end_dev_attrs
[SAS_END_DEV_ATTRS
+ 1];
68 struct class_device_attribute
*expander_attrs
[SAS_EXPANDER_ATTRS
+ 1];
70 #define to_sas_internal(tmpl) container_of(tmpl, struct sas_internal, t)
72 struct sas_host_attrs
{
73 struct list_head rphy_list
;
78 #define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
82 * Hack to allow attributes of the same name in different objects.
84 #define SAS_CLASS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
85 struct class_device_attribute class_device_attr_##_prefix##_##_name = \
86 __ATTR(_name,_mode,_show,_store)
90 * Pretty printing helpers
93 #define sas_bitfield_name_match(title, table) \
95 get_sas_##title##_names(u32 table_key, char *buf) \
101 for (i = 0; i < sizeof(table)/sizeof(table[0]); i++) { \
102 if (table[i].value & table_key) { \
103 len += sprintf(buf + len, "%s%s", \
104 prefix, table[i].name); \
108 len += sprintf(buf + len, "\n"); \
112 #define sas_bitfield_name_search(title, table) \
114 get_sas_##title##_names(u32 table_key, char *buf) \
119 for (i = 0; i < sizeof(table)/sizeof(table[0]); i++) { \
120 if (table[i].value == table_key) { \
121 len += sprintf(buf + len, "%s", \
126 len += sprintf(buf + len, "\n"); \
133 } sas_device_type_names
[] = {
134 { SAS_PHY_UNUSED
, "unused" },
135 { SAS_END_DEVICE
, "end device" },
136 { SAS_EDGE_EXPANDER_DEVICE
, "edge expander" },
137 { SAS_FANOUT_EXPANDER_DEVICE
, "fanout expander" },
139 sas_bitfield_name_search(device_type
, sas_device_type_names
)
145 } sas_protocol_names
[] = {
146 { SAS_PROTOCOL_SATA
, "sata" },
147 { SAS_PROTOCOL_SMP
, "smp" },
148 { SAS_PROTOCOL_STP
, "stp" },
149 { SAS_PROTOCOL_SSP
, "ssp" },
151 sas_bitfield_name_match(protocol
, sas_protocol_names
)
156 } sas_linkspeed_names
[] = {
157 { SAS_LINK_RATE_UNKNOWN
, "Unknown" },
158 { SAS_PHY_DISABLED
, "Phy disabled" },
159 { SAS_LINK_RATE_FAILED
, "Link Rate failed" },
160 { SAS_SATA_SPINUP_HOLD
, "Spin-up hold" },
161 { SAS_LINK_RATE_1_5_GBPS
, "1.5 Gbit" },
162 { SAS_LINK_RATE_3_0_GBPS
, "3.0 Gbit" },
163 { SAS_LINK_RATE_6_0_GBPS
, "6.0 Gbit" },
165 sas_bitfield_name_search(linkspeed
, sas_linkspeed_names
)
169 * SAS host attributes
172 static int sas_host_setup(struct transport_container
*tc
, struct device
*dev
,
173 struct class_device
*cdev
)
175 struct Scsi_Host
*shost
= dev_to_shost(dev
);
176 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
178 INIT_LIST_HEAD(&sas_host
->rphy_list
);
179 mutex_init(&sas_host
->lock
);
180 sas_host
->next_target_id
= 0;
181 sas_host
->next_expander_id
= 0;
185 static DECLARE_TRANSPORT_CLASS(sas_host_class
,
186 "sas_host", sas_host_setup
, NULL
, NULL
);
188 static int sas_host_match(struct attribute_container
*cont
,
191 struct Scsi_Host
*shost
;
192 struct sas_internal
*i
;
194 if (!scsi_is_host_device(dev
))
196 shost
= dev_to_shost(dev
);
198 if (!shost
->transportt
)
200 if (shost
->transportt
->host_attrs
.ac
.class !=
201 &sas_host_class
.class)
204 i
= to_sas_internal(shost
->transportt
);
205 return &i
->t
.host_attrs
.ac
== cont
;
208 static int do_sas_phy_delete(struct device
*dev
, void *data
)
210 if (scsi_is_sas_phy(dev
))
211 sas_phy_delete(dev_to_phy(dev
));
216 * sas_remove_host -- tear down a Scsi_Host's SAS data structures
217 * @shost: Scsi Host that is torn down
219 * Removes all SAS PHYs and remote PHYs for a given Scsi_Host.
220 * Must be called just before scsi_remove_host for SAS HBAs.
222 void sas_remove_host(struct Scsi_Host
*shost
)
224 device_for_each_child(&shost
->shost_gendev
, NULL
, do_sas_phy_delete
);
226 EXPORT_SYMBOL(sas_remove_host
);
230 * SAS Port attributes
233 #define sas_phy_show_simple(field, name, format_string, cast) \
235 show_sas_phy_##name(struct class_device *cdev, char *buf) \
237 struct sas_phy *phy = transport_class_to_phy(cdev); \
239 return snprintf(buf, 20, format_string, cast phy->field); \
242 #define sas_phy_simple_attr(field, name, format_string, type) \
243 sas_phy_show_simple(field, name, format_string, (type)) \
244 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
246 #define sas_phy_show_protocol(field, name) \
248 show_sas_phy_##name(struct class_device *cdev, char *buf) \
250 struct sas_phy *phy = transport_class_to_phy(cdev); \
253 return snprintf(buf, 20, "none\n"); \
254 return get_sas_protocol_names(phy->field, buf); \
257 #define sas_phy_protocol_attr(field, name) \
258 sas_phy_show_protocol(field, name) \
259 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
261 #define sas_phy_show_linkspeed(field) \
263 show_sas_phy_##field(struct class_device *cdev, char *buf) \
265 struct sas_phy *phy = transport_class_to_phy(cdev); \
267 return get_sas_linkspeed_names(phy->field, buf); \
270 #define sas_phy_linkspeed_attr(field) \
271 sas_phy_show_linkspeed(field) \
272 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
274 #define sas_phy_show_linkerror(field) \
276 show_sas_phy_##field(struct class_device *cdev, char *buf) \
278 struct sas_phy *phy = transport_class_to_phy(cdev); \
279 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
280 struct sas_internal *i = to_sas_internal(shost->transportt); \
283 if (!phy->local_attached) \
286 error = i->f->get_linkerrors ? i->f->get_linkerrors(phy) : 0; \
289 return snprintf(buf, 20, "%u\n", phy->field); \
292 #define sas_phy_linkerror_attr(field) \
293 sas_phy_show_linkerror(field) \
294 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
298 show_sas_device_type(struct class_device
*cdev
, char *buf
)
300 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
302 if (!phy
->identify
.device_type
)
303 return snprintf(buf
, 20, "none\n");
304 return get_sas_device_type_names(phy
->identify
.device_type
, buf
);
306 static CLASS_DEVICE_ATTR(device_type
, S_IRUGO
, show_sas_device_type
, NULL
);
308 static ssize_t
do_sas_phy_reset(struct class_device
*cdev
,
309 size_t count
, int hard_reset
)
311 struct sas_phy
*phy
= transport_class_to_phy(cdev
);
312 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
313 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
316 if (!phy
->local_attached
)
319 error
= i
->f
->phy_reset(phy
, hard_reset
);
325 static ssize_t
store_sas_link_reset(struct class_device
*cdev
,
326 const char *buf
, size_t count
)
328 return do_sas_phy_reset(cdev
, count
, 0);
330 static CLASS_DEVICE_ATTR(link_reset
, S_IWUSR
, NULL
, store_sas_link_reset
);
332 static ssize_t
store_sas_hard_reset(struct class_device
*cdev
,
333 const char *buf
, size_t count
)
335 return do_sas_phy_reset(cdev
, count
, 1);
337 static CLASS_DEVICE_ATTR(hard_reset
, S_IWUSR
, NULL
, store_sas_hard_reset
);
339 sas_phy_protocol_attr(identify
.initiator_port_protocols
,
340 initiator_port_protocols
);
341 sas_phy_protocol_attr(identify
.target_port_protocols
,
342 target_port_protocols
);
343 sas_phy_simple_attr(identify
.sas_address
, sas_address
, "0x%016llx\n",
345 sas_phy_simple_attr(identify
.phy_identifier
, phy_identifier
, "%d\n", u8
);
346 sas_phy_simple_attr(port_identifier
, port_identifier
, "%d\n", u8
);
347 sas_phy_linkspeed_attr(negotiated_linkrate
);
348 sas_phy_linkspeed_attr(minimum_linkrate_hw
);
349 sas_phy_linkspeed_attr(minimum_linkrate
);
350 sas_phy_linkspeed_attr(maximum_linkrate_hw
);
351 sas_phy_linkspeed_attr(maximum_linkrate
);
352 sas_phy_linkerror_attr(invalid_dword_count
);
353 sas_phy_linkerror_attr(running_disparity_error_count
);
354 sas_phy_linkerror_attr(loss_of_dword_sync_count
);
355 sas_phy_linkerror_attr(phy_reset_problem_count
);
358 static DECLARE_TRANSPORT_CLASS(sas_phy_class
,
359 "sas_phy", NULL
, NULL
, NULL
);
361 static int sas_phy_match(struct attribute_container
*cont
, struct device
*dev
)
363 struct Scsi_Host
*shost
;
364 struct sas_internal
*i
;
366 if (!scsi_is_sas_phy(dev
))
368 shost
= dev_to_shost(dev
->parent
);
370 if (!shost
->transportt
)
372 if (shost
->transportt
->host_attrs
.ac
.class !=
373 &sas_host_class
.class)
376 i
= to_sas_internal(shost
->transportt
);
377 return &i
->phy_attr_cont
.ac
== cont
;
380 static void sas_phy_release(struct device
*dev
)
382 struct sas_phy
*phy
= dev_to_phy(dev
);
384 put_device(dev
->parent
);
389 * sas_phy_alloc -- allocates and initialize a SAS PHY structure
390 * @parent: Parent device
393 * Allocates an SAS PHY structure. It will be added in the device tree
394 * below the device specified by @parent, which has to be either a Scsi_Host
398 * SAS PHY allocated or %NULL if the allocation failed.
400 struct sas_phy
*sas_phy_alloc(struct device
*parent
, int number
)
402 struct Scsi_Host
*shost
= dev_to_shost(parent
);
405 phy
= kzalloc(sizeof(*phy
), GFP_KERNEL
);
411 phy
->number
= number
;
413 device_initialize(&phy
->dev
);
414 phy
->dev
.parent
= get_device(parent
);
415 phy
->dev
.release
= sas_phy_release
;
416 if (scsi_is_sas_expander_device(parent
)) {
417 struct sas_rphy
*rphy
= dev_to_rphy(parent
);
418 sprintf(phy
->dev
.bus_id
, "phy-%d-%d:%d", shost
->host_no
,
419 rphy
->scsi_target_id
, number
);
421 sprintf(phy
->dev
.bus_id
, "phy-%d:%d", shost
->host_no
, number
);
423 transport_setup_device(&phy
->dev
);
427 EXPORT_SYMBOL(sas_phy_alloc
);
430 * sas_phy_add -- add a SAS PHY to the device hierachy
431 * @phy: The PHY to be added
433 * Publishes a SAS PHY to the rest of the system.
435 int sas_phy_add(struct sas_phy
*phy
)
439 error
= device_add(&phy
->dev
);
441 transport_add_device(&phy
->dev
);
442 transport_configure_device(&phy
->dev
);
447 EXPORT_SYMBOL(sas_phy_add
);
450 * sas_phy_free -- free a SAS PHY
451 * @phy: SAS PHY to free
453 * Frees the specified SAS PHY.
456 * This function must only be called on a PHY that has not
457 * sucessfully been added using sas_phy_add().
459 void sas_phy_free(struct sas_phy
*phy
)
461 transport_destroy_device(&phy
->dev
);
462 put_device(phy
->dev
.parent
);
463 put_device(phy
->dev
.parent
);
464 put_device(phy
->dev
.parent
);
467 EXPORT_SYMBOL(sas_phy_free
);
470 * sas_phy_delete -- remove SAS PHY
471 * @phy: SAS PHY to remove
473 * Removes the specified SAS PHY. If the SAS PHY has an
474 * associated remote PHY it is removed before.
477 sas_phy_delete(struct sas_phy
*phy
)
479 struct device
*dev
= &phy
->dev
;
482 sas_rphy_delete(phy
->rphy
);
484 transport_remove_device(dev
);
486 transport_destroy_device(dev
);
487 put_device(dev
->parent
);
489 EXPORT_SYMBOL(sas_phy_delete
);
492 * scsi_is_sas_phy -- check if a struct device represents a SAS PHY
493 * @dev: device to check
496 * %1 if the device represents a SAS PHY, %0 else
498 int scsi_is_sas_phy(const struct device
*dev
)
500 return dev
->release
== sas_phy_release
;
502 EXPORT_SYMBOL(scsi_is_sas_phy
);
505 * SAS remote PHY attributes.
508 #define sas_rphy_show_simple(field, name, format_string, cast) \
510 show_sas_rphy_##name(struct class_device *cdev, char *buf) \
512 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
514 return snprintf(buf, 20, format_string, cast rphy->field); \
517 #define sas_rphy_simple_attr(field, name, format_string, type) \
518 sas_rphy_show_simple(field, name, format_string, (type)) \
519 static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
520 show_sas_rphy_##name, NULL)
522 #define sas_rphy_show_protocol(field, name) \
524 show_sas_rphy_##name(struct class_device *cdev, char *buf) \
526 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
529 return snprintf(buf, 20, "none\n"); \
530 return get_sas_protocol_names(rphy->field, buf); \
533 #define sas_rphy_protocol_attr(field, name) \
534 sas_rphy_show_protocol(field, name) \
535 static SAS_CLASS_DEVICE_ATTR(rphy, name, S_IRUGO, \
536 show_sas_rphy_##name, NULL)
539 show_sas_rphy_device_type(struct class_device
*cdev
, char *buf
)
541 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
543 if (!rphy
->identify
.device_type
)
544 return snprintf(buf
, 20, "none\n");
545 return get_sas_device_type_names(
546 rphy
->identify
.device_type
, buf
);
549 static SAS_CLASS_DEVICE_ATTR(rphy
, device_type
, S_IRUGO
,
550 show_sas_rphy_device_type
, NULL
);
553 show_sas_rphy_enclosure_identifier(struct class_device
*cdev
, char *buf
)
555 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
556 struct sas_phy
*phy
= dev_to_phy(rphy
->dev
.parent
);
557 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
558 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
563 * Only devices behind an expander are supported, because the
564 * enclosure identifier is a SMP feature.
566 if (phy
->local_attached
)
569 error
= i
->f
->get_enclosure_identifier(rphy
, &identifier
);
572 return sprintf(buf
, "0x%llx\n", (unsigned long long)identifier
);
575 static SAS_CLASS_DEVICE_ATTR(rphy
, enclosure_identifier
, S_IRUGO
,
576 show_sas_rphy_enclosure_identifier
, NULL
);
579 show_sas_rphy_bay_identifier(struct class_device
*cdev
, char *buf
)
581 struct sas_rphy
*rphy
= transport_class_to_rphy(cdev
);
582 struct sas_phy
*phy
= dev_to_phy(rphy
->dev
.parent
);
583 struct Scsi_Host
*shost
= dev_to_shost(phy
->dev
.parent
);
584 struct sas_internal
*i
= to_sas_internal(shost
->transportt
);
587 if (phy
->local_attached
)
590 val
= i
->f
->get_bay_identifier(rphy
);
593 return sprintf(buf
, "%d\n", val
);
596 static SAS_CLASS_DEVICE_ATTR(rphy
, bay_identifier
, S_IRUGO
,
597 show_sas_rphy_bay_identifier
, NULL
);
599 sas_rphy_protocol_attr(identify
.initiator_port_protocols
,
600 initiator_port_protocols
);
601 sas_rphy_protocol_attr(identify
.target_port_protocols
, target_port_protocols
);
602 sas_rphy_simple_attr(identify
.sas_address
, sas_address
, "0x%016llx\n",
604 sas_rphy_simple_attr(identify
.phy_identifier
, phy_identifier
, "%d\n", u8
);
606 /* only need 8 bytes of data plus header (4 or 8) */
609 int sas_read_port_mode_page(struct scsi_device
*sdev
)
611 char *buffer
= kzalloc(BUF_SIZE
, GFP_KERNEL
), *msdata
;
612 struct sas_rphy
*rphy
= target_to_rphy(sdev
->sdev_target
);
613 struct sas_end_device
*rdev
;
614 struct scsi_mode_data mode_data
;
617 BUG_ON(rphy
->identify
.device_type
!= SAS_END_DEVICE
);
619 rdev
= rphy_to_end_device(rphy
);
624 res
= scsi_mode_sense(sdev
, 1, 0x19, buffer
, BUF_SIZE
, 30*HZ
, 3,
628 if (!scsi_status_is_good(res
))
631 msdata
= buffer
+ mode_data
.header_length
+
632 mode_data
.block_descriptor_length
;
634 if (msdata
- buffer
> BUF_SIZE
- 8)
639 rdev
->ready_led_meaning
= msdata
[2] & 0x10 ? 1 : 0;
640 rdev
->I_T_nexus_loss_timeout
= (msdata
[4] << 8) + msdata
[5];
641 rdev
->initiator_response_timeout
= (msdata
[6] << 8) + msdata
[7];
647 EXPORT_SYMBOL(sas_read_port_mode_page
);
649 static DECLARE_TRANSPORT_CLASS(sas_end_dev_class
,
650 "sas_end_device", NULL
, NULL
, NULL
);
652 #define sas_end_dev_show_simple(field, name, format_string, cast) \
654 show_sas_end_dev_##name(struct class_device *cdev, char *buf) \
656 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
657 struct sas_end_device *rdev = rphy_to_end_device(rphy); \
659 return snprintf(buf, 20, format_string, cast rdev->field); \
662 #define sas_end_dev_simple_attr(field, name, format_string, type) \
663 sas_end_dev_show_simple(field, name, format_string, (type)) \
664 static SAS_CLASS_DEVICE_ATTR(end_dev, name, S_IRUGO, \
665 show_sas_end_dev_##name, NULL)
667 sas_end_dev_simple_attr(ready_led_meaning
, ready_led_meaning
, "%d\n", int);
668 sas_end_dev_simple_attr(I_T_nexus_loss_timeout
, I_T_nexus_loss_timeout
,
670 sas_end_dev_simple_attr(initiator_response_timeout
, initiator_response_timeout
,
673 static DECLARE_TRANSPORT_CLASS(sas_expander_class
,
674 "sas_expander", NULL
, NULL
, NULL
);
676 #define sas_expander_show_simple(field, name, format_string, cast) \
678 show_sas_expander_##name(struct class_device *cdev, char *buf) \
680 struct sas_rphy *rphy = transport_class_to_rphy(cdev); \
681 struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
683 return snprintf(buf, 20, format_string, cast edev->field); \
686 #define sas_expander_simple_attr(field, name, format_string, type) \
687 sas_expander_show_simple(field, name, format_string, (type)) \
688 static SAS_CLASS_DEVICE_ATTR(expander, name, S_IRUGO, \
689 show_sas_expander_##name, NULL)
691 sas_expander_simple_attr(vendor_id
, vendor_id
, "%s\n", char *);
692 sas_expander_simple_attr(product_id
, product_id
, "%s\n", char *);
693 sas_expander_simple_attr(product_rev
, product_rev
, "%s\n", char *);
694 sas_expander_simple_attr(component_vendor_id
, component_vendor_id
,
696 sas_expander_simple_attr(component_id
, component_id
, "%u\n", unsigned int);
697 sas_expander_simple_attr(component_revision_id
, component_revision_id
, "%u\n",
699 sas_expander_simple_attr(level
, level
, "%d\n", int);
701 static DECLARE_TRANSPORT_CLASS(sas_rphy_class
,
702 "sas_device", NULL
, NULL
, NULL
);
704 static int sas_rphy_match(struct attribute_container
*cont
, struct device
*dev
)
706 struct Scsi_Host
*shost
;
707 struct sas_internal
*i
;
709 if (!scsi_is_sas_rphy(dev
))
711 shost
= dev_to_shost(dev
->parent
->parent
);
713 if (!shost
->transportt
)
715 if (shost
->transportt
->host_attrs
.ac
.class !=
716 &sas_host_class
.class)
719 i
= to_sas_internal(shost
->transportt
);
720 return &i
->rphy_attr_cont
.ac
== cont
;
723 static int sas_end_dev_match(struct attribute_container
*cont
,
726 struct Scsi_Host
*shost
;
727 struct sas_internal
*i
;
728 struct sas_rphy
*rphy
;
730 if (!scsi_is_sas_rphy(dev
))
732 shost
= dev_to_shost(dev
->parent
->parent
);
733 rphy
= dev_to_rphy(dev
);
735 if (!shost
->transportt
)
737 if (shost
->transportt
->host_attrs
.ac
.class !=
738 &sas_host_class
.class)
741 i
= to_sas_internal(shost
->transportt
);
742 return &i
->end_dev_attr_cont
.ac
== cont
&&
743 rphy
->identify
.device_type
== SAS_END_DEVICE
;
746 static int sas_expander_match(struct attribute_container
*cont
,
749 struct Scsi_Host
*shost
;
750 struct sas_internal
*i
;
751 struct sas_rphy
*rphy
;
753 if (!scsi_is_sas_rphy(dev
))
755 shost
= dev_to_shost(dev
->parent
->parent
);
756 rphy
= dev_to_rphy(dev
);
758 if (!shost
->transportt
)
760 if (shost
->transportt
->host_attrs
.ac
.class !=
761 &sas_host_class
.class)
764 i
= to_sas_internal(shost
->transportt
);
765 return &i
->expander_attr_cont
.ac
== cont
&&
766 (rphy
->identify
.device_type
== SAS_EDGE_EXPANDER_DEVICE
||
767 rphy
->identify
.device_type
== SAS_FANOUT_EXPANDER_DEVICE
);
770 static void sas_expander_release(struct device
*dev
)
772 struct sas_rphy
*rphy
= dev_to_rphy(dev
);
773 struct sas_expander_device
*edev
= rphy_to_expander_device(rphy
);
775 put_device(dev
->parent
);
779 static void sas_end_device_release(struct device
*dev
)
781 struct sas_rphy
*rphy
= dev_to_rphy(dev
);
782 struct sas_end_device
*edev
= rphy_to_end_device(rphy
);
784 put_device(dev
->parent
);
789 * sas_end_device_alloc - allocate an rphy for an end device
791 * Allocates an SAS remote PHY structure, connected to @parent.
794 * SAS PHY allocated or %NULL if the allocation failed.
796 struct sas_rphy
*sas_end_device_alloc(struct sas_phy
*parent
)
798 struct Scsi_Host
*shost
= dev_to_shost(&parent
->dev
);
799 struct sas_end_device
*rdev
;
801 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
803 put_device(&parent
->dev
);
807 device_initialize(&rdev
->rphy
.dev
);
808 rdev
->rphy
.dev
.parent
= get_device(&parent
->dev
);
809 rdev
->rphy
.dev
.release
= sas_end_device_release
;
810 sprintf(rdev
->rphy
.dev
.bus_id
, "end_device-%d:%d-%d",
811 shost
->host_no
, parent
->port_identifier
, parent
->number
);
812 rdev
->rphy
.identify
.device_type
= SAS_END_DEVICE
;
813 transport_setup_device(&rdev
->rphy
.dev
);
817 EXPORT_SYMBOL(sas_end_device_alloc
);
820 * sas_expander_alloc - allocate an rphy for an end device
822 * Allocates an SAS remote PHY structure, connected to @parent.
825 * SAS PHY allocated or %NULL if the allocation failed.
827 struct sas_rphy
*sas_expander_alloc(struct sas_phy
*parent
,
828 enum sas_device_type type
)
830 struct Scsi_Host
*shost
= dev_to_shost(&parent
->dev
);
831 struct sas_expander_device
*rdev
;
832 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
834 BUG_ON(type
!= SAS_EDGE_EXPANDER_DEVICE
&&
835 type
!= SAS_FANOUT_EXPANDER_DEVICE
);
837 rdev
= kzalloc(sizeof(*rdev
), GFP_KERNEL
);
839 put_device(&parent
->dev
);
843 device_initialize(&rdev
->rphy
.dev
);
844 rdev
->rphy
.dev
.parent
= get_device(&parent
->dev
);
845 rdev
->rphy
.dev
.release
= sas_expander_release
;
846 mutex_lock(&sas_host
->lock
);
847 rdev
->rphy
.scsi_target_id
= sas_host
->next_expander_id
++;
848 mutex_unlock(&sas_host
->lock
);
849 sprintf(rdev
->rphy
.dev
.bus_id
, "expander-%d:%d",
850 shost
->host_no
, rdev
->rphy
.scsi_target_id
);
851 rdev
->rphy
.identify
.device_type
= type
;
852 transport_setup_device(&rdev
->rphy
.dev
);
856 EXPORT_SYMBOL(sas_expander_alloc
);
859 * sas_rphy_add -- add a SAS remote PHY to the device hierachy
860 * @rphy: The remote PHY to be added
862 * Publishes a SAS remote PHY to the rest of the system.
864 int sas_rphy_add(struct sas_rphy
*rphy
)
866 struct sas_phy
*parent
= dev_to_phy(rphy
->dev
.parent
);
867 struct Scsi_Host
*shost
= dev_to_shost(parent
->dev
.parent
);
868 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
869 struct sas_identify
*identify
= &rphy
->identify
;
876 error
= device_add(&rphy
->dev
);
879 transport_add_device(&rphy
->dev
);
880 transport_configure_device(&rphy
->dev
);
882 mutex_lock(&sas_host
->lock
);
883 list_add_tail(&rphy
->list
, &sas_host
->rphy_list
);
884 if (identify
->device_type
== SAS_END_DEVICE
&&
885 (identify
->target_port_protocols
&
886 (SAS_PROTOCOL_SSP
|SAS_PROTOCOL_STP
|SAS_PROTOCOL_SATA
)))
887 rphy
->scsi_target_id
= sas_host
->next_target_id
++;
888 mutex_unlock(&sas_host
->lock
);
890 if (identify
->device_type
== SAS_END_DEVICE
&&
891 rphy
->scsi_target_id
!= -1) {
892 scsi_scan_target(&rphy
->dev
, parent
->port_identifier
,
893 rphy
->scsi_target_id
, ~0, 0);
898 EXPORT_SYMBOL(sas_rphy_add
);
901 * sas_rphy_free -- free a SAS remote PHY
902 * @rphy SAS remote PHY to free
904 * Frees the specified SAS remote PHY.
907 * This function must only be called on a remote
908 * PHY that has not sucessfully been added using
911 void sas_rphy_free(struct sas_rphy
*rphy
)
913 struct Scsi_Host
*shost
= dev_to_shost(rphy
->dev
.parent
->parent
);
914 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
916 mutex_lock(&sas_host
->lock
);
917 list_del(&rphy
->list
);
918 mutex_unlock(&sas_host
->lock
);
920 transport_destroy_device(&rphy
->dev
);
921 put_device(rphy
->dev
.parent
);
922 put_device(rphy
->dev
.parent
);
923 put_device(rphy
->dev
.parent
);
924 if (rphy
->identify
.device_type
== SAS_END_DEVICE
) {
925 struct sas_end_device
*edev
= rphy_to_end_device(rphy
);
929 /* must be expander */
930 struct sas_expander_device
*edev
=
931 rphy_to_expander_device(rphy
);
936 EXPORT_SYMBOL(sas_rphy_free
);
939 * sas_rphy_delete -- remove SAS remote PHY
940 * @rphy: SAS remote PHY to remove
942 * Removes the specified SAS remote PHY.
945 sas_rphy_delete(struct sas_rphy
*rphy
)
947 struct device
*dev
= &rphy
->dev
;
948 struct sas_phy
*parent
= dev_to_phy(dev
->parent
);
949 struct Scsi_Host
*shost
= dev_to_shost(parent
->dev
.parent
);
950 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
952 switch (rphy
->identify
.device_type
) {
954 scsi_remove_target(dev
);
956 case SAS_EDGE_EXPANDER_DEVICE
:
957 case SAS_FANOUT_EXPANDER_DEVICE
:
958 device_for_each_child(dev
, NULL
, do_sas_phy_delete
);
964 transport_remove_device(dev
);
966 transport_destroy_device(dev
);
968 mutex_lock(&sas_host
->lock
);
969 list_del(&rphy
->list
);
970 mutex_unlock(&sas_host
->lock
);
974 put_device(&parent
->dev
);
976 EXPORT_SYMBOL(sas_rphy_delete
);
979 * scsi_is_sas_rphy -- check if a struct device represents a SAS remote PHY
980 * @dev: device to check
983 * %1 if the device represents a SAS remote PHY, %0 else
985 int scsi_is_sas_rphy(const struct device
*dev
)
987 return dev
->release
== sas_end_device_release
||
988 dev
->release
== sas_expander_release
;
990 EXPORT_SYMBOL(scsi_is_sas_rphy
);
997 static int sas_user_scan(struct Scsi_Host
*shost
, uint channel
,
1000 struct sas_host_attrs
*sas_host
= to_sas_host_attrs(shost
);
1001 struct sas_rphy
*rphy
;
1003 mutex_lock(&sas_host
->lock
);
1004 list_for_each_entry(rphy
, &sas_host
->rphy_list
, list
) {
1005 struct sas_phy
*parent
= dev_to_phy(rphy
->dev
.parent
);
1007 if (rphy
->scsi_target_id
== -1)
1010 if ((channel
== SCAN_WILD_CARD
|| channel
== parent
->port_identifier
) &&
1011 (id
== SCAN_WILD_CARD
|| id
== rphy
->scsi_target_id
)) {
1012 scsi_scan_target(&rphy
->dev
, parent
->port_identifier
,
1013 rphy
->scsi_target_id
, lun
, 1);
1016 mutex_unlock(&sas_host
->lock
);
1023 * Setup / Teardown code
1026 #define SETUP_TEMPLATE(attrb, field, perm, test) \
1027 i->private_##attrb[count] = class_device_attr_##field; \
1028 i->private_##attrb[count].attr.mode = perm; \
1029 i->private_##attrb[count].store = NULL; \
1030 i->attrb[count] = &i->private_##attrb[count]; \
1035 #define SETUP_RPORT_ATTRIBUTE(field) \
1036 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, 1)
1038 #define SETUP_OPTIONAL_RPORT_ATTRIBUTE(field, func) \
1039 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, i->f->func)
1041 #define SETUP_PORT_ATTRIBUTE(field) \
1042 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, 1)
1044 #define SETUP_OPTIONAL_PORT_ATTRIBUTE(field, func) \
1045 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, i->f->func)
1047 #define SETUP_PORT_ATTRIBUTE_WRONLY(field) \
1048 SETUP_TEMPLATE(phy_attrs, field, S_IWUGO, 1)
1050 #define SETUP_OPTIONAL_PORT_ATTRIBUTE_WRONLY(field, func) \
1051 SETUP_TEMPLATE(phy_attrs, field, S_IWUGO, i->f->func)
1053 #define SETUP_END_DEV_ATTRIBUTE(field) \
1054 SETUP_TEMPLATE(end_dev_attrs, field, S_IRUGO, 1)
1056 #define SETUP_EXPANDER_ATTRIBUTE(field) \
1057 SETUP_TEMPLATE(expander_attrs, expander_##field, S_IRUGO, 1)
1060 * sas_attach_transport -- instantiate SAS transport template
1061 * @ft: SAS transport class function template
1063 struct scsi_transport_template
*
1064 sas_attach_transport(struct sas_function_template
*ft
)
1066 struct sas_internal
*i
;
1069 i
= kzalloc(sizeof(struct sas_internal
), GFP_KERNEL
);
1073 i
->t
.user_scan
= sas_user_scan
;
1075 i
->t
.host_attrs
.ac
.attrs
= &i
->host_attrs
[0];
1076 i
->t
.host_attrs
.ac
.class = &sas_host_class
.class;
1077 i
->t
.host_attrs
.ac
.match
= sas_host_match
;
1078 transport_container_register(&i
->t
.host_attrs
);
1079 i
->t
.host_size
= sizeof(struct sas_host_attrs
);
1081 i
->phy_attr_cont
.ac
.class = &sas_phy_class
.class;
1082 i
->phy_attr_cont
.ac
.attrs
= &i
->phy_attrs
[0];
1083 i
->phy_attr_cont
.ac
.match
= sas_phy_match
;
1084 transport_container_register(&i
->phy_attr_cont
);
1086 i
->rphy_attr_cont
.ac
.class = &sas_rphy_class
.class;
1087 i
->rphy_attr_cont
.ac
.attrs
= &i
->rphy_attrs
[0];
1088 i
->rphy_attr_cont
.ac
.match
= sas_rphy_match
;
1089 transport_container_register(&i
->rphy_attr_cont
);
1091 i
->end_dev_attr_cont
.ac
.class = &sas_end_dev_class
.class;
1092 i
->end_dev_attr_cont
.ac
.attrs
= &i
->end_dev_attrs
[0];
1093 i
->end_dev_attr_cont
.ac
.match
= sas_end_dev_match
;
1094 transport_container_register(&i
->end_dev_attr_cont
);
1096 i
->expander_attr_cont
.ac
.class = &sas_expander_class
.class;
1097 i
->expander_attr_cont
.ac
.attrs
= &i
->expander_attrs
[0];
1098 i
->expander_attr_cont
.ac
.match
= sas_expander_match
;
1099 transport_container_register(&i
->expander_attr_cont
);
1104 i
->host_attrs
[count
] = NULL
;
1107 SETUP_PORT_ATTRIBUTE(initiator_port_protocols
);
1108 SETUP_PORT_ATTRIBUTE(target_port_protocols
);
1109 SETUP_PORT_ATTRIBUTE(device_type
);
1110 SETUP_PORT_ATTRIBUTE(sas_address
);
1111 SETUP_PORT_ATTRIBUTE(phy_identifier
);
1112 SETUP_PORT_ATTRIBUTE(port_identifier
);
1113 SETUP_PORT_ATTRIBUTE(negotiated_linkrate
);
1114 SETUP_PORT_ATTRIBUTE(minimum_linkrate_hw
);
1115 SETUP_PORT_ATTRIBUTE(minimum_linkrate
);
1116 SETUP_PORT_ATTRIBUTE(maximum_linkrate_hw
);
1117 SETUP_PORT_ATTRIBUTE(maximum_linkrate
);
1119 SETUP_PORT_ATTRIBUTE(invalid_dword_count
);
1120 SETUP_PORT_ATTRIBUTE(running_disparity_error_count
);
1121 SETUP_PORT_ATTRIBUTE(loss_of_dword_sync_count
);
1122 SETUP_PORT_ATTRIBUTE(phy_reset_problem_count
);
1123 SETUP_OPTIONAL_PORT_ATTRIBUTE_WRONLY(link_reset
, phy_reset
);
1124 SETUP_OPTIONAL_PORT_ATTRIBUTE_WRONLY(hard_reset
, phy_reset
);
1125 i
->phy_attrs
[count
] = NULL
;
1128 SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols
);
1129 SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols
);
1130 SETUP_RPORT_ATTRIBUTE(rphy_device_type
);
1131 SETUP_RPORT_ATTRIBUTE(rphy_sas_address
);
1132 SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier
);
1133 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_enclosure_identifier
,
1134 get_enclosure_identifier
);
1135 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_bay_identifier
,
1136 get_bay_identifier
);
1137 i
->rphy_attrs
[count
] = NULL
;
1140 SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning
);
1141 SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout
);
1142 SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout
);
1143 i
->end_dev_attrs
[count
] = NULL
;
1146 SETUP_EXPANDER_ATTRIBUTE(vendor_id
);
1147 SETUP_EXPANDER_ATTRIBUTE(product_id
);
1148 SETUP_EXPANDER_ATTRIBUTE(product_rev
);
1149 SETUP_EXPANDER_ATTRIBUTE(component_vendor_id
);
1150 SETUP_EXPANDER_ATTRIBUTE(component_id
);
1151 SETUP_EXPANDER_ATTRIBUTE(component_revision_id
);
1152 SETUP_EXPANDER_ATTRIBUTE(level
);
1153 i
->expander_attrs
[count
] = NULL
;
1157 EXPORT_SYMBOL(sas_attach_transport
);
1160 * sas_release_transport -- release SAS transport template instance
1161 * @t: transport template instance
1163 void sas_release_transport(struct scsi_transport_template
*t
)
1165 struct sas_internal
*i
= to_sas_internal(t
);
1167 transport_container_unregister(&i
->t
.host_attrs
);
1168 transport_container_unregister(&i
->phy_attr_cont
);
1169 transport_container_unregister(&i
->rphy_attr_cont
);
1170 transport_container_unregister(&i
->end_dev_attr_cont
);
1171 transport_container_unregister(&i
->expander_attr_cont
);
1175 EXPORT_SYMBOL(sas_release_transport
);
1177 static __init
int sas_transport_init(void)
1181 error
= transport_class_register(&sas_host_class
);
1184 error
= transport_class_register(&sas_phy_class
);
1186 goto out_unregister_transport
;
1187 error
= transport_class_register(&sas_rphy_class
);
1189 goto out_unregister_phy
;
1190 error
= transport_class_register(&sas_end_dev_class
);
1192 goto out_unregister_rphy
;
1193 error
= transport_class_register(&sas_expander_class
);
1195 goto out_unregister_end_dev
;
1199 out_unregister_end_dev
:
1200 transport_class_unregister(&sas_end_dev_class
);
1201 out_unregister_rphy
:
1202 transport_class_unregister(&sas_rphy_class
);
1204 transport_class_unregister(&sas_phy_class
);
1205 out_unregister_transport
:
1206 transport_class_unregister(&sas_host_class
);
1212 static void __exit
sas_transport_exit(void)
1214 transport_class_unregister(&sas_host_class
);
1215 transport_class_unregister(&sas_phy_class
);
1216 transport_class_unregister(&sas_rphy_class
);
1217 transport_class_unregister(&sas_end_dev_class
);
1218 transport_class_unregister(&sas_expander_class
);
1221 MODULE_AUTHOR("Christoph Hellwig");
1222 MODULE_DESCRIPTION("SAS Transphy Attributes");
1223 MODULE_LICENSE("GPL");
1225 module_init(sas_transport_init
);
1226 module_exit(sas_transport_exit
);