drivers/scsi/scsi_transport_sas.c

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