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