1 /* 2 * This file is provided under a dual BSD/GPLv2 license. When using or 3 * redistributing this file, you may do so under either license. 4 * 5 * GPL LICENSE SUMMARY 6 * 7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 21 * The full GNU General Public License is included in this distribution 22 * in the file called LICENSE.GPL. 23 * 24 * BSD LICENSE 25 * 26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 27 * All rights reserved. 28 * 29 * Redistribution and use in source and binary forms, with or without 30 * modification, are permitted provided that the following conditions 31 * are met: 32 * 33 * * Redistributions of source code must retain the above copyright 34 * notice, this list of conditions and the following disclaimer. 35 * * Redistributions in binary form must reproduce the above copyright 36 * notice, this list of conditions and the following disclaimer in 37 * the documentation and/or other materials provided with the 38 * distribution. 39 * * Neither the name of Intel Corporation nor the names of its 40 * contributors may be used to endorse or promote products derived 41 * from this software without specific prior written permission. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #include "isci.h" 57 #include "scic_io_request.h" 58 #include "scic_task_request.h" 59 #include "scic_port.h" 60 #include "task.h" 61 #include "request.h" 62 #include "sata.h" 63 #include "scu_completion_codes.h" 64 #include "scic_sds_request.h" 65 #include "sas.h" 66 67 static enum sci_status isci_request_ssp_request_construct( 68 struct isci_request *request) 69 { 70 enum sci_status status; 71 72 dev_dbg(&request->isci_host->pdev->dev, 73 "%s: request = %p\n", 74 __func__, 75 request); 76 status = scic_io_request_construct_basic_ssp(&request->sci); 77 return status; 78 } 79 80 static enum sci_status isci_request_stp_request_construct( 81 struct isci_request *request) 82 { 83 struct sas_task *task = isci_request_access_task(request); 84 enum sci_status status; 85 struct host_to_dev_fis *register_fis; 86 87 dev_dbg(&request->isci_host->pdev->dev, 88 "%s: request = %p\n", 89 __func__, 90 request); 91 92 /* Get the host_to_dev_fis from the core and copy 93 * the fis from the task into it. 94 */ 95 register_fis = isci_sata_task_to_fis_copy(task); 96 97 status = scic_io_request_construct_basic_sata(&request->sci); 98 99 /* Set the ncq tag in the fis, from the queue 100 * command in the task. 101 */ 102 if (isci_sata_is_task_ncq(task)) { 103 104 isci_sata_set_ncq_tag( 105 register_fis, 106 task 107 ); 108 } 109 110 return status; 111 } 112 113 /* 114 * isci_smp_request_build() - This function builds the smp request. 115 * @ireq: This parameter points to the isci_request allocated in the 116 * request construct function. 117 * 118 * SCI_SUCCESS on successfull completion, or specific failure code. 119 */ 120 static enum sci_status isci_smp_request_build(struct isci_request *ireq) 121 { 122 enum sci_status status = SCI_FAILURE; 123 struct sas_task *task = isci_request_access_task(ireq); 124 struct scic_sds_request *sci_req = &ireq->sci; 125 126 dev_dbg(&ireq->isci_host->pdev->dev, 127 "%s: request = %p\n", __func__, ireq); 128 129 dev_dbg(&ireq->isci_host->pdev->dev, 130 "%s: smp_req len = %d\n", 131 __func__, 132 task->smp_task.smp_req.length); 133 134 /* copy the smp_command to the address; */ 135 sg_copy_to_buffer(&task->smp_task.smp_req, 1, 136 &sci_req->smp.cmd, 137 sizeof(struct smp_req)); 138 139 status = scic_io_request_construct_smp(sci_req); 140 if (status != SCI_SUCCESS) 141 dev_warn(&ireq->isci_host->pdev->dev, 142 "%s: failed with status = %d\n", 143 __func__, 144 status); 145 146 return status; 147 } 148 149 /** 150 * isci_io_request_build() - This function builds the io request object. 151 * @isci_host: This parameter specifies the ISCI host object 152 * @request: This parameter points to the isci_request object allocated in the 153 * request construct function. 154 * @sci_device: This parameter is the handle for the sci core's remote device 155 * object that is the destination for this request. 156 * 157 * SCI_SUCCESS on successfull completion, or specific failure code. 158 */ 159 static enum sci_status isci_io_request_build( 160 struct isci_host *isci_host, 161 struct isci_request *request, 162 struct isci_remote_device *isci_device) 163 { 164 enum sci_status status = SCI_SUCCESS; 165 struct sas_task *task = isci_request_access_task(request); 166 struct scic_sds_remote_device *sci_device = &isci_device->sci; 167 168 dev_dbg(&isci_host->pdev->dev, 169 "%s: isci_device = 0x%p; request = %p, " 170 "num_scatter = %d\n", 171 __func__, 172 isci_device, 173 request, 174 task->num_scatter); 175 176 /* map the sgl addresses, if present. 177 * libata does the mapping for sata devices 178 * before we get the request. 179 */ 180 if (task->num_scatter && 181 !sas_protocol_ata(task->task_proto) && 182 !(SAS_PROTOCOL_SMP & task->task_proto)) { 183 184 request->num_sg_entries = dma_map_sg( 185 &isci_host->pdev->dev, 186 task->scatter, 187 task->num_scatter, 188 task->data_dir 189 ); 190 191 if (request->num_sg_entries == 0) 192 return SCI_FAILURE_INSUFFICIENT_RESOURCES; 193 } 194 195 /* build the common request object. For now, 196 * we will let the core allocate the IO tag. 197 */ 198 status = scic_io_request_construct(&isci_host->sci, sci_device, 199 SCI_CONTROLLER_INVALID_IO_TAG, 200 &request->sci); 201 202 if (status != SCI_SUCCESS) { 203 dev_warn(&isci_host->pdev->dev, 204 "%s: failed request construct\n", 205 __func__); 206 return SCI_FAILURE; 207 } 208 209 switch (task->task_proto) { 210 case SAS_PROTOCOL_SMP: 211 status = isci_smp_request_build(request); 212 break; 213 case SAS_PROTOCOL_SSP: 214 status = isci_request_ssp_request_construct(request); 215 break; 216 case SAS_PROTOCOL_SATA: 217 case SAS_PROTOCOL_STP: 218 case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP: 219 status = isci_request_stp_request_construct(request); 220 break; 221 default: 222 dev_warn(&isci_host->pdev->dev, 223 "%s: unknown protocol\n", __func__); 224 return SCI_FAILURE; 225 } 226 227 return SCI_SUCCESS; 228 } 229 230 231 /** 232 * isci_request_alloc_core() - This function gets the request object from the 233 * isci_host dma cache. 234 * @isci_host: This parameter specifies the ISCI host object 235 * @isci_request: This parameter will contain the pointer to the new 236 * isci_request object. 237 * @isci_device: This parameter is the pointer to the isci remote device object 238 * that is the destination for this request. 239 * @gfp_flags: This parameter specifies the os allocation flags. 240 * 241 * SCI_SUCCESS on successfull completion, or specific failure code. 242 */ 243 static int isci_request_alloc_core( 244 struct isci_host *isci_host, 245 struct isci_request **isci_request, 246 struct isci_remote_device *isci_device, 247 gfp_t gfp_flags) 248 { 249 int ret = 0; 250 dma_addr_t handle; 251 struct isci_request *request; 252 253 254 /* get pointer to dma memory. This actually points 255 * to both the isci_remote_device object and the 256 * sci object. The isci object is at the beginning 257 * of the memory allocated here. 258 */ 259 request = dma_pool_alloc(isci_host->dma_pool, gfp_flags, &handle); 260 if (!request) { 261 dev_warn(&isci_host->pdev->dev, 262 "%s: dma_pool_alloc returned NULL\n", __func__); 263 return -ENOMEM; 264 } 265 266 /* initialize the request object. */ 267 spin_lock_init(&request->state_lock); 268 request->request_daddr = handle; 269 request->isci_host = isci_host; 270 request->isci_device = isci_device; 271 request->io_request_completion = NULL; 272 request->terminated = false; 273 274 request->num_sg_entries = 0; 275 276 request->complete_in_target = false; 277 278 INIT_LIST_HEAD(&request->completed_node); 279 INIT_LIST_HEAD(&request->dev_node); 280 281 *isci_request = request; 282 isci_request_change_state(request, allocated); 283 284 return ret; 285 } 286 287 static int isci_request_alloc_io( 288 struct isci_host *isci_host, 289 struct sas_task *task, 290 struct isci_request **isci_request, 291 struct isci_remote_device *isci_device, 292 gfp_t gfp_flags) 293 { 294 int retval = isci_request_alloc_core(isci_host, isci_request, 295 isci_device, gfp_flags); 296 297 if (!retval) { 298 (*isci_request)->ttype_ptr.io_task_ptr = task; 299 (*isci_request)->ttype = io_task; 300 301 task->lldd_task = *isci_request; 302 } 303 return retval; 304 } 305 306 /** 307 * isci_request_alloc_tmf() - This function gets the request object from the 308 * isci_host dma cache and initializes the relevant fields as a sas_task. 309 * @isci_host: This parameter specifies the ISCI host object 310 * @sas_task: This parameter is the task struct from the upper layer driver. 311 * @isci_request: This parameter will contain the pointer to the new 312 * isci_request object. 313 * @isci_device: This parameter is the pointer to the isci remote device object 314 * that is the destination for this request. 315 * @gfp_flags: This parameter specifies the os allocation flags. 316 * 317 * SCI_SUCCESS on successfull completion, or specific failure code. 318 */ 319 int isci_request_alloc_tmf( 320 struct isci_host *isci_host, 321 struct isci_tmf *isci_tmf, 322 struct isci_request **isci_request, 323 struct isci_remote_device *isci_device, 324 gfp_t gfp_flags) 325 { 326 int retval = isci_request_alloc_core(isci_host, isci_request, 327 isci_device, gfp_flags); 328 329 if (!retval) { 330 331 (*isci_request)->ttype_ptr.tmf_task_ptr = isci_tmf; 332 (*isci_request)->ttype = tmf_task; 333 } 334 return retval; 335 } 336 337 /** 338 * isci_request_execute() - This function allocates the isci_request object, 339 * all fills in some common fields. 340 * @isci_host: This parameter specifies the ISCI host object 341 * @sas_task: This parameter is the task struct from the upper layer driver. 342 * @isci_request: This parameter will contain the pointer to the new 343 * isci_request object. 344 * @gfp_flags: This parameter specifies the os allocation flags. 345 * 346 * SCI_SUCCESS on successfull completion, or specific failure code. 347 */ 348 int isci_request_execute( 349 struct isci_host *isci_host, 350 struct sas_task *task, 351 struct isci_request **isci_request, 352 gfp_t gfp_flags) 353 { 354 int ret = 0; 355 struct scic_sds_remote_device *sci_device; 356 enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL; 357 struct isci_remote_device *isci_device; 358 struct isci_request *request; 359 unsigned long flags; 360 361 isci_device = task->dev->lldd_dev; 362 sci_device = &isci_device->sci; 363 364 /* do common allocation and init of request object. */ 365 ret = isci_request_alloc_io( 366 isci_host, 367 task, 368 &request, 369 isci_device, 370 gfp_flags 371 ); 372 373 if (ret) 374 goto out; 375 376 status = isci_io_request_build(isci_host, request, isci_device); 377 if (status != SCI_SUCCESS) { 378 dev_warn(&isci_host->pdev->dev, 379 "%s: request_construct failed - status = 0x%x\n", 380 __func__, 381 status); 382 goto out; 383 } 384 385 spin_lock_irqsave(&isci_host->scic_lock, flags); 386 387 /* send the request, let the core assign the IO TAG. */ 388 status = scic_controller_start_io(&isci_host->sci, sci_device, 389 &request->sci, 390 SCI_CONTROLLER_INVALID_IO_TAG); 391 if (status != SCI_SUCCESS && 392 status != SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) { 393 dev_warn(&isci_host->pdev->dev, 394 "%s: failed request start (0x%x)\n", 395 __func__, status); 396 spin_unlock_irqrestore(&isci_host->scic_lock, flags); 397 goto out; 398 } 399 400 /* Either I/O started OK, or the core has signaled that 401 * the device needs a target reset. 402 * 403 * In either case, hold onto the I/O for later. 404 * 405 * Update it's status and add it to the list in the 406 * remote device object. 407 */ 408 isci_request_change_state(request, started); 409 list_add(&request->dev_node, &isci_device->reqs_in_process); 410 411 if (status == SCI_SUCCESS) { 412 /* Save the tag for possible task mgmt later. */ 413 request->io_tag = scic_io_request_get_io_tag(&request->sci); 414 } else { 415 /* The request did not really start in the 416 * hardware, so clear the request handle 417 * here so no terminations will be done. 418 */ 419 request->terminated = true; 420 } 421 spin_unlock_irqrestore(&isci_host->scic_lock, flags); 422 423 if (status == 424 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) { 425 /* Signal libsas that we need the SCSI error 426 * handler thread to work on this I/O and that 427 * we want a device reset. 428 */ 429 spin_lock_irqsave(&task->task_state_lock, flags); 430 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET; 431 spin_unlock_irqrestore(&task->task_state_lock, flags); 432 433 /* Cause this task to be scheduled in the SCSI error 434 * handler thread. 435 */ 436 isci_execpath_callback(isci_host, task, 437 sas_task_abort); 438 439 /* Change the status, since we are holding 440 * the I/O until it is managed by the SCSI 441 * error handler. 442 */ 443 status = SCI_SUCCESS; 444 } 445 446 out: 447 if (status != SCI_SUCCESS) { 448 /* release dma memory on failure. */ 449 isci_request_free(isci_host, request); 450 request = NULL; 451 ret = SCI_FAILURE; 452 } 453 454 *isci_request = request; 455 return ret; 456 } 457 458 459 /** 460 * isci_request_process_response_iu() - This function sets the status and 461 * response iu, in the task struct, from the request object for the upper 462 * layer driver. 463 * @sas_task: This parameter is the task struct from the upper layer driver. 464 * @resp_iu: This parameter points to the response iu of the completed request. 465 * @dev: This parameter specifies the linux device struct. 466 * 467 * none. 468 */ 469 static void isci_request_process_response_iu( 470 struct sas_task *task, 471 struct ssp_response_iu *resp_iu, 472 struct device *dev) 473 { 474 dev_dbg(dev, 475 "%s: resp_iu = %p " 476 "resp_iu->status = 0x%x,\nresp_iu->datapres = %d " 477 "resp_iu->response_data_len = %x, " 478 "resp_iu->sense_data_len = %x\nrepsonse data: ", 479 __func__, 480 resp_iu, 481 resp_iu->status, 482 resp_iu->datapres, 483 resp_iu->response_data_len, 484 resp_iu->sense_data_len); 485 486 task->task_status.stat = resp_iu->status; 487 488 /* libsas updates the task status fields based on the response iu. */ 489 sas_ssp_task_response(dev, task, resp_iu); 490 } 491 492 /** 493 * isci_request_set_open_reject_status() - This function prepares the I/O 494 * completion for OPEN_REJECT conditions. 495 * @request: This parameter is the completed isci_request object. 496 * @response_ptr: This parameter specifies the service response for the I/O. 497 * @status_ptr: This parameter specifies the exec status for the I/O. 498 * @complete_to_host_ptr: This parameter specifies the action to be taken by 499 * the LLDD with respect to completing this request or forcing an abort 500 * condition on the I/O. 501 * @open_rej_reason: This parameter specifies the encoded reason for the 502 * abandon-class reject. 503 * 504 * none. 505 */ 506 static void isci_request_set_open_reject_status( 507 struct isci_request *request, 508 struct sas_task *task, 509 enum service_response *response_ptr, 510 enum exec_status *status_ptr, 511 enum isci_completion_selection *complete_to_host_ptr, 512 enum sas_open_rej_reason open_rej_reason) 513 { 514 /* Task in the target is done. */ 515 request->complete_in_target = true; 516 *response_ptr = SAS_TASK_UNDELIVERED; 517 *status_ptr = SAS_OPEN_REJECT; 518 *complete_to_host_ptr = isci_perform_normal_io_completion; 519 task->task_status.open_rej_reason = open_rej_reason; 520 } 521 522 /** 523 * isci_request_handle_controller_specific_errors() - This function decodes 524 * controller-specific I/O completion error conditions. 525 * @request: This parameter is the completed isci_request object. 526 * @response_ptr: This parameter specifies the service response for the I/O. 527 * @status_ptr: This parameter specifies the exec status for the I/O. 528 * @complete_to_host_ptr: This parameter specifies the action to be taken by 529 * the LLDD with respect to completing this request or forcing an abort 530 * condition on the I/O. 531 * 532 * none. 533 */ 534 static void isci_request_handle_controller_specific_errors( 535 struct isci_remote_device *isci_device, 536 struct isci_request *request, 537 struct sas_task *task, 538 enum service_response *response_ptr, 539 enum exec_status *status_ptr, 540 enum isci_completion_selection *complete_to_host_ptr) 541 { 542 unsigned int cstatus; 543 544 cstatus = scic_request_get_controller_status(&request->sci); 545 546 dev_dbg(&request->isci_host->pdev->dev, 547 "%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR " 548 "- controller status = 0x%x\n", 549 __func__, request, cstatus); 550 551 /* Decode the controller-specific errors; most 552 * important is to recognize those conditions in which 553 * the target may still have a task outstanding that 554 * must be aborted. 555 * 556 * Note that there are SCU completion codes being 557 * named in the decode below for which SCIC has already 558 * done work to handle them in a way other than as 559 * a controller-specific completion code; these are left 560 * in the decode below for completeness sake. 561 */ 562 switch (cstatus) { 563 case SCU_TASK_DONE_DMASETUP_DIRERR: 564 /* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */ 565 case SCU_TASK_DONE_XFERCNT_ERR: 566 /* Also SCU_TASK_DONE_SMP_UFI_ERR: */ 567 if (task->task_proto == SAS_PROTOCOL_SMP) { 568 /* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */ 569 *response_ptr = SAS_TASK_COMPLETE; 570 571 /* See if the device has been/is being stopped. Note 572 * that we ignore the quiesce state, since we are 573 * concerned about the actual device state. 574 */ 575 if ((isci_device->status == isci_stopping) || 576 (isci_device->status == isci_stopped)) 577 *status_ptr = SAS_DEVICE_UNKNOWN; 578 else 579 *status_ptr = SAS_ABORTED_TASK; 580 581 request->complete_in_target = true; 582 583 *complete_to_host_ptr = 584 isci_perform_normal_io_completion; 585 } else { 586 /* Task in the target is not done. */ 587 *response_ptr = SAS_TASK_UNDELIVERED; 588 589 if ((isci_device->status == isci_stopping) || 590 (isci_device->status == isci_stopped)) 591 *status_ptr = SAS_DEVICE_UNKNOWN; 592 else 593 *status_ptr = SAM_STAT_TASK_ABORTED; 594 595 request->complete_in_target = false; 596 597 *complete_to_host_ptr = 598 isci_perform_error_io_completion; 599 } 600 601 break; 602 603 case SCU_TASK_DONE_CRC_ERR: 604 case SCU_TASK_DONE_NAK_CMD_ERR: 605 case SCU_TASK_DONE_EXCESS_DATA: 606 case SCU_TASK_DONE_UNEXP_FIS: 607 /* Also SCU_TASK_DONE_UNEXP_RESP: */ 608 case SCU_TASK_DONE_VIIT_ENTRY_NV: /* TODO - conditions? */ 609 case SCU_TASK_DONE_IIT_ENTRY_NV: /* TODO - conditions? */ 610 case SCU_TASK_DONE_RNCNV_OUTBOUND: /* TODO - conditions? */ 611 /* These are conditions in which the target 612 * has completed the task, so that no cleanup 613 * is necessary. 614 */ 615 *response_ptr = SAS_TASK_COMPLETE; 616 617 /* See if the device has been/is being stopped. Note 618 * that we ignore the quiesce state, since we are 619 * concerned about the actual device state. 620 */ 621 if ((isci_device->status == isci_stopping) || 622 (isci_device->status == isci_stopped)) 623 *status_ptr = SAS_DEVICE_UNKNOWN; 624 else 625 *status_ptr = SAS_ABORTED_TASK; 626 627 request->complete_in_target = true; 628 629 *complete_to_host_ptr = isci_perform_normal_io_completion; 630 break; 631 632 633 /* Note that the only open reject completion codes seen here will be 634 * abandon-class codes; all others are automatically retried in the SCU. 635 */ 636 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION: 637 638 isci_request_set_open_reject_status( 639 request, task, response_ptr, status_ptr, 640 complete_to_host_ptr, SAS_OREJ_WRONG_DEST); 641 break; 642 643 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION: 644 645 /* Note - the return of AB0 will change when 646 * libsas implements detection of zone violations. 647 */ 648 isci_request_set_open_reject_status( 649 request, task, response_ptr, status_ptr, 650 complete_to_host_ptr, SAS_OREJ_RESV_AB0); 651 break; 652 653 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1: 654 655 isci_request_set_open_reject_status( 656 request, task, response_ptr, status_ptr, 657 complete_to_host_ptr, SAS_OREJ_RESV_AB1); 658 break; 659 660 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2: 661 662 isci_request_set_open_reject_status( 663 request, task, response_ptr, status_ptr, 664 complete_to_host_ptr, SAS_OREJ_RESV_AB2); 665 break; 666 667 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3: 668 669 isci_request_set_open_reject_status( 670 request, task, response_ptr, status_ptr, 671 complete_to_host_ptr, SAS_OREJ_RESV_AB3); 672 break; 673 674 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION: 675 676 isci_request_set_open_reject_status( 677 request, task, response_ptr, status_ptr, 678 complete_to_host_ptr, SAS_OREJ_BAD_DEST); 679 break; 680 681 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY: 682 683 isci_request_set_open_reject_status( 684 request, task, response_ptr, status_ptr, 685 complete_to_host_ptr, SAS_OREJ_STP_NORES); 686 break; 687 688 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED: 689 690 isci_request_set_open_reject_status( 691 request, task, response_ptr, status_ptr, 692 complete_to_host_ptr, SAS_OREJ_EPROTO); 693 break; 694 695 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED: 696 697 isci_request_set_open_reject_status( 698 request, task, response_ptr, status_ptr, 699 complete_to_host_ptr, SAS_OREJ_CONN_RATE); 700 break; 701 702 case SCU_TASK_DONE_LL_R_ERR: 703 /* Also SCU_TASK_DONE_ACK_NAK_TO: */ 704 case SCU_TASK_DONE_LL_PERR: 705 case SCU_TASK_DONE_LL_SY_TERM: 706 /* Also SCU_TASK_DONE_NAK_ERR:*/ 707 case SCU_TASK_DONE_LL_LF_TERM: 708 /* Also SCU_TASK_DONE_DATA_LEN_ERR: */ 709 case SCU_TASK_DONE_LL_ABORT_ERR: 710 case SCU_TASK_DONE_SEQ_INV_TYPE: 711 /* Also SCU_TASK_DONE_UNEXP_XR: */ 712 case SCU_TASK_DONE_XR_IU_LEN_ERR: 713 case SCU_TASK_DONE_INV_FIS_LEN: 714 /* Also SCU_TASK_DONE_XR_WD_LEN: */ 715 case SCU_TASK_DONE_SDMA_ERR: 716 case SCU_TASK_DONE_OFFSET_ERR: 717 case SCU_TASK_DONE_MAX_PLD_ERR: 718 case SCU_TASK_DONE_LF_ERR: 719 case SCU_TASK_DONE_SMP_RESP_TO_ERR: /* Escalate to dev reset? */ 720 case SCU_TASK_DONE_SMP_LL_RX_ERR: 721 case SCU_TASK_DONE_UNEXP_DATA: 722 case SCU_TASK_DONE_UNEXP_SDBFIS: 723 case SCU_TASK_DONE_REG_ERR: 724 case SCU_TASK_DONE_SDB_ERR: 725 case SCU_TASK_DONE_TASK_ABORT: 726 default: 727 /* Task in the target is not done. */ 728 *response_ptr = SAS_TASK_UNDELIVERED; 729 *status_ptr = SAM_STAT_TASK_ABORTED; 730 request->complete_in_target = false; 731 732 *complete_to_host_ptr = isci_perform_error_io_completion; 733 break; 734 } 735 } 736 737 /** 738 * isci_task_save_for_upper_layer_completion() - This function saves the 739 * request for later completion to the upper layer driver. 740 * @host: This parameter is a pointer to the host on which the the request 741 * should be queued (either as an error or success). 742 * @request: This parameter is the completed request. 743 * @response: This parameter is the response code for the completed task. 744 * @status: This parameter is the status code for the completed task. 745 * 746 * none. 747 */ 748 static void isci_task_save_for_upper_layer_completion( 749 struct isci_host *host, 750 struct isci_request *request, 751 enum service_response response, 752 enum exec_status status, 753 enum isci_completion_selection task_notification_selection) 754 { 755 struct sas_task *task = isci_request_access_task(request); 756 757 task_notification_selection 758 = isci_task_set_completion_status(task, response, status, 759 task_notification_selection); 760 761 /* Tasks aborted specifically by a call to the lldd_abort_task 762 * function should not be completed to the host in the regular path. 763 */ 764 switch (task_notification_selection) { 765 766 case isci_perform_normal_io_completion: 767 768 /* Normal notification (task_done) */ 769 dev_dbg(&host->pdev->dev, 770 "%s: Normal - task = %p, response=%d (%d), status=%d (%d)\n", 771 __func__, 772 task, 773 task->task_status.resp, response, 774 task->task_status.stat, status); 775 /* Add to the completed list. */ 776 list_add(&request->completed_node, 777 &host->requests_to_complete); 778 779 /* Take the request off the device's pending request list. */ 780 list_del_init(&request->dev_node); 781 break; 782 783 case isci_perform_aborted_io_completion: 784 /* No notification to libsas because this request is 785 * already in the abort path. 786 */ 787 dev_warn(&host->pdev->dev, 788 "%s: Aborted - task = %p, response=%d (%d), status=%d (%d)\n", 789 __func__, 790 task, 791 task->task_status.resp, response, 792 task->task_status.stat, status); 793 794 /* Wake up whatever process was waiting for this 795 * request to complete. 796 */ 797 WARN_ON(request->io_request_completion == NULL); 798 799 if (request->io_request_completion != NULL) { 800 801 /* Signal whoever is waiting that this 802 * request is complete. 803 */ 804 complete(request->io_request_completion); 805 } 806 break; 807 808 case isci_perform_error_io_completion: 809 /* Use sas_task_abort */ 810 dev_warn(&host->pdev->dev, 811 "%s: Error - task = %p, response=%d (%d), status=%d (%d)\n", 812 __func__, 813 task, 814 task->task_status.resp, response, 815 task->task_status.stat, status); 816 /* Add to the aborted list. */ 817 list_add(&request->completed_node, 818 &host->requests_to_errorback); 819 break; 820 821 default: 822 dev_warn(&host->pdev->dev, 823 "%s: Unknown - task = %p, response=%d (%d), status=%d (%d)\n", 824 __func__, 825 task, 826 task->task_status.resp, response, 827 task->task_status.stat, status); 828 829 /* Add to the error to libsas list. */ 830 list_add(&request->completed_node, 831 &host->requests_to_errorback); 832 break; 833 } 834 } 835 836 /** 837 * isci_request_io_request_complete() - This function is called by the sci core 838 * when an io request completes. 839 * @isci_host: This parameter specifies the ISCI host object 840 * @request: This parameter is the completed isci_request object. 841 * @completion_status: This parameter specifies the completion status from the 842 * sci core. 843 * 844 * none. 845 */ 846 void isci_request_io_request_complete( 847 struct isci_host *isci_host, 848 struct isci_request *request, 849 enum sci_io_status completion_status) 850 { 851 struct sas_task *task = isci_request_access_task(request); 852 struct ssp_response_iu *resp_iu; 853 void *resp_buf; 854 unsigned long task_flags; 855 struct isci_remote_device *isci_device = request->isci_device; 856 enum service_response response = SAS_TASK_UNDELIVERED; 857 enum exec_status status = SAS_ABORTED_TASK; 858 enum isci_request_status request_status; 859 enum isci_completion_selection complete_to_host 860 = isci_perform_normal_io_completion; 861 862 dev_dbg(&isci_host->pdev->dev, 863 "%s: request = %p, task = %p,\n" 864 "task->data_dir = %d completion_status = 0x%x\n", 865 __func__, 866 request, 867 task, 868 task->data_dir, 869 completion_status); 870 871 spin_lock(&request->state_lock); 872 request_status = isci_request_get_state(request); 873 874 /* Decode the request status. Note that if the request has been 875 * aborted by a task management function, we don't care 876 * what the status is. 877 */ 878 switch (request_status) { 879 880 case aborted: 881 /* "aborted" indicates that the request was aborted by a task 882 * management function, since once a task management request is 883 * perfomed by the device, the request only completes because 884 * of the subsequent driver terminate. 885 * 886 * Aborted also means an external thread is explicitly managing 887 * this request, so that we do not complete it up the stack. 888 * 889 * The target is still there (since the TMF was successful). 890 */ 891 request->complete_in_target = true; 892 response = SAS_TASK_COMPLETE; 893 894 /* See if the device has been/is being stopped. Note 895 * that we ignore the quiesce state, since we are 896 * concerned about the actual device state. 897 */ 898 if ((isci_device->status == isci_stopping) 899 || (isci_device->status == isci_stopped) 900 ) 901 status = SAS_DEVICE_UNKNOWN; 902 else 903 status = SAS_ABORTED_TASK; 904 905 complete_to_host = isci_perform_aborted_io_completion; 906 /* This was an aborted request. */ 907 908 spin_unlock(&request->state_lock); 909 break; 910 911 case aborting: 912 /* aborting means that the task management function tried and 913 * failed to abort the request. We need to note the request 914 * as SAS_TASK_UNDELIVERED, so that the scsi mid layer marks the 915 * target as down. 916 * 917 * Aborting also means an external thread is explicitly managing 918 * this request, so that we do not complete it up the stack. 919 */ 920 request->complete_in_target = true; 921 response = SAS_TASK_UNDELIVERED; 922 923 if ((isci_device->status == isci_stopping) || 924 (isci_device->status == isci_stopped)) 925 /* The device has been /is being stopped. Note that 926 * we ignore the quiesce state, since we are 927 * concerned about the actual device state. 928 */ 929 status = SAS_DEVICE_UNKNOWN; 930 else 931 status = SAS_PHY_DOWN; 932 933 complete_to_host = isci_perform_aborted_io_completion; 934 935 /* This was an aborted request. */ 936 937 spin_unlock(&request->state_lock); 938 break; 939 940 case terminating: 941 942 /* This was an terminated request. This happens when 943 * the I/O is being terminated because of an action on 944 * the device (reset, tear down, etc.), and the I/O needs 945 * to be completed up the stack. 946 */ 947 request->complete_in_target = true; 948 response = SAS_TASK_UNDELIVERED; 949 950 /* See if the device has been/is being stopped. Note 951 * that we ignore the quiesce state, since we are 952 * concerned about the actual device state. 953 */ 954 if ((isci_device->status == isci_stopping) || 955 (isci_device->status == isci_stopped)) 956 status = SAS_DEVICE_UNKNOWN; 957 else 958 status = SAS_ABORTED_TASK; 959 960 complete_to_host = isci_perform_aborted_io_completion; 961 962 /* This was a terminated request. */ 963 964 spin_unlock(&request->state_lock); 965 break; 966 967 default: 968 969 /* The request is done from an SCU HW perspective. */ 970 request->status = completed; 971 972 spin_unlock(&request->state_lock); 973 974 /* This is an active request being completed from the core. */ 975 switch (completion_status) { 976 977 case SCI_IO_FAILURE_RESPONSE_VALID: 978 dev_dbg(&isci_host->pdev->dev, 979 "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n", 980 __func__, 981 request, 982 task); 983 984 if (sas_protocol_ata(task->task_proto)) { 985 resp_buf = &request->sci.stp.rsp; 986 isci_request_process_stp_response(task, 987 resp_buf); 988 } else if (SAS_PROTOCOL_SSP == task->task_proto) { 989 990 /* crack the iu response buffer. */ 991 resp_iu = &request->sci.ssp.rsp; 992 isci_request_process_response_iu(task, resp_iu, 993 &isci_host->pdev->dev); 994 995 } else if (SAS_PROTOCOL_SMP == task->task_proto) { 996 997 dev_err(&isci_host->pdev->dev, 998 "%s: SCI_IO_FAILURE_RESPONSE_VALID: " 999 "SAS_PROTOCOL_SMP protocol\n", 1000 __func__); 1001 1002 } else 1003 dev_err(&isci_host->pdev->dev, 1004 "%s: unknown protocol\n", __func__); 1005 1006 /* use the task status set in the task struct by the 1007 * isci_request_process_response_iu call. 1008 */ 1009 request->complete_in_target = true; 1010 response = task->task_status.resp; 1011 status = task->task_status.stat; 1012 break; 1013 1014 case SCI_IO_SUCCESS: 1015 case SCI_IO_SUCCESS_IO_DONE_EARLY: 1016 1017 response = SAS_TASK_COMPLETE; 1018 status = SAM_STAT_GOOD; 1019 request->complete_in_target = true; 1020 1021 if (task->task_proto == SAS_PROTOCOL_SMP) { 1022 void *rsp = &request->sci.smp.rsp; 1023 1024 dev_dbg(&isci_host->pdev->dev, 1025 "%s: SMP protocol completion\n", 1026 __func__); 1027 1028 sg_copy_from_buffer( 1029 &task->smp_task.smp_resp, 1, 1030 rsp, sizeof(struct smp_resp)); 1031 } else if (completion_status 1032 == SCI_IO_SUCCESS_IO_DONE_EARLY) { 1033 1034 /* This was an SSP / STP / SATA transfer. 1035 * There is a possibility that less data than 1036 * the maximum was transferred. 1037 */ 1038 u32 transferred_length 1039 = scic_io_request_get_number_of_bytes_transferred(&request->sci); 1040 1041 task->task_status.residual 1042 = task->total_xfer_len - transferred_length; 1043 1044 /* If there were residual bytes, call this an 1045 * underrun. 1046 */ 1047 if (task->task_status.residual != 0) 1048 status = SAS_DATA_UNDERRUN; 1049 1050 dev_dbg(&isci_host->pdev->dev, 1051 "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n", 1052 __func__, 1053 status); 1054 1055 } else 1056 dev_dbg(&isci_host->pdev->dev, 1057 "%s: SCI_IO_SUCCESS\n", 1058 __func__); 1059 1060 break; 1061 1062 case SCI_IO_FAILURE_TERMINATED: 1063 dev_dbg(&isci_host->pdev->dev, 1064 "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n", 1065 __func__, 1066 request, 1067 task); 1068 1069 /* The request was terminated explicitly. No handling 1070 * is needed in the SCSI error handler path. 1071 */ 1072 request->complete_in_target = true; 1073 response = SAS_TASK_UNDELIVERED; 1074 1075 /* See if the device has been/is being stopped. Note 1076 * that we ignore the quiesce state, since we are 1077 * concerned about the actual device state. 1078 */ 1079 if ((isci_device->status == isci_stopping) || 1080 (isci_device->status == isci_stopped)) 1081 status = SAS_DEVICE_UNKNOWN; 1082 else 1083 status = SAS_ABORTED_TASK; 1084 1085 complete_to_host = isci_perform_normal_io_completion; 1086 break; 1087 1088 case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR: 1089 1090 isci_request_handle_controller_specific_errors( 1091 isci_device, request, task, &response, &status, 1092 &complete_to_host); 1093 1094 break; 1095 1096 case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED: 1097 /* This is a special case, in that the I/O completion 1098 * is telling us that the device needs a reset. 1099 * In order for the device reset condition to be 1100 * noticed, the I/O has to be handled in the error 1101 * handler. Set the reset flag and cause the 1102 * SCSI error thread to be scheduled. 1103 */ 1104 spin_lock_irqsave(&task->task_state_lock, task_flags); 1105 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET; 1106 spin_unlock_irqrestore(&task->task_state_lock, task_flags); 1107 1108 /* Fail the I/O. */ 1109 response = SAS_TASK_UNDELIVERED; 1110 status = SAM_STAT_TASK_ABORTED; 1111 1112 complete_to_host = isci_perform_error_io_completion; 1113 request->complete_in_target = false; 1114 break; 1115 1116 default: 1117 /* Catch any otherwise unhandled error codes here. */ 1118 dev_warn(&isci_host->pdev->dev, 1119 "%s: invalid completion code: 0x%x - " 1120 "isci_request = %p\n", 1121 __func__, completion_status, request); 1122 1123 response = SAS_TASK_UNDELIVERED; 1124 1125 /* See if the device has been/is being stopped. Note 1126 * that we ignore the quiesce state, since we are 1127 * concerned about the actual device state. 1128 */ 1129 if ((isci_device->status == isci_stopping) || 1130 (isci_device->status == isci_stopped)) 1131 status = SAS_DEVICE_UNKNOWN; 1132 else 1133 status = SAS_ABORTED_TASK; 1134 1135 complete_to_host = isci_perform_error_io_completion; 1136 request->complete_in_target = false; 1137 break; 1138 } 1139 break; 1140 } 1141 1142 isci_request_unmap_sgl(request, isci_host->pdev); 1143 1144 /* Put the completed request on the correct list */ 1145 isci_task_save_for_upper_layer_completion(isci_host, request, response, 1146 status, complete_to_host 1147 ); 1148 1149 /* complete the io request to the core. */ 1150 scic_controller_complete_io(&isci_host->sci, 1151 &isci_device->sci, 1152 &request->sci); 1153 /* set terminated handle so it cannot be completed or 1154 * terminated again, and to cause any calls into abort 1155 * task to recognize the already completed case. 1156 */ 1157 request->terminated = true; 1158 1159 isci_host_can_dequeue(isci_host, 1); 1160 } 1161