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