bitmap: drop _reg_op() function

Now that all _reg_op() users are switched to alternative functions,
_reg_op() machinery is not needed anymore.

CC: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
CC: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Signed-off-by: Yury Norov <yury.norov@gmail.com>

diff --git a/lib/bitmap.c b/lib/bitmap.c
index e4d761a..66da8c3 100644 (file)
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -708,82 +708,6 @@ void bitmap_fold(unsigned long *dst, const unsigned long *orig,
 }
 #endif /* CONFIG_NUMA */
 
-/*
- * Common code for bitmap_*_region() routines.
- *     bitmap: array of unsigned longs corresponding to the bitmap
- *     pos: the beginning of the region
- *     order: region size (log base 2 of number of bits)
- *     reg_op: operation(s) to perform on that region of bitmap
- *
- * Can set, verify and/or release a region of bits in a bitmap,
- * depending on which combination of REG_OP_* flag bits is set.
- *
- * A region of a bitmap is a sequence of bits in the bitmap, of
- * some size '1 << order' (a power of two), aligned to that same
- * '1 << order' power of two.
- *
- * Return: 1 if REG_OP_ISFREE succeeds (region is all zero bits).
- *        0 in all other cases and reg_ops.
- */
-
-enum {
-       REG_OP_ISFREE,          /* true if region is all zero bits */
-       REG_OP_ALLOC,           /* set all bits in region */
-       REG_OP_RELEASE,         /* clear all bits in region */
-};
-
-static int __reg_op(unsigned long *bitmap, unsigned int pos, int order, int reg_op)
-{
-       int nbits_reg;          /* number of bits in region */
-       int index;              /* index first long of region in bitmap */
-       int offset;             /* bit offset region in bitmap[index] */
-       int nlongs_reg;         /* num longs spanned by region in bitmap */
-       int nbitsinlong;        /* num bits of region in each spanned long */
-       unsigned long mask;     /* bitmask for one long of region */
-       int i;                  /* scans bitmap by longs */
-       int ret = 0;            /* return value */
-
-       /*
-        * Either nlongs_reg == 1 (for small orders that fit in one long)
-        * or (offset == 0 && mask == ~0UL) (for larger multiword orders.)
-        */
-       nbits_reg = 1 << order;
-       index = pos / BITS_PER_LONG;
-       offset = pos - (index * BITS_PER_LONG);
-       nlongs_reg = BITS_TO_LONGS(nbits_reg);
-       nbitsinlong = min(nbits_reg,  BITS_PER_LONG);
-
-       /*
-        * Can't do "mask = (1UL << nbitsinlong) - 1", as that
-        * overflows if nbitsinlong == BITS_PER_LONG.
-        */
-       mask = (1UL << (nbitsinlong - 1));
-       mask += mask - 1;
-       mask <<= offset;
-
-       switch (reg_op) {
-       case REG_OP_ISFREE:
-               for (i = 0; i < nlongs_reg; i++) {
-                       if (bitmap[index + i] & mask)
-                               goto done;
-               }
-               ret = 1;        /* all bits in region free (zero) */
-               break;
-
-       case REG_OP_ALLOC:
-               for (i = 0; i < nlongs_reg; i++)
-                       bitmap[index + i] |= mask;
-               break;
-
-       case REG_OP_RELEASE:
-               for (i = 0; i < nlongs_reg; i++)
-                       bitmap[index + i] &= ~mask;
-               break;
-       }
-done:
-       return ret;
-}
-
 /**
  * bitmap_find_free_region - find a contiguous aligned mem region
  *     @bitmap: array of unsigned longs corresponding to the bitmap