2 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
3 * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
4 * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved.
7 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
8 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
10 * Permission is hereby granted to use or copy this program
11 * for any purpose, provided the above notices are retained on all copies.
12 * Permission to modify the code and to distribute modified code is granted,
13 * provided the above notices are retained, and a notice that the code was
14 * modified is included with the above copyright notice.
18 #include "../read_ordered.h"
20 #include "../test_and_set_t_is_ao_t.h" /* Probably suboptimal */
22 /* NEC LE-IT: ARMv6 is the first architecture providing support for simple LL/SC
23 * A data memory barrier must be raised via CP15 command (see documentation).
25 * ARMv7 is compatible to ARMv6 but has a simpler command for issuing a
26 * memory barrier (DMB). Raising it via CP15 should still work as told me by the
27 * support engineers. If it turns out to be much quicker than we should implement
28 * custom code for ARMv7 using the asm { dmb } command.
30 * If only a single processor is used, we can define AO_UNIPROCESSOR
31 * and do not need to access CP15 for ensuring a DMB
34 /* NEC LE-IT: gcc has no way to easily check the arm architecture
35 * but defines only one of __ARM_ARCH_x__ to be true */
36 #if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
37 || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__) \
38 || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
39 || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7R__)
41 #include "../standard_ao_double_t.h"
46 #ifndef AO_UNIPROCESSOR
47 /* issue an data memory barrier (keeps ordering of memory transactions */
48 /* before and after this operation) */
50 __asm__ __volatile__("mcr p15,0,%0,c7,c10,5" :"=&r"(dest) : : "memory");
54 #define AO_HAVE_nop_full
56 /* NEC LE-IT: AO_t load is simple reading */
58 AO_load(const volatile AO_t *addr)
60 /* Cast away the volatile for architectures like IA64 where */
61 /* volatile adds barrier semantics. */
62 return (*(const AO_t *)addr);
66 /* NEC LE-IT: atomic "store" - according to ARM documentation this is
67 * the only safe way to set variables also used in LL/SC environment.
68 * A direct write won't be recognized by the LL/SC construct on the _same_ CPU.
69 * Support engineers response for behaviour of ARMv6:
72 ===================================
75 -----------------------------------
79 -----------------------------------
83 -----------------------------------
85 * ARMv7 behaves similar, see documentation CortexA8 TRM, point 8.5
87 * HB: I think this is only a problem if interrupt handlers do not clear
88 * the reservation, as they almost certainly should. Probably change this back
91 AO_INLINE void AO_store(volatile AO_t *addr, AO_t value)
95 __asm__ __volatile__("@AO_store\n"
97 " strex %0, %3, [%2]\n"
100 : "=&r"(flag), "+m"(*addr)
101 : "r" (addr), "r"(value)
104 #define AO_HAVE_store
106 /* NEC LE-IT: replace the SWAP as recommended by ARM:
108 "Applies to: ARM11 Cores
109 Though the SWP instruction will still work with ARM V6 cores, it is
110 recommended to use the new V6 synchronization instructions. The SWP
111 instruction produces 'locked' read and write accesses which are atomic,
112 i.e. another operation cannot be done between these locked accesses which
113 ties up external bus (AHB,AXI) bandwidth and can increase worst case
114 interrupt latencies. LDREX,STREX are more flexible, other instructions can
115 be done between the LDREX and STREX accesses.
119 AO_test_and_set(volatile AO_TS_t *addr) {
124 __asm__ __volatile__("@AO_test_and_set\n"
125 "1: ldrex %0, [%3]\n"
126 " strex %1, %4, [%3]\n"
129 : "=&r"(oldval),"=&r"(flag), "+m"(*addr)
136 #define AO_HAVE_test_and_set
138 /* NEC LE-IT: fetch and add for ARMv6 */
140 AO_fetch_and_add(volatile AO_t *p, AO_t incr)
142 unsigned long flag,tmp;
145 __asm__ __volatile__("@AO_fetch_and_add\n"
146 "1: ldrex %0, [%5]\n" /* get original */
147 " add %2, %0, %4\n" /* sum up in incr */
148 " strex %1, %2, [%5]\n" /* store them */
151 : "=&r"(result),"=&r"(flag),"=&r"(tmp),"+m"(*p) /* 0..3 */
152 : "r"(incr), "r"(p) /* 4..5 */
158 #define AO_HAVE_fetch_and_add
160 /* NEC LE-IT: fetch and add1 for ARMv6 */
162 AO_fetch_and_add1(volatile AO_t *p)
164 unsigned long flag,tmp;
167 __asm__ __volatile__("@AO_fetch_and_add1\n"
168 "1: ldrex %0, [%4]\n" /* get original */
169 " add %1, %0, #1\n" /* increment */
170 " strex %2, %1, [%4]\n" /* store them */
173 : "=&r"(result), "=&r"(tmp), "=&r"(flag), "+m"(*p)
180 #define AO_HAVE_fetch_and_add1
182 /* NEC LE-IT: fetch and sub for ARMv6 */
184 AO_fetch_and_sub1(volatile AO_t *p)
186 unsigned long flag,tmp;
189 __asm__ __volatile__("@AO_fetch_and_sub1\n"
190 "1: ldrex %0, [%4]\n" /* get original */
191 " sub %1, %0, #1\n" /* decrement */
192 " strex %2, %1, [%4]\n" /* store them */
195 : "=&r"(result), "=&r"(tmp), "=&r"(flag), "+m"(*p)
202 #define AO_HAVE_fetch_and_sub1
204 /* NEC LE-IT: compare and swap */
205 /* Returns nonzero if the comparison succeeded. */
207 AO_compare_and_swap(volatile AO_t *addr,
208 AO_t old_val, AO_t new_val)
212 __asm__ __volatile__("@ AO_compare_and_swap\n"
213 "1: mov %0, #2\n" /* store a flag */
214 " ldrex %1, [%3]\n" /* get original */
215 " teq %1, %4\n" /* see if match */
216 " strexeq %0, %5, [%3]\n" /* store new one if matched */
218 " beq 1b\n" /* if update failed, repeat */
219 : "=&r"(result), "=&r"(tmp), "+m"(*addr)
220 : "r"(addr), "r"(old_val), "r"(new_val)
223 return !(result&2); /* if succeded, return 1, else 0 */
225 #define AO_HAVE_compare_and_swap
228 AO_compare_double_and_swap_double(volatile AO_double_t *addr,
229 AO_t old_val1, AO_t old_val2,
230 AO_t new_val1, AO_t new_val2)
232 double_ptr_storage old_val = ((double_ptr_storage)old_val2 << 32) | old_val1;
233 double_ptr_storage new_val = ((double_ptr_storage)new_val2 << 32) | new_val1;
235 double_ptr_storage tmp;
239 __asm__ __volatile__("@ AO_compare_and_swap_double\n"
240 " ldrexd %0, [%1]\n" /* get original to r1&r2*/
244 if(tmp != old_val) return 0;
245 __asm__ __volatile__(
246 " strexd %0, %2, [%3]\n" /* store new one if matched */
247 : "=&r"(result),"+m"(*addr)
248 : "r"(new_val), "r"(addr)
250 if(!result) return 1;
254 #define AO_HAVE_compare_double_and_swap_double
257 /* pre ARMv6 architecures ... */
259 /* I found a slide set that, if I read it correctly, claims that */
260 /* Loads followed by either a Load or Store are ordered, but nothing */
262 /* It appears that SWP is the only simple memory barrier. */
263 #include "../all_atomic_load_store.h"
265 AO_INLINE AO_TS_VAL_t
266 AO_test_and_set_full(volatile AO_TS_t *addr) {
268 /* SWP on ARM is very similar to XCHG on x86. */
269 /* The first operand is the result, the second the value */
270 /* to be stored. Both registers must be different from addr. */
271 /* Make the address operand an early clobber output so it */
272 /* doesn't overlap with the other operands. The early clobber*/
273 /* on oldval is necessary to prevent the compiler allocating */
274 /* them to the same register if they are both unused. */
275 __asm__ __volatile__("swp %0, %2, [%3]"
276 : "=&r"(oldval), "=&r"(addr)
282 #define AO_HAVE_test_and_set_full
284 #endif // __ARM_ARCH_x