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 #include "scsi_priv.h"
44
45 struct sas_host_attrs {
46 struct list_head rphy_list;
47 struct mutex lock;
48 struct request_queue *q;
49 u32 next_target_id;
50 u32 next_expander_id;
51 int next_port_id;
52 };
53 #define to_sas_host_attrs(host) ((struct sas_host_attrs *)(host)->shost_data)
54
55
56 /*
57 * Hack to allow attributes of the same name in different objects.
58 */
59 #define SAS_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
60 struct device_attribute dev_attr_##_prefix##_##_name = \
61 __ATTR(_name,_mode,_show,_store)
62
63
64 /*
65 * Pretty printing helpers
66 */
67
68 #define sas_bitfield_name_match(title, table) \
69 static ssize_t \
70 get_sas_##title##_names(u32 table_key, char *buf) \
71 { \
72 char *prefix = ""; \
73 ssize_t len = 0; \
74 int i; \
75 \
76 for (i = 0; i < ARRAY_SIZE(table); i++) { \
77 if (table[i].value & table_key) { \
78 len += sprintf(buf + len, "%s%s", \
79 prefix, table[i].name); \
80 prefix = ", "; \
81 } \
82 } \
83 len += sprintf(buf + len, "\n"); \
84 return len; \
85 }
86
87 #define sas_bitfield_name_set(title, table) \
88 static ssize_t \
89 set_sas_##title##_names(u32 *table_key, const char *buf) \
90 { \
91 ssize_t len = 0; \
92 int i; \
93 \
94 for (i = 0; i < ARRAY_SIZE(table); i++) { \
95 len = strlen(table[i].name); \
96 if (strncmp(buf, table[i].name, len) == 0 && \
97 (buf[len] == '\n' || buf[len] == '\0')) { \
98 *table_key = table[i].value; \
99 return 0; \
100 } \
101 } \
102 return -EINVAL; \
103 }
104
105 #define sas_bitfield_name_search(title, table) \
106 static ssize_t \
107 get_sas_##title##_names(u32 table_key, char *buf) \
108 { \
109 ssize_t len = 0; \
110 int i; \
111 \
112 for (i = 0; i < ARRAY_SIZE(table); i++) { \
113 if (table[i].value == table_key) { \
114 len += sprintf(buf + len, "%s", \
115 table[i].name); \
116 break; \
117 } \
118 } \
119 len += sprintf(buf + len, "\n"); \
120 return len; \
121 }
122
123 static struct {
124 u32 value;
125 char *name;
126 } sas_device_type_names[] = {
127 { SAS_PHY_UNUSED, "unused" },
128 { SAS_END_DEVICE, "end device" },
129 { SAS_EDGE_EXPANDER_DEVICE, "edge expander" },
130 { SAS_FANOUT_EXPANDER_DEVICE, "fanout expander" },
131 };
132 sas_bitfield_name_search(device_type, sas_device_type_names)
133
134
135 static struct {
136 u32 value;
137 char *name;
138 } sas_protocol_names[] = {
139 { SAS_PROTOCOL_SATA, "sata" },
140 { SAS_PROTOCOL_SMP, "smp" },
141 { SAS_PROTOCOL_STP, "stp" },
142 { SAS_PROTOCOL_SSP, "ssp" },
143 };
144 sas_bitfield_name_match(protocol, sas_protocol_names)
145
146 static struct {
147 u32 value;
148 char *name;
149 } sas_linkspeed_names[] = {
150 { SAS_LINK_RATE_UNKNOWN, "Unknown" },
151 { SAS_PHY_DISABLED, "Phy disabled" },
152 { SAS_LINK_RATE_FAILED, "Link Rate failed" },
153 { SAS_SATA_SPINUP_HOLD, "Spin-up hold" },
154 { SAS_LINK_RATE_1_5_GBPS, "1.5 Gbit" },
155 { SAS_LINK_RATE_3_0_GBPS, "3.0 Gbit" },
156 { SAS_LINK_RATE_6_0_GBPS, "6.0 Gbit" },
157 { SAS_LINK_RATE_12_0_GBPS, "12.0 Gbit" },
158 { SAS_LINK_RATE_22_5_GBPS, "22.5 Gbit" },
159 };
sas_bitfield_name_search(linkspeed,sas_linkspeed_names)160 sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
161 sas_bitfield_name_set(linkspeed, sas_linkspeed_names)
162
163 static struct sas_end_device *sas_sdev_to_rdev(struct scsi_device *sdev)
164 {
165 struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
166 struct sas_end_device *rdev;
167
168 BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
169
170 rdev = rphy_to_end_device(rphy);
171 return rdev;
172 }
173
sas_smp_dispatch(struct bsg_job * job)174 static int sas_smp_dispatch(struct bsg_job *job)
175 {
176 struct Scsi_Host *shost = dev_to_shost(job->dev);
177 struct sas_rphy *rphy = NULL;
178
179 if (!scsi_is_host_device(job->dev))
180 rphy = dev_to_rphy(job->dev);
181
182 if (!job->reply_payload.payload_len) {
183 dev_warn(job->dev, "space for a smp response is missing\n");
184 bsg_job_done(job, -EINVAL, 0);
185 return 0;
186 }
187
188 to_sas_internal(shost->transportt)->f->smp_handler(job, shost, rphy);
189 return 0;
190 }
191
sas_bsg_initialize(struct Scsi_Host * shost,struct sas_rphy * rphy)192 static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
193 {
194 struct request_queue *q;
195
196 if (!to_sas_internal(shost->transportt)->f->smp_handler) {
197 printk("%s can't handle SMP requests\n", shost->hostt->name);
198 return 0;
199 }
200
201 if (rphy) {
202 q = bsg_setup_queue(&rphy->dev, dev_name(&rphy->dev), NULL,
203 sas_smp_dispatch, NULL, 0);
204 if (IS_ERR(q))
205 return PTR_ERR(q);
206 rphy->q = q;
207 } else {
208 char name[20];
209
210 snprintf(name, sizeof(name), "sas_host%d", shost->host_no);
211 q = bsg_setup_queue(&shost->shost_gendev, name, NULL,
212 sas_smp_dispatch, NULL, 0);
213 if (IS_ERR(q))
214 return PTR_ERR(q);
215 to_sas_host_attrs(shost)->q = q;
216 }
217
218 return 0;
219 }
220
221 /*
222 * SAS host attributes
223 */
224
sas_host_setup(struct transport_container * tc,struct device * dev,struct device * cdev)225 static int sas_host_setup(struct transport_container *tc, struct device *dev,
226 struct device *cdev)
227 {
228 struct Scsi_Host *shost = dev_to_shost(dev);
229 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
230 struct device *dma_dev = shost->dma_dev;
231
232 INIT_LIST_HEAD(&sas_host->rphy_list);
233 mutex_init(&sas_host->lock);
234 sas_host->next_target_id = 0;
235 sas_host->next_expander_id = 0;
236 sas_host->next_port_id = 0;
237
238 if (sas_bsg_initialize(shost, NULL))
239 dev_printk(KERN_ERR, dev, "fail to a bsg device %d\n",
240 shost->host_no);
241
242 if (dma_dev->dma_mask) {
243 shost->opt_sectors = min_t(unsigned int, shost->max_sectors,
244 dma_opt_mapping_size(dma_dev) >> SECTOR_SHIFT);
245 }
246
247 return 0;
248 }
249
sas_host_remove(struct transport_container * tc,struct device * dev,struct device * cdev)250 static int sas_host_remove(struct transport_container *tc, struct device *dev,
251 struct device *cdev)
252 {
253 struct Scsi_Host *shost = dev_to_shost(dev);
254 struct request_queue *q = to_sas_host_attrs(shost)->q;
255
256 bsg_remove_queue(q);
257 return 0;
258 }
259
260 static DECLARE_TRANSPORT_CLASS(sas_host_class,
261 "sas_host", sas_host_setup, sas_host_remove, NULL);
262
sas_host_match(struct attribute_container * cont,struct device * dev)263 static int sas_host_match(struct attribute_container *cont,
264 struct device *dev)
265 {
266 struct Scsi_Host *shost;
267 struct sas_internal *i;
268
269 if (!scsi_is_host_device(dev))
270 return 0;
271 shost = dev_to_shost(dev);
272
273 if (!shost->transportt)
274 return 0;
275 if (shost->transportt->host_attrs.ac.class !=
276 &sas_host_class.class)
277 return 0;
278
279 i = to_sas_internal(shost->transportt);
280 return &i->t.host_attrs.ac == cont;
281 }
282
do_sas_phy_delete(struct device * dev,void * data)283 static int do_sas_phy_delete(struct device *dev, void *data)
284 {
285 int pass = (int)(unsigned long)data;
286
287 if (pass == 0 && scsi_is_sas_port(dev))
288 sas_port_delete(dev_to_sas_port(dev));
289 else if (pass == 1 && scsi_is_sas_phy(dev))
290 sas_phy_delete(dev_to_phy(dev));
291 return 0;
292 }
293
294 /**
295 * sas_remove_children - tear down a devices SAS data structures
296 * @dev: device belonging to the sas object
297 *
298 * Removes all SAS PHYs and remote PHYs for a given object
299 */
sas_remove_children(struct device * dev)300 void sas_remove_children(struct device *dev)
301 {
302 device_for_each_child(dev, (void *)0, do_sas_phy_delete);
303 device_for_each_child(dev, (void *)1, do_sas_phy_delete);
304 }
305 EXPORT_SYMBOL(sas_remove_children);
306
307 /**
308 * sas_remove_host - tear down a Scsi_Host's SAS data structures
309 * @shost: Scsi Host that is torn down
310 *
311 * Removes all SAS PHYs and remote PHYs for a given Scsi_Host and remove the
312 * Scsi_Host as well.
313 *
314 * Note: Do not call scsi_remove_host() on the Scsi_Host any more, as it is
315 * already removed.
316 */
sas_remove_host(struct Scsi_Host * shost)317 void sas_remove_host(struct Scsi_Host *shost)
318 {
319 sas_remove_children(&shost->shost_gendev);
320 scsi_remove_host(shost);
321 }
322 EXPORT_SYMBOL(sas_remove_host);
323
324 /**
325 * sas_get_address - return the SAS address of the device
326 * @sdev: scsi device
327 *
328 * Returns the SAS address of the scsi device
329 */
sas_get_address(struct scsi_device * sdev)330 u64 sas_get_address(struct scsi_device *sdev)
331 {
332 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
333
334 return rdev->rphy.identify.sas_address;
335 }
336 EXPORT_SYMBOL(sas_get_address);
337
338 /**
339 * sas_tlr_supported - checking TLR bit in vpd 0x90
340 * @sdev: scsi device struct
341 *
342 * Check Transport Layer Retries are supported or not.
343 * If vpd page 0x90 is present, TRL is supported.
344 *
345 */
346 unsigned int
sas_tlr_supported(struct scsi_device * sdev)347 sas_tlr_supported(struct scsi_device *sdev)
348 {
349 const int vpd_len = 32;
350 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
351 char *buffer = kzalloc(vpd_len, GFP_KERNEL);
352 int ret = 0;
353
354 if (!buffer)
355 goto out;
356
357 if (scsi_get_vpd_page(sdev, 0x90, buffer, vpd_len))
358 goto out;
359
360 /*
361 * Magic numbers: the VPD Protocol page (0x90)
362 * has a 4 byte header and then one entry per device port
363 * the TLR bit is at offset 8 on each port entry
364 * if we take the first port, that's at total offset 12
365 */
366 ret = buffer[12] & 0x01;
367
368 out:
369 kfree(buffer);
370 rdev->tlr_supported = ret;
371 return ret;
372
373 }
374 EXPORT_SYMBOL_GPL(sas_tlr_supported);
375
376 /**
377 * sas_disable_tlr - setting TLR flags
378 * @sdev: scsi device struct
379 *
380 * Seting tlr_enabled flag to 0.
381 *
382 */
383 void
sas_disable_tlr(struct scsi_device * sdev)384 sas_disable_tlr(struct scsi_device *sdev)
385 {
386 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
387
388 rdev->tlr_enabled = 0;
389 }
390 EXPORT_SYMBOL_GPL(sas_disable_tlr);
391
392 /**
393 * sas_enable_tlr - setting TLR flags
394 * @sdev: scsi device struct
395 *
396 * Seting tlr_enabled flag 1.
397 *
398 */
sas_enable_tlr(struct scsi_device * sdev)399 void sas_enable_tlr(struct scsi_device *sdev)
400 {
401 unsigned int tlr_supported = 0;
402 tlr_supported = sas_tlr_supported(sdev);
403
404 if (tlr_supported) {
405 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
406
407 rdev->tlr_enabled = 1;
408 }
409
410 return;
411 }
412 EXPORT_SYMBOL_GPL(sas_enable_tlr);
413
sas_is_tlr_enabled(struct scsi_device * sdev)414 unsigned int sas_is_tlr_enabled(struct scsi_device *sdev)
415 {
416 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
417 return rdev->tlr_enabled;
418 }
419 EXPORT_SYMBOL_GPL(sas_is_tlr_enabled);
420
421 /**
422 * sas_ata_ncq_prio_supported - Check for ATA NCQ command priority support
423 * @sdev: SCSI device
424 *
425 * Check if an ATA device supports NCQ priority using VPD page 89h (ATA
426 * Information). Since this VPD page is implemented only for ATA devices,
427 * this function always returns false for SCSI devices.
428 */
sas_ata_ncq_prio_supported(struct scsi_device * sdev)429 bool sas_ata_ncq_prio_supported(struct scsi_device *sdev)
430 {
431 struct scsi_vpd *vpd;
432 bool ncq_prio_supported = false;
433
434 rcu_read_lock();
435 vpd = rcu_dereference(sdev->vpd_pg89);
436 if (vpd && vpd->len >= 214)
437 ncq_prio_supported = (vpd->data[213] >> 4) & 1;
438 rcu_read_unlock();
439
440 return ncq_prio_supported;
441 }
442 EXPORT_SYMBOL_GPL(sas_ata_ncq_prio_supported);
443
444 /*
445 * SAS Phy attributes
446 */
447
448 #define sas_phy_show_simple(field, name, format_string, cast) \
449 static ssize_t \
450 show_sas_phy_##name(struct device *dev, \
451 struct device_attribute *attr, char *buf) \
452 { \
453 struct sas_phy *phy = transport_class_to_phy(dev); \
454 \
455 return snprintf(buf, 20, format_string, cast phy->field); \
456 }
457
458 #define sas_phy_simple_attr(field, name, format_string, type) \
459 sas_phy_show_simple(field, name, format_string, (type)) \
460 static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
461
462 #define sas_phy_show_protocol(field, name) \
463 static ssize_t \
464 show_sas_phy_##name(struct device *dev, \
465 struct device_attribute *attr, char *buf) \
466 { \
467 struct sas_phy *phy = transport_class_to_phy(dev); \
468 \
469 if (!phy->field) \
470 return snprintf(buf, 20, "none\n"); \
471 return get_sas_protocol_names(phy->field, buf); \
472 }
473
474 #define sas_phy_protocol_attr(field, name) \
475 sas_phy_show_protocol(field, name) \
476 static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
477
478 #define sas_phy_show_linkspeed(field) \
479 static ssize_t \
480 show_sas_phy_##field(struct device *dev, \
481 struct device_attribute *attr, char *buf) \
482 { \
483 struct sas_phy *phy = transport_class_to_phy(dev); \
484 \
485 return get_sas_linkspeed_names(phy->field, buf); \
486 }
487
488 /* Fudge to tell if we're minimum or maximum */
489 #define sas_phy_store_linkspeed(field) \
490 static ssize_t \
491 store_sas_phy_##field(struct device *dev, \
492 struct device_attribute *attr, \
493 const char *buf, size_t count) \
494 { \
495 struct sas_phy *phy = transport_class_to_phy(dev); \
496 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
497 struct sas_internal *i = to_sas_internal(shost->transportt); \
498 u32 value; \
499 struct sas_phy_linkrates rates = {0}; \
500 int error; \
501 \
502 error = set_sas_linkspeed_names(&value, buf); \
503 if (error) \
504 return error; \
505 rates.field = value; \
506 error = i->f->set_phy_speed(phy, &rates); \
507 \
508 return error ? error : count; \
509 }
510
511 #define sas_phy_linkspeed_rw_attr(field) \
512 sas_phy_show_linkspeed(field) \
513 sas_phy_store_linkspeed(field) \
514 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, \
515 store_sas_phy_##field)
516
517 #define sas_phy_linkspeed_attr(field) \
518 sas_phy_show_linkspeed(field) \
519 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
520
521
522 #define sas_phy_show_linkerror(field) \
523 static ssize_t \
524 show_sas_phy_##field(struct device *dev, \
525 struct device_attribute *attr, char *buf) \
526 { \
527 struct sas_phy *phy = transport_class_to_phy(dev); \
528 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); \
529 struct sas_internal *i = to_sas_internal(shost->transportt); \
530 int error; \
531 \
532 error = i->f->get_linkerrors ? i->f->get_linkerrors(phy) : 0; \
533 if (error) \
534 return error; \
535 return snprintf(buf, 20, "%u\n", phy->field); \
536 }
537
538 #define sas_phy_linkerror_attr(field) \
539 sas_phy_show_linkerror(field) \
540 static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
541
542
543 static ssize_t
show_sas_device_type(struct device * dev,struct device_attribute * attr,char * buf)544 show_sas_device_type(struct device *dev,
545 struct device_attribute *attr, char *buf)
546 {
547 struct sas_phy *phy = transport_class_to_phy(dev);
548
549 if (!phy->identify.device_type)
550 return snprintf(buf, 20, "none\n");
551 return get_sas_device_type_names(phy->identify.device_type, buf);
552 }
553 static DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
554
do_sas_phy_enable(struct device * dev,size_t count,int enable)555 static ssize_t do_sas_phy_enable(struct device *dev,
556 size_t count, int enable)
557 {
558 struct sas_phy *phy = transport_class_to_phy(dev);
559 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
560 struct sas_internal *i = to_sas_internal(shost->transportt);
561 int error;
562
563 error = i->f->phy_enable(phy, enable);
564 if (error)
565 return error;
566 phy->enabled = enable;
567 return count;
568 };
569
570 static ssize_t
store_sas_phy_enable(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)571 store_sas_phy_enable(struct device *dev, struct device_attribute *attr,
572 const char *buf, size_t count)
573 {
574 if (count < 1)
575 return -EINVAL;
576
577 switch (buf[0]) {
578 case '0':
579 do_sas_phy_enable(dev, count, 0);
580 break;
581 case '1':
582 do_sas_phy_enable(dev, count, 1);
583 break;
584 default:
585 return -EINVAL;
586 }
587
588 return count;
589 }
590
591 static ssize_t
show_sas_phy_enable(struct device * dev,struct device_attribute * attr,char * buf)592 show_sas_phy_enable(struct device *dev, struct device_attribute *attr,
593 char *buf)
594 {
595 struct sas_phy *phy = transport_class_to_phy(dev);
596
597 return snprintf(buf, 20, "%d\n", phy->enabled);
598 }
599
600 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable,
601 store_sas_phy_enable);
602
603 static ssize_t
do_sas_phy_reset(struct device * dev,size_t count,int hard_reset)604 do_sas_phy_reset(struct device *dev, size_t count, int hard_reset)
605 {
606 struct sas_phy *phy = transport_class_to_phy(dev);
607 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
608 struct sas_internal *i = to_sas_internal(shost->transportt);
609 int error;
610
611 error = i->f->phy_reset(phy, hard_reset);
612 if (error)
613 return error;
614 phy->enabled = 1;
615 return count;
616 };
617
618 static ssize_t
store_sas_link_reset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)619 store_sas_link_reset(struct device *dev, struct device_attribute *attr,
620 const char *buf, size_t count)
621 {
622 return do_sas_phy_reset(dev, count, 0);
623 }
624 static DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset);
625
626 static ssize_t
store_sas_hard_reset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)627 store_sas_hard_reset(struct device *dev, struct device_attribute *attr,
628 const char *buf, size_t count)
629 {
630 return do_sas_phy_reset(dev, count, 1);
631 }
632 static DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset);
633
634 sas_phy_protocol_attr(identify.initiator_port_protocols,
635 initiator_port_protocols);
636 sas_phy_protocol_attr(identify.target_port_protocols,
637 target_port_protocols);
638 sas_phy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
639 unsigned long long);
640 sas_phy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
641 sas_phy_linkspeed_attr(negotiated_linkrate);
642 sas_phy_linkspeed_attr(minimum_linkrate_hw);
643 sas_phy_linkspeed_rw_attr(minimum_linkrate);
644 sas_phy_linkspeed_attr(maximum_linkrate_hw);
645 sas_phy_linkspeed_rw_attr(maximum_linkrate);
646 sas_phy_linkerror_attr(invalid_dword_count);
647 sas_phy_linkerror_attr(running_disparity_error_count);
648 sas_phy_linkerror_attr(loss_of_dword_sync_count);
649 sas_phy_linkerror_attr(phy_reset_problem_count);
650
sas_phy_setup(struct transport_container * tc,struct device * dev,struct device * cdev)651 static int sas_phy_setup(struct transport_container *tc, struct device *dev,
652 struct device *cdev)
653 {
654 struct sas_phy *phy = dev_to_phy(dev);
655 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
656 struct sas_internal *i = to_sas_internal(shost->transportt);
657
658 if (i->f->phy_setup)
659 i->f->phy_setup(phy);
660
661 return 0;
662 }
663
664 static DECLARE_TRANSPORT_CLASS(sas_phy_class,
665 "sas_phy", sas_phy_setup, NULL, NULL);
666
sas_phy_match(struct attribute_container * cont,struct device * dev)667 static int sas_phy_match(struct attribute_container *cont, struct device *dev)
668 {
669 struct Scsi_Host *shost;
670 struct sas_internal *i;
671
672 if (!scsi_is_sas_phy(dev))
673 return 0;
674 shost = dev_to_shost(dev->parent);
675
676 if (!shost->transportt)
677 return 0;
678 if (shost->transportt->host_attrs.ac.class !=
679 &sas_host_class.class)
680 return 0;
681
682 i = to_sas_internal(shost->transportt);
683 return &i->phy_attr_cont.ac == cont;
684 }
685
sas_phy_release(struct device * dev)686 static void sas_phy_release(struct device *dev)
687 {
688 struct sas_phy *phy = dev_to_phy(dev);
689 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
690 struct sas_internal *i = to_sas_internal(shost->transportt);
691
692 if (i->f->phy_release)
693 i->f->phy_release(phy);
694 put_device(dev->parent);
695 kfree(phy);
696 }
697
698 /**
699 * sas_phy_alloc - allocates and initialize a SAS PHY structure
700 * @parent: Parent device
701 * @number: Phy index
702 *
703 * Allocates an SAS PHY structure. It will be added in the device tree
704 * below the device specified by @parent, which has to be either a Scsi_Host
705 * or sas_rphy.
706 *
707 * Returns:
708 * SAS PHY allocated or %NULL if the allocation failed.
709 */
sas_phy_alloc(struct device * parent,int number)710 struct sas_phy *sas_phy_alloc(struct device *parent, int number)
711 {
712 struct Scsi_Host *shost = dev_to_shost(parent);
713 struct sas_phy *phy;
714
715 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
716 if (!phy)
717 return NULL;
718
719 phy->number = number;
720 phy->enabled = 1;
721
722 device_initialize(&phy->dev);
723 phy->dev.parent = get_device(parent);
724 phy->dev.release = sas_phy_release;
725 INIT_LIST_HEAD(&phy->port_siblings);
726 if (scsi_is_sas_expander_device(parent)) {
727 struct sas_rphy *rphy = dev_to_rphy(parent);
728 dev_set_name(&phy->dev, "phy-%d:%d:%d", shost->host_no,
729 rphy->scsi_target_id, number);
730 } else
731 dev_set_name(&phy->dev, "phy-%d:%d", shost->host_no, number);
732
733 transport_setup_device(&phy->dev);
734
735 return phy;
736 }
737 EXPORT_SYMBOL(sas_phy_alloc);
738
739 /**
740 * sas_phy_add - add a SAS PHY to the device hierarchy
741 * @phy: The PHY to be added
742 *
743 * Publishes a SAS PHY to the rest of the system.
744 */
sas_phy_add(struct sas_phy * phy)745 int sas_phy_add(struct sas_phy *phy)
746 {
747 int error;
748
749 error = device_add(&phy->dev);
750 if (error)
751 return error;
752
753 error = transport_add_device(&phy->dev);
754 if (error) {
755 device_del(&phy->dev);
756 return error;
757 }
758 transport_configure_device(&phy->dev);
759
760 return 0;
761 }
762 EXPORT_SYMBOL(sas_phy_add);
763
764 /**
765 * sas_phy_free - free a SAS PHY
766 * @phy: SAS PHY to free
767 *
768 * Frees the specified SAS PHY.
769 *
770 * Note:
771 * This function must only be called on a PHY that has not
772 * successfully been added using sas_phy_add().
773 */
sas_phy_free(struct sas_phy * phy)774 void sas_phy_free(struct sas_phy *phy)
775 {
776 transport_destroy_device(&phy->dev);
777 put_device(&phy->dev);
778 }
779 EXPORT_SYMBOL(sas_phy_free);
780
781 /**
782 * sas_phy_delete - remove SAS PHY
783 * @phy: SAS PHY to remove
784 *
785 * Removes the specified SAS PHY. If the SAS PHY has an
786 * associated remote PHY it is removed before.
787 */
788 void
sas_phy_delete(struct sas_phy * phy)789 sas_phy_delete(struct sas_phy *phy)
790 {
791 struct device *dev = &phy->dev;
792
793 /* this happens if the phy is still part of a port when deleted */
794 BUG_ON(!list_empty(&phy->port_siblings));
795
796 transport_remove_device(dev);
797 device_del(dev);
798 transport_destroy_device(dev);
799 put_device(dev);
800 }
801 EXPORT_SYMBOL(sas_phy_delete);
802
803 /**
804 * scsi_is_sas_phy - check if a struct device represents a SAS PHY
805 * @dev: device to check
806 *
807 * Returns:
808 * %1 if the device represents a SAS PHY, %0 else
809 */
scsi_is_sas_phy(const struct device * dev)810 int scsi_is_sas_phy(const struct device *dev)
811 {
812 return dev->release == sas_phy_release;
813 }
814 EXPORT_SYMBOL(scsi_is_sas_phy);
815
816 /*
817 * SAS Port attributes
818 */
819 #define sas_port_show_simple(field, name, format_string, cast) \
820 static ssize_t \
821 show_sas_port_##name(struct device *dev, \
822 struct device_attribute *attr, char *buf) \
823 { \
824 struct sas_port *port = transport_class_to_sas_port(dev); \
825 \
826 return snprintf(buf, 20, format_string, cast port->field); \
827 }
828
829 #define sas_port_simple_attr(field, name, format_string, type) \
830 sas_port_show_simple(field, name, format_string, (type)) \
831 static DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
832
833 sas_port_simple_attr(num_phys, num_phys, "%d\n", int);
834
835 static DECLARE_TRANSPORT_CLASS(sas_port_class,
836 "sas_port", NULL, NULL, NULL);
837
sas_port_match(struct attribute_container * cont,struct device * dev)838 static int sas_port_match(struct attribute_container *cont, struct device *dev)
839 {
840 struct Scsi_Host *shost;
841 struct sas_internal *i;
842
843 if (!scsi_is_sas_port(dev))
844 return 0;
845 shost = dev_to_shost(dev->parent);
846
847 if (!shost->transportt)
848 return 0;
849 if (shost->transportt->host_attrs.ac.class !=
850 &sas_host_class.class)
851 return 0;
852
853 i = to_sas_internal(shost->transportt);
854 return &i->port_attr_cont.ac == cont;
855 }
856
857
sas_port_release(struct device * dev)858 static void sas_port_release(struct device *dev)
859 {
860 struct sas_port *port = dev_to_sas_port(dev);
861
862 BUG_ON(!list_empty(&port->phy_list));
863
864 put_device(dev->parent);
865 kfree(port);
866 }
867
sas_port_create_link(struct sas_port * port,struct sas_phy * phy)868 static void sas_port_create_link(struct sas_port *port,
869 struct sas_phy *phy)
870 {
871 int res;
872
873 res = sysfs_create_link(&port->dev.kobj, &phy->dev.kobj,
874 dev_name(&phy->dev));
875 if (res)
876 goto err;
877 res = sysfs_create_link(&phy->dev.kobj, &port->dev.kobj, "port");
878 if (res)
879 goto err;
880 return;
881 err:
882 printk(KERN_ERR "%s: Cannot create port links, err=%d\n",
883 __func__, res);
884 }
885
sas_port_delete_link(struct sas_port * port,struct sas_phy * phy)886 static void sas_port_delete_link(struct sas_port *port,
887 struct sas_phy *phy)
888 {
889 sysfs_remove_link(&port->dev.kobj, dev_name(&phy->dev));
890 sysfs_remove_link(&phy->dev.kobj, "port");
891 }
892
893 /** sas_port_alloc - allocate and initialize a SAS port structure
894 *
895 * @parent: parent device
896 * @port_id: port number
897 *
898 * Allocates a SAS port structure. It will be added to the device tree
899 * below the device specified by @parent which must be either a Scsi_Host
900 * or a sas_expander_device.
901 *
902 * Returns %NULL on error
903 */
sas_port_alloc(struct device * parent,int port_id)904 struct sas_port *sas_port_alloc(struct device *parent, int port_id)
905 {
906 struct Scsi_Host *shost = dev_to_shost(parent);
907 struct sas_port *port;
908
909 port = kzalloc(sizeof(*port), GFP_KERNEL);
910 if (!port)
911 return NULL;
912
913 port->port_identifier = port_id;
914
915 device_initialize(&port->dev);
916
917 port->dev.parent = get_device(parent);
918 port->dev.release = sas_port_release;
919
920 mutex_init(&port->phy_list_mutex);
921 INIT_LIST_HEAD(&port->phy_list);
922
923 if (scsi_is_sas_expander_device(parent)) {
924 struct sas_rphy *rphy = dev_to_rphy(parent);
925 dev_set_name(&port->dev, "port-%d:%d:%d", shost->host_no,
926 rphy->scsi_target_id, port->port_identifier);
927 } else
928 dev_set_name(&port->dev, "port-%d:%d", shost->host_no,
929 port->port_identifier);
930
931 transport_setup_device(&port->dev);
932
933 return port;
934 }
935 EXPORT_SYMBOL(sas_port_alloc);
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
scan_channel_zero(struct Scsi_Host * shost,uint id,u64 lun)1686 static void scan_channel_zero(struct Scsi_Host *shost, uint id, u64 lun)
1687 {
1688 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1689 struct sas_rphy *rphy;
1690
1691 list_for_each_entry(rphy, &sas_host->rphy_list, list) {
1692 if (rphy->identify.device_type != SAS_END_DEVICE ||
1693 rphy->scsi_target_id == -1)
1694 continue;
1695
1696 if (id == SCAN_WILD_CARD || id == rphy->scsi_target_id) {
1697 scsi_scan_target(&rphy->dev, 0, rphy->scsi_target_id,
1698 lun, SCSI_SCAN_MANUAL);
1699 }
1700 }
1701 }
1702
1703 /*
1704 * SCSI scan helper
1705 */
1706
sas_user_scan(struct Scsi_Host * shost,uint channel,uint id,u64 lun)1707 static int sas_user_scan(struct Scsi_Host *shost, uint channel,
1708 uint id, u64 lun)
1709 {
1710 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1711 int res = 0;
1712 int i;
1713
1714 switch (channel) {
1715 case 0:
1716 mutex_lock(&sas_host->lock);
1717 scan_channel_zero(shost, id, lun);
1718 mutex_unlock(&sas_host->lock);
1719 break;
1720
1721 case SCAN_WILD_CARD:
1722 mutex_lock(&sas_host->lock);
1723 scan_channel_zero(shost, id, lun);
1724 mutex_unlock(&sas_host->lock);
1725
1726 for (i = 1; i <= shost->max_channel; i++) {
1727 res = scsi_scan_host_selected(shost, i, id, lun,
1728 SCSI_SCAN_MANUAL);
1729 if (res)
1730 goto exit_scan;
1731 }
1732 break;
1733
1734 default:
1735 if (channel < shost->max_channel) {
1736 res = scsi_scan_host_selected(shost, channel, id, lun,
1737 SCSI_SCAN_MANUAL);
1738 } else {
1739 res = -EINVAL;
1740 }
1741 break;
1742 }
1743
1744 exit_scan:
1745 return res;
1746 }
1747
1748
1749 /*
1750 * Setup / Teardown code
1751 */
1752
1753 #define SETUP_TEMPLATE(attrb, field, perm, test) \
1754 i->private_##attrb[count] = dev_attr_##field; \
1755 i->private_##attrb[count].attr.mode = perm; \
1756 i->attrb[count] = &i->private_##attrb[count]; \
1757 if (test) \
1758 count++
1759
1760 #define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \
1761 i->private_##attrb[count] = dev_attr_##field; \
1762 i->private_##attrb[count].attr.mode = perm; \
1763 if (ro_test) { \
1764 i->private_##attrb[count].attr.mode = ro_perm; \
1765 i->private_##attrb[count].store = NULL; \
1766 } \
1767 i->attrb[count] = &i->private_##attrb[count]; \
1768 if (test) \
1769 count++
1770
1771 #define SETUP_RPORT_ATTRIBUTE(field) \
1772 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, 1)
1773
1774 #define SETUP_OPTIONAL_RPORT_ATTRIBUTE(field, func) \
1775 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, i->f->func)
1776
1777 #define SETUP_PHY_ATTRIBUTE(field) \
1778 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, 1)
1779
1780 #define SETUP_PHY_ATTRIBUTE_RW(field) \
1781 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1782 !i->f->set_phy_speed, S_IRUGO)
1783
1784 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(field, func) \
1785 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1786 !i->f->func, S_IRUGO)
1787
1788 #define SETUP_PORT_ATTRIBUTE(field) \
1789 SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1)
1790
1791 #define SETUP_OPTIONAL_PHY_ATTRIBUTE(field, func) \
1792 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, i->f->func)
1793
1794 #define SETUP_PHY_ATTRIBUTE_WRONLY(field) \
1795 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, 1)
1796
1797 #define SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(field, func) \
1798 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, i->f->func)
1799
1800 #define SETUP_END_DEV_ATTRIBUTE(field) \
1801 SETUP_TEMPLATE(end_dev_attrs, field, S_IRUGO, 1)
1802
1803 #define SETUP_EXPANDER_ATTRIBUTE(field) \
1804 SETUP_TEMPLATE(expander_attrs, expander_##field, S_IRUGO, 1)
1805
1806 /**
1807 * sas_attach_transport - instantiate SAS transport template
1808 * @ft: SAS transport class function template
1809 */
1810 struct scsi_transport_template *
sas_attach_transport(struct sas_function_template * ft)1811 sas_attach_transport(struct sas_function_template *ft)
1812 {
1813 struct sas_internal *i;
1814 int count;
1815
1816 i = kzalloc(sizeof(struct sas_internal), GFP_KERNEL);
1817 if (!i)
1818 return NULL;
1819
1820 i->t.user_scan = sas_user_scan;
1821
1822 i->t.host_attrs.ac.attrs = &i->host_attrs[0];
1823 i->t.host_attrs.ac.class = &sas_host_class.class;
1824 i->t.host_attrs.ac.match = sas_host_match;
1825 transport_container_register(&i->t.host_attrs);
1826 i->t.host_size = sizeof(struct sas_host_attrs);
1827
1828 i->phy_attr_cont.ac.class = &sas_phy_class.class;
1829 i->phy_attr_cont.ac.attrs = &i->phy_attrs[0];
1830 i->phy_attr_cont.ac.match = sas_phy_match;
1831 transport_container_register(&i->phy_attr_cont);
1832
1833 i->port_attr_cont.ac.class = &sas_port_class.class;
1834 i->port_attr_cont.ac.attrs = &i->port_attrs[0];
1835 i->port_attr_cont.ac.match = sas_port_match;
1836 transport_container_register(&i->port_attr_cont);
1837
1838 i->rphy_attr_cont.ac.class = &sas_rphy_class.class;
1839 i->rphy_attr_cont.ac.attrs = &i->rphy_attrs[0];
1840 i->rphy_attr_cont.ac.match = sas_rphy_match;
1841 transport_container_register(&i->rphy_attr_cont);
1842
1843 i->end_dev_attr_cont.ac.class = &sas_end_dev_class.class;
1844 i->end_dev_attr_cont.ac.attrs = &i->end_dev_attrs[0];
1845 i->end_dev_attr_cont.ac.match = sas_end_dev_match;
1846 transport_container_register(&i->end_dev_attr_cont);
1847
1848 i->expander_attr_cont.ac.class = &sas_expander_class.class;
1849 i->expander_attr_cont.ac.attrs = &i->expander_attrs[0];
1850 i->expander_attr_cont.ac.match = sas_expander_match;
1851 transport_container_register(&i->expander_attr_cont);
1852
1853 i->f = ft;
1854
1855 count = 0;
1856 SETUP_PHY_ATTRIBUTE(initiator_port_protocols);
1857 SETUP_PHY_ATTRIBUTE(target_port_protocols);
1858 SETUP_PHY_ATTRIBUTE(device_type);
1859 SETUP_PHY_ATTRIBUTE(sas_address);
1860 SETUP_PHY_ATTRIBUTE(phy_identifier);
1861 SETUP_PHY_ATTRIBUTE(negotiated_linkrate);
1862 SETUP_PHY_ATTRIBUTE(minimum_linkrate_hw);
1863 SETUP_PHY_ATTRIBUTE_RW(minimum_linkrate);
1864 SETUP_PHY_ATTRIBUTE(maximum_linkrate_hw);
1865 SETUP_PHY_ATTRIBUTE_RW(maximum_linkrate);
1866
1867 SETUP_PHY_ATTRIBUTE(invalid_dword_count);
1868 SETUP_PHY_ATTRIBUTE(running_disparity_error_count);
1869 SETUP_PHY_ATTRIBUTE(loss_of_dword_sync_count);
1870 SETUP_PHY_ATTRIBUTE(phy_reset_problem_count);
1871 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(link_reset, phy_reset);
1872 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(hard_reset, phy_reset);
1873 SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(enable, phy_enable);
1874 i->phy_attrs[count] = NULL;
1875
1876 count = 0;
1877 SETUP_PORT_ATTRIBUTE(num_phys);
1878 i->port_attrs[count] = NULL;
1879
1880 count = 0;
1881 SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols);
1882 SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols);
1883 SETUP_RPORT_ATTRIBUTE(rphy_device_type);
1884 SETUP_RPORT_ATTRIBUTE(rphy_sas_address);
1885 SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier);
1886 SETUP_RPORT_ATTRIBUTE(rphy_scsi_target_id);
1887 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_enclosure_identifier,
1888 get_enclosure_identifier);
1889 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_bay_identifier,
1890 get_bay_identifier);
1891 i->rphy_attrs[count] = NULL;
1892
1893 count = 0;
1894 SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning);
1895 SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout);
1896 SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout);
1897 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_supported);
1898 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_enabled);
1899 i->end_dev_attrs[count] = NULL;
1900
1901 count = 0;
1902 SETUP_EXPANDER_ATTRIBUTE(vendor_id);
1903 SETUP_EXPANDER_ATTRIBUTE(product_id);
1904 SETUP_EXPANDER_ATTRIBUTE(product_rev);
1905 SETUP_EXPANDER_ATTRIBUTE(component_vendor_id);
1906 SETUP_EXPANDER_ATTRIBUTE(component_id);
1907 SETUP_EXPANDER_ATTRIBUTE(component_revision_id);
1908 SETUP_EXPANDER_ATTRIBUTE(level);
1909 i->expander_attrs[count] = NULL;
1910
1911 return &i->t;
1912 }
1913 EXPORT_SYMBOL(sas_attach_transport);
1914
1915 /**
1916 * sas_release_transport - release SAS transport template instance
1917 * @t: transport template instance
1918 */
sas_release_transport(struct scsi_transport_template * t)1919 void sas_release_transport(struct scsi_transport_template *t)
1920 {
1921 struct sas_internal *i = to_sas_internal(t);
1922
1923 transport_container_unregister(&i->t.host_attrs);
1924 transport_container_unregister(&i->phy_attr_cont);
1925 transport_container_unregister(&i->port_attr_cont);
1926 transport_container_unregister(&i->rphy_attr_cont);
1927 transport_container_unregister(&i->end_dev_attr_cont);
1928 transport_container_unregister(&i->expander_attr_cont);
1929
1930 kfree(i);
1931 }
1932 EXPORT_SYMBOL(sas_release_transport);
1933
sas_transport_init(void)1934 static __init int sas_transport_init(void)
1935 {
1936 int error;
1937
1938 error = transport_class_register(&sas_host_class);
1939 if (error)
1940 goto out;
1941 error = transport_class_register(&sas_phy_class);
1942 if (error)
1943 goto out_unregister_transport;
1944 error = transport_class_register(&sas_port_class);
1945 if (error)
1946 goto out_unregister_phy;
1947 error = transport_class_register(&sas_rphy_class);
1948 if (error)
1949 goto out_unregister_port;
1950 error = transport_class_register(&sas_end_dev_class);
1951 if (error)
1952 goto out_unregister_rphy;
1953 error = transport_class_register(&sas_expander_class);
1954 if (error)
1955 goto out_unregister_end_dev;
1956
1957 return 0;
1958
1959 out_unregister_end_dev:
1960 transport_class_unregister(&sas_end_dev_class);
1961 out_unregister_rphy:
1962 transport_class_unregister(&sas_rphy_class);
1963 out_unregister_port:
1964 transport_class_unregister(&sas_port_class);
1965 out_unregister_phy:
1966 transport_class_unregister(&sas_phy_class);
1967 out_unregister_transport:
1968 transport_class_unregister(&sas_host_class);
1969 out:
1970 return error;
1971
1972 }
1973
sas_transport_exit(void)1974 static void __exit sas_transport_exit(void)
1975 {
1976 transport_class_unregister(&sas_host_class);
1977 transport_class_unregister(&sas_phy_class);
1978 transport_class_unregister(&sas_port_class);
1979 transport_class_unregister(&sas_rphy_class);
1980 transport_class_unregister(&sas_end_dev_class);
1981 transport_class_unregister(&sas_expander_class);
1982 }
1983
1984 MODULE_AUTHOR("Christoph Hellwig");
1985 MODULE_DESCRIPTION("SAS Transport Attributes");
1986 MODULE_LICENSE("GPL");
1987
1988 module_init(sas_transport_init);
1989 module_exit(sas_transport_exit);
1990