You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

etherfabric.h 20KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553
  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. FILE_LICENCE ( GPL_ANY );
  20. #ifndef EFAB_BITFIELD_H
  21. #define EFAB_BITFIELD_H
  22. /** @file
  23. *
  24. * Etherfabric bitfield access
  25. *
  26. * Etherfabric NICs make extensive use of bitfields up to 128 bits
  27. * wide. Since there is no native 128-bit datatype on most systems,
  28. * and since 64-bit datatypes are inefficient on 32-bit systems and
  29. * vice versa, we wrap accesses in a way that uses the most efficient
  30. * datatype.
  31. *
  32. * The NICs are PCI devices and therefore little-endian. Since most
  33. * of the quantities that we deal with are DMAed to/from host memory,
  34. * we define our datatypes (efab_oword_t, efab_qword_t and
  35. * efab_dword_t) to be little-endian.
  36. *
  37. * In the less common case of using PIO for individual register
  38. * writes, we construct the little-endian datatype in host memory and
  39. * then use non-swapping equivalents of writel/writeq, rather than
  40. * constructing a native-endian datatype and relying on the implicit
  41. * byte-swapping done by writel/writeq. (We use a similar strategy
  42. * for register reads.)
  43. */
  44. /** Dummy field low bit number */
  45. #define EFAB_DUMMY_FIELD_LBN 0
  46. /** Dummy field width */
  47. #define EFAB_DUMMY_FIELD_WIDTH 0
  48. /** Dword 0 low bit number */
  49. #define EFAB_DWORD_0_LBN 0
  50. /** Dword 0 width */
  51. #define EFAB_DWORD_0_WIDTH 32
  52. /** Dword 1 low bit number */
  53. #define EFAB_DWORD_1_LBN 32
  54. /** Dword 1 width */
  55. #define EFAB_DWORD_1_WIDTH 32
  56. /** Dword 2 low bit number */
  57. #define EFAB_DWORD_2_LBN 64
  58. /** Dword 2 width */
  59. #define EFAB_DWORD_2_WIDTH 32
  60. /** Dword 3 low bit number */
  61. #define EFAB_DWORD_3_LBN 96
  62. /** Dword 3 width */
  63. #define EFAB_DWORD_3_WIDTH 32
  64. /** Specified attribute (e.g. LBN) of the specified field */
  65. #define EFAB_VAL(field,attribute) field ## _ ## attribute
  66. /** Low bit number of the specified field */
  67. #define EFAB_LOW_BIT( field ) EFAB_VAL ( field, LBN )
  68. /** Bit width of the specified field */
  69. #define EFAB_WIDTH( field ) EFAB_VAL ( field, WIDTH )
  70. /** High bit number of the specified field */
  71. #define EFAB_HIGH_BIT(field) ( EFAB_LOW_BIT(field) + EFAB_WIDTH(field) - 1 )
  72. /** Mask equal in width to the specified field.
  73. *
  74. * For example, a field with width 5 would have a mask of 0x1f.
  75. *
  76. * The maximum width mask that can be generated is 64 bits.
  77. */
  78. #define EFAB_MASK64( field ) \
  79. ( EFAB_WIDTH(field) == 64 ? ~( ( uint64_t ) 0 ) : \
  80. ( ( ( ( ( uint64_t ) 1 ) << EFAB_WIDTH(field) ) ) - 1 ) )
  81. /** Mask equal in width to the specified field.
  82. *
  83. * For example, a field with width 5 would have a mask of 0x1f.
  84. *
  85. * The maximum width mask that can be generated is 32 bits. Use
  86. * EFAB_MASK64 for higher width fields.
  87. */
  88. #define EFAB_MASK32( field ) \
  89. ( EFAB_WIDTH(field) == 32 ? ~( ( uint32_t ) 0 ) : \
  90. ( ( ( ( ( uint32_t ) 1 ) << EFAB_WIDTH(field) ) ) - 1 ) )
  91. /** A doubleword (i.e. 4 byte) datatype
  92. *
  93. * This datatype is defined to be little-endian.
  94. */
  95. typedef union efab_dword {
  96. uint32_t u32[1];
  97. uint32_t opaque; /* For bitwise operations between two efab_dwords */
  98. } efab_dword_t;
  99. /** A quadword (i.e. 8 byte) datatype
  100. *
  101. * This datatype is defined to be little-endian.
  102. */
  103. typedef union efab_qword {
  104. uint64_t u64[1];
  105. uint32_t u32[2];
  106. efab_dword_t dword[2];
  107. } efab_qword_t;
  108. /**
  109. * An octword (eight-word, i.e. 16 byte) datatype
  110. *
  111. * This datatype is defined to be little-endian.
  112. */
  113. typedef union efab_oword {
  114. uint64_t u64[2];
  115. efab_qword_t qword[2];
  116. uint32_t u32[4];
  117. efab_dword_t dword[4];
  118. } efab_oword_t;
  119. /** Format string for printing an efab_dword_t */
  120. #define EFAB_DWORD_FMT "%08x"
  121. /** Format string for printing an efab_qword_t */
  122. #define EFAB_QWORD_FMT "%08x:%08x"
  123. /** Format string for printing an efab_oword_t */
  124. #define EFAB_OWORD_FMT "%08x:%08x:%08x:%08x"
  125. /** printk parameters for printing an efab_dword_t */
  126. #define EFAB_DWORD_VAL(dword) \
  127. ( ( unsigned int ) le32_to_cpu ( (dword).u32[0] ) )
  128. /** printk parameters for printing an efab_qword_t */
  129. #define EFAB_QWORD_VAL(qword) \
  130. ( ( unsigned int ) le32_to_cpu ( (qword).u32[1] ) ), \
  131. ( ( unsigned int ) le32_to_cpu ( (qword).u32[0] ) )
  132. /** printk parameters for printing an efab_oword_t */
  133. #define EFAB_OWORD_VAL(oword) \
  134. ( ( unsigned int ) le32_to_cpu ( (oword).u32[3] ) ), \
  135. ( ( unsigned int ) le32_to_cpu ( (oword).u32[2] ) ), \
  136. ( ( unsigned int ) le32_to_cpu ( (oword).u32[1] ) ), \
  137. ( ( unsigned int ) le32_to_cpu ( (oword).u32[0] ) )
  138. /**
  139. * Extract bit field portion [low,high) from the native-endian element
  140. * which contains bits [min,max).
  141. *
  142. * For example, suppose "element" represents the high 32 bits of a
  143. * 64-bit value, and we wish to extract the bits belonging to the bit
  144. * field occupying bits 28-45 of this 64-bit value.
  145. *
  146. * Then EFAB_EXTRACT ( element, 32, 63, 28, 45 ) would give
  147. *
  148. * ( element ) << 4
  149. *
  150. * The result will contain the relevant bits filled in in the range
  151. * [0,high-low), with garbage in bits [high-low+1,...).
  152. */
  153. #define EFAB_EXTRACT_NATIVE( native_element, min ,max ,low ,high ) \
  154. ( ( ( low > max ) || ( high < min ) ) ? 0 : \
  155. ( ( low > min ) ? \
  156. ( (native_element) >> ( low - min ) ) : \
  157. ( (native_element) << ( min - low ) ) ) )
  158. /**
  159. * Extract bit field portion [low,high) from the 64-bit little-endian
  160. * element which contains bits [min,max)
  161. */
  162. #define EFAB_EXTRACT64( element, min, max, low, high ) \
  163. EFAB_EXTRACT_NATIVE ( le64_to_cpu(element), min, max, low, high )
  164. /**
  165. * Extract bit field portion [low,high) from the 32-bit little-endian
  166. * element which contains bits [min,max)
  167. */
  168. #define EFAB_EXTRACT32( element, min, max, low, high ) \
  169. EFAB_EXTRACT_NATIVE ( le32_to_cpu(element), min, max, low, high )
  170. #define EFAB_EXTRACT_OWORD64( oword, low, high ) \
  171. ( EFAB_EXTRACT64 ( (oword).u64[0], 0, 63, low, high ) | \
  172. EFAB_EXTRACT64 ( (oword).u64[1], 64, 127, low, high ) )
  173. #define EFAB_EXTRACT_QWORD64( qword, low, high ) \
  174. ( EFAB_EXTRACT64 ( (qword).u64[0], 0, 63, low, high ) )
  175. #define EFAB_EXTRACT_OWORD32( oword, low, high ) \
  176. ( EFAB_EXTRACT32 ( (oword).u32[0], 0, 31, low, high ) | \
  177. EFAB_EXTRACT32 ( (oword).u32[1], 32, 63, low, high ) | \
  178. EFAB_EXTRACT32 ( (oword).u32[2], 64, 95, low, high ) | \
  179. EFAB_EXTRACT32 ( (oword).u32[3], 96, 127, low, high ) )
  180. #define EFAB_EXTRACT_QWORD32( qword, low, high ) \
  181. ( EFAB_EXTRACT32 ( (qword).u32[0], 0, 31, low, high ) | \
  182. EFAB_EXTRACT32 ( (qword).u32[1], 32, 63, low, high ) )
  183. #define EFAB_EXTRACT_DWORD( dword, low, high ) \
  184. ( EFAB_EXTRACT32 ( (dword).u32[0], 0, 31, low, high ) )
  185. #define EFAB_OWORD_FIELD64( oword, field ) \
  186. ( EFAB_EXTRACT_OWORD64 ( oword, EFAB_LOW_BIT ( field ), \
  187. EFAB_HIGH_BIT ( field ) ) & \
  188. EFAB_MASK64 ( field ) )
  189. #define EFAB_QWORD_FIELD64( qword, field ) \
  190. ( EFAB_EXTRACT_QWORD64 ( qword, EFAB_LOW_BIT ( field ), \
  191. EFAB_HIGH_BIT ( field ) ) & \
  192. EFAB_MASK64 ( field ) )
  193. #define EFAB_OWORD_FIELD32( oword, field ) \
  194. ( EFAB_EXTRACT_OWORD32 ( oword, EFAB_LOW_BIT ( field ), \
  195. EFAB_HIGH_BIT ( field ) ) & \
  196. EFAB_MASK32 ( field ) )
  197. #define EFAB_QWORD_FIELD32( qword, field ) \
  198. ( EFAB_EXTRACT_QWORD32 ( qword, EFAB_LOW_BIT ( field ), \
  199. EFAB_HIGH_BIT ( field ) ) & \
  200. EFAB_MASK32 ( field ) )
  201. #define EFAB_DWORD_FIELD( dword, field ) \
  202. ( EFAB_EXTRACT_DWORD ( dword, EFAB_LOW_BIT ( field ), \
  203. EFAB_HIGH_BIT ( field ) ) & \
  204. EFAB_MASK32 ( field ) )
  205. #define EFAB_OWORD_IS_ZERO64( oword ) \
  206. ( ! ( (oword).u64[0] || (oword).u64[1] ) )
  207. #define EFAB_QWORD_IS_ZERO64( qword ) \
  208. ( ! ( (qword).u64[0] ) )
  209. #define EFAB_OWORD_IS_ZERO32( oword ) \
  210. ( ! ( (oword).u32[0] || (oword).u32[1] || \
  211. (oword).u32[2] || (oword).u32[3] ) )
  212. #define EFAB_QWORD_IS_ZERO32( qword ) \
  213. ( ! ( (qword).u32[0] || (qword).u32[1] ) )
  214. #define EFAB_DWORD_IS_ZERO( dword ) \
  215. ( ! ( (dword).u32[0] ) )
  216. #define EFAB_OWORD_IS_ALL_ONES64( oword ) \
  217. ( ( (oword).u64[0] & (oword).u64[1] ) == ~( ( uint64_t ) 0 ) )
  218. #define EFAB_QWORD_IS_ALL_ONES64( qword ) \
  219. ( (qword).u64[0] == ~( ( uint64_t ) 0 ) )
  220. #define EFAB_OWORD_IS_ALL_ONES32( oword ) \
  221. ( ( (oword).u32[0] & (oword).u32[1] & \
  222. (oword).u32[2] & (oword).u32[3] ) == ~( ( uint32_t ) 0 ) )
  223. #define EFAB_QWORD_IS_ALL_ONES32( qword ) \
  224. ( ( (qword).u32[0] & (qword).u32[1] ) == ~( ( uint32_t ) 0 ) )
  225. #define EFAB_DWORD_IS_ALL_ONES( dword ) \
  226. ( (dword).u32[0] == ~( ( uint32_t ) 0 ) )
  227. #if ( BITS_PER_LONG == 64 )
  228. #define EFAB_OWORD_FIELD EFAB_OWORD_FIELD64
  229. #define EFAB_QWORD_FIELD EFAB_QWORD_FIELD64
  230. #define EFAB_OWORD_IS_ZERO EFAB_OWORD_IS_ZERO64
  231. #define EFAB_QWORD_IS_ZERO EFAB_QWORD_IS_ZERO64
  232. #define EFAB_OWORD_IS_ALL_ONES EFAB_OWORD_IS_ALL_ONES64
  233. #define EFAB_QWORD_IS_ALL_ONES EFAB_QWORD_IS_ALL_ONES64
  234. #else
  235. #define EFAB_OWORD_FIELD EFAB_OWORD_FIELD32
  236. #define EFAB_QWORD_FIELD EFAB_QWORD_FIELD32
  237. #define EFAB_OWORD_IS_ZERO EFAB_OWORD_IS_ZERO32
  238. #define EFAB_QWORD_IS_ZERO EFAB_QWORD_IS_ZERO32
  239. #define EFAB_OWORD_IS_ALL_ONES EFAB_OWORD_IS_ALL_ONES32
  240. #define EFAB_QWORD_IS_ALL_ONES EFAB_QWORD_IS_ALL_ONES32
  241. #endif
  242. /**
  243. * Construct bit field portion
  244. *
  245. * Creates the portion of the bit field [low,high) that lies within
  246. * the range [min,max).
  247. */
  248. #define EFAB_INSERT_NATIVE64( min, max, low, high, value ) \
  249. ( ( ( low > max ) || ( high < min ) ) ? 0 : \
  250. ( ( low > min ) ? \
  251. ( ( ( uint64_t ) (value) ) << ( low - min ) ) : \
  252. ( ( ( uint64_t ) (value) ) >> ( min - low ) ) ) )
  253. #define EFAB_INSERT_NATIVE32( min, max, low, high, value ) \
  254. ( ( ( low > max ) || ( high < min ) ) ? 0 : \
  255. ( ( low > min ) ? \
  256. ( ( ( uint32_t ) (value) ) << ( low - min ) ) : \
  257. ( ( ( uint32_t ) (value) ) >> ( min - low ) ) ) )
  258. #define EFAB_INSERT_NATIVE( min, max, low, high, value ) \
  259. ( ( ( ( max - min ) >= 32 ) || \
  260. ( ( high - low ) >= 32 ) ) \
  261. ? EFAB_INSERT_NATIVE64 ( min, max, low, high, value ) \
  262. : EFAB_INSERT_NATIVE32 ( min, max, low, high, value ) )
  263. /**
  264. * Construct bit field portion
  265. *
  266. * Creates the portion of the named bit field that lies within the
  267. * range [min,max).
  268. */
  269. #define EFAB_INSERT_FIELD_NATIVE( min, max, field, value ) \
  270. EFAB_INSERT_NATIVE ( min, max, EFAB_LOW_BIT ( field ), \
  271. EFAB_HIGH_BIT ( field ), value )
  272. /**
  273. * Construct bit field
  274. *
  275. * Creates the portion of the named bit fields that lie within the
  276. * range [min,max).
  277. */
  278. #define EFAB_INSERT_FIELDS_NATIVE( min, max, \
  279. field1, value1, \
  280. field2, value2, \
  281. field3, value3, \
  282. field4, value4, \
  283. field5, value5, \
  284. field6, value6, \
  285. field7, value7, \
  286. field8, value8, \
  287. field9, value9, \
  288. field10, value10 ) \
  289. ( EFAB_INSERT_FIELD_NATIVE ( min, max, field1, value1 ) | \
  290. EFAB_INSERT_FIELD_NATIVE ( min, max, field2, value2 ) | \
  291. EFAB_INSERT_FIELD_NATIVE ( min, max, field3, value3 ) | \
  292. EFAB_INSERT_FIELD_NATIVE ( min, max, field4, value4 ) | \
  293. EFAB_INSERT_FIELD_NATIVE ( min, max, field5, value5 ) | \
  294. EFAB_INSERT_FIELD_NATIVE ( min, max, field6, value6 ) | \
  295. EFAB_INSERT_FIELD_NATIVE ( min, max, field7, value7 ) | \
  296. EFAB_INSERT_FIELD_NATIVE ( min, max, field8, value8 ) | \
  297. EFAB_INSERT_FIELD_NATIVE ( min, max, field9, value9 ) | \
  298. EFAB_INSERT_FIELD_NATIVE ( min, max, field10, value10 ) )
  299. #define EFAB_INSERT_FIELDS64( ... ) \
  300. cpu_to_le64 ( EFAB_INSERT_FIELDS_NATIVE ( __VA_ARGS__ ) )
  301. #define EFAB_INSERT_FIELDS32( ... ) \
  302. cpu_to_le32 ( EFAB_INSERT_FIELDS_NATIVE ( __VA_ARGS__ ) )
  303. #define EFAB_POPULATE_OWORD64( oword, ... ) do { \
  304. (oword).u64[0] = EFAB_INSERT_FIELDS64 ( 0, 63, __VA_ARGS__ );\
  305. (oword).u64[1] = EFAB_INSERT_FIELDS64 ( 64, 127, __VA_ARGS__ );\
  306. } while ( 0 )
  307. #define EFAB_POPULATE_QWORD64( qword, ... ) do { \
  308. (qword).u64[0] = EFAB_INSERT_FIELDS64 ( 0, 63, __VA_ARGS__ );\
  309. } while ( 0 )
  310. #define EFAB_POPULATE_OWORD32( oword, ... ) do { \
  311. (oword).u32[0] = EFAB_INSERT_FIELDS32 ( 0, 31, __VA_ARGS__ );\
  312. (oword).u32[1] = EFAB_INSERT_FIELDS32 ( 32, 63, __VA_ARGS__ );\
  313. (oword).u32[2] = EFAB_INSERT_FIELDS32 ( 64, 95, __VA_ARGS__ );\
  314. (oword).u32[3] = EFAB_INSERT_FIELDS32 ( 96, 127, __VA_ARGS__ );\
  315. } while ( 0 )
  316. #define EFAB_POPULATE_QWORD32( qword, ... ) do { \
  317. (qword).u32[0] = EFAB_INSERT_FIELDS32 ( 0, 31, __VA_ARGS__ );\
  318. (qword).u32[1] = EFAB_INSERT_FIELDS32 ( 32, 63, __VA_ARGS__ );\
  319. } while ( 0 )
  320. #define EFAB_POPULATE_DWORD( dword, ... ) do { \
  321. (dword).u32[0] = EFAB_INSERT_FIELDS32 ( 0, 31, __VA_ARGS__ );\
  322. } while ( 0 )
  323. #if ( BITS_PER_LONG == 64 )
  324. #define EFAB_POPULATE_OWORD EFAB_POPULATE_OWORD64
  325. #define EFAB_POPULATE_QWORD EFAB_POPULATE_QWORD64
  326. #else
  327. #define EFAB_POPULATE_OWORD EFAB_POPULATE_OWORD32
  328. #define EFAB_POPULATE_QWORD EFAB_POPULATE_QWORD32
  329. #endif
  330. /* Populate an octword field with various numbers of arguments */
  331. #define EFAB_POPULATE_OWORD_10 EFAB_POPULATE_OWORD
  332. #define EFAB_POPULATE_OWORD_9( oword, ... ) \
  333. EFAB_POPULATE_OWORD_10 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  334. #define EFAB_POPULATE_OWORD_8( oword, ... ) \
  335. EFAB_POPULATE_OWORD_9 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  336. #define EFAB_POPULATE_OWORD_7( oword, ... ) \
  337. EFAB_POPULATE_OWORD_8 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  338. #define EFAB_POPULATE_OWORD_6( oword, ... ) \
  339. EFAB_POPULATE_OWORD_7 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  340. #define EFAB_POPULATE_OWORD_5( oword, ... ) \
  341. EFAB_POPULATE_OWORD_6 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  342. #define EFAB_POPULATE_OWORD_4( oword, ... ) \
  343. EFAB_POPULATE_OWORD_5 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  344. #define EFAB_POPULATE_OWORD_3( oword, ... ) \
  345. EFAB_POPULATE_OWORD_4 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  346. #define EFAB_POPULATE_OWORD_2( oword, ... ) \
  347. EFAB_POPULATE_OWORD_3 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  348. #define EFAB_POPULATE_OWORD_1( oword, ... ) \
  349. EFAB_POPULATE_OWORD_2 ( oword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  350. #define EFAB_ZERO_OWORD( oword ) \
  351. EFAB_POPULATE_OWORD_1 ( oword, EFAB_DUMMY_FIELD, 0 )
  352. #define EFAB_SET_OWORD( oword ) \
  353. EFAB_POPULATE_OWORD_4 ( oword, \
  354. EFAB_DWORD_0, 0xffffffff, \
  355. EFAB_DWORD_1, 0xffffffff, \
  356. EFAB_DWORD_2, 0xffffffff, \
  357. EFAB_DWORD_3, 0xffffffff )
  358. /* Populate a quadword field with various numbers of arguments */
  359. #define EFAB_POPULATE_QWORD_10 EFAB_POPULATE_QWORD
  360. #define EFAB_POPULATE_QWORD_9( qword, ... ) \
  361. EFAB_POPULATE_QWORD_10 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  362. #define EFAB_POPULATE_QWORD_8( qword, ... ) \
  363. EFAB_POPULATE_QWORD_9 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  364. #define EFAB_POPULATE_QWORD_7( qword, ... ) \
  365. EFAB_POPULATE_QWORD_8 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  366. #define EFAB_POPULATE_QWORD_6( qword, ... ) \
  367. EFAB_POPULATE_QWORD_7 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  368. #define EFAB_POPULATE_QWORD_5( qword, ... ) \
  369. EFAB_POPULATE_QWORD_6 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  370. #define EFAB_POPULATE_QWORD_4( qword, ... ) \
  371. EFAB_POPULATE_QWORD_5 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  372. #define EFAB_POPULATE_QWORD_3( qword, ... ) \
  373. EFAB_POPULATE_QWORD_4 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  374. #define EFAB_POPULATE_QWORD_2( qword, ... ) \
  375. EFAB_POPULATE_QWORD_3 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  376. #define EFAB_POPULATE_QWORD_1( qword, ... ) \
  377. EFAB_POPULATE_QWORD_2 ( qword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  378. #define EFAB_ZERO_QWORD( qword ) \
  379. EFAB_POPULATE_QWORD_1 ( qword, EFAB_DUMMY_FIELD, 0 )
  380. #define EFAB_SET_QWORD( qword ) \
  381. EFAB_POPULATE_QWORD_2 ( qword, \
  382. EFAB_DWORD_0, 0xffffffff, \
  383. EFAB_DWORD_1, 0xffffffff )
  384. /* Populate a dword field with various numbers of arguments */
  385. #define EFAB_POPULATE_DWORD_10 EFAB_POPULATE_DWORD
  386. #define EFAB_POPULATE_DWORD_9( dword, ... ) \
  387. EFAB_POPULATE_DWORD_10 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  388. #define EFAB_POPULATE_DWORD_8( dword, ... ) \
  389. EFAB_POPULATE_DWORD_9 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  390. #define EFAB_POPULATE_DWORD_7( dword, ... ) \
  391. EFAB_POPULATE_DWORD_8 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  392. #define EFAB_POPULATE_DWORD_6( dword, ... ) \
  393. EFAB_POPULATE_DWORD_7 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  394. #define EFAB_POPULATE_DWORD_5( dword, ... ) \
  395. EFAB_POPULATE_DWORD_6 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  396. #define EFAB_POPULATE_DWORD_4( dword, ... ) \
  397. EFAB_POPULATE_DWORD_5 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  398. #define EFAB_POPULATE_DWORD_3( dword, ... ) \
  399. EFAB_POPULATE_DWORD_4 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  400. #define EFAB_POPULATE_DWORD_2( dword, ... ) \
  401. EFAB_POPULATE_DWORD_3 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  402. #define EFAB_POPULATE_DWORD_1( dword, ... ) \
  403. EFAB_POPULATE_DWORD_2 ( dword, EFAB_DUMMY_FIELD, 0, __VA_ARGS__ )
  404. #define EFAB_ZERO_DWORD( dword ) \
  405. EFAB_POPULATE_DWORD_1 ( dword, EFAB_DUMMY_FIELD, 0 )
  406. #define EFAB_SET_DWORD( dword ) \
  407. EFAB_POPULATE_DWORD_1 ( dword, EFAB_DWORD_0, 0xffffffff )
  408. /*
  409. * Modify a named field within an already-populated structure. Used
  410. * for read-modify-write operations.
  411. *
  412. */
  413. #define EFAB_INSERT_FIELD64( ... ) \
  414. cpu_to_le64 ( EFAB_INSERT_FIELD_NATIVE ( __VA_ARGS__ ) )
  415. #define EFAB_INSERT_FIELD32( ... ) \
  416. cpu_to_le32 ( EFAB_INSERT_FIELD_NATIVE ( __VA_ARGS__ ) )
  417. #define EFAB_INPLACE_MASK64( min, max, field ) \
  418. EFAB_INSERT_FIELD64 ( min, max, field, EFAB_MASK64 ( field ) )
  419. #define EFAB_INPLACE_MASK32( min, max, field ) \
  420. EFAB_INSERT_FIELD32 ( min, max, field, EFAB_MASK32 ( field ) )
  421. #define EFAB_SET_OWORD_FIELD64( oword, field, value ) do { \
  422. (oword).u64[0] = ( ( (oword).u64[0] \
  423. & ~EFAB_INPLACE_MASK64 ( 0, 63, field ) ) \
  424. | EFAB_INSERT_FIELD64 ( 0, 63, field, value ) ); \
  425. (oword).u64[1] = ( ( (oword).u64[1] \
  426. & ~EFAB_INPLACE_MASK64 ( 64, 127, field ) ) \
  427. | EFAB_INSERT_FIELD64 ( 64, 127, field, value ) ); \
  428. } while ( 0 )
  429. #define EFAB_SET_QWORD_FIELD64( qword, field, value ) do { \
  430. (qword).u64[0] = ( ( (qword).u64[0] \
  431. & ~EFAB_INPLACE_MASK64 ( 0, 63, field ) ) \
  432. | EFAB_INSERT_FIELD64 ( 0, 63, field, value ) ); \
  433. } while ( 0 )
  434. #define EFAB_SET_OWORD_FIELD32( oword, field, value ) do { \
  435. (oword).u32[0] = ( ( (oword).u32[0] \
  436. & ~EFAB_INPLACE_MASK32 ( 0, 31, field ) ) \
  437. | EFAB_INSERT_FIELD32 ( 0, 31, field, value ) ); \
  438. (oword).u32[1] = ( ( (oword).u32[1] \
  439. & ~EFAB_INPLACE_MASK32 ( 32, 63, field ) ) \
  440. | EFAB_INSERT_FIELD32 ( 32, 63, field, value ) ); \
  441. (oword).u32[2] = ( ( (oword).u32[2] \
  442. & ~EFAB_INPLACE_MASK32 ( 64, 95, field ) ) \
  443. | EFAB_INSERT_FIELD32 ( 64, 95, field, value ) ); \
  444. (oword).u32[3] = ( ( (oword).u32[3] \
  445. & ~EFAB_INPLACE_MASK32 ( 96, 127, field ) ) \
  446. | EFAB_INSERT_FIELD32 ( 96, 127, field, value ) ); \
  447. } while ( 0 )
  448. #define EFAB_SET_QWORD_FIELD32( qword, field, value ) do { \
  449. (qword).u32[0] = ( ( (qword).u32[0] \
  450. & ~EFAB_INPLACE_MASK32 ( 0, 31, field ) ) \
  451. | EFAB_INSERT_FIELD32 ( 0, 31, field, value ) ); \
  452. (qword).u32[1] = ( ( (qword).u32[1] \
  453. & ~EFAB_INPLACE_MASK32 ( 32, 63, field ) ) \
  454. | EFAB_INSERT_FIELD32 ( 32, 63, field, value ) ); \
  455. } while ( 0 )
  456. #define EFAB_SET_DWORD_FIELD( dword, field, value ) do { \
  457. (dword).u32[0] = ( ( (dword).u32[0] \
  458. & ~EFAB_INPLACE_MASK32 ( 0, 31, field ) ) \
  459. | EFAB_INSERT_FIELD32 ( 0, 31, field, value ) ); \
  460. } while ( 0 )
  461. #if ( BITS_PER_LONG == 64 )
  462. #define EFAB_SET_OWORD_FIELD EFAB_SET_OWORD_FIELD64
  463. #define EFAB_SET_QWORD_FIELD EFAB_SET_QWORD_FIELD64
  464. #else
  465. #define EFAB_SET_OWORD_FIELD EFAB_SET_OWORD_FIELD32
  466. #define EFAB_SET_QWORD_FIELD EFAB_SET_QWORD_FIELD32
  467. #endif
  468. /* Used to avoid compiler warnings about shift range exceeding width
  469. * of the data types when dma_addr_t is only 32 bits wide.
  470. */
  471. #define DMA_ADDR_T_WIDTH ( 8 * sizeof ( dma_addr_t ) )
  472. #define EFAB_DMA_TYPE_WIDTH( width ) \
  473. ( ( (width) < DMA_ADDR_T_WIDTH ) ? (width) : DMA_ADDR_T_WIDTH )
  474. #define EFAB_DMA_MAX_MASK ( ( DMA_ADDR_T_WIDTH == 64 ) ? \
  475. ~( ( uint64_t ) 0 ) : ~( ( uint32_t ) 0 ) )
  476. #define EFAB_DMA_MASK(mask) ( (mask) & EFAB_DMA_MAX_MASK )
  477. #endif /* EFAB_BITFIELD_H */
  478. /*
  479. * Local variables:
  480. * c-basic-offset: 8
  481. * c-indent-level: 8
  482. * tab-width: 8
  483. * End:
  484. */