sfc/falcon/bitfield.h

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 EF4_BITFIELD_H
0009 #define EF4_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 (ef4_oword_t, ef4_qword_t and
0023  * ef4_dword_t) to be little-endian.
0024  */
0025
0026 /* Lowest bit numbers and widths */
0027 #define EF4_DUMMY_FIELD_LBN 0
0028 #define EF4_DUMMY_FIELD_WIDTH 0
0029 #define EF4_WORD_0_LBN 0
0030 #define EF4_WORD_0_WIDTH 16
0031 #define EF4_WORD_1_LBN 16
0032 #define EF4_WORD_1_WIDTH 16
0033 #define EF4_DWORD_0_LBN 0
0034 #define EF4_DWORD_0_WIDTH 32
0035 #define EF4_DWORD_1_LBN 32
0036 #define EF4_DWORD_1_WIDTH 32
0037 #define EF4_DWORD_2_LBN 64
0038 #define EF4_DWORD_2_WIDTH 32
0039 #define EF4_DWORD_3_LBN 96
0040 #define EF4_DWORD_3_WIDTH 32
0041 #define EF4_QWORD_0_LBN 0
0042 #define EF4_QWORD_0_WIDTH 64
0043
0044 /* Specified attribute (e.g. LBN) of the specified field */
0045 #define EF4_VAL(field, attribute) field ## _ ## attribute
0046 /* Low bit number of the specified field */
0047 #define EF4_LOW_BIT(field) EF4_VAL(field, LBN)
0048 /* Bit width of the specified field */
0049 #define EF4_WIDTH(field) EF4_VAL(field, WIDTH)
0050 /* High bit number of the specified field */
0051 #define EF4_HIGH_BIT(field) (EF4_LOW_BIT(field) + EF4_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 EF4_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  * EF4_MASK64 for higher width fields.
0068  */
0069 #define EF4_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 ef4_dword {
0075     __le32 u32[1];
0076 } ef4_dword_t;
0077
0078 /* A quadword (i.e. 8 byte) datatype - little-endian in HW */
0079 typedef union ef4_qword {
0080     __le64 u64[1];
0081     __le32 u32[2];
0082     ef4_dword_t dword[2];
0083 } ef4_qword_t;
0084
0085 /* An octword (eight-word, i.e. 16 byte) datatype - little-endian in HW */
0086 typedef union ef4_oword {
0087     __le64 u64[2];
0088     ef4_qword_t qword[2];
0089     __le32 u32[4];
0090     ef4_dword_t dword[4];
0091 } ef4_oword_t;
0092
0093 /* Format string and value expanders for printk */
0094 #define EF4_DWORD_FMT "%08x"
0095 #define EF4_QWORD_FMT "%08x:%08x"
0096 #define EF4_OWORD_FMT "%08x:%08x:%08x:%08x"
0097 #define EF4_DWORD_VAL(dword)                \
0098     ((unsigned int) le32_to_cpu((dword).u32[0]))
0099 #define EF4_QWORD_VAL(qword)                \
0100     ((unsigned int) le32_to_cpu((qword).u32[1])),   \
0101     ((unsigned int) le32_to_cpu((qword).u32[0]))
0102 #define EF4_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 EF4_EXTRACT ( element, 32, 63, 28, 45 ) would give
0117  *
0118  *   ( element ) << 4
0119  *
0120  * The result will contain the relevant bits filled in the range
0121  * [0,high-low), with garbage in bits [high-low+1,...).
0122  */
0123 #define EF4_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 EF4_EXTRACT64(element, min, max, low, high)         \
0134     EF4_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 EF4_EXTRACT32(element, min, max, low, high)         \
0141     EF4_EXTRACT_NATIVE(le32_to_cpu(element), min, max, low, high)
0142
0143 #define EF4_EXTRACT_OWORD64(oword, low, high)               \
0144     ((EF4_EXTRACT64((oword).u64[0], 0, 63, low, high) |     \
0145       EF4_EXTRACT64((oword).u64[1], 64, 127, low, high)) &      \
0146      EF4_MASK64((high) + 1 - (low)))
0147
0148 #define EF4_EXTRACT_QWORD64(qword, low, high)               \
0149     (EF4_EXTRACT64((qword).u64[0], 0, 63, low, high) &      \
0150      EF4_MASK64((high) + 1 - (low)))
0151
0152 #define EF4_EXTRACT_OWORD32(oword, low, high)               \
0153     ((EF4_EXTRACT32((oword).u32[0], 0, 31, low, high) |     \
0154       EF4_EXTRACT32((oword).u32[1], 32, 63, low, high) |        \
0155       EF4_EXTRACT32((oword).u32[2], 64, 95, low, high) |        \
0156       EF4_EXTRACT32((oword).u32[3], 96, 127, low, high)) &      \
0157      EF4_MASK32((high) + 1 - (low)))
0158
0159 #define EF4_EXTRACT_QWORD32(qword, low, high)               \
0160     ((EF4_EXTRACT32((qword).u32[0], 0, 31, low, high) |     \
0161       EF4_EXTRACT32((qword).u32[1], 32, 63, low, high)) &       \
0162      EF4_MASK32((high) + 1 - (low)))
0163
0164 #define EF4_EXTRACT_DWORD(dword, low, high)         \
0165     (EF4_EXTRACT32((dword).u32[0], 0, 31, low, high) &  \
0166      EF4_MASK32((high) + 1 - (low)))
0167
0168 #define EF4_OWORD_FIELD64(oword, field)             \
0169     EF4_EXTRACT_OWORD64(oword, EF4_LOW_BIT(field),      \
0170                 EF4_HIGH_BIT(field))
0171
0172 #define EF4_QWORD_FIELD64(qword, field)             \
0173     EF4_EXTRACT_QWORD64(qword, EF4_LOW_BIT(field),      \
0174                 EF4_HIGH_BIT(field))
0175
0176 #define EF4_OWORD_FIELD32(oword, field)             \
0177     EF4_EXTRACT_OWORD32(oword, EF4_LOW_BIT(field),      \
0178                 EF4_HIGH_BIT(field))
0179
0180 #define EF4_QWORD_FIELD32(qword, field)             \
0181     EF4_EXTRACT_QWORD32(qword, EF4_LOW_BIT(field),      \
0182                 EF4_HIGH_BIT(field))
0183
0184 #define EF4_DWORD_FIELD(dword, field)               \
0185     EF4_EXTRACT_DWORD(dword, EF4_LOW_BIT(field),        \
0186               EF4_HIGH_BIT(field))
0187
0188 #define EF4_OWORD_IS_ZERO64(oword)                  \
0189     (((oword).u64[0] | (oword).u64[1]) == (__force __le64) 0)
0190
0191 #define EF4_QWORD_IS_ZERO64(qword)                  \
0192     (((qword).u64[0]) == (__force __le64) 0)
0193
0194 #define EF4_OWORD_IS_ZERO32(oword)                       \
0195     (((oword).u32[0] | (oword).u32[1] | (oword).u32[2] | (oword).u32[3]) \
0196      == (__force __le32) 0)
0197
0198 #define EF4_QWORD_IS_ZERO32(qword)                  \
0199     (((qword).u32[0] | (qword).u32[1]) == (__force __le32) 0)
0200
0201 #define EF4_DWORD_IS_ZERO(dword)                    \
0202     (((dword).u32[0]) == (__force __le32) 0)
0203
0204 #define EF4_OWORD_IS_ALL_ONES64(oword)                  \
0205     (((oword).u64[0] & (oword).u64[1]) == ~((__force __le64) 0))
0206
0207 #define EF4_QWORD_IS_ALL_ONES64(qword)                  \
0208     ((qword).u64[0] == ~((__force __le64) 0))
0209
0210 #define EF4_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 EF4_QWORD_IS_ALL_ONES32(qword)                  \
0215     (((qword).u32[0] & (qword).u32[1]) == ~((__force __le32) 0))
0216
0217 #define EF4_DWORD_IS_ALL_ONES(dword)                    \
0218     ((dword).u32[0] == ~((__force __le32) 0))
0219
0220 #if BITS_PER_LONG == 64
0221 #define EF4_OWORD_FIELD     EF4_OWORD_FIELD64
0222 #define EF4_QWORD_FIELD     EF4_QWORD_FIELD64
0223 #define EF4_OWORD_IS_ZERO   EF4_OWORD_IS_ZERO64
0224 #define EF4_QWORD_IS_ZERO   EF4_QWORD_IS_ZERO64
0225 #define EF4_OWORD_IS_ALL_ONES   EF4_OWORD_IS_ALL_ONES64
0226 #define EF4_QWORD_IS_ALL_ONES   EF4_QWORD_IS_ALL_ONES64
0227 #else
0228 #define EF4_OWORD_FIELD     EF4_OWORD_FIELD32
0229 #define EF4_QWORD_FIELD     EF4_QWORD_FIELD32
0230 #define EF4_OWORD_IS_ZERO   EF4_OWORD_IS_ZERO32
0231 #define EF4_QWORD_IS_ZERO   EF4_QWORD_IS_ZERO32
0232 #define EF4_OWORD_IS_ALL_ONES   EF4_OWORD_IS_ALL_ONES32
0233 #define EF4_QWORD_IS_ALL_ONES   EF4_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 EF4_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 EF4_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 EF4_INSERT_NATIVE(min, max, low, high, value)       \
0255     ((((max - min) >= 32) || ((high - low) >= 32)) ?    \
0256      EF4_INSERT_NATIVE64(min, max, low, high, value) :  \
0257      EF4_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 EF4_INSERT_FIELD_NATIVE(min, max, field, value)     \
0266     EF4_INSERT_NATIVE(min, max, EF4_LOW_BIT(field),     \
0267               EF4_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 EF4_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     (EF4_INSERT_FIELD_NATIVE((min), (max), field1, (value1)) |  \
0287      EF4_INSERT_FIELD_NATIVE((min), (max), field2, (value2)) |  \
0288      EF4_INSERT_FIELD_NATIVE((min), (max), field3, (value3)) |  \
0289      EF4_INSERT_FIELD_NATIVE((min), (max), field4, (value4)) |  \
0290      EF4_INSERT_FIELD_NATIVE((min), (max), field5, (value5)) |  \
0291      EF4_INSERT_FIELD_NATIVE((min), (max), field6, (value6)) |  \
0292      EF4_INSERT_FIELD_NATIVE((min), (max), field7, (value7)) |  \
0293      EF4_INSERT_FIELD_NATIVE((min), (max), field8, (value8)) |  \
0294      EF4_INSERT_FIELD_NATIVE((min), (max), field9, (value9)) |  \
0295      EF4_INSERT_FIELD_NATIVE((min), (max), field10, (value10)))
0296
0297 #define EF4_INSERT_FIELDS64(...)                \
0298     cpu_to_le64(EF4_INSERT_FIELDS_NATIVE(__VA_ARGS__))
0299
0300 #define EF4_INSERT_FIELDS32(...)                \
0301     cpu_to_le32(EF4_INSERT_FIELDS_NATIVE(__VA_ARGS__))
0302
0303 #define EF4_POPULATE_OWORD64(oword, ...) do {               \
0304     (oword).u64[0] = EF4_INSERT_FIELDS64(0, 63, __VA_ARGS__);   \
0305     (oword).u64[1] = EF4_INSERT_FIELDS64(64, 127, __VA_ARGS__); \
0306     } while (0)
0307
0308 #define EF4_POPULATE_QWORD64(qword, ...) do {               \
0309     (qword).u64[0] = EF4_INSERT_FIELDS64(0, 63, __VA_ARGS__);   \
0310     } while (0)
0311
0312 #define EF4_POPULATE_OWORD32(oword, ...) do {               \
0313     (oword).u32[0] = EF4_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0314     (oword).u32[1] = EF4_INSERT_FIELDS32(32, 63, __VA_ARGS__);  \
0315     (oword).u32[2] = EF4_INSERT_FIELDS32(64, 95, __VA_ARGS__);  \
0316     (oword).u32[3] = EF4_INSERT_FIELDS32(96, 127, __VA_ARGS__); \
0317     } while (0)
0318
0319 #define EF4_POPULATE_QWORD32(qword, ...) do {               \
0320     (qword).u32[0] = EF4_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0321     (qword).u32[1] = EF4_INSERT_FIELDS32(32, 63, __VA_ARGS__);  \
0322     } while (0)
0323
0324 #define EF4_POPULATE_DWORD(dword, ...) do {             \
0325     (dword).u32[0] = EF4_INSERT_FIELDS32(0, 31, __VA_ARGS__);   \
0326     } while (0)
0327
0328 #if BITS_PER_LONG == 64
0329 #define EF4_POPULATE_OWORD EF4_POPULATE_OWORD64
0330 #define EF4_POPULATE_QWORD EF4_POPULATE_QWORD64
0331 #else
0332 #define EF4_POPULATE_OWORD EF4_POPULATE_OWORD32
0333 #define EF4_POPULATE_QWORD EF4_POPULATE_QWORD32
0334 #endif
0335
0336 /* Populate an octword field with various numbers of arguments */
0337 #define EF4_POPULATE_OWORD_10 EF4_POPULATE_OWORD
0338 #define EF4_POPULATE_OWORD_9(oword, ...) \
0339     EF4_POPULATE_OWORD_10(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0340 #define EF4_POPULATE_OWORD_8(oword, ...) \
0341     EF4_POPULATE_OWORD_9(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0342 #define EF4_POPULATE_OWORD_7(oword, ...) \
0343     EF4_POPULATE_OWORD_8(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0344 #define EF4_POPULATE_OWORD_6(oword, ...) \
0345     EF4_POPULATE_OWORD_7(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0346 #define EF4_POPULATE_OWORD_5(oword, ...) \
0347     EF4_POPULATE_OWORD_6(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0348 #define EF4_POPULATE_OWORD_4(oword, ...) \
0349     EF4_POPULATE_OWORD_5(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0350 #define EF4_POPULATE_OWORD_3(oword, ...) \
0351     EF4_POPULATE_OWORD_4(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0352 #define EF4_POPULATE_OWORD_2(oword, ...) \
0353     EF4_POPULATE_OWORD_3(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0354 #define EF4_POPULATE_OWORD_1(oword, ...) \
0355     EF4_POPULATE_OWORD_2(oword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0356 #define EF4_ZERO_OWORD(oword) \
0357     EF4_POPULATE_OWORD_1(oword, EF4_DUMMY_FIELD, 0)
0358 #define EF4_SET_OWORD(oword) \
0359     EF4_POPULATE_OWORD_4(oword, \
0360                  EF4_DWORD_0, 0xffffffff, \
0361                  EF4_DWORD_1, 0xffffffff, \
0362                  EF4_DWORD_2, 0xffffffff, \
0363                  EF4_DWORD_3, 0xffffffff)
0364
0365 /* Populate a quadword field with various numbers of arguments */
0366 #define EF4_POPULATE_QWORD_10 EF4_POPULATE_QWORD
0367 #define EF4_POPULATE_QWORD_9(qword, ...) \
0368     EF4_POPULATE_QWORD_10(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0369 #define EF4_POPULATE_QWORD_8(qword, ...) \
0370     EF4_POPULATE_QWORD_9(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0371 #define EF4_POPULATE_QWORD_7(qword, ...) \
0372     EF4_POPULATE_QWORD_8(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0373 #define EF4_POPULATE_QWORD_6(qword, ...) \
0374     EF4_POPULATE_QWORD_7(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0375 #define EF4_POPULATE_QWORD_5(qword, ...) \
0376     EF4_POPULATE_QWORD_6(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0377 #define EF4_POPULATE_QWORD_4(qword, ...) \
0378     EF4_POPULATE_QWORD_5(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0379 #define EF4_POPULATE_QWORD_3(qword, ...) \
0380     EF4_POPULATE_QWORD_4(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0381 #define EF4_POPULATE_QWORD_2(qword, ...) \
0382     EF4_POPULATE_QWORD_3(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0383 #define EF4_POPULATE_QWORD_1(qword, ...) \
0384     EF4_POPULATE_QWORD_2(qword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0385 #define EF4_ZERO_QWORD(qword) \
0386     EF4_POPULATE_QWORD_1(qword, EF4_DUMMY_FIELD, 0)
0387 #define EF4_SET_QWORD(qword) \
0388     EF4_POPULATE_QWORD_2(qword, \
0389                  EF4_DWORD_0, 0xffffffff, \
0390                  EF4_DWORD_1, 0xffffffff)
0391
0392 /* Populate a dword field with various numbers of arguments */
0393 #define EF4_POPULATE_DWORD_10 EF4_POPULATE_DWORD
0394 #define EF4_POPULATE_DWORD_9(dword, ...) \
0395     EF4_POPULATE_DWORD_10(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0396 #define EF4_POPULATE_DWORD_8(dword, ...) \
0397     EF4_POPULATE_DWORD_9(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0398 #define EF4_POPULATE_DWORD_7(dword, ...) \
0399     EF4_POPULATE_DWORD_8(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0400 #define EF4_POPULATE_DWORD_6(dword, ...) \
0401     EF4_POPULATE_DWORD_7(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0402 #define EF4_POPULATE_DWORD_5(dword, ...) \
0403     EF4_POPULATE_DWORD_6(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0404 #define EF4_POPULATE_DWORD_4(dword, ...) \
0405     EF4_POPULATE_DWORD_5(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0406 #define EF4_POPULATE_DWORD_3(dword, ...) \
0407     EF4_POPULATE_DWORD_4(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0408 #define EF4_POPULATE_DWORD_2(dword, ...) \
0409     EF4_POPULATE_DWORD_3(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0410 #define EF4_POPULATE_DWORD_1(dword, ...) \
0411     EF4_POPULATE_DWORD_2(dword, EF4_DUMMY_FIELD, 0, __VA_ARGS__)
0412 #define EF4_ZERO_DWORD(dword) \
0413     EF4_POPULATE_DWORD_1(dword, EF4_DUMMY_FIELD, 0)
0414 #define EF4_SET_DWORD(dword) \
0415     EF4_POPULATE_DWORD_1(dword, EF4_DWORD_0, 0xffffffff)
0416
0417 /*
0418  * Modify a named field within an already-populated structure.  Used
0419  * for read-modify-write operations.
0420  *
0421  */
0422 #define EF4_INVERT_OWORD(oword) do {        \
0423     (oword).u64[0] = ~((oword).u64[0]); \
0424     (oword).u64[1] = ~((oword).u64[1]); \
0425     } while (0)
0426
0427 #define EF4_AND_OWORD(oword, from, mask)            \
0428     do {                            \
0429         (oword).u64[0] = (from).u64[0] & (mask).u64[0]; \
0430         (oword).u64[1] = (from).u64[1] & (mask).u64[1]; \
0431     } while (0)
0432
0433 #define EF4_OR_OWORD(oword, from, mask)             \
0434     do {                            \
0435         (oword).u64[0] = (from).u64[0] | (mask).u64[0]; \
0436         (oword).u64[1] = (from).u64[1] | (mask).u64[1]; \
0437     } while (0)
0438
0439 #define EF4_INSERT64(min, max, low, high, value)            \
0440     cpu_to_le64(EF4_INSERT_NATIVE(min, max, low, high, value))
0441
0442 #define EF4_INSERT32(min, max, low, high, value)            \
0443     cpu_to_le32(EF4_INSERT_NATIVE(min, max, low, high, value))
0444
0445 #define EF4_INPLACE_MASK64(min, max, low, high)             \
0446     EF4_INSERT64(min, max, low, high, EF4_MASK64((high) + 1 - (low)))
0447
0448 #define EF4_INPLACE_MASK32(min, max, low, high)             \
0449     EF4_INSERT32(min, max, low, high, EF4_MASK32((high) + 1 - (low)))
0450
0451 #define EF4_SET_OWORD64(oword, low, high, value) do {           \
0452     (oword).u64[0] = (((oword).u64[0]               \
0453                & ~EF4_INPLACE_MASK64(0,  63, low, high))    \
0454               | EF4_INSERT64(0,  63, low, high, value));    \
0455     (oword).u64[1] = (((oword).u64[1]               \
0456                & ~EF4_INPLACE_MASK64(64, 127, low, high))   \
0457               | EF4_INSERT64(64, 127, low, high, value));   \
0458     } while (0)
0459
0460 #define EF4_SET_QWORD64(qword, low, high, value) do {           \
0461     (qword).u64[0] = (((qword).u64[0]               \
0462                & ~EF4_INPLACE_MASK64(0, 63, low, high)) \
0463               | EF4_INSERT64(0, 63, low, high, value)); \
0464     } while (0)
0465
0466 #define EF4_SET_OWORD32(oword, low, high, value) do {           \
0467     (oword).u32[0] = (((oword).u32[0]               \
0468                & ~EF4_INPLACE_MASK32(0, 31, low, high)) \
0469               | EF4_INSERT32(0, 31, low, high, value)); \
0470     (oword).u32[1] = (((oword).u32[1]               \
0471                & ~EF4_INPLACE_MASK32(32, 63, low, high))    \
0472               | EF4_INSERT32(32, 63, low, high, value));    \
0473     (oword).u32[2] = (((oword).u32[2]               \
0474                & ~EF4_INPLACE_MASK32(64, 95, low, high))    \
0475               | EF4_INSERT32(64, 95, low, high, value));    \
0476     (oword).u32[3] = (((oword).u32[3]               \
0477                & ~EF4_INPLACE_MASK32(96, 127, low, high))   \
0478               | EF4_INSERT32(96, 127, low, high, value));   \
0479     } while (0)
0480
0481 #define EF4_SET_QWORD32(qword, low, high, value) do {           \
0482     (qword).u32[0] = (((qword).u32[0]               \
0483                & ~EF4_INPLACE_MASK32(0, 31, low, high)) \
0484               | EF4_INSERT32(0, 31, low, high, value)); \
0485     (qword).u32[1] = (((qword).u32[1]               \
0486                & ~EF4_INPLACE_MASK32(32, 63, low, high))    \
0487               | EF4_INSERT32(32, 63, low, high, value));    \
0488     } while (0)
0489
0490 #define EF4_SET_DWORD32(dword, low, high, value) do {           \
0491     (dword).u32[0] = (((dword).u32[0]               \
0492                & ~EF4_INPLACE_MASK32(0, 31, low, high)) \
0493               | EF4_INSERT32(0, 31, low, high, value)); \
0494     } while (0)
0495
0496 #define EF4_SET_OWORD_FIELD64(oword, field, value)          \
0497     EF4_SET_OWORD64(oword, EF4_LOW_BIT(field),          \
0498              EF4_HIGH_BIT(field), value)
0499
0500 #define EF4_SET_QWORD_FIELD64(qword, field, value)          \
0501     EF4_SET_QWORD64(qword, EF4_LOW_BIT(field),          \
0502              EF4_HIGH_BIT(field), value)
0503
0504 #define EF4_SET_OWORD_FIELD32(oword, field, value)          \
0505     EF4_SET_OWORD32(oword, EF4_LOW_BIT(field),          \
0506              EF4_HIGH_BIT(field), value)
0507
0508 #define EF4_SET_QWORD_FIELD32(qword, field, value)          \
0509     EF4_SET_QWORD32(qword, EF4_LOW_BIT(field),          \
0510              EF4_HIGH_BIT(field), value)
0511
0512 #define EF4_SET_DWORD_FIELD(dword, field, value)            \
0513     EF4_SET_DWORD32(dword, EF4_LOW_BIT(field),          \
0514              EF4_HIGH_BIT(field), value)
0515
0516
0517
0518 #if BITS_PER_LONG == 64
0519 #define EF4_SET_OWORD_FIELD EF4_SET_OWORD_FIELD64
0520 #define EF4_SET_QWORD_FIELD EF4_SET_QWORD_FIELD64
0521 #else
0522 #define EF4_SET_OWORD_FIELD EF4_SET_OWORD_FIELD32
0523 #define EF4_SET_QWORD_FIELD EF4_SET_QWORD_FIELD32
0524 #endif
0525
0526 /* Used to avoid compiler warnings about shift range exceeding width
0527  * of the data types when dma_addr_t is only 32 bits wide.
0528  */
0529 #define DMA_ADDR_T_WIDTH    (8 * sizeof(dma_addr_t))
0530 #define EF4_DMA_TYPE_WIDTH(width) \
0531     (((width) < DMA_ADDR_T_WIDTH) ? (width) : DMA_ADDR_T_WIDTH)
0532
0533
0534 /* Static initialiser */
0535 #define EF4_OWORD32(a, b, c, d)             \
0536     { .u32 = { cpu_to_le32(a), cpu_to_le32(b),  \
0537            cpu_to_le32(c), cpu_to_le32(d) } }
0538
0539 #endif /* EF4_BITFIELD_H */