sys/dev/isci/scil/sati_passthrough.c

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license.  When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  * GPL LICENSE SUMMARY
   6  *
   7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of version 2 of the GNU General Public License as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called LICENSE.GPL.
  23  *
  24  * BSD LICENSE
  25  *
  26  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  27  * All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  *
  33  *   * Redistributions of source code must retain the above copyright
  34  *     notice, this list of conditions and the following disclaimer.
  35  *   * Redistributions in binary form must reproduce the above copyright
  36  *     notice, this list of conditions and the following disclaimer in
  37  *     the documentation and/or other materials provided with the
  38  *     distribution.
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  41  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  42  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  43  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  44  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  46  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  47  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  48  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  49  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  50  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  51  */
  52
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  55
  56 /**
  57  * @file
  58  * @brief This file contains the method implementations required to
  59  *        translate the SCSI passthru command.
  60  */
  61
  62 #if !defined(DISABLE_SATI_PASSTHROUGH)
  63
  64 #include <dev/isci/scil/sati.h>
  65 #include <dev/isci/scil/sati_passthrough.h>
  66 #include <dev/isci/scil/sati_util.h>
  67 #include <dev/isci/scil/sati_callbacks.h>
  68 #include <dev/isci/scil/intel_ata.h>
  69
  70 #define PASSTHROUGH_CDB_PROTOCOL_MASK       0x1E
  71 #define PASSTHROUGH_CDB_EXTEND_MASK         0x1
  72 #define PASSTHROUGH_CDB_CK_COND_MASK        0x20
  73 #define PASSTHROUGH_CDB_T_DIR_MASK          0x8
  74
  75 #define PASSTHROUGH_ISOLATE_BITS(cdb, index, mask, shift) (((sati_get_cdb_byte(cdb, index) & mask) >> shift))
  76
  77 #define PASSTHROUGH_CDB_PROTOCOL(cdb)      PASSTHROUGH_ISOLATE_BITS(cdb, 1, PASSTHROUGH_CDB_PROTOCOL_MASK, 1)
  78 #define PASSTHROUGH_CDB_EXTEND(cdb)        PASSTHROUGH_ISOLATE_BITS(cdb, 1, PASSTHROUGH_CDB_EXTEND_MASK, 0)
  79 #define PASSTHROUGH_CDB_CK_COND(cdb)       PASSTHROUGH_ISOLATE_BITS(cdb, 2, PASSTHROUGH_CDB_CK_COND_MASK, 5)
  80 #define PASSTHROUGH_CDB_T_DIR(cdb)         PASSTHROUGH_ISOLATE_BITS(cdb, 2, PASSTHROUGH_CDB_T_DIR_MASK, 3)
  81
  82 #define PASSTHROUGH_CDB_MULTIPLE_COUNT(cdb)         (sati_get_cdb_byte(cdb, 1) >> 5)
  83 #define PASSTHROUGH_CDB_COMMAND(cdb, index)         sati_get_cdb_byte(cdb, index)
  84
  85 // Protocols
  86 #define PASSTHROUGH_PIO_DATA_IN            0x4
  87 #define PASSTHROUGH_PIO_DATA_OUT           0x5
  88 #define PASSTHROUGH_DMA                    0x6
  89 #define PASSTHROUGH_UDMA_DATA_IN           0xA
  90 #define PASSTHROUGH_UDMA_DATA_OUT          0xB
  91 #define PASSTHROUGH_RETURN_RESPONSE        0xF
  92
  93 /**
  94 * @brief This function will check the multiple_count field in the SCSI CDB
  95 *        and if multiple_count is nonzero the function will check the
  96 *        ATA command code. Only Read and Write Multiple commands are allowed
  97 *        when multiple_count is a nonzero value.
  98 *
  99 * @param[in]     cdb The SCSI cdb for the ATA pass-through command
 100 *
 101 * @return BOOL
 102   @retval TRUE - multiple_count is nonzero with a unsupported command
 103   @retval FALSE - multiple_count is zero or the command supports a nonzero value
 104 */
 105 static
 106 BOOL sati_passthrough_multiple_count_error(
 107    U8 *     cdb
 108 )
 109 {
 110    U8 ata_command_code;
 111
 112    if(PASSTHROUGH_CDB_MULTIPLE_COUNT(cdb) > 0)
 113    {
 114       if(sati_get_cdb_byte(cdb, 0 ) == SCSI_ATA_PASSTHRU_12)
 115       {
 116          ata_command_code = PASSTHROUGH_CDB_COMMAND(cdb, 9);
 117       }
 118       else
 119       {
 120          ata_command_code = PASSTHROUGH_CDB_COMMAND(cdb, 14);
 121       }
 122
 123       switch(ata_command_code)
 124       {  //MULTICOUNT bit is supported
 125          case ATA_READ_MULTIPLE:
 126          case ATA_READ_MULTIPLE_EXT:
 127          case ATA_WRITE_MULTIPLE:
 128          case ATA_WRITE_MULTIPLE_EXT:
 129          case ATA_WRITE_MULTIPLE_FUA_EXT:
 130             return FALSE;
 131          break;
 132
 133          default:
 134             return TRUE;
 135       }
 136    }
 137    //MULTICOUNT bit is not set
 138    return FALSE;
 139 }
 140
 141 /**
 142  * @brief This method will construct the sense data buffer in the user's
 143  *        sense data buffer location.  Additionally, it will set the user's
 144  *        SCSI status.
 145  *
 146  * @param[in]     sequence This parameter specifies the translation sequence
 147  *                for which to construct the sense data.
 148  * @param[in]     register_fis This parameter specifies the fis from which
 149  *                to get the data.
 150  * @param[in,out] scsi_io This parameter specifies the user's IO request
 151  *                for which to construct the sense data.
 152  * @param[in]     scsi_status This parameter specifies the SCSI status
 153  *                value for the user's IO request.
 154  * @param[in]     sense_key This parameter specifies the sense key to
 155  *                be set for the user's IO request.
 156  * @param[in]     additional_sense_code This parameter specifies the
 157  *                additional sense code (ASC) key to be set for the user's
 158  *                IO request.
 159  * @param[in]     additional_sense_code_qualifier This parameter specifies
 160  *                the additional sense code qualifier (ASCQ) key to be set
 161  *                for the user's IO request.
 162  *
 163  * @return none
 164  */
 165 static
 166 void sati_passthrough_construct_sense(
 167    SATI_TRANSLATOR_SEQUENCE_T * sequence,
 168    U8                         * register_fis,
 169    void                       * scsi_io,
 170    U8                           scsi_status,
 171    U8                           sense_key,
 172    U8                           additional_sense_code,
 173    U8                           additional_sense_code_qualifier
 174 )
 175 {
 176    U8                    * sense_data;
 177    U32                     sense_len;
 178    U8                    * cdb;
 179    unsigned char           sector_count_upper;
 180    unsigned char           lba_upper;
 181
 182 #ifdef SATI_TRANSPORT_SUPPORTS_SAS
 183    SCI_SSP_RESPONSE_IU_T * rsp_iu = (SCI_SSP_RESPONSE_IU_T*)
 184                                     sati_cb_get_response_iu_address(scsi_io);
 185
 186    sati_scsi_common_response_iu_construct(
 187       rsp_iu,
 188       scsi_status,
 189       SCSI_FIXED_SENSE_DATA_BASE_LENGTH,
 190       SCSI_RESPONSE_DATA_PRES_SENSE_DATA
 191    );
 192
 193    sense_data                   = (U8*) rsp_iu->data;
 194    sense_len                    = SSP_RESPONSE_IU_MAX_DATA * 4;  // dwords to bytes
 195 #else
 196    sense_data = sati_cb_get_sense_data_address(scsi_io);
 197    sense_len  = sati_cb_get_sense_data_length(scsi_io);
 198 #endif // SATI_TRANSPORT_SUPPORTS_SAS
 199
 200    sati_scsi_sense_data_construct(
 201       sequence,
 202       scsi_io,
 203       scsi_status,
 204       sense_key,
 205       additional_sense_code,
 206       additional_sense_code_qualifier
 207    );
 208
 209    cdb = sati_cb_get_cdb_address(scsi_io);
 210
 211    if (sati_get_ata_sector_count_ext(register_fis) != 0) {
 212       sector_count_upper = 1;
 213    } else {
 214        sector_count_upper = 0;
 215    }
 216
 217    if (sati_get_ata_lba_high_ext(register_fis) != 0 ||
 218        sati_get_ata_lba_mid_ext(register_fis) != 0 ||
 219        sati_get_ata_lba_low_ext(register_fis) != 0) {
 220       lba_upper = 1;
 221    } else {
 222        lba_upper = 0;
 223    }
 224
 225    // Information section
 226    sati_set_sense_data_byte(sense_data, sense_len, 3,  (U8)sati_get_ata_error(register_fis));
 227    sati_set_sense_data_byte(sense_data, sense_len, 4,  (U8)sati_get_ata_status(register_fis));
 228    sati_set_sense_data_byte(sense_data, sense_len, 5,  sati_get_ata_device(register_fis));
 229    sati_set_sense_data_byte(sense_data, sense_len, 6,  sati_get_ata_sector_count(register_fis));
 230
 231    // Command specific section
 232    sati_set_sense_data_byte(sense_data, sense_len, 8,  (PASSTHROUGH_CDB_EXTEND(cdb) << 7) | (sector_count_upper << 6) | (lba_upper << 5));
 233    sati_set_sense_data_byte(sense_data, sense_len, 9,  sati_get_ata_lba_high(register_fis));
 234    sati_set_sense_data_byte(sense_data, sense_len, 10, sati_get_ata_lba_mid(register_fis));
 235    sati_set_sense_data_byte(sense_data, sense_len, 11, sati_get_ata_lba_low(register_fis));
 236
 237    sequence->is_sense_response_set = TRUE;
 238 }
 239
 240 /**
 241  * @brief This method will verify that the T_DIR bit matches the protocol bit.
 242  *        It will additionally set the direction on the sequence.
 243  *
 244  * @param[in,out] sequence This parameter specifies the translation sequence
 245  *                for which to construct the sense data.
 246  * @param[in]     cdb The CDB containing the passthrough command
 247  *
 248  * @return none
 249  */
 250 static
 251 SATI_STATUS sati_passthrough_check_direction(
 252    SATI_TRANSLATOR_SEQUENCE_T * sequence,
 253    U8           * cdb
 254 )
 255 {
 256    if ((sequence->protocol == PASSTHROUGH_PIO_DATA_IN) ||
 257        (sequence->protocol == PASSTHROUGH_UDMA_DATA_IN))
 258    {
 259       if (PASSTHROUGH_CDB_T_DIR(cdb) == 0x0)
 260       {
 261          return SATI_FAILURE;
 262       }
 263       else
 264       {
 265          sequence->data_direction = SATI_DATA_DIRECTION_IN;
 266       }
 267    }
 268    else if ((sequence->protocol == PASSTHROUGH_PIO_DATA_OUT) ||
 269             (sequence->protocol == PASSTHROUGH_UDMA_DATA_OUT))
 270    {
 271       if (PASSTHROUGH_CDB_T_DIR(cdb) == 0x1)
 272       {
 273          return SATI_FAILURE;
 274       }
 275       else
 276       {
 277          sequence->data_direction = SATI_DATA_DIRECTION_OUT;
 278       }
 279    }
 280    else
 281    {
 282       sequence->data_direction = SATI_DATA_DIRECTION_NONE;
 283    }
 284
 285    return SATI_COMPLETE;
 286 }
 287
 288 //******************************************************************************
 289 //* P U B L I C   M E T H O D S
 290 //******************************************************************************
 291
 292 /**
 293  * @brief This method will translate the SCSI Passthrough command
 294  *        into the corresponding ATA command.
 295  *
 296  * @return Indicate if the command translation succeeded.
 297  * @retval SATI_SUCCESS This is returned if the command translation was
 298  *         successful.
 299  * @retval SATI_FAILURE This is returned if the command translation was
 300  *         unsuccessful
 301  */
 302
 303 SATI_STATUS sati_passthrough_12_translate_command(
 304    SATI_TRANSLATOR_SEQUENCE_T * sequence,
 305    void                       * scsi_io,
 306    void                       * ata_io
 307 )
 308 {
 309    SATI_STATUS   status;
 310    U8          * cdb;
 311    U8          * register_fis;
 312
 313    status = SATI_FAILURE;
 314
 315    sequence->type = SATI_SEQUENCE_ATA_PASSTHROUGH_12;
 316    sequence->state = SATI_SEQUENCE_STATE_TRANSLATE_DATA;
 317
 318    cdb = sati_cb_get_cdb_address(scsi_io);
 319    sequence->protocol = PASSTHROUGH_CDB_PROTOCOL (cdb);
 320    register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
 321
 322    /*
 323     * CAM will send passthrough commands with protocol set to multiword
 324     * DMA even though no multiword DMA mode is selected on the device.
 325     * This is because some controllers (LSI) will only accept
 326     * ATA_PASSTHROUGH commands with DMA mode - not UDMA_IN/OUT.
 327     *
 328     * Since isci does not support multiword DMA, fix this up here.
 329     */
 330    if (sequence->protocol == PASSTHROUGH_DMA)
 331    {
 332       if (PASSTHROUGH_CDB_T_DIR(cdb) == 0x1)
 333       {
 334          sequence->protocol = PASSTHROUGH_UDMA_DATA_IN;
 335       }
 336       else
 337       {
 338          sequence->protocol = PASSTHROUGH_UDMA_DATA_OUT;
 339       }
 340    }
 341
 342    if (sati_passthrough_check_direction(sequence, cdb) != SATI_COMPLETE
 343        || sati_passthrough_multiple_count_error(cdb)
 344       )
 345    {
 346       // Fail due to mismatch
 347       sati_scsi_sense_data_construct(
 348          sequence,
 349          scsi_io,
 350          SCSI_STATUS_CHECK_CONDITION,
 351          SCSI_SENSE_ILLEGAL_REQUEST,
 352          SCSI_ASC_INVALID_FIELD_IN_CDB,
 353          SCSI_ASCQ_INVALID_FIELD_IN_CDB
 354       );
 355       return SATI_FAILURE_CHECK_RESPONSE_DATA;
 356    }
 357
 358    sati_set_ata_features(register_fis, sati_get_cdb_byte(cdb, 3));
 359    sati_set_ata_sector_count(register_fis, sati_get_cdb_byte(cdb, 4));
 360    sati_set_ata_lba_low(register_fis, sati_get_cdb_byte(cdb, 5));
 361    sati_set_ata_lba_mid(register_fis, sati_get_cdb_byte(cdb, 6));
 362    sati_set_ata_lba_high(register_fis, sati_get_cdb_byte(cdb, 7));
 363    sati_set_ata_device_head(register_fis, sati_get_cdb_byte(cdb, 8));
 364    sati_set_ata_command(register_fis, sati_get_cdb_byte(cdb, 9));
 365
 366    sequence->state = SATI_SEQUENCE_STATE_AWAIT_RESPONSE;
 367
 368    return SATI_SUCCESS;
 369 }
 370
 371 /**
 372  * @brief This method will translate the SCSI Passthrough command
 373  *        into the corresponding ATA command.
 374  *
 375  * @return Indicate if the command translation succeeded.
 376  * @retval SATI_SUCCESS This is returned if the command translation was
 377  *         successful.
 378  * @retval SATI_FAILURE This is returned if the command translation was
 379  *         unsuccessful
 380  */
 381 SATI_STATUS sati_passthrough_16_translate_command(
 382    SATI_TRANSLATOR_SEQUENCE_T * sequence,
 383    void                       * scsi_io,
 384    void                       * ata_io
 385 )
 386 {
 387    SATI_STATUS   status;
 388    U8          * cdb;
 389    U8          * register_fis;
 390
 391    status = SATI_FAILURE;
 392
 393    sequence->type = SATI_SEQUENCE_ATA_PASSTHROUGH_16;
 394    sequence->state = SATI_SEQUENCE_STATE_TRANSLATE_DATA;
 395
 396    cdb = sati_cb_get_cdb_address(scsi_io);
 397    sequence->protocol = PASSTHROUGH_CDB_PROTOCOL(cdb);
 398    register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
 399
 400    /*
 401     * CAM will send passthrough commands with protocol set to multiword
 402     * DMA even though no multiword DMA mode is selected on the device.
 403     * This is because some controllers (LSI) will only accept
 404     * ATA_PASSTHROUGH commands with DMA mode - not UDMA_IN/OUT.
 405     *
 406     * Since isci does not support multiword DMA, fix this up here.
 407     */
 408    if (sequence->protocol == PASSTHROUGH_DMA)
 409    {
 410       if (PASSTHROUGH_CDB_T_DIR(cdb) == 0x1)
 411       {
 412          sequence->protocol = PASSTHROUGH_UDMA_DATA_IN;
 413       }
 414       else
 415       {
 416          sequence->protocol = PASSTHROUGH_UDMA_DATA_OUT;
 417       }
 418    }
 419
 420    if (sati_passthrough_check_direction(sequence, cdb) != SATI_COMPLETE
 421        || sati_passthrough_multiple_count_error(cdb)
 422       )
 423    {
 424       // Fail due to mismatch
 425       sati_scsi_sense_data_construct(
 426          sequence,
 427          scsi_io,
 428          SCSI_STATUS_CHECK_CONDITION,
 429          SCSI_SENSE_ILLEGAL_REQUEST,
 430          SCSI_ASC_INVALID_FIELD_IN_CDB,
 431          SCSI_ASCQ_INVALID_FIELD_IN_CDB
 432       );
 433       return SATI_FAILURE_CHECK_RESPONSE_DATA;
 434    }
 435
 436    if (PASSTHROUGH_CDB_EXTEND(cdb) == 1)
 437    {
 438       sati_set_ata_features_exp(register_fis, sati_get_cdb_byte(cdb, 3));
 439       sati_set_ata_sector_count_exp(register_fis, sati_get_cdb_byte(cdb, 5));
 440       sati_set_ata_lba_low_exp(register_fis, sati_get_cdb_byte(cdb, 7));
 441       sati_set_ata_lba_mid_exp(register_fis, sati_get_cdb_byte(cdb, 9));
 442       sati_set_ata_lba_high_exp(register_fis, sati_get_cdb_byte(cdb, 11));
 443    }
 444    sati_set_ata_features(register_fis, sati_get_cdb_byte(cdb, 4));
 445    sati_set_ata_sector_count(register_fis, sati_get_cdb_byte(cdb, 6));
 446    sati_set_ata_lba_low(register_fis, sati_get_cdb_byte(cdb, 8));
 447    sati_set_ata_lba_mid(register_fis, sati_get_cdb_byte(cdb, 10));
 448    sati_set_ata_lba_high(register_fis, sati_get_cdb_byte(cdb, 12));
 449    sati_set_ata_device_head(register_fis, sati_get_cdb_byte(cdb, 13));
 450    sati_set_ata_command(register_fis, sati_get_cdb_byte(cdb, 14));
 451
 452    sequence->state = SATI_SEQUENCE_STATE_AWAIT_RESPONSE;
 453
 454    return SATI_SUCCESS;
 455 }
 456
 457 /**
 458  * @brief This method will translate the ATA command
 459  *        response
 460  *
 461  * @return Indicate if the command translation succeeded.
 462  * @retval SATI_COMPLETE This is returned if the command translation was
 463  *         successful.
 464  * @retval SATI_FAILURE This is returned if the command translation was
 465  *         unsuccessful
 466  */
 467 SATI_STATUS sati_passthrough_translate_response(
 468    SATI_TRANSLATOR_SEQUENCE_T * sequence,
 469    void                       * scsi_io,
 470    void                       * ata_io
 471 )
 472 {
 473    U8 * cdb;
 474    U8 * register_fis;
 475
 476    cdb = sati_cb_get_cdb_address(scsi_io);
 477    register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
 478
 479    // Check for device errors
 480    if (sati_get_ata_status(register_fis) & ATA_STATUS_REG_ERROR_BIT)
 481    {
 482       sati_translate_error(sequence, scsi_io, (U8)sati_get_ata_error(register_fis));
 483       return SATI_FAILURE_CHECK_RESPONSE_DATA;
 484    }
 485
 486    // If the user set the check condition bit, fill out the sense data
 487    if (PASSTHROUGH_CDB_CK_COND(cdb) ||
 488        PASSTHROUGH_CDB_PROTOCOL(cdb) == PASSTHROUGH_RETURN_RESPONSE)
 489    {
 490       sati_passthrough_construct_sense(
 491          sequence,
 492          register_fis,
 493          scsi_io,
 494          SCSI_STATUS_CHECK_CONDITION,
 495          SCSI_SENSE_RECOVERED_ERROR,
 496          SCSI_ASC_NO_ADDITIONAL_SENSE,
 497          SCSI_ASCQ_ATA_PASS_THROUGH_INFORMATION_AVAILABLE
 498       );
 499    }
 500
 501    sequence->state = SATI_SEQUENCE_STATE_FINAL;
 502
 503    return SATI_COMPLETE;
 504 }
 505
 506 #endif // !defined(DISABLE_SATI_PASSTHROUGH)