]> git.sur5r.net Git - u-boot/blob - include/asm-mips/bitops.h
SPEAr : Support added for SPEAr300 board
[u-boot] / include / asm-mips / bitops.h
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (c) 1994 - 1997, 1999, 2000  Ralf Baechle (ralf@gnu.org)
7  * Copyright (c) 2000  Silicon Graphics, Inc.
8  */
9 #ifndef _ASM_BITOPS_H
10 #define _ASM_BITOPS_H
11
12 #include <linux/types.h>
13 #include <asm/byteorder.h>              /* sigh ... */
14
15 #ifdef __KERNEL__
16
17 #include <asm/sgidefs.h>
18 #include <asm/system.h>
19 #include <linux/config.h>
20
21 /*
22  * clear_bit() doesn't provide any barrier for the compiler.
23  */
24 #define smp_mb__before_clear_bit()      barrier()
25 #define smp_mb__after_clear_bit()       barrier()
26
27 /*
28  * Only disable interrupt for kernel mode stuff to keep usermode stuff
29  * that dares to use kernel include files alive.
30  */
31 #define __bi_flags unsigned long flags
32 #define __bi_cli() __cli()
33 #define __bi_save_flags(x) __save_flags(x)
34 #define __bi_save_and_cli(x) __save_and_cli(x)
35 #define __bi_restore_flags(x) __restore_flags(x)
36 #else
37 #define __bi_flags
38 #define __bi_cli()
39 #define __bi_save_flags(x)
40 #define __bi_save_and_cli(x)
41 #define __bi_restore_flags(x)
42 #endif /* __KERNEL__ */
43
44 #ifdef CONFIG_CPU_HAS_LLSC
45
46 #include <asm/mipsregs.h>
47
48 /*
49  * These functions for MIPS ISA > 1 are interrupt and SMP proof and
50  * interrupt friendly
51  */
52
53 /*
54  * set_bit - Atomically set a bit in memory
55  * @nr: the bit to set
56  * @addr: the address to start counting from
57  *
58  * This function is atomic and may not be reordered.  See __set_bit()
59  * if you do not require the atomic guarantees.
60  * Note that @nr may be almost arbitrarily large; this function is not
61  * restricted to acting on a single-word quantity.
62  */
63 static __inline__ void
64 set_bit(int nr, volatile void *addr)
65 {
66         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
67         unsigned long temp;
68
69         __asm__ __volatile__(
70                 "1:\tll\t%0, %1\t\t# set_bit\n\t"
71                 "or\t%0, %2\n\t"
72                 "sc\t%0, %1\n\t"
73                 "beqz\t%0, 1b"
74                 : "=&r" (temp), "=m" (*m)
75                 : "ir" (1UL << (nr & 0x1f)), "m" (*m));
76 }
77
78 /*
79  * __set_bit - Set a bit in memory
80  * @nr: the bit to set
81  * @addr: the address to start counting from
82  *
83  * Unlike set_bit(), this function is non-atomic and may be reordered.
84  * If it's called on the same region of memory simultaneously, the effect
85  * may be that only one operation succeeds.
86  */
87 static __inline__ void __set_bit(int nr, volatile void * addr)
88 {
89         unsigned long * m = ((unsigned long *) addr) + (nr >> 5);
90
91         *m |= 1UL << (nr & 31);
92 }
93 #define PLATFORM__SET_BIT
94
95 /*
96  * clear_bit - Clears a bit in memory
97  * @nr: Bit to clear
98  * @addr: Address to start counting from
99  *
100  * clear_bit() is atomic and may not be reordered.  However, it does
101  * not contain a memory barrier, so if it is used for locking purposes,
102  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
103  * in order to ensure changes are visible on other processors.
104  */
105 static __inline__ void
106 clear_bit(int nr, volatile void *addr)
107 {
108         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
109         unsigned long temp;
110
111         __asm__ __volatile__(
112                 "1:\tll\t%0, %1\t\t# clear_bit\n\t"
113                 "and\t%0, %2\n\t"
114                 "sc\t%0, %1\n\t"
115                 "beqz\t%0, 1b\n\t"
116                 : "=&r" (temp), "=m" (*m)
117                 : "ir" (~(1UL << (nr & 0x1f))), "m" (*m));
118 }
119
120 /*
121  * change_bit - Toggle a bit in memory
122  * @nr: Bit to clear
123  * @addr: Address to start counting from
124  *
125  * change_bit() is atomic and may not be reordered.
126  * Note that @nr may be almost arbitrarily large; this function is not
127  * restricted to acting on a single-word quantity.
128  */
129 static __inline__ void
130 change_bit(int nr, volatile void *addr)
131 {
132         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
133         unsigned long temp;
134
135         __asm__ __volatile__(
136                 "1:\tll\t%0, %1\t\t# change_bit\n\t"
137                 "xor\t%0, %2\n\t"
138                 "sc\t%0, %1\n\t"
139                 "beqz\t%0, 1b"
140                 : "=&r" (temp), "=m" (*m)
141                 : "ir" (1UL << (nr & 0x1f)), "m" (*m));
142 }
143
144 /*
145  * __change_bit - Toggle a bit in memory
146  * @nr: the bit to set
147  * @addr: the address to start counting from
148  *
149  * Unlike change_bit(), this function is non-atomic and may be reordered.
150  * If it's called on the same region of memory simultaneously, the effect
151  * may be that only one operation succeeds.
152  */
153 static __inline__ void __change_bit(int nr, volatile void * addr)
154 {
155         unsigned long * m = ((unsigned long *) addr) + (nr >> 5);
156
157         *m ^= 1UL << (nr & 31);
158 }
159
160 /*
161  * test_and_set_bit - Set a bit and return its old value
162  * @nr: Bit to set
163  * @addr: Address to count from
164  *
165  * This operation is atomic and cannot be reordered.
166  * It also implies a memory barrier.
167  */
168 static __inline__ int
169 test_and_set_bit(int nr, volatile void *addr)
170 {
171         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
172         unsigned long temp, res;
173
174         __asm__ __volatile__(
175                 ".set\tnoreorder\t\t# test_and_set_bit\n"
176                 "1:\tll\t%0, %1\n\t"
177                 "or\t%2, %0, %3\n\t"
178                 "sc\t%2, %1\n\t"
179                 "beqz\t%2, 1b\n\t"
180                 " and\t%2, %0, %3\n\t"
181                 ".set\treorder"
182                 : "=&r" (temp), "=m" (*m), "=&r" (res)
183                 : "r" (1UL << (nr & 0x1f)), "m" (*m)
184                 : "memory");
185
186         return res != 0;
187 }
188
189 /*
190  * __test_and_set_bit - Set a bit and return its old value
191  * @nr: Bit to set
192  * @addr: Address to count from
193  *
194  * This operation is non-atomic and can be reordered.
195  * If two examples of this operation race, one can appear to succeed
196  * but actually fail.  You must protect multiple accesses with a lock.
197  */
198 static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
199 {
200         int mask, retval;
201         volatile int *a = addr;
202
203         a += nr >> 5;
204         mask = 1 << (nr & 0x1f);
205         retval = (mask & *a) != 0;
206         *a |= mask;
207
208         return retval;
209 }
210
211 /*
212  * test_and_clear_bit - Clear a bit and return its old value
213  * @nr: Bit to set
214  * @addr: Address to count from
215  *
216  * This operation is atomic and cannot be reordered.
217  * It also implies a memory barrier.
218  */
219 static __inline__ int
220 test_and_clear_bit(int nr, volatile void *addr)
221 {
222         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
223         unsigned long temp, res;
224
225         __asm__ __volatile__(
226                 ".set\tnoreorder\t\t# test_and_clear_bit\n"
227                 "1:\tll\t%0, %1\n\t"
228                 "or\t%2, %0, %3\n\t"
229                 "xor\t%2, %3\n\t"
230                 "sc\t%2, %1\n\t"
231                 "beqz\t%2, 1b\n\t"
232                 " and\t%2, %0, %3\n\t"
233                 ".set\treorder"
234                 : "=&r" (temp), "=m" (*m), "=&r" (res)
235                 : "r" (1UL << (nr & 0x1f)), "m" (*m)
236                 : "memory");
237
238         return res != 0;
239 }
240
241 /*
242  * __test_and_clear_bit - Clear a bit and return its old value
243  * @nr: Bit to set
244  * @addr: Address to count from
245  *
246  * This operation is non-atomic and can be reordered.
247  * If two examples of this operation race, one can appear to succeed
248  * but actually fail.  You must protect multiple accesses with a lock.
249  */
250 static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
251 {
252         int     mask, retval;
253         volatile int    *a = addr;
254
255         a += nr >> 5;
256         mask = 1 << (nr & 0x1f);
257         retval = (mask & *a) != 0;
258         *a &= ~mask;
259
260         return retval;
261 }
262
263 /*
264  * test_and_change_bit - Change a bit and return its new value
265  * @nr: Bit to set
266  * @addr: Address to count from
267  *
268  * This operation is atomic and cannot be reordered.
269  * It also implies a memory barrier.
270  */
271 static __inline__ int
272 test_and_change_bit(int nr, volatile void *addr)
273 {
274         unsigned long *m = ((unsigned long *) addr) + (nr >> 5);
275         unsigned long temp, res;
276
277         __asm__ __volatile__(
278                 ".set\tnoreorder\t\t# test_and_change_bit\n"
279                 "1:\tll\t%0, %1\n\t"
280                 "xor\t%2, %0, %3\n\t"
281                 "sc\t%2, %1\n\t"
282                 "beqz\t%2, 1b\n\t"
283                 " and\t%2, %0, %3\n\t"
284                 ".set\treorder"
285                 : "=&r" (temp), "=m" (*m), "=&r" (res)
286                 : "r" (1UL << (nr & 0x1f)), "m" (*m)
287                 : "memory");
288
289         return res != 0;
290 }
291
292 /*
293  * __test_and_change_bit - Change a bit and return its old value
294  * @nr: Bit to set
295  * @addr: Address to count from
296  *
297  * This operation is non-atomic and can be reordered.
298  * If two examples of this operation race, one can appear to succeed
299  * but actually fail.  You must protect multiple accesses with a lock.
300  */
301 static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
302 {
303         int     mask, retval;
304         volatile int    *a = addr;
305
306         a += nr >> 5;
307         mask = 1 << (nr & 0x1f);
308         retval = (mask & *a) != 0;
309         *a ^= mask;
310
311         return retval;
312 }
313
314 #else /* MIPS I */
315
316 /*
317  * set_bit - Atomically set a bit in memory
318  * @nr: the bit to set
319  * @addr: the address to start counting from
320  *
321  * This function is atomic and may not be reordered.  See __set_bit()
322  * if you do not require the atomic guarantees.
323  * Note that @nr may be almost arbitrarily large; this function is not
324  * restricted to acting on a single-word quantity.
325  */
326 static __inline__ void set_bit(int nr, volatile void * addr)
327 {
328         int     mask;
329         volatile int    *a = addr;
330         __bi_flags;
331
332         a += nr >> 5;
333         mask = 1 << (nr & 0x1f);
334         __bi_save_and_cli(flags);
335         *a |= mask;
336         __bi_restore_flags(flags);
337 }
338
339 /*
340  * __set_bit - Set a bit in memory
341  * @nr: the bit to set
342  * @addr: the address to start counting from
343  *
344  * Unlike set_bit(), this function is non-atomic and may be reordered.
345  * If it's called on the same region of memory simultaneously, the effect
346  * may be that only one operation succeeds.
347  */
348 static __inline__ void __set_bit(int nr, volatile void * addr)
349 {
350         int     mask;
351         volatile int    *a = addr;
352
353         a += nr >> 5;
354         mask = 1 << (nr & 0x1f);
355         *a |= mask;
356 }
357
358 /*
359  * clear_bit - Clears a bit in memory
360  * @nr: Bit to clear
361  * @addr: Address to start counting from
362  *
363  * clear_bit() is atomic and may not be reordered.  However, it does
364  * not contain a memory barrier, so if it is used for locking purposes,
365  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
366  * in order to ensure changes are visible on other processors.
367  */
368 static __inline__ void clear_bit(int nr, volatile void * addr)
369 {
370         int     mask;
371         volatile int    *a = addr;
372         __bi_flags;
373
374         a += nr >> 5;
375         mask = 1 << (nr & 0x1f);
376         __bi_save_and_cli(flags);
377         *a &= ~mask;
378         __bi_restore_flags(flags);
379 }
380
381 /*
382  * change_bit - Toggle a bit in memory
383  * @nr: Bit to clear
384  * @addr: Address to start counting from
385  *
386  * change_bit() is atomic and may not be reordered.
387  * Note that @nr may be almost arbitrarily large; this function is not
388  * restricted to acting on a single-word quantity.
389  */
390 static __inline__ void change_bit(int nr, volatile void * addr)
391 {
392         int     mask;
393         volatile int    *a = addr;
394         __bi_flags;
395
396         a += nr >> 5;
397         mask = 1 << (nr & 0x1f);
398         __bi_save_and_cli(flags);
399         *a ^= mask;
400         __bi_restore_flags(flags);
401 }
402
403 /*
404  * __change_bit - Toggle a bit in memory
405  * @nr: the bit to set
406  * @addr: the address to start counting from
407  *
408  * Unlike change_bit(), this function is non-atomic and may be reordered.
409  * If it's called on the same region of memory simultaneously, the effect
410  * may be that only one operation succeeds.
411  */
412 static __inline__ void __change_bit(int nr, volatile void * addr)
413 {
414         unsigned long * m = ((unsigned long *) addr) + (nr >> 5);
415
416         *m ^= 1UL << (nr & 31);
417 }
418
419 /*
420  * test_and_set_bit - Set a bit and return its old value
421  * @nr: Bit to set
422  * @addr: Address to count from
423  *
424  * This operation is atomic and cannot be reordered.
425  * It also implies a memory barrier.
426  */
427 static __inline__ int test_and_set_bit(int nr, volatile void * addr)
428 {
429         int     mask, retval;
430         volatile int    *a = addr;
431         __bi_flags;
432
433         a += nr >> 5;
434         mask = 1 << (nr & 0x1f);
435         __bi_save_and_cli(flags);
436         retval = (mask & *a) != 0;
437         *a |= mask;
438         __bi_restore_flags(flags);
439
440         return retval;
441 }
442
443 /*
444  * __test_and_set_bit - Set a bit and return its old value
445  * @nr: Bit to set
446  * @addr: Address to count from
447  *
448  * This operation is non-atomic and can be reordered.
449  * If two examples of this operation race, one can appear to succeed
450  * but actually fail.  You must protect multiple accesses with a lock.
451  */
452 static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
453 {
454         int     mask, retval;
455         volatile int    *a = addr;
456
457         a += nr >> 5;
458         mask = 1 << (nr & 0x1f);
459         retval = (mask & *a) != 0;
460         *a |= mask;
461
462         return retval;
463 }
464
465 /*
466  * test_and_clear_bit - Clear a bit and return its old value
467  * @nr: Bit to set
468  * @addr: Address to count from
469  *
470  * This operation is atomic and cannot be reordered.
471  * It also implies a memory barrier.
472  */
473 static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
474 {
475         int     mask, retval;
476         volatile int    *a = addr;
477         __bi_flags;
478
479         a += nr >> 5;
480         mask = 1 << (nr & 0x1f);
481         __bi_save_and_cli(flags);
482         retval = (mask & *a) != 0;
483         *a &= ~mask;
484         __bi_restore_flags(flags);
485
486         return retval;
487 }
488
489 /*
490  * __test_and_clear_bit - Clear a bit and return its old value
491  * @nr: Bit to set
492  * @addr: Address to count from
493  *
494  * This operation is non-atomic and can be reordered.
495  * If two examples of this operation race, one can appear to succeed
496  * but actually fail.  You must protect multiple accesses with a lock.
497  */
498 static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
499 {
500         int     mask, retval;
501         volatile int    *a = addr;
502
503         a += nr >> 5;
504         mask = 1 << (nr & 0x1f);
505         retval = (mask & *a) != 0;
506         *a &= ~mask;
507
508         return retval;
509 }
510
511 /*
512  * test_and_change_bit - Change a bit and return its new value
513  * @nr: Bit to set
514  * @addr: Address to count from
515  *
516  * This operation is atomic and cannot be reordered.
517  * It also implies a memory barrier.
518  */
519 static __inline__ int test_and_change_bit(int nr, volatile void * addr)
520 {
521         int     mask, retval;
522         volatile int    *a = addr;
523         __bi_flags;
524
525         a += nr >> 5;
526         mask = 1 << (nr & 0x1f);
527         __bi_save_and_cli(flags);
528         retval = (mask & *a) != 0;
529         *a ^= mask;
530         __bi_restore_flags(flags);
531
532         return retval;
533 }
534
535 /*
536  * __test_and_change_bit - Change a bit and return its old value
537  * @nr: Bit to set
538  * @addr: Address to count from
539  *
540  * This operation is non-atomic and can be reordered.
541  * If two examples of this operation race, one can appear to succeed
542  * but actually fail.  You must protect multiple accesses with a lock.
543  */
544 static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
545 {
546         int     mask, retval;
547         volatile int    *a = addr;
548
549         a += nr >> 5;
550         mask = 1 << (nr & 0x1f);
551         retval = (mask & *a) != 0;
552         *a ^= mask;
553
554         return retval;
555 }
556
557 #undef __bi_flags
558 #undef __bi_cli
559 #undef __bi_save_flags
560 #undef __bi_restore_flags
561
562 #endif /* MIPS I */
563
564 /*
565  * test_bit - Determine whether a bit is set
566  * @nr: bit number to test
567  * @addr: Address to start counting from
568  */
569 static __inline__ int test_bit(int nr, volatile void *addr)
570 {
571         return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
572 }
573
574 #ifndef __MIPSEB__
575
576 /* Little endian versions. */
577
578 /*
579  * find_first_zero_bit - find the first zero bit in a memory region
580  * @addr: The address to start the search at
581  * @size: The maximum size to search
582  *
583  * Returns the bit-number of the first zero bit, not the number of the byte
584  * containing a bit.
585  */
586 static __inline__ int find_first_zero_bit (void *addr, unsigned size)
587 {
588         unsigned long dummy;
589         int res;
590
591         if (!size)
592                 return 0;
593
594         __asm__ (".set\tnoreorder\n\t"
595                 ".set\tnoat\n"
596                 "1:\tsubu\t$1,%6,%0\n\t"
597                 "blez\t$1,2f\n\t"
598                 "lw\t$1,(%5)\n\t"
599                 "addiu\t%5,4\n\t"
600 #if (_MIPS_ISA == _MIPS_ISA_MIPS2 ) || (_MIPS_ISA == _MIPS_ISA_MIPS3 ) || \
601     (_MIPS_ISA == _MIPS_ISA_MIPS4 ) || (_MIPS_ISA == _MIPS_ISA_MIPS5 ) || \
602     (_MIPS_ISA == _MIPS_ISA_MIPS32) || (_MIPS_ISA == _MIPS_ISA_MIPS64)
603                 "beql\t%1,$1,1b\n\t"
604                 "addiu\t%0,32\n\t"
605 #else
606                 "addiu\t%0,32\n\t"
607                 "beq\t%1,$1,1b\n\t"
608                 "nop\n\t"
609                 "subu\t%0,32\n\t"
610 #endif
611 #ifdef __MIPSEB__
612 #error "Fix this for big endian"
613 #endif /* __MIPSEB__ */
614                 "li\t%1,1\n"
615                 "1:\tand\t%2,$1,%1\n\t"
616                 "beqz\t%2,2f\n\t"
617                 "sll\t%1,%1,1\n\t"
618                 "bnez\t%1,1b\n\t"
619                 "add\t%0,%0,1\n\t"
620                 ".set\tat\n\t"
621                 ".set\treorder\n"
622                 "2:"
623                 : "=r" (res), "=r" (dummy), "=r" (addr)
624                 : "0" ((signed int) 0), "1" ((unsigned int) 0xffffffff),
625                   "2" (addr), "r" (size)
626                 : "$1");
627
628         return res;
629 }
630
631 /*
632  * find_next_zero_bit - find the first zero bit in a memory region
633  * @addr: The address to base the search on
634  * @offset: The bitnumber to start searching at
635  * @size: The maximum size to search
636  */
637 static __inline__ int find_next_zero_bit (void * addr, int size, int offset)
638 {
639         unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
640         int set = 0, bit = offset & 31, res;
641         unsigned long dummy;
642
643         if (bit) {
644                 /*
645                  * Look for zero in first byte
646                  */
647 #ifdef __MIPSEB__
648 #error "Fix this for big endian byte order"
649 #endif
650                 __asm__(".set\tnoreorder\n\t"
651                         ".set\tnoat\n"
652                         "1:\tand\t$1,%4,%1\n\t"
653                         "beqz\t$1,1f\n\t"
654                         "sll\t%1,%1,1\n\t"
655                         "bnez\t%1,1b\n\t"
656                         "addiu\t%0,1\n\t"
657                         ".set\tat\n\t"
658                         ".set\treorder\n"
659                         "1:"
660                         : "=r" (set), "=r" (dummy)
661                         : "0" (0), "1" (1 << bit), "r" (*p)
662                         : "$1");
663                 if (set < (32 - bit))
664                         return set + offset;
665                 set = 32 - bit;
666                 p++;
667         }
668         /*
669          * No zero yet, search remaining full bytes for a zero
670          */
671         res = find_first_zero_bit(p, size - 32 * (p - (unsigned int *) addr));
672         return offset + set + res;
673 }
674
675 #endif /* !(__MIPSEB__) */
676
677 /*
678  * ffz - find first zero in word.
679  * @word: The word to search
680  *
681  * Undefined if no zero exists, so code should check against ~0UL first.
682  */
683 static __inline__ unsigned long ffz(unsigned long word)
684 {
685         unsigned int    __res;
686         unsigned int    mask = 1;
687
688         __asm__ (
689                 ".set\tnoreorder\n\t"
690                 ".set\tnoat\n\t"
691                 "move\t%0,$0\n"
692                 "1:\tand\t$1,%2,%1\n\t"
693                 "beqz\t$1,2f\n\t"
694                 "sll\t%1,1\n\t"
695                 "bnez\t%1,1b\n\t"
696                 "addiu\t%0,1\n\t"
697                 ".set\tat\n\t"
698                 ".set\treorder\n"
699                 "2:\n\t"
700                 : "=&r" (__res), "=r" (mask)
701                 : "r" (word), "1" (mask)
702                 : "$1");
703
704         return __res;
705 }
706
707 #ifdef __KERNEL__
708
709 /*
710  * hweightN - returns the hamming weight of a N-bit word
711  * @x: the word to weigh
712  *
713  * The Hamming Weight of a number is the total number of bits set in it.
714  */
715
716 #define hweight32(x) generic_hweight32(x)
717 #define hweight16(x) generic_hweight16(x)
718 #define hweight8(x) generic_hweight8(x)
719
720 #endif /* __KERNEL__ */
721
722 #ifdef __MIPSEB__
723 /*
724  * find_next_zero_bit - find the first zero bit in a memory region
725  * @addr: The address to base the search on
726  * @offset: The bitnumber to start searching at
727  * @size: The maximum size to search
728  */
729 static __inline__ int find_next_zero_bit(void *addr, int size, int offset)
730 {
731         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
732         unsigned long result = offset & ~31UL;
733         unsigned long tmp;
734
735         if (offset >= size)
736                 return size;
737         size -= result;
738         offset &= 31UL;
739         if (offset) {
740                 tmp = *(p++);
741                 tmp |= ~0UL >> (32-offset);
742                 if (size < 32)
743                         goto found_first;
744                 if (~tmp)
745                         goto found_middle;
746                 size -= 32;
747                 result += 32;
748         }
749         while (size & ~31UL) {
750                 if (~(tmp = *(p++)))
751                         goto found_middle;
752                 result += 32;
753                 size -= 32;
754         }
755         if (!size)
756                 return result;
757         tmp = *p;
758
759 found_first:
760         tmp |= ~0UL << size;
761 found_middle:
762         return result + ffz(tmp);
763 }
764
765 /* Linus sez that gcc can optimize the following correctly, we'll see if this
766  * holds on the Sparc as it does for the ALPHA.
767  */
768
769 #if 0 /* Fool kernel-doc since it doesn't do macros yet */
770 /*
771  * find_first_zero_bit - find the first zero bit in a memory region
772  * @addr: The address to start the search at
773  * @size: The maximum size to search
774  *
775  * Returns the bit-number of the first zero bit, not the number of the byte
776  * containing a bit.
777  */
778 static int find_first_zero_bit (void *addr, unsigned size);
779 #endif
780
781 #define find_first_zero_bit(addr, size) \
782         find_next_zero_bit((addr), (size), 0)
783
784 #endif /* (__MIPSEB__) */
785
786 /* Now for the ext2 filesystem bit operations and helper routines. */
787
788 #ifdef __MIPSEB__
789 static __inline__ int ext2_set_bit(int nr, void * addr)
790 {
791         int             mask, retval, flags;
792         unsigned char   *ADDR = (unsigned char *) addr;
793
794         ADDR += nr >> 3;
795         mask = 1 << (nr & 0x07);
796         save_and_cli(flags);
797         retval = (mask & *ADDR) != 0;
798         *ADDR |= mask;
799         restore_flags(flags);
800         return retval;
801 }
802
803 static __inline__ int ext2_clear_bit(int nr, void * addr)
804 {
805         int             mask, retval, flags;
806         unsigned char   *ADDR = (unsigned char *) addr;
807
808         ADDR += nr >> 3;
809         mask = 1 << (nr & 0x07);
810         save_and_cli(flags);
811         retval = (mask & *ADDR) != 0;
812         *ADDR &= ~mask;
813         restore_flags(flags);
814         return retval;
815 }
816
817 static __inline__ int ext2_test_bit(int nr, const void * addr)
818 {
819         int                     mask;
820         const unsigned char     *ADDR = (const unsigned char *) addr;
821
822         ADDR += nr >> 3;
823         mask = 1 << (nr & 0x07);
824         return ((mask & *ADDR) != 0);
825 }
826
827 #define ext2_find_first_zero_bit(addr, size) \
828         ext2_find_next_zero_bit((addr), (size), 0)
829
830 static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
831 {
832         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
833         unsigned long result = offset & ~31UL;
834         unsigned long tmp;
835
836         if (offset >= size)
837                 return size;
838         size -= result;
839         offset &= 31UL;
840         if(offset) {
841                 /* We hold the little endian value in tmp, but then the
842                  * shift is illegal. So we could keep a big endian value
843                  * in tmp, like this:
844                  *
845                  * tmp = __swab32(*(p++));
846                  * tmp |= ~0UL >> (32-offset);
847                  *
848                  * but this would decrease preformance, so we change the
849                  * shift:
850                  */
851                 tmp = *(p++);
852                 tmp |= __swab32(~0UL >> (32-offset));
853                 if(size < 32)
854                         goto found_first;
855                 if(~tmp)
856                         goto found_middle;
857                 size -= 32;
858                 result += 32;
859         }
860         while(size & ~31UL) {
861                 if(~(tmp = *(p++)))
862                         goto found_middle;
863                 result += 32;
864                 size -= 32;
865         }
866         if(!size)
867                 return result;
868         tmp = *p;
869
870 found_first:
871         /* tmp is little endian, so we would have to swab the shift,
872          * see above. But then we have to swab tmp below for ffz, so
873          * we might as well do this here.
874          */
875         return result + ffz(__swab32(tmp) | (~0UL << size));
876 found_middle:
877         return result + ffz(__swab32(tmp));
878 }
879 #else /* !(__MIPSEB__) */
880
881 /* Native ext2 byte ordering, just collapse using defines. */
882 #define ext2_set_bit(nr, addr) test_and_set_bit((nr), (addr))
883 #define ext2_clear_bit(nr, addr) test_and_clear_bit((nr), (addr))
884 #define ext2_test_bit(nr, addr) test_bit((nr), (addr))
885 #define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size))
886 #define ext2_find_next_zero_bit(addr, size, offset) \
887                 find_next_zero_bit((addr), (size), (offset))
888
889 #endif /* !(__MIPSEB__) */
890
891 /*
892  * Bitmap functions for the minix filesystem.
893  * FIXME: These assume that Minix uses the native byte/bitorder.
894  * This limits the Minix filesystem's value for data exchange very much.
895  */
896 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
897 #define minix_set_bit(nr,addr) set_bit(nr,addr)
898 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
899 #define minix_test_bit(nr,addr) test_bit(nr,addr)
900 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
901
902 #endif /* _ASM_BITOPS_H */