1 #ifndef __ASM_SPINLOCK_H 2 #define __ASM_SPINLOCK_H 3 4 #include <asm/barrier.h> 5 #include <asm/ldcw.h> 6 #include <asm/processor.h> 7 #include <asm/spinlock_types.h> 8 9 static inline int arch_spin_is_locked(arch_spinlock_t *x) 10 { 11 volatile unsigned int *a = __ldcw_align(x); 12 return *a == 0; 13 } 14 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)) 18 19 static inline void arch_spin_lock_flags(arch_spinlock_t *x, 20 unsigned long flags) 21 { 22 volatile unsigned int *a; 23 24 mb(); 25 a = __ldcw_align(x); 26 while (__ldcw(a) == 0) 27 while (*a == 0) 28 if (flags & PSW_SM_I) { 29 local_irq_enable(); 30 cpu_relax(); 31 local_irq_disable(); 32 } else 33 cpu_relax(); 34 mb(); 35 } 36 37 static inline void arch_spin_unlock(arch_spinlock_t *x) 38 { 39 volatile unsigned int *a; 40 mb(); 41 a = __ldcw_align(x); 42 *a = 1; 43 mb(); 44 } 45 46 static inline int arch_spin_trylock(arch_spinlock_t *x) 47 { 48 volatile unsigned int *a; 49 int ret; 50 51 mb(); 52 a = __ldcw_align(x); 53 ret = __ldcw(a) != 0; 54 mb(); 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 */ 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 */ 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 */ 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 */ 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 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 */ 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 /* 174 * read_can_lock - would read_trylock() succeed? 175 * @lock: the rwlock in question. 176 */ 177 static __inline__ int arch_read_can_lock(arch_rwlock_t *rw) 178 { 179 return rw->counter >= 0; 180 } 181 182 /* 183 * write_can_lock - would write_trylock() succeed? 184 * @lock: the rwlock in question. 185 */ 186 static __inline__ int arch_write_can_lock(arch_rwlock_t *rw) 187 { 188 return !rw->counter; 189 } 190 191 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) 192 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) 193 194 #endif /* __ASM_SPINLOCK_H */ 195