[PATCH] bitops: m68k: use generic bitops (ba1a5b32) · Commits · 戴 / test

arch/m68k/Kconfig

+4 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,10 @@ config RWSEM_GENERIC_SPINLOCK
		config RWSEM_XCHGADD_ALGORITHM
		bool

		config GENERIC_HWEIGHT
		bool
		default y

		config GENERIC_CALIBRATE_DELAY
		bool
		default y

include/asm-m68k/bitops.h

+5 −81

Original line number	Diff line number	Diff line
		@@ -310,36 +310,10 @@ static inline int fls(int x)

		return 32 - cnt;
		}
		#define fls64(x) generic_fls64(x)

		/*
		* Every architecture must define this function. It's the fastest
		* way of searching a 140-bit bitmap where the first 100 bits are
		* unlikely to be set. It's guaranteed that at least one of the 140
		* bits is cleared.
		*/
		static inline int sched_find_first_bit(const unsigned long *b)
		{
		if (unlikely(b[0]))
		return __ffs(b[0]);
		if (unlikely(b[1]))
		return __ffs(b[1]) + 32;
		if (unlikely(b[2]))
		return __ffs(b[2]) + 64;
		if (b[3])
		return __ffs(b[3]) + 96;
		return __ffs(b[4]) + 128;
		}


		/*
		* hweightN: returns the hamming weight (i.e. the number
		* of bits set) of a N-bit word
		*/

		#define hweight32(x) generic_hweight32(x)
		#define hweight16(x) generic_hweight16(x)
		#define hweight8(x) generic_hweight8(x)
		#include <asm-generic/bitops/fls64.h>
		#include <asm-generic/bitops/sched.h>
		#include <asm-generic/bitops/hweight.h>

		/* Bitmap functions for the minix filesystem */

		@@ -377,61 +351,11 @@ static inline int minix_test_bit(int nr, const void *vaddr)

		/* Bitmap functions for the ext2 filesystem. */

		#define ext2_set_bit(nr, addr) __test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))
		#include <asm-generic/bitops/ext2-non-atomic.h>

		#define ext2_set_bit_atomic(lock, nr, addr) test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))
		#define ext2_clear_bit(nr, addr) __test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))
		#define ext2_clear_bit_atomic(lock, nr, addr) test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))

		static inline int ext2_test_bit(int nr, const void *vaddr)
		{
		const unsigned char *p = vaddr;
		return (p[nr >> 3] & (1U << (nr & 7))) != 0;
		}

		static inline int ext2_find_first_zero_bit(const void *vaddr, unsigned size)
		{
		const unsigned long p = vaddr, addr = vaddr;
		int res;

		if (!size)
		return 0;

		size = (size >> 5) + ((size & 31) > 0);
		while (*p++ == ~0UL)
		{
		if (--size == 0)
		return (p - addr) << 5;
		}

		--p;
		for (res = 0; res < 32; res++)
		if (!ext2_test_bit (res, p))
		break;
		return (p - addr) * 32 + res;
		}

		static inline int ext2_find_next_zero_bit(const void *vaddr, unsigned size,
		unsigned offset)
		{
		const unsigned long *addr = vaddr;
		const unsigned long *p = addr + (offset >> 5);
		int bit = offset & 31UL, res;

		if (offset >= size)
		return size;

		if (bit) {
		/* Look for zero in first longword */
		for (res = bit; res < 32; res++)
		if (!ext2_test_bit (res, p))
		return (p - addr) * 32 + res;
		p++;
		}
		/* No zero yet, search remaining full bytes for a zero */
		res = ext2_find_first_zero_bit (p, size - 32 * (p - addr));
		return (p - addr) * 32 + res;
		}

		#endif /* __KERNEL__ */

		#endif /* _M68K_BITOPS_H */

Admin message