aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
authorAkinobu Mita <mita@miraclelinux.com>2006-03-26 04:39:35 -0500
committerLinus Torvalds <torvalds@g5.osdl.org>2006-03-26 11:57:14 -0500
commite2268c7129e6cab53a5dac1ab0790a547555e21a (patch)
tree9d7303c5a2fe2db5cb3863793c63fc8b40673675 /include
parent7e33db4e2e9d67ee01d105e33fb773eed8ba10f0 (diff)
[PATCH] bitops: sh: use generic bitops
- remove __{,test_and_}{set,clear,change}_bit() and test_bit() - remove find_{next,first}{,_zero}_bit() - remove generic_ffs() - remove generic_hweight{32,16,8}() - remove sched_find_first_bit() - remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit() - remove ext2_{set,clear}_bit_atomic() - remove minix_{test,set,test_and_clear,test,find_first_zero}_bit() - remove generic_fls() - remove generic_fls64() Signed-off-by: Akinobu Mita <mita@miraclelinux.com> Cc: Paul Mundt <lethal@linux-sh.org> Cc: Kazumoto Kojima <kkojima@rr.iij4u.or.jp> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'include')
-rw-r--r--include/asm-sh/bitops.h342
1 files changed, 10 insertions, 332 deletions
diff --git a/include/asm-sh/bitops.h b/include/asm-sh/bitops.h
index f8d504e7d9d6..e34f82508568 100644
--- a/include/asm-sh/bitops.h
+++ b/include/asm-sh/bitops.h
@@ -19,16 +19,6 @@ static __inline__ void set_bit(int nr, volatile void * addr)
19 local_irq_restore(flags); 19 local_irq_restore(flags);
20} 20}
21 21
22static __inline__ void __set_bit(int nr, volatile void * addr)
23{
24 int mask;
25 volatile unsigned int *a = addr;
26
27 a += nr >> 5;
28 mask = 1 << (nr & 0x1f);
29 *a |= mask;
30}
31
32/* 22/*
33 * clear_bit() doesn't provide any barrier for the compiler. 23 * clear_bit() doesn't provide any barrier for the compiler.
34 */ 24 */
@@ -47,16 +37,6 @@ static __inline__ void clear_bit(int nr, volatile void * addr)
47 local_irq_restore(flags); 37 local_irq_restore(flags);
48} 38}
49 39
50static __inline__ void __clear_bit(int nr, volatile void * addr)
51{
52 int mask;
53 volatile unsigned int *a = addr;
54
55 a += nr >> 5;
56 mask = 1 << (nr & 0x1f);
57 *a &= ~mask;
58}
59
60static __inline__ void change_bit(int nr, volatile void * addr) 40static __inline__ void change_bit(int nr, volatile void * addr)
61{ 41{
62 int mask; 42 int mask;
@@ -70,16 +50,6 @@ static __inline__ void change_bit(int nr, volatile void * addr)
70 local_irq_restore(flags); 50 local_irq_restore(flags);
71} 51}
72 52
73static __inline__ void __change_bit(int nr, volatile void * addr)
74{
75 int mask;
76 volatile unsigned int *a = addr;
77
78 a += nr >> 5;
79 mask = 1 << (nr & 0x1f);
80 *a ^= mask;
81}
82
83static __inline__ int test_and_set_bit(int nr, volatile void * addr) 53static __inline__ int test_and_set_bit(int nr, volatile void * addr)
84{ 54{
85 int mask, retval; 55 int mask, retval;
@@ -96,19 +66,6 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr)
96 return retval; 66 return retval;
97} 67}
98 68
99static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
100{
101 int mask, retval;
102 volatile unsigned int *a = addr;
103
104 a += nr >> 5;
105 mask = 1 << (nr & 0x1f);
106 retval = (mask & *a) != 0;
107 *a |= mask;
108
109 return retval;
110}
111
112static __inline__ int test_and_clear_bit(int nr, volatile void * addr) 69static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
113{ 70{
114 int mask, retval; 71 int mask, retval;
@@ -125,19 +82,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
125 return retval; 82 return retval;
126} 83}
127 84
128static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
129{
130 int mask, retval;
131 volatile unsigned int *a = addr;
132
133 a += nr >> 5;
134 mask = 1 << (nr & 0x1f);
135 retval = (mask & *a) != 0;
136 *a &= ~mask;
137
138 return retval;
139}
140
141static __inline__ int test_and_change_bit(int nr, volatile void * addr) 85static __inline__ int test_and_change_bit(int nr, volatile void * addr)
142{ 86{
143 int mask, retval; 87 int mask, retval;
@@ -154,23 +98,7 @@ static __inline__ int test_and_change_bit(int nr, volatile void * addr)
154 return retval; 98 return retval;
155} 99}
156 100
157static __inline__ int __test_and_change_bit(int nr, volatile void * addr) 101#include <asm-generic/bitops/non-atomic.h>
158{
159 int mask, retval;
160 volatile unsigned int *a = addr;
161
162 a += nr >> 5;
163 mask = 1 << (nr & 0x1f);
164 retval = (mask & *a) != 0;
165 *a ^= mask;
166
167 return retval;
168}
169
170static __inline__ int test_bit(int nr, const volatile void *addr)
171{
172 return 1UL & (((const volatile unsigned int *) addr)[nr >> 5] >> (nr & 31));
173}
174 102
175static __inline__ unsigned long ffz(unsigned long word) 103static __inline__ unsigned long ffz(unsigned long word)
176{ 104{
@@ -206,265 +134,15 @@ static __inline__ unsigned long __ffs(unsigned long word)
206 return result; 134 return result;
207} 135}
208 136
209/** 137#include <asm-generic/bitops/find.h>
210 * find_next_bit - find the next set bit in a memory region 138#include <asm-generic/bitops/ffs.h>
211 * @addr: The address to base the search on 139#include <asm-generic/bitops/hweight.h>
212 * @offset: The bitnumber to start searching at 140#include <asm-generic/bitops/sched.h>
213 * @size: The maximum size to search 141#include <asm-generic/bitops/ext2-non-atomic.h>
214 */ 142#include <asm-generic/bitops/ext2-atomic.h>
215static __inline__ unsigned long find_next_bit(const unsigned long *addr, 143#include <asm-generic/bitops/minix.h>
216 unsigned long size, unsigned long offset) 144#include <asm-generic/bitops/fls.h>
217{ 145#include <asm-generic/bitops/fls64.h>
218 unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
219 unsigned int result = offset & ~31UL;
220 unsigned int tmp;
221
222 if (offset >= size)
223 return size;
224 size -= result;
225 offset &= 31UL;
226 if (offset) {
227 tmp = *p++;
228 tmp &= ~0UL << offset;
229 if (size < 32)
230 goto found_first;
231 if (tmp)
232 goto found_middle;
233 size -= 32;
234 result += 32;
235 }
236 while (size >= 32) {
237 if ((tmp = *p++) != 0)
238 goto found_middle;
239 result += 32;
240 size -= 32;
241 }
242 if (!size)
243 return result;
244 tmp = *p;
245
246found_first:
247 tmp &= ~0UL >> (32 - size);
248 if (tmp == 0UL) /* Are any bits set? */
249 return result + size; /* Nope. */
250found_middle:
251 return result + __ffs(tmp);
252}
253
254/**
255 * find_first_bit - find the first set bit in a memory region
256 * @addr: The address to start the search at
257 * @size: The maximum size to search
258 *
259 * Returns the bit-number of the first set bit, not the number of the byte
260 * containing a bit.
261 */
262#define find_first_bit(addr, size) \
263 find_next_bit((addr), (size), 0)
264
265static __inline__ int find_next_zero_bit(const unsigned long *addr, int size, int offset)
266{
267 const unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
268 unsigned long result = offset & ~31UL;
269 unsigned long tmp;
270
271 if (offset >= size)
272 return size;
273 size -= result;
274 offset &= 31UL;
275 if (offset) {
276 tmp = *(p++);
277 tmp |= ~0UL >> (32-offset);
278 if (size < 32)
279 goto found_first;
280 if (~tmp)
281 goto found_middle;
282 size -= 32;
283 result += 32;
284 }
285 while (size & ~31UL) {
286 if (~(tmp = *(p++)))
287 goto found_middle;
288 result += 32;
289 size -= 32;
290 }
291 if (!size)
292 return result;
293 tmp = *p;
294
295found_first:
296 tmp |= ~0UL << size;
297found_middle:
298 return result + ffz(tmp);
299}
300
301#define find_first_zero_bit(addr, size) \
302 find_next_zero_bit((addr), (size), 0)
303
304/*
305 * ffs: find first bit set. This is defined the same way as
306 * the libc and compiler builtin ffs routines, therefore
307 * differs in spirit from the above ffz (man ffs).
308 */
309
310#define ffs(x) generic_ffs(x)
311
312/*
313 * hweightN: returns the hamming weight (i.e. the number
314 * of bits set) of a N-bit word
315 */
316
317#define hweight32(x) generic_hweight32(x)
318#define hweight16(x) generic_hweight16(x)
319#define hweight8(x) generic_hweight8(x)
320
321/*
322 * Every architecture must define this function. It's the fastest
323 * way of searching a 140-bit bitmap where the first 100 bits are
324 * unlikely to be set. It's guaranteed that at least one of the 140
325 * bits is cleared.
326 */
327
328static inline int sched_find_first_bit(const unsigned long *b)
329{
330 if (unlikely(b[0]))
331 return __ffs(b[0]);
332 if (unlikely(b[1]))
333 return __ffs(b[1]) + 32;
334 if (unlikely(b[2]))
335 return __ffs(b[2]) + 64;
336 if (b[3])
337 return __ffs(b[3]) + 96;
338 return __ffs(b[4]) + 128;
339}
340
341#ifdef __LITTLE_ENDIAN__
342#define ext2_set_bit(nr, addr) __test_and_set_bit((nr), (addr))
343#define ext2_clear_bit(nr, addr) __test_and_clear_bit((nr), (addr))
344#define ext2_test_bit(nr, addr) test_bit((nr), (addr))
345#define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size))
346#define ext2_find_next_zero_bit(addr, size, offset) \
347 find_next_zero_bit((unsigned long *)(addr), (size), (offset))
348#else
349static __inline__ int ext2_set_bit(int nr, volatile void * addr)
350{
351 int mask, retval;
352 volatile unsigned char *ADDR = (unsigned char *) addr;
353
354 ADDR += nr >> 3;
355 mask = 1 << (nr & 0x07);
356 retval = (mask & *ADDR) != 0;
357 *ADDR |= mask;
358 return retval;
359}
360
361static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
362{
363 int mask, retval;
364 volatile unsigned char *ADDR = (unsigned char *) addr;
365
366 ADDR += nr >> 3;
367 mask = 1 << (nr & 0x07);
368 retval = (mask & *ADDR) != 0;
369 *ADDR &= ~mask;
370 return retval;
371}
372
373static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
374{
375 int mask;
376 const volatile unsigned char *ADDR = (const unsigned char *) addr;
377
378 ADDR += nr >> 3;
379 mask = 1 << (nr & 0x07);
380 return ((mask & *ADDR) != 0);
381}
382
383#define ext2_find_first_zero_bit(addr, size) \
384 ext2_find_next_zero_bit((addr), (size), 0)
385
386static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
387{
388 unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
389 unsigned long result = offset & ~31UL;
390 unsigned long tmp;
391
392 if (offset >= size)
393 return size;
394 size -= result;
395 offset &= 31UL;
396 if(offset) {
397 /* We hold the little endian value in tmp, but then the
398 * shift is illegal. So we could keep a big endian value
399 * in tmp, like this:
400 *
401 * tmp = __swab32(*(p++));
402 * tmp |= ~0UL >> (32-offset);
403 *
404 * but this would decrease preformance, so we change the
405 * shift:
406 */
407 tmp = *(p++);
408 tmp |= __swab32(~0UL >> (32-offset));
409 if(size < 32)
410 goto found_first;
411 if(~tmp)
412 goto found_middle;
413 size -= 32;
414 result += 32;
415 }
416 while(size & ~31UL) {
417 if(~(tmp = *(p++)))
418 goto found_middle;
419 result += 32;
420 size -= 32;
421 }
422 if(!size)
423 return result;
424 tmp = *p;
425
426found_first:
427 /* tmp is little endian, so we would have to swab the shift,
428 * see above. But then we have to swab tmp below for ffz, so
429 * we might as well do this here.
430 */
431 return result + ffz(__swab32(tmp) | (~0UL << size));
432found_middle:
433 return result + ffz(__swab32(tmp));
434}
435#endif
436
437#define ext2_set_bit_atomic(lock, nr, addr) \
438 ({ \
439 int ret; \
440 spin_lock(lock); \
441 ret = ext2_set_bit((nr), (addr)); \
442 spin_unlock(lock); \
443 ret; \
444 })
445
446#define ext2_clear_bit_atomic(lock, nr, addr) \
447 ({ \
448 int ret; \
449 spin_lock(lock); \
450 ret = ext2_clear_bit((nr), (addr)); \
451 spin_unlock(lock); \
452 ret; \
453 })
454
455/* Bitmap functions for the minix filesystem. */
456#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,addr)
457#define minix_set_bit(nr,addr) __set_bit(nr,addr)
458#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,addr)
459#define minix_test_bit(nr,addr) test_bit(nr,addr)
460#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
461
462/*
463 * fls: find last bit set.
464 */
465
466#define fls(x) generic_fls(x)
467#define fls64(x) generic_fls64(x)
468 146
469#endif /* __KERNEL__ */ 147#endif /* __KERNEL__ */
470 148