1 /* $FreeBSD: src/sys/dev/asr/i2odep.h,v 1.1.2.1 2000/09/21 20:33:50 msmith Exp $ */ 2 /* $DragonFly: src/sys/dev/raid/asr/i2odep.h,v 1.2 2003/06/17 04:28:22 dillon Exp $ */ 3 /**************************************************************************** 4 * 5 * Copyright (c) 1996-2000 Distributed Processing Technology Corporation 6 * Copyright (c) 2000 Adaptec Corporation. 7 * All rights reserved. 8 * 9 * Copyright (c) 1998 I2O Special Interest Group (I2O SIG) 10 * All rights reserved 11 * 12 * Redistribution and use in source form, with or without modification, are 13 * permitted provided that redistributions of source code must retain the 14 * above copyright notice, this list of conditions and the following disclaimer. 15 * 16 * This software is provided `as is' by Distributed Processing Technology and 17 * any express or implied warranties, including, but not limited to, the 18 * implied warranties of merchantability and fitness for a particular purpose, 19 * are disclaimed. In no event shall Distributed Processing Technology be 20 * liable for any direct, indirect, incidental, special, exemplary or 21 * consequential damages (including, but not limited to, procurement of 22 * substitute goods or services; loss of use, data, or profits; or business 23 * interruptions) however caused and on any theory of liability, whether in 24 * contract, strict liability, or tort (including negligence or otherwise) 25 * arising in any way out of the use of this driver software, even if advised 26 * of the possibility of such damage. 27 * 28 * This information is provided on an as-is basis without warranty of any 29 * kind, either express or implied, including but not limited to, implied 30 * warranties or merchantability and fitness for a particular purpose. I2O SIG 31 * does not warrant that this program will meet the user's requirements or 32 * that the operation of these programs will be uninterrupted or error-free. 33 * The I2O SIG disclaims all liability, including liability for infringement 34 * of any proprietary rights, relating to implementation of information in 35 * this specification. The I2O SIG does not warrant or represent that such 36 * implementations(s) will not infringe such rights. Acceptance and use of 37 * this program constitutes the user's understanding that he will have no 38 * recourse to I2O SIG for any actual or consequential damages including, but 39 * not limited to, loss profits arising out of use or inability to use this 40 * program. 41 * 42 * This information is provided for the purpose of recompilation of the 43 * driver code provided by Distributed Processing Technology only. It is 44 * NOT to be used for any other purpose. 45 * 46 * To develop other products based upon I2O definitions, it is necessary to 47 * become a "Registered Developer" of the I2O SIG. This can be done by calling 48 * 415-750-8352 in the US, or via http://www.i2osig.org. 49 * 50 **************************************************************************/ 51 52 /* 53 * This template provides place holders for architecture and compiler 54 * dependencies. It should be filled in and renamed as i2odep.h. 55 * i2odep.h is included by i2otypes.h. <xxx> marks the places to fill. 56 */ 57 58 #ifndef __INCi2odeph 59 #define __INCi2odeph 60 61 #define I2ODEP_REV 1_5_4 62 63 /* 64 * Pragma macros. These are to assure appropriate alignment between 65 * host/IOP as defined by the I2O Specification. Each one of the shared 66 * header files includes these macros. 67 */ 68 69 #define PRAGMA_ALIGN_PUSH 70 #define PRAGMA_ALIGN_POP 71 #define PRAGMA_PACK_PUSH 72 #define PRAGMA_PACK_POP 73 74 /* Setup the basics */ 75 76 typedef signed char S8; 77 typedef signed short S16; 78 79 typedef unsigned char U8; 80 typedef unsigned short U16; 81 82 typedef unsigned long U32; 83 typedef unsigned short S32; 84 85 86 /* Bitfields */ 87 88 #if (defined(__BORLANDC__)) 89 typedef U16 BF; 90 #else 91 typedef U32 BF; 92 #endif 93 94 95 /* VOID */ 96 97 #ifndef __VOID 98 #if (defined(_DPT_ARC)) 99 # define VOID void 100 #else 101 typedef void VOID; 102 #endif 103 #define __VOID 104 #endif 105 106 107 /* Boolean */ 108 109 #ifndef __BOOL 110 #define __BOOL 111 112 typedef unsigned char BOOL; 113 #endif 114 115 #if (!defined(__FAR__)) 116 # if (defined(__BORLANDC__)) 117 # define __FAR__ far 118 # else 119 # define __FAR__ 120 # endif 121 #endif 122 123 /* NULL */ 124 125 #if (!defined(NULL)) 126 # define NULL ((VOID __FAR__ *)0L) 127 #endif 128 129 130 #if (defined(__SPARC__) || defined(__linux__)) 131 typedef char CHAR; 132 typedef char *pCHAR; 133 typedef char INT8; 134 typedef char *pINT8; 135 typedef unsigned char UINT8; 136 typedef unsigned char *pUINT8; 137 typedef short INT16; 138 typedef short *pINT16; 139 typedef unsigned short UINT16; 140 typedef unsigned short *pUINT16; 141 typedef long INT32; 142 typedef long *pINT32; 143 typedef unsigned long UINT32; 144 typedef unsigned long *pUINT32; 145 //typedef SCSI_REQUEST_BLOCK OS_REQUEST_T; 146 //typedef PSCSI_REQUEST_BLOCK pOS_REQUEST_T; 147 #define STATIC static 148 #ifndef __NEAR__ 149 # if (defined(__BORLANDC__)) 150 # define __NEAR__ near 151 # else 152 # define __NEAR__ 153 # endif 154 #endif 155 #define pVOID void * 156 #define pBOOLEAN BOOLEAN * 157 #endif 158 159 160 /* 161 * Copyright (c) 1996-2000 Distributed Processing Technology Corporation 162 * Copyright (c) 2000 Adaptec Corporation. 163 * All rights reserved. 164 */ 165 /* 166 * Define some generalized portability macros 167 * These macros follow the following parameterization: 168 * _F_getXXX(pointer,primaryElement<,offset>,referredElement) 169 * _F_setXXX(pointer,primaryElement<,offset>,referredElement,newValue) 170 * These parameters are shortened to u, w, x, y and z to reduce clutter. 171 */ 172 #if (defined(__BORLANDC__)) 173 # define I2O_TID_MASK ((U16)((1L<<I2O_TID_SZ)-1)) 174 /* First 12 bits */ 175 # define _F_getTID(w,x,y) (*((U16 __FAR__ *)(&((w)->x))) & I2O_TID_MASK) 176 # define _F_setTID(w,x,y,z) (*((U16 __FAR__ *)(&((w)->x)))\ 177 &= 0xFFFF - I2O_TID_MASK);\ 178 (*((U16 __FAR__ *)(&((w)->x)))\ 179 |=(U16)(z)&I2O_TID_MASK) 180 /* Seconds 12 bits (optimized with the assumption of 12 & 12) */ 181 # define _F_getTID1(w,x,y) ((*(U16 __FAR__ *)(((U8 __FAR__ *)(&((w)->x)))\ 182 + (I2O_TID_SZ/8)))\ 183 >> (I2O_TID_SZ-((I2O_TID_SZ/8)*8))) 184 # define _F_setTID1(w,x,y,z) ((*((U16 __FAR__ *)(((U8 __FAR__ *)(&((w)->x)))\ 185 + (I2O_TID_SZ/8)))) &= (0xFFFF >> I2O_TID_SZ));\ 186 ((*((U16 __FAR__ *)(((U8 __FAR__ *)(&((w)->x)))\ 187 + (I2O_TID_SZ/8)))) |= (z)\ 188 << (I2O_TID_SZ-((I2O_TID_SZ/8)*8))) 189 /* Last 8 bits */ 190 # define _F_getFunc(w,x,y) (*(((U8 __FAR__ *)(&((w)->x)))\ 191 + ((I2O_TID_SZ+I2O_TID_SZ)/8))) 192 # define _F_setFunc(w,x,y,z) (_F_getFunc(w,x,y) = (z)) 193 # define I2O_SG_COUNT_MASK ((U32)((1L<<I2O_SG_COUNT_SZ)-1)) 194 /* First 24 bits */ 195 # define _F_getCount(w,x,y) (*((U32 __FAR__ *)(&((w)->x)))&I2O_SG_COUNT_MASK) 196 /* 197 * The following is less efficient because of compiler inefficiencies: 198 * 199 * # define _F_setCount(w,x,y,z) *((U16 __FAR__ *)(&((w)->x))) = (U16)(z);\ 200 * ((U8 __FAR__ *)(&((w)->x)))[2]= (U8)((z)>>16L) 201 * 202 * so we will use the apparently more code intensive: 203 */ 204 # define _F_setCount(w,x,y,z) (*((U32 __FAR__ *)(&((w)->x)))\ 205 &= 0xFFFFFFFFL - I2O_SG_COUNT_MASK);\ 206 (*((U32 __FAR__ *)(&((w)->x)))\ 207 |= (z) & I2O_SG_COUNT_MASK) 208 /* Last 8 bits */ 209 # define _F_getFlags(w,x,y) (*(((U8 __FAR__ *)(&((w)->x)))\ 210 + (I2O_SG_COUNT_SZ/8))) 211 # define _F_setFlags(w,x,y,z) (_F_getFlags(w,x,y) = (z)) 212 /* Other accesses that are simpler */ 213 # define _F_get1bit(w,x,y,z) ((U8)((w)->z)) 214 # define _F_set1bit(w,x,y,z,u) ((w)->z = (u)) 215 # define _F_get1bit1(w,x,y,z) ((U8)((w)->z)) 216 # define _F_set1bit1(w,x,y,z,u) ((w)->z = (u)) 217 # define _F_get4bit4(w,x,y,z) ((U8)((w)->z)) 218 # define _F_set4bit4(w,x,y,z,u) ((w)->z = (u)) 219 # define _F_get8bit(w,x,y,z) ((U8)((w)->z)) 220 # define _F_set8bit(w,x,y,z,u) ((w)->z = (u)) 221 # define _F_get12bit(w,x,y,z) ((U16)((w)->z)) 222 # define _F_set12bit(w,x,y,z,u) ((w)->z = (u)) 223 # define _F_get12bit4(w,x,y,z) ((U16)((w)->z)) 224 # define _F_set12bit4(w,x,y,z,u) ((w)->z = (u)) 225 # define _F_get16bit(w,x,y,z) ((U16)((w)->z)) 226 # define _F_set16bit(w,x,y,z,u) ((w)->z = (u)) 227 #elif (defined(_DPT_BIG_ENDIAN)) 228 /* First 12 bits */ 229 # define _F_getTID(w,x,y) getL12bit(w,x,0) 230 # define _F_setTID(w,x,y,z) setL12bit(w,x,0,z) 231 # define _F_getTID1(w,x,y) getL12bit1(w,x,0) 232 # define _F_setTID1(w,x,y,z) setL12bit1(w,x,0,z) 233 # define _F_getFunc(w,x,y) getL8bit(w,x,3) 234 # define _F_setFunc(w,x,y,z) setL8bit(w,x,3,z) 235 # define _F_getCount(w,x,y) getL24bit1(w,x,0) 236 # define _F_setCount(w,x,y,z) setL24bit1(w,x,0,z) 237 # define _F_getFlags(w,x,y) getL8bit(w,x,3) 238 # define _F_setFlags(w,x,y,z) setL8bit(w,x,3,z) 239 /* Other accesses that are simpler */ 240 # define _F_get1bit(w,x,y,z) getL1bit(w,x,y) 241 # define _F_set1bit(w,x,y,z,u) setL1bit(w,x,y,u) 242 # define _F_get1bit1(w,x,y,z) getL1bit1(w,x,y) 243 # define _F_set1bit1(w,x,y,z,u) setL1bit1(w,x,y,u) 244 # define _F_get4bit4(w,x,y,z) getL4bit(w,x,y) 245 # define _F_set4bit4(w,x,y,z,u) setL4bit(w,x,y,u) 246 # define _F_get8bit(w,x,y,z) getL8bit(w,x,y) 247 # define _F_set8bit(w,x,y,z,u) setL8bit(w,x,y,u) 248 # define _F_get12bit(w,x,y,z) getL12bit(w,x,y) 249 # define _F_set12bit(w,x,y,z,u) setL12bit(w,x,y,z) 250 # define _F_get12bit4(w,x,y,z) getL12bit1(w,x,(y)-1) 251 # define _F_set12bit4(w,x,y,z,u) setL12bit1(w,x,(y)-1,u) 252 # define _F_get16bit(w,x,y,z) getL16bit(w,x,y) 253 # define _F_set16bit(w,x,y,z,u) setL16bit(w,x,y,u) 254 #else 255 # define _F_getTID(w,x,y) ((U16)((w)->y)) 256 # define _F_setTID(w,x,y,z) ((w)->y = (z)) 257 # define _F_getTID1(w,x,y) ((U16)((w)->y)) 258 # define _F_setTID1(w,x,y,z) ((w)->y = (z)) 259 # define _F_getFunc(w,x,y) ((U8)((w)->y)) 260 # define _F_setFunc(w,x,y,z) ((w)->y = (z)) 261 # define _F_getCount(w,x,y) ((U32)((w)->y)) 262 # define _F_setCount(w,x,y,z) ((w)->y = (z)) 263 # define _F_getFlags(w,x,y) ((U8)((w)->y)) 264 # define _F_setFlags(w,x,y,z) ((w)->y = (z)) 265 # define _F_get1bit(w,x,y,z) ((U8)((w)->z)) 266 # define _F_set1bit(w,x,y,z,u) ((w)->z = (u)) 267 # define _F_get1bit1(w,x,y,z) ((U8)((w)->z)) 268 # define _F_set1bit1(w,x,y,z,u) ((w)->z = (u)) 269 # define _F_get4bit4(w,x,y,z) ((U8)((w)->z)) 270 # define _F_set4bit4(w,x,y,z,u) ((w)->z = (u)) 271 # define _F_get8bit(w,x,y,z) ((U8)((w)->z)) 272 # define _F_set8bit(w,x,y,z,u) ((w)->z = (u)) 273 # define _F_get12bit(w,x,y,z) ((U16)((w)->z)) 274 # define _F_set12bit(w,x,y,z,u) ((w)->z = (u)) 275 # define _F_get12bit4(w,x,y,z) ((U16)((w)->z)) 276 # define _F_set12bit4(w,x,y,z,u) ((w)->z = (u)) 277 # define _F_get16bit(w,x,y,z) ((U16)((w)->z)) 278 # define _F_set16bit(w,x,y,z,u) ((w)->z = (u)) 279 #endif 280 281 /* 282 * Define some specific portability macros 283 * These macros follow the following parameterization: 284 * XXX_getYYY (pointer) 285 * XXX_setYYY (pointer, newValue) 286 * These parameters are shortened to x and y to reduce clutter. 287 */ 288 289 /* 290 * General SGE 291 */ 292 #define I2O_FLAGS_COUNT_getCount(x) _F_getCount(x,Count,Count) 293 #define I2O_FLAGS_COUNT_setCount(x,y) _F_setCount(x,Count,Count,y) 294 #define I2O_FLAGS_COUNT_getFlags(x) _F_getFlags(x,Count,Flags) 295 #define I2O_FLAGS_COUNT_setFlags(x,y) _F_setFlags(x,Count,Flags,y) 296 297 /* 298 * I2O_SGE_SIMPLE_ELEMENT 299 */ 300 #define I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(x) \ 301 getLU4((&(x)->PhysicalAddress),0) 302 #define I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(x,y) \ 303 setLU4((&(x)->PhysicalAddress),0,y) 304 /* 305 * I2O_SGE_LONG_TRANSACTION_ELEMENT 306 */ 307 #define I2O_SGE_LONG_TRANSACTION_ELEMENT_getLongElementLength(x)\ 308 _F_getCount(x,LongElementLength,LongElementLength) 309 #define I2O_SGE_LONG_TRANSACTION_ELEMENT_setLongElementLength(x,y)\ 310 _F_setCount(x,LongElementLength,LongElementLength,y) 311 #define I2O_SGE_LONG_TRANSACTION_ELEMENT_getFlags(x)\ 312 _F_getFlags(x,LongElementLength,Flags) 313 #define I2O_SGE_LONG_TRANSACTION_ELEMENT_setFlags(x,y)\ 314 _F_setFlags(x,LongElementLength,Flags,y) 315 316 /* 317 * I2O_SGE_LONG_TRANSPORT_ELEMENT 318 */ 319 #define I2O_SGE_LONG_TRANSPORT_ELEMENT_getLongElementLength(x)\ 320 _F_getCount(x,LongElementLength,LongElementLength) 321 #define I2O_SGE_LONG_TRANSPORT_ELEMENT_setLongElementLength(x,y)\ 322 _F_setCount(x,LongElementLength,LongElementLength,y) 323 #define I2O_SGE_LONG_TRANSPORT_ELEMENT_getFlags(x)\ 324 _F_getFlags(x,LongElementLength,Flags) 325 #define I2O_SGE_LONG_TRANSPORT_ELEMENT_setFlags(x,y)\ 326 _F_setFlags(x,LongElementLength,Flags,y) 327 328 /* 329 * I2O_EXEC_ADAPTER_ASSIGN_MESSAGE 330 */ 331 #define I2O_EXEC_ADAPTER_ASSIGN_MESSAGE_getDdmTID(x)\ 332 _F_getTID(x,DdmTID,DdmTID) 333 #define I2O_EXEC_ADAPTER_ASSIGN_MESSAGE_setDdmTID(x,y)\ 334 _F_setTID(x,DDdmTID,DdmTID,y) 335 #define I2O_EXEC_ADAPTER_ASSIGN_MESSAGE_getOperationFlags(x)\ 336 _F_getFunc(x,DdmTID,OperationFlags) 337 #define I2O_EXEC_ADAPTER_ASSIGN_MESSAGE_setOperationFlags(x,y)\ 338 _F_setFunc(x,DdmTID,OperationFlags,y) 339 340 /* 341 * I2O_EXEC_BIOS_INFO_SET_MESSAGE 342 */ 343 #define I2O_EXEC_BIOS_INFO_SET_MESSAGE_getDeviceTID(x)\ 344 _F_getTID(x,DeviceTID,DeviceTID) 345 #define I2O_EXEC_BIOS_INFO_SET_MESSAGE_setDeviceTID(x,y)\ 346 _F_setTID(x,DeviceTID,DeviceTID,y) 347 #define I2O_EXEC_BIOS_INFO_SET_MESSAGE_getBiosInfo(x)\ 348 _F_getFunc(x,DeviceTID,BiosInfo) 349 #define I2O_EXEC_BIOS_INFO_SET_MESSAGE_setBiosInfo(x,y) \ 350 _F_setFunc(x,DeviceTID,BiosInfo,y) 351 352 /* 353 * I2O_ALIAS_CONNECT_SETUP 354 */ 355 #define I2O_ALIAS_CONNECT_SETUP_getIOP1AliasForTargetDevice(x)\ 356 _F_getTID(x,IOP1AliasForTargetDevice,IOP1AliasForTargetDevice) 357 #define I2O_ALIAS_CONNECT_SETUP_setIOP1AliasForTargetDevice(x,y)\ 358 _F_setTID(x,IOP1AliasForTargetDevice,IOP1AliasForTargetDevice,y) 359 #define I2O_ALIAS_CONNECT_SETUP_getIOP2AliasForInitiatorDevice(x)\ 360 _F_getTID1(x,IOP1AliasForTargetDevice,IOP2AliasForInitiatorDevice) 361 #define I2O_ALIAS_CONNECT_SETUP_setIOP2AliasForInitiatorDevice(x,y)\ 362 _F_setTID1(x,IOP1AliasForTargetDevice,IOP2AliasForInitiatorDevice,y) 363 364 /* 365 * I2O_OBJECT_CONNECT_SETUP 366 */ 367 #define I2O_OBJECT_CONNECT_SETUP_getTargetDevice(x)\ 368 _F_getTID(x,TargetDevice,TargetDevice) 369 #define I2O_OBJECT_CONNECT_SETUP_setTargetDevice(x,y)\ 370 _F_setTID(x,TargetDevice,TargetDevice,y) 371 #define I2O_OBJECT_CONNECT_SETUP_getInitiatorDevice(x)\ 372 _F_getTID1(x,TargetDevice,InitiatorDevice) 373 #define I2O_OBJECT_CONNECT_SETUP_setInitiatorDevice(x,y)\ 374 _F_setTID1(x,TargetDevice,InitiatorDevice,y) 375 #define I2O_OBJECT_CONNECT_SETUP_getOperationFlags(x)\ 376 _F_getFunc(x,TargetDevice,OperationFlags) 377 #define I2O_OBJECT_CONNECT_SETUP_setOperationFlags(x,y)\ 378 _F_setFunc(x,TargetDevice,OperationFlags,y) 379 380 /* 381 * I2O_OBJECT_CONNECT_REPLY 382 */ 383 #define I2O_OBJECT_CONNECT_REPLY_getTargetDevice(x)\ 384 _F_getTID(x,TargetDevice,TargetDevice) 385 #define I2O_OBJECT_CONNECT_REPLY_setTargetDevice(x,y)\ 386 _F_setTID(x,TargetDevice,TargetDevice,y) 387 #define I2O_OBJECT_CONNECT_REPLY_getInitiatorDevice(x)\ 388 _F_getTID1(x,TargetDevice,InitiatorDevice) 389 #define I2O_OBJECT_CONNECT_REPLY_setInitiatorDevice(x,y)\ 390 _F_setTID1(x,TargetDevice,InitiatorDevice,y) 391 #define I2O_OBJECT_CONNECT_REPLY_getReplyStatusCode(x)\ 392 _F_getFunc(x,TargetDevice,ReplyStatusCode) 393 #define I2O_OBJECT_CONNECT_REPLY_setReplyStatusCode(x,y)\ 394 _F_setFunc(x,TargetDevice,ReplyStatusCode,y) 395 396 /* 397 * I2O_EXEC_DEVICE_ASSIGN_MESSAGE 398 */ 399 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_getDeviceTID(x)\ 400 _F_getTID(x,Object.DeviceTID,Object.DeviceTID) 401 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_setDeviceTID(x,y)\ 402 _F_setTID(x,Object.DeviceTID,Object.DeviceTID,y) 403 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_getIOP_ID(x)\ 404 _F_getTID1(x,Object.DeviceTID,Object.IOP_ID) 405 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_setIOP_ID(x,y)\ 406 _F_setTID1(x,Object.DeviceTID,Object.IOP_ID,y) 407 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_getOperationFlags(x)\ 408 _F_getFunc(x,Object.DeviceTID,Object.OperationFlags) 409 #define I2O_EXEC_DEVICE_ASSIGN_MESSAGE_setOperationFlags(x,y)\ 410 _F_setFunc(x,Object.DeviceTID,Object.OperationFlags,y) 411 412 /* 413 * I2O_EXEC_DEVICE_RELEASE_MESSAGE 414 */ 415 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_getDeviceTID(x)\ 416 _F_getTID(x,Object.DeviceTID,Object.DeviceTID) 417 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_setDeviceTID(x,y)\ 418 _F_setTID(x,Object.DeviceTID,Object.DeviceTID,y) 419 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_getIOP_ID(x)\ 420 _F_getTID1(x,Object.DeviceTID,Object.IOP_ID) 421 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_setIOP_ID(x,y)\ 422 _F_setTID1(x,Object.DeviceTID,Object.IOP_ID,y) 423 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_getOperationFlags(x)\ 424 _F_getFunc(x,Object.DeviceTID,Object.OperationFlags) 425 #define I2O_EXEC_DEVICE_RELEASE_MESSAGE_setOperationFlags(x,y)\ 426 _F_setFunc(x,Object.DeviceTID,Object.OperationFlags,y) 427 428 /* 429 * I2O_EXEC_IOP_RESET_MESSAGE 430 */ 431 #define I2O_EXEC_IOP_RESET_MESSAGE_getTargetAddress(x)\ 432 _F_getTID(x,TargetAddress,TargetAddress) 433 #define I2O_EXEC_IOP_RESET_MESSAGE_setTargetAddress(x,y)\ 434 _F_setTID(x,TargetAddress,TargetAddress,y) 435 #define I2O_EXEC_IOP_RESET_MESSAGE_getInitiatorAddress(x)\ 436 _F_getTID1(x,TargetAddress,InitiatorAddress) 437 #define I2O_EXEC_IOP_RESET_MESSAGE_setInitiatorAddress(x,y)\ 438 _F_setTID1(x,TargetAddress,InitiatorAddress,y) 439 #define I2O_EXEC_IOP_RESET_MESSAGE_getFunction(x)\ 440 _F_getFunc(x,TargetAddress,Function) 441 #define I2O_EXEC_IOP_RESET_MESSAGE_setFunction(x,y)\ 442 _F_setFunc(x,TargetAddress,Function,y) 443 #define I2O_EXEC_IOP_RESET_MESSAGE_getVersionOffset(x)\ 444 getU1((&(x)->VersionOffset),0) 445 #define I2O_EXEC_IOP_RESET_MESSAGE_setVersionOffset(x,y)\ 446 setU1((&(x)->VersionOffset),0,y) 447 #define I2O_EXEC_IOP_RESET_MESSAGE_getMsgFlags(x)\ 448 getU1((&(x)->VersionOffset),1) 449 #define I2O_EXEC_IOP_RESET_MESSAGE_setMsgFlags(x,y)\ 450 setU1((&(x)->VersionOffset),1,y) 451 #define I2O_EXEC_IOP_RESET_MESSAGE_getMessageSize(x)\ 452 getLU2((&(x)->VersionOffset),2) 453 #define I2O_EXEC_IOP_RESET_MESSAGE_setMessageSize(x,y)\ 454 setLU2((&(x)->VersionOffset),2,y) 455 #define I2O_EXEC_IOP_RESET_MESSAGE_getStatusWordLowAddress(x)\ 456 getLU4((&(x)->StatusWordLowAddress),0) 457 #define I2O_EXEC_IOP_RESET_MESSAGE_setStatusWordLowAddress(x,y)\ 458 setLU4((&(x)->StatusWordLowAddress),0,y) 459 #define I2O_EXEC_IOP_RESET_MESSAGE_getStatusWordHighAddress(x)\ 460 getLU4((&(x)->StatusWordHighAddress),0) 461 #define I2O_EXEC_IOP_RESET_MESSAGE_setStatusWordHighAddress(x,y)\ 462 setLU4((&(x)->StatusWordHighAddress),0,y) 463 464 465 /* 466 * I2O_EXEC_STATUS_GET_MESSAGE 467 */ 468 #define I2O_EXEC_STATUS_GET_MESSAGE_getVersionOffset(x)\ 469 getU1((&(x)->VersionOffset),0) 470 #define I2O_EXEC_STATUS_GET_MESSAGE_setVersionOffset(x,y)\ 471 setU1((&(x)->VersionOffset),0,y) 472 #define I2O_EXEC_STATUS_GET_MESSAGE_getMsgFlags(x)\ 473 getU1((&(x)->VersionOffset),1) 474 #define I2O_EXEC_STATUS_GET_MESSAGE_setMsgFlags(x,y)\ 475 setU1((&(x)->VersionOffset),1,y) 476 #define I2O_EXEC_STATUS_GET_MESSAGE_getMessageSize(x)\ 477 getLU2((&(x)->VersionOffset),2) 478 #define I2O_EXEC_STATUS_GET_MESSAGE_setMessageSize(x,y)\ 479 setLU2((&(x)->VersionOffset),2,y) 480 #define I2O_EXEC_STATUS_GET_MESSAGE_getReplyBufferAddressLow(x)\ 481 getLU4((&(x)->ReplyBufferAddressLow),0) 482 #define I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferAddressLow(x,y)\ 483 setLU4((&(x)->ReplyBufferAddressLow),0,y) 484 #define I2O_EXEC_STATUS_GET_MESSAGE_getReplyBufferAddressHigh(x)\ 485 getLU4((&(x)->ReplyBufferAddressHigh),0) 486 #define I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferAddressHigh(x,y)\ 487 setLU4((&(x)->ReplyBufferAddressHigh),0,y) 488 #define I2O_EXEC_STATUS_GET_MESSAGE_getReplyBufferLength(x)\ 489 getLU4((&(x)->ReplyBufferLength),0) 490 #define I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferLength(x,y)\ 491 setLU4((&(x)->ReplyBufferLength),0,y) 492 #define I2O_EXEC_STATUS_GET_MESSAGE_getTargetAddress(x)\ 493 _F_getTID(x,TargetAddress,TargetAddress) 494 #define I2O_EXEC_STATUS_GET_MESSAGE_setTargetAddress(x,y)\ 495 _F_setTID(x,TargetAddress,TargetAddress,y) 496 #define I2O_EXEC_STATUS_GET_MESSAGE_getInitiatorAddress(x)\ 497 _F_getTID1(x,TargetAddress,InitiatorAddress) 498 #define I2O_EXEC_STATUS_GET_MESSAGE_setInitiatorAddress(x,y)\ 499 _F_setTID1(x,TargetAddress,InitiatorAddress,y) 500 #define I2O_EXEC_STATUS_GET_MESSAGE_getFunction(x)\ 501 _F_getFunc(x,TargetAddress,Function) 502 #define I2O_EXEC_STATUS_GET_MESSAGE_setFunction(x,y)\ 503 _F_setFunc(x,TargetAddress,Function,y) 504 505 /* 506 * I2O_MESSAGE_FRAME 507 */ 508 #define I2O_MESSAGE_FRAME_getVersionOffset(x)\ 509 getU1((&((x)->VersionOffset)),0) 510 #define I2O_MESSAGE_FRAME_setVersionOffset(x,y)\ 511 setU1(((&(x)->VersionOffset)),0,y) 512 #define I2O_MESSAGE_FRAME_getMsgFlags(x)\ 513 getU1((&((x)->VersionOffset)),1) 514 #define I2O_MESSAGE_FRAME_setMsgFlags(x,y)\ 515 setU1((&((x)->VersionOffset)),1,y) 516 #define I2O_MESSAGE_FRAME_getMessageSize(x)\ 517 getLU2((&((x)->VersionOffset)),2) 518 #define I2O_MESSAGE_FRAME_setMessageSize(x,y)\ 519 setLU2((&((x)->VersionOffset)),2,y) 520 #define I2O_MESSAGE_FRAME_getTargetAddress(x)\ 521 _F_getTID(x,TargetAddress,TargetAddress) 522 #define I2O_MESSAGE_FRAME_setTargetAddress(x,y)\ 523 _F_setTID(x,TargetAddress,TargetAddress,y) 524 #define I2O_MESSAGE_FRAME_getInitiatorAddress(x)\ 525 _F_getTID1(x,TargetAddress,InitiatorAddress) 526 #define I2O_MESSAGE_FRAME_setInitiatorAddress(x,y)\ 527 _F_setTID1(x,TargetAddress,InitiatorAddress,y) 528 #define I2O_MESSAGE_FRAME_getFunction(x)\ 529 _F_getFunc(x,TargetAddress,Function) 530 #define I2O_MESSAGE_FRAME_setFunction(x,y)\ 531 _F_setFunc(x,TargetAddress,Function,y) 532 /* 32 bit only for now */ 533 #define I2O_MESSAGE_FRAME_getInitiatorContext(x)\ 534 (x)->InitiatorContext 535 #define I2O_MESSAGE_FRAME_setInitiatorContext(x,y)\ 536 ((x)->InitiatorContext = (y)) 537 /* 538 * We are spilling the 64 bit Context field into the Transaction 539 * context of the specific frames. Synchronous commands (resetIop 540 * et al) do not have this field, so beware. Also, Failed Reply frames 541 * can not contain the 64 bit context, the software must reference 542 * the PreservedMFA and pick up the 64 bit context from the incoming 543 * message frame. The software must make no reference to the 544 * TransactionContext field at all. 545 */ 546 #if defined(_MSC_VER) && _MSC_VER >= 800 547 #ifndef u_int64_t 548 #define u_int64_t unsigned __int64 549 #endif 550 #endif 551 #define I2O_MESSAGE_FRAME_getInitiatorContext64(x)\ 552 (*((u_int64_t *)(&((x)->InitiatorContext)))) 553 #define I2O_MESSAGE_FRAME_setInitiatorContext64(x,y)\ 554 ((*((u_int64_t *)(&((x)->InitiatorContext))))=(y)) 555 556 /* 557 * I2O_EXEC_OUTBOUND_INIT_MESSAGE 558 */ 559 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_getHostPageFrameSize(x)\ 560 getLU4((&(x)->HostPageFrameSize),0) 561 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_setHostPageFrameSize(x,y)\ 562 setLU4((&(x)->HostPageFrameSize),0,y) 563 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_getInitCode(x)\ 564 getU1((&(x)->InitCode),0) 565 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_setInitCode(x,y)\ 566 setU1((&(x)->InitCode),0,y) 567 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_getreserved(x)\ 568 getU1((&(x)->reserved),0) 569 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_setreserved(x,y)\ 570 setU1((&(x)->reserved),0,y) 571 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_getOutboundMFrameSize(x)\ 572 getLU2((&(x)->OutboundMFrameSize),0) 573 #define I2O_EXEC_OUTBOUND_INIT_MESSAGE_setOutboundMFrameSize(x,y)\ 574 setLU2((&(x)->OutboundMFrameSize),0,y) 575 576 /* 577 * I2O_EXEC_SYS_TAB_SET_MESSAGE 578 */ 579 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_getIOP_ID(x)\ 580 _F_get12bit(x,IOP_ID,IOP_ID) 581 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_setIOP_ID(x,y)\ 582 _F_set12bit(x,IOP_ID,IOP_ID,y) 583 /* #define I2O_EXEC_SYS_TAB_SET_MESSAGE_getreserved1(x) */ 584 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_getHostUnitID(x)\ 585 _F_get16bit(x,IOP_ID,2,HostUnitID) 586 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_setHostUnitID(x,y)\ 587 _F_set16bit(x,IOP_ID,2,HostUnitID,y) 588 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_getSegmentNumber(x)\ 589 _F_get12bit(x,SegmentNumber,SegmentNumber) 590 #define I2O_EXEC_SYS_TAB_SET_MESSAGE_setSegmentNumber(x,y)\ 591 _F_get12bit(x,SegmentNumber,SegmentNumber,y) 592 593 /* later 594 * I2O_EXEC_SYS_ENABLE_MESSAGE 595 */ 596 597 /* 598 * I2O_CLASS_ID 599 */ 600 #define I2O_CLASS_ID_getClass(x)\ 601 _F_get12bit(x,Class,0,Class) 602 #define I2O_CLASS_ID_setClass(x,y)\ 603 _F_set12bit(x,Class,0,Class,y) 604 #define I2O_CLASS_ID_getVersion(x)\ 605 _F_get4bit4(x,Class,1,Version) 606 #define I2O_CLASS_ID_setVersion(x,y)\ 607 _F_set4bit4(x,Class,1,Version,y) 608 #define I2O_CLASS_ID_getOrganizationID(x)\ 609 _F_get16bit(x,Class,2,OrganizationID) 610 #define I2O_CLASS_ID_setOrganizationID(x,y)\ 611 _F_set16bit(x,Class,2,OrganizationID,y) 612 613 /* 614 * I2O_SET_SYSTAB_HEADER 615 */ 616 #define I2O_SET_SYSTAB_HEADER_getNumberEntries(x)\ 617 getU1((&((x)->NumberEntries)),0) 618 #define I2O_SET_SYSTAB_HEADER_setNumberEntries(x,y)\ 619 setU1((&(x)->NumberEntries),0,y) 620 #define I2O_SET_SYSTAB_HEADER_getSysTabVersion(x)\ 621 getU1((&((x)->SysTabVersion)),0) 622 #define I2O_SET_SYSTAB_HEADER_setSysTabVersion(x,y)\ 623 setU1((&(x)->SysTabVersion),0,y) 624 /* U16 reserved */ 625 /* U32 CurrentChangeIndicator */ 626 627 628 629 630 /* 631 * I2O_IOP_ENTRY 632 */ 633 #define I2O_IOP_ENTRY_getOrganizationID(x)\ 634 getLU2((&((x)->OrganizationID)),0) 635 #define I2O_IOP_ENTRY_setOrganizationID(x,y)\ 636 setLU2((&((x)->OrganizationID)),0,y) 637 /* #define I2O_IOP_ENTRY_getreserved U16; */ 638 #define I2O_IOP_ENTRY_getIOP_ID(x)\ 639 _F_get12bit(x,IOP_ID,0,IOP_ID) 640 #define I2O_IOP_ENTRY_setIOP_ID(x,y)\ 641 _F_set12bit(x,IOP_ID,0,IOP_ID,y) 642 /* BF reserved3:I2O_RESERVED_4BITS; */ 643 /* BF reserved1:I2O_RESERVED_16BITS; */ 644 #define I2O_IOP_ENTRY_getSegmentNumber(x)\ 645 _F_get12bit(x,SegmentNumber,0,SegmentNumber) 646 #define I2O_IOP_ENTRY_setSegmentNumber(x,y)\ 647 _F_set12bit(x,SegmentNumber,0,SegmentNumber,y) 648 #define I2O_IOP_ENTRY_getI2oVersion(x)\ 649 _F_get4bit4(x,SegmentNumber,1,I2oVersion) 650 #define I2O_IOP_ENTRY_setI2oVersion(x,y)\ 651 _F_set4bit4(x,SegmentNumber,1,I2oVersion,y) 652 #define I2O_IOP_ENTRY_getIopState(x)\ 653 _F_get8bit(x,SegmentNumber,2,IopState) 654 #define I2O_IOP_ENTRY_setIopState(x,y)\ 655 _F_set8bit(x,SegmentNumber,2,IopState,y) 656 #define I2O_IOP_ENTRY_getMessengerType(x)\ 657 _F_get8bit(x,SegmentNumber,3,MessengerType) 658 #define I2O_IOP_ENTRY_setMessengerType(x,y)\ 659 _F_set8bit(x,SegmentNumber,3,MessengerType,y) 660 #define I2O_IOP_ENTRY_getInboundMessageFrameSize(x)\ 661 getLU2((&((x)->InboundMessageFrameSize)),0) 662 #define I2O_IOP_ENTRY_setInboundMessageFrameSize(x,y)\ 663 setLU2((&((x)->InboundMessageFrameSize)),0,y) 664 #define I2O_IOP_ENTRY_getreserved2(x)\ 665 getLU2((&((x)->reserved2)),0) 666 #define I2O_IOP_ENTRY_setreserved2(x,y)\ 667 setLU2((&((x)->reserved2)),0,y) 668 #define I2O_IOP_ENTRY_getLastChanged(x)\ 669 getLU4((&((x)->LastChanged)),0) 670 #define I2O_IOP_ENTRY_setLastChanged(x,y)\ 671 setLU4((&((x)->LastChanged)),0,y) 672 #define I2O_IOP_ENTRY_getIopCapabilities(x)\ 673 getLU4((&((x)->IopCapabilities)),0) 674 #define I2O_IOP_ENTRY_setIopCapabilities(x,y)\ 675 setLU4((&((x)->IopCapabilities)),0,y) 676 677 /* might want to declare I2O_MESSENGER_INFO struct */ 678 679 #define I2O_IOP_ENTRY_getInboundMessagePortAddressLow(x)\ 680 getLU4((&((x)->MessengerInfo.InboundMessagePortAddressLow)),0) 681 #define I2O_IOP_ENTRY_setInboundMessagePortAddressLow(x,y)\ 682 setLU4((&((x)->MessengerInfo.InboundMessagePortAddressLow)),0,y) 683 684 #define I2O_IOP_ENTRY_getInboundMessagePortAddressHigh(x)\ 685 getLU4((&((x)->MessengerInfo.InboundMessagePortAddressHigh)),0) 686 #define I2O_IOP_ENTRY_setInboundMessagePortAddressHigh(x,y)\ 687 setLU4((&((x)->MessengerInfo.InboundMessagePortAddressHigh)),0,y) 688 689 /* 690 * I2O_HRT 691 */ 692 #define I2O_HRT_getNumberEntries(x)\ 693 getLU2((&((x)->NumberEntries)),0) 694 #define I2O_HRT_setNumberEntries(x,y)\ 695 setLU2((&(x)->NumberEntries),0,y) 696 #define I2O_HRT_getEntryLength(x)\ 697 getU1((&(x)->EntryLength),0) 698 #define I2O_HRT_setEntryLength(x,y)\ 699 setU1((&(x)->EntryLength),0,y) 700 #define I2O_HRT_getHRTVersion(x)\ 701 getU1((&(x)->HRTVersion),0) 702 #define I2O_HRT_setHRTVersion(x,y)\ 703 setU1((&(x)->HRTVersion),0,y) 704 #define I2O_HRT_getCurrentChangeIndicator(x)\ 705 getLU4((&(x)->CurrentChangeIndicator),0) 706 #define I2O_HRT_setCurrentChangeIndicator(x,y)\ 707 setLU4((&(x)->CurrentChangeIndicator),0,y) 708 #define I2O_HRT_getHRTEntryPtr(x,y)\ 709 ((&((x)->HRTEntry[0+y]))) 710 711 /* 712 * I2O_HRT_ENTRY 713 */ 714 #define I2O_HRT_ENTRY_getAdapterID(x)\ 715 getLU4((&((x)->AdapterID)),0) 716 #define I2O_HRT_ENTRY_setAdapterID(x,y)\ 717 setLU4((&(x)->AdapterID),0,y) 718 #define I2O_HRT_ENTRY_getControllingTID(x)\ 719 _F_get12bit(x,ControllingTID,ControllingTID) 720 #define I2O_HRT_ENTRY_setControllingTID(x,y)\ 721 _F_set12bit(x,ControllingTID,ControllingTID,y) 722 #define I2O_HRT_ENTRY_getAdapterState(x)\ 723 _F_get4bit4(x,ControllingTID,1,AdapterState) 724 #define I2O_HRT_ENTRY_setIAdapterState(x,y)\ 725 _F_set4bit4(x,ControllingTID,1,AdapterState,y) 726 #define I2O_HRT_ENTRY_getBusNumber(x)\ 727 _F_get8bit(x,ControllingTID,2,BusNumber) 728 #define I2O_HRT_ENTRY_setBusNumber(x,y)\ 729 _F_set8bit(x,ControllingTID,2,BusNumber,y) 730 #define I2O_HRT_ENTRY_getBusType(x)\ 731 _F_get8bit(x,ControllingTID,3,BusType) 732 #define I2O_HRT_ENTRY_setBusType(x,y)\ 733 _F_set8bit(x,ControllingTID,3,BusType,y) 734 #define I2O_HRT_ENTRY_getPCIBusPtr(x,y)\ 735 (&((x)->uBus.PCIBus)) 736 737 /* 738 * I2O_LCT 739 */ 740 #define I2O_LCT_getTableSize(x)\ 741 _F_get16bit(x,TableSize,0,TableSize) 742 #define I2O_LCT_setTableSize(x,y)\ 743 _F_set16bit(x,TableSize,0,TableSize,y) 744 #define I2O_LCT_getBootDeviceTID(x)\ 745 _F_get12bit(x,TableSize,2,BootDeviceTID) 746 #define I2O_LCT_setBootDeviceTID(x,y)\ 747 _F_set12bit(x,TableSize,2,BootDeviceTID,y) 748 #define I2O_LCT_getLctVer(x)\ 749 _F_get4bit4(x,TableSize,3,LctVer) 750 #define I2O_LCT_setLctVer(x,y)\ 751 _F_set4bit4(x,TableSize,3,LctVer,y) 752 #define I2O_LCT_getIopFlags(x)\ 753 getLU4((&(x)->IopFlags),0) 754 #define I2O_LCT_setIopFlags(x,y)\ 755 setLU4((&(x)->IopFlags),0,y) 756 #define I2O_LCT_getCurrentChangeIndicator(x)\ 757 getLU4((&(x)->CurrentChangeIndicator),0) 758 #define I2O_LCT_setCurrentChangeIndicator(x,y)\ 759 setLU4((&(x)->CurrentChangeIndicator),0,y) 760 #define I2O_LCT_getLCTEntryPtr(x,y)\ 761 (&((x)->LCTEntry[0+y])) 762 763 /* 764 * I2O_LCT_ENTRY 765 */ 766 #define I2O_LCT_ENTRY_getTableEntrySize(x)\ 767 _F_get16bit(x,TableEntrySize,0,TableEntrySize) 768 #define I2O_LCT_ENTRY_setTableEntrySize(x,y)\ 769 _F_set16bit(x,TableEntrySize,0,TableEntrySize,y) 770 #define I2O_LCT_ENTRY_getLocalTID(x)\ 771 _F_get12bit(x,TableEntrySize,2,LocalTID) 772 #define I2O_LCT_ENTRY_setLocalTID(x,y)\ 773 _F_set12bit(x,TableEntrySize,2,LocalTID,y) 774 /* BF 4 reserved:I2O_4BIT_VERSION_SZ; */ 775 #define I2O_LCT_ENTRY_getChangeIndicator(x)\ 776 getLU4((&(x)->ChangeIndicator),0) 777 #define I2O_LCT_ENTRY_setChangeIndicator(x,y)\ 778 setLU4((&(x)->ChangeIndicator),0,y) 779 #define I2O_LCT_ENTRY_getDeviceFlags(x)\ 780 getLU4((&(x)->DeviceFlags),0) 781 #define I2O_LCT_ENTRY_setDeviceFlags(x,y)\ 782 setLU4((&(x)->DeviceFlags),0,y) 783 #define I2O_LCT_ENTRY_getClassIDPtr(x)\ 784 (&((x)->ClassID)) 785 #define I2O_LCT_ENTRY_getSubClassInfo(x)\ 786 getLU4((&(x)->SubClassInfo),0) 787 #define I2O_LCT_ENTRY_setSubClassInfo(x,y)\ 788 setLU4((&(x)->SubClassInfo),0,y) 789 #define I2O_LCT_ENTRY_getUserTID(x)\ 790 _F_getTID(x,UserTID,UserTID) 791 #define I2O_LCT_ENTRY_setUserTID(x,y)\ 792 _F_setTID(x,UserTID,UserTID,y) 793 #define I2O_LCT_ENTRY_getParentTID(x)\ 794 _F_getTID1(x,UserTID,ParentTID) 795 #define I2O_LCT_ENTRY_setParentTID(x,y)\ 796 _F_getTID1(x,UserTID,ParentTID,y) 797 #define I2O_LCT_ENTRY_getBiosInfo(x)\ 798 _F_getFunc(x,UserTID,BiosInfo) 799 #define I2O_LCT_ENTRY_setBiosInfo(x,y)\ 800 _F_setFunc(x,UserTID,BiosInfo,y) 801 /* 2 ulong U8 8 IdentityTag[I2O_IDENTITY_TAG_SZ]; */ 802 #define I2O_LCT_ENTRY_getEventCapabilities(x)\ 803 getLU4((&(x)->EventCapabilities),0) 804 #define I2O_LCT_ENTRY_setEventCapabilities(x,y)\ 805 setLU4((&(x)->EventCapabilities),0,y) 806 807 /* 808 * I2O_PARAM_OPERATIONS_LIST_HEADER 809 */ 810 #define I2O_PARAM_OPERATIONS_LIST_HEADER_getOperationCount(x)\ 811 getLU2((&(x)->OperationCount),0) 812 #define I2O_PARAM_OPERATIONS_LIST_HEADER_setOperationCount(x,y)\ 813 setLU2((&(x)->OperationCount),0,y) 814 #define I2O_PARAM_OPERATIONS_LIST_HEADER_getReserved(x)\ 815 getLU2((&(x)->Reserved),0) 816 #define I2O_PARAM_OPERATIONS_LIST_HEADER_setReserved(x,y)\ 817 setLU2((&(x)->Reserved),0,y) 818 819 /* 820 * I2O_PARAM_OPERATION_ALL_TEMPLATE 821 */ 822 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_getOperation(x)\ 823 getLU2((&(x)->Operation),0) 824 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_setOperation(x,y)\ 825 setLU2((&(x)->Operation),0,y) 826 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_getGroupNumber(x)\ 827 getLU2((&(x)->GroupNumber),0) 828 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_setGroupNumber(x,y)\ 829 setLU2((&(x)->GroupNumber),0,y) 830 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_getFieldCount(x)\ 831 getLU2((&(x)->FieldCount),0) 832 #define I2O_PARAM_OPERATION_ALL_TEMPLATE_setFieldCount(x,y)\ 833 setLU2((&(x)->FieldCount),0,y) 834 835 /* 836 * I2O_PARAM_RESULTS_LIST_HEADER 837 */ 838 #define I2O_PARAM_RESULTS_LIST_HEADER_getResultCount(x)\ 839 getLU2((&(x)->ResultCount),0) 840 #define I2O_PARAM_RESULTS_LIST_HEADER_setResultCount(x,y)\ 841 setLU2((&(x)->ResultCount),0,y) 842 #define I2O_PARAM_RESULTS_LIST_HEADER_getReserved(x)\ 843 getLU2((&(x)->Reserved),0) 844 #define I2O_PARAM_RESULTS_LIST_HEADER_setReserved(x,y)\ 845 setLU2((&(x)->Reserved),0,y) 846 847 /* later 848 * I2O_HBA_ADAPTER_RESET_MESSAGE 849 */ 850 851 852 /* LATER 853 * I2O_SCSI_DEVICE_RESET_MESSAGE 854 */ 855 856 857 /* LATER 858 * I2O_HBA_BUS_RESET_MESSAGE 859 */ 860 861 862 /* 863 * I2O_EXEC_LCT_NOTIFY_MESSAGE 864 */ 865 /* I2O_MESSAGE_FRAME StdMessageFrame; */ 866 /* I2O_TRANSACTION_CONTEXT TransactionContext; */ 867 #define I2O_EXEC_LCT_NOTIFY_MESSAGE_getClassIdentifier(x)\ 868 getLU4((&(x)->ClassIdentifier),0) 869 #define I2O_EXEC_LCT_NOTIFY_MESSAGE_setClassIdentifier(x,y)\ 870 setLU4((&(x)->ClassIdentifier),0,y) 871 #define I2O_EXEC_LCT_NOTIFY_MESSAGE_getLastReportedChangeIndicator(x)\ 872 getLU4((&(x)->LastReportedChangeIndicator),0) 873 #define I2O_EXEC_LCT_NOTIFY_MESSAGE_setLastReportedChangeIndicator(x,y)\ 874 setLU4((&(x)->LastReportedChangeIndicator),0,y) 875 /* I2O_SG_ELEMENT SGL; */ 876 877 878 879 /* 880 * I2O_UTIL_PARAMS_GET_MESSAGE 881 */ 882 /* I2O_MESSAGE_FRAME StdMessageFrame; */ 883 /* I2O_TRANSACTION_CONTEXT TransactionContext; */ 884 #define I2O_UTIL_PARAMS_GET_MESSAGE_getOperationFlags(x)\ 885 getLU4((&(x)->OperationFlags),0) 886 #define I2O_UTIL_PARAMS_GET_MESSAGE_setOperationFlags(x,y)\ 887 setLU4((&(x)->OperationFlags),0,y) 888 /* I2O_SG_ELEMENT SGL; */ 889 890 891 /* 892 * I2O_SCSI_SCB_ABORT_MESSAGE 893 */ 894 #define I2O_SCSI_SCB_ABORT_MESSAGE_getStdMessageFramePtr(x)\ 895 (&((x)->StdMessageFrame)) 896 #define I2O_SCSI_SCB_ABORT_MESSAGE_getTransactionContext(x)\ 897 (x)->TransactionContext 898 #define I2O_SCSI_SCB_ABORT_MESSAGE_setTransactionContext(x,y)\ 899 ((x)->TransactionContext = (y)) 900 #define I2O_SCSI_SCB_ABORT_MESSAGE_getTransactionContextToAbort(x)\ 901 (x)->TransactionContextToAbort 902 #define I2O_SCSI_SCB_ABORT_MESSAGE_setTransactionContextToAbort(x,y)\ 903 ((x)->TransactionContextToAbort = (y)) 904 905 906 /* 907 * I2O_DPT_DEVICE_INFO_SCALAR 908 */ 909 #define I2O_DPT_DEVICE_INFO_SCALAR_getDeviceType(x)\ 910 getU1((&(x)->DeviceType),0) 911 #define I2O_DPT_DEVICE_INFO_SCALAR_setDeviceType(x,y)\ 912 setU1((&(x)->DeviceType),0,y) 913 #define I2O_DPT_DEVICE_INFO_SCALAR_getFlags(x)\ 914 getU1((&(x)->Flags),0) 915 #define I2O_DPT_DEVICE_INFO_SCALAR_setFlags(x,y)\ 916 setU1((&(x)->Flags),0,y) 917 #define I2O_DPT_DEVICE_INFO_SCALAR_getBus(x)\ 918 getLU2((&(x)->Bus),0) 919 #define I2O_DPT_DEVICE_INFO_SCALAR_setBus(x,y)\ 920 setLU2((&(x)->Bus),0,y) 921 #define I2O_DPT_DEVICE_INFO_SCALAR_getIdentifier(x)\ 922 getLU4((&(x)->Identifier),0) 923 #define I2O_DPT_DEVICE_INFO_SCALAR_setIdentifier(x,y)\ 924 setLU4((&(x)->Identifier),0,y) 925 /* U8 LunInfo[8]; // SCSI-2 8-bit scalar LUN goes into offset 1 */ 926 #define I2O_DPT_DEVICE_INFO_SCALAR_getLunInfo(x)\ 927 getU1((&(x)->LunInfo[0]),1) 928 #define I2O_DPT_DEVICE_INFO_SCALAR_setLunInfo(x,y)\ 929 setU1((&(x)->LunInfo[0]),1,y) 930 931 /* 932 * I2O_DPT_EXEC_IOP_BUFFERS_SCALAR 933 */ 934 #define I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialOutputOffset(x)\ 935 getLU4((&(x)->SerialOutputOffset),0) 936 #define I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialOutputSizet(x)\ 937 getLU4((&(x)->SerialOutputSize),0) 938 #define I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialHeaderSize(x)\ 939 getLU4((&(x)->SerialHeaderSize),0) 940 #define I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialFlagsSupported(x)\ 941 getLU4((&(x)->SerialFlagsSupported),0) 942 943 /* 944 * I2O_PRIVATE_MESSAGE_FRAME 945 */ 946 /* typedef struct _I2O_PRIVATE_MESSAGE_FRAME { */ 947 /* I2O_MESSAGE_FRAME StdMessageFrame; */ 948 /* I2O_TRANSACTION_CONTEXT TransactionContext; */ 949 /* U16 XFunctionCode; */ 950 /* U16 OrganizationID; */ 951 /* PrivatePayload[]; */ 952 /* } I2O_PRIVATE_MESSAGE_FRAME, *PI2O_PRIVATE_MESSAGE_FRAME; */ 953 #define I2O_PRIVATE_MESSAGE_FRAME_getTransactionContext(x) \ 954 (x)->TransactionContext 955 #define I2O_PRIVATE_MESSAGE_FRAME_setTransactionContext(x,y) \ 956 ((x)->TransactionContext = (y)) 957 #define I2O_PRIVATE_MESSAGE_FRAME_getXFunctionCode(x) \ 958 getLU2((&(x)->XFunctionCode),0) 959 #define I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode(x,y) \ 960 setLU2((&(x)->XFunctionCode),0,y) 961 #define I2O_PRIVATE_MESSAGE_FRAME_getOrganizationID(x) \ 962 getLU2((&(x)->OrganizationID),0) 963 #define I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID(x,y) \ 964 setLU2((&(x)->OrganizationID),0,y) 965 /* typedef struct _PRIVATE_SCSI_SCB_EXECUTE_MESSAGE { 966 * I2O_PRIVATE_MESSAGE_FRAME PRIVATE_SCSI_SCB_EXECUTE_MESSAGE; 967 * BF TID:16; // Upper four bits currently are zero 968 * // Command is interpreted by the host 969 * BF Interpret:1; 970 * // if TRUE, deal with Physical Firmware Array information 971 * BF Physical:1; 972 * BF Reserved1:14; 973 * U8 CDBLength; 974 * U8 Reserved; 975 * I2O_SCB_FLAGS SCBFlags; 976 * U8 CDB[ I2O_SCSI_CDB_LENGTH=16 ]; 977 * U32 ByteCount; 978 * I2O_SG_ELEMENT SGL; 979 * } PRIVATE_SCSI_SCB_EXECUTE_MESSAGE, * PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE; 980 */ 981 /* 982 * PRIVATE_SCSI_SCB_EXECUTE_MESSAGE 983 */ 984 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getPRIVATE_SCSI_SCB_EXECUTE_MESSAGEPtr(x)\ 985 (&((x)->PRIVATE_SCSI_SCB_EXECUTE_MESSAGE)) 986 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getCDBLength(x)\ 987 getU1((&(x)->CDBLength),0) 988 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(x,y)\ 989 setU1((&(x)->CDBLength),0,y) 990 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getReserved(x)\ 991 getU1((&(x)->Reserved),0) 992 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setReserved(x,y)\ 993 setU1((&(x)->Reserved),0,y) 994 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getSCBFlags(x)\ 995 getLU2((&(x)->SCBFlags),0) 996 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags(x,y)\ 997 setLU2((&(x)->SCBFlags),0,y) 998 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getByteCount(x)\ 999 getLU4((&((x)->ByteCount)),0) 1000 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setByteCount(x,y)\ 1001 setLU4((&((x)->ByteCount)),0,y) 1002 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getTID(x)\ 1003 _F_get16bit(x,TID,0,TID) 1004 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setTID(x,y)\ 1005 _F_set16bit(x,TID,0,TID,y) 1006 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getInterpret(x)\ 1007 _F_get1bit(x,TID,2,Interpret) 1008 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setInterpret(x,y)\ 1009 _F_set1bit(x,TID,2,Interpret,y) 1010 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getPhysical(x)\ 1011 _F_get1bit1(x,TID,2,Physical) 1012 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setPhysical(x,y)\ 1013 _F_set1bit1(x,TID,2,Physical,y) 1014 #define PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getCDBPtr(x)\ 1015 (&((x)->CDB[0])) 1016 1017 1018 /* 1019 * PRIVATE_FLASH_REGION_MESSAGE 1020 */ 1021 #define PRIVATE_FLASH_REGION_MESSAGE_getFlashRegion(x) \ 1022 getLU4((&((x)->FlashRegion)),0) 1023 #define PRIVATE_FLASH_REGION_MESSAGE_setFlashRegion(x,y) \ 1024 setLU4((&((x)->FlashRegion)),0,y) 1025 #define PRIVATE_FLASH_REGION_MESSAGE_getRegionOffset(x) \ 1026 getLU4((&((x)->RegionOffset)),0) 1027 #define PRIVATE_FLASH_REGION_MESSAGE_setRegionOffset(x,y) \ 1028 setLU4((&((x)->RegionOffset)),0,y) 1029 #define PRIVATE_FLASH_REGION_MESSAGE_getByteCount(x) \ 1030 getLU4((&((x)->ByteCount)),0) 1031 #define PRIVATE_FLASH_REGION_MESSAGE_setByteCount(x,y) \ 1032 setLU4((&((x)->ByteCount)),0,y) 1033 1034 /* 1035 * I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR 1036 */ 1037 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getSCSIType(x)\ 1038 getU1((&(x)->SCSIType),0) 1039 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setSCSIType(x,y)\ 1040 setU1((&(x)->SCSIType),0,y) 1041 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getProtectionManagement(x)\ 1042 getU1((&(x)->ProtectionManagement),0) 1043 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setProtectionManagement(x,y)\ 1044 setU1((&(x)->ProtectionManagement),0,y) 1045 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getSettings(x)\ 1046 getU1((&(x)->Settings),0) 1047 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setSettings(x,y)\ 1048 setU1((&(x)->Settings),0,y) 1049 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getReserved1(x)\ 1050 getU1((&(x)->Reserved1),0) 1051 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setReserved1(x,y)\ 1052 setU1((&(x)->Reserved1),0,y) 1053 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getInitiatorID(x)\ 1054 getLU4((&(x)->InitiatorID),0) 1055 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setInitiatorID(x,y)\ 1056 setLU4((&(x)->InitiatorID),0,y) 1057 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getScanLun0Only(x)\ 1058 getLU4((&(x)->ScanLun0Only),0) 1059 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setScanLun0Only(x,y)\ 1060 setLU4((&(x)->ScanLun0Only),0,y) 1061 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getDisableDevice(x)\ 1062 getLU2((&(x)->DisableDevice),0) 1063 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setDisableDevice(x,y)\ 1064 setLU2((&(x)->DisableDevice),0,y) 1065 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getMaxOffset(x)\ 1066 getU1((&(x)->MaxOffset),0) 1067 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setMaxOffset(x,y)\ 1068 setU1((&(x)->MaxOffset),0,y) 1069 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getMaxDataWidth(x)\ 1070 getU1((&(x)->MaxDataWidth),0) 1071 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setMaxDataWidth(x,y)\ 1072 setU1((&(x)->MaxDataWidth),0,y) 1073 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getMaxSyncRate(x)\ 1074 getLU4((&(x)->MaxSyncRate),0) 1075 #define I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_setMaxSyncRate(x,y)\ 1076 setLU4((&(x)->MaxSyncRate),0,y) 1077 1078 /* 1079 * I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME 1080 */ 1081 #define I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getStdReplyFramePtr(x)\ 1082 (&((x)->StdReplyFrame)) 1083 #define I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getTransferCount(x)\ 1084 getLU4((&(x)->TransferCount),0) 1085 #define I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setTransferCount(x,y)\ 1086 setLU4((&(x)->TransferCount),0,y) 1087 #define I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getAutoSenseTransferCount(x)\ 1088 getLU4((&(x)->AutoSenseTransferCount),0) 1089 #define I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setAutoSenseTransferCount(x,y)\ 1090 setLU4((&(x)->AutoSenseTransferCount),0,y) 1091 1092 /* 1093 * I2O_SINGLE_REPLY_MESSAGE_FRAME 1094 */ 1095 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_getStdMessageFramePtr(x)\ 1096 (&((x)->StdMessageFrame)) 1097 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_getTransactionContext(x)\ 1098 (x)->TransactionContext 1099 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_setTransactionContext(x,y)\ 1100 ((x)->TransactionContext = (y)) 1101 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_getDetailedStatusCode(x)\ 1102 getLU2((&((x)->DetailedStatusCode)),0) 1103 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode(x,y)\ 1104 setLU2((&((x)->DetailedStatusCode)),0,y) 1105 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_getreserved(x)\ 1106 getU1((&((x)->reserved)),0) 1107 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_setreserved(x,y)\ 1108 setU1((&((x)->reserved)),0,y) 1109 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_getReqStatus(x)\ 1110 getU1((&((x)->ReqStatus)),0) 1111 #define I2O_SINGLE_REPLY_MESSAGE_FRAME_setReqStatus(x,y)\ 1112 setU1((&((x)->ReqStatus)),0,y) 1113 1114 1115 /* 1116 * I2O_SCSI_SCB_EXECUTE_MESSAGE 1117 */ 1118 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getStdMessageFramePtr(x)\ 1119 (&((x)->StdMessageFrame)) 1120 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getTransactionContext(x)\ 1121 (x)->TransactionContext 1122 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_setTransactionContext(x,y)\ 1123 ((x)->TransactionContext = (y)) 1124 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getCDBLength(x)\ 1125 getU1((&((x)->CDBLength)),0) 1126 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(x,y)\ 1127 setU1((&((x)->CDBLength)),0,y) 1128 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getReserved(x)\ 1129 getU1((&((x)->Reserved)),0) 1130 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_setReserved(x,y)\ 1131 setU1((&((x)->Reserved)),0,y) 1132 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getSCBFlags(x)\ 1133 getLU2((&((x)->SCBFlags)),0) 1134 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags(x,y)\ 1135 setLU2((&((x)->SCBFlags)),0,y) 1136 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_getByteCount(x)\ 1137 getLU2((&((x)->ByteCount)),0) 1138 #define I2O_SCSI_SCB_EXECUTE_MESSAGE_setByteCount(x,y)\ 1139 setLU2((&((x)->ByteCount)),0,y) 1140 /* define for these */ 1141 /* U8 CDB[16]; */ 1142 /* I2O_SG_ELEMENT SGL; */ 1143 1144 1145 /* 1146 * I2O_FAILURE_REPLY_MESSAGE_FRAME 1147 */ 1148 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getStdMessageFramePtr(x)\ 1149 (&((x)->StdMessageFrame)) 1150 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getTransactionContext(x)\ 1151 (x)->TransactionContext 1152 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setTransactionContext(x,y)\ 1153 ((x)->TransactionContext = (y)) 1154 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getLowestVersion(x)\ 1155 getU1((&((x)->LowestVersion)),0) 1156 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setLowestVersion(x,y)\ 1157 setU1((&((x)->LowestVersion)),0,y) 1158 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getHighestVersion(x)\ 1159 getU1((&((x)->HighestVersion)),0) 1160 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setHighestVersion(x,y)\ 1161 setU1((&((x)->HighestVersion)),0,y) 1162 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getAgeLimit(x)\ 1163 getLU4((&((x)->AgeLimit)),0) 1164 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setAgeLimit(x,y)\ 1165 setLU4((&((x)->AgeLimit)),0,y) 1166 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getSeverity(x)\ 1167 _F_get8bit(x,Severity,0,Severity) 1168 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setSeverity(x,y)\ 1169 _F_set8bit(x,Severity,0,Severity,y) 1170 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getFailureCode(x)\ 1171 _F_get8bit(x,Severity,1,FailureCode) 1172 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setFailureCode(x,y)\ 1173 _F_get8bit(x,Severity,1,FailureCode,y) 1174 /* 1175 * #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getFailingHostUnitID(x)\ 1176 * _F_get16bit(x,reserved,1,FailingHostUnitID) 1177 * #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setFailingHostUnitID(x,y)\ 1178 * _F_set16bit(x,reserved,1,FailingHostUnitID,y) 1179 */ 1180 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_getPreservedMFA(x)\ 1181 getLU4((&((x)->PreservedMFA)),0) 1182 #define I2O_FAILURE_REPLY_MESSAGE_FRAME_setPreservedMFA(x,y)\ 1183 setLU4((&((x)->PreservedMFA)),0,y) 1184 1185 1186 1187 /* 1188 * I2O_EXEC_STATUS_GET_REPLY 1189 */ 1190 #define I2O_EXEC_STATUS_GET_REPLY_getOrganizationID(x)\ 1191 getLU2((&(x)->OrganizationID),0) 1192 #define I2O_EXEC_STATUS_GET_REPLY_setOrganizationID(x,y)\ 1193 setLU2((&(x)->OrganizationID),0,y) 1194 /* #define I2O_EXEC_STATUS_GET_REPLY_getreserved; */ 1195 #define I2O_EXEC_STATUS_GET_REPLY_getIOP_ID(x)\ 1196 _F_get12bit(x,IOP_ID,0,IOP_ID) 1197 #define I2O_EXEC_STATUS_GET_REPLY_setIOP_ID(x,y)\ 1198 _F_set12bit(x,IOP_ID,0,IOP_ID,y) 1199 /* #define I2O_EXEC_STATUS_GET_REPLY_getreserved1(x) */ 1200 #define I2O_EXEC_STATUS_GET_REPLY_getHostUnitID(x)\ 1201 _F_get16bit(x,IOP_ID,2,HostUnitID) 1202 #define I2O_EXEC_STATUS_GET_REPLY_setHostUnitID(x,y)\ 1203 _F_set16bit(x,IOP_ID,2,HostUnitID,y) 1204 #define I2O_EXEC_STATUS_GET_REPLY_getSegmentNumber(x)\ 1205 _F_get12bit(x,SegmentNumber,0,SegmentNumber) 1206 #define I2O_EXEC_STATUS_GET_REPLY_setSegmentNumber(x,y)\ 1207 _F_set12bit(x,SegmentNumber,0,SegmentNumber,y) 1208 #define I2O_EXEC_STATUS_GET_REPLY_getI2oVersion(x)\ 1209 _F_get4bit4(x,SegmentNumber,1,I2oVersion) 1210 #define I2O_EXEC_STATUS_GET_REPLY_setI2oVersion(x,y)\ 1211 _F_set4bit4(x,SegmentNumber,1,I2oVersion,y) 1212 #define I2O_EXEC_STATUS_GET_REPLY_getIopState(x)\ 1213 _F_get8bit(x,SegmentNumver,2,IopState) 1214 #define I2O_EXEC_STATUS_GET_REPLY_setIopState(x,y)\ 1215 _F_set8bit(x,SegmentNumver,2,IopState,y) 1216 #define I2O_EXEC_STATUS_GET_REPLY_getMessengerType(x)\ 1217 _F_get8bit(x,SegmentNumber,3,MessengerType) 1218 #define I2O_EXEC_STATUS_GET_REPLY_setMessengerType(x,y)\ 1219 _F_get8bit(x,SegmentNumber,3,MessengerType,y) 1220 #define I2O_EXEC_STATUS_GET_REPLY_getInboundMFrameSize(x)\ 1221 getLU2((&(x)->InboundMFrameSize),0) 1222 #define I2O_EXEC_STATUS_GET_REPLY_setInboundMFrameSize(x,y)\ 1223 setLU2((&(x)->InboundMFrameSize),0,y) 1224 #define I2O_EXEC_STATUS_GET_REPLY_getInitCode(x)\ 1225 getU1((&(x)->InitCode),0) 1226 #define I2O_EXEC_STATUS_GET_REPLY_setInitCode(x,y)\ 1227 setU1((&(x)->InitCode),0,y) 1228 /* #define I2O_EXEC_STATUS_GET_REPLY_getreserved2(x) */ 1229 #define I2O_EXEC_STATUS_GET_REPLY_getMaxInboundMFrames(x)\ 1230 getLU4((&(x)->MaxInboundMFrames),0) 1231 #define I2O_EXEC_STATUS_GET_REPLY_setMaxInboundMFrames(x,y)\ 1232 setLU4((&(x)->MaxInboundMFrames),0,y) 1233 #define I2O_EXEC_STATUS_GET_REPLY_getCurrentInboundMFrames(x)\ 1234 getLU4((&(x)->CurrentInboundMFrames),0) 1235 #define I2O_EXEC_STATUS_GET_REPLY_setCurrentInboundMFrames(x,y)\ 1236 setLU4((&(x)->CurrentInboundMFrames),0,y) 1237 #define I2O_EXEC_STATUS_GET_REPLY_getMaxOutboundMFrames(x)\ 1238 getLU4((&(x)->MaxOutboundMFrames),0) 1239 #define I2O_EXEC_STATUS_GET_REPLY_setMaxOutboundMFrames(x,y)\ 1240 setLU4((&(x)->MaxOutboundMFrames),0,y) 1241 /* #define I2O_EXEC_STATUS_GET_REPLY_getProductIDString(x) */ 1242 #define I2O_EXEC_STATUS_GET_REPLY_getExpectedLCTSize(x)\ 1243 getLU4((&(x)->ExpectedLCTSize),0) 1244 #define I2O_EXEC_STATUS_GET_REPLY_setExpectedLCTSize(x,y)\ 1245 setLU4((&(x)->ExpectedLCTSize),0,y) 1246 #define I2O_EXEC_STATUS_GET_REPLY_getIopCapabilities(x)\ 1247 getLU4((&(x)->IopCapabilities),0) 1248 #define I2O_EXEC_STATUS_GET_REPLY_setIopCapabilities(x,y)\ 1249 setLU4((&(x)->IopCapabilities),0,y) 1250 #define I2O_EXEC_STATUS_GET_REPLY_getDesiredPrivateMemSize(x)\ 1251 getLU4((&(x)->DesiredPrivateMemSize),0) 1252 #define I2O_EXEC_STATUS_GET_REPLY_setDesiredPrivateMemSize(x,y)\ 1253 setLU4((&(x)->DesiredPrivateMemSize),0,y) 1254 #define I2O_EXEC_STATUS_GET_REPLY_getCurrentPrivateMemSize(x)\ 1255 getLU4((&(x)->CurrentPrivateMemSize),0) 1256 #define I2O_EXEC_STATUS_GET_REPLY_setCurrentPrivateMemSize(x,y)\ 1257 setLU4((&(x)->CurrentPrivateMemSize),0,y) 1258 #define I2O_EXEC_STATUS_GET_REPLY_getCurrentPrivateMemBase(x)\ 1259 getLU4((&(x)->CurrentPrivateMemBase),0) 1260 #define I2O_EXEC_STATUS_GET_REPLY_setCurrentPrivateMemBase(x,y)\ 1261 setLU4((&(x)->CurrentPrivateMemBase),0,y) 1262 #define I2O_EXEC_STATUS_GET_REPLY_getDesiredPrivateIOSize(x)\ 1263 getLU4((&(x)->DesiredPrivateIOSize),0) 1264 #define I2O_EXEC_STATUS_GET_REPLY_setDesiredPrivateIOSize(x,y)\ 1265 setLU4((&(x)->DesiredPrivateIOSize),0,y) 1266 #define I2O_EXEC_STATUS_GET_REPLY_getCurrentPrivateIOSize(x)\ 1267 getLU4((&(x)->CurrentPrivateIOSize),0) 1268 #define I2O_EXEC_STATUS_GET_REPLY_setCurrentPrivateIOSize(x,y)\ 1269 setLU4((&(x)->CurrentPrivateIOSize),0,y) 1270 #define I2O_EXEC_STATUS_GET_REPLY_getCurrentPrivateIOBase(x)\ 1271 getLU4((&(x)->CurrentPrivateIOBase),0) 1272 #define I2O_EXEC_STATUS_GET_REPLY_setCurrentPrivateIOBase(x,y)\ 1273 setLU4((&(x)->CurrentPrivateIOBase),0,y) 1274 /* #define I2O_EXEC_STATUS_GET_REPLY_getreserved3(x) */ 1275 #define I2O_EXEC_STATUS_GET_REPLY_getSyncByte(x)\ 1276 getU1((&(x)->SyncByte),0) 1277 #define I2O_EXEC_STATUS_GET_REPLY_setSyncByte(x,y)\ 1278 setU1((&(x)->SyncByte),0,y) 1279 1280 1281 1282 /* 1283 * I2O_HBA_BUS_QUIESCE_MESSAGE 1284 */ 1285 #define I2O_HBA_BUS_QUIESCE_MESSAGE_getStdMessageFramePtr(x)\ 1286 (&((x)->StdMessageFrame)) 1287 #define I2O_HBA_BUS_QUIESCE_MESSAGE_getTransactionContext(x)\ 1288 getBU4((&((x)->TransactionContext)),0) 1289 #define I2O_HBA_BUS_QUIESCE_MESSAGE_setTransactionContext(x,y)\ 1290 setBU4((&((x)->TransactionContext)),0,y) 1291 #define I2O_HBA_BUS_QUIESCE_MESSAGE_getFlags(x)\ 1292 getLU4((&(x)->Flags),0) 1293 #define I2O_HBA_BUS_QUIESCE_MESSAGE_setFlags(x,y)\ 1294 setLU4((&(x)->Flags),0,y) 1295 1296 1297 #endif /* __INCi2odeph */ 1298