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