sas_scsi_host.c revision 3673f4bf6a277f4f2944ad153ceb167b340f9ffc
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/ctype.h> 29 30#include "sas_internal.h" 31 32#include <scsi/scsi_host.h> 33#include <scsi/scsi_device.h> 34#include <scsi/scsi_tcq.h> 35#include <scsi/scsi.h> 36#include <scsi/scsi_eh.h> 37#include <scsi/scsi_transport.h> 38#include <scsi/scsi_transport_sas.h> 39#include <scsi/sas_ata.h> 40#include "../scsi_sas_internal.h" 41#include "../scsi_transport_api.h" 42#include "../scsi_priv.h" 43 44#include <linux/err.h> 45#include <linux/blkdev.h> 46#include <linux/freezer.h> 47#include <linux/gfp.h> 48#include <linux/scatterlist.h> 49#include <linux/libata.h> 50 51/* ---------- SCSI Host glue ---------- */ 52 53static void sas_scsi_task_done(struct sas_task *task) 54{ 55 struct task_status_struct *ts = &task->task_status; 56 struct scsi_cmnd *sc = task->uldd_task; 57 int hs = 0, stat = 0; 58 59 if (unlikely(task->task_state_flags & SAS_TASK_STATE_ABORTED)) { 60 /* Aborted tasks will be completed by the error handler */ 61 SAS_DPRINTK("task done but aborted\n"); 62 return; 63 } 64 65 if (unlikely(!sc)) { 66 SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n"); 67 list_del_init(&task->list); 68 sas_free_task(task); 69 return; 70 } 71 72 if (ts->resp == SAS_TASK_UNDELIVERED) { 73 /* transport error */ 74 hs = DID_NO_CONNECT; 75 } else { /* ts->resp == SAS_TASK_COMPLETE */ 76 /* task delivered, what happened afterwards? */ 77 switch (ts->stat) { 78 case SAS_DEV_NO_RESPONSE: 79 case SAS_INTERRUPTED: 80 case SAS_PHY_DOWN: 81 case SAS_NAK_R_ERR: 82 case SAS_OPEN_TO: 83 hs = DID_NO_CONNECT; 84 break; 85 case SAS_DATA_UNDERRUN: 86 scsi_set_resid(sc, ts->residual); 87 if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow) 88 hs = DID_ERROR; 89 break; 90 case SAS_DATA_OVERRUN: 91 hs = DID_ERROR; 92 break; 93 case SAS_QUEUE_FULL: 94 hs = DID_SOFT_ERROR; /* retry */ 95 break; 96 case SAS_DEVICE_UNKNOWN: 97 hs = DID_BAD_TARGET; 98 break; 99 case SAS_SG_ERR: 100 hs = DID_PARITY; 101 break; 102 case SAS_OPEN_REJECT: 103 if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY) 104 hs = DID_SOFT_ERROR; /* retry */ 105 else 106 hs = DID_ERROR; 107 break; 108 case SAS_PROTO_RESPONSE: 109 SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP " 110 "task; please report this\n", 111 task->dev->port->ha->sas_ha_name); 112 break; 113 case SAS_ABORTED_TASK: 114 hs = DID_ABORT; 115 break; 116 case SAM_STAT_CHECK_CONDITION: 117 memcpy(sc->sense_buffer, ts->buf, 118 min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size)); 119 stat = SAM_STAT_CHECK_CONDITION; 120 break; 121 default: 122 stat = ts->stat; 123 break; 124 } 125 } 126 ASSIGN_SAS_TASK(sc, NULL); 127 sc->result = (hs << 16) | stat; 128 list_del_init(&task->list); 129 sas_free_task(task); 130 sc->scsi_done(sc); 131} 132 133static struct sas_task *sas_create_task(struct scsi_cmnd *cmd, 134 struct domain_device *dev, 135 gfp_t gfp_flags) 136{ 137 struct sas_task *task = sas_alloc_task(gfp_flags); 138 struct scsi_lun lun; 139 140 if (!task) 141 return NULL; 142 143 task->uldd_task = cmd; 144 ASSIGN_SAS_TASK(cmd, task); 145 146 task->dev = dev; 147 task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */ 148 149 task->ssp_task.retry_count = 1; 150 int_to_scsilun(cmd->device->lun, &lun); 151 memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8); 152 task->ssp_task.task_attr = TASK_ATTR_SIMPLE; 153 memcpy(task->ssp_task.cdb, cmd->cmnd, 16); 154 155 task->scatter = scsi_sglist(cmd); 156 task->num_scatter = scsi_sg_count(cmd); 157 task->total_xfer_len = scsi_bufflen(cmd); 158 task->data_dir = cmd->sc_data_direction; 159 160 task->task_done = sas_scsi_task_done; 161 162 return task; 163} 164 165int sas_queue_up(struct sas_task *task) 166{ 167 struct sas_ha_struct *sas_ha = task->dev->port->ha; 168 struct scsi_core *core = &sas_ha->core; 169 unsigned long flags; 170 LIST_HEAD(list); 171 172 spin_lock_irqsave(&core->task_queue_lock, flags); 173 if (sas_ha->lldd_queue_size < core->task_queue_size + 1) { 174 spin_unlock_irqrestore(&core->task_queue_lock, flags); 175 return -SAS_QUEUE_FULL; 176 } 177 list_add_tail(&task->list, &core->task_queue); 178 core->task_queue_size += 1; 179 spin_unlock_irqrestore(&core->task_queue_lock, flags); 180 wake_up_process(core->queue_thread); 181 182 return 0; 183} 184 185/** 186 * sas_queuecommand -- Enqueue a command for processing 187 * @parameters: See SCSI Core documentation 188 * 189 * Note: XXX: Remove the host unlock/lock pair when SCSI Core can 190 * call us without holding an IRQ spinlock... 191 */ 192static int sas_queuecommand_lck(struct scsi_cmnd *cmd, 193 void (*scsi_done)(struct scsi_cmnd *)) 194 __releases(host->host_lock) 195 __acquires(dev->sata_dev.ap->lock) 196 __releases(dev->sata_dev.ap->lock) 197 __acquires(host->host_lock) 198{ 199 int res = 0; 200 struct domain_device *dev = cmd_to_domain_dev(cmd); 201 struct Scsi_Host *host = cmd->device->host; 202 struct sas_internal *i = to_sas_internal(host->transportt); 203 204 spin_unlock_irq(host->host_lock); 205 206 { 207 struct sas_ha_struct *sas_ha = dev->port->ha; 208 struct sas_task *task; 209 210 /* If the device fell off, no sense in issuing commands */ 211 if (dev->gone) { 212 cmd->result = DID_BAD_TARGET << 16; 213 scsi_done(cmd); 214 goto out; 215 } 216 217 if (dev_is_sata(dev)) { 218 unsigned long flags; 219 220 spin_lock_irqsave(dev->sata_dev.ap->lock, flags); 221 res = ata_sas_queuecmd(cmd, dev->sata_dev.ap); 222 spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags); 223 goto out; 224 } 225 226 res = -ENOMEM; 227 task = sas_create_task(cmd, dev, GFP_ATOMIC); 228 if (!task) 229 goto out; 230 231 cmd->scsi_done = scsi_done; 232 /* Queue up, Direct Mode or Task Collector Mode. */ 233 if (sas_ha->lldd_max_execute_num < 2) 234 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 235 else 236 res = sas_queue_up(task); 237 238 /* Examine */ 239 if (res) { 240 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 241 ASSIGN_SAS_TASK(cmd, NULL); 242 sas_free_task(task); 243 if (res == -SAS_QUEUE_FULL) { 244 cmd->result = DID_SOFT_ERROR << 16; /* retry */ 245 res = 0; 246 scsi_done(cmd); 247 } 248 goto out; 249 } 250 } 251out: 252 spin_lock_irq(host->host_lock); 253 return res; 254} 255 256DEF_SCSI_QCMD(sas_queuecommand) 257 258static void sas_eh_finish_cmd(struct scsi_cmnd *cmd) 259{ 260 struct sas_task *task = TO_SAS_TASK(cmd); 261 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host); 262 263 /* remove the aborted task flag to allow the task to be 264 * completed now. At this point, we only get called following 265 * an actual abort of the task, so we should be guaranteed not 266 * to be racing with any completions from the LLD (hence we 267 * don't need the task state lock to clear the flag) */ 268 task->task_state_flags &= ~SAS_TASK_STATE_ABORTED; 269 /* Now call task_done. However, task will be free'd after 270 * this */ 271 task->task_done(task); 272 /* now finish the command and move it on to the error 273 * handler done list, this also takes it off the 274 * error handler pending list */ 275 scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q); 276} 277 278static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd) 279{ 280 struct scsi_cmnd *cmd, *n; 281 282 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 283 if (cmd->device->sdev_target == my_cmd->device->sdev_target && 284 cmd->device->lun == my_cmd->device->lun) 285 sas_eh_finish_cmd(cmd); 286 } 287} 288 289static void sas_scsi_clear_queue_I_T(struct list_head *error_q, 290 struct domain_device *dev) 291{ 292 struct scsi_cmnd *cmd, *n; 293 294 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 295 struct domain_device *x = cmd_to_domain_dev(cmd); 296 297 if (x == dev) 298 sas_eh_finish_cmd(cmd); 299 } 300} 301 302static void sas_scsi_clear_queue_port(struct list_head *error_q, 303 struct asd_sas_port *port) 304{ 305 struct scsi_cmnd *cmd, *n; 306 307 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 308 struct domain_device *dev = cmd_to_domain_dev(cmd); 309 struct asd_sas_port *x = dev->port; 310 311 if (x == port) 312 sas_eh_finish_cmd(cmd); 313 } 314} 315 316enum task_disposition { 317 TASK_IS_DONE, 318 TASK_IS_ABORTED, 319 TASK_IS_AT_LU, 320 TASK_IS_NOT_AT_LU, 321 TASK_ABORT_FAILED, 322}; 323 324static enum task_disposition sas_scsi_find_task(struct sas_task *task) 325{ 326 struct sas_ha_struct *ha = task->dev->port->ha; 327 unsigned long flags; 328 int i, res; 329 struct sas_internal *si = 330 to_sas_internal(task->dev->port->ha->core.shost->transportt); 331 332 if (ha->lldd_max_execute_num > 1) { 333 struct scsi_core *core = &ha->core; 334 struct sas_task *t, *n; 335 336 spin_lock_irqsave(&core->task_queue_lock, flags); 337 list_for_each_entry_safe(t, n, &core->task_queue, list) { 338 if (task == t) { 339 list_del_init(&t->list); 340 spin_unlock_irqrestore(&core->task_queue_lock, 341 flags); 342 SAS_DPRINTK("%s: task 0x%p aborted from " 343 "task_queue\n", 344 __func__, task); 345 return TASK_IS_ABORTED; 346 } 347 } 348 spin_unlock_irqrestore(&core->task_queue_lock, flags); 349 } 350 351 for (i = 0; i < 5; i++) { 352 SAS_DPRINTK("%s: aborting task 0x%p\n", __func__, task); 353 res = si->dft->lldd_abort_task(task); 354 355 spin_lock_irqsave(&task->task_state_lock, flags); 356 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 357 spin_unlock_irqrestore(&task->task_state_lock, flags); 358 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 359 task); 360 return TASK_IS_DONE; 361 } 362 spin_unlock_irqrestore(&task->task_state_lock, flags); 363 364 if (res == TMF_RESP_FUNC_COMPLETE) { 365 SAS_DPRINTK("%s: task 0x%p is aborted\n", 366 __func__, task); 367 return TASK_IS_ABORTED; 368 } else if (si->dft->lldd_query_task) { 369 SAS_DPRINTK("%s: querying task 0x%p\n", 370 __func__, task); 371 res = si->dft->lldd_query_task(task); 372 switch (res) { 373 case TMF_RESP_FUNC_SUCC: 374 SAS_DPRINTK("%s: task 0x%p at LU\n", 375 __func__, task); 376 return TASK_IS_AT_LU; 377 case TMF_RESP_FUNC_COMPLETE: 378 SAS_DPRINTK("%s: task 0x%p not at LU\n", 379 __func__, task); 380 return TASK_IS_NOT_AT_LU; 381 case TMF_RESP_FUNC_FAILED: 382 SAS_DPRINTK("%s: task 0x%p failed to abort\n", 383 __func__, task); 384 return TASK_ABORT_FAILED; 385 } 386 387 } 388 } 389 return res; 390} 391 392static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd) 393{ 394 int res = TMF_RESP_FUNC_FAILED; 395 struct scsi_lun lun; 396 struct sas_internal *i = 397 to_sas_internal(dev->port->ha->core.shost->transportt); 398 399 int_to_scsilun(cmd->device->lun, &lun); 400 401 SAS_DPRINTK("eh: device %llx LUN %x has the task\n", 402 SAS_ADDR(dev->sas_addr), 403 cmd->device->lun); 404 405 if (i->dft->lldd_abort_task_set) 406 res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun); 407 408 if (res == TMF_RESP_FUNC_FAILED) { 409 if (i->dft->lldd_clear_task_set) 410 res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun); 411 } 412 413 if (res == TMF_RESP_FUNC_FAILED) { 414 if (i->dft->lldd_lu_reset) 415 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 416 } 417 418 return res; 419} 420 421static int sas_recover_I_T(struct domain_device *dev) 422{ 423 int res = TMF_RESP_FUNC_FAILED; 424 struct sas_internal *i = 425 to_sas_internal(dev->port->ha->core.shost->transportt); 426 427 SAS_DPRINTK("I_T nexus reset for dev %016llx\n", 428 SAS_ADDR(dev->sas_addr)); 429 430 if (i->dft->lldd_I_T_nexus_reset) 431 res = i->dft->lldd_I_T_nexus_reset(dev); 432 433 return res; 434} 435 436/* Find the sas_phy that's attached to this device */ 437struct sas_phy *sas_find_local_phy(struct domain_device *dev) 438{ 439 struct domain_device *pdev = dev->parent; 440 struct ex_phy *exphy = NULL; 441 int i; 442 443 /* Directly attached device */ 444 if (!pdev) 445 return dev->port->phy; 446 447 /* Otherwise look in the expander */ 448 for (i = 0; i < pdev->ex_dev.num_phys; i++) 449 if (!memcmp(dev->sas_addr, 450 pdev->ex_dev.ex_phy[i].attached_sas_addr, 451 SAS_ADDR_SIZE)) { 452 exphy = &pdev->ex_dev.ex_phy[i]; 453 break; 454 } 455 456 BUG_ON(!exphy); 457 return exphy->phy; 458} 459EXPORT_SYMBOL_GPL(sas_find_local_phy); 460 461/* Attempt to send a LUN reset message to a device */ 462int sas_eh_device_reset_handler(struct scsi_cmnd *cmd) 463{ 464 struct domain_device *dev = cmd_to_domain_dev(cmd); 465 struct sas_internal *i = 466 to_sas_internal(dev->port->ha->core.shost->transportt); 467 struct scsi_lun lun; 468 int res; 469 470 int_to_scsilun(cmd->device->lun, &lun); 471 472 if (!i->dft->lldd_lu_reset) 473 return FAILED; 474 475 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 476 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 477 return SUCCESS; 478 479 return FAILED; 480} 481 482/* Attempt to send a phy (bus) reset */ 483int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd) 484{ 485 struct domain_device *dev = cmd_to_domain_dev(cmd); 486 struct sas_phy *phy = sas_find_local_phy(dev); 487 int res; 488 489 res = sas_phy_reset(phy, 1); 490 if (res) 491 SAS_DPRINTK("Bus reset of %s failed 0x%x\n", 492 kobject_name(&phy->dev.kobj), 493 res); 494 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 495 return SUCCESS; 496 497 return FAILED; 498} 499 500/* Try to reset a device */ 501static int try_to_reset_cmd_device(struct scsi_cmnd *cmd) 502{ 503 int res; 504 struct Scsi_Host *shost = cmd->device->host; 505 506 if (!shost->hostt->eh_device_reset_handler) 507 goto try_bus_reset; 508 509 res = shost->hostt->eh_device_reset_handler(cmd); 510 if (res == SUCCESS) 511 return res; 512 513try_bus_reset: 514 if (shost->hostt->eh_bus_reset_handler) 515 return shost->hostt->eh_bus_reset_handler(cmd); 516 517 return FAILED; 518} 519 520static int sas_eh_handle_sas_errors(struct Scsi_Host *shost, 521 struct list_head *work_q, 522 struct list_head *done_q) 523{ 524 struct scsi_cmnd *cmd, *n; 525 enum task_disposition res = TASK_IS_DONE; 526 int tmf_resp, need_reset; 527 struct sas_internal *i = to_sas_internal(shost->transportt); 528 unsigned long flags; 529 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 530 531Again: 532 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 533 struct sas_task *task = TO_SAS_TASK(cmd); 534 535 if (!task) 536 continue; 537 538 list_del_init(&cmd->eh_entry); 539 540 spin_lock_irqsave(&task->task_state_lock, flags); 541 need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET; 542 spin_unlock_irqrestore(&task->task_state_lock, flags); 543 544 if (need_reset) { 545 SAS_DPRINTK("%s: task 0x%p requests reset\n", 546 __func__, task); 547 goto reset; 548 } 549 550 SAS_DPRINTK("trying to find task 0x%p\n", task); 551 res = sas_scsi_find_task(task); 552 553 cmd->eh_eflags = 0; 554 555 switch (res) { 556 case TASK_IS_DONE: 557 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 558 task); 559 sas_eh_finish_cmd(cmd); 560 continue; 561 case TASK_IS_ABORTED: 562 SAS_DPRINTK("%s: task 0x%p is aborted\n", 563 __func__, task); 564 sas_eh_finish_cmd(cmd); 565 continue; 566 case TASK_IS_AT_LU: 567 SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task); 568 reset: 569 tmf_resp = sas_recover_lu(task->dev, cmd); 570 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 571 SAS_DPRINTK("dev %016llx LU %x is " 572 "recovered\n", 573 SAS_ADDR(task->dev), 574 cmd->device->lun); 575 sas_eh_finish_cmd(cmd); 576 sas_scsi_clear_queue_lu(work_q, cmd); 577 goto Again; 578 } 579 /* fallthrough */ 580 case TASK_IS_NOT_AT_LU: 581 case TASK_ABORT_FAILED: 582 SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n", 583 task); 584 tmf_resp = sas_recover_I_T(task->dev); 585 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 586 struct domain_device *dev = task->dev; 587 SAS_DPRINTK("I_T %016llx recovered\n", 588 SAS_ADDR(task->dev->sas_addr)); 589 sas_eh_finish_cmd(cmd); 590 sas_scsi_clear_queue_I_T(work_q, dev); 591 goto Again; 592 } 593 /* Hammer time :-) */ 594 try_to_reset_cmd_device(cmd); 595 if (i->dft->lldd_clear_nexus_port) { 596 struct asd_sas_port *port = task->dev->port; 597 SAS_DPRINTK("clearing nexus for port:%d\n", 598 port->id); 599 res = i->dft->lldd_clear_nexus_port(port); 600 if (res == TMF_RESP_FUNC_COMPLETE) { 601 SAS_DPRINTK("clear nexus port:%d " 602 "succeeded\n", port->id); 603 sas_eh_finish_cmd(cmd); 604 sas_scsi_clear_queue_port(work_q, 605 port); 606 goto Again; 607 } 608 } 609 if (i->dft->lldd_clear_nexus_ha) { 610 SAS_DPRINTK("clear nexus ha\n"); 611 res = i->dft->lldd_clear_nexus_ha(ha); 612 if (res == TMF_RESP_FUNC_COMPLETE) { 613 SAS_DPRINTK("clear nexus ha " 614 "succeeded\n"); 615 sas_eh_finish_cmd(cmd); 616 goto clear_q; 617 } 618 } 619 /* If we are here -- this means that no amount 620 * of effort could recover from errors. Quite 621 * possibly the HA just disappeared. 622 */ 623 SAS_DPRINTK("error from device %llx, LUN %x " 624 "couldn't be recovered in any way\n", 625 SAS_ADDR(task->dev->sas_addr), 626 cmd->device->lun); 627 628 sas_eh_finish_cmd(cmd); 629 goto clear_q; 630 } 631 } 632 return list_empty(work_q); 633clear_q: 634 SAS_DPRINTK("--- Exit %s -- clear_q\n", __func__); 635 list_for_each_entry_safe(cmd, n, work_q, eh_entry) 636 sas_eh_finish_cmd(cmd); 637 638 return list_empty(work_q); 639} 640 641void sas_scsi_recover_host(struct Scsi_Host *shost) 642{ 643 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 644 unsigned long flags; 645 LIST_HEAD(eh_work_q); 646 647 spin_lock_irqsave(shost->host_lock, flags); 648 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 649 shost->host_eh_scheduled = 0; 650 spin_unlock_irqrestore(shost->host_lock, flags); 651 652 SAS_DPRINTK("Enter %s\n", __func__); 653 /* 654 * Deal with commands that still have SAS tasks (i.e. they didn't 655 * complete via the normal sas_task completion mechanism) 656 */ 657 if (sas_eh_handle_sas_errors(shost, &eh_work_q, &ha->eh_done_q)) 658 goto out; 659 660 /* 661 * Now deal with SCSI commands that completed ok but have a an error 662 * code (and hopefully sense data) attached. This is roughly what 663 * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any 664 * command we see here has no sas_task and is thus unknown to the HA. 665 */ 666 if (!sas_ata_eh(shost, &eh_work_q, &ha->eh_done_q)) 667 if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q)) 668 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q); 669 670out: 671 /* now link into libata eh --- if we have any ata devices */ 672 sas_ata_strategy_handler(shost); 673 674 scsi_eh_flush_done_q(&ha->eh_done_q); 675 676 SAS_DPRINTK("--- Exit %s\n", __func__); 677 return; 678} 679 680enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd) 681{ 682 struct sas_task *task = TO_SAS_TASK(cmd); 683 unsigned long flags; 684 enum blk_eh_timer_return rtn; 685 686 if (sas_ata_timed_out(cmd, task, &rtn)) 687 return rtn; 688 689 if (!task) { 690 cmd->request->timeout /= 2; 691 SAS_DPRINTK("command 0x%p, task 0x%p, gone: %s\n", 692 cmd, task, (cmd->request->timeout ? 693 "BLK_EH_RESET_TIMER" : "BLK_EH_NOT_HANDLED")); 694 if (!cmd->request->timeout) 695 return BLK_EH_NOT_HANDLED; 696 return BLK_EH_RESET_TIMER; 697 } 698 699 spin_lock_irqsave(&task->task_state_lock, flags); 700 BUG_ON(task->task_state_flags & SAS_TASK_STATE_ABORTED); 701 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 702 spin_unlock_irqrestore(&task->task_state_lock, flags); 703 SAS_DPRINTK("command 0x%p, task 0x%p, timed out: " 704 "BLK_EH_HANDLED\n", cmd, task); 705 return BLK_EH_HANDLED; 706 } 707 if (!(task->task_state_flags & SAS_TASK_AT_INITIATOR)) { 708 spin_unlock_irqrestore(&task->task_state_lock, flags); 709 SAS_DPRINTK("command 0x%p, task 0x%p, not at initiator: " 710 "BLK_EH_RESET_TIMER\n", 711 cmd, task); 712 return BLK_EH_RESET_TIMER; 713 } 714 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 715 spin_unlock_irqrestore(&task->task_state_lock, flags); 716 717 SAS_DPRINTK("command 0x%p, task 0x%p, timed out: BLK_EH_NOT_HANDLED\n", 718 cmd, task); 719 720 return BLK_EH_NOT_HANDLED; 721} 722 723int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg) 724{ 725 struct domain_device *dev = sdev_to_domain_dev(sdev); 726 727 if (dev_is_sata(dev)) 728 return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg); 729 730 return -EINVAL; 731} 732 733struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy) 734{ 735 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent); 736 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 737 struct domain_device *found_dev = NULL; 738 int i; 739 unsigned long flags; 740 741 spin_lock_irqsave(&ha->phy_port_lock, flags); 742 for (i = 0; i < ha->num_phys; i++) { 743 struct asd_sas_port *port = ha->sas_port[i]; 744 struct domain_device *dev; 745 746 spin_lock(&port->dev_list_lock); 747 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 748 if (rphy == dev->rphy) { 749 found_dev = dev; 750 spin_unlock(&port->dev_list_lock); 751 goto found; 752 } 753 } 754 spin_unlock(&port->dev_list_lock); 755 } 756 found: 757 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 758 759 return found_dev; 760} 761 762static inline struct domain_device *sas_find_target(struct scsi_target *starget) 763{ 764 struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent); 765 766 return sas_find_dev_by_rphy(rphy); 767} 768 769int sas_target_alloc(struct scsi_target *starget) 770{ 771 struct domain_device *found_dev = sas_find_target(starget); 772 int res; 773 774 if (!found_dev) 775 return -ENODEV; 776 777 if (dev_is_sata(found_dev)) { 778 res = sas_ata_init_host_and_port(found_dev, starget); 779 if (res) 780 return res; 781 } 782 783 starget->hostdata = found_dev; 784 return 0; 785} 786 787#define SAS_DEF_QD 32 788#define SAS_MAX_QD 64 789 790int sas_slave_configure(struct scsi_device *scsi_dev) 791{ 792 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 793 struct sas_ha_struct *sas_ha; 794 795 BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE); 796 797 if (dev_is_sata(dev)) { 798 ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap); 799 return 0; 800 } 801 802 sas_ha = dev->port->ha; 803 804 sas_read_port_mode_page(scsi_dev); 805 806 if (scsi_dev->tagged_supported) { 807 scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG); 808 scsi_activate_tcq(scsi_dev, SAS_DEF_QD); 809 } else { 810 SAS_DPRINTK("device %llx, LUN %x doesn't support " 811 "TCQ\n", SAS_ADDR(dev->sas_addr), 812 scsi_dev->lun); 813 scsi_dev->tagged_supported = 0; 814 scsi_set_tag_type(scsi_dev, 0); 815 scsi_deactivate_tcq(scsi_dev, 1); 816 } 817 818 scsi_dev->allow_restart = 1; 819 820 return 0; 821} 822 823void sas_slave_destroy(struct scsi_device *scsi_dev) 824{ 825 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 826 827 if (dev_is_sata(dev)) 828 dev->sata_dev.ap->link.device[0].class = ATA_DEV_NONE; 829} 830 831int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth, 832 int reason) 833{ 834 int res = min(new_depth, SAS_MAX_QD); 835 836 if (reason != SCSI_QDEPTH_DEFAULT) 837 return -EOPNOTSUPP; 838 839 if (scsi_dev->tagged_supported) 840 scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev), 841 res); 842 else { 843 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 844 sas_printk("device %llx LUN %x queue depth changed to 1\n", 845 SAS_ADDR(dev->sas_addr), 846 scsi_dev->lun); 847 scsi_adjust_queue_depth(scsi_dev, 0, 1); 848 res = 1; 849 } 850 851 return res; 852} 853 854int sas_change_queue_type(struct scsi_device *scsi_dev, int qt) 855{ 856 if (!scsi_dev->tagged_supported) 857 return 0; 858 859 scsi_deactivate_tcq(scsi_dev, 1); 860 861 scsi_set_tag_type(scsi_dev, qt); 862 scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth); 863 864 return qt; 865} 866 867int sas_bios_param(struct scsi_device *scsi_dev, 868 struct block_device *bdev, 869 sector_t capacity, int *hsc) 870{ 871 hsc[0] = 255; 872 hsc[1] = 63; 873 sector_div(capacity, 255*63); 874 hsc[2] = capacity; 875 876 return 0; 877} 878 879/* ---------- Task Collector Thread implementation ---------- */ 880 881static void sas_queue(struct sas_ha_struct *sas_ha) 882{ 883 struct scsi_core *core = &sas_ha->core; 884 unsigned long flags; 885 LIST_HEAD(q); 886 int can_queue; 887 int res; 888 struct sas_internal *i = to_sas_internal(core->shost->transportt); 889 890 spin_lock_irqsave(&core->task_queue_lock, flags); 891 while (!kthread_should_stop() && 892 !list_empty(&core->task_queue)) { 893 894 can_queue = sas_ha->lldd_queue_size - core->task_queue_size; 895 if (can_queue >= 0) { 896 can_queue = core->task_queue_size; 897 list_splice_init(&core->task_queue, &q); 898 } else { 899 struct list_head *a, *n; 900 901 can_queue = sas_ha->lldd_queue_size; 902 list_for_each_safe(a, n, &core->task_queue) { 903 list_move_tail(a, &q); 904 if (--can_queue == 0) 905 break; 906 } 907 can_queue = sas_ha->lldd_queue_size; 908 } 909 core->task_queue_size -= can_queue; 910 spin_unlock_irqrestore(&core->task_queue_lock, flags); 911 { 912 struct sas_task *task = list_entry(q.next, 913 struct sas_task, 914 list); 915 list_del_init(&q); 916 res = i->dft->lldd_execute_task(task, can_queue, 917 GFP_KERNEL); 918 if (unlikely(res)) 919 __list_add(&q, task->list.prev, &task->list); 920 } 921 spin_lock_irqsave(&core->task_queue_lock, flags); 922 if (res) { 923 list_splice_init(&q, &core->task_queue); /*at head*/ 924 core->task_queue_size += can_queue; 925 } 926 } 927 spin_unlock_irqrestore(&core->task_queue_lock, flags); 928} 929 930/** 931 * sas_queue_thread -- The Task Collector thread 932 * @_sas_ha: pointer to struct sas_ha 933 */ 934static int sas_queue_thread(void *_sas_ha) 935{ 936 struct sas_ha_struct *sas_ha = _sas_ha; 937 938 while (1) { 939 set_current_state(TASK_INTERRUPTIBLE); 940 schedule(); 941 sas_queue(sas_ha); 942 if (kthread_should_stop()) 943 break; 944 } 945 946 return 0; 947} 948 949int sas_init_queue(struct sas_ha_struct *sas_ha) 950{ 951 struct scsi_core *core = &sas_ha->core; 952 953 spin_lock_init(&core->task_queue_lock); 954 core->task_queue_size = 0; 955 INIT_LIST_HEAD(&core->task_queue); 956 957 core->queue_thread = kthread_run(sas_queue_thread, sas_ha, 958 "sas_queue_%d", core->shost->host_no); 959 if (IS_ERR(core->queue_thread)) 960 return PTR_ERR(core->queue_thread); 961 return 0; 962} 963 964void sas_shutdown_queue(struct sas_ha_struct *sas_ha) 965{ 966 unsigned long flags; 967 struct scsi_core *core = &sas_ha->core; 968 struct sas_task *task, *n; 969 970 kthread_stop(core->queue_thread); 971 972 if (!list_empty(&core->task_queue)) 973 SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n", 974 SAS_ADDR(sas_ha->sas_addr)); 975 976 spin_lock_irqsave(&core->task_queue_lock, flags); 977 list_for_each_entry_safe(task, n, &core->task_queue, list) { 978 struct scsi_cmnd *cmd = task->uldd_task; 979 980 list_del_init(&task->list); 981 982 ASSIGN_SAS_TASK(cmd, NULL); 983 sas_free_task(task); 984 cmd->result = DID_ABORT << 16; 985 cmd->scsi_done(cmd); 986 } 987 spin_unlock_irqrestore(&core->task_queue_lock, flags); 988} 989 990/* 991 * Call the LLDD task abort routine directly. This function is intended for 992 * use by upper layers that need to tell the LLDD to abort a task. 993 */ 994int __sas_task_abort(struct sas_task *task) 995{ 996 struct sas_internal *si = 997 to_sas_internal(task->dev->port->ha->core.shost->transportt); 998 unsigned long flags; 999 int res; 1000 1001 spin_lock_irqsave(&task->task_state_lock, flags); 1002 if (task->task_state_flags & SAS_TASK_STATE_ABORTED || 1003 task->task_state_flags & SAS_TASK_STATE_DONE) { 1004 spin_unlock_irqrestore(&task->task_state_lock, flags); 1005 SAS_DPRINTK("%s: Task %p already finished.\n", __func__, 1006 task); 1007 return 0; 1008 } 1009 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 1010 spin_unlock_irqrestore(&task->task_state_lock, flags); 1011 1012 if (!si->dft->lldd_abort_task) 1013 return -ENODEV; 1014 1015 res = si->dft->lldd_abort_task(task); 1016 1017 spin_lock_irqsave(&task->task_state_lock, flags); 1018 if ((task->task_state_flags & SAS_TASK_STATE_DONE) || 1019 (res == TMF_RESP_FUNC_COMPLETE)) 1020 { 1021 spin_unlock_irqrestore(&task->task_state_lock, flags); 1022 task->task_done(task); 1023 return 0; 1024 } 1025 1026 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 1027 task->task_state_flags &= ~SAS_TASK_STATE_ABORTED; 1028 spin_unlock_irqrestore(&task->task_state_lock, flags); 1029 1030 return -EAGAIN; 1031} 1032 1033/* 1034 * Tell an upper layer that it needs to initiate an abort for a given task. 1035 * This should only ever be called by an LLDD. 1036 */ 1037void sas_task_abort(struct sas_task *task) 1038{ 1039 struct scsi_cmnd *sc = task->uldd_task; 1040 1041 /* Escape for libsas internal commands */ 1042 if (!sc) { 1043 if (!del_timer(&task->timer)) 1044 return; 1045 task->timer.function(task->timer.data); 1046 return; 1047 } 1048 1049 if (dev_is_sata(task->dev)) { 1050 sas_ata_task_abort(task); 1051 } else { 1052 struct request_queue *q = sc->device->request_queue; 1053 unsigned long flags; 1054 1055 spin_lock_irqsave(q->queue_lock, flags); 1056 blk_abort_request(sc->request); 1057 spin_unlock_irqrestore(q->queue_lock, flags); 1058 scsi_schedule_eh(sc->device->host); 1059 } 1060} 1061 1062int sas_slave_alloc(struct scsi_device *scsi_dev) 1063{ 1064 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 1065 1066 if (dev_is_sata(dev)) 1067 return ata_sas_port_init(dev->sata_dev.ap); 1068 1069 return 0; 1070} 1071 1072void sas_target_destroy(struct scsi_target *starget) 1073{ 1074 struct domain_device *found_dev = sas_find_target(starget); 1075 1076 if (!found_dev) 1077 return; 1078 1079 if (dev_is_sata(found_dev)) 1080 ata_sas_port_destroy(found_dev->sata_dev.ap); 1081 1082 return; 1083} 1084 1085static void sas_parse_addr(u8 *sas_addr, const char *p) 1086{ 1087 int i; 1088 for (i = 0; i < SAS_ADDR_SIZE; i++) { 1089 u8 h, l; 1090 if (!*p) 1091 break; 1092 h = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 1093 p++; 1094 l = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 1095 p++; 1096 sas_addr[i] = (h<<4) | l; 1097 } 1098} 1099 1100#define SAS_STRING_ADDR_SIZE 16 1101 1102int sas_request_addr(struct Scsi_Host *shost, u8 *addr) 1103{ 1104 int res; 1105 const struct firmware *fw; 1106 1107 res = request_firmware(&fw, "sas_addr", &shost->shost_gendev); 1108 if (res) 1109 return res; 1110 1111 if (fw->size < SAS_STRING_ADDR_SIZE) { 1112 res = -ENODEV; 1113 goto out; 1114 } 1115 1116 sas_parse_addr(addr, fw->data); 1117 1118out: 1119 release_firmware(fw); 1120 return res; 1121} 1122EXPORT_SYMBOL_GPL(sas_request_addr); 1123 1124EXPORT_SYMBOL_GPL(sas_queuecommand); 1125EXPORT_SYMBOL_GPL(sas_target_alloc); 1126EXPORT_SYMBOL_GPL(sas_slave_configure); 1127EXPORT_SYMBOL_GPL(sas_slave_destroy); 1128EXPORT_SYMBOL_GPL(sas_change_queue_depth); 1129EXPORT_SYMBOL_GPL(sas_change_queue_type); 1130EXPORT_SYMBOL_GPL(sas_bios_param); 1131EXPORT_SYMBOL_GPL(__sas_task_abort); 1132EXPORT_SYMBOL_GPL(sas_task_abort); 1133EXPORT_SYMBOL_GPL(sas_phy_reset); 1134EXPORT_SYMBOL_GPL(sas_phy_enable); 1135EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler); 1136EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler); 1137EXPORT_SYMBOL_GPL(sas_slave_alloc); 1138EXPORT_SYMBOL_GPL(sas_target_destroy); 1139EXPORT_SYMBOL_GPL(sas_ioctl); 1140