ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-2.6.6.tar.bz2
[linux-2.6.git] / include / asm-ppc64 / bitops.h
1 /*
2  * PowerPC64 atomic bit operations.
3  * Dave Engebretsen, Todd Inglett, Don Reed, Pat McCarthy, Peter Bergner,
4  * Anton Blanchard
5  *
6  * Originally taken from the 32b PPC code.  Modified to use 64b values for
7  * the various counters & memory references.
8  *
9  * Bitops are odd when viewed on big-endian systems.  They were designed
10  * on little endian so the size of the bitset doesn't matter (low order bytes
11  * come first) as long as the bit in question is valid.
12  *
13  * Bits are "tested" often using the C expression (val & (1<<nr)) so we do
14  * our best to stay compatible with that.  The assumption is that val will
15  * be unsigned long for such tests.  As such, we assume the bits are stored
16  * as an array of unsigned long (the usual case is a single unsigned long,
17  * of course).  Here's an example bitset with bit numbering:
18  *
19  *   |63..........0|127........64|195.......128|255.......196|
20  *
21  * This leads to a problem. If an int, short or char is passed as a bitset
22  * it will be a bad memory reference since we want to store in chunks
23  * of unsigned long (64 bits here) size.
24  *
25  * This program is free software; you can redistribute it and/or
26  * modify it under the terms of the GNU General Public License
27  * as published by the Free Software Foundation; either version
28  * 2 of the License, or (at your option) any later version.
29  */
30
31 #ifndef _PPC64_BITOPS_H
32 #define _PPC64_BITOPS_H
33
34 #ifdef __KERNEL__
35
36 #include <asm/memory.h>
37
38 /*
39  * clear_bit doesn't imply a memory barrier
40  */
41 #define smp_mb__before_clear_bit()      smp_mb()
42 #define smp_mb__after_clear_bit()       smp_mb()
43
44 static __inline__ int test_bit(unsigned long nr, __const__ volatile unsigned long *addr)
45 {
46         return (1UL & (addr[nr >> 6] >> (nr & 63)));
47 }
48
49 static __inline__ void set_bit(unsigned long nr, volatile unsigned long *addr)
50 {
51         unsigned long old;
52         unsigned long mask = 1UL << (nr & 0x3f);
53         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
54
55         __asm__ __volatile__(
56 "1:     ldarx   %0,0,%3         # set_bit\n\
57         or      %0,%0,%2\n\
58         stdcx.  %0,0,%3\n\
59         bne-    1b"
60         : "=&r" (old), "=m" (*p)
61         : "r" (mask), "r" (p), "m" (*p)
62         : "cc");
63 }
64
65 static __inline__ void clear_bit(unsigned long nr, volatile unsigned long *addr)
66 {
67         unsigned long old;
68         unsigned long mask = 1UL << (nr & 0x3f);
69         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
70
71         __asm__ __volatile__(
72 "1:     ldarx   %0,0,%3         # clear_bit\n\
73         andc    %0,%0,%2\n\
74         stdcx.  %0,0,%3\n\
75         bne-    1b"
76         : "=&r" (old), "=m" (*p)
77         : "r" (mask), "r" (p), "m" (*p)
78         : "cc");
79 }
80
81 static __inline__ void change_bit(unsigned long nr, volatile unsigned long *addr)
82 {
83         unsigned long old;
84         unsigned long mask = 1UL << (nr & 0x3f);
85         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
86
87         __asm__ __volatile__(
88 "1:     ldarx   %0,0,%3         # change_bit\n\
89         xor     %0,%0,%2\n\
90         stdcx.  %0,0,%3\n\
91         bne-    1b"
92         : "=&r" (old), "=m" (*p)
93         : "r" (mask), "r" (p), "m" (*p)
94         : "cc");
95 }
96
97 static __inline__ int test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
98 {
99         unsigned long old, t;
100         unsigned long mask = 1UL << (nr & 0x3f);
101         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
102
103         __asm__ __volatile__(
104         EIEIO_ON_SMP
105 "1:     ldarx   %0,0,%3         # test_and_set_bit\n\
106         or      %1,%0,%2 \n\
107         stdcx.  %1,0,%3 \n\
108         bne-    1b"
109         ISYNC_ON_SMP
110         : "=&r" (old), "=&r" (t)
111         : "r" (mask), "r" (p)
112         : "cc", "memory");
113
114         return (old & mask) != 0;
115 }
116
117 static __inline__ int test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
118 {
119         unsigned long old, t;
120         unsigned long mask = 1UL << (nr & 0x3f);
121         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
122
123         __asm__ __volatile__(
124         EIEIO_ON_SMP
125 "1:     ldarx   %0,0,%3         # test_and_clear_bit\n\
126         andc    %1,%0,%2\n\
127         stdcx.  %1,0,%3\n\
128         bne-    1b"
129         ISYNC_ON_SMP
130         : "=&r" (old), "=&r" (t)
131         : "r" (mask), "r" (p)
132         : "cc", "memory");
133
134         return (old & mask) != 0;
135 }
136
137 static __inline__ int test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
138 {
139         unsigned long old, t;
140         unsigned long mask = 1UL << (nr & 0x3f);
141         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
142
143         __asm__ __volatile__(
144         EIEIO_ON_SMP
145 "1:     ldarx   %0,0,%3         # test_and_change_bit\n\
146         xor     %1,%0,%2\n\
147         stdcx.  %1,0,%3\n\
148         bne-    1b"
149         ISYNC_ON_SMP
150         : "=&r" (old), "=&r" (t)
151         : "r" (mask), "r" (p)
152         : "cc", "memory");
153
154         return (old & mask) != 0;
155 }
156
157 /*
158  * non-atomic versions
159  */
160 static __inline__ void __set_bit(unsigned long nr, volatile unsigned long *addr)
161 {
162         unsigned long mask = 1UL << (nr & 0x3f);
163         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
164
165         *p |= mask;
166 }
167
168 static __inline__ void __clear_bit(unsigned long nr, volatile unsigned long *addr)
169 {
170         unsigned long mask = 1UL << (nr & 0x3f);
171         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
172
173         *p &= ~mask;
174 }
175
176 static __inline__ void __change_bit(unsigned long nr, volatile unsigned long *addr)
177 {
178         unsigned long mask = 1UL << (nr & 0x3f);
179         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
180
181         *p ^= mask;
182 }
183
184 static __inline__ int __test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
185 {
186         unsigned long mask = 1UL << (nr & 0x3f);
187         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
188         unsigned long old = *p;
189
190         *p = old | mask;
191         return (old & mask) != 0;
192 }
193
194 static __inline__ int __test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
195 {
196         unsigned long mask = 1UL << (nr & 0x3f);
197         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
198         unsigned long old = *p;
199
200         *p = old & ~mask;
201         return (old & mask) != 0;
202 }
203
204 static __inline__ int __test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
205 {
206         unsigned long mask = 1UL << (nr & 0x3f);
207         unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
208         unsigned long old = *p;
209
210         *p = old ^ mask;
211         return (old & mask) != 0;
212 }
213
214 /*
215  * Return the zero-based bit position (from RIGHT TO LEFT, 63 -> 0) of the
216  * most significant (left-most) 1-bit in a double word.
217  */
218 static __inline__ int __ilog2(unsigned long x)
219 {
220         int lz;
221
222         asm ("cntlzd %0,%1" : "=r" (lz) : "r" (x));
223         return 63 - lz;
224 }
225
226 /*
227  * Determines the bit position of the least significant (rightmost) 0 bit
228  * in the specified double word. The returned bit position will be zero-based,
229  * starting from the right side (63 - 0).
230  */
231 static __inline__ unsigned long ffz(unsigned long x)
232 {
233         /* no zero exists anywhere in the 8 byte area. */
234         if ((x = ~x) == 0)
235                 return 64;
236
237         /*
238          * Calculate the bit position of the least signficant '1' bit in x
239          * (since x has been changed this will actually be the least signficant
240          * '0' bit in * the original x).  Note: (x & -x) gives us a mask that
241          * is the least significant * (RIGHT-most) 1-bit of the value in x.
242          */
243         return __ilog2(x & -x);
244 }
245
246 static __inline__ int __ffs(unsigned long x)
247 {
248         return __ilog2(x & -x);
249 }
250
251 /*
252  * ffs: find first bit set. This is defined the same way as
253  * the libc and compiler builtin ffs routines, therefore
254  * differs in spirit from the above ffz (man ffs).
255  */
256 static __inline__ int ffs(int x)
257 {
258         unsigned long i = (unsigned long)x;
259         return __ilog2(i & -i) + 1;
260 }
261
262 /*
263  * fls: find last (most-significant) bit set.
264  * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
265  */
266 #define fls(x) generic_fls(x)
267
268 /*
269  * hweightN: returns the hamming weight (i.e. the number
270  * of bits set) of a N-bit word
271  */
272 #define hweight64(x) generic_hweight64(x)
273 #define hweight32(x) generic_hweight32(x)
274 #define hweight16(x) generic_hweight16(x)
275 #define hweight8(x) generic_hweight8(x)
276
277 extern unsigned long find_next_zero_bit(unsigned long *addr, unsigned long size, unsigned long offset);
278 #define find_first_zero_bit(addr, size) \
279         find_next_zero_bit((addr), (size), 0)
280
281 extern unsigned long find_next_bit(unsigned long *addr, unsigned long size, unsigned long offset);
282 #define find_first_bit(addr, size) \
283         find_next_bit((addr), (size), 0)
284
285 extern unsigned long find_next_zero_le_bit(unsigned long *addr, unsigned long size, unsigned long offset);
286 #define find_first_zero_le_bit(addr, size) \
287         find_next_zero_le_bit((addr), (size), 0)
288
289 static __inline__ int test_le_bit(unsigned long nr, __const__ unsigned long * addr)
290 {
291         __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
292         return (ADDR[nr >> 3] >> (nr & 7)) & 1;
293 }
294
295 /*
296  * non-atomic versions
297  */
298 static __inline__ void __set_le_bit(unsigned long nr, unsigned long *addr)
299 {
300         unsigned char *ADDR = (unsigned char *)addr;
301
302         ADDR += nr >> 3;
303         *ADDR |= 1 << (nr & 0x07);
304 }
305
306 static __inline__ void __clear_le_bit(unsigned long nr, unsigned long *addr)
307 {
308         unsigned char *ADDR = (unsigned char *)addr;
309
310         ADDR += nr >> 3;
311         *ADDR &= ~(1 << (nr & 0x07));
312 }
313
314 static __inline__ int __test_and_set_le_bit(unsigned long nr, unsigned long *addr)
315 {
316         int mask, retval;
317         unsigned char *ADDR = (unsigned char *)addr;
318
319         ADDR += nr >> 3;
320         mask = 1 << (nr & 0x07);
321         retval = (mask & *ADDR) != 0;
322         *ADDR |= mask;
323         return retval;
324 }
325
326 static __inline__ int __test_and_clear_le_bit(unsigned long nr, unsigned long *addr)
327 {
328         int mask, retval;
329         unsigned char *ADDR = (unsigned char *)addr;
330
331         ADDR += nr >> 3;
332         mask = 1 << (nr & 0x07);
333         retval = (mask & *ADDR) != 0;
334         *ADDR &= ~mask;
335         return retval;
336 }
337
338 #define ext2_set_bit(nr,addr) \
339         __test_and_set_le_bit((nr),(unsigned long*)addr)
340 #define ext2_clear_bit(nr, addr) \
341         __test_and_clear_le_bit((nr),(unsigned long*)addr)
342
343 #define ext2_set_bit_atomic(lock, nr, addr)             \
344         ({                                              \
345                 int ret;                                \
346                 spin_lock(lock);                        \
347                 ret = ext2_set_bit((nr), (addr));       \
348                 spin_unlock(lock);                      \
349                 ret;                                    \
350         })
351
352 #define ext2_clear_bit_atomic(lock, nr, addr)           \
353         ({                                              \
354                 int ret;                                \
355                 spin_lock(lock);                        \
356                 ret = ext2_clear_bit((nr), (addr));     \
357                 spin_unlock(lock);                      \
358                 ret;                                    \
359         })
360
361 #define ext2_test_bit(nr, addr)      test_le_bit((nr),(unsigned long*)addr)
362 #define ext2_find_first_zero_bit(addr, size) \
363         find_first_zero_le_bit((unsigned long*)addr, size)
364 #define ext2_find_next_zero_bit(addr, size, off) \
365         find_next_zero_le_bit((unsigned long*)addr, size, off)
366
367 #define minix_test_and_set_bit(nr,addr)         test_and_set_bit(nr,addr)
368 #define minix_set_bit(nr,addr)                  set_bit(nr,addr)
369 #define minix_test_and_clear_bit(nr,addr)       test_and_clear_bit(nr,addr)
370 #define minix_test_bit(nr,addr)                 test_bit(nr,addr)
371 #define minix_find_first_zero_bit(addr,size)    find_first_zero_bit(addr,size)
372
373 #endif /* __KERNEL__ */
374 #endif /* _PPC64_BITOPS_H */