1 /* 2 * include/asm-xtensa/spinlock.h 3 * 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. 7 * 8 * Copyright (C) 2001 - 2005 Tensilica Inc. 9 */ 10 11 #ifndef _XTENSA_SPINLOCK_H 12 #define _XTENSA_SPINLOCK_H 13 14 #include <asm/barrier.h> 15 #include <asm/processor.h> 16 17 /* 18 * spinlock 19 * 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). 22 * 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. 27 * 28 * possible values: 29 * 30 * 0 nobody owns the spinlock 31 * 1 somebody owns the spinlock 32 */ 33 34 #define arch_spin_is_locked(x) ((x)->slock != 0) 35 36 static inline void arch_spin_unlock_wait(arch_spinlock_t *lock) 37 { 38 smp_cond_load_acquire(&lock->slock, !VAL); 39 } 40 41 #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock) 42 43 static inline void arch_spin_lock(arch_spinlock_t *lock) 44 { 45 unsigned long tmp; 46 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"); 56 } 57 58 /* Returns 1 if the lock is obtained, 0 otherwise. */ 59 60 static inline int arch_spin_trylock(arch_spinlock_t *lock) 61 { 62 unsigned long tmp; 63 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"); 72 73 return tmp == 0 ? 1 : 0; 74 } 75 76 static inline void arch_spin_unlock(arch_spinlock_t *lock) 77 { 78 unsigned long tmp; 79 80 __asm__ __volatile__( 81 " movi %0, 0\n" 82 " s32ri %0, %1, 0\n" 83 : "=&a" (tmp) 84 : "a" (&lock->slock) 85 : "memory"); 86 } 87 88 /* 89 * rwlock 90 * 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. 96 * 97 * possible values: 98 * 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 103 */ 104 105 #define arch_write_can_lock(x) ((x)->lock == 0) 106 107 static inline void arch_write_lock(arch_rwlock_t *rw) 108 { 109 unsigned long tmp; 110 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"); 121 } 122 123 /* Returns 1 if the lock is obtained, 0 otherwise. */ 124 125 static inline int arch_write_trylock(arch_rwlock_t *rw) 126 { 127 unsigned long tmp; 128 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"); 138 139 return tmp == 0 ? 1 : 0; 140 } 141 142 static inline void arch_write_unlock(arch_rwlock_t *rw) 143 { 144 unsigned long tmp; 145 146 __asm__ __volatile__( 147 " movi %0, 0\n" 148 " s32ri %0, %1, 0\n" 149 : "=&a" (tmp) 150 : "a" (&rw->lock) 151 : "memory"); 152 } 153 154 static inline void arch_read_lock(arch_rwlock_t *rw) 155 { 156 unsigned long tmp; 157 unsigned long result; 158 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"); 169 } 170 171 /* Returns 1 if the lock is obtained, 0 otherwise. */ 172 173 static inline int arch_read_trylock(arch_rwlock_t *rw) 174 { 175 unsigned long result; 176 unsigned long tmp; 177 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"); 189 190 return result == 0; 191 } 192 193 static inline void arch_read_unlock(arch_rwlock_t *rw) 194 { 195 unsigned long tmp1, tmp2; 196 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"); 206 } 207 208 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) 209 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) 210 211 #endif /* _XTENSA_SPINLOCK_H */ 212