Context Navigation

source: bootcd/isolinux/syslinux-6.03/gpxe/src/drivers/net/etherfabric.h @ 26ffad7

Last change on this file since 26ffad7 was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 20.5 KB

Line
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	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: