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