forbid asm/bitops.h direct inclusion
[linux-2.6.git] / include / asm-blackfin / bitops.h
1 #ifndef _BLACKFIN_BITOPS_H
2 #define _BLACKFIN_BITOPS_H
3
4 /*
5  * Copyright 1992, Linus Torvalds.
6  */
7
8 #include <linux/compiler.h>
9 #include <asm/byteorder.h>      /* swab32 */
10 #include <asm/system.h>         /* save_flags */
11
12 #ifdef __KERNEL__
13
14 #ifndef _LINUX_BITOPS_H
15 #error only <linux/bitops.h> can be included directly
16 #endif
17
18 #include <asm-generic/bitops/ffs.h>
19 #include <asm-generic/bitops/__ffs.h>
20 #include <asm-generic/bitops/sched.h>
21 #include <asm-generic/bitops/ffz.h>
22
23 static __inline__ void set_bit(int nr, volatile unsigned long *addr)
24 {
25         int *a = (int *)addr;
26         int mask;
27         unsigned long flags;
28
29         a += nr >> 5;
30         mask = 1 << (nr & 0x1f);
31         local_irq_save(flags);
32         *a |= mask;
33         local_irq_restore(flags);
34 }
35
36 static __inline__ void __set_bit(int nr, volatile unsigned long *addr)
37 {
38         int *a = (int *)addr;
39         int mask;
40
41         a += nr >> 5;
42         mask = 1 << (nr & 0x1f);
43         *a |= mask;
44 }
45
46 /*
47  * clear_bit() doesn't provide any barrier for the compiler.
48  */
49 #define smp_mb__before_clear_bit()      barrier()
50 #define smp_mb__after_clear_bit()       barrier()
51
52 static __inline__ void clear_bit(int nr, volatile unsigned long *addr)
53 {
54         int *a = (int *)addr;
55         int mask;
56         unsigned long flags;
57         a += nr >> 5;
58         mask = 1 << (nr & 0x1f);
59         local_irq_save(flags);
60         *a &= ~mask;
61         local_irq_restore(flags);
62 }
63
64 static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
65 {
66         int *a = (int *)addr;
67         int mask;
68
69         a += nr >> 5;
70         mask = 1 << (nr & 0x1f);
71         *a &= ~mask;
72 }
73
74 static __inline__ void change_bit(int nr, volatile unsigned long *addr)
75 {
76         int mask, flags;
77         unsigned long *ADDR = (unsigned long *)addr;
78
79         ADDR += nr >> 5;
80         mask = 1 << (nr & 31);
81         local_irq_save(flags);
82         *ADDR ^= mask;
83         local_irq_restore(flags);
84 }
85
86 static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
87 {
88         int mask;
89         unsigned long *ADDR = (unsigned long *)addr;
90
91         ADDR += nr >> 5;
92         mask = 1 << (nr & 31);
93         *ADDR ^= mask;
94 }
95
96 static __inline__ int test_and_set_bit(int nr, void *addr)
97 {
98         int mask, retval;
99         volatile unsigned int *a = (volatile unsigned int *)addr;
100         unsigned long flags;
101
102         a += nr >> 5;
103         mask = 1 << (nr & 0x1f);
104         local_irq_save(flags);
105         retval = (mask & *a) != 0;
106         *a |= mask;
107         local_irq_restore(flags);
108
109         return retval;
110 }
111
112 static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr)
113 {
114         int mask, retval;
115         volatile unsigned int *a = (volatile unsigned int *)addr;
116
117         a += nr >> 5;
118         mask = 1 << (nr & 0x1f);
119         retval = (mask & *a) != 0;
120         *a |= mask;
121         return retval;
122 }
123
124 static __inline__ int test_and_clear_bit(int nr, volatile unsigned long *addr)
125 {
126         int mask, retval;
127         volatile unsigned int *a = (volatile unsigned int *)addr;
128         unsigned long flags;
129
130         a += nr >> 5;
131         mask = 1 << (nr & 0x1f);
132         local_irq_save(flags);
133         retval = (mask & *a) != 0;
134         *a &= ~mask;
135         local_irq_restore(flags);
136
137         return retval;
138 }
139
140 static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr)
141 {
142         int mask, retval;
143         volatile unsigned int *a = (volatile unsigned int *)addr;
144
145         a += nr >> 5;
146         mask = 1 << (nr & 0x1f);
147         retval = (mask & *a) != 0;
148         *a &= ~mask;
149         return retval;
150 }
151
152 static __inline__ int test_and_change_bit(int nr, volatile unsigned long *addr)
153 {
154         int mask, retval;
155         volatile unsigned int *a = (volatile unsigned int *)addr;
156         unsigned long flags;
157
158         a += nr >> 5;
159         mask = 1 << (nr & 0x1f);
160         local_irq_save(flags);
161         retval = (mask & *a) != 0;
162         *a ^= mask;
163         local_irq_restore(flags);
164         return retval;
165 }
166
167 static __inline__ int __test_and_change_bit(int nr,
168                                             volatile unsigned long *addr)
169 {
170         int mask, retval;
171         volatile unsigned int *a = (volatile unsigned int *)addr;
172
173         a += nr >> 5;
174         mask = 1 << (nr & 0x1f);
175         retval = (mask & *a) != 0;
176         *a ^= mask;
177         return retval;
178 }
179
180 /*
181  * This routine doesn't need to be atomic.
182  */
183 static __inline__ int __constant_test_bit(int nr, const void *addr)
184 {
185         return ((1UL << (nr & 31)) &
186                 (((const volatile unsigned int *)addr)[nr >> 5])) != 0;
187 }
188
189 static __inline__ int __test_bit(int nr, const void *addr)
190 {
191         int *a = (int *)addr;
192         int mask;
193
194         a += nr >> 5;
195         mask = 1 << (nr & 0x1f);
196         return ((mask & *a) != 0);
197 }
198
199 #define test_bit(nr,addr) \
200 (__builtin_constant_p(nr) ? \
201  __constant_test_bit((nr),(addr)) : \
202  __test_bit((nr),(addr)))
203
204 #include <asm-generic/bitops/find.h>
205 #include <asm-generic/bitops/hweight.h>
206 #include <asm-generic/bitops/lock.h>
207
208 #include <asm-generic/bitops/ext2-atomic.h>
209 #include <asm-generic/bitops/ext2-non-atomic.h>
210
211 #include <asm-generic/bitops/minix.h>
212
213 #endif                          /* __KERNEL__ */
214
215 #include <asm-generic/bitops/fls.h>
216 #include <asm-generic/bitops/fls64.h>
217
218 #endif                          /* _BLACKFIN_BITOPS_H */