2 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
9 #ifndef __ASM_SPINLOCK_H
10 #define __ASM_SPINLOCK_H
12 #include <asm/spinlock_types.h>
13 #include <asm/processor.h>
14 #include <asm/barrier.h>
16 #define arch_spin_is_locked(x) ((x)->slock != __ARCH_SPIN_LOCK_UNLOCKED__)
17 #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock)
18 #define arch_spin_unlock_wait(x) \
19 do { while (arch_spin_is_locked(x)) cpu_relax(); } while (0)
21 #ifdef CONFIG_ARC_HAS_LLSC
23 static inline void arch_spin_lock(arch_spinlock_t
*lock
)
30 "1: llock %[val], [%[slock]] \n"
31 " breq %[val], %[LOCKED], 1b \n" /* spin while LOCKED */
32 " scond %[LOCKED], [%[slock]] \n" /* acquire */
36 : [slock
] "r" (&(lock
->slock
)),
37 [LOCKED
] "r" (__ARCH_SPIN_LOCK_LOCKED__
)
43 /* 1 - lock taken successfully */
44 static inline int arch_spin_trylock(arch_spinlock_t
*lock
)
46 unsigned int val
, got_it
= 0;
51 "1: llock %[val], [%[slock]] \n"
52 " breq %[val], %[LOCKED], 4f \n" /* already LOCKED, just bail */
53 " scond %[LOCKED], [%[slock]] \n" /* acquire */
55 " mov %[got_it], 1 \n"
59 [got_it
] "+&r" (got_it
)
60 : [slock
] "r" (&(lock
->slock
)),
61 [LOCKED
] "r" (__ARCH_SPIN_LOCK_LOCKED__
)
69 static inline void arch_spin_unlock(arch_spinlock_t
*lock
)
73 lock
->slock
= __ARCH_SPIN_LOCK_UNLOCKED__
;
79 * Read-write spinlocks, allowing multiple readers but only one writer.
80 * Unfair locking as Writers could be starved indefinitely by Reader(s)
83 static inline void arch_read_lock(arch_rwlock_t
*rw
)
90 * zero means writer holds the lock exclusively, deny Reader.
91 * Otherwise grant lock to first/subseq reader
93 * if (rw->counter > 0) {
100 "1: llock %[val], [%[rwlock]] \n"
101 " brls %[val], %[WR_LOCKED], 1b\n" /* <= 0: spin while write locked */
102 " sub %[val], %[val], 1 \n" /* reader lock */
103 " scond %[val], [%[rwlock]] \n"
107 : [rwlock
] "r" (&(rw
->counter
)),
114 /* 1 - lock taken successfully */
115 static inline int arch_read_trylock(arch_rwlock_t
*rw
)
117 unsigned int val
, got_it
= 0;
121 __asm__
__volatile__(
122 "1: llock %[val], [%[rwlock]] \n"
123 " brls %[val], %[WR_LOCKED], 4f\n" /* <= 0: already write locked, bail */
124 " sub %[val], %[val], 1 \n" /* counter-- */
125 " scond %[val], [%[rwlock]] \n"
126 " bnz 1b \n" /* retry if collided with someone */
127 " mov %[got_it], 1 \n"
129 "4: ; --- done --- \n"
132 [got_it
] "+&r" (got_it
)
133 : [rwlock
] "r" (&(rw
->counter
)),
142 static inline void arch_write_lock(arch_rwlock_t
*rw
)
149 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),
150 * deny writer. Otherwise if unlocked grant to writer
151 * Hence the claim that Linux rwlocks are unfair to writers.
152 * (can be starved for an indefinite time by readers).
154 * if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) {
160 __asm__
__volatile__(
161 "1: llock %[val], [%[rwlock]] \n"
162 " brne %[val], %[UNLOCKED], 1b \n" /* while !UNLOCKED spin */
163 " mov %[val], %[WR_LOCKED] \n"
164 " scond %[val], [%[rwlock]] \n"
168 : [rwlock
] "r" (&(rw
->counter
)),
169 [UNLOCKED
] "ir" (__ARCH_RW_LOCK_UNLOCKED__
),
176 /* 1 - lock taken successfully */
177 static inline int arch_write_trylock(arch_rwlock_t
*rw
)
179 unsigned int val
, got_it
= 0;
183 __asm__
__volatile__(
184 "1: llock %[val], [%[rwlock]] \n"
185 " brne %[val], %[UNLOCKED], 4f \n" /* !UNLOCKED, bail */
186 " mov %[val], %[WR_LOCKED] \n"
187 " scond %[val], [%[rwlock]] \n"
188 " bnz 1b \n" /* retry if collided with someone */
189 " mov %[got_it], 1 \n"
191 "4: ; --- done --- \n"
194 [got_it
] "+&r" (got_it
)
195 : [rwlock
] "r" (&(rw
->counter
)),
196 [UNLOCKED
] "ir" (__ARCH_RW_LOCK_UNLOCKED__
),
205 static inline void arch_read_unlock(arch_rwlock_t
*rw
)
214 __asm__
__volatile__(
215 "1: llock %[val], [%[rwlock]] \n"
216 " add %[val], %[val], 1 \n"
217 " scond %[val], [%[rwlock]] \n"
221 : [rwlock
] "r" (&(rw
->counter
))
227 static inline void arch_write_unlock(arch_rwlock_t
*rw
)
231 rw
->counter
= __ARCH_RW_LOCK_UNLOCKED__
;
236 #else /* !CONFIG_ARC_HAS_LLSC */
238 static inline void arch_spin_lock(arch_spinlock_t
*lock
)
240 unsigned int val
= __ARCH_SPIN_LOCK_LOCKED__
;
243 * This smp_mb() is technically superfluous, we only need the one
244 * after the lock for providing the ACQUIRE semantics.
245 * However doing the "right" thing was regressing hackbench
246 * so keeping this, pending further investigation
250 __asm__
__volatile__(
252 " breq %0, %2, 1b \n"
254 : "r"(&(lock
->slock
)), "ir"(__ARCH_SPIN_LOCK_LOCKED__
)
258 * ACQUIRE barrier to ensure load/store after taking the lock
259 * don't "bleed-up" out of the critical section (leak-in is allowed)
260 * http://www.spinics.net/lists/kernel/msg2010409.html
262 * ARCv2 only has load-load, store-store and all-all barrier
263 * thus need the full all-all barrier
268 /* 1 - lock taken successfully */
269 static inline int arch_spin_trylock(arch_spinlock_t
*lock
)
271 unsigned int val
= __ARCH_SPIN_LOCK_LOCKED__
;
275 __asm__
__volatile__(
278 : "r"(&(lock
->slock
))
283 return (val
== __ARCH_SPIN_LOCK_UNLOCKED__
);
286 static inline void arch_spin_unlock(arch_spinlock_t
*lock
)
288 unsigned int val
= __ARCH_SPIN_LOCK_UNLOCKED__
;
291 * RELEASE barrier: given the instructions avail on ARCv2, full barrier
296 __asm__
__volatile__(
299 : "r"(&(lock
->slock
))
303 * superfluous, but keeping for now - see pairing version in
304 * arch_spin_lock above
310 * Read-write spinlocks, allowing multiple readers but only one writer.
311 * Unfair locking as Writers could be starved indefinitely by Reader(s)
313 * The spinlock itself is contained in @counter and access to it is
314 * serialized with @lock_mutex.
317 /* 1 - lock taken successfully */
318 static inline int arch_read_trylock(arch_rwlock_t
*rw
)
323 local_irq_save(flags
);
324 arch_spin_lock(&(rw
->lock_mutex
));
327 * zero means writer holds the lock exclusively, deny Reader.
328 * Otherwise grant lock to first/subseq reader
330 if (rw
->counter
> 0) {
335 arch_spin_unlock(&(rw
->lock_mutex
));
336 local_irq_restore(flags
);
342 /* 1 - lock taken successfully */
343 static inline int arch_write_trylock(arch_rwlock_t
*rw
)
348 local_irq_save(flags
);
349 arch_spin_lock(&(rw
->lock_mutex
));
352 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),
353 * deny writer. Otherwise if unlocked grant to writer
354 * Hence the claim that Linux rwlocks are unfair to writers.
355 * (can be starved for an indefinite time by readers).
357 if (rw
->counter
== __ARCH_RW_LOCK_UNLOCKED__
) {
361 arch_spin_unlock(&(rw
->lock_mutex
));
362 local_irq_restore(flags
);
367 static inline void arch_read_lock(arch_rwlock_t
*rw
)
369 while (!arch_read_trylock(rw
))
373 static inline void arch_write_lock(arch_rwlock_t
*rw
)
375 while (!arch_write_trylock(rw
))
379 static inline void arch_read_unlock(arch_rwlock_t
*rw
)
383 local_irq_save(flags
);
384 arch_spin_lock(&(rw
->lock_mutex
));
386 arch_spin_unlock(&(rw
->lock_mutex
));
387 local_irq_restore(flags
);
390 static inline void arch_write_unlock(arch_rwlock_t
*rw
)
394 local_irq_save(flags
);
395 arch_spin_lock(&(rw
->lock_mutex
));
396 rw
->counter
= __ARCH_RW_LOCK_UNLOCKED__
;
397 arch_spin_unlock(&(rw
->lock_mutex
));
398 local_irq_restore(flags
);
403 #define arch_read_can_lock(x) ((x)->counter > 0)
404 #define arch_write_can_lock(x) ((x)->counter == __ARCH_RW_LOCK_UNLOCKED__)
406 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
407 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
409 #define arch_spin_relax(lock) cpu_relax()
410 #define arch_read_relax(lock) cpu_relax()
411 #define arch_write_relax(lock) cpu_relax()
413 #endif /* __ASM_SPINLOCK_H */