Merge branch 'master' of /home/sam/kernel/linux-2.6/
[linux-2.6] / include / asm-frv / bitops.h
1 /* bitops.h: bit operations for the Fujitsu FR-V CPUs
2  *
3  * For an explanation of how atomic ops work in this arch, see:
4  *   Documentation/fujitsu/frv/atomic-ops.txt
5  *
6  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
7  * Written by David Howells (dhowells@redhat.com)
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version
12  * 2 of the License, or (at your option) any later version.
13  */
14 #ifndef _ASM_BITOPS_H
15 #define _ASM_BITOPS_H
16
17 #include <linux/compiler.h>
18 #include <asm/byteorder.h>
19 #include <asm/system.h>
20 #include <asm/atomic.h>
21
22 #ifdef __KERNEL__
23
24 #include <asm-generic/bitops/ffz.h>
25
26 /*
27  * clear_bit() doesn't provide any barrier for the compiler.
28  */
29 #define smp_mb__before_clear_bit()      barrier()
30 #define smp_mb__after_clear_bit()       barrier()
31
32 static inline int test_and_clear_bit(int nr, volatile void *addr)
33 {
34         volatile unsigned long *ptr = addr;
35         unsigned long mask = 1UL << (nr & 31);
36         ptr += nr >> 5;
37         return (atomic_test_and_ANDNOT_mask(mask, ptr) & mask) != 0;
38 }
39
40 static inline int test_and_set_bit(int nr, volatile void *addr)
41 {
42         volatile unsigned long *ptr = addr;
43         unsigned long mask = 1UL << (nr & 31);
44         ptr += nr >> 5;
45         return (atomic_test_and_OR_mask(mask, ptr) & mask) != 0;
46 }
47
48 static inline int test_and_change_bit(int nr, volatile void *addr)
49 {
50         volatile unsigned long *ptr = addr;
51         unsigned long mask = 1UL << (nr & 31);
52         ptr += nr >> 5;
53         return (atomic_test_and_XOR_mask(mask, ptr) & mask) != 0;
54 }
55
56 static inline void clear_bit(int nr, volatile void *addr)
57 {
58         test_and_clear_bit(nr, addr);
59 }
60
61 static inline void set_bit(int nr, volatile void *addr)
62 {
63         test_and_set_bit(nr, addr);
64 }
65
66 static inline void change_bit(int nr, volatile void * addr)
67 {
68         test_and_change_bit(nr, addr);
69 }
70
71 static inline void __clear_bit(int nr, volatile void * addr)
72 {
73         volatile unsigned long *a = addr;
74         int mask;
75
76         a += nr >> 5;
77         mask = 1 << (nr & 31);
78         *a &= ~mask;
79 }
80
81 static inline void __set_bit(int nr, volatile void * addr)
82 {
83         volatile unsigned long *a = addr;
84         int mask;
85
86         a += nr >> 5;
87         mask = 1 << (nr & 31);
88         *a |= mask;
89 }
90
91 static inline void __change_bit(int nr, volatile void *addr)
92 {
93         volatile unsigned long *a = addr;
94         int mask;
95
96         a += nr >> 5;
97         mask = 1 << (nr & 31);
98         *a ^= mask;
99 }
100
101 static inline int __test_and_clear_bit(int nr, volatile void * addr)
102 {
103         volatile unsigned long *a = addr;
104         int mask, retval;
105
106         a += nr >> 5;
107         mask = 1 << (nr & 31);
108         retval = (mask & *a) != 0;
109         *a &= ~mask;
110         return retval;
111 }
112
113 static inline int __test_and_set_bit(int nr, volatile void * addr)
114 {
115         volatile unsigned long *a = addr;
116         int mask, retval;
117
118         a += nr >> 5;
119         mask = 1 << (nr & 31);
120         retval = (mask & *a) != 0;
121         *a |= mask;
122         return retval;
123 }
124
125 static inline int __test_and_change_bit(int nr, volatile void * addr)
126 {
127         volatile unsigned long *a = addr;
128         int mask, retval;
129
130         a += nr >> 5;
131         mask = 1 << (nr & 31);
132         retval = (mask & *a) != 0;
133         *a ^= mask;
134         return retval;
135 }
136
137 /*
138  * This routine doesn't need to be atomic.
139  */
140 static inline int __constant_test_bit(int nr, const volatile void * addr)
141 {
142         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
143 }
144
145 static inline int __test_bit(int nr, const volatile void * addr)
146 {
147         int     * a = (int *) addr;
148         int     mask;
149
150         a += nr >> 5;
151         mask = 1 << (nr & 0x1f);
152         return ((mask & *a) != 0);
153 }
154
155 #define test_bit(nr,addr) \
156 (__builtin_constant_p(nr) ? \
157  __constant_test_bit((nr),(addr)) : \
158  __test_bit((nr),(addr)))
159
160 #include <asm-generic/bitops/ffs.h>
161 #include <asm-generic/bitops/__ffs.h>
162 #include <asm-generic/bitops/find.h>
163
164 /*
165  * fls: find last bit set.
166  */
167 #define fls(x)                                          \
168 ({                                                      \
169         int bit;                                        \
170                                                         \
171         asm("scan %1,gr0,%0" : "=r"(bit) : "r"(x));     \
172                                                         \
173         bit ? 33 - bit : bit;                           \
174 })
175
176 #include <asm-generic/bitops/fls64.h>
177 #include <asm-generic/bitops/sched.h>
178 #include <asm-generic/bitops/hweight.h>
179
180 #include <asm-generic/bitops/ext2-non-atomic.h>
181
182 #define ext2_set_bit_atomic(lock,nr,addr)       test_and_set_bit  ((nr) ^ 0x18, (addr))
183 #define ext2_clear_bit_atomic(lock,nr,addr)     test_and_clear_bit((nr) ^ 0x18, (addr))
184
185 #include <asm-generic/bitops/minix-le.h>
186
187 #endif /* __KERNEL__ */
188
189 #endif /* _ASM_BITOPS_H */