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 EXPORT_SYMBOL_GPL(sas_alloc_task); 39 40 struct sas_task *sas_alloc_slow_task(gfp_t flags) 41 { 42 struct sas_task *task = sas_alloc_task(flags); 43 struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags); 44 45 if (!task || !slow) { 46 if (task) 47 kmem_cache_free(sas_task_cache, task); 48 kfree(slow); 49 return NULL; 50 } 51 52 task->slow_task = slow; 53 slow->task = task; 54 timer_setup(&slow->timer, NULL, 0); 55 init_completion(&slow->completion); 56 57 return task; 58 } 59 EXPORT_SYMBOL_GPL(sas_alloc_slow_task); 60 61 void sas_free_task(struct sas_task *task) 62 { 63 if (task) { 64 kfree(task->slow_task); 65 kmem_cache_free(sas_task_cache, task); 66 } 67 } 68 EXPORT_SYMBOL_GPL(sas_free_task); 69 70 /*------------ SAS addr hash -----------*/ 71 void sas_hash_addr(u8 *hashed, const u8 *sas_addr) 72 { 73 const u32 poly = 0x00DB2777; 74 u32 r = 0; 75 int i; 76 77 for (i = 0; i < SAS_ADDR_SIZE; i++) { 78 int b; 79 80 for (b = (SAS_ADDR_SIZE - 1); b >= 0; b--) { 81 r <<= 1; 82 if ((1 << b) & sas_addr[i]) { 83 if (!(r & 0x01000000)) 84 r ^= poly; 85 } else if (r & 0x01000000) { 86 r ^= poly; 87 } 88 } 89 } 90 91 hashed[0] = (r >> 16) & 0xFF; 92 hashed[1] = (r >> 8) & 0xFF; 93 hashed[2] = r & 0xFF; 94 } 95 96 int sas_register_ha(struct sas_ha_struct *sas_ha) 97 { 98 char name[64]; 99 int error = 0; 100 101 mutex_init(&sas_ha->disco_mutex); 102 spin_lock_init(&sas_ha->phy_port_lock); 103 sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr); 104 105 set_bit(SAS_HA_REGISTERED, &sas_ha->state); 106 spin_lock_init(&sas_ha->lock); 107 mutex_init(&sas_ha->drain_mutex); 108 init_waitqueue_head(&sas_ha->eh_wait_q); 109 INIT_LIST_HEAD(&sas_ha->defer_q); 110 INIT_LIST_HEAD(&sas_ha->eh_dev_q); 111 112 sas_ha->event_thres = SAS_PHY_SHUTDOWN_THRES; 113 114 error = sas_register_phys(sas_ha); 115 if (error) { 116 pr_notice("couldn't register sas phys:%d\n", error); 117 return error; 118 } 119 120 error = sas_register_ports(sas_ha); 121 if (error) { 122 pr_notice("couldn't register sas ports:%d\n", error); 123 goto Undo_phys; 124 } 125 126 error = -ENOMEM; 127 snprintf(name, sizeof(name), "%s_event_q", dev_name(sas_ha->dev)); 128 sas_ha->event_q = create_singlethread_workqueue(name); 129 if (!sas_ha->event_q) 130 goto Undo_ports; 131 132 snprintf(name, sizeof(name), "%s_disco_q", dev_name(sas_ha->dev)); 133 sas_ha->disco_q = create_singlethread_workqueue(name); 134 if (!sas_ha->disco_q) 135 goto Undo_event_q; 136 137 INIT_LIST_HEAD(&sas_ha->eh_done_q); 138 INIT_LIST_HEAD(&sas_ha->eh_ata_q); 139 140 return 0; 141 142 Undo_event_q: 143 destroy_workqueue(sas_ha->event_q); 144 Undo_ports: 145 sas_unregister_ports(sas_ha); 146 Undo_phys: 147 148 return error; 149 } 150 151 static void sas_disable_events(struct sas_ha_struct *sas_ha) 152 { 153 /* Set the state to unregistered to avoid further unchained 154 * events to be queued, and flush any in-progress drainers 155 */ 156 mutex_lock(&sas_ha->drain_mutex); 157 spin_lock_irq(&sas_ha->lock); 158 clear_bit(SAS_HA_REGISTERED, &sas_ha->state); 159 spin_unlock_irq(&sas_ha->lock); 160 __sas_drain_work(sas_ha); 161 mutex_unlock(&sas_ha->drain_mutex); 162 } 163 164 int sas_unregister_ha(struct sas_ha_struct *sas_ha) 165 { 166 sas_disable_events(sas_ha); 167 sas_unregister_ports(sas_ha); 168 169 /* flush unregistration work */ 170 mutex_lock(&sas_ha->drain_mutex); 171 __sas_drain_work(sas_ha); 172 mutex_unlock(&sas_ha->drain_mutex); 173 174 destroy_workqueue(sas_ha->disco_q); 175 destroy_workqueue(sas_ha->event_q); 176 177 return 0; 178 } 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->core.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->core.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 static 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->core.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 288 int sas_phy_reset(struct sas_phy *phy, int hard_reset) 289 { 290 int ret; 291 enum phy_func reset_type; 292 293 if (!phy->enabled) 294 return -ENODEV; 295 296 if (hard_reset) 297 reset_type = PHY_FUNC_HARD_RESET; 298 else 299 reset_type = PHY_FUNC_LINK_RESET; 300 301 if (scsi_is_sas_phy_local(phy)) { 302 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 303 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 304 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 305 struct sas_internal *i = 306 to_sas_internal(sas_ha->core.shost->transportt); 307 308 ret = i->dft->lldd_control_phy(asd_phy, reset_type, NULL); 309 } else { 310 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 311 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 312 ret = sas_smp_phy_control(ddev, phy->number, reset_type, NULL); 313 } 314 return ret; 315 } 316 317 int sas_set_phy_speed(struct sas_phy *phy, 318 struct sas_phy_linkrates *rates) 319 { 320 int ret; 321 322 if ((rates->minimum_linkrate && 323 rates->minimum_linkrate > phy->maximum_linkrate) || 324 (rates->maximum_linkrate && 325 rates->maximum_linkrate < phy->minimum_linkrate)) 326 return -EINVAL; 327 328 if (rates->minimum_linkrate && 329 rates->minimum_linkrate < phy->minimum_linkrate_hw) 330 rates->minimum_linkrate = phy->minimum_linkrate_hw; 331 332 if (rates->maximum_linkrate && 333 rates->maximum_linkrate > phy->maximum_linkrate_hw) 334 rates->maximum_linkrate = phy->maximum_linkrate_hw; 335 336 if (scsi_is_sas_phy_local(phy)) { 337 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 338 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 339 struct asd_sas_phy *asd_phy = sas_ha->sas_phy[phy->number]; 340 struct sas_internal *i = 341 to_sas_internal(sas_ha->core.shost->transportt); 342 343 ret = i->dft->lldd_control_phy(asd_phy, PHY_FUNC_SET_LINK_RATE, 344 rates); 345 } else { 346 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 347 struct domain_device *ddev = sas_find_dev_by_rphy(rphy); 348 ret = sas_smp_phy_control(ddev, phy->number, 349 PHY_FUNC_LINK_RESET, rates); 350 351 } 352 353 return ret; 354 } 355 356 void sas_prep_resume_ha(struct sas_ha_struct *ha) 357 { 358 int i; 359 360 set_bit(SAS_HA_REGISTERED, &ha->state); 361 362 /* clear out any stale link events/data from the suspension path */ 363 for (i = 0; i < ha->num_phys; i++) { 364 struct asd_sas_phy *phy = ha->sas_phy[i]; 365 366 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 367 phy->frame_rcvd_size = 0; 368 } 369 } 370 EXPORT_SYMBOL(sas_prep_resume_ha); 371 372 static int phys_suspended(struct sas_ha_struct *ha) 373 { 374 int i, rc = 0; 375 376 for (i = 0; i < ha->num_phys; i++) { 377 struct asd_sas_phy *phy = ha->sas_phy[i]; 378 379 if (phy->suspended) 380 rc++; 381 } 382 383 return rc; 384 } 385 386 void sas_resume_ha(struct sas_ha_struct *ha) 387 { 388 const unsigned long tmo = msecs_to_jiffies(25000); 389 int i; 390 391 /* deform ports on phys that did not resume 392 * at this point we may be racing the phy coming back (as posted 393 * by the lldd). So we post the event and once we are in the 394 * libsas context check that the phy remains suspended before 395 * tearing it down. 396 */ 397 i = phys_suspended(ha); 398 if (i) 399 dev_info(ha->dev, "waiting up to 25 seconds for %d phy%s to resume\n", 400 i, i > 1 ? "s" : ""); 401 wait_event_timeout(ha->eh_wait_q, phys_suspended(ha) == 0, tmo); 402 for (i = 0; i < ha->num_phys; i++) { 403 struct asd_sas_phy *phy = ha->sas_phy[i]; 404 405 if (phy->suspended) { 406 dev_warn(&phy->phy->dev, "resume timeout\n"); 407 sas_notify_phy_event(phy, PHYE_RESUME_TIMEOUT, 408 GFP_KERNEL); 409 } 410 } 411 412 /* all phys are back up or timed out, turn on i/o so we can 413 * flush out disks that did not return 414 */ 415 scsi_unblock_requests(ha->core.shost); 416 sas_drain_work(ha); 417 } 418 EXPORT_SYMBOL(sas_resume_ha); 419 420 void sas_suspend_ha(struct sas_ha_struct *ha) 421 { 422 int i; 423 424 sas_disable_events(ha); 425 scsi_block_requests(ha->core.shost); 426 for (i = 0; i < ha->num_phys; i++) { 427 struct asd_sas_port *port = ha->sas_port[i]; 428 429 sas_discover_event(port, DISCE_SUSPEND); 430 } 431 432 /* flush suspend events while unregistered */ 433 mutex_lock(&ha->drain_mutex); 434 __sas_drain_work(ha); 435 mutex_unlock(&ha->drain_mutex); 436 } 437 EXPORT_SYMBOL(sas_suspend_ha); 438 439 static void sas_phy_release(struct sas_phy *phy) 440 { 441 kfree(phy->hostdata); 442 phy->hostdata = NULL; 443 } 444 445 static void phy_reset_work(struct work_struct *work) 446 { 447 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work); 448 449 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 450 } 451 452 static void phy_enable_work(struct work_struct *work) 453 { 454 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work); 455 456 d->enable_result = sas_phy_enable(d->phy, d->enable); 457 } 458 459 static int sas_phy_setup(struct sas_phy *phy) 460 { 461 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 462 463 if (!d) 464 return -ENOMEM; 465 466 mutex_init(&d->event_lock); 467 INIT_SAS_WORK(&d->reset_work, phy_reset_work); 468 INIT_SAS_WORK(&d->enable_work, phy_enable_work); 469 d->phy = phy; 470 phy->hostdata = d; 471 472 return 0; 473 } 474 475 static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 476 { 477 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 478 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 479 struct sas_phy_data *d = phy->hostdata; 480 int rc; 481 482 if (!d) 483 return -ENOMEM; 484 485 /* libsas workqueue coordinates ata-eh reset with discovery */ 486 mutex_lock(&d->event_lock); 487 d->reset_result = 0; 488 d->hard_reset = hard_reset; 489 490 spin_lock_irq(&ha->lock); 491 sas_queue_work(ha, &d->reset_work); 492 spin_unlock_irq(&ha->lock); 493 494 rc = sas_drain_work(ha); 495 if (rc == 0) 496 rc = d->reset_result; 497 mutex_unlock(&d->event_lock); 498 499 return rc; 500 } 501 502 static int queue_phy_enable(struct sas_phy *phy, int enable) 503 { 504 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 505 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 506 struct sas_phy_data *d = phy->hostdata; 507 int rc; 508 509 if (!d) 510 return -ENOMEM; 511 512 /* libsas workqueue coordinates ata-eh reset with discovery */ 513 mutex_lock(&d->event_lock); 514 d->enable_result = 0; 515 d->enable = enable; 516 517 spin_lock_irq(&ha->lock); 518 sas_queue_work(ha, &d->enable_work); 519 spin_unlock_irq(&ha->lock); 520 521 rc = sas_drain_work(ha); 522 if (rc == 0) 523 rc = d->enable_result; 524 mutex_unlock(&d->event_lock); 525 526 return rc; 527 } 528 529 static struct sas_function_template sft = { 530 .phy_enable = queue_phy_enable, 531 .phy_reset = queue_phy_reset, 532 .phy_setup = sas_phy_setup, 533 .phy_release = sas_phy_release, 534 .set_phy_speed = sas_set_phy_speed, 535 .get_linkerrors = sas_get_linkerrors, 536 .smp_handler = sas_smp_handler, 537 }; 538 539 static inline ssize_t phy_event_threshold_show(struct device *dev, 540 struct device_attribute *attr, char *buf) 541 { 542 struct Scsi_Host *shost = class_to_shost(dev); 543 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 544 545 return scnprintf(buf, PAGE_SIZE, "%u\n", sha->event_thres); 546 } 547 548 static inline ssize_t phy_event_threshold_store(struct device *dev, 549 struct device_attribute *attr, 550 const char *buf, size_t count) 551 { 552 struct Scsi_Host *shost = class_to_shost(dev); 553 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 554 555 sha->event_thres = simple_strtol(buf, NULL, 10); 556 557 /* threshold cannot be set too small */ 558 if (sha->event_thres < 32) 559 sha->event_thres = 32; 560 561 return count; 562 } 563 564 DEVICE_ATTR(phy_event_threshold, 565 S_IRUGO|S_IWUSR, 566 phy_event_threshold_show, 567 phy_event_threshold_store); 568 EXPORT_SYMBOL_GPL(dev_attr_phy_event_threshold); 569 570 struct scsi_transport_template * 571 sas_domain_attach_transport(struct sas_domain_function_template *dft) 572 { 573 struct scsi_transport_template *stt = sas_attach_transport(&sft); 574 struct sas_internal *i; 575 576 if (!stt) 577 return stt; 578 579 i = to_sas_internal(stt); 580 i->dft = dft; 581 stt->create_work_queue = 1; 582 stt->eh_strategy_handler = sas_scsi_recover_host; 583 584 return stt; 585 } 586 EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 587 588 struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy, 589 gfp_t gfp_flags) 590 { 591 struct asd_sas_event *event; 592 struct sas_ha_struct *sas_ha = phy->ha; 593 struct sas_internal *i = 594 to_sas_internal(sas_ha->core.shost->transportt); 595 596 event = kmem_cache_zalloc(sas_event_cache, gfp_flags); 597 if (!event) 598 return NULL; 599 600 atomic_inc(&phy->event_nr); 601 602 if (atomic_read(&phy->event_nr) > phy->ha->event_thres) { 603 if (i->dft->lldd_control_phy) { 604 if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) { 605 pr_notice("The phy%d bursting events, shut it down.\n", 606 phy->id); 607 sas_notify_phy_event(phy, PHYE_SHUTDOWN, 608 gfp_flags); 609 } 610 } else { 611 /* Do not support PHY control, stop allocating events */ 612 WARN_ONCE(1, "PHY control not supported.\n"); 613 kmem_cache_free(sas_event_cache, event); 614 atomic_dec(&phy->event_nr); 615 event = NULL; 616 } 617 } 618 619 return event; 620 } 621 622 void sas_free_event(struct asd_sas_event *event) 623 { 624 struct asd_sas_phy *phy = event->phy; 625 626 kmem_cache_free(sas_event_cache, event); 627 atomic_dec(&phy->event_nr); 628 } 629 630 /* ---------- SAS Class register/unregister ---------- */ 631 632 static int __init sas_class_init(void) 633 { 634 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 635 if (!sas_task_cache) 636 goto out; 637 638 sas_event_cache = KMEM_CACHE(asd_sas_event, SLAB_HWCACHE_ALIGN); 639 if (!sas_event_cache) 640 goto free_task_kmem; 641 642 return 0; 643 free_task_kmem: 644 kmem_cache_destroy(sas_task_cache); 645 out: 646 return -ENOMEM; 647 } 648 649 static void __exit sas_class_exit(void) 650 { 651 kmem_cache_destroy(sas_task_cache); 652 kmem_cache_destroy(sas_event_cache); 653 } 654 655 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 656 MODULE_DESCRIPTION("SAS Transport Layer"); 657 MODULE_LICENSE("GPL v2"); 658 659 module_init(sas_class_init); 660 module_exit(sas_class_exit); 661 662 EXPORT_SYMBOL_GPL(sas_register_ha); 663 EXPORT_SYMBOL_GPL(sas_unregister_ha); 664