1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2005-2006 Dell Inc.
4 *
5 * Serial Attached SCSI (SAS) transport class.
6 *
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 management
10 * interfaces to userspace.
11 *
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
19 * the same.
20 *
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.
24 */
25
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>
32 #include <linux/blkdev.h>
33 #include <linux/bsg.h>
34
35 #include <scsi/scsi.h>
36 #include <scsi/scsi_cmnd.h>
37 #include <scsi/scsi_device.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_transport.h>
40 #include <scsi/scsi_transport_sas.h>
41
42 #include "scsi_sas_internal.h"
43 struct sas_host_attrs {
44 struct list_head rphy_list;
45 struct mutex lock;
46 struct request_queue *q;
47 u32 next_target_id;
48 u32 next_expander_id;
49 int next_port_id;
50 };
51 #define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
52
53
54 /*
55 * Hack to allow attributes of the same name in different objects.
56 */
57 #define SAS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
58 struct device_attribute dev_attr_##_prefix##_##_name = \
59 __ATTR(_name,_mode,_show,_store)
60
61
62 /*
63 * Pretty printing helpers
64 */
65
66 #define sas_bitfield_name_match(title, table) \
67 static ssize_t \
68 get_sas_##title##_names(u32 table_key, char *buf) \
69 { \
70 char *prefix = ""; \
71 ssize_t len = 0; \
72 int i; \
73 \
74 for (i = 0; i < ARRAY_SIZE(table); i++) { \
75 if (table[i].value & table_key) { \
76 len += sprintf(buf + len, "%s%s", \
77 prefix, table[i].name); \
78 prefix = ", "; \
79 } \
80 } \
81 len += sprintf(buf + len, "\n"); \
82 return len; \
83 }
84
85 #define sas_bitfield_name_set(title, table) \
86 static ssize_t \
87 set_sas_##title##_names(u32 *table_key, const char *buf) \
88 { \
89 ssize_t len = 0; \
90 int i; \
91 \
92 for (i = 0; i < ARRAY_SIZE(table); i++) { \
93 len = strlen(table[i].name); \
94 if (strncmp(buf, table[i].name, len) == 0 && \
95 (buf[len] == '\n' || buf[len] == '\0')) { \
96 *table_key = table[i].value; \
97 return 0; \
98 } \
99 } \
100 return -EINVAL; \
101 }
102
103 #define sas_bitfield_name_search(title, table) \
104 static ssize_t \
105 get_sas_##title##_names(u32 table_key, char *buf) \
106 { \
107 ssize_t len = 0; \
108 int i; \
109 \
110 for (i = 0; i < ARRAY_SIZE(table); i++) { \
111 if (table[i].value == table_key) { \
112 len += sprintf(buf + len, "%s", \
113 table[i].name); \
114 break; \
115 } \
116 } \
117 len += sprintf(buf + len, "\n"); \
118 return len; \
119 }
120
121 static struct {
122 u32 value;
123 char *name;
124 } sas_device_type_names[] = {
125 { SAS_PHY_UNUSED, "unused" },
126 { SAS_END_DEVICE, "end device" },
127 { SAS_EDGE_EXPANDER_DEVICE, "edge expander" },
128 { SAS_FANOUT_EXPANDER_DEVICE, "fanout expander" },
129 };
130 sas_bitfield_name_search(device_type, sas_device_type_names)
131
132
133 static struct {
134 u32 value;
135 char *name;
136 } sas_protocol_names[] = {
137 { SAS_PROTOCOL_SATA, "sata" },
138 { SAS_PROTOCOL_SMP, "smp" },
139 { SAS_PROTOCOL_STP, "stp" },
140 { SAS_PROTOCOL_SSP, "ssp" },
141 };
142 sas_bitfield_name_match(protocol, sas_protocol_names)
143
144 static struct {
145 u32 value;
146 char *name;
147 } sas_linkspeed_names[] = {
148 { SAS_LINK_RATE_UNKNOWN, "Unknown" },
149 { SAS_PHY_DISABLED, "Phy disabled" },
150 { SAS_LINK_RATE_FAILED, "Link Rate failed" },
151 { SAS_SATA_SPINUP_HOLD, "Spin-up hold" },
152 { SAS_LINK_RATE_1_5_GBPS, "1.5 Gbit" },
153 { SAS_LINK_RATE_3_0_GBPS, "3.0 Gbit" },
154 { SAS_LINK_RATE_6_0_GBPS, "6.0 Gbit" },
155 { SAS_LINK_RATE_12_0_GBPS, "12.0 Gbit" },
156 { SAS_LINK_RATE_22_5_GBPS, "22.5 Gbit" },
157 };
sas_bitfield_name_search(linkspeed,sas_linkspeed_names)158 sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
159 sas_bitfield_name_set(linkspeed, sas_linkspeed_names)
160
161 static struct sas_end_device *sas_sdev_to_rdev(struct scsi_device *sdev)
162 {
163 struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
164 struct sas_end_device *rdev;
165
166 BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
167
168 rdev = rphy_to_end_device(rphy);
169 return rdev;
170 }
171
sas_smp_dispatch(struct bsg_job * job)172 static int sas_smp_dispatch(struct bsg_job *job)
173 {
174 struct Scsi_Host *shost = dev_to_shost(job->dev);
175 struct sas_rphy *rphy = NULL;
176
177 if (!scsi_is_host_device(job->dev))
178 rphy = dev_to_rphy(job->dev);
179
180 if (!job->reply_payload.payload_len) {
181 dev_warn(job->dev, "space for a smp response is missing\n");
182 bsg_job_done(job, -EINVAL, 0);
183 return 0;
184 }
185
186 to_sas_internal(shost->transportt)->f->smp_handler(job, shost, rphy);
187 return 0;
188 }
189
sas_bsg_initialize(struct Scsi_Host * shost,struct sas_rphy * rphy)190 static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
191 {
192 struct request_queue *q;
193
194 if (!to_sas_internal(shost->transportt)->f->smp_handler) {
195 printk("%s can't handle SMP requests\n", shost->hostt->name);
196 return 0;
197 }
198
199 if (rphy) {
200 q = bsg_setup_queue(&rphy->dev, dev_name(&rphy->dev), NULL,
201 sas_smp_dispatch, NULL, 0);
202 if (IS_ERR(q))
203 return PTR_ERR(q);
204 rphy->q = q;
205 } else {
206 char name[20];
207
208 snprintf(name, sizeof(name), "sas_host%d", shost->host_no);
209 q = bsg_setup_queue(&shost->shost_gendev, name, NULL,
210 sas_smp_dispatch, NULL, 0);
211 if (IS_ERR(q))
212 return PTR_ERR(q);
213 to_sas_host_attrs(shost)->q = q;
214 }
215
216 return 0;
217 }
218
219 /*
220 * SAS host attributes
221 */
222
sas_host_setup(struct transport_container * tc,struct device * dev,struct device * cdev)223 static int sas_host_setup(struct transport_container *tc, struct device *dev,
224 struct device *cdev)
225 {
226 struct Scsi_Host *shost = dev_to_shost(dev);
227 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
228 struct device *dma_dev = shost->dma_dev;
229
230 INIT_LIST_HEAD(&sas_host->rphy_list);
231 mutex_init(&sas_host->lock);
232 sas_host->next_target_id = 0;
233 sas_host->next_expander_id = 0;
234 sas_host->next_port_id = 0;
235
236 if (sas_bsg_initialize(shost, NULL))
237 dev_printk(KERN_ERR, dev, "fail to a bsg device %d\n",
238 shost->host_no);
239
240 if (dma_dev->dma_mask) {
241 shost->opt_sectors = min_t(unsigned int, shost->max_sectors,
242 dma_opt_mapping_size(dma_dev) >> SECTOR_SHIFT);
243 }
244
245 return 0;
246 }
247
sas_host_remove(struct transport_container * tc,struct device * dev,struct device * cdev)248 static int sas_host_remove(struct transport_container *tc, struct device *dev,
249 struct device *cdev)
250 {
251 struct Scsi_Host *shost = dev_to_shost(dev);
252 struct request_queue *q = to_sas_host_attrs(shost)->q;
253
254 bsg_remove_queue(q);
255 return 0;
256 }
257
258 static DECLARE_TRANSPORT_CLASS(sas_host_class,
259 "sas_host", sas_host_setup, sas_host_remove, NULL);
260
sas_host_match(struct attribute_container * cont,struct device * dev)261 static int sas_host_match(struct attribute_container *cont,
262 struct device *dev)
263 {
264 struct Scsi_Host *shost;
265 struct sas_internal *i;
266
267 if (!scsi_is_host_device(dev))
268 return 0;
269 shost = dev_to_shost(dev);
270
271 if (!shost->transportt)
272 return 0;
273 if (shost->transportt->host_attrs.ac.class !=
274 &sas_host_class.class)
275 return 0;
276
277 i = to_sas_internal(shost->transportt);
278 return &i->t.host_attrs.ac == cont;
279 }
280
do_sas_phy_delete(struct device * dev,void * data)281 static int do_sas_phy_delete(struct device *dev, void *data)
282 {
283 int pass = (int)(unsigned long)data;
284
285 if (pass == 0 && scsi_is_sas_port(dev))
286 sas_port_delete(dev_to_sas_port(dev));
287 else if (pass == 1 && scsi_is_sas_phy(dev))
288 sas_phy_delete(dev_to_phy(dev));
289 return 0;
290 }
291
292 /**
293 * sas_remove_children - tear down a devices SAS data structures
294 * @dev: device belonging to the sas object
295 *
296 * Removes all SAS PHYs and remote PHYs for a given object
297 */
sas_remove_children(struct device * dev)298 void sas_remove_children(struct device *dev)
299 {
300 device_for_each_child(dev, (void *)0, do_sas_phy_delete);
301 device_for_each_child(dev, (void *)1, do_sas_phy_delete);
302 }
303 EXPORT_SYMBOL(sas_remove_children);
304
305 /**
306 * sas_remove_host - tear down a Scsi_Host's SAS data structures
307 * @shost: Scsi Host that is torn down
308 *
309 * Removes all SAS PHYs and remote PHYs for a given Scsi_Host and remove the
310 * Scsi_Host as well.
311 *
312 * Note: Do not call scsi_remove_host() on the Scsi_Host any more, as it is
313 * already removed.
314 */
sas_remove_host(struct Scsi_Host * shost)315 void sas_remove_host(struct Scsi_Host *shost)
316 {
317 sas_remove_children(&shost->shost_gendev);
318 scsi_remove_host(shost);
319 }
320 EXPORT_SYMBOL(sas_remove_host);
321
322 /**
323 * sas_get_address - return the SAS address of the device
324 * @sdev: scsi device
325 *
326 * Returns the SAS address of the scsi device
327 */
sas_get_address(struct scsi_device * sdev)328 u64 sas_get_address(struct scsi_device *sdev)
329 {
330 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
331
332 return rdev->rphy.identify.sas_address;
333 }
334 EXPORT_SYMBOL(sas_get_address);
335
336 /**
337 * sas_tlr_supported - checking TLR bit in vpd 0x90
338 * @sdev: scsi device struct
339 *
340 * Check Transport Layer Retries are supported or not.
341 * If vpd page 0x90 is present, TRL is supported.
342 *
343 */
344 unsigned int
sas_tlr_supported(struct scsi_device * sdev)345 sas_tlr_supported(struct scsi_device *sdev)
346 {
347 const int vpd_len = 32;
348 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
349 char *buffer = kzalloc(vpd_len, GFP_KERNEL);
350 int ret = 0;
351
352 if (!buffer)
353 goto out;
354
355 if (scsi_get_vpd_page(sdev, 0x90, buffer, vpd_len))
356 goto out;
357
358 /*
359 * Magic numbers: the VPD Protocol page (0x90)
360 * has a 4 byte header and then one entry per device port
361 * the TLR bit is at offset 8 on each port entry
362 * if we take the first port, that's at total offset 12
363 */
364 ret = buffer[12] & 0x01;
365
366 out:
367 kfree(buffer);
368 rdev->tlr_supported = ret;
369 return ret;
370
371 }
372 EXPORT_SYMBOL_GPL(sas_tlr_supported);
373
374 /**
375 * sas_disable_tlr - setting TLR flags
376 * @sdev: scsi device struct
377 *
378 * Seting tlr_enabled flag to 0.
379 *
380 */
381 void
sas_disable_tlr(struct scsi_device * sdev)382 sas_disable_tlr(struct scsi_device *sdev)
383 {
384 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
385
386 rdev->tlr_enabled = 0;
387 }
388 EXPORT_SYMBOL_GPL(sas_disable_tlr);
389
390 /**
391 * sas_enable_tlr - setting TLR flags
392 * @sdev: scsi device struct
393 *
394 * Seting tlr_enabled flag 1.
395 *
396 */
sas_enable_tlr(struct scsi_device * sdev)397 void sas_enable_tlr(struct scsi_device *sdev)
398 {
399 unsigned int tlr_supported = 0;
400 tlr_supported = sas_tlr_supported(sdev);
401
402 if (tlr_supported) {
403 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
404
405 rdev->tlr_enabled = 1;
406 }
407
408 return;
409 }
410 EXPORT_SYMBOL_GPL(sas_enable_tlr);
411
sas_is_tlr_enabled(struct scsi_device * sdev)412 unsigned int sas_is_tlr_enabled(struct scsi_device *sdev)
413 {
414 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
415 return rdev->tlr_enabled;
416 }
417 EXPORT_SYMBOL_GPL(sas_is_tlr_enabled);
418
419 /**
420 * sas_ata_ncq_prio_supported - Check for ATA NCQ command priority support
421 * @sdev: SCSI device
422 *
423 * Check if an ATA device supports NCQ priority using VPD page 89h (ATA
424 * Information). Since this VPD page is implemented only for ATA devices,
425 * this function always returns false for SCSI devices.
426 */
sas_ata_ncq_prio_supported(struct scsi_device * sdev)427 bool sas_ata_ncq_prio_supported(struct scsi_device *sdev)
428 {
429 struct scsi_vpd *vpd;
430 bool ncq_prio_supported = false;
431
432 rcu_read_lock();
433 vpd = rcu_dereference(sdev->vpd_pg89);
434 if (vpd && vpd->len >= 214)
435 ncq_prio_supported = (vpd->data[213] >> 4) & 1;
436 rcu_read_unlock();
437
438 return ncq_prio_supported;
439 }
440 EXPORT_SYMBOL_GPL(sas_ata_ncq_prio_supported);
441
442 /*
443 * SAS Phy attributes
444 */
445
446 #define sas_phy_show_simple(field, name, format_string, cast) \
447 static ssize_t \
448 show_sas_phy_##name(struct device *dev, \
449 struct device_attribute *attr, char *buf) \
450 { \
451 struct sas_phy *phy = transport_class_to_phy(dev); \
452 \
453 return snprintf(buf, 20, format_string, cast phy->field); \
454 }
455
456 #define sas_phy_simple_attr(field, name, format_string, type) \
457 sas_phy_show_simple(field, name, format_string, (type)) \
458 static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
459
460 #define sas_phy_show_protocol(field, name) \
461 static ssize_t \
462 show_sas_phy_##name(struct device *dev, \
463 struct device_attribute *attr, char *buf) \
464 { \
465 struct sas_phy *phy = transport_class_to_phy(dev); \
466 \
467 if (!phy->field) \
468 return snprintf(buf, 20, "none\n"); \
469 return get_sas_protocol_names(phy->field, buf); \
470 }
471
472 #define sas_phy_protocol_attr(field, name) \
473 sas_phy_show_protocol(field, name) \
474 static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
475
476 #define sas_phy_show_linkspeed(field) \
477 static ssize_t \
478 show_sas_phy_##field(struct device *dev, \
479 struct device_attribute *attr, char *buf) \
480 { \
481 struct sas_phy *phy = transport_class_to_phy(dev); \
482 \
483 return get_sas_linkspeed_names(phy->field, buf); \
484 }
485
486 /* Fudge to tell if we're minimum or maximum */
487 #define sas_phy_store_linkspeed(field) \
488 static ssize_t \
489 store_sas_phy_##field(struct device *dev, \
490 struct device_attribute *attr, \
491 const char *buf, size_t count) \
492 { \
493 struct sas_phy *phy = transport_class_to_phy(dev); \
494 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
495 struct sas_internal *i = to_sas_internal(shost->transportt); \
496 u32 value; \
497 struct sas_phy_linkrates rates = {0}; \
498 int error; \
499 \
500 error = set_sas_linkspeed_names(&value, buf); \
501 if (error) \
502 return error; \
503 rates.field = value; \
504 error = i->f->set_phy_speed(phy, &rates); \
505 \
506 return error ? error : count; \
507 }
508
509 #define sas_phy_linkspeed_rw_attr(field) \
510 sas_phy_show_linkspeed(field) \
511 sas_phy_store_linkspeed(field) \
512 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, \
513 store_sas_phy_##field)
514
515 #define sas_phy_linkspeed_attr(field) \
516 sas_phy_show_linkspeed(field) \
517 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
518
519
520 #define sas_phy_show_linkerror(field) \
521 static ssize_t \
522 show_sas_phy_##field(struct device *dev, \
523 struct device_attribute *attr, char *buf) \
524 { \
525 struct sas_phy *phy = transport_class_to_phy(dev); \
526 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
527 struct sas_internal *i = to_sas_internal(shost->transportt); \
528 int error; \
529 \
530 error = i->f->get_linkerrors ? i->f->get_linkerrors(phy) : 0; \
531 if (error) \
532 return error; \
533 return snprintf(buf, 20, "%u\n", phy->field); \
534 }
535
536 #define sas_phy_linkerror_attr(field) \
537 sas_phy_show_linkerror(field) \
538 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
539
540
541 static ssize_t
show_sas_device_type(struct device * dev,struct device_attribute * attr,char * buf)542 show_sas_device_type(struct device *dev,
543 struct device_attribute *attr, char *buf)
544 {
545 struct sas_phy *phy = transport_class_to_phy(dev);
546
547 if (!phy->identify.device_type)
548 return snprintf(buf, 20, "none\n");
549 return get_sas_device_type_names(phy->identify.device_type, buf);
550 }
551 static DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
552
do_sas_phy_enable(struct device * dev,size_t count,int enable)553 static ssize_t do_sas_phy_enable(struct device *dev,
554 size_t count, int enable)
555 {
556 struct sas_phy *phy = transport_class_to_phy(dev);
557 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
558 struct sas_internal *i = to_sas_internal(shost->transportt);
559 int error;
560
561 error = i->f->phy_enable(phy, enable);
562 if (error)
563 return error;
564 phy->enabled = enable;
565 return count;
566 };
567
568 static ssize_t
store_sas_phy_enable(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)569 store_sas_phy_enable(struct device *dev, struct device_attribute *attr,
570 const char *buf, size_t count)
571 {
572 if (count < 1)
573 return -EINVAL;
574
575 switch (buf[0]) {
576 case '0':
577 do_sas_phy_enable(dev, count, 0);
578 break;
579 case '1':
580 do_sas_phy_enable(dev, count, 1);
581 break;
582 default:
583 return -EINVAL;
584 }
585
586 return count;
587 }
588
589 static ssize_t
show_sas_phy_enable(struct device * dev,struct device_attribute * attr,char * buf)590 show_sas_phy_enable(struct device *dev, struct device_attribute *attr,
591 char *buf)
592 {
593 struct sas_phy *phy = transport_class_to_phy(dev);
594
595 return snprintf(buf, 20, "%d\n", phy->enabled);
596 }
597
598 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable,
599 store_sas_phy_enable);
600
601 static ssize_t
do_sas_phy_reset(struct device * dev,size_t count,int hard_reset)602 do_sas_phy_reset(struct device *dev, size_t count, int hard_reset)
603 {
604 struct sas_phy *phy = transport_class_to_phy(dev);
605 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
606 struct sas_internal *i = to_sas_internal(shost->transportt);
607 int error;
608
609 error = i->f->phy_reset(phy, hard_reset);
610 if (error)
611 return error;
612 phy->enabled = 1;
613 return count;
614 };
615
616 static ssize_t
store_sas_link_reset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)617 store_sas_link_reset(struct device *dev, struct device_attribute *attr,
618 const char *buf, size_t count)
619 {
620 return do_sas_phy_reset(dev, count, 0);
621 }
622 static DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset);
623
624 static ssize_t
store_sas_hard_reset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)625 store_sas_hard_reset(struct device *dev, struct device_attribute *attr,
626 const char *buf, size_t count)
627 {
628 return do_sas_phy_reset(dev, count, 1);
629 }
630 static DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset);
631
632 sas_phy_protocol_attr(identify.initiator_port_protocols,
633 initiator_port_protocols);
634 sas_phy_protocol_attr(identify.target_port_protocols,
635 target_port_protocols);
636 sas_phy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
637 unsigned long long);
638 sas_phy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
639 sas_phy_linkspeed_attr(negotiated_linkrate);
640 sas_phy_linkspeed_attr(minimum_linkrate_hw);
641 sas_phy_linkspeed_rw_attr(minimum_linkrate);
642 sas_phy_linkspeed_attr(maximum_linkrate_hw);
643 sas_phy_linkspeed_rw_attr(maximum_linkrate);
644 sas_phy_linkerror_attr(invalid_dword_count);
645 sas_phy_linkerror_attr(running_disparity_error_count);
646 sas_phy_linkerror_attr(loss_of_dword_sync_count);
647 sas_phy_linkerror_attr(phy_reset_problem_count);
648
sas_phy_setup(struct transport_container * tc,struct device * dev,struct device * cdev)649 static int sas_phy_setup(struct transport_container *tc, struct device *dev,
650 struct device *cdev)
651 {
652 struct sas_phy *phy = dev_to_phy(dev);
653 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
654 struct sas_internal *i = to_sas_internal(shost->transportt);
655
656 if (i->f->phy_setup)
657 i->f->phy_setup(phy);
658
659 return 0;
660 }
661
662 static DECLARE_TRANSPORT_CLASS(sas_phy_class,
663 "sas_phy", sas_phy_setup, NULL, NULL);
664
sas_phy_match(struct attribute_container * cont,struct device * dev)665 static int sas_phy_match(struct attribute_container *cont, struct device *dev)
666 {
667 struct Scsi_Host *shost;
668 struct sas_internal *i;
669
670 if (!scsi_is_sas_phy(dev))
671 return 0;
672 shost = dev_to_shost(dev->parent);
673
674 if (!shost->transportt)
675 return 0;
676 if (shost->transportt->host_attrs.ac.class !=
677 &sas_host_class.class)
678 return 0;
679
680 i = to_sas_internal(shost->transportt);
681 return &i->phy_attr_cont.ac == cont;
682 }
683
sas_phy_release(struct device * dev)684 static void sas_phy_release(struct device *dev)
685 {
686 struct sas_phy *phy = dev_to_phy(dev);
687 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
688 struct sas_internal *i = to_sas_internal(shost->transportt);
689
690 if (i->f->phy_release)
691 i->f->phy_release(phy);
692 put_device(dev->parent);
693 kfree(phy);
694 }
695
696 /**
697 * sas_phy_alloc - allocates and initialize a SAS PHY structure
698 * @parent: Parent device
699 * @number: Phy index
700 *
701 * Allocates an SAS PHY structure. It will be added in the device tree
702 * below the device specified by @parent, which has to be either a Scsi_Host
703 * or sas_rphy.
704 *
705 * Returns:
706 * SAS PHY allocated or %NULL if the allocation failed.
707 */
sas_phy_alloc(struct device * parent,int number)708 struct sas_phy *sas_phy_alloc(struct device *parent, int number)
709 {
710 struct Scsi_Host *shost = dev_to_shost(parent);
711 struct sas_phy *phy;
712
713 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
714 if (!phy)
715 return NULL;
716
717 phy->number = number;
718 phy->enabled = 1;
719
720 device_initialize(&phy->dev);
721 phy->dev.parent = get_device(parent);
722 phy->dev.release = sas_phy_release;
723 INIT_LIST_HEAD(&phy->port_siblings);
724 if (scsi_is_sas_expander_device(parent)) {
725 struct sas_rphy *rphy = dev_to_rphy(parent);
726 dev_set_name(&phy->dev, "phy-%d:%d:%d", shost->host_no,
727 rphy->scsi_target_id, number);
728 } else
729 dev_set_name(&phy->dev, "phy-%d:%d", shost->host_no, number);
730
731 transport_setup_device(&phy->dev);
732
733 return phy;
734 }
735 EXPORT_SYMBOL(sas_phy_alloc);
736
737 /**
738 * sas_phy_add - add a SAS PHY to the device hierarchy
739 * @phy: The PHY to be added
740 *
741 * Publishes a SAS PHY to the rest of the system.
742 */
sas_phy_add(struct sas_phy * phy)743 int sas_phy_add(struct sas_phy *phy)
744 {
745 int error;
746
747 error = device_add(&phy->dev);
748 if (error)
749 return error;
750
751 error = transport_add_device(&phy->dev);
752 if (error) {
753 device_del(&phy->dev);
754 return error;
755 }
756 transport_configure_device(&phy->dev);
757
758 return 0;
759 }
760 EXPORT_SYMBOL(sas_phy_add);
761
762 /**
763 * sas_phy_free - free a SAS PHY
764 * @phy: SAS PHY to free
765 *
766 * Frees the specified SAS PHY.
767 *
768 * Note:
769 * This function must only be called on a PHY that has not
770 * successfully been added using sas_phy_add().
771 */
sas_phy_free(struct sas_phy * phy)772 void sas_phy_free(struct sas_phy *phy)
773 {
774 transport_destroy_device(&phy->dev);
775 put_device(&phy->dev);
776 }
777 EXPORT_SYMBOL(sas_phy_free);
778
779 /**
780 * sas_phy_delete - remove SAS PHY
781 * @phy: SAS PHY to remove
782 *
783 * Removes the specified SAS PHY. If the SAS PHY has an
784 * associated remote PHY it is removed before.
785 */
786 void
sas_phy_delete(struct sas_phy * phy)787 sas_phy_delete(struct sas_phy *phy)
788 {
789 struct device *dev = &phy->dev;
790
791 /* this happens if the phy is still part of a port when deleted */
792 BUG_ON(!list_empty(&phy->port_siblings));
793
794 transport_remove_device(dev);
795 device_del(dev);
796 transport_destroy_device(dev);
797 put_device(dev);
798 }
799 EXPORT_SYMBOL(sas_phy_delete);
800
801 /**
802 * scsi_is_sas_phy - check if a struct device represents a SAS PHY
803 * @dev: device to check
804 *
805 * Returns:
806 * %1 if the device represents a SAS PHY, %0 else
807 */
scsi_is_sas_phy(const struct device * dev)808 int scsi_is_sas_phy(const struct device *dev)
809 {
810 return dev->release == sas_phy_release;
811 }
812 EXPORT_SYMBOL(scsi_is_sas_phy);
813
814 /*
815 * SAS Port attributes
816 */
817 #define sas_port_show_simple(field, name, format_string, cast) \
818 static ssize_t \
819 show_sas_port_##name(struct device *dev, \
820 struct device_attribute *attr, char *buf) \
821 { \
822 struct sas_port *port = transport_class_to_sas_port(dev); \
823 \
824 return snprintf(buf, 20, format_string, cast port->field); \
825 }
826
827 #define sas_port_simple_attr(field, name, format_string, type) \
828 sas_port_show_simple(field, name, format_string, (type)) \
829 static DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
830
831 sas_port_simple_attr(num_phys, num_phys, "%d\n", int);
832
833 static DECLARE_TRANSPORT_CLASS(sas_port_class,
834 "sas_port", NULL, NULL, NULL);
835
sas_port_match(struct attribute_container * cont,struct device * dev)836 static int sas_port_match(struct attribute_container *cont, struct device *dev)
837 {
838 struct Scsi_Host *shost;
839 struct sas_internal *i;
840
841 if (!scsi_is_sas_port(dev))
842 return 0;
843 shost = dev_to_shost(dev->parent);
844
845 if (!shost->transportt)
846 return 0;
847 if (shost->transportt->host_attrs.ac.class !=
848 &sas_host_class.class)
849 return 0;
850
851 i = to_sas_internal(shost->transportt);
852 return &i->port_attr_cont.ac == cont;
853 }
854
855
sas_port_release(struct device * dev)856 static void sas_port_release(struct device *dev)
857 {
858 struct sas_port *port = dev_to_sas_port(dev);
859
860 BUG_ON(!list_empty(&port->phy_list));
861
862 put_device(dev->parent);
863 kfree(port);
864 }
865
sas_port_create_link(struct sas_port * port,struct sas_phy * phy)866 static void sas_port_create_link(struct sas_port *port,
867 struct sas_phy *phy)
868 {
869 int res;
870
871 res = sysfs_create_link(&port->dev.kobj, &phy->dev.kobj,
872 dev_name(&phy->dev));
873 if (res)
874 goto err;
875 res = sysfs_create_link(&phy->dev.kobj, &port->dev.kobj, "port");
876 if (res)
877 goto err;
878 return;
879 err:
880 printk(KERN_ERR "%s: Cannot create port links, err=%d\n",
881 __func__, res);
882 }
883
sas_port_delete_link(struct sas_port * port,struct sas_phy * phy)884 static void sas_port_delete_link(struct sas_port *port,
885 struct sas_phy *phy)
886 {
887 sysfs_remove_link(&port->dev.kobj, dev_name(&phy->dev));
888 sysfs_remove_link(&phy->dev.kobj, "port");
889 }
890
891 /**
892 * sas_port_alloc - allocate and initialize a SAS port structure
893 *
894 * @parent: parent device
895 * @port_id: port number
896 *
897 * Allocates a SAS port structure. It will be added to the device tree
898 * below the device specified by @parent which must be either a Scsi_Host
899 * or a sas_expander_device.
900 *
901 * Returns: %NULL on error
902 */
sas_port_alloc(struct device * parent,int port_id)903 struct sas_port *sas_port_alloc(struct device *parent, int port_id)
904 {
905 struct Scsi_Host *shost = dev_to_shost(parent);
906 struct sas_port *port;
907
908 port = kzalloc(sizeof(*port), GFP_KERNEL);
909 if (!port)
910 return NULL;
911
912 port->port_identifier = port_id;
913
914 device_initialize(&port->dev);
915
916 port->dev.parent = get_device(parent);
917 port->dev.release = sas_port_release;
918
919 mutex_init(&port->phy_list_mutex);
920 INIT_LIST_HEAD(&port->phy_list);
921
922 if (scsi_is_sas_expander_device(parent)) {
923 struct sas_rphy *rphy = dev_to_rphy(parent);
924 dev_set_name(&port->dev, "port-%d:%d:%d", shost->host_no,
925 rphy->scsi_target_id, port->port_identifier);
926 } else
927 dev_set_name(&port->dev, "port-%d:%d", shost->host_no,
928 port->port_identifier);
929
930 transport_setup_device(&port->dev);
931
932 return port;
933 }
934 EXPORT_SYMBOL(sas_port_alloc);
935
936 /**
937 * sas_port_alloc_num - allocate and initialize a SAS port structure
938 *
939 * @parent: parent device
940 *
941 * Allocates a SAS port structure and a number to go with it. This
942 * interface is really for adapters where the port number has no
943 * meansing, so the sas class should manage them. It will be added to
944 * the device tree below the device specified by @parent which must be
945 * either a Scsi_Host or a sas_expander_device.
946 *
947 * Returns: %NULL on error
948 */
sas_port_alloc_num(struct device * parent)949 struct sas_port *sas_port_alloc_num(struct device *parent)
950 {
951 int index;
952 struct Scsi_Host *shost = dev_to_shost(parent);
953 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
954
955 /* FIXME: use idr for this eventually */
956 mutex_lock(&sas_host->lock);
957 if (scsi_is_sas_expander_device(parent)) {
958 struct sas_rphy *rphy = dev_to_rphy(parent);
959 struct sas_expander_device *exp = rphy_to_expander_device(rphy);
960
961 index = exp->next_port_id++;
962 } else
963 index = sas_host->next_port_id++;
964 mutex_unlock(&sas_host->lock);
965 return sas_port_alloc(parent, index);
966 }
967 EXPORT_SYMBOL(sas_port_alloc_num);
968
969 /**
970 * sas_port_add - add a SAS port to the device hierarchy
971 * @port: port to be added
972 *
973 * publishes a port to the rest of the system
974 */
sas_port_add(struct sas_port * port)975 int sas_port_add(struct sas_port *port)
976 {
977 int error;
978
979 /* No phys should be added until this is made visible */
980 BUG_ON(!list_empty(&port->phy_list));
981
982 error = device_add(&port->dev);
983
984 if (error)
985 return error;
986
987 transport_add_device(&port->dev);
988 transport_configure_device(&port->dev);
989
990 return 0;
991 }
992 EXPORT_SYMBOL(sas_port_add);
993
994 /**
995 * sas_port_free - free a SAS PORT
996 * @port: SAS PORT to free
997 *
998 * Frees the specified SAS PORT.
999 *
1000 * Note:
1001 * This function must only be called on a PORT that has not
1002 * successfully been added using sas_port_add().
1003 */
sas_port_free(struct sas_port * port)1004 void sas_port_free(struct sas_port *port)
1005 {
1006 transport_destroy_device(&port->dev);
1007 put_device(&port->dev);
1008 }
1009 EXPORT_SYMBOL(sas_port_free);
1010
1011 /**
1012 * sas_port_delete - remove SAS PORT
1013 * @port: SAS PORT to remove
1014 *
1015 * Removes the specified SAS PORT. If the SAS PORT has an
1016 * associated phys, unlink them from the port as well.
1017 */
sas_port_delete(struct sas_port * port)1018 void sas_port_delete(struct sas_port *port)
1019 {
1020 struct device *dev = &port->dev;
1021 struct sas_phy *phy, *tmp_phy;
1022
1023 if (port->rphy) {
1024 sas_rphy_delete(port->rphy);
1025 port->rphy = NULL;
1026 }
1027
1028 mutex_lock(&port->phy_list_mutex);
1029 list_for_each_entry_safe(phy, tmp_phy, &port->phy_list,
1030 port_siblings) {
1031 sas_port_delete_link(port, phy);
1032 list_del_init(&phy->port_siblings);
1033 }
1034 mutex_unlock(&port->phy_list_mutex);
1035
1036 if (port->is_backlink) {
1037 struct device *parent = port->dev.parent;
1038
1039 sysfs_remove_link(&port->dev.kobj, dev_name(parent));
1040 port->is_backlink = 0;
1041 }
1042
1043 transport_remove_device(dev);
1044 device_del(dev);
1045 transport_destroy_device(dev);
1046 put_device(dev);
1047 }
1048 EXPORT_SYMBOL(sas_port_delete);
1049
1050 /**
1051 * scsi_is_sas_port - check if a struct device represents a SAS port
1052 * @dev: device to check
1053 *
1054 * Returns:
1055 * %1 if the device represents a SAS Port, %0 else
1056 */
scsi_is_sas_port(const struct device * dev)1057 int scsi_is_sas_port(const struct device *dev)
1058 {
1059 return dev->release == sas_port_release;
1060 }
1061 EXPORT_SYMBOL(scsi_is_sas_port);
1062
1063 /**
1064 * sas_port_get_phy - try to take a reference on a port member
1065 * @port: port to check
1066 */
sas_port_get_phy(struct sas_port * port)1067 struct sas_phy *sas_port_get_phy(struct sas_port *port)
1068 {
1069 struct sas_phy *phy;
1070
1071 mutex_lock(&port->phy_list_mutex);
1072 if (list_empty(&port->phy_list))
1073 phy = NULL;
1074 else {
1075 struct list_head *ent = port->phy_list.next;
1076
1077 phy = list_entry(ent, typeof(*phy), port_siblings);
1078 get_device(&phy->dev);
1079 }
1080 mutex_unlock(&port->phy_list_mutex);
1081
1082 return phy;
1083 }
1084 EXPORT_SYMBOL(sas_port_get_phy);
1085
1086 /**
1087 * sas_port_add_phy - add another phy to a port to form a wide port
1088 * @port: port to add the phy to
1089 * @phy: phy to add
1090 *
1091 * When a port is initially created, it is empty (has no phys). All
1092 * ports must have at least one phy to operated, and all wide ports
1093 * must have at least two. The current code makes no difference
1094 * between ports and wide ports, but the only object that can be
1095 * connected to a remote device is a port, so ports must be formed on
1096 * all devices with phys if they're connected to anything.
1097 */
sas_port_add_phy(struct sas_port * port,struct sas_phy * phy)1098 void sas_port_add_phy(struct sas_port *port, struct sas_phy *phy)
1099 {
1100 mutex_lock(&port->phy_list_mutex);
1101 if (unlikely(!list_empty(&phy->port_siblings))) {
1102 /* make sure we're already on this port */
1103 struct sas_phy *tmp;
1104
1105 list_for_each_entry(tmp, &port->phy_list, port_siblings)
1106 if (tmp == phy)
1107 break;
1108 /* If this trips, you added a phy that was already
1109 * part of a different port */
1110 if (unlikely(tmp != phy)) {
1111 dev_printk(KERN_ERR, &port->dev, "trying to add phy %s fails: it's already part of another port\n",
1112 dev_name(&phy->dev));
1113 BUG();
1114 }
1115 } else {
1116 sas_port_create_link(port, phy);
1117 list_add_tail(&phy->port_siblings, &port->phy_list);
1118 port->num_phys++;
1119 }
1120 mutex_unlock(&port->phy_list_mutex);
1121 }
1122 EXPORT_SYMBOL(sas_port_add_phy);
1123
1124 /**
1125 * sas_port_delete_phy - remove a phy from a port or wide port
1126 * @port: port to remove the phy from
1127 * @phy: phy to remove
1128 *
1129 * This operation is used for tearing down ports again. It must be
1130 * done to every port or wide port before calling sas_port_delete.
1131 */
sas_port_delete_phy(struct sas_port * port,struct sas_phy * phy)1132 void sas_port_delete_phy(struct sas_port *port, struct sas_phy *phy)
1133 {
1134 mutex_lock(&port->phy_list_mutex);
1135 sas_port_delete_link(port, phy);
1136 list_del_init(&phy->port_siblings);
1137 port->num_phys--;
1138 mutex_unlock(&port->phy_list_mutex);
1139 }
1140 EXPORT_SYMBOL(sas_port_delete_phy);
1141
sas_port_mark_backlink(struct sas_port * port)1142 void sas_port_mark_backlink(struct sas_port *port)
1143 {
1144 int res;
1145 struct device *parent = port->dev.parent->parent->parent;
1146
1147 if (port->is_backlink)
1148 return;
1149 port->is_backlink = 1;
1150 res = sysfs_create_link(&port->dev.kobj, &parent->kobj,
1151 dev_name(parent));
1152 if (res)
1153 goto err;
1154 return;
1155 err:
1156 printk(KERN_ERR "%s: Cannot create port backlink, err=%d\n",
1157 __func__, res);
1158
1159 }
1160 EXPORT_SYMBOL(sas_port_mark_backlink);
1161
1162 /*
1163 * SAS remote PHY attributes.
1164 */
1165
1166 #define sas_rphy_show_simple(field, name, format_string, cast) \
1167 static ssize_t \
1168 show_sas_rphy_##name(struct device *dev, \
1169 struct device_attribute *attr, char *buf) \
1170 { \
1171 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1172 \
1173 return snprintf(buf, 20, format_string, cast rphy->field); \
1174 }
1175
1176 #define sas_rphy_simple_attr(field, name, format_string, type) \
1177 sas_rphy_show_simple(field, name, format_string, (type)) \
1178 static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \
1179 show_sas_rphy_##name, NULL)
1180
1181 #define sas_rphy_show_protocol(field, name) \
1182 static ssize_t \
1183 show_sas_rphy_##name(struct device *dev, \
1184 struct device_attribute *attr, char *buf) \
1185 { \
1186 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1187 \
1188 if (!rphy->field) \
1189 return snprintf(buf, 20, "none\n"); \
1190 return get_sas_protocol_names(rphy->field, buf); \
1191 }
1192
1193 #define sas_rphy_protocol_attr(field, name) \
1194 sas_rphy_show_protocol(field, name) \
1195 static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \
1196 show_sas_rphy_##name, NULL)
1197
1198 static ssize_t
show_sas_rphy_device_type(struct device * dev,struct device_attribute * attr,char * buf)1199 show_sas_rphy_device_type(struct device *dev,
1200 struct device_attribute *attr, char *buf)
1201 {
1202 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1203
1204 if (!rphy->identify.device_type)
1205 return snprintf(buf, 20, "none\n");
1206 return get_sas_device_type_names(
1207 rphy->identify.device_type, buf);
1208 }
1209
1210 static SAS_DEVICE_ATTR(rphy, device_type, S_IRUGO,
1211 show_sas_rphy_device_type, NULL);
1212
1213 static ssize_t
show_sas_rphy_enclosure_identifier(struct device * dev,struct device_attribute * attr,char * buf)1214 show_sas_rphy_enclosure_identifier(struct device *dev,
1215 struct device_attribute *attr, char *buf)
1216 {
1217 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1218 struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
1219 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1220 struct sas_internal *i = to_sas_internal(shost->transportt);
1221 u64 identifier;
1222 int error;
1223
1224 error = i->f->get_enclosure_identifier(rphy, &identifier);
1225 if (error)
1226 return error;
1227 return sprintf(buf, "0x%llx\n", (unsigned long long)identifier);
1228 }
1229
1230 static SAS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO,
1231 show_sas_rphy_enclosure_identifier, NULL);
1232
1233 static ssize_t
show_sas_rphy_bay_identifier(struct device * dev,struct device_attribute * attr,char * buf)1234 show_sas_rphy_bay_identifier(struct device *dev,
1235 struct device_attribute *attr, char *buf)
1236 {
1237 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1238 struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
1239 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1240 struct sas_internal *i = to_sas_internal(shost->transportt);
1241 int val;
1242
1243 val = i->f->get_bay_identifier(rphy);
1244 if (val < 0)
1245 return val;
1246 return sprintf(buf, "%d\n", val);
1247 }
1248
1249 static SAS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO,
1250 show_sas_rphy_bay_identifier, NULL);
1251
1252 sas_rphy_protocol_attr(identify.initiator_port_protocols,
1253 initiator_port_protocols);
1254 sas_rphy_protocol_attr(identify.target_port_protocols, target_port_protocols);
1255 sas_rphy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
1256 unsigned long long);
1257 sas_rphy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
1258 sas_rphy_simple_attr(scsi_target_id, scsi_target_id, "%d\n", u32);
1259
1260 /* only need 8 bytes of data plus header (4 or 8) */
1261 #define BUF_SIZE 64
1262
sas_read_port_mode_page(struct scsi_device * sdev)1263 int sas_read_port_mode_page(struct scsi_device *sdev)
1264 {
1265 char *buffer = kzalloc(BUF_SIZE, GFP_KERNEL), *msdata;
1266 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
1267 struct scsi_mode_data mode_data;
1268 int error;
1269
1270 if (!buffer)
1271 return -ENOMEM;
1272
1273 error = scsi_mode_sense(sdev, 1, 0x19, 0, buffer, BUF_SIZE, 30*HZ, 3,
1274 &mode_data, NULL);
1275
1276 if (error)
1277 goto out;
1278
1279 msdata = buffer + mode_data.header_length +
1280 mode_data.block_descriptor_length;
1281
1282 if (msdata - buffer > BUF_SIZE - 8)
1283 goto out;
1284
1285 error = 0;
1286
1287 rdev->ready_led_meaning = msdata[2] & 0x10 ? 1 : 0;
1288 rdev->I_T_nexus_loss_timeout = (msdata[4] << 8) + msdata[5];
1289 rdev->initiator_response_timeout = (msdata[6] << 8) + msdata[7];
1290
1291 out:
1292 kfree(buffer);
1293 return error;
1294 }
1295 EXPORT_SYMBOL(sas_read_port_mode_page);
1296
1297 static DECLARE_TRANSPORT_CLASS(sas_end_dev_class,
1298 "sas_end_device", NULL, NULL, NULL);
1299
1300 #define sas_end_dev_show_simple(field, name, format_string, cast) \
1301 static ssize_t \
1302 show_sas_end_dev_##name(struct device *dev, \
1303 struct device_attribute *attr, char *buf) \
1304 { \
1305 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1306 struct sas_end_device *rdev = rphy_to_end_device(rphy); \
1307 \
1308 return snprintf(buf, 20, format_string, cast rdev->field); \
1309 }
1310
1311 #define sas_end_dev_simple_attr(field, name, format_string, type) \
1312 sas_end_dev_show_simple(field, name, format_string, (type)) \
1313 static SAS_DEVICE_ATTR(end_dev, name, S_IRUGO, \
1314 show_sas_end_dev_##name, NULL)
1315
1316 sas_end_dev_simple_attr(ready_led_meaning, ready_led_meaning, "%d\n", int);
1317 sas_end_dev_simple_attr(I_T_nexus_loss_timeout, I_T_nexus_loss_timeout,
1318 "%d\n", int);
1319 sas_end_dev_simple_attr(initiator_response_timeout, initiator_response_timeout,
1320 "%d\n", int);
1321 sas_end_dev_simple_attr(tlr_supported, tlr_supported,
1322 "%d\n", int);
1323 sas_end_dev_simple_attr(tlr_enabled, tlr_enabled,
1324 "%d\n", int);
1325
1326 static DECLARE_TRANSPORT_CLASS(sas_expander_class,
1327 "sas_expander", NULL, NULL, NULL);
1328
1329 #define sas_expander_show_simple(field, name, format_string, cast) \
1330 static ssize_t \
1331 show_sas_expander_##name(struct device *dev, \
1332 struct device_attribute *attr, char *buf) \
1333 { \
1334 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1335 struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
1336 \
1337 return snprintf(buf, 20, format_string, cast edev->field); \
1338 }
1339
1340 #define sas_expander_simple_attr(field, name, format_string, type) \
1341 sas_expander_show_simple(field, name, format_string, (type)) \
1342 static SAS_DEVICE_ATTR(expander, name, S_IRUGO, \
1343 show_sas_expander_##name, NULL)
1344
1345 sas_expander_simple_attr(vendor_id, vendor_id, "%s\n", char *);
1346 sas_expander_simple_attr(product_id, product_id, "%s\n", char *);
1347 sas_expander_simple_attr(product_rev, product_rev, "%s\n", char *);
1348 sas_expander_simple_attr(component_vendor_id, component_vendor_id,
1349 "%s\n", char *);
1350 sas_expander_simple_attr(component_id, component_id, "%u\n", unsigned int);
1351 sas_expander_simple_attr(component_revision_id, component_revision_id, "%u\n",
1352 unsigned int);
1353 sas_expander_simple_attr(level, level, "%d\n", int);
1354
1355 static DECLARE_TRANSPORT_CLASS(sas_rphy_class,
1356 "sas_device", NULL, NULL, NULL);
1357
sas_rphy_match(struct attribute_container * cont,struct device * dev)1358 static int sas_rphy_match(struct attribute_container *cont, struct device *dev)
1359 {
1360 struct Scsi_Host *shost;
1361 struct sas_internal *i;
1362
1363 if (!scsi_is_sas_rphy(dev))
1364 return 0;
1365 shost = dev_to_shost(dev->parent->parent);
1366
1367 if (!shost->transportt)
1368 return 0;
1369 if (shost->transportt->host_attrs.ac.class !=
1370 &sas_host_class.class)
1371 return 0;
1372
1373 i = to_sas_internal(shost->transportt);
1374 return &i->rphy_attr_cont.ac == cont;
1375 }
1376
sas_end_dev_match(struct attribute_container * cont,struct device * dev)1377 static int sas_end_dev_match(struct attribute_container *cont,
1378 struct device *dev)
1379 {
1380 struct Scsi_Host *shost;
1381 struct sas_internal *i;
1382 struct sas_rphy *rphy;
1383
1384 if (!scsi_is_sas_rphy(dev))
1385 return 0;
1386 shost = dev_to_shost(dev->parent->parent);
1387 rphy = dev_to_rphy(dev);
1388
1389 if (!shost->transportt)
1390 return 0;
1391 if (shost->transportt->host_attrs.ac.class !=
1392 &sas_host_class.class)
1393 return 0;
1394
1395 i = to_sas_internal(shost->transportt);
1396 return &i->end_dev_attr_cont.ac == cont &&
1397 rphy->identify.device_type == SAS_END_DEVICE;
1398 }
1399
sas_expander_match(struct attribute_container * cont,struct device * dev)1400 static int sas_expander_match(struct attribute_container *cont,
1401 struct device *dev)
1402 {
1403 struct Scsi_Host *shost;
1404 struct sas_internal *i;
1405 struct sas_rphy *rphy;
1406
1407 if (!scsi_is_sas_rphy(dev))
1408 return 0;
1409 shost = dev_to_shost(dev->parent->parent);
1410 rphy = dev_to_rphy(dev);
1411
1412 if (!shost->transportt)
1413 return 0;
1414 if (shost->transportt->host_attrs.ac.class !=
1415 &sas_host_class.class)
1416 return 0;
1417
1418 i = to_sas_internal(shost->transportt);
1419 return &i->expander_attr_cont.ac == cont &&
1420 (rphy->identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
1421 rphy->identify.device_type == SAS_FANOUT_EXPANDER_DEVICE);
1422 }
1423
sas_expander_release(struct device * dev)1424 static void sas_expander_release(struct device *dev)
1425 {
1426 struct sas_rphy *rphy = dev_to_rphy(dev);
1427 struct sas_expander_device *edev = rphy_to_expander_device(rphy);
1428
1429 put_device(dev->parent);
1430 kfree(edev);
1431 }
1432
sas_end_device_release(struct device * dev)1433 static void sas_end_device_release(struct device *dev)
1434 {
1435 struct sas_rphy *rphy = dev_to_rphy(dev);
1436 struct sas_end_device *edev = rphy_to_end_device(rphy);
1437
1438 put_device(dev->parent);
1439 kfree(edev);
1440 }
1441
1442 /**
1443 * sas_rphy_initialize - common rphy initialization
1444 * @rphy: rphy to initialise
1445 *
1446 * Used by both sas_end_device_alloc() and sas_expander_alloc() to
1447 * initialise the common rphy component of each.
1448 */
sas_rphy_initialize(struct sas_rphy * rphy)1449 static void sas_rphy_initialize(struct sas_rphy *rphy)
1450 {
1451 INIT_LIST_HEAD(&rphy->list);
1452 }
1453
1454 /**
1455 * sas_end_device_alloc - allocate an rphy for an end device
1456 * @parent: which port
1457 *
1458 * Allocates an SAS remote PHY structure, connected to @parent.
1459 *
1460 * Returns:
1461 * SAS PHY allocated or %NULL if the allocation failed.
1462 */
sas_end_device_alloc(struct sas_port * parent)1463 struct sas_rphy *sas_end_device_alloc(struct sas_port *parent)
1464 {
1465 struct Scsi_Host *shost = dev_to_shost(&parent->dev);
1466 struct sas_end_device *rdev;
1467
1468 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
1469 if (!rdev) {
1470 return NULL;
1471 }
1472
1473 device_initialize(&rdev->rphy.dev);
1474 rdev->rphy.dev.parent = get_device(&parent->dev);
1475 rdev->rphy.dev.release = sas_end_device_release;
1476 if (scsi_is_sas_expander_device(parent->dev.parent)) {
1477 struct sas_rphy *rphy = dev_to_rphy(parent->dev.parent);
1478 dev_set_name(&rdev->rphy.dev, "end_device-%d:%d:%d",
1479 shost->host_no, rphy->scsi_target_id,
1480 parent->port_identifier);
1481 } else
1482 dev_set_name(&rdev->rphy.dev, "end_device-%d:%d",
1483 shost->host_no, parent->port_identifier);
1484 rdev->rphy.identify.device_type = SAS_END_DEVICE;
1485 sas_rphy_initialize(&rdev->rphy);
1486 transport_setup_device(&rdev->rphy.dev);
1487
1488 return &rdev->rphy;
1489 }
1490 EXPORT_SYMBOL(sas_end_device_alloc);
1491
1492 /**
1493 * sas_expander_alloc - allocate an rphy for an end device
1494 * @parent: which port
1495 * @type: SAS_EDGE_EXPANDER_DEVICE or SAS_FANOUT_EXPANDER_DEVICE
1496 *
1497 * Allocates an SAS remote PHY structure, connected to @parent.
1498 *
1499 * Returns:
1500 * SAS PHY allocated or %NULL if the allocation failed.
1501 */
sas_expander_alloc(struct sas_port * parent,enum sas_device_type type)1502 struct sas_rphy *sas_expander_alloc(struct sas_port *parent,
1503 enum sas_device_type type)
1504 {
1505 struct Scsi_Host *shost = dev_to_shost(&parent->dev);
1506 struct sas_expander_device *rdev;
1507 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1508
1509 BUG_ON(type != SAS_EDGE_EXPANDER_DEVICE &&
1510 type != SAS_FANOUT_EXPANDER_DEVICE);
1511
1512 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
1513 if (!rdev) {
1514 return NULL;
1515 }
1516
1517 device_initialize(&rdev->rphy.dev);
1518 rdev->rphy.dev.parent = get_device(&parent->dev);
1519 rdev->rphy.dev.release = sas_expander_release;
1520 mutex_lock(&sas_host->lock);
1521 rdev->rphy.scsi_target_id = sas_host->next_expander_id++;
1522 mutex_unlock(&sas_host->lock);
1523 dev_set_name(&rdev->rphy.dev, "expander-%d:%d",
1524 shost->host_no, rdev->rphy.scsi_target_id);
1525 rdev->rphy.identify.device_type = type;
1526 sas_rphy_initialize(&rdev->rphy);
1527 transport_setup_device(&rdev->rphy.dev);
1528
1529 return &rdev->rphy;
1530 }
1531 EXPORT_SYMBOL(sas_expander_alloc);
1532
1533 /**
1534 * sas_rphy_add - add a SAS remote PHY to the device hierarchy
1535 * @rphy: The remote PHY to be added
1536 *
1537 * Publishes a SAS remote PHY to the rest of the system.
1538 */
sas_rphy_add(struct sas_rphy * rphy)1539 int sas_rphy_add(struct sas_rphy *rphy)
1540 {
1541 struct sas_port *parent = dev_to_sas_port(rphy->dev.parent);
1542 struct Scsi_Host *shost = dev_to_shost(parent->dev.parent);
1543 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1544 struct sas_identify *identify = &rphy->identify;
1545 int error;
1546
1547 if (parent->rphy)
1548 return -ENXIO;
1549 parent->rphy = rphy;
1550
1551 error = device_add(&rphy->dev);
1552 if (error)
1553 return error;
1554 transport_add_device(&rphy->dev);
1555 transport_configure_device(&rphy->dev);
1556 if (sas_bsg_initialize(shost, rphy))
1557 printk("fail to a bsg device %s\n", dev_name(&rphy->dev));
1558
1559
1560 mutex_lock(&sas_host->lock);
1561 list_add_tail(&rphy->list, &sas_host->rphy_list);
1562 if (identify->device_type == SAS_END_DEVICE &&
1563 (identify->target_port_protocols &
1564 (SAS_PROTOCOL_SSP | SAS_PROTOCOL_STP | SAS_PROTOCOL_SATA)))
1565 rphy->scsi_target_id = sas_host->next_target_id++;
1566 else if (identify->device_type == SAS_END_DEVICE)
1567 rphy->scsi_target_id = -1;
1568 mutex_unlock(&sas_host->lock);
1569
1570 if (identify->device_type == SAS_END_DEVICE &&
1571 rphy->scsi_target_id != -1) {
1572 int lun;
1573
1574 if (identify->target_port_protocols & SAS_PROTOCOL_SSP)
1575 lun = SCAN_WILD_CARD;
1576 else
1577 lun = 0;
1578
1579 scsi_scan_target(&rphy->dev, 0, rphy->scsi_target_id, lun,
1580 SCSI_SCAN_INITIAL);
1581 }
1582
1583 return 0;
1584 }
1585 EXPORT_SYMBOL(sas_rphy_add);
1586
1587 /**
1588 * sas_rphy_free - free a SAS remote PHY
1589 * @rphy: SAS remote PHY to free
1590 *
1591 * Frees the specified SAS remote PHY.
1592 *
1593 * Note:
1594 * This function must only be called on a remote
1595 * PHY that has not successfully been added using
1596 * sas_rphy_add() (or has been sas_rphy_remove()'d)
1597 */
sas_rphy_free(struct sas_rphy * rphy)1598 void sas_rphy_free(struct sas_rphy *rphy)
1599 {
1600 struct device *dev = &rphy->dev;
1601 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
1602 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1603
1604 mutex_lock(&sas_host->lock);
1605 list_del(&rphy->list);
1606 mutex_unlock(&sas_host->lock);
1607
1608 transport_destroy_device(dev);
1609
1610 put_device(dev);
1611 }
1612 EXPORT_SYMBOL(sas_rphy_free);
1613
1614 /**
1615 * sas_rphy_delete - remove and free SAS remote PHY
1616 * @rphy: SAS remote PHY to remove and free
1617 *
1618 * Removes the specified SAS remote PHY and frees it.
1619 */
1620 void
sas_rphy_delete(struct sas_rphy * rphy)1621 sas_rphy_delete(struct sas_rphy *rphy)
1622 {
1623 sas_rphy_remove(rphy);
1624 sas_rphy_free(rphy);
1625 }
1626 EXPORT_SYMBOL(sas_rphy_delete);
1627
1628 /**
1629 * sas_rphy_unlink - unlink SAS remote PHY
1630 * @rphy: SAS remote phy to unlink from its parent port
1631 *
1632 * Removes port reference to an rphy
1633 */
sas_rphy_unlink(struct sas_rphy * rphy)1634 void sas_rphy_unlink(struct sas_rphy *rphy)
1635 {
1636 struct sas_port *parent = dev_to_sas_port(rphy->dev.parent);
1637
1638 parent->rphy = NULL;
1639 }
1640 EXPORT_SYMBOL(sas_rphy_unlink);
1641
1642 /**
1643 * sas_rphy_remove - remove SAS remote PHY
1644 * @rphy: SAS remote phy to remove
1645 *
1646 * Removes the specified SAS remote PHY.
1647 */
1648 void
sas_rphy_remove(struct sas_rphy * rphy)1649 sas_rphy_remove(struct sas_rphy *rphy)
1650 {
1651 struct device *dev = &rphy->dev;
1652
1653 switch (rphy->identify.device_type) {
1654 case SAS_END_DEVICE:
1655 scsi_remove_target(dev);
1656 break;
1657 case SAS_EDGE_EXPANDER_DEVICE:
1658 case SAS_FANOUT_EXPANDER_DEVICE:
1659 sas_remove_children(dev);
1660 break;
1661 default:
1662 break;
1663 }
1664
1665 sas_rphy_unlink(rphy);
1666 bsg_remove_queue(rphy->q);
1667 transport_remove_device(dev);
1668 device_del(dev);
1669 }
1670 EXPORT_SYMBOL(sas_rphy_remove);
1671
1672 /**
1673 * scsi_is_sas_rphy - check if a struct device represents a SAS remote PHY
1674 * @dev: device to check
1675 *
1676 * Returns:
1677 * %1 if the device represents a SAS remote PHY, %0 else
1678 */
scsi_is_sas_rphy(const struct device * dev)1679 int scsi_is_sas_rphy(const struct device *dev)
1680 {
1681 return dev->release == sas_end_device_release ||
1682 dev->release == sas_expander_release;
1683 }
1684 EXPORT_SYMBOL(scsi_is_sas_rphy);
1685
1686
1687 /*
1688 * SCSI scan helper
1689 */
1690
sas_user_scan(struct Scsi_Host * shost,uint channel,uint id,u64 lun)1691 static int sas_user_scan(struct Scsi_Host *shost, uint channel,
1692 uint id, u64 lun)
1693 {
1694 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1695 struct sas_rphy *rphy;
1696
1697 mutex_lock(&sas_host->lock);
1698 list_for_each_entry(rphy, &sas_host->rphy_list, list) {
1699 if (rphy->identify.device_type != SAS_END_DEVICE ||
1700 rphy->scsi_target_id == -1)
1701 continue;
1702
1703 if ((channel == SCAN_WILD_CARD || channel == 0) &&
1704 (id == SCAN_WILD_CARD || id == rphy->scsi_target_id)) {
1705 scsi_scan_target(&rphy->dev, 0, rphy->scsi_target_id,
1706 lun, SCSI_SCAN_MANUAL);
1707 }
1708 }
1709 mutex_unlock(&sas_host->lock);
1710
1711 return 0;
1712 }
1713
1714
1715 /*
1716 * Setup / Teardown code
1717 */
1718
1719 #define SETUP_TEMPLATE(attrb, field, perm, test) \
1720 i->private_##attrb[count] = dev_attr_##field; \
1721 i->private_##attrb[count].attr.mode = perm; \
1722 i->attrb[count] = &i->private_##attrb[count]; \
1723 if (test) \
1724 count++
1725
1726 #define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \
1727 i->private_##attrb[count] = dev_attr_##field; \
1728 i->private_##attrb[count].attr.mode = perm; \
1729 if (ro_test) { \
1730 i->private_##attrb[count].attr.mode = ro_perm; \
1731 i->private_##attrb[count].store = NULL; \
1732 } \
1733 i->attrb[count] = &i->private_##attrb[count]; \
1734 if (test) \
1735 count++
1736
1737 #define SETUP_RPORT_ATTRIBUTE(field) \
1738 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, 1)
1739
1740 #define SETUP_OPTIONAL_RPORT_ATTRIBUTE(field, func) \
1741 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, i->f->func)
1742
1743 #define SETUP_PHY_ATTRIBUTE(field) \
1744 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, 1)
1745
1746 #define SETUP_PHY_ATTRIBUTE_RW(field) \
1747 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1748 !i->f->set_phy_speed, S_IRUGO)
1749
1750 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(field, func) \
1751 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1752 !i->f->func, S_IRUGO)
1753
1754 #define SETUP_PORT_ATTRIBUTE(field) \
1755 SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1)
1756
1757 #define SETUP_OPTIONAL_PHY_ATTRIBUTE(field, func) \
1758 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, i->f->func)
1759
1760 #define SETUP_PHY_ATTRIBUTE_WRONLY(field) \
1761 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, 1)
1762
1763 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(field, func) \
1764 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, i->f->func)
1765
1766 #define SETUP_END_DEV_ATTRIBUTE(field) \
1767 SETUP_TEMPLATE(end_dev_attrs, field, S_IRUGO, 1)
1768
1769 #define SETUP_EXPANDER_ATTRIBUTE(field) \
1770 SETUP_TEMPLATE(expander_attrs, expander_##field, S_IRUGO, 1)
1771
1772 /**
1773 * sas_attach_transport - instantiate SAS transport template
1774 * @ft: SAS transport class function template
1775 */
1776 struct scsi_transport_template *
sas_attach_transport(struct sas_function_template * ft)1777 sas_attach_transport(struct sas_function_template *ft)
1778 {
1779 struct sas_internal *i;
1780 int count;
1781
1782 i = kzalloc(sizeof(struct sas_internal), GFP_KERNEL);
1783 if (!i)
1784 return NULL;
1785
1786 i->t.user_scan = sas_user_scan;
1787
1788 i->t.host_attrs.ac.attrs = &i->host_attrs[0];
1789 i->t.host_attrs.ac.class = &sas_host_class.class;
1790 i->t.host_attrs.ac.match = sas_host_match;
1791 transport_container_register(&i->t.host_attrs);
1792 i->t.host_size = sizeof(struct sas_host_attrs);
1793
1794 i->phy_attr_cont.ac.class = &sas_phy_class.class;
1795 i->phy_attr_cont.ac.attrs = &i->phy_attrs[0];
1796 i->phy_attr_cont.ac.match = sas_phy_match;
1797 transport_container_register(&i->phy_attr_cont);
1798
1799 i->port_attr_cont.ac.class = &sas_port_class.class;
1800 i->port_attr_cont.ac.attrs = &i->port_attrs[0];
1801 i->port_attr_cont.ac.match = sas_port_match;
1802 transport_container_register(&i->port_attr_cont);
1803
1804 i->rphy_attr_cont.ac.class = &sas_rphy_class.class;
1805 i->rphy_attr_cont.ac.attrs = &i->rphy_attrs[0];
1806 i->rphy_attr_cont.ac.match = sas_rphy_match;
1807 transport_container_register(&i->rphy_attr_cont);
1808
1809 i->end_dev_attr_cont.ac.class = &sas_end_dev_class.class;
1810 i->end_dev_attr_cont.ac.attrs = &i->end_dev_attrs[0];
1811 i->end_dev_attr_cont.ac.match = sas_end_dev_match;
1812 transport_container_register(&i->end_dev_attr_cont);
1813
1814 i->expander_attr_cont.ac.class = &sas_expander_class.class;
1815 i->expander_attr_cont.ac.attrs = &i->expander_attrs[0];
1816 i->expander_attr_cont.ac.match = sas_expander_match;
1817 transport_container_register(&i->expander_attr_cont);
1818
1819 i->f = ft;
1820
1821 count = 0;
1822 SETUP_PHY_ATTRIBUTE(initiator_port_protocols);
1823 SETUP_PHY_ATTRIBUTE(target_port_protocols);
1824 SETUP_PHY_ATTRIBUTE(device_type);
1825 SETUP_PHY_ATTRIBUTE(sas_address);
1826 SETUP_PHY_ATTRIBUTE(phy_identifier);
1827 SETUP_PHY_ATTRIBUTE(negotiated_linkrate);
1828 SETUP_PHY_ATTRIBUTE(minimum_linkrate_hw);
1829 SETUP_PHY_ATTRIBUTE_RW(minimum_linkrate);
1830 SETUP_PHY_ATTRIBUTE(maximum_linkrate_hw);
1831 SETUP_PHY_ATTRIBUTE_RW(maximum_linkrate);
1832
1833 SETUP_PHY_ATTRIBUTE(invalid_dword_count);
1834 SETUP_PHY_ATTRIBUTE(running_disparity_error_count);
1835 SETUP_PHY_ATTRIBUTE(loss_of_dword_sync_count);
1836 SETUP_PHY_ATTRIBUTE(phy_reset_problem_count);
1837 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(link_reset, phy_reset);
1838 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(hard_reset, phy_reset);
1839 SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(enable, phy_enable);
1840 i->phy_attrs[count] = NULL;
1841
1842 count = 0;
1843 SETUP_PORT_ATTRIBUTE(num_phys);
1844 i->port_attrs[count] = NULL;
1845
1846 count = 0;
1847 SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols);
1848 SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols);
1849 SETUP_RPORT_ATTRIBUTE(rphy_device_type);
1850 SETUP_RPORT_ATTRIBUTE(rphy_sas_address);
1851 SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier);
1852 SETUP_RPORT_ATTRIBUTE(rphy_scsi_target_id);
1853 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_enclosure_identifier,
1854 get_enclosure_identifier);
1855 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_bay_identifier,
1856 get_bay_identifier);
1857 i->rphy_attrs[count] = NULL;
1858
1859 count = 0;
1860 SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning);
1861 SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout);
1862 SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout);
1863 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_supported);
1864 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_enabled);
1865 i->end_dev_attrs[count] = NULL;
1866
1867 count = 0;
1868 SETUP_EXPANDER_ATTRIBUTE(vendor_id);
1869 SETUP_EXPANDER_ATTRIBUTE(product_id);
1870 SETUP_EXPANDER_ATTRIBUTE(product_rev);
1871 SETUP_EXPANDER_ATTRIBUTE(component_vendor_id);
1872 SETUP_EXPANDER_ATTRIBUTE(component_id);
1873 SETUP_EXPANDER_ATTRIBUTE(component_revision_id);
1874 SETUP_EXPANDER_ATTRIBUTE(level);
1875 i->expander_attrs[count] = NULL;
1876
1877 return &i->t;
1878 }
1879 EXPORT_SYMBOL(sas_attach_transport);
1880
1881 /**
1882 * sas_release_transport - release SAS transport template instance
1883 * @t: transport template instance
1884 */
sas_release_transport(struct scsi_transport_template * t)1885 void sas_release_transport(struct scsi_transport_template *t)
1886 {
1887 struct sas_internal *i = to_sas_internal(t);
1888
1889 transport_container_unregister(&i->t.host_attrs);
1890 transport_container_unregister(&i->phy_attr_cont);
1891 transport_container_unregister(&i->port_attr_cont);
1892 transport_container_unregister(&i->rphy_attr_cont);
1893 transport_container_unregister(&i->end_dev_attr_cont);
1894 transport_container_unregister(&i->expander_attr_cont);
1895
1896 kfree(i);
1897 }
1898 EXPORT_SYMBOL(sas_release_transport);
1899
sas_transport_init(void)1900 static __init int sas_transport_init(void)
1901 {
1902 int error;
1903
1904 error = transport_class_register(&sas_host_class);
1905 if (error)
1906 goto out;
1907 error = transport_class_register(&sas_phy_class);
1908 if (error)
1909 goto out_unregister_transport;
1910 error = transport_class_register(&sas_port_class);
1911 if (error)
1912 goto out_unregister_phy;
1913 error = transport_class_register(&sas_rphy_class);
1914 if (error)
1915 goto out_unregister_port;
1916 error = transport_class_register(&sas_end_dev_class);
1917 if (error)
1918 goto out_unregister_rphy;
1919 error = transport_class_register(&sas_expander_class);
1920 if (error)
1921 goto out_unregister_end_dev;
1922
1923 return 0;
1924
1925 out_unregister_end_dev:
1926 transport_class_unregister(&sas_end_dev_class);
1927 out_unregister_rphy:
1928 transport_class_unregister(&sas_rphy_class);
1929 out_unregister_port:
1930 transport_class_unregister(&sas_port_class);
1931 out_unregister_phy:
1932 transport_class_unregister(&sas_phy_class);
1933 out_unregister_transport:
1934 transport_class_unregister(&sas_host_class);
1935 out:
1936 return error;
1937
1938 }
1939
sas_transport_exit(void)1940 static void __exit sas_transport_exit(void)
1941 {
1942 transport_class_unregister(&sas_host_class);
1943 transport_class_unregister(&sas_phy_class);
1944 transport_class_unregister(&sas_port_class);
1945 transport_class_unregister(&sas_rphy_class);
1946 transport_class_unregister(&sas_end_dev_class);
1947 transport_class_unregister(&sas_expander_class);
1948 }
1949
1950 MODULE_AUTHOR("Christoph Hellwig");
1951 MODULE_DESCRIPTION("SAS Transport Attributes");
1952 MODULE_LICENSE("GPL");
1953
1954 module_init(sas_transport_init);
1955 module_exit(sas_transport_exit);
1956