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