Return to etherfabric.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net

Annotation of qemu/roms/ipxe/src/drivers/net/etherfabric.h, revision 1.1

1.1     ! root        1: /**************************************************************************
        !             2:  *
        !             3:  * GPL net driver for Level 5 Etherfabric network cards
        !             4:  *
        !             5:  * Written by Michael Brown <[email protected]>
        !             6:  *
        !             7:  * Copyright Fen Systems Ltd. 2005
        !             8:  * Copyright Level 5 Networks Inc. 2005
        !             9:  *
        !            10:  * This software may be used and distributed according to the terms of
        !            11:  * the GNU General Public License (GPL), incorporated herein by
        !            12:  * reference.  Drivers based on or derived from this code fall under
        !            13:  * the GPL and must retain the authorship, copyright and license
        !            14:  * notice.  This file is not a complete program and may only be used
        !            15:  * when the entire operating system is licensed under the GPL.
        !            16:  *
        !            17:  **************************************************************************
        !            18:  */
        !            19: 
        !            20: FILE_LICENCE ( GPL_ANY );
        !            21: 
        !            22: #ifndef EFAB_BITFIELD_H
        !            23: #define EFAB_BITFIELD_H
        !            24: 
        !            25: /** @file
        !            26:  *
        !            27:  * Etherfabric bitfield access
        !            28:  *
        !            29:  * Etherfabric NICs make extensive use of bitfields up to 128 bits
        !            30:  * wide.  Since there is no native 128-bit datatype on most systems,
        !            31:  * and since 64-bit datatypes are inefficient on 32-bit systems and
        !            32:  * vice versa, we wrap accesses in a way that uses the most efficient
        !            33:  * datatype.
        !            34:  *
        !            35:  * The NICs are PCI devices and therefore little-endian.  Since most
        !            36:  * of the quantities that we deal with are DMAed to/from host memory,
        !            37:  * we define our datatypes (efab_oword_t, efab_qword_t and
        !            38:  * efab_dword_t) to be little-endian.
        !            39:  *
        !            40:  * In the less common case of using PIO for individual register
        !            41:  * writes, we construct the little-endian datatype in host memory and
        !            42:  * then use non-swapping equivalents of writel/writeq, rather than
        !            43:  * constructing a native-endian datatype and relying on the implicit
        !            44:  * byte-swapping done by writel/writeq.  (We use a similar strategy
        !            45:  * for register reads.)
        !            46:  */
        !            47: 
        !            48: /** Dummy field low bit number */
        !            49: #define EFAB_DUMMY_FIELD_LBN 0
        !            50: /** Dummy field width */
        !            51: #define EFAB_DUMMY_FIELD_WIDTH 0
        !            52: /** Dword 0 low bit number */
        !            53: #define EFAB_DWORD_0_LBN 0
        !            54: /** Dword 0 width */
        !            55: #define EFAB_DWORD_0_WIDTH 32
        !            56: /** Dword 1 low bit number */
        !            57: #define EFAB_DWORD_1_LBN 32
        !            58: /** Dword 1 width */
        !            59: #define EFAB_DWORD_1_WIDTH 32
        !            60: /** Dword 2 low bit number */
        !            61: #define EFAB_DWORD_2_LBN 64
        !            62: /** Dword 2 width */
        !            63: #define EFAB_DWORD_2_WIDTH 32
        !            64: /** Dword 3 low bit number */
        !            65: #define EFAB_DWORD_3_LBN 96
        !            66: /** Dword 3 width */
        !            67: #define EFAB_DWORD_3_WIDTH 32
        !            68: 
        !            69: /** Specified attribute (e.g. LBN) of the specified field */
        !            70: #define EFAB_VAL(field,attribute) field ## _ ## attribute
        !            71: /** Low bit number of the specified field */
        !            72: #define EFAB_LOW_BIT( field ) EFAB_VAL ( field, LBN )
        !            73: /** Bit width of the specified field */
        !            74: #define EFAB_WIDTH( field ) EFAB_VAL ( field, WIDTH )
        !            75: /** High bit number of the specified field */
        !            76: #define EFAB_HIGH_BIT(field) ( EFAB_LOW_BIT(field) + EFAB_WIDTH(field) - 1 )
        !            77: /** Mask equal in width to the specified field.
        !            78:  *
        !            79:  * For example, a field with width 5 would have a mask of 0x1f.
        !            80:  *
        !            81:  * The maximum width mask that can be generated is 64 bits.
        !            82:  */
        !            83: #define EFAB_MASK64( field )                                           \
        !            84:        ( EFAB_WIDTH(field) == 64 ? ~( ( uint64_t ) 0 ) :               \
        !            85:          ( ( ( ( ( uint64_t ) 1 ) << EFAB_WIDTH(field) ) ) - 1 ) )
        !            86: 
        !            87: /** Mask equal in width to the specified field.
        !            88:  *
        !            89:  * For example, a field with width 5 would have a mask of 0x1f.
        !            90:  *
        !            91:  * The maximum width mask that can be generated is 32 bits.  Use
        !            92:  * EFAB_MASK64 for higher width fields.
        !            93:  */
        !            94: #define EFAB_MASK32( field )                                           \
        !            95:        ( EFAB_WIDTH(field) == 32 ? ~( ( uint32_t ) 0 ) :               \
        !            96:          ( ( ( ( ( uint32_t ) 1 ) << EFAB_WIDTH(field) ) ) - 1 ) )
        !            97: 
        !            98: /** A doubleword (i.e. 4 byte) datatype
        !            99:  *
        !           100:  * This datatype is defined to be little-endian.
        !           101:  */
        !           102: typedef union efab_dword {
        !           103:        uint32_t u32[1];
        !           104:        uint32_t opaque; /* For bitwise operations between two efab_dwords */
        !           105: } efab_dword_t;
        !           106: 
        !           107: /** A quadword (i.e. 8 byte) datatype
        !           108:  *
        !           109:  * This datatype is defined to be little-endian.
        !           110:  */
        !           111: typedef union efab_qword {
        !           112:        uint64_t u64[1];
        !           113:        uint32_t u32[2];
        !           114:        efab_dword_t dword[2];
        !           115: } efab_qword_t;
        !           116: 
        !           117: /**
        !           118:  * An octword (eight-word, i.e. 16 byte) datatype
        !           119:  *
        !           120:  * This datatype is defined to be little-endian.
        !           121:  */
        !           122: typedef union efab_oword {
        !           123:        uint64_t u64[2];
        !           124:        efab_qword_t qword[2];
        !           125:        uint32_t u32[4];
        !           126:        efab_dword_t dword[4];
        !           127: } efab_oword_t;
        !           128: 
        !           129: /** Format string for printing an efab_dword_t */
        !           130: #define EFAB_DWORD_FMT "%08x"
        !           131: 
        !           132: /** Format string for printing an efab_qword_t */
        !           133: #define EFAB_QWORD_FMT "%08x:%08x"
        !           134: 
        !           135: /** Format string for printing an efab_oword_t */
        !           136: #define EFAB_OWORD_FMT "%08x:%08x:%08x:%08x"
        !           137: 
        !           138: /** printk parameters for printing an efab_dword_t */
        !           139: #define EFAB_DWORD_VAL(dword)                                  \
        !           140:        ( ( unsigned int ) le32_to_cpu ( (dword).u32[0] ) )
        !           141: 
        !           142: /** printk parameters for printing an efab_qword_t */
        !           143: #define EFAB_QWORD_VAL(qword)                                  \
        !           144:        ( ( unsigned int ) le32_to_cpu ( (qword).u32[1] ) ),    \
        !           145:        ( ( unsigned int ) le32_to_cpu ( (qword).u32[0] ) )
        !           146: 
        !           147: /** printk parameters for printing an efab_oword_t */
        !           148: #define EFAB_OWORD_VAL(oword)                                  \
        !           149:        ( ( unsigned int ) le32_to_cpu ( (oword).u32[3] ) ),    \
        !           150:        ( ( unsigned int ) le32_to_cpu ( (oword).u32[2] ) ),    \
        !           151:        ( ( unsigned int ) le32_to_cpu ( (oword).u32[1] ) ),    \
        !           152:        ( ( unsigned int ) le32_to_cpu ( (oword).u32[0] ) )
        !           153: 
        !           154: /**
        !           155:  * Extract bit field portion [low,high) from the native-endian element
        !           156:  * which contains bits [min,max).
        !           157:  *
        !           158:  * For example, suppose "element" represents the high 32 bits of a
        !           159:  * 64-bit value, and we wish to extract the bits belonging to the bit
        !           160:  * field occupying bits 28-45 of this 64-bit value.
        !           161:  *
        !           162:  * Then EFAB_EXTRACT ( element, 32, 63, 28, 45 ) would give
        !           163:  *
        !           164:  *   ( element ) << 4
        !           165:  *
        !           166:  * The result will contain the relevant bits filled in in the range
        !           167:  * [0,high-low), with garbage in bits [high-low+1,...).
        !           168:  */
        !           169: #define EFAB_EXTRACT_NATIVE( native_element, min ,max ,low ,high )     \
        !           170:        ( ( ( low > max ) || ( high < min ) ) ? 0 :                     \
        !           171:          ( ( low > min ) ?                                             \
        !           172:            ( (native_element) >> ( low - min ) ) :                     \
        !           173:            ( (native_element) << ( min - low ) ) ) )
        !           174: 
        !           175: /**
        !           176:  * Extract bit field portion [low,high) from the 64-bit little-endian
        !           177:  * element which contains bits [min,max)
        !           178:  */
        !           179: #define EFAB_EXTRACT64( element, min, max, low, high )                 \
        !           180:        EFAB_EXTRACT_NATIVE ( le64_to_cpu(element), min, max, low, high )
        !           181: 
        !           182: /**
        !           183:  * Extract bit field portion [low,high) from the 32-bit little-endian
        !           184:  * element which contains bits [min,max)
        !           185:  */
        !           186: #define EFAB_EXTRACT32( element, min, max, low, high )                 \
        !           187:        EFAB_EXTRACT_NATIVE ( le32_to_cpu(element), min, max, low, high )
        !           188: 
        !           189: #define EFAB_EXTRACT_OWORD64( oword, low, high )                       \
        !           190:        ( EFAB_EXTRACT64 ( (oword).u64[0],   0,  63, low, high ) |      \
        !           191:          EFAB_EXTRACT64 ( (oword).u64[1],  64, 127, low, high ) )
        !           192: 
        !           193: #define EFAB_EXTRACT_QWORD64( qword, low, high )                       \
        !           194:        ( EFAB_EXTRACT64 ( (qword).u64[0],   0,  63, low, high ) )
        !           195: 
        !           196: #define EFAB_EXTRACT_OWORD32( oword, low, high )                       \
        !           197:        ( EFAB_EXTRACT32 ( (oword).u32[0],   0,  31, low, high ) |      \
        !           198:          EFAB_EXTRACT32 ( (oword).u32[1],  32,  63, low, high ) |      \
        !           199:          EFAB_EXTRACT32 ( (oword).u32[2],  64,  95, low, high ) |      \
        !           200:          EFAB_EXTRACT32 ( (oword).u32[3],  96, 127, low, high ) )
        !           201: 
        !           202: #define EFAB_EXTRACT_QWORD32( qword, low, high )                       \
        !           203:        ( EFAB_EXTRACT32 ( (qword).u32[0],   0,  31, low, high ) |      \
        !           204:          EFAB_EXTRACT32 ( (qword).u32[1],  32,  63, low, high ) )
        !           205: 
        !           206: #define EFAB_EXTRACT_DWORD( dword, low, high )                         \
        !           207:        ( EFAB_EXTRACT32 ( (dword).u32[0],   0,  31, low, high ) )
        !           208: 
        !           209: #define EFAB_OWORD_FIELD64( oword, field )                             \
        !           210:        ( EFAB_EXTRACT_OWORD64 ( oword, EFAB_LOW_BIT ( field ),         \
        !           211:                                 EFAB_HIGH_BIT ( field ) ) &            \
        !           212:          EFAB_MASK64 ( field ) )
        !           213: 
        !           214: #define EFAB_QWORD_FIELD64( qword, field )                             \
        !           215:        ( EFAB_EXTRACT_QWORD64 ( qword, EFAB_LOW_BIT ( field ),         \
        !           216:                                 EFAB_HIGH_BIT ( field ) ) &            \
        !           217:          EFAB_MASK64 ( field ) )
        !           218: 
        !           219: #define EFAB_OWORD_FIELD32( oword, field )                             \
        !           220:        ( EFAB_EXTRACT_OWORD32 ( oword, EFAB_LOW_BIT ( field ),         \
        !           221:                                 EFAB_HIGH_BIT ( field ) ) &            \
        !           222:          EFAB_MASK32 ( field ) )
        !           223: 
        !           224: #define EFAB_QWORD_FIELD32( qword, field )                             \
        !           225:        ( EFAB_EXTRACT_QWORD32 ( qword, EFAB_LOW_BIT ( field ),         \
        !           226:                                 EFAB_HIGH_BIT ( field ) ) &            \
        !           227:          EFAB_MASK32 ( field ) )
        !           228: 
        !           229: #define EFAB_DWORD_FIELD( dword, field )                               \
        !           230:        ( EFAB_EXTRACT_DWORD ( dword, EFAB_LOW_BIT ( field ),           \
        !           231:                               EFAB_HIGH_BIT ( field ) ) &              \
        !           232:          EFAB_MASK32 ( field ) )
        !           233: 
        !           234: #define EFAB_OWORD_IS_ZERO64( oword )                                  \
        !           235:        ( ! ( (oword).u64[0] || (oword).u64[1] ) )
        !           236: 
        !           237: #define EFAB_QWORD_IS_ZERO64( qword )                                  \
        !           238:        ( ! ( (qword).u64[0] ) )
        !           239: 
        !           240: #define EFAB_OWORD_IS_ZERO32( oword )                                  \
        !           241:        ( ! ( (oword).u32[0] || (oword).u32[1] ||                       \
        !           242:              (oword).u32[2] || (oword).u32[3] ) )
        !           243: 
        !           244: #define EFAB_QWORD_IS_ZERO32( qword )                                  \
        !           245:        ( ! ( (qword).u32[0] || (qword).u32[1] ) )
        !           246: 
        !           247: #define EFAB_DWORD_IS_ZERO( dword )                                    \
        !           248:        ( ! ( (dword).u32[0] ) )
        !           249: 
        !           250: #define EFAB_OWORD_IS_ALL_ONES64( oword )                              \
        !           251:        ( ( (oword).u64[0] & (oword).u64[1] ) == ~( ( uint64_t ) 0 ) )
        !           252: 
        !           253: #define EFAB_QWORD_IS_ALL_ONES64( qword )                              \
        !           254:        ( (qword).u64[0] == ~( ( uint64_t ) 0 ) )
        !           255: 
        !           256: #define EFAB_OWORD_IS_ALL_ONES32( oword )                              \
        !           257:        ( ( (oword).u32[0] & (oword).u32[1] &                           \
        !           258:            (oword).u32[2] & (oword).u32[3] ) == ~( ( uint32_t ) 0 ) )
        !           259: 
        !           260: #define EFAB_QWORD_IS_ALL_ONES32( qword )                              \
        !           261:        ( ( (qword).u32[0] & (qword).u32[1] ) == ~( ( uint32_t ) 0 ) )
        !           262: 
        !           263: #define EFAB_DWORD_IS_ALL_ONES( dword )                                        \
        !           264:        ( (dword).u32[0] == ~( ( uint32_t ) 0 ) )
        !           265: 
        !           266: #if ( BITS_PER_LONG == 64 )
        !           267: #define EFAB_OWORD_FIELD       EFAB_OWORD_FIELD64
        !           268: #define EFAB_QWORD_FIELD       EFAB_QWORD_FIELD64
        !           269: #define EFAB_OWORD_IS_ZERO     EFAB_OWORD_IS_ZERO64
        !           270: #define EFAB_QWORD_IS_ZERO     EFAB_QWORD_IS_ZERO64
        !           271: #define EFAB_OWORD_IS_ALL_ONES EFAB_OWORD_IS_ALL_ONES64
        !           272: #define EFAB_QWORD_IS_ALL_ONES EFAB_QWORD_IS_ALL_ONES64
        !           273: #else
        !           274: #define EFAB_OWORD_FIELD       EFAB_OWORD_FIELD32
        !           275: #define EFAB_QWORD_FIELD       EFAB_QWORD_FIELD32
        !           276: #define EFAB_OWORD_IS_ZERO     EFAB_OWORD_IS_ZERO32
        !           277: #define EFAB_QWORD_IS_ZERO     EFAB_QWORD_IS_ZERO32
        !           278: #define EFAB_OWORD_IS_ALL_ONES EFAB_OWORD_IS_ALL_ONES32
        !           279: #define EFAB_QWORD_IS_ALL_ONES EFAB_QWORD_IS_ALL_ONES32
        !           280: #endif
        !           281: 
        !           282: /**
        !           283:  * Construct bit field portion
        !           284:  *
        !           285:  * Creates the portion of the bit field [low,high) that lies within
        !           286:  * the range [min,max).
        !           287:  */
        !           288: #define EFAB_INSERT_NATIVE64( min, max, low, high, value )     \
        !           289:        ( ( ( low > max ) || ( high < min ) ) ? 0 :             \
        !           290:          ( ( low > min ) ?                                     \
        !           291:            ( ( ( uint64_t ) (value) ) << ( low - min ) ) :     \
        !           292:            ( ( ( uint64_t ) (value) ) >> ( min - low ) ) ) )
        !           293: 
        !           294: #define EFAB_INSERT_NATIVE32( min, max, low, high, value )     \
        !           295:        ( ( ( low > max ) || ( high < min ) ) ? 0 :             \
        !           296:          ( ( low > min ) ?                                     \
        !           297:            ( ( ( uint32_t ) (value) ) << ( low - min ) ) :     \
        !           298:            ( ( ( uint32_t ) (value) ) >> ( min - low ) ) ) )
        !           299: 
        !           300: #define EFAB_INSERT_NATIVE( min, max, low, high, value )       \
        !           301:        ( ( ( ( max - min ) >= 32 ) ||                          \
        !           302:            ( ( high - low ) >= 32 ) )                          \
        !           303:          ? EFAB_INSERT_NATIVE64 ( min, max, low, high, value ) \
        !           304:          : EFAB_INSERT_NATIVE32 ( min, max, low, high, value ) )
        !           305: 
        !           306: /**
        !           307:  * Construct bit field portion
        !           308:  *
        !           309:  * Creates the portion of the named bit field that lies within the
        !           310:  * range [min,max).
        !           311:  */
        !           312: #define EFAB_INSERT_FIELD_NATIVE( min, max, field, value )     \
        !           313:        EFAB_INSERT_NATIVE ( min, max, EFAB_LOW_BIT ( field ),  \
        !           314:                             EFAB_HIGH_BIT ( field ), value )
        !           315: 
        !           316: /**
        !           317:  * Construct bit field
        !           318:  *
        !           319:  * Creates the portion of the named bit fields that lie within the
        !           320:  * range [min,max).
        !           321:  */
        !           322: #define EFAB_INSERT_FIELDS_NATIVE( min, max,                           \
        !           323:                                   field1, value1,                      \
        !           324:                                   field2, value2,                      \
        !           325:                                   field3, value3,                      \
        !           326:                                   field4, value4,                      \
        !           327:                                   field5, value5,                      \
        !           328:                                   field6, value6,                      \
        !           329:                                   field7, value7,                      \
        !           330:                                   field8, value8,                      \
        !           331:                                   field9, value9,                      \
        !           332:                                   field10, value10 )                   \
        !           333:        ( EFAB_INSERT_FIELD_NATIVE ( min, max, field1, value1 ) |       \
        !           334:          EFAB_INSERT_FIELD_NATIVE ( min, max, field2, value2 ) |       \
        !           335:          EFAB_INSERT_FIELD_NATIVE ( min, max, field3, value3 ) |       \
        !           336:          EFAB_INSERT_FIELD_NATIVE ( min, max, field4, value4 ) |       \
        !           337:          EFAB_INSERT_FIELD_NATIVE ( min, max, field5, value5 ) |       \
        !           338:          EFAB_INSERT_FIELD_NATIVE ( min, max, field6, value6 ) |       \
        !           339:          EFAB_INSERT_FIELD_NATIVE ( min, max, field7, value7 ) |       \
        !           340:          EFAB_INSERT_FIELD_NATIVE ( min, max, field8, value8 ) |       \
        !           341:          EFAB_INSERT_FIELD_NATIVE ( min, max, field9, value9 ) |       \
        !           342:          EFAB_INSERT_FIELD_NATIVE ( min, max, field10, value10 ) )
        !           343: 
        !           344: #define EFAB_INSERT_FIELDS64( ... )                                    \
        !           345:        cpu_to_le64 ( EFAB_INSERT_FIELDS_NATIVE ( __VA_ARGS__ ) )
        !           346: 
        !           347: #define EFAB_INSERT_FIELDS32( ... )                                    \
        !           348:        cpu_to_le32 ( EFAB_INSERT_FIELDS_NATIVE ( __VA_ARGS__ ) )
        !           349: 
        !           350: #define EFAB_POPULATE_OWORD64( oword, ... ) do {                       \
        !           351:        (oword).u64[0] = EFAB_INSERT_FIELDS64 (   0,  63, __VA_ARGS__ );\
        !           352:        (oword).u64[1] = EFAB_INSERT_FIELDS64 (  64, 127, __VA_ARGS__ );\
        !           353:        } while ( 0 )
        !           354: 
        !           355: #define EFAB_POPULATE_QWORD64( qword, ... ) do {                       \
        !           356:        (qword).u64[0] = EFAB_INSERT_FIELDS64 (   0,  63, __VA_ARGS__ );\
        !           357:        } while ( 0 )
        !           358: 
        !           359: #define EFAB_POPULATE_OWORD32( oword, ... ) do {                       \
        !           360:        (oword).u32[0] = EFAB_INSERT_FIELDS32 (   0,  31, __VA_ARGS__ );\
        !           361:        (oword).u32[1] = EFAB_INSERT_FIELDS32 (  32,  63, __VA_ARGS__ );\
        !           362:        (oword).u32[2] = EFAB_INSERT_FIELDS32 (  64,  95, __VA_ARGS__ );\
        !           363:        (oword).u32[3] = EFAB_INSERT_FIELDS32 (  96, 127, __VA_ARGS__ );\
        !           364:        } while ( 0 )
        !           365: 
        !           366: #define EFAB_POPULATE_QWORD32( qword, ... ) do {                       \
        !           367:        (qword).u32[0] = EFAB_INSERT_FIELDS32 (   0,  31, __VA_ARGS__ );\
        !           368:        (qword).u32[1] = EFAB_INSERT_FIELDS32 (  32,  63, __VA_ARGS__ );\
        !           369:        } while ( 0 )
        !           370: 
        !           371: #define EFAB_POPULATE_DWORD( dword, ... ) do {                         \
        !           372:        (dword).u32[0] = EFAB_INSERT_FIELDS32 (   0,  31, __VA_ARGS__ );\
        !           373:        } while ( 0 )
        !           374: 
        !           375: #if ( BITS_PER_LONG == 64 )
        !           376: #define EFAB_POPULATE_OWORD EFAB_POPULATE_OWORD64
        !           377: #define EFAB_POPULATE_QWORD EFAB_POPULATE_QWORD64
        !           378: #else
        !           379: #define EFAB_POPULATE_OWORD EFAB_POPULATE_OWORD32
        !           380: #define EFAB_POPULATE_QWORD EFAB_POPULATE_QWORD32
        !           381: #endif
        !           382: 
        !           383: /* Populate an octword field with various numbers of arguments */
        !           384: #define EFAB_POPULATE_OWORD_10 EFAB_POPULATE_OWORD
        !           385: #define EFAB_POPULATE_OWORD_9( oword, ... ) \
        !           386:        EFAB_POPULATE_OWORD_10 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           387: #define EFAB_POPULATE_OWORD_8( oword, ... ) \
        !           388:        EFAB_POPULATE_OWORD_9 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           389: #define EFAB_POPULATE_OWORD_7( oword, ... ) \
        !           390:        EFAB_POPULATE_OWORD_8 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           391: #define EFAB_POPULATE_OWORD_6( oword, ... ) \
        !           392:        EFAB_POPULATE_OWORD_7 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           393: #define EFAB_POPULATE_OWORD_5( oword, ... ) \
        !           394:        EFAB_POPULATE_OWORD_6 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           395: #define EFAB_POPULATE_OWORD_4( oword, ... ) \
        !           396:        EFAB_POPULATE_OWORD_5 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           397: #define EFAB_POPULATE_OWORD_3( oword, ... ) \
        !           398:        EFAB_POPULATE_OWORD_4 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           399: #define EFAB_POPULATE_OWORD_2( oword, ... ) \
        !           400:        EFAB_POPULATE_OWORD_3 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           401: #define EFAB_POPULATE_OWORD_1( oword, ... ) \
        !           402:        EFAB_POPULATE_OWORD_2 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           403: #define EFAB_ZERO_OWORD( oword ) \
        !           404:        EFAB_POPULATE_OWORD_1 ( oword, EFAB_DUMMY_FIELD, 0 )
        !           405: #define EFAB_SET_OWORD( oword ) \
        !           406:        EFAB_POPULATE_OWORD_4 ( oword, \
        !           407:                                EFAB_DWORD_0, 0xffffffff, \
        !           408:                                EFAB_DWORD_1, 0xffffffff, \
        !           409:                                EFAB_DWORD_2, 0xffffffff, \
        !           410:                                EFAB_DWORD_3, 0xffffffff )
        !           411: 
        !           412: /* Populate a quadword field with various numbers of arguments */
        !           413: #define EFAB_POPULATE_QWORD_10 EFAB_POPULATE_QWORD
        !           414: #define EFAB_POPULATE_QWORD_9( qword, ... ) \
        !           415:        EFAB_POPULATE_QWORD_10 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           416: #define EFAB_POPULATE_QWORD_8( qword, ... ) \
        !           417:        EFAB_POPULATE_QWORD_9 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           418: #define EFAB_POPULATE_QWORD_7( qword, ... ) \
        !           419:        EFAB_POPULATE_QWORD_8 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           420: #define EFAB_POPULATE_QWORD_6( qword, ... ) \
        !           421:        EFAB_POPULATE_QWORD_7 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           422: #define EFAB_POPULATE_QWORD_5( qword, ... ) \
        !           423:        EFAB_POPULATE_QWORD_6 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           424: #define EFAB_POPULATE_QWORD_4( qword, ... ) \
        !           425:        EFAB_POPULATE_QWORD_5 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           426: #define EFAB_POPULATE_QWORD_3( qword, ... ) \
        !           427:        EFAB_POPULATE_QWORD_4 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           428: #define EFAB_POPULATE_QWORD_2( qword, ... ) \
        !           429:        EFAB_POPULATE_QWORD_3 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           430: #define EFAB_POPULATE_QWORD_1( qword, ... ) \
        !           431:        EFAB_POPULATE_QWORD_2 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           432: #define EFAB_ZERO_QWORD( qword ) \
        !           433:        EFAB_POPULATE_QWORD_1 ( qword, EFAB_DUMMY_FIELD, 0 )
        !           434: #define EFAB_SET_QWORD( qword ) \
        !           435:        EFAB_POPULATE_QWORD_2 ( qword, \
        !           436:                                EFAB_DWORD_0, 0xffffffff, \
        !           437:                                EFAB_DWORD_1, 0xffffffff )
        !           438: 
        !           439: /* Populate a dword field with various numbers of arguments */
        !           440: #define EFAB_POPULATE_DWORD_10 EFAB_POPULATE_DWORD
        !           441: #define EFAB_POPULATE_DWORD_9( dword, ... ) \
        !           442:        EFAB_POPULATE_DWORD_10 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           443: #define EFAB_POPULATE_DWORD_8( dword, ... ) \
        !           444:        EFAB_POPULATE_DWORD_9 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           445: #define EFAB_POPULATE_DWORD_7( dword, ... ) \
        !           446:        EFAB_POPULATE_DWORD_8 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           447: #define EFAB_POPULATE_DWORD_6( dword, ... ) \
        !           448:        EFAB_POPULATE_DWORD_7 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           449: #define EFAB_POPULATE_DWORD_5( dword, ... ) \
        !           450:        EFAB_POPULATE_DWORD_6 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           451: #define EFAB_POPULATE_DWORD_4( dword, ... ) \
        !           452:        EFAB_POPULATE_DWORD_5 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           453: #define EFAB_POPULATE_DWORD_3( dword, ... ) \
        !           454:        EFAB_POPULATE_DWORD_4 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           455: #define EFAB_POPULATE_DWORD_2( dword, ... ) \
        !           456:        EFAB_POPULATE_DWORD_3 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           457: #define EFAB_POPULATE_DWORD_1( dword, ... ) \
        !           458:        EFAB_POPULATE_DWORD_2 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
        !           459: #define EFAB_ZERO_DWORD( dword ) \
        !           460:        EFAB_POPULATE_DWORD_1 ( dword, EFAB_DUMMY_FIELD, 0 )
        !           461: #define EFAB_SET_DWORD( dword ) \
        !           462:        EFAB_POPULATE_DWORD_1 ( dword, EFAB_DWORD_0, 0xffffffff )
        !           463: 
        !           464: /*
        !           465:  * Modify a named field within an already-populated structure.  Used
        !           466:  * for read-modify-write operations.
        !           467:  *
        !           468:  */
        !           469: 
        !           470: #define EFAB_INSERT_FIELD64( ... )                                     \
        !           471:        cpu_to_le64 ( EFAB_INSERT_FIELD_NATIVE ( __VA_ARGS__ ) )
        !           472: 
        !           473: #define EFAB_INSERT_FIELD32( ... )                                     \
        !           474:        cpu_to_le32 ( EFAB_INSERT_FIELD_NATIVE ( __VA_ARGS__ ) )
        !           475: 
        !           476: #define EFAB_INPLACE_MASK64( min, max, field )                         \
        !           477:        EFAB_INSERT_FIELD64 ( min, max, field, EFAB_MASK64 ( field ) )
        !           478: 
        !           479: #define EFAB_INPLACE_MASK32( min, max, field )                         \
        !           480:        EFAB_INSERT_FIELD32 ( min, max, field, EFAB_MASK32 ( field ) )
        !           481: 
        !           482: #define EFAB_SET_OWORD_FIELD64( oword, field, value ) do {                   \
        !           483:        (oword).u64[0] = ( ( (oword).u64[0]                                   \
        !           484:                             & ~EFAB_INPLACE_MASK64 (  0,  63, field ) )      \
        !           485:                           | EFAB_INSERT_FIELD64 (  0,  63, field, value ) ); \
        !           486:        (oword).u64[1] = ( ( (oword).u64[1]                                   \
        !           487:                             & ~EFAB_INPLACE_MASK64 ( 64, 127, field ) )      \
        !           488:                           | EFAB_INSERT_FIELD64 ( 64, 127, field, value ) ); \
        !           489:        } while ( 0 )
        !           490: 
        !           491: #define EFAB_SET_QWORD_FIELD64( qword, field, value ) do {                   \
        !           492:        (qword).u64[0] = ( ( (qword).u64[0]                                   \
        !           493:                             & ~EFAB_INPLACE_MASK64 (  0,  63, field ) )      \
        !           494:                           | EFAB_INSERT_FIELD64 (  0,  63, field, value ) ); \
        !           495:        } while ( 0 )
        !           496: 
        !           497: #define EFAB_SET_OWORD_FIELD32( oword, field, value ) do {                   \
        !           498:        (oword).u32[0] = ( ( (oword).u32[0]                                   \
        !           499:                             & ~EFAB_INPLACE_MASK32 (  0,  31, field ) )      \
        !           500:                           | EFAB_INSERT_FIELD32 (  0,  31, field, value ) ); \
        !           501:        (oword).u32[1] = ( ( (oword).u32[1]                                   \
        !           502:                             & ~EFAB_INPLACE_MASK32 ( 32,  63, field ) )      \
        !           503:                           | EFAB_INSERT_FIELD32 ( 32,  63, field, value ) ); \
        !           504:        (oword).u32[2] = ( ( (oword).u32[2]                                   \
        !           505:                             & ~EFAB_INPLACE_MASK32 ( 64,  95, field ) )      \
        !           506:                           | EFAB_INSERT_FIELD32 ( 64,  95, field, value ) ); \
        !           507:        (oword).u32[3] = ( ( (oword).u32[3]                                   \
        !           508:                             & ~EFAB_INPLACE_MASK32 ( 96, 127, field ) )      \
        !           509:                           | EFAB_INSERT_FIELD32 ( 96, 127, field, value ) ); \
        !           510:        } while ( 0 )
        !           511: 
        !           512: #define EFAB_SET_QWORD_FIELD32( qword, field, value ) do {                   \
        !           513:        (qword).u32[0] = ( ( (qword).u32[0]                                   \
        !           514:                             & ~EFAB_INPLACE_MASK32 (  0,  31, field ) )      \
        !           515:                           | EFAB_INSERT_FIELD32 (  0,  31, field, value ) ); \
        !           516:        (qword).u32[1] = ( ( (qword).u32[1]                                   \
        !           517:                             & ~EFAB_INPLACE_MASK32 ( 32,  63, field ) )      \
        !           518:                           | EFAB_INSERT_FIELD32 ( 32,  63, field, value ) ); \
        !           519:        } while ( 0 )
        !           520: 
        !           521: #define EFAB_SET_DWORD_FIELD( dword, field, value ) do {                     \
        !           522:        (dword).u32[0] = ( ( (dword).u32[0]                                   \
        !           523:                             & ~EFAB_INPLACE_MASK32 (  0,  31, field ) )      \
        !           524:                           | EFAB_INSERT_FIELD32 (  0,  31, field, value ) ); \
        !           525:        } while ( 0 )
        !           526: 
        !           527: #if ( BITS_PER_LONG == 64 )
        !           528: #define EFAB_SET_OWORD_FIELD EFAB_SET_OWORD_FIELD64
        !           529: #define EFAB_SET_QWORD_FIELD EFAB_SET_QWORD_FIELD64
        !           530: #else
        !           531: #define EFAB_SET_OWORD_FIELD EFAB_SET_OWORD_FIELD32
        !           532: #define EFAB_SET_QWORD_FIELD EFAB_SET_QWORD_FIELD32
        !           533: #endif
        !           534: 
        !           535: /* Used to avoid compiler warnings about shift range exceeding width
        !           536:  * of the data types when dma_addr_t is only 32 bits wide.
        !           537:  */
        !           538: #define DMA_ADDR_T_WIDTH       ( 8 * sizeof ( dma_addr_t ) )
        !           539: #define EFAB_DMA_TYPE_WIDTH( width ) \
        !           540:        ( ( (width) < DMA_ADDR_T_WIDTH ) ? (width) : DMA_ADDR_T_WIDTH )
        !           541: #define EFAB_DMA_MAX_MASK ( ( DMA_ADDR_T_WIDTH == 64 ) ? \
        !           542:                            ~( ( uint64_t ) 0 ) : ~( ( uint32_t ) 0 ) )
        !           543: #define EFAB_DMA_MASK(mask) ( (mask) & EFAB_DMA_MAX_MASK )
        !           544: 
        !           545: #endif /* EFAB_BITFIELD_H */
        !           546: 
        !           547: /*
        !           548:  * Local variables:
        !           549:  *  c-basic-offset: 8
        !           550:  *  c-indent-level: 8
        !           551:  *  tab-width: 8
        !           552:  * End:
        !           553:  */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.