efx_types.h

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

FreeBSD/Linux Kernel Cross Reference
sys/dev/sfxge/common/efx_types.h
