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