linux-imx

/*

 * lib/bitmap.c

 * Helper functions for bitmap.h.

 *

 * This source code is licensed under the GNU General Public License,

 * Version 2.  See the file COPYING for more details.

 */

#include <linux/export.h>

#include <linux/thread_info.h>

#include <linux/ctype.h>

#include <linux/errno.h>

#include <linux/bitmap.h>

#include <linux/bitops.h>

#include <linux/bug.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/uaccess.h>

​

#include <asm/page.h>

​

/**

 * DOC: bitmap introduction

 *

 * bitmaps provide an array of bits, implemented using an an

 * array of unsigned longs.  The number of valid bits in a

 * given bitmap does _not_ need to be an exact multiple of

 * BITS_PER_LONG.

 *

 * The possible unused bits in the last, partially used word

 * of a bitmap are 'don't care'.  The implementation makes

 * no particular effort to keep them zero.  It ensures that

 * their value will not affect the results of any operation.

 * The bitmap operations that return Boolean (bitmap_empty,

 * for example) or scalar (bitmap_weight, for example) results

 * carefully filter out these unused bits from impacting their

 * results.

 *

 * The byte ordering of bitmaps is more natural on little

 * endian architectures.  See the big-endian headers

 * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h

 * for the best explanations of this ordering.

 */

​

int __bitmap_equal(const unsigned long *bitmap1,

        const unsigned long *bitmap2, unsigned int bits)

{

    unsigned int k, lim = bits/BITS_PER_LONG;

    for (k = 0; k < lim; ++k)

        if (bitmap1[k] != bitmap2[k])

            return 0;

​

    if (bits % BITS_PER_LONG)

        if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))

            return 0;

​

    return 1;

}

EXPORT_SYMBOL(__bitmap_equal);

​

void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)

{

    unsigned int k, lim = BITS_TO_LONGS(bits);

    for (k = 0; k < lim; ++k)

        dst[k] = ~src[k];

}

EXPORT_SYMBOL(__bitmap_complement);

​

/**

 * __bitmap_shift_right - logical right shift of the bits in a bitmap

 *   @dst : destination bitmap

 *   @src : source bitmap

 *   @shift : shift by this many bits

 *   @nbits : bitmap size, in bits

 *

 * Shifting right (dividing) means moving bits in the MS -> LS bit

 * direction.  Zeros are fed into the vacated MS positions and the

 * LS bits shifted off the bottom are lost.

 */

void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,

            unsigned shift, unsigned nbits)

{

    unsigned k, lim = BITS_TO_LONGS(nbits);

    unsigned off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;

    unsigned long mask = BITMAP_LAST_WORD_MASK(nbits);

    for (k = 0; off + k < lim; ++k) {

        unsigned long upper, lower;

​

        /*

         * If shift is not word aligned, take lower rem bits of

         * word above and make them the top rem bits of result.