1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __ASM_SPINLOCK_H
3 #define __ASM_SPINLOCK_H
4
5 #include <asm/barrier.h>
6 #include <asm/ldcw.h>
7 #include <asm/processor.h>
8 #include <asm/spinlock_types.h>
9
arch_spin_is_locked(arch_spinlock_t * x)10 static inline int arch_spin_is_locked(arch_spinlock_t *x)
11 {
12 volatile unsigned int *a = __ldcw_align(x);
13 return *a == 0;
14 }
15
16 #define arch_spin_lock(lock) arch_spin_lock_flags(lock, 0)
17
arch_spin_lock_flags(arch_spinlock_t * x,unsigned long flags)18 static inline void arch_spin_lock_flags(arch_spinlock_t *x,
19 unsigned long flags)
20 {
21 volatile unsigned int *a;
22
23 a = __ldcw_align(x);
24 while (__ldcw(a) == 0)
25 while (*a == 0)
26 if (flags & PSW_SM_I) {
27 local_irq_enable();
28 cpu_relax();
29 local_irq_disable();
30 } else
31 cpu_relax();
32 }
33 #define arch_spin_lock_flags arch_spin_lock_flags
34
arch_spin_unlock(arch_spinlock_t * x)35 static inline void arch_spin_unlock(arch_spinlock_t *x)
36 {
37 volatile unsigned int *a;
38
39 a = __ldcw_align(x);
40 #ifdef CONFIG_SMP
41 (void) __ldcw(a);
42 #else
43 mb();
44 #endif
45 *a = 1;
46 }
47
arch_spin_trylock(arch_spinlock_t * x)48 static inline int arch_spin_trylock(arch_spinlock_t *x)
49 {
50 volatile unsigned int *a;
51 int ret;
52
53 a = __ldcw_align(x);
54 ret = __ldcw(a) != 0;
55
56 return ret;
57 }
58
59 /*
60 * Read-write spinlocks, allowing multiple readers but only one writer.
61 * Linux rwlocks are unfair to writers; they can be starved for an indefinite
62 * time by readers. With care, they can also be taken in interrupt context.
63 *
64 * In the PA-RISC implementation, we have a spinlock and a counter.
65 * Readers use the lock to serialise their access to the counter (which
66 * records how many readers currently hold the lock).
67 * Writers hold the spinlock, preventing any readers or other writers from
68 * grabbing the rwlock.
69 */
70
71 /* Note that we have to ensure interrupts are disabled in case we're
72 * interrupted by some other code that wants to grab the same read lock */
arch_read_lock(arch_rwlock_t * rw)73 static __inline__ void arch_read_lock(arch_rwlock_t *rw)
74 {
75 unsigned long flags;
76 local_irq_save(flags);
77 arch_spin_lock_flags(&rw->lock, flags);
78 rw->counter++;
79 arch_spin_unlock(&rw->lock);
80 local_irq_restore(flags);
81 }
82
83 /* Note that we have to ensure interrupts are disabled in case we're
84 * interrupted by some other code that wants to grab the same read lock */
arch_read_unlock(arch_rwlock_t * rw)85 static __inline__ void arch_read_unlock(arch_rwlock_t *rw)
86 {
87 unsigned long flags;
88 local_irq_save(flags);
89 arch_spin_lock_flags(&rw->lock, flags);
90 rw->counter--;
91 arch_spin_unlock(&rw->lock);
92 local_irq_restore(flags);
93 }
94
95 /* Note that we have to ensure interrupts are disabled in case we're
96 * interrupted by some other code that wants to grab the same read lock */
arch_read_trylock(arch_rwlock_t * rw)97 static __inline__ int arch_read_trylock(arch_rwlock_t *rw)
98 {
99 unsigned long flags;
100 retry:
101 local_irq_save(flags);
102 if (arch_spin_trylock(&rw->lock)) {
103 rw->counter++;
104 arch_spin_unlock(&rw->lock);
105 local_irq_restore(flags);
106 return 1;
107 }
108
109 local_irq_restore(flags);
110 /* If write-locked, we fail to acquire the lock */
111 if (rw->counter < 0)
112 return 0;
113
114 /* Wait until we have a realistic chance at the lock */
115 while (arch_spin_is_locked(&rw->lock) && rw->counter >= 0)
116 cpu_relax();
117
118 goto retry;
119 }
120
121 /* Note that we have to ensure interrupts are disabled in case we're
122 * interrupted by some other code that wants to read_trylock() this lock */
arch_write_lock(arch_rwlock_t * rw)123 static __inline__ void arch_write_lock(arch_rwlock_t *rw)
124 {
125 unsigned long flags;
126 retry:
127 local_irq_save(flags);
128 arch_spin_lock_flags(&rw->lock, flags);
129
130 if (rw->counter != 0) {
131 arch_spin_unlock(&rw->lock);
132 local_irq_restore(flags);
133
134 while (rw->counter != 0)
135 cpu_relax();
136
137 goto retry;
138 }
139
140 rw->counter = -1; /* mark as write-locked */
141 mb();
142 local_irq_restore(flags);
143 }
144
arch_write_unlock(arch_rwlock_t * rw)145 static __inline__ void arch_write_unlock(arch_rwlock_t *rw)
146 {
147 rw->counter = 0;
148 arch_spin_unlock(&rw->lock);
149 }
150
151 /* Note that we have to ensure interrupts are disabled in case we're
152 * interrupted by some other code that wants to read_trylock() this lock */
arch_write_trylock(arch_rwlock_t * rw)153 static __inline__ int arch_write_trylock(arch_rwlock_t *rw)
154 {
155 unsigned long flags;
156 int result = 0;
157
158 local_irq_save(flags);
159 if (arch_spin_trylock(&rw->lock)) {
160 if (rw->counter == 0) {
161 rw->counter = -1;
162 result = 1;
163 } else {
164 /* Read-locked. Oh well. */
165 arch_spin_unlock(&rw->lock);
166 }
167 }
168 local_irq_restore(flags);
169
170 return result;
171 }
172
173 #endif /* __ASM_SPINLOCK_H */
174