1/* 2 * Serial Attached SCSI (SAS) class SCSI Host glue. 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/kthread.h> 27#include <linux/firmware.h> 28#include <linux/export.h> 29#include <linux/ctype.h> 30 31#include "sas_internal.h" 32 33#include <scsi/scsi_host.h> 34#include <scsi/scsi_device.h> 35#include <scsi/scsi_tcq.h> 36#include <scsi/scsi.h> 37#include <scsi/scsi_eh.h> 38#include <scsi/scsi_transport.h> 39#include <scsi/scsi_transport_sas.h> 40#include <scsi/sas_ata.h> 41#include "../scsi_sas_internal.h" 42#include "../scsi_transport_api.h" 43#include "../scsi_priv.h" 44 45#include <linux/err.h> 46#include <linux/blkdev.h> 47#include <linux/freezer.h> 48#include <linux/gfp.h> 49#include <linux/scatterlist.h> 50#include <linux/libata.h> 51 52/* record final status and free the task */ 53static void sas_end_task(struct scsi_cmnd *sc, struct sas_task *task) 54{ 55 struct task_status_struct *ts = &task->task_status; 56 int hs = 0, stat = 0; 57 58 if (ts->resp == SAS_TASK_UNDELIVERED) { 59 /* transport error */ 60 hs = DID_NO_CONNECT; 61 } else { /* ts->resp == SAS_TASK_COMPLETE */ 62 /* task delivered, what happened afterwards? */ 63 switch (ts->stat) { 64 case SAS_DEV_NO_RESPONSE: 65 case SAS_INTERRUPTED: 66 case SAS_PHY_DOWN: 67 case SAS_NAK_R_ERR: 68 case SAS_OPEN_TO: 69 hs = DID_NO_CONNECT; 70 break; 71 case SAS_DATA_UNDERRUN: 72 scsi_set_resid(sc, ts->residual); 73 if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow) 74 hs = DID_ERROR; 75 break; 76 case SAS_DATA_OVERRUN: 77 hs = DID_ERROR; 78 break; 79 case SAS_QUEUE_FULL: 80 hs = DID_SOFT_ERROR; /* retry */ 81 break; 82 case SAS_DEVICE_UNKNOWN: 83 hs = DID_BAD_TARGET; 84 break; 85 case SAS_SG_ERR: 86 hs = DID_PARITY; 87 break; 88 case SAS_OPEN_REJECT: 89 if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY) 90 hs = DID_SOFT_ERROR; /* retry */ 91 else 92 hs = DID_ERROR; 93 break; 94 case SAS_PROTO_RESPONSE: 95 SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP " 96 "task; please report this\n", 97 task->dev->port->ha->sas_ha_name); 98 break; 99 case SAS_ABORTED_TASK: 100 hs = DID_ABORT; 101 break; 102 case SAM_STAT_CHECK_CONDITION: 103 memcpy(sc->sense_buffer, ts->buf, 104 min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size)); 105 stat = SAM_STAT_CHECK_CONDITION; 106 break; 107 default: 108 stat = ts->stat; 109 break; 110 } 111 } 112 113 sc->result = (hs << 16) | stat; 114 ASSIGN_SAS_TASK(sc, NULL); 115 sas_free_task(task); 116} 117 118static void sas_scsi_task_done(struct sas_task *task) 119{ 120 struct scsi_cmnd *sc = task->uldd_task; 121 struct domain_device *dev = task->dev; 122 struct sas_ha_struct *ha = dev->port->ha; 123 unsigned long flags; 124 125 spin_lock_irqsave(&dev->done_lock, flags); 126 if (test_bit(SAS_HA_FROZEN, &ha->state)) 127 task = NULL; 128 else 129 ASSIGN_SAS_TASK(sc, NULL); 130 spin_unlock_irqrestore(&dev->done_lock, flags); 131 132 if (unlikely(!task)) { 133 /* task will be completed by the error handler */ 134 SAS_DPRINTK("task done but aborted\n"); 135 return; 136 } 137 138 if (unlikely(!sc)) { 139 SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n"); 140 sas_free_task(task); 141 return; 142 } 143 144 sas_end_task(sc, task); 145 sc->scsi_done(sc); 146} 147 148static struct sas_task *sas_create_task(struct scsi_cmnd *cmd, 149 struct domain_device *dev, 150 gfp_t gfp_flags) 151{ 152 struct sas_task *task = sas_alloc_task(gfp_flags); 153 struct scsi_lun lun; 154 155 if (!task) 156 return NULL; 157 158 task->uldd_task = cmd; 159 ASSIGN_SAS_TASK(cmd, task); 160 161 task->dev = dev; 162 task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */ 163 164 task->ssp_task.retry_count = 1; 165 int_to_scsilun(cmd->device->lun, &lun); 166 memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8); 167 task->ssp_task.task_attr = TASK_ATTR_SIMPLE; 168 task->ssp_task.cmd = cmd; 169 170 task->scatter = scsi_sglist(cmd); 171 task->num_scatter = scsi_sg_count(cmd); 172 task->total_xfer_len = scsi_bufflen(cmd); 173 task->data_dir = cmd->sc_data_direction; 174 175 task->task_done = sas_scsi_task_done; 176 177 return task; 178} 179 180int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) 181{ 182 struct sas_internal *i = to_sas_internal(host->transportt); 183 struct domain_device *dev = cmd_to_domain_dev(cmd); 184 struct sas_task *task; 185 int res = 0; 186 187 /* If the device fell off, no sense in issuing commands */ 188 if (test_bit(SAS_DEV_GONE, &dev->state)) { 189 cmd->result = DID_BAD_TARGET << 16; 190 goto out_done; 191 } 192 193 if (dev_is_sata(dev)) { 194 spin_lock_irq(dev->sata_dev.ap->lock); 195 res = ata_sas_queuecmd(cmd, dev->sata_dev.ap); 196 spin_unlock_irq(dev->sata_dev.ap->lock); 197 return res; 198 } 199 200 task = sas_create_task(cmd, dev, GFP_ATOMIC); 201 if (!task) 202 return SCSI_MLQUEUE_HOST_BUSY; 203 204 res = i->dft->lldd_execute_task(task, GFP_ATOMIC); 205 if (res) 206 goto out_free_task; 207 return 0; 208 209out_free_task: 210 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 211 ASSIGN_SAS_TASK(cmd, NULL); 212 sas_free_task(task); 213 if (res == -SAS_QUEUE_FULL) 214 cmd->result = DID_SOFT_ERROR << 16; /* retry */ 215 else 216 cmd->result = DID_ERROR << 16; 217out_done: 218 cmd->scsi_done(cmd); 219 return 0; 220} 221 222static void sas_eh_finish_cmd(struct scsi_cmnd *cmd) 223{ 224 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host); 225 struct sas_task *task = TO_SAS_TASK(cmd); 226 227 /* At this point, we only get called following an actual abort 228 * of the task, so we should be guaranteed not to be racing with 229 * any completions from the LLD. Task is freed after this. 230 */ 231 sas_end_task(cmd, task); 232 233 /* now finish the command and move it on to the error 234 * handler done list, this also takes it off the 235 * error handler pending list. 236 */ 237 scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q); 238} 239 240static void sas_eh_defer_cmd(struct scsi_cmnd *cmd) 241{ 242 struct domain_device *dev = cmd_to_domain_dev(cmd); 243 struct sas_ha_struct *ha = dev->port->ha; 244 struct sas_task *task = TO_SAS_TASK(cmd); 245 246 if (!dev_is_sata(dev)) { 247 sas_eh_finish_cmd(cmd); 248 return; 249 } 250 251 /* report the timeout to libata */ 252 sas_end_task(cmd, task); 253 list_move_tail(&cmd->eh_entry, &ha->eh_ata_q); 254} 255 256static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd) 257{ 258 struct scsi_cmnd *cmd, *n; 259 260 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 261 if (cmd->device->sdev_target == my_cmd->device->sdev_target && 262 cmd->device->lun == my_cmd->device->lun) 263 sas_eh_defer_cmd(cmd); 264 } 265} 266 267static void sas_scsi_clear_queue_I_T(struct list_head *error_q, 268 struct domain_device *dev) 269{ 270 struct scsi_cmnd *cmd, *n; 271 272 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 273 struct domain_device *x = cmd_to_domain_dev(cmd); 274 275 if (x == dev) 276 sas_eh_finish_cmd(cmd); 277 } 278} 279 280static void sas_scsi_clear_queue_port(struct list_head *error_q, 281 struct asd_sas_port *port) 282{ 283 struct scsi_cmnd *cmd, *n; 284 285 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 286 struct domain_device *dev = cmd_to_domain_dev(cmd); 287 struct asd_sas_port *x = dev->port; 288 289 if (x == port) 290 sas_eh_finish_cmd(cmd); 291 } 292} 293 294enum task_disposition { 295 TASK_IS_DONE, 296 TASK_IS_ABORTED, 297 TASK_IS_AT_LU, 298 TASK_IS_NOT_AT_LU, 299 TASK_ABORT_FAILED, 300}; 301 302static enum task_disposition sas_scsi_find_task(struct sas_task *task) 303{ 304 unsigned long flags; 305 int i, res; 306 struct sas_internal *si = 307 to_sas_internal(task->dev->port->ha->core.shost->transportt); 308 309 for (i = 0; i < 5; i++) { 310 SAS_DPRINTK("%s: aborting task 0x%p\n", __func__, task); 311 res = si->dft->lldd_abort_task(task); 312 313 spin_lock_irqsave(&task->task_state_lock, flags); 314 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 315 spin_unlock_irqrestore(&task->task_state_lock, flags); 316 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 317 task); 318 return TASK_IS_DONE; 319 } 320 spin_unlock_irqrestore(&task->task_state_lock, flags); 321 322 if (res == TMF_RESP_FUNC_COMPLETE) { 323 SAS_DPRINTK("%s: task 0x%p is aborted\n", 324 __func__, task); 325 return TASK_IS_ABORTED; 326 } else if (si->dft->lldd_query_task) { 327 SAS_DPRINTK("%s: querying task 0x%p\n", 328 __func__, task); 329 res = si->dft->lldd_query_task(task); 330 switch (res) { 331 case TMF_RESP_FUNC_SUCC: 332 SAS_DPRINTK("%s: task 0x%p at LU\n", 333 __func__, task); 334 return TASK_IS_AT_LU; 335 case TMF_RESP_FUNC_COMPLETE: 336 SAS_DPRINTK("%s: task 0x%p not at LU\n", 337 __func__, task); 338 return TASK_IS_NOT_AT_LU; 339 case TMF_RESP_FUNC_FAILED: 340 SAS_DPRINTK("%s: task 0x%p failed to abort\n", 341 __func__, task); 342 return TASK_ABORT_FAILED; 343 } 344 345 } 346 } 347 return res; 348} 349 350static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd) 351{ 352 int res = TMF_RESP_FUNC_FAILED; 353 struct scsi_lun lun; 354 struct sas_internal *i = 355 to_sas_internal(dev->port->ha->core.shost->transportt); 356 357 int_to_scsilun(cmd->device->lun, &lun); 358 359 SAS_DPRINTK("eh: device %llx LUN %llx has the task\n", 360 SAS_ADDR(dev->sas_addr), 361 cmd->device->lun); 362 363 if (i->dft->lldd_abort_task_set) 364 res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun); 365 366 if (res == TMF_RESP_FUNC_FAILED) { 367 if (i->dft->lldd_clear_task_set) 368 res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun); 369 } 370 371 if (res == TMF_RESP_FUNC_FAILED) { 372 if (i->dft->lldd_lu_reset) 373 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 374 } 375 376 return res; 377} 378 379static int sas_recover_I_T(struct domain_device *dev) 380{ 381 int res = TMF_RESP_FUNC_FAILED; 382 struct sas_internal *i = 383 to_sas_internal(dev->port->ha->core.shost->transportt); 384 385 SAS_DPRINTK("I_T nexus reset for dev %016llx\n", 386 SAS_ADDR(dev->sas_addr)); 387 388 if (i->dft->lldd_I_T_nexus_reset) 389 res = i->dft->lldd_I_T_nexus_reset(dev); 390 391 return res; 392} 393 394/* take a reference on the last known good phy for this device */ 395struct sas_phy *sas_get_local_phy(struct domain_device *dev) 396{ 397 struct sas_ha_struct *ha = dev->port->ha; 398 struct sas_phy *phy; 399 unsigned long flags; 400 401 /* a published domain device always has a valid phy, it may be 402 * stale, but it is never NULL 403 */ 404 BUG_ON(!dev->phy); 405 406 spin_lock_irqsave(&ha->phy_port_lock, flags); 407 phy = dev->phy; 408 get_device(&phy->dev); 409 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 410 411 return phy; 412} 413EXPORT_SYMBOL_GPL(sas_get_local_phy); 414 415static void sas_wait_eh(struct domain_device *dev) 416{ 417 struct sas_ha_struct *ha = dev->port->ha; 418 DEFINE_WAIT(wait); 419 420 if (dev_is_sata(dev)) { 421 ata_port_wait_eh(dev->sata_dev.ap); 422 return; 423 } 424 retry: 425 spin_lock_irq(&ha->lock); 426 427 while (test_bit(SAS_DEV_EH_PENDING, &dev->state)) { 428 prepare_to_wait(&ha->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); 429 spin_unlock_irq(&ha->lock); 430 schedule(); 431 spin_lock_irq(&ha->lock); 432 } 433 finish_wait(&ha->eh_wait_q, &wait); 434 435 spin_unlock_irq(&ha->lock); 436 437 /* make sure SCSI EH is complete */ 438 if (scsi_host_in_recovery(ha->core.shost)) { 439 msleep(10); 440 goto retry; 441 } 442} 443EXPORT_SYMBOL(sas_wait_eh); 444 445static int sas_queue_reset(struct domain_device *dev, int reset_type, 446 u64 lun, int wait) 447{ 448 struct sas_ha_struct *ha = dev->port->ha; 449 int scheduled = 0, tries = 100; 450 451 /* ata: promote lun reset to bus reset */ 452 if (dev_is_sata(dev)) { 453 sas_ata_schedule_reset(dev); 454 if (wait) 455 sas_ata_wait_eh(dev); 456 return SUCCESS; 457 } 458 459 while (!scheduled && tries--) { 460 spin_lock_irq(&ha->lock); 461 if (!test_bit(SAS_DEV_EH_PENDING, &dev->state) && 462 !test_bit(reset_type, &dev->state)) { 463 scheduled = 1; 464 ha->eh_active++; 465 list_add_tail(&dev->ssp_dev.eh_list_node, &ha->eh_dev_q); 466 set_bit(SAS_DEV_EH_PENDING, &dev->state); 467 set_bit(reset_type, &dev->state); 468 int_to_scsilun(lun, &dev->ssp_dev.reset_lun); 469 scsi_schedule_eh(ha->core.shost); 470 } 471 spin_unlock_irq(&ha->lock); 472 473 if (wait) 474 sas_wait_eh(dev); 475 476 if (scheduled) 477 return SUCCESS; 478 } 479 480 SAS_DPRINTK("%s reset of %s failed\n", 481 reset_type == SAS_DEV_LU_RESET ? "LUN" : "Bus", 482 dev_name(&dev->rphy->dev)); 483 484 return FAILED; 485} 486 487int sas_eh_abort_handler(struct scsi_cmnd *cmd) 488{ 489 int res; 490 struct sas_task *task = TO_SAS_TASK(cmd); 491 struct Scsi_Host *host = cmd->device->host; 492 struct sas_internal *i = to_sas_internal(host->transportt); 493 494 if (current != host->ehandler) 495 return FAILED; 496 497 if (!i->dft->lldd_abort_task) 498 return FAILED; 499 500 res = i->dft->lldd_abort_task(task); 501 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 502 return SUCCESS; 503 504 return FAILED; 505} 506EXPORT_SYMBOL_GPL(sas_eh_abort_handler); 507 508/* Attempt to send a LUN reset message to a device */ 509int sas_eh_device_reset_handler(struct scsi_cmnd *cmd) 510{ 511 int res; 512 struct scsi_lun lun; 513 struct Scsi_Host *host = cmd->device->host; 514 struct domain_device *dev = cmd_to_domain_dev(cmd); 515 struct sas_internal *i = to_sas_internal(host->transportt); 516 517 if (current != host->ehandler) 518 return sas_queue_reset(dev, SAS_DEV_LU_RESET, cmd->device->lun, 0); 519 520 int_to_scsilun(cmd->device->lun, &lun); 521 522 if (!i->dft->lldd_lu_reset) 523 return FAILED; 524 525 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 526 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 527 return SUCCESS; 528 529 return FAILED; 530} 531 532int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd) 533{ 534 int res; 535 struct Scsi_Host *host = cmd->device->host; 536 struct domain_device *dev = cmd_to_domain_dev(cmd); 537 struct sas_internal *i = to_sas_internal(host->transportt); 538 539 if (current != host->ehandler) 540 return sas_queue_reset(dev, SAS_DEV_RESET, 0, 0); 541 542 if (!i->dft->lldd_I_T_nexus_reset) 543 return FAILED; 544 545 res = i->dft->lldd_I_T_nexus_reset(dev); 546 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE || 547 res == -ENODEV) 548 return SUCCESS; 549 550 return FAILED; 551} 552 553/* Try to reset a device */ 554static int try_to_reset_cmd_device(struct scsi_cmnd *cmd) 555{ 556 int res; 557 struct Scsi_Host *shost = cmd->device->host; 558 559 if (!shost->hostt->eh_device_reset_handler) 560 goto try_bus_reset; 561 562 res = shost->hostt->eh_device_reset_handler(cmd); 563 if (res == SUCCESS) 564 return res; 565 566try_bus_reset: 567 if (shost->hostt->eh_bus_reset_handler) 568 return shost->hostt->eh_bus_reset_handler(cmd); 569 570 return FAILED; 571} 572 573static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *work_q) 574{ 575 struct scsi_cmnd *cmd, *n; 576 enum task_disposition res = TASK_IS_DONE; 577 int tmf_resp, need_reset; 578 struct sas_internal *i = to_sas_internal(shost->transportt); 579 unsigned long flags; 580 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 581 LIST_HEAD(done); 582 583 /* clean out any commands that won the completion vs eh race */ 584 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 585 struct domain_device *dev = cmd_to_domain_dev(cmd); 586 struct sas_task *task; 587 588 spin_lock_irqsave(&dev->done_lock, flags); 589 /* by this point the lldd has either observed 590 * SAS_HA_FROZEN and is leaving the task alone, or has 591 * won the race with eh and decided to complete it 592 */ 593 task = TO_SAS_TASK(cmd); 594 spin_unlock_irqrestore(&dev->done_lock, flags); 595 596 if (!task) 597 list_move_tail(&cmd->eh_entry, &done); 598 } 599 600 Again: 601 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 602 struct sas_task *task = TO_SAS_TASK(cmd); 603 604 list_del_init(&cmd->eh_entry); 605 606 spin_lock_irqsave(&task->task_state_lock, flags); 607 need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET; 608 spin_unlock_irqrestore(&task->task_state_lock, flags); 609 610 if (need_reset) { 611 SAS_DPRINTK("%s: task 0x%p requests reset\n", 612 __func__, task); 613 goto reset; 614 } 615 616 SAS_DPRINTK("trying to find task 0x%p\n", task); 617 res = sas_scsi_find_task(task); 618 619 cmd->eh_eflags = 0; 620 621 switch (res) { 622 case TASK_IS_DONE: 623 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 624 task); 625 sas_eh_defer_cmd(cmd); 626 continue; 627 case TASK_IS_ABORTED: 628 SAS_DPRINTK("%s: task 0x%p is aborted\n", 629 __func__, task); 630 sas_eh_defer_cmd(cmd); 631 continue; 632 case TASK_IS_AT_LU: 633 SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task); 634 reset: 635 tmf_resp = sas_recover_lu(task->dev, cmd); 636 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 637 SAS_DPRINTK("dev %016llx LU %llx is " 638 "recovered\n", 639 SAS_ADDR(task->dev), 640 cmd->device->lun); 641 sas_eh_defer_cmd(cmd); 642 sas_scsi_clear_queue_lu(work_q, cmd); 643 goto Again; 644 } 645 /* fallthrough */ 646 case TASK_IS_NOT_AT_LU: 647 case TASK_ABORT_FAILED: 648 SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n", 649 task); 650 tmf_resp = sas_recover_I_T(task->dev); 651 if (tmf_resp == TMF_RESP_FUNC_COMPLETE || 652 tmf_resp == -ENODEV) { 653 struct domain_device *dev = task->dev; 654 SAS_DPRINTK("I_T %016llx recovered\n", 655 SAS_ADDR(task->dev->sas_addr)); 656 sas_eh_finish_cmd(cmd); 657 sas_scsi_clear_queue_I_T(work_q, dev); 658 goto Again; 659 } 660 /* Hammer time :-) */ 661 try_to_reset_cmd_device(cmd); 662 if (i->dft->lldd_clear_nexus_port) { 663 struct asd_sas_port *port = task->dev->port; 664 SAS_DPRINTK("clearing nexus for port:%d\n", 665 port->id); 666 res = i->dft->lldd_clear_nexus_port(port); 667 if (res == TMF_RESP_FUNC_COMPLETE) { 668 SAS_DPRINTK("clear nexus port:%d " 669 "succeeded\n", port->id); 670 sas_eh_finish_cmd(cmd); 671 sas_scsi_clear_queue_port(work_q, 672 port); 673 goto Again; 674 } 675 } 676 if (i->dft->lldd_clear_nexus_ha) { 677 SAS_DPRINTK("clear nexus ha\n"); 678 res = i->dft->lldd_clear_nexus_ha(ha); 679 if (res == TMF_RESP_FUNC_COMPLETE) { 680 SAS_DPRINTK("clear nexus ha " 681 "succeeded\n"); 682 sas_eh_finish_cmd(cmd); 683 goto clear_q; 684 } 685 } 686 /* If we are here -- this means that no amount 687 * of effort could recover from errors. Quite 688 * possibly the HA just disappeared. 689 */ 690 SAS_DPRINTK("error from device %llx, LUN %llx " 691 "couldn't be recovered in any way\n", 692 SAS_ADDR(task->dev->sas_addr), 693 cmd->device->lun); 694 695 sas_eh_finish_cmd(cmd); 696 goto clear_q; 697 } 698 } 699 out: 700 list_splice_tail(&done, work_q); 701 list_splice_tail_init(&ha->eh_ata_q, work_q); 702 return; 703 704 clear_q: 705 SAS_DPRINTK("--- Exit %s -- clear_q\n", __func__); 706 list_for_each_entry_safe(cmd, n, work_q, eh_entry) 707 sas_eh_finish_cmd(cmd); 708 goto out; 709} 710 711static void sas_eh_handle_resets(struct Scsi_Host *shost) 712{ 713 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 714 struct sas_internal *i = to_sas_internal(shost->transportt); 715 716 /* handle directed resets to sas devices */ 717 spin_lock_irq(&ha->lock); 718 while (!list_empty(&ha->eh_dev_q)) { 719 struct domain_device *dev; 720 struct ssp_device *ssp; 721 722 ssp = list_entry(ha->eh_dev_q.next, typeof(*ssp), eh_list_node); 723 list_del_init(&ssp->eh_list_node); 724 dev = container_of(ssp, typeof(*dev), ssp_dev); 725 kref_get(&dev->kref); 726 WARN_ONCE(dev_is_sata(dev), "ssp reset to ata device?\n"); 727 728 spin_unlock_irq(&ha->lock); 729 730 if (test_and_clear_bit(SAS_DEV_LU_RESET, &dev->state)) 731 i->dft->lldd_lu_reset(dev, ssp->reset_lun.scsi_lun); 732 733 if (test_and_clear_bit(SAS_DEV_RESET, &dev->state)) 734 i->dft->lldd_I_T_nexus_reset(dev); 735 736 sas_put_device(dev); 737 spin_lock_irq(&ha->lock); 738 clear_bit(SAS_DEV_EH_PENDING, &dev->state); 739 ha->eh_active--; 740 } 741 spin_unlock_irq(&ha->lock); 742} 743 744 745void sas_scsi_recover_host(struct Scsi_Host *shost) 746{ 747 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 748 LIST_HEAD(eh_work_q); 749 int tries = 0; 750 bool retry; 751 752retry: 753 tries++; 754 retry = true; 755 spin_lock_irq(shost->host_lock); 756 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 757 spin_unlock_irq(shost->host_lock); 758 759 SAS_DPRINTK("Enter %s busy: %d failed: %d\n", 760 __func__, atomic_read(&shost->host_busy), shost->host_failed); 761 /* 762 * Deal with commands that still have SAS tasks (i.e. they didn't 763 * complete via the normal sas_task completion mechanism), 764 * SAS_HA_FROZEN gives eh dominion over all sas_task completion. 765 */ 766 set_bit(SAS_HA_FROZEN, &ha->state); 767 sas_eh_handle_sas_errors(shost, &eh_work_q); 768 clear_bit(SAS_HA_FROZEN, &ha->state); 769 if (list_empty(&eh_work_q)) 770 goto out; 771 772 /* 773 * Now deal with SCSI commands that completed ok but have a an error 774 * code (and hopefully sense data) attached. This is roughly what 775 * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any 776 * command we see here has no sas_task and is thus unknown to the HA. 777 */ 778 sas_ata_eh(shost, &eh_work_q, &ha->eh_done_q); 779 if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q)) 780 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q); 781 782out: 783 sas_eh_handle_resets(shost); 784 785 /* now link into libata eh --- if we have any ata devices */ 786 sas_ata_strategy_handler(shost); 787 788 scsi_eh_flush_done_q(&ha->eh_done_q); 789 790 /* check if any new eh work was scheduled during the last run */ 791 spin_lock_irq(&ha->lock); 792 if (ha->eh_active == 0) { 793 shost->host_eh_scheduled = 0; 794 retry = false; 795 } 796 spin_unlock_irq(&ha->lock); 797 798 if (retry) 799 goto retry; 800 801 SAS_DPRINTK("--- Exit %s: busy: %d failed: %d tries: %d\n", 802 __func__, atomic_read(&shost->host_busy), 803 shost->host_failed, tries); 804} 805 806enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd) 807{ 808 scmd_dbg(cmd, "command %p timed out\n", cmd); 809 810 return BLK_EH_NOT_HANDLED; 811} 812 813int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg) 814{ 815 struct domain_device *dev = sdev_to_domain_dev(sdev); 816 817 if (dev_is_sata(dev)) 818 return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg); 819 820 return -EINVAL; 821} 822 823struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy) 824{ 825 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent); 826 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 827 struct domain_device *found_dev = NULL; 828 int i; 829 unsigned long flags; 830 831 spin_lock_irqsave(&ha->phy_port_lock, flags); 832 for (i = 0; i < ha->num_phys; i++) { 833 struct asd_sas_port *port = ha->sas_port[i]; 834 struct domain_device *dev; 835 836 spin_lock(&port->dev_list_lock); 837 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 838 if (rphy == dev->rphy) { 839 found_dev = dev; 840 spin_unlock(&port->dev_list_lock); 841 goto found; 842 } 843 } 844 spin_unlock(&port->dev_list_lock); 845 } 846 found: 847 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 848 849 return found_dev; 850} 851 852int sas_target_alloc(struct scsi_target *starget) 853{ 854 struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent); 855 struct domain_device *found_dev = sas_find_dev_by_rphy(rphy); 856 857 if (!found_dev) 858 return -ENODEV; 859 860 kref_get(&found_dev->kref); 861 starget->hostdata = found_dev; 862 return 0; 863} 864 865#define SAS_DEF_QD 256 866 867int sas_slave_configure(struct scsi_device *scsi_dev) 868{ 869 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 870 struct sas_ha_struct *sas_ha; 871 872 BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE); 873 874 if (dev_is_sata(dev)) { 875 ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap); 876 return 0; 877 } 878 879 sas_ha = dev->port->ha; 880 881 sas_read_port_mode_page(scsi_dev); 882 883 if (scsi_dev->tagged_supported) { 884 scsi_change_queue_depth(scsi_dev, SAS_DEF_QD); 885 } else { 886 SAS_DPRINTK("device %llx, LUN %llx doesn't support " 887 "TCQ\n", SAS_ADDR(dev->sas_addr), 888 scsi_dev->lun); 889 scsi_change_queue_depth(scsi_dev, 1); 890 } 891 892 scsi_dev->allow_restart = 1; 893 894 return 0; 895} 896 897int sas_change_queue_depth(struct scsi_device *sdev, int depth) 898{ 899 struct domain_device *dev = sdev_to_domain_dev(sdev); 900 901 if (dev_is_sata(dev)) 902 return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth); 903 904 if (!sdev->tagged_supported) 905 depth = 1; 906 return scsi_change_queue_depth(sdev, depth); 907} 908 909int sas_bios_param(struct scsi_device *scsi_dev, 910 struct block_device *bdev, 911 sector_t capacity, int *hsc) 912{ 913 hsc[0] = 255; 914 hsc[1] = 63; 915 sector_div(capacity, 255*63); 916 hsc[2] = capacity; 917 918 return 0; 919} 920 921/* 922 * Tell an upper layer that it needs to initiate an abort for a given task. 923 * This should only ever be called by an LLDD. 924 */ 925void sas_task_abort(struct sas_task *task) 926{ 927 struct scsi_cmnd *sc = task->uldd_task; 928 929 /* Escape for libsas internal commands */ 930 if (!sc) { 931 struct sas_task_slow *slow = task->slow_task; 932 933 if (!slow) 934 return; 935 if (!del_timer(&slow->timer)) 936 return; 937 slow->timer.function(slow->timer.data); 938 return; 939 } 940 941 if (dev_is_sata(task->dev)) { 942 sas_ata_task_abort(task); 943 } else { 944 struct request_queue *q = sc->device->request_queue; 945 unsigned long flags; 946 947 spin_lock_irqsave(q->queue_lock, flags); 948 blk_abort_request(sc->request); 949 spin_unlock_irqrestore(q->queue_lock, flags); 950 } 951} 952 953void sas_target_destroy(struct scsi_target *starget) 954{ 955 struct domain_device *found_dev = starget->hostdata; 956 957 if (!found_dev) 958 return; 959 960 starget->hostdata = NULL; 961 sas_put_device(found_dev); 962} 963 964static void sas_parse_addr(u8 *sas_addr, const char *p) 965{ 966 int i; 967 for (i = 0; i < SAS_ADDR_SIZE; i++) { 968 u8 h, l; 969 if (!*p) 970 break; 971 h = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 972 p++; 973 l = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 974 p++; 975 sas_addr[i] = (h<<4) | l; 976 } 977} 978 979#define SAS_STRING_ADDR_SIZE 16 980 981int sas_request_addr(struct Scsi_Host *shost, u8 *addr) 982{ 983 int res; 984 const struct firmware *fw; 985 986 res = request_firmware(&fw, "sas_addr", &shost->shost_gendev); 987 if (res) 988 return res; 989 990 if (fw->size < SAS_STRING_ADDR_SIZE) { 991 res = -ENODEV; 992 goto out; 993 } 994 995 sas_parse_addr(addr, fw->data); 996 997out: 998 release_firmware(fw); 999 return res; 1000} 1001EXPORT_SYMBOL_GPL(sas_request_addr); 1002 1003EXPORT_SYMBOL_GPL(sas_queuecommand); 1004EXPORT_SYMBOL_GPL(sas_target_alloc); 1005EXPORT_SYMBOL_GPL(sas_slave_configure); 1006EXPORT_SYMBOL_GPL(sas_change_queue_depth); 1007EXPORT_SYMBOL_GPL(sas_bios_param); 1008EXPORT_SYMBOL_GPL(sas_task_abort); 1009EXPORT_SYMBOL_GPL(sas_phy_reset); 1010EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler); 1011EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler); 1012EXPORT_SYMBOL_GPL(sas_target_destroy); 1013EXPORT_SYMBOL_GPL(sas_ioctl); 1014