1 /* 2 * Serial Attached SCSI (SAS) Transport Layer initialization 3 * 4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 6 * 7 * This file is licensed under GPLv2. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/slab.h> 28 #include <linux/init.h> 29 #include <linux/device.h> 30 #include <linux/spinlock.h> 31 #include <scsi/sas_ata.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_device.h> 34 #include <scsi/scsi_transport.h> 35 #include <scsi/scsi_transport_sas.h> 36 37 #include "sas_internal.h" 38 39 #include "../scsi_sas_internal.h" 40 41 static struct kmem_cache *sas_task_cache; 42 43 struct sas_task *sas_alloc_task(gfp_t flags) 44 { 45 struct sas_task *task = kmem_cache_zalloc(sas_task_cache, flags); 46 47 if (task) { 48 spin_lock_init(&task->task_state_lock); 49 task->task_state_flags = SAS_TASK_STATE_PENDING; 50 } 51 52 return task; 53 } 54 EXPORT_SYMBOL_GPL(sas_alloc_task); 55 56 struct sas_task *sas_alloc_slow_task(gfp_t flags) 57 { 58 struct sas_task *task = sas_alloc_task(flags); 59 struct sas_task_slow *slow = kmalloc(sizeof(*slow), flags); 60 61 if (!task || !slow) { 62 if (task) 63 kmem_cache_free(sas_task_cache, task); 64 kfree(slow); 65 return NULL; 66 } 67 68 task->slow_task = slow; 69 slow->task = task; 70 timer_setup(&slow->timer, NULL, 0); 71 init_completion(&slow->completion); 72 73 return task; 74 } 75 EXPORT_SYMBOL_GPL(sas_alloc_slow_task); 76 77 void sas_free_task(struct sas_task *task) 78 { 79 if (task) { 80 kfree(task->slow_task); 81 kmem_cache_free(sas_task_cache, task); 82 } 83 } 84 EXPORT_SYMBOL_GPL(sas_free_task); 85 86 /*------------ SAS addr hash -----------*/ 87 void sas_hash_addr(u8 *hashed, const u8 *sas_addr) 88 { 89 const u32 poly = 0x00DB2777; 90 u32 r = 0; 91 int i; 92 93 for (i = 0; i < 8; i++) { 94 int b; 95 for (b = 7; b >= 0; b--) { 96 r <<= 1; 97 if ((1 << b) & sas_addr[i]) { 98 if (!(r & 0x01000000)) 99 r ^= poly; 100 } else if (r & 0x01000000) 101 r ^= poly; 102 } 103 } 104 105 hashed[0] = (r >> 16) & 0xFF; 106 hashed[1] = (r >> 8) & 0xFF ; 107 hashed[2] = r & 0xFF; 108 } 109 110 int sas_register_ha(struct sas_ha_struct *sas_ha) 111 { 112 int error = 0; 113 114 mutex_init(&sas_ha->disco_mutex); 115 spin_lock_init(&sas_ha->phy_port_lock); 116 sas_hash_addr(sas_ha->hashed_sas_addr, sas_ha->sas_addr); 117 118 set_bit(SAS_HA_REGISTERED, &sas_ha->state); 119 spin_lock_init(&sas_ha->lock); 120 mutex_init(&sas_ha->drain_mutex); 121 init_waitqueue_head(&sas_ha->eh_wait_q); 122 INIT_LIST_HEAD(&sas_ha->defer_q); 123 INIT_LIST_HEAD(&sas_ha->eh_dev_q); 124 125 error = sas_register_phys(sas_ha); 126 if (error) { 127 printk(KERN_NOTICE "couldn't register sas phys:%d\n", error); 128 return error; 129 } 130 131 error = sas_register_ports(sas_ha); 132 if (error) { 133 printk(KERN_NOTICE "couldn't register sas ports:%d\n", error); 134 goto Undo_phys; 135 } 136 137 error = sas_init_events(sas_ha); 138 if (error) { 139 printk(KERN_NOTICE "couldn't start event thread:%d\n", error); 140 goto Undo_ports; 141 } 142 143 INIT_LIST_HEAD(&sas_ha->eh_done_q); 144 INIT_LIST_HEAD(&sas_ha->eh_ata_q); 145 146 return 0; 147 Undo_ports: 148 sas_unregister_ports(sas_ha); 149 Undo_phys: 150 151 return error; 152 } 153 154 static void sas_disable_events(struct sas_ha_struct *sas_ha) 155 { 156 /* Set the state to unregistered to avoid further unchained 157 * events to be queued, and flush any in-progress drainers 158 */ 159 mutex_lock(&sas_ha->drain_mutex); 160 spin_lock_irq(&sas_ha->lock); 161 clear_bit(SAS_HA_REGISTERED, &sas_ha->state); 162 spin_unlock_irq(&sas_ha->lock); 163 __sas_drain_work(sas_ha); 164 mutex_unlock(&sas_ha->drain_mutex); 165 } 166 167 int sas_unregister_ha(struct sas_ha_struct *sas_ha) 168 { 169 sas_disable_events(sas_ha); 170 sas_unregister_ports(sas_ha); 171 172 /* flush unregistration work */ 173 mutex_lock(&sas_ha->drain_mutex); 174 __sas_drain_work(sas_ha); 175 mutex_unlock(&sas_ha->drain_mutex); 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->port_events_pending = 0; 368 phy->phy_events_pending = 0; 369 phy->frame_rcvd_size = 0; 370 } 371 } 372 EXPORT_SYMBOL(sas_prep_resume_ha); 373 374 static int phys_suspended(struct sas_ha_struct *ha) 375 { 376 int i, rc = 0; 377 378 for (i = 0; i < ha->num_phys; i++) { 379 struct asd_sas_phy *phy = ha->sas_phy[i]; 380 381 if (phy->suspended) 382 rc++; 383 } 384 385 return rc; 386 } 387 388 void sas_resume_ha(struct sas_ha_struct *ha) 389 { 390 const unsigned long tmo = msecs_to_jiffies(25000); 391 int i; 392 393 /* deform ports on phys that did not resume 394 * at this point we may be racing the phy coming back (as posted 395 * by the lldd). So we post the event and once we are in the 396 * libsas context check that the phy remains suspended before 397 * tearing it down. 398 */ 399 i = phys_suspended(ha); 400 if (i) 401 dev_info(ha->dev, "waiting up to 25 seconds for %d phy%s to resume\n", 402 i, i > 1 ? "s" : ""); 403 wait_event_timeout(ha->eh_wait_q, phys_suspended(ha) == 0, tmo); 404 for (i = 0; i < ha->num_phys; i++) { 405 struct asd_sas_phy *phy = ha->sas_phy[i]; 406 407 if (phy->suspended) { 408 dev_warn(&phy->phy->dev, "resume timeout\n"); 409 sas_notify_phy_event(phy, PHYE_RESUME_TIMEOUT); 410 } 411 } 412 413 /* all phys are back up or timed out, turn on i/o so we can 414 * flush out disks that did not return 415 */ 416 scsi_unblock_requests(ha->core.shost); 417 sas_drain_work(ha); 418 } 419 EXPORT_SYMBOL(sas_resume_ha); 420 421 void sas_suspend_ha(struct sas_ha_struct *ha) 422 { 423 int i; 424 425 sas_disable_events(ha); 426 scsi_block_requests(ha->core.shost); 427 for (i = 0; i < ha->num_phys; i++) { 428 struct asd_sas_port *port = ha->sas_port[i]; 429 430 sas_discover_event(port, DISCE_SUSPEND); 431 } 432 433 /* flush suspend events while unregistered */ 434 mutex_lock(&ha->drain_mutex); 435 __sas_drain_work(ha); 436 mutex_unlock(&ha->drain_mutex); 437 } 438 EXPORT_SYMBOL(sas_suspend_ha); 439 440 static void sas_phy_release(struct sas_phy *phy) 441 { 442 kfree(phy->hostdata); 443 phy->hostdata = NULL; 444 } 445 446 static void phy_reset_work(struct work_struct *work) 447 { 448 struct sas_phy_data *d = container_of(work, typeof(*d), reset_work.work); 449 450 d->reset_result = transport_sas_phy_reset(d->phy, d->hard_reset); 451 } 452 453 static void phy_enable_work(struct work_struct *work) 454 { 455 struct sas_phy_data *d = container_of(work, typeof(*d), enable_work.work); 456 457 d->enable_result = sas_phy_enable(d->phy, d->enable); 458 } 459 460 static int sas_phy_setup(struct sas_phy *phy) 461 { 462 struct sas_phy_data *d = kzalloc(sizeof(*d), GFP_KERNEL); 463 464 if (!d) 465 return -ENOMEM; 466 467 mutex_init(&d->event_lock); 468 INIT_SAS_WORK(&d->reset_work, phy_reset_work); 469 INIT_SAS_WORK(&d->enable_work, phy_enable_work); 470 d->phy = phy; 471 phy->hostdata = d; 472 473 return 0; 474 } 475 476 static int queue_phy_reset(struct sas_phy *phy, int hard_reset) 477 { 478 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 479 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 480 struct sas_phy_data *d = phy->hostdata; 481 int rc; 482 483 if (!d) 484 return -ENOMEM; 485 486 /* libsas workqueue coordinates ata-eh reset with discovery */ 487 mutex_lock(&d->event_lock); 488 d->reset_result = 0; 489 d->hard_reset = hard_reset; 490 491 spin_lock_irq(&ha->lock); 492 sas_queue_work(ha, &d->reset_work); 493 spin_unlock_irq(&ha->lock); 494 495 rc = sas_drain_work(ha); 496 if (rc == 0) 497 rc = d->reset_result; 498 mutex_unlock(&d->event_lock); 499 500 return rc; 501 } 502 503 static int queue_phy_enable(struct sas_phy *phy, int enable) 504 { 505 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 506 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 507 struct sas_phy_data *d = phy->hostdata; 508 int rc; 509 510 if (!d) 511 return -ENOMEM; 512 513 /* libsas workqueue coordinates ata-eh reset with discovery */ 514 mutex_lock(&d->event_lock); 515 d->enable_result = 0; 516 d->enable = enable; 517 518 spin_lock_irq(&ha->lock); 519 sas_queue_work(ha, &d->enable_work); 520 spin_unlock_irq(&ha->lock); 521 522 rc = sas_drain_work(ha); 523 if (rc == 0) 524 rc = d->enable_result; 525 mutex_unlock(&d->event_lock); 526 527 return rc; 528 } 529 530 static struct sas_function_template sft = { 531 .phy_enable = queue_phy_enable, 532 .phy_reset = queue_phy_reset, 533 .phy_setup = sas_phy_setup, 534 .phy_release = sas_phy_release, 535 .set_phy_speed = sas_set_phy_speed, 536 .get_linkerrors = sas_get_linkerrors, 537 .smp_handler = sas_smp_handler, 538 }; 539 540 struct scsi_transport_template * 541 sas_domain_attach_transport(struct sas_domain_function_template *dft) 542 { 543 struct scsi_transport_template *stt = sas_attach_transport(&sft); 544 struct sas_internal *i; 545 546 if (!stt) 547 return stt; 548 549 i = to_sas_internal(stt); 550 i->dft = dft; 551 stt->create_work_queue = 1; 552 stt->eh_strategy_handler = sas_scsi_recover_host; 553 554 return stt; 555 } 556 EXPORT_SYMBOL_GPL(sas_domain_attach_transport); 557 558 /* ---------- SAS Class register/unregister ---------- */ 559 560 static int __init sas_class_init(void) 561 { 562 sas_task_cache = KMEM_CACHE(sas_task, SLAB_HWCACHE_ALIGN); 563 if (!sas_task_cache) 564 return -ENOMEM; 565 566 return 0; 567 } 568 569 static void __exit sas_class_exit(void) 570 { 571 kmem_cache_destroy(sas_task_cache); 572 } 573 574 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 575 MODULE_DESCRIPTION("SAS Transport Layer"); 576 MODULE_LICENSE("GPL v2"); 577 578 module_init(sas_class_init); 579 module_exit(sas_class_exit); 580 581 EXPORT_SYMBOL_GPL(sas_register_ha); 582 EXPORT_SYMBOL_GPL(sas_unregister_ha); 583