1 /*****************************************************************************/ 2 /* srp.h -- SCSI RDMA Protocol definitions */ 3 /* */ 4 /* Written By: Colin Devilbis, IBM Corporation */ 5 /* */ 6 /* Copyright (C) 2003 IBM Corporation */ 7 /* */ 8 /* This program is free software; you can redistribute it and/or modify */ 9 /* it under the terms of the GNU General Public License as published by */ 10 /* the Free Software Foundation; either version 2 of the License, or */ 11 /* (at your option) any later version. */ 12 /* */ 13 /* This program is distributed in the hope that it will be useful, */ 14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ 15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ 16 /* GNU 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ 21 /* */ 22 /* */ 23 /* This file contains structures and definitions for IBM RPA (RS/6000 */ 24 /* platform architecture) implementation of the SRP (SCSI RDMA Protocol) */ 25 /* standard. SRP is used on IBM iSeries and pSeries platforms to send SCSI */ 26 /* commands between logical partitions. */ 27 /* */ 28 /* SRP Information Units (IUs) are sent on a "Command/Response Queue" (CRQ) */ 29 /* between partitions. The definitions in this file are architected, */ 30 /* and cannot be changed without breaking compatibility with other versions */ 31 /* of Linux and other operating systems (AIX, OS/400) that talk this protocol*/ 32 /* between logical partitions */ 33 /*****************************************************************************/ 34 #ifndef VIOSRP_H 35 #define VIOSRP_H 36 #include <scsi/srp.h> 37 38 #define SRP_VERSION "16.a" 39 #define SRP_MAX_IU_LEN 256 40 #define SRP_MAX_LOC_LEN 32 41 42 union srp_iu { 43 struct srp_login_req login_req; 44 struct srp_login_rsp login_rsp; 45 struct srp_login_rej login_rej; 46 struct srp_i_logout i_logout; 47 struct srp_t_logout t_logout; 48 struct srp_tsk_mgmt tsk_mgmt; 49 struct srp_cmd cmd; 50 struct srp_rsp rsp; 51 u8 reserved[SRP_MAX_IU_LEN]; 52 }; 53 54 enum viosrp_crq_formats { 55 VIOSRP_SRP_FORMAT = 0x01, 56 VIOSRP_MAD_FORMAT = 0x02, 57 VIOSRP_OS400_FORMAT = 0x03, 58 VIOSRP_AIX_FORMAT = 0x04, 59 VIOSRP_LINUX_FORMAT = 0x06, 60 VIOSRP_INLINE_FORMAT = 0x07 61 }; 62 63 enum viosrp_crq_status { 64 VIOSRP_OK = 0x0, 65 VIOSRP_NONRECOVERABLE_ERR = 0x1, 66 VIOSRP_VIOLATES_MAX_XFER = 0x2, 67 VIOSRP_PARTNER_PANIC = 0x3, 68 VIOSRP_DEVICE_BUSY = 0x8, 69 VIOSRP_ADAPTER_FAIL = 0x10, 70 VIOSRP_OK2 = 0x99, 71 }; 72 73 struct viosrp_crq { 74 u8 valid; /* used by RPA */ 75 u8 format; /* SCSI vs out-of-band */ 76 u8 reserved; 77 u8 status; /* non-scsi failure? (e.g. DMA failure) */ 78 u16 timeout; /* in seconds */ 79 u16 IU_length; /* in bytes */ 80 u64 IU_data_ptr; /* the TCE for transferring data */ 81 }; 82 83 /* MADs are Management requests above and beyond the IUs defined in the SRP 84 * standard. 85 */ 86 enum viosrp_mad_types { 87 VIOSRP_EMPTY_IU_TYPE = 0x01, 88 VIOSRP_ERROR_LOG_TYPE = 0x02, 89 VIOSRP_ADAPTER_INFO_TYPE = 0x03, 90 VIOSRP_HOST_CONFIG_TYPE = 0x04, 91 VIOSRP_CAPABILITIES_TYPE = 0x05, 92 VIOSRP_ENABLE_FAST_FAIL = 0x08, 93 }; 94 95 enum viosrp_mad_status { 96 VIOSRP_MAD_SUCCESS = 0x00, 97 VIOSRP_MAD_NOT_SUPPORTED = 0xF1, 98 VIOSRP_MAD_FAILED = 0xF7, 99 }; 100 101 enum viosrp_capability_type { 102 MIGRATION_CAPABILITIES = 0x01, 103 RESERVATION_CAPABILITIES = 0x02, 104 }; 105 106 enum viosrp_capability_support { 107 SERVER_DOES_NOT_SUPPORTS_CAP = 0x0, 108 SERVER_SUPPORTS_CAP = 0x01, 109 SERVER_CAP_DATA = 0x02, 110 }; 111 112 enum viosrp_reserve_type { 113 CLIENT_RESERVE_SCSI_2 = 0x01, 114 }; 115 116 enum viosrp_capability_flag { 117 CLIENT_MIGRATED = 0x01, 118 CLIENT_RECONNECT = 0x02, 119 CAP_LIST_SUPPORTED = 0x04, 120 CAP_LIST_DATA = 0x08, 121 }; 122 123 /* 124 * Common MAD header 125 */ 126 struct mad_common { 127 u32 type; 128 u16 status; 129 u16 length; 130 u64 tag; 131 }; 132 133 /* 134 * All SRP (and MAD) requests normally flow from the 135 * client to the server. There is no way for the server to send 136 * an asynchronous message back to the client. The Empty IU is used 137 * to hang out a meaningless request to the server so that it can respond 138 * asynchrouously with something like a SCSI AER 139 */ 140 struct viosrp_empty_iu { 141 struct mad_common common; 142 u64 buffer; 143 u32 port; 144 }; 145 146 struct viosrp_error_log { 147 struct mad_common common; 148 u64 buffer; 149 }; 150 151 struct viosrp_adapter_info { 152 struct mad_common common; 153 u64 buffer; 154 }; 155 156 struct viosrp_host_config { 157 struct mad_common common; 158 u64 buffer; 159 }; 160 161 struct viosrp_fast_fail { 162 struct mad_common common; 163 }; 164 165 struct viosrp_capabilities { 166 struct mad_common common; 167 u64 buffer; 168 }; 169 170 struct mad_capability_common { 171 u32 cap_type; 172 u16 length; 173 u16 server_support; 174 }; 175 176 struct mad_reserve_cap { 177 struct mad_capability_common common; 178 u32 type; 179 }; 180 181 struct mad_migration_cap { 182 struct mad_capability_common common; 183 u32 ecl; 184 }; 185 186 struct capabilities{ 187 u32 flags; 188 char name[SRP_MAX_LOC_LEN]; 189 char loc[SRP_MAX_LOC_LEN]; 190 struct mad_migration_cap migration; 191 struct mad_reserve_cap reserve; 192 }; 193 194 union mad_iu { 195 struct viosrp_empty_iu empty_iu; 196 struct viosrp_error_log error_log; 197 struct viosrp_adapter_info adapter_info; 198 struct viosrp_host_config host_config; 199 struct viosrp_fast_fail fast_fail; 200 struct viosrp_capabilities capabilities; 201 }; 202 203 union viosrp_iu { 204 union srp_iu srp; 205 union mad_iu mad; 206 }; 207 208 struct mad_adapter_info_data { 209 char srp_version[8]; 210 char partition_name[96]; 211 u32 partition_number; 212 u32 mad_version; 213 u32 os_type; 214 u32 port_max_txu[8]; /* per-port maximum transfer */ 215 }; 216 217 #endif 218