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