drivers/scsi/isci/request.c

   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(
  77                 request->sci_request_handle
  78                 );
  79         return status;
  80 }
  81
  82 static 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  */
 124 static 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  */
 164 static 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->sci,
 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  */
 255 static 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
 301 static 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  */
 333 int 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  */
 362 int 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->sci,
 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  */
 489 static 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  */
 526 static 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  */
 554 static 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  */
 770 static 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  */
 868 void 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->sci,
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 }