iPXE
etherfabric.h
Go to the documentation of this file.
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  */
efab_qword
A quadword (i.e.
Definition: etherfabric.h:111
efab_dword_t
union efab_dword efab_dword_t
A doubleword (i.e.
uint64_t
unsigned long long uint64_t
Definition: stdint.h:13
efab_dword
A doubleword (i.e.
Definition: etherfabric.h:102
u64
uint64_t u64
Definition: stdint.h:25
efab_dword::opaque
uint32_t opaque
Definition: etherfabric.h:104
efab_oword::qword
efab_qword_t qword[2]
Definition: etherfabric.h:124
uint32_t
unsigned int uint32_t
Definition: stdint.h:12
efab_oword
An octword (eight-word, i.e.
Definition: etherfabric.h:122
efab_qword_t
union efab_qword efab_qword_t
A quadword (i.e.
FILE_LICENCE
FILE_LICENCE(GPL_ANY)
efab_oword_t
union efab_oword efab_oword_t
An octword (eight-word, i.e.
dword
unsigned long int dword
Definition: smc9000.h:40
u32
uint32_t u32
Definition: stdint.h:23
Generated by   doxygen 1.8.15