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 24static struct kmem_cache *sas_task_cache; 25static struct kmem_cache *sas_event_cache; 26 27struct 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} 38EXPORT_SYMBOL_GPL(sas_alloc_task); 39 40struct 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} 59EXPORT_SYMBOL_GPL(sas_alloc_slow_task); 60 61void 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} 68EXPORT_SYMBOL_GPL(sas_free_task); 69 70/*------------ SAS addr hash -----------*/ 71void 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 96int 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 142Undo_event_q: 143 destroy_workqueue(sas_ha->event_q); 144Undo_ports: 145 sas_unregister_ports(sas_ha); 146Undo_phys: 147 148 return error; 149} 150 151static 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 164int 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 180static 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 195int 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 */ 222static 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 255static 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 288int 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 317int 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 356void 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} 370EXPORT_SYMBOL(sas_prep_resume_ha); 371 372static 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 386void 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 } 409 } 410 411 /* all phys are back up or timed out, turn on i/o so we can 412 * flush out disks that did not return 413 */ 414 scsi_unblock_requests(ha->core.shost); 415 sas_drain_work(ha); 416} 417EXPORT_SYMBOL(sas_resume_ha); 418 419void sas_suspend_ha(struct sas_ha_struct *ha) 420{ 421 int i; 422 423 sas_disable_events(ha); 424 scsi_block_requests(ha->core.shost); 425 for (i = 0; i < ha->num_phys; i++) { 426 struct asd_sas_port *port = ha->sas_port[i]; 427 428 sas_discover_event(port, DISCE_SUSPEND); 429 } 430 431 /* flush suspend events while unregistered */ 432 mutex_lock(&ha->drain_mutex); 433 __sas_drain_work(ha); 434 mutex_unlock(&ha->drain_mutex); 435} 436EXPORT_SYMBOL(sas_suspend_ha); 437 438static void sas_phy_release(struct sas_phy *phy) 439{ 440 kfree(phy->hostdata); 441 phy->hostdata = NULL; 442} 443 444static void phy_reset_work(struct work_struct *work) 445{ 446 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work); 447 448 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 449} 450 451static void phy_enable_work(struct work_struct *work) 452{ 453 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work); 454 455 d->enable_result = sas_phy_enable(d->phy, d->enable); 456} 457 458static int sas_phy_setup(struct sas_phy *phy) 459{ 460 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 461 462 if (!d) 463 return -ENOMEM; 464 465 mutex_init(&d->event_lock); 466 INIT_SAS_WORK(&d->reset_work, phy_reset_work); 467 INIT_SAS_WORK(&d->enable_work, phy_enable_work); 468 d->phy = phy; 469 phy->hostdata = d; 470 471 return 0; 472} 473 474static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 475{ 476 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 477 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 478 struct sas_phy_data *d = phy->hostdata; 479 int rc; 480 481 if (!d) 482 return -ENOMEM; 483 484 /* libsas workqueue coordinates ata-eh reset with discovery */ 485 mutex_lock(&d->event_lock); 486 d->reset_result = 0; 487 d->hard_reset = hard_reset; 488 489 spin_lock_irq(&ha->lock); 490 sas_queue_work(ha, &d->reset_work); 491 spin_unlock_irq(&ha->lock); 492 493 rc = sas_drain_work(ha); 494 if (rc == 0) 495 rc = d->reset_result; 496 mutex_unlock(&d->event_lock); 497 498 return rc; 499} 500 501static int queue_phy_enable(struct sas_phy *phy, int enable) 502{ 503 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 504 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 505 struct sas_phy_data *d = phy->hostdata; 506 int rc; 507 508 if (!d) 509 return -ENOMEM; 510 511 /* libsas workqueue coordinates ata-eh reset with discovery */ 512 mutex_lock(&d->event_lock); 513 d->enable_result = 0; 514 d->enable = enable; 515 516 spin_lock_irq(&ha->lock); 517 sas_queue_work(ha, &d->enable_work); 518 spin_unlock_irq(&ha->lock); 519 520 rc = sas_drain_work(ha); 521 if (rc == 0) 522 rc = d->enable_result; 523 mutex_unlock(&d->event_lock); 524 525 return rc; 526} 527 528static struct sas_function_template sft = { 529 .phy_enable = queue_phy_enable, 530 .phy_reset = queue_phy_reset, 531 .phy_setup = sas_phy_setup, 532 .phy_release = sas_phy_release, 533 .set_phy_speed = sas_set_phy_speed, 534 .get_linkerrors = sas_get_linkerrors, 535 .smp_handler = sas_smp_handler, 536}; 537 538static inline ssize_t phy_event_threshold_show(struct device *dev, 539 struct device_attribute *attr, char *buf) 540{ 541 struct Scsi_Host *shost = class_to_shost(dev); 542 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 543 544 return scnprintf(buf, PAGE_SIZE, "%u\n", sha->event_thres); 545} 546 547static inline ssize_t phy_event_threshold_store(struct device *dev, 548 struct device_attribute *attr, 549 const char *buf, size_t count) 550{ 551 struct Scsi_Host *shost = class_to_shost(dev); 552 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost); 553 554 sha->event_thres = simple_strtol(buf, NULL, 10); 555 556 /* threshold cannot be set too small */ 557 if (sha->event_thres < 32) 558 sha->event_thres = 32; 559 560 return count; 561} 562 563DEVICE_ATTR(phy_event_threshold, 564 S_IRUGO|S_IWUSR, 565 phy_event_threshold_show, 566 phy_event_threshold_store); 567EXPORT_SYMBOL_GPL(dev_attr_phy_event_threshold); 568 569struct scsi_transport_template * 570sas_domain_attach_transport(struct sas_domain_function_template *dft) 571{ 572 struct scsi_transport_template *stt = sas_attach_transport(&sft); 573 struct sas_internal *i; 574 575 if (!stt) 576 return stt; 577 578 i = to_sas_internal(stt); 579 i->dft = dft; 580 stt->create_work_queue = 1; 581 stt->eh_strategy_handler = sas_scsi_recover_host; 582 583 return stt; 584} 585EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 586 587static struct asd_sas_event *__sas_alloc_event(struct asd_sas_phy *phy, 588 gfp_t gfp_flags) 589{ 590 struct asd_sas_event *event; 591 struct sas_ha_struct *sas_ha = phy->ha; 592 struct sas_internal *i = 593 to_sas_internal(sas_ha->core.shost->transportt); 594 595 event = kmem_cache_zalloc(sas_event_cache, gfp_flags); 596 if (!event) 597 return NULL; 598 599 atomic_inc(&phy->event_nr); 600 601 if (atomic_read(&phy->event_nr) > phy->ha->event_thres) { 602 if (i->dft->lldd_control_phy) { 603 if (cmpxchg(&phy->in_shutdown, 0, 1) == 0) { 604 pr_notice("The phy%d bursting events, shut it down.\n", 605 phy->id); 606 sas_notify_phy_event_gfp(phy, PHYE_SHUTDOWN, 607 gfp_flags); 608 } 609 } else { 610 /* Do not support PHY control, stop allocating events */ 611 WARN_ONCE(1, "PHY control not supported.\n"); 612 kmem_cache_free(sas_event_cache, event); 613 atomic_dec(&phy->event_nr); 614 event = NULL; 615 } 616 } 617 618 return event; 619} 620 621struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy) 622{ 623 return __sas_alloc_event(phy, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL); 624} 625 626struct asd_sas_event *sas_alloc_event_gfp(struct asd_sas_phy *phy, 627 gfp_t gfp_flags) 628{ 629 return __sas_alloc_event(phy, gfp_flags); 630} 631 632void sas_free_event(struct asd_sas_event *event) 633{ 634 struct asd_sas_phy *phy = event->phy; 635 636 kmem_cache_free(sas_event_cache, event); 637 atomic_dec(&phy->event_nr); 638} 639 640/* ---------- SAS Class register/unregister ---------- */ 641 642static int __init sas_class_init(void) 643{ 644 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 645 if (!sas_task_cache) 646 goto out; 647 648 sas_event_cache = KMEM_CACHE(asd_sas_event, SLAB_HWCACHE_ALIGN); 649 if (!sas_event_cache) 650 goto free_task_kmem; 651 652 return 0; 653free_task_kmem: 654 kmem_cache_destroy(sas_task_cache); 655out: 656 return -ENOMEM; 657} 658 659static void __exit sas_class_exit(void) 660{ 661 kmem_cache_destroy(sas_task_cache); 662 kmem_cache_destroy(sas_event_cache); 663} 664 665MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 666MODULE_DESCRIPTION("SAS Transport Layer"); 667MODULE_LICENSE("GPL v2"); 668 669module_init(sas_class_init); 670module_exit(sas_class_exit); 671 672EXPORT_SYMBOL_GPL(sas_register_ha); 673EXPORT_SYMBOL_GPL(sas_unregister_ha); 674