sys/dev/raid/asr/i2odep.h

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