1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * S390 version 4 * Copyright IBM Corp. 1999 5 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com) 6 * 7 * Derived from "include/asm-i386/spinlock.h" 8 */ 9 10 #ifndef __ASM_SPINLOCK_H 11 #define __ASM_SPINLOCK_H 12 13 #include <linux/smp.h> 14 #include <asm/atomic_ops.h> 15 #include <asm/barrier.h> 16 #include <asm/processor.h> 17 #include <asm/alternative.h> 18 19 #define SPINLOCK_LOCKVAL (S390_lowcore.spinlock_lockval) 20 21 extern int spin_retry; 22 23 bool arch_vcpu_is_preempted(int cpu); 24 25 #define vcpu_is_preempted arch_vcpu_is_preempted 26 27 /* 28 * Simple spin lock operations. There are two variants, one clears IRQ's 29 * on the local processor, one does not. 30 * 31 * We make no fairness assumptions. They have a cost. 32 * 33 * (the type definitions are in asm/spinlock_types.h) 34 */ 35 36 void arch_spin_relax(arch_spinlock_t *lock); 37 #define arch_spin_relax arch_spin_relax 38 39 void arch_spin_lock_wait(arch_spinlock_t *); 40 int arch_spin_trylock_retry(arch_spinlock_t *); 41 void arch_spin_lock_setup(int cpu); 42 43 static inline u32 arch_spin_lockval(int cpu) 44 { 45 return cpu + 1; 46 } 47 48 static inline int arch_spin_value_unlocked(arch_spinlock_t lock) 49 { 50 return lock.lock == 0; 51 } 52 53 static inline int arch_spin_is_locked(arch_spinlock_t *lp) 54 { 55 return READ_ONCE(lp->lock) != 0; 56 } 57 58 static inline int arch_spin_trylock_once(arch_spinlock_t *lp) 59 { 60 barrier(); 61 return likely(__atomic_cmpxchg_bool(&lp->lock, 0, SPINLOCK_LOCKVAL)); 62 } 63 64 static inline void arch_spin_lock(arch_spinlock_t *lp) 65 { 66 if (!arch_spin_trylock_once(lp)) 67 arch_spin_lock_wait(lp); 68 } 69 70 static inline int arch_spin_trylock(arch_spinlock_t *lp) 71 { 72 if (!arch_spin_trylock_once(lp)) 73 return arch_spin_trylock_retry(lp); 74 return 1; 75 } 76 77 static inline void arch_spin_unlock(arch_spinlock_t *lp) 78 { 79 typecheck(int, lp->lock); 80 asm_inline volatile( 81 ALTERNATIVE("", ".long 0xb2fa0070", 49) /* NIAI 7 */ 82 " sth %1,%0\n" 83 : "=R" (((unsigned short *) &lp->lock)[1]) 84 : "d" (0) : "cc", "memory"); 85 } 86 87 /* 88 * Read-write spinlocks, allowing multiple readers 89 * but only one writer. 90 * 91 * NOTE! it is quite common to have readers in interrupts 92 * but no interrupt writers. For those circumstances we 93 * can "mix" irq-safe locks - any writer needs to get a 94 * irq-safe write-lock, but readers can get non-irqsafe 95 * read-locks. 96 */ 97 98 #define arch_read_relax(rw) barrier() 99 #define arch_write_relax(rw) barrier() 100 101 void arch_read_lock_wait(arch_rwlock_t *lp); 102 void arch_write_lock_wait(arch_rwlock_t *lp); 103 104 static inline void arch_read_lock(arch_rwlock_t *rw) 105 { 106 int old; 107 108 old = __atomic_add(1, &rw->cnts); 109 if (old & 0xffff0000) 110 arch_read_lock_wait(rw); 111 } 112 113 static inline void arch_read_unlock(arch_rwlock_t *rw) 114 { 115 __atomic_add_const_barrier(-1, &rw->cnts); 116 } 117 118 static inline void arch_write_lock(arch_rwlock_t *rw) 119 { 120 if (!__atomic_cmpxchg_bool(&rw->cnts, 0, 0x30000)) 121 arch_write_lock_wait(rw); 122 } 123 124 static inline void arch_write_unlock(arch_rwlock_t *rw) 125 { 126 __atomic_add_barrier(-0x30000, &rw->cnts); 127 } 128 129 130 static inline int arch_read_trylock(arch_rwlock_t *rw) 131 { 132 int old; 133 134 old = READ_ONCE(rw->cnts); 135 return (!(old & 0xffff0000) && 136 __atomic_cmpxchg_bool(&rw->cnts, old, old + 1)); 137 } 138 139 static inline int arch_write_trylock(arch_rwlock_t *rw) 140 { 141 int old; 142 143 old = READ_ONCE(rw->cnts); 144 return !old && __atomic_cmpxchg_bool(&rw->cnts, 0, 0x30000); 145 } 146 147 #endif /* __ASM_SPINLOCK_H */ 148