Line data Source code
1 : #ifndef _LINUX_BITOPS_H
2 : #define _LINUX_BITOPS_H
3 : #include <asm/types.h>
4 :
5 : #ifdef __KERNEL__
6 : #define BIT(nr) (1UL << (nr))
7 : #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
8 : #define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
9 : #define BITS_PER_BYTE 8
10 : #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
11 : #endif
12 :
13 : /*
14 : * Include this here because some architectures need generic_ffs/fls in
15 : * scope
16 : */
17 : #include <asm/bitops.h>
18 :
19 : #define for_each_bit(bit, addr, size) \
20 : for ((bit) = find_first_bit((addr), (size)); \
21 : (bit) < (size); \
22 : (bit) = find_next_bit((addr), (size), (bit) + 1))
23 :
24 :
25 : static __inline__ int get_bitmask_order(unsigned int count)
26 : {
27 : int order;
28 :
29 : order = fls(count);
30 : return order; /* We could be slightly more clever with -1 here... */
31 : }
32 :
33 : static __inline__ int get_count_order(unsigned int count)
34 : {
35 0 : int order;
36 0 :
37 0 : order = fls(count) - 1;
38 0 : if (count & (count - 1))
39 0 : order++;
40 0 : return order;
41 : }
42 :
43 : static inline unsigned long hweight_long(unsigned long w)
44 : {
45 : return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
46 : }
47 :
48 : /**
49 : * rol32 - rotate a 32-bit value left
50 : * @word: value to rotate
51 : * @shift: bits to roll
52 : */
53 : static inline __u32 rol32(__u32 word, unsigned int shift)
54 : {
55 : return (word << shift) | (word >> (32 - shift));
56 : }
57 :
58 : /**
59 : * ror32 - rotate a 32-bit value right
60 : * @word: value to rotate
61 : * @shift: bits to roll
62 : */
63 : static inline __u32 ror32(__u32 word, unsigned int shift)
64 : {
65 : return (word >> shift) | (word << (32 - shift));
66 : }
67 :
68 : /**
69 : * rol16 - rotate a 16-bit value left
70 : * @word: value to rotate
71 : * @shift: bits to roll
72 : */
73 : static inline __u16 rol16(__u16 word, unsigned int shift)
74 : {
75 : return (word << shift) | (word >> (16 - shift));
76 : }
77 :
78 : /**
79 : * ror16 - rotate a 16-bit value right
80 : * @word: value to rotate
81 : * @shift: bits to roll
82 : */
83 : static inline __u16 ror16(__u16 word, unsigned int shift)
84 : {
85 : return (word >> shift) | (word << (16 - shift));
86 : }
87 :
88 : /**
89 : * rol8 - rotate an 8-bit value left
90 : * @word: value to rotate
91 : * @shift: bits to roll
92 : */
93 : static inline __u8 rol8(__u8 word, unsigned int shift)
94 : {
95 : return (word << shift) | (word >> (8 - shift));
96 : }
97 :
98 : /**
99 : * ror8 - rotate an 8-bit value right
100 : * @word: value to rotate
101 : * @shift: bits to roll
102 : */
103 : static inline __u8 ror8(__u8 word, unsigned int shift)
104 : {
105 : return (word >> shift) | (word << (8 - shift));
106 : }
107 :
108 : static inline unsigned fls_long(unsigned long l)
109 : {
110 : if (sizeof(l) == 4)
111 : return fls(l);
112 : return fls64(l);
113 : }
114 :
115 : /**
116 : * __ffs64 - find first set bit in a 64 bit word
117 : * @word: The 64 bit word
118 : *
119 : * On 64 bit arches this is a synomyn for __ffs
120 : * The result is not defined if no bits are set, so check that @word
121 : * is non-zero before calling this.
122 : */
123 : static inline unsigned long __ffs64(u64 word)
124 : {
125 : #if BITS_PER_LONG == 32
126 : if (((u32)word) == 0UL)
127 : return __ffs((u32)(word >> 32)) + 32;
128 : #elif BITS_PER_LONG != 64
129 : #error BITS_PER_LONG not 32 or 64
130 : #endif
131 : return __ffs((unsigned long)word);
132 : }
133 :
134 : #ifdef __KERNEL__
135 : #ifdef CONFIG_GENERIC_FIND_FIRST_BIT
136 :
137 : /**
138 : * find_first_bit - find the first set bit in a memory region
139 : * @addr: The address to start the search at
140 : * @size: The maximum size to search
141 : *
142 : * Returns the bit number of the first set bit.
143 : */
144 : extern unsigned long find_first_bit(const unsigned long *addr,
145 : unsigned long size);
146 :
147 : /**
148 : * find_first_zero_bit - find the first cleared bit in a memory region
149 : * @addr: The address to start the search at
150 : * @size: The maximum size to search
151 : *
152 : * Returns the bit number of the first cleared bit.
153 : */
154 : extern unsigned long find_first_zero_bit(const unsigned long *addr,
155 : unsigned long size);
156 : #endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
157 :
158 : #ifdef CONFIG_GENERIC_FIND_LAST_BIT
159 : /**
160 : * find_last_bit - find the last set bit in a memory region
161 : * @addr: The address to start the search at
162 : * @size: The maximum size to search
163 : *
164 : * Returns the bit number of the first set bit, or size.
165 : */
166 : extern unsigned long find_last_bit(const unsigned long *addr,
167 : unsigned long size);
168 : #endif /* CONFIG_GENERIC_FIND_LAST_BIT */
169 :
170 : #ifdef CONFIG_GENERIC_FIND_NEXT_BIT
171 :
172 : /**
173 : * find_next_bit - find the next set bit in a memory region
174 : * @addr: The address to base the search on
175 : * @offset: The bitnumber to start searching at
176 : * @size: The bitmap size in bits
177 : */
178 : extern unsigned long find_next_bit(const unsigned long *addr,
179 : unsigned long size, unsigned long offset);
180 :
181 : /**
182 : * find_next_zero_bit - find the next cleared bit in a memory region
183 : * @addr: The address to base the search on
184 : * @offset: The bitnumber to start searching at
185 : * @size: The bitmap size in bits
186 : */
187 :
188 : extern unsigned long find_next_zero_bit(const unsigned long *addr,
189 : unsigned long size,
190 : unsigned long offset);
191 :
192 : #endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
193 : #endif /* __KERNEL__ */
194 : #endif
|