include/linux/bitops.h

   1 #ifndef _LINUX_BITOPS_H
   2 #define _LINUX_BITOPS_H
   3 #include <asm/types.h>
   4
   5 #ifdef  __KERNEL__
   6 #define BIT(nr)                 (1UL << (nr))
   7 #define BIT_ULL(nr)             (1ULL << (nr))
   8 #define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
   9 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
  10 #define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
  11 #define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
  12 #define BITS_PER_BYTE           8
  13 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
  14 #endif
  15
  16 extern unsigned int __sw_hweight8(unsigned int w);
  17 extern unsigned int __sw_hweight16(unsigned int w);
  18 extern unsigned int __sw_hweight32(unsigned int w);
  19 extern unsigned long __sw_hweight64(__u64 w);
  20
  21 /*
  22  * Include this here because some architectures need generic_ffs/fls in
  23  * scope
  24  */
  25 #include <asm/bitops.h>
  26
  27 #define for_each_set_bit(bit, addr, size) \
  28         for ((bit) = find_first_bit((addr), (size)); \
  29              (bit) < (size); \
  30              (bit) = find_next_bit((addr), (size), (bit) + 1))
  31
  32 static __inline__ int get_bitmask_order(unsigned int count)
  33 {
  34         int order;
  35
  36         order = fls(count);
  37         return order;   /* We could be slightly more clever with -1 here... */
  38 }
  39
  40 static __inline__ int get_count_order(unsigned int count)
  41 {
  42         int order;
  43
  44         order = fls(count) - 1;
  45         if (count & (count - 1))
  46                 order++;
  47         return order;
  48 }
  49
  50 static inline unsigned long hweight_long(unsigned long w)
  51 {
  52         return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
  53 }
  54
  55 /**
  56  * rol64 - rotate a 64-bit value left
  57  * @word: value to rotate
  58  * @shift: bits to roll
  59  */
  60 static inline __u64 rol64(__u64 word, unsigned int shift)
  61 {
  62         return (word << shift) | (word >> (64 - shift));
  63 }
  64
  65 /**
  66  * ror64 - rotate a 64-bit value right
  67  * @word: value to rotate
  68  * @shift: bits to roll
  69  */
  70 static inline __u64 ror64(__u64 word, unsigned int shift)
  71 {
  72         return (word >> shift) | (word << (64 - shift));
  73 }
  74
  75 /**
  76  * rol32 - rotate a 32-bit value left
  77  * @word: value to rotate
  78  * @shift: bits to roll
  79  */
  80 static inline __u32 rol32(__u32 word, unsigned int shift)
  81 {
  82         return (word << shift) | (word >> (32 - shift));
  83 }
  84
  85 /**
  86  * ror32 - rotate a 32-bit value right
  87  * @word: value to rotate
  88  * @shift: bits to roll
  89  */
  90 static inline __u32 ror32(__u32 word, unsigned int shift)
  91 {
  92         return (word >> shift) | (word << (32 - shift));
  93 }
  94
  95 /**
  96  * rol16 - rotate a 16-bit value left
  97  * @word: value to rotate
  98  * @shift: bits to roll
  99  */
 100 static inline __u16 rol16(__u16 word, unsigned int shift)
 101 {
 102         return (word << shift) | (word >> (16 - shift));
 103 }
 104
 105 /**
 106  * ror16 - rotate a 16-bit value right
 107  * @word: value to rotate
 108  * @shift: bits to roll
 109  */
 110 static inline __u16 ror16(__u16 word, unsigned int shift)
 111 {
 112         return (word >> shift) | (word << (16 - shift));
 113 }
 114
 115 /**
 116  * rol8 - rotate an 8-bit value left
 117  * @word: value to rotate
 118  * @shift: bits to roll
 119  */
 120 static inline __u8 rol8(__u8 word, unsigned int shift)
 121 {
 122         return (word << shift) | (word >> (8 - shift));
 123 }
 124
 125 /**
 126  * ror8 - rotate an 8-bit value right
 127  * @word: value to rotate
 128  * @shift: bits to roll
 129  */
 130 static inline __u8 ror8(__u8 word, unsigned int shift)
 131 {
 132         return (word >> shift) | (word << (8 - shift));
 133 }
 134
 135 /**
 136  * sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit
 137  * @value: value to sign extend
 138  * @index: 0 based bit index (0<=index<32) to sign bit
 139  */
 140 static inline __s32 sign_extend32(__u32 value, int index)
 141 {
 142         __u8 shift = 31 - index;
 143         return (__s32)(value << shift) >> shift;
 144 }
 145
 146 static inline unsigned fls_long(unsigned long l)
 147 {
 148         if (sizeof(l) == 4)
 149                 return fls(l);
 150         return fls64(l);
 151 }
 152
 153 /**
 154  * __ffs64 - find first set bit in a 64 bit word
 155  * @word: The 64 bit word
 156  *
 157  * On 64 bit arches this is a synomyn for __ffs
 158  * The result is not defined if no bits are set, so check that @word
 159  * is non-zero before calling this.
 160  */
 161 static inline unsigned long __ffs64(u64 word)
 162 {
 163 #if BITS_PER_LONG == 32
 164         if (((u32)word) == 0UL)
 165                 return __ffs((u32)(word >> 32)) + 32;
 166 #elif BITS_PER_LONG != 64
 167 #error BITS_PER_LONG not 32 or 64
 168 #endif
 169         return __ffs((unsigned long)word);
 170 }
 171
 172 #ifdef __KERNEL__
 173
 174 #ifndef set_mask_bits
 175 #define set_mask_bits(ptr, _mask, _bits)        \
 176 ({                                                              \
 177         const typeof(*ptr) mask = (_mask), bits = (_bits);      \
 178         typeof(*ptr) old, new;                                  \
 179                                                                 \
 180         do {                                                    \
 181                 old = ACCESS_ONCE(*ptr);                        \
 182                 new = (old & ~mask) | bits;                     \
 183         } while (cmpxchg(ptr, old, new) != old);                \
 184                                                                 \
 185         new;                                                    \
 186 })
 187 #endif
 188
 189 #ifndef find_last_bit
 190 /**
 191  * find_last_bit - find the last set bit in a memory region
 192  * @addr: The address to start the search at
 193  * @size: The maximum size to search
 194  *
 195  * Returns the bit number of the first set bit, or size.
 196  */
 197 extern unsigned long find_last_bit(const unsigned long *addr,
 198                                    unsigned long size);
 199 #endif
 200
 201 #endif /* __KERNEL__ */
 202 #endif