1 /* 2 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 */ 8 9 #ifndef __ASM_SPINLOCK_H 10 #define __ASM_SPINLOCK_H 11 12 #include <asm/spinlock_types.h> 13 #include <asm/processor.h> 14 #include <asm/barrier.h> 15 16 #define arch_spin_is_locked(x) ((x)->slock != __ARCH_SPIN_LOCK_UNLOCKED__) 17 #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock) 18 #define arch_spin_unlock_wait(x) \ 19 do { while (arch_spin_is_locked(x)) cpu_relax(); } while (0) 20 21 static inline void arch_spin_lock(arch_spinlock_t *lock) 22 { 23 unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__; 24 25 __asm__ __volatile__( 26 "1: ex %0, [%1] \n" 27 " breq %0, %2, 1b \n" 28 : "+&r" (tmp) 29 : "r"(&(lock->slock)), "ir"(__ARCH_SPIN_LOCK_LOCKED__) 30 : "memory"); 31 } 32 33 static inline int arch_spin_trylock(arch_spinlock_t *lock) 34 { 35 unsigned int tmp = __ARCH_SPIN_LOCK_LOCKED__; 36 37 __asm__ __volatile__( 38 "1: ex %0, [%1] \n" 39 : "+r" (tmp) 40 : "r"(&(lock->slock)) 41 : "memory"); 42 43 return (tmp == __ARCH_SPIN_LOCK_UNLOCKED__); 44 } 45 46 static inline void arch_spin_unlock(arch_spinlock_t *lock) 47 { 48 lock->slock = __ARCH_SPIN_LOCK_UNLOCKED__; 49 smp_mb(); 50 } 51 52 /* 53 * Read-write spinlocks, allowing multiple readers but only one writer. 54 * 55 * The spinlock itself is contained in @counter and access to it is 56 * serialized with @lock_mutex. 57 * 58 * Unfair locking as Writers could be starved indefinitely by Reader(s) 59 */ 60 61 /* Would read_trylock() succeed? */ 62 #define arch_read_can_lock(x) ((x)->counter > 0) 63 64 /* Would write_trylock() succeed? */ 65 #define arch_write_can_lock(x) ((x)->counter == __ARCH_RW_LOCK_UNLOCKED__) 66 67 /* 1 - lock taken successfully */ 68 static inline int arch_read_trylock(arch_rwlock_t *rw) 69 { 70 int ret = 0; 71 72 arch_spin_lock(&(rw->lock_mutex)); 73 74 /* 75 * zero means writer holds the lock exclusively, deny Reader. 76 * Otherwise grant lock to first/subseq reader 77 */ 78 if (rw->counter > 0) { 79 rw->counter--; 80 ret = 1; 81 } 82 83 arch_spin_unlock(&(rw->lock_mutex)); 84 85 smp_mb(); 86 return ret; 87 } 88 89 /* 1 - lock taken successfully */ 90 static inline int arch_write_trylock(arch_rwlock_t *rw) 91 { 92 int ret = 0; 93 94 arch_spin_lock(&(rw->lock_mutex)); 95 96 /* 97 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__), 98 * deny writer. Otherwise if unlocked grant to writer 99 * Hence the claim that Linux rwlocks are unfair to writers. 100 * (can be starved for an indefinite time by readers). 101 */ 102 if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) { 103 rw->counter = 0; 104 ret = 1; 105 } 106 arch_spin_unlock(&(rw->lock_mutex)); 107 108 return ret; 109 } 110 111 static inline void arch_read_lock(arch_rwlock_t *rw) 112 { 113 while (!arch_read_trylock(rw)) 114 cpu_relax(); 115 } 116 117 static inline void arch_write_lock(arch_rwlock_t *rw) 118 { 119 while (!arch_write_trylock(rw)) 120 cpu_relax(); 121 } 122 123 static inline void arch_read_unlock(arch_rwlock_t *rw) 124 { 125 arch_spin_lock(&(rw->lock_mutex)); 126 rw->counter++; 127 arch_spin_unlock(&(rw->lock_mutex)); 128 } 129 130 static inline void arch_write_unlock(arch_rwlock_t *rw) 131 { 132 arch_spin_lock(&(rw->lock_mutex)); 133 rw->counter = __ARCH_RW_LOCK_UNLOCKED__; 134 arch_spin_unlock(&(rw->lock_mutex)); 135 } 136 137 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) 138 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) 139 140 #define arch_spin_relax(lock) cpu_relax() 141 #define arch_read_relax(lock) cpu_relax() 142 #define arch_write_relax(lock) cpu_relax() 143 144 #endif /* __ASM_SPINLOCK_H */ 145