1
2#ifndef _LINUX_BITOPS_H
3#define _LINUX_BITOPS_H
4
5#include <asm/types.h>
6#include <linux/bits.h>
7#include <linux/typecheck.h>
8
9#include <uapi/linux/kernel.h>
10
11
12#ifdef __LITTLE_ENDIAN
13# define aligned_byte_mask(n) ((1UL << 8*(n))-1)
14#else
15# define aligned_byte_mask(n) (~0xffUL << (BITS_PER_LONG - 8 - 8*(n)))
16#endif
17
18#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
19#define BITS_TO_LONGS(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(long))
20#define BITS_TO_U64(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(u64))
21#define BITS_TO_U32(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(u32))
22#define BITS_TO_BYTES(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(char))
23
24extern unsigned int __sw_hweight8(unsigned int w);
25extern unsigned int __sw_hweight16(unsigned int w);
26extern unsigned int __sw_hweight32(unsigned int w);
27extern unsigned long __sw_hweight64(__u64 w);
28
29
30
31
32
33#include <asm/bitops.h>
34
35#define for_each_set_bit(bit, addr, size) \
36 for ((bit) = find_first_bit((addr), (size)); \
37 (bit) < (size); \
38 (bit) = find_next_bit((addr), (size), (bit) + 1))
39
40
41#define for_each_set_bit_from(bit, addr, size) \
42 for ((bit) = find_next_bit((addr), (size), (bit)); \
43 (bit) < (size); \
44 (bit) = find_next_bit((addr), (size), (bit) + 1))
45
46#define for_each_clear_bit(bit, addr, size) \
47 for ((bit) = find_first_zero_bit((addr), (size)); \
48 (bit) < (size); \
49 (bit) = find_next_zero_bit((addr), (size), (bit) + 1))
50
51
52#define for_each_clear_bit_from(bit, addr, size) \
53 for ((bit) = find_next_zero_bit((addr), (size), (bit)); \
54 (bit) < (size); \
55 (bit) = find_next_zero_bit((addr), (size), (bit) + 1))
56
57
58
59
60
61
62
63
64#define for_each_set_clump8(start, clump, bits, size) \
65 for ((start) = find_first_clump8(&(clump), (bits), (size)); \
66 (start) < (size); \
67 (start) = find_next_clump8(&(clump), (bits), (size), (start) + 8))
68
69static inline int get_bitmask_order(unsigned int count)
70{
71 int order;
72
73 order = fls(count);
74 return order;
75}
76
77static __always_inline unsigned long hweight_long(unsigned long w)
78{
79 return sizeof(w) == 4 ? hweight32(w) : hweight64((__u64)w);
80}
81
82
83
84
85
86
87static inline __u64 rol64(__u64 word, unsigned int shift)
88{
89 return (word << (shift & 63)) | (word >> ((-shift) & 63));
90}
91
92
93
94
95
96
97static inline __u64 ror64(__u64 word, unsigned int shift)
98{
99 return (word >> (shift & 63)) | (word << ((-shift) & 63));
100}
101
102
103
104
105
106
107static inline __u32 rol32(__u32 word, unsigned int shift)
108{
109 return (word << (shift & 31)) | (word >> ((-shift) & 31));
110}
111
112
113
114
115
116
117static inline __u32 ror32(__u32 word, unsigned int shift)
118{
119 return (word >> (shift & 31)) | (word << ((-shift) & 31));
120}
121
122
123
124
125
126
127static inline __u16 rol16(__u16 word, unsigned int shift)
128{
129 return (word << (shift & 15)) | (word >> ((-shift) & 15));
130}
131
132
133
134
135
136
137static inline __u16 ror16(__u16 word, unsigned int shift)
138{
139 return (word >> (shift & 15)) | (word << ((-shift) & 15));
140}
141
142
143
144
145
146
147static inline __u8 rol8(__u8 word, unsigned int shift)
148{
149 return (word << (shift & 7)) | (word >> ((-shift) & 7));
150}
151
152
153
154
155
156
157static inline __u8 ror8(__u8 word, unsigned int shift)
158{
159 return (word >> (shift & 7)) | (word << ((-shift) & 7));
160}
161
162
163
164
165
166
167
168
169static __always_inline __s32 sign_extend32(__u32 value, int index)
170{
171 __u8 shift = 31 - index;
172 return (__s32)(value << shift) >> shift;
173}
174
175
176
177
178
179
180static __always_inline __s64 sign_extend64(__u64 value, int index)
181{
182 __u8 shift = 63 - index;
183 return (__s64)(value << shift) >> shift;
184}
185
186static inline unsigned fls_long(unsigned long l)
187{
188 if (sizeof(l) == 4)
189 return fls(l);
190 return fls64(l);
191}
192
193static inline int get_count_order(unsigned int count)
194{
195 if (count == 0)
196 return -1;
197
198 return fls(--count);
199}
200
201
202
203
204
205
206
207static inline int get_count_order_long(unsigned long l)
208{
209 if (l == 0UL)
210 return -1;
211 return (int)fls_long(--l);
212}
213
214
215
216
217
218
219
220
221
222static inline unsigned long __ffs64(u64 word)
223{
224#if BITS_PER_LONG == 32
225 if (((u32)word) == 0UL)
226 return __ffs((u32)(word >> 32)) + 32;
227#elif BITS_PER_LONG != 64
228#error BITS_PER_LONG not 32 or 64
229#endif
230 return __ffs((unsigned long)word);
231}
232
233
234
235
236
237
238
239static __always_inline void assign_bit(long nr, volatile unsigned long *addr,
240 bool value)
241{
242 if (value)
243 set_bit(nr, addr);
244 else
245 clear_bit(nr, addr);
246}
247
248static __always_inline void __assign_bit(long nr, volatile unsigned long *addr,
249 bool value)
250{
251 if (value)
252 __set_bit(nr, addr);
253 else
254 __clear_bit(nr, addr);
255}
256
257
258
259
260
261
262
263
264
265
266#define __ptr_set_bit(nr, addr) \
267 ({ \
268 typecheck_pointer(*(addr)); \
269 __set_bit(nr, (unsigned long *)(addr)); \
270 })
271
272
273
274
275
276
277
278
279
280
281#define __ptr_clear_bit(nr, addr) \
282 ({ \
283 typecheck_pointer(*(addr)); \
284 __clear_bit(nr, (unsigned long *)(addr)); \
285 })
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300#define __ptr_test_bit(nr, addr) \
301 ({ \
302 typecheck_pointer(*(addr)); \
303 test_bit(nr, (unsigned long *)(addr)); \
304 })
305
306#ifdef __KERNEL__
307
308#ifndef set_mask_bits
309#define set_mask_bits(ptr, mask, bits) \
310({ \
311 const typeof(*(ptr)) mask__ = (mask), bits__ = (bits); \
312 typeof(*(ptr)) old__, new__; \
313 \
314 do { \
315 old__ = READ_ONCE(*(ptr)); \
316 new__ = (old__ & ~mask__) | bits__; \
317 } while (cmpxchg(ptr, old__, new__) != old__); \
318 \
319 old__; \
320})
321#endif
322
323#ifndef bit_clear_unless
324#define bit_clear_unless(ptr, clear, test) \
325({ \
326 const typeof(*(ptr)) clear__ = (clear), test__ = (test);\
327 typeof(*(ptr)) old__, new__; \
328 \
329 do { \
330 old__ = READ_ONCE(*(ptr)); \
331 new__ = old__ & ~clear__; \
332 } while (!(old__ & test__) && \
333 cmpxchg(ptr, old__, new__) != old__); \
334 \
335 !(old__ & test__); \
336})
337#endif
338
339#endif
340#endif
341