1 /* 2 * Copyright 2008 ioogle, Inc. All rights reserved. 3 * Released under GPL v2. 4 * 5 * Libata transport class. 6 * 7 * The ATA transport class contains common code to deal with ATA HBAs, 8 * an approximated representation of ATA topologies in the driver model, 9 * and various sysfs attributes to expose these topologies and management 10 * interfaces to user-space. 11 * 12 * There are 3 objects defined in in this class: 13 * - ata_port 14 * - ata_link 15 * - ata_device 16 * Each port has a link object. Each link can have up to two devices for PATA 17 * and generally one for SATA. 18 * If there is SATA port multiplier [PMP], 15 additional ata_link object are 19 * created. 20 * 21 * These objects are created when the ata host is initialized and when a PMP is 22 * found. They are removed only when the HBA is removed, cleaned before the 23 * error handler runs. 24 */ 25 26 27 #include <linux/kernel.h> 28 #include <linux/blkdev.h> 29 #include <linux/spinlock.h> 30 #include <linux/slab.h> 31 #include <scsi/scsi_transport.h> 32 #include <linux/libata.h> 33 #include <linux/hdreg.h> 34 #include <linux/uaccess.h> 35 36 #include "libata.h" 37 #include "libata-transport.h" 38 39 #define ATA_PORT_ATTRS 2 40 #define ATA_LINK_ATTRS 3 41 #define ATA_DEV_ATTRS 9 42 43 struct scsi_transport_template; 44 struct scsi_transport_template *ata_scsi_transport_template; 45 46 struct ata_internal { 47 struct scsi_transport_template t; 48 49 struct device_attribute private_port_attrs[ATA_PORT_ATTRS]; 50 struct device_attribute private_link_attrs[ATA_LINK_ATTRS]; 51 struct device_attribute private_dev_attrs[ATA_DEV_ATTRS]; 52 53 struct transport_container link_attr_cont; 54 struct transport_container dev_attr_cont; 55 56 /* 57 * The array of null terminated pointers to attributes 58 * needed by scsi_sysfs.c 59 */ 60 struct device_attribute *link_attrs[ATA_LINK_ATTRS + 1]; 61 struct device_attribute *port_attrs[ATA_PORT_ATTRS + 1]; 62 struct device_attribute *dev_attrs[ATA_DEV_ATTRS + 1]; 63 }; 64 #define to_ata_internal(tmpl) container_of(tmpl, struct ata_internal, t) 65 66 67 #define tdev_to_device(d) \ 68 container_of((d), struct ata_device, tdev) 69 #define transport_class_to_dev(dev) \ 70 tdev_to_device((dev)->parent) 71 72 #define tdev_to_link(d) \ 73 container_of((d), struct ata_link, tdev) 74 #define transport_class_to_link(dev) \ 75 tdev_to_link((dev)->parent) 76 77 #define tdev_to_port(d) \ 78 container_of((d), struct ata_port, tdev) 79 #define transport_class_to_port(dev) \ 80 tdev_to_port((dev)->parent) 81 82 83 /* Device objects are always created whit link objects */ 84 static int ata_tdev_add(struct ata_device *dev); 85 static void ata_tdev_delete(struct ata_device *dev); 86 87 88 /* 89 * Hack to allow attributes of the same name in different objects. 90 */ 91 #define ATA_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \ 92 struct device_attribute device_attr_##_prefix##_##_name = \ 93 __ATTR(_name,_mode,_show,_store) 94 95 #define ata_bitfield_name_match(title, table) \ 96 static ssize_t \ 97 get_ata_##title##_names(u32 table_key, char *buf) \ 98 { \ 99 char *prefix = ""; \ 100 ssize_t len = 0; \ 101 int i; \ 102 \ 103 for (i = 0; i < ARRAY_SIZE(table); i++) { \ 104 if (table[i].value & table_key) { \ 105 len += sprintf(buf + len, "%s%s", \ 106 prefix, table[i].name); \ 107 prefix = ", "; \ 108 } \ 109 } \ 110 len += sprintf(buf + len, "\n"); \ 111 return len; \ 112 } 113 114 #define ata_bitfield_name_search(title, table) \ 115 static ssize_t \ 116 get_ata_##title##_names(u32 table_key, char *buf) \ 117 { \ 118 ssize_t len = 0; \ 119 int i; \ 120 \ 121 for (i = 0; i < ARRAY_SIZE(table); i++) { \ 122 if (table[i].value == table_key) { \ 123 len += sprintf(buf + len, "%s", \ 124 table[i].name); \ 125 break; \ 126 } \ 127 } \ 128 len += sprintf(buf + len, "\n"); \ 129 return len; \ 130 } 131 132 static struct { 133 u32 value; 134 char *name; 135 } ata_class_names[] = { 136 { ATA_DEV_UNKNOWN, "unknown" }, 137 { ATA_DEV_ATA, "ata" }, 138 { ATA_DEV_ATA_UNSUP, "ata" }, 139 { ATA_DEV_ATAPI, "atapi" }, 140 { ATA_DEV_ATAPI_UNSUP, "atapi" }, 141 { ATA_DEV_PMP, "pmp" }, 142 { ATA_DEV_PMP_UNSUP, "pmp" }, 143 { ATA_DEV_SEMB, "semb" }, 144 { ATA_DEV_SEMB_UNSUP, "semb" }, 145 { ATA_DEV_NONE, "none" } 146 }; 147 ata_bitfield_name_search(class, ata_class_names) 148 149 150 static struct { 151 u32 value; 152 char *name; 153 } ata_err_names[] = { 154 { AC_ERR_DEV, "DeviceError" }, 155 { AC_ERR_HSM, "HostStateMachineError" }, 156 { AC_ERR_TIMEOUT, "Timeout" }, 157 { AC_ERR_MEDIA, "MediaError" }, 158 { AC_ERR_ATA_BUS, "BusError" }, 159 { AC_ERR_HOST_BUS, "HostBusError" }, 160 { AC_ERR_SYSTEM, "SystemError" }, 161 { AC_ERR_INVALID, "InvalidArg" }, 162 { AC_ERR_OTHER, "Unknown" }, 163 { AC_ERR_NODEV_HINT, "NoDeviceHint" }, 164 { AC_ERR_NCQ, "NCQError" } 165 }; 166 ata_bitfield_name_match(err, ata_err_names) 167 168 static struct { 169 u32 value; 170 char *name; 171 } ata_xfer_names[] = { 172 { XFER_UDMA_7, "XFER_UDMA_7" }, 173 { XFER_UDMA_6, "XFER_UDMA_6" }, 174 { XFER_UDMA_5, "XFER_UDMA_5" }, 175 { XFER_UDMA_4, "XFER_UDMA_4" }, 176 { XFER_UDMA_3, "XFER_UDMA_3" }, 177 { XFER_UDMA_2, "XFER_UDMA_2" }, 178 { XFER_UDMA_1, "XFER_UDMA_1" }, 179 { XFER_UDMA_0, "XFER_UDMA_0" }, 180 { XFER_MW_DMA_4, "XFER_MW_DMA_4" }, 181 { XFER_MW_DMA_3, "XFER_MW_DMA_3" }, 182 { XFER_MW_DMA_2, "XFER_MW_DMA_2" }, 183 { XFER_MW_DMA_1, "XFER_MW_DMA_1" }, 184 { XFER_MW_DMA_0, "XFER_MW_DMA_0" }, 185 { XFER_SW_DMA_2, "XFER_SW_DMA_2" }, 186 { XFER_SW_DMA_1, "XFER_SW_DMA_1" }, 187 { XFER_SW_DMA_0, "XFER_SW_DMA_0" }, 188 { XFER_PIO_6, "XFER_PIO_6" }, 189 { XFER_PIO_5, "XFER_PIO_5" }, 190 { XFER_PIO_4, "XFER_PIO_4" }, 191 { XFER_PIO_3, "XFER_PIO_3" }, 192 { XFER_PIO_2, "XFER_PIO_2" }, 193 { XFER_PIO_1, "XFER_PIO_1" }, 194 { XFER_PIO_0, "XFER_PIO_0" }, 195 { XFER_PIO_SLOW, "XFER_PIO_SLOW" } 196 }; 197 ata_bitfield_name_match(xfer,ata_xfer_names) 198 199 /* 200 * ATA Port attributes 201 */ 202 #define ata_port_show_simple(field, name, format_string, cast) \ 203 static ssize_t \ 204 show_ata_port_##name(struct device *dev, \ 205 struct device_attribute *attr, char *buf) \ 206 { \ 207 struct ata_port *ap = transport_class_to_port(dev); \ 208 \ 209 return snprintf(buf, 20, format_string, cast ap->field); \ 210 } 211 212 #define ata_port_simple_attr(field, name, format_string, type) \ 213 ata_port_show_simple(field, name, format_string, (type)) \ 214 static DEVICE_ATTR(name, S_IRUGO, show_ata_port_##name, NULL) 215 216 ata_port_simple_attr(nr_pmp_links, nr_pmp_links, "%d\n", int); 217 ata_port_simple_attr(stats.idle_irq, idle_irq, "%ld\n", unsigned long); 218 219 static DECLARE_TRANSPORT_CLASS(ata_port_class, 220 "ata_port", NULL, NULL, NULL); 221 222 static void ata_tport_release(struct device *dev) 223 { 224 put_device(dev->parent); 225 } 226 227 /** 228 * ata_is_port -- check if a struct device represents a ATA port 229 * @dev: device to check 230 * 231 * Returns: 232 * %1 if the device represents a ATA Port, %0 else 233 */ 234 int ata_is_port(const struct device *dev) 235 { 236 return dev->release == ata_tport_release; 237 } 238 239 static int ata_tport_match(struct attribute_container *cont, 240 struct device *dev) 241 { 242 if (!ata_is_port(dev)) 243 return 0; 244 return &ata_scsi_transport_template->host_attrs.ac == cont; 245 } 246 247 /** 248 * ata_tport_delete -- remove ATA PORT 249 * @port: ATA PORT to remove 250 * 251 * Removes the specified ATA PORT. Remove the associated link as well. 252 */ 253 void ata_tport_delete(struct ata_port *ap) 254 { 255 struct device *dev = &ap->tdev; 256 257 ata_tlink_delete(&ap->link); 258 259 transport_remove_device(dev); 260 device_del(dev); 261 transport_destroy_device(dev); 262 put_device(dev); 263 } 264 265 /** ata_tport_add - initialize a transport ATA port structure 266 * 267 * @parent: parent device 268 * @ap: existing ata_port structure 269 * 270 * Initialize a ATA port structure for sysfs. It will be added to the device 271 * tree below the device specified by @parent which could be a PCI device. 272 * 273 * Returns %0 on success 274 */ 275 int ata_tport_add(struct device *parent, 276 struct ata_port *ap) 277 { 278 int error; 279 struct device *dev = &ap->tdev; 280 281 device_initialize(dev); 282 283 dev->parent = get_device(parent); 284 dev->release = ata_tport_release; 285 dev_set_name(dev, "ata%d", ap->print_id); 286 transport_setup_device(dev); 287 error = device_add(dev); 288 if (error) { 289 goto tport_err; 290 } 291 292 transport_add_device(dev); 293 transport_configure_device(dev); 294 295 error = ata_tlink_add(&ap->link); 296 if (error) { 297 goto tport_link_err; 298 } 299 return 0; 300 301 tport_link_err: 302 transport_remove_device(dev); 303 device_del(dev); 304 305 tport_err: 306 transport_destroy_device(dev); 307 put_device(dev); 308 return error; 309 } 310 311 312 /* 313 * ATA link attributes 314 */ 315 316 317 #define ata_link_show_linkspeed(field) \ 318 static ssize_t \ 319 show_ata_link_##field(struct device *dev, \ 320 struct device_attribute *attr, char *buf) \ 321 { \ 322 struct ata_link *link = transport_class_to_link(dev); \ 323 \ 324 return sprintf(buf,"%s\n", sata_spd_string(fls(link->field))); \ 325 } 326 327 #define ata_link_linkspeed_attr(field) \ 328 ata_link_show_linkspeed(field) \ 329 static DEVICE_ATTR(field, S_IRUGO, show_ata_link_##field, NULL) 330 331 ata_link_linkspeed_attr(hw_sata_spd_limit); 332 ata_link_linkspeed_attr(sata_spd_limit); 333 ata_link_linkspeed_attr(sata_spd); 334 335 336 static DECLARE_TRANSPORT_CLASS(ata_link_class, 337 "ata_link", NULL, NULL, NULL); 338 339 static void ata_tlink_release(struct device *dev) 340 { 341 put_device(dev->parent); 342 } 343 344 /** 345 * ata_is_link -- check if a struct device represents a ATA link 346 * @dev: device to check 347 * 348 * Returns: 349 * %1 if the device represents a ATA link, %0 else 350 */ 351 int ata_is_link(const struct device *dev) 352 { 353 return dev->release == ata_tlink_release; 354 } 355 356 static int ata_tlink_match(struct attribute_container *cont, 357 struct device *dev) 358 { 359 struct ata_internal* i = to_ata_internal(ata_scsi_transport_template); 360 if (!ata_is_link(dev)) 361 return 0; 362 return &i->link_attr_cont.ac == cont; 363 } 364 365 /** 366 * ata_tlink_delete -- remove ATA LINK 367 * @port: ATA LINK to remove 368 * 369 * Removes the specified ATA LINK. remove associated ATA device(s) as well. 370 */ 371 void ata_tlink_delete(struct ata_link *link) 372 { 373 struct device *dev = &link->tdev; 374 struct ata_device *ata_dev; 375 376 ata_for_each_dev(ata_dev, link, ALL) { 377 ata_tdev_delete(ata_dev); 378 } 379 380 transport_remove_device(dev); 381 device_del(dev); 382 transport_destroy_device(dev); 383 put_device(dev); 384 } 385 386 /** 387 * ata_tlink_add -- initialize a transport ATA link structure 388 * @link: allocated ata_link structure. 389 * 390 * Initialize an ATA LINK structure for sysfs. It will be added in the 391 * device tree below the ATA PORT it belongs to. 392 * 393 * Returns %0 on success 394 */ 395 int ata_tlink_add(struct ata_link *link) 396 { 397 struct device *dev = &link->tdev; 398 struct ata_port *ap = link->ap; 399 struct ata_device *ata_dev; 400 int error; 401 402 device_initialize(dev); 403 dev->parent = get_device(&ap->tdev); 404 dev->release = ata_tlink_release; 405 if (ata_is_host_link(link)) 406 dev_set_name(dev, "link%d", ap->print_id); 407 else 408 dev_set_name(dev, "link%d.%d", ap->print_id, link->pmp); 409 410 transport_setup_device(dev); 411 412 error = device_add(dev); 413 if (error) { 414 goto tlink_err; 415 } 416 417 transport_add_device(dev); 418 transport_configure_device(dev); 419 420 ata_for_each_dev(ata_dev, link, ALL) { 421 error = ata_tdev_add(ata_dev); 422 if (error) { 423 goto tlink_dev_err; 424 } 425 } 426 return 0; 427 tlink_dev_err: 428 while (--ata_dev >= link->device) { 429 ata_tdev_delete(ata_dev); 430 } 431 transport_remove_device(dev); 432 device_del(dev); 433 tlink_err: 434 transport_destroy_device(dev); 435 put_device(dev); 436 return error; 437 } 438 439 /* 440 * ATA device attributes 441 */ 442 443 #define ata_dev_show_class(title, field) \ 444 static ssize_t \ 445 show_ata_dev_##field(struct device *dev, \ 446 struct device_attribute *attr, char *buf) \ 447 { \ 448 struct ata_device *ata_dev = transport_class_to_dev(dev); \ 449 \ 450 return get_ata_##title##_names(ata_dev->field, buf); \ 451 } 452 453 #define ata_dev_attr(title, field) \ 454 ata_dev_show_class(title, field) \ 455 static DEVICE_ATTR(field, S_IRUGO, show_ata_dev_##field, NULL) 456 457 ata_dev_attr(class, class); 458 ata_dev_attr(xfer, pio_mode); 459 ata_dev_attr(xfer, dma_mode); 460 ata_dev_attr(xfer, xfer_mode); 461 462 463 #define ata_dev_show_simple(field, format_string, cast) \ 464 static ssize_t \ 465 show_ata_dev_##field(struct device *dev, \ 466 struct device_attribute *attr, char *buf) \ 467 { \ 468 struct ata_device *ata_dev = transport_class_to_dev(dev); \ 469 \ 470 return snprintf(buf, 20, format_string, cast ata_dev->field); \ 471 } 472 473 #define ata_dev_simple_attr(field, format_string, type) \ 474 ata_dev_show_simple(field, format_string, (type)) \ 475 static DEVICE_ATTR(field, S_IRUGO, \ 476 show_ata_dev_##field, NULL) 477 478 ata_dev_simple_attr(spdn_cnt, "%d\n", int); 479 480 struct ata_show_ering_arg { 481 char* buf; 482 int written; 483 }; 484 485 static int ata_show_ering(struct ata_ering_entry *ent, void *void_arg) 486 { 487 struct ata_show_ering_arg* arg = void_arg; 488 struct timespec time; 489 490 jiffies_to_timespec(ent->timestamp,&time); 491 arg->written += sprintf(arg->buf + arg->written, 492 "[%5lu.%06lu]", 493 time.tv_sec, time.tv_nsec); 494 arg->written += get_ata_err_names(ent->err_mask, 495 arg->buf + arg->written); 496 return 0; 497 } 498 499 static ssize_t 500 show_ata_dev_ering(struct device *dev, 501 struct device_attribute *attr, char *buf) 502 { 503 struct ata_device *ata_dev = transport_class_to_dev(dev); 504 struct ata_show_ering_arg arg = { buf, 0 }; 505 506 ata_ering_map(&ata_dev->ering, ata_show_ering, &arg); 507 return arg.written; 508 } 509 510 511 static DEVICE_ATTR(ering, S_IRUGO, show_ata_dev_ering, NULL); 512 513 static ssize_t 514 show_ata_dev_id(struct device *dev, 515 struct device_attribute *attr, char *buf) 516 { 517 struct ata_device *ata_dev = transport_class_to_dev(dev); 518 int written = 0, i = 0; 519 520 if (ata_dev->class == ATA_DEV_PMP) 521 return 0; 522 for(i=0;i<ATA_ID_WORDS;i++) { 523 written += snprintf(buf+written, 20, "%04x%c", 524 ata_dev->id[i], 525 ((i+1) & 7) ? ' ' : '\n'); 526 } 527 return written; 528 } 529 530 static DEVICE_ATTR(id, S_IRUGO, show_ata_dev_id, NULL); 531 532 static ssize_t 533 show_ata_dev_gscr(struct device *dev, 534 struct device_attribute *attr, char *buf) 535 { 536 struct ata_device *ata_dev = transport_class_to_dev(dev); 537 int written = 0, i = 0; 538 539 if (ata_dev->class != ATA_DEV_PMP) 540 return 0; 541 for(i=0;i<SATA_PMP_GSCR_DWORDS;i++) { 542 written += snprintf(buf+written, 20, "%08x%c", 543 ata_dev->gscr[i], 544 ((i+1) & 3) ? ' ' : '\n'); 545 } 546 if (SATA_PMP_GSCR_DWORDS & 3) 547 buf[written-1] = '\n'; 548 return written; 549 } 550 551 static DEVICE_ATTR(gscr, S_IRUGO, show_ata_dev_gscr, NULL); 552 553 static DECLARE_TRANSPORT_CLASS(ata_dev_class, 554 "ata_device", NULL, NULL, NULL); 555 556 static void ata_tdev_release(struct device *dev) 557 { 558 put_device(dev->parent); 559 } 560 561 /** 562 * ata_is_ata_dev -- check if a struct device represents a ATA device 563 * @dev: device to check 564 * 565 * Returns: 566 * %1 if the device represents a ATA device, %0 else 567 */ 568 int ata_is_ata_dev(const struct device *dev) 569 { 570 return dev->release == ata_tdev_release; 571 } 572 573 static int ata_tdev_match(struct attribute_container *cont, 574 struct device *dev) 575 { 576 struct ata_internal* i = to_ata_internal(ata_scsi_transport_template); 577 if (!ata_is_ata_dev(dev)) 578 return 0; 579 return &i->dev_attr_cont.ac == cont; 580 } 581 582 /** 583 * ata_tdev_free -- free a ATA LINK 584 * @dev: ATA PHY to free 585 * 586 * Frees the specified ATA PHY. 587 * 588 * Note: 589 * This function must only be called on a PHY that has not 590 * successfully been added using ata_tdev_add(). 591 */ 592 static void ata_tdev_free(struct ata_device *dev) 593 { 594 transport_destroy_device(&dev->tdev); 595 put_device(&dev->tdev); 596 } 597 598 /** 599 * ata_tdev_delete -- remove ATA device 600 * @port: ATA PORT to remove 601 * 602 * Removes the specified ATA device. 603 */ 604 static void ata_tdev_delete(struct ata_device *ata_dev) 605 { 606 struct device *dev = &ata_dev->tdev; 607 608 transport_remove_device(dev); 609 device_del(dev); 610 ata_tdev_free(ata_dev); 611 } 612 613 614 /** 615 * ata_tdev_add -- initialize a transport ATA device structure. 616 * @ata_dev: ata_dev structure. 617 * 618 * Initialize an ATA device structure for sysfs. It will be added in the 619 * device tree below the ATA LINK device it belongs to. 620 * 621 * Returns %0 on success 622 */ 623 static int ata_tdev_add(struct ata_device *ata_dev) 624 { 625 struct device *dev = &ata_dev->tdev; 626 struct ata_link *link = ata_dev->link; 627 struct ata_port *ap = link->ap; 628 int error; 629 630 device_initialize(dev); 631 dev->parent = get_device(&link->tdev); 632 dev->release = ata_tdev_release; 633 if (ata_is_host_link(link)) 634 dev_set_name(dev, "dev%d.%d", ap->print_id,ata_dev->devno); 635 else 636 dev_set_name(dev, "dev%d.%d.0", ap->print_id, link->pmp); 637 638 transport_setup_device(dev); 639 error = device_add(dev); 640 if (error) { 641 ata_tdev_free(ata_dev); 642 return error; 643 } 644 645 transport_add_device(dev); 646 transport_configure_device(dev); 647 return 0; 648 } 649 650 651 /* 652 * Setup / Teardown code 653 */ 654 655 #define SETUP_TEMPLATE(attrb, field, perm, test) \ 656 i->private_##attrb[count] = dev_attr_##field; \ 657 i->private_##attrb[count].attr.mode = perm; \ 658 i->attrb[count] = &i->private_##attrb[count]; \ 659 if (test) \ 660 count++ 661 662 #define SETUP_LINK_ATTRIBUTE(field) \ 663 SETUP_TEMPLATE(link_attrs, field, S_IRUGO, 1) 664 665 #define SETUP_PORT_ATTRIBUTE(field) \ 666 SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1) 667 668 #define SETUP_DEV_ATTRIBUTE(field) \ 669 SETUP_TEMPLATE(dev_attrs, field, S_IRUGO, 1) 670 671 /** 672 * ata_attach_transport -- instantiate ATA transport template 673 */ 674 struct scsi_transport_template *ata_attach_transport(void) 675 { 676 struct ata_internal *i; 677 int count; 678 679 i = kzalloc(sizeof(struct ata_internal), GFP_KERNEL); 680 if (!i) 681 return NULL; 682 683 i->t.eh_strategy_handler = ata_scsi_error; 684 i->t.eh_timed_out = ata_scsi_timed_out; 685 i->t.user_scan = ata_scsi_user_scan; 686 687 i->t.host_attrs.ac.attrs = &i->port_attrs[0]; 688 i->t.host_attrs.ac.class = &ata_port_class.class; 689 i->t.host_attrs.ac.match = ata_tport_match; 690 transport_container_register(&i->t.host_attrs); 691 692 i->link_attr_cont.ac.class = &ata_link_class.class; 693 i->link_attr_cont.ac.attrs = &i->link_attrs[0]; 694 i->link_attr_cont.ac.match = ata_tlink_match; 695 transport_container_register(&i->link_attr_cont); 696 697 i->dev_attr_cont.ac.class = &ata_dev_class.class; 698 i->dev_attr_cont.ac.attrs = &i->dev_attrs[0]; 699 i->dev_attr_cont.ac.match = ata_tdev_match; 700 transport_container_register(&i->dev_attr_cont); 701 702 count = 0; 703 SETUP_PORT_ATTRIBUTE(nr_pmp_links); 704 SETUP_PORT_ATTRIBUTE(idle_irq); 705 BUG_ON(count > ATA_PORT_ATTRS); 706 i->port_attrs[count] = NULL; 707 708 count = 0; 709 SETUP_LINK_ATTRIBUTE(hw_sata_spd_limit); 710 SETUP_LINK_ATTRIBUTE(sata_spd_limit); 711 SETUP_LINK_ATTRIBUTE(sata_spd); 712 BUG_ON(count > ATA_LINK_ATTRS); 713 i->link_attrs[count] = NULL; 714 715 count = 0; 716 SETUP_DEV_ATTRIBUTE(class); 717 SETUP_DEV_ATTRIBUTE(pio_mode); 718 SETUP_DEV_ATTRIBUTE(dma_mode); 719 SETUP_DEV_ATTRIBUTE(xfer_mode); 720 SETUP_DEV_ATTRIBUTE(spdn_cnt); 721 SETUP_DEV_ATTRIBUTE(ering); 722 SETUP_DEV_ATTRIBUTE(id); 723 SETUP_DEV_ATTRIBUTE(gscr); 724 BUG_ON(count > ATA_DEV_ATTRS); 725 i->dev_attrs[count] = NULL; 726 727 return &i->t; 728 } 729 730 /** 731 * ata_release_transport -- release ATA transport template instance 732 * @t: transport template instance 733 */ 734 void ata_release_transport(struct scsi_transport_template *t) 735 { 736 struct ata_internal *i = to_ata_internal(t); 737 738 transport_container_unregister(&i->t.host_attrs); 739 transport_container_unregister(&i->link_attr_cont); 740 transport_container_unregister(&i->dev_attr_cont); 741 742 kfree(i); 743 } 744 745 __init int libata_transport_init(void) 746 { 747 int error; 748 749 error = transport_class_register(&ata_link_class); 750 if (error) 751 goto out_unregister_transport; 752 error = transport_class_register(&ata_port_class); 753 if (error) 754 goto out_unregister_link; 755 error = transport_class_register(&ata_dev_class); 756 if (error) 757 goto out_unregister_port; 758 return 0; 759 760 out_unregister_port: 761 transport_class_unregister(&ata_port_class); 762 out_unregister_link: 763 transport_class_unregister(&ata_link_class); 764 out_unregister_transport: 765 return error; 766 767 } 768 769 void __exit libata_transport_exit(void) 770 { 771 transport_class_unregister(&ata_link_class); 772 transport_class_unregister(&ata_port_class); 773 transport_class_unregister(&ata_dev_class); 774 } 775