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 /* 15 * spinlock 16 * 17 * There is at most one owner of a spinlock. There are not different 18 * types of spinlock owners like there are for rwlocks (see below). 19 * 20 * When trying to obtain a spinlock, the function "spins" forever, or busy- 21 * waits, until the lock is obtained. When spinning, presumably some other 22 * owner will soon give up the spinlock making it available to others. Use 23 * the trylock functions to avoid spinning forever. 24 * 25 * possible values: 26 * 27 * 0 nobody owns the spinlock 28 * 1 somebody owns the spinlock 29 */ 30 31 #define __raw_spin_is_locked(x) ((x)->slock != 0) 32 #define __raw_spin_unlock_wait(lock) \ 33 do { while (__raw_spin_is_locked(lock)) cpu_relax(); } while (0) 34 35 #define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock) 36 37 static inline void __raw_spin_lock(raw_spinlock_t *lock) 38 { 39 unsigned long tmp; 40 41 __asm__ __volatile__( 42 " movi %0, 0\n" 43 " wsr %0, scompare1\n" 44 "1: movi %0, 1\n" 45 " s32c1i %0, %1, 0\n" 46 " bnez %0, 1b\n" 47 : "=&a" (tmp) 48 : "a" (&lock->slock) 49 : "memory"); 50 } 51 52 /* Returns 1 if the lock is obtained, 0 otherwise. */ 53 54 static inline int __raw_spin_trylock(raw_spinlock_t *lock) 55 { 56 unsigned long tmp; 57 58 __asm__ __volatile__( 59 " movi %0, 0\n" 60 " wsr %0, scompare1\n" 61 " movi %0, 1\n" 62 " s32c1i %0, %1, 0\n" 63 : "=&a" (tmp) 64 : "a" (&lock->slock) 65 : "memory"); 66 67 return tmp == 0 ? 1 : 0; 68 } 69 70 static inline void __raw_spin_unlock(raw_spinlock_t *lock) 71 { 72 unsigned long tmp; 73 74 __asm__ __volatile__( 75 " movi %0, 0\n" 76 " s32ri %0, %1, 0\n" 77 : "=&a" (tmp) 78 : "a" (&lock->slock) 79 : "memory"); 80 } 81 82 /* 83 * rwlock 84 * 85 * Read-write locks are really a more flexible spinlock. They allow 86 * multiple readers but only one writer. Write ownership is exclusive 87 * (i.e., all other readers and writers are blocked from ownership while 88 * there is a write owner). These rwlocks are unfair to writers. Writers 89 * can be starved for an indefinite time by readers. 90 * 91 * possible values: 92 * 93 * 0 nobody owns the rwlock 94 * >0 one or more readers own the rwlock 95 * (the positive value is the actual number of readers) 96 * 0x80000000 one writer owns the rwlock, no other writers, no readers 97 */ 98 99 #define __raw_write_can_lock(x) ((x)->lock == 0) 100 101 static inline void __raw_write_lock(raw_rwlock_t *rw) 102 { 103 unsigned long tmp; 104 105 __asm__ __volatile__( 106 " movi %0, 0\n" 107 " wsr %0, scompare1\n" 108 "1: movi %0, 1\n" 109 " slli %0, %0, 31\n" 110 " s32c1i %0, %1, 0\n" 111 " bnez %0, 1b\n" 112 : "=&a" (tmp) 113 : "a" (&rw->lock) 114 : "memory"); 115 } 116 117 /* Returns 1 if the lock is obtained, 0 otherwise. */ 118 119 static inline int __raw_write_trylock(raw_rwlock_t *rw) 120 { 121 unsigned long tmp; 122 123 __asm__ __volatile__( 124 " movi %0, 0\n" 125 " wsr %0, scompare1\n" 126 " movi %0, 1\n" 127 " slli %0, %0, 31\n" 128 " s32c1i %0, %1, 0\n" 129 : "=&a" (tmp) 130 : "a" (&rw->lock) 131 : "memory"); 132 133 return tmp == 0 ? 1 : 0; 134 } 135 136 static inline void __raw_write_unlock(raw_rwlock_t *rw) 137 { 138 unsigned long tmp; 139 140 __asm__ __volatile__( 141 " movi %0, 0\n" 142 " s32ri %0, %1, 0\n" 143 : "=&a" (tmp) 144 : "a" (&rw->lock) 145 : "memory"); 146 } 147 148 static inline void __raw_read_lock(raw_rwlock_t *rw) 149 { 150 unsigned long tmp; 151 unsigned long result; 152 153 __asm__ __volatile__( 154 "1: l32i %1, %2, 0\n" 155 " bltz %1, 1b\n" 156 " wsr %1, scompare1\n" 157 " addi %0, %1, 1\n" 158 " s32c1i %0, %2, 0\n" 159 " bne %0, %1, 1b\n" 160 : "=&a" (result), "=&a" (tmp) 161 : "a" (&rw->lock) 162 : "memory"); 163 } 164 165 /* Returns 1 if the lock is obtained, 0 otherwise. */ 166 167 static inline int __raw_read_trylock(raw_rwlock_t *rw) 168 { 169 unsigned long result; 170 unsigned long tmp; 171 172 __asm__ __volatile__( 173 " l32i %1, %2, 0\n" 174 " addi %0, %1, 1\n" 175 " bltz %0, 1f\n" 176 " wsr %1, scompare1\n" 177 " s32c1i %0, %2, 0\n" 178 " sub %0, %0, %1\n" 179 "1:\n" 180 : "=&a" (result), "=&a" (tmp) 181 : "a" (&rw->lock) 182 : "memory"); 183 184 return result == 0; 185 } 186 187 static inline void __raw_read_unlock(raw_rwlock_t *rw) 188 { 189 unsigned long tmp1, tmp2; 190 191 __asm__ __volatile__( 192 "1: l32i %1, %2, 0\n" 193 " addi %0, %1, -1\n" 194 " wsr %1, scompare1\n" 195 " s32c1i %0, %2, 0\n" 196 " bne %0, %1, 1b\n" 197 : "=&a" (tmp1), "=&a" (tmp2) 198 : "a" (&rw->lock) 199 : "memory"); 200 } 201 202 #endif /* _XTENSA_SPINLOCK_H */ 203