aboutsummaryrefslogtreecommitdiffstats
path: root/arch/cris/include/asm/bitops.h
diff options
context:
space:
mode:
Diffstat (limited to 'arch/cris/include/asm/bitops.h')
-rw-r--r--arch/cris/include/asm/bitops.h166
1 files changed, 166 insertions, 0 deletions
diff --git a/arch/cris/include/asm/bitops.h b/arch/cris/include/asm/bitops.h
new file mode 100644
index 000000000000..c0e62f811e09
--- /dev/null
+++ b/arch/cris/include/asm/bitops.h
@@ -0,0 +1,166 @@
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/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/ext2-non-atomic.h>
157
158#define ext2_set_bit_atomic(l,n,a) test_and_set_bit(n,a)
159#define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
160
161#include <asm-generic/bitops/minix.h>
162#include <asm-generic/bitops/sched.h>
163
164#endif /* __KERNEL__ */
165
166#endif /* _CRIS_BITOPS_H */