Subversion Repositories or1k

#ifndef _ASM_GENERIC_BITOPS_H_

#define _ASM_GENERIC_BITOPS_H_

#include <asm/system.h>

/*

 * N.B.: we shouldn't assume addresses are long*'s; nr can be > 31.

 */

static __inline__ long set_bit(long nr, void *a)

{

        long*   addr = a;

        int     mask, oldval;

        addr += nr >> 5;

        mask = 1 << (nr & 0x1f);

        __asm__ __volatile__

                ("atmod %3, %2, %2"

                 : "=m" (*addr), "=r" (oldval)

                 : "1" (mask), "r" (addr), "m"(*addr));

        return (oldval & mask) != 0;

}

static __inline__ long clear_bit(long nr, void *a)

{

        long*   addr = a;

        int     mask, oldval;

        addr += nr >> 5;

        mask = 1 << (nr & 0x1f);

        __asm__ __volatile__

                ("atmod %4, %3, %2"

                 : "=m" (*addr), "=r"(oldval)

                 : "1" (0), "r" (mask), "r"(addr), "m"(*addr));

        return (oldval & mask) != 0;

}

static __inline__ long change_bit(long nr, void *a)

{

        long*   addr = a;

        long    flags;

        int     bitpos, retval;

        addr += nr >> 5;

        bitpos = (nr & 0x1f);

        save_flags(flags);

        cli();

#if 1

        retval = (*addr & (1 << bitpos));

        *addr ^= (1 << bitpos);

#else

        __asm__

                ("ld            (%2), r3\n\t"

                 "notbit        %1, r3, r4\n\t"

                 "st            r4, (%2)\n\t"

                 "ldconst       1, r4\n\t"

                 "shlo          %1, r4, r4\n\t"

                 "and           r4, r3, %0\n\t"

                 : "=&r" (retval)

                 : "r" (bitpos), "r" (addr)

                 : "r3", "r4", "memory");

#endif

        restore_flags(flags);

        return retval != 0;

}

static __inline__ long test_bit(long nr, void *a)

{

        int     * addr = a;

        int     mask;

        addr += nr >> 5;

        mask = 1 << (nr & 0x1f);

        return ((mask & *addr) != 0);

}

/* The easy/cheese version for now. */

extern __inline__ unsigned long ffz(unsigned long word)

{

        unsigned long result = 0;

        while(word & 1) {

                result++;

                word >>= 1;

        }

        return result;

}

/* find_next_zero_bit() finds the first zero bit in a bit string of length

 * 'size' bits, starting the search at bit 'offset'. This is largely based

 * on Linus's ALPHA routines, which are pretty portable BTW.

 */

extern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)

{

        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);

        unsigned long result = offset & ~31UL;

        unsigned long tmp;

        if (offset >= size)

                return size;

        size -= result;

        offset &= 31UL;

        if (offset) {

                tmp = *(p++);

                tmp |= ~0UL >> (32-offset);

                if (size < 32)

                        goto found_first;

                if (~tmp)

                        goto found_middle;

                size -= 32;

                result += 32;

        }

        while (size & ~31UL) {

                if (~(tmp = *(p++)))

                        goto found_middle;

                result += 32;

                size -= 32;

        }

        if (!size)

                return result;

        tmp = *p;

found_first:

        tmp |= ~0UL >> size;

found_middle:

        return result + ffz(tmp);

}

/* Linus sez that gcc can optimize the following correctly, we'll see if this

 * holds on the Sparc as it does for the ALPHA.

 */

#define find_first_zero_bit(addr, size) \

        find_next_zero_bit((addr), (size), 0)

#endif /* _ASM_I960_BITOPS_H */