Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_SWAB_H
3#define _LINUX_SWAB_H
4
5#include <uapi/linux/swab.h>
6
7# define swab16 __swab16
8# define swab32 __swab32
9# define swab64 __swab64
10# define swab __swab
11# define swahw32 __swahw32
12# define swahb32 __swahb32
13# define swab16p __swab16p
14# define swab32p __swab32p
15# define swab64p __swab64p
16# define swahw32p __swahw32p
17# define swahb32p __swahb32p
18# define swab16s __swab16s
19# define swab32s __swab32s
20# define swab64s __swab64s
21# define swahw32s __swahw32s
22# define swahb32s __swahb32s
23#endif /* _LINUX_SWAB_H */
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
46static 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
55static 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
64static 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
77static 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
86static 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 */
148static 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 */
161static 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 */
174static 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 */
189static 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 */
204static 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 */
217static 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 */
229static 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 */
242static 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 */
257static 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 */
272static 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 */