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