1 #ifndef __ASM_SPINLOCK_H
2 #define __ASM_SPINLOCK_H
4 #include <asm/barrier.h>
6 #include <asm/processor.h>
7 #include <asm/spinlock_types.h>
9 static inline int arch_spin_is_locked(arch_spinlock_t *x)
11 volatile unsigned int *a = __ldcw_align(x);
15 #define arch_spin_lock(lock) arch_spin_lock_flags(lock, 0)
16 #define arch_spin_unlock_wait(x) \
17 do { cpu_relax(); } while (arch_spin_is_locked(x))
19 static inline void arch_spin_lock_flags(arch_spinlock_t *x,
22 volatile unsigned int *a;
26 while (__ldcw(a) == 0)
28 if (flags & PSW_SM_I) {
37 static inline void arch_spin_unlock(arch_spinlock_t *x)
39 volatile unsigned int *a;
46 static inline int arch_spin_trylock(arch_spinlock_t *x)
48 volatile unsigned int *a;
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.
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.
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 */
73 static __inline__ void arch_read_lock(arch_rwlock_t *rw)
76 local_irq_save(flags);
77 arch_spin_lock_flags(&rw->lock, flags);
79 arch_spin_unlock(&rw->lock);
80 local_irq_restore(flags);
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 */
85 static __inline__ void arch_read_unlock(arch_rwlock_t *rw)
88 local_irq_save(flags);
89 arch_spin_lock_flags(&rw->lock, flags);
91 arch_spin_unlock(&rw->lock);
92 local_irq_restore(flags);
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 */
97 static __inline__ int arch_read_trylock(arch_rwlock_t *rw)
101 local_irq_save(flags);
102 if (arch_spin_trylock(&rw->lock)) {
104 arch_spin_unlock(&rw->lock);
105 local_irq_restore(flags);
109 local_irq_restore(flags);
110 /* If write-locked, we fail to acquire the lock */
114 /* Wait until we have a realistic chance at the lock */
115 while (arch_spin_is_locked(&rw->lock) && rw->counter >= 0)
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 */
123 static __inline__ void arch_write_lock(arch_rwlock_t *rw)
127 local_irq_save(flags);
128 arch_spin_lock_flags(&rw->lock, flags);
130 if (rw->counter != 0) {
131 arch_spin_unlock(&rw->lock);
132 local_irq_restore(flags);
134 while (rw->counter != 0)
140 rw->counter = -1; /* mark as write-locked */
142 local_irq_restore(flags);
145 static __inline__ void arch_write_unlock(arch_rwlock_t *rw)
148 arch_spin_unlock(&rw->lock);
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 */
153 static __inline__ int arch_write_trylock(arch_rwlock_t *rw)
158 local_irq_save(flags);
159 if (arch_spin_trylock(&rw->lock)) {
160 if (rw->counter == 0) {
164 /* Read-locked. Oh well. */
165 arch_spin_unlock(&rw->lock);
168 local_irq_restore(flags);
174 * read_can_lock - would read_trylock() succeed?
175 * @lock: the rwlock in question.
177 static __inline__ int arch_read_can_lock(arch_rwlock_t *rw)
179 return rw->counter >= 0;
183 * write_can_lock - would write_trylock() succeed?
184 * @lock: the rwlock in question.
186 static __inline__ int arch_write_can_lock(arch_rwlock_t *rw)
191 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
192 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
194 #endif /* __ASM_SPINLOCK_H */