Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-only */
0002 /****************************************************************************
0003  * Driver for Solarflare network controllers and boards
0004  * Copyright 2005-2006 Fen Systems Ltd.
0005  * Copyright 2006-2013 Solarflare Communications Inc.
0006  */
0007 
0008 #ifndef EFX_BITFIELD_H
0009 #define EFX_BITFIELD_H
0010 
0011 /*
0012  * Efx bitfield access
0013  *
0014  * Efx NICs make extensive use of bitfields up to 128 bits
0015  * wide.  Since there is no native 128-bit datatype on most systems,
0016  * and since 64-bit datatypes are inefficient on 32-bit systems and
0017  * vice versa, we wrap accesses in a way that uses the most efficient
0018  * datatype.
0019  *
0020  * The NICs are PCI devices and therefore little-endian.  Since most
0021  * of the quantities that we deal with are DMAed to/from host memory,
0022  * we define our datatypes (efx_oword_t, efx_qword_t and
0023  * efx_dword_t) to be little-endian.
0024  */
0025 
0026 /* Lowest bit numbers and widths */
0027 #define EFX_DUMMY_FIELD_LBN 0
0028 #define EFX_DUMMY_FIELD_WIDTH 0
0029 #define EFX_WORD_0_LBN 0
0030 #define EFX_WORD_0_WIDTH 16
0031 #define EFX_WORD_1_LBN 16
0032 #define EFX_WORD_1_WIDTH 16
0033 #define EFX_DWORD_0_LBN 0
0034 #define EFX_DWORD_0_WIDTH 32
0035 #define EFX_DWORD_1_LBN 32
0036 #define EFX_DWORD_1_WIDTH 32
0037 #define EFX_DWORD_2_LBN 64
0038 #define EFX_DWORD_2_WIDTH 32
0039 #define EFX_DWORD_3_LBN 96
0040 #define EFX_DWORD_3_WIDTH 32
0041 #define EFX_QWORD_0_LBN 0
0042 #define EFX_QWORD_0_WIDTH 64
0043 
0044 /* Specified attribute (e.g. LBN) of the specified field */
0045 #define EFX_VAL(field, attribute) field ## _ ## attribute
0046 /* Low bit number of the specified field */
0047 #define EFX_LOW_BIT(field) EFX_VAL(field, LBN)
0048 /* Bit width of the specified field */
0049 #define EFX_WIDTH(field) EFX_VAL(field, WIDTH)
0050 /* High bit number of the specified field */
0051 #define EFX_HIGH_BIT(field) (EFX_LOW_BIT(field) + EFX_WIDTH(field) - 1)
0052 /* Mask equal in width to the specified field.
0053  *
0054  * For example, a field with width 5 would have a mask of 0x1f.
0055  *
0056  * The maximum width mask that can be generated is 64 bits.
0057  */
0058 #define EFX_MASK64(width)           \
0059     ((width) == 64 ? ~((u64) 0) :       \
0060      (((((u64) 1) << (width))) - 1))
0061 
0062 /* Mask equal in width to the specified field.
0063  *
0064  * For example, a field with width 5 would have a mask of 0x1f.
0065  *
0066  * The maximum width mask that can be generated is 32 bits.  Use
0067  * EFX_MASK64 for higher width fields.
0068  */
0069 #define EFX_MASK32(width)           \
0070     ((width) == 32 ? ~((u32) 0) :       \
0071      (((((u32) 1) << (width))) - 1))
0072 
0073 /* A doubleword (i.e. 4 byte) datatype - little-endian in HW */
0074 typedef union efx_dword {
0075     __le32 u32[1];
0076 } efx_dword_t;
0077 
0078 /* A quadword (i.e. 8 byte) datatype - little-endian in HW */
0079 typedef union efx_qword {
0080     __le64 u64[1];
0081     __le32 u32[2];
0082     efx_dword_t dword[2];
0083 } efx_qword_t;
0084 
0085 /* An octword (eight-word, i.e. 16 byte) datatype - little-endian in HW */
0086 typedef union efx_oword {
0087     __le64 u64[2];
0088     efx_qword_t qword[2];
0089     __le32 u32[4];
0090     efx_dword_t dword[4];
0091 } efx_oword_t;
0092 
0093 /* Format string and value expanders for printk */
0094 #define EFX_DWORD_FMT "%08x"
0095 #define EFX_QWORD_FMT "%08x:%08x"
0096 #define EFX_OWORD_FMT "%08x:%08x:%08x:%08x"
0097 #define EFX_DWORD_VAL(dword)                \
0098     ((unsigned int) le32_to_cpu((dword).u32[0]))
0099 #define EFX_QWORD_VAL(qword)                \
0100     ((unsigned int) le32_to_cpu((qword).u32[1])),   \
0101     ((unsigned int) le32_to_cpu((qword).u32[0]))
0102 #define EFX_OWORD_VAL(oword)                \
0103     ((unsigned int) le32_to_cpu((oword).u32[3])),   \
0104     ((unsigned int) le32_to_cpu((oword).u32[2])),   \
0105     ((unsigned int) le32_to_cpu((oword).u32[1])),   \
0106     ((unsigned int) le32_to_cpu((oword).u32[0]))
0107 
0108 /*
0109  * Extract bit field portion [low,high) from the native-endian element
0110  * which contains bits [min,max).
0111  *
0112  * For example, suppose "element" represents the high 32 bits of a
0113  * 64-bit value, and we wish to extract the bits belonging to the bit
0114  * field occupying bits 28-45 of this 64-bit value.
0115  *
0116  * Then EFX_EXTRACT ( element, 32, 63, 28, 45 ) would give
0117  *
0118  *   ( element ) << 4
0119  *
0120  * The result will contain the relevant bits filled in in the range
0121  * [0,high-low), with garbage in bits [high-low+1,...).
0122  */
0123 #define EFX_EXTRACT_NATIVE(native_element, min, max, low, high)     \
0124     ((low) > (max) || (high) < (min) ? 0 :              \
0125      (low) > (min) ?                        \
0126      (native_element) >> ((low) - (min)) :              \
0127      (native_element) << ((min) - (low)))
0128 
0129 /*
0130  * Extract bit field portion [low,high) from the 64-bit little-endian
0131  * element which contains bits [min,max)
0132  */
0133 #define EFX_EXTRACT64(element, min, max, low, high)         \
0134     EFX_EXTRACT_NATIVE(le64_to_cpu(element), min, max, low, high)
0135 
0136 /*
0137  * Extract bit field portion [low,high) from the 32-bit little-endian
0138  * element which contains bits [min,max)
0139  */
0140 #define EFX_EXTRACT32(element, min, max, low, high)         \
0141     EFX_EXTRACT_NATIVE(le32_to_cpu(element), min, max, low, high)
0142 
0143 #define EFX_EXTRACT_OWORD64(oword, low, high)               \
0144     ((EFX_EXTRACT64((oword).u64[0], 0, 63, low, high) |     \
0145       EFX_EXTRACT64((oword).u64[1], 64, 127, low, high)) &      \
0146      EFX_MASK64((high) + 1 - (low)))
0147 
0148 #define EFX_EXTRACT_QWORD64(qword, low, high)               \
0149     (EFX_EXTRACT64((qword).u64[0], 0, 63, low, high) &      \
0150      EFX_MASK64((high) + 1 - (low)))
0151 
0152 #define EFX_EXTRACT_OWORD32(oword, low, high)               \
0153     ((EFX_EXTRACT32((oword).u32[0], 0, 31, low, high) |     \
0154       EFX_EXTRACT32((oword).u32[1], 32, 63, low, high) |        \
0155       EFX_EXTRACT32((oword).u32[2], 64, 95, low, high) |        \
0156       EFX_EXTRACT32((oword).u32[3], 96, 127, low, high)) &      \
0157      EFX_MASK32((high) + 1 - (low)))
0158 
0159 #define EFX_EXTRACT_QWORD32(qword, low, high)               \
0160     ((EFX_EXTRACT32((qword).u32[0], 0, 31, low, high) |     \
0161       EFX_EXTRACT32((qword).u32[1], 32, 63, low, high)) &       \
0162      EFX_MASK32((high) + 1 - (low)))
0163 
0164 #define EFX_EXTRACT_DWORD(dword, low, high)         \
0165     (EFX_EXTRACT32((dword).u32[0], 0, 31, low, high) &  \
0166      EFX_MASK32((high) + 1 - (low)))
0167 
0168 #define EFX_OWORD_FIELD64(oword, field)             \
0169     EFX_EXTRACT_OWORD64(oword, EFX_LOW_BIT(field),      \
0170                 EFX_HIGH_BIT(field))
0171 
0172 #define EFX_QWORD_FIELD64(qword, field)             \
0173     EFX_EXTRACT_QWORD64(qword, EFX_LOW_BIT(field),      \
0174                 EFX_HIGH_BIT(field))
0175 
0176 #define EFX_OWORD_FIELD32(oword, field)             \
0177     EFX_EXTRACT_OWORD32(oword, EFX_LOW_BIT(field),      \
0178                 EFX_HIGH_BIT(field))
0179 
0180 #define EFX_QWORD_FIELD32(qword, field)             \
0181     EFX_EXTRACT_QWORD32(qword, EFX_LOW_BIT(field),      \
0182                 EFX_HIGH_BIT(field))
0183 
0184 #define EFX_DWORD_FIELD(dword, field)               \
0185     EFX_EXTRACT_DWORD(dword, EFX_LOW_BIT(field),        \
0186               EFX_HIGH_BIT(field))
0187 
0188 #define EFX_OWORD_IS_ZERO64(oword)                  \
0189     (((oword).u64[0] | (oword).u64[1]) == (__force __le64) 0)
0190 
0191 #define EFX_QWORD_IS_ZERO64(qword)                  \
0192     (((qword).u64[0]) == (__force __le64) 0)
0193 
0194 #define EFX_OWORD_IS_ZERO32(oword)                       \
0195     (((oword).u32[0] | (oword).u32[1] | (oword).u32[2] | (oword).u32[3]) \
0196      == (__force __le32) 0)
0197 
0198 #define EFX_QWORD_IS_ZERO32(qword)                  \
0199     (((qword).u32[0] | (qword).u32[1]) == (__force __le32) 0)
0200 
0201 #define EFX_DWORD_IS_ZERO(dword)                    \
0202     (((dword).u32[0]) == (__force __le32) 0)
0203 
0204 #define EFX_OWORD_IS_ALL_ONES64(oword)                  \
0205     (((oword).u64[0] & (oword).u64[1]) == ~((__force __le64) 0))
0206 
0207 #define EFX_QWORD_IS_ALL_ONES64(qword)                  \
0208     ((qword).u64[0] == ~((__force __le64) 0))
0209 
0210 #define EFX_OWORD_IS_ALL_ONES32(oword)                  \
0211     (((oword).u32[0] & (oword).u32[1] & (oword).u32[2] & (oword).u32[3]) \
0212      == ~((__force __le32) 0))
0213 
0214 #define EFX_QWORD_IS_ALL_ONES32(qword)                  \
0215     (((qword).u32[0] & (qword).u32[1]) == ~((__force __le32) 0))
0216 
0217 #define EFX_DWORD_IS_ALL_ONES(dword)                    \
0218     ((dword).u32[0] == ~((__force __le32) 0))
0219 
0220 #if BITS_PER_LONG == 64
0221 #define EFX_OWORD_FIELD     EFX_OWORD_FIELD64
0222 #define EFX_QWORD_FIELD     EFX_QWORD_FIELD64
0223 #define EFX_OWORD_IS_ZERO   EFX_OWORD_IS_ZERO64
0224 #define EFX_QWORD_IS_ZERO   EFX_QWORD_IS_ZERO64
0225 #define EFX_OWORD_IS_ALL_ONES   EFX_OWORD_IS_ALL_ONES64
0226 #define EFX_QWORD_IS_ALL_ONES   EFX_QWORD_IS_ALL_ONES64
0227 #else
0228 #define EFX_OWORD_FIELD     EFX_OWORD_FIELD32
0229 #define EFX_QWORD_FIELD     EFX_QWORD_FIELD32
0230 #define EFX_OWORD_IS_ZERO   EFX_OWORD_IS_ZERO32
0231 #define EFX_QWORD_IS_ZERO   EFX_QWORD_IS_ZERO32
0232 #define EFX_OWORD_IS_ALL_ONES   EFX_OWORD_IS_ALL_ONES32
0233 #define EFX_QWORD_IS_ALL_ONES   EFX_QWORD_IS_ALL_ONES32
0234 #endif
0235 
0236 /*
0237  * Construct bit field portion
0238  *
0239  * Creates the portion of the bit field [low,high) that lies within
0240  * the range [min,max).
0241  */
0242 #define EFX_INSERT_NATIVE64(min, max, low, high, value)     \
0243     (((low > max) || (high < min)) ? 0 :            \
0244      ((low > min) ?                     \
0245       (((u64) (value)) << (low - min)) :        \
0246       (((u64) (value)) >> (min - low))))
0247 
0248 #define EFX_INSERT_NATIVE32(min, max, low, high, value)     \
0249     (((low > max) || (high < min)) ? 0 :            \
0250      ((low > min) ?                     \
0251       (((u32) (value)) << (low - min)) :        \
0252       (((u32) (value)) >> (min - low))))
0253 
0254 #define EFX_INSERT_NATIVE(min, max, low, high, value)       \
0255     ((((max - min) >= 32) || ((high - low) >= 32)) ?    \
0256      EFX_INSERT_NATIVE64(min, max, low, high, value) :  \
0257      EFX_INSERT_NATIVE32(min, max, low, high, value))
0258 
0259 /*
0260  * Construct bit field portion
0261  *
0262  * Creates the portion of the named bit field that lies within the
0263  * range [min,max).
0264  */
0265 #define EFX_INSERT_FIELD_NATIVE(min, max, field, value)     \
0266     EFX_INSERT_NATIVE(min, max, EFX_LOW_BIT(field),     \
0267               EFX_HIGH_BIT(field), value)
0268 
0269 /*
0270  * Construct bit field
0271  *
0272  * Creates the portion of the named bit fields that lie within the
0273  * range [min,max).
0274  */
0275 #define EFX_INSERT_FIELDS_NATIVE(min, max,              \
0276                  field1, value1,            \
0277                  field2, value2,            \
0278                  field3, value3,            \
0279                  field4, value4,            \
0280                  field5, value5,            \
0281                  field6, value6,            \
0282                  field7, value7,            \
0283                  field8, value8,            \
0284                  field9, value9,            \
0285                  field10, value10,          \
0286                  field11, value11,          \
0287                  field12, value12,          \
0288                  field13, value13,          \
0289                  field14, value14,          \
0290                  field15, value15,          \
0291                  field16, value16,          \
0292                  field17, value17,          \
0293                  field18, value18,          \
0294                  field19, value19)          \
0295     (EFX_INSERT_FIELD_NATIVE((min), (max), field1, (value1)) |  \
0296      EFX_INSERT_FIELD_NATIVE((min), (max), field2, (value2)) |  \
0297      EFX_INSERT_FIELD_NATIVE((min), (max), field3, (value3)) |  \
0298      EFX_INSERT_FIELD_NATIVE((min), (max), field4, (value4)) |  \
0299      EFX_INSERT_FIELD_NATIVE((min), (max), field5, (value5)) |  \
0300      EFX_INSERT_FIELD_NATIVE((min), (max), field6, (value6)) |  \
0301      EFX_INSERT_FIELD_NATIVE((min), (max), field7, (value7)) |  \
0302      EFX_INSERT_FIELD_NATIVE((min), (max), field8, (value8)) |  \
0303      EFX_INSERT_FIELD_NATIVE((min), (max), field9, (value9)) |  \
0304      EFX_INSERT_FIELD_NATIVE((min), (max), field10, (value10)) |    \
0305      EFX_INSERT_FIELD_NATIVE((min), (max), field11, (value11)) |    \
0306      EFX_INSERT_FIELD_NATIVE((min), (max), field12, (value12)) |    \
0307      EFX_INSERT_FIELD_NATIVE((min), (max), field13, (value13)) |    \
0308      EFX_INSERT_FIELD_NATIVE((min), (max), field14, (value14)) |    \
0309      EFX_INSERT_FIELD_NATIVE((min), (max), field15, (value15)) |    \
0310      EFX_INSERT_FIELD_NATIVE((min), (max), field16, (value16)) |    \
0311      EFX_INSERT_FIELD_NATIVE((min), (max), field17, (value17)) |    \
0312      EFX_INSERT_FIELD_NATIVE((min), (max), field18, (value18)) |    \
0313      EFX_INSERT_FIELD_NATIVE((min), (max), field19, (value19)))
0314 
0315 #define EFX_INSERT_FIELDS64(...)                \
0316     cpu_to_le64(EFX_INSERT_FIELDS_NATIVE(__VA_ARGS__))
0317 
0318 #define EFX_INSERT_FIELDS32(...)                \
0319     cpu_to_le32(EFX_INSERT_FIELDS_NATIVE(__VA_ARGS__))
0320 
0321 #define EFX_POPULATE_OWORD64(oword, ...) do {               \
0322     (oword).u64[0] = EFX_INSERT_FIELDS64(0, 63, __VA_ARGS__);   \
0323     (oword).u64[1] = EFX_INSERT_FIELDS64(64, 127, __VA_ARGS__); \
0324     } while (0)
0325 
0326 #define EFX_POPULATE_QWORD64(qword, ...) do {               \
0327     (qword).u64[0] = EFX_INSERT_FIELDS64(0, 63, __VA_ARGS__);   \
0328     } while (0)
0329 
0330 #define EFX_POPULATE_OWORD32(oword, ...) do {               \
0331     (oword).u32[0] = EFX_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0332     (oword).u32[1] = EFX_INSERT_FIELDS32(32, 63, __VA_ARGS__);  \
0333     (oword).u32[2] = EFX_INSERT_FIELDS32(64, 95, __VA_ARGS__);  \
0334     (oword).u32[3] = EFX_INSERT_FIELDS32(96, 127, __VA_ARGS__); \
0335     } while (0)
0336 
0337 #define EFX_POPULATE_QWORD32(qword, ...) do {               \
0338     (qword).u32[0] = EFX_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0339     (qword).u32[1] = EFX_INSERT_FIELDS32(32, 63, __VA_ARGS__);  \
0340     } while (0)
0341 
0342 #define EFX_POPULATE_DWORD(dword, ...) do {             \
0343     (dword).u32[0] = EFX_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0344     } while (0)
0345 
0346 #if BITS_PER_LONG == 64
0347 #define EFX_POPULATE_OWORD EFX_POPULATE_OWORD64
0348 #define EFX_POPULATE_QWORD EFX_POPULATE_QWORD64
0349 #else
0350 #define EFX_POPULATE_OWORD EFX_POPULATE_OWORD32
0351 #define EFX_POPULATE_QWORD EFX_POPULATE_QWORD32
0352 #endif
0353 
0354 /* Populate an octword field with various numbers of arguments */
0355 #define EFX_POPULATE_OWORD_19 EFX_POPULATE_OWORD
0356 #define EFX_POPULATE_OWORD_18(oword, ...) \
0357     EFX_POPULATE_OWORD_19(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0358 #define EFX_POPULATE_OWORD_17(oword, ...) \
0359     EFX_POPULATE_OWORD_18(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0360 #define EFX_POPULATE_OWORD_16(oword, ...) \
0361     EFX_POPULATE_OWORD_17(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0362 #define EFX_POPULATE_OWORD_15(oword, ...) \
0363     EFX_POPULATE_OWORD_16(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0364 #define EFX_POPULATE_OWORD_14(oword, ...) \
0365     EFX_POPULATE_OWORD_15(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0366 #define EFX_POPULATE_OWORD_13(oword, ...) \
0367     EFX_POPULATE_OWORD_14(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0368 #define EFX_POPULATE_OWORD_12(oword, ...) \
0369     EFX_POPULATE_OWORD_13(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0370 #define EFX_POPULATE_OWORD_11(oword, ...) \
0371     EFX_POPULATE_OWORD_12(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0372 #define EFX_POPULATE_OWORD_10(oword, ...) \
0373     EFX_POPULATE_OWORD_11(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0374 #define EFX_POPULATE_OWORD_9(oword, ...) \
0375     EFX_POPULATE_OWORD_10(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0376 #define EFX_POPULATE_OWORD_8(oword, ...) \
0377     EFX_POPULATE_OWORD_9(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0378 #define EFX_POPULATE_OWORD_7(oword, ...) \
0379     EFX_POPULATE_OWORD_8(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0380 #define EFX_POPULATE_OWORD_6(oword, ...) \
0381     EFX_POPULATE_OWORD_7(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0382 #define EFX_POPULATE_OWORD_5(oword, ...) \
0383     EFX_POPULATE_OWORD_6(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0384 #define EFX_POPULATE_OWORD_4(oword, ...) \
0385     EFX_POPULATE_OWORD_5(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0386 #define EFX_POPULATE_OWORD_3(oword, ...) \
0387     EFX_POPULATE_OWORD_4(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0388 #define EFX_POPULATE_OWORD_2(oword, ...) \
0389     EFX_POPULATE_OWORD_3(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0390 #define EFX_POPULATE_OWORD_1(oword, ...) \
0391     EFX_POPULATE_OWORD_2(oword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0392 #define EFX_ZERO_OWORD(oword) \
0393     EFX_POPULATE_OWORD_1(oword, EFX_DUMMY_FIELD, 0)
0394 #define EFX_SET_OWORD(oword) \
0395     EFX_POPULATE_OWORD_4(oword, \
0396                  EFX_DWORD_0, 0xffffffff, \
0397                  EFX_DWORD_1, 0xffffffff, \
0398                  EFX_DWORD_2, 0xffffffff, \
0399                  EFX_DWORD_3, 0xffffffff)
0400 
0401 /* Populate a quadword field with various numbers of arguments */
0402 #define EFX_POPULATE_QWORD_19 EFX_POPULATE_QWORD
0403 #define EFX_POPULATE_QWORD_18(qword, ...) \
0404     EFX_POPULATE_QWORD_19(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0405 #define EFX_POPULATE_QWORD_17(qword, ...) \
0406     EFX_POPULATE_QWORD_18(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0407 #define EFX_POPULATE_QWORD_16(qword, ...) \
0408     EFX_POPULATE_QWORD_17(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0409 #define EFX_POPULATE_QWORD_15(qword, ...) \
0410     EFX_POPULATE_QWORD_16(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0411 #define EFX_POPULATE_QWORD_14(qword, ...) \
0412     EFX_POPULATE_QWORD_15(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0413 #define EFX_POPULATE_QWORD_13(qword, ...) \
0414     EFX_POPULATE_QWORD_14(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0415 #define EFX_POPULATE_QWORD_12(qword, ...) \
0416     EFX_POPULATE_QWORD_13(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0417 #define EFX_POPULATE_QWORD_11(qword, ...) \
0418     EFX_POPULATE_QWORD_12(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0419 #define EFX_POPULATE_QWORD_10(qword, ...) \
0420     EFX_POPULATE_QWORD_11(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0421 #define EFX_POPULATE_QWORD_9(qword, ...) \
0422     EFX_POPULATE_QWORD_10(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0423 #define EFX_POPULATE_QWORD_8(qword, ...) \
0424     EFX_POPULATE_QWORD_9(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0425 #define EFX_POPULATE_QWORD_7(qword, ...) \
0426     EFX_POPULATE_QWORD_8(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0427 #define EFX_POPULATE_QWORD_6(qword, ...) \
0428     EFX_POPULATE_QWORD_7(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0429 #define EFX_POPULATE_QWORD_5(qword, ...) \
0430     EFX_POPULATE_QWORD_6(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0431 #define EFX_POPULATE_QWORD_4(qword, ...) \
0432     EFX_POPULATE_QWORD_5(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0433 #define EFX_POPULATE_QWORD_3(qword, ...) \
0434     EFX_POPULATE_QWORD_4(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0435 #define EFX_POPULATE_QWORD_2(qword, ...) \
0436     EFX_POPULATE_QWORD_3(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0437 #define EFX_POPULATE_QWORD_1(qword, ...) \
0438     EFX_POPULATE_QWORD_2(qword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0439 #define EFX_ZERO_QWORD(qword) \
0440     EFX_POPULATE_QWORD_1(qword, EFX_DUMMY_FIELD, 0)
0441 #define EFX_SET_QWORD(qword) \
0442     EFX_POPULATE_QWORD_2(qword, \
0443                  EFX_DWORD_0, 0xffffffff, \
0444                  EFX_DWORD_1, 0xffffffff)
0445 
0446 /* Populate a dword field with various numbers of arguments */
0447 #define EFX_POPULATE_DWORD_19 EFX_POPULATE_DWORD
0448 #define EFX_POPULATE_DWORD_18(dword, ...) \
0449     EFX_POPULATE_DWORD_19(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0450 #define EFX_POPULATE_DWORD_17(dword, ...) \
0451     EFX_POPULATE_DWORD_18(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0452 #define EFX_POPULATE_DWORD_16(dword, ...) \
0453     EFX_POPULATE_DWORD_17(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0454 #define EFX_POPULATE_DWORD_15(dword, ...) \
0455     EFX_POPULATE_DWORD_16(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0456 #define EFX_POPULATE_DWORD_14(dword, ...) \
0457     EFX_POPULATE_DWORD_15(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0458 #define EFX_POPULATE_DWORD_13(dword, ...) \
0459     EFX_POPULATE_DWORD_14(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0460 #define EFX_POPULATE_DWORD_12(dword, ...) \
0461     EFX_POPULATE_DWORD_13(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0462 #define EFX_POPULATE_DWORD_11(dword, ...) \
0463     EFX_POPULATE_DWORD_12(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0464 #define EFX_POPULATE_DWORD_10(dword, ...) \
0465     EFX_POPULATE_DWORD_11(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0466 #define EFX_POPULATE_DWORD_9(dword, ...) \
0467     EFX_POPULATE_DWORD_10(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0468 #define EFX_POPULATE_DWORD_8(dword, ...) \
0469     EFX_POPULATE_DWORD_9(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0470 #define EFX_POPULATE_DWORD_7(dword, ...) \
0471     EFX_POPULATE_DWORD_8(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0472 #define EFX_POPULATE_DWORD_6(dword, ...) \
0473     EFX_POPULATE_DWORD_7(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0474 #define EFX_POPULATE_DWORD_5(dword, ...) \
0475     EFX_POPULATE_DWORD_6(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0476 #define EFX_POPULATE_DWORD_4(dword, ...) \
0477     EFX_POPULATE_DWORD_5(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0478 #define EFX_POPULATE_DWORD_3(dword, ...) \
0479     EFX_POPULATE_DWORD_4(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0480 #define EFX_POPULATE_DWORD_2(dword, ...) \
0481     EFX_POPULATE_DWORD_3(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0482 #define EFX_POPULATE_DWORD_1(dword, ...) \
0483     EFX_POPULATE_DWORD_2(dword, EFX_DUMMY_FIELD, 0, __VA_ARGS__)
0484 #define EFX_ZERO_DWORD(dword) \
0485     EFX_POPULATE_DWORD_1(dword, EFX_DUMMY_FIELD, 0)
0486 #define EFX_SET_DWORD(dword) \
0487     EFX_POPULATE_DWORD_1(dword, EFX_DWORD_0, 0xffffffff)
0488 
0489 /*
0490  * Modify a named field within an already-populated structure.  Used
0491  * for read-modify-write operations.
0492  *
0493  */
0494 #define EFX_INVERT_OWORD(oword) do {        \
0495     (oword).u64[0] = ~((oword).u64[0]); \
0496     (oword).u64[1] = ~((oword).u64[1]); \
0497     } while (0)
0498 
0499 #define EFX_AND_OWORD(oword, from, mask)            \
0500     do {                            \
0501         (oword).u64[0] = (from).u64[0] & (mask).u64[0]; \
0502         (oword).u64[1] = (from).u64[1] & (mask).u64[1]; \
0503     } while (0)
0504 
0505 #define EFX_AND_QWORD(qword, from, mask)            \
0506         (qword).u64[0] = (from).u64[0] & (mask).u64[0]
0507 
0508 #define EFX_OR_OWORD(oword, from, mask)             \
0509     do {                            \
0510         (oword).u64[0] = (from).u64[0] | (mask).u64[0]; \
0511         (oword).u64[1] = (from).u64[1] | (mask).u64[1]; \
0512     } while (0)
0513 
0514 #define EFX_INSERT64(min, max, low, high, value)            \
0515     cpu_to_le64(EFX_INSERT_NATIVE(min, max, low, high, value))
0516 
0517 #define EFX_INSERT32(min, max, low, high, value)            \
0518     cpu_to_le32(EFX_INSERT_NATIVE(min, max, low, high, value))
0519 
0520 #define EFX_INPLACE_MASK64(min, max, low, high)             \
0521     EFX_INSERT64(min, max, low, high, EFX_MASK64((high) + 1 - (low)))
0522 
0523 #define EFX_INPLACE_MASK32(min, max, low, high)             \
0524     EFX_INSERT32(min, max, low, high, EFX_MASK32((high) + 1 - (low)))
0525 
0526 #define EFX_SET_OWORD64(oword, low, high, value) do {           \
0527     (oword).u64[0] = (((oword).u64[0]               \
0528                & ~EFX_INPLACE_MASK64(0,  63, low, high))    \
0529               | EFX_INSERT64(0,  63, low, high, value));    \
0530     (oword).u64[1] = (((oword).u64[1]               \
0531                & ~EFX_INPLACE_MASK64(64, 127, low, high))   \
0532               | EFX_INSERT64(64, 127, low, high, value));   \
0533     } while (0)
0534 
0535 #define EFX_SET_QWORD64(qword, low, high, value) do {           \
0536     (qword).u64[0] = (((qword).u64[0]               \
0537                & ~EFX_INPLACE_MASK64(0, 63, low, high)) \
0538               | EFX_INSERT64(0, 63, low, high, value)); \
0539     } while (0)
0540 
0541 #define EFX_SET_OWORD32(oword, low, high, value) do {           \
0542     (oword).u32[0] = (((oword).u32[0]               \
0543                & ~EFX_INPLACE_MASK32(0, 31, low, high)) \
0544               | EFX_INSERT32(0, 31, low, high, value)); \
0545     (oword).u32[1] = (((oword).u32[1]               \
0546                & ~EFX_INPLACE_MASK32(32, 63, low, high))    \
0547               | EFX_INSERT32(32, 63, low, high, value));    \
0548     (oword).u32[2] = (((oword).u32[2]               \
0549                & ~EFX_INPLACE_MASK32(64, 95, low, high))    \
0550               | EFX_INSERT32(64, 95, low, high, value));    \
0551     (oword).u32[3] = (((oword).u32[3]               \
0552                & ~EFX_INPLACE_MASK32(96, 127, low, high))   \
0553               | EFX_INSERT32(96, 127, low, high, value));   \
0554     } while (0)
0555 
0556 #define EFX_SET_QWORD32(qword, low, high, value) do {           \
0557     (qword).u32[0] = (((qword).u32[0]               \
0558                & ~EFX_INPLACE_MASK32(0, 31, low, high)) \
0559               | EFX_INSERT32(0, 31, low, high, value)); \
0560     (qword).u32[1] = (((qword).u32[1]               \
0561                & ~EFX_INPLACE_MASK32(32, 63, low, high))    \
0562               | EFX_INSERT32(32, 63, low, high, value));    \
0563     } while (0)
0564 
0565 #define EFX_SET_DWORD32(dword, low, high, value) do {           \
0566     (dword).u32[0] = (((dword).u32[0]               \
0567                & ~EFX_INPLACE_MASK32(0, 31, low, high)) \
0568               | EFX_INSERT32(0, 31, low, high, value)); \
0569     } while (0)
0570 
0571 #define EFX_SET_OWORD_FIELD64(oword, field, value)          \
0572     EFX_SET_OWORD64(oword, EFX_LOW_BIT(field),          \
0573              EFX_HIGH_BIT(field), value)
0574 
0575 #define EFX_SET_QWORD_FIELD64(qword, field, value)          \
0576     EFX_SET_QWORD64(qword, EFX_LOW_BIT(field),          \
0577              EFX_HIGH_BIT(field), value)
0578 
0579 #define EFX_SET_OWORD_FIELD32(oword, field, value)          \
0580     EFX_SET_OWORD32(oword, EFX_LOW_BIT(field),          \
0581              EFX_HIGH_BIT(field), value)
0582 
0583 #define EFX_SET_QWORD_FIELD32(qword, field, value)          \
0584     EFX_SET_QWORD32(qword, EFX_LOW_BIT(field),          \
0585              EFX_HIGH_BIT(field), value)
0586 
0587 #define EFX_SET_DWORD_FIELD(dword, field, value)            \
0588     EFX_SET_DWORD32(dword, EFX_LOW_BIT(field),          \
0589              EFX_HIGH_BIT(field), value)
0590 
0591 
0592 
0593 #if BITS_PER_LONG == 64
0594 #define EFX_SET_OWORD_FIELD EFX_SET_OWORD_FIELD64
0595 #define EFX_SET_QWORD_FIELD EFX_SET_QWORD_FIELD64
0596 #else
0597 #define EFX_SET_OWORD_FIELD EFX_SET_OWORD_FIELD32
0598 #define EFX_SET_QWORD_FIELD EFX_SET_QWORD_FIELD32
0599 #endif
0600 
0601 /* Used to avoid compiler warnings about shift range exceeding width
0602  * of the data types when dma_addr_t is only 32 bits wide.
0603  */
0604 #define DMA_ADDR_T_WIDTH    (8 * sizeof(dma_addr_t))
0605 #define EFX_DMA_TYPE_WIDTH(width) \
0606     (((width) < DMA_ADDR_T_WIDTH) ? (width) : DMA_ADDR_T_WIDTH)
0607 
0608 
0609 /* Static initialiser */
0610 #define EFX_OWORD32(a, b, c, d)             \
0611     { .u32 = { cpu_to_le32(a), cpu_to_le32(b),  \
0612            cpu_to_le32(c), cpu_to_le32(d) } }
0613 
0614 #endif /* EFX_BITFIELD_H */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!