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