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