1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Serial Attached SCSI (SAS) Transport Layer initialization 4 * 5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/init.h> 12 #include <linux/device.h> 13 #include <linux/spinlock.h> 14 #include <scsi/sas_ata.h> 15 #include <scsi/scsi_host.h> 16 #include <scsi/scsi_device.h> 17 #include <scsi/scsi_transport.h> 18 #include <scsi/scsi_transport_sas.h> 19 20 #include "sas_internal.h" 21 22 #include "scsi_sas_internal.h" 23 24 static struct kmem_cache *sas_task_cache; 25 static struct kmem_cache *sas_event_cache; 26 27 struct sas_task *sas_alloc_task(gfp_t flags) 28 { 29 struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags); 30 31 if (task) { 32 spin_lock_init(&task->task_state_lock); 33 task->task_state_flags = SAS_TASK_STATE_PENDING; 34 } 35 36 return task; 37 } 38 39 struct sas_task *sas_alloc_slow_task(gfp_t flags) 40 { 41 struct sas_task *task = sas_alloc_task(flags); 42 struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags); 43 44 if (!task || !slow) { 45 if (task) 46 kmem_cache_free(sas_task_cache, task); 47 kfree(slow); 48 return NULL; 49 } 50 51 task->slow_task = slow; 52 slow->task = task; 53 timer_setup(&slow->timer, NULL, 0); 54 init_completion(&slow->completion); 55 56 return task; 57 } 58 59 void sas_free_task(struct sas_task *task) 60 { 61 if (task) { 62 kfree(task->slow_task); 63 kmem_cache_free(sas_task_cache, task); 64 } 65 } 66 67 /*------------ SAS addr hash -----------*/ 68 void sas_hash_addr(u8 *hashed, const u8 *sas_addr) 69 { 70 const u32 poly = 0x00DB2777; 71 u32 r = 0; 72 int i; 73 74 for (i = 0; i < SAS_ADDR_SIZE; i++) { 75 int b; 76 77 for (b = (SAS_ADDR_SIZE - 1); b >= 0; b--) { 78 r <<= 1; 79 if ((1 << b) & sas_addr[i]) { 80 if (!(r & 0x01000000)) 81 r ^= poly; 82 } else if (r & 0x01000000) { 83 r ^= poly; 84 } 85 } 86 } 87 88 hashed[0] = (r >> 16) & 0xFF; 89 hashed[1] = (r >> 8) & 0xFF; 90 hashed[2] = r & 0xFF; 91 } 92 93 int sas_register_ha(struct sas_ha_struct *sas_ha) 94 { 95 char name[64]; 96 int error = 0; 97 98 mutex_init(&sas_ha->disco_mutex); 99 spin_lock_init(&sas_ha->phy_port_lock); 100 sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr); 101 102 set_bit(SAS_HA_REGISTERED, &sas_ha->state); 103 spin_lock_init(&sas_ha->lock); 104 mutex_init(&sas_ha->drain_mutex); 105 init_waitqueue_head(&sas_ha->eh_wait_q); 106 INIT_LIST_HEAD(&sas_ha->defer_q); 107 INIT_LIST_HEAD(&sas_ha->eh_dev_q); 108 109 sas_ha->event_thres = SAS_PHY_SHUTDOWN_THRES; 110 111 error = sas_register_phys(sas_ha); 112 if (error) { 113 pr_notice("couldn't register sas phys:%d\n", error); 114 return error; 115 } 116 117 error = sas_register_ports(sas_ha); 118 if (error) { 119 pr_notice("couldn't register sas ports:%d\n", error); 120 goto Undo_phys; 121 } 122 123 error = -ENOMEM; 124 snprintf(name, sizeof(name), "%s_event_q", dev_name(sas_ha->dev)); 125 sas_ha->event_q = alloc_ordered_workqueue("%s", WQ_MEM_RECLAIM, name); 126 if (!sas_ha->event_q) 127 goto Undo_ports; 128 129 snprintf(name, sizeof(name), "%s_disco_q", dev_name(sas_ha->dev)); 130 sas_ha->disco_q = alloc_ordered_workqueue("%s", WQ_MEM_RECLAIM, name); 131 if (!sas_ha->disco_q) 132 goto Undo_event_q; 133 134 INIT_LIST_HEAD(&sas_ha->eh_done_q); 135 INIT_LIST_HEAD(&sas_ha->eh_ata_q); 136 137 return 0; 138 139 Undo_event_q: 140 destroy_workqueue(sas_ha->event_q); 141 Undo_ports: 142 sas_unregister_ports(sas_ha); 143 Undo_phys: 144 sas_unregister_phys(sas_ha); 145 146 return error; 147 } 148 EXPORT_SYMBOL_GPL(sas_register_ha); 149 150 static void sas_disable_events(struct sas_ha_struct *sas_ha) 151 { 152 /* Set the state to unregistered to avoid further unchained 153 * events to be queued, and flush any in-progress drainers 154 */ 155 mutex_lock(&sas_ha->drain_mutex); 156 spin_lock_irq(&sas_ha->lock); 157 clear_bit(SAS_HA_REGISTERED, &sas_ha->state); 158 spin_unlock_irq(&sas_ha->lock); 159 __sas_drain_work(sas_ha); 160 mutex_unlock(&sas_ha->drain_mutex); 161 } 162 163 int sas_unregister_ha(struct sas_ha_struct *sas_ha) 164 { 165 sas_disable_events(sas_ha); 166 sas_unregister_ports(sas_ha); 167 168 /* flush unregistration work */ 169 mutex_lock(&sas_ha->drain_mutex); 170 __sas_drain_work(sas_ha); 171 mutex_unlock(&sas_ha->drain_mutex); 172 173 destroy_workqueue(sas_ha->disco_q); 174 destroy_workqueue(sas_ha->event_q); 175 176 return 0; 177 } 178 EXPORT_SYMBOL_GPL(sas_unregister_ha); 179 180 static int sas_get_linkerrors(struct sas_phy *phy) 181 { 182 if (scsi_is_sas_phy_local(phy)) { 183 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 184 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 185 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 186 struct sas_internal *i = 187 to_sas_internal(sas_ha->shost->transportt); 188 189 return i->dft->lldd_control_phy(asd_phy, PHY_FUNC_GET_EVENTS, NULL); 190 } 191 192 return sas_smp_get_phy_events(phy); 193 } 194 195 int sas_try_ata_reset(struct asd_sas_phy *asd_phy) 196 { 197 struct domain_device *dev = NULL; 198 199 /* try to route user requested link resets through libata */ 200 if (asd_phy->port) 201 dev = asd_phy->port->port_dev; 202 203 /* validate that dev has been probed */ 204 if (dev) 205 dev = sas_find_dev_by_rphy(dev->rphy); 206 207 if (dev && dev_is_sata(dev)) { 208 sas_ata_schedule_reset(dev); 209 sas_ata_wait_eh(dev); 210 return 0; 211 } 212 213 return -ENODEV; 214 } 215 216 /* 217 * transport_sas_phy_reset - reset a phy and permit libata to manage the link 218 * 219 * phy reset request via sysfs in host workqueue context so we know we 220 * can block on eh and safely traverse the domain_device topology 221 */ 222 static int transport_sas_phy_reset(struct sas_phy *phy, int hard_reset) 223 { 224 enum phy_func reset_type; 225 226 if (hard_reset) 227 reset_type = PHY_FUNC_HARD_RESET; 228 else 229 reset_type = PHY_FUNC_LINK_RESET; 230 231 if (scsi_is_sas_phy_local(phy)) { 232 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 233 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 234 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 235 struct sas_internal *i = 236 to_sas_internal(sas_ha->shost->transportt); 237 238 if (!hard_reset && sas_try_ata_reset(asd_phy) == 0) 239 return 0; 240 return i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 241 } else { 242 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 243 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 244 struct domain_device *ata_dev = sas_ex_to_ata(ddev, phy->number); 245 246 if (ata_dev && !hard_reset) { 247 sas_ata_schedule_reset(ata_dev); 248 sas_ata_wait_eh(ata_dev); 249 return 0; 250 } else 251 return sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 252 } 253 } 254 255 int sas_phy_enable(struct sas_phy *phy, int enable) 256 { 257 int ret; 258 enum phy_func cmd; 259 260 if (enable) 261 cmd = PHY_FUNC_LINK_RESET; 262 else 263 cmd = PHY_FUNC_DISABLE; 264 265 if (scsi_is_sas_phy_local(phy)) { 266 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 267 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 268 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 269 struct sas_internal *i = 270 to_sas_internal(sas_ha->shost->transportt); 271 272 if (enable) 273 ret = transport_sas_phy_reset(phy, 0); 274 else 275 ret = i->dft->lldd_control_phy(asd_phy, cmd, NULL); 276 } else { 277 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 278 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 279 280 if (enable) 281 ret = transport_sas_phy_reset(phy, 0); 282 else 283 ret = sas_smp_phy_control(ddev, phy->number, cmd, NULL); 284 } 285 return ret; 286 } 287 EXPORT_SYMBOL_GPL(sas_phy_enable); 288 289 int sas_phy_reset(struct sas_phy *phy, int hard_reset) 290 { 291 int ret; 292 enum phy_func reset_type; 293 294 if (!phy->enabled) 295 return -ENODEV; 296 297 if (hard_reset) 298 reset_type = PHY_FUNC_HARD_RESET; 299 else 300 reset_type = PHY_FUNC_LINK_RESET; 301 302 if (scsi_is_sas_phy_local(phy)) { 303 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 304 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 305 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 306 struct sas_internal *i = 307 to_sas_internal(sas_ha->shost->transportt); 308 309 ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 310 } else { 311 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 312 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 313 ret = sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 314 } 315 return ret; 316 } 317 EXPORT_SYMBOL_GPL(sas_phy_reset); 318 319 static int sas_set_phy_speed(struct sas_phy *phy, 320 struct sas_phy_linkrates *rates) 321 { 322 int ret; 323 324 if ((rates->minimum_linkrate && 325 rates->minimum_linkrate > phy->maximum_linkrate) || 326 (rates->maximum_linkrate && 327 rates->maximum_linkrate < phy->minimum_linkrate)) 328 return -EINVAL; 329 330 if (rates->minimum_linkrate && 331 rates->minimum_linkrate < phy->minimum_linkrate_hw) 332 rates->minimum_linkrate = phy->minimum_linkrate_hw; 333 334 if (rates->maximum_linkrate && 335 rates->maximum_linkrate > phy->maximum_linkrate_hw) 336 rates->maximum_linkrate = phy->maximum_linkrate_hw; 337 338 if (scsi_is_sas_phy_local(phy)) { 339 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 340 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 341 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 342 struct sas_internal *i = 343 to_sas_internal(sas_ha->shost->transportt); 344 345 ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE, 346 rates); 347 } else { 348 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 349 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 350 ret = sas_smp_phy_control(ddev, phy->number, 351 PHY_FUNC_LINK_RESET, rates); 352 353 } 354 355 return ret; 356 } 357 358 void sas_prep_resume_ha(struct sas_ha_struct *ha) 359 { 360 int i; 361 362 set_bit(SAS_HA_REGISTERED, &ha->state); 363 set_bit(SAS_HA_RESUMING, &ha->state); 364 365 /* clear out any stale link events/data from the suspension path */ 366 for (i = 0; i < ha->num_phys; i++) { 367 struct asd_sas_phy *phy = ha->sas_phy[i]; 368 369 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 370 phy->frame_rcvd_size = 0; 371 } 372 } 373 EXPORT_SYMBOL(sas_prep_resume_ha); 374 375 static int phys_suspended(struct sas_ha_struct *ha) 376 { 377 int i, rc = 0; 378 379 for (i = 0; i < ha->num_phys; i++) { 380 struct asd_sas_phy *phy = ha->sas_phy[i]; 381 382 if (phy->suspended) 383 rc++; 384 } 385 386 return rc; 387 } 388 389 static void sas_resume_insert_broadcast_ha(struct sas_ha_struct *ha) 390 { 391 int i; 392 393 for (i = 0; i < ha->num_phys; i++) { 394 struct asd_sas_port *port = ha->sas_port[i]; 395 struct domain_device *dev = port->port_dev; 396 397 if (dev && dev_is_expander(dev->dev_type)) { 398 struct asd_sas_phy *first_phy; 399 400 spin_lock(&port->phy_list_lock); 401 first_phy = list_first_entry_or_null( 402 &port->phy_list, struct asd_sas_phy, 403 port_phy_el); 404 spin_unlock(&port->phy_list_lock); 405 406 if (first_phy) 407 sas_notify_port_event(first_phy, 408 PORTE_BROADCAST_RCVD, GFP_KERNEL); 409 } 410 } 411 } 412 413 static void _sas_resume_ha(struct sas_ha_struct *ha, bool drain) 414 { 415 const unsigned long tmo = msecs_to_jiffies(25000); 416 int i; 417 418 /* deform ports on phys that did not resume 419 * at this point we may be racing the phy coming back (as posted 420 * by the lldd). So we post the event and once we are in the 421 * libsas context check that the phy remains suspended before 422 * tearing it down. 423 */ 424 i = phys_suspended(ha); 425 if (i) 426 dev_info(ha->dev, "waiting up to 25 seconds for %d phy%s to resume\n", 427 i, i > 1 ? "s" : ""); 428 wait_event_timeout(ha->eh_wait_q, phys_suspended(ha) == 0, tmo); 429 for (i = 0; i < ha->num_phys; i++) { 430 struct asd_sas_phy *phy = ha->sas_phy[i]; 431 432 if (phy->suspended) { 433 dev_warn(&phy->phy->dev, "resume timeout\n"); 434 sas_notify_phy_event(phy, PHYE_RESUME_TIMEOUT, 435 GFP_KERNEL); 436 } 437 } 438 439 /* all phys are back up or timed out, turn on i/o so we can 440 * flush out disks that did not return 441 */ 442 scsi_unblock_requests(ha->shost); 443 if (drain) 444 sas_drain_work(ha); 445 clear_bit(SAS_HA_RESUMING, &ha->state); 446 447 sas_queue_deferred_work(ha); 448 /* send event PORTE_BROADCAST_RCVD to identify some new inserted 449 * disks for expander 450 */ 451 sas_resume_insert_broadcast_ha(ha); 452 } 453 454 void sas_resume_ha(struct sas_ha_struct *ha) 455 { 456 _sas_resume_ha(ha, true); 457 } 458 EXPORT_SYMBOL(sas_resume_ha); 459 460 /* A no-sync variant, which does not call sas_drain_ha(). */ 461 void sas_resume_ha_no_sync(struct sas_ha_struct *ha) 462 { 463 _sas_resume_ha(ha, false); 464 } 465 EXPORT_SYMBOL(sas_resume_ha_no_sync); 466 467 void sas_suspend_ha(struct sas_ha_struct *ha) 468 { 469 int i; 470 471 sas_disable_events(ha); 472 scsi_block_requests(ha->shost); 473 for (i = 0; i < ha->num_phys; i++) { 474 struct asd_sas_port *port = ha->sas_port[i]; 475 476 sas_discover_event(port, DISCE_SUSPEND); 477 } 478 479 /* flush suspend events while unregistered */ 480 mutex_lock(&ha->drain_mutex); 481 __sas_drain_work(ha); 482 mutex_unlock(&ha->drain_mutex); 483 } 484 EXPORT_SYMBOL(sas_suspend_ha); 485 486 static void sas_phy_release(struct sas_phy *phy) 487 { 488 kfree(phy->hostdata); 489 phy->hostdata = NULL; 490 } 491 492 static void phy_reset_work(struct work_struct *work) 493 { 494 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work); 495 496 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 497 } 498 499 static void phy_enable_work(struct work_struct *work) 500 { 501 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work); 502 503 d->enable_result = sas_phy_enable(d->phy, d->enable); 504 } 505 506 static int sas_phy_setup(struct sas_phy *phy) 507 { 508 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 509 510 if (!d) 511 return -ENOMEM; 512 513 mutex_init(&d->event_lock); 514 INIT_SAS_WORK(&d->reset_work, phy_reset_work); 515 INIT_SAS_WORK(&d->enable_work, phy_enable_work); 516 d->phy = phy; 517 phy->hostdata = d; 518 519 return 0; 520 } 521 522 static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 523 { 524 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 525 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 526 struct sas_phy_data *d = phy->hostdata; 527 int rc; 528 529 if (!d) 530 return -ENOMEM; 531 532 pm_runtime_get_sync(ha->dev); 533 /* libsas workqueue coordinates ata-eh reset with discovery */ 534 mutex_lock(&d->event_lock); 535 d->reset_result = 0; 536 d->hard_reset = hard_reset; 537 538 spin_lock_irq(&ha->lock); 539 sas_queue_work(ha, &d->reset_work); 540 spin_unlock_irq(&ha->lock); 541 542 rc = sas_drain_work(ha); 543 if (rc == 0) 544 rc = d->reset_result; 545 mutex_unlock(&d->event_lock); 546 pm_runtime_put_sync(ha->dev); 547 548 return rc; 549 } 550 551 static int queue_phy_enable(struct sas_phy *phy, int enable) 552 { 553 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 554 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 555 struct sas_phy_data *d = phy->hostdata; 556 int rc; 557 558 if (!d) 559 return -ENOMEM; 560 561 pm_runtime_get_sync(ha->dev); 562 /* libsas workqueue coordinates ata-eh reset with discovery */ 563 mutex_lock(&d->event_lock); 564 d->enable_result = 0; 565 d->enable = enable; 566 567 spin_lock_irq(&ha->lock); 568 sas_queue_work(ha, &d->enable_work); 569 spin_unlock_irq(&ha->lock); 570 571 rc = sas_drain_work(ha); 572 if (rc == 0) 573 rc = d->enable_result; 574 mutex_unlock(&d->event_lock); 575 pm_runtime_put_sync(ha->dev); 576 577 return rc; 578 } 579 580 static struct sas_function_template sft = { 581 .phy_enable = queue_phy_enable, 582 .phy_reset = queue_phy_reset, 583 .phy_setup = sas_phy_setup, 584 .phy_release = sas_phy_release, 585 .set_phy_speed = sas_set_phy_speed, 586 .get_linkerrors = sas_get_linkerrors, 587 .smp_handler = sas_smp_handler, 588 }; 589 590 static inline ssize_t phy_event_threshold_show(struct device *dev, 591 struct device_attribute *attr, char *buf) 592 { 593 struct Scsi_Host *shost = class_to_shost(dev); 594 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 595 596 return scnprintf(buf, PAGE_SIZE, "%u\n", sha->event_thres); 597 } 598 599 static inline ssize_t phy_event_threshold_store(struct device *dev, 600 struct device_attribute *attr, 601 const char *buf, size_t count) 602 { 603 struct Scsi_Host *shost = class_to_shost(dev); 604 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 605 606 sha->event_thres = simple_strtol(buf, NULL, 10); 607 608 /* threshold cannot be set too small */ 609 if (sha->event_thres < 32) 610 sha->event_thres = 32; 611 612 return count; 613 } 614 615 DEVICE_ATTR(phy_event_threshold, 616 S_IRUGO|S_IWUSR, 617 phy_event_threshold_show, 618 phy_event_threshold_store); 619 EXPORT_SYMBOL_GPL(dev_attr_phy_event_threshold); 620 621 struct scsi_transport_template * 622 sas_domain_attach_transport(struct sas_domain_function_template *dft) 623 { 624 struct scsi_transport_template *stt = sas_attach_transport(&sft); 625 struct sas_internal *i; 626 627 if (!stt) 628 return stt; 629 630 i = to_sas_internal(stt); 631 i->dft = dft; 632 stt->create_work_queue = 1; 633 stt->eh_strategy_handler = sas_scsi_recover_host; 634 635 return stt; 636 } 637 EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 638 639 struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy, 640 gfp_t gfp_flags) 641 { 642 struct asd_sas_event *event; 643 struct sas_ha_struct *sas_ha = phy->ha; 644 struct sas_internal *i = 645 to_sas_internal(sas_ha->shost->transportt); 646 647 event = kmem_cache_zalloc(sas_event_cache, gfp_flags); 648 if (!event) 649 return NULL; 650 651 atomic_inc(&phy->event_nr); 652 653 if (atomic_read(&phy->event_nr) > phy->ha->event_thres) { 654 if (i->dft->lldd_control_phy) { 655 if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) { 656 pr_notice("The phy%d bursting events, shut it down.\n", 657 phy->id); 658 sas_notify_phy_event(phy, PHYE_SHUTDOWN, 659 gfp_flags); 660 } 661 } else { 662 /* Do not support PHY control, stop allocating events */ 663 WARN_ONCE(1, "PHY control not supported.\n"); 664 kmem_cache_free(sas_event_cache, event); 665 atomic_dec(&phy->event_nr); 666 event = NULL; 667 } 668 } 669 670 return event; 671 } 672 673 void sas_free_event(struct asd_sas_event *event) 674 { 675 struct asd_sas_phy *phy = event->phy; 676 677 kmem_cache_free(sas_event_cache, event); 678 atomic_dec(&phy->event_nr); 679 } 680 681 /* ---------- SAS Class register/unregister ---------- */ 682 683 static int __init sas_class_init(void) 684 { 685 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 686 if (!sas_task_cache) 687 goto out; 688 689 sas_event_cache = KMEM_CACHE(asd_sas_event, SLAB_HWCACHE_ALIGN); 690 if (!sas_event_cache) 691 goto free_task_kmem; 692 693 return 0; 694 free_task_kmem: 695 kmem_cache_destroy(sas_task_cache); 696 out: 697 return -ENOMEM; 698 } 699 700 static void __exit sas_class_exit(void) 701 { 702 kmem_cache_destroy(sas_task_cache); 703 kmem_cache_destroy(sas_event_cache); 704 } 705 706 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 707 MODULE_DESCRIPTION("SAS Transport Layer"); 708 MODULE_LICENSE("GPL v2"); 709 710 module_init(sas_class_init); 711 module_exit(sas_class_exit); 712 713