1 /************************************************************************** 2 * 3 * GPL net driver for Level 5 Etherfabric network cards 4 * 5 * Written by Michael Brown <mbrown@fensystems.co.uk> 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 */ 554