[linux-2.6-block.git] / lib / find_next_bit.c

/* find_next_bit.c: fallback find next bit implementation
 *
 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/bitops.h>
#include <linux/module.h>
#include <asm/types.h>
#include <asm/byteorder.h>

#define BITOP_WORD(nr)		((nr) / BITS_PER_LONG)

#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
/*
 * Find the next set bit in a memory region.
 */
unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
			    unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG-1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset %= BITS_PER_LONG;
	if (offset) {
		tmp = *(p++);
		tmp &= (~0UL << offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}
	while (size & ~(BITS_PER_LONG-1)) {
		if ((tmp = *(p++)))
			goto found_middle;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = *p;

found_first:
	tmp &= (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size;	/* Nope. */
found_middle:
	return result + __ffs(tmp);
}
EXPORT_SYMBOL(find_next_bit);

/*
 * This implementation of find_{first,next}_zero_bit was stolen from
 * Linus' asm-alpha/bitops.h.
 */
unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
				 unsigned long offset)
{
	const unsigned long *p = addr + BITOP_WORD(offset);
	unsigned long result = offset & ~(BITS_PER_LONG-1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	size -= result;
	offset %= BITS_PER_LONG;
	if (offset) {
		tmp = *(p++);
		tmp |= ~0UL >> (BITS_PER_LONG - offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (~tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}
	while (size & ~(BITS_PER_LONG-1)) {
		if (~(tmp = *(p++)))
			goto found_middle;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = *p;

found_first:
	tmp |= ~0UL << size;
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size;	/* Nope. */
found_middle:
	return result + ffz(tmp);
}
EXPORT_SYMBOL(find_next_zero_bit);
#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */

#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
/*
 * Find the first set bit in a memory region.
 */
unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
{
	const unsigned long *p = addr;
	unsigned long result = 0;
	unsigned long tmp;

	while (size & ~(BITS_PER_LONG-1)) {
		if ((tmp = *(p++)))
			goto found;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;

	tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size;	/* Nope. */
found:
	return result + __ffs(tmp);
}
EXPORT_SYMBOL(find_first_bit);

/*
 * Find the first cleared bit in a memory region.
 */
unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
{
	const unsigned long *p = addr;
	unsigned long result = 0;
	unsigned long tmp;

	while (size & ~(BITS_PER_LONG-1)) {
		if (~(tmp = *(p++)))
			goto found;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;

	tmp = (*p) | (~0UL << size);
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size;	/* Nope. */
found:
	return result + ffz(tmp);
}
EXPORT_SYMBOL(find_first_zero_bit);
#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */

#ifdef __BIG_ENDIAN
#ifdef CONFIG_GENERIC_FIND_BIT_LE

/* include/linux/byteorder does not support "unsigned long" type */
static inline unsigned long ext2_swabp(const unsigned long * x)
{
#if BITS_PER_LONG == 64
	return (unsigned long) __swab64p((u64 *) x);
#elif BITS_PER_LONG == 32
	return (unsigned long) __swab32p((u32 *) x);
#else
#error BITS_PER_LONG not defined
#endif
}

/* include/linux/byteorder doesn't support "unsigned long" type */
static inline unsigned long ext2_swab(const unsigned long y)
{
#if BITS_PER_LONG == 64
	return (unsigned long) __swab64((u64) y);
#elif BITS_PER_LONG == 32
	return (unsigned long) __swab32((u32) y);
#else
#error BITS_PER_LONG not defined
#endif
}

unsigned long find_next_zero_bit_le(const void *addr, unsigned
		long size, unsigned long offset)
{
	const unsigned long *p = addr;
	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	p += BITOP_WORD(offset);
	size -= result;
	offset &= (BITS_PER_LONG - 1UL);
	if (offset) {
		tmp = ext2_swabp(p++);
		tmp |= (~0UL >> (BITS_PER_LONG - offset));
		if (size < BITS_PER_LONG)
			goto found_first;
		if (~tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}

	while (size & ~(BITS_PER_LONG - 1)) {
		if (~(tmp = *(p++)))
			goto found_middle_swap;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = ext2_swabp(p);
found_first:
	tmp |= ~0UL << size;
	if (tmp == ~0UL)	/* Are any bits zero? */
		return result + size; /* Nope. Skip ffz */
found_middle:
	return result + ffz(tmp);

found_middle_swap:
	return result + ffz(ext2_swab(tmp));
}
EXPORT_SYMBOL(find_next_zero_bit_le);

unsigned long find_next_bit_le(const void *addr, unsigned
		long size, unsigned long offset)
{
	const unsigned long *p = addr;
	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	unsigned long tmp;

	if (offset >= size)
		return size;
	p += BITOP_WORD(offset);
	size -= result;
	offset &= (BITS_PER_LONG - 1UL);
	if (offset) {
		tmp = ext2_swabp(p++);
		tmp &= (~0UL << offset);
		if (size < BITS_PER_LONG)
			goto found_first;
		if (tmp)
			goto found_middle;
		size -= BITS_PER_LONG;
		result += BITS_PER_LONG;
	}

	while (size & ~(BITS_PER_LONG - 1)) {
		tmp = *(p++);
		if (tmp)
			goto found_middle_swap;
		result += BITS_PER_LONG;
		size -= BITS_PER_LONG;
	}
	if (!size)
		return result;
	tmp = ext2_swabp(p);
found_first:
	tmp &= (~0UL >> (BITS_PER_LONG - size));
	if (tmp == 0UL)		/* Are any bits set? */
		return result + size; /* Nope. */
found_middle:
	return result + __ffs(tmp);

found_middle_swap:
	return result + __ffs(ext2_swab(tmp));
}
EXPORT_SYMBOL(find_next_bit_le);

#endif /* CONFIG_GENERIC_FIND_BIT_LE */
#endif /* __BIG_ENDIAN */
Commit	Line	Data
1da177e4 LT	1	/* find_next_bit.c: fallback find next bit implementation
	2	*
	3	* Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/bitops.h>
40234401	13	#include <linux/module.h>
c7f612cd	14	#include <asm/types.h>
930ae745	15	#include <asm/byteorder.h>
1da177e4	16
c7f612cd AM	17	#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
c7f612cd AM	18
77b9bd9c	19	#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
64970b68 AH	20	/*
64970b68 AH	21	* Find the next set bit in a memory region.
c7f612cd	22	*/
fee4b19f TG	23	unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
fee4b19f TG	24	unsigned long offset)
1da177e4	25	{
c7f612cd AM	26	const unsigned long *p = addr + BITOP_WORD(offset);
c7f612cd AM	27	unsigned long result = offset & ~(BITS_PER_LONG-1);
1da177e4 LT	28	unsigned long tmp;
1da177e4 LT	29
c7f612cd AM	30	if (offset >= size)
	31	return size;
	32	size -= result;
	33	offset %= BITS_PER_LONG;
1da177e4	34	if (offset) {
c7f612cd AM	35	tmp = *(p++);
	36	tmp &= (~0UL << offset);
	37	if (size < BITS_PER_LONG)
	38	goto found_first;
	39	if (tmp)
	40	goto found_middle;
	41	size -= BITS_PER_LONG;
	42	result += BITS_PER_LONG;
	43	}
	44	while (size & ~(BITS_PER_LONG-1)) {
	45	if ((tmp = *(p++)))
	46	goto found_middle;
	47	result += BITS_PER_LONG;
	48	size -= BITS_PER_LONG;
1da177e4	49	}
c7f612cd AM	50	if (!size)
	51	return result;
	52	tmp = *p;
1da177e4	53
c7f612cd AM	54	found_first:
	55	tmp &= (~0UL >> (BITS_PER_LONG - size));
	56	if (tmp == 0UL) /* Are any bits set? */
	57	return result + size; /* Nope. */
	58	found_middle:
	59	return result + __ffs(tmp);
	60	}
fee4b19f	61	EXPORT_SYMBOL(find_next_bit);
1da177e4	62
c7f612cd AM	63	/*
	64	* This implementation of find_{first,next}_zero_bit was stolen from
	65	* Linus' asm-alpha/bitops.h.
	66	*/
fee4b19f TG	67	unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
fee4b19f TG	68	unsigned long offset)
c7f612cd AM	69	{
	70	const unsigned long *p = addr + BITOP_WORD(offset);
	71	unsigned long result = offset & ~(BITS_PER_LONG-1);
	72	unsigned long tmp;
1da177e4	73
c7f612cd AM	74	if (offset >= size)
	75	return size;
	76	size -= result;
	77	offset %= BITS_PER_LONG;
	78	if (offset) {
	79	tmp = *(p++);
	80	tmp \|= ~0UL >> (BITS_PER_LONG - offset);
	81	if (size < BITS_PER_LONG)
	82	goto found_first;
	83	if (~tmp)
	84	goto found_middle;
	85	size -= BITS_PER_LONG;
	86	result += BITS_PER_LONG;
	87	}
	88	while (size & ~(BITS_PER_LONG-1)) {
	89	if (~(tmp = *(p++)))
	90	goto found_middle;
	91	result += BITS_PER_LONG;
	92	size -= BITS_PER_LONG;
1da177e4	93	}
c7f612cd AM	94	if (!size)
	95	return result;
	96	tmp = *p;
1da177e4	97
c7f612cd AM	98	found_first:
	99	tmp \|= ~0UL << size;
	100	if (tmp == ~0UL) /* Are any bits zero? */
	101	return result + size; /* Nope. */
	102	found_middle:
	103	return result + ffz(tmp);
1da177e4	104	}
fee4b19f	105	EXPORT_SYMBOL(find_next_zero_bit);
77b9bd9c AH	106	#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
	107
	108	#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
	109	/*
	110	* Find the first set bit in a memory region.
	111	*/
fee4b19f	112	unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
77b9bd9c AH	113	{
	114	const unsigned long *p = addr;
	115	unsigned long result = 0;
	116	unsigned long tmp;
	117
	118	while (size & ~(BITS_PER_LONG-1)) {
	119	if ((tmp = *(p++)))
	120	goto found;
	121	result += BITS_PER_LONG;
	122	size -= BITS_PER_LONG;
	123	}
	124	if (!size)
	125	return result;
	126
	127	tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
	128	if (tmp == 0UL) /* Are any bits set? */
	129	return result + size; /* Nope. */
	130	found:
	131	return result + __ffs(tmp);
	132	}
fee4b19f	133	EXPORT_SYMBOL(find_first_bit);
77b9bd9c AH	134
	135	/*
	136	* Find the first cleared bit in a memory region.
	137	*/
fee4b19f	138	unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
77b9bd9c AH	139	{
	140	const unsigned long *p = addr;
	141	unsigned long result = 0;
	142	unsigned long tmp;
	143
	144	while (size & ~(BITS_PER_LONG-1)) {
	145	if (~(tmp = *(p++)))
	146	goto found;
	147	result += BITS_PER_LONG;
	148	size -= BITS_PER_LONG;
	149	}
	150	if (!size)
	151	return result;
	152
	153	tmp = (*p) \| (~0UL << size);
	154	if (tmp == ~0UL) /* Are any bits zero? */
	155	return result + size; /* Nope. */
	156	found:
	157	return result + ffz(tmp);
	158	}
fee4b19f	159	EXPORT_SYMBOL(find_first_zero_bit);
77b9bd9c	160	#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
930ae745 AM	161
930ae745 AM	162	#ifdef __BIG_ENDIAN
0664996b	163	#ifdef CONFIG_GENERIC_FIND_BIT_LE
930ae745 AM	164
	165	/* include/linux/byteorder does not support "unsigned long" type */
	166	static inline unsigned long ext2_swabp(const unsigned long * x)
	167	{
	168	#if BITS_PER_LONG == 64
	169	return (unsigned long) __swab64p((u64 *) x);
	170	#elif BITS_PER_LONG == 32
	171	return (unsigned long) __swab32p((u32 *) x);
	172	#else
	173	#error BITS_PER_LONG not defined
	174	#endif
	175	}
	176
	177	/* include/linux/byteorder doesn't support "unsigned long" type */
	178	static inline unsigned long ext2_swab(const unsigned long y)
	179	{
	180	#if BITS_PER_LONG == 64
	181	return (unsigned long) __swab64((u64) y);
	182	#elif BITS_PER_LONG == 32
	183	return (unsigned long) __swab32((u32) y);
	184	#else
	185	#error BITS_PER_LONG not defined
	186	#endif
	187	}
	188
a56560b3	189	unsigned long find_next_zero_bit_le(const void *addr, unsigned
930ae745 AM	190	long size, unsigned long offset)
930ae745 AM	191	{
a56560b3	192	const unsigned long *p = addr;
930ae745 AM	193	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	194	unsigned long tmp;
	195
	196	if (offset >= size)
	197	return size;
a56560b3	198	p += BITOP_WORD(offset);
930ae745 AM	199	size -= result;
	200	offset &= (BITS_PER_LONG - 1UL);
	201	if (offset) {
	202	tmp = ext2_swabp(p++);
	203	tmp \|= (~0UL >> (BITS_PER_LONG - offset));
	204	if (size < BITS_PER_LONG)
	205	goto found_first;
	206	if (~tmp)
	207	goto found_middle;
	208	size -= BITS_PER_LONG;
	209	result += BITS_PER_LONG;
	210	}
	211
	212	while (size & ~(BITS_PER_LONG - 1)) {
	213	if (~(tmp = *(p++)))
	214	goto found_middle_swap;
	215	result += BITS_PER_LONG;
	216	size -= BITS_PER_LONG;
	217	}
	218	if (!size)
	219	return result;
	220	tmp = ext2_swabp(p);
	221	found_first:
	222	tmp \|= ~0UL << size;
	223	if (tmp == ~0UL) /* Are any bits zero? */
	224	return result + size; /* Nope. Skip ffz */
	225	found_middle:
	226	return result + ffz(tmp);
	227
	228	found_middle_swap:
	229	return result + ffz(ext2_swab(tmp));
	230	}
c4945b9e	231	EXPORT_SYMBOL(find_next_zero_bit_le);
930ae745	232
a56560b3	233	unsigned long find_next_bit_le(const void *addr, unsigned
aa02ad67 AK	234	long size, unsigned long offset)
aa02ad67 AK	235	{
a56560b3	236	const unsigned long *p = addr;
aa02ad67 AK	237	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	238	unsigned long tmp;
	239
	240	if (offset >= size)
	241	return size;
a56560b3	242	p += BITOP_WORD(offset);
aa02ad67 AK	243	size -= result;
	244	offset &= (BITS_PER_LONG - 1UL);
	245	if (offset) {
	246	tmp = ext2_swabp(p++);
	247	tmp &= (~0UL << offset);
	248	if (size < BITS_PER_LONG)
	249	goto found_first;
	250	if (tmp)
	251	goto found_middle;
	252	size -= BITS_PER_LONG;
	253	result += BITS_PER_LONG;
	254	}
	255
	256	while (size & ~(BITS_PER_LONG - 1)) {
	257	tmp = *(p++);
	258	if (tmp)
	259	goto found_middle_swap;
	260	result += BITS_PER_LONG;
	261	size -= BITS_PER_LONG;
	262	}
	263	if (!size)
	264	return result;
	265	tmp = ext2_swabp(p);
	266	found_first:
	267	tmp &= (~0UL >> (BITS_PER_LONG - size));
	268	if (tmp == 0UL) /* Are any bits set? */
	269	return result + size; /* Nope. */
	270	found_middle:
	271	return result + __ffs(tmp);
	272
	273	found_middle_swap:
	274	return result + __ffs(ext2_swab(tmp));
	275	}
c4945b9e	276	EXPORT_SYMBOL(find_next_bit_le);
0664996b AM	277
0664996b AM	278	#endif /* CONFIG_GENERIC_FIND_BIT_LE */
930ae745	279	#endif /* __BIG_ENDIAN */