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