f8a6747693148350c3cce205b29bf82f6fa0a5f6
[linux-2.6.git] / include / asm-cris / bitops.h
1 /* asm/bitops.h for Linux/CRIS
2  *
3  * TODO: asm versions if speed is needed
4  *
5  * All bit operations return 0 if the bit was cleared before the
6  * operation and != 0 if it was not.
7  *
8  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
9  */
10
11 #ifndef _CRIS_BITOPS_H
12 #define _CRIS_BITOPS_H
13
14 /* Currently this is unsuitable for consumption outside the kernel.  */
15 #ifdef __KERNEL__ 
16
17 #include <asm/arch/bitops.h>
18 #include <asm/system.h>
19 #include <asm/atomic.h>
20 #include <linux/compiler.h>
21
22 /*
23  * Some hacks to defeat gcc over-optimizations..
24  */
25 struct __dummy { unsigned long a[100]; };
26 #define ADDR (*(struct __dummy *) addr)
27 #define CONST_ADDR (*(const struct __dummy *) addr)
28
29 /*
30  * set_bit - Atomically set a bit in memory
31  * @nr: the bit to set
32  * @addr: the address to start counting from
33  *
34  * This function is atomic and may not be reordered.  See __set_bit()
35  * if you do not require the atomic guarantees.
36  * Note that @nr may be almost arbitrarily large; this function is not
37  * restricted to acting on a single-word quantity.
38  */
39
40 #define set_bit(nr, addr)    (void)test_and_set_bit(nr, addr)
41
42 #define __set_bit(nr, addr)    (void)__test_and_set_bit(nr, addr)
43
44 /*
45  * clear_bit - Clears a bit in memory
46  * @nr: Bit to clear
47  * @addr: Address to start counting from
48  *
49  * clear_bit() is atomic and may not be reordered.  However, it does
50  * not contain a memory barrier, so if it is used for locking purposes,
51  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
52  * in order to ensure changes are visible on other processors.
53  */
54
55 #define clear_bit(nr, addr)  (void)test_and_clear_bit(nr, addr)
56
57 #define __clear_bit(nr, addr)  (void)__test_and_clear_bit(nr, addr)
58
59 /*
60  * change_bit - Toggle a bit in memory
61  * @nr: Bit to change
62  * @addr: Address to start counting from
63  *
64  * change_bit() is atomic and may not be reordered.
65  * Note that @nr may be almost arbitrarily large; this function is not
66  * restricted to acting on a single-word quantity.
67  */
68
69 #define change_bit(nr, addr) (void)test_and_change_bit(nr, addr)
70
71 /*
72  * __change_bit - Toggle a bit in memory
73  * @nr: the bit to change
74  * @addr: the address to start counting from
75  *
76  * Unlike change_bit(), this function is non-atomic and may be reordered.
77  * If it's called on the same region of memory simultaneously, the effect
78  * may be that only one operation succeeds.
79  */
80
81 #define __change_bit(nr, addr) (void)__test_and_change_bit(nr, addr)
82
83 /**
84  * test_and_set_bit - Set a bit and return its old value
85  * @nr: Bit to set
86  * @addr: Address to count from
87  *
88  * This operation is atomic and cannot be reordered.  
89  * It also implies a memory barrier.
90  */
91
92 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
93 {
94         unsigned int mask, retval;
95         unsigned long flags;
96         unsigned int *adr = (unsigned int *)addr;
97         
98         adr += nr >> 5;
99         mask = 1 << (nr & 0x1f);
100         cris_atomic_save(addr, flags);
101         retval = (mask & *adr) != 0;
102         *adr |= mask;
103         cris_atomic_restore(addr, flags);
104         return retval;
105 }
106
107 static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)
108 {
109         unsigned int mask, retval;
110         unsigned int *adr = (unsigned int *)addr;
111         
112         adr += nr >> 5;
113         mask = 1 << (nr & 0x1f);
114         retval = (mask & *adr) != 0;
115         *adr |= mask;
116         return retval;
117 }
118
119 /*
120  * clear_bit() doesn't provide any barrier for the compiler.
121  */
122 #define smp_mb__before_clear_bit()      barrier()
123 #define smp_mb__after_clear_bit()       barrier()
124
125 /**
126  * test_and_clear_bit - Clear a bit and return its old value
127  * @nr: Bit to clear
128  * @addr: Address to count from
129  *
130  * This operation is atomic and cannot be reordered.  
131  * It also implies a memory barrier.
132  */
133
134 static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
135 {
136         unsigned int mask, retval;
137         unsigned long flags;
138         unsigned int *adr = (unsigned int *)addr;
139         
140         adr += nr >> 5;
141         mask = 1 << (nr & 0x1f);
142         cris_atomic_save(addr, flags);
143         retval = (mask & *adr) != 0;
144         *adr &= ~mask;
145         cris_atomic_restore(addr, flags);
146         return retval;
147 }
148
149 /**
150  * __test_and_clear_bit - Clear a bit and return its old value
151  * @nr: Bit to clear
152  * @addr: Address to count from
153  *
154  * This operation is non-atomic and can be reordered.  
155  * If two examples of this operation race, one can appear to succeed
156  * but actually fail.  You must protect multiple accesses with a lock.
157  */
158
159 static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
160 {
161         unsigned int mask, retval;
162         unsigned int *adr = (unsigned int *)addr;
163         
164         adr += nr >> 5;
165         mask = 1 << (nr & 0x1f);
166         retval = (mask & *adr) != 0;
167         *adr &= ~mask;
168         return retval;
169 }
170 /**
171  * test_and_change_bit - Change a bit and return its old value
172  * @nr: Bit to change
173  * @addr: Address to count from
174  *
175  * This operation is atomic and cannot be reordered.  
176  * It also implies a memory barrier.
177  */
178
179 static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
180 {
181         unsigned int mask, retval;
182         unsigned long flags;
183         unsigned int *adr = (unsigned int *)addr;
184         adr += nr >> 5;
185         mask = 1 << (nr & 0x1f);
186         cris_atomic_save(addr, flags);
187         retval = (mask & *adr) != 0;
188         *adr ^= mask;
189         cris_atomic_restore(addr, flags);
190         return retval;
191 }
192
193 /* WARNING: non atomic and it can be reordered! */
194
195 static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
196 {
197         unsigned int mask, retval;
198         unsigned int *adr = (unsigned int *)addr;
199
200         adr += nr >> 5;
201         mask = 1 << (nr & 0x1f);
202         retval = (mask & *adr) != 0;
203         *adr ^= mask;
204
205         return retval;
206 }
207
208 /**
209  * test_bit - Determine whether a bit is set
210  * @nr: bit number to test
211  * @addr: Address to start counting from
212  *
213  * This routine doesn't need to be atomic.
214  */
215
216 static inline int test_bit(int nr, const volatile unsigned long *addr)
217 {
218         unsigned int mask;
219         unsigned int *adr = (unsigned int *)addr;
220         
221         adr += nr >> 5;
222         mask = 1 << (nr & 0x1f);
223         return ((mask & *adr) != 0);
224 }
225
226 /*
227  * Find-bit routines..
228  */
229
230 /*
231  * Since we define it "external", it collides with the built-in
232  * definition, which doesn't have the same semantics.  We don't want to
233  * use -fno-builtin, so just hide the name ffs.
234  */
235 #define ffs kernel_ffs
236
237 /*
238  * fls: find last bit set.
239  */
240
241 #define fls(x) generic_fls(x)
242 #define fls64(x)   generic_fls64(x)
243
244 /*
245  * hweightN - returns the hamming weight of a N-bit word
246  * @x: the word to weigh
247  *
248  * The Hamming Weight of a number is the total number of bits set in it.
249  */
250
251 #define hweight32(x) generic_hweight32(x)
252 #define hweight16(x) generic_hweight16(x)
253 #define hweight8(x) generic_hweight8(x)
254
255 /**
256  * find_next_zero_bit - find the first zero bit in a memory region
257  * @addr: The address to base the search on
258  * @offset: The bitnumber to start searching at
259  * @size: The maximum size to search
260  */
261 static inline int find_next_zero_bit (const unsigned long * addr, int size, int offset)
262 {
263         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
264         unsigned long result = offset & ~31UL;
265         unsigned long tmp;
266         
267         if (offset >= size)
268                 return size;
269         size -= result;
270         offset &= 31UL;
271         if (offset) {
272                 tmp = *(p++);
273                 tmp |= ~0UL >> (32-offset);
274                 if (size < 32)
275                         goto found_first;
276                 if (~tmp)
277                         goto found_middle;
278                 size -= 32;
279                 result += 32;
280         }
281         while (size & ~31UL) {
282                 if (~(tmp = *(p++)))
283                         goto found_middle;
284                 result += 32;
285                 size -= 32;
286         }
287         if (!size)
288                 return result;
289         tmp = *p;
290         
291  found_first:
292         tmp |= ~0UL << size;
293  found_middle:
294         return result + ffz(tmp);
295 }
296
297 /**
298  * find_next_bit - find the first set bit in a memory region
299  * @addr: The address to base the search on
300  * @offset: The bitnumber to start searching at
301  * @size: The maximum size to search
302  */
303 static __inline__ int find_next_bit(const unsigned long *addr, int size, int offset)
304 {
305         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
306         unsigned long result = offset & ~31UL;
307         unsigned long tmp;
308
309         if (offset >= size)
310                 return size;
311         size -= result;
312         offset &= 31UL;
313         if (offset) {
314                 tmp = *(p++);
315                 tmp &= (~0UL << offset);
316                 if (size < 32)
317                         goto found_first;
318                 if (tmp)
319                         goto found_middle;
320                 size -= 32;
321                 result += 32;
322         }
323         while (size & ~31UL) {
324                 if ((tmp = *(p++)))
325                         goto found_middle;
326                 result += 32;
327                 size -= 32;
328         }
329         if (!size)
330                 return result;
331         tmp = *p;
332
333 found_first:
334         tmp &= (~0UL >> (32 - size));
335         if (tmp == 0UL)        /* Are any bits set? */
336                 return result + size; /* Nope. */
337 found_middle:
338         return result + __ffs(tmp);
339 }
340
341 /**
342  * find_first_zero_bit - find the first zero bit in a memory region
343  * @addr: The address to start the search at
344  * @size: The maximum size to search
345  *
346  * Returns the bit-number of the first zero bit, not the number of the byte
347  * containing a bit.
348  */
349
350 #define find_first_zero_bit(addr, size) \
351         find_next_zero_bit((addr), (size), 0)
352 #define find_first_bit(addr, size) \
353         find_next_bit((addr), (size), 0)
354
355 #define ext2_set_bit                 test_and_set_bit
356 #define ext2_set_bit_atomic(l,n,a)   test_and_set_bit(n,a)
357 #define ext2_clear_bit               test_and_clear_bit
358 #define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
359 #define ext2_test_bit                test_bit
360 #define ext2_find_first_zero_bit     find_first_zero_bit
361 #define ext2_find_next_zero_bit      find_next_zero_bit
362
363 /* Bitmap functions for the minix filesystem.  */
364 #define minix_set_bit(nr,addr) test_and_set_bit(nr,addr)
365 #define minix_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
366 #define minix_test_bit(nr,addr) test_bit(nr,addr)
367 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
368
369 static inline int sched_find_first_bit(const unsigned long *b)
370 {
371         if (unlikely(b[0]))
372                 return __ffs(b[0]);
373         if (unlikely(b[1]))
374                 return __ffs(b[1]) + 32;
375         if (unlikely(b[2]))
376                 return __ffs(b[2]) + 64;
377         if (unlikely(b[3]))
378                 return __ffs(b[3]) + 96;
379         if (b[4])
380                 return __ffs(b[4]) + 128;
381         return __ffs(b[5]) + 32 + 128;
382 }
383
384 #endif /* __KERNEL__ */
385
386 #endif /* _CRIS_BITOPS_H */