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