Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3f5527fe authored by Akinobu Mita's avatar Akinobu Mita Committed by Linus Torvalds
Browse files

m68k: introduce little-endian bitops 



Introduce little-endian bit operations by renaming native ext2 bit
operations and changing find_*_bit_le() to take a "void *".  The ext2 bit
operations are kept as wrapper macros using little-endian bit operations
to maintain bisectability until the conversions are finished.

Signed-off-by: default avatarAkinobu Mita <akinobu.mita@gmail.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roman Zippel <zippel@linux-m68k.org>
Cc: Andreas Schwab <schwab@linux-m68k.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent f6b57e32

arch/m68k/include/asm/bitops_mm.h

+67 −26
Original line number Original line Diff line number Diff line
@@ -359,24 +359,45 @@ static inline int minix_test_bit(int nr, const void *vaddr) 
	return (p[nr >> 4] & (1U << (nr & 15))) != 0;

	return (p[nr >> 4] & (1U << (nr & 15))) != 0;

}

}





/* Bitmap functions for the ext2 filesystem. */

/* Bitmap functions for the little endian bitmap. */





#define ext2_set_bit(nr, addr)			__test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))

static inline void __set_bit_le(int nr, void *addr)

#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))

	__set_bit(nr ^ 24, addr);

#define ext2_clear_bit_atomic(lock, nr, addr)	test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))

}

#define ext2_find_next_zero_bit(addr, size, offset) \



	find_next_zero_bit_le((unsigned long *)addr, size, offset)

static inline void __clear_bit_le(int nr, void *addr)

#define ext2_find_next_bit(addr, size, offset) \

{

	find_next_bit_le((unsigned long *)addr, size, offset)

	__clear_bit(nr ^ 24, addr);

}



static inline int __test_and_set_bit_le(int nr, void *addr)

{

	return __test_and_set_bit(nr ^ 24, addr);

}





static inline int ext2_test_bit(int nr, const void *vaddr)

static inline int test_and_set_bit_le(int nr, void *addr)

{

	return test_and_set_bit(nr ^ 24, addr);

}



static inline int __test_and_clear_bit_le(int nr, void *addr)

{

	return __test_and_clear_bit(nr ^ 24, addr);

}



static inline int test_and_clear_bit_le(int nr, void *addr)

{

	return test_and_clear_bit(nr ^ 24, addr);

}



static inline int test_bit_le(int nr, const void *vaddr)

{

{

	const unsigned char *p = vaddr;

	const unsigned char *p = vaddr;

	return (p[nr >> 3] & (1U << (nr & 7))) != 0;

	return (p[nr >> 3] & (1U << (nr & 7))) != 0;

}

}





static inline int ext2_find_first_zero_bit(const void *vaddr, unsigned size)

static inline int find_first_zero_bit_le(const void *vaddr, unsigned size)

{

{

	const unsigned long *p = vaddr, *addr = vaddr;

	const unsigned long *p = vaddr, *addr = vaddr;

	int res;

	int res;
@@ -393,33 +414,36 @@ static inline int ext2_find_first_zero_bit(const void *vaddr, unsigned size) 




	--p;

	--p;

	for (res = 0; res < 32; res++)

	for (res = 0; res < 32; res++)

		if (!ext2_test_bit (res, p))

		if (!test_bit_le(res, p))

			break;

			break;

	return (p - addr) * 32 + res;

	return (p - addr) * 32 + res;

}

}





static inline unsigned long find_next_zero_bit_le(const unsigned long *addr,

static inline unsigned long find_next_zero_bit_le(const void *addr,

		unsigned long size, unsigned long offset)

		unsigned long size, unsigned long offset)

{

{

	const unsigned long *p = addr + (offset >> 5);

	const unsigned long *p = addr;

	int bit = offset & 31UL, res;

	int bit = offset & 31UL, res;





	if (offset >= size)

	if (offset >= size)

		return size;

		return size;





	p += offset >> 5;



	if (bit) {

	if (bit) {

		offset -= bit;

		/* Look for zero in first longword */

		/* Look for zero in first longword */

		for (res = bit; res < 32; res++)

		for (res = bit; res < 32; res++)

			if (!ext2_test_bit (res, p))

			if (!test_bit_le(res, p))

				return (p - addr) * 32 + res;

				return offset + res;

		p++;

		p++;

		offset += 32;

	}

	}

	/* No zero yet, search remaining full bytes for a zero */

	/* No zero yet, search remaining full bytes for a zero */

	res = ext2_find_first_zero_bit (p, size - 32 * (p - addr));

	return offset + find_first_zero_bit_le(p, size - offset);

	return (p - addr) * 32 + res;

}

}





static inline int ext2_find_first_bit(const void *vaddr, unsigned size)

static inline int find_first_bit_le(const void *vaddr, unsigned size)

{

{

	const unsigned long *p = vaddr, *addr = vaddr;

	const unsigned long *p = vaddr, *addr = vaddr;

	int res;

	int res;
@@ -435,32 +459,49 @@ static inline int ext2_find_first_bit(const void *vaddr, unsigned size) 




	--p;

	--p;

	for (res = 0; res < 32; res++)

	for (res = 0; res < 32; res++)

		if (ext2_test_bit(res, p))

		if (test_bit_le(res, p))

			break;

			break;

	return (p - addr) * 32 + res;

	return (p - addr) * 32 + res;

}

}





static inline unsigned long find_next_bit_le(const unsigned long *addr,

static inline unsigned long find_next_bit_le(const void *addr,

		unsigned long size, unsigned long offset)

		unsigned long size, unsigned long offset)

{

{

	const unsigned long *p = addr + (offset >> 5);

	const unsigned long *p = addr;

	int bit = offset & 31UL, res;

	int bit = offset & 31UL, res;





	if (offset >= size)

	if (offset >= size)

		return size;

		return size;





	p += offset >> 5;



	if (bit) {

	if (bit) {

		offset -= bit;

		/* Look for one in first longword */

		/* Look for one in first longword */

		for (res = bit; res < 32; res++)

		for (res = bit; res < 32; res++)

			if (ext2_test_bit(res, p))

			if (test_bit_le(res, p))

				return (p - addr) * 32 + res;

				return offset + res;

		p++;

		p++;

		offset += 32;

	}

	}

	/* No set bit yet, search remaining full bytes for a set bit */

	/* No set bit yet, search remaining full bytes for a set bit */

	res = ext2_find_first_bit(p, size - 32 * (p - addr));

	return offset + find_first_bit_le(p, size - offset);

	return (p - addr) * 32 + res;

}

}





/* Bitmap functions for the ext2 filesystem. */



#define ext2_set_bit __test_and_set_bit_le

#define ext2_set_bit_atomic(lock, nr, addr)	\

	test_and_set_bit_le(nr, addr)

#define ext2_clear_bit __test_and_clear_bit_le

#define ext2_clear_bit_atomic(lock, nr, addr)	\

	test_and_clear_bit_le(nr, addr)

#define ext2_find_next_zero_bit find_next_zero_bit_le

#define ext2_find_next_bit find_next_bit_le

#define ext2_test_bit test_bit_le

#define ext2_find_first_zero_bit find_first_zero_bit_le

#define ext2_find_first_bit find_first_bit_le



#endif /* __KERNEL__ */

#endif /* __KERNEL__ */





#endif /* _M68K_BITOPS_H */
 
#endif /* _M68K_BITOPS_H */