drivers/common/sfc_efx/base/efx_types.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 Xilinx, Inc.
   4  * Copyright(c) 2007-2019 Solarflare Communications Inc.
   5  *
   6  * Ackowledgement to Fen Systems Ltd.
   7  */
   8
   9 #ifndef _SYS_EFX_TYPES_H
  10 #define _SYS_EFX_TYPES_H
  11
  12 #include "efsys.h"
  13 #include "efx_annote.h"
  14
  15 #ifdef  __cplusplus
  16 extern "C" {
  17 #endif
  18
  19 /*
  20  * Bitfield access
  21  *
  22  * Solarflare NICs make extensive use of bitfields up to 256 bits
  23  * wide.  Since there is no native 256-bit datatype on most systems,
  24  * and since 64-bit datatypes are inefficient on 32-bit systems and
  25  * vice versa, we wrap accesses in a way that uses the most efficient
  26  * datatype.
  27  *
  28  * The NICs are PCI devices and therefore little-endian.  Since most
  29  * of the quantities that we deal with are DMAed to/from host memory,
  30  * we define our datatypes (efx_xword_t, efx_oword_t, efx_qword_t and
  31  * efx_dword_t) to be little-endian.
  32  *
  33  * In the less common case of using PIO for individual register
  34  * writes, we construct the little-endian datatype in host memory and
  35  * then use non-swapping register access primitives, rather than
  36  * constructing a native-endian datatype and relying on implicit
  37  * byte-swapping.  (We use a similar strategy for register reads.)
  38  */
  39
  40 /*
  41  * NOTE: Field definitions here and elsewhere are done in terms of a lowest
  42  *       bit number (LBN) and a width.
  43  */
  44
  45 #define EFX_DUMMY_FIELD_LBN 0
  46 #define EFX_DUMMY_FIELD_WIDTH 0
  47
  48 #define EFX_BYTE_0_LBN 0
  49 #define EFX_BYTE_0_WIDTH 8
  50
  51 #define EFX_BYTE_1_LBN 8
  52 #define EFX_BYTE_1_WIDTH 8
  53
  54 #define EFX_BYTE_2_LBN 16
  55 #define EFX_BYTE_2_WIDTH 8
  56
  57 #define EFX_BYTE_3_LBN 24
  58 #define EFX_BYTE_3_WIDTH 8
  59
  60 #define EFX_BYTE_4_LBN 32
  61 #define EFX_BYTE_4_WIDTH 8
  62
  63 #define EFX_BYTE_5_LBN 40
  64 #define EFX_BYTE_5_WIDTH 8
  65
  66 #define EFX_BYTE_6_LBN 48
  67 #define EFX_BYTE_6_WIDTH 8
  68
  69 #define EFX_BYTE_7_LBN 56
  70 #define EFX_BYTE_7_WIDTH 8
  71
  72 #define EFX_WORD_0_LBN 0
  73 #define EFX_WORD_0_WIDTH 16
  74
  75 #define EFX_WORD_1_LBN 16
  76 #define EFX_WORD_1_WIDTH 16
  77
  78 #define EFX_WORD_2_LBN 32
  79 #define EFX_WORD_2_WIDTH 16
  80
  81 #define EFX_WORD_3_LBN 48
  82 #define EFX_WORD_3_WIDTH 16
  83
  84 #define EFX_DWORD_0_LBN 0
  85 #define EFX_DWORD_0_WIDTH 32
  86
  87 #define EFX_DWORD_1_LBN 32
  88 #define EFX_DWORD_1_WIDTH 32
  89
  90 #define EFX_DWORD_2_LBN 64
  91 #define EFX_DWORD_2_WIDTH 32
  92
  93 #define EFX_DWORD_3_LBN 96
  94 #define EFX_DWORD_3_WIDTH 32
  95
  96 #define EFX_DWORD_4_LBN 128
  97 #define EFX_DWORD_4_WIDTH 32
  98
  99 #define EFX_DWORD_5_LBN 160
 100 #define EFX_DWORD_5_WIDTH 32
 101
 102 #define EFX_DWORD_6_LBN 192
 103 #define EFX_DWORD_6_WIDTH 32
 104
 105 #define EFX_DWORD_7_LBN 224
 106 #define EFX_DWORD_7_WIDTH 32
 107
 108 /*
 109  * There are intentionally no EFX_QWORD_<N> field definitions here as the
 110  * implementation of EFX_QWORD_FIELD, EFX_OWORD_FIELD and EFX_XWORD_FIELD
 111  * do not support field widths larger than 32 bits.
 112  */
 113
 114 /* Specified attribute (i.e. LBN ow WIDTH) of the specified field */
 115 #define EFX_VAL(_field, _attribute)                                     \
 116         _field ## _ ## _attribute
 117
 118 /* Lowest bit number of the specified field */
 119 #define EFX_LOW_BIT(_field)                                             \
 120         EFX_VAL(_field, LBN)
 121
 122 /* Width of the specified field */
 123 #define EFX_WIDTH(_field)                                               \
 124         EFX_VAL(_field, WIDTH)
 125
 126 /* Highest bit number of the specified field */
 127 #define EFX_HIGH_BIT(_field)                                            \
 128         (EFX_LOW_BIT(_field) + EFX_WIDTH(_field) - 1)
 129
 130 /*
 131  * 64-bit mask equal in width to the specified field.
 132  *
 133  * For example, a field with width 5 would have a mask of 0x000000000000001f.
 134  */
 135 #define EFX_MASK64(_field)                                              \
 136         ((EFX_WIDTH(_field) == 64) ? ~((uint64_t)0) :                   \
 137             (((((uint64_t)1) << EFX_WIDTH(_field))) - 1))
 138 /*
 139  * 32-bit mask equal in width to the specified field.
 140  *
 141  * For example, a field with width 5 would have a mask of 0x0000001f.
 142  */
 143 #define EFX_MASK32(_field)                                              \
 144         ((EFX_WIDTH(_field) == 32) ? ~((uint32_t)0) :                   \
 145             (((((uint32_t)1) << EFX_WIDTH(_field))) - 1))
 146
 147 /*
 148  * 16-bit mask equal in width to the specified field.
 149  *
 150  * For example, a field with width 5 would have a mask of 0x001f.
 151  */
 152 #define EFX_MASK16(_field)                                              \
 153         ((EFX_WIDTH(_field) == 16) ? 0xffffu :                          \
 154             (uint16_t)((1 << EFX_WIDTH(_field)) - 1))
 155
 156 /*
 157  * 8-bit mask equal in width to the specified field.
 158  *
 159  * For example, a field with width 5 would have a mask of 0x1f.
 160  */
 161 #define EFX_MASK8(_field)                                               \
 162         ((uint8_t)((1 << EFX_WIDTH(_field)) - 1))
 163
 164 #pragma pack(1)
 165
 166 /*
 167  * A byte (i.e. 8-bit) datatype
 168  */
 169 typedef union efx_byte_u {
 170         uint8_t eb_u8[1];
 171 } efx_byte_t;
 172
 173 /*
 174  * A word (i.e. 16-bit) datatype
 175  *
 176  * This datatype is defined to be little-endian.
 177  */
 178 typedef union efx_word_u {
 179         efx_byte_t ew_byte[2];
 180         uint16_t ew_u16[1];
 181         uint8_t ew_u8[2];
 182 } efx_word_t;
 183
 184 /*
 185  * A doubleword (i.e. 32-bit) datatype
 186  *
 187  * This datatype is defined to be little-endian.
 188  */
 189 typedef union efx_dword_u {
 190         efx_byte_t ed_byte[4];
 191         efx_word_t ed_word[2];
 192         uint32_t ed_u32[1];
 193         uint16_t ed_u16[2];
 194         uint8_t ed_u8[4];
 195 } efx_dword_t;
 196
 197 /*
 198  * A quadword (i.e. 64-bit) datatype
 199  *
 200  * This datatype is defined to be little-endian.
 201  */
 202 typedef union efx_qword_u {
 203         efx_byte_t eq_byte[8];
 204         efx_word_t eq_word[4];
 205         efx_dword_t eq_dword[2];
 206 #if EFSYS_HAS_UINT64
 207         uint64_t eq_u64[1];
 208 #endif
 209         uint32_t eq_u32[2];
 210         uint16_t eq_u16[4];
 211         uint8_t eq_u8[8];
 212 } efx_qword_t;
 213
 214 /*
 215  * An octword (i.e. 128-bit) datatype
 216  *
 217  * This datatype is defined to be little-endian.
 218  */
 219 typedef union efx_oword_u {
 220         efx_byte_t eo_byte[16];
 221         efx_word_t eo_word[8];
 222         efx_dword_t eo_dword[4];
 223         efx_qword_t eo_qword[2];
 224 #if EFSYS_HAS_SSE2_M128
 225         __m128i eo_u128[1];
 226 #endif
 227 #if EFSYS_HAS_UINT64
 228         uint64_t eo_u64[2];
 229 #endif
 230         uint32_t eo_u32[4];
 231         uint16_t eo_u16[8];
 232         uint8_t eo_u8[16];
 233 } efx_oword_t;
 234
 235 /*
 236  * A hexaword (i.e. 256-bit) datatype
 237  *
 238  * This datatype is defined to be little-endian.
 239  */
 240 typedef union efx_xword_u {
 241         efx_byte_t ex_byte[32];
 242         efx_word_t ex_word[16];
 243         efx_dword_t ex_dword[8];
 244         efx_qword_t ex_qword[4];
 245         efx_oword_t ex_oword[2];
 246 #if EFSYS_HAS_SSE2_M128
 247         __m128i ex_u128[2];
 248 #endif
 249 #if EFSYS_HAS_UINT64
 250         uint64_t ex_u64[4];
 251 #endif
 252         uint32_t ex_u32[8];
 253         uint16_t ex_u16[16];
 254         uint8_t ex_u8[32];
 255 } efx_xword_t;
 256
 257 #pragma pack()
 258
 259 #define __SWAP16(_x)                            \
 260         ((((_x) & 0xff) << 8) |                 \
 261         (((_x) >> 8) & 0xff))
 262
 263 #define __SWAP32(_x)                            \
 264         ((__SWAP16((_x) & 0xffff) << 16) |      \
 265         __SWAP16(((_x) >> 16) & 0xffff))
 266
 267 #define __SWAP64(_x)                            \
 268         ((__SWAP32((_x) & 0xffffffff) << 32) |  \
 269         __SWAP32(((_x) >> 32) & 0xffffffff))
 270
 271 #define __NOSWAP16(_x)          (_x)
 272 #define __NOSWAP32(_x)          (_x)
 273 #define __NOSWAP64(_x)          (_x)
 274
 275 #if EFSYS_IS_BIG_ENDIAN
 276
 277 #define __CPU_TO_LE_16(_x)      ((uint16_t)__SWAP16(_x))
 278 #define __LE_TO_CPU_16(_x)      ((uint16_t)__SWAP16(_x))
 279 #define __CPU_TO_BE_16(_x)      ((uint16_t)__NOSWAP16(_x))
 280 #define __BE_TO_CPU_16(_x)      ((uint16_t)__NOSWAP16(_x))
 281
 282 #define __CPU_TO_LE_32(_x)      ((uint32_t)__SWAP32(_x))
 283 #define __LE_TO_CPU_32(_x)      ((uint32_t)__SWAP32(_x))
 284 #define __CPU_TO_BE_32(_x)      ((uint32_t)__NOSWAP32(_x))
 285 #define __BE_TO_CPU_32(_x)      ((uint32_t)__NOSWAP32(_x))
 286
 287 #define __CPU_TO_LE_64(_x)      ((uint64_t)__SWAP64(_x))
 288 #define __LE_TO_CPU_64(_x)      ((uint64_t)__SWAP64(_x))
 289 #define __CPU_TO_BE_64(_x)      ((uint64_t)__NOSWAP64(_x))
 290 #define __BE_TO_CPU_64(_x)      ((uint64_t)__NOSWAP64(_x))
 291
 292 #elif EFSYS_IS_LITTLE_ENDIAN
 293
 294 #define __CPU_TO_LE_16(_x)      ((uint16_t)__NOSWAP16(_x))
 295 #define __LE_TO_CPU_16(_x)      ((uint16_t)__NOSWAP16(_x))
 296 #define __CPU_TO_BE_16(_x)      ((uint16_t)__SWAP16(_x))
 297 #define __BE_TO_CPU_16(_x)      ((uint16_t)__SWAP16(_x))
 298
 299 #define __CPU_TO_LE_32(_x)      ((uint32_t)__NOSWAP32(_x))
 300 #define __LE_TO_CPU_32(_x)      ((uint32_t)__NOSWAP32(_x))
 301 #define __CPU_TO_BE_32(_x)      ((uint32_t)__SWAP32(_x))
 302 #define __BE_TO_CPU_32(_x)      ((uint32_t)__SWAP32(_x))
 303
 304 #define __CPU_TO_LE_64(_x)      ((uint64_t)__NOSWAP64(_x))
 305 #define __LE_TO_CPU_64(_x)      ((uint64_t)__NOSWAP64(_x))
 306 #define __CPU_TO_BE_64(_x)      ((uint64_t)__SWAP64(_x))
 307 #define __BE_TO_CPU_64(_x)      ((uint64_t)__SWAP64(_x))
 308
 309 #else
 310
 311 #error "Neither of EFSYS_IS_{BIG,LITTLE}_ENDIAN is set"
 312
 313 #endif
 314
 315 #define __NATIVE_8(_x)  (uint8_t)(_x)
 316
 317 /* Format string for printing an efx_byte_t */
 318 #define EFX_BYTE_FMT "0x%02x"
 319
 320 /* Format string for printing an efx_word_t */
 321 #define EFX_WORD_FMT "0x%04x"
 322
 323 /* Format string for printing an efx_dword_t */
 324 #define EFX_DWORD_FMT "0x%08x"
 325
 326 /* Format string for printing an efx_qword_t */
 327 #define EFX_QWORD_FMT "0x%08x:%08x"
 328
 329 /* Format string for printing an efx_oword_t */
 330 #define EFX_OWORD_FMT "0x%08x:%08x:%08x:%08x"
 331
 332 /* Format string for printing an efx_xword_t */
 333 #define EFX_XWORD_FMT "0x%08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x"
 334
 335 /* Parameters for printing an efx_byte_t */
 336 #define EFX_BYTE_VAL(_byte)                                     \
 337         ((unsigned int)__NATIVE_8((_byte).eb_u8[0]))
 338
 339 /* Parameters for printing an efx_word_t */
 340 #define EFX_WORD_VAL(_word)                                     \
 341         ((unsigned int)__LE_TO_CPU_16((_word).ew_u16[0]))
 342
 343 /* Parameters for printing an efx_dword_t */
 344 #define EFX_DWORD_VAL(_dword)                                   \
 345         ((unsigned int)__LE_TO_CPU_32((_dword).ed_u32[0]))
 346
 347 /* Parameters for printing an efx_qword_t */
 348 #define EFX_QWORD_VAL(_qword)                                   \
 349         ((unsigned int)__LE_TO_CPU_32((_qword).eq_u32[1])),     \
 350         ((unsigned int)__LE_TO_CPU_32((_qword).eq_u32[0]))
 351
 352 /* Parameters for printing an efx_oword_t */
 353 #define EFX_OWORD_VAL(_oword)                                   \
 354         ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[3])),     \
 355         ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[2])),     \
 356         ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[1])),     \
 357         ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[0]))
 358
 359 /* Parameters for printing an efx_xword_t */
 360 #define EFX_XWORD_VAL(_xword)                                   \
 361         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[7])),     \
 362         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[6])),     \
 363         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[5])),     \
 364         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[4])),     \
 365         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[3])),     \
 366         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[2])),     \
 367         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[1])),     \
 368         ((unsigned int)__LE_TO_CPU_32((_xword).ex_u32[0]))
 369
 370 /*
 371  * Stop lint complaining about some shifts.
 372  */
 373 #ifdef  __lint
 374 extern int fix_lint;
 375 #define FIX_LINT(_x)    (_x + fix_lint)
 376 #else
 377 #define FIX_LINT(_x)    (_x)
 378 #endif
 379
 380 /*
 381  * Saturation arithmetic subtract with minimum equal to zero.
 382  *
 383  * Use saturating arithmetic to ensure a non-negative result. This
 384  * avoids undefined behaviour (and compiler warnings) when used as a
 385  * shift count.
 386  */
 387 #define EFX_SSUB(_val, _sub) \
 388         ((_val) > (_sub) ? ((_val) - (_sub)) : 0)
 389
 390 /*
 391  * Extract bit field portion [low,high) from the native-endian element
 392  * which contains bits [min,max).
 393  *
 394  * For example, suppose "element" represents the high 32 bits of a
 395  * 64-bit value, and we wish to extract the bits belonging to the bit
 396  * field occupying bits 28-45 of this 64-bit value.
 397  *
 398  * Then EFX_EXTRACT(_element, 32, 63, 28, 45) would give
 399  *
 400  *   (_element) << 4
 401  *
 402  * The result will contain the relevant bits filled in in the range
 403  * [0,high-low), with garbage in bits [high-low+1,...).
 404  */
 405 #define EFX_EXTRACT_NATIVE(_element, _min, _max, _low, _high)           \
 406         ((FIX_LINT(_low > _max) || FIX_LINT(_high < _min)) ?            \
 407                 0U :                                                    \
 408                 ((_low > _min) ?                                        \
 409                         ((_element) >> EFX_SSUB(_low, _min)) :          \
 410                         ((_element) << EFX_SSUB(_min, _low))))
 411
 412 /*
 413  * Extract bit field portion [low,high) from the 64-bit little-endian
 414  * element which contains bits [min,max)
 415  */
 416 #define EFX_EXTRACT64(_element, _min, _max, _low, _high)                \
 417         EFX_EXTRACT_NATIVE(__LE_TO_CPU_64(_element), _min, _max, _low, _high)
 418
 419 /*
 420  * Extract bit field portion [low,high) from the 32-bit little-endian
 421  * element which contains bits [min,max)
 422  */
 423 #define EFX_EXTRACT32(_element, _min, _max, _low, _high)                \
 424         EFX_EXTRACT_NATIVE(__LE_TO_CPU_32(_element), _min, _max, _low, _high)
 425
 426 /*
 427  * Extract bit field portion [low,high) from the 16-bit little-endian
 428  * element which contains bits [min,max)
 429  */
 430 #define EFX_EXTRACT16(_element, _min, _max, _low, _high)                \
 431         EFX_EXTRACT_NATIVE(__LE_TO_CPU_16(_element), _min, _max, _low, _high)
 432
 433 /*
 434  * Extract bit field portion [low,high) from the 8-bit
 435  * element which contains bits [min,max)
 436  */
 437 #define EFX_EXTRACT8(_element, _min, _max, _low, _high)                 \
 438         EFX_EXTRACT_NATIVE(__NATIVE_8(_element), _min, _max, _low, _high)
 439
 440 #define EFX_EXTRACT_XWORD64(_xword, _low, _high)                        \
 441         (EFX_EXTRACT64((_xword).ex_u64[0], FIX_LINT(0), FIX_LINT(63),   \
 442             _low, _high) |                                              \
 443         EFX_EXTRACT64((_xword).ex_u64[1], FIX_LINT(64), FIX_LINT(127),  \
 444             _low, _high) |                                              \
 445         EFX_EXTRACT64((_xword).ex_u64[2], FIX_LINT(128), FIX_LINT(191), \
 446             _low, _high) |                                              \
 447         EFX_EXTRACT64((_xword).ex_u64[3], FIX_LINT(192), FIX_LINT(255), \
 448             _low, _high))
 449
 450 #define EFX_EXTRACT_XWORD32(_oword, _low, _high)                        \
 451         (EFX_EXTRACT32((_xword).ex_u32[0], FIX_LINT(0), FIX_LINT(31),   \
 452             _low, _high) |                                              \
 453         EFX_EXTRACT32((_xword).ex_u32[1], FIX_LINT(32), FIX_LINT(63),   \
 454             _low, _high) |                                              \
 455         EFX_EXTRACT32((_xword).ex_u32[2], FIX_LINT(64), FIX_LINT(95),   \
 456             _low, _high) |                                              \
 457         EFX_EXTRACT32((_xword).ex_u32[3], FIX_LINT(96), FIX_LINT(127),  \
 458             _low, _high) |                                              \
 459         EFX_EXTRACT32((_xword).ex_u32[4], FIX_LINT(128), FIX_LINT(159), \
 460             _low, _high) |                                              \
 461         EFX_EXTRACT32((_xword).ex_u32[5], FIX_LINT(160), FIX_LINT(191), \
 462             _low, _high) |                                              \
 463         EFX_EXTRACT32((_xword).ex_u32[6], FIX_LINT(192), FIX_LINT(223), \
 464             _low, _high) |                                              \
 465         EFX_EXTRACT32((_xword).ex_u32[7], FIX_LINT(224), FIX_LINT(255), \
 466             _low, _high))
 467
 468 #define EFX_EXTRACT_OWORD64(_oword, _low, _high)                        \
 469         (EFX_EXTRACT64((_oword).eo_u64[0], FIX_LINT(0), FIX_LINT(63),   \
 470             _low, _high) |                                              \
 471         EFX_EXTRACT64((_oword).eo_u64[1], FIX_LINT(64), FIX_LINT(127),  \
 472             _low, _high))
 473
 474 #define EFX_EXTRACT_OWORD32(_oword, _low, _high)                        \
 475         (EFX_EXTRACT32((_oword).eo_u32[0], FIX_LINT(0), FIX_LINT(31),   \
 476             _low, _high) |                                              \
 477         EFX_EXTRACT32((_oword).eo_u32[1], FIX_LINT(32), FIX_LINT(63),   \
 478             _low, _high) |                                              \
 479         EFX_EXTRACT32((_oword).eo_u32[2], FIX_LINT(64), FIX_LINT(95),   \
 480             _low, _high) |                                              \
 481         EFX_EXTRACT32((_oword).eo_u32[3], FIX_LINT(96), FIX_LINT(127),  \
 482             _low, _high))
 483
 484 #define EFX_EXTRACT_QWORD64(_qword, _low, _high)                        \
 485         (EFX_EXTRACT64((_qword).eq_u64[0], FIX_LINT(0), FIX_LINT(63),   \
 486             _low, _high))
 487
 488 #define EFX_EXTRACT_QWORD32(_qword, _low, _high)                        \
 489         (EFX_EXTRACT32((_qword).eq_u32[0], FIX_LINT(0), FIX_LINT(31),   \
 490             _low, _high) |                                              \
 491         EFX_EXTRACT32((_qword).eq_u32[1], FIX_LINT(32), FIX_LINT(63),   \
 492             _low, _high))
 493
 494 #define EFX_EXTRACT_DWORD(_dword, _low, _high)                          \
 495         (EFX_EXTRACT32((_dword).ed_u32[0], FIX_LINT(0), FIX_LINT(31),   \
 496             _low, _high))
 497
 498 #define EFX_EXTRACT_WORD(_word, _low, _high)                            \
 499         (EFX_EXTRACT16((_word).ew_u16[0], FIX_LINT(0), FIX_LINT(15),    \
 500             _low, _high))
 501
 502 #define EFX_EXTRACT_BYTE(_byte, _low, _high)                            \
 503         (EFX_EXTRACT8((_byte).eb_u8[0], FIX_LINT(0), FIX_LINT(7),       \
 504             _low, _high))
 505
 506
 507 #define EFX_XWORD_FIELD64(_xword, _field)                               \
 508         ((uint32_t)EFX_EXTRACT_XWORD64(_xword, EFX_LOW_BIT(_field),     \
 509             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 510
 511 #define EFX_XWORD_FIELD32(_xword, _field)                               \
 512         (EFX_EXTRACT_XWORD32(_xword, EFX_LOW_BIT(_field),               \
 513             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 514
 515 #define EFX_OWORD_FIELD64(_oword, _field)                               \
 516         ((uint32_t)EFX_EXTRACT_OWORD64(_oword, EFX_LOW_BIT(_field),     \
 517             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 518
 519 #define EFX_OWORD_FIELD32(_oword, _field)                               \
 520         (EFX_EXTRACT_OWORD32(_oword, EFX_LOW_BIT(_field),               \
 521             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 522
 523 #define EFX_QWORD_FIELD64(_qword, _field)                               \
 524         ((uint32_t)EFX_EXTRACT_QWORD64(_qword, EFX_LOW_BIT(_field),     \
 525             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 526
 527 #define EFX_QWORD_FIELD32(_qword, _field)                               \
 528         (EFX_EXTRACT_QWORD32(_qword, EFX_LOW_BIT(_field),               \
 529             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 530
 531 #define EFX_DWORD_FIELD(_dword, _field)                                 \
 532         (EFX_EXTRACT_DWORD(_dword, EFX_LOW_BIT(_field),                 \
 533             EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
 534
 535 #define EFX_WORD_FIELD(_word, _field)                                   \
 536         (EFX_EXTRACT_WORD(_word, EFX_LOW_BIT(_field),                   \
 537             EFX_HIGH_BIT(_field)) & EFX_MASK16(_field))
 538
 539 #define EFX_BYTE_FIELD(_byte, _field)                                   \
 540         (EFX_EXTRACT_BYTE(_byte, EFX_LOW_BIT(_field),                   \
 541             EFX_HIGH_BIT(_field)) & EFX_MASK8(_field))
 542
 543
 544 #define EFX_XWORD_IS_EQUAL64(_xword_a, _xword_b)                        \
 545         ((_xword_a).ex_u64[0] == (_xword_b).ex_u64[0] &&                \
 546             (_xword_a).ex_u64[1] == (_xword_b).ex_u64[1] &&             \
 547             (_xword_a).ex_u64[2] == (_xword_b).ex_u64[2] &&             \
 548             (_xword_a).ex_u64[3] == (_xword_b).ex_u64[3])
 549
 550 #define EFX_XWORD_IS_EQUAL32(_xword_a, _xword_b)                        \
 551         ((_xword_a).ex_u32[0] == (_xword_b).ex_u32[0] &&                \
 552             (_xword_a).ex_u32[1] == (_xword_b).ex_u32[1] &&             \
 553             (_xword_a).ex_u32[2] == (_xword_b).ex_u32[2] &&             \
 554             (_xword_a).ex_u32[3] == (_xword_b).ex_u32[3] &&             \
 555             (_xword_a).ex_u32[4] == (_xword_b).ex_u32[4] &&             \
 556             (_xword_a).ex_u32[5] == (_xword_b).ex_u32[5] &&             \
 557             (_xword_a).ex_u32[6] == (_xword_b).ex_u32[6] &&             \
 558             (_xword_a).ex_u32[7] == (_xword_b).ex_u32[7])
 559
 560 #define EFX_OWORD_IS_EQUAL64(_oword_a, _oword_b)                        \
 561         ((_oword_a).eo_u64[0] == (_oword_b).eo_u64[0] &&                \
 562             (_oword_a).eo_u64[1] == (_oword_b).eo_u64[1])
 563
 564 #define EFX_OWORD_IS_EQUAL32(_oword_a, _oword_b)                        \
 565         ((_oword_a).eo_u32[0] == (_oword_b).eo_u32[0] &&                \
 566             (_oword_a).eo_u32[1] == (_oword_b).eo_u32[1] &&             \
 567             (_oword_a).eo_u32[2] == (_oword_b).eo_u32[2] &&             \
 568             (_oword_a).eo_u32[3] == (_oword_b).eo_u32[3])
 569
 570 #define EFX_QWORD_IS_EQUAL64(_qword_a, _qword_b)                        \
 571         ((_qword_a).eq_u64[0] == (_qword_b).eq_u64[0])
 572
 573 #define EFX_QWORD_IS_EQUAL32(_qword_a, _qword_b)                        \
 574         ((_qword_a).eq_u32[0] == (_qword_b).eq_u32[0] &&                \
 575             (_qword_a).eq_u32[1] == (_qword_b).eq_u32[1])
 576
 577 #define EFX_DWORD_IS_EQUAL(_dword_a, _dword_b)                          \
 578         ((_dword_a).ed_u32[0] == (_dword_b).ed_u32[0])
 579
 580 #define EFX_WORD_IS_EQUAL(_word_a, _word_b)                             \
 581         ((_word_a).ew_u16[0] == (_word_b).ew_u16[0])
 582
 583 #define EFX_BYTE_IS_EQUAL(_byte_a, _byte_b)                             \
 584         ((_byte_a).eb_u8[0] == (_byte_b).eb_u8[0])
 585
 586
 587 #define EFX_XWORD_IS_ZERO64(_xword)                                     \
 588         (((_xword).ex_u64[0] |                                          \
 589             (_xword).ex_u64[1] |                                        \
 590             (_xword).ex_u64[2] |                                        \
 591             (_xword).ex_u64[3]) == 0)
 592
 593 #define EFX_XWORD_IS_ZERO32(_xword)                                     \
 594         (((_xword).ex_u32[0] |                                          \
 595             (_xword).ex_u32[1] |                                        \
 596             (_xword).ex_u32[2] |                                        \
 597             (_xword).ex_u32[3] |                                        \
 598             (_xword).ex_u32[4] |                                        \
 599             (_xword).ex_u32[5] |                                        \
 600             (_xword).ex_u32[6] |                                        \
 601             (_xword).ex_u32[7]) == 0)
 602
 603 #define EFX_OWORD_IS_ZERO64(_oword)                                     \
 604         (((_oword).eo_u64[0] |                                          \
 605             (_oword).eo_u64[1]) == 0)
 606
 607 #define EFX_OWORD_IS_ZERO32(_oword)                                     \
 608         (((_oword).eo_u32[0] |                                          \
 609             (_oword).eo_u32[1] |                                        \
 610             (_oword).eo_u32[2] |                                        \
 611             (_oword).eo_u32[3]) == 0)
 612
 613 #define EFX_QWORD_IS_ZERO64(_qword)                                     \
 614         (((_qword).eq_u64[0]) == 0)
 615
 616 #define EFX_QWORD_IS_ZERO32(_qword)                                     \
 617         (((_qword).eq_u32[0] |                                          \
 618             (_qword).eq_u32[1]) == 0)
 619
 620 #define EFX_DWORD_IS_ZERO(_dword)                                       \
 621         (((_dword).ed_u32[0]) == 0)
 622
 623 #define EFX_WORD_IS_ZERO(_word)                                         \
 624         (((_word).ew_u16[0]) == 0)
 625
 626 #define EFX_BYTE_IS_ZERO(_byte)                                         \
 627         (((_byte).eb_u8[0]) == 0)
 628
 629
 630 #define EFX_XWORD_IS_SET64(_xword)                                      \
 631         (((_xword).ex_u64[0] &                                          \
 632             (_xword).ex_u64[1] &                                        \
 633             (_xword).ex_u64[2] &                                        \
 634             (_xword).ex_u64[3]) == ~((uint64_t)0))
 635
 636 #define EFX_XWORD_IS_SET32(_xword)                                      \
 637         (((_xword).ex_u32[0] &                                          \
 638             (_xword).ex_u32[1] &                                        \
 639             (_xword).ex_u32[2] &                                        \
 640             (_xword).ex_u32[3] &                                        \
 641             (_xword).ex_u32[4] &                                        \
 642             (_xword).ex_u32[5] &                                        \
 643             (_xword).ex_u32[6] &                                        \
 644             (_xword).ex_u32[7]) == ~((uint32_t)0))
 645
 646 #define EFX_OWORD_IS_SET64(_oword)                                      \
 647         (((_oword).eo_u64[0] &                                          \
 648             (_oword).eo_u64[1]) == ~((uint64_t)0))
 649
 650 #define EFX_OWORD_IS_SET32(_oword)                                      \
 651         (((_oword).eo_u32[0] &                                          \
 652             (_oword).eo_u32[1] &                                        \
 653             (_oword).eo_u32[2] &                                        \
 654             (_oword).eo_u32[3]) == ~((uint32_t)0))
 655
 656 #define EFX_QWORD_IS_SET64(_qword)                                      \
 657         (((_qword).eq_u64[0]) == ~((uint64_t)0))
 658
 659 #define EFX_QWORD_IS_SET32(_qword)                                      \
 660         (((_qword).eq_u32[0] &                                          \
 661             (_qword).eq_u32[1]) == ~((uint32_t)0))
 662
 663 #define EFX_DWORD_IS_SET(_dword)                                        \
 664         ((_dword).ed_u32[0] == ~((uint32_t)0))
 665
 666 #define EFX_WORD_IS_SET(_word)                                          \
 667         ((_word).ew_u16[0] == ~((uint16_t)0))
 668
 669 #define EFX_BYTE_IS_SET(_byte)                                          \
 670         ((_byte).eb_u8[0] == ~((uint8_t)0))
 671
 672 /*
 673  * Construct bit field portion
 674  *
 675  * Creates the portion of the bit field [low,high) that lies within
 676  * the range [min,max).
 677  */
 678
 679 #define EFX_INSERT_NATIVE64(_min, _max, _low, _high, _value)            \
 680         (((_low > _max) || (_high < _min)) ?                            \
 681                 0U :                                                    \
 682                 ((_low > _min) ?                                        \
 683                         (((uint64_t)(_value)) << EFX_SSUB(_low, _min)) :\
 684                         (((uint64_t)(_value)) >> EFX_SSUB(_min, _low))))
 685
 686 #define EFX_INSERT_NATIVE32(_min, _max, _low, _high, _value)            \
 687         (((_low > _max) || (_high < _min)) ?                            \
 688                 0U :                                                    \
 689                 ((_low > _min) ?                                        \
 690                         (((uint32_t)(_value)) << EFX_SSUB(_low, _min)) :\
 691                         (((uint32_t)(_value)) >> EFX_SSUB(_min, _low))))
 692
 693 #define EFX_INSERT_NATIVE16(_min, _max, _low, _high, _value)            \
 694         (((_low > _max) || (_high < _min)) ?                            \
 695                 0U :                                                    \
 696                 (uint16_t)((_low > _min) ?                              \
 697                                 ((_value) << EFX_SSUB(_low, _min)) :    \
 698                                 ((_value) >> EFX_SSUB(_min, _low))))
 699
 700 #define EFX_INSERT_NATIVE8(_min, _max, _low, _high, _value)             \
 701         (((_low > _max) || (_high < _min)) ?                            \
 702                 0U :                                                    \
 703                 (uint8_t)((_low > _min) ?                               \
 704                                 ((_value) << EFX_SSUB(_low, _min)) :    \
 705                                 ((_value) >> EFX_SSUB(_min, _low))))
 706
 707 /*
 708  * Construct bit field portion
 709  *
 710  * Creates the portion of the named bit field that lies within the
 711  * range [min,max).
 712  */
 713 #define EFX_INSERT_FIELD_NATIVE64(_min, _max, _field, _value)           \
 714         EFX_INSERT_NATIVE64(_min, _max, EFX_LOW_BIT(_field),            \
 715             EFX_HIGH_BIT(_field), _value)
 716
 717 #define EFX_INSERT_FIELD_NATIVE32(_min, _max, _field, _value)           \
 718         EFX_INSERT_NATIVE32(_min, _max, EFX_LOW_BIT(_field),            \
 719             EFX_HIGH_BIT(_field), _value)
 720
 721 #define EFX_INSERT_FIELD_NATIVE16(_min, _max, _field, _value)           \
 722         EFX_INSERT_NATIVE16(_min, _max, EFX_LOW_BIT(_field),            \
 723             EFX_HIGH_BIT(_field), _value)
 724
 725 #define EFX_INSERT_FIELD_NATIVE8(_min, _max, _field, _value)            \
 726         EFX_INSERT_NATIVE8(_min, _max, EFX_LOW_BIT(_field),             \
 727             EFX_HIGH_BIT(_field), _value)
 728
 729 /*
 730  * Construct bit field
 731  *
 732  * Creates the portion of the named bit fields that lie within the
 733  * range [min,max).
 734  */
 735 #define EFX_INSERT_FIELDS64(_min, _max,                                 \
 736             _field1, _value1, _field2, _value2, _field3, _value3,       \
 737             _field4, _value4, _field5, _value5, _field6, _value6,       \
 738             _field7, _value7, _field8, _value8, _field9, _value9,       \
 739             _field10, _value10)                                         \
 740         __CPU_TO_LE_64(                                                 \
 741             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field1, _value1) |   \
 742             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field2, _value2) |   \
 743             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field3, _value3) |   \
 744             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field4, _value4) |   \
 745             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field5, _value5) |   \
 746             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field6, _value6) |   \
 747             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field7, _value7) |   \
 748             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field8, _value8) |   \
 749             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field9, _value9) |   \
 750             EFX_INSERT_FIELD_NATIVE64(_min, _max, _field10, _value10))
 751
 752 #define EFX_INSERT_FIELDS32(_min, _max,                                 \
 753             _field1, _value1, _field2, _value2, _field3, _value3,       \
 754             _field4, _value4, _field5, _value5, _field6, _value6,       \
 755             _field7, _value7, _field8, _value8, _field9, _value9,       \
 756             _field10, _value10)                                         \
 757         __CPU_TO_LE_32(                                                 \
 758             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field1, _value1) |   \
 759             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field2, _value2) |   \
 760             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field3, _value3) |   \
 761             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field4, _value4) |   \
 762             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field5, _value5) |   \
 763             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field6, _value6) |   \
 764             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field7, _value7) |   \
 765             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field8, _value8) |   \
 766             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field9, _value9) |   \
 767             EFX_INSERT_FIELD_NATIVE32(_min, _max, _field10, _value10))
 768
 769 #define EFX_INSERT_FIELDS16(_min, _max,                                 \
 770             _field1, _value1, _field2, _value2, _field3, _value3,       \
 771             _field4, _value4, _field5, _value5, _field6, _value6,       \
 772             _field7, _value7, _field8, _value8, _field9, _value9,       \
 773             _field10, _value10)                                         \
 774         __CPU_TO_LE_16(                                                 \
 775             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field1, _value1) |   \
 776             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field2, _value2) |   \
 777             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field3, _value3) |   \
 778             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field4, _value4) |   \
 779             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field5, _value5) |   \
 780             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field6, _value6) |   \
 781             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field7, _value7) |   \
 782             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field8, _value8) |   \
 783             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field9, _value9) |   \
 784             EFX_INSERT_FIELD_NATIVE16(_min, _max, _field10, _value10))
 785
 786 #define EFX_INSERT_FIELDS8(_min, _max,                                  \
 787             _field1, _value1, _field2, _value2, _field3, _value3,       \
 788             _field4, _value4, _field5, _value5, _field6, _value6,       \
 789             _field7, _value7, _field8, _value8, _field9, _value9,       \
 790             _field10, _value10)                                         \
 791         __NATIVE_8(                                                     \
 792             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field1, _value1) |    \
 793             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field2, _value2) |    \
 794             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field3, _value3) |    \
 795             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field4, _value4) |    \
 796             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field5, _value5) |    \
 797             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field6, _value6) |    \
 798             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field7, _value7) |    \
 799             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field8, _value8) |    \
 800             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field9, _value9) |    \
 801             EFX_INSERT_FIELD_NATIVE8(_min, _max, _field10, _value10))
 802
 803 #define EFX_POPULATE_XWORD64(_xword,                                    \
 804             _field1, _value1, _field2, _value2, _field3, _value3,       \
 805             _field4, _value4, _field5, _value5, _field6, _value6,       \
 806             _field7, _value7, _field8, _value8, _field9, _value9,       \
 807             _field10, _value10)                                         \
 808         do {                                                            \
 809                 _NOTE(CONSTANTCONDITION)                                \
 810                 (_xword).ex_u64[0] = EFX_INSERT_FIELDS64(0, 63,         \
 811                     _field1, _value1, _field2, _value2,                 \
 812                     _field3, _value3, _field4, _value4,                 \
 813                     _field5, _value5, _field6, _value6,                 \
 814                     _field7, _value7, _field8, _value8,                 \
 815                     _field9, _value9, _field10, _value10);              \
 816                 _NOTE(CONSTANTCONDITION)                                \
 817                 (_xword).ex_u64[1] = EFX_INSERT_FIELDS64(64, 127,       \
 818                     _field1, _value1, _field2, _value2,                 \
 819                     _field3, _value3, _field4, _value4,                 \
 820                     _field5, _value5, _field6, _value6,                 \
 821                     _field7, _value7, _field8, _value8,                 \
 822                     _field9, _value9, _field10, _value10);              \
 823                 _NOTE(CONSTANTCONDITION)                                \
 824                 (_xword).ex_u64[2] = EFX_INSERT_FIELDS64(128, 191,      \
 825                     _field1, _value1, _field2, _value2,                 \
 826                     _field3, _value3, _field4, _value4,                 \
 827                     _field5, _value5, _field6, _value6,                 \
 828                     _field7, _value7, _field8, _value8,                 \
 829                     _field9, _value9, _field10, _value10);              \
 830                 _NOTE(CONSTANTCONDITION)                                \
 831                 (_xword).ex_u64[3] = EFX_INSERT_FIELDS64(192, 255,      \
 832                     _field1, _value1, _field2, _value2,                 \
 833                     _field3, _value3, _field4, _value4,                 \
 834                     _field5, _value5, _field6, _value6,                 \
 835                     _field7, _value7, _field8, _value8,                 \
 836                     _field9, _value9, _field10, _value10);              \
 837         _NOTE(CONSTANTCONDITION)                                        \
 838         } while (B_FALSE)
 839
 840 #define EFX_POPULATE_XWORD32(_xword,                                    \
 841             _field1, _value1, _field2, _value2, _field3, _value3,       \
 842             _field4, _value4, _field5, _value5, _field6, _value6,       \
 843             _field7, _value7, _field8, _value8, _field9, _value9,       \
 844             _field10, _value10)                                         \
 845         do {                                                            \
 846                 _NOTE(CONSTANTCONDITION)                                \
 847                 (_xword).ex_u32[0] = EFX_INSERT_FIELDS32(0, 31,         \
 848                     _field1, _value1, _field2, _value2,                 \
 849                     _field3, _value3, _field4, _value4,                 \
 850                     _field5, _value5, _field6, _value6,                 \
 851                     _field7, _value7, _field8, _value8,                 \
 852                     _field9, _value9, _field10, _value10);              \
 853                 _NOTE(CONSTANTCONDITION)                                \
 854                 (_xword).ex_u32[1] = EFX_INSERT_FIELDS32(32, 63,        \
 855                     _field1, _value1, _field2, _value2,                 \
 856                     _field3, _value3, _field4, _value4,                 \
 857                     _field5, _value5, _field6, _value6,                 \
 858                     _field7, _value7, _field8, _value8,                 \
 859                     _field9, _value9, _field10, _value10);              \
 860                 _NOTE(CONSTANTCONDITION)                                \
 861                 (_xword).ex_u32[2] = EFX_INSERT_FIELDS32(64, 95,        \
 862                     _field1, _value1, _field2, _value2,                 \
 863                     _field3, _value3, _field4, _value4,                 \
 864                     _field5, _value5, _field6, _value6,                 \
 865                     _field7, _value7, _field8, _value8,                 \
 866                     _field9, _value9, _field10, _value10);              \
 867                 _NOTE(CONSTANTCONDITION)                                \
 868                 (_xword).ex_u32[3] = EFX_INSERT_FIELDS32(96, 127,       \
 869                     _field1, _value1, _field2, _value2,                 \
 870                     _field3, _value3, _field4, _value4,                 \
 871                     _field5, _value5, _field6, _value6,                 \
 872                     _field7, _value7, _field8, _value8,                 \
 873                     _field9, _value9, _field10, _value10);              \
 874                 _NOTE(CONSTANTCONDITION)                                \
 875                 (_xword).ex_u32[4] = EFX_INSERT_FIELDS32(128, 159,      \
 876                     _field1, _value1, _field2, _value2,                 \
 877                     _field3, _value3, _field4, _value4,                 \
 878                     _field5, _value5, _field6, _value6,                 \
 879                     _field7, _value7, _field8, _value8,                 \
 880                     _field9, _value9, _field10, _value10);              \
 881                 _NOTE(CONSTANTCONDITION)                                \
 882                 (_xword).ex_u32[5] = EFX_INSERT_FIELDS32(160, 191,      \
 883                     _field1, _value1, _field2, _value2,                 \
 884                     _field3, _value3, _field4, _value4,                 \
 885                     _field5, _value5, _field6, _value6,                 \
 886                     _field7, _value7, _field8, _value8,                 \
 887                     _field9, _value9, _field10, _value10);              \
 888                 _NOTE(CONSTANTCONDITION)                                \
 889                 (_xword).ex_u32[6] = EFX_INSERT_FIELDS32(192, 223,      \
 890                     _field1, _value1, _field2, _value2,                 \
 891                     _field3, _value3, _field4, _value4,                 \
 892                     _field5, _value5, _field6, _value6,                 \
 893                     _field7, _value7, _field8, _value8,                 \
 894                     _field9, _value9, _field10, _value10);              \
 895                 _NOTE(CONSTANTCONDITION)                                \
 896                 (_xword).ex_u32[7] = EFX_INSERT_FIELDS32(224, 255,      \
 897                     _field1, _value1, _field2, _value2,                 \
 898                     _field3, _value3, _field4, _value4,                 \
 899                     _field5, _value5, _field6, _value6,                 \
 900                     _field7, _value7, _field8, _value8,                 \
 901                     _field9, _value9, _field10, _value10);              \
 902         _NOTE(CONSTANTCONDITION)                                        \
 903         } while (B_FALSE)
 904
 905 #define EFX_POPULATE_OWORD64(_oword,                                    \
 906             _field1, _value1, _field2, _value2, _field3, _value3,       \
 907             _field4, _value4, _field5, _value5, _field6, _value6,       \
 908             _field7, _value7, _field8, _value8, _field9, _value9,       \
 909             _field10, _value10)                                         \
 910         do {                                                            \
 911                 _NOTE(CONSTANTCONDITION)                                \
 912                 (_oword).eo_u64[0] = EFX_INSERT_FIELDS64(0, 63,         \
 913                     _field1, _value1, _field2, _value2,                 \
 914                     _field3, _value3, _field4, _value4,                 \
 915                     _field5, _value5, _field6, _value6,                 \
 916                     _field7, _value7, _field8, _value8,                 \
 917                     _field9, _value9, _field10, _value10);              \
 918                 _NOTE(CONSTANTCONDITION)                                \
 919                 (_oword).eo_u64[1] = EFX_INSERT_FIELDS64(64, 127,       \
 920                     _field1, _value1, _field2, _value2,                 \
 921                     _field3, _value3, _field4, _value4,                 \
 922                     _field5, _value5, _field6, _value6,                 \
 923                     _field7, _value7, _field8, _value8,                 \
 924                     _field9, _value9, _field10, _value10);              \
 925         _NOTE(CONSTANTCONDITION)                                        \
 926         } while (B_FALSE)
 927
 928 #define EFX_POPULATE_OWORD32(_oword,                                    \
 929             _field1, _value1, _field2, _value2, _field3, _value3,       \
 930             _field4, _value4, _field5, _value5, _field6, _value6,       \
 931             _field7, _value7, _field8, _value8, _field9, _value9,       \
 932             _field10, _value10)                                         \
 933         do {                                                            \
 934                 _NOTE(CONSTANTCONDITION)                                \
 935                 (_oword).eo_u32[0] = EFX_INSERT_FIELDS32(0, 31,         \
 936                     _field1, _value1, _field2, _value2,                 \
 937                     _field3, _value3, _field4, _value4,                 \
 938                     _field5, _value5, _field6, _value6,                 \
 939                     _field7, _value7, _field8, _value8,                 \
 940                     _field9, _value9, _field10, _value10);              \
 941                 _NOTE(CONSTANTCONDITION)                                \
 942                 (_oword).eo_u32[1] = EFX_INSERT_FIELDS32(32, 63,        \
 943                     _field1, _value1, _field2, _value2,                 \
 944                     _field3, _value3, _field4, _value4,                 \
 945                     _field5, _value5, _field6, _value6,                 \
 946                     _field7, _value7, _field8, _value8,                 \
 947                     _field9, _value9, _field10, _value10);              \
 948                 _NOTE(CONSTANTCONDITION)                                \
 949                 (_oword).eo_u32[2] = EFX_INSERT_FIELDS32(64, 95,        \
 950                     _field1, _value1, _field2, _value2,                 \
 951                     _field3, _value3, _field4, _value4,                 \
 952                     _field5, _value5, _field6, _value6,                 \
 953                     _field7, _value7, _field8, _value8,                 \
 954                     _field9, _value9, _field10, _value10);              \
 955                 _NOTE(CONSTANTCONDITION)                                \
 956                 (_oword).eo_u32[3] = EFX_INSERT_FIELDS32(96, 127,       \
 957                     _field1, _value1, _field2, _value2,                 \
 958                     _field3, _value3, _field4, _value4,                 \
 959                     _field5, _value5, _field6, _value6,                 \
 960                     _field7, _value7, _field8, _value8,                 \
 961                     _field9, _value9, _field10, _value10);              \
 962         _NOTE(CONSTANTCONDITION)                                        \
 963         } while (B_FALSE)
 964
 965 #define EFX_POPULATE_QWORD64(_qword,                                    \
 966             _field1, _value1, _field2, _value2, _field3, _value3,       \
 967             _field4, _value4, _field5, _value5, _field6, _value6,       \
 968             _field7, _value7, _field8, _value8, _field9, _value9,       \
 969             _field10, _value10)                                         \
 970         do {                                                            \
 971                 _NOTE(CONSTANTCONDITION)                                \
 972                 (_qword).eq_u64[0] = EFX_INSERT_FIELDS64(0, 63,         \
 973                     _field1, _value1, _field2, _value2,                 \
 974                     _field3, _value3, _field4, _value4,                 \
 975                     _field5, _value5, _field6, _value6,                 \
 976                     _field7, _value7, _field8, _value8,                 \
 977                     _field9, _value9, _field10, _value10);              \
 978         _NOTE(CONSTANTCONDITION)                                        \
 979         } while (B_FALSE)
 980
 981 #define EFX_POPULATE_QWORD32(_qword,                                    \
 982             _field1, _value1, _field2, _value2, _field3, _value3,       \
 983             _field4, _value4, _field5, _value5, _field6, _value6,       \
 984             _field7, _value7, _field8, _value8, _field9, _value9,       \
 985             _field10, _value10)                                         \
 986         do {                                                            \
 987                 _NOTE(CONSTANTCONDITION)                                \
 988                 (_qword).eq_u32[0] = EFX_INSERT_FIELDS32(0, 31,         \
 989                     _field1, _value1, _field2, _value2,                 \
 990                     _field3, _value3, _field4, _value4,                 \
 991                     _field5, _value5, _field6, _value6,                 \
 992                     _field7, _value7, _field8, _value8,                 \
 993                     _field9, _value9, _field10, _value10);              \
 994                 _NOTE(CONSTANTCONDITION)                                \
 995                 (_qword).eq_u32[1] = EFX_INSERT_FIELDS32(32, 63,        \
 996                     _field1, _value1, _field2, _value2,                 \
 997                     _field3, _value3, _field4, _value4,                 \
 998                     _field5, _value5, _field6, _value6,                 \
 999                     _field7, _value7, _field8, _value8,                 \
1000                     _field9, _value9, _field10, _value10);              \
1001         _NOTE(CONSTANTCONDITION)                                        \
1002         } while (B_FALSE)
1003
1004 #define EFX_POPULATE_DWORD(_dword,                                      \
1005             _field1, _value1, _field2, _value2, _field3, _value3,       \
1006             _field4, _value4, _field5, _value5, _field6, _value6,       \
1007             _field7, _value7, _field8, _value8, _field9, _value9,       \
1008             _field10, _value10)                                         \
1009         do {                                                            \
1010                 _NOTE(CONSTANTCONDITION)                                \
1011                 (_dword).ed_u32[0] = EFX_INSERT_FIELDS32(0, 31,         \
1012                     _field1, _value1, _field2, _value2,                 \
1013                     _field3, _value3, _field4, _value4,                 \
1014                     _field5, _value5, _field6, _value6,                 \
1015                     _field7, _value7, _field8, _value8,                 \
1016                     _field9, _value9, _field10, _value10);              \
1017         _NOTE(CONSTANTCONDITION)                                        \
1018         } while (B_FALSE)
1019
1020 #define EFX_POPULATE_WORD(_word,                                        \
1021             _field1, _value1, _field2, _value2, _field3, _value3,       \
1022             _field4, _value4, _field5, _value5, _field6, _value6,       \
1023             _field7, _value7, _field8, _value8, _field9, _value9,       \
1024             _field10, _value10)                                         \
1025         do {                                                            \
1026                 _NOTE(CONSTANTCONDITION)                                \
1027                 (_word).ew_u16[0] = EFX_INSERT_FIELDS16(0, 15,          \
1028                     _field1, _value1, _field2, _value2,                 \
1029                     _field3, _value3, _field4, _value4,                 \
1030                     _field5, _value5, _field6, _value6,                 \
1031                     _field7, _value7, _field8, _value8,                 \
1032                     _field9, _value9, _field10, _value10);              \
1033         _NOTE(CONSTANTCONDITION)                                        \
1034         } while (B_FALSE)
1035
1036 #define EFX_POPULATE_BYTE(_byte,                                        \
1037             _field1, _value1, _field2, _value2, _field3, _value3,       \
1038             _field4, _value4, _field5, _value5, _field6, _value6,       \
1039             _field7, _value7, _field8, _value8, _field9, _value9,       \
1040             _field10, _value10)                                         \
1041         do {                                                            \
1042                 _NOTE(CONSTANTCONDITION)                                \
1043                 (_byte).eb_u8[0] = EFX_INSERT_FIELDS8(0, 7,             \
1044                     _field1, _value1, _field2, _value2,                 \
1045                     _field3, _value3, _field4, _value4,                 \
1046                     _field5, _value5, _field6, _value6,                 \
1047                     _field7, _value7, _field8, _value8,                 \
1048                     _field9, _value9, _field10, _value10);              \
1049         _NOTE(CONSTANTCONDITION)                                        \
1050         } while (B_FALSE)
1051
1052 /* Populate a hexaword field with various numbers of arguments */
1053 #define EFX_POPULATE_XWORD_10 EFX_POPULATE_XWORD
1054
1055 #define EFX_POPULATE_XWORD_9(_xword,                                    \
1056             _field1, _value1, _field2, _value2, _field3, _value3,       \
1057             _field4, _value4, _field5, _value5, _field6, _value6,       \
1058             _field7, _value7, _field8, _value8, _field9, _value9)       \
1059         EFX_POPULATE_XWORD_10(_xword, EFX_DUMMY_FIELD, 0,               \
1060             _field1, _value1, _field2, _value2, _field3, _value3,       \
1061             _field4, _value4, _field5, _value5, _field6, _value6,       \
1062             _field7, _value7, _field8, _value8, _field9, _value9)
1063
1064 #define EFX_POPULATE_XWORD_8(_xword,                                    \
1065             _field1, _value1, _field2, _value2, _field3, _value3,       \
1066             _field4, _value4, _field5, _value5, _field6, _value6,       \
1067             _field7, _value7, _field8, _value8)                         \
1068         EFX_POPULATE_XWORD_9(_xword, EFX_DUMMY_FIELD, 0,                \
1069             _field1, _value1, _field2, _value2, _field3, _value3,       \
1070             _field4, _value4, _field5, _value5, _field6, _value6,       \
1071             _field7, _value7, _field8, _value8)
1072
1073 #define EFX_POPULATE_XWORD_7(_xword,                                    \
1074             _field1, _value1, _field2, _value2, _field3, _value3,       \
1075             _field4, _value4, _field5, _value5, _field6, _value6,       \
1076             _field7, _value7)                                           \
1077         EFX_POPULATE_XWORD_8(_xword, EFX_DUMMY_FIELD, 0,                \
1078             _field1, _value1, _field2, _value2, _field3, _value3,       \
1079             _field4, _value4, _field5, _value5, _field6, _value6,       \
1080             _field7, _value7)
1081
1082 #define EFX_POPULATE_XWORD_6(_xword,                                    \
1083             _field1, _value1, _field2, _value2, _field3, _value3,       \
1084             _field4, _value4, _field5, _value5, _field6, _value6)       \
1085         EFX_POPULATE_XWORD_7(_xword, EFX_DUMMY_FIELD, 0,                \
1086             _field1, _value1, _field2, _value2, _field3, _value3,       \
1087             _field4, _value4, _field5, _value5, _field6, _value6)
1088
1089 #define EFX_POPULATE_XWORD_5(_xword,                                    \
1090             _field1, _value1, _field2, _value2, _field3, _value3,       \
1091             _field4, _value4, _field5, _value5)                         \
1092         EFX_POPULATE_XWORD_6(_xword, EFX_DUMMY_FIELD, 0,                \
1093             _field1, _value1, _field2, _value2, _field3, _value3,       \
1094             _field4, _value4, _field5, _value5)
1095
1096 #define EFX_POPULATE_XWORD_4(_xword,                                    \
1097             _field1, _value1, _field2, _value2, _field3, _value3,       \
1098             _field4, _value4)                                           \
1099         EFX_POPULATE_XWORD_5(_xword, EFX_DUMMY_FIELD, 0,                \
1100             _field1, _value1, _field2, _value2, _field3, _value3,       \
1101             _field4, _value4)
1102
1103 #define EFX_POPULATE_XWORD_3(_xword,                                    \
1104             _field1, _value1, _field2, _value2, _field3, _value3)       \
1105         EFX_POPULATE_XWORD_4(_xword, EFX_DUMMY_FIELD, 0,                \
1106             _field1, _value1, _field2, _value2, _field3, _value3)
1107
1108 #define EFX_POPULATE_XWORD_2(_xword,                                    \
1109             _field1, _value1, _field2, _value2)                         \
1110         EFX_POPULATE_XWORD_3(_xword, EFX_DUMMY_FIELD, 0,                \
1111             _field1, _value1, _field2, _value2)
1112
1113 #define EFX_POPULATE_XWORD_1(_xword,                                    \
1114             _field1, _value1)                                           \
1115         EFX_POPULATE_XWORD_2(_xword, EFX_DUMMY_FIELD, 0,                \
1116             _field1, _value1)
1117
1118 #define EFX_ZERO_XWORD(_xword)                                          \
1119         EFX_POPULATE_XWORD_1(_xword, EFX_DUMMY_FIELD, 0)
1120
1121 #define EFX_SET_XWORD(_xword)                                           \
1122         EFX_POPULATE_XWORD_8(_xword,                                    \
1123             EFX_DWORD_0, 0xffffffff, EFX_DWORD_1, 0xffffffff,           \
1124             EFX_DWORD_2, 0xffffffff, EFX_DWORD_3, 0xffffffff,           \
1125             EFX_DWORD_4, 0xffffffff, EFX_DWORD_5, 0xffffffff,           \
1126             EFX_DWORD_6, 0xffffffff, EFX_DWORD_7, 0xffffffff)
1127
1128 /* Populate an octword field with various numbers of arguments */
1129 #define EFX_POPULATE_OWORD_10 EFX_POPULATE_OWORD
1130
1131 #define EFX_POPULATE_OWORD_9(_oword,                                    \
1132             _field1, _value1, _field2, _value2, _field3, _value3,       \
1133             _field4, _value4, _field5, _value5, _field6, _value6,       \
1134             _field7, _value7, _field8, _value8, _field9, _value9)       \
1135         EFX_POPULATE_OWORD_10(_oword, EFX_DUMMY_FIELD, 0,               \
1136             _field1, _value1, _field2, _value2, _field3, _value3,       \
1137             _field4, _value4, _field5, _value5, _field6, _value6,       \
1138             _field7, _value7, _field8, _value8, _field9, _value9)
1139
1140 #define EFX_POPULATE_OWORD_8(_oword,                                    \
1141             _field1, _value1, _field2, _value2, _field3, _value3,       \
1142             _field4, _value4, _field5, _value5, _field6, _value6,       \
1143             _field7, _value7, _field8, _value8)                         \
1144         EFX_POPULATE_OWORD_9(_oword, EFX_DUMMY_FIELD, 0,                \
1145             _field1, _value1, _field2, _value2, _field3, _value3,       \
1146             _field4, _value4, _field5, _value5, _field6, _value6,       \
1147             _field7, _value7, _field8, _value8)
1148
1149 #define EFX_POPULATE_OWORD_7(_oword,                                    \
1150             _field1, _value1, _field2, _value2, _field3, _value3,       \
1151             _field4, _value4, _field5, _value5, _field6, _value6,       \
1152             _field7, _value7)                                           \
1153         EFX_POPULATE_OWORD_8(_oword, EFX_DUMMY_FIELD, 0,                \
1154             _field1, _value1, _field2, _value2, _field3, _value3,       \
1155             _field4, _value4, _field5, _value5, _field6, _value6,       \
1156             _field7, _value7)
1157
1158 #define EFX_POPULATE_OWORD_6(_oword,                                    \
1159             _field1, _value1, _field2, _value2, _field3, _value3,       \
1160             _field4, _value4, _field5, _value5, _field6, _value6)       \
1161         EFX_POPULATE_OWORD_7(_oword, EFX_DUMMY_FIELD, 0,                \
1162             _field1, _value1, _field2, _value2, _field3, _value3,       \
1163             _field4, _value4, _field5, _value5, _field6, _value6)
1164
1165 #define EFX_POPULATE_OWORD_5(_oword,                                    \
1166             _field1, _value1, _field2, _value2, _field3, _value3,       \
1167             _field4, _value4, _field5, _value5)                         \
1168         EFX_POPULATE_OWORD_6(_oword, EFX_DUMMY_FIELD, 0,                \
1169             _field1, _value1, _field2, _value2, _field3, _value3,       \
1170             _field4, _value4, _field5, _value5)
1171
1172 #define EFX_POPULATE_OWORD_4(_oword,                                    \
1173             _field1, _value1, _field2, _value2, _field3, _value3,       \
1174             _field4, _value4)                                           \
1175         EFX_POPULATE_OWORD_5(_oword, EFX_DUMMY_FIELD, 0,                \
1176             _field1, _value1, _field2, _value2, _field3, _value3,       \
1177             _field4, _value4)
1178
1179 #define EFX_POPULATE_OWORD_3(_oword,                                    \
1180             _field1, _value1, _field2, _value2, _field3, _value3)       \
1181         EFX_POPULATE_OWORD_4(_oword, EFX_DUMMY_FIELD, 0,                \
1182             _field1, _value1, _field2, _value2, _field3, _value3)
1183
1184 #define EFX_POPULATE_OWORD_2(_oword,                                    \
1185             _field1, _value1, _field2, _value2)                         \
1186         EFX_POPULATE_OWORD_3(_oword, EFX_DUMMY_FIELD, 0,                \
1187             _field1, _value1, _field2, _value2)
1188
1189 #define EFX_POPULATE_OWORD_1(_oword,                                    \
1190             _field1, _value1)                                           \
1191         EFX_POPULATE_OWORD_2(_oword, EFX_DUMMY_FIELD, 0,                \
1192             _field1, _value1)
1193
1194 #define EFX_ZERO_OWORD(_oword)                                          \
1195         EFX_POPULATE_OWORD_1(_oword, EFX_DUMMY_FIELD, 0)
1196
1197 #define EFX_SET_OWORD(_oword)                                           \
1198         EFX_POPULATE_OWORD_4(_oword,                                    \
1199             EFX_DWORD_0, 0xffffffff, EFX_DWORD_1, 0xffffffff,           \
1200             EFX_DWORD_2, 0xffffffff, EFX_DWORD_3, 0xffffffff)
1201
1202 /* Populate a quadword field with various numbers of arguments */
1203 #define EFX_POPULATE_QWORD_10 EFX_POPULATE_QWORD
1204
1205 #define EFX_POPULATE_QWORD_9(_qword,                                    \
1206             _field1, _value1, _field2, _value2, _field3, _value3,       \
1207             _field4, _value4, _field5, _value5, _field6, _value6,       \
1208             _field7, _value7, _field8, _value8, _field9, _value9)       \
1209         EFX_POPULATE_QWORD_10(_qword, EFX_DUMMY_FIELD, 0,               \
1210             _field1, _value1, _field2, _value2, _field3, _value3,       \
1211             _field4, _value4, _field5, _value5, _field6, _value6,       \
1212             _field7, _value7, _field8, _value8, _field9, _value9)
1213
1214 #define EFX_POPULATE_QWORD_8(_qword,                                    \
1215             _field1, _value1, _field2, _value2, _field3, _value3,       \
1216             _field4, _value4, _field5, _value5, _field6, _value6,       \
1217             _field7, _value7, _field8, _value8)                         \
1218         EFX_POPULATE_QWORD_9(_qword, EFX_DUMMY_FIELD, 0,                \
1219             _field1, _value1, _field2, _value2, _field3, _value3,       \
1220             _field4, _value4, _field5, _value5, _field6, _value6,       \
1221             _field7, _value7, _field8, _value8)
1222
1223 #define EFX_POPULATE_QWORD_7(_qword,                                    \
1224             _field1, _value1, _field2, _value2, _field3, _value3,       \
1225             _field4, _value4, _field5, _value5, _field6, _value6,       \
1226             _field7, _value7)                                           \
1227         EFX_POPULATE_QWORD_8(_qword, EFX_DUMMY_FIELD, 0,                \
1228             _field1, _value1, _field2, _value2, _field3, _value3,       \
1229             _field4, _value4, _field5, _value5, _field6, _value6,       \
1230             _field7, _value7)
1231
1232 #define EFX_POPULATE_QWORD_6(_qword,                                    \
1233             _field1, _value1, _field2, _value2, _field3, _value3,       \
1234             _field4, _value4, _field5, _value5, _field6, _value6)       \
1235         EFX_POPULATE_QWORD_7(_qword, EFX_DUMMY_FIELD, 0,                \
1236             _field1, _value1, _field2, _value2, _field3, _value3,       \
1237             _field4, _value4, _field5, _value5, _field6, _value6)
1238
1239 #define EFX_POPULATE_QWORD_5(_qword,                                    \
1240             _field1, _value1, _field2, _value2, _field3, _value3,       \
1241             _field4, _value4, _field5, _value5)                         \
1242         EFX_POPULATE_QWORD_6(_qword, EFX_DUMMY_FIELD, 0,                \
1243             _field1, _value1, _field2, _value2, _field3, _value3,       \
1244             _field4, _value4, _field5, _value5)
1245
1246 #define EFX_POPULATE_QWORD_4(_qword,                                    \
1247             _field1, _value1, _field2, _value2, _field3, _value3,       \
1248             _field4, _value4)                                           \
1249         EFX_POPULATE_QWORD_5(_qword, EFX_DUMMY_FIELD, 0,                \
1250             _field1, _value1, _field2, _value2, _field3, _value3,       \
1251             _field4, _value4)
1252
1253 #define EFX_POPULATE_QWORD_3(_qword,                                    \
1254             _field1, _value1, _field2, _value2, _field3, _value3)       \
1255         EFX_POPULATE_QWORD_4(_qword, EFX_DUMMY_FIELD, 0,                \
1256             _field1, _value1, _field2, _value2, _field3, _value3)
1257
1258 #define EFX_POPULATE_QWORD_2(_qword,                                    \
1259             _field1, _value1, _field2, _value2)                         \
1260         EFX_POPULATE_QWORD_3(_qword, EFX_DUMMY_FIELD, 0,                \
1261             _field1, _value1, _field2, _value2)
1262
1263 #define EFX_POPULATE_QWORD_1(_qword,                                    \
1264             _field1, _value1)                                           \
1265         EFX_POPULATE_QWORD_2(_qword, EFX_DUMMY_FIELD, 0,                \
1266             _field1, _value1)
1267
1268 #define EFX_ZERO_QWORD(_qword)                                          \
1269         EFX_POPULATE_QWORD_1(_qword, EFX_DUMMY_FIELD, 0)
1270
1271 #define EFX_SET_QWORD(_qword)                                           \
1272         EFX_POPULATE_QWORD_2(_qword,                                    \
1273             EFX_DWORD_0, 0xffffffff, EFX_DWORD_1, 0xffffffff)
1274
1275 /* Populate a dword field with various numbers of arguments */
1276 #define EFX_POPULATE_DWORD_10 EFX_POPULATE_DWORD
1277
1278 #define EFX_POPULATE_DWORD_9(_dword,                                    \
1279             _field1, _value1, _field2, _value2, _field3, _value3,       \
1280             _field4, _value4, _field5, _value5, _field6, _value6,       \
1281             _field7, _value7, _field8, _value8, _field9, _value9)       \
1282         EFX_POPULATE_DWORD_10(_dword, EFX_DUMMY_FIELD, 0,               \
1283             _field1, _value1, _field2, _value2, _field3, _value3,       \
1284             _field4, _value4, _field5, _value5, _field6, _value6,       \
1285             _field7, _value7, _field8, _value8, _field9, _value9)
1286
1287 #define EFX_POPULATE_DWORD_8(_dword,                                    \
1288             _field1, _value1, _field2, _value2, _field3, _value3,       \
1289             _field4, _value4, _field5, _value5, _field6, _value6,       \
1290             _field7, _value7, _field8, _value8)                         \
1291         EFX_POPULATE_DWORD_9(_dword, EFX_DUMMY_FIELD, 0,                \
1292             _field1, _value1, _field2, _value2, _field3, _value3,       \
1293             _field4, _value4, _field5, _value5, _field6, _value6,       \
1294             _field7, _value7, _field8, _value8)
1295
1296 #define EFX_POPULATE_DWORD_7(_dword,                                    \
1297             _field1, _value1, _field2, _value2, _field3, _value3,       \
1298             _field4, _value4, _field5, _value5, _field6, _value6,       \
1299             _field7, _value7)                                           \
1300         EFX_POPULATE_DWORD_8(_dword, EFX_DUMMY_FIELD, 0,                \
1301             _field1, _value1, _field2, _value2, _field3, _value3,       \
1302             _field4, _value4, _field5, _value5, _field6, _value6,       \
1303             _field7, _value7)
1304
1305 #define EFX_POPULATE_DWORD_6(_dword,                                    \
1306             _field1, _value1, _field2, _value2, _field3, _value3,       \
1307             _field4, _value4, _field5, _value5, _field6, _value6)       \
1308         EFX_POPULATE_DWORD_7(_dword, EFX_DUMMY_FIELD, 0,                \
1309             _field1, _value1, _field2, _value2, _field3, _value3,       \
1310             _field4, _value4, _field5, _value5, _field6, _value6)
1311
1312 #define EFX_POPULATE_DWORD_5(_dword,                                    \
1313             _field1, _value1, _field2, _value2, _field3, _value3,       \
1314             _field4, _value4, _field5, _value5)                         \
1315         EFX_POPULATE_DWORD_6(_dword, EFX_DUMMY_FIELD, 0,                \
1316             _field1, _value1, _field2, _value2, _field3, _value3,       \
1317             _field4, _value4, _field5, _value5)
1318
1319 #define EFX_POPULATE_DWORD_4(_dword,                                    \
1320             _field1, _value1, _field2, _value2, _field3, _value3,       \
1321             _field4, _value4)                                           \
1322         EFX_POPULATE_DWORD_5(_dword, EFX_DUMMY_FIELD, 0,                \
1323             _field1, _value1, _field2, _value2, _field3, _value3,       \
1324             _field4, _value4)
1325
1326 #define EFX_POPULATE_DWORD_3(_dword,                                    \
1327             _field1, _value1, _field2, _value2, _field3, _value3)       \
1328         EFX_POPULATE_DWORD_4(_dword, EFX_DUMMY_FIELD, 0,                \
1329             _field1, _value1, _field2, _value2, _field3, _value3)
1330
1331 #define EFX_POPULATE_DWORD_2(_dword,                                    \
1332             _field1, _value1, _field2, _value2)                         \
1333         EFX_POPULATE_DWORD_3(_dword, EFX_DUMMY_FIELD, 0,                \
1334             _field1, _value1, _field2, _value2)
1335
1336 #define EFX_POPULATE_DWORD_1(_dword,                                    \
1337             _field1, _value1)                                           \
1338         EFX_POPULATE_DWORD_2(_dword, EFX_DUMMY_FIELD, 0,                \
1339             _field1, _value1)
1340
1341 #define EFX_ZERO_DWORD(_dword)                                          \
1342         EFX_POPULATE_DWORD_1(_dword, EFX_DUMMY_FIELD, 0)
1343
1344 #define EFX_SET_DWORD(_dword)                                           \
1345         EFX_POPULATE_DWORD_1(_dword,                                    \
1346             EFX_DWORD_0, 0xffffffff)
1347
1348 /* Populate a word field with various numbers of arguments */
1349 #define EFX_POPULATE_WORD_10 EFX_POPULATE_WORD
1350
1351 #define EFX_POPULATE_WORD_9(_word,                                      \
1352             _field1, _value1, _field2, _value2, _field3, _value3,       \
1353             _field4, _value4, _field5, _value5, _field6, _value6,       \
1354             _field7, _value7, _field8, _value8, _field9, _value9)       \
1355         EFX_POPULATE_WORD_10(_word, EFX_DUMMY_FIELD, 0,                 \
1356             _field1, _value1, _field2, _value2, _field3, _value3,       \
1357             _field4, _value4, _field5, _value5, _field6, _value6,       \
1358             _field7, _value7, _field8, _value8, _field9, _value9)
1359
1360 #define EFX_POPULATE_WORD_8(_word,                                      \
1361             _field1, _value1, _field2, _value2, _field3, _value3,       \
1362             _field4, _value4, _field5, _value5, _field6, _value6,       \
1363             _field7, _value7, _field8, _value8)                         \
1364         EFX_POPULATE_WORD_9(_word, EFX_DUMMY_FIELD, 0,                  \
1365             _field1, _value1, _field2, _value2, _field3, _value3,       \
1366             _field4, _value4, _field5, _value5, _field6, _value6,       \
1367             _field7, _value7, _field8, _value8)
1368
1369 #define EFX_POPULATE_WORD_7(_word,                                      \
1370             _field1, _value1, _field2, _value2, _field3, _value3,       \
1371             _field4, _value4, _field5, _value5, _field6, _value6,       \
1372             _field7, _value7)                                           \
1373         EFX_POPULATE_WORD_8(_word, EFX_DUMMY_FIELD, 0,                  \
1374             _field1, _value1, _field2, _value2, _field3, _value3,       \
1375             _field4, _value4, _field5, _value5, _field6, _value6,       \
1376             _field7, _value7)
1377
1378 #define EFX_POPULATE_WORD_6(_word,                                      \
1379             _field1, _value1, _field2, _value2, _field3, _value3,       \
1380             _field4, _value4, _field5, _value5, _field6, _value6)       \
1381         EFX_POPULATE_WORD_7(_word, EFX_DUMMY_FIELD, 0,                  \
1382             _field1, _value1, _field2, _value2, _field3, _value3,       \
1383             _field4, _value4, _field5, _value5, _field6, _value6)
1384
1385 #define EFX_POPULATE_WORD_5(_word,                                      \
1386             _field1, _value1, _field2, _value2, _field3, _value3,       \
1387             _field4, _value4, _field5, _value5)                         \
1388         EFX_POPULATE_WORD_6(_word, EFX_DUMMY_FIELD, 0,                  \
1389             _field1, _value1, _field2, _value2, _field3, _value3,       \
1390             _field4, _value4, _field5, _value5)
1391
1392 #define EFX_POPULATE_WORD_4(_word,                                      \
1393             _field1, _value1, _field2, _value2, _field3, _value3,       \
1394             _field4, _value4)                                           \
1395         EFX_POPULATE_WORD_5(_word, EFX_DUMMY_FIELD, 0,                  \
1396             _field1, _value1, _field2, _value2, _field3, _value3,       \
1397             _field4, _value4)
1398
1399 #define EFX_POPULATE_WORD_3(_word,                                      \
1400             _field1, _value1, _field2, _value2, _field3, _value3)       \
1401         EFX_POPULATE_WORD_4(_word, EFX_DUMMY_FIELD, 0,                  \
1402             _field1, _value1, _field2, _value2, _field3, _value3)
1403
1404 #define EFX_POPULATE_WORD_2(_word,                                      \
1405             _field1, _value1, _field2, _value2)                         \
1406         EFX_POPULATE_WORD_3(_word, EFX_DUMMY_FIELD, 0,                  \
1407             _field1, _value1, _field2, _value2)
1408
1409 #define EFX_POPULATE_WORD_1(_word,                                      \
1410             _field1, _value1)                                           \
1411         EFX_POPULATE_WORD_2(_word, EFX_DUMMY_FIELD, 0,                  \
1412             _field1, _value1)
1413
1414 #define EFX_ZERO_WORD(_word)                                            \
1415         EFX_POPULATE_WORD_1(_word, EFX_DUMMY_FIELD, 0)
1416
1417 #define EFX_SET_WORD(_word)                                             \
1418         EFX_POPULATE_WORD_1(_word,                                      \
1419             EFX_WORD_0, 0xffff)
1420
1421 /* Populate a byte field with various numbers of arguments */
1422 #define EFX_POPULATE_BYTE_10 EFX_POPULATE_BYTE
1423
1424 #define EFX_POPULATE_BYTE_9(_byte,                                      \
1425             _field1, _value1, _field2, _value2, _field3, _value3,       \
1426             _field4, _value4, _field5, _value5, _field6, _value6,       \
1427             _field7, _value7, _field8, _value8, _field9, _value9)       \
1428         EFX_POPULATE_BYTE_10(_byte, EFX_DUMMY_FIELD, 0,                 \
1429             _field1, _value1, _field2, _value2, _field3, _value3,       \
1430             _field4, _value4, _field5, _value5, _field6, _value6,       \
1431             _field7, _value7, _field8, _value8, _field9, _value9)
1432
1433 #define EFX_POPULATE_BYTE_8(_byte,                                      \
1434             _field1, _value1, _field2, _value2, _field3, _value3,       \
1435             _field4, _value4, _field5, _value5, _field6, _value6,       \
1436             _field7, _value7, _field8, _value8)                         \
1437         EFX_POPULATE_BYTE_9(_byte, EFX_DUMMY_FIELD, 0,                  \
1438             _field1, _value1, _field2, _value2, _field3, _value3,       \
1439             _field4, _value4, _field5, _value5, _field6, _value6,       \
1440             _field7, _value7, _field8, _value8)
1441
1442 #define EFX_POPULATE_BYTE_7(_byte,                                      \
1443             _field1, _value1, _field2, _value2, _field3, _value3,       \
1444             _field4, _value4, _field5, _value5, _field6, _value6,       \
1445             _field7, _value7)                                           \
1446         EFX_POPULATE_BYTE_8(_byte, EFX_DUMMY_FIELD, 0,                  \
1447             _field1, _value1, _field2, _value2, _field3, _value3,       \
1448             _field4, _value4, _field5, _value5, _field6, _value6,       \
1449             _field7, _value7)
1450
1451 #define EFX_POPULATE_BYTE_6(_byte,                                      \
1452             _field1, _value1, _field2, _value2, _field3, _value3,       \
1453             _field4, _value4, _field5, _value5, _field6, _value6)       \
1454         EFX_POPULATE_BYTE_7(_byte, EFX_DUMMY_FIELD, 0,                  \
1455             _field1, _value1, _field2, _value2, _field3, _value3,       \
1456             _field4, _value4, _field5, _value5, _field6, _value6)
1457
1458 #define EFX_POPULATE_BYTE_5(_byte,                                      \
1459             _field1, _value1, _field2, _value2, _field3, _value3,       \
1460             _field4, _value4, _field5, _value5)                         \
1461         EFX_POPULATE_BYTE_6(_byte, EFX_DUMMY_FIELD, 0,                  \
1462             _field1, _value1, _field2, _value2, _field3, _value3,       \
1463             _field4, _value4, _field5, _value5)
1464
1465 #define EFX_POPULATE_BYTE_4(_byte,                                      \
1466             _field1, _value1, _field2, _value2, _field3, _value3,       \
1467             _field4, _value4)                                           \
1468         EFX_POPULATE_BYTE_5(_byte, EFX_DUMMY_FIELD, 0,                  \
1469             _field1, _value1, _field2, _value2, _field3, _value3,       \
1470             _field4, _value4)
1471
1472 #define EFX_POPULATE_BYTE_3(_byte,                                      \
1473             _field1, _value1, _field2, _value2, _field3, _value3)       \
1474         EFX_POPULATE_BYTE_4(_byte, EFX_DUMMY_FIELD, 0,                  \
1475             _field1, _value1, _field2, _value2, _field3, _value3)
1476
1477 #define EFX_POPULATE_BYTE_2(_byte,                                      \
1478             _field1, _value1, _field2, _value2)                         \
1479         EFX_POPULATE_BYTE_3(_byte, EFX_DUMMY_FIELD, 0,                  \
1480             _field1, _value1, _field2, _value2)
1481
1482 #define EFX_POPULATE_BYTE_1(_byte,                                      \
1483             _field1, _value1)                                           \
1484         EFX_POPULATE_BYTE_2(_byte, EFX_DUMMY_FIELD, 0,                  \
1485             _field1, _value1)
1486
1487 #define EFX_ZERO_BYTE(_byte)                                            \
1488         EFX_POPULATE_BYTE_1(_byte, EFX_DUMMY_FIELD, 0)
1489
1490 #define EFX_SET_BYTE(_byte)                                             \
1491         EFX_POPULATE_BYTE_1(_byte,                                      \
1492             EFX_BYTE_0, 0xff)
1493
1494 /*
1495  * Modify a named field within an already-populated structure.  Used
1496  * for read-modify-write operations.
1497  */
1498
1499 #define EFX_INSERT_FIELD64(_min, _max, _field, _value)                  \
1500         __CPU_TO_LE_64(EFX_INSERT_FIELD_NATIVE64(_min, _max, _field, _value))
1501
1502 #define EFX_INSERT_FIELD32(_min, _max, _field, _value)                  \
1503         __CPU_TO_LE_32(EFX_INSERT_FIELD_NATIVE32(_min, _max, _field, _value))
1504
1505 #define EFX_INSERT_FIELD16(_min, _max, _field, _value)                  \
1506         __CPU_TO_LE_16(EFX_INSERT_FIELD_NATIVE16(_min, _max, _field, _value))
1507
1508 #define EFX_INSERT_FIELD8(_min, _max, _field, _value)                   \
1509         __NATIVE_8(EFX_INSERT_FIELD_NATIVE8(_min, _max, _field, _value))
1510
1511 #define EFX_INPLACE_MASK64(_min, _max, _field)                          \
1512         EFX_INSERT_FIELD64(_min, _max, _field, EFX_MASK64(_field))
1513
1514 #define EFX_INPLACE_MASK32(_min, _max, _field)                          \
1515         EFX_INSERT_FIELD32(_min, _max, _field, EFX_MASK32(_field))
1516
1517 #define EFX_INPLACE_MASK16(_min, _max, _field)                          \
1518         EFX_INSERT_FIELD16(_min, _max, _field, EFX_MASK16(_field))
1519
1520 #define EFX_INPLACE_MASK8(_min, _max, _field)                           \
1521         EFX_INSERT_FIELD8(_min, _max, _field, EFX_MASK8(_field))
1522
1523 #define EFX_SET_XWORD_FIELD64(_xword, _field, _value)                   \
1524         do {                                                            \
1525                 _NOTE(CONSTANTCONDITION)                                \
1526                 (_xword).ex_u64[0] = (((_xword).ex_u64[0] &             \
1527                     ~EFX_INPLACE_MASK64(0, 63, _field)) |               \
1528                     EFX_INSERT_FIELD64(0, 63, _field, _value));         \
1529                 _NOTE(CONSTANTCONDITION)                                \
1530                 (_xword).ex_u64[1] = (((_xword).ex_u64[1] &             \
1531                     ~EFX_INPLACE_MASK64(64, 127, _field)) |             \
1532                     EFX_INSERT_FIELD64(64, 127, _field, _value));       \
1533                 _NOTE(CONSTANTCONDITION)                                \
1534                 (_xword).ex_u64[2] = (((_xword).ex_u64[2] &             \
1535                     ~EFX_INPLACE_MASK64(128, 191, _field)) |            \
1536                     EFX_INSERT_FIELD64(128, 191, _field, _value));      \
1537                 _NOTE(CONSTANTCONDITION)                                \
1538                 (_xword).ex_u64[3] = (((_xword).ex_u64[3] &             \
1539                     ~EFX_INPLACE_MASK64(192, 255, _field)) |            \
1540                     EFX_INSERT_FIELD64(192, 255, _field, _value));      \
1541         _NOTE(CONSTANTCONDITION)                                        \
1542         } while (B_FALSE)
1543
1544 #define EFX_SET_XWORD_FIELD32(_xword, _field, _value)                   \
1545         do {                                                            \
1546                 _NOTE(CONSTANTCONDITION)                                \
1547                 (_xword).ex_u32[0] = (((_xword).ex_u32[0] &             \
1548                     ~EFX_INPLACE_MASK32(0, 31, _field)) |               \
1549                     EFX_INSERT_FIELD32(0, 31, _field, _value));         \
1550                 _NOTE(CONSTANTCONDITION)                                \
1551                 (_xword).ex_u32[1] = (((_xword).ex_u32[1] &             \
1552                     ~EFX_INPLACE_MASK32(32, 63, _field)) |              \
1553                     EFX_INSERT_FIELD32(32, 63, _field, _value));        \
1554                 _NOTE(CONSTANTCONDITION)                                \
1555                 (_xword).ex_u32[2] = (((_xword).ex_u32[2] &             \
1556                     ~EFX_INPLACE_MASK32(64, 95, _field)) |              \
1557                     EFX_INSERT_FIELD32(64, 95, _field, _value));        \
1558                 _NOTE(CONSTANTCONDITION)                                \
1559                 (_xword).ex_u32[3] = (((_xword).ex_u32[3] &             \
1560                     ~EFX_INPLACE_MASK32(96, 127, _field)) |             \
1561                     EFX_INSERT_FIELD32(96, 127, _field, _value));       \
1562                 _NOTE(CONSTANTCONDITION)                                \
1563                 (_xword).ex_u32[4] = (((_xword).ex_u32[4] &             \
1564                     ~EFX_INPLACE_MASK32(128, 159, _field)) |            \
1565                     EFX_INSERT_FIELD32(128, 159, _field, _value));      \
1566                 _NOTE(CONSTANTCONDITION)                                \
1567                 (_xword).ex_u32[5] = (((_xword).ex_u32[5] &             \
1568                     ~EFX_INPLACE_MASK32(160, 191, _field)) |            \
1569                     EFX_INSERT_FIELD32(160, 191, _field, _value));      \
1570                 _NOTE(CONSTANTCONDITION)                                \
1571                 (_xword).ex_u32[6] = (((_xword).ex_u32[6] &             \
1572                     ~EFX_INPLACE_MASK32(192, 223, _field)) |            \
1573                     EFX_INSERT_FIELD32(192, 223, _field, _value));      \
1574                 _NOTE(CONSTANTCONDITION)                                \
1575                 (_xword).ex_u32[7] = (((_xword).ex_u32[7] &             \
1576                     ~EFX_INPLACE_MASK32(224, 255, _field)) |            \
1577                     EFX_INSERT_FIELD32(224, 255, _field, _value));      \
1578         _NOTE(CONSTANTCONDITION)                                        \
1579         } while (B_FALSE)
1580
1581 #define EFX_SET_OWORD_FIELD64(_oword, _field, _value)                   \
1582         do {                                                            \
1583                 _NOTE(CONSTANTCONDITION)                                \
1584                 (_oword).eo_u64[0] = (((_oword).eo_u64[0] &             \
1585                     ~EFX_INPLACE_MASK64(0, 63, _field)) |               \
1586                     EFX_INSERT_FIELD64(0, 63, _field, _value));         \
1587                 _NOTE(CONSTANTCONDITION)                                \
1588                 (_oword).eo_u64[1] = (((_oword).eo_u64[1] &             \
1589                     ~EFX_INPLACE_MASK64(64, 127, _field)) |             \
1590                     EFX_INSERT_FIELD64(64, 127, _field, _value));       \
1591         _NOTE(CONSTANTCONDITION)                                        \
1592         } while (B_FALSE)
1593
1594 #define EFX_SET_OWORD_FIELD32(_oword, _field, _value)                   \
1595         do {                                                            \
1596                 _NOTE(CONSTANTCONDITION)                                \
1597                 (_oword).eo_u32[0] = (((_oword).eo_u32[0] &             \
1598                     ~EFX_INPLACE_MASK32(0, 31, _field)) |               \
1599                     EFX_INSERT_FIELD32(0, 31, _field, _value));         \
1600                 _NOTE(CONSTANTCONDITION)                                \
1601                 (_oword).eo_u32[1] = (((_oword).eo_u32[1] &             \
1602                     ~EFX_INPLACE_MASK32(32, 63, _field)) |              \
1603                     EFX_INSERT_FIELD32(32, 63, _field, _value));        \
1604                 _NOTE(CONSTANTCONDITION)                                \
1605                 (_oword).eo_u32[2] = (((_oword).eo_u32[2] &             \
1606                     ~EFX_INPLACE_MASK32(64, 95, _field)) |              \
1607                     EFX_INSERT_FIELD32(64, 95, _field, _value));        \
1608                 _NOTE(CONSTANTCONDITION)                                \
1609                 (_oword).eo_u32[3] = (((_oword).eo_u32[3] &             \
1610                     ~EFX_INPLACE_MASK32(96, 127, _field)) |             \
1611                     EFX_INSERT_FIELD32(96, 127, _field, _value));       \
1612         _NOTE(CONSTANTCONDITION)                                        \
1613         } while (B_FALSE)
1614
1615 #define EFX_SET_QWORD_FIELD64(_qword, _field, _value)                   \
1616         do {                                                            \
1617                 _NOTE(CONSTANTCONDITION)                                \
1618                 (_qword).eq_u64[0] = (((_qword).eq_u64[0] &             \
1619                     ~EFX_INPLACE_MASK64(0, 63, _field)) |               \
1620                     EFX_INSERT_FIELD64(0, 63, _field, _value));         \
1621         _NOTE(CONSTANTCONDITION)                                        \
1622         } while (B_FALSE)
1623
1624 #define EFX_SET_QWORD_FIELD32(_qword, _field, _value)                   \
1625         do {                                                            \
1626                 _NOTE(CONSTANTCONDITION)                                \
1627                 (_qword).eq_u32[0] = (((_qword).eq_u32[0] &             \
1628                     ~EFX_INPLACE_MASK32(0, 31, _field)) |               \
1629                     EFX_INSERT_FIELD32(0, 31, _field, _value));         \
1630                 _NOTE(CONSTANTCONDITION)                                \
1631                 (_qword).eq_u32[1] = (((_qword).eq_u32[1] &             \
1632                     ~EFX_INPLACE_MASK32(32, 63, _field)) |              \
1633                     EFX_INSERT_FIELD32(32, 63, _field, _value));        \
1634         _NOTE(CONSTANTCONDITION)                                        \
1635         } while (B_FALSE)
1636
1637 #define EFX_SET_DWORD_FIELD(_dword, _field, _value)                     \
1638         do {                                                            \
1639                 _NOTE(CONSTANTCONDITION)                                \
1640                 (_dword).ed_u32[0] = (((_dword).ed_u32[0] &             \
1641                     ~EFX_INPLACE_MASK32(0, 31, _field)) |               \
1642                     EFX_INSERT_FIELD32(0, 31, _field, _value));         \
1643         _NOTE(CONSTANTCONDITION)                                        \
1644         } while (B_FALSE)
1645
1646 #define EFX_SET_WORD_FIELD(_word, _field, _value)                       \
1647         do {                                                            \
1648                 _NOTE(CONSTANTCONDITION)                                \
1649                 (_word).ew_u16[0] = (((_word).ew_u16[0] &               \
1650                     ~EFX_INPLACE_MASK16(0, 15, _field)) |               \
1651                     EFX_INSERT_FIELD16(0, 15, _field, _value));         \
1652         _NOTE(CONSTANTCONDITION)                                        \
1653         } while (B_FALSE)
1654
1655 #define EFX_SET_BYTE_FIELD(_byte, _field, _value)                       \
1656         do {                                                            \
1657                 _NOTE(CONSTANTCONDITION)                                \
1658                 (_byte).eb_u8[0] = (((_byte).eb_u8[0] &                 \
1659                     ~EFX_INPLACE_MASK8(0, 7, _field)) |                 \
1660                     EFX_INSERT_FIELD8(0, 7, _field, _value));           \
1661         _NOTE(CONSTANTCONDITION)                                        \
1662         } while (B_FALSE)
1663
1664 /*
1665  * Set or clear a numbered bit within an octword.
1666  */
1667
1668 #define EFX_SHIFT64(_bit, _base)                                        \
1669         (((_bit) >= (_base) && (_bit) < (_base) + 64) ?                 \
1670                 ((uint64_t)1 << EFX_SSUB((_bit), (_base))) :            \
1671                 0U)
1672
1673 #define EFX_SHIFT32(_bit, _base)                                        \
1674         (((_bit) >= (_base) && (_bit) < (_base) + 32) ?                 \
1675                 ((uint32_t)1 << EFX_SSUB((_bit),(_base))) :             \
1676                 0U)
1677
1678 #define EFX_SHIFT16(_bit, _base)                                        \
1679         (((_bit) >= (_base) && (_bit) < (_base) + 16) ?                 \
1680                 (uint16_t)(1 << EFX_SSUB((_bit), (_base))) :            \
1681                 0U)
1682
1683 #define EFX_SHIFT8(_bit, _base)                                         \
1684         (((_bit) >= (_base) && (_bit) < (_base) + 8) ?                  \
1685                 (uint8_t)(1 << EFX_SSUB((_bit), (_base))) :             \
1686                 0U)
1687
1688 #define EFX_SET_XWORD_BIT64(_xword, _bit)                               \
1689         do {                                                            \
1690                 _NOTE(CONSTANTCONDITION)                                \
1691                 (_xword).ex_u64[0] |=                                   \
1692                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)));     \
1693                 (_xword).ex_u64[1] |=                                   \
1694                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64)));    \
1695                 (_xword).ex_u64[2] |=                                   \
1696                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(128)));   \
1697                 (_xword).ex_u64[3] |=                                   \
1698                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(192)));   \
1699         _NOTE(CONSTANTCONDITION)                                        \
1700         } while (B_FALSE)
1701
1702 #define EFX_SET_XWORD_BIT32(_xword, _bit)                               \
1703         do {                                                            \
1704                 _NOTE(CONSTANTCONDITION)                                \
1705                 (_xword).ex_u32[0] |=                                   \
1706                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)));     \
1707                 (_xword).ex_u32[1] |=                                   \
1708                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)));    \
1709                 (_xword).ex_u32[2] |=                                   \
1710                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64)));    \
1711                 (_xword).ex_u32[3] |=                                   \
1712                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96)));    \
1713                 (_xword).ex_u32[4] |=                                   \
1714                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(128)));   \
1715                 (_xword).ex_u32[5] |=                                   \
1716                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(160)));   \
1717                 (_xword).ex_u32[6] |=                                   \
1718                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(192)));   \
1719                 (_xword).ex_u32[7] |=                                   \
1720                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(224)));   \
1721         _NOTE(CONSTANTCONDITION)                                        \
1722         } while (B_FALSE)
1723
1724 #define EFX_CLEAR_XWORD_BIT64(_xword, _bit)                             \
1725         do {                                                            \
1726                 _NOTE(CONSTANTCONDITION)                                \
1727                 (_xword).ex_u64[0] &=                                   \
1728                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(0)));    \
1729                 (_xword).ex_u64[1] &=                                   \
1730                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(64)));   \
1731                 (_xword).ex_u64[2] &=                                   \
1732                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(128)));  \
1733                 (_xword).ex_u64[3] &=                                   \
1734                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(192)));  \
1735         _NOTE(CONSTANTCONDITION)                                        \
1736         } while (B_FALSE)
1737
1738 #define EFX_CLEAR_XWORD_BIT32(_xword, _bit)                             \
1739         do {                                                            \
1740                 _NOTE(CONSTANTCONDITION)                                \
1741                 (_xword).ex_u32[0] &=                                   \
1742                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(0)));    \
1743                 (_xword).ex_u32[1] &=                                   \
1744                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(32)));   \
1745                 (_xword).ex_u32[2] &=                                   \
1746                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(64)));   \
1747                 (_xword).ex_u32[3] &=                                   \
1748                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(96)));   \
1749                 (_xword).ex_u32[4] &=                                   \
1750                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(128)));  \
1751                 (_xword).ex_u32[5] &=                                   \
1752                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(160)));  \
1753                 (_xword).ex_u32[6] &=                                   \
1754                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(192)));  \
1755                 (_xword).ex_u32[7] &=                                   \
1756                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(224)));  \
1757         _NOTE(CONSTANTCONDITION)                                        \
1758         } while (B_FALSE)
1759
1760 #define EFX_TEST_XWORD_BIT64(_xword, _bit)                              \
1761         (((_xword).ex_u64[0] &                                          \
1762                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)))) ||  \
1763         ((_xword).ex_u64[1] &                                           \
1764                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64)))) || \
1765         ((_xword).ex_u64[2] &                                           \
1766                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(128)))) ||\
1767         ((_xword).ex_u64[3] &                                           \
1768                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(192)))))
1769
1770 #define EFX_TEST_XWORD_BIT32(_xword, _bit)                              \
1771         (((_xword).ex_u32[0] &                                          \
1772                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)))) ||  \
1773         ((_xword).ex_u32[1] &                                           \
1774                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)))) || \
1775         ((_xword).ex_u32[2] &                                           \
1776                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64)))) || \
1777         ((_xword).ex_u32[3] &                                           \
1778                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96)))) || \
1779         ((_xword).ex_u32[4] &                                           \
1780                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(128)))) ||\
1781         ((_xword).ex_u32[5] &                                           \
1782                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(160)))) ||\
1783         ((_xword).ex_u32[6] &                                           \
1784                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(192)))) ||\
1785         ((_xword).ex_u32[7] &                                           \
1786                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(224)))))
1787
1788
1789 #define EFX_SET_OWORD_BIT64(_oword, _bit)                               \
1790         do {                                                            \
1791                 _NOTE(CONSTANTCONDITION)                                \
1792                 (_oword).eo_u64[0] |=                                   \
1793                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)));     \
1794                 (_oword).eo_u64[1] |=                                   \
1795                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64)));    \
1796         _NOTE(CONSTANTCONDITION)                                        \
1797         } while (B_FALSE)
1798
1799 #define EFX_SET_OWORD_BIT32(_oword, _bit)                               \
1800         do {                                                            \
1801                 _NOTE(CONSTANTCONDITION)                                \
1802                 (_oword).eo_u32[0] |=                                   \
1803                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)));     \
1804                 (_oword).eo_u32[1] |=                                   \
1805                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)));    \
1806                 (_oword).eo_u32[2] |=                                   \
1807                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64)));    \
1808                 (_oword).eo_u32[3] |=                                   \
1809                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96)));    \
1810         _NOTE(CONSTANTCONDITION)                                        \
1811         } while (B_FALSE)
1812
1813 #define EFX_CLEAR_OWORD_BIT64(_oword, _bit)                             \
1814         do {                                                            \
1815                 _NOTE(CONSTANTCONDITION)                                \
1816                 (_oword).eo_u64[0] &=                                   \
1817                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(0)));    \
1818                 (_oword).eo_u64[1] &=                                   \
1819                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(64)));   \
1820         _NOTE(CONSTANTCONDITION)                                        \
1821         } while (B_FALSE)
1822
1823 #define EFX_CLEAR_OWORD_BIT32(_oword, _bit)                             \
1824         do {                                                            \
1825                 _NOTE(CONSTANTCONDITION)                                \
1826                 (_oword).eo_u32[0] &=                                   \
1827                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(0)));    \
1828                 (_oword).eo_u32[1] &=                                   \
1829                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(32)));   \
1830                 (_oword).eo_u32[2] &=                                   \
1831                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(64)));   \
1832                 (_oword).eo_u32[3] &=                                   \
1833                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(96)));   \
1834         _NOTE(CONSTANTCONDITION)                                        \
1835         } while (B_FALSE)
1836
1837 #define EFX_TEST_OWORD_BIT64(_oword, _bit)                              \
1838         (((_oword).eo_u64[0] &                                          \
1839                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)))) ||  \
1840         ((_oword).eo_u64[1] &                                           \
1841                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64)))))
1842
1843 #define EFX_TEST_OWORD_BIT32(_oword, _bit)                              \
1844         (((_oword).eo_u32[0] &                                          \
1845                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)))) ||  \
1846         ((_oword).eo_u32[1] &                                           \
1847                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)))) || \
1848         ((_oword).eo_u32[2] &                                           \
1849                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64)))) || \
1850         ((_oword).eo_u32[3] &                                           \
1851                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96)))))
1852
1853
1854 #define EFX_SET_QWORD_BIT64(_qword, _bit)                               \
1855         do {                                                            \
1856                 _NOTE(CONSTANTCONDITION)                                \
1857                 (_qword).eq_u64[0] |=                                   \
1858                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)));     \
1859         _NOTE(CONSTANTCONDITION)                                        \
1860         } while (B_FALSE)
1861
1862 #define EFX_SET_QWORD_BIT32(_qword, _bit)                               \
1863         do {                                                            \
1864                 _NOTE(CONSTANTCONDITION)                                \
1865                 (_qword).eq_u32[0] |=                                   \
1866                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)));     \
1867                 (_qword).eq_u32[1] |=                                   \
1868                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)));    \
1869         _NOTE(CONSTANTCONDITION)                                        \
1870         } while (B_FALSE)
1871
1872 #define EFX_CLEAR_QWORD_BIT64(_qword, _bit)                             \
1873         do {                                                            \
1874                 _NOTE(CONSTANTCONDITION)                                \
1875                 (_qword).eq_u64[0] &=                                   \
1876                     __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(0)));    \
1877         _NOTE(CONSTANTCONDITION)                                        \
1878         } while (B_FALSE)
1879
1880 #define EFX_CLEAR_QWORD_BIT32(_qword, _bit)                             \
1881         do {                                                            \
1882                 _NOTE(CONSTANTCONDITION)                                \
1883                 (_qword).eq_u32[0] &=                                   \
1884                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(0)));    \
1885                 (_qword).eq_u32[1] &=                                   \
1886                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(32)));   \
1887         _NOTE(CONSTANTCONDITION)                                        \
1888         } while (B_FALSE)
1889
1890 #define EFX_TEST_QWORD_BIT64(_qword, _bit)                              \
1891         (((_qword).eq_u64[0] &                                          \
1892                     __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(0)))) != 0)
1893
1894 #define EFX_TEST_QWORD_BIT32(_qword, _bit)                              \
1895         (((_qword).eq_u32[0] &                                          \
1896                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)))) ||  \
1897         ((_qword).eq_u32[1] &                                           \
1898                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)))))
1899
1900
1901 #define EFX_SET_DWORD_BIT(_dword, _bit)                                 \
1902         do {                                                            \
1903                 (_dword).ed_u32[0] |=                                   \
1904                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)));     \
1905         _NOTE(CONSTANTCONDITION)                                        \
1906         } while (B_FALSE)
1907
1908 #define EFX_CLEAR_DWORD_BIT(_dword, _bit)                               \
1909         do {                                                            \
1910                 (_dword).ed_u32[0] &=                                   \
1911                     __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(0)));    \
1912         _NOTE(CONSTANTCONDITION)                                        \
1913         } while (B_FALSE)
1914
1915 #define EFX_TEST_DWORD_BIT(_dword, _bit)                                \
1916         (((_dword).ed_u32[0] &                                          \
1917                     __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(0)))) != 0)
1918
1919
1920 #define EFX_SET_WORD_BIT(_word, _bit)                                   \
1921         do {                                                            \
1922                 (_word).ew_u16[0] |=                                    \
1923                     __CPU_TO_LE_16(EFX_SHIFT16(_bit, FIX_LINT(0)));     \
1924         _NOTE(CONSTANTCONDITION)                                        \
1925         } while (B_FALSE)
1926
1927 #define EFX_CLEAR_WORD_BIT(_word, _bit)                                 \
1928         do {                                                            \
1929                 (_word).ew_u32[0] &=                                    \
1930                     __CPU_TO_LE_16(~EFX_SHIFT16(_bit, FIX_LINT(0)));    \
1931         _NOTE(CONSTANTCONDITION)                                        \
1932         } while (B_FALSE)
1933
1934 #define EFX_TEST_WORD_BIT(_word, _bit)                                  \
1935         (((_word).ew_u16[0] &                                           \
1936                     __CPU_TO_LE_16(EFX_SHIFT16(_bit, FIX_LINT(0)))) != 0)
1937
1938
1939 #define EFX_SET_BYTE_BIT(_byte, _bit)                                   \
1940         do {                                                            \
1941                 (_byte).eb_u8[0] |=                                     \
1942                     __NATIVE_8(EFX_SHIFT8(_bit, FIX_LINT(0)));          \
1943         _NOTE(CONSTANTCONDITION)                                        \
1944         } while (B_FALSE)
1945
1946 #define EFX_CLEAR_BYTE_BIT(_byte, _bit)                                 \
1947         do {                                                            \
1948                 (_byte).eb_u8[0] &=                                     \
1949                     __NATIVE_8(~EFX_SHIFT8(_bit, FIX_LINT(0)));         \
1950         _NOTE(CONSTANTCONDITION)                                        \
1951         } while (B_FALSE)
1952
1953 #define EFX_TEST_BYTE_BIT(_byte, _bit)                                  \
1954         (((_byte).eb_u8[0] &                                            \
1955                     __NATIVE_8(EFX_SHIFT8(_bit, FIX_LINT(0)))) != 0)
1956
1957
1958 #define EFX_OR_XWORD64(_xword1, _xword2)                                \
1959         do {                                                            \
1960                 (_xword1).ex_u64[0] |= (_xword2).ex_u64[0];             \
1961                 (_xword1).ex_u64[1] |= (_xword2).ex_u64[1];             \
1962                 (_xword1).ex_u64[2] |= (_xword2).ex_u64[2];             \
1963                 (_xword1).ex_u64[3] |= (_xword2).ex_u64[3];             \
1964         _NOTE(CONSTANTCONDITION)                                        \
1965         } while (B_FALSE)
1966
1967 #define EFX_OR_XWORD32(_xword1, _xword2)                                \
1968         do {                                                            \
1969                 (_xword1).ex_u32[0] |= (_xword2).ex_u32[0];             \
1970                 (_xword1).ex_u32[1] |= (_xword2).ex_u32[1];             \
1971                 (_xword1).ex_u32[2] |= (_xword2).ex_u32[2];             \
1972                 (_xword1).ex_u32[3] |= (_xword2).ex_u32[3];             \
1973                 (_xword1).ex_u32[4] |= (_xword2).ex_u32[4];             \
1974                 (_xword1).ex_u32[5] |= (_xword2).ex_u32[5];             \
1975                 (_xword1).ex_u32[6] |= (_xword2).ex_u32[6];             \
1976                 (_xword1).ex_u32[7] |= (_xword2).ex_u32[7];             \
1977         _NOTE(CONSTANTCONDITION)                                        \
1978         } while (B_FALSE)
1979
1980 #define EFX_AND_XWORD64(_xword1, _xword2)                               \
1981         do {                                                            \
1982                 (_xword1).ex_u64[0] &= (_xword2).ex_u64[0];             \
1983                 (_xword1).ex_u64[1] &= (_xword2).ex_u64[1];             \
1984                 (_xword1).ex_u64[2] &= (_xword2).ex_u64[2];             \
1985                 (_xword1).ex_u64[3] &= (_xword2).ex_u64[3];             \
1986         _NOTE(CONSTANTCONDITION)                                        \
1987         } while (B_FALSE)
1988
1989 #define EFX_AND_XWORD32(_xword1, _xword2)                               \
1990         do {                                                            \
1991                 (_xword1).ex_u32[0] &= (_xword2).ex_u32[0];             \
1992                 (_xword1).ex_u32[1] &= (_xword2).ex_u32[1];             \
1993                 (_xword1).ex_u32[2] &= (_xword2).ex_u32[2];             \
1994                 (_xword1).ex_u32[3] &= (_xword2).ex_u32[3];             \
1995                 (_xword1).ex_u32[4] &= (_xword2).ex_u32[4];             \
1996                 (_xword1).ex_u32[5] &= (_xword2).ex_u32[5];             \
1997                 (_xword1).ex_u32[6] &= (_xword2).ex_u32[6];             \
1998                 (_xword1).ex_u32[7] &= (_xword2).ex_u32[7];             \
1999         _NOTE(CONSTANTCONDITION)                                        \
2000         } while (B_FALSE)
2001
2002 #define EFX_OR_OWORD64(_oword1, _oword2)                                \
2003         do {                                                            \
2004                 (_oword1).eo_u64[0] |= (_oword2).eo_u64[0];             \
2005                 (_oword1).eo_u64[1] |= (_oword2).eo_u64[1];             \
2006         _NOTE(CONSTANTCONDITION)                                        \
2007         } while (B_FALSE)
2008
2009 #define EFX_OR_OWORD32(_oword1, _oword2)                                \
2010         do {                                                            \
2011                 (_oword1).eo_u32[0] |= (_oword2).eo_u32[0];             \
2012                 (_oword1).eo_u32[1] |= (_oword2).eo_u32[1];             \
2013                 (_oword1).eo_u32[2] |= (_oword2).eo_u32[2];             \
2014                 (_oword1).eo_u32[3] |= (_oword2).eo_u32[3];             \
2015         _NOTE(CONSTANTCONDITION)                                        \
2016         } while (B_FALSE)
2017
2018 #define EFX_AND_OWORD64(_oword1, _oword2)                               \
2019         do {                                                            \
2020                 (_oword1).eo_u64[0] &= (_oword2).eo_u64[0];             \
2021                 (_oword1).eo_u64[1] &= (_oword2).eo_u64[1];             \
2022         _NOTE(CONSTANTCONDITION)                                        \
2023         } while (B_FALSE)
2024
2025 #define EFX_AND_OWORD32(_oword1, _oword2)                               \
2026         do {                                                            \
2027                 (_oword1).eo_u32[0] &= (_oword2).eo_u32[0];             \
2028                 (_oword1).eo_u32[1] &= (_oword2).eo_u32[1];             \
2029                 (_oword1).eo_u32[2] &= (_oword2).eo_u32[2];             \
2030                 (_oword1).eo_u32[3] &= (_oword2).eo_u32[3];             \
2031         _NOTE(CONSTANTCONDITION)                                        \
2032         } while (B_FALSE)
2033
2034 #define EFX_OR_QWORD64(_qword1, _qword2)                                \
2035         do {                                                            \
2036                 (_qword1).eq_u64[0] |= (_qword2).eq_u64[0];             \
2037         _NOTE(CONSTANTCONDITION)                                        \
2038         } while (B_FALSE)
2039
2040 #define EFX_OR_QWORD32(_qword1, _qword2)                                \
2041         do {                                                            \
2042                 (_qword1).eq_u32[0] |= (_qword2).eq_u32[0];             \
2043                 (_qword1).eq_u32[1] |= (_qword2).eq_u32[1];             \
2044         _NOTE(CONSTANTCONDITION)                                        \
2045         } while (B_FALSE)
2046
2047 #define EFX_AND_QWORD64(_qword1, _qword2)                               \
2048         do {                                                            \
2049                 (_qword1).eq_u64[0] &= (_qword2).eq_u64[0];             \
2050         _NOTE(CONSTANTCONDITION)                                        \
2051         } while (B_FALSE)
2052
2053 #define EFX_AND_QWORD32(_qword1, _qword2)                               \
2054         do {                                                            \
2055                 (_qword1).eq_u32[0] &= (_qword2).eq_u32[0];             \
2056                 (_qword1).eq_u32[1] &= (_qword2).eq_u32[1];             \
2057         _NOTE(CONSTANTCONDITION)                                        \
2058         } while (B_FALSE)
2059
2060 #define EFX_OR_DWORD(_dword1, _dword2)                                  \
2061         do {                                                            \
2062                 (_dword1).ed_u32[0] |= (_dword2).ed_u32[0];             \
2063         _NOTE(CONSTANTCONDITION)                                        \
2064         } while (B_FALSE)
2065
2066 #define EFX_AND_DWORD(_dword1, _dword2)                                 \
2067         do {                                                            \
2068                 (_dword1).ed_u32[0] &= (_dword2).ed_u32[0];             \
2069         _NOTE(CONSTANTCONDITION)                                        \
2070         } while (B_FALSE)
2071
2072 #define EFX_OR_WORD(_word1, _word2)                                     \
2073         do {                                                            \
2074                 (_word1).ew_u16[0] |= (_word2).ew_u16[0];               \
2075         _NOTE(CONSTANTCONDITION)                                        \
2076         } while (B_FALSE)
2077
2078 #define EFX_AND_WORD(_word1, _word2)                                    \
2079         do {                                                            \
2080                 (_word1).ew_u16[0] &= (_word2).ew_u16[0];               \
2081         _NOTE(CONSTANTCONDITION)                                        \
2082         } while (B_FALSE)
2083
2084 #define EFX_OR_BYTE(_byte1, _byte2)                                     \
2085         do {                                                            \
2086                 (_byte1).eb_u8[0] |= (_byte2).eb_u8[0];                 \
2087         _NOTE(CONSTANTCONDITION)                                        \
2088         } while (B_FALSE)
2089
2090 #define EFX_AND_BYTE(_byte1, _byte2)                                    \
2091         do {                                                            \
2092                 (_byte1).eb_u8[0] &= (_byte2).eb_u8[0];                 \
2093         _NOTE(CONSTANTCONDITION)                                        \
2094         } while (B_FALSE)
2095
2096
2097 #if EFSYS_USE_UINT64
2098
2099 #define EFX_XWORD_FIELD         EFX_XWORD_FIELD64
2100 #define EFX_OWORD_FIELD         EFX_OWORD_FIELD64
2101 #define EFX_QWORD_FIELD         EFX_QWORD_FIELD64
2102
2103 #define EFX_XWORD_IS_EQUAL      EFX_XWORD_IS_EQUAL64
2104 #define EFX_OWORD_IS_EQUAL      EFX_OWORD_IS_EQUAL64
2105 #define EFX_QWORD_IS_EQUAL      EFX_QWORD_IS_EQUAL64
2106
2107 #define EFX_XWORD_IS_ZERO       EFX_XWORD_IS_ZERO64
2108 #define EFX_OWORD_IS_ZERO       EFX_OWORD_IS_ZERO64
2109 #define EFX_QWORD_IS_ZERO       EFX_QWORD_IS_ZERO64
2110
2111 #define EFX_XWORD_IS_SET        EFX_XWORD_IS_SET64
2112 #define EFX_OWORD_IS_SET        EFX_OWORD_IS_SET64
2113 #define EFX_QWORD_IS_SET        EFX_QWORD_IS_SET64
2114
2115 #define EFX_POPULATE_XWORD      EFX_POPULATE_XWORD64
2116 #define EFX_POPULATE_OWORD      EFX_POPULATE_OWORD64
2117 #define EFX_POPULATE_QWORD      EFX_POPULATE_QWORD64
2118
2119 #define EFX_SET_XWORD_FIELD     EFX_SET_XWORD_FIELD64
2120 #define EFX_SET_OWORD_FIELD     EFX_SET_OWORD_FIELD64
2121 #define EFX_SET_QWORD_FIELD     EFX_SET_QWORD_FIELD64
2122
2123 #define EFX_SET_XWORD_BIT       EFX_SET_XWORD_BIT64
2124 #define EFX_CLEAR_XWORD_BIT     EFX_CLEAR_XWORD_BIT64
2125 #define EFX_TEST_XWORD_BIT      EFX_TEST_XWORD_BIT64
2126
2127 #define EFX_SET_OWORD_BIT       EFX_SET_OWORD_BIT64
2128 #define EFX_CLEAR_OWORD_BIT     EFX_CLEAR_OWORD_BIT64
2129 #define EFX_TEST_OWORD_BIT      EFX_TEST_OWORD_BIT64
2130
2131 #define EFX_SET_QWORD_BIT       EFX_SET_QWORD_BIT64
2132 #define EFX_CLEAR_QWORD_BIT     EFX_CLEAR_QWORD_BIT64
2133 #define EFX_TEST_QWORD_BIT      EFX_TEST_QWORD_BIT64
2134
2135 #define EFX_OR_XWORD            EFX_OR_XWORD64
2136 #define EFX_AND_XWORD           EFX_AND_XWORD64
2137
2138 #define EFX_OR_OWORD            EFX_OR_OWORD64
2139 #define EFX_AND_OWORD           EFX_AND_OWORD64
2140
2141 #define EFX_OR_QWORD            EFX_OR_QWORD64
2142 #define EFX_AND_QWORD           EFX_AND_QWORD64
2143
2144 #else /* EFSYS_USE_UINT64 */
2145
2146 #define EFX_XWORD_FIELD         EFX_XWORD_FIELD32
2147 #define EFX_OWORD_FIELD         EFX_OWORD_FIELD32
2148 #define EFX_QWORD_FIELD         EFX_QWORD_FIELD32
2149
2150 #define EFX_XWORD_IS_EQUAL      EFX_XWORD_IS_EQUAL32
2151 #define EFX_OWORD_IS_EQUAL      EFX_OWORD_IS_EQUAL32
2152 #define EFX_QWORD_IS_EQUAL      EFX_QWORD_IS_EQUAL32
2153
2154 #define EFX_XWORD_IS_ZERO       EFX_XWORD_IS_ZERO32
2155 #define EFX_OWORD_IS_ZERO       EFX_OWORD_IS_ZERO32
2156 #define EFX_QWORD_IS_ZERO       EFX_QWORD_IS_ZERO32
2157
2158 #define EFX_XWORD_IS_SET        EFX_XWORD_IS_SET32
2159 #define EFX_OWORD_IS_SET        EFX_OWORD_IS_SET32
2160 #define EFX_QWORD_IS_SET        EFX_QWORD_IS_SET32
2161
2162 #define EFX_POPULATE_XWORD      EFX_POPULATE_XWORD32
2163 #define EFX_POPULATE_OWORD      EFX_POPULATE_OWORD32
2164 #define EFX_POPULATE_QWORD      EFX_POPULATE_QWORD32
2165
2166 #define EFX_SET_XWORD_FIELD     EFX_SET_XWORD_FIELD32
2167 #define EFX_SET_OWORD_FIELD     EFX_SET_OWORD_FIELD32
2168 #define EFX_SET_QWORD_FIELD     EFX_SET_QWORD_FIELD32
2169
2170 #define EFX_SET_XWORD_BIT       EFX_SET_XWORD_BIT32
2171 #define EFX_CLEAR_XWORD_BIT     EFX_CLEAR_XWORD_BIT32
2172 #define EFX_TEST_XWORD_BIT      EFX_TEST_XWORD_BIT32
2173
2174 #define EFX_SET_OWORD_BIT       EFX_SET_OWORD_BIT32
2175 #define EFX_CLEAR_OWORD_BIT     EFX_CLEAR_OWORD_BIT32
2176 #define EFX_TEST_OWORD_BIT      EFX_TEST_OWORD_BIT32
2177
2178 #define EFX_SET_QWORD_BIT       EFX_SET_QWORD_BIT32
2179 #define EFX_CLEAR_QWORD_BIT     EFX_CLEAR_QWORD_BIT32
2180 #define EFX_TEST_QWORD_BIT      EFX_TEST_QWORD_BIT32
2181
2182 #define EFX_OR_XWORD            EFX_OR_XWORD32
2183 #define EFX_AND_XWORD           EFX_AND_XWORD32
2184
2185 #define EFX_OR_OWORD            EFX_OR_OWORD32
2186 #define EFX_AND_OWORD           EFX_AND_OWORD32
2187
2188 #define EFX_OR_QWORD            EFX_OR_QWORD32
2189 #define EFX_AND_QWORD           EFX_AND_QWORD32
2190
2191 #endif /* EFSYS_USE_UINT64 */
2192
2193
2194 #ifdef  __cplusplus
2195 }
2196 #endif
2197
2198 #endif  /* _SYS_EFX_TYPES_H */