1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Low level function for atomic operations
4 *
5 * Copyright IBM Corp. 1999, 2016
6 */
7
8 #ifndef __ARCH_S390_ATOMIC_OPS__
9 #define __ARCH_S390_ATOMIC_OPS__
10
11 #include <linux/limits.h>
12 #include <asm/march.h>
13 #include <asm/asm.h>
14
__atomic_read(const int * ptr)15 static __always_inline int __atomic_read(const int *ptr)
16 {
17 int val;
18
19 asm volatile(
20 " l %[val],%[ptr]\n"
21 : [val] "=d" (val) : [ptr] "R" (*ptr));
22 return val;
23 }
24
__atomic_set(int * ptr,int val)25 static __always_inline void __atomic_set(int *ptr, int val)
26 {
27 if (__builtin_constant_p(val) && val >= S16_MIN && val <= S16_MAX) {
28 asm volatile(
29 " mvhi %[ptr],%[val]\n"
30 : [ptr] "=Q" (*ptr) : [val] "K" (val));
31 } else {
32 asm volatile(
33 " st %[val],%[ptr]\n"
34 : [ptr] "=R" (*ptr) : [val] "d" (val));
35 }
36 }
37
__atomic64_read(const long * ptr)38 static __always_inline long __atomic64_read(const long *ptr)
39 {
40 long val;
41
42 asm volatile(
43 " lg %[val],%[ptr]\n"
44 : [val] "=d" (val) : [ptr] "RT" (*ptr));
45 return val;
46 }
47
__atomic64_set(long * ptr,long val)48 static __always_inline void __atomic64_set(long *ptr, long val)
49 {
50 if (__builtin_constant_p(val) && val >= S16_MIN && val <= S16_MAX) {
51 asm volatile(
52 " mvghi %[ptr],%[val]\n"
53 : [ptr] "=Q" (*ptr) : [val] "K" (val));
54 } else {
55 asm volatile(
56 " stg %[val],%[ptr]\n"
57 : [ptr] "=RT" (*ptr) : [val] "d" (val));
58 }
59 }
60
61 #ifdef MARCH_HAS_Z196_FEATURES
62
63 #define __ATOMIC_OP(op_name, op_type, op_string, op_barrier) \
64 static __always_inline op_type op_name(op_type val, op_type *ptr) \
65 { \
66 op_type old; \
67 \
68 asm volatile( \
69 op_string " %[old],%[val],%[ptr]\n" \
70 op_barrier \
71 : [old] "=d" (old), [ptr] "+QS" (*ptr) \
72 : [val] "d" (val) : "cc", "memory"); \
73 return old; \
74 } \
75
76 #define __ATOMIC_OPS(op_name, op_type, op_string) \
77 __ATOMIC_OP(op_name, op_type, op_string, "") \
78 __ATOMIC_OP(op_name##_barrier, op_type, op_string, "bcr 14,0\n")
79
80 __ATOMIC_OPS(__atomic_add, int, "laa")
81 __ATOMIC_OPS(__atomic_and, int, "lan")
82 __ATOMIC_OPS(__atomic_or, int, "lao")
83 __ATOMIC_OPS(__atomic_xor, int, "lax")
84
85 __ATOMIC_OPS(__atomic64_add, long, "laag")
86 __ATOMIC_OPS(__atomic64_and, long, "lang")
87 __ATOMIC_OPS(__atomic64_or, long, "laog")
88 __ATOMIC_OPS(__atomic64_xor, long, "laxg")
89
90 #undef __ATOMIC_OPS
91 #undef __ATOMIC_OP
92
93 #define __ATOMIC_CONST_OP(op_name, op_type, op_string, op_barrier) \
94 static __always_inline void op_name(op_type val, op_type *ptr) \
95 { \
96 asm volatile( \
97 op_string " %[ptr],%[val]\n" \
98 op_barrier \
99 : [ptr] "+QS" (*ptr) : [val] "i" (val) : "cc", "memory");\
100 }
101
102 #define __ATOMIC_CONST_OPS(op_name, op_type, op_string) \
103 __ATOMIC_CONST_OP(op_name, op_type, op_string, "") \
104 __ATOMIC_CONST_OP(op_name##_barrier, op_type, op_string, "bcr 14,0\n")
105
106 __ATOMIC_CONST_OPS(__atomic_add_const, int, "asi")
107 __ATOMIC_CONST_OPS(__atomic64_add_const, long, "agsi")
108
109 #undef __ATOMIC_CONST_OPS
110 #undef __ATOMIC_CONST_OP
111
112 #else /* MARCH_HAS_Z196_FEATURES */
113
114 #define __ATOMIC_OP(op_name, op_string) \
115 static __always_inline int op_name(int val, int *ptr) \
116 { \
117 int old, new; \
118 \
119 asm volatile( \
120 "0: lr %[new],%[old]\n" \
121 op_string " %[new],%[val]\n" \
122 " cs %[old],%[new],%[ptr]\n" \
123 " jl 0b" \
124 : [old] "=d" (old), [new] "=&d" (new), [ptr] "+Q" (*ptr)\
125 : [val] "d" (val), "0" (*ptr) : "cc", "memory"); \
126 return old; \
127 }
128
129 #define __ATOMIC_OPS(op_name, op_string) \
130 __ATOMIC_OP(op_name, op_string) \
131 __ATOMIC_OP(op_name##_barrier, op_string)
132
133 __ATOMIC_OPS(__atomic_add, "ar")
134 __ATOMIC_OPS(__atomic_and, "nr")
135 __ATOMIC_OPS(__atomic_or, "or")
136 __ATOMIC_OPS(__atomic_xor, "xr")
137
138 #undef __ATOMIC_OPS
139
140 #define __ATOMIC64_OP(op_name, op_string) \
141 static __always_inline long op_name(long val, long *ptr) \
142 { \
143 long old, new; \
144 \
145 asm volatile( \
146 "0: lgr %[new],%[old]\n" \
147 op_string " %[new],%[val]\n" \
148 " csg %[old],%[new],%[ptr]\n" \
149 " jl 0b" \
150 : [old] "=d" (old), [new] "=&d" (new), [ptr] "+QS" (*ptr)\
151 : [val] "d" (val), "0" (*ptr) : "cc", "memory"); \
152 return old; \
153 }
154
155 #define __ATOMIC64_OPS(op_name, op_string) \
156 __ATOMIC64_OP(op_name, op_string) \
157 __ATOMIC64_OP(op_name##_barrier, op_string)
158
159 __ATOMIC64_OPS(__atomic64_add, "agr")
160 __ATOMIC64_OPS(__atomic64_and, "ngr")
161 __ATOMIC64_OPS(__atomic64_or, "ogr")
162 __ATOMIC64_OPS(__atomic64_xor, "xgr")
163
164 #undef __ATOMIC64_OPS
165
166 #define __atomic_add_const(val, ptr) __atomic_add(val, ptr)
167 #define __atomic_add_const_barrier(val, ptr) __atomic_add(val, ptr)
168 #define __atomic64_add_const(val, ptr) __atomic64_add(val, ptr)
169 #define __atomic64_add_const_barrier(val, ptr) __atomic64_add(val, ptr)
170
171 #endif /* MARCH_HAS_Z196_FEATURES */
172
173 #if defined(MARCH_HAS_Z196_FEATURES) && defined(__HAVE_ASM_FLAG_OUTPUTS__)
174
175 #define __ATOMIC_TEST_OP(op_name, op_type, op_string, op_barrier) \
176 static __always_inline bool op_name(op_type val, op_type *ptr) \
177 { \
178 op_type tmp; \
179 int cc; \
180 \
181 asm volatile( \
182 op_string " %[tmp],%[val],%[ptr]\n" \
183 op_barrier \
184 : "=@cc" (cc), [tmp] "=d" (tmp), [ptr] "+QS" (*ptr) \
185 : [val] "d" (val) \
186 : "memory"); \
187 return (cc == 0) || (cc == 2); \
188 } \
189
190 #define __ATOMIC_TEST_OPS(op_name, op_type, op_string) \
191 __ATOMIC_TEST_OP(op_name, op_type, op_string, "") \
192 __ATOMIC_TEST_OP(op_name##_barrier, op_type, op_string, "bcr 14,0\n")
193
194 __ATOMIC_TEST_OPS(__atomic_add_and_test, int, "laal")
195 __ATOMIC_TEST_OPS(__atomic64_add_and_test, long, "laalg")
196
197 #undef __ATOMIC_TEST_OPS
198 #undef __ATOMIC_TEST_OP
199
200 #define __ATOMIC_CONST_TEST_OP(op_name, op_type, op_string, op_barrier) \
201 static __always_inline bool op_name(op_type val, op_type *ptr) \
202 { \
203 int cc; \
204 \
205 asm volatile( \
206 op_string " %[ptr],%[val]\n" \
207 op_barrier \
208 : "=@cc" (cc), [ptr] "+QS" (*ptr) \
209 : [val] "i" (val) \
210 : "memory"); \
211 return (cc == 0) || (cc == 2); \
212 }
213
214 #define __ATOMIC_CONST_TEST_OPS(op_name, op_type, op_string) \
215 __ATOMIC_CONST_TEST_OP(op_name, op_type, op_string, "") \
216 __ATOMIC_CONST_TEST_OP(op_name##_barrier, op_type, op_string, "bcr 14,0\n")
217
218 __ATOMIC_CONST_TEST_OPS(__atomic_add_const_and_test, int, "alsi")
219 __ATOMIC_CONST_TEST_OPS(__atomic64_add_const_and_test, long, "algsi")
220
221 #undef __ATOMIC_CONST_TEST_OPS
222 #undef __ATOMIC_CONST_TEST_OP
223
224 #else /* defined(MARCH_HAS_Z196_FEATURES) && defined(__HAVE_ASM_FLAG_OUTPUTS__) */
225
226 #define __ATOMIC_TEST_OP(op_name, op_func, op_type) \
227 static __always_inline bool op_name(op_type val, op_type *ptr) \
228 { \
229 return op_func(val, ptr) == -val; \
230 }
231
232 __ATOMIC_TEST_OP(__atomic_add_and_test, __atomic_add, int)
233 __ATOMIC_TEST_OP(__atomic_add_and_test_barrier, __atomic_add_barrier, int)
234 __ATOMIC_TEST_OP(__atomic_add_const_and_test, __atomic_add, int)
235 __ATOMIC_TEST_OP(__atomic_add_const_and_test_barrier, __atomic_add_barrier, int)
236 __ATOMIC_TEST_OP(__atomic64_add_and_test, __atomic64_add, long)
237 __ATOMIC_TEST_OP(__atomic64_add_and_test_barrier, __atomic64_add_barrier, long)
238 __ATOMIC_TEST_OP(__atomic64_add_const_and_test, __atomic64_add, long)
239 __ATOMIC_TEST_OP(__atomic64_add_const_and_test_barrier, __atomic64_add_barrier, long)
240
241 #undef __ATOMIC_TEST_OP
242
243 #endif /* defined(MARCH_HAS_Z196_FEATURES) && defined(__HAVE_ASM_FLAG_OUTPUTS__) */
244
245 #endif /* __ARCH_S390_ATOMIC_OPS__ */
246