Context Navigation

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

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

Rev	Line
[e16e8f2]	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: