1 #ifndef __ASM_SPINLOCK_H
2 #define __ASM_SPINLOCK_H
4 #include <asm/system.h>
5 #include <asm/processor.h>
6 #include <asm/spinlock_types.h>
8 static inline int __raw_spin_is_locked(raw_spinlock_t *x)
10 volatile unsigned int *a = __ldcw_align(x);
14 #define __raw_spin_lock(lock) __raw_spin_lock_flags(lock, 0)
15 #define __raw_spin_unlock_wait(x) \
16 do { cpu_relax(); } while (__raw_spin_is_locked(x))
18 static inline void __raw_spin_lock_flags(raw_spinlock_t *x,
21 volatile unsigned int *a;
25 while (__ldcw(a) == 0)
27 if (flags & PSW_SM_I) {
36 static inline void __raw_spin_unlock(raw_spinlock_t *x)
38 volatile unsigned int *a;
45 static inline int __raw_spin_trylock(raw_spinlock_t *x)
47 volatile unsigned int *a;
59 * Read-write spinlocks, allowing multiple readers but only one writer.
60 * Linux rwlocks are unfair to writers; they can be starved for an indefinite
61 * time by readers. With care, they can also be taken in interrupt context.
63 * In the PA-RISC implementation, we have a spinlock and a counter.
64 * Readers use the lock to serialise their access to the counter (which
65 * records how many readers currently hold the lock).
66 * Writers hold the spinlock, preventing any readers or other writers from
67 * grabbing the rwlock.
70 /* Note that we have to ensure interrupts are disabled in case we're
71 * interrupted by some other code that wants to grab the same read lock */
72 static __inline__ void __raw_read_lock(raw_rwlock_t *rw)
75 local_irq_save(flags);
76 __raw_spin_lock_flags(&rw->lock, flags);
78 __raw_spin_unlock(&rw->lock);
79 local_irq_restore(flags);
82 /* Note that we have to ensure interrupts are disabled in case we're
83 * interrupted by some other code that wants to grab the same read lock */
84 static __inline__ void __raw_read_unlock(raw_rwlock_t *rw)
87 local_irq_save(flags);
88 __raw_spin_lock_flags(&rw->lock, flags);
90 __raw_spin_unlock(&rw->lock);
91 local_irq_restore(flags);
94 /* Note that we have to ensure interrupts are disabled in case we're
95 * interrupted by some other code that wants to grab the same read lock */
96 static __inline__ int __raw_read_trylock(raw_rwlock_t *rw)
100 local_irq_save(flags);
101 if (__raw_spin_trylock(&rw->lock)) {
103 __raw_spin_unlock(&rw->lock);
104 local_irq_restore(flags);
108 local_irq_restore(flags);
109 /* If write-locked, we fail to acquire the lock */
113 /* Wait until we have a realistic chance at the lock */
114 while (__raw_spin_is_locked(&rw->lock) && rw->counter >= 0)
120 /* Note that we have to ensure interrupts are disabled in case we're
121 * interrupted by some other code that wants to read_trylock() this lock */
122 static __inline__ void __raw_write_lock(raw_rwlock_t *rw)
126 local_irq_save(flags);
127 __raw_spin_lock_flags(&rw->lock, flags);
129 if (rw->counter != 0) {
130 __raw_spin_unlock(&rw->lock);
131 local_irq_restore(flags);
133 while (rw->counter != 0)
139 rw->counter = -1; /* mark as write-locked */
141 local_irq_restore(flags);
144 static __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
147 __raw_spin_unlock(&rw->lock);
150 /* Note that we have to ensure interrupts are disabled in case we're
151 * interrupted by some other code that wants to read_trylock() this lock */
152 static __inline__ int __raw_write_trylock(raw_rwlock_t *rw)
157 local_irq_save(flags);
158 if (__raw_spin_trylock(&rw->lock)) {
159 if (rw->counter == 0) {
163 /* Read-locked. Oh well. */
164 __raw_spin_unlock(&rw->lock);
167 local_irq_restore(flags);
173 * read_can_lock - would read_trylock() succeed?
174 * @lock: the rwlock in question.
176 static __inline__ int __raw_read_can_lock(raw_rwlock_t *rw)
178 return rw->counter >= 0;
182 * write_can_lock - would write_trylock() succeed?
183 * @lock: the rwlock in question.
185 static __inline__ int __raw_write_can_lock(raw_rwlock_t *rw)
190 #define _raw_spin_relax(lock) cpu_relax()
191 #define _raw_read_relax(lock) cpu_relax()
192 #define _raw_write_relax(lock) cpu_relax()
194 #endif /* __ASM_SPINLOCK_H */