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