hw/scsi/srp.h

   1 /*
   2  * Copyright (c) 2005 Cisco Systems.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  *
  32  */
  33
  34 #ifndef SCSI_SRP_H
  35 #define SCSI_SRP_H
  36
  37 /*
  38  * Structures and constants for the SCSI RDMA Protocol (SRP) as
  39  * defined by the INCITS T10 committee.  This file was written using
  40  * draft Revision 16a of the SRP standard.
  41  */
  42
  43 enum {
  44
  45     SRP_LOGIN_REQ = 0x00,
  46     SRP_TSK_MGMT  = 0x01,
  47     SRP_CMD       = 0x02,
  48     SRP_I_LOGOUT  = 0x03,
  49     SRP_LOGIN_RSP = 0xc0,
  50     SRP_RSP       = 0xc1,
  51     SRP_LOGIN_REJ = 0xc2,
  52     SRP_T_LOGOUT  = 0x80,
  53     SRP_CRED_REQ  = 0x81,
  54     SRP_AER_REQ   = 0x82,
  55     SRP_CRED_RSP  = 0x41,
  56     SRP_AER_RSP   = 0x42
  57 };
  58
  59 enum {
  60     SRP_BUF_FORMAT_DIRECT   = 1 << 1,
  61     SRP_BUF_FORMAT_INDIRECT = 1 << 2
  62 };
  63
  64 enum {
  65     SRP_NO_DATA_DESC       = 0,
  66     SRP_DATA_DESC_DIRECT   = 1,
  67     SRP_DATA_DESC_INDIRECT = 2
  68 };
  69
  70 enum {
  71     SRP_TSK_ABORT_TASK     = 0x01,
  72     SRP_TSK_ABORT_TASK_SET = 0x02,
  73     SRP_TSK_CLEAR_TASK_SET = 0x04,
  74     SRP_TSK_LUN_RESET      = 0x08,
  75     SRP_TSK_CLEAR_ACA      = 0x40
  76 };
  77
  78 enum srp_login_rej_reason {
  79     SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL   = 0x00010000,
  80     SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES     = 0x00010001,
  81     SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE = 0x00010002,
  82     SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL   = 0x00010003,
  83     SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT = 0x00010004,
  84     SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED  = 0x00010005,
  85     SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED      = 0x00010006
  86 };
  87
  88 enum {
  89     SRP_REV10_IB_IO_CLASS  = 0xff00,
  90     SRP_REV16A_IB_IO_CLASS = 0x0100
  91 };
  92
  93 enum {
  94     SRP_TSK_MGMT_COMPLETE       = 0x00,
  95     SRP_TSK_MGMT_FIELDS_INVALID = 0x02,
  96     SRP_TSK_MGMT_NOT_SUPPORTED  = 0x04,
  97     SRP_TSK_MGMT_FAILED         = 0x05
  98 };
  99
 100 struct srp_direct_buf {
 101     uint64_t    va;
 102     uint32_t    key;
 103     uint32_t    len;
 104 };
 105
 106 /*
 107  * We need the packed attribute because the SRP spec puts the list of
 108  * descriptors at an offset of 20, which is not aligned to the size of
 109  * struct srp_direct_buf.  The whole structure must be packed to avoid
 110  * having the 20-byte structure padded to 24 bytes on 64-bit architectures.
 111  */
 112 struct srp_indirect_buf {
 113     struct srp_direct_buf    table_desc;
 114     uint32_t                 len;
 115     struct srp_direct_buf    desc_list[0];
 116 } QEMU_PACKED;
 117
 118 enum {
 119     SRP_MULTICHAN_SINGLE = 0,
 120     SRP_MULTICHAN_MULTI  = 1
 121 };
 122
 123 struct srp_login_req {
 124     uint8_t    opcode;
 125     uint8_t    reserved1[7];
 126     uint64_t   tag;
 127     uint32_t   req_it_iu_len;
 128     uint8_t    reserved2[4];
 129     uint16_t   req_buf_fmt;
 130     uint8_t    req_flags;
 131     uint8_t    reserved3[5];
 132     uint8_t    initiator_port_id[16];
 133     uint8_t    target_port_id[16];
 134 };
 135
 136 /*
 137  * The SRP spec defines the size of the LOGIN_RSP structure to be 52
 138  * bytes, so it needs to be packed to avoid having it padded to 56
 139  * bytes on 64-bit architectures.
 140  */
 141 struct srp_login_rsp {
 142     uint8_t    opcode;
 143     uint8_t    reserved1[3];
 144     uint32_t   req_lim_delta;
 145     uint64_t   tag;
 146     uint32_t   max_it_iu_len;
 147     uint32_t   max_ti_iu_len;
 148     uint16_t   buf_fmt;
 149     uint8_t    rsp_flags;
 150     uint8_t    reserved2[25];
 151 } QEMU_PACKED;
 152
 153 struct srp_login_rej {
 154     uint8_t    opcode;
 155     uint8_t    reserved1[3];
 156     uint32_t   reason;
 157     uint64_t   tag;
 158     uint8_t    reserved2[8];
 159     uint16_t   buf_fmt;
 160     uint8_t    reserved3[6];
 161 };
 162
 163 struct srp_i_logout {
 164     uint8_t    opcode;
 165     uint8_t    reserved[7];
 166     uint64_t   tag;
 167 };
 168
 169 struct srp_t_logout {
 170     uint8_t    opcode;
 171     uint8_t    sol_not;
 172     uint8_t    reserved[2];
 173     uint32_t   reason;
 174     uint64_t   tag;
 175 };
 176
 177 /*
 178  * We need the packed attribute because the SRP spec only aligns the
 179  * 8-byte LUN field to 4 bytes.
 180  */
 181 struct srp_tsk_mgmt {
 182     uint8_t    opcode;
 183     uint8_t    sol_not;
 184     uint8_t    reserved1[6];
 185     uint64_t   tag;
 186     uint8_t    reserved2[4];
 187     uint64_t   lun;
 188     uint8_t    reserved3[2];
 189     uint8_t    tsk_mgmt_func;
 190     uint8_t    reserved4;
 191     uint64_t   task_tag;
 192     uint8_t    reserved5[8];
 193 } QEMU_PACKED;
 194
 195 /*
 196  * We need the packed attribute because the SRP spec only aligns the
 197  * 8-byte LUN field to 4 bytes.
 198  */
 199 struct srp_cmd {
 200     uint8_t    opcode;
 201     uint8_t    sol_not;
 202     uint8_t    reserved1[3];
 203     uint8_t    buf_fmt;
 204     uint8_t    data_out_desc_cnt;
 205     uint8_t    data_in_desc_cnt;
 206     uint64_t   tag;
 207     uint8_t    reserved2[4];
 208     uint64_t   lun;
 209     uint8_t    reserved3;
 210     uint8_t    task_attr;
 211     uint8_t    reserved4;
 212     uint8_t    add_cdb_len;
 213     uint8_t    cdb[16];
 214     uint8_t    add_data[0];
 215 } QEMU_PACKED;
 216
 217 enum {
 218     SRP_RSP_FLAG_RSPVALID = 1 << 0,
 219     SRP_RSP_FLAG_SNSVALID = 1 << 1,
 220     SRP_RSP_FLAG_DOOVER   = 1 << 2,
 221     SRP_RSP_FLAG_DOUNDER  = 1 << 3,
 222     SRP_RSP_FLAG_DIOVER   = 1 << 4,
 223     SRP_RSP_FLAG_DIUNDER  = 1 << 5
 224 };
 225
 226 /*
 227  * The SRP spec defines the size of the RSP structure to be 36 bytes,
 228  * so it needs to be packed to avoid having it padded to 40 bytes on
 229  * 64-bit architectures.
 230  */
 231 struct srp_rsp {
 232     uint8_t    opcode;
 233     uint8_t    sol_not;
 234     uint8_t    reserved1[2];
 235     uint32_t   req_lim_delta;
 236     uint64_t   tag;
 237     uint8_t    reserved2[2];
 238     uint8_t    flags;
 239     uint8_t    status;
 240     uint32_t   data_out_res_cnt;
 241     uint32_t   data_in_res_cnt;
 242     uint32_t   sense_data_len;
 243     uint32_t   resp_data_len;
 244     uint8_t    data[0];
 245 } QEMU_PACKED;
 246
 247 #endif /* SCSI_SRP_H */