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 * $Id$ 33 */ 34 35 #ifndef SCSI_SRP_H 36 #define SCSI_SRP_H 37 38 /* 39 * Structures and constants for the SCSI RDMA Protocol (SRP) as 40 * defined by the INCITS T10 committee. This file was written using 41 * draft Revision 16a of the SRP standard. 42 */ 43 44 #include <linux/types.h> 45 #include <scsi/scsi.h> 46 47 enum { 48 SRP_LOGIN_REQ = 0x00, 49 SRP_TSK_MGMT = 0x01, 50 SRP_CMD = 0x02, 51 SRP_I_LOGOUT = 0x03, 52 SRP_LOGIN_RSP = 0xc0, 53 SRP_RSP = 0xc1, 54 SRP_LOGIN_REJ = 0xc2, 55 SRP_T_LOGOUT = 0x80, 56 SRP_CRED_REQ = 0x81, 57 SRP_AER_REQ = 0x82, 58 SRP_CRED_RSP = 0x41, 59 SRP_AER_RSP = 0x42 60 }; 61 62 enum { 63 SRP_BUF_FORMAT_DIRECT = 1 << 1, 64 SRP_BUF_FORMAT_INDIRECT = 1 << 2 65 }; 66 67 enum { 68 SRP_NO_DATA_DESC = 0, 69 SRP_DATA_DESC_DIRECT = 1, 70 SRP_DATA_DESC_INDIRECT = 2, 71 SRP_DATA_DESC_IMM = 3, /* new in SRP2 */ 72 }; 73 74 enum { 75 SRP_TSK_ABORT_TASK = 0x01, 76 SRP_TSK_ABORT_TASK_SET = 0x02, 77 SRP_TSK_CLEAR_TASK_SET = 0x04, 78 SRP_TSK_LUN_RESET = 0x08, 79 SRP_TSK_CLEAR_ACA = 0x40 80 }; 81 82 enum srp_login_rej_reason { 83 SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL = 0x00010000, 84 SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES = 0x00010001, 85 SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE = 0x00010002, 86 SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL = 0x00010003, 87 SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT = 0x00010004, 88 SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED = 0x00010005, 89 SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED = 0x00010006 90 }; 91 92 enum { 93 SRP_REV10_IB_IO_CLASS = 0xff00, 94 SRP_REV16A_IB_IO_CLASS = 0x0100 95 }; 96 97 struct srp_direct_buf { 98 __be64 va; 99 __be32 key; 100 __be32 len; 101 }; 102 103 /* 104 * We need the packed attribute because the SRP spec puts the list of 105 * descriptors at an offset of 20, which is not aligned to the size of 106 * struct srp_direct_buf. The whole structure must be packed to avoid 107 * having the 20-byte structure padded to 24 bytes on 64-bit architectures. 108 */ 109 struct srp_indirect_buf { 110 struct srp_direct_buf table_desc __packed __aligned(4); 111 __be32 len; 112 struct srp_direct_buf desc_list[] __packed __aligned(4); 113 }; 114 115 /* Immediate data buffer descriptor as defined in SRP2. */ 116 struct srp_imm_buf { 117 __be32 len; 118 }; 119 120 /* srp_login_req.flags */ 121 enum { 122 SRP_MULTICHAN_SINGLE = 0, 123 SRP_MULTICHAN_MULTI = 1, 124 SRP_IMMED_REQUESTED = 0x80, /* new in SRP2 */ 125 }; 126 127 struct srp_login_req { 128 u8 opcode; 129 u8 reserved1[7]; 130 u64 tag; 131 __be32 req_it_iu_len; 132 u8 reserved2[4]; 133 __be16 req_buf_fmt; 134 u8 req_flags; 135 u8 reserved3[1]; 136 __be16 imm_data_offset; /* new in SRP2 */ 137 u8 reserved4[2]; 138 u8 initiator_port_id[16]; 139 u8 target_port_id[16]; 140 }; 141 142 /** 143 * struct srp_login_req_rdma - RDMA/CM login parameters. 144 * 145 * RDMA/CM over InfiniBand can only carry 92 - 36 = 56 bytes of private 146 * data. The %srp_login_req_rdma structure contains the same information as 147 * %srp_login_req but with the reserved data removed. 148 */ 149 struct srp_login_req_rdma { 150 u64 tag; 151 __be16 req_buf_fmt; 152 u8 req_flags; 153 u8 opcode; 154 __be32 req_it_iu_len; 155 u8 initiator_port_id[16]; 156 u8 target_port_id[16]; 157 __be16 imm_data_offset; 158 u8 reserved[6]; 159 }; 160 161 /* srp_login_rsp.rsp_flags */ 162 enum { 163 SRP_LOGIN_RSP_MULTICHAN_NO_CHAN = 0x0, 164 SRP_LOGIN_RSP_MULTICHAN_TERMINATED = 0x1, 165 SRP_LOGIN_RSP_MULTICHAN_MAINTAINED = 0x2, 166 SRP_LOGIN_RSP_IMMED_SUPP = 0x80, /* new in SRP2 */ 167 }; 168 169 /* 170 * The SRP spec defines the size of the LOGIN_RSP structure to be 52 171 * bytes, so it needs to be packed to avoid having it padded to 56 172 * bytes on 64-bit architectures. 173 */ 174 struct srp_login_rsp { 175 u8 opcode; 176 u8 reserved1[3]; 177 __be32 req_lim_delta; 178 u64 tag __packed __aligned(4); 179 __be32 max_it_iu_len; 180 __be32 max_ti_iu_len; 181 __be16 buf_fmt; 182 u8 rsp_flags; 183 u8 reserved2[25]; 184 }; 185 186 struct srp_login_rej { 187 u8 opcode; 188 u8 reserved1[3]; 189 __be32 reason; 190 u64 tag; 191 u8 reserved2[8]; 192 __be16 buf_fmt; 193 u8 reserved3[6]; 194 }; 195 196 struct srp_i_logout { 197 u8 opcode; 198 u8 reserved[7]; 199 u64 tag; 200 }; 201 202 struct srp_t_logout { 203 u8 opcode; 204 u8 sol_not; 205 u8 reserved[2]; 206 __be32 reason; 207 u64 tag; 208 }; 209 210 struct srp_tsk_mgmt { 211 u8 opcode; 212 u8 sol_not; 213 u8 reserved1[6]; 214 u64 tag; 215 u8 reserved2[4]; 216 struct scsi_lun lun; 217 u8 reserved3[2]; 218 u8 tsk_mgmt_func; 219 u8 reserved4; 220 u64 task_tag; 221 u8 reserved5[8]; 222 }; 223 224 struct srp_cmd { 225 u8 opcode; 226 u8 sol_not; 227 u8 reserved1[3]; 228 u8 buf_fmt; 229 u8 data_out_desc_cnt; 230 u8 data_in_desc_cnt; 231 u64 tag; 232 u8 reserved2[4]; 233 struct scsi_lun lun; 234 u8 reserved3; 235 u8 task_attr; 236 u8 reserved4; 237 u8 add_cdb_len; 238 u8 cdb[16]; 239 u8 add_data[]; 240 }; 241 242 enum { 243 SRP_RSP_FLAG_RSPVALID = 1 << 0, 244 SRP_RSP_FLAG_SNSVALID = 1 << 1, 245 SRP_RSP_FLAG_DOOVER = 1 << 2, 246 SRP_RSP_FLAG_DOUNDER = 1 << 3, 247 SRP_RSP_FLAG_DIOVER = 1 << 4, 248 SRP_RSP_FLAG_DIUNDER = 1 << 5 249 }; 250 251 /* 252 * The SRP spec defines the size of the RSP structure to be 36 bytes, 253 * so it needs to be packed to avoid having it padded to 40 bytes on 254 * 64-bit architectures. 255 */ 256 struct srp_rsp { 257 u8 opcode; 258 u8 sol_not; 259 u8 reserved1[2]; 260 __be32 req_lim_delta; 261 u64 tag __packed __aligned(4); 262 u8 reserved2[2]; 263 u8 flags; 264 u8 status; 265 __be32 data_out_res_cnt; 266 __be32 data_in_res_cnt; 267 __be32 sense_data_len; 268 __be32 resp_data_len; 269 u8 data[]; 270 }; 271 272 struct srp_cred_req { 273 u8 opcode; 274 u8 sol_not; 275 u8 reserved[2]; 276 __be32 req_lim_delta; 277 u64 tag; 278 }; 279 280 struct srp_cred_rsp { 281 u8 opcode; 282 u8 reserved[7]; 283 u64 tag; 284 }; 285 286 /* 287 * The SRP spec defines the fixed portion of the AER_REQ structure to be 288 * 36 bytes, so it needs to be packed to avoid having it padded to 40 bytes 289 * on 64-bit architectures. 290 */ 291 struct srp_aer_req { 292 u8 opcode; 293 u8 sol_not; 294 u8 reserved[2]; 295 __be32 req_lim_delta; 296 u64 tag __packed __aligned(4); 297 u32 reserved2; 298 struct scsi_lun lun; 299 __be32 sense_data_len; 300 u32 reserved3; 301 u8 sense_data[]; 302 }; 303 304 struct srp_aer_rsp { 305 u8 opcode; 306 u8 reserved[7]; 307 u64 tag; 308 }; 309 310 #endif /* SCSI_SRP_H */ 311