[PATCH] bitops: m68knommu: use generic bitops
[linux-2.6.git] / include / asm-m68knommu / bitops.h
1 #ifndef _M68KNOMMU_BITOPS_H
2 #define _M68KNOMMU_BITOPS_H
3
4 /*
5  * Copyright 1992, Linus Torvalds.
6  */
7
8 #include <linux/config.h>
9 #include <linux/compiler.h>
10 #include <asm/byteorder.h>      /* swab32 */
11 #include <asm/system.h>         /* save_flags */
12
13 #ifdef __KERNEL__
14
15 #include <asm-generic/bitops/ffs.h>
16 #include <asm-generic/bitops/__ffs.h>
17 #include <asm-generic/bitops/sched.h>
18 #include <asm-generic/bitops/ffz.h>
19
20 static __inline__ void set_bit(int nr, volatile unsigned long * addr)
21 {
22 #ifdef CONFIG_COLDFIRE
23         __asm__ __volatile__ ("lea %0,%%a0; bset %1,(%%a0)"
24              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
25              : "d" (nr)
26              : "%a0", "cc");
27 #else
28         __asm__ __volatile__ ("bset %1,%0"
29              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
30              : "di" (nr)
31              : "cc");
32 #endif
33 }
34
35 #define __set_bit(nr, addr) set_bit(nr, addr)
36
37 /*
38  * clear_bit() doesn't provide any barrier for the compiler.
39  */
40 #define smp_mb__before_clear_bit()      barrier()
41 #define smp_mb__after_clear_bit()       barrier()
42
43 static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
44 {
45 #ifdef CONFIG_COLDFIRE
46         __asm__ __volatile__ ("lea %0,%%a0; bclr %1,(%%a0)"
47              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
48              : "d" (nr)
49              : "%a0", "cc");
50 #else
51         __asm__ __volatile__ ("bclr %1,%0"
52              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
53              : "di" (nr)
54              : "cc");
55 #endif
56 }
57
58 #define __clear_bit(nr, addr) clear_bit(nr, addr)
59
60 static __inline__ void change_bit(int nr, volatile unsigned long * addr)
61 {
62 #ifdef CONFIG_COLDFIRE
63         __asm__ __volatile__ ("lea %0,%%a0; bchg %1,(%%a0)"
64              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
65              : "d" (nr)
66              : "%a0", "cc");
67 #else
68         __asm__ __volatile__ ("bchg %1,%0"
69              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
70              : "di" (nr)
71              : "cc");
72 #endif
73 }
74
75 #define __change_bit(nr, addr) change_bit(nr, addr)
76
77 static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
78 {
79         char retval;
80
81 #ifdef CONFIG_COLDFIRE
82         __asm__ __volatile__ ("lea %1,%%a0; bset %2,(%%a0); sne %0"
83              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
84              : "d" (nr)
85              : "%a0");
86 #else
87         __asm__ __volatile__ ("bset %2,%1; sne %0"
88              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
89              : "di" (nr)
90              /* No clobber */);
91 #endif
92
93         return retval;
94 }
95
96 #define __test_and_set_bit(nr, addr) test_and_set_bit(nr, addr)
97
98 static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
99 {
100         char retval;
101
102 #ifdef CONFIG_COLDFIRE
103         __asm__ __volatile__ ("lea %1,%%a0; bclr %2,(%%a0); sne %0"
104              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
105              : "d" (nr)
106              : "%a0");
107 #else
108         __asm__ __volatile__ ("bclr %2,%1; sne %0"
109              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
110              : "di" (nr)
111              /* No clobber */);
112 #endif
113
114         return retval;
115 }
116
117 #define __test_and_clear_bit(nr, addr) test_and_clear_bit(nr, addr)
118
119 static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
120 {
121         char retval;
122
123 #ifdef CONFIG_COLDFIRE
124         __asm__ __volatile__ ("lea %1,%%a0\n\tbchg %2,(%%a0)\n\tsne %0"
125              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
126              : "d" (nr)
127              : "%a0");
128 #else
129         __asm__ __volatile__ ("bchg %2,%1; sne %0"
130              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
131              : "di" (nr)
132              /* No clobber */);
133 #endif
134
135         return retval;
136 }
137
138 #define __test_and_change_bit(nr, addr) test_and_change_bit(nr, addr)
139
140 /*
141  * This routine doesn't need to be atomic.
142  */
143 static __inline__ int __constant_test_bit(int nr, const volatile unsigned long * addr)
144 {
145         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
146 }
147
148 static __inline__ int __test_bit(int nr, const volatile unsigned long * addr)
149 {
150         int     * a = (int *) addr;
151         int     mask;
152
153         a += nr >> 5;
154         mask = 1 << (nr & 0x1f);
155         return ((mask & *a) != 0);
156 }
157
158 #define test_bit(nr,addr) \
159 (__builtin_constant_p(nr) ? \
160  __constant_test_bit((nr),(addr)) : \
161  __test_bit((nr),(addr)))
162
163 #include <asm-generic/bitops/find.h>
164 #include <asm-generic/bitops/hweight.h>
165
166 static __inline__ int ext2_set_bit(int nr, volatile void * addr)
167 {
168         char retval;
169
170 #ifdef CONFIG_COLDFIRE
171         __asm__ __volatile__ ("lea %1,%%a0; bset %2,(%%a0); sne %0"
172              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
173              : "d" (nr)
174              : "%a0");
175 #else
176         __asm__ __volatile__ ("bset %2,%1; sne %0"
177              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
178              : "di" (nr)
179              /* No clobber */);
180 #endif
181
182         return retval;
183 }
184
185 static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
186 {
187         char retval;
188
189 #ifdef CONFIG_COLDFIRE
190         __asm__ __volatile__ ("lea %1,%%a0; bclr %2,(%%a0); sne %0"
191              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
192              : "d" (nr)
193              : "%a0");
194 #else
195         __asm__ __volatile__ ("bclr %2,%1; sne %0"
196              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
197              : "di" (nr)
198              /* No clobber */);
199 #endif
200
201         return retval;
202 }
203
204 #define ext2_set_bit_atomic(lock, nr, addr)             \
205         ({                                              \
206                 int ret;                                \
207                 spin_lock(lock);                        \
208                 ret = ext2_set_bit((nr), (addr));       \
209                 spin_unlock(lock);                      \
210                 ret;                                    \
211         })
212
213 #define ext2_clear_bit_atomic(lock, nr, addr)           \
214         ({                                              \
215                 int ret;                                \
216                 spin_lock(lock);                        \
217                 ret = ext2_clear_bit((nr), (addr));     \
218                 spin_unlock(lock);                      \
219                 ret;                                    \
220         })
221
222 static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
223 {
224         char retval;
225
226 #ifdef CONFIG_COLDFIRE
227         __asm__ __volatile__ ("lea %1,%%a0; btst %2,(%%a0); sne %0"
228              : "=d" (retval)
229              : "m" (((const volatile char *)addr)[nr >> 3]), "d" (nr)
230              : "%a0");
231 #else
232         __asm__ __volatile__ ("btst %2,%1; sne %0"
233              : "=d" (retval)
234              : "m" (((const volatile char *)addr)[nr >> 3]), "di" (nr)
235              /* No clobber */);
236 #endif
237
238         return retval;
239 }
240
241 #define ext2_find_first_zero_bit(addr, size) \
242         ext2_find_next_zero_bit((addr), (size), 0)
243
244 static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
245 {
246         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
247         unsigned long result = offset & ~31UL;
248         unsigned long tmp;
249
250         if (offset >= size)
251                 return size;
252         size -= result;
253         offset &= 31UL;
254         if(offset) {
255                 /* We hold the little endian value in tmp, but then the
256                  * shift is illegal. So we could keep a big endian value
257                  * in tmp, like this:
258                  *
259                  * tmp = __swab32(*(p++));
260                  * tmp |= ~0UL >> (32-offset);
261                  *
262                  * but this would decrease preformance, so we change the
263                  * shift:
264                  */
265                 tmp = *(p++);
266                 tmp |= __swab32(~0UL >> (32-offset));
267                 if(size < 32)
268                         goto found_first;
269                 if(~tmp)
270                         goto found_middle;
271                 size -= 32;
272                 result += 32;
273         }
274         while(size & ~31UL) {
275                 if(~(tmp = *(p++)))
276                         goto found_middle;
277                 result += 32;
278                 size -= 32;
279         }
280         if(!size)
281                 return result;
282         tmp = *p;
283
284 found_first:
285         /* tmp is little endian, so we would have to swab the shift,
286          * see above. But then we have to swab tmp below for ffz, so
287          * we might as well do this here.
288          */
289         return result + ffz(__swab32(tmp) | (~0UL << size));
290 found_middle:
291         return result + ffz(__swab32(tmp));
292 }
293
294 #include <asm-generic/bitops/minix.h>
295
296 #endif /* __KERNEL__ */
297
298 #include <asm-generic/bitops/fls.h>
299 #include <asm-generic/bitops/fls64.h>
300
301 #endif /* _M68KNOMMU_BITOPS_H */