forbid asm/bitops.h direct inclusion
[linux-2.6.git] / include / asm-frv / bitops.h
1 /* bitops.h: bit operations for the Fujitsu FR-V CPUs
2  *
3  * For an explanation of how atomic ops work in this arch, see:
4  *   Documentation/fujitsu/frv/atomic-ops.txt
5  *
6  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
7  * Written by David Howells (dhowells@redhat.com)
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version
12  * 2 of the License, or (at your option) any later version.
13  */
14 #ifndef _ASM_BITOPS_H
15 #define _ASM_BITOPS_H
16
17 #include <linux/compiler.h>
18 #include <asm/byteorder.h>
19 #include <asm/system.h>
20 #include <asm/atomic.h>
21
22 #ifdef __KERNEL__
23
24 #ifndef _LINUX_BITOPS_H
25 #error only <linux/bitops.h> can be included directly
26 #endif
27
28 #include <asm-generic/bitops/ffz.h>
29
30 /*
31  * clear_bit() doesn't provide any barrier for the compiler.
32  */
33 #define smp_mb__before_clear_bit()      barrier()
34 #define smp_mb__after_clear_bit()       barrier()
35
36 static inline int test_and_clear_bit(int nr, volatile void *addr)
37 {
38         volatile unsigned long *ptr = addr;
39         unsigned long mask = 1UL << (nr & 31);
40         ptr += nr >> 5;
41         return (atomic_test_and_ANDNOT_mask(mask, ptr) & mask) != 0;
42 }
43
44 static inline int test_and_set_bit(int nr, volatile void *addr)
45 {
46         volatile unsigned long *ptr = addr;
47         unsigned long mask = 1UL << (nr & 31);
48         ptr += nr >> 5;
49         return (atomic_test_and_OR_mask(mask, ptr) & mask) != 0;
50 }
51
52 static inline int test_and_change_bit(int nr, volatile void *addr)
53 {
54         volatile unsigned long *ptr = addr;
55         unsigned long mask = 1UL << (nr & 31);
56         ptr += nr >> 5;
57         return (atomic_test_and_XOR_mask(mask, ptr) & mask) != 0;
58 }
59
60 static inline void clear_bit(int nr, volatile void *addr)
61 {
62         test_and_clear_bit(nr, addr);
63 }
64
65 static inline void set_bit(int nr, volatile void *addr)
66 {
67         test_and_set_bit(nr, addr);
68 }
69
70 static inline void change_bit(int nr, volatile void * addr)
71 {
72         test_and_change_bit(nr, addr);
73 }
74
75 static inline void __clear_bit(int nr, volatile void * addr)
76 {
77         volatile unsigned long *a = addr;
78         int mask;
79
80         a += nr >> 5;
81         mask = 1 << (nr & 31);
82         *a &= ~mask;
83 }
84
85 static inline void __set_bit(int nr, volatile void * addr)
86 {
87         volatile unsigned long *a = addr;
88         int mask;
89
90         a += nr >> 5;
91         mask = 1 << (nr & 31);
92         *a |= mask;
93 }
94
95 static inline void __change_bit(int nr, volatile void *addr)
96 {
97         volatile unsigned long *a = addr;
98         int mask;
99
100         a += nr >> 5;
101         mask = 1 << (nr & 31);
102         *a ^= mask;
103 }
104
105 static inline int __test_and_clear_bit(int nr, volatile void * addr)
106 {
107         volatile unsigned long *a = addr;
108         int mask, retval;
109
110         a += nr >> 5;
111         mask = 1 << (nr & 31);
112         retval = (mask & *a) != 0;
113         *a &= ~mask;
114         return retval;
115 }
116
117 static inline int __test_and_set_bit(int nr, volatile void * addr)
118 {
119         volatile unsigned long *a = addr;
120         int mask, retval;
121
122         a += nr >> 5;
123         mask = 1 << (nr & 31);
124         retval = (mask & *a) != 0;
125         *a |= mask;
126         return retval;
127 }
128
129 static inline int __test_and_change_bit(int nr, volatile void * addr)
130 {
131         volatile unsigned long *a = addr;
132         int mask, retval;
133
134         a += nr >> 5;
135         mask = 1 << (nr & 31);
136         retval = (mask & *a) != 0;
137         *a ^= mask;
138         return retval;
139 }
140
141 /*
142  * This routine doesn't need to be atomic.
143  */
144 static inline int __constant_test_bit(int nr, const volatile void * addr)
145 {
146         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
147 }
148
149 static inline int __test_bit(int nr, const volatile void * addr)
150 {
151         int     * a = (int *) addr;
152         int     mask;
153
154         a += nr >> 5;
155         mask = 1 << (nr & 0x1f);
156         return ((mask & *a) != 0);
157 }
158
159 #define test_bit(nr,addr) \
160 (__builtin_constant_p(nr) ? \
161  __constant_test_bit((nr),(addr)) : \
162  __test_bit((nr),(addr)))
163
164 #include <asm-generic/bitops/find.h>
165
166 /**
167  * fls - find last bit set
168  * @x: the word to search
169  *
170  * This is defined the same way as ffs:
171  * - return 32..1 to indicate bit 31..0 most significant bit set
172  * - return 0 to indicate no bits set
173  */
174 #define fls(x)                                          \
175 ({                                                      \
176         int bit;                                        \
177                                                         \
178         asm("   subcc   %1,gr0,gr0,icc0         \n"     \
179             "   ckne    icc0,cc4                \n"     \
180             "   cscan.p %1,gr0,%0       ,cc4,#1 \n"     \
181             "   csub    %0,%0,%0        ,cc4,#0 \n"     \
182             "   csub    %2,%0,%0        ,cc4,#1 \n"     \
183             : "=&r"(bit)                                \
184             : "r"(x), "r"(32)                           \
185             : "icc0", "cc4"                             \
186             );                                          \
187                                                         \
188         bit;                                            \
189 })
190
191 /**
192  * fls64 - find last bit set in a 64-bit value
193  * @n: the value to search
194  *
195  * This is defined the same way as ffs:
196  * - return 64..1 to indicate bit 63..0 most significant bit set
197  * - return 0 to indicate no bits set
198  */
199 static inline __attribute__((const))
200 int fls64(u64 n)
201 {
202         union {
203                 u64 ll;
204                 struct { u32 h, l; };
205         } _;
206         int bit, x, y;
207
208         _.ll = n;
209
210         asm("   subcc.p         %3,gr0,gr0,icc0         \n"
211             "   subcc           %4,gr0,gr0,icc1         \n"
212             "   ckne            icc0,cc4                \n"
213             "   ckne            icc1,cc5                \n"
214             "   norcr           cc4,cc5,cc6             \n"
215             "   csub.p          %0,%0,%0        ,cc6,1  \n"
216             "   orcr            cc5,cc4,cc4             \n"
217             "   andcr           cc4,cc5,cc4             \n"
218             "   cscan.p         %3,gr0,%0       ,cc4,0  \n"
219             "   setlos          #64,%1                  \n"
220             "   cscan.p         %4,gr0,%0       ,cc4,1  \n"
221             "   setlos          #32,%2                  \n"
222             "   csub.p          %1,%0,%0        ,cc4,0  \n"
223             "   csub            %2,%0,%0        ,cc4,1  \n"
224             : "=&r"(bit), "=r"(x), "=r"(y)
225             : "0r"(_.h), "r"(_.l)
226             : "icc0", "icc1", "cc4", "cc5", "cc6"
227             );
228         return bit;
229
230 }
231
232 /**
233  * ffs - find first bit set
234  * @x: the word to search
235  *
236  * - return 32..1 to indicate bit 31..0 most least significant bit set
237  * - return 0 to indicate no bits set
238  */
239 static inline __attribute__((const))
240 int ffs(int x)
241 {
242         /* Note: (x & -x) gives us a mask that is the least significant
243          * (rightmost) 1-bit of the value in x.
244          */
245         return fls(x & -x);
246 }
247
248 /**
249  * __ffs - find first bit set
250  * @x: the word to search
251  *
252  * - return 31..0 to indicate bit 31..0 most least significant bit set
253  * - if no bits are set in x, the result is undefined
254  */
255 static inline __attribute__((const))
256 int __ffs(unsigned long x)
257 {
258         int bit;
259         asm("scan %1,gr0,%0" : "=r"(bit) : "r"(x & -x));
260         return 31 - bit;
261 }
262
263 /*
264  * special slimline version of fls() for calculating ilog2_u32()
265  * - note: no protection against n == 0
266  */
267 #define ARCH_HAS_ILOG2_U32
268 static inline __attribute__((const))
269 int __ilog2_u32(u32 n)
270 {
271         int bit;
272         asm("scan %1,gr0,%0" : "=r"(bit) : "r"(n));
273         return 31 - bit;
274 }
275
276 /*
277  * special slimline version of fls64() for calculating ilog2_u64()
278  * - note: no protection against n == 0
279  */
280 #define ARCH_HAS_ILOG2_U64
281 static inline __attribute__((const))
282 int __ilog2_u64(u64 n)
283 {
284         union {
285                 u64 ll;
286                 struct { u32 h, l; };
287         } _;
288         int bit, x, y;
289
290         _.ll = n;
291
292         asm("   subcc           %3,gr0,gr0,icc0         \n"
293             "   ckeq            icc0,cc4                \n"
294             "   cscan.p         %3,gr0,%0       ,cc4,0  \n"
295             "   setlos          #63,%1                  \n"
296             "   cscan.p         %4,gr0,%0       ,cc4,1  \n"
297             "   setlos          #31,%2                  \n"
298             "   csub.p          %1,%0,%0        ,cc4,0  \n"
299             "   csub            %2,%0,%0        ,cc4,1  \n"
300             : "=&r"(bit), "=r"(x), "=r"(y)
301             : "0r"(_.h), "r"(_.l)
302             : "icc0", "cc4"
303             );
304         return bit;
305 }
306
307 #include <asm-generic/bitops/sched.h>
308 #include <asm-generic/bitops/hweight.h>
309 #include <asm-generic/bitops/lock.h>
310
311 #include <asm-generic/bitops/ext2-non-atomic.h>
312
313 #define ext2_set_bit_atomic(lock,nr,addr)       test_and_set_bit  ((nr) ^ 0x18, (addr))
314 #define ext2_clear_bit_atomic(lock,nr,addr)     test_and_clear_bit((nr) ^ 0x18, (addr))
315
316 #include <asm-generic/bitops/minix-le.h>
317
318 #endif /* __KERNEL__ */
319
320 #endif /* _ASM_BITOPS_H */