asm-generic: rename atomic.h to atomic-long.h
[sfrench/cifs-2.6.git] / arch / s390 / include / asm / atomic.h
1 #ifndef __ARCH_S390_ATOMIC__
2 #define __ARCH_S390_ATOMIC__
3
4 #include <linux/compiler.h>
5 #include <linux/types.h>
6
7 /*
8  *  include/asm-s390/atomic.h
9  *
10  *  S390 version
11  *    Copyright (C) 1999-2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
12  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
13  *               Denis Joseph Barrow,
14  *               Arnd Bergmann (arndb@de.ibm.com)
15  *
16  *  Derived from "include/asm-i386/bitops.h"
17  *    Copyright (C) 1992, Linus Torvalds
18  *
19  */
20
21 /*
22  * Atomic operations that C can't guarantee us.  Useful for
23  * resource counting etc..
24  * S390 uses 'Compare And Swap' for atomicity in SMP enviroment
25  */
26
27 #define ATOMIC_INIT(i)  { (i) }
28
29 #ifdef __KERNEL__
30
31 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
32
33 #define __CS_LOOP(ptr, op_val, op_string) ({                            \
34         typeof(ptr->counter) old_val, new_val;                          \
35         asm volatile(                                                   \
36                 "       l       %0,%2\n"                                \
37                 "0:     lr      %1,%0\n"                                \
38                 op_string "     %1,%3\n"                                \
39                 "       cs      %0,%1,%2\n"                             \
40                 "       jl      0b"                                     \
41                 : "=&d" (old_val), "=&d" (new_val),                     \
42                   "=Q" (((atomic_t *)(ptr))->counter)                   \
43                 : "d" (op_val),  "Q" (((atomic_t *)(ptr))->counter)     \
44                 : "cc", "memory");                                      \
45         new_val;                                                        \
46 })
47
48 #else /* __GNUC__ */
49
50 #define __CS_LOOP(ptr, op_val, op_string) ({                            \
51         typeof(ptr->counter) old_val, new_val;                          \
52         asm volatile(                                                   \
53                 "       l       %0,0(%3)\n"                             \
54                 "0:     lr      %1,%0\n"                                \
55                 op_string "     %1,%4\n"                                \
56                 "       cs      %0,%1,0(%3)\n"                          \
57                 "       jl      0b"                                     \
58                 : "=&d" (old_val), "=&d" (new_val),                     \
59                   "=m" (((atomic_t *)(ptr))->counter)                   \
60                 : "a" (ptr), "d" (op_val),                              \
61                   "m" (((atomic_t *)(ptr))->counter)                    \
62                 : "cc", "memory");                                      \
63         new_val;                                                        \
64 })
65
66 #endif /* __GNUC__ */
67
68 static inline int atomic_read(const atomic_t *v)
69 {
70         barrier();
71         return v->counter;
72 }
73
74 static inline void atomic_set(atomic_t *v, int i)
75 {
76         v->counter = i;
77         barrier();
78 }
79
80 static __inline__ int atomic_add_return(int i, atomic_t * v)
81 {
82         return __CS_LOOP(v, i, "ar");
83 }
84 #define atomic_add(_i, _v)              atomic_add_return(_i, _v)
85 #define atomic_add_negative(_i, _v)     (atomic_add_return(_i, _v) < 0)
86 #define atomic_inc(_v)                  atomic_add_return(1, _v)
87 #define atomic_inc_return(_v)           atomic_add_return(1, _v)
88 #define atomic_inc_and_test(_v)         (atomic_add_return(1, _v) == 0)
89
90 static __inline__ int atomic_sub_return(int i, atomic_t * v)
91 {
92         return __CS_LOOP(v, i, "sr");
93 }
94 #define atomic_sub(_i, _v)              atomic_sub_return(_i, _v)
95 #define atomic_sub_and_test(_i, _v)     (atomic_sub_return(_i, _v) == 0)
96 #define atomic_dec(_v)                  atomic_sub_return(1, _v)
97 #define atomic_dec_return(_v)           atomic_sub_return(1, _v)
98 #define atomic_dec_and_test(_v)         (atomic_sub_return(1, _v) == 0)
99
100 static __inline__ void atomic_clear_mask(unsigned long mask, atomic_t * v)
101 {
102                __CS_LOOP(v, ~mask, "nr");
103 }
104
105 static __inline__ void atomic_set_mask(unsigned long mask, atomic_t * v)
106 {
107                __CS_LOOP(v, mask, "or");
108 }
109
110 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
111
112 static __inline__ int atomic_cmpxchg(atomic_t *v, int old, int new)
113 {
114 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
115         asm volatile(
116                 "       cs      %0,%2,%1"
117                 : "+d" (old), "=Q" (v->counter)
118                 : "d" (new), "Q" (v->counter)
119                 : "cc", "memory");
120 #else /* __GNUC__ */
121         asm volatile(
122                 "       cs      %0,%3,0(%2)"
123                 : "+d" (old), "=m" (v->counter)
124                 : "a" (v), "d" (new), "m" (v->counter)
125                 : "cc", "memory");
126 #endif /* __GNUC__ */
127         return old;
128 }
129
130 static __inline__ int atomic_add_unless(atomic_t *v, int a, int u)
131 {
132         int c, old;
133         c = atomic_read(v);
134         for (;;) {
135                 if (unlikely(c == u))
136                         break;
137                 old = atomic_cmpxchg(v, c, c + a);
138                 if (likely(old == c))
139                         break;
140                 c = old;
141         }
142         return c != u;
143 }
144
145 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
146
147 #undef __CS_LOOP
148
149 #ifdef __s390x__
150 #define ATOMIC64_INIT(i)  { (i) }
151
152 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
153
154 #define __CSG_LOOP(ptr, op_val, op_string) ({                           \
155         typeof(ptr->counter) old_val, new_val;                          \
156         asm volatile(                                                   \
157                 "       lg      %0,%2\n"                                \
158                 "0:     lgr     %1,%0\n"                                \
159                 op_string "     %1,%3\n"                                \
160                 "       csg     %0,%1,%2\n"                             \
161                 "       jl      0b"                                     \
162                 : "=&d" (old_val), "=&d" (new_val),                     \
163                   "=Q" (((atomic_t *)(ptr))->counter)                   \
164                 : "d" (op_val), "Q" (((atomic_t *)(ptr))->counter)      \
165                 : "cc", "memory" );                                     \
166         new_val;                                                        \
167 })
168
169 #else /* __GNUC__ */
170
171 #define __CSG_LOOP(ptr, op_val, op_string) ({                           \
172         typeof(ptr->counter) old_val, new_val;                          \
173         asm volatile(                                                   \
174                 "       lg      %0,0(%3)\n"                             \
175                 "0:     lgr     %1,%0\n"                                \
176                 op_string "     %1,%4\n"                                \
177                 "       csg     %0,%1,0(%3)\n"                          \
178                 "       jl      0b"                                     \
179                 : "=&d" (old_val), "=&d" (new_val),                     \
180                   "=m" (((atomic_t *)(ptr))->counter)                   \
181                 : "a" (ptr), "d" (op_val),                              \
182                   "m" (((atomic_t *)(ptr))->counter)                    \
183                 : "cc", "memory" );                                     \
184         new_val;                                                        \
185 })
186
187 #endif /* __GNUC__ */
188
189 static inline long long atomic64_read(const atomic64_t *v)
190 {
191         barrier();
192         return v->counter;
193 }
194
195 static inline void atomic64_set(atomic64_t *v, long long i)
196 {
197         v->counter = i;
198         barrier();
199 }
200
201 static __inline__ long long atomic64_add_return(long long i, atomic64_t * v)
202 {
203         return __CSG_LOOP(v, i, "agr");
204 }
205 #define atomic64_add(_i, _v)            atomic64_add_return(_i, _v)
206 #define atomic64_add_negative(_i, _v)   (atomic64_add_return(_i, _v) < 0)
207 #define atomic64_inc(_v)                atomic64_add_return(1, _v)
208 #define atomic64_inc_return(_v)         atomic64_add_return(1, _v)
209 #define atomic64_inc_and_test(_v)       (atomic64_add_return(1, _v) == 0)
210
211 static __inline__ long long atomic64_sub_return(long long i, atomic64_t * v)
212 {
213         return __CSG_LOOP(v, i, "sgr");
214 }
215 #define atomic64_sub(_i, _v)            atomic64_sub_return(_i, _v)
216 #define atomic64_sub_and_test(_i, _v)   (atomic64_sub_return(_i, _v) == 0)
217 #define atomic64_dec(_v)                atomic64_sub_return(1, _v)
218 #define atomic64_dec_return(_v)         atomic64_sub_return(1, _v)
219 #define atomic64_dec_and_test(_v)       (atomic64_sub_return(1, _v) == 0)
220
221 static __inline__ void atomic64_clear_mask(unsigned long mask, atomic64_t * v)
222 {
223                __CSG_LOOP(v, ~mask, "ngr");
224 }
225
226 static __inline__ void atomic64_set_mask(unsigned long mask, atomic64_t * v)
227 {
228                __CSG_LOOP(v, mask, "ogr");
229 }
230
231 #define atomic64_xchg(v, new) (xchg(&((v)->counter), new))
232
233 static __inline__ long long atomic64_cmpxchg(atomic64_t *v,
234                                              long long old, long long new)
235 {
236 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
237         asm volatile(
238                 "       csg     %0,%2,%1"
239                 : "+d" (old), "=Q" (v->counter)
240                 : "d" (new), "Q" (v->counter)
241                 : "cc", "memory");
242 #else /* __GNUC__ */
243         asm volatile(
244                 "       csg     %0,%3,0(%2)"
245                 : "+d" (old), "=m" (v->counter)
246                 : "a" (v), "d" (new), "m" (v->counter)
247                 : "cc", "memory");
248 #endif /* __GNUC__ */
249         return old;
250 }
251
252 static __inline__ int atomic64_add_unless(atomic64_t *v,
253                                           long long a, long long u)
254 {
255         long long c, old;
256         c = atomic64_read(v);
257         for (;;) {
258                 if (unlikely(c == u))
259                         break;
260                 old = atomic64_cmpxchg(v, c, c + a);
261                 if (likely(old == c))
262                         break;
263                 c = old;
264         }
265         return c != u;
266 }
267
268 #define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
269
270 #undef __CSG_LOOP
271 #endif
272
273 #define smp_mb__before_atomic_dec()     smp_mb()
274 #define smp_mb__after_atomic_dec()      smp_mb()
275 #define smp_mb__before_atomic_inc()     smp_mb()
276 #define smp_mb__after_atomic_inc()      smp_mb()
277
278 #include <asm-generic/atomic-long.h>
279 #endif /* __KERNEL__ */
280 #endif /* __ARCH_S390_ATOMIC__  */