1 /*
2 * Copyright (c) 2007-2015 Solarflare Communications Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * The views and conclusions contained in the software and documentation are
27 * those of the authors and should not be interpreted as representing official
28 * policies, either expressed or implied, of the FreeBSD Project.
29 *
30 * Ackowledgement to Fen Systems Ltd.
31 */
32
33 #ifndef _SYS_EFX_TYPES_H
34 #define _SYS_EFX_TYPES_H
35
36 #include "efsys.h"
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41
42 /*
43 * Bitfield access
44 *
45 * Solarflare NICs make extensive use of bitfields up to 128 bits
46 * wide. Since there is no native 128-bit datatype on most systems,
47 * and since 64-bit datatypes are inefficient on 32-bit systems and
48 * vice versa, we wrap accesses in a way that uses the most efficient
49 * datatype.
50 *
51 * The NICs are PCI devices and therefore little-endian. Since most
52 * of the quantities that we deal with are DMAed to/from host memory,
53 * we define our datatypes (efx_oword_t, efx_qword_t and efx_dword_t)
54 * to be little-endian.
55 *
56 * In the less common case of using PIO for individual register
57 * writes, we construct the little-endian datatype in host memory and
58 * then use non-swapping register access primitives, rather than
59 * constructing a native-endian datatype and relying on implicit
60 * byte-swapping. (We use a similar strategy for register reads.)
61 */
62
63 /*
64 * NOTE: Field definitions here and elsewhere are done in terms of a lowest
65 * bit number (LBN) and a width.
66 */
67
68 #define EFX_DUMMY_FIELD_LBN 0
69 #define EFX_DUMMY_FIELD_WIDTH 0
70
71 #define EFX_BYTE_0_LBN 0
72 #define EFX_BYTE_0_WIDTH 8
73
74 #define EFX_BYTE_1_LBN 8
75 #define EFX_BYTE_1_WIDTH 8
76
77 #define EFX_BYTE_2_LBN 16
78 #define EFX_BYTE_2_WIDTH 8
79
80 #define EFX_BYTE_3_LBN 24
81 #define EFX_BYTE_3_WIDTH 8
82
83 #define EFX_BYTE_4_LBN 32
84 #define EFX_BYTE_4_WIDTH 8
85
86 #define EFX_BYTE_5_LBN 40
87 #define EFX_BYTE_5_WIDTH 8
88
89 #define EFX_BYTE_6_LBN 48
90 #define EFX_BYTE_6_WIDTH 8
91
92 #define EFX_BYTE_7_LBN 56
93 #define EFX_BYTE_7_WIDTH 8
94
95 #define EFX_WORD_0_LBN 0
96 #define EFX_WORD_0_WIDTH 16
97
98 #define EFX_WORD_1_LBN 16
99 #define EFX_WORD_1_WIDTH 16
100
101 #define EFX_WORD_2_LBN 32
102 #define EFX_WORD_2_WIDTH 16
103
104 #define EFX_WORD_3_LBN 48
105 #define EFX_WORD_3_WIDTH 16
106
107 #define EFX_DWORD_0_LBN 0
108 #define EFX_DWORD_0_WIDTH 32
109
110 #define EFX_DWORD_1_LBN 32
111 #define EFX_DWORD_1_WIDTH 32
112
113 #define EFX_DWORD_2_LBN 64
114 #define EFX_DWORD_2_WIDTH 32
115
116 #define EFX_DWORD_3_LBN 96
117 #define EFX_DWORD_3_WIDTH 32
118
119 /* There are intentionally no EFX_QWORD_0 or EFX_QWORD_1 field definitions
120 * here as the implementaion of EFX_QWORD_FIELD and EFX_OWORD_FIELD do not
121 * support field widths larger than 32 bits.
122 */
123
124 /* Specified attribute (i.e. LBN ow WIDTH) of the specified field */
125 #define EFX_VAL(_field, _attribute) \
126 _field ## _ ## _attribute
127
128 /* Lowest bit number of the specified field */
129 #define EFX_LOW_BIT(_field) \
130 EFX_VAL(_field, LBN)
131
132 /* Width of the specified field */
133 #define EFX_WIDTH(_field) \
134 EFX_VAL(_field, WIDTH)
135
136 /* Highest bit number of the specified field */
137 #define EFX_HIGH_BIT(_field) \
138 (EFX_LOW_BIT(_field) + EFX_WIDTH(_field) - 1)
139
140 /*
141 * 64-bit mask equal in width to the specified field.
142 *
143 * For example, a field with width 5 would have a mask of 0x000000000000001f.
144 */
145 #define EFX_MASK64(_field) \
146 ((EFX_WIDTH(_field) == 64) ? ~((uint64_t)0) : \
147 (((((uint64_t)1) << EFX_WIDTH(_field))) - 1))
148 /*
149 * 32-bit mask equal in width to the specified field.
150 *
151 * For example, a field with width 5 would have a mask of 0x0000001f.
152 */
153 #define EFX_MASK32(_field) \
154 ((EFX_WIDTH(_field) == 32) ? ~((uint32_t)0) : \
155 (((((uint32_t)1) << EFX_WIDTH(_field))) - 1))
156
157 /*
158 * 16-bit mask equal in width to the specified field.
159 *
160 * For example, a field with width 5 would have a mask of 0x001f.
161 */
162 #define EFX_MASK16(_field) \
163 ((EFX_WIDTH(_field) == 16) ? 0xffffu : \
164 (uint16_t)((1 << EFX_WIDTH(_field)) - 1))
165
166 /*
167 * 8-bit mask equal in width to the specified field.
168 *
169 * For example, a field with width 5 would have a mask of 0x1f.
170 */
171 #define EFX_MASK8(_field) \
172 ((uint8_t)((1 << EFX_WIDTH(_field)) - 1))
173
174 #pragma pack(1)
175
176 /*
177 * A byte (i.e. 8-bit) datatype
178 */
179 typedef union efx_byte_u {
180 uint8_t eb_u8[1];
181 } efx_byte_t;
182
183 /*
184 * A word (i.e. 16-bit) datatype
185 *
186 * This datatype is defined to be little-endian.
187 */
188 typedef union efx_word_u {
189 efx_byte_t ew_byte[2];
190 uint16_t ew_u16[1];
191 uint8_t ew_u8[2];
192 } efx_word_t;
193
194 /*
195 * A doubleword (i.e. 32-bit) datatype
196 *
197 * This datatype is defined to be little-endian.
198 */
199 typedef union efx_dword_u {
200 efx_byte_t ed_byte[4];
201 efx_word_t ed_word[2];
202 uint32_t ed_u32[1];
203 uint16_t ed_u16[2];
204 uint8_t ed_u8[4];
205 } efx_dword_t;
206
207 /*
208 * A quadword (i.e. 64-bit) datatype
209 *
210 * This datatype is defined to be little-endian.
211 */
212 typedef union efx_qword_u {
213 efx_byte_t eq_byte[8];
214 efx_word_t eq_word[4];
215 efx_dword_t eq_dword[2];
216 #if EFSYS_HAS_UINT64
217 uint64_t eq_u64[1];
218 #endif
219 uint32_t eq_u32[2];
220 uint16_t eq_u16[4];
221 uint8_t eq_u8[8];
222 } efx_qword_t;
223
224 /*
225 * An octword (i.e. 128-bit) datatype
226 *
227 * This datatype is defined to be little-endian.
228 */
229 typedef union efx_oword_u {
230 efx_byte_t eo_byte[16];
231 efx_word_t eo_word[8];
232 efx_dword_t eo_dword[4];
233 efx_qword_t eo_qword[2];
234 #if EFSYS_HAS_SSE2_M128
235 __m128i eo_u128[1];
236 #endif
237 #if EFSYS_HAS_UINT64
238 uint64_t eo_u64[2];
239 #endif
240 uint32_t eo_u32[4];
241 uint16_t eo_u16[8];
242 uint8_t eo_u8[16];
243 } efx_oword_t;
244
245 #pragma pack()
246
247 #define __SWAP16(_x) \
248 ((((_x) & 0xff) << 8) | \
249 (((_x) >> 8) & 0xff))
250
251 #define __SWAP32(_x) \
252 ((__SWAP16((_x) & 0xffff) << 16) | \
253 __SWAP16(((_x) >> 16) & 0xffff))
254
255 #define __SWAP64(_x) \
256 ((__SWAP32((_x) & 0xffffffff) << 32) | \
257 __SWAP32(((_x) >> 32) & 0xffffffff))
258
259 #define __NOSWAP16(_x) (_x)
260 #define __NOSWAP32(_x) (_x)
261 #define __NOSWAP64(_x) (_x)
262
263 #if EFSYS_IS_BIG_ENDIAN
264
265 #define __CPU_TO_LE_16(_x) (uint16_t)__SWAP16(_x)
266 #define __LE_TO_CPU_16(_x) (uint16_t)__SWAP16(_x)
267 #define __CPU_TO_BE_16(_x) (uint16_t)__NOSWAP16(_x)
268 #define __BE_TO_CPU_16(_x) (uint16_t)__NOSWAP16(_x)
269
270 #define __CPU_TO_LE_32(_x) (uint32_t)__SWAP32(_x)
271 #define __LE_TO_CPU_32(_x) (uint32_t)__SWAP32(_x)
272 #define __CPU_TO_BE_32(_x) (uint32_t)__NOSWAP32(_x)
273 #define __BE_TO_CPU_32(_x) (uint32_t)__NOSWAP32(_x)
274
275 #define __CPU_TO_LE_64(_x) (uint64_t)__SWAP64(_x)
276 #define __LE_TO_CPU_64(_x) (uint64_t)__SWAP64(_x)
277 #define __CPU_TO_BE_64(_x) (uint64_t)__NOSWAP64(_x)
278 #define __BE_TO_CPU_64(_x) (uint64_t)__NOSWAP64(_x)
279
280 #elif EFSYS_IS_LITTLE_ENDIAN
281
282 #define __CPU_TO_LE_16(_x) (uint16_t)__NOSWAP16(_x)
283 #define __LE_TO_CPU_16(_x) (uint16_t)__NOSWAP16(_x)
284 #define __CPU_TO_BE_16(_x) (uint16_t)__SWAP16(_x)
285 #define __BE_TO_CPU_16(_x) (uint16_t)__SWAP16(_x)
286
287 #define __CPU_TO_LE_32(_x) (uint32_t)__NOSWAP32(_x)
288 #define __LE_TO_CPU_32(_x) (uint32_t)__NOSWAP32(_x)
289 #define __CPU_TO_BE_32(_x) (uint32_t)__SWAP32(_x)
290 #define __BE_TO_CPU_32(_x) (uint32_t)__SWAP32(_x)
291
292 #define __CPU_TO_LE_64(_x) (uint64_t)__NOSWAP64(_x)
293 #define __LE_TO_CPU_64(_x) (uint64_t)__NOSWAP64(_x)
294 #define __CPU_TO_BE_64(_x) (uint64_t)__SWAP64(_x)
295 #define __BE_TO_CPU_64(_x) (uint64_t)__SWAP64(_x)
296
297 #else
298
299 #error "Neither of EFSYS_IS_{BIG,LITTLE}_ENDIAN is set"
300
301 #endif
302
303 #define __NATIVE_8(_x) (uint8_t)(_x)
304
305 /* Format string for printing an efx_byte_t */
306 #define EFX_BYTE_FMT "0x%02x"
307
308 /* Format string for printing an efx_word_t */
309 #define EFX_WORD_FMT "0x%04x"
310
311 /* Format string for printing an efx_dword_t */
312 #define EFX_DWORD_FMT "0x%08x"
313
314 /* Format string for printing an efx_qword_t */
315 #define EFX_QWORD_FMT "0x%08x:%08x"
316
317 /* Format string for printing an efx_oword_t */
318 #define EFX_OWORD_FMT "0x%08x:%08x:%08x:%08x"
319
320 /* Parameters for printing an efx_byte_t */
321 #define EFX_BYTE_VAL(_byte) \
322 ((unsigned int)__NATIVE_8((_byte).eb_u8[0]))
323
324 /* Parameters for printing an efx_word_t */
325 #define EFX_WORD_VAL(_word) \
326 ((unsigned int)__LE_TO_CPU_16((_word).ew_u16[0]))
327
328 /* Parameters for printing an efx_dword_t */
329 #define EFX_DWORD_VAL(_dword) \
330 ((unsigned int)__LE_TO_CPU_32((_dword).ed_u32[0]))
331
332 /* Parameters for printing an efx_qword_t */
333 #define EFX_QWORD_VAL(_qword) \
334 ((unsigned int)__LE_TO_CPU_32((_qword).eq_u32[1])), \
335 ((unsigned int)__LE_TO_CPU_32((_qword).eq_u32[0]))
336
337 /* Parameters for printing an efx_oword_t */
338 #define EFX_OWORD_VAL(_oword) \
339 ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[3])), \
340 ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[2])), \
341 ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[1])), \
342 ((unsigned int)__LE_TO_CPU_32((_oword).eo_u32[0]))
343
344 /*
345 * Stop lint complaining about some shifts.
346 */
347 #ifdef __lint
348 extern int fix_lint;
349 #define FIX_LINT(_x) (_x + fix_lint)
350 #else
351 #define FIX_LINT(_x) (_x)
352 #endif
353
354 /*
355 * Extract bit field portion [low,high) from the native-endian element
356 * which contains bits [min,max).
357 *
358 * For example, suppose "element" represents the high 32 bits of a
359 * 64-bit value, and we wish to extract the bits belonging to the bit
360 * field occupying bits 28-45 of this 64-bit value.
361 *
362 * Then EFX_EXTRACT(_element, 32, 63, 28, 45) would give
363 *
364 * (_element) << 4
365 *
366 * The result will contain the relevant bits filled in in the range
367 * [0,high-low), with garbage in bits [high-low+1,...).
368 */
369 #define EFX_EXTRACT_NATIVE(_element, _min, _max, _low, _high) \
370 ((FIX_LINT(_low > _max) || FIX_LINT(_high < _min)) ? \
371 0U : \
372 ((_low > _min) ? \
373 ((_element) >> (_low - _min)) : \
374 ((_element) << (_min - _low))))
375
376 /*
377 * Extract bit field portion [low,high) from the 64-bit little-endian
378 * element which contains bits [min,max)
379 */
380 #define EFX_EXTRACT64(_element, _min, _max, _low, _high) \
381 EFX_EXTRACT_NATIVE(__LE_TO_CPU_64(_element), _min, _max, _low, _high)
382
383 /*
384 * Extract bit field portion [low,high) from the 32-bit little-endian
385 * element which contains bits [min,max)
386 */
387 #define EFX_EXTRACT32(_element, _min, _max, _low, _high) \
388 EFX_EXTRACT_NATIVE(__LE_TO_CPU_32(_element), _min, _max, _low, _high)
389
390 /*
391 * Extract bit field portion [low,high) from the 16-bit little-endian
392 * element which contains bits [min,max)
393 */
394 #define EFX_EXTRACT16(_element, _min, _max, _low, _high) \
395 EFX_EXTRACT_NATIVE(__LE_TO_CPU_16(_element), _min, _max, _low, _high)
396
397 /*
398 * Extract bit field portion [low,high) from the 8-bit
399 * element which contains bits [min,max)
400 */
401 #define EFX_EXTRACT8(_element, _min, _max, _low, _high) \
402 EFX_EXTRACT_NATIVE(__NATIVE_8(_element), _min, _max, _low, _high)
403
404 #define EFX_EXTRACT_OWORD64(_oword, _low, _high) \
405 (EFX_EXTRACT64((_oword).eo_u64[0], FIX_LINT(0), FIX_LINT(63), \
406 _low, _high) | \
407 EFX_EXTRACT64((_oword).eo_u64[1], FIX_LINT(64), FIX_LINT(127), \
408 _low, _high))
409
410 #define EFX_EXTRACT_OWORD32(_oword, _low, _high) \
411 (EFX_EXTRACT32((_oword).eo_u32[0], FIX_LINT(0), FIX_LINT(31), \
412 _low, _high) | \
413 EFX_EXTRACT32((_oword).eo_u32[1], FIX_LINT(32), FIX_LINT(63), \
414 _low, _high) | \
415 EFX_EXTRACT32((_oword).eo_u32[2], FIX_LINT(64), FIX_LINT(95), \
416 _low, _high) | \
417 EFX_EXTRACT32((_oword).eo_u32[3], FIX_LINT(96), FIX_LINT(127), \
418 _low, _high))
419
420 #define EFX_EXTRACT_QWORD64(_qword, _low, _high) \
421 (EFX_EXTRACT64((_qword).eq_u64[0], FIX_LINT(0), FIX_LINT(63), \
422 _low, _high))
423
424 #define EFX_EXTRACT_QWORD32(_qword, _low, _high) \
425 (EFX_EXTRACT32((_qword).eq_u32[0], FIX_LINT(0), FIX_LINT(31), \
426 _low, _high) | \
427 EFX_EXTRACT32((_qword).eq_u32[1], FIX_LINT(32), FIX_LINT(63), \
428 _low, _high))
429
430 #define EFX_EXTRACT_DWORD(_dword, _low, _high) \
431 (EFX_EXTRACT32((_dword).ed_u32[0], FIX_LINT(0), FIX_LINT(31), \
432 _low, _high))
433
434 #define EFX_EXTRACT_WORD(_word, _low, _high) \
435 (EFX_EXTRACT16((_word).ew_u16[0], FIX_LINT(0), FIX_LINT(15), \
436 _low, _high))
437
438 #define EFX_EXTRACT_BYTE(_byte, _low, _high) \
439 (EFX_EXTRACT8((_byte).eb_u8[0], FIX_LINT(0), FIX_LINT(7), \
440 _low, _high))
441
442
443 #define EFX_OWORD_FIELD64(_oword, _field) \
444 ((uint32_t)EFX_EXTRACT_OWORD64(_oword, EFX_LOW_BIT(_field), \
445 EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
446
447 #define EFX_OWORD_FIELD32(_oword, _field) \
448 (EFX_EXTRACT_OWORD32(_oword, EFX_LOW_BIT(_field), \
449 EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
450
451 #define EFX_QWORD_FIELD64(_qword, _field) \
452 ((uint32_t)EFX_EXTRACT_QWORD64(_qword, EFX_LOW_BIT(_field), \
453 EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
454
455 #define EFX_QWORD_FIELD32(_qword, _field) \
456 (EFX_EXTRACT_QWORD32(_qword, EFX_LOW_BIT(_field), \
457 EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
458
459 #define EFX_DWORD_FIELD(_dword, _field) \
460 (EFX_EXTRACT_DWORD(_dword, EFX_LOW_BIT(_field), \
461 EFX_HIGH_BIT(_field)) & EFX_MASK32(_field))
462
463 #define EFX_WORD_FIELD(_word, _field) \
464 (EFX_EXTRACT_WORD(_word, EFX_LOW_BIT(_field), \
465 EFX_HIGH_BIT(_field)) & EFX_MASK16(_field))
466
467 #define EFX_BYTE_FIELD(_byte, _field) \
468 (EFX_EXTRACT_BYTE(_byte, EFX_LOW_BIT(_field), \
469 EFX_HIGH_BIT(_field)) & EFX_MASK8(_field))
470
471
472 #define EFX_OWORD_IS_EQUAL64(_oword_a, _oword_b) \
473 ((_oword_a).eo_u64[0] == (_oword_b).eo_u64[0] && \
474 (_oword_a).eo_u64[1] == (_oword_b).eo_u64[1])
475
476 #define EFX_OWORD_IS_EQUAL32(_oword_a, _oword_b) \
477 ((_oword_a).eo_u32[0] == (_oword_b).eo_u32[0] && \
478 (_oword_a).eo_u32[1] == (_oword_b).eo_u32[1] && \
479 (_oword_a).eo_u32[2] == (_oword_b).eo_u32[2] && \
480 (_oword_a).eo_u32[3] == (_oword_b).eo_u32[3])
481
482 #define EFX_QWORD_IS_EQUAL64(_qword_a, _qword_b) \
483 ((_qword_a).eq_u64[0] == (_qword_b).eq_u64[0])
484
485 #define EFX_QWORD_IS_EQUAL32(_qword_a, _qword_b) \
486 ((_qword_a).eq_u32[0] == (_qword_b).eq_u32[0] && \
487 (_qword_a).eq_u32[1] == (_qword_b).eq_u32[1])
488
489 #define EFX_DWORD_IS_EQUAL(_dword_a, _dword_b) \
490 ((_dword_a).ed_u32[0] == (_dword_b).ed_u32[0])
491
492 #define EFX_WORD_IS_EQUAL(_word_a, _word_b) \
493 ((_word_a).ew_u16[0] == (_word_b).ew_u16[0])
494
495 #define EFX_BYTE_IS_EQUAL(_byte_a, _byte_b) \
496 ((_byte_a).eb_u8[0] == (_byte_b).eb_u8[0])
497
498
499 #define EFX_OWORD_IS_ZERO64(_oword) \
500 (((_oword).eo_u64[0] | \
501 (_oword).eo_u64[1]) == 0)
502
503 #define EFX_OWORD_IS_ZERO32(_oword) \
504 (((_oword).eo_u32[0] | \
505 (_oword).eo_u32[1] | \
506 (_oword).eo_u32[2] | \
507 (_oword).eo_u32[3]) == 0)
508
509 #define EFX_QWORD_IS_ZERO64(_qword) \
510 (((_qword).eq_u64[0]) == 0)
511
512 #define EFX_QWORD_IS_ZERO32(_qword) \
513 (((_qword).eq_u32[0] | \
514 (_qword).eq_u32[1]) == 0)
515
516 #define EFX_DWORD_IS_ZERO(_dword) \
517 (((_dword).ed_u32[0]) == 0)
518
519 #define EFX_WORD_IS_ZERO(_word) \
520 (((_word).ew_u16[0]) == 0)
521
522 #define EFX_BYTE_IS_ZERO(_byte) \
523 (((_byte).eb_u8[0]) == 0)
524
525
526 #define EFX_OWORD_IS_SET64(_oword) \
527 (((_oword).eo_u64[0] & \
528 (_oword).eo_u64[1]) == ~((uint64_t)0))
529
530 #define EFX_OWORD_IS_SET32(_oword) \
531 (((_oword).eo_u32[0] & \
532 (_oword).eo_u32[1] & \
533 (_oword).eo_u32[2] & \
534 (_oword).eo_u32[3]) == ~((uint32_t)0))
535
536 #define EFX_QWORD_IS_SET64(_qword) \
537 (((_qword).eq_u64[0]) == ~((uint64_t)0))
538
539 #define EFX_QWORD_IS_SET32(_qword) \
540 (((_qword).eq_u32[0] & \
541 (_qword).eq_u32[1]) == ~((uint32_t)0))
542
543 #define EFX_DWORD_IS_SET(_dword) \
544 ((_dword).ed_u32[0] == ~((uint32_t)0))
545
546 #define EFX_WORD_IS_SET(_word) \
547 ((_word).ew_u16[0] == ~((uint16_t)0))
548
549 #define EFX_BYTE_IS_SET(_byte) \
550 ((_byte).eb_u8[0] == ~((uint8_t)0))
551
552 /*
553 * Construct bit field portion
554 *
555 * Creates the portion of the bit field [low,high) that lies within
556 * the range [min,max).
557 */
558
559 #define EFX_INSERT_NATIVE64(_min, _max, _low, _high, _value) \
560 (((_low > _max) || (_high < _min)) ? \
561 0U : \
562 ((_low > _min) ? \
563 (((uint64_t)(_value)) << (_low - _min)) : \
564 (((uint64_t)(_value)) >> (_min - _low))))
565
566 #define EFX_INSERT_NATIVE32(_min, _max, _low, _high, _value) \
567 (((_low > _max) || (_high < _min)) ? \
568 0U : \
569 ((_low > _min) ? \
570 (((uint32_t)(_value)) << (_low - _min)) : \
571 (((uint32_t)(_value)) >> (_min - _low))))
572
573 #define EFX_INSERT_NATIVE16(_min, _max, _low, _high, _value) \
574 (((_low > _max) || (_high < _min)) ? \
575 0U : \
576 (uint16_t)((_low > _min) ? \
577 ((_value) << (_low - _min)) : \
578 ((_value) >> (_min - _low))))
579
580 #define EFX_INSERT_NATIVE8(_min, _max, _low, _high, _value) \
581 (((_low > _max) || (_high < _min)) ? \
582 0U : \
583 (uint8_t)((_low > _min) ? \
584 ((_value) << (_low - _min)) : \
585 ((_value) >> (_min - _low))))
586
587 /*
588 * Construct bit field portion
589 *
590 * Creates the portion of the named bit field that lies within the
591 * range [min,max).
592 */
593 #define EFX_INSERT_FIELD_NATIVE64(_min, _max, _field, _value) \
594 EFX_INSERT_NATIVE64(_min, _max, EFX_LOW_BIT(_field), \
595 EFX_HIGH_BIT(_field), _value)
596
597 #define EFX_INSERT_FIELD_NATIVE32(_min, _max, _field, _value) \
598 EFX_INSERT_NATIVE32(_min, _max, EFX_LOW_BIT(_field), \
599 EFX_HIGH_BIT(_field), _value)
600
601 #define EFX_INSERT_FIELD_NATIVE16(_min, _max, _field, _value) \
602 EFX_INSERT_NATIVE16(_min, _max, EFX_LOW_BIT(_field), \
603 EFX_HIGH_BIT(_field), _value)
604
605 #define EFX_INSERT_FIELD_NATIVE8(_min, _max, _field, _value) \
606 EFX_INSERT_NATIVE8(_min, _max, EFX_LOW_BIT(_field), \
607 EFX_HIGH_BIT(_field), _value)
608
609 /*
610 * Construct bit field
611 *
612 * Creates the portion of the named bit fields that lie within the
613 * range [min,max).
614 */
615 #define EFX_INSERT_FIELDS64(_min, _max, \
616 _field1, _value1, _field2, _value2, _field3, _value3, \
617 _field4, _value4, _field5, _value5, _field6, _value6, \
618 _field7, _value7, _field8, _value8, _field9, _value9, \
619 _field10, _value10) \
620 __CPU_TO_LE_64( \
621 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field1, _value1) | \
622 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field2, _value2) | \
623 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field3, _value3) | \
624 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field4, _value4) | \
625 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field5, _value5) | \
626 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field6, _value6) | \
627 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field7, _value7) | \
628 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field8, _value8) | \
629 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field9, _value9) | \
630 EFX_INSERT_FIELD_NATIVE64(_min, _max, _field10, _value10))
631
632 #define EFX_INSERT_FIELDS32(_min, _max, \
633 _field1, _value1, _field2, _value2, _field3, _value3, \
634 _field4, _value4, _field5, _value5, _field6, _value6, \
635 _field7, _value7, _field8, _value8, _field9, _value9, \
636 _field10, _value10) \
637 __CPU_TO_LE_32( \
638 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field1, _value1) | \
639 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field2, _value2) | \
640 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field3, _value3) | \
641 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field4, _value4) | \
642 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field5, _value5) | \
643 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field6, _value6) | \
644 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field7, _value7) | \
645 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field8, _value8) | \
646 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field9, _value9) | \
647 EFX_INSERT_FIELD_NATIVE32(_min, _max, _field10, _value10))
648
649 #define EFX_INSERT_FIELDS16(_min, _max, \
650 _field1, _value1, _field2, _value2, _field3, _value3, \
651 _field4, _value4, _field5, _value5, _field6, _value6, \
652 _field7, _value7, _field8, _value8, _field9, _value9, \
653 _field10, _value10) \
654 __CPU_TO_LE_16( \
655 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field1, _value1) | \
656 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field2, _value2) | \
657 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field3, _value3) | \
658 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field4, _value4) | \
659 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field5, _value5) | \
660 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field6, _value6) | \
661 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field7, _value7) | \
662 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field8, _value8) | \
663 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field9, _value9) | \
664 EFX_INSERT_FIELD_NATIVE16(_min, _max, _field10, _value10))
665
666 #define EFX_INSERT_FIELDS8(_min, _max, \
667 _field1, _value1, _field2, _value2, _field3, _value3, \
668 _field4, _value4, _field5, _value5, _field6, _value6, \
669 _field7, _value7, _field8, _value8, _field9, _value9, \
670 _field10, _value10) \
671 __NATIVE_8( \
672 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field1, _value1) | \
673 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field2, _value2) | \
674 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field3, _value3) | \
675 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field4, _value4) | \
676 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field5, _value5) | \
677 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field6, _value6) | \
678 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field7, _value7) | \
679 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field8, _value8) | \
680 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field9, _value9) | \
681 EFX_INSERT_FIELD_NATIVE8(_min, _max, _field10, _value10))
682
683 #define EFX_POPULATE_OWORD64(_oword, \
684 _field1, _value1, _field2, _value2, _field3, _value3, \
685 _field4, _value4, _field5, _value5, _field6, _value6, \
686 _field7, _value7, _field8, _value8, _field9, _value9, \
687 _field10, _value10) \
688 do { \
689 _NOTE(CONSTANTCONDITION) \
690 (_oword).eo_u64[0] = EFX_INSERT_FIELDS64(0, 63, \
691 _field1, _value1, _field2, _value2, \
692 _field3, _value3, _field4, _value4, \
693 _field5, _value5, _field6, _value6, \
694 _field7, _value7, _field8, _value8, \
695 _field9, _value9, _field10, _value10); \
696 _NOTE(CONSTANTCONDITION) \
697 (_oword).eo_u64[1] = EFX_INSERT_FIELDS64(64, 127, \
698 _field1, _value1, _field2, _value2, \
699 _field3, _value3, _field4, _value4, \
700 _field5, _value5, _field6, _value6, \
701 _field7, _value7, _field8, _value8, \
702 _field9, _value9, _field10, _value10); \
703 _NOTE(CONSTANTCONDITION) \
704 } while (B_FALSE)
705
706 #define EFX_POPULATE_OWORD32(_oword, \
707 _field1, _value1, _field2, _value2, _field3, _value3, \
708 _field4, _value4, _field5, _value5, _field6, _value6, \
709 _field7, _value7, _field8, _value8, _field9, _value9, \
710 _field10, _value10) \
711 do { \
712 _NOTE(CONSTANTCONDITION) \
713 (_oword).eo_u32[0] = EFX_INSERT_FIELDS32(0, 31, \
714 _field1, _value1, _field2, _value2, \
715 _field3, _value3, _field4, _value4, \
716 _field5, _value5, _field6, _value6, \
717 _field7, _value7, _field8, _value8, \
718 _field9, _value9, _field10, _value10); \
719 _NOTE(CONSTANTCONDITION) \
720 (_oword).eo_u32[1] = EFX_INSERT_FIELDS32(32, 63, \
721 _field1, _value1, _field2, _value2, \
722 _field3, _value3, _field4, _value4, \
723 _field5, _value5, _field6, _value6, \
724 _field7, _value7, _field8, _value8, \
725 _field9, _value9, _field10, _value10); \
726 _NOTE(CONSTANTCONDITION) \
727 (_oword).eo_u32[2] = EFX_INSERT_FIELDS32(64, 95, \
728 _field1, _value1, _field2, _value2, \
729 _field3, _value3, _field4, _value4, \
730 _field5, _value5, _field6, _value6, \
731 _field7, _value7, _field8, _value8, \
732 _field9, _value9, _field10, _value10); \
733 _NOTE(CONSTANTCONDITION) \
734 (_oword).eo_u32[3] = EFX_INSERT_FIELDS32(96, 127, \
735 _field1, _value1, _field2, _value2, \
736 _field3, _value3, _field4, _value4, \
737 _field5, _value5, _field6, _value6, \
738 _field7, _value7, _field8, _value8, \
739 _field9, _value9, _field10, _value10); \
740 _NOTE(CONSTANTCONDITION) \
741 } while (B_FALSE)
742
743 #define EFX_POPULATE_QWORD64(_qword, \
744 _field1, _value1, _field2, _value2, _field3, _value3, \
745 _field4, _value4, _field5, _value5, _field6, _value6, \
746 _field7, _value7, _field8, _value8, _field9, _value9, \
747 _field10, _value10) \
748 do { \
749 _NOTE(CONSTANTCONDITION) \
750 (_qword).eq_u64[0] = EFX_INSERT_FIELDS64(0, 63, \
751 _field1, _value1, _field2, _value2, \
752 _field3, _value3, _field4, _value4, \
753 _field5, _value5, _field6, _value6, \
754 _field7, _value7, _field8, _value8, \
755 _field9, _value9, _field10, _value10); \
756 _NOTE(CONSTANTCONDITION) \
757 } while (B_FALSE)
758
759 #define EFX_POPULATE_QWORD32(_qword, \
760 _field1, _value1, _field2, _value2, _field3, _value3, \
761 _field4, _value4, _field5, _value5, _field6, _value6, \
762 _field7, _value7, _field8, _value8, _field9, _value9, \
763 _field10, _value10) \
764 do { \
765 _NOTE(CONSTANTCONDITION) \
766 (_qword).eq_u32[0] = EFX_INSERT_FIELDS32(0, 31, \
767 _field1, _value1, _field2, _value2, \
768 _field3, _value3, _field4, _value4, \
769 _field5, _value5, _field6, _value6, \
770 _field7, _value7, _field8, _value8, \
771 _field9, _value9, _field10, _value10); \
772 _NOTE(CONSTANTCONDITION) \
773 (_qword).eq_u32[1] = EFX_INSERT_FIELDS32(32, 63, \
774 _field1, _value1, _field2, _value2, \
775 _field3, _value3, _field4, _value4, \
776 _field5, _value5, _field6, _value6, \
777 _field7, _value7, _field8, _value8, \
778 _field9, _value9, _field10, _value10); \
779 _NOTE(CONSTANTCONDITION) \
780 } while (B_FALSE)
781
782 #define EFX_POPULATE_DWORD(_dword, \
783 _field1, _value1, _field2, _value2, _field3, _value3, \
784 _field4, _value4, _field5, _value5, _field6, _value6, \
785 _field7, _value7, _field8, _value8, _field9, _value9, \
786 _field10, _value10) \
787 do { \
788 _NOTE(CONSTANTCONDITION) \
789 (_dword).ed_u32[0] = EFX_INSERT_FIELDS32(0, 31, \
790 _field1, _value1, _field2, _value2, \
791 _field3, _value3, _field4, _value4, \
792 _field5, _value5, _field6, _value6, \
793 _field7, _value7, _field8, _value8, \
794 _field9, _value9, _field10, _value10); \
795 _NOTE(CONSTANTCONDITION) \
796 } while (B_FALSE)
797
798 #define EFX_POPULATE_WORD(_word, \
799 _field1, _value1, _field2, _value2, _field3, _value3, \
800 _field4, _value4, _field5, _value5, _field6, _value6, \
801 _field7, _value7, _field8, _value8, _field9, _value9, \
802 _field10, _value10) \
803 do { \
804 _NOTE(CONSTANTCONDITION) \
805 (_word).ew_u16[0] = EFX_INSERT_FIELDS16(0, 15, \
806 _field1, _value1, _field2, _value2, \
807 _field3, _value3, _field4, _value4, \
808 _field5, _value5, _field6, _value6, \
809 _field7, _value7, _field8, _value8, \
810 _field9, _value9, _field10, _value10); \
811 _NOTE(CONSTANTCONDITION) \
812 } while (B_FALSE)
813
814 #define EFX_POPULATE_BYTE(_byte, \
815 _field1, _value1, _field2, _value2, _field3, _value3, \
816 _field4, _value4, _field5, _value5, _field6, _value6, \
817 _field7, _value7, _field8, _value8, _field9, _value9, \
818 _field10, _value10) \
819 do { \
820 _NOTE(CONSTANTCONDITION) \
821 (_byte).eb_u8[0] = EFX_INSERT_FIELDS8(0, 7, \
822 _field1, _value1, _field2, _value2, \
823 _field3, _value3, _field4, _value4, \
824 _field5, _value5, _field6, _value6, \
825 _field7, _value7, _field8, _value8, \
826 _field9, _value9, _field10, _value10); \
827 _NOTE(CONSTANTCONDITION) \
828 } while (B_FALSE)
829
830 /* Populate an octword field with various numbers of arguments */
831 #define EFX_POPULATE_OWORD_10 EFX_POPULATE_OWORD
832
833 #define EFX_POPULATE_OWORD_9(_oword, \
834 _field1, _value1, _field2, _value2, _field3, _value3, \
835 _field4, _value4, _field5, _value5, _field6, _value6, \
836 _field7, _value7, _field8, _value8, _field9, _value9) \
837 EFX_POPULATE_OWORD_10(_oword, EFX_DUMMY_FIELD, 0, \
838 _field1, _value1, _field2, _value2, _field3, _value3, \
839 _field4, _value4, _field5, _value5, _field6, _value6, \
840 _field7, _value7, _field8, _value8, _field9, _value9)
841
842 #define EFX_POPULATE_OWORD_8(_oword, \
843 _field1, _value1, _field2, _value2, _field3, _value3, \
844 _field4, _value4, _field5, _value5, _field6, _value6, \
845 _field7, _value7, _field8, _value8) \
846 EFX_POPULATE_OWORD_9(_oword, EFX_DUMMY_FIELD, 0, \
847 _field1, _value1, _field2, _value2, _field3, _value3, \
848 _field4, _value4, _field5, _value5, _field6, _value6, \
849 _field7, _value7, _field8, _value8)
850
851 #define EFX_POPULATE_OWORD_7(_oword, \
852 _field1, _value1, _field2, _value2, _field3, _value3, \
853 _field4, _value4, _field5, _value5, _field6, _value6, \
854 _field7, _value7) \
855 EFX_POPULATE_OWORD_8(_oword, EFX_DUMMY_FIELD, 0, \
856 _field1, _value1, _field2, _value2, _field3, _value3, \
857 _field4, _value4, _field5, _value5, _field6, _value6, \
858 _field7, _value7)
859
860 #define EFX_POPULATE_OWORD_6(_oword, \
861 _field1, _value1, _field2, _value2, _field3, _value3, \
862 _field4, _value4, _field5, _value5, _field6, _value6) \
863 EFX_POPULATE_OWORD_7(_oword, EFX_DUMMY_FIELD, 0, \
864 _field1, _value1, _field2, _value2, _field3, _value3, \
865 _field4, _value4, _field5, _value5, _field6, _value6)
866
867 #define EFX_POPULATE_OWORD_5(_oword, \
868 _field1, _value1, _field2, _value2, _field3, _value3, \
869 _field4, _value4, _field5, _value5) \
870 EFX_POPULATE_OWORD_6(_oword, EFX_DUMMY_FIELD, 0, \
871 _field1, _value1, _field2, _value2, _field3, _value3, \
872 _field4, _value4, _field5, _value5)
873
874 #define EFX_POPULATE_OWORD_4(_oword, \
875 _field1, _value1, _field2, _value2, _field3, _value3, \
876 _field4, _value4) \
877 EFX_POPULATE_OWORD_5(_oword, EFX_DUMMY_FIELD, 0, \
878 _field1, _value1, _field2, _value2, _field3, _value3, \
879 _field4, _value4)
880
881 #define EFX_POPULATE_OWORD_3(_oword, \
882 _field1, _value1, _field2, _value2, _field3, _value3) \
883 EFX_POPULATE_OWORD_4(_oword, EFX_DUMMY_FIELD, 0, \
884 _field1, _value1, _field2, _value2, _field3, _value3)
885
886 #define EFX_POPULATE_OWORD_2(_oword, \
887 _field1, _value1, _field2, _value2) \
888 EFX_POPULATE_OWORD_3(_oword, EFX_DUMMY_FIELD, 0, \
889 _field1, _value1, _field2, _value2)
890
891 #define EFX_POPULATE_OWORD_1(_oword, \
892 _field1, _value1) \
893 EFX_POPULATE_OWORD_2(_oword, EFX_DUMMY_FIELD, 0, \
894 _field1, _value1)
895
896 #define EFX_ZERO_OWORD(_oword) \
897 EFX_POPULATE_OWORD_1(_oword, EFX_DUMMY_FIELD, 0)
898
899 #define EFX_SET_OWORD(_oword) \
900 EFX_POPULATE_OWORD_4(_oword, \
901 EFX_DWORD_0, 0xffffffff, EFX_DWORD_1, 0xffffffff, \
902 EFX_DWORD_2, 0xffffffff, EFX_DWORD_3, 0xffffffff)
903
904 /* Populate a quadword field with various numbers of arguments */
905 #define EFX_POPULATE_QWORD_10 EFX_POPULATE_QWORD
906
907 #define EFX_POPULATE_QWORD_9(_qword, \
908 _field1, _value1, _field2, _value2, _field3, _value3, \
909 _field4, _value4, _field5, _value5, _field6, _value6, \
910 _field7, _value7, _field8, _value8, _field9, _value9) \
911 EFX_POPULATE_QWORD_10(_qword, EFX_DUMMY_FIELD, 0, \
912 _field1, _value1, _field2, _value2, _field3, _value3, \
913 _field4, _value4, _field5, _value5, _field6, _value6, \
914 _field7, _value7, _field8, _value8, _field9, _value9)
915
916 #define EFX_POPULATE_QWORD_8(_qword, \
917 _field1, _value1, _field2, _value2, _field3, _value3, \
918 _field4, _value4, _field5, _value5, _field6, _value6, \
919 _field7, _value7, _field8, _value8) \
920 EFX_POPULATE_QWORD_9(_qword, EFX_DUMMY_FIELD, 0, \
921 _field1, _value1, _field2, _value2, _field3, _value3, \
922 _field4, _value4, _field5, _value5, _field6, _value6, \
923 _field7, _value7, _field8, _value8)
924
925 #define EFX_POPULATE_QWORD_7(_qword, \
926 _field1, _value1, _field2, _value2, _field3, _value3, \
927 _field4, _value4, _field5, _value5, _field6, _value6, \
928 _field7, _value7) \
929 EFX_POPULATE_QWORD_8(_qword, EFX_DUMMY_FIELD, 0, \
930 _field1, _value1, _field2, _value2, _field3, _value3, \
931 _field4, _value4, _field5, _value5, _field6, _value6, \
932 _field7, _value7)
933
934 #define EFX_POPULATE_QWORD_6(_qword, \
935 _field1, _value1, _field2, _value2, _field3, _value3, \
936 _field4, _value4, _field5, _value5, _field6, _value6) \
937 EFX_POPULATE_QWORD_7(_qword, EFX_DUMMY_FIELD, 0, \
938 _field1, _value1, _field2, _value2, _field3, _value3, \
939 _field4, _value4, _field5, _value5, _field6, _value6)
940
941 #define EFX_POPULATE_QWORD_5(_qword, \
942 _field1, _value1, _field2, _value2, _field3, _value3, \
943 _field4, _value4, _field5, _value5) \
944 EFX_POPULATE_QWORD_6(_qword, EFX_DUMMY_FIELD, 0, \
945 _field1, _value1, _field2, _value2, _field3, _value3, \
946 _field4, _value4, _field5, _value5)
947
948 #define EFX_POPULATE_QWORD_4(_qword, \
949 _field1, _value1, _field2, _value2, _field3, _value3, \
950 _field4, _value4) \
951 EFX_POPULATE_QWORD_5(_qword, EFX_DUMMY_FIELD, 0, \
952 _field1, _value1, _field2, _value2, _field3, _value3, \
953 _field4, _value4)
954
955 #define EFX_POPULATE_QWORD_3(_qword, \
956 _field1, _value1, _field2, _value2, _field3, _value3) \
957 EFX_POPULATE_QWORD_4(_qword, EFX_DUMMY_FIELD, 0, \
958 _field1, _value1, _field2, _value2, _field3, _value3)
959
960 #define EFX_POPULATE_QWORD_2(_qword, \
961 _field1, _value1, _field2, _value2) \
962 EFX_POPULATE_QWORD_3(_qword, EFX_DUMMY_FIELD, 0, \
963 _field1, _value1, _field2, _value2)
964
965 #define EFX_POPULATE_QWORD_1(_qword, \
966 _field1, _value1) \
967 EFX_POPULATE_QWORD_2(_qword, EFX_DUMMY_FIELD, 0, \
968 _field1, _value1)
969
970 #define EFX_ZERO_QWORD(_qword) \
971 EFX_POPULATE_QWORD_1(_qword, EFX_DUMMY_FIELD, 0)
972
973 #define EFX_SET_QWORD(_qword) \
974 EFX_POPULATE_QWORD_2(_qword, \
975 EFX_DWORD_0, 0xffffffff, EFX_DWORD_1, 0xffffffff)
976
977 /* Populate a dword field with various numbers of arguments */
978 #define EFX_POPULATE_DWORD_10 EFX_POPULATE_DWORD
979
980 #define EFX_POPULATE_DWORD_9(_dword, \
981 _field1, _value1, _field2, _value2, _field3, _value3, \
982 _field4, _value4, _field5, _value5, _field6, _value6, \
983 _field7, _value7, _field8, _value8, _field9, _value9) \
984 EFX_POPULATE_DWORD_10(_dword, EFX_DUMMY_FIELD, 0, \
985 _field1, _value1, _field2, _value2, _field3, _value3, \
986 _field4, _value4, _field5, _value5, _field6, _value6, \
987 _field7, _value7, _field8, _value8, _field9, _value9)
988
989 #define EFX_POPULATE_DWORD_8(_dword, \
990 _field1, _value1, _field2, _value2, _field3, _value3, \
991 _field4, _value4, _field5, _value5, _field6, _value6, \
992 _field7, _value7, _field8, _value8) \
993 EFX_POPULATE_DWORD_9(_dword, EFX_DUMMY_FIELD, 0, \
994 _field1, _value1, _field2, _value2, _field3, _value3, \
995 _field4, _value4, _field5, _value5, _field6, _value6, \
996 _field7, _value7, _field8, _value8)
997
998 #define EFX_POPULATE_DWORD_7(_dword, \
999 _field1, _value1, _field2, _value2, _field3, _value3, \
1000 _field4, _value4, _field5, _value5, _field6, _value6, \
1001 _field7, _value7) \
1002 EFX_POPULATE_DWORD_8(_dword, EFX_DUMMY_FIELD, 0, \
1003 _field1, _value1, _field2, _value2, _field3, _value3, \
1004 _field4, _value4, _field5, _value5, _field6, _value6, \
1005 _field7, _value7)
1006
1007 #define EFX_POPULATE_DWORD_6(_dword, \
1008 _field1, _value1, _field2, _value2, _field3, _value3, \
1009 _field4, _value4, _field5, _value5, _field6, _value6) \
1010 EFX_POPULATE_DWORD_7(_dword, EFX_DUMMY_FIELD, 0, \
1011 _field1, _value1, _field2, _value2, _field3, _value3, \
1012 _field4, _value4, _field5, _value5, _field6, _value6)
1013
1014 #define EFX_POPULATE_DWORD_5(_dword, \
1015 _field1, _value1, _field2, _value2, _field3, _value3, \
1016 _field4, _value4, _field5, _value5) \
1017 EFX_POPULATE_DWORD_6(_dword, EFX_DUMMY_FIELD, 0, \
1018 _field1, _value1, _field2, _value2, _field3, _value3, \
1019 _field4, _value4, _field5, _value5)
1020
1021 #define EFX_POPULATE_DWORD_4(_dword, \
1022 _field1, _value1, _field2, _value2, _field3, _value3, \
1023 _field4, _value4) \
1024 EFX_POPULATE_DWORD_5(_dword, EFX_DUMMY_FIELD, 0, \
1025 _field1, _value1, _field2, _value2, _field3, _value3, \
1026 _field4, _value4)
1027
1028 #define EFX_POPULATE_DWORD_3(_dword, \
1029 _field1, _value1, _field2, _value2, _field3, _value3) \
1030 EFX_POPULATE_DWORD_4(_dword, EFX_DUMMY_FIELD, 0, \
1031 _field1, _value1, _field2, _value2, _field3, _value3)
1032
1033 #define EFX_POPULATE_DWORD_2(_dword, \
1034 _field1, _value1, _field2, _value2) \
1035 EFX_POPULATE_DWORD_3(_dword, EFX_DUMMY_FIELD, 0, \
1036 _field1, _value1, _field2, _value2)
1037
1038 #define EFX_POPULATE_DWORD_1(_dword, \
1039 _field1, _value1) \
1040 EFX_POPULATE_DWORD_2(_dword, EFX_DUMMY_FIELD, 0, \
1041 _field1, _value1)
1042
1043 #define EFX_ZERO_DWORD(_dword) \
1044 EFX_POPULATE_DWORD_1(_dword, EFX_DUMMY_FIELD, 0)
1045
1046 #define EFX_SET_DWORD(_dword) \
1047 EFX_POPULATE_DWORD_1(_dword, \
1048 EFX_DWORD_0, 0xffffffff)
1049
1050 /* Populate a word field with various numbers of arguments */
1051 #define EFX_POPULATE_WORD_10 EFX_POPULATE_WORD
1052
1053 #define EFX_POPULATE_WORD_9(_word, \
1054 _field1, _value1, _field2, _value2, _field3, _value3, \
1055 _field4, _value4, _field5, _value5, _field6, _value6, \
1056 _field7, _value7, _field8, _value8, _field9, _value9) \
1057 EFX_POPULATE_WORD_10(_word, EFX_DUMMY_FIELD, 0, \
1058 _field1, _value1, _field2, _value2, _field3, _value3, \
1059 _field4, _value4, _field5, _value5, _field6, _value6, \
1060 _field7, _value7, _field8, _value8, _field9, _value9)
1061
1062 #define EFX_POPULATE_WORD_8(_word, \
1063 _field1, _value1, _field2, _value2, _field3, _value3, \
1064 _field4, _value4, _field5, _value5, _field6, _value6, \
1065 _field7, _value7, _field8, _value8) \
1066 EFX_POPULATE_WORD_9(_word, EFX_DUMMY_FIELD, 0, \
1067 _field1, _value1, _field2, _value2, _field3, _value3, \
1068 _field4, _value4, _field5, _value5, _field6, _value6, \
1069 _field7, _value7, _field8, _value8)
1070
1071 #define EFX_POPULATE_WORD_7(_word, \
1072 _field1, _value1, _field2, _value2, _field3, _value3, \
1073 _field4, _value4, _field5, _value5, _field6, _value6, \
1074 _field7, _value7) \
1075 EFX_POPULATE_WORD_8(_word, EFX_DUMMY_FIELD, 0, \
1076 _field1, _value1, _field2, _value2, _field3, _value3, \
1077 _field4, _value4, _field5, _value5, _field6, _value6, \
1078 _field7, _value7)
1079
1080 #define EFX_POPULATE_WORD_6(_word, \
1081 _field1, _value1, _field2, _value2, _field3, _value3, \
1082 _field4, _value4, _field5, _value5, _field6, _value6) \
1083 EFX_POPULATE_WORD_7(_word, EFX_DUMMY_FIELD, 0, \
1084 _field1, _value1, _field2, _value2, _field3, _value3, \
1085 _field4, _value4, _field5, _value5, _field6, _value6)
1086
1087 #define EFX_POPULATE_WORD_5(_word, \
1088 _field1, _value1, _field2, _value2, _field3, _value3, \
1089 _field4, _value4, _field5, _value5) \
1090 EFX_POPULATE_WORD_6(_word, EFX_DUMMY_FIELD, 0, \
1091 _field1, _value1, _field2, _value2, _field3, _value3, \
1092 _field4, _value4, _field5, _value5)
1093
1094 #define EFX_POPULATE_WORD_4(_word, \
1095 _field1, _value1, _field2, _value2, _field3, _value3, \
1096 _field4, _value4) \
1097 EFX_POPULATE_WORD_5(_word, EFX_DUMMY_FIELD, 0, \
1098 _field1, _value1, _field2, _value2, _field3, _value3, \
1099 _field4, _value4)
1100
1101 #define EFX_POPULATE_WORD_3(_word, \
1102 _field1, _value1, _field2, _value2, _field3, _value3) \
1103 EFX_POPULATE_WORD_4(_word, EFX_DUMMY_FIELD, 0, \
1104 _field1, _value1, _field2, _value2, _field3, _value3)
1105
1106 #define EFX_POPULATE_WORD_2(_word, \
1107 _field1, _value1, _field2, _value2) \
1108 EFX_POPULATE_WORD_3(_word, EFX_DUMMY_FIELD, 0, \
1109 _field1, _value1, _field2, _value2)
1110
1111 #define EFX_POPULATE_WORD_1(_word, \
1112 _field1, _value1) \
1113 EFX_POPULATE_WORD_2(_word, EFX_DUMMY_FIELD, 0, \
1114 _field1, _value1)
1115
1116 #define EFX_ZERO_WORD(_word) \
1117 EFX_POPULATE_WORD_1(_word, EFX_DUMMY_FIELD, 0)
1118
1119 #define EFX_SET_WORD(_word) \
1120 EFX_POPULATE_WORD_1(_word, \
1121 EFX_WORD_0, 0xffff)
1122
1123 /* Populate a byte field with various numbers of arguments */
1124 #define EFX_POPULATE_BYTE_10 EFX_POPULATE_BYTE
1125
1126 #define EFX_POPULATE_BYTE_9(_byte, \
1127 _field1, _value1, _field2, _value2, _field3, _value3, \
1128 _field4, _value4, _field5, _value5, _field6, _value6, \
1129 _field7, _value7, _field8, _value8, _field9, _value9) \
1130 EFX_POPULATE_BYTE_10(_byte, EFX_DUMMY_FIELD, 0, \
1131 _field1, _value1, _field2, _value2, _field3, _value3, \
1132 _field4, _value4, _field5, _value5, _field6, _value6, \
1133 _field7, _value7, _field8, _value8, _field9, _value9)
1134
1135 #define EFX_POPULATE_BYTE_8(_byte, \
1136 _field1, _value1, _field2, _value2, _field3, _value3, \
1137 _field4, _value4, _field5, _value5, _field6, _value6, \
1138 _field7, _value7, _field8, _value8) \
1139 EFX_POPULATE_BYTE_9(_byte, EFX_DUMMY_FIELD, 0, \
1140 _field1, _value1, _field2, _value2, _field3, _value3, \
1141 _field4, _value4, _field5, _value5, _field6, _value6, \
1142 _field7, _value7, _field8, _value8)
1143
1144 #define EFX_POPULATE_BYTE_7(_byte, \
1145 _field1, _value1, _field2, _value2, _field3, _value3, \
1146 _field4, _value4, _field5, _value5, _field6, _value6, \
1147 _field7, _value7) \
1148 EFX_POPULATE_BYTE_8(_byte, EFX_DUMMY_FIELD, 0, \
1149 _field1, _value1, _field2, _value2, _field3, _value3, \
1150 _field4, _value4, _field5, _value5, _field6, _value6, \
1151 _field7, _value7)
1152
1153 #define EFX_POPULATE_BYTE_6(_byte, \
1154 _field1, _value1, _field2, _value2, _field3, _value3, \
1155 _field4, _value4, _field5, _value5, _field6, _value6) \
1156 EFX_POPULATE_BYTE_7(_byte, EFX_DUMMY_FIELD, 0, \
1157 _field1, _value1, _field2, _value2, _field3, _value3, \
1158 _field4, _value4, _field5, _value5, _field6, _value6)
1159
1160 #define EFX_POPULATE_BYTE_5(_byte, \
1161 _field1, _value1, _field2, _value2, _field3, _value3, \
1162 _field4, _value4, _field5, _value5) \
1163 EFX_POPULATE_BYTE_6(_byte, EFX_DUMMY_FIELD, 0, \
1164 _field1, _value1, _field2, _value2, _field3, _value3, \
1165 _field4, _value4, _field5, _value5)
1166
1167 #define EFX_POPULATE_BYTE_4(_byte, \
1168 _field1, _value1, _field2, _value2, _field3, _value3, \
1169 _field4, _value4) \
1170 EFX_POPULATE_BYTE_5(_byte, EFX_DUMMY_FIELD, 0, \
1171 _field1, _value1, _field2, _value2, _field3, _value3, \
1172 _field4, _value4)
1173
1174 #define EFX_POPULATE_BYTE_3(_byte, \
1175 _field1, _value1, _field2, _value2, _field3, _value3) \
1176 EFX_POPULATE_BYTE_4(_byte, EFX_DUMMY_FIELD, 0, \
1177 _field1, _value1, _field2, _value2, _field3, _value3)
1178
1179 #define EFX_POPULATE_BYTE_2(_byte, \
1180 _field1, _value1, _field2, _value2) \
1181 EFX_POPULATE_BYTE_3(_byte, EFX_DUMMY_FIELD, 0, \
1182 _field1, _value1, _field2, _value2)
1183
1184 #define EFX_POPULATE_BYTE_1(_byte, \
1185 _field1, _value1) \
1186 EFX_POPULATE_BYTE_2(_byte, EFX_DUMMY_FIELD, 0, \
1187 _field1, _value1)
1188
1189 #define EFX_ZERO_BYTE(_byte) \
1190 EFX_POPULATE_BYTE_1(_byte, EFX_DUMMY_FIELD, 0)
1191
1192 #define EFX_SET_BYTE(_byte) \
1193 EFX_POPULATE_BYTE_1(_byte, \
1194 EFX_BYTE_0, 0xff)
1195
1196 /*
1197 * Modify a named field within an already-populated structure. Used
1198 * for read-modify-write operations.
1199 */
1200
1201 #define EFX_INSERT_FIELD64(_min, _max, _field, _value) \
1202 __CPU_TO_LE_64(EFX_INSERT_FIELD_NATIVE64(_min, _max, _field, _value))
1203
1204 #define EFX_INSERT_FIELD32(_min, _max, _field, _value) \
1205 __CPU_TO_LE_32(EFX_INSERT_FIELD_NATIVE32(_min, _max, _field, _value))
1206
1207 #define EFX_INSERT_FIELD16(_min, _max, _field, _value) \
1208 __CPU_TO_LE_16(EFX_INSERT_FIELD_NATIVE16(_min, _max, _field, _value))
1209
1210 #define EFX_INSERT_FIELD8(_min, _max, _field, _value) \
1211 __NATIVE_8(EFX_INSERT_FIELD_NATIVE8(_min, _max, _field, _value))
1212
1213 #define EFX_INPLACE_MASK64(_min, _max, _field) \
1214 EFX_INSERT_FIELD64(_min, _max, _field, EFX_MASK64(_field))
1215
1216 #define EFX_INPLACE_MASK32(_min, _max, _field) \
1217 EFX_INSERT_FIELD32(_min, _max, _field, EFX_MASK32(_field))
1218
1219 #define EFX_INPLACE_MASK16(_min, _max, _field) \
1220 EFX_INSERT_FIELD16(_min, _max, _field, EFX_MASK16(_field))
1221
1222 #define EFX_INPLACE_MASK8(_min, _max, _field) \
1223 EFX_INSERT_FIELD8(_min, _max, _field, EFX_MASK8(_field))
1224
1225 #define EFX_SET_OWORD_FIELD64(_oword, _field, _value) \
1226 do { \
1227 _NOTE(CONSTANTCONDITION) \
1228 (_oword).eo_u64[0] = (((_oword).eo_u64[0] & \
1229 ~EFX_INPLACE_MASK64(0, 63, _field)) | \
1230 EFX_INSERT_FIELD64(0, 63, _field, _value)); \
1231 _NOTE(CONSTANTCONDITION) \
1232 (_oword).eo_u64[1] = (((_oword).eo_u64[1] & \
1233 ~EFX_INPLACE_MASK64(64, 127, _field)) | \
1234 EFX_INSERT_FIELD64(64, 127, _field, _value)); \
1235 _NOTE(CONSTANTCONDITION) \
1236 } while (B_FALSE)
1237
1238 #define EFX_SET_OWORD_FIELD32(_oword, _field, _value) \
1239 do { \
1240 _NOTE(CONSTANTCONDITION) \
1241 (_oword).eo_u32[0] = (((_oword).eo_u32[0] & \
1242 ~EFX_INPLACE_MASK32(0, 31, _field)) | \
1243 EFX_INSERT_FIELD32(0, 31, _field, _value)); \
1244 _NOTE(CONSTANTCONDITION) \
1245 (_oword).eo_u32[1] = (((_oword).eo_u32[1] & \
1246 ~EFX_INPLACE_MASK32(32, 63, _field)) | \
1247 EFX_INSERT_FIELD32(32, 63, _field, _value)); \
1248 _NOTE(CONSTANTCONDITION) \
1249 (_oword).eo_u32[2] = (((_oword).eo_u32[2] & \
1250 ~EFX_INPLACE_MASK32(64, 95, _field)) | \
1251 EFX_INSERT_FIELD32(64, 95, _field, _value)); \
1252 _NOTE(CONSTANTCONDITION) \
1253 (_oword).eo_u32[3] = (((_oword).eo_u32[3] & \
1254 ~EFX_INPLACE_MASK32(96, 127, _field)) | \
1255 EFX_INSERT_FIELD32(96, 127, _field, _value)); \
1256 _NOTE(CONSTANTCONDITION) \
1257 } while (B_FALSE)
1258
1259 #define EFX_SET_QWORD_FIELD64(_qword, _field, _value) \
1260 do { \
1261 _NOTE(CONSTANTCONDITION) \
1262 (_qword).eq_u64[0] = (((_qword).eq_u64[0] & \
1263 ~EFX_INPLACE_MASK64(0, 63, _field)) | \
1264 EFX_INSERT_FIELD64(0, 63, _field, _value)); \
1265 _NOTE(CONSTANTCONDITION) \
1266 } while (B_FALSE)
1267
1268 #define EFX_SET_QWORD_FIELD32(_qword, _field, _value) \
1269 do { \
1270 _NOTE(CONSTANTCONDITION) \
1271 (_qword).eq_u32[0] = (((_qword).eq_u32[0] & \
1272 ~EFX_INPLACE_MASK32(0, 31, _field)) | \
1273 EFX_INSERT_FIELD32(0, 31, _field, _value)); \
1274 _NOTE(CONSTANTCONDITION) \
1275 (_qword).eq_u32[1] = (((_qword).eq_u32[1] & \
1276 ~EFX_INPLACE_MASK32(32, 63, _field)) | \
1277 EFX_INSERT_FIELD32(32, 63, _field, _value)); \
1278 _NOTE(CONSTANTCONDITION) \
1279 } while (B_FALSE)
1280
1281 #define EFX_SET_DWORD_FIELD(_dword, _field, _value) \
1282 do { \
1283 _NOTE(CONSTANTCONDITION) \
1284 (_dword).ed_u32[0] = (((_dword).ed_u32[0] & \
1285 ~EFX_INPLACE_MASK32(0, 31, _field)) | \
1286 EFX_INSERT_FIELD32(0, 31, _field, _value)); \
1287 _NOTE(CONSTANTCONDITION) \
1288 } while (B_FALSE)
1289
1290 #define EFX_SET_WORD_FIELD(_word, _field, _value) \
1291 do { \
1292 _NOTE(CONSTANTCONDITION) \
1293 (_word).ew_u16[0] = (((_word).ew_u16[0] & \
1294 ~EFX_INPLACE_MASK16(0, 15, _field)) | \
1295 EFX_INSERT_FIELD16(0, 15, _field, _value)); \
1296 _NOTE(CONSTANTCONDITION) \
1297 } while (B_FALSE)
1298
1299 #define EFX_SET_BYTE_FIELD(_byte, _field, _value) \
1300 do { \
1301 _NOTE(CONSTANTCONDITION) \
1302 (_byte).eb_u8[0] = (((_byte).eb_u8[0] & \
1303 ~EFX_INPLACE_MASK8(0, 7, _field)) | \
1304 EFX_INSERT_FIELD8(0, 7, _field, _value)); \
1305 _NOTE(CONSTANTCONDITION) \
1306 } while (B_FALSE)
1307
1308 /*
1309 * Set or clear a numbered bit within an octword.
1310 */
1311
1312 #define EFX_SHIFT64_0(_bit) \
1313 (((_bit) < 64) ? ((uint64_t)1 << (_bit)) : 0U)
1314
1315 #define EFX_SHIFT64(_bit, _base) \
1316 (((_bit) >= (_base) && (_bit) < (_base) + 64) ? \
1317 ((uint64_t)1 << ((_bit) - (_base))) : \
1318 0U)
1319
1320 #define EFX_SHIFT32_0(_bit) \
1321 ((_bit) < (32) ? ((uint32_t)1 << (_bit)) : 0U)
1322
1323 #define EFX_SHIFT32(_bit, _base) \
1324 (((_bit) >= (_base) && (_bit) < (_base) + 32) ? \
1325 ((uint32_t)1 << ((_bit) - (_base))) : \
1326 0U)
1327
1328 #define EFX_SHIFT16(_bit, _base) \
1329 (((_bit) >= (_base) && (_bit) < (_base) + 16) ? \
1330 (uint16_t)(1 << ((_bit) - (_base))) : \
1331 0U)
1332
1333 #define EFX_SHIFT8(_bit, _base) \
1334 (((_bit) >= (_base) && (_bit) < (_base) + 8) ? \
1335 (uint8_t)(1 << ((_bit) - (_base))) : \
1336 0U)
1337
1338 #define EFX_SET_OWORD_BIT64(_oword, _bit) \
1339 do { \
1340 _NOTE(CONSTANTCONDITION) \
1341 (_oword).eo_u64[0] |= \
1342 __CPU_TO_LE_64(EFX_SHIFT64_0(_bit)); \
1343 (_oword).eo_u64[1] |= \
1344 __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64))); \
1345 _NOTE(CONSTANTCONDITION) \
1346 } while (B_FALSE)
1347
1348 #define EFX_SET_OWORD_BIT32(_oword, _bit) \
1349 do { \
1350 _NOTE(CONSTANTCONDITION) \
1351 (_oword).eo_u32[0] |= \
1352 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit)); \
1353 (_oword).eo_u32[1] |= \
1354 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32))); \
1355 (_oword).eo_u32[2] |= \
1356 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64))); \
1357 (_oword).eo_u32[3] |= \
1358 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96))); \
1359 _NOTE(CONSTANTCONDITION) \
1360 } while (B_FALSE)
1361
1362 #define EFX_CLEAR_OWORD_BIT64(_oword, _bit) \
1363 do { \
1364 _NOTE(CONSTANTCONDITION) \
1365 (_oword).eo_u64[0] &= \
1366 __CPU_TO_LE_64(~EFX_SHIFT64_0(_bit)); \
1367 (_oword).eo_u64[1] &= \
1368 __CPU_TO_LE_64(~EFX_SHIFT64(_bit, FIX_LINT(64))); \
1369 _NOTE(CONSTANTCONDITION) \
1370 } while (B_FALSE)
1371
1372 #define EFX_CLEAR_OWORD_BIT32(_oword, _bit) \
1373 do { \
1374 _NOTE(CONSTANTCONDITION) \
1375 (_oword).eo_u32[0] &= \
1376 __CPU_TO_LE_32(~EFX_SHIFT32_0(_bit)); \
1377 (_oword).eo_u32[1] &= \
1378 __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(32))); \
1379 (_oword).eo_u32[2] &= \
1380 __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(64))); \
1381 (_oword).eo_u32[3] &= \
1382 __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(96))); \
1383 _NOTE(CONSTANTCONDITION) \
1384 } while (B_FALSE)
1385
1386 #define EFX_TEST_OWORD_BIT64(_oword, _bit) \
1387 (((_oword).eo_u64[0] & \
1388 __CPU_TO_LE_64(EFX_SHIFT64_0(_bit))) || \
1389 ((_oword).eo_u64[1] & \
1390 __CPU_TO_LE_64(EFX_SHIFT64(_bit, FIX_LINT(64)))))
1391
1392 #define EFX_TEST_OWORD_BIT32(_oword, _bit) \
1393 (((_oword).eo_u32[0] & \
1394 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit))) || \
1395 ((_oword).eo_u32[1] & \
1396 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)))) || \
1397 ((_oword).eo_u32[2] & \
1398 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(64)))) || \
1399 ((_oword).eo_u32[3] & \
1400 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(96)))))
1401
1402
1403 #define EFX_SET_QWORD_BIT64(_qword, _bit) \
1404 do { \
1405 _NOTE(CONSTANTCONDITION) \
1406 (_qword).eq_u64[0] |= \
1407 __CPU_TO_LE_64(EFX_SHIFT64_0(_bit)); \
1408 _NOTE(CONSTANTCONDITION) \
1409 } while (B_FALSE)
1410
1411 #define EFX_SET_QWORD_BIT32(_qword, _bit) \
1412 do { \
1413 _NOTE(CONSTANTCONDITION) \
1414 (_qword).eq_u32[0] |= \
1415 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit)); \
1416 (_qword).eq_u32[1] |= \
1417 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32))); \
1418 _NOTE(CONSTANTCONDITION) \
1419 } while (B_FALSE)
1420
1421 #define EFX_CLEAR_QWORD_BIT64(_qword, _bit) \
1422 do { \
1423 _NOTE(CONSTANTCONDITION) \
1424 (_qword).eq_u64[0] &= \
1425 __CPU_TO_LE_64(~EFX_SHIFT64_0(_bit)); \
1426 _NOTE(CONSTANTCONDITION) \
1427 } while (B_FALSE)
1428
1429 #define EFX_CLEAR_QWORD_BIT32(_qword, _bit) \
1430 do { \
1431 _NOTE(CONSTANTCONDITION) \
1432 (_qword).eq_u32[0] &= \
1433 __CPU_TO_LE_32(~EFX_SHIFT32_0(_bit)); \
1434 (_qword).eq_u32[1] &= \
1435 __CPU_TO_LE_32(~EFX_SHIFT32(_bit, FIX_LINT(32))); \
1436 _NOTE(CONSTANTCONDITION) \
1437 } while (B_FALSE)
1438
1439 #define EFX_TEST_QWORD_BIT64(_qword, _bit) \
1440 (((_qword).eq_u64[0] & \
1441 __CPU_TO_LE_64(EFX_SHIFT64_0(_bit))) != 0)
1442
1443 #define EFX_TEST_QWORD_BIT32(_qword, _bit) \
1444 (((_qword).eq_u32[0] & \
1445 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit))) || \
1446 ((_qword).eq_u32[1] & \
1447 __CPU_TO_LE_32(EFX_SHIFT32(_bit, FIX_LINT(32)))))
1448
1449
1450 #define EFX_SET_DWORD_BIT(_dword, _bit) \
1451 do { \
1452 (_dword).ed_u32[0] |= \
1453 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit)); \
1454 _NOTE(CONSTANTCONDITION) \
1455 } while (B_FALSE)
1456
1457 #define EFX_CLEAR_DWORD_BIT(_dword, _bit) \
1458 do { \
1459 (_dword).ed_u32[0] &= \
1460 __CPU_TO_LE_32(~EFX_SHIFT32_0(_bit)); \
1461 _NOTE(CONSTANTCONDITION) \
1462 } while (B_FALSE)
1463
1464 #define EFX_TEST_DWORD_BIT(_dword, _bit) \
1465 (((_dword).ed_u32[0] & \
1466 __CPU_TO_LE_32(EFX_SHIFT32_0(_bit))) != 0)
1467
1468
1469 #define EFX_SET_WORD_BIT(_word, _bit) \
1470 do { \
1471 (_word).ew_u16[0] |= \
1472 __CPU_TO_LE_16(EFX_SHIFT16(_bit, FIX_LINT(0))); \
1473 _NOTE(CONSTANTCONDITION) \
1474 } while (B_FALSE)
1475
1476 #define EFX_CLEAR_WORD_BIT(_word, _bit) \
1477 do { \
1478 (_word).ew_u32[0] &= \
1479 __CPU_TO_LE_16(~EFX_SHIFT16(_bit, FIX_LINT(0))); \
1480 _NOTE(CONSTANTCONDITION) \
1481 } while (B_FALSE)
1482
1483 #define EFX_TEST_WORD_BIT(_word, _bit) \
1484 (((_word).ew_u16[0] & \
1485 __CPU_TO_LE_16(EFX_SHIFT16(_bit, FIX_LINT(0)))) != 0)
1486
1487
1488 #define EFX_SET_BYTE_BIT(_byte, _bit) \
1489 do { \
1490 (_byte).eb_u8[0] |= \
1491 __NATIVE_8(EFX_SHIFT8(_bit, FIX_LINT(0))); \
1492 _NOTE(CONSTANTCONDITION) \
1493 } while (B_FALSE)
1494
1495 #define EFX_CLEAR_BYTE_BIT(_byte, _bit) \
1496 do { \
1497 (_byte).eb_u8[0] &= \
1498 __NATIVE_8(~EFX_SHIFT8(_bit, FIX_LINT(0))); \
1499 _NOTE(CONSTANTCONDITION) \
1500 } while (B_FALSE)
1501
1502 #define EFX_TEST_BYTE_BIT(_byte, _bit) \
1503 (((_byte).eb_u8[0] & \
1504 __NATIVE_8(EFX_SHIFT8(_bit, FIX_LINT(0)))) != 0)
1505
1506
1507 #define EFX_OR_OWORD64(_oword1, _oword2) \
1508 do { \
1509 (_oword1).eo_u64[0] |= (_oword2).eo_u64[0]; \
1510 (_oword1).eo_u64[1] |= (_oword2).eo_u64[1]; \
1511 _NOTE(CONSTANTCONDITION) \
1512 } while (B_FALSE)
1513
1514 #define EFX_OR_OWORD32(_oword1, _oword2) \
1515 do { \
1516 (_oword1).eo_u32[0] |= (_oword2).eo_u32[0]; \
1517 (_oword1).eo_u32[1] |= (_oword2).eo_u32[1]; \
1518 (_oword1).eo_u32[2] |= (_oword2).eo_u32[2]; \
1519 (_oword1).eo_u32[3] |= (_oword2).eo_u32[3]; \
1520 _NOTE(CONSTANTCONDITION) \
1521 } while (B_FALSE)
1522
1523 #define EFX_AND_OWORD64(_oword1, _oword2) \
1524 do { \
1525 (_oword1).eo_u64[0] &= (_oword2).eo_u64[0]; \
1526 (_oword1).eo_u64[1] &= (_oword2).eo_u64[1]; \
1527 _NOTE(CONSTANTCONDITION) \
1528 } while (B_FALSE)
1529
1530 #define EFX_AND_OWORD32(_oword1, _oword2) \
1531 do { \
1532 (_oword1).eo_u32[0] &= (_oword2).eo_u32[0]; \
1533 (_oword1).eo_u32[1] &= (_oword2).eo_u32[1]; \
1534 (_oword1).eo_u32[2] &= (_oword2).eo_u32[2]; \
1535 (_oword1).eo_u32[3] &= (_oword2).eo_u32[3]; \
1536 _NOTE(CONSTANTCONDITION) \
1537 } while (B_FALSE)
1538
1539 #define EFX_OR_QWORD64(_qword1, _qword2) \
1540 do { \
1541 (_qword1).eq_u64[0] |= (_qword2).eq_u64[0]; \
1542 _NOTE(CONSTANTCONDITION) \
1543 } while (B_FALSE)
1544
1545 #define EFX_OR_QWORD32(_qword1, _qword2) \
1546 do { \
1547 (_qword1).eq_u32[0] |= (_qword2).eq_u32[0]; \
1548 (_qword1).eq_u32[1] |= (_qword2).eq_u32[1]; \
1549 _NOTE(CONSTANTCONDITION) \
1550 } while (B_FALSE)
1551
1552 #define EFX_AND_QWORD64(_qword1, _qword2) \
1553 do { \
1554 (_qword1).eq_u64[0] &= (_qword2).eq_u64[0]; \
1555 _NOTE(CONSTANTCONDITION) \
1556 } while (B_FALSE)
1557
1558 #define EFX_AND_QWORD32(_qword1, _qword2) \
1559 do { \
1560 (_qword1).eq_u32[0] &= (_qword2).eq_u32[0]; \
1561 (_qword1).eq_u32[1] &= (_qword2).eq_u32[1]; \
1562 _NOTE(CONSTANTCONDITION) \
1563 } while (B_FALSE)
1564
1565 #define EFX_OR_DWORD(_dword1, _dword2) \
1566 do { \
1567 (_dword1).ed_u32[0] |= (_dword2).ed_u32[0]; \
1568 _NOTE(CONSTANTCONDITION) \
1569 } while (B_FALSE)
1570
1571 #define EFX_AND_DWORD(_dword1, _dword2) \
1572 do { \
1573 (_dword1).ed_u32[0] &= (_dword2).ed_u32[0]; \
1574 _NOTE(CONSTANTCONDITION) \
1575 } while (B_FALSE)
1576
1577 #define EFX_OR_WORD(_word1, _word2) \
1578 do { \
1579 (_word1).ew_u16[0] |= (_word2).ew_u16[0]; \
1580 _NOTE(CONSTANTCONDITION) \
1581 } while (B_FALSE)
1582
1583 #define EFX_AND_WORD(_word1, _word2) \
1584 do { \
1585 (_word1).ew_u16[0] &= (_word2).ew_u16[0]; \
1586 _NOTE(CONSTANTCONDITION) \
1587 } while (B_FALSE)
1588
1589 #define EFX_OR_BYTE(_byte1, _byte2) \
1590 do { \
1591 (_byte1).eb_u8[0] |= (_byte2).eb_u8[0]; \
1592 _NOTE(CONSTANTCONDITION) \
1593 } while (B_FALSE)
1594
1595 #define EFX_AND_BYTE(_byte1, _byte2) \
1596 do { \
1597 (_byte1).eb_u8[0] &= (_byte2).eb_u8[0]; \
1598 _NOTE(CONSTANTCONDITION) \
1599 } while (B_FALSE)
1600
1601 #if EFSYS_USE_UINT64
1602 #define EFX_OWORD_FIELD EFX_OWORD_FIELD64
1603 #define EFX_QWORD_FIELD EFX_QWORD_FIELD64
1604 #define EFX_OWORD_IS_EQUAL EFX_OWORD_IS_EQUAL64
1605 #define EFX_QWORD_IS_EQUAL EFX_QWORD_IS_EQUAL64
1606 #define EFX_OWORD_IS_ZERO EFX_OWORD_IS_ZERO64
1607 #define EFX_QWORD_IS_ZERO EFX_QWORD_IS_ZERO64
1608 #define EFX_OWORD_IS_SET EFX_OWORD_IS_SET64
1609 #define EFX_QWORD_IS_SET EFX_QWORD_IS_SET64
1610 #define EFX_POPULATE_OWORD EFX_POPULATE_OWORD64
1611 #define EFX_POPULATE_QWORD EFX_POPULATE_QWORD64
1612 #define EFX_SET_OWORD_FIELD EFX_SET_OWORD_FIELD64
1613 #define EFX_SET_QWORD_FIELD EFX_SET_QWORD_FIELD64
1614 #define EFX_SET_OWORD_BIT EFX_SET_OWORD_BIT64
1615 #define EFX_CLEAR_OWORD_BIT EFX_CLEAR_OWORD_BIT64
1616 #define EFX_TEST_OWORD_BIT EFX_TEST_OWORD_BIT64
1617 #define EFX_SET_QWORD_BIT EFX_SET_QWORD_BIT64
1618 #define EFX_CLEAR_QWORD_BIT EFX_CLEAR_QWORD_BIT64
1619 #define EFX_TEST_QWORD_BIT EFX_TEST_QWORD_BIT64
1620 #define EFX_OR_OWORD EFX_OR_OWORD64
1621 #define EFX_AND_OWORD EFX_AND_OWORD64
1622 #define EFX_OR_QWORD EFX_OR_QWORD64
1623 #define EFX_AND_QWORD EFX_AND_QWORD64
1624 #else
1625 #define EFX_OWORD_FIELD EFX_OWORD_FIELD32
1626 #define EFX_QWORD_FIELD EFX_QWORD_FIELD32
1627 #define EFX_OWORD_IS_EQUAL EFX_OWORD_IS_EQUAL32
1628 #define EFX_QWORD_IS_EQUAL EFX_QWORD_IS_EQUAL32
1629 #define EFX_OWORD_IS_ZERO EFX_OWORD_IS_ZERO32
1630 #define EFX_QWORD_IS_ZERO EFX_QWORD_IS_ZERO32
1631 #define EFX_OWORD_IS_SET EFX_OWORD_IS_SET32
1632 #define EFX_QWORD_IS_SET EFX_QWORD_IS_SET32
1633 #define EFX_POPULATE_OWORD EFX_POPULATE_OWORD32
1634 #define EFX_POPULATE_QWORD EFX_POPULATE_QWORD32
1635 #define EFX_SET_OWORD_FIELD EFX_SET_OWORD_FIELD32
1636 #define EFX_SET_QWORD_FIELD EFX_SET_QWORD_FIELD32
1637 #define EFX_SET_OWORD_BIT EFX_SET_OWORD_BIT32
1638 #define EFX_CLEAR_OWORD_BIT EFX_CLEAR_OWORD_BIT32
1639 #define EFX_TEST_OWORD_BIT EFX_TEST_OWORD_BIT32
1640 #define EFX_SET_QWORD_BIT EFX_SET_QWORD_BIT32
1641 #define EFX_CLEAR_QWORD_BIT EFX_CLEAR_QWORD_BIT32
1642 #define EFX_TEST_QWORD_BIT EFX_TEST_QWORD_BIT32
1643 #define EFX_OR_OWORD EFX_OR_OWORD32
1644 #define EFX_AND_OWORD EFX_AND_OWORD32
1645 #define EFX_OR_QWORD EFX_OR_QWORD32
1646 #define EFX_AND_QWORD EFX_AND_QWORD32
1647 #endif
1648
1649 #ifdef __cplusplus
1650 }
1651 #endif
1652
1653 #endif /* _SYS_EFX_TYPES_H */