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