xref: /dpdk/drivers/common/sfc_efx/base/efx_types.h (revision 672386c1e9e1f64f7aa3b1360ad22dc737ea8d72)
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