linux/drivers/scsi/isci/request.c
<<
>>
Prefs
   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 <scsi/scsi_cmnd.h>
  57#include "isci.h"
  58#include "task.h"
  59#include "request.h"
  60#include "scu_completion_codes.h"
  61#include "scu_event_codes.h"
  62#include "sas.h"
  63
  64#undef C
  65#define C(a) (#a)
  66const char *req_state_name(enum sci_base_request_states state)
  67{
  68        static const char * const strings[] = REQUEST_STATES;
  69
  70        return strings[state];
  71}
  72#undef C
  73
  74static struct scu_sgl_element_pair *to_sgl_element_pair(struct isci_request *ireq,
  75                                                        int idx)
  76{
  77        if (idx == 0)
  78                return &ireq->tc->sgl_pair_ab;
  79        else if (idx == 1)
  80                return &ireq->tc->sgl_pair_cd;
  81        else if (idx < 0)
  82                return NULL;
  83        else
  84                return &ireq->sg_table[idx - 2];
  85}
  86
  87static dma_addr_t to_sgl_element_pair_dma(struct isci_host *ihost,
  88                                          struct isci_request *ireq, u32 idx)
  89{
  90        u32 offset;
  91
  92        if (idx == 0) {
  93                offset = (void *) &ireq->tc->sgl_pair_ab -
  94                         (void *) &ihost->task_context_table[0];
  95                return ihost->tc_dma + offset;
  96        } else if (idx == 1) {
  97                offset = (void *) &ireq->tc->sgl_pair_cd -
  98                         (void *) &ihost->task_context_table[0];
  99                return ihost->tc_dma + offset;
 100        }
 101
 102        return sci_io_request_get_dma_addr(ireq, &ireq->sg_table[idx - 2]);
 103}
 104
 105static void init_sgl_element(struct scu_sgl_element *e, struct scatterlist *sg)
 106{
 107        e->length = sg_dma_len(sg);
 108        e->address_upper = upper_32_bits(sg_dma_address(sg));
 109        e->address_lower = lower_32_bits(sg_dma_address(sg));
 110        e->address_modifier = 0;
 111}
 112
 113static void sci_request_build_sgl(struct isci_request *ireq)
 114{
 115        struct isci_host *ihost = ireq->isci_host;
 116        struct sas_task *task = isci_request_access_task(ireq);
 117        struct scatterlist *sg = NULL;
 118        dma_addr_t dma_addr;
 119        u32 sg_idx = 0;
 120        struct scu_sgl_element_pair *scu_sg   = NULL;
 121        struct scu_sgl_element_pair *prev_sg  = NULL;
 122
 123        if (task->num_scatter > 0) {
 124                sg = task->scatter;
 125
 126                while (sg) {
 127                        scu_sg = to_sgl_element_pair(ireq, sg_idx);
 128                        init_sgl_element(&scu_sg->A, sg);
 129                        sg = sg_next(sg);
 130                        if (sg) {
 131                                init_sgl_element(&scu_sg->B, sg);
 132                                sg = sg_next(sg);
 133                        } else
 134                                memset(&scu_sg->B, 0, sizeof(scu_sg->B));
 135
 136                        if (prev_sg) {
 137                                dma_addr = to_sgl_element_pair_dma(ihost,
 138                                                                   ireq,
 139                                                                   sg_idx);
 140
 141                                prev_sg->next_pair_upper =
 142                                        upper_32_bits(dma_addr);
 143                                prev_sg->next_pair_lower =
 144                                        lower_32_bits(dma_addr);
 145                        }
 146
 147                        prev_sg = scu_sg;
 148                        sg_idx++;
 149                }
 150        } else {        /* handle when no sg */
 151                scu_sg = to_sgl_element_pair(ireq, sg_idx);
 152
 153                dma_addr = dma_map_single(&ihost->pdev->dev,
 154                                          task->scatter,
 155                                          task->total_xfer_len,
 156                                          task->data_dir);
 157
 158                ireq->zero_scatter_daddr = dma_addr;
 159
 160                scu_sg->A.length = task->total_xfer_len;
 161                scu_sg->A.address_upper = upper_32_bits(dma_addr);
 162                scu_sg->A.address_lower = lower_32_bits(dma_addr);
 163        }
 164
 165        if (scu_sg) {
 166                scu_sg->next_pair_upper = 0;
 167                scu_sg->next_pair_lower = 0;
 168        }
 169}
 170
 171static void sci_io_request_build_ssp_command_iu(struct isci_request *ireq)
 172{
 173        struct ssp_cmd_iu *cmd_iu;
 174        struct sas_task *task = isci_request_access_task(ireq);
 175
 176        cmd_iu = &ireq->ssp.cmd;
 177
 178        memcpy(cmd_iu->LUN, task->ssp_task.LUN, 8);
 179        cmd_iu->add_cdb_len = 0;
 180        cmd_iu->_r_a = 0;
 181        cmd_iu->_r_b = 0;
 182        cmd_iu->en_fburst = 0; /* unsupported */
 183        cmd_iu->task_prio = task->ssp_task.task_prio;
 184        cmd_iu->task_attr = task->ssp_task.task_attr;
 185        cmd_iu->_r_c = 0;
 186
 187        sci_swab32_cpy(&cmd_iu->cdb, task->ssp_task.cmd->cmnd,
 188                       (task->ssp_task.cmd->cmd_len+3) / sizeof(u32));
 189}
 190
 191static void sci_task_request_build_ssp_task_iu(struct isci_request *ireq)
 192{
 193        struct ssp_task_iu *task_iu;
 194        struct sas_task *task = isci_request_access_task(ireq);
 195        struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
 196
 197        task_iu = &ireq->ssp.tmf;
 198
 199        memset(task_iu, 0, sizeof(struct ssp_task_iu));
 200
 201        memcpy(task_iu->LUN, task->ssp_task.LUN, 8);
 202
 203        task_iu->task_func = isci_tmf->tmf_code;
 204        task_iu->task_tag =
 205                (test_bit(IREQ_TMF, &ireq->flags)) ?
 206                isci_tmf->io_tag :
 207                SCI_CONTROLLER_INVALID_IO_TAG;
 208}
 209
 210/**
 211 * This method is will fill in the SCU Task Context for any type of SSP request.
 212 * @sci_req:
 213 * @task_context:
 214 *
 215 */
 216static void scu_ssp_reqeust_construct_task_context(
 217        struct isci_request *ireq,
 218        struct scu_task_context *task_context)
 219{
 220        dma_addr_t dma_addr;
 221        struct isci_remote_device *idev;
 222        struct isci_port *iport;
 223
 224        idev = ireq->target_device;
 225        iport = idev->owning_port;
 226
 227        /* Fill in the TC with the its required data */
 228        task_context->abort = 0;
 229        task_context->priority = 0;
 230        task_context->initiator_request = 1;
 231        task_context->connection_rate = idev->connection_rate;
 232        task_context->protocol_engine_index = ISCI_PEG;
 233        task_context->logical_port_index = iport->physical_port_index;
 234        task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
 235        task_context->valid = SCU_TASK_CONTEXT_VALID;
 236        task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 237
 238        task_context->remote_node_index = idev->rnc.remote_node_index;
 239        task_context->command_code = 0;
 240
 241        task_context->link_layer_control = 0;
 242        task_context->do_not_dma_ssp_good_response = 1;
 243        task_context->strict_ordering = 0;
 244        task_context->control_frame = 0;
 245        task_context->timeout_enable = 0;
 246        task_context->block_guard_enable = 0;
 247
 248        task_context->address_modifier = 0;
 249
 250        /* task_context->type.ssp.tag = ireq->io_tag; */
 251        task_context->task_phase = 0x01;
 252
 253        ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 254                              (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 255                              (iport->physical_port_index <<
 256                               SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 257                              ISCI_TAG_TCI(ireq->io_tag));
 258
 259        /*
 260         * Copy the physical address for the command buffer to the
 261         * SCU Task Context
 262         */
 263        dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.cmd);
 264
 265        task_context->command_iu_upper = upper_32_bits(dma_addr);
 266        task_context->command_iu_lower = lower_32_bits(dma_addr);
 267
 268        /*
 269         * Copy the physical address for the response buffer to the
 270         * SCU Task Context
 271         */
 272        dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.rsp);
 273
 274        task_context->response_iu_upper = upper_32_bits(dma_addr);
 275        task_context->response_iu_lower = lower_32_bits(dma_addr);
 276}
 277
 278static u8 scu_bg_blk_size(struct scsi_device *sdp)
 279{
 280        switch (sdp->sector_size) {
 281        case 512:
 282                return 0;
 283        case 1024:
 284                return 1;
 285        case 4096:
 286                return 3;
 287        default:
 288                return 0xff;
 289        }
 290}
 291
 292static u32 scu_dif_bytes(u32 len, u32 sector_size)
 293{
 294        return (len >> ilog2(sector_size)) * 8;
 295}
 296
 297static void scu_ssp_ireq_dif_insert(struct isci_request *ireq, u8 type, u8 op)
 298{
 299        struct scu_task_context *tc = ireq->tc;
 300        struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
 301        u8 blk_sz = scu_bg_blk_size(scmd->device);
 302
 303        tc->block_guard_enable = 1;
 304        tc->blk_prot_en = 1;
 305        tc->blk_sz = blk_sz;
 306        /* DIF write insert */
 307        tc->blk_prot_func = 0x2;
 308
 309        tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
 310                                                   scmd->device->sector_size);
 311
 312        /* always init to 0, used by hw */
 313        tc->interm_crc_val = 0;
 314
 315        tc->init_crc_seed = 0;
 316        tc->app_tag_verify = 0;
 317        tc->app_tag_gen = 0;
 318        tc->ref_tag_seed_verify = 0;
 319
 320        /* always init to same as bg_blk_sz */
 321        tc->UD_bytes_immed_val = scmd->device->sector_size;
 322
 323        tc->reserved_DC_0 = 0;
 324
 325        /* always init to 8 */
 326        tc->DIF_bytes_immed_val = 8;
 327
 328        tc->reserved_DC_1 = 0;
 329        tc->bgc_blk_sz = scmd->device->sector_size;
 330        tc->reserved_E0_0 = 0;
 331        tc->app_tag_gen_mask = 0;
 332
 333        /** setup block guard control **/
 334        tc->bgctl = 0;
 335
 336        /* DIF write insert */
 337        tc->bgctl_f.op = 0x2;
 338
 339        tc->app_tag_verify_mask = 0;
 340
 341        /* must init to 0 for hw */
 342        tc->blk_guard_err = 0;
 343
 344        tc->reserved_E8_0 = 0;
 345
 346        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
 347                tc->ref_tag_seed_gen = scsi_get_lba(scmd) & 0xffffffff;
 348        else if (type & SCSI_PROT_DIF_TYPE3)
 349                tc->ref_tag_seed_gen = 0;
 350}
 351
 352static void scu_ssp_ireq_dif_strip(struct isci_request *ireq, u8 type, u8 op)
 353{
 354        struct scu_task_context *tc = ireq->tc;
 355        struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
 356        u8 blk_sz = scu_bg_blk_size(scmd->device);
 357
 358        tc->block_guard_enable = 1;
 359        tc->blk_prot_en = 1;
 360        tc->blk_sz = blk_sz;
 361        /* DIF read strip */
 362        tc->blk_prot_func = 0x1;
 363
 364        tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
 365                                                   scmd->device->sector_size);
 366
 367        /* always init to 0, used by hw */
 368        tc->interm_crc_val = 0;
 369
 370        tc->init_crc_seed = 0;
 371        tc->app_tag_verify = 0;
 372        tc->app_tag_gen = 0;
 373
 374        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
 375                tc->ref_tag_seed_verify = scsi_get_lba(scmd) & 0xffffffff;
 376        else if (type & SCSI_PROT_DIF_TYPE3)
 377                tc->ref_tag_seed_verify = 0;
 378
 379        /* always init to same as bg_blk_sz */
 380        tc->UD_bytes_immed_val = scmd->device->sector_size;
 381
 382        tc->reserved_DC_0 = 0;
 383
 384        /* always init to 8 */
 385        tc->DIF_bytes_immed_val = 8;
 386
 387        tc->reserved_DC_1 = 0;
 388        tc->bgc_blk_sz = scmd->device->sector_size;
 389        tc->reserved_E0_0 = 0;
 390        tc->app_tag_gen_mask = 0;
 391
 392        /** setup block guard control **/
 393        tc->bgctl = 0;
 394
 395        /* DIF read strip */
 396        tc->bgctl_f.crc_verify = 1;
 397        tc->bgctl_f.op = 0x1;
 398        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2)) {
 399                tc->bgctl_f.ref_tag_chk = 1;
 400                tc->bgctl_f.app_f_detect = 1;
 401        } else if (type & SCSI_PROT_DIF_TYPE3)
 402                tc->bgctl_f.app_ref_f_detect = 1;
 403
 404        tc->app_tag_verify_mask = 0;
 405
 406        /* must init to 0 for hw */
 407        tc->blk_guard_err = 0;
 408
 409        tc->reserved_E8_0 = 0;
 410        tc->ref_tag_seed_gen = 0;
 411}
 412
 413/**
 414 * This method is will fill in the SCU Task Context for a SSP IO request.
 415 * @sci_req:
 416 *
 417 */
 418static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
 419                                                      enum dma_data_direction dir,
 420                                                      u32 len)
 421{
 422        struct scu_task_context *task_context = ireq->tc;
 423        struct sas_task *sas_task = ireq->ttype_ptr.io_task_ptr;
 424        struct scsi_cmnd *scmd = sas_task->uldd_task;
 425        u8 prot_type = scsi_get_prot_type(scmd);
 426        u8 prot_op = scsi_get_prot_op(scmd);
 427
 428        scu_ssp_reqeust_construct_task_context(ireq, task_context);
 429
 430        task_context->ssp_command_iu_length =
 431                sizeof(struct ssp_cmd_iu) / sizeof(u32);
 432        task_context->type.ssp.frame_type = SSP_COMMAND;
 433
 434        switch (dir) {
 435        case DMA_FROM_DEVICE:
 436        case DMA_NONE:
 437        default:
 438                task_context->task_type = SCU_TASK_TYPE_IOREAD;
 439                break;
 440        case DMA_TO_DEVICE:
 441                task_context->task_type = SCU_TASK_TYPE_IOWRITE;
 442                break;
 443        }
 444
 445        task_context->transfer_length_bytes = len;
 446
 447        if (task_context->transfer_length_bytes > 0)
 448                sci_request_build_sgl(ireq);
 449
 450        if (prot_type != SCSI_PROT_DIF_TYPE0) {
 451                if (prot_op == SCSI_PROT_READ_STRIP)
 452                        scu_ssp_ireq_dif_strip(ireq, prot_type, prot_op);
 453                else if (prot_op == SCSI_PROT_WRITE_INSERT)
 454                        scu_ssp_ireq_dif_insert(ireq, prot_type, prot_op);
 455        }
 456}
 457
 458/**
 459 * This method will fill in the SCU Task Context for a SSP Task request.  The
 460 *    following important settings are utilized: -# priority ==
 461 *    SCU_TASK_PRIORITY_HIGH.  This ensures that the task request is issued
 462 *    ahead of other task destined for the same Remote Node. -# task_type ==
 463 *    SCU_TASK_TYPE_IOREAD.  This simply indicates that a normal request type
 464 *    (i.e. non-raw frame) is being utilized to perform task management. -#
 465 *    control_frame == 1.  This ensures that the proper endianess is set so
 466 *    that the bytes are transmitted in the right order for a task frame.
 467 * @sci_req: This parameter specifies the task request object being
 468 *    constructed.
 469 *
 470 */
 471static void scu_ssp_task_request_construct_task_context(struct isci_request *ireq)
 472{
 473        struct scu_task_context *task_context = ireq->tc;
 474
 475        scu_ssp_reqeust_construct_task_context(ireq, task_context);
 476
 477        task_context->control_frame                = 1;
 478        task_context->priority                     = SCU_TASK_PRIORITY_HIGH;
 479        task_context->task_type                    = SCU_TASK_TYPE_RAW_FRAME;
 480        task_context->transfer_length_bytes        = 0;
 481        task_context->type.ssp.frame_type          = SSP_TASK;
 482        task_context->ssp_command_iu_length =
 483                sizeof(struct ssp_task_iu) / sizeof(u32);
 484}
 485
 486/**
 487 * This method is will fill in the SCU Task Context for any type of SATA
 488 *    request.  This is called from the various SATA constructors.
 489 * @sci_req: The general IO request object which is to be used in
 490 *    constructing the SCU task context.
 491 * @task_context: The buffer pointer for the SCU task context which is being
 492 *    constructed.
 493 *
 494 * The general io request construction is complete. The buffer assignment for
 495 * the command buffer is complete. none Revisit task context construction to
 496 * determine what is common for SSP/SMP/STP task context structures.
 497 */
 498static void scu_sata_reqeust_construct_task_context(
 499        struct isci_request *ireq,
 500        struct scu_task_context *task_context)
 501{
 502        dma_addr_t dma_addr;
 503        struct isci_remote_device *idev;
 504        struct isci_port *iport;
 505
 506        idev = ireq->target_device;
 507        iport = idev->owning_port;
 508
 509        /* Fill in the TC with the its required data */
 510        task_context->abort = 0;
 511        task_context->priority = SCU_TASK_PRIORITY_NORMAL;
 512        task_context->initiator_request = 1;
 513        task_context->connection_rate = idev->connection_rate;
 514        task_context->protocol_engine_index = ISCI_PEG;
 515        task_context->logical_port_index = iport->physical_port_index;
 516        task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_STP;
 517        task_context->valid = SCU_TASK_CONTEXT_VALID;
 518        task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 519
 520        task_context->remote_node_index = idev->rnc.remote_node_index;
 521        task_context->command_code = 0;
 522
 523        task_context->link_layer_control = 0;
 524        task_context->do_not_dma_ssp_good_response = 1;
 525        task_context->strict_ordering = 0;
 526        task_context->control_frame = 0;
 527        task_context->timeout_enable = 0;
 528        task_context->block_guard_enable = 0;
 529
 530        task_context->address_modifier = 0;
 531        task_context->task_phase = 0x01;
 532
 533        task_context->ssp_command_iu_length =
 534                (sizeof(struct host_to_dev_fis) - sizeof(u32)) / sizeof(u32);
 535
 536        /* Set the first word of the H2D REG FIS */
 537        task_context->type.words[0] = *(u32 *)&ireq->stp.cmd;
 538
 539        ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 540                              (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 541                              (iport->physical_port_index <<
 542                               SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 543                              ISCI_TAG_TCI(ireq->io_tag));
 544        /*
 545         * Copy the physical address for the command buffer to the SCU Task
 546         * Context. We must offset the command buffer by 4 bytes because the
 547         * first 4 bytes are transfered in the body of the TC.
 548         */
 549        dma_addr = sci_io_request_get_dma_addr(ireq,
 550                                                ((char *) &ireq->stp.cmd) +
 551                                                sizeof(u32));
 552
 553        task_context->command_iu_upper = upper_32_bits(dma_addr);
 554        task_context->command_iu_lower = lower_32_bits(dma_addr);
 555
 556        /* SATA Requests do not have a response buffer */
 557        task_context->response_iu_upper = 0;
 558        task_context->response_iu_lower = 0;
 559}
 560
 561static void scu_stp_raw_request_construct_task_context(struct isci_request *ireq)
 562{
 563        struct scu_task_context *task_context = ireq->tc;
 564
 565        scu_sata_reqeust_construct_task_context(ireq, task_context);
 566
 567        task_context->control_frame         = 0;
 568        task_context->priority              = SCU_TASK_PRIORITY_NORMAL;
 569        task_context->task_type             = SCU_TASK_TYPE_SATA_RAW_FRAME;
 570        task_context->type.stp.fis_type     = FIS_REGH2D;
 571        task_context->transfer_length_bytes = sizeof(struct host_to_dev_fis) - sizeof(u32);
 572}
 573
 574static enum sci_status sci_stp_pio_request_construct(struct isci_request *ireq,
 575                                                          bool copy_rx_frame)
 576{
 577        struct isci_stp_request *stp_req = &ireq->stp.req;
 578
 579        scu_stp_raw_request_construct_task_context(ireq);
 580
 581        stp_req->status = 0;
 582        stp_req->sgl.offset = 0;
 583        stp_req->sgl.set = SCU_SGL_ELEMENT_PAIR_A;
 584
 585        if (copy_rx_frame) {
 586                sci_request_build_sgl(ireq);
 587                stp_req->sgl.index = 0;
 588        } else {
 589                /* The user does not want the data copied to the SGL buffer location */
 590                stp_req->sgl.index = -1;
 591        }
 592
 593        return SCI_SUCCESS;
 594}
 595
 596/**
 597 *
 598 * @sci_req: This parameter specifies the request to be constructed as an
 599 *    optimized request.
 600 * @optimized_task_type: This parameter specifies whether the request is to be
 601 *    an UDMA request or a NCQ request. - A value of 0 indicates UDMA. - A
 602 *    value of 1 indicates NCQ.
 603 *
 604 * This method will perform request construction common to all types of STP
 605 * requests that are optimized by the silicon (i.e. UDMA, NCQ). This method
 606 * returns an indication as to whether the construction was successful.
 607 */
 608static void sci_stp_optimized_request_construct(struct isci_request *ireq,
 609                                                     u8 optimized_task_type,
 610                                                     u32 len,
 611                                                     enum dma_data_direction dir)
 612{
 613        struct scu_task_context *task_context = ireq->tc;
 614
 615        /* Build the STP task context structure */
 616        scu_sata_reqeust_construct_task_context(ireq, task_context);
 617
 618        /* Copy over the SGL elements */
 619        sci_request_build_sgl(ireq);
 620
 621        /* Copy over the number of bytes to be transfered */
 622        task_context->transfer_length_bytes = len;
 623
 624        if (dir == DMA_TO_DEVICE) {
 625                /*
 626                 * The difference between the DMA IN and DMA OUT request task type
 627                 * values are consistent with the difference between FPDMA READ
 628                 * and FPDMA WRITE values.  Add the supplied task type parameter
 629                 * to this difference to set the task type properly for this
 630                 * DATA OUT (WRITE) case. */
 631                task_context->task_type = optimized_task_type + (SCU_TASK_TYPE_DMA_OUT
 632                                                                 - SCU_TASK_TYPE_DMA_IN);
 633        } else {
 634                /*
 635                 * For the DATA IN (READ) case, simply save the supplied
 636                 * optimized task type. */
 637                task_context->task_type = optimized_task_type;
 638        }
 639}
 640
 641static void sci_atapi_construct(struct isci_request *ireq)
 642{
 643        struct host_to_dev_fis *h2d_fis = &ireq->stp.cmd;
 644        struct sas_task *task;
 645
 646        /* To simplify the implementation we take advantage of the
 647         * silicon's partial acceleration of atapi protocol (dma data
 648         * transfers), so we promote all commands to dma protocol.  This
 649         * breaks compatibility with ATA_HORKAGE_ATAPI_MOD16_DMA drives.
 650         */
 651        h2d_fis->features |= ATAPI_PKT_DMA;
 652
 653        scu_stp_raw_request_construct_task_context(ireq);
 654
 655        task = isci_request_access_task(ireq);
 656        if (task->data_dir == DMA_NONE)
 657                task->total_xfer_len = 0;
 658
 659        /* clear the response so we can detect arrivial of an
 660         * unsolicited h2d fis
 661         */
 662        ireq->stp.rsp.fis_type = 0;
 663}
 664
 665static enum sci_status
 666sci_io_request_construct_sata(struct isci_request *ireq,
 667                               u32 len,
 668                               enum dma_data_direction dir,
 669                               bool copy)
 670{
 671        enum sci_status status = SCI_SUCCESS;
 672        struct sas_task *task = isci_request_access_task(ireq);
 673        struct domain_device *dev = ireq->target_device->domain_dev;
 674
 675        /* check for management protocols */
 676        if (test_bit(IREQ_TMF, &ireq->flags)) {
 677                struct isci_tmf *tmf = isci_request_access_tmf(ireq);
 678
 679                dev_err(&ireq->owning_controller->pdev->dev,
 680                        "%s: Request 0x%p received un-handled SAT "
 681                        "management protocol 0x%x.\n",
 682                        __func__, ireq, tmf->tmf_code);
 683
 684                return SCI_FAILURE;
 685        }
 686
 687        if (!sas_protocol_ata(task->task_proto)) {
 688                dev_err(&ireq->owning_controller->pdev->dev,
 689                        "%s: Non-ATA protocol in SATA path: 0x%x\n",
 690                        __func__,
 691                        task->task_proto);
 692                return SCI_FAILURE;
 693
 694        }
 695
 696        /* ATAPI */
 697        if (dev->sata_dev.class == ATA_DEV_ATAPI &&
 698            task->ata_task.fis.command == ATA_CMD_PACKET) {
 699                sci_atapi_construct(ireq);
 700                return SCI_SUCCESS;
 701        }
 702
 703        /* non data */
 704        if (task->data_dir == DMA_NONE) {
 705                scu_stp_raw_request_construct_task_context(ireq);
 706                return SCI_SUCCESS;
 707        }
 708
 709        /* NCQ */
 710        if (task->ata_task.use_ncq) {
 711                sci_stp_optimized_request_construct(ireq,
 712                                                         SCU_TASK_TYPE_FPDMAQ_READ,
 713                                                         len, dir);
 714                return SCI_SUCCESS;
 715        }
 716
 717        /* DMA */
 718        if (task->ata_task.dma_xfer) {
 719                sci_stp_optimized_request_construct(ireq,
 720                                                         SCU_TASK_TYPE_DMA_IN,
 721                                                         len, dir);
 722                return SCI_SUCCESS;
 723        } else /* PIO */
 724                return sci_stp_pio_request_construct(ireq, copy);
 725
 726        return status;
 727}
 728
 729static enum sci_status sci_io_request_construct_basic_ssp(struct isci_request *ireq)
 730{
 731        struct sas_task *task = isci_request_access_task(ireq);
 732
 733        ireq->protocol = SAS_PROTOCOL_SSP;
 734
 735        scu_ssp_io_request_construct_task_context(ireq,
 736                                                  task->data_dir,
 737                                                  task->total_xfer_len);
 738
 739        sci_io_request_build_ssp_command_iu(ireq);
 740
 741        sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 742
 743        return SCI_SUCCESS;
 744}
 745
 746enum sci_status sci_task_request_construct_ssp(
 747        struct isci_request *ireq)
 748{
 749        /* Construct the SSP Task SCU Task Context */
 750        scu_ssp_task_request_construct_task_context(ireq);
 751
 752        /* Fill in the SSP Task IU */
 753        sci_task_request_build_ssp_task_iu(ireq);
 754
 755        sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 756
 757        return SCI_SUCCESS;
 758}
 759
 760static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *ireq)
 761{
 762        enum sci_status status;
 763        bool copy = false;
 764        struct sas_task *task = isci_request_access_task(ireq);
 765
 766        ireq->protocol = SAS_PROTOCOL_STP;
 767
 768        copy = (task->data_dir == DMA_NONE) ? false : true;
 769
 770        status = sci_io_request_construct_sata(ireq,
 771                                                task->total_xfer_len,
 772                                                task->data_dir,
 773                                                copy);
 774
 775        if (status == SCI_SUCCESS)
 776                sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 777
 778        return status;
 779}
 780
 781/**
 782 * sci_req_tx_bytes - bytes transferred when reply underruns request
 783 * @ireq: request that was terminated early
 784 */
 785#define SCU_TASK_CONTEXT_SRAM 0x200000
 786static u32 sci_req_tx_bytes(struct isci_request *ireq)
 787{
 788        struct isci_host *ihost = ireq->owning_controller;
 789        u32 ret_val = 0;
 790
 791        if (readl(&ihost->smu_registers->address_modifier) == 0) {
 792                void __iomem *scu_reg_base = ihost->scu_registers;
 793
 794                /* get the bytes of data from the Address == BAR1 + 20002Ch + (256*TCi) where
 795                 *   BAR1 is the scu_registers
 796                 *   0x20002C = 0x200000 + 0x2c
 797                 *            = start of task context SRAM + offset of (type.ssp.data_offset)
 798                 *   TCi is the io_tag of struct sci_request
 799                 */
 800                ret_val = readl(scu_reg_base +
 801                                (SCU_TASK_CONTEXT_SRAM + offsetof(struct scu_task_context, type.ssp.data_offset)) +
 802                                ((sizeof(struct scu_task_context)) * ISCI_TAG_TCI(ireq->io_tag)));
 803        }
 804
 805        return ret_val;
 806}
 807
 808enum sci_status sci_request_start(struct isci_request *ireq)
 809{
 810        enum sci_base_request_states state;
 811        struct scu_task_context *tc = ireq->tc;
 812        struct isci_host *ihost = ireq->owning_controller;
 813
 814        state = ireq->sm.current_state_id;
 815        if (state != SCI_REQ_CONSTRUCTED) {
 816                dev_warn(&ihost->pdev->dev,
 817                        "%s: SCIC IO Request requested to start while in wrong "
 818                         "state %d\n", __func__, state);
 819                return SCI_FAILURE_INVALID_STATE;
 820        }
 821
 822        tc->task_index = ISCI_TAG_TCI(ireq->io_tag);
 823
 824        switch (tc->protocol_type) {
 825        case SCU_TASK_CONTEXT_PROTOCOL_SMP:
 826        case SCU_TASK_CONTEXT_PROTOCOL_SSP:
 827                /* SSP/SMP Frame */
 828                tc->type.ssp.tag = ireq->io_tag;
 829                tc->type.ssp.target_port_transfer_tag = 0xFFFF;
 830                break;
 831
 832        case SCU_TASK_CONTEXT_PROTOCOL_STP:
 833                /* STP/SATA Frame
 834                 * tc->type.stp.ncq_tag = ireq->ncq_tag;
 835                 */
 836                break;
 837
 838        case SCU_TASK_CONTEXT_PROTOCOL_NONE:
 839                /* / @todo When do we set no protocol type? */
 840                break;
 841
 842        default:
 843                /* This should never happen since we build the IO
 844                 * requests */
 845                break;
 846        }
 847
 848        /* Add to the post_context the io tag value */
 849        ireq->post_context |= ISCI_TAG_TCI(ireq->io_tag);
 850
 851        /* Everything is good go ahead and change state */
 852        sci_change_state(&ireq->sm, SCI_REQ_STARTED);
 853
 854        return SCI_SUCCESS;
 855}
 856
 857enum sci_status
 858sci_io_request_terminate(struct isci_request *ireq)
 859{
 860        enum sci_base_request_states state;
 861
 862        state = ireq->sm.current_state_id;
 863
 864        switch (state) {
 865        case SCI_REQ_CONSTRUCTED:
 866                /* Set to make sure no HW terminate posting is done: */
 867                set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
 868                ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
 869                ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
 870                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 871                return SCI_SUCCESS;
 872        case SCI_REQ_STARTED:
 873        case SCI_REQ_TASK_WAIT_TC_COMP:
 874        case SCI_REQ_SMP_WAIT_RESP:
 875        case SCI_REQ_SMP_WAIT_TC_COMP:
 876        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
 877        case SCI_REQ_STP_UDMA_WAIT_D2H:
 878        case SCI_REQ_STP_NON_DATA_WAIT_H2D:
 879        case SCI_REQ_STP_NON_DATA_WAIT_D2H:
 880        case SCI_REQ_STP_PIO_WAIT_H2D:
 881        case SCI_REQ_STP_PIO_WAIT_FRAME:
 882        case SCI_REQ_STP_PIO_DATA_IN:
 883        case SCI_REQ_STP_PIO_DATA_OUT:
 884        case SCI_REQ_ATAPI_WAIT_H2D:
 885        case SCI_REQ_ATAPI_WAIT_PIO_SETUP:
 886        case SCI_REQ_ATAPI_WAIT_D2H:
 887        case SCI_REQ_ATAPI_WAIT_TC_COMP:
 888                /* Fall through and change state to ABORTING... */
 889        case SCI_REQ_TASK_WAIT_TC_RESP:
 890                /* The task frame was already confirmed to have been
 891                 * sent by the SCU HW.  Since the state machine is
 892                 * now only waiting for the task response itself,
 893                 * abort the request and complete it immediately
 894                 * and don't wait for the task response.
 895                 */
 896                sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
 897                /* Fall through and handle like ABORTING... */
 898        case SCI_REQ_ABORTING:
 899                if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
 900                        set_bit(IREQ_PENDING_ABORT, &ireq->flags);
 901                else
 902                        clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
 903                /* If the request is only waiting on the remote device
 904                 * suspension, return SUCCESS so the caller will wait too.
 905                 */
 906                return SCI_SUCCESS;
 907        case SCI_REQ_COMPLETED:
 908        default:
 909                dev_warn(&ireq->owning_controller->pdev->dev,
 910                         "%s: SCIC IO Request requested to abort while in wrong "
 911                         "state %d\n", __func__, ireq->sm.current_state_id);
 912                break;
 913        }
 914
 915        return SCI_FAILURE_INVALID_STATE;
 916}
 917
 918enum sci_status sci_request_complete(struct isci_request *ireq)
 919{
 920        enum sci_base_request_states state;
 921        struct isci_host *ihost = ireq->owning_controller;
 922
 923        state = ireq->sm.current_state_id;
 924        if (WARN_ONCE(state != SCI_REQ_COMPLETED,
 925                      "isci: request completion from wrong state (%s)\n",
 926                      req_state_name(state)))
 927                return SCI_FAILURE_INVALID_STATE;
 928
 929        if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
 930                sci_controller_release_frame(ihost,
 931                                                  ireq->saved_rx_frame_index);
 932
 933        /* XXX can we just stop the machine and remove the 'final' state? */
 934        sci_change_state(&ireq->sm, SCI_REQ_FINAL);
 935        return SCI_SUCCESS;
 936}
 937
 938enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
 939                                                  u32 event_code)
 940{
 941        enum sci_base_request_states state;
 942        struct isci_host *ihost = ireq->owning_controller;
 943
 944        state = ireq->sm.current_state_id;
 945
 946        if (state != SCI_REQ_STP_PIO_DATA_IN) {
 947                dev_warn(&ihost->pdev->dev, "%s: (%x) in wrong state %s\n",
 948                         __func__, event_code, req_state_name(state));
 949
 950                return SCI_FAILURE_INVALID_STATE;
 951        }
 952
 953        switch (scu_get_event_specifier(event_code)) {
 954        case SCU_TASK_DONE_CRC_ERR << SCU_EVENT_SPECIFIC_CODE_SHIFT:
 955                /* We are waiting for data and the SCU has R_ERR the data frame.
 956                 * Go back to waiting for the D2H Register FIS
 957                 */
 958                sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 959                return SCI_SUCCESS;
 960        default:
 961                dev_err(&ihost->pdev->dev,
 962                        "%s: pio request unexpected event %#x\n",
 963                        __func__, event_code);
 964
 965                /* TODO Should we fail the PIO request when we get an
 966                 * unexpected event?
 967                 */
 968                return SCI_FAILURE;
 969        }
 970}
 971
 972/*
 973 * This function copies response data for requests returning response data
 974 *    instead of sense data.
 975 * @sci_req: This parameter specifies the request object for which to copy
 976 *    the response data.
 977 */
 978static void sci_io_request_copy_response(struct isci_request *ireq)
 979{
 980        void *resp_buf;
 981        u32 len;
 982        struct ssp_response_iu *ssp_response;
 983        struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
 984
 985        ssp_response = &ireq->ssp.rsp;
 986
 987        resp_buf = &isci_tmf->resp.resp_iu;
 988
 989        len = min_t(u32,
 990                    SSP_RESP_IU_MAX_SIZE,
 991                    be32_to_cpu(ssp_response->response_data_len));
 992
 993        memcpy(resp_buf, ssp_response->resp_data, len);
 994}
 995
 996static enum sci_status
 997request_started_state_tc_event(struct isci_request *ireq,
 998                               u32 completion_code)
 999{
1000        struct ssp_response_iu *resp_iu;
1001        u8 datapres;
1002
1003        /* TODO: Any SDMA return code of other than 0 is bad decode 0x003C0000
1004         * to determine SDMA status
1005         */
1006        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1007        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1008                ireq->scu_status = SCU_TASK_DONE_GOOD;
1009                ireq->sci_status = SCI_SUCCESS;
1010                break;
1011        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EARLY_RESP): {
1012                /* There are times when the SCU hardware will return an early
1013                 * response because the io request specified more data than is
1014                 * returned by the target device (mode pages, inquiry data,
1015                 * etc.).  We must check the response stats to see if this is
1016                 * truly a failed request or a good request that just got
1017                 * completed early.
1018                 */
1019                struct ssp_response_iu *resp = &ireq->ssp.rsp;
1020                ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
1021
1022                sci_swab32_cpy(&ireq->ssp.rsp,
1023                               &ireq->ssp.rsp,
1024                               word_cnt);
1025
1026                if (resp->status == 0) {
1027                        ireq->scu_status = SCU_TASK_DONE_GOOD;
1028                        ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
1029                } else {
1030                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1031                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1032                }
1033                break;
1034        }
1035        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE): {
1036                ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
1037
1038                sci_swab32_cpy(&ireq->ssp.rsp,
1039                               &ireq->ssp.rsp,
1040                               word_cnt);
1041
1042                ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1043                ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1044                break;
1045        }
1046
1047        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RESP_LEN_ERR):
1048                /* TODO With TASK_DONE_RESP_LEN_ERR is the response frame
1049                 * guaranteed to be received before this completion status is
1050                 * posted?
1051                 */
1052                resp_iu = &ireq->ssp.rsp;
1053                datapres = resp_iu->datapres;
1054
1055                if (datapres == 1 || datapres == 2) {
1056                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1057                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1058                } else {
1059                        ireq->scu_status = SCU_TASK_DONE_GOOD;
1060                        ireq->sci_status = SCI_SUCCESS;
1061                }
1062                break;
1063        /* only stp device gets suspended. */
1064        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
1065        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_PERR):
1066        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_ERR):
1067        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_DATA_LEN_ERR):
1068        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_ABORT_ERR):
1069        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_WD_LEN):
1070        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
1071        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_RESP):
1072        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
1073        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
1074        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
1075                if (ireq->protocol == SAS_PROTOCOL_STP) {
1076                        ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1077                                           SCU_COMPLETION_TL_STATUS_SHIFT;
1078                        ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1079                } else {
1080                        ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1081                                           SCU_COMPLETION_TL_STATUS_SHIFT;
1082                        ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1083                }
1084                break;
1085
1086        /* both stp/ssp device gets suspended */
1087        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LF_ERR):
1088        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_WRONG_DESTINATION):
1089        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1):
1090        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2):
1091        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3):
1092        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_BAD_DESTINATION):
1093        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_ZONE_VIOLATION):
1094        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY):
1095        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED):
1096        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED):
1097                ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1098                                   SCU_COMPLETION_TL_STATUS_SHIFT;
1099                ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
1100                break;
1101
1102        /* neither ssp nor stp gets suspended. */
1103        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_CMD_ERR):
1104        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_XR):
1105        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_IU_LEN_ERR):
1106        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDMA_ERR):
1107        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OFFSET_ERR):
1108        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EXCESS_DATA):
1109        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
1110        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
1111        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
1112        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
1113        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_DATA):
1114        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OPEN_FAIL):
1115        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_VIIT_ENTRY_NV):
1116        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_IIT_ENTRY_NV):
1117        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND):
1118        default:
1119                ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1120                                   SCU_COMPLETION_TL_STATUS_SHIFT;
1121                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1122                break;
1123        }
1124
1125        /*
1126         * TODO: This is probably wrong for ACK/NAK timeout conditions
1127         */
1128
1129        /* In all cases we will treat this as the completion of the IO req. */
1130        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1131        return SCI_SUCCESS;
1132}
1133
1134static enum sci_status
1135request_aborting_state_tc_event(struct isci_request *ireq,
1136                                u32 completion_code)
1137{
1138        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1139        case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
1140        case (SCU_TASK_DONE_TASK_ABORT << SCU_COMPLETION_TL_STATUS_SHIFT):
1141                ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
1142                ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
1143                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1144                break;
1145
1146        default:
1147                /* Unless we get some strange error wait for the task abort to complete
1148                 * TODO: Should there be a state change for this completion?
1149                 */
1150                break;
1151        }
1152
1153        return SCI_SUCCESS;
1154}
1155
1156static enum sci_status ssp_task_request_await_tc_event(struct isci_request *ireq,
1157                                                       u32 completion_code)
1158{
1159        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1160        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1161                ireq->scu_status = SCU_TASK_DONE_GOOD;
1162                ireq->sci_status = SCI_SUCCESS;
1163                sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1164                break;
1165        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
1166                /* Currently, the decision is to simply allow the task request
1167                 * to timeout if the task IU wasn't received successfully.
1168                 * There is a potential for receiving multiple task responses if
1169                 * we decide to send the task IU again.
1170                 */
1171                dev_warn(&ireq->owning_controller->pdev->dev,
1172                         "%s: TaskRequest:0x%p CompletionCode:%x - "
1173                         "ACK/NAK timeout\n", __func__, ireq,
1174                         completion_code);
1175
1176                sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
1177                break;
1178        default:
1179                /*
1180                 * All other completion status cause the IO to be complete.
1181                 * If a NAK was received, then it is up to the user to retry
1182                 * the request.
1183                 */
1184                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1185                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1186                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1187                break;
1188        }
1189
1190        return SCI_SUCCESS;
1191}
1192
1193static enum sci_status
1194smp_request_await_response_tc_event(struct isci_request *ireq,
1195                                    u32 completion_code)
1196{
1197        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1198        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1199                /* In the AWAIT RESPONSE state, any TC completion is
1200                 * unexpected.  but if the TC has success status, we
1201                 * complete the IO anyway.
1202                 */
1203                ireq->scu_status = SCU_TASK_DONE_GOOD;
1204                ireq->sci_status = SCI_SUCCESS;
1205                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1206                break;
1207        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
1208        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
1209        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
1210        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
1211                /* These status has been seen in a specific LSI
1212                 * expander, which sometimes is not able to send smp
1213                 * response within 2 ms. This causes our hardware break
1214                 * the connection and set TC completion with one of
1215                 * these SMP_XXX_XX_ERR status. For these type of error,
1216                 * we ask ihost user to retry the request.
1217                 */
1218                ireq->scu_status = SCU_TASK_DONE_SMP_RESP_TO_ERR;
1219                ireq->sci_status = SCI_FAILURE_RETRY_REQUIRED;
1220                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1221                break;
1222        default:
1223                /* All other completion status cause the IO to be complete.  If a NAK
1224                 * was received, then it is up to the user to retry the request
1225                 */
1226                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1227                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1228                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1229                break;
1230        }
1231
1232        return SCI_SUCCESS;
1233}
1234
1235static enum sci_status
1236smp_request_await_tc_event(struct isci_request *ireq,
1237                           u32 completion_code)
1238{
1239        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1240        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1241                ireq->scu_status = SCU_TASK_DONE_GOOD;
1242                ireq->sci_status = SCI_SUCCESS;
1243                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1244                break;
1245        default:
1246                /* All other completion status cause the IO to be
1247                 * complete.  If a NAK was received, then it is up to
1248                 * the user to retry the request.
1249                 */
1250                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1251                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1252                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1253                break;
1254        }
1255
1256        return SCI_SUCCESS;
1257}
1258
1259static struct scu_sgl_element *pio_sgl_next(struct isci_stp_request *stp_req)
1260{
1261        struct scu_sgl_element *sgl;
1262        struct scu_sgl_element_pair *sgl_pair;
1263        struct isci_request *ireq = to_ireq(stp_req);
1264        struct isci_stp_pio_sgl *pio_sgl = &stp_req->sgl;
1265
1266        sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1267        if (!sgl_pair)
1268                sgl = NULL;
1269        else if (pio_sgl->set == SCU_SGL_ELEMENT_PAIR_A) {
1270                if (sgl_pair->B.address_lower == 0 &&
1271                    sgl_pair->B.address_upper == 0) {
1272                        sgl = NULL;
1273                } else {
1274                        pio_sgl->set = SCU_SGL_ELEMENT_PAIR_B;
1275                        sgl = &sgl_pair->B;
1276                }
1277        } else {
1278                if (sgl_pair->next_pair_lower == 0 &&
1279                    sgl_pair->next_pair_upper == 0) {
1280                        sgl = NULL;
1281                } else {
1282                        pio_sgl->index++;
1283                        pio_sgl->set = SCU_SGL_ELEMENT_PAIR_A;
1284                        sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
1285                        sgl = &sgl_pair->A;
1286                }
1287        }
1288
1289        return sgl;
1290}
1291
1292static enum sci_status
1293stp_request_non_data_await_h2d_tc_event(struct isci_request *ireq,
1294                                        u32 completion_code)
1295{
1296        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1297        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1298                ireq->scu_status = SCU_TASK_DONE_GOOD;
1299                ireq->sci_status = SCI_SUCCESS;
1300                sci_change_state(&ireq->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
1301                break;
1302
1303        default:
1304                /* All other completion status cause the IO to be
1305                 * complete.  If a NAK was received, then it is up to
1306                 * the user to retry the request.
1307                 */
1308                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1309                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1310                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1311                break;
1312        }
1313
1314        return SCI_SUCCESS;
1315}
1316
1317#define SCU_MAX_FRAME_BUFFER_SIZE  0x400  /* 1K is the maximum SCU frame data payload */
1318
1319/* transmit DATA_FIS from (current sgl + offset) for input
1320 * parameter length. current sgl and offset is alreay stored in the IO request
1321 */
1322static enum sci_status sci_stp_request_pio_data_out_trasmit_data_frame(
1323        struct isci_request *ireq,
1324        u32 length)
1325{
1326        struct isci_stp_request *stp_req = &ireq->stp.req;
1327        struct scu_task_context *task_context = ireq->tc;
1328        struct scu_sgl_element_pair *sgl_pair;
1329        struct scu_sgl_element *current_sgl;
1330
1331        /* Recycle the TC and reconstruct it for sending out DATA FIS containing
1332         * for the data from current_sgl+offset for the input length
1333         */
1334        sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1335        if (stp_req->sgl.set == SCU_SGL_ELEMENT_PAIR_A)
1336                current_sgl = &sgl_pair->A;
1337        else
1338                current_sgl = &sgl_pair->B;
1339
1340        /* update the TC */
1341        task_context->command_iu_upper = current_sgl->address_upper;
1342        task_context->command_iu_lower = current_sgl->address_lower;
1343        task_context->transfer_length_bytes = length;
1344        task_context->type.stp.fis_type = FIS_DATA;
1345
1346        /* send the new TC out. */
1347        return sci_controller_continue_io(ireq);
1348}
1349
1350static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_request *ireq)
1351{
1352        struct isci_stp_request *stp_req = &ireq->stp.req;
1353        struct scu_sgl_element_pair *sgl_pair;
1354        enum sci_status status = SCI_SUCCESS;
1355        struct scu_sgl_element *sgl;
1356        u32 offset;
1357        u32 len = 0;
1358
1359        offset = stp_req->sgl.offset;
1360        sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
1361        if (WARN_ONCE(!sgl_pair, "%s: null sgl element", __func__))
1362                return SCI_FAILURE;
1363
1364        if (stp_req->sgl.set == SCU_SGL_ELEMENT_PAIR_A) {
1365                sgl = &sgl_pair->A;
1366                len = sgl_pair->A.length - offset;
1367        } else {
1368                sgl = &sgl_pair->B;
1369                len = sgl_pair->B.length - offset;
1370        }
1371
1372        if (stp_req->pio_len == 0)
1373                return SCI_SUCCESS;
1374
1375        if (stp_req->pio_len >= len) {
1376                status = sci_stp_request_pio_data_out_trasmit_data_frame(ireq, len);
1377                if (status != SCI_SUCCESS)
1378                        return status;
1379                stp_req->pio_len -= len;
1380
1381                /* update the current sgl, offset and save for future */
1382                sgl = pio_sgl_next(stp_req);
1383                offset = 0;
1384        } else if (stp_req->pio_len < len) {
1385                sci_stp_request_pio_data_out_trasmit_data_frame(ireq, stp_req->pio_len);
1386
1387                /* Sgl offset will be adjusted and saved for future */
1388                offset += stp_req->pio_len;
1389                sgl->address_lower += stp_req->pio_len;
1390                stp_req->pio_len = 0;
1391        }
1392
1393        stp_req->sgl.offset = offset;
1394
1395        return status;
1396}
1397
1398/**
1399 *
1400 * @stp_request: The request that is used for the SGL processing.
1401 * @data_buffer: The buffer of data to be copied.
1402 * @length: The length of the data transfer.
1403 *
1404 * Copy the data from the buffer for the length specified to the IO reqeust SGL
1405 * specified data region. enum sci_status
1406 */
1407static enum sci_status
1408sci_stp_request_pio_data_in_copy_data_buffer(struct isci_stp_request *stp_req,
1409                                             u8 *data_buf, u32 len)
1410{
1411        struct isci_request *ireq;
1412        u8 *src_addr;
1413        int copy_len;
1414        struct sas_task *task;
1415        struct scatterlist *sg;
1416        void *kaddr;
1417        int total_len = len;
1418
1419        ireq = to_ireq(stp_req);
1420        task = isci_request_access_task(ireq);
1421        src_addr = data_buf;
1422
1423        if (task->num_scatter > 0) {
1424                sg = task->scatter;
1425
1426                while (total_len > 0) {
1427                        struct page *page = sg_page(sg);
1428
1429                        copy_len = min_t(int, total_len, sg_dma_len(sg));
1430                        kaddr = kmap_atomic(page);
1431                        memcpy(kaddr + sg->offset, src_addr, copy_len);
1432                        kunmap_atomic(kaddr);
1433                        total_len -= copy_len;
1434                        src_addr += copy_len;
1435                        sg = sg_next(sg);
1436                }
1437        } else {
1438                BUG_ON(task->total_xfer_len < total_len);
1439                memcpy(task->scatter, src_addr, total_len);
1440        }
1441
1442        return SCI_SUCCESS;
1443}
1444
1445/**
1446 *
1447 * @sci_req: The PIO DATA IN request that is to receive the data.
1448 * @data_buffer: The buffer to copy from.
1449 *
1450 * Copy the data buffer to the io request data region. enum sci_status
1451 */
1452static enum sci_status sci_stp_request_pio_data_in_copy_data(
1453        struct isci_stp_request *stp_req,
1454        u8 *data_buffer)
1455{
1456        enum sci_status status;
1457
1458        /*
1459         * If there is less than 1K remaining in the transfer request
1460         * copy just the data for the transfer */
1461        if (stp_req->pio_len < SCU_MAX_FRAME_BUFFER_SIZE) {
1462                status = sci_stp_request_pio_data_in_copy_data_buffer(
1463                        stp_req, data_buffer, stp_req->pio_len);
1464
1465                if (status == SCI_SUCCESS)
1466                        stp_req->pio_len = 0;
1467        } else {
1468                /* We are transfering the whole frame so copy */
1469                status = sci_stp_request_pio_data_in_copy_data_buffer(
1470                        stp_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
1471
1472                if (status == SCI_SUCCESS)
1473                        stp_req->pio_len -= SCU_MAX_FRAME_BUFFER_SIZE;
1474        }
1475
1476        return status;
1477}
1478
1479static enum sci_status
1480stp_request_pio_await_h2d_completion_tc_event(struct isci_request *ireq,
1481                                              u32 completion_code)
1482{
1483        enum sci_status status = SCI_SUCCESS;
1484
1485        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1486        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1487                ireq->scu_status = SCU_TASK_DONE_GOOD;
1488                ireq->sci_status = SCI_SUCCESS;
1489                sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1490                break;
1491
1492        default:
1493                /* All other completion status cause the IO to be
1494                 * complete.  If a NAK was received, then it is up to
1495                 * the user to retry the request.
1496                 */
1497                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1498                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1499                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1500                break;
1501        }
1502
1503        return status;
1504}
1505
1506static enum sci_status
1507pio_data_out_tx_done_tc_event(struct isci_request *ireq,
1508                              u32 completion_code)
1509{
1510        enum sci_status status = SCI_SUCCESS;
1511        bool all_frames_transferred = false;
1512        struct isci_stp_request *stp_req = &ireq->stp.req;
1513
1514        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1515        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1516                /* Transmit data */
1517                if (stp_req->pio_len != 0) {
1518                        status = sci_stp_request_pio_data_out_transmit_data(ireq);
1519                        if (status == SCI_SUCCESS) {
1520                                if (stp_req->pio_len == 0)
1521                                        all_frames_transferred = true;
1522                        }
1523                } else if (stp_req->pio_len == 0) {
1524                        /*
1525                         * this will happen if the all data is written at the
1526                         * first time after the pio setup fis is received
1527                         */
1528                        all_frames_transferred  = true;
1529                }
1530
1531                /* all data transferred. */
1532                if (all_frames_transferred) {
1533                        /*
1534                         * Change the state to SCI_REQ_STP_PIO_DATA_IN
1535                         * and wait for PIO_SETUP fis / or D2H REg fis. */
1536                        sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1537                }
1538                break;
1539
1540        default:
1541                /*
1542                 * All other completion status cause the IO to be complete.
1543                 * If a NAK was received, then it is up to the user to retry
1544                 * the request.
1545                 */
1546                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
1547                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1548                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1549                break;
1550        }
1551
1552        return status;
1553}
1554
1555static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_request *ireq,
1556                                                                       u32 frame_index)
1557{
1558        struct isci_host *ihost = ireq->owning_controller;
1559        struct dev_to_host_fis *frame_header;
1560        enum sci_status status;
1561        u32 *frame_buffer;
1562
1563        status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1564                                                               frame_index,
1565                                                               (void **)&frame_header);
1566
1567        if ((status == SCI_SUCCESS) &&
1568            (frame_header->fis_type == FIS_REGD2H)) {
1569                sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1570                                                              frame_index,
1571                                                              (void **)&frame_buffer);
1572
1573                sci_controller_copy_sata_response(&ireq->stp.rsp,
1574                                                       frame_header,
1575                                                       frame_buffer);
1576        }
1577
1578        sci_controller_release_frame(ihost, frame_index);
1579
1580        return status;
1581}
1582
1583static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
1584                                               u32 frame_index)
1585{
1586        struct isci_host *ihost = ireq->owning_controller;
1587        enum sci_status status;
1588        struct dev_to_host_fis *frame_header;
1589        u32 *frame_buffer;
1590
1591        status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1592                                                          frame_index,
1593                                                          (void **)&frame_header);
1594
1595        if (status != SCI_SUCCESS)
1596                return status;
1597
1598        if (frame_header->fis_type != FIS_REGD2H) {
1599                dev_err(&ireq->isci_host->pdev->dev,
1600                        "%s ERROR: invalid fis type 0x%X\n",
1601                        __func__, frame_header->fis_type);
1602                return SCI_FAILURE;
1603        }
1604
1605        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1606                                                 frame_index,
1607                                                 (void **)&frame_buffer);
1608
1609        sci_controller_copy_sata_response(&ireq->stp.rsp,
1610                                          (u32 *)frame_header,
1611                                          frame_buffer);
1612
1613        /* Frame has been decoded return it to the controller */
1614        sci_controller_release_frame(ihost, frame_index);
1615
1616        return status;
1617}
1618
1619static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
1620                                                   u32 frame_index)
1621{
1622        struct sas_task *task = isci_request_access_task(ireq);
1623        enum sci_status status;
1624
1625        status = process_unsolicited_fis(ireq, frame_index);
1626
1627        if (status == SCI_SUCCESS) {
1628                if (ireq->stp.rsp.status & ATA_ERR)
1629                        status = SCI_IO_FAILURE_RESPONSE_VALID;
1630        } else {
1631                status = SCI_IO_FAILURE_RESPONSE_VALID;
1632        }
1633
1634        if (status != SCI_SUCCESS) {
1635                ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1636                ireq->sci_status = status;
1637        } else {
1638                ireq->scu_status = SCU_TASK_DONE_GOOD;
1639                ireq->sci_status = SCI_SUCCESS;
1640        }
1641
1642        /* the d2h ufi is the end of non-data commands */
1643        if (task->data_dir == DMA_NONE)
1644                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1645
1646        return status;
1647}
1648
1649static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
1650{
1651        struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1652        void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
1653        struct scu_task_context *task_context = ireq->tc;
1654
1655        /* fill in the SCU Task Context for a DATA fis containing CDB in Raw Frame
1656         * type. The TC for previous Packet fis was already there, we only need to
1657         * change the H2D fis content.
1658         */
1659        memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
1660        memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
1661        memset(&(task_context->type.stp), 0, sizeof(struct stp_task_context));
1662        task_context->type.stp.fis_type = FIS_DATA;
1663        task_context->transfer_length_bytes = dev->cdb_len;
1664}
1665
1666static void scu_atapi_construct_task_context(struct isci_request *ireq)
1667{
1668        struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
1669        struct sas_task *task = isci_request_access_task(ireq);
1670        struct scu_task_context *task_context = ireq->tc;
1671        int cdb_len = dev->cdb_len;
1672
1673        /* reference: SSTL 1.13.4.2
1674         * task_type, sata_direction
1675         */
1676        if (task->data_dir == DMA_TO_DEVICE) {
1677                task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
1678                task_context->sata_direction = 0;
1679        } else {
1680                /* todo: for NO_DATA command, we need to send out raw frame. */
1681                task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_IN;
1682                task_context->sata_direction = 1;
1683        }
1684
1685        memset(&task_context->type.stp, 0, sizeof(task_context->type.stp));
1686        task_context->type.stp.fis_type = FIS_DATA;
1687
1688        memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
1689        memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
1690        task_context->ssp_command_iu_length = cdb_len / sizeof(u32);
1691
1692        /* task phase is set to TX_CMD */
1693        task_context->task_phase = 0x1;
1694
1695        /* retry counter */
1696        task_context->stp_retry_count = 0;
1697
1698        /* data transfer size. */
1699        task_context->transfer_length_bytes = task->total_xfer_len;
1700
1701        /* setup sgl */
1702        sci_request_build_sgl(ireq);
1703}
1704
1705enum sci_status
1706sci_io_request_frame_handler(struct isci_request *ireq,
1707                                  u32 frame_index)
1708{
1709        struct isci_host *ihost = ireq->owning_controller;
1710        struct isci_stp_request *stp_req = &ireq->stp.req;
1711        enum sci_base_request_states state;
1712        enum sci_status status;
1713        ssize_t word_cnt;
1714
1715        state = ireq->sm.current_state_id;
1716        switch (state)  {
1717        case SCI_REQ_STARTED: {
1718                struct ssp_frame_hdr ssp_hdr;
1719                void *frame_header;
1720
1721                sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1722                                                              frame_index,
1723                                                              &frame_header);
1724
1725                word_cnt = sizeof(struct ssp_frame_hdr) / sizeof(u32);
1726                sci_swab32_cpy(&ssp_hdr, frame_header, word_cnt);
1727
1728                if (ssp_hdr.frame_type == SSP_RESPONSE) {
1729                        struct ssp_response_iu *resp_iu;
1730                        ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
1731
1732                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1733                                                                      frame_index,
1734                                                                      (void **)&resp_iu);
1735
1736                        sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);
1737
1738                        resp_iu = &ireq->ssp.rsp;
1739
1740                        if (resp_iu->datapres == 0x01 ||
1741                            resp_iu->datapres == 0x02) {
1742                                ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1743                                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1744                        } else {
1745                                ireq->scu_status = SCU_TASK_DONE_GOOD;
1746                                ireq->sci_status = SCI_SUCCESS;
1747                        }
1748                } else {
1749                        /* not a response frame, why did it get forwarded? */
1750                        dev_err(&ihost->pdev->dev,
1751                                "%s: SCIC IO Request 0x%p received unexpected "
1752                                "frame %d type 0x%02x\n", __func__, ireq,
1753                                frame_index, ssp_hdr.frame_type);
1754                }
1755
1756                /*
1757                 * In any case we are done with this frame buffer return it to
1758                 * the controller
1759                 */
1760                sci_controller_release_frame(ihost, frame_index);
1761
1762                return SCI_SUCCESS;
1763        }
1764
1765        case SCI_REQ_TASK_WAIT_TC_RESP:
1766                sci_io_request_copy_response(ireq);
1767                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1768                sci_controller_release_frame(ihost, frame_index);
1769                return SCI_SUCCESS;
1770
1771        case SCI_REQ_SMP_WAIT_RESP: {
1772                struct sas_task *task = isci_request_access_task(ireq);
1773                struct scatterlist *sg = &task->smp_task.smp_resp;
1774                void *frame_header, *kaddr;
1775                u8 *rsp;
1776
1777                sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1778                                                         frame_index,
1779                                                         &frame_header);
1780                kaddr = kmap_atomic(sg_page(sg));
1781                rsp = kaddr + sg->offset;
1782                sci_swab32_cpy(rsp, frame_header, 1);
1783
1784                if (rsp[0] == SMP_RESPONSE) {
1785                        void *smp_resp;
1786
1787                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1788                                                                 frame_index,
1789                                                                 &smp_resp);
1790
1791                        word_cnt = (sg->length/4)-1;
1792                        if (word_cnt > 0)
1793                                word_cnt = min_t(unsigned int, word_cnt,
1794                                                 SCU_UNSOLICITED_FRAME_BUFFER_SIZE/4);
1795                        sci_swab32_cpy(rsp + 4, smp_resp, word_cnt);
1796
1797                        ireq->scu_status = SCU_TASK_DONE_GOOD;
1798                        ireq->sci_status = SCI_SUCCESS;
1799                        sci_change_state(&ireq->sm, SCI_REQ_SMP_WAIT_TC_COMP);
1800                } else {
1801                        /*
1802                         * This was not a response frame why did it get
1803                         * forwarded?
1804                         */
1805                        dev_err(&ihost->pdev->dev,
1806                                "%s: SCIC SMP Request 0x%p received unexpected "
1807                                "frame %d type 0x%02x\n",
1808                                __func__,
1809                                ireq,
1810                                frame_index,
1811                                rsp[0]);
1812
1813                        ireq->scu_status = SCU_TASK_DONE_SMP_FRM_TYPE_ERR;
1814                        ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
1815                        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1816                }
1817                kunmap_atomic(kaddr);
1818
1819                sci_controller_release_frame(ihost, frame_index);
1820
1821                return SCI_SUCCESS;
1822        }
1823
1824        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
1825                return sci_stp_request_udma_general_frame_handler(ireq,
1826                                                                       frame_index);
1827
1828        case SCI_REQ_STP_UDMA_WAIT_D2H:
1829                /* Use the general frame handler to copy the resposne data */
1830                status = sci_stp_request_udma_general_frame_handler(ireq, frame_index);
1831
1832                if (status != SCI_SUCCESS)
1833                        return status;
1834
1835                ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1836                ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1837                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1838                return SCI_SUCCESS;
1839
1840        case SCI_REQ_STP_NON_DATA_WAIT_D2H: {
1841                struct dev_to_host_fis *frame_header;
1842                u32 *frame_buffer;
1843
1844                status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1845                                                                       frame_index,
1846                                                                       (void **)&frame_header);
1847
1848                if (status != SCI_SUCCESS) {
1849                        dev_err(&ihost->pdev->dev,
1850                                "%s: SCIC IO Request 0x%p could not get frame "
1851                                "header for frame index %d, status %x\n",
1852                                __func__,
1853                                stp_req,
1854                                frame_index,
1855                                status);
1856
1857                        return status;
1858                }
1859
1860                switch (frame_header->fis_type) {
1861                case FIS_REGD2H:
1862                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1863                                                                      frame_index,
1864                                                                      (void **)&frame_buffer);
1865
1866                        sci_controller_copy_sata_response(&ireq->stp.rsp,
1867                                                               frame_header,
1868                                                               frame_buffer);
1869
1870                        /* The command has completed with error */
1871                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1872                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1873                        break;
1874
1875                default:
1876                        dev_warn(&ihost->pdev->dev,
1877                                 "%s: IO Request:0x%p Frame Id:%d protocol "
1878                                  "violation occurred\n", __func__, stp_req,
1879                                  frame_index);
1880
1881                        ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
1882                        ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
1883                        break;
1884                }
1885
1886                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1887
1888                /* Frame has been decoded return it to the controller */
1889                sci_controller_release_frame(ihost, frame_index);
1890
1891                return status;
1892        }
1893
1894        case SCI_REQ_STP_PIO_WAIT_FRAME: {
1895                struct sas_task *task = isci_request_access_task(ireq);
1896                struct dev_to_host_fis *frame_header;
1897                u32 *frame_buffer;
1898
1899                status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
1900                                                                       frame_index,
1901                                                                       (void **)&frame_header);
1902
1903                if (status != SCI_SUCCESS) {
1904                        dev_err(&ihost->pdev->dev,
1905                                "%s: SCIC IO Request 0x%p could not get frame "
1906                                "header for frame index %d, status %x\n",
1907                                __func__, stp_req, frame_index, status);
1908                        return status;
1909                }
1910
1911                switch (frame_header->fis_type) {
1912                case FIS_PIO_SETUP:
1913                        /* Get from the frame buffer the PIO Setup Data */
1914                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1915                                                                      frame_index,
1916                                                                      (void **)&frame_buffer);
1917
1918                        /* Get the data from the PIO Setup The SCU Hardware
1919                         * returns first word in the frame_header and the rest
1920                         * of the data is in the frame buffer so we need to
1921                         * back up one dword
1922                         */
1923
1924                        /* transfer_count: first 16bits in the 4th dword */
1925                        stp_req->pio_len = frame_buffer[3] & 0xffff;
1926
1927                        /* status: 4th byte in the 3rd dword */
1928                        stp_req->status = (frame_buffer[2] >> 24) & 0xff;
1929
1930                        sci_controller_copy_sata_response(&ireq->stp.rsp,
1931                                                               frame_header,
1932                                                               frame_buffer);
1933
1934                        ireq->stp.rsp.status = stp_req->status;
1935
1936                        /* The next state is dependent on whether the
1937                         * request was PIO Data-in or Data out
1938                         */
1939                        if (task->data_dir == DMA_FROM_DEVICE) {
1940                                sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_IN);
1941                        } else if (task->data_dir == DMA_TO_DEVICE) {
1942                                /* Transmit data */
1943                                status = sci_stp_request_pio_data_out_transmit_data(ireq);
1944                                if (status != SCI_SUCCESS)
1945                                        break;
1946                                sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_OUT);
1947                        }
1948                        break;
1949
1950                case FIS_SETDEVBITS:
1951                        sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
1952                        break;
1953
1954                case FIS_REGD2H:
1955                        if (frame_header->status & ATA_BUSY) {
1956                                /*
1957                                 * Now why is the drive sending a D2H Register
1958                                 * FIS when it is still busy?  Do nothing since
1959                                 * we are still in the right state.
1960                                 */
1961                                dev_dbg(&ihost->pdev->dev,
1962                                        "%s: SCIC PIO Request 0x%p received "
1963                                        "D2H Register FIS with BSY status "
1964                                        "0x%x\n",
1965                                        __func__,
1966                                        stp_req,
1967                                        frame_header->status);
1968                                break;
1969                        }
1970
1971                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
1972                                                                      frame_index,
1973                                                                      (void **)&frame_buffer);
1974
1975                        sci_controller_copy_sata_response(&ireq->stp.rsp,
1976                                                               frame_header,
1977                                                               frame_buffer);
1978
1979                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
1980                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
1981                        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
1982                        break;
1983
1984                default:
1985                        /* FIXME: what do we do here? */
1986                        break;
1987                }
1988
1989                /* Frame is decoded return it to the controller */
1990                sci_controller_release_frame(ihost, frame_index);
1991
1992                return status;
1993        }
1994
1995        case SCI_REQ_STP_PIO_DATA_IN: {
1996                struct dev_to_host_fis *frame_header;
1997                struct sata_fis_data *frame_buffer;
1998
1999                status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
2000                                                                       frame_index,
2001                                                                       (void **)&frame_header);
2002
2003                if (status != SCI_SUCCESS) {
2004                        dev_err(&ihost->pdev->dev,
2005                                "%s: SCIC IO Request 0x%p could not get frame "
2006                                "header for frame index %d, status %x\n",
2007                                __func__,
2008                                stp_req,
2009                                frame_index,
2010                                status);
2011                        return status;
2012                }
2013
2014                if (frame_header->fis_type != FIS_DATA) {
2015                        dev_err(&ihost->pdev->dev,
2016                                "%s: SCIC PIO Request 0x%p received frame %d "
2017                                "with fis type 0x%02x when expecting a data "
2018                                "fis.\n",
2019                                __func__,
2020                                stp_req,
2021                                frame_index,
2022                                frame_header->fis_type);
2023
2024                        ireq->scu_status = SCU_TASK_DONE_GOOD;
2025                        ireq->sci_status = SCI_FAILURE_IO_REQUIRES_SCSI_ABORT;
2026                        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2027
2028                        /* Frame is decoded return it to the controller */
2029                        sci_controller_release_frame(ihost, frame_index);
2030                        return status;
2031                }
2032
2033                if (stp_req->sgl.index < 0) {
2034                        ireq->saved_rx_frame_index = frame_index;
2035                        stp_req->pio_len = 0;
2036                } else {
2037                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
2038                                                                      frame_index,
2039                                                                      (void **)&frame_buffer);
2040
2041                        status = sci_stp_request_pio_data_in_copy_data(stp_req,
2042                                                                            (u8 *)frame_buffer);
2043
2044                        /* Frame is decoded return it to the controller */
2045                        sci_controller_release_frame(ihost, frame_index);
2046                }
2047
2048                /* Check for the end of the transfer, are there more
2049                 * bytes remaining for this data transfer
2050                 */
2051                if (status != SCI_SUCCESS || stp_req->pio_len != 0)
2052                        return status;
2053
2054                if ((stp_req->status & ATA_BUSY) == 0) {
2055                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2056                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2057                        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2058                } else {
2059                        sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
2060                }
2061                return status;
2062        }
2063
2064        case SCI_REQ_ATAPI_WAIT_PIO_SETUP: {
2065                struct sas_task *task = isci_request_access_task(ireq);
2066
2067                sci_controller_release_frame(ihost, frame_index);
2068                ireq->target_device->working_request = ireq;
2069                if (task->data_dir == DMA_NONE) {
2070                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
2071                        scu_atapi_reconstruct_raw_frame_task_context(ireq);
2072                } else {
2073                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2074                        scu_atapi_construct_task_context(ireq);
2075                }
2076
2077                sci_controller_continue_io(ireq);
2078                return SCI_SUCCESS;
2079        }
2080        case SCI_REQ_ATAPI_WAIT_D2H:
2081                return atapi_d2h_reg_frame_handler(ireq, frame_index);
2082        case SCI_REQ_ABORTING:
2083                /*
2084                 * TODO: Is it even possible to get an unsolicited frame in the
2085                 * aborting state?
2086                 */
2087                sci_controller_release_frame(ihost, frame_index);
2088                return SCI_SUCCESS;
2089
2090        default:
2091                dev_warn(&ihost->pdev->dev,
2092                         "%s: SCIC IO Request given unexpected frame %x while "
2093                         "in state %d\n",
2094                         __func__,
2095                         frame_index,
2096                         state);
2097
2098                sci_controller_release_frame(ihost, frame_index);
2099                return SCI_FAILURE_INVALID_STATE;
2100        }
2101}
2102
2103static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq,
2104                                                       u32 completion_code)
2105{
2106        enum sci_status status = SCI_SUCCESS;
2107
2108        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2109        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
2110                ireq->scu_status = SCU_TASK_DONE_GOOD;
2111                ireq->sci_status = SCI_SUCCESS;
2112                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2113                break;
2114        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS):
2115        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
2116                /* We must check ther response buffer to see if the D2H
2117                 * Register FIS was received before we got the TC
2118                 * completion.
2119                 */
2120                if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
2121                        sci_remote_device_suspend(ireq->target_device,
2122                                                  SCI_SW_SUSPEND_NORMAL);
2123
2124                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2125                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2126                        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2127                } else {
2128                        /* If we have an error completion status for the
2129                         * TC then we can expect a D2H register FIS from
2130                         * the device so we must change state to wait
2131                         * for it
2132                         */
2133                        sci_change_state(&ireq->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
2134                }
2135                break;
2136
2137        /* TODO Check to see if any of these completion status need to
2138         * wait for the device to host register fis.
2139         */
2140        /* TODO We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR
2141         * - this comes only for B0
2142         */
2143        default:
2144                /* All other completion status cause the IO to be complete. */
2145                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2146                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2147                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2148                break;
2149        }
2150
2151        return status;
2152}
2153
2154static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
2155                                                  enum sci_base_request_states next)
2156{
2157        enum sci_status status = SCI_SUCCESS;
2158
2159        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2160        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
2161                ireq->scu_status = SCU_TASK_DONE_GOOD;
2162                ireq->sci_status = SCI_SUCCESS;
2163                sci_change_state(&ireq->sm, next);
2164                break;
2165        default:
2166                /* All other completion status cause the IO to be complete.
2167                 * If a NAK was received, then it is up to the user to retry
2168                 * the request.
2169                 */
2170                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
2171                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
2172
2173                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2174                break;
2175        }
2176
2177        return status;
2178}
2179
2180static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
2181                                                        u32 completion_code)
2182{
2183        struct isci_remote_device *idev = ireq->target_device;
2184        struct dev_to_host_fis *d2h = &ireq->stp.rsp;
2185        enum sci_status status = SCI_SUCCESS;
2186
2187        switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2188        case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
2189                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2190                break;
2191
2192        case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT): {
2193                u16 len = sci_req_tx_bytes(ireq);
2194
2195                /* likely non-error data underrrun, workaround missing
2196                 * d2h frame from the controller
2197                 */
2198                if (d2h->fis_type != FIS_REGD2H) {
2199                        d2h->fis_type = FIS_REGD2H;
2200                        d2h->flags = (1 << 6);
2201                        d2h->status = 0x50;
2202                        d2h->error = 0;
2203                        d2h->lbal = 0;
2204                        d2h->byte_count_low = len & 0xff;
2205                        d2h->byte_count_high = len >> 8;
2206                        d2h->device = 0xa0;
2207                        d2h->lbal_exp = 0;
2208                        d2h->lbam_exp = 0;
2209                        d2h->lbah_exp = 0;
2210                        d2h->_r_a = 0;
2211                        d2h->sector_count = 0x3;
2212                        d2h->sector_count_exp = 0;
2213                        d2h->_r_b = 0;
2214                        d2h->_r_c = 0;
2215                        d2h->_r_d = 0;
2216                }
2217
2218                ireq->scu_status = SCU_TASK_DONE_GOOD;
2219                ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
2220                status = ireq->sci_status;
2221
2222                /* the hw will have suspended the rnc, so complete the
2223                 * request upon pending resume
2224                 */
2225                sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
2226                break;
2227        }
2228        case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
2229                /* In this case, there is no UF coming after.
2230                 * compelte the IO now.
2231                 */
2232                ireq->scu_status = SCU_TASK_DONE_GOOD;
2233                ireq->sci_status = SCI_SUCCESS;
2234                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
2235                break;
2236
2237        default:
2238                if (d2h->fis_type == FIS_REGD2H) {
2239                        /* UF received change the device state to ATAPI_ERROR */
2240                        status = ireq->sci_status;
2241                        sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
2242                } else {
2243                        /* If receiving any non-success TC status, no UF
2244                         * received yet, then an UF for the status fis
2245                         * is coming after (XXX: suspect this is
2246                         * actually a protocol error or a bug like the
2247                         * DONE_UNEXP_FIS case)
2248                         */
2249                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
2250                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
2251
2252                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
2253                }
2254                break;
2255        }
2256
2257        return status;
2258}
2259
2260static int sci_request_smp_completion_status_is_tx_suspend(
2261        unsigned int completion_status)
2262{
2263        switch (completion_status) {
2264        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
2265        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
2266        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
2267        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
2268        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
2269        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
2270                return 1;
2271        }
2272        return 0;
2273}
2274
2275static int sci_request_smp_completion_status_is_tx_rx_suspend(
2276        unsigned int completion_status)
2277{
2278        return 0; /* There are no Tx/Rx SMP suspend conditions. */
2279}
2280
2281static int sci_request_ssp_completion_status_is_tx_suspend(
2282        unsigned int completion_status)
2283{
2284        switch (completion_status) {
2285        case SCU_TASK_DONE_TX_RAW_CMD_ERR:
2286        case SCU_TASK_DONE_LF_ERR:
2287        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
2288        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
2289        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
2290        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
2291        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
2292        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
2293        case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
2294        case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
2295        case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
2296                return 1;
2297        }
2298        return 0;
2299}
2300
2301static int sci_request_ssp_completion_status_is_tx_rx_suspend(
2302        unsigned int completion_status)
2303{
2304        return 0; /* There are no Tx/Rx SSP suspend conditions. */
2305}
2306
2307static int sci_request_stpsata_completion_status_is_tx_suspend(
2308        unsigned int completion_status)
2309{
2310        switch (completion_status) {
2311        case SCU_TASK_DONE_TX_RAW_CMD_ERR:
2312        case SCU_TASK_DONE_LL_R_ERR:
2313        case SCU_TASK_DONE_LL_PERR:
2314        case SCU_TASK_DONE_REG_ERR:
2315        case SCU_TASK_DONE_SDB_ERR:
2316        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
2317        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
2318        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
2319        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
2320        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
2321        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
2322        case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
2323        case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
2324        case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
2325                return 1;
2326        }
2327        return 0;
2328}
2329
2330
2331static int sci_request_stpsata_completion_status_is_tx_rx_suspend(
2332        unsigned int completion_status)
2333{
2334        switch (completion_status) {
2335        case SCU_TASK_DONE_LF_ERR:
2336        case SCU_TASK_DONE_LL_SY_TERM:
2337        case SCU_TASK_DONE_LL_LF_TERM:
2338        case SCU_TASK_DONE_BREAK_RCVD:
2339        case SCU_TASK_DONE_INV_FIS_LEN:
2340        case SCU_TASK_DONE_UNEXP_FIS:
2341        case SCU_TASK_DONE_UNEXP_SDBFIS:
2342        case SCU_TASK_DONE_MAX_PLD_ERR:
2343                return 1;
2344        }
2345        return 0;
2346}
2347
2348static void sci_request_handle_suspending_completions(
2349        struct isci_request *ireq,
2350        u32 completion_code)
2351{
2352        int is_tx = 0;
2353        int is_tx_rx = 0;
2354
2355        switch (ireq->protocol) {
2356        case SAS_PROTOCOL_SMP:
2357                is_tx = sci_request_smp_completion_status_is_tx_suspend(
2358                        completion_code);
2359                is_tx_rx = sci_request_smp_completion_status_is_tx_rx_suspend(
2360                        completion_code);
2361                break;
2362        case SAS_PROTOCOL_SSP:
2363                is_tx = sci_request_ssp_completion_status_is_tx_suspend(
2364                        completion_code);
2365                is_tx_rx = sci_request_ssp_completion_status_is_tx_rx_suspend(
2366                        completion_code);
2367                break;
2368        case SAS_PROTOCOL_STP:
2369                is_tx = sci_request_stpsata_completion_status_is_tx_suspend(
2370                        completion_code);
2371                is_tx_rx =
2372                        sci_request_stpsata_completion_status_is_tx_rx_suspend(
2373                                completion_code);
2374                break;
2375        default:
2376                dev_warn(&ireq->isci_host->pdev->dev,
2377                         "%s: request %p has no valid protocol\n",
2378                         __func__, ireq);
2379                break;
2380        }
2381        if (is_tx || is_tx_rx) {
2382                BUG_ON(is_tx && is_tx_rx);
2383
2384                sci_remote_node_context_suspend(
2385                        &ireq->target_device->rnc,
2386                        SCI_HW_SUSPEND,
2387                        (is_tx_rx) ? SCU_EVENT_TL_RNC_SUSPEND_TX_RX
2388                                   : SCU_EVENT_TL_RNC_SUSPEND_TX);
2389        }
2390}
2391
2392enum sci_status
2393sci_io_request_tc_completion(struct isci_request *ireq,
2394                             u32 completion_code)
2395{
2396        enum sci_base_request_states state;
2397        struct isci_host *ihost = ireq->owning_controller;
2398
2399        state = ireq->sm.current_state_id;
2400
2401        /* Decode those completions that signal upcoming suspension events. */
2402        sci_request_handle_suspending_completions(
2403                ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
2404
2405        switch (state) {
2406        case SCI_REQ_STARTED:
2407                return request_started_state_tc_event(ireq, completion_code);
2408
2409        case SCI_REQ_TASK_WAIT_TC_COMP:
2410                return ssp_task_request_await_tc_event(ireq,
2411                                                       completion_code);
2412
2413        case SCI_REQ_SMP_WAIT_RESP:
2414                return smp_request_await_response_tc_event(ireq,
2415                                                           completion_code);
2416
2417        case SCI_REQ_SMP_WAIT_TC_COMP:
2418                return smp_request_await_tc_event(ireq, completion_code);
2419
2420        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
2421                return stp_request_udma_await_tc_event(ireq,
2422                                                       completion_code);
2423
2424        case SCI_REQ_STP_NON_DATA_WAIT_H2D:
2425                return stp_request_non_data_await_h2d_tc_event(ireq,
2426                                                               completion_code);
2427
2428        case SCI_REQ_STP_PIO_WAIT_H2D:
2429                return stp_request_pio_await_h2d_completion_tc_event(ireq,
2430                                                                     completion_code);
2431
2432        case SCI_REQ_STP_PIO_DATA_OUT:
2433                return pio_data_out_tx_done_tc_event(ireq, completion_code);
2434
2435        case SCI_REQ_ABORTING:
2436                return request_aborting_state_tc_event(ireq,
2437                                                       completion_code);
2438
2439        case SCI_REQ_ATAPI_WAIT_H2D:
2440                return atapi_raw_completion(ireq, completion_code,
2441                                            SCI_REQ_ATAPI_WAIT_PIO_SETUP);
2442
2443        case SCI_REQ_ATAPI_WAIT_TC_COMP:
2444                return atapi_raw_completion(ireq, completion_code,
2445                                            SCI_REQ_ATAPI_WAIT_D2H);
2446
2447        case SCI_REQ_ATAPI_WAIT_D2H:
2448                return atapi_data_tc_completion_handler(ireq, completion_code);
2449
2450        default:
2451                dev_warn(&ihost->pdev->dev, "%s: %x in wrong state %s\n",
2452                         __func__, completion_code, req_state_name(state));
2453                return SCI_FAILURE_INVALID_STATE;
2454        }
2455}
2456
2457/**
2458 * isci_request_process_response_iu() - This function sets the status and
2459 *    response iu, in the task struct, from the request object for the upper
2460 *    layer driver.
2461 * @sas_task: This parameter is the task struct from the upper layer driver.
2462 * @resp_iu: This parameter points to the response iu of the completed request.
2463 * @dev: This parameter specifies the linux device struct.
2464 *
2465 * none.
2466 */
2467static void isci_request_process_response_iu(
2468        struct sas_task *task,
2469        struct ssp_response_iu *resp_iu,
2470        struct device *dev)
2471{
2472        dev_dbg(dev,
2473                "%s: resp_iu = %p "
2474                "resp_iu->status = 0x%x,\nresp_iu->datapres = %d "
2475                "resp_iu->response_data_len = %x, "
2476                "resp_iu->sense_data_len = %x\nrepsonse data: ",
2477                __func__,
2478                resp_iu,
2479                resp_iu->status,
2480                resp_iu->datapres,
2481                resp_iu->response_data_len,
2482                resp_iu->sense_data_len);
2483
2484        task->task_status.stat = resp_iu->status;
2485
2486        /* libsas updates the task status fields based on the response iu. */
2487        sas_ssp_task_response(dev, task, resp_iu);
2488}
2489
2490/**
2491 * isci_request_set_open_reject_status() - This function prepares the I/O
2492 *    completion for OPEN_REJECT conditions.
2493 * @request: This parameter is the completed isci_request object.
2494 * @response_ptr: This parameter specifies the service response for the I/O.
2495 * @status_ptr: This parameter specifies the exec status for the I/O.
2496 * @open_rej_reason: This parameter specifies the encoded reason for the
2497 *    abandon-class reject.
2498 *
2499 * none.
2500 */
2501static void isci_request_set_open_reject_status(
2502        struct isci_request *request,
2503        struct sas_task *task,
2504        enum service_response *response_ptr,
2505        enum exec_status *status_ptr,
2506        enum sas_open_rej_reason open_rej_reason)
2507{
2508        /* Task in the target is done. */
2509        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2510        *response_ptr                     = SAS_TASK_UNDELIVERED;
2511        *status_ptr                       = SAS_OPEN_REJECT;
2512        task->task_status.open_rej_reason = open_rej_reason;
2513}
2514
2515/**
2516 * isci_request_handle_controller_specific_errors() - This function decodes
2517 *    controller-specific I/O completion error conditions.
2518 * @request: This parameter is the completed isci_request object.
2519 * @response_ptr: This parameter specifies the service response for the I/O.
2520 * @status_ptr: This parameter specifies the exec status for the I/O.
2521 *
2522 * none.
2523 */
2524static void isci_request_handle_controller_specific_errors(
2525        struct isci_remote_device *idev,
2526        struct isci_request *request,
2527        struct sas_task *task,
2528        enum service_response *response_ptr,
2529        enum exec_status *status_ptr)
2530{
2531        unsigned int cstatus;
2532
2533        cstatus = request->scu_status;
2534
2535        dev_dbg(&request->isci_host->pdev->dev,
2536                "%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR "
2537                "- controller status = 0x%x\n",
2538                __func__, request, cstatus);
2539
2540        /* Decode the controller-specific errors; most
2541         * important is to recognize those conditions in which
2542         * the target may still have a task outstanding that
2543         * must be aborted.
2544         *
2545         * Note that there are SCU completion codes being
2546         * named in the decode below for which SCIC has already
2547         * done work to handle them in a way other than as
2548         * a controller-specific completion code; these are left
2549         * in the decode below for completeness sake.
2550         */
2551        switch (cstatus) {
2552        case SCU_TASK_DONE_DMASETUP_DIRERR:
2553        /* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */
2554        case SCU_TASK_DONE_XFERCNT_ERR:
2555                /* Also SCU_TASK_DONE_SMP_UFI_ERR: */
2556                if (task->task_proto == SAS_PROTOCOL_SMP) {
2557                        /* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */
2558                        *response_ptr = SAS_TASK_COMPLETE;
2559
2560                        /* See if the device has been/is being stopped. Note
2561                         * that we ignore the quiesce state, since we are
2562                         * concerned about the actual device state.
2563                         */
2564                        if (!idev)
2565                                *status_ptr = SAS_DEVICE_UNKNOWN;
2566                        else
2567                                *status_ptr = SAS_ABORTED_TASK;
2568
2569                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2570                } else {
2571                        /* Task in the target is not done. */
2572                        *response_ptr = SAS_TASK_UNDELIVERED;
2573
2574                        if (!idev)
2575                                *status_ptr = SAS_DEVICE_UNKNOWN;
2576                        else
2577                                *status_ptr = SAM_STAT_TASK_ABORTED;
2578
2579                        clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2580                }
2581
2582                break;
2583
2584        case SCU_TASK_DONE_CRC_ERR:
2585        case SCU_TASK_DONE_NAK_CMD_ERR:
2586        case SCU_TASK_DONE_EXCESS_DATA:
2587        case SCU_TASK_DONE_UNEXP_FIS:
2588        /* Also SCU_TASK_DONE_UNEXP_RESP: */
2589        case SCU_TASK_DONE_VIIT_ENTRY_NV:       /* TODO - conditions? */
2590        case SCU_TASK_DONE_IIT_ENTRY_NV:        /* TODO - conditions? */
2591        case SCU_TASK_DONE_RNCNV_OUTBOUND:      /* TODO - conditions? */
2592                /* These are conditions in which the target
2593                 * has completed the task, so that no cleanup
2594                 * is necessary.
2595                 */
2596                *response_ptr = SAS_TASK_COMPLETE;
2597
2598                /* See if the device has been/is being stopped. Note
2599                 * that we ignore the quiesce state, since we are
2600                 * concerned about the actual device state.
2601                 */
2602                if (!idev)
2603                        *status_ptr = SAS_DEVICE_UNKNOWN;
2604                else
2605                        *status_ptr = SAS_ABORTED_TASK;
2606
2607                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2608                break;
2609
2610
2611        /* Note that the only open reject completion codes seen here will be
2612         * abandon-class codes; all others are automatically retried in the SCU.
2613         */
2614        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
2615
2616                isci_request_set_open_reject_status(
2617                        request, task, response_ptr, status_ptr,
2618                        SAS_OREJ_WRONG_DEST);
2619                break;
2620
2621        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
2622
2623                /* Note - the return of AB0 will change when
2624                 * libsas implements detection of zone violations.
2625                 */
2626                isci_request_set_open_reject_status(
2627                        request, task, response_ptr, status_ptr,
2628                        SAS_OREJ_RESV_AB0);
2629                break;
2630
2631        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
2632
2633                isci_request_set_open_reject_status(
2634                        request, task, response_ptr, status_ptr,
2635                        SAS_OREJ_RESV_AB1);
2636                break;
2637
2638        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
2639
2640                isci_request_set_open_reject_status(
2641                        request, task, response_ptr, status_ptr,
2642                        SAS_OREJ_RESV_AB2);
2643                break;
2644
2645        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
2646
2647                isci_request_set_open_reject_status(
2648                        request, task, response_ptr, status_ptr,
2649                        SAS_OREJ_RESV_AB3);
2650                break;
2651
2652        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
2653
2654                isci_request_set_open_reject_status(
2655                        request, task, response_ptr, status_ptr,
2656                        SAS_OREJ_BAD_DEST);
2657                break;
2658
2659        case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
2660
2661                isci_request_set_open_reject_status(
2662                        request, task, response_ptr, status_ptr,
2663                        SAS_OREJ_STP_NORES);
2664                break;
2665
2666        case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
2667
2668                isci_request_set_open_reject_status(
2669                        request, task, response_ptr, status_ptr,
2670                        SAS_OREJ_EPROTO);
2671                break;
2672
2673        case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
2674
2675                isci_request_set_open_reject_status(
2676                        request, task, response_ptr, status_ptr,
2677                        SAS_OREJ_CONN_RATE);
2678                break;
2679
2680        case SCU_TASK_DONE_LL_R_ERR:
2681        /* Also SCU_TASK_DONE_ACK_NAK_TO: */
2682        case SCU_TASK_DONE_LL_PERR:
2683        case SCU_TASK_DONE_LL_SY_TERM:
2684        /* Also SCU_TASK_DONE_NAK_ERR:*/
2685        case SCU_TASK_DONE_LL_LF_TERM:
2686        /* Also SCU_TASK_DONE_DATA_LEN_ERR: */
2687        case SCU_TASK_DONE_LL_ABORT_ERR:
2688        case SCU_TASK_DONE_SEQ_INV_TYPE:
2689        /* Also SCU_TASK_DONE_UNEXP_XR: */
2690        case SCU_TASK_DONE_XR_IU_LEN_ERR:
2691        case SCU_TASK_DONE_INV_FIS_LEN:
2692        /* Also SCU_TASK_DONE_XR_WD_LEN: */
2693        case SCU_TASK_DONE_SDMA_ERR:
2694        case SCU_TASK_DONE_OFFSET_ERR:
2695        case SCU_TASK_DONE_MAX_PLD_ERR:
2696        case SCU_TASK_DONE_LF_ERR:
2697        case SCU_TASK_DONE_SMP_RESP_TO_ERR:  /* Escalate to dev reset? */
2698        case SCU_TASK_DONE_SMP_LL_RX_ERR:
2699        case SCU_TASK_DONE_UNEXP_DATA:
2700        case SCU_TASK_DONE_UNEXP_SDBFIS:
2701        case SCU_TASK_DONE_REG_ERR:
2702        case SCU_TASK_DONE_SDB_ERR:
2703        case SCU_TASK_DONE_TASK_ABORT:
2704        default:
2705                /* Task in the target is not done. */
2706                *response_ptr = SAS_TASK_UNDELIVERED;
2707                *status_ptr = SAM_STAT_TASK_ABORTED;
2708
2709                if (task->task_proto == SAS_PROTOCOL_SMP)
2710                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2711                else
2712                        clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2713                break;
2714        }
2715}
2716
2717static void isci_process_stp_response(struct sas_task *task, struct dev_to_host_fis *fis)
2718{
2719        struct task_status_struct *ts = &task->task_status;
2720        struct ata_task_resp *resp = (void *)&ts->buf[0];
2721
2722        resp->frame_len = sizeof(*fis);
2723        memcpy(resp->ending_fis, fis, sizeof(*fis));
2724        ts->buf_valid_size = sizeof(*resp);
2725
2726        /* If an error is flagged let libata decode the fis */
2727        if (ac_err_mask(fis->status))
2728                ts->stat = SAS_PROTO_RESPONSE;
2729        else
2730                ts->stat = SAM_STAT_GOOD;
2731
2732        ts->resp = SAS_TASK_COMPLETE;
2733}
2734
2735static void isci_request_io_request_complete(struct isci_host *ihost,
2736                                             struct isci_request *request,
2737                                             enum sci_io_status completion_status)
2738{
2739        struct sas_task *task = isci_request_access_task(request);
2740        struct ssp_response_iu *resp_iu;
2741        unsigned long task_flags;
2742        struct isci_remote_device *idev = request->target_device;
2743        enum service_response response = SAS_TASK_UNDELIVERED;
2744        enum exec_status status = SAS_ABORTED_TASK;
2745
2746        dev_dbg(&ihost->pdev->dev,
2747                "%s: request = %p, task = %p, "
2748                "task->data_dir = %d completion_status = 0x%x\n",
2749                __func__, request, task, task->data_dir, completion_status);
2750
2751        /* The request is done from an SCU HW perspective. */
2752
2753        /* This is an active request being completed from the core. */
2754        switch (completion_status) {
2755
2756        case SCI_IO_FAILURE_RESPONSE_VALID:
2757                dev_dbg(&ihost->pdev->dev,
2758                        "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
2759                        __func__, request, task);
2760
2761                if (sas_protocol_ata(task->task_proto)) {
2762                        isci_process_stp_response(task, &request->stp.rsp);
2763                } else if (SAS_PROTOCOL_SSP == task->task_proto) {
2764
2765                        /* crack the iu response buffer. */
2766                        resp_iu = &request->ssp.rsp;
2767                        isci_request_process_response_iu(task, resp_iu,
2768                                                         &ihost->pdev->dev);
2769
2770                } else if (SAS_PROTOCOL_SMP == task->task_proto) {
2771
2772                        dev_err(&ihost->pdev->dev,
2773                                "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
2774                                        "SAS_PROTOCOL_SMP protocol\n",
2775                                __func__);
2776
2777                } else
2778                        dev_err(&ihost->pdev->dev,
2779                                "%s: unknown protocol\n", __func__);
2780
2781                /* use the task status set in the task struct by the
2782                * isci_request_process_response_iu call.
2783                */
2784                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2785                response = task->task_status.resp;
2786                status = task->task_status.stat;
2787                break;
2788
2789        case SCI_IO_SUCCESS:
2790        case SCI_IO_SUCCESS_IO_DONE_EARLY:
2791
2792                response = SAS_TASK_COMPLETE;
2793                status   = SAM_STAT_GOOD;
2794                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2795
2796                if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
2797
2798                        /* This was an SSP / STP / SATA transfer.
2799                        * There is a possibility that less data than
2800                        * the maximum was transferred.
2801                        */
2802                        u32 transferred_length = sci_req_tx_bytes(request);
2803
2804                        task->task_status.residual
2805                                = task->total_xfer_len - transferred_length;
2806
2807                        /* If there were residual bytes, call this an
2808                        * underrun.
2809                        */
2810                        if (task->task_status.residual != 0)
2811                                status = SAS_DATA_UNDERRUN;
2812
2813                        dev_dbg(&ihost->pdev->dev,
2814                                "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
2815                                __func__, status);
2816
2817                } else
2818                        dev_dbg(&ihost->pdev->dev, "%s: SCI_IO_SUCCESS\n",
2819                                __func__);
2820                break;
2821
2822        case SCI_IO_FAILURE_TERMINATED:
2823
2824                dev_dbg(&ihost->pdev->dev,
2825                        "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
2826                        __func__, request, task);
2827
2828                /* The request was terminated explicitly. */
2829                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2830                response = SAS_TASK_UNDELIVERED;
2831
2832                /* See if the device has been/is being stopped. Note
2833                * that we ignore the quiesce state, since we are
2834                * concerned about the actual device state.
2835                */
2836                if (!idev)
2837                        status = SAS_DEVICE_UNKNOWN;
2838                else
2839                        status = SAS_ABORTED_TASK;
2840                break;
2841
2842        case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
2843
2844                isci_request_handle_controller_specific_errors(idev, request,
2845                                                               task, &response,
2846                                                               &status);
2847                break;
2848
2849        case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
2850                /* This is a special case, in that the I/O completion
2851                * is telling us that the device needs a reset.
2852                * In order for the device reset condition to be
2853                * noticed, the I/O has to be handled in the error
2854                * handler.  Set the reset flag and cause the
2855                * SCSI error thread to be scheduled.
2856                */
2857                spin_lock_irqsave(&task->task_state_lock, task_flags);
2858                task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
2859                spin_unlock_irqrestore(&task->task_state_lock, task_flags);
2860
2861                /* Fail the I/O. */
2862                response = SAS_TASK_UNDELIVERED;
2863                status = SAM_STAT_TASK_ABORTED;
2864
2865                clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2866                break;
2867
2868        case SCI_FAILURE_RETRY_REQUIRED:
2869
2870                /* Fail the I/O so it can be retried. */
2871                response = SAS_TASK_UNDELIVERED;
2872                if (!idev)
2873                        status = SAS_DEVICE_UNKNOWN;
2874                else
2875                        status = SAS_ABORTED_TASK;
2876
2877                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2878                break;
2879
2880
2881        default:
2882                /* Catch any otherwise unhandled error codes here. */
2883                dev_dbg(&ihost->pdev->dev,
2884                        "%s: invalid completion code: 0x%x - "
2885                                "isci_request = %p\n",
2886                        __func__, completion_status, request);
2887
2888                response = SAS_TASK_UNDELIVERED;
2889
2890                /* See if the device has been/is being stopped. Note
2891                * that we ignore the quiesce state, since we are
2892                * concerned about the actual device state.
2893                */
2894                if (!idev)
2895                        status = SAS_DEVICE_UNKNOWN;
2896                else
2897                        status = SAS_ABORTED_TASK;
2898
2899                if (SAS_PROTOCOL_SMP == task->task_proto)
2900                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2901                else
2902                        clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
2903                break;
2904        }
2905
2906        switch (task->task_proto) {
2907        case SAS_PROTOCOL_SSP:
2908                if (task->data_dir == DMA_NONE)
2909                        break;
2910                if (task->num_scatter == 0)
2911                        /* 0 indicates a single dma address */
2912                        dma_unmap_single(&ihost->pdev->dev,
2913                                         request->zero_scatter_daddr,
2914                                         task->total_xfer_len, task->data_dir);
2915                else  /* unmap the sgl dma addresses */
2916                        dma_unmap_sg(&ihost->pdev->dev, task->scatter,
2917                                     request->num_sg_entries, task->data_dir);
2918                break;
2919        case SAS_PROTOCOL_SMP: {
2920                struct scatterlist *sg = &task->smp_task.smp_req;
2921                struct smp_req *smp_req;
2922                void *kaddr;
2923
2924                dma_unmap_sg(&ihost->pdev->dev, sg, 1, DMA_TO_DEVICE);
2925
2926                /* need to swab it back in case the command buffer is re-used */
2927                kaddr = kmap_atomic(sg_page(sg));
2928                smp_req = kaddr + sg->offset;
2929                sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
2930                kunmap_atomic(kaddr);
2931                break;
2932        }
2933        default:
2934                break;
2935        }
2936
2937        spin_lock_irqsave(&task->task_state_lock, task_flags);
2938
2939        task->task_status.resp = response;
2940        task->task_status.stat = status;
2941
2942        if (test_bit(IREQ_COMPLETE_IN_TARGET, &request->flags)) {
2943                /* Normal notification (task_done) */
2944                task->task_state_flags |= SAS_TASK_STATE_DONE;
2945                task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
2946                                            SAS_TASK_STATE_PENDING);
2947        }
2948        spin_unlock_irqrestore(&task->task_state_lock, task_flags);
2949
2950        /* complete the io request to the core. */
2951        sci_controller_complete_io(ihost, request->target_device, request);
2952
2953        /* set terminated handle so it cannot be completed or
2954         * terminated again, and to cause any calls into abort
2955         * task to recognize the already completed case.
2956         */
2957        set_bit(IREQ_TERMINATED, &request->flags);
2958
2959        ireq_done(ihost, request, task);
2960}
2961
2962static void sci_request_started_state_enter(struct sci_base_state_machine *sm)
2963{
2964        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
2965        struct domain_device *dev = ireq->target_device->domain_dev;
2966        enum sci_base_request_states state;
2967        struct sas_task *task;
2968
2969        /* XXX as hch said always creating an internal sas_task for tmf
2970         * requests would simplify the driver
2971         */
2972        task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
2973
2974        /* all unaccelerated request types (non ssp or ncq) handled with
2975         * substates
2976         */
2977        if (!task && dev->dev_type == SAS_END_DEVICE) {
2978                state = SCI_REQ_TASK_WAIT_TC_COMP;
2979        } else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
2980                state = SCI_REQ_SMP_WAIT_RESP;
2981        } else if (task && sas_protocol_ata(task->task_proto) &&
2982                   !task->ata_task.use_ncq) {
2983                if (dev->sata_dev.class == ATA_DEV_ATAPI &&
2984                        task->ata_task.fis.command == ATA_CMD_PACKET) {
2985                        state = SCI_REQ_ATAPI_WAIT_H2D;
2986                } else if (task->data_dir == DMA_NONE) {
2987                        state = SCI_REQ_STP_NON_DATA_WAIT_H2D;
2988                } else if (task->ata_task.dma_xfer) {
2989                        state = SCI_REQ_STP_UDMA_WAIT_TC_COMP;
2990                } else /* PIO */ {
2991                        state = SCI_REQ_STP_PIO_WAIT_H2D;
2992                }
2993        } else {
2994                /* SSP or NCQ are fully accelerated, no substates */
2995                return;
2996        }
2997        sci_change_state(sm, state);
2998}
2999
3000static void sci_request_completed_state_enter(struct sci_base_state_machine *sm)
3001{
3002        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3003        struct isci_host *ihost = ireq->owning_controller;
3004
3005        /* Tell the SCI_USER that the IO request is complete */
3006        if (!test_bit(IREQ_TMF, &ireq->flags))
3007                isci_request_io_request_complete(ihost, ireq,
3008                                                 ireq->sci_status);
3009        else
3010                isci_task_request_complete(ihost, ireq, ireq->sci_status);
3011}
3012
3013static void sci_request_aborting_state_enter(struct sci_base_state_machine *sm)
3014{
3015        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3016
3017        /* Setting the abort bit in the Task Context is required by the silicon. */
3018        ireq->tc->abort = 1;
3019}
3020
3021static void sci_stp_request_started_non_data_await_h2d_completion_enter(struct sci_base_state_machine *sm)
3022{
3023        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3024
3025        ireq->target_device->working_request = ireq;
3026}
3027
3028static void sci_stp_request_started_pio_await_h2d_completion_enter(struct sci_base_state_machine *sm)
3029{
3030        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
3031
3032        ireq->target_device->working_request = ireq;
3033}
3034
3035static const struct sci_base_state sci_request_state_table[] = {
3036        [SCI_REQ_INIT] = { },
3037        [SCI_REQ_CONSTRUCTED] = { },
3038        [SCI_REQ_STARTED] = {
3039                .enter_state = sci_request_started_state_enter,
3040        },
3041        [SCI_REQ_STP_NON_DATA_WAIT_H2D] = {
3042                .enter_state = sci_stp_request_started_non_data_await_h2d_completion_enter,
3043        },
3044        [SCI_REQ_STP_NON_DATA_WAIT_D2H] = { },
3045        [SCI_REQ_STP_PIO_WAIT_H2D] = {
3046                .enter_state = sci_stp_request_started_pio_await_h2d_completion_enter,
3047        },
3048        [SCI_REQ_STP_PIO_WAIT_FRAME] = { },
3049        [SCI_REQ_STP_PIO_DATA_IN] = { },
3050        [SCI_REQ_STP_PIO_DATA_OUT] = { },
3051        [SCI_REQ_STP_UDMA_WAIT_TC_COMP] = { },
3052        [SCI_REQ_STP_UDMA_WAIT_D2H] = { },
3053        [SCI_REQ_TASK_WAIT_TC_COMP] = { },
3054        [SCI_REQ_TASK_WAIT_TC_RESP] = { },
3055        [SCI_REQ_SMP_WAIT_RESP] = { },
3056        [SCI_REQ_SMP_WAIT_TC_COMP] = { },
3057        [SCI_REQ_ATAPI_WAIT_H2D] = { },
3058        [SCI_REQ_ATAPI_WAIT_PIO_SETUP] = { },
3059        [SCI_REQ_ATAPI_WAIT_D2H] = { },
3060        [SCI_REQ_ATAPI_WAIT_TC_COMP] = { },
3061        [SCI_REQ_COMPLETED] = {
3062                .enter_state = sci_request_completed_state_enter,
3063        },
3064        [SCI_REQ_ABORTING] = {
3065                .enter_state = sci_request_aborting_state_enter,
3066        },
3067        [SCI_REQ_FINAL] = { },
3068};
3069
3070static void
3071sci_general_request_construct(struct isci_host *ihost,
3072                                   struct isci_remote_device *idev,
3073                                   struct isci_request *ireq)
3074{
3075        sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
3076
3077        ireq->target_device = idev;
3078        ireq->protocol = SAS_PROTOCOL_NONE;
3079        ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
3080
3081        ireq->sci_status   = SCI_SUCCESS;
3082        ireq->scu_status   = 0;
3083        ireq->post_context = 0xFFFFFFFF;
3084}
3085
3086static enum sci_status
3087sci_io_request_construct(struct isci_host *ihost,
3088                          struct isci_remote_device *idev,
3089                          struct isci_request *ireq)
3090{
3091        struct domain_device *dev = idev->domain_dev;
3092        enum sci_status status = SCI_SUCCESS;
3093
3094        /* Build the common part of the request */
3095        sci_general_request_construct(ihost, idev, ireq);
3096
3097        if (idev->rnc.remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
3098                return SCI_FAILURE_INVALID_REMOTE_DEVICE;
3099
3100        if (dev->dev_type == SAS_END_DEVICE)
3101                /* pass */;
3102        else if (dev_is_sata(dev))
3103                memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
3104        else if (dev_is_expander(dev))
3105                /* pass */;
3106        else
3107                return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
3108
3109        memset(ireq->tc, 0, offsetof(struct scu_task_context, sgl_pair_ab));
3110
3111        return status;
3112}
3113
3114enum sci_status sci_task_request_construct(struct isci_host *ihost,
3115                                            struct isci_remote_device *idev,
3116                                            u16 io_tag, struct isci_request *ireq)
3117{
3118        struct domain_device *dev = idev->domain_dev;
3119        enum sci_status status = SCI_SUCCESS;
3120
3121        /* Build the common part of the request */
3122        sci_general_request_construct(ihost, idev, ireq);
3123
3124        if (dev->dev_type == SAS_END_DEVICE || dev_is_sata(dev)) {
3125                set_bit(IREQ_TMF, &ireq->flags);
3126                memset(ireq->tc, 0, sizeof(struct scu_task_context));
3127
3128                /* Set the protocol indicator. */
3129                if (dev_is_sata(dev))
3130                        ireq->protocol = SAS_PROTOCOL_STP;
3131                else
3132                        ireq->protocol = SAS_PROTOCOL_SSP;
3133        } else
3134                status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
3135
3136        return status;
3137}
3138
3139static enum sci_status isci_request_ssp_request_construct(
3140        struct isci_request *request)
3141{
3142        enum sci_status status;
3143
3144        dev_dbg(&request->isci_host->pdev->dev,
3145                "%s: request = %p\n",
3146                __func__,
3147                request);
3148        status = sci_io_request_construct_basic_ssp(request);
3149        return status;
3150}
3151
3152static enum sci_status isci_request_stp_request_construct(struct isci_request *ireq)
3153{
3154        struct sas_task *task = isci_request_access_task(ireq);
3155        struct host_to_dev_fis *fis = &ireq->stp.cmd;
3156        struct ata_queued_cmd *qc = task->uldd_task;
3157        enum sci_status status;
3158
3159        dev_dbg(&ireq->isci_host->pdev->dev,
3160                "%s: ireq = %p\n",
3161                __func__,
3162                ireq);
3163
3164        memcpy(fis, &task->ata_task.fis, sizeof(struct host_to_dev_fis));
3165        if (!task->ata_task.device_control_reg_update)
3166                fis->flags |= 0x80;
3167        fis->flags &= 0xF0;
3168
3169        status = sci_io_request_construct_basic_sata(ireq);
3170
3171        if (qc && (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
3172                   qc->tf.command == ATA_CMD_FPDMA_READ ||
3173                   qc->tf.command == ATA_CMD_FPDMA_RECV ||
3174                   qc->tf.command == ATA_CMD_FPDMA_SEND ||
3175                   qc->tf.command == ATA_CMD_NCQ_NON_DATA)) {
3176                fis->sector_count = qc->tag << 3;
3177                ireq->tc->type.stp.ncq_tag = qc->tag;
3178        }
3179
3180        return status;
3181}
3182
3183static enum sci_status
3184sci_io_request_construct_smp(struct device *dev,
3185                              struct isci_request *ireq,
3186                              struct sas_task *task)
3187{
3188        struct scatterlist *sg = &task->smp_task.smp_req;
3189        struct isci_remote_device *idev;
3190        struct scu_task_context *task_context;
3191        struct isci_port *iport;
3192        struct smp_req *smp_req;
3193        void *kaddr;
3194        u8 req_len;
3195        u32 cmd;
3196
3197        kaddr = kmap_atomic(sg_page(sg));
3198        smp_req = kaddr + sg->offset;
3199        /*
3200         * Look at the SMP requests' header fields; for certain SAS 1.x SMP
3201         * functions under SAS 2.0, a zero request length really indicates
3202         * a non-zero default length.
3203         */
3204        if (smp_req->req_len == 0) {
3205                switch (smp_req->func) {
3206                case SMP_DISCOVER:
3207                case SMP_REPORT_PHY_ERR_LOG:
3208                case SMP_REPORT_PHY_SATA:
3209                case SMP_REPORT_ROUTE_INFO:
3210                        smp_req->req_len = 2;
3211                        break;
3212                case SMP_CONF_ROUTE_INFO:
3213                case SMP_PHY_CONTROL:
3214                case SMP_PHY_TEST_FUNCTION:
3215                        smp_req->req_len = 9;
3216                        break;
3217                        /* Default - zero is a valid default for 2.0. */
3218                }
3219        }
3220        req_len = smp_req->req_len;
3221        sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
3222        cmd = *(u32 *) smp_req;
3223        kunmap_atomic(kaddr);
3224
3225        if (!dma_map_sg(dev, sg, 1, DMA_TO_DEVICE))
3226                return SCI_FAILURE;
3227
3228        ireq->protocol = SAS_PROTOCOL_SMP;
3229
3230        /* byte swap the smp request. */
3231
3232        task_context = ireq->tc;
3233
3234        idev = ireq->target_device;
3235        iport = idev->owning_port;
3236
3237        /*
3238         * Fill in the TC with the its required data
3239         * 00h
3240         */
3241        task_context->priority = 0;
3242        task_context->initiator_request = 1;
3243        task_context->connection_rate = idev->connection_rate;
3244        task_context->protocol_engine_index = ISCI_PEG;
3245        task_context->logical_port_index = iport->physical_port_index;
3246        task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SMP;
3247        task_context->abort = 0;
3248        task_context->valid = SCU_TASK_CONTEXT_VALID;
3249        task_context->context_type = SCU_TASK_CONTEXT_TYPE;
3250
3251        /* 04h */
3252        task_context->remote_node_index = idev->rnc.remote_node_index;
3253        task_context->command_code = 0;
3254        task_context->task_type = SCU_TASK_TYPE_SMP_REQUEST;
3255
3256        /* 08h */
3257        task_context->link_layer_control = 0;
3258        task_context->do_not_dma_ssp_good_response = 1;
3259        task_context->strict_ordering = 0;
3260        task_context->control_frame = 1;
3261        task_context->timeout_enable = 0;
3262        task_context->block_guard_enable = 0;
3263
3264        /* 0ch */
3265        task_context->address_modifier = 0;
3266
3267        /* 10h */
3268        task_context->ssp_command_iu_length = req_len;
3269
3270        /* 14h */
3271        task_context->transfer_length_bytes = 0;
3272
3273        /*
3274         * 18h ~ 30h, protocol specific
3275         * since commandIU has been build by framework at this point, we just
3276         * copy the frist DWord from command IU to this location. */
3277        memcpy(&task_context->type.smp, &cmd, sizeof(u32));
3278
3279        /*
3280         * 40h
3281         * "For SMP you could program it to zero. We would prefer that way
3282         * so that done code will be consistent." - Venki
3283         */
3284        task_context->task_phase = 0;
3285
3286        ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3287                              (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
3288                               (iport->physical_port_index <<
3289                                SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
3290                              ISCI_TAG_TCI(ireq->io_tag));
3291        /*
3292         * Copy the physical address for the command buffer to the SCU Task
3293         * Context command buffer should not contain command header.
3294         */
3295        task_context->command_iu_upper = upper_32_bits(sg_dma_address(sg));
3296        task_context->command_iu_lower = lower_32_bits(sg_dma_address(sg) + sizeof(u32));
3297
3298        /* SMP response comes as UF, so no need to set response IU address. */
3299        task_context->response_iu_upper = 0;
3300        task_context->response_iu_lower = 0;
3301
3302        sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
3303
3304        return SCI_SUCCESS;
3305}
3306
3307/*
3308 * isci_smp_request_build() - This function builds the smp request.
3309 * @ireq: This parameter points to the isci_request allocated in the
3310 *    request construct function.
3311 *
3312 * SCI_SUCCESS on successfull completion, or specific failure code.
3313 */
3314static enum sci_status isci_smp_request_build(struct isci_request *ireq)
3315{
3316        struct sas_task *task = isci_request_access_task(ireq);
3317        struct device *dev = &ireq->isci_host->pdev->dev;
3318        enum sci_status status = SCI_FAILURE;
3319
3320        status = sci_io_request_construct_smp(dev, ireq, task);
3321        if (status != SCI_SUCCESS)
3322                dev_dbg(&ireq->isci_host->pdev->dev,
3323                         "%s: failed with status = %d\n",
3324                         __func__,
3325                         status);
3326
3327        return status;
3328}
3329
3330/**
3331 * isci_io_request_build() - This function builds the io request object.
3332 * @ihost: This parameter specifies the ISCI host object
3333 * @request: This parameter points to the isci_request object allocated in the
3334 *    request construct function.
3335 * @sci_device: This parameter is the handle for the sci core's remote device
3336 *    object that is the destination for this request.
3337 *
3338 * SCI_SUCCESS on successfull completion, or specific failure code.
3339 */
3340static enum sci_status isci_io_request_build(struct isci_host *ihost,
3341                                             struct isci_request *request,
3342                                             struct isci_remote_device *idev)
3343{
3344        enum sci_status status = SCI_SUCCESS;
3345        struct sas_task *task = isci_request_access_task(request);
3346
3347        dev_dbg(&ihost->pdev->dev,
3348                "%s: idev = 0x%p; request = %p, "
3349                "num_scatter = %d\n",
3350                __func__,
3351                idev,
3352                request,
3353                task->num_scatter);
3354
3355        /* map the sgl addresses, if present.
3356         * libata does the mapping for sata devices
3357         * before we get the request.
3358         */
3359        if (task->num_scatter &&
3360            !sas_protocol_ata(task->task_proto) &&
3361            !(SAS_PROTOCOL_SMP & task->task_proto)) {
3362
3363                request->num_sg_entries = dma_map_sg(
3364                        &ihost->pdev->dev,
3365                        task->scatter,
3366                        task->num_scatter,
3367                        task->data_dir
3368                        );
3369
3370                if (request->num_sg_entries == 0)
3371                        return SCI_FAILURE_INSUFFICIENT_RESOURCES;
3372        }
3373
3374        status = sci_io_request_construct(ihost, idev, request);
3375
3376        if (status != SCI_SUCCESS) {
3377                dev_dbg(&ihost->pdev->dev,
3378                         "%s: failed request construct\n",
3379                         __func__);
3380                return SCI_FAILURE;
3381        }
3382
3383        switch (task->task_proto) {
3384        case SAS_PROTOCOL_SMP:
3385                status = isci_smp_request_build(request);
3386                break;
3387        case SAS_PROTOCOL_SSP:
3388                status = isci_request_ssp_request_construct(request);
3389                break;
3390        case SAS_PROTOCOL_SATA:
3391        case SAS_PROTOCOL_STP:
3392        case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
3393                status = isci_request_stp_request_construct(request);
3394                break;
3395        default:
3396                dev_dbg(&ihost->pdev->dev,
3397                         "%s: unknown protocol\n", __func__);
3398                return SCI_FAILURE;
3399        }
3400
3401        return SCI_SUCCESS;
3402}
3403
3404static struct isci_request *isci_request_from_tag(struct isci_host *ihost, u16 tag)
3405{
3406        struct isci_request *ireq;
3407
3408        ireq = ihost->reqs[ISCI_TAG_TCI(tag)];
3409        ireq->io_tag = tag;
3410        ireq->io_request_completion = NULL;
3411        ireq->flags = 0;
3412        ireq->num_sg_entries = 0;
3413
3414        return ireq;
3415}
3416
3417static struct isci_request *isci_io_request_from_tag(struct isci_host *ihost,
3418                                                     struct sas_task *task,
3419                                                     u16 tag)
3420{
3421        struct isci_request *ireq;
3422
3423        ireq = isci_request_from_tag(ihost, tag);
3424        ireq->ttype_ptr.io_task_ptr = task;
3425        clear_bit(IREQ_TMF, &ireq->flags);
3426        task->lldd_task = ireq;
3427
3428        return ireq;
3429}
3430
3431struct isci_request *isci_tmf_request_from_tag(struct isci_host *ihost,
3432                                               struct isci_tmf *isci_tmf,
3433                                               u16 tag)
3434{
3435        struct isci_request *ireq;
3436
3437        ireq = isci_request_from_tag(ihost, tag);
3438        ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
3439        set_bit(IREQ_TMF, &ireq->flags);
3440
3441        return ireq;
3442}
3443
3444int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
3445                         struct sas_task *task, u16 tag)
3446{
3447        enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
3448        struct isci_request *ireq;
3449        unsigned long flags;
3450        int ret = 0;
3451
3452        /* do common allocation and init of request object. */
3453        ireq = isci_io_request_from_tag(ihost, task, tag);
3454
3455        status = isci_io_request_build(ihost, ireq, idev);
3456        if (status != SCI_SUCCESS) {
3457                dev_dbg(&ihost->pdev->dev,
3458                         "%s: request_construct failed - status = 0x%x\n",
3459                         __func__,
3460                         status);
3461                return status;
3462        }
3463
3464        spin_lock_irqsave(&ihost->scic_lock, flags);
3465
3466        if (test_bit(IDEV_IO_NCQERROR, &idev->flags)) {
3467
3468                if (isci_task_is_ncq_recovery(task)) {
3469
3470                        /* The device is in an NCQ recovery state.  Issue the
3471                         * request on the task side.  Note that it will
3472                         * complete on the I/O request side because the
3473                         * request was built that way (ie.
3474                         * ireq->is_task_management_request is false).
3475                         */
3476                        status = sci_controller_start_task(ihost,
3477                                                            idev,
3478                                                            ireq);
3479                } else {
3480                        status = SCI_FAILURE;
3481                }
3482        } else {
3483                /* send the request, let the core assign the IO TAG.    */
3484                status = sci_controller_start_io(ihost, idev,
3485                                                  ireq);
3486        }
3487
3488        if (status != SCI_SUCCESS &&
3489            status != SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
3490                dev_dbg(&ihost->pdev->dev,
3491                         "%s: failed request start (0x%x)\n",
3492                         __func__, status);
3493                spin_unlock_irqrestore(&ihost->scic_lock, flags);
3494                return status;
3495        }
3496        /* Either I/O started OK, or the core has signaled that
3497         * the device needs a target reset.
3498         */
3499        if (status != SCI_SUCCESS) {
3500                /* The request did not really start in the
3501                 * hardware, so clear the request handle
3502                 * here so no terminations will be done.
3503                 */
3504                set_bit(IREQ_TERMINATED, &ireq->flags);
3505        }
3506        spin_unlock_irqrestore(&ihost->scic_lock, flags);
3507
3508        if (status ==
3509            SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
3510                /* Signal libsas that we need the SCSI error
3511                 * handler thread to work on this I/O and that
3512                 * we want a device reset.
3513                 */
3514                spin_lock_irqsave(&task->task_state_lock, flags);
3515                task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
3516                spin_unlock_irqrestore(&task->task_state_lock, flags);
3517
3518                /* Cause this task to be scheduled in the SCSI error
3519                 * handler thread.
3520                 */
3521                sas_task_abort(task);
3522
3523                /* Change the status, since we are holding
3524                 * the I/O until it is managed by the SCSI
3525                 * error handler.
3526                 */
3527                status = SCI_SUCCESS;
3528        }
3529
3530        return ret;
3531}
3532