Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #ifndef _LINUX_SWAB_H
  2. #define _LINUX_SWAB_H
  3.  
  4. #include <linux/types.h>
  5. #include <linux/compiler.h>
  6. #include <asm/swab.h>
  7.  
  8. /*
  9.  * casts are necessary for constants, because we never know how for sure
  10.  * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
  11.  */
  12. #define ___constant_swab16(x) ((__u16)(                         \
  13.         (((__u16)(x) & (__u16)0x00ffU) << 8) |                  \
  14.         (((__u16)(x) & (__u16)0xff00U) >> 8)))
  15.  
  16. #define ___constant_swab32(x) ((__u32)(                         \
  17.         (((__u32)(x) & (__u32)0x000000ffUL) << 24) |            \
  18.         (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) |            \
  19.         (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
  20.         (((__u32)(x) & (__u32)0xff000000UL) >> 24)))
  21.  
  22. #define ___constant_swab64(x) ((__u64)(                         \
  23.         (((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) |   \
  24.         (((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) |   \
  25.         (((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) |   \
  26.         (((__u64)(x) & (__u64)0x00000000ff000000ULL) <<  8) |   \
  27.         (((__u64)(x) & (__u64)0x000000ff00000000ULL) >>  8) |   \
  28.         (((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) |   \
  29.         (((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) |   \
  30.         (((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56)))
  31.  
  32. #define ___constant_swahw32(x) ((__u32)(                        \
  33.         (((__u32)(x) & (__u32)0x0000ffffUL) << 16) |            \
  34.         (((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
  35.  
  36. #define ___constant_swahb32(x) ((__u32)(                        \
  37.         (((__u32)(x) & (__u32)0x00ff00ffUL) << 8) |             \
  38.         (((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
  39.  
  40. /*
  41.  * Implement the following as inlines, but define the interface using
  42.  * macros to allow constant folding when possible:
  43.  * ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
  44.  */
  45.  
  46. static inline __attribute_const__ __u16 __fswab16(__u16 val)
  47. {
  48. #ifdef __arch_swab16
  49.         return __arch_swab16(val);
  50. #else
  51.         return ___constant_swab16(val);
  52. #endif
  53. }
  54.  
  55. static inline __attribute_const__ __u32 __fswab32(__u32 val)
  56. {
  57. #ifdef __arch_swab32
  58.         return __arch_swab32(val);
  59. #else
  60.         return ___constant_swab32(val);
  61. #endif
  62. }
  63.  
  64. static inline __attribute_const__ __u64 __fswab64(__u64 val)
  65. {
  66. #ifdef __arch_swab64
  67.         return __arch_swab64(val);
  68. #elif defined(__SWAB_64_THRU_32__)
  69.         __u32 h = val >> 32;
  70.         __u32 l = val & ((1ULL << 32) - 1);
  71.         return (((__u64)__fswab32(l)) << 32) | ((__u64)(__fswab32(h)));
  72. #else
  73.         return ___constant_swab64(val);
  74. #endif
  75. }
  76.  
  77. static inline __attribute_const__ __u32 __fswahw32(__u32 val)
  78. {
  79. #ifdef __arch_swahw32
  80.         return __arch_swahw32(val);
  81. #else
  82.         return ___constant_swahw32(val);
  83. #endif
  84. }
  85.  
  86. static inline __attribute_const__ __u32 __fswahb32(__u32 val)
  87. {
  88. #ifdef __arch_swahb32
  89.         return __arch_swahb32(val);
  90. #else
  91.         return ___constant_swahb32(val);
  92. #endif
  93. }
  94.  
  95. /**
  96.  * __swab16 - return a byteswapped 16-bit value
  97.  * @x: value to byteswap
  98.  */
  99. #define __swab16(x)                             \
  100.         (__builtin_constant_p((__u16)(x)) ?     \
  101.         ___constant_swab16(x) :                 \
  102.         __fswab16(x))
  103.  
  104. /**
  105.  * __swab32 - return a byteswapped 32-bit value
  106.  * @x: value to byteswap
  107.  */
  108. #define __swab32(x)                             \
  109.         (__builtin_constant_p((__u32)(x)) ?     \
  110.         ___constant_swab32(x) :                 \
  111.         __fswab32(x))
  112.  
  113. /**
  114.  * __swab64 - return a byteswapped 64-bit value
  115.  * @x: value to byteswap
  116.  */
  117. #define __swab64(x)                             \
  118.         (__builtin_constant_p((__u64)(x)) ?     \
  119.         ___constant_swab64(x) :                 \
  120.         __fswab64(x))
  121.  
  122. /**
  123.  * __swahw32 - return a word-swapped 32-bit value
  124.  * @x: value to wordswap
  125.  *
  126.  * __swahw32(0x12340000) is 0x00001234
  127.  */
  128. #define __swahw32(x)                            \
  129.         (__builtin_constant_p((__u32)(x)) ?     \
  130.         ___constant_swahw32(x) :                \
  131.         __fswahw32(x))
  132.  
  133. /**
  134.  * __swahb32 - return a high and low byte-swapped 32-bit value
  135.  * @x: value to byteswap
  136.  *
  137.  * __swahb32(0x12345678) is 0x34127856
  138.  */
  139. #define __swahb32(x)                            \
  140.         (__builtin_constant_p((__u32)(x)) ?     \
  141.         ___constant_swahb32(x) :                \
  142.         __fswahb32(x))
  143.  
  144. /**
  145.  * __swab16p - return a byteswapped 16-bit value from a pointer
  146.  * @p: pointer to a naturally-aligned 16-bit value
  147.  */
  148. static inline __u16 __swab16p(const __u16 *p)
  149. {
  150. #ifdef __arch_swab16p
  151.         return __arch_swab16p(p);
  152. #else
  153.         return __swab16(*p);
  154. #endif
  155. }
  156.  
  157. /**
  158.  * __swab32p - return a byteswapped 32-bit value from a pointer
  159.  * @p: pointer to a naturally-aligned 32-bit value
  160.  */
  161. static inline __u32 __swab32p(const __u32 *p)
  162. {
  163. #ifdef __arch_swab32p
  164.         return __arch_swab32p(p);
  165. #else
  166.         return __swab32(*p);
  167. #endif
  168. }
  169.  
  170. /**
  171.  * __swab64p - return a byteswapped 64-bit value from a pointer
  172.  * @p: pointer to a naturally-aligned 64-bit value
  173.  */
  174. static inline __u64 __swab64p(const __u64 *p)
  175. {
  176. #ifdef __arch_swab64p
  177.         return __arch_swab64p(p);
  178. #else
  179.         return __swab64(*p);
  180. #endif
  181. }
  182.  
  183. /**
  184.  * __swahw32p - return a wordswapped 32-bit value from a pointer
  185.  * @p: pointer to a naturally-aligned 32-bit value
  186.  *
  187.  * See __swahw32() for details of wordswapping.
  188.  */
  189. static inline __u32 __swahw32p(const __u32 *p)
  190. {
  191. #ifdef __arch_swahw32p
  192.         return __arch_swahw32p(p);
  193. #else
  194.         return __swahw32(*p);
  195. #endif
  196. }
  197.  
  198. /**
  199.  * __swahb32p - return a high and low byteswapped 32-bit value from a pointer
  200.  * @p: pointer to a naturally-aligned 32-bit value
  201.  *
  202.  * See __swahb32() for details of high/low byteswapping.
  203.  */
  204. static inline __u32 __swahb32p(const __u32 *p)
  205. {
  206. #ifdef __arch_swahb32p
  207.         return __arch_swahb32p(p);
  208. #else
  209.         return __swahb32(*p);
  210. #endif
  211. }
  212.  
  213. /**
  214.  * __swab16s - byteswap a 16-bit value in-place
  215.  * @p: pointer to a naturally-aligned 16-bit value
  216.  */
  217. static inline void __swab16s(__u16 *p)
  218. {
  219. #ifdef __arch_swab16s
  220.         __arch_swab16s(p);
  221. #else
  222.         *p = __swab16p(p);
  223. #endif
  224. }
  225. /**
  226.  * __swab32s - byteswap a 32-bit value in-place
  227.  * @p: pointer to a naturally-aligned 32-bit value
  228.  */
  229. static inline void __swab32s(__u32 *p)
  230. {
  231. #ifdef __arch_swab32s
  232.         __arch_swab32s(p);
  233. #else
  234.         *p = __swab32p(p);
  235. #endif
  236. }
  237.  
  238. /**
  239.  * __swab64s - byteswap a 64-bit value in-place
  240.  * @p: pointer to a naturally-aligned 64-bit value
  241.  */
  242. static inline void __swab64s(__u64 *p)
  243. {
  244. #ifdef __arch_swab64s
  245.         __arch_swab64s(p);
  246. #else
  247.         *p = __swab64p(p);
  248. #endif
  249. }
  250.  
  251. /**
  252.  * __swahw32s - wordswap a 32-bit value in-place
  253.  * @p: pointer to a naturally-aligned 32-bit value
  254.  *
  255.  * See __swahw32() for details of wordswapping
  256.  */
  257. static inline void __swahw32s(__u32 *p)
  258. {
  259. #ifdef __arch_swahw32s
  260.         __arch_swahw32s(p);
  261. #else
  262.         *p = __swahw32p(p);
  263. #endif
  264. }
  265.  
  266. /**
  267.  * __swahb32s - high and low byteswap a 32-bit value in-place
  268.  * @p: pointer to a naturally-aligned 32-bit value
  269.  *
  270.  * See __swahb32() for details of high and low byte swapping
  271.  */
  272. static inline void __swahb32s(__u32 *p)
  273. {
  274. #ifdef __arch_swahb32s
  275.         __arch_swahb32s(p);
  276. #else
  277.         *p = __swahb32p(p);
  278. #endif
  279. }
  280.  
  281. #ifdef __KERNEL__
  282. # define swab16 __swab16
  283. # define swab32 __swab32
  284. # define swab64 __swab64
  285. # define swahw32 __swahw32
  286. # define swahb32 __swahb32
  287. # define swab16p __swab16p
  288. # define swab32p __swab32p
  289. # define swab64p __swab64p
  290. # define swahw32p __swahw32p
  291. # define swahb32p __swahb32p
  292. # define swab16s __swab16s
  293. # define swab32s __swab32s
  294. # define swab64s __swab64s
  295. # define swahw32s __swahw32s
  296. # define swahb32s __swahb32s
  297. #endif /* __KERNEL__ */
  298.  
  299. #endif /* _LINUX_SWAB_H */
  300.