Linux 4.13.16
[linux/fpc-iii.git] / arch / xtensa / include / asm / spinlock.h
bloba36221cf63637fc2e066850e937bc138698af973
1 /*
2 * include/asm-xtensa/spinlock.h
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
6 * for more details.
8 * Copyright (C) 2001 - 2005 Tensilica Inc.
9 */
11 #ifndef _XTENSA_SPINLOCK_H
12 #define _XTENSA_SPINLOCK_H
14 #include <asm/barrier.h>
15 #include <asm/processor.h>
18 * spinlock
20 * There is at most one owner of a spinlock. There are not different
21 * types of spinlock owners like there are for rwlocks (see below).
23 * When trying to obtain a spinlock, the function "spins" forever, or busy-
24 * waits, until the lock is obtained. When spinning, presumably some other
25 * owner will soon give up the spinlock making it available to others. Use
26 * the trylock functions to avoid spinning forever.
28 * possible values:
30 * 0 nobody owns the spinlock
31 * 1 somebody owns the spinlock
34 #define arch_spin_is_locked(x) ((x)->slock != 0)
36 static inline void arch_spin_unlock_wait(arch_spinlock_t *lock)
38 smp_cond_load_acquire(&lock->slock, !VAL);
41 #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock)
43 static inline void arch_spin_lock(arch_spinlock_t *lock)
45 unsigned long tmp;
47 __asm__ __volatile__(
48 " movi %0, 0\n"
49 " wsr %0, scompare1\n"
50 "1: movi %0, 1\n"
51 " s32c1i %0, %1, 0\n"
52 " bnez %0, 1b\n"
53 : "=&a" (tmp)
54 : "a" (&lock->slock)
55 : "memory");
58 /* Returns 1 if the lock is obtained, 0 otherwise. */
60 static inline int arch_spin_trylock(arch_spinlock_t *lock)
62 unsigned long tmp;
64 __asm__ __volatile__(
65 " movi %0, 0\n"
66 " wsr %0, scompare1\n"
67 " movi %0, 1\n"
68 " s32c1i %0, %1, 0\n"
69 : "=&a" (tmp)
70 : "a" (&lock->slock)
71 : "memory");
73 return tmp == 0 ? 1 : 0;
76 static inline void arch_spin_unlock(arch_spinlock_t *lock)
78 unsigned long tmp;
80 __asm__ __volatile__(
81 " movi %0, 0\n"
82 " s32ri %0, %1, 0\n"
83 : "=&a" (tmp)
84 : "a" (&lock->slock)
85 : "memory");
89 * rwlock
91 * Read-write locks are really a more flexible spinlock. They allow
92 * multiple readers but only one writer. Write ownership is exclusive
93 * (i.e., all other readers and writers are blocked from ownership while
94 * there is a write owner). These rwlocks are unfair to writers. Writers
95 * can be starved for an indefinite time by readers.
97 * possible values:
99 * 0 nobody owns the rwlock
100 * >0 one or more readers own the rwlock
101 * (the positive value is the actual number of readers)
102 * 0x80000000 one writer owns the rwlock, no other writers, no readers
105 #define arch_write_can_lock(x) ((x)->lock == 0)
107 static inline void arch_write_lock(arch_rwlock_t *rw)
109 unsigned long tmp;
111 __asm__ __volatile__(
112 " movi %0, 0\n"
113 " wsr %0, scompare1\n"
114 "1: movi %0, 1\n"
115 " slli %0, %0, 31\n"
116 " s32c1i %0, %1, 0\n"
117 " bnez %0, 1b\n"
118 : "=&a" (tmp)
119 : "a" (&rw->lock)
120 : "memory");
123 /* Returns 1 if the lock is obtained, 0 otherwise. */
125 static inline int arch_write_trylock(arch_rwlock_t *rw)
127 unsigned long tmp;
129 __asm__ __volatile__(
130 " movi %0, 0\n"
131 " wsr %0, scompare1\n"
132 " movi %0, 1\n"
133 " slli %0, %0, 31\n"
134 " s32c1i %0, %1, 0\n"
135 : "=&a" (tmp)
136 : "a" (&rw->lock)
137 : "memory");
139 return tmp == 0 ? 1 : 0;
142 static inline void arch_write_unlock(arch_rwlock_t *rw)
144 unsigned long tmp;
146 __asm__ __volatile__(
147 " movi %0, 0\n"
148 " s32ri %0, %1, 0\n"
149 : "=&a" (tmp)
150 : "a" (&rw->lock)
151 : "memory");
154 static inline void arch_read_lock(arch_rwlock_t *rw)
156 unsigned long tmp;
157 unsigned long result;
159 __asm__ __volatile__(
160 "1: l32i %1, %2, 0\n"
161 " bltz %1, 1b\n"
162 " wsr %1, scompare1\n"
163 " addi %0, %1, 1\n"
164 " s32c1i %0, %2, 0\n"
165 " bne %0, %1, 1b\n"
166 : "=&a" (result), "=&a" (tmp)
167 : "a" (&rw->lock)
168 : "memory");
171 /* Returns 1 if the lock is obtained, 0 otherwise. */
173 static inline int arch_read_trylock(arch_rwlock_t *rw)
175 unsigned long result;
176 unsigned long tmp;
178 __asm__ __volatile__(
179 " l32i %1, %2, 0\n"
180 " addi %0, %1, 1\n"
181 " bltz %0, 1f\n"
182 " wsr %1, scompare1\n"
183 " s32c1i %0, %2, 0\n"
184 " sub %0, %0, %1\n"
185 "1:\n"
186 : "=&a" (result), "=&a" (tmp)
187 : "a" (&rw->lock)
188 : "memory");
190 return result == 0;
193 static inline void arch_read_unlock(arch_rwlock_t *rw)
195 unsigned long tmp1, tmp2;
197 __asm__ __volatile__(
198 "1: l32i %1, %2, 0\n"
199 " addi %0, %1, -1\n"
200 " wsr %1, scompare1\n"
201 " s32c1i %0, %2, 0\n"
202 " bne %0, %1, 1b\n"
203 : "=&a" (tmp1), "=&a" (tmp2)
204 : "a" (&rw->lock)
205 : "memory");
208 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
209 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
211 #endif /* _XTENSA_SPINLOCK_H */