xref: /openbmc/linux/arch/parisc/include/asm/spinlock.h (revision a0f4b787)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __ASM_SPINLOCK_H
3 #define __ASM_SPINLOCK_H
4 
5 #include <asm/barrier.h>
6 #include <asm/ldcw.h>
7 #include <asm/processor.h>
8 #include <asm/spinlock_types.h>
9 
arch_spin_val_check(int lock_val)10 static inline void arch_spin_val_check(int lock_val)
11 {
12 	if (IS_ENABLED(CONFIG_LIGHTWEIGHT_SPINLOCK_CHECK))
13 		asm volatile(	"andcm,= %0,%1,%%r0\n"
14 				".word %2\n"
15 		: : "r" (lock_val), "r" (__ARCH_SPIN_LOCK_UNLOCKED_VAL),
16 			"i" (SPINLOCK_BREAK_INSN));
17 }
18 
arch_spin_is_locked(arch_spinlock_t * x)19 static inline int arch_spin_is_locked(arch_spinlock_t *x)
20 {
21 	volatile unsigned int *a;
22 	int lock_val;
23 
24 	a = __ldcw_align(x);
25 	lock_val = READ_ONCE(*a);
26 	arch_spin_val_check(lock_val);
27 	return (lock_val == 0);
28 }
29 
arch_spin_lock(arch_spinlock_t * x)30 static inline void arch_spin_lock(arch_spinlock_t *x)
31 {
32 	volatile unsigned int *a;
33 
34 	a = __ldcw_align(x);
35 	do {
36 		int lock_val_old;
37 
38 		lock_val_old = __ldcw(a);
39 		arch_spin_val_check(lock_val_old);
40 		if (lock_val_old)
41 			return;	/* got lock */
42 
43 		/* wait until we should try to get lock again */
44 		while (*a == 0)
45 			continue;
46 	} while (1);
47 }
48 
arch_spin_unlock(arch_spinlock_t * x)49 static inline void arch_spin_unlock(arch_spinlock_t *x)
50 {
51 	volatile unsigned int *a;
52 
53 	a = __ldcw_align(x);
54 	/* Release with ordered store. */
55 	__asm__ __volatile__("stw,ma %0,0(%1)"
56 		: : "r"(__ARCH_SPIN_LOCK_UNLOCKED_VAL), "r"(a) : "memory");
57 }
58 
arch_spin_trylock(arch_spinlock_t * x)59 static inline int arch_spin_trylock(arch_spinlock_t *x)
60 {
61 	volatile unsigned int *a;
62 	int lock_val;
63 
64 	a = __ldcw_align(x);
65 	lock_val = __ldcw(a);
66 	arch_spin_val_check(lock_val);
67 	return lock_val != 0;
68 }
69 
70 /*
71  * Read-write spinlocks, allowing multiple readers but only one writer.
72  * Unfair locking as Writers could be starved indefinitely by Reader(s)
73  *
74  * The spinlock itself is contained in @counter and access to it is
75  * serialized with @lock_mutex.
76  */
77 
78 /* 1 - lock taken successfully */
arch_read_trylock(arch_rwlock_t * rw)79 static inline int arch_read_trylock(arch_rwlock_t *rw)
80 {
81 	int ret = 0;
82 	unsigned long flags;
83 
84 	local_irq_save(flags);
85 	arch_spin_lock(&(rw->lock_mutex));
86 
87 	/*
88 	 * zero means writer holds the lock exclusively, deny Reader.
89 	 * Otherwise grant lock to first/subseq reader
90 	 */
91 	if (rw->counter > 0) {
92 		rw->counter--;
93 		ret = 1;
94 	}
95 
96 	arch_spin_unlock(&(rw->lock_mutex));
97 	local_irq_restore(flags);
98 
99 	return ret;
100 }
101 
102 /* 1 - lock taken successfully */
arch_write_trylock(arch_rwlock_t * rw)103 static inline int arch_write_trylock(arch_rwlock_t *rw)
104 {
105 	int ret = 0;
106 	unsigned long flags;
107 
108 	local_irq_save(flags);
109 	arch_spin_lock(&(rw->lock_mutex));
110 
111 	/*
112 	 * If reader(s) hold lock (lock < __ARCH_RW_LOCK_UNLOCKED__),
113 	 * deny writer. Otherwise if unlocked grant to writer
114 	 * Hence the claim that Linux rwlocks are unfair to writers.
115 	 * (can be starved for an indefinite time by readers).
116 	 */
117 	if (rw->counter == __ARCH_RW_LOCK_UNLOCKED__) {
118 		rw->counter = 0;
119 		ret = 1;
120 	}
121 	arch_spin_unlock(&(rw->lock_mutex));
122 	local_irq_restore(flags);
123 
124 	return ret;
125 }
126 
arch_read_lock(arch_rwlock_t * rw)127 static inline void arch_read_lock(arch_rwlock_t *rw)
128 {
129 	while (!arch_read_trylock(rw))
130 		cpu_relax();
131 }
132 
arch_write_lock(arch_rwlock_t * rw)133 static inline void arch_write_lock(arch_rwlock_t *rw)
134 {
135 	while (!arch_write_trylock(rw))
136 		cpu_relax();
137 }
138 
arch_read_unlock(arch_rwlock_t * rw)139 static inline void arch_read_unlock(arch_rwlock_t *rw)
140 {
141 	unsigned long flags;
142 
143 	local_irq_save(flags);
144 	arch_spin_lock(&(rw->lock_mutex));
145 	rw->counter++;
146 	arch_spin_unlock(&(rw->lock_mutex));
147 	local_irq_restore(flags);
148 }
149 
arch_write_unlock(arch_rwlock_t * rw)150 static inline void arch_write_unlock(arch_rwlock_t *rw)
151 {
152 	unsigned long flags;
153 
154 	local_irq_save(flags);
155 	arch_spin_lock(&(rw->lock_mutex));
156 	rw->counter = __ARCH_RW_LOCK_UNLOCKED__;
157 	arch_spin_unlock(&(rw->lock_mutex));
158 	local_irq_restore(flags);
159 }
160 
161 #endif /* __ASM_SPINLOCK_H */
162