1 #ifndef _LINUX_BITOPS_H 2 #define _LINUX_BITOPS_H 3 4 #include <asm/types.h> 5 #include <asm-generic/bitsperlong.h> 6 #include <linux/compiler.h> 7 8 #ifdef __KERNEL__ 9 #define BIT(nr) (1UL << (nr)) 10 #define BIT_ULL(nr) (1ULL << (nr)) 11 #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) 12 #define BIT_WORD(nr) ((nr) / BITS_PER_LONG) 13 #define BIT_ULL_MASK(nr) (1ULL << ((nr) % BITS_PER_LONG_LONG)) 14 #define BIT_ULL_WORD(nr) ((nr) / BITS_PER_LONG_LONG) 15 #define BITS_PER_BYTE 8 16 #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) 17 #endif 18 19 /* 20 * Create a contiguous bitmask starting at bit position @l and ending at 21 * position @h. For example 22 * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000. 23 */ 24 #ifdef CONFIG_SANDBOX 25 #define GENMASK(h, l) \ 26 (((~0UL) << (l)) & (~0UL >> (CONFIG_SANDBOX_BITS_PER_LONG - 1 - (h)))) 27 #else 28 #define GENMASK(h, l) \ 29 (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h)))) 30 #endif 31 32 #define GENMASK_ULL(h, l) \ 33 (((~0ULL) << (l)) & (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h)))) 34 35 /* 36 * ffs: find first bit set. This is defined the same way as 37 * the libc and compiler builtin ffs routines, therefore 38 * differs in spirit from the above ffz (man ffs). 39 */ 40 41 static inline int generic_ffs(int x) 42 { 43 int r = 1; 44 45 if (!x) 46 return 0; 47 if (!(x & 0xffff)) { 48 x >>= 16; 49 r += 16; 50 } 51 if (!(x & 0xff)) { 52 x >>= 8; 53 r += 8; 54 } 55 if (!(x & 0xf)) { 56 x >>= 4; 57 r += 4; 58 } 59 if (!(x & 3)) { 60 x >>= 2; 61 r += 2; 62 } 63 if (!(x & 1)) { 64 x >>= 1; 65 r += 1; 66 } 67 return r; 68 } 69 70 /** 71 * fls - find last (most-significant) bit set 72 * @x: the word to search 73 * 74 * This is defined the same way as ffs. 75 * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32. 76 */ 77 static inline int generic_fls(int x) 78 { 79 int r = 32; 80 81 if (!x) 82 return 0; 83 if (!(x & 0xffff0000u)) { 84 x <<= 16; 85 r -= 16; 86 } 87 if (!(x & 0xff000000u)) { 88 x <<= 8; 89 r -= 8; 90 } 91 if (!(x & 0xf0000000u)) { 92 x <<= 4; 93 r -= 4; 94 } 95 if (!(x & 0xc0000000u)) { 96 x <<= 2; 97 r -= 2; 98 } 99 if (!(x & 0x80000000u)) { 100 x <<= 1; 101 r -= 1; 102 } 103 return r; 104 } 105 106 107 /* 108 * hweightN: returns the hamming weight (i.e. the number 109 * of bits set) of a N-bit word 110 */ 111 112 static inline unsigned int generic_hweight32(unsigned int w) 113 { 114 unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); 115 res = (res & 0x33333333) + ((res >> 2) & 0x33333333); 116 res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F); 117 res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF); 118 return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF); 119 } 120 121 static inline unsigned int generic_hweight16(unsigned int w) 122 { 123 unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555); 124 res = (res & 0x3333) + ((res >> 2) & 0x3333); 125 res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F); 126 return (res & 0x00FF) + ((res >> 8) & 0x00FF); 127 } 128 129 static inline unsigned int generic_hweight8(unsigned int w) 130 { 131 unsigned int res = (w & 0x55) + ((w >> 1) & 0x55); 132 res = (res & 0x33) + ((res >> 2) & 0x33); 133 return (res & 0x0F) + ((res >> 4) & 0x0F); 134 } 135 136 #include <asm/bitops.h> 137 138 /* linux/include/asm-generic/bitops/non-atomic.h */ 139 140 #ifndef PLATFORM__SET_BIT 141 # define __set_bit generic_set_bit 142 #endif 143 144 #ifndef PLATFORM__CLEAR_BIT 145 # define __clear_bit generic_clear_bit 146 #endif 147 148 #ifndef PLATFORM_FFS 149 # define ffs generic_ffs 150 #endif 151 152 #ifndef PLATFORM_FLS 153 # define fls generic_fls 154 #endif 155 156 static inline unsigned fls_long(unsigned long l) 157 { 158 if (sizeof(l) == 4) 159 return fls(l); 160 return fls64(l); 161 } 162 163 /** 164 * __ffs64 - find first set bit in a 64 bit word 165 * @word: The 64 bit word 166 * 167 * On 64 bit arches this is a synomyn for __ffs 168 * The result is not defined if no bits are set, so check that @word 169 * is non-zero before calling this. 170 */ 171 static inline unsigned long __ffs64(u64 word) 172 { 173 #if BITS_PER_LONG == 32 174 if (((u32)word) == 0UL) 175 return __ffs((u32)(word >> 32)) + 32; 176 #elif BITS_PER_LONG != 64 177 #error BITS_PER_LONG not 32 or 64 178 #endif 179 return __ffs((unsigned long)word); 180 } 181 182 /** 183 * __set_bit - Set a bit in memory 184 * @nr: the bit to set 185 * @addr: the address to start counting from 186 * 187 * Unlike set_bit(), this function is non-atomic and may be reordered. 188 * If it's called on the same region of memory simultaneously, the effect 189 * may be that only one operation succeeds. 190 */ 191 static inline void generic_set_bit(int nr, volatile unsigned long *addr) 192 { 193 unsigned long mask = BIT_MASK(nr); 194 unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); 195 196 *p |= mask; 197 } 198 199 static inline void generic_clear_bit(int nr, volatile unsigned long *addr) 200 { 201 unsigned long mask = BIT_MASK(nr); 202 unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); 203 204 *p &= ~mask; 205 } 206 207 #endif 208