| /drivers/include/asm-generic/bitops/const_hweight.h |
|---|
| 0,0 → 1,43 |
| #ifndef _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_ |
| #define _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_ |
| /* |
| * Compile time versions of __arch_hweightN() |
| */ |
| #define __const_hweight8(w) \ |
| ((unsigned int) \ |
| ((!!((w) & (1ULL << 0))) + \ |
| (!!((w) & (1ULL << 1))) + \ |
| (!!((w) & (1ULL << 2))) + \ |
| (!!((w) & (1ULL << 3))) + \ |
| (!!((w) & (1ULL << 4))) + \ |
| (!!((w) & (1ULL << 5))) + \ |
| (!!((w) & (1ULL << 6))) + \ |
| (!!((w) & (1ULL << 7))))) |
| #define __const_hweight16(w) (__const_hweight8(w) + __const_hweight8((w) >> 8 )) |
| #define __const_hweight32(w) (__const_hweight16(w) + __const_hweight16((w) >> 16)) |
| #define __const_hweight64(w) (__const_hweight32(w) + __const_hweight32((w) >> 32)) |
| /* |
| * Generic interface. |
| */ |
| #define hweight8(w) (__builtin_constant_p(w) ? __const_hweight8(w) : __arch_hweight8(w)) |
| #define hweight16(w) (__builtin_constant_p(w) ? __const_hweight16(w) : __arch_hweight16(w)) |
| #define hweight32(w) (__builtin_constant_p(w) ? __const_hweight32(w) : __arch_hweight32(w)) |
| #define hweight64(w) (__builtin_constant_p(w) ? __const_hweight64(w) : __arch_hweight64(w)) |
| /* |
| * Interface for known constant arguments |
| */ |
| #define HWEIGHT8(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight8(w)) |
| #define HWEIGHT16(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight16(w)) |
| #define HWEIGHT32(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight32(w)) |
| #define HWEIGHT64(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight64(w)) |
| /* |
| * Type invariant interface to the compile time constant hweight functions. |
| */ |
| #define HWEIGHT(w) HWEIGHT64((u64)w) |
| #endif /* _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_ */ |
| /drivers/include/asm-generic/bitops/ext2-atomic-setbit.h |
|---|
| 0,0 → 1,11 |
| #ifndef _ASM_GENERIC_BITOPS_EXT2_ATOMIC_SETBIT_H_ |
| #define _ASM_GENERIC_BITOPS_EXT2_ATOMIC_SETBIT_H_ |
| /* |
| * Atomic bitops based version of ext2 atomic bitops |
| */ |
| #define ext2_set_bit_atomic(l, nr, addr) test_and_set_bit_le(nr, addr) |
| #define ext2_clear_bit_atomic(l, nr, addr) test_and_clear_bit_le(nr, addr) |
| #endif /* _ASM_GENERIC_BITOPS_EXT2_ATOMIC_SETBIT_H_ */ |
| /drivers/include/asm-generic/bitops/ext2-non-atomic.h |
|---|
| 0,0 → 1,20 |
| #ifndef _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_ |
| #define _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_ |
| #include <asm-generic/bitops/le.h> |
| #define ext2_set_bit(nr,addr) \ |
| generic___test_and_set_le_bit((nr),(unsigned long *)(addr)) |
| #define ext2_clear_bit(nr,addr) \ |
| generic___test_and_clear_le_bit((nr),(unsigned long *)(addr)) |
| #define ext2_test_bit(nr,addr) \ |
| generic_test_le_bit((nr),(unsigned long *)(addr)) |
| #define ext2_find_first_zero_bit(addr, size) \ |
| generic_find_first_zero_le_bit((unsigned long *)(addr), (size)) |
| #define ext2_find_next_zero_bit(addr, size, off) \ |
| generic_find_next_zero_le_bit((unsigned long *)(addr), (size), (off)) |
| #define ext2_find_next_bit(addr, size, off) \ |
| generic_find_next_le_bit((unsigned long *)(addr), (size), (off)) |
| #endif /* _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_ */ |
| /drivers/include/asm-generic/bitops/find.h |
|---|
| 0,0 → 1,62 |
| #ifndef _ASM_GENERIC_BITOPS_FIND_H_ |
| #define _ASM_GENERIC_BITOPS_FIND_H_ |
| #ifndef find_next_bit |
| /** |
| * find_next_bit - find the next set bit in a memory region |
| * @addr: The address to base the search on |
| * @offset: The bitnumber to start searching at |
| * @size: The bitmap size in bits |
| * |
| * Returns the bit number for the next set bit |
| * If no bits are set, returns @size. |
| */ |
| extern unsigned long find_next_bit(const unsigned long *addr, unsigned long |
| size, unsigned long offset); |
| #endif |
| #ifndef find_next_zero_bit |
| /** |
| * find_next_zero_bit - find the next cleared bit in a memory region |
| * @addr: The address to base the search on |
| * @offset: The bitnumber to start searching at |
| * @size: The bitmap size in bits |
| * |
| * Returns the bit number of the next zero bit |
| * If no bits are zero, returns @size. |
| */ |
| extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned |
| long size, unsigned long offset); |
| #endif |
| #ifdef CONFIG_GENERIC_FIND_FIRST_BIT |
| /** |
| * find_first_bit - find the first set bit in a memory region |
| * @addr: The address to start the search at |
| * @size: The maximum number of bits to search |
| * |
| * Returns the bit number of the first set bit. |
| * If no bits are set, returns @size. |
| */ |
| extern unsigned long find_first_bit(const unsigned long *addr, |
| unsigned long size); |
| /** |
| * find_first_zero_bit - find the first cleared bit in a memory region |
| * @addr: The address to start the search at |
| * @size: The maximum number of bits to search |
| * |
| * Returns the bit number of the first cleared bit. |
| * If no bits are zero, returns @size. |
| */ |
| extern unsigned long find_first_zero_bit(const unsigned long *addr, |
| unsigned long size); |
| #else /* CONFIG_GENERIC_FIND_FIRST_BIT */ |
| #define find_first_bit(addr, size) find_next_bit((addr), (size), 0) |
| #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0) |
| #endif /* CONFIG_GENERIC_FIND_FIRST_BIT */ |
| #endif /*_ASM_GENERIC_BITOPS_FIND_H_ */ |
| /drivers/include/asm-generic/bitops/fls64.h |
|---|
| 0,0 → 1,36 |
| #ifndef _ASM_GENERIC_BITOPS_FLS64_H_ |
| #define _ASM_GENERIC_BITOPS_FLS64_H_ |
| #include <asm/types.h> |
| /** |
| * fls64 - find last set bit in a 64-bit word |
| * @x: the word to search |
| * |
| * This is defined in a similar way as the libc and compiler builtin |
| * ffsll, but returns the position of the most significant set bit. |
| * |
| * fls64(value) returns 0 if value is 0 or the position of the last |
| * set bit if value is nonzero. The last (most significant) bit is |
| * at position 64. |
| */ |
| #if BITS_PER_LONG == 32 |
| static __always_inline int fls64(__u64 x) |
| { |
| __u32 h = x >> 32; |
| if (h) |
| return fls(h) + 32; |
| return fls(x); |
| } |
| #elif BITS_PER_LONG == 64 |
| static __always_inline int fls64(__u64 x) |
| { |
| if (x == 0) |
| return 0; |
| return __fls(x) + 1; |
| } |
| #else |
| #error BITS_PER_LONG not 32 or 64 |
| #endif |
| #endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */ |
| /drivers/include/asm-generic/bitops/hweight.h |
|---|
| 0,0 → 1,7 |
| #ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_ |
| #define _ASM_GENERIC_BITOPS_HWEIGHT_H_ |
| #include <asm-generic/bitops/arch_hweight.h> |
| #include <asm-generic/bitops/const_hweight.h> |
| #endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */ |
| /drivers/include/asm-generic/bitops/le.h |
|---|
| 0,0 → 1,97 |
| #ifndef _ASM_GENERIC_BITOPS_LE_H_ |
| #define _ASM_GENERIC_BITOPS_LE_H_ |
| #include <asm/types.h> |
| #include <asm/byteorder.h> |
| #if defined(__LITTLE_ENDIAN) |
| #define BITOP_LE_SWIZZLE 0 |
| static inline unsigned long find_next_zero_bit_le(const void *addr, |
| unsigned long size, unsigned long offset) |
| { |
| return find_next_zero_bit(addr, size, offset); |
| } |
| static inline unsigned long find_next_bit_le(const void *addr, |
| unsigned long size, unsigned long offset) |
| { |
| return find_next_bit(addr, size, offset); |
| } |
| static inline unsigned long find_first_zero_bit_le(const void *addr, |
| unsigned long size) |
| { |
| return find_first_zero_bit(addr, size); |
| } |
| #elif defined(__BIG_ENDIAN) |
| #define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7) |
| #ifndef find_next_zero_bit_le |
| extern unsigned long find_next_zero_bit_le(const void *addr, |
| unsigned long size, unsigned long offset); |
| #endif |
| #ifndef find_next_bit_le |
| extern unsigned long find_next_bit_le(const void *addr, |
| unsigned long size, unsigned long offset); |
| #endif |
| #ifndef find_first_zero_bit_le |
| #define find_first_zero_bit_le(addr, size) \ |
| find_next_zero_bit_le((addr), (size), 0) |
| #endif |
| #else |
| #error "Please fix <asm/byteorder.h>" |
| #endif |
| static inline int test_bit_le(int nr, const void *addr) |
| { |
| return test_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline void set_bit_le(int nr, void *addr) |
| { |
| set_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline void clear_bit_le(int nr, void *addr) |
| { |
| clear_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline void __set_bit_le(int nr, void *addr) |
| { |
| __set_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline void __clear_bit_le(int nr, void *addr) |
| { |
| __clear_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline int test_and_set_bit_le(int nr, void *addr) |
| { |
| return test_and_set_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline int test_and_clear_bit_le(int nr, void *addr) |
| { |
| return test_and_clear_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline int __test_and_set_bit_le(int nr, void *addr) |
| { |
| return __test_and_set_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| static inline int __test_and_clear_bit_le(int nr, void *addr) |
| { |
| return __test_and_clear_bit(nr ^ BITOP_LE_SWIZZLE, addr); |
| } |
| #endif /* _ASM_GENERIC_BITOPS_LE_H_ */ |
| /drivers/include/asm-generic/bitops/minix.h |
|---|
| 0,0 → 1,15 |
| #ifndef _ASM_GENERIC_BITOPS_MINIX_H_ |
| #define _ASM_GENERIC_BITOPS_MINIX_H_ |
| #define minix_test_and_set_bit(nr,addr) \ |
| __test_and_set_bit((nr),(unsigned long *)(addr)) |
| #define minix_set_bit(nr,addr) \ |
| __set_bit((nr),(unsigned long *)(addr)) |
| #define minix_test_and_clear_bit(nr,addr) \ |
| __test_and_clear_bit((nr),(unsigned long *)(addr)) |
| #define minix_test_bit(nr,addr) \ |
| test_bit((nr),(unsigned long *)(addr)) |
| #define minix_find_first_zero_bit(addr,size) \ |
| find_first_zero_bit((unsigned long *)(addr),(size)) |
| #endif /* _ASM_GENERIC_BITOPS_MINIX_H_ */ |
| /drivers/include/asm-generic/bitops/sched.h |
|---|
| 0,0 → 1,31 |
| #ifndef _ASM_GENERIC_BITOPS_SCHED_H_ |
| #define _ASM_GENERIC_BITOPS_SCHED_H_ |
| #include <linux/compiler.h> /* unlikely() */ |
| #include <asm/types.h> |
| /* |
| * Every architecture must define this function. It's the fastest |
| * way of searching a 100-bit bitmap. It's guaranteed that at least |
| * one of the 100 bits is cleared. |
| */ |
| static inline int sched_find_first_bit(const unsigned long *b) |
| { |
| #if BITS_PER_LONG == 64 |
| if (b[0]) |
| return __ffs(b[0]); |
| return __ffs(b[1]) + 64; |
| #elif BITS_PER_LONG == 32 |
| if (b[0]) |
| return __ffs(b[0]); |
| if (b[1]) |
| return __ffs(b[1]) + 32; |
| if (b[2]) |
| return __ffs(b[2]) + 64; |
| return __ffs(b[3]) + 96; |
| #else |
| #error BITS_PER_LONG not defined |
| #endif |
| } |
| #endif /* _ASM_GENERIC_BITOPS_SCHED_H_ */ |