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
45struct 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) \
69static ssize_t \
70get_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) \
88static ssize_t \
89set_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) \
106static ssize_t \
107get_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
123static 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};
132sas_bitfield_name_search(device_type, sas_device_type_names)
133
134
135static 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};
144sas_bitfield_name_match(protocol, sas_protocol_names)
145
146static 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};
160sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
161sas_bitfield_name_set(linkspeed, sas_linkspeed_names)
162
163static 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
174static int sas_smp_dispatch(struct bsg_job *job)
175{
176 struct Scsi_Host *shost = dev_to_shost(dev: 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, result: -EINVAL, reply_payload_rcv_len: 0);
185 return 0;
186 }
187
188 to_sas_internal(shost->transportt)->f->smp_handler(job, shost, rphy);
189 return 0;
190}
191
192static 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(dev: &rphy->dev, name: dev_name(dev: &rphy->dev), NULL,
203 job_fn: sas_smp_dispatch, NULL, dd_job_size: 0);
204 if (IS_ERR(ptr: q))
205 return PTR_ERR(ptr: q);
206 rphy->q = q;
207 } else {
208 char name[20];
209
210 snprintf(buf: name, size: sizeof(name), fmt: "sas_host%d", shost->host_no);
211 q = bsg_setup_queue(dev: &shost->shost_gendev, name, NULL,
212 job_fn: sas_smp_dispatch, NULL, dd_job_size: 0);
213 if (IS_ERR(ptr: q))
214 return PTR_ERR(ptr: q);
215 to_sas_host_attrs(shost)->q = q;
216 }
217
218 return 0;
219}
220
221/*
222 * SAS host attributes
223 */
224
225static 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(list: &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
250static 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
260static DECLARE_TRANSPORT_CLASS(sas_host_class,
261 "sas_host", sas_host_setup, sas_host_remove, NULL);
262
263static 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
283static 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 */
300void sas_remove_children(struct device *dev)
301{
302 device_for_each_child(parent: dev, data: (void *)0, fn: do_sas_phy_delete);
303 device_for_each_child(parent: dev, data: (void *)1, fn: do_sas_phy_delete);
304}
305EXPORT_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 */
317void sas_remove_host(struct Scsi_Host *shost)
318{
319 sas_remove_children(&shost->shost_gendev);
320 scsi_remove_host(shost);
321}
322EXPORT_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 */
330u64 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}
336EXPORT_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 */
346unsigned int
347sas_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, page: 0x90, buf: buffer, buf_len: 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(objp: buffer);
370 rdev->tlr_supported = ret;
371 return ret;
372
373}
374EXPORT_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 */
383void
384sas_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}
390EXPORT_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 */
399void 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}
412EXPORT_SYMBOL_GPL(sas_enable_tlr);
413
414unsigned 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}
419EXPORT_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 */
429bool 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}
442EXPORT_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) \
449static ssize_t \
450show_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)) \
460static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
461
462#define sas_phy_show_protocol(field, name) \
463static ssize_t \
464show_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) \
476static DEVICE_ATTR(name, S_IRUGO, show_sas_phy_##name, NULL)
477
478#define sas_phy_show_linkspeed(field) \
479static ssize_t \
480show_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) \
490static ssize_t \
491store_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) \
514static 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) \
519static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
520
521
522#define sas_phy_show_linkerror(field) \
523static ssize_t \
524show_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) \
540static DEVICE_ATTR(field, S_IRUGO, show_sas_phy_##field, NULL)
541
542
543static ssize_t
544show_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, size: 20, fmt: "none\n");
551 return get_sas_device_type_names(table_key: phy->identify.device_type, buf);
552}
553static DEVICE_ATTR(device_type, S_IRUGO, show_sas_device_type, NULL);
554
555static 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(dev: 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
570static ssize_t
571store_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, enable: 0);
580 break;
581 case '1':
582 do_sas_phy_enable(dev, count, enable: 1);
583 break;
584 default:
585 return -EINVAL;
586 }
587
588 return count;
589}
590
591static ssize_t
592show_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, size: 20, fmt: "%d\n", phy->enabled);
598}
599
600static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, show_sas_phy_enable,
601 store_sas_phy_enable);
602
603static ssize_t
604do_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(dev: 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
618static ssize_t
619store_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, hard_reset: 0);
623}
624static DEVICE_ATTR(link_reset, S_IWUSR, NULL, store_sas_link_reset);
625
626static ssize_t
627store_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, hard_reset: 1);
631}
632static DEVICE_ATTR(hard_reset, S_IWUSR, NULL, store_sas_hard_reset);
633
634sas_phy_protocol_attr(identify.initiator_port_protocols,
635 initiator_port_protocols);
636sas_phy_protocol_attr(identify.target_port_protocols,
637 target_port_protocols);
638sas_phy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
639 unsigned long long);
640sas_phy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
641sas_phy_linkspeed_attr(negotiated_linkrate);
642sas_phy_linkspeed_attr(minimum_linkrate_hw);
643sas_phy_linkspeed_rw_attr(minimum_linkrate);
644sas_phy_linkspeed_attr(maximum_linkrate_hw);
645sas_phy_linkspeed_rw_attr(maximum_linkrate);
646sas_phy_linkerror_attr(invalid_dword_count);
647sas_phy_linkerror_attr(running_disparity_error_count);
648sas_phy_linkerror_attr(loss_of_dword_sync_count);
649sas_phy_linkerror_attr(phy_reset_problem_count);
650
651static 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(dev: 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
664static DECLARE_TRANSPORT_CLASS(sas_phy_class,
665 "sas_phy", sas_phy_setup, NULL, NULL);
666
667static 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: 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
686static 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(dev: 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: dev->parent);
695 kfree(objp: 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 */
710struct sas_phy *sas_phy_alloc(struct device *parent, int number)
711{
712 struct Scsi_Host *shost = dev_to_shost(dev: 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(dev: &phy->dev);
723 phy->dev.parent = get_device(dev: parent);
724 phy->dev.release = sas_phy_release;
725 INIT_LIST_HEAD(list: &phy->port_siblings);
726 if (scsi_is_sas_expander_device(dev: parent)) {
727 struct sas_rphy *rphy = dev_to_rphy(parent);
728 dev_set_name(dev: &phy->dev, name: "phy-%d:%d:%d", shost->host_no,
729 rphy->scsi_target_id, number);
730 } else
731 dev_set_name(dev: &phy->dev, name: "phy-%d:%d", shost->host_no, number);
732
733 transport_setup_device(&phy->dev);
734
735 return phy;
736}
737EXPORT_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 */
745int sas_phy_add(struct sas_phy *phy)
746{
747 int error;
748
749 error = device_add(dev: &phy->dev);
750 if (error)
751 return error;
752
753 error = transport_add_device(&phy->dev);
754 if (error) {
755 device_del(dev: &phy->dev);
756 return error;
757 }
758 transport_configure_device(&phy->dev);
759
760 return 0;
761}
762EXPORT_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 */
774void sas_phy_free(struct sas_phy *phy)
775{
776 transport_destroy_device(&phy->dev);
777 put_device(dev: &phy->dev);
778}
779EXPORT_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 */
788void
789sas_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}
801EXPORT_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 */
810int scsi_is_sas_phy(const struct device *dev)
811{
812 return dev->release == sas_phy_release;
813}
814EXPORT_SYMBOL(scsi_is_sas_phy);
815
816/*
817 * SAS Port attributes
818 */
819#define sas_port_show_simple(field, name, format_string, cast) \
820static ssize_t \
821show_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)) \
831static DEVICE_ATTR(name, S_IRUGO, show_sas_port_##name, NULL)
832
833sas_port_simple_attr(num_phys, num_phys, "%d\n", int);
834
835static DECLARE_TRANSPORT_CLASS(sas_port_class,
836 "sas_port", NULL, NULL, NULL);
837
838static 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: 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
858static 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: dev->parent);
865 kfree(objp: port);
866}
867
868static void sas_port_create_link(struct sas_port *port,
869 struct sas_phy *phy)
870{
871 int res;
872
873 res = sysfs_create_link(kobj: &port->dev.kobj, target: &phy->dev.kobj,
874 name: dev_name(dev: &phy->dev));
875 if (res)
876 goto err;
877 res = sysfs_create_link(kobj: &phy->dev.kobj, target: &port->dev.kobj, name: "port");
878 if (res)
879 goto err;
880 return;
881err:
882 printk(KERN_ERR "%s: Cannot create port links, err=%d\n",
883 __func__, res);
884}
885
886static void sas_port_delete_link(struct sas_port *port,
887 struct sas_phy *phy)
888{
889 sysfs_remove_link(kobj: &port->dev.kobj, name: dev_name(dev: &phy->dev));
890 sysfs_remove_link(kobj: &phy->dev.kobj, name: "port");
891}
892
893/**
894 * sas_port_alloc - allocate and initialize a SAS port structure
895 *
896 * @parent: parent device
897 * @port_id: port number
898 *
899 * Allocates a SAS port structure. It will be added to the device tree
900 * below the device specified by @parent which must be either a Scsi_Host
901 * or a sas_expander_device.
902 *
903 * Returns: %NULL on error
904 */
905struct sas_port *sas_port_alloc(struct device *parent, int port_id)
906{
907 struct Scsi_Host *shost = dev_to_shost(dev: parent);
908 struct sas_port *port;
909
910 port = kzalloc(sizeof(*port), GFP_KERNEL);
911 if (!port)
912 return NULL;
913
914 port->port_identifier = port_id;
915
916 device_initialize(dev: &port->dev);
917
918 port->dev.parent = get_device(dev: parent);
919 port->dev.release = sas_port_release;
920
921 mutex_init(&port->phy_list_mutex);
922 INIT_LIST_HEAD(list: &port->phy_list);
923
924 if (scsi_is_sas_expander_device(dev: parent)) {
925 struct sas_rphy *rphy = dev_to_rphy(parent);
926 dev_set_name(dev: &port->dev, name: "port-%d:%d:%d", shost->host_no,
927 rphy->scsi_target_id, port->port_identifier);
928 } else
929 dev_set_name(dev: &port->dev, name: "port-%d:%d", shost->host_no,
930 port->port_identifier);
931
932 transport_setup_device(&port->dev);
933
934 return port;
935}
936EXPORT_SYMBOL(sas_port_alloc);
937
938/**
939 * sas_port_alloc_num - allocate and initialize a SAS port structure
940 *
941 * @parent: parent device
942 *
943 * Allocates a SAS port structure and a number to go with it. This
944 * interface is really for adapters where the port number has no
945 * meansing, so the sas class should manage them. It will be added to
946 * the device tree below the device specified by @parent which must be
947 * either a Scsi_Host or a sas_expander_device.
948 *
949 * Returns: %NULL on error
950 */
951struct sas_port *sas_port_alloc_num(struct device *parent)
952{
953 int index;
954 struct Scsi_Host *shost = dev_to_shost(dev: parent);
955 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
956
957 /* FIXME: use idr for this eventually */
958 mutex_lock(&sas_host->lock);
959 if (scsi_is_sas_expander_device(dev: parent)) {
960 struct sas_rphy *rphy = dev_to_rphy(parent);
961 struct sas_expander_device *exp = rphy_to_expander_device(rphy);
962
963 index = exp->next_port_id++;
964 } else
965 index = sas_host->next_port_id++;
966 mutex_unlock(lock: &sas_host->lock);
967 return sas_port_alloc(parent, index);
968}
969EXPORT_SYMBOL(sas_port_alloc_num);
970
971/**
972 * sas_port_add - add a SAS port to the device hierarchy
973 * @port: port to be added
974 *
975 * publishes a port to the rest of the system
976 */
977int sas_port_add(struct sas_port *port)
978{
979 int error;
980
981 /* No phys should be added until this is made visible */
982 BUG_ON(!list_empty(&port->phy_list));
983
984 error = device_add(dev: &port->dev);
985
986 if (error)
987 return error;
988
989 transport_add_device(&port->dev);
990 transport_configure_device(&port->dev);
991
992 return 0;
993}
994EXPORT_SYMBOL(sas_port_add);
995
996/**
997 * sas_port_free - free a SAS PORT
998 * @port: SAS PORT to free
999 *
1000 * Frees the specified SAS PORT.
1001 *
1002 * Note:
1003 * This function must only be called on a PORT that has not
1004 * successfully been added using sas_port_add().
1005 */
1006void sas_port_free(struct sas_port *port)
1007{
1008 transport_destroy_device(&port->dev);
1009 put_device(dev: &port->dev);
1010}
1011EXPORT_SYMBOL(sas_port_free);
1012
1013/**
1014 * sas_port_delete - remove SAS PORT
1015 * @port: SAS PORT to remove
1016 *
1017 * Removes the specified SAS PORT. If the SAS PORT has an
1018 * associated phys, unlink them from the port as well.
1019 */
1020void sas_port_delete(struct sas_port *port)
1021{
1022 struct device *dev = &port->dev;
1023 struct sas_phy *phy, *tmp_phy;
1024
1025 if (port->rphy) {
1026 sas_rphy_delete(port->rphy);
1027 port->rphy = NULL;
1028 }
1029
1030 mutex_lock(&port->phy_list_mutex);
1031 list_for_each_entry_safe(phy, tmp_phy, &port->phy_list,
1032 port_siblings) {
1033 sas_port_delete_link(port, phy);
1034 list_del_init(entry: &phy->port_siblings);
1035 }
1036 mutex_unlock(lock: &port->phy_list_mutex);
1037
1038 if (port->is_backlink) {
1039 struct device *parent = port->dev.parent;
1040
1041 sysfs_remove_link(kobj: &port->dev.kobj, name: dev_name(dev: parent));
1042 port->is_backlink = 0;
1043 }
1044
1045 transport_remove_device(dev);
1046 device_del(dev);
1047 transport_destroy_device(dev);
1048 put_device(dev);
1049}
1050EXPORT_SYMBOL(sas_port_delete);
1051
1052/**
1053 * scsi_is_sas_port - check if a struct device represents a SAS port
1054 * @dev: device to check
1055 *
1056 * Returns:
1057 * %1 if the device represents a SAS Port, %0 else
1058 */
1059int scsi_is_sas_port(const struct device *dev)
1060{
1061 return dev->release == sas_port_release;
1062}
1063EXPORT_SYMBOL(scsi_is_sas_port);
1064
1065/**
1066 * sas_port_get_phy - try to take a reference on a port member
1067 * @port: port to check
1068 */
1069struct sas_phy *sas_port_get_phy(struct sas_port *port)
1070{
1071 struct sas_phy *phy;
1072
1073 mutex_lock(&port->phy_list_mutex);
1074 if (list_empty(head: &port->phy_list))
1075 phy = NULL;
1076 else {
1077 struct list_head *ent = port->phy_list.next;
1078
1079 phy = list_entry(ent, typeof(*phy), port_siblings);
1080 get_device(dev: &phy->dev);
1081 }
1082 mutex_unlock(lock: &port->phy_list_mutex);
1083
1084 return phy;
1085}
1086EXPORT_SYMBOL(sas_port_get_phy);
1087
1088/**
1089 * sas_port_add_phy - add another phy to a port to form a wide port
1090 * @port: port to add the phy to
1091 * @phy: phy to add
1092 *
1093 * When a port is initially created, it is empty (has no phys). All
1094 * ports must have at least one phy to operated, and all wide ports
1095 * must have at least two. The current code makes no difference
1096 * between ports and wide ports, but the only object that can be
1097 * connected to a remote device is a port, so ports must be formed on
1098 * all devices with phys if they're connected to anything.
1099 */
1100void sas_port_add_phy(struct sas_port *port, struct sas_phy *phy)
1101{
1102 mutex_lock(&port->phy_list_mutex);
1103 if (unlikely(!list_empty(&phy->port_siblings))) {
1104 /* make sure we're already on this port */
1105 struct sas_phy *tmp;
1106
1107 list_for_each_entry(tmp, &port->phy_list, port_siblings)
1108 if (tmp == phy)
1109 break;
1110 /* If this trips, you added a phy that was already
1111 * part of a different port */
1112 if (unlikely(tmp != phy)) {
1113 dev_printk(KERN_ERR, &port->dev, "trying to add phy %s fails: it's already part of another port\n",
1114 dev_name(&phy->dev));
1115 BUG();
1116 }
1117 } else {
1118 sas_port_create_link(port, phy);
1119 list_add_tail(new: &phy->port_siblings, head: &port->phy_list);
1120 port->num_phys++;
1121 }
1122 mutex_unlock(lock: &port->phy_list_mutex);
1123}
1124EXPORT_SYMBOL(sas_port_add_phy);
1125
1126/**
1127 * sas_port_delete_phy - remove a phy from a port or wide port
1128 * @port: port to remove the phy from
1129 * @phy: phy to remove
1130 *
1131 * This operation is used for tearing down ports again. It must be
1132 * done to every port or wide port before calling sas_port_delete.
1133 */
1134void sas_port_delete_phy(struct sas_port *port, struct sas_phy *phy)
1135{
1136 mutex_lock(&port->phy_list_mutex);
1137 sas_port_delete_link(port, phy);
1138 list_del_init(entry: &phy->port_siblings);
1139 port->num_phys--;
1140 mutex_unlock(lock: &port->phy_list_mutex);
1141}
1142EXPORT_SYMBOL(sas_port_delete_phy);
1143
1144void sas_port_mark_backlink(struct sas_port *port)
1145{
1146 int res;
1147 struct device *parent = port->dev.parent->parent->parent;
1148
1149 if (port->is_backlink)
1150 return;
1151 port->is_backlink = 1;
1152 res = sysfs_create_link(kobj: &port->dev.kobj, target: &parent->kobj,
1153 name: dev_name(dev: parent));
1154 if (res)
1155 goto err;
1156 return;
1157err:
1158 printk(KERN_ERR "%s: Cannot create port backlink, err=%d\n",
1159 __func__, res);
1160
1161}
1162EXPORT_SYMBOL(sas_port_mark_backlink);
1163
1164/*
1165 * SAS remote PHY attributes.
1166 */
1167
1168#define sas_rphy_show_simple(field, name, format_string, cast) \
1169static ssize_t \
1170show_sas_rphy_##name(struct device *dev, \
1171 struct device_attribute *attr, char *buf) \
1172{ \
1173 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1174 \
1175 return snprintf(buf, 20, format_string, cast rphy->field); \
1176}
1177
1178#define sas_rphy_simple_attr(field, name, format_string, type) \
1179 sas_rphy_show_simple(field, name, format_string, (type)) \
1180static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \
1181 show_sas_rphy_##name, NULL)
1182
1183#define sas_rphy_show_protocol(field, name) \
1184static ssize_t \
1185show_sas_rphy_##name(struct device *dev, \
1186 struct device_attribute *attr, char *buf) \
1187{ \
1188 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1189 \
1190 if (!rphy->field) \
1191 return snprintf(buf, 20, "none\n"); \
1192 return get_sas_protocol_names(rphy->field, buf); \
1193}
1194
1195#define sas_rphy_protocol_attr(field, name) \
1196 sas_rphy_show_protocol(field, name) \
1197static SAS_DEVICE_ATTR(rphy, name, S_IRUGO, \
1198 show_sas_rphy_##name, NULL)
1199
1200static ssize_t
1201show_sas_rphy_device_type(struct device *dev,
1202 struct device_attribute *attr, char *buf)
1203{
1204 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1205
1206 if (!rphy->identify.device_type)
1207 return snprintf(buf, size: 20, fmt: "none\n");
1208 return get_sas_device_type_names(
1209 table_key: rphy->identify.device_type, buf);
1210}
1211
1212static SAS_DEVICE_ATTR(rphy, device_type, S_IRUGO,
1213 show_sas_rphy_device_type, NULL);
1214
1215static ssize_t
1216show_sas_rphy_enclosure_identifier(struct device *dev,
1217 struct device_attribute *attr, char *buf)
1218{
1219 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1220 struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
1221 struct Scsi_Host *shost = dev_to_shost(dev: phy->dev.parent);
1222 struct sas_internal *i = to_sas_internal(shost->transportt);
1223 u64 identifier;
1224 int error;
1225
1226 error = i->f->get_enclosure_identifier(rphy, &identifier);
1227 if (error)
1228 return error;
1229 return sprintf(buf, fmt: "0x%llx\n", (unsigned long long)identifier);
1230}
1231
1232static SAS_DEVICE_ATTR(rphy, enclosure_identifier, S_IRUGO,
1233 show_sas_rphy_enclosure_identifier, NULL);
1234
1235static ssize_t
1236show_sas_rphy_bay_identifier(struct device *dev,
1237 struct device_attribute *attr, char *buf)
1238{
1239 struct sas_rphy *rphy = transport_class_to_rphy(dev);
1240 struct sas_phy *phy = dev_to_phy(rphy->dev.parent);
1241 struct Scsi_Host *shost = dev_to_shost(dev: phy->dev.parent);
1242 struct sas_internal *i = to_sas_internal(shost->transportt);
1243 int val;
1244
1245 val = i->f->get_bay_identifier(rphy);
1246 if (val < 0)
1247 return val;
1248 return sprintf(buf, fmt: "%d\n", val);
1249}
1250
1251static SAS_DEVICE_ATTR(rphy, bay_identifier, S_IRUGO,
1252 show_sas_rphy_bay_identifier, NULL);
1253
1254sas_rphy_protocol_attr(identify.initiator_port_protocols,
1255 initiator_port_protocols);
1256sas_rphy_protocol_attr(identify.target_port_protocols, target_port_protocols);
1257sas_rphy_simple_attr(identify.sas_address, sas_address, "0x%016llx\n",
1258 unsigned long long);
1259sas_rphy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
1260sas_rphy_simple_attr(scsi_target_id, scsi_target_id, "%d\n", u32);
1261
1262/* only need 8 bytes of data plus header (4 or 8) */
1263#define BUF_SIZE 64
1264
1265int sas_read_port_mode_page(struct scsi_device *sdev)
1266{
1267 char *buffer = kzalloc(BUF_SIZE, GFP_KERNEL), *msdata;
1268 struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
1269 struct scsi_mode_data mode_data;
1270 int error;
1271
1272 if (!buffer)
1273 return -ENOMEM;
1274
1275 error = scsi_mode_sense(sdev, dbd: 1, modepage: 0x19, subpage: 0, buffer, BUF_SIZE, timeout: 30*HZ, retries: 3,
1276 data: &mode_data, NULL);
1277
1278 if (error)
1279 goto out;
1280
1281 msdata = buffer + mode_data.header_length +
1282 mode_data.block_descriptor_length;
1283
1284 if (msdata - buffer > BUF_SIZE - 8)
1285 goto out;
1286
1287 error = 0;
1288
1289 rdev->ready_led_meaning = msdata[2] & 0x10 ? 1 : 0;
1290 rdev->I_T_nexus_loss_timeout = (msdata[4] << 8) + msdata[5];
1291 rdev->initiator_response_timeout = (msdata[6] << 8) + msdata[7];
1292
1293 out:
1294 kfree(objp: buffer);
1295 return error;
1296}
1297EXPORT_SYMBOL(sas_read_port_mode_page);
1298
1299static DECLARE_TRANSPORT_CLASS(sas_end_dev_class,
1300 "sas_end_device", NULL, NULL, NULL);
1301
1302#define sas_end_dev_show_simple(field, name, format_string, cast) \
1303static ssize_t \
1304show_sas_end_dev_##name(struct device *dev, \
1305 struct device_attribute *attr, char *buf) \
1306{ \
1307 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1308 struct sas_end_device *rdev = rphy_to_end_device(rphy); \
1309 \
1310 return snprintf(buf, 20, format_string, cast rdev->field); \
1311}
1312
1313#define sas_end_dev_simple_attr(field, name, format_string, type) \
1314 sas_end_dev_show_simple(field, name, format_string, (type)) \
1315static SAS_DEVICE_ATTR(end_dev, name, S_IRUGO, \
1316 show_sas_end_dev_##name, NULL)
1317
1318sas_end_dev_simple_attr(ready_led_meaning, ready_led_meaning, "%d\n", int);
1319sas_end_dev_simple_attr(I_T_nexus_loss_timeout, I_T_nexus_loss_timeout,
1320 "%d\n", int);
1321sas_end_dev_simple_attr(initiator_response_timeout, initiator_response_timeout,
1322 "%d\n", int);
1323sas_end_dev_simple_attr(tlr_supported, tlr_supported,
1324 "%d\n", int);
1325sas_end_dev_simple_attr(tlr_enabled, tlr_enabled,
1326 "%d\n", int);
1327
1328static DECLARE_TRANSPORT_CLASS(sas_expander_class,
1329 "sas_expander", NULL, NULL, NULL);
1330
1331#define sas_expander_show_simple(field, name, format_string, cast) \
1332static ssize_t \
1333show_sas_expander_##name(struct device *dev, \
1334 struct device_attribute *attr, char *buf) \
1335{ \
1336 struct sas_rphy *rphy = transport_class_to_rphy(dev); \
1337 struct sas_expander_device *edev = rphy_to_expander_device(rphy); \
1338 \
1339 return snprintf(buf, 20, format_string, cast edev->field); \
1340}
1341
1342#define sas_expander_simple_attr(field, name, format_string, type) \
1343 sas_expander_show_simple(field, name, format_string, (type)) \
1344static SAS_DEVICE_ATTR(expander, name, S_IRUGO, \
1345 show_sas_expander_##name, NULL)
1346
1347sas_expander_simple_attr(vendor_id, vendor_id, "%s\n", char *);
1348sas_expander_simple_attr(product_id, product_id, "%s\n", char *);
1349sas_expander_simple_attr(product_rev, product_rev, "%s\n", char *);
1350sas_expander_simple_attr(component_vendor_id, component_vendor_id,
1351 "%s\n", char *);
1352sas_expander_simple_attr(component_id, component_id, "%u\n", unsigned int);
1353sas_expander_simple_attr(component_revision_id, component_revision_id, "%u\n",
1354 unsigned int);
1355sas_expander_simple_attr(level, level, "%d\n", int);
1356
1357static DECLARE_TRANSPORT_CLASS(sas_rphy_class,
1358 "sas_device", NULL, NULL, NULL);
1359
1360static int sas_rphy_match(struct attribute_container *cont, struct device *dev)
1361{
1362 struct Scsi_Host *shost;
1363 struct sas_internal *i;
1364
1365 if (!scsi_is_sas_rphy(dev))
1366 return 0;
1367 shost = dev_to_shost(dev: dev->parent->parent);
1368
1369 if (!shost->transportt)
1370 return 0;
1371 if (shost->transportt->host_attrs.ac.class !=
1372 &sas_host_class.class)
1373 return 0;
1374
1375 i = to_sas_internal(shost->transportt);
1376 return &i->rphy_attr_cont.ac == cont;
1377}
1378
1379static int sas_end_dev_match(struct attribute_container *cont,
1380 struct device *dev)
1381{
1382 struct Scsi_Host *shost;
1383 struct sas_internal *i;
1384 struct sas_rphy *rphy;
1385
1386 if (!scsi_is_sas_rphy(dev))
1387 return 0;
1388 shost = dev_to_shost(dev: dev->parent->parent);
1389 rphy = dev_to_rphy(dev);
1390
1391 if (!shost->transportt)
1392 return 0;
1393 if (shost->transportt->host_attrs.ac.class !=
1394 &sas_host_class.class)
1395 return 0;
1396
1397 i = to_sas_internal(shost->transportt);
1398 return &i->end_dev_attr_cont.ac == cont &&
1399 rphy->identify.device_type == SAS_END_DEVICE;
1400}
1401
1402static int sas_expander_match(struct attribute_container *cont,
1403 struct device *dev)
1404{
1405 struct Scsi_Host *shost;
1406 struct sas_internal *i;
1407 struct sas_rphy *rphy;
1408
1409 if (!scsi_is_sas_rphy(dev))
1410 return 0;
1411 shost = dev_to_shost(dev: dev->parent->parent);
1412 rphy = dev_to_rphy(dev);
1413
1414 if (!shost->transportt)
1415 return 0;
1416 if (shost->transportt->host_attrs.ac.class !=
1417 &sas_host_class.class)
1418 return 0;
1419
1420 i = to_sas_internal(shost->transportt);
1421 return &i->expander_attr_cont.ac == cont &&
1422 (rphy->identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
1423 rphy->identify.device_type == SAS_FANOUT_EXPANDER_DEVICE);
1424}
1425
1426static void sas_expander_release(struct device *dev)
1427{
1428 struct sas_rphy *rphy = dev_to_rphy(dev);
1429 struct sas_expander_device *edev = rphy_to_expander_device(rphy);
1430
1431 put_device(dev: dev->parent);
1432 kfree(objp: edev);
1433}
1434
1435static void sas_end_device_release(struct device *dev)
1436{
1437 struct sas_rphy *rphy = dev_to_rphy(dev);
1438 struct sas_end_device *edev = rphy_to_end_device(rphy);
1439
1440 put_device(dev: dev->parent);
1441 kfree(objp: edev);
1442}
1443
1444/**
1445 * sas_rphy_initialize - common rphy initialization
1446 * @rphy: rphy to initialise
1447 *
1448 * Used by both sas_end_device_alloc() and sas_expander_alloc() to
1449 * initialise the common rphy component of each.
1450 */
1451static void sas_rphy_initialize(struct sas_rphy *rphy)
1452{
1453 INIT_LIST_HEAD(list: &rphy->list);
1454}
1455
1456/**
1457 * sas_end_device_alloc - allocate an rphy for an end device
1458 * @parent: which port
1459 *
1460 * Allocates an SAS remote PHY structure, connected to @parent.
1461 *
1462 * Returns:
1463 * SAS PHY allocated or %NULL if the allocation failed.
1464 */
1465struct sas_rphy *sas_end_device_alloc(struct sas_port *parent)
1466{
1467 struct Scsi_Host *shost = dev_to_shost(dev: &parent->dev);
1468 struct sas_end_device *rdev;
1469
1470 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
1471 if (!rdev) {
1472 return NULL;
1473 }
1474
1475 device_initialize(dev: &rdev->rphy.dev);
1476 rdev->rphy.dev.parent = get_device(dev: &parent->dev);
1477 rdev->rphy.dev.release = sas_end_device_release;
1478 if (scsi_is_sas_expander_device(dev: parent->dev.parent)) {
1479 struct sas_rphy *rphy = dev_to_rphy(parent->dev.parent);
1480 dev_set_name(dev: &rdev->rphy.dev, name: "end_device-%d:%d:%d",
1481 shost->host_no, rphy->scsi_target_id,
1482 parent->port_identifier);
1483 } else
1484 dev_set_name(dev: &rdev->rphy.dev, name: "end_device-%d:%d",
1485 shost->host_no, parent->port_identifier);
1486 rdev->rphy.identify.device_type = SAS_END_DEVICE;
1487 sas_rphy_initialize(rphy: &rdev->rphy);
1488 transport_setup_device(&rdev->rphy.dev);
1489
1490 return &rdev->rphy;
1491}
1492EXPORT_SYMBOL(sas_end_device_alloc);
1493
1494/**
1495 * sas_expander_alloc - allocate an rphy for an end device
1496 * @parent: which port
1497 * @type: SAS_EDGE_EXPANDER_DEVICE or SAS_FANOUT_EXPANDER_DEVICE
1498 *
1499 * Allocates an SAS remote PHY structure, connected to @parent.
1500 *
1501 * Returns:
1502 * SAS PHY allocated or %NULL if the allocation failed.
1503 */
1504struct sas_rphy *sas_expander_alloc(struct sas_port *parent,
1505 enum sas_device_type type)
1506{
1507 struct Scsi_Host *shost = dev_to_shost(dev: &parent->dev);
1508 struct sas_expander_device *rdev;
1509 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1510
1511 BUG_ON(type != SAS_EDGE_EXPANDER_DEVICE &&
1512 type != SAS_FANOUT_EXPANDER_DEVICE);
1513
1514 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
1515 if (!rdev) {
1516 return NULL;
1517 }
1518
1519 device_initialize(dev: &rdev->rphy.dev);
1520 rdev->rphy.dev.parent = get_device(dev: &parent->dev);
1521 rdev->rphy.dev.release = sas_expander_release;
1522 mutex_lock(&sas_host->lock);
1523 rdev->rphy.scsi_target_id = sas_host->next_expander_id++;
1524 mutex_unlock(lock: &sas_host->lock);
1525 dev_set_name(dev: &rdev->rphy.dev, name: "expander-%d:%d",
1526 shost->host_no, rdev->rphy.scsi_target_id);
1527 rdev->rphy.identify.device_type = type;
1528 sas_rphy_initialize(rphy: &rdev->rphy);
1529 transport_setup_device(&rdev->rphy.dev);
1530
1531 return &rdev->rphy;
1532}
1533EXPORT_SYMBOL(sas_expander_alloc);
1534
1535/**
1536 * sas_rphy_add - add a SAS remote PHY to the device hierarchy
1537 * @rphy: The remote PHY to be added
1538 *
1539 * Publishes a SAS remote PHY to the rest of the system.
1540 */
1541int sas_rphy_add(struct sas_rphy *rphy)
1542{
1543 struct sas_port *parent = dev_to_sas_port(rphy->dev.parent);
1544 struct Scsi_Host *shost = dev_to_shost(dev: parent->dev.parent);
1545 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1546 struct sas_identify *identify = &rphy->identify;
1547 int error;
1548
1549 if (parent->rphy)
1550 return -ENXIO;
1551 parent->rphy = rphy;
1552
1553 error = device_add(dev: &rphy->dev);
1554 if (error)
1555 return error;
1556 transport_add_device(&rphy->dev);
1557 transport_configure_device(&rphy->dev);
1558 if (sas_bsg_initialize(shost, rphy))
1559 printk("fail to a bsg device %s\n", dev_name(&rphy->dev));
1560
1561
1562 mutex_lock(&sas_host->lock);
1563 list_add_tail(new: &rphy->list, head: &sas_host->rphy_list);
1564 if (identify->device_type == SAS_END_DEVICE &&
1565 (identify->target_port_protocols &
1566 (SAS_PROTOCOL_SSP | SAS_PROTOCOL_STP | SAS_PROTOCOL_SATA)))
1567 rphy->scsi_target_id = sas_host->next_target_id++;
1568 else if (identify->device_type == SAS_END_DEVICE)
1569 rphy->scsi_target_id = -1;
1570 mutex_unlock(lock: &sas_host->lock);
1571
1572 if (identify->device_type == SAS_END_DEVICE &&
1573 rphy->scsi_target_id != -1) {
1574 int lun;
1575
1576 if (identify->target_port_protocols & SAS_PROTOCOL_SSP)
1577 lun = SCAN_WILD_CARD;
1578 else
1579 lun = 0;
1580
1581 scsi_scan_target(parent: &rphy->dev, channel: 0, id: rphy->scsi_target_id, lun,
1582 rescan: SCSI_SCAN_INITIAL);
1583 }
1584
1585 return 0;
1586}
1587EXPORT_SYMBOL(sas_rphy_add);
1588
1589/**
1590 * sas_rphy_free - free a SAS remote PHY
1591 * @rphy: SAS remote PHY to free
1592 *
1593 * Frees the specified SAS remote PHY.
1594 *
1595 * Note:
1596 * This function must only be called on a remote
1597 * PHY that has not successfully been added using
1598 * sas_rphy_add() (or has been sas_rphy_remove()'d)
1599 */
1600void sas_rphy_free(struct sas_rphy *rphy)
1601{
1602 struct device *dev = &rphy->dev;
1603 struct Scsi_Host *shost = dev_to_shost(dev: rphy->dev.parent->parent);
1604 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1605
1606 mutex_lock(&sas_host->lock);
1607 list_del(entry: &rphy->list);
1608 mutex_unlock(lock: &sas_host->lock);
1609
1610 transport_destroy_device(dev);
1611
1612 put_device(dev);
1613}
1614EXPORT_SYMBOL(sas_rphy_free);
1615
1616/**
1617 * sas_rphy_delete - remove and free SAS remote PHY
1618 * @rphy: SAS remote PHY to remove and free
1619 *
1620 * Removes the specified SAS remote PHY and frees it.
1621 */
1622void
1623sas_rphy_delete(struct sas_rphy *rphy)
1624{
1625 sas_rphy_remove(rphy);
1626 sas_rphy_free(rphy);
1627}
1628EXPORT_SYMBOL(sas_rphy_delete);
1629
1630/**
1631 * sas_rphy_unlink - unlink SAS remote PHY
1632 * @rphy: SAS remote phy to unlink from its parent port
1633 *
1634 * Removes port reference to an rphy
1635 */
1636void sas_rphy_unlink(struct sas_rphy *rphy)
1637{
1638 struct sas_port *parent = dev_to_sas_port(rphy->dev.parent);
1639
1640 parent->rphy = NULL;
1641}
1642EXPORT_SYMBOL(sas_rphy_unlink);
1643
1644/**
1645 * sas_rphy_remove - remove SAS remote PHY
1646 * @rphy: SAS remote phy to remove
1647 *
1648 * Removes the specified SAS remote PHY.
1649 */
1650void
1651sas_rphy_remove(struct sas_rphy *rphy)
1652{
1653 struct device *dev = &rphy->dev;
1654
1655 switch (rphy->identify.device_type) {
1656 case SAS_END_DEVICE:
1657 scsi_remove_target(dev);
1658 break;
1659 case SAS_EDGE_EXPANDER_DEVICE:
1660 case SAS_FANOUT_EXPANDER_DEVICE:
1661 sas_remove_children(dev);
1662 break;
1663 default:
1664 break;
1665 }
1666
1667 sas_rphy_unlink(rphy);
1668 bsg_remove_queue(q: rphy->q);
1669 transport_remove_device(dev);
1670 device_del(dev);
1671}
1672EXPORT_SYMBOL(sas_rphy_remove);
1673
1674/**
1675 * scsi_is_sas_rphy - check if a struct device represents a SAS remote PHY
1676 * @dev: device to check
1677 *
1678 * Returns:
1679 * %1 if the device represents a SAS remote PHY, %0 else
1680 */
1681int scsi_is_sas_rphy(const struct device *dev)
1682{
1683 return dev->release == sas_end_device_release ||
1684 dev->release == sas_expander_release;
1685}
1686EXPORT_SYMBOL(scsi_is_sas_rphy);
1687
1688static void scan_channel_zero(struct Scsi_Host *shost, uint id, u64 lun)
1689{
1690 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1691 struct sas_rphy *rphy;
1692
1693 list_for_each_entry(rphy, &sas_host->rphy_list, list) {
1694 if (rphy->identify.device_type != SAS_END_DEVICE ||
1695 rphy->scsi_target_id == -1)
1696 continue;
1697
1698 if (id == SCAN_WILD_CARD || id == rphy->scsi_target_id) {
1699 scsi_scan_target(parent: &rphy->dev, channel: 0, id: rphy->scsi_target_id,
1700 lun, rescan: SCSI_SCAN_MANUAL);
1701 }
1702 }
1703}
1704
1705/*
1706 * SCSI scan helper
1707 */
1708
1709static int sas_user_scan(struct Scsi_Host *shost, uint channel,
1710 uint id, u64 lun)
1711{
1712 struct sas_host_attrs *sas_host = to_sas_host_attrs(shost);
1713 int res = 0;
1714 int i;
1715
1716 switch (channel) {
1717 case 0:
1718 mutex_lock(&sas_host->lock);
1719 scan_channel_zero(shost, id, lun);
1720 mutex_unlock(lock: &sas_host->lock);
1721 break;
1722
1723 case SCAN_WILD_CARD:
1724 mutex_lock(&sas_host->lock);
1725 scan_channel_zero(shost, id, lun);
1726 mutex_unlock(lock: &sas_host->lock);
1727
1728 for (i = 1; i <= shost->max_channel; i++) {
1729 res = scsi_scan_host_selected(shost, i, id, lun,
1730 SCSI_SCAN_MANUAL);
1731 if (res)
1732 goto exit_scan;
1733 }
1734 break;
1735
1736 default:
1737 if (channel < shost->max_channel) {
1738 res = scsi_scan_host_selected(shost, channel, id, lun,
1739 SCSI_SCAN_MANUAL);
1740 } else {
1741 res = -EINVAL;
1742 }
1743 break;
1744 }
1745
1746exit_scan:
1747 return res;
1748}
1749
1750
1751/*
1752 * Setup / Teardown code
1753 */
1754
1755#define SETUP_TEMPLATE(attrb, field, perm, test) \
1756 i->private_##attrb[count] = dev_attr_##field; \
1757 i->private_##attrb[count].attr.mode = perm; \
1758 i->attrb[count] = &i->private_##attrb[count]; \
1759 if (test) \
1760 count++
1761
1762#define SETUP_TEMPLATE_RW(attrb, field, perm, test, ro_test, ro_perm) \
1763 i->private_##attrb[count] = dev_attr_##field; \
1764 i->private_##attrb[count].attr.mode = perm; \
1765 if (ro_test) { \
1766 i->private_##attrb[count].attr.mode = ro_perm; \
1767 i->private_##attrb[count].store = NULL; \
1768 } \
1769 i->attrb[count] = &i->private_##attrb[count]; \
1770 if (test) \
1771 count++
1772
1773#define SETUP_RPORT_ATTRIBUTE(field) \
1774 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, 1)
1775
1776#define SETUP_OPTIONAL_RPORT_ATTRIBUTE(field, func) \
1777 SETUP_TEMPLATE(rphy_attrs, field, S_IRUGO, i->f->func)
1778
1779#define SETUP_PHY_ATTRIBUTE(field) \
1780 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, 1)
1781
1782#define SETUP_PHY_ATTRIBUTE_RW(field) \
1783 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1784 !i->f->set_phy_speed, S_IRUGO)
1785
1786#define SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(field, func) \
1787 SETUP_TEMPLATE_RW(phy_attrs, field, S_IRUGO | S_IWUSR, 1, \
1788 !i->f->func, S_IRUGO)
1789
1790#define SETUP_PORT_ATTRIBUTE(field) \
1791 SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1)
1792
1793#define SETUP_OPTIONAL_PHY_ATTRIBUTE(field, func) \
1794 SETUP_TEMPLATE(phy_attrs, field, S_IRUGO, i->f->func)
1795
1796#define SETUP_PHY_ATTRIBUTE_WRONLY(field) \
1797 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, 1)
1798
1799#define SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(field, func) \
1800 SETUP_TEMPLATE(phy_attrs, field, S_IWUSR, i->f->func)
1801
1802#define SETUP_END_DEV_ATTRIBUTE(field) \
1803 SETUP_TEMPLATE(end_dev_attrs, field, S_IRUGO, 1)
1804
1805#define SETUP_EXPANDER_ATTRIBUTE(field) \
1806 SETUP_TEMPLATE(expander_attrs, expander_##field, S_IRUGO, 1)
1807
1808/**
1809 * sas_attach_transport - instantiate SAS transport template
1810 * @ft: SAS transport class function template
1811 */
1812struct scsi_transport_template *
1813sas_attach_transport(struct sas_function_template *ft)
1814{
1815 struct sas_internal *i;
1816 int count;
1817
1818 i = kzalloc(sizeof(struct sas_internal), GFP_KERNEL);
1819 if (!i)
1820 return NULL;
1821
1822 i->t.user_scan = sas_user_scan;
1823
1824 i->t.host_attrs.ac.attrs = &i->host_attrs[0];
1825 i->t.host_attrs.ac.class = &sas_host_class.class;
1826 i->t.host_attrs.ac.match = sas_host_match;
1827 transport_container_register(tc: &i->t.host_attrs);
1828 i->t.host_size = sizeof(struct sas_host_attrs);
1829
1830 i->phy_attr_cont.ac.class = &sas_phy_class.class;
1831 i->phy_attr_cont.ac.attrs = &i->phy_attrs[0];
1832 i->phy_attr_cont.ac.match = sas_phy_match;
1833 transport_container_register(tc: &i->phy_attr_cont);
1834
1835 i->port_attr_cont.ac.class = &sas_port_class.class;
1836 i->port_attr_cont.ac.attrs = &i->port_attrs[0];
1837 i->port_attr_cont.ac.match = sas_port_match;
1838 transport_container_register(tc: &i->port_attr_cont);
1839
1840 i->rphy_attr_cont.ac.class = &sas_rphy_class.class;
1841 i->rphy_attr_cont.ac.attrs = &i->rphy_attrs[0];
1842 i->rphy_attr_cont.ac.match = sas_rphy_match;
1843 transport_container_register(tc: &i->rphy_attr_cont);
1844
1845 i->end_dev_attr_cont.ac.class = &sas_end_dev_class.class;
1846 i->end_dev_attr_cont.ac.attrs = &i->end_dev_attrs[0];
1847 i->end_dev_attr_cont.ac.match = sas_end_dev_match;
1848 transport_container_register(tc: &i->end_dev_attr_cont);
1849
1850 i->expander_attr_cont.ac.class = &sas_expander_class.class;
1851 i->expander_attr_cont.ac.attrs = &i->expander_attrs[0];
1852 i->expander_attr_cont.ac.match = sas_expander_match;
1853 transport_container_register(tc: &i->expander_attr_cont);
1854
1855 i->f = ft;
1856
1857 count = 0;
1858 SETUP_PHY_ATTRIBUTE(initiator_port_protocols);
1859 SETUP_PHY_ATTRIBUTE(target_port_protocols);
1860 SETUP_PHY_ATTRIBUTE(device_type);
1861 SETUP_PHY_ATTRIBUTE(sas_address);
1862 SETUP_PHY_ATTRIBUTE(phy_identifier);
1863 SETUP_PHY_ATTRIBUTE(negotiated_linkrate);
1864 SETUP_PHY_ATTRIBUTE(minimum_linkrate_hw);
1865 SETUP_PHY_ATTRIBUTE_RW(minimum_linkrate);
1866 SETUP_PHY_ATTRIBUTE(maximum_linkrate_hw);
1867 SETUP_PHY_ATTRIBUTE_RW(maximum_linkrate);
1868
1869 SETUP_PHY_ATTRIBUTE(invalid_dword_count);
1870 SETUP_PHY_ATTRIBUTE(running_disparity_error_count);
1871 SETUP_PHY_ATTRIBUTE(loss_of_dword_sync_count);
1872 SETUP_PHY_ATTRIBUTE(phy_reset_problem_count);
1873 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(link_reset, phy_reset);
1874 SETUP_OPTIONAL_PHY_ATTRIBUTE_WRONLY(hard_reset, phy_reset);
1875 SETUP_OPTIONAL_PHY_ATTRIBUTE_RW(enable, phy_enable);
1876 i->phy_attrs[count] = NULL;
1877
1878 count = 0;
1879 SETUP_PORT_ATTRIBUTE(num_phys);
1880 i->port_attrs[count] = NULL;
1881
1882 count = 0;
1883 SETUP_RPORT_ATTRIBUTE(rphy_initiator_port_protocols);
1884 SETUP_RPORT_ATTRIBUTE(rphy_target_port_protocols);
1885 SETUP_RPORT_ATTRIBUTE(rphy_device_type);
1886 SETUP_RPORT_ATTRIBUTE(rphy_sas_address);
1887 SETUP_RPORT_ATTRIBUTE(rphy_phy_identifier);
1888 SETUP_RPORT_ATTRIBUTE(rphy_scsi_target_id);
1889 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_enclosure_identifier,
1890 get_enclosure_identifier);
1891 SETUP_OPTIONAL_RPORT_ATTRIBUTE(rphy_bay_identifier,
1892 get_bay_identifier);
1893 i->rphy_attrs[count] = NULL;
1894
1895 count = 0;
1896 SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning);
1897 SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout);
1898 SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout);
1899 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_supported);
1900 SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_enabled);
1901 i->end_dev_attrs[count] = NULL;
1902
1903 count = 0;
1904 SETUP_EXPANDER_ATTRIBUTE(vendor_id);
1905 SETUP_EXPANDER_ATTRIBUTE(product_id);
1906 SETUP_EXPANDER_ATTRIBUTE(product_rev);
1907 SETUP_EXPANDER_ATTRIBUTE(component_vendor_id);
1908 SETUP_EXPANDER_ATTRIBUTE(component_id);
1909 SETUP_EXPANDER_ATTRIBUTE(component_revision_id);
1910 SETUP_EXPANDER_ATTRIBUTE(level);
1911 i->expander_attrs[count] = NULL;
1912
1913 return &i->t;
1914}
1915EXPORT_SYMBOL(sas_attach_transport);
1916
1917/**
1918 * sas_release_transport - release SAS transport template instance
1919 * @t: transport template instance
1920 */
1921void sas_release_transport(struct scsi_transport_template *t)
1922{
1923 struct sas_internal *i = to_sas_internal(t);
1924
1925 transport_container_unregister(tc: &i->t.host_attrs);
1926 transport_container_unregister(tc: &i->phy_attr_cont);
1927 transport_container_unregister(tc: &i->port_attr_cont);
1928 transport_container_unregister(tc: &i->rphy_attr_cont);
1929 transport_container_unregister(tc: &i->end_dev_attr_cont);
1930 transport_container_unregister(tc: &i->expander_attr_cont);
1931
1932 kfree(objp: i);
1933}
1934EXPORT_SYMBOL(sas_release_transport);
1935
1936static __init int sas_transport_init(void)
1937{
1938 int error;
1939
1940 error = transport_class_register(&sas_host_class);
1941 if (error)
1942 goto out;
1943 error = transport_class_register(&sas_phy_class);
1944 if (error)
1945 goto out_unregister_transport;
1946 error = transport_class_register(&sas_port_class);
1947 if (error)
1948 goto out_unregister_phy;
1949 error = transport_class_register(&sas_rphy_class);
1950 if (error)
1951 goto out_unregister_port;
1952 error = transport_class_register(&sas_end_dev_class);
1953 if (error)
1954 goto out_unregister_rphy;
1955 error = transport_class_register(&sas_expander_class);
1956 if (error)
1957 goto out_unregister_end_dev;
1958
1959 return 0;
1960
1961 out_unregister_end_dev:
1962 transport_class_unregister(&sas_end_dev_class);
1963 out_unregister_rphy:
1964 transport_class_unregister(&sas_rphy_class);
1965 out_unregister_port:
1966 transport_class_unregister(&sas_port_class);
1967 out_unregister_phy:
1968 transport_class_unregister(&sas_phy_class);
1969 out_unregister_transport:
1970 transport_class_unregister(&sas_host_class);
1971 out:
1972 return error;
1973
1974}
1975
1976static void __exit sas_transport_exit(void)
1977{
1978 transport_class_unregister(&sas_host_class);
1979 transport_class_unregister(&sas_phy_class);
1980 transport_class_unregister(&sas_port_class);
1981 transport_class_unregister(&sas_rphy_class);
1982 transport_class_unregister(&sas_end_dev_class);
1983 transport_class_unregister(&sas_expander_class);
1984}
1985
1986MODULE_AUTHOR("Christoph Hellwig");
1987MODULE_DESCRIPTION("SAS Transport Attributes");
1988MODULE_LICENSE("GPL");
1989
1990module_init(sas_transport_init);
1991module_exit(sas_transport_exit);
1992

source code of linux/drivers/scsi/scsi_transport_sas.c