arch/cris/include/asm/bitops.h

   1 /* asm/bitops.h for Linux/CRIS
   2  *
   3  * TODO: asm versions if speed is needed
   4  *
   5  * All bit operations return 0 if the bit was cleared before the
   6  * operation and != 0 if it was not.
   7  *
   8  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
   9  */
  10
  11 #ifndef _CRIS_BITOPS_H
  12 #define _CRIS_BITOPS_H
  13
  14 /* Currently this is unsuitable for consumption outside the kernel.  */
  15 #ifdef __KERNEL__
  16
  17 #ifndef _LINUX_BITOPS_H
  18 #error only <linux/bitops.h> can be included directly
  19 #endif
  20
  21 #include <arch/bitops.h>
  22 #include <linux/atomic.h>
  23 #include <linux/compiler.h>
  24
  25 /*
  26  * set_bit - Atomically set a bit in memory
  27  * @nr: the bit to set
  28  * @addr: the address to start counting from
  29  *
  30  * This function is atomic and may not be reordered.  See __set_bit()
  31  * if you do not require the atomic guarantees.
  32  * Note that @nr may be almost arbitrarily large; this function is not
  33  * restricted to acting on a single-word quantity.
  34  */
  35
  36 #define set_bit(nr, addr)    (void)test_and_set_bit(nr, addr)
  37
  38 /*
  39  * clear_bit - Clears a bit in memory
  40  * @nr: Bit to clear
  41  * @addr: Address to start counting from
  42  *
  43  * clear_bit() is atomic and may not be reordered.  However, it does
  44  * not contain a memory barrier, so if it is used for locking purposes,
  45  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  46  * in order to ensure changes are visible on other processors.
  47  */
  48
  49 #define clear_bit(nr, addr)  (void)test_and_clear_bit(nr, addr)
  50
  51 /*
  52  * change_bit - Toggle a bit in memory
  53  * @nr: Bit to change
  54  * @addr: Address to start counting from
  55  *
  56  * change_bit() is atomic and may not be reordered.
  57  * Note that @nr may be almost arbitrarily large; this function is not
  58  * restricted to acting on a single-word quantity.
  59  */
  60
  61 #define change_bit(nr, addr) (void)test_and_change_bit(nr, addr)
  62
  63 /**
  64  * test_and_set_bit - Set a bit and return its old value
  65  * @nr: Bit to set
  66  * @addr: Address to count from
  67  *
  68  * This operation is atomic and cannot be reordered.
  69  * It also implies a memory barrier.
  70  */
  71
  72 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
  73 {
  74         unsigned int mask, retval;
  75         unsigned long flags;
  76         unsigned int *adr = (unsigned int *)addr;
  77
  78         adr += nr >> 5;
  79         mask = 1 << (nr & 0x1f);
  80         cris_atomic_save(addr, flags);
  81         retval = (mask & *adr) != 0;
  82         *adr |= mask;
  83         cris_atomic_restore(addr, flags);
  84         return retval;
  85 }
  86
  87 /*
  88  * clear_bit() doesn't provide any barrier for the compiler.
  89  */
  90 #define smp_mb__before_clear_bit()      barrier()
  91 #define smp_mb__after_clear_bit()       barrier()
  92
  93 /**
  94  * test_and_clear_bit - Clear a bit and return its old value
  95  * @nr: Bit to clear
  96  * @addr: Address to count from
  97  *
  98  * This operation is atomic and cannot be reordered.
  99  * It also implies a memory barrier.
 100  */
 101
 102 static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
 103 {
 104         unsigned int mask, retval;
 105         unsigned long flags;
 106         unsigned int *adr = (unsigned int *)addr;
 107
 108         adr += nr >> 5;
 109         mask = 1 << (nr & 0x1f);
 110         cris_atomic_save(addr, flags);
 111         retval = (mask & *adr) != 0;
 112         *adr &= ~mask;
 113         cris_atomic_restore(addr, flags);
 114         return retval;
 115 }
 116
 117 /**
 118  * test_and_change_bit - Change a bit and return its old value
 119  * @nr: Bit to change
 120  * @addr: Address to count from
 121  *
 122  * This operation is atomic and cannot be reordered.
 123  * It also implies a memory barrier.
 124  */
 125
 126 static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
 127 {
 128         unsigned int mask, retval;
 129         unsigned long flags;
 130         unsigned int *adr = (unsigned int *)addr;
 131         adr += nr >> 5;
 132         mask = 1 << (nr & 0x1f);
 133         cris_atomic_save(addr, flags);
 134         retval = (mask & *adr) != 0;
 135         *adr ^= mask;
 136         cris_atomic_restore(addr, flags);
 137         return retval;
 138 }
 139
 140 #include <asm-generic/bitops/non-atomic.h>
 141
 142 /*
 143  * Since we define it "external", it collides with the built-in
 144  * definition, which doesn't have the same semantics.  We don't want to
 145  * use -fno-builtin, so just hide the name ffs.
 146  */
 147 #define ffs kernel_ffs
 148
 149 #include <asm-generic/bitops/fls.h>
 150 #include <asm-generic/bitops/__fls.h>
 151 #include <asm-generic/bitops/fls64.h>
 152 #include <asm-generic/bitops/hweight.h>
 153 #include <asm-generic/bitops/find.h>
 154 #include <asm-generic/bitops/lock.h>
 155
 156 #include <asm-generic/bitops/le.h>
 157
 158 #include <asm-generic/bitops/ext2-atomic-setbit.h>
 159
 160 #include <asm-generic/bitops/sched.h>
 161
 162 #endif /* __KERNEL__ */
 163
 164 #endif /* _CRIS_BITOPS_H */