[mirror_ubuntu-artful-kernel.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

/* 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 generic_find_next_zero_le_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 - 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(generic_find_next_zero_le_bit);

unsigned long generic_find_next_le_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 - 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(generic_find_next_le_bit);
#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	*/
64970b68 AH	23	unsigned long __find_next_bit(const unsigned long *addr,
64970b68 AH	24	unsigned long size, 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	}
64970b68	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	*/
64970b68 AH	67	unsigned long __find_next_zero_bit(const unsigned long *addr,
64970b68 AH	68	unsigned long size, 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	}
64970b68	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	*/
	112	unsigned long __find_first_bit(const unsigned long *addr,
	113	unsigned long size)
	114	{
	115	const unsigned long *p = addr;
	116	unsigned long result = 0;
	117	unsigned long tmp;
	118
	119	while (size & ~(BITS_PER_LONG-1)) {
	120	if ((tmp = *(p++)))
	121	goto found;
	122	result += BITS_PER_LONG;
	123	size -= BITS_PER_LONG;
	124	}
	125	if (!size)
	126	return result;
	127
	128	tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
	129	if (tmp == 0UL) /* Are any bits set? */
	130	return result + size; /* Nope. */
	131	found:
	132	return result + __ffs(tmp);
	133	}
	134	EXPORT_SYMBOL(__find_first_bit);
	135
	136	/*
	137	* Find the first cleared bit in a memory region.
	138	*/
	139	unsigned long __find_first_zero_bit(const unsigned long *addr,
	140	unsigned long size)
	141	{
	142	const unsigned long *p = addr;
	143	unsigned long result = 0;
	144	unsigned long tmp;
	145
	146	while (size & ~(BITS_PER_LONG-1)) {
	147	if (~(tmp = *(p++)))
	148	goto found;
	149	result += BITS_PER_LONG;
	150	size -= BITS_PER_LONG;
	151	}
	152	if (!size)
	153	return result;
	154
	155	tmp = (*p) \| (~0UL << size);
	156	if (tmp == ~0UL) /* Are any bits zero? */
	157	return result + size; /* Nope. */
	158	found:
	159	return result + ffz(tmp);
	160	}
	161	EXPORT_SYMBOL(__find_first_zero_bit);
	162	#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
930ae745 AM	163
	164	#ifdef __BIG_ENDIAN
	165
	166	/* include/linux/byteorder does not support "unsigned long" type */
	167	static inline unsigned long ext2_swabp(const unsigned long * x)
	168	{
	169	#if BITS_PER_LONG == 64
	170	return (unsigned long) __swab64p((u64 *) x);
	171	#elif BITS_PER_LONG == 32
	172	return (unsigned long) __swab32p((u32 *) x);
	173	#else
	174	#error BITS_PER_LONG not defined
	175	#endif
	176	}
	177
	178	/* include/linux/byteorder doesn't support "unsigned long" type */
	179	static inline unsigned long ext2_swab(const unsigned long y)
	180	{
	181	#if BITS_PER_LONG == 64
	182	return (unsigned long) __swab64((u64) y);
	183	#elif BITS_PER_LONG == 32
	184	return (unsigned long) __swab32((u32) y);
	185	#else
	186	#error BITS_PER_LONG not defined
	187	#endif
	188	}
	189
	190	unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
	191	long size, unsigned long offset)
	192	{
	193	const unsigned long *p = addr + BITOP_WORD(offset);
	194	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	195	unsigned long tmp;
	196
	197	if (offset >= size)
	198	return size;
	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	}
231
232	EXPORT_SYMBOL(generic_find_next_zero_le_bit);
233
aa02ad67 AK	234	unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
	235	long size, unsigned long offset)
	236	{
	237	const unsigned long *p = addr + BITOP_WORD(offset);
	238	unsigned long result = offset & ~(BITS_PER_LONG - 1);
	239	unsigned long tmp;
	240
	241	if (offset >= size)
	242	return size;
	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	}
	276	EXPORT_SYMBOL(generic_find_next_le_bit);
930ae745	277	#endif /* __BIG_ENDIAN */