[PATCH] powerpc: Merge bitops.h
[linux-2.6.git] / arch / powerpc / lib / bitops.c
similarity index 66%
rename from arch/ppc64/kernel/bitops.c
rename to arch/powerpc/lib/bitops.c
index ae329e8..b67ce30 100644 (file)
@@ -1,93 +1,97 @@
-/*
- * These are too big to be inlined.
- */
-
-#include <linux/kernel.h>
+#include <linux/types.h>
 #include <linux/module.h>
-#include <linux/bitops.h>
 #include <asm/byteorder.h>
+#include <asm/bitops.h>
 
-unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
-                                unsigned long offset)
+/**
+ * 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 maximum size to search
+ */
+unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
+                           unsigned long offset)
 {
-       const unsigned long *p = addr + (offset >> 6);
-       unsigned long result = offset & ~63UL;
+       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 &= 63UL;
+       offset %= BITS_PER_LONG;
        if (offset) {
                tmp = *(p++);
-               tmp |= ~0UL >> (64 - offset);
-               if (size < 64)
+               tmp &= (~0UL << offset);
+               if (size < BITS_PER_LONG)
                        goto found_first;
-               if (~tmp)
+               if (tmp)
                        goto found_middle;
-               size -= 64;
-               result += 64;
+               size -= BITS_PER_LONG;
+               result += BITS_PER_LONG;
        }
-       while (size & ~63UL) {
-               if (~(tmp = *(p++)))
+       while (size & ~(BITS_PER_LONG-1)) {
+               if ((tmp = *(p++)))
                        goto found_middle;
-               result += 64;
-               size -= 64;
+               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? */
+       tmp &= (~0UL >> (64 - size));
+       if (tmp == 0UL)         /* Are any bits set? */
                return result + size;   /* Nope. */
 found_middle:
-       return result + ffz(tmp);
+       return result + __ffs(tmp);
 }
+EXPORT_SYMBOL(find_next_bit);
 
-EXPORT_SYMBOL(find_next_zero_bit);
-
-unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
-                           unsigned long offset)
+/*
+ * 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 + (offset >> 6);
-       unsigned long result = offset & ~63UL;
+       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 &= 63UL;
+       offset %= BITS_PER_LONG;
        if (offset) {
                tmp = *(p++);
-               tmp &= (~0UL << offset);
-               if (size < 64)
+               tmp |= ~0UL >> (BITS_PER_LONG - offset);
+               if (size < BITS_PER_LONG)
                        goto found_first;
-               if (tmp)
+               if (~tmp)
                        goto found_middle;
-               size -= 64;
-               result += 64;
+               size -= BITS_PER_LONG;
+               result += BITS_PER_LONG;
        }
-       while (size & ~63UL) {
-               if ((tmp = *(p++)))
+       while (size & ~(BITS_PER_LONG-1)) {
+               if (~(tmp = *(p++)))
                        goto found_middle;
-               result += 64;
-               size -= 64;
+               result += BITS_PER_LONG;
+               size -= BITS_PER_LONG;
        }
        if (!size)
                return result;
        tmp = *p;
 
 found_first:
-       tmp &= (~0UL >> (64 - size));
-       if (tmp == 0UL)         /* Are any bits set? */
+       tmp |= ~0UL << size;
+       if (tmp == ~0UL)        /* Are any bits zero? */
                return result + size;   /* Nope. */
 found_middle:
-       return result + __ffs(tmp);
+       return result + ffz(tmp);
 }
-
-EXPORT_SYMBOL(find_next_bit);
+EXPORT_SYMBOL(find_next_zero_bit);
 
 static inline unsigned int ext2_ilog2(unsigned int x)
 {
@@ -106,8 +110,8 @@ static inline unsigned int ext2_ffz(unsigned int x)
        return rc;
 }
 
-unsigned long find_next_zero_le_bit(const unsigned long *addr, unsigned long size,
-                                   unsigned long offset)
+unsigned long find_next_zero_le_bit(const unsigned long *addr,
+                                   unsigned long size, unsigned long offset)
 {
        const unsigned int *p = ((const unsigned int *)addr) + (offset >> 5);
        unsigned int result = offset & ~31;
@@ -143,5 +147,4 @@ found_first:
 found_middle:
        return result + ext2_ffz(tmp);
 }
-
 EXPORT_SYMBOL(find_next_zero_le_bit);