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