| 1 |
1276 |
phoenix |
/*
|
| 2 |
|
|
* Copyright 1995, Russell King.
|
| 3 |
|
|
* Various bits and pieces copyrights include:
|
| 4 |
|
|
* Linus Torvalds (test_bit).
|
| 5 |
|
|
*
|
| 6 |
|
|
* bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
|
| 7 |
|
|
*
|
| 8 |
|
|
* Please note that the code in this file should never be included
|
| 9 |
|
|
* from user space. Many of these are not implemented in assembler
|
| 10 |
|
|
* since they would be too costly. Also, they require priviledged
|
| 11 |
|
|
* instructions (which are not available from user mode) to ensure
|
| 12 |
|
|
* that they are atomic.
|
| 13 |
|
|
*/
|
| 14 |
|
|
|
| 15 |
|
|
#ifndef __ASM_ARM_BITOPS_H
|
| 16 |
|
|
#define __ASM_ARM_BITOPS_H
|
| 17 |
|
|
|
| 18 |
|
|
#ifdef __KERNEL__
|
| 19 |
|
|
|
| 20 |
|
|
#define smp_mb__before_clear_bit() do { } while (0)
|
| 21 |
|
|
#define smp_mb__after_clear_bit() do { } while (0)
|
| 22 |
|
|
|
| 23 |
|
|
/*
|
| 24 |
|
|
* Function prototypes to keep gcc -Wall happy.
|
| 25 |
|
|
*/
|
| 26 |
|
|
extern void set_bit(int nr, volatile void * addr);
|
| 27 |
|
|
|
| 28 |
|
|
static inline void __set_bit(int nr, volatile void *addr)
|
| 29 |
|
|
{
|
| 30 |
|
|
((unsigned char *) addr)[nr >> 3] |= (1U << (nr & 7));
|
| 31 |
|
|
}
|
| 32 |
|
|
|
| 33 |
|
|
extern void clear_bit(int nr, volatile void * addr);
|
| 34 |
|
|
|
| 35 |
|
|
static inline void __clear_bit(int nr, volatile void *addr)
|
| 36 |
|
|
{
|
| 37 |
|
|
((unsigned char *) addr)[nr >> 3] &= ~(1U << (nr & 7));
|
| 38 |
|
|
}
|
| 39 |
|
|
|
| 40 |
|
|
extern void change_bit(int nr, volatile void * addr);
|
| 41 |
|
|
|
| 42 |
|
|
static inline void __change_bit(int nr, volatile void *addr)
|
| 43 |
|
|
{
|
| 44 |
|
|
((unsigned char *) addr)[nr >> 3] ^= (1U << (nr & 7));
|
| 45 |
|
|
}
|
| 46 |
|
|
|
| 47 |
|
|
extern int test_and_set_bit(int nr, volatile void * addr);
|
| 48 |
|
|
|
| 49 |
|
|
static inline int __test_and_set_bit(int nr, volatile void *addr)
|
| 50 |
|
|
{
|
| 51 |
|
|
unsigned int mask = 1 << (nr & 7);
|
| 52 |
|
|
unsigned int oldval;
|
| 53 |
|
|
|
| 54 |
|
|
oldval = ((unsigned char *) addr)[nr >> 3];
|
| 55 |
|
|
((unsigned char *) addr)[nr >> 3] = oldval | mask;
|
| 56 |
|
|
return oldval & mask;
|
| 57 |
|
|
}
|
| 58 |
|
|
|
| 59 |
|
|
extern int test_and_clear_bit(int nr, volatile void * addr);
|
| 60 |
|
|
|
| 61 |
|
|
static inline int __test_and_clear_bit(int nr, volatile void *addr)
|
| 62 |
|
|
{
|
| 63 |
|
|
unsigned int mask = 1 << (nr & 7);
|
| 64 |
|
|
unsigned int oldval;
|
| 65 |
|
|
|
| 66 |
|
|
oldval = ((unsigned char *) addr)[nr >> 3];
|
| 67 |
|
|
((unsigned char *) addr)[nr >> 3] = oldval & ~mask;
|
| 68 |
|
|
return oldval & mask;
|
| 69 |
|
|
}
|
| 70 |
|
|
|
| 71 |
|
|
extern int test_and_change_bit(int nr, volatile void * addr);
|
| 72 |
|
|
|
| 73 |
|
|
static inline int __test_and_change_bit(int nr, volatile void *addr)
|
| 74 |
|
|
{
|
| 75 |
|
|
unsigned int mask = 1 << (nr & 7);
|
| 76 |
|
|
unsigned int oldval;
|
| 77 |
|
|
|
| 78 |
|
|
oldval = ((unsigned char *) addr)[nr >> 3];
|
| 79 |
|
|
((unsigned char *) addr)[nr >> 3] = oldval ^ mask;
|
| 80 |
|
|
return oldval & mask;
|
| 81 |
|
|
}
|
| 82 |
|
|
|
| 83 |
|
|
extern int find_first_zero_bit(void * addr, unsigned size);
|
| 84 |
|
|
extern int find_next_zero_bit(void * addr, int size, int offset);
|
| 85 |
|
|
|
| 86 |
|
|
/*
|
| 87 |
|
|
* This routine doesn't need to be atomic.
|
| 88 |
|
|
*/
|
| 89 |
|
|
static inline int test_bit(int nr, const void * addr)
|
| 90 |
|
|
{
|
| 91 |
|
|
return (((unsigned char *) addr)[nr >> 3] >> (nr & 7)) & 1;
|
| 92 |
|
|
}
|
| 93 |
|
|
|
| 94 |
|
|
/*
|
| 95 |
|
|
* ffz = Find First Zero in word. Undefined if no zero exists,
|
| 96 |
|
|
* so code should check against ~0UL first..
|
| 97 |
|
|
*/
|
| 98 |
|
|
static inline unsigned long ffz(unsigned long word)
|
| 99 |
|
|
{
|
| 100 |
|
|
int k;
|
| 101 |
|
|
|
| 102 |
|
|
word = ~word;
|
| 103 |
|
|
k = 31;
|
| 104 |
|
|
if (word & 0x0000ffff) { k -= 16; word <<= 16; }
|
| 105 |
|
|
if (word & 0x00ff0000) { k -= 8; word <<= 8; }
|
| 106 |
|
|
if (word & 0x0f000000) { k -= 4; word <<= 4; }
|
| 107 |
|
|
if (word & 0x30000000) { k -= 2; word <<= 2; }
|
| 108 |
|
|
if (word & 0x40000000) { k -= 1; }
|
| 109 |
|
|
return k;
|
| 110 |
|
|
}
|
| 111 |
|
|
|
| 112 |
|
|
/*
|
| 113 |
|
|
* ffs: find first bit set. This is defined the same way as
|
| 114 |
|
|
* the libc and compiler builtin ffs routines, therefore
|
| 115 |
|
|
* differs in spirit from the above ffz (man ffs).
|
| 116 |
|
|
*/
|
| 117 |
|
|
|
| 118 |
|
|
#define ffs(x) generic_ffs(x)
|
| 119 |
|
|
|
| 120 |
|
|
/*
|
| 121 |
|
|
* hweightN: returns the hamming weight (i.e. the number
|
| 122 |
|
|
* of bits set) of a N-bit word
|
| 123 |
|
|
*/
|
| 124 |
|
|
|
| 125 |
|
|
#define hweight32(x) generic_hweight32(x)
|
| 126 |
|
|
#define hweight16(x) generic_hweight16(x)
|
| 127 |
|
|
#define hweight8(x) generic_hweight8(x)
|
| 128 |
|
|
|
| 129 |
|
|
#define ext2_set_bit test_and_set_bit
|
| 130 |
|
|
#define ext2_clear_bit test_and_clear_bit
|
| 131 |
|
|
#define ext2_test_bit test_bit
|
| 132 |
|
|
#define ext2_find_first_zero_bit find_first_zero_bit
|
| 133 |
|
|
#define ext2_find_next_zero_bit find_next_zero_bit
|
| 134 |
|
|
|
| 135 |
|
|
/* Bitmap functions for the minix filesystem. */
|
| 136 |
|
|
#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
|
| 137 |
|
|
#define minix_set_bit(nr,addr) set_bit(nr,addr)
|
| 138 |
|
|
#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
|
| 139 |
|
|
#define minix_test_bit(nr,addr) test_bit(nr,addr)
|
| 140 |
|
|
#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
|
| 141 |
|
|
|
| 142 |
|
|
#endif /* __KERNEL__ */
|
| 143 |
|
|
|
| 144 |
|
|
#endif /* _ARM_BITOPS_H */
|
