[PATCH] splice: add support for SPLICE_F_MOVE flag
[linux-2.6] / include / asm-arm26 / bitops.h
1 /*
2  * Copyright 1995, Russell King.
3  *
4  * Based on the arm32 version by RMK (and others). Their copyrights apply to
5  * Those parts.
6  * Modified for arm26 by Ian Molton on 25/11/04
7  *
8  * bit 0 is the LSB of an "unsigned long" quantity.
9  *
10  * Please note that the code in this file should never be included
11  * from user space.  Many of these are not implemented in assembler
12  * since they would be too costly.  Also, they require privileged
13  * instructions (which are not available from user mode) to ensure
14  * that they are atomic.
15  */
16
17 #ifndef __ASM_ARM_BITOPS_H
18 #define __ASM_ARM_BITOPS_H
19
20 #ifdef __KERNEL__
21
22 #include <linux/compiler.h>
23 #include <asm/system.h>
24
25 #define smp_mb__before_clear_bit()      do { } while (0)
26 #define smp_mb__after_clear_bit()       do { } while (0)
27
28 /*
29  * These functions are the basis of our bit ops.
30  *
31  * First, the atomic bitops. These use native endian.
32  */
33 static inline void ____atomic_set_bit(unsigned int bit, volatile unsigned long *p)
34 {
35         unsigned long flags;
36         unsigned long mask = 1UL << (bit & 31);
37
38         p += bit >> 5;
39
40         local_irq_save(flags);
41         *p |= mask;
42         local_irq_restore(flags);
43 }
44
45 static inline void ____atomic_clear_bit(unsigned int bit, volatile unsigned long *p)
46 {
47         unsigned long flags;
48         unsigned long mask = 1UL << (bit & 31);
49
50         p += bit >> 5;
51
52         local_irq_save(flags);
53         *p &= ~mask;
54         local_irq_restore(flags);
55 }
56
57 static inline void ____atomic_change_bit(unsigned int bit, volatile unsigned long *p)
58 {
59         unsigned long flags;
60         unsigned long mask = 1UL << (bit & 31);
61
62         p += bit >> 5;
63
64         local_irq_save(flags);
65         *p ^= mask;
66         local_irq_restore(flags);
67 }
68
69 static inline int
70 ____atomic_test_and_set_bit(unsigned int bit, volatile unsigned long *p)
71 {
72         unsigned long flags;
73         unsigned int res;
74         unsigned long mask = 1UL << (bit & 31);
75
76         p += bit >> 5;
77
78         local_irq_save(flags);
79         res = *p;
80         *p = res | mask;
81         local_irq_restore(flags);
82
83         return res & mask;
84 }
85
86 static inline int
87 ____atomic_test_and_clear_bit(unsigned int bit, volatile unsigned long *p)
88 {
89         unsigned long flags;
90         unsigned int res;
91         unsigned long mask = 1UL << (bit & 31);
92
93         p += bit >> 5;
94
95         local_irq_save(flags);
96         res = *p;
97         *p = res & ~mask;
98         local_irq_restore(flags);
99
100         return res & mask;
101 }
102
103 static inline int
104 ____atomic_test_and_change_bit(unsigned int bit, volatile unsigned long *p)
105 {
106         unsigned long flags;
107         unsigned int res;
108         unsigned long mask = 1UL << (bit & 31);
109
110         p += bit >> 5;
111
112         local_irq_save(flags);
113         res = *p;
114         *p = res ^ mask;
115         local_irq_restore(flags);
116
117         return res & mask;
118 }
119
120 #include <asm-generic/bitops/non-atomic.h>
121
122 /*
123  * Little endian assembly bitops.  nr = 0 -> byte 0 bit 0.
124  */
125 extern void _set_bit_le(int nr, volatile unsigned long * p);
126 extern void _clear_bit_le(int nr, volatile unsigned long * p);
127 extern void _change_bit_le(int nr, volatile unsigned long * p);
128 extern int _test_and_set_bit_le(int nr, volatile unsigned long * p);
129 extern int _test_and_clear_bit_le(int nr, volatile unsigned long * p);
130 extern int _test_and_change_bit_le(int nr, volatile unsigned long * p);
131 extern int _find_first_zero_bit_le(const unsigned long * p, unsigned size);
132 extern int _find_next_zero_bit_le(void * p, int size, int offset);
133 extern int _find_first_bit_le(const unsigned long *p, unsigned size);
134 extern int _find_next_bit_le(const unsigned long *p, int size, int offset);
135
136 /*
137  * The __* form of bitops are non-atomic and may be reordered.
138  */
139 #define ATOMIC_BITOP_LE(name,nr,p)              \
140         (__builtin_constant_p(nr) ?             \
141          ____atomic_##name(nr, p) :             \
142          _##name##_le(nr,p))
143
144 #define NONATOMIC_BITOP(name,nr,p)              \
145         (____nonatomic_##name(nr, p))
146
147 /*
148  * These are the little endian, atomic definitions.
149  */
150 #define set_bit(nr,p)                   ATOMIC_BITOP_LE(set_bit,nr,p)
151 #define clear_bit(nr,p)                 ATOMIC_BITOP_LE(clear_bit,nr,p)
152 #define change_bit(nr,p)                ATOMIC_BITOP_LE(change_bit,nr,p)
153 #define test_and_set_bit(nr,p)          ATOMIC_BITOP_LE(test_and_set_bit,nr,p)
154 #define test_and_clear_bit(nr,p)        ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
155 #define test_and_change_bit(nr,p)       ATOMIC_BITOP_LE(test_and_change_bit,nr,p)
156 #define find_first_zero_bit(p,sz)       _find_first_zero_bit_le(p,sz)
157 #define find_next_zero_bit(p,sz,off)    _find_next_zero_bit_le(p,sz,off)
158 #define find_first_bit(p,sz)            _find_first_bit_le(p,sz)
159 #define find_next_bit(p,sz,off)         _find_next_bit_le(p,sz,off)
160
161 #define WORD_BITOFF_TO_LE(x)            ((x))
162
163 #include <asm-generic/bitops/ffz.h>
164 #include <asm-generic/bitops/__ffs.h>
165 #include <asm-generic/bitops/fls.h>
166 #include <asm-generic/bitops/fls64.h>
167 #include <asm-generic/bitops/ffs.h>
168 #include <asm-generic/bitops/sched.h>
169 #include <asm-generic/bitops/hweight.h>
170
171 /*
172  * Ext2 is defined to use little-endian byte ordering.
173  * These do not need to be atomic.
174  */
175 #define ext2_set_bit(nr,p)                      \
176                 __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
177 #define ext2_set_bit_atomic(lock,nr,p)          \
178                 test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
179 #define ext2_clear_bit(nr,p)                    \
180                 __test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
181 #define ext2_clear_bit_atomic(lock,nr,p)        \
182                 test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
183 #define ext2_test_bit(nr,p)                     \
184                 test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
185 #define ext2_find_first_zero_bit(p,sz)          \
186                 _find_first_zero_bit_le(p,sz)
187 #define ext2_find_next_zero_bit(p,sz,off)       \
188                 _find_next_zero_bit_le(p,sz,off)
189
190 /*
191  * Minix is defined to use little-endian byte ordering.
192  * These do not need to be atomic.
193  */
194 #define minix_set_bit(nr,p)                     \
195                 __set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
196 #define minix_test_bit(nr,p)                    \
197                 test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
198 #define minix_test_and_set_bit(nr,p)            \
199                 __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
200 #define minix_test_and_clear_bit(nr,p)          \
201                 __test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
202 #define minix_find_first_zero_bit(p,sz)         \
203                 _find_first_zero_bit_le((unsigned long *)(p),sz)
204
205 #endif /* __KERNEL__ */
206
207 #endif /* _ARM_BITOPS_H */