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