1 /* SPDX-License-Identifier: BSD-3-Clause 2 * 3 * Copyright(c) 2019-2021 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_UINT128 225 efsys_uint128_t 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_UINT128 247 efsys_uint128_t 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(_xword, _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 */ 2199