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