]>
Commit | Line | Data |
---|---|---|
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 | ||
10 | static inline int arch_spin_is_locked(arch_spinlock_t *x) | |
11 | { | |
12 | volatile unsigned int *a = __ldcw_align(x); | |
13 | return *a == 0; | |
14 | } | |
15 | ||
16 | #define arch_spin_lock(lock) arch_spin_lock_flags(lock, 0) | |
17 | ||
18 | static inline void arch_spin_lock_flags(arch_spinlock_t *x, | |
19 | unsigned long flags) | |
20 | { | |
21 | volatile unsigned int *a; | |
22 | ||
23 | a = __ldcw_align(x); | |
24 | while (__ldcw(a) == 0) | |
25 | while (*a == 0) | |
26 | if (flags & PSW_SM_I) { | |
27 | local_irq_enable(); | |
28 | cpu_relax(); | |
29 | local_irq_disable(); | |
30 | } else | |
31 | cpu_relax(); | |
32 | } | |
33 | #define arch_spin_lock_flags arch_spin_lock_flags | |
34 | ||
35 | static inline void arch_spin_unlock(arch_spinlock_t *x) | |
36 | { | |
37 | volatile unsigned int *a; | |
38 | ||
39 | a = __ldcw_align(x); | |
40 | mb(); | |
41 | *a = 1; | |
42 | } | |
43 | ||
44 | static inline int arch_spin_trylock(arch_spinlock_t *x) | |
45 | { | |
46 | volatile unsigned int *a; | |
47 | int ret; | |
48 | ||
49 | a = __ldcw_align(x); | |
50 | ret = __ldcw(a) != 0; | |
51 | ||
52 | return ret; | |
53 | } | |
54 | ||
55 | /* | |
56 | * Read-write spinlocks, allowing multiple readers but only one writer. | |
57 | * Linux rwlocks are unfair to writers; they can be starved for an indefinite | |
58 | * time by readers. With care, they can also be taken in interrupt context. | |
59 | * | |
60 | * In the PA-RISC implementation, we have a spinlock and a counter. | |
61 | * Readers use the lock to serialise their access to the counter (which | |
62 | * records how many readers currently hold the lock). | |
63 | * Writers hold the spinlock, preventing any readers or other writers from | |
64 | * grabbing the rwlock. | |
65 | */ | |
66 | ||
67 | /* Note that we have to ensure interrupts are disabled in case we're | |
68 | * interrupted by some other code that wants to grab the same read lock */ | |
69 | static __inline__ void arch_read_lock(arch_rwlock_t *rw) | |
70 | { | |
71 | unsigned long flags; | |
72 | local_irq_save(flags); | |
73 | arch_spin_lock_flags(&rw->lock, flags); | |
74 | rw->counter++; | |
75 | arch_spin_unlock(&rw->lock); | |
76 | local_irq_restore(flags); | |
77 | } | |
78 | ||
79 | /* Note that we have to ensure interrupts are disabled in case we're | |
80 | * interrupted by some other code that wants to grab the same read lock */ | |
81 | static __inline__ void arch_read_unlock(arch_rwlock_t *rw) | |
82 | { | |
83 | unsigned long flags; | |
84 | local_irq_save(flags); | |
85 | arch_spin_lock_flags(&rw->lock, flags); | |
86 | rw->counter--; | |
87 | arch_spin_unlock(&rw->lock); | |
88 | local_irq_restore(flags); | |
89 | } | |
90 | ||
91 | /* Note that we have to ensure interrupts are disabled in case we're | |
92 | * interrupted by some other code that wants to grab the same read lock */ | |
93 | static __inline__ int arch_read_trylock(arch_rwlock_t *rw) | |
94 | { | |
95 | unsigned long flags; | |
96 | retry: | |
97 | local_irq_save(flags); | |
98 | if (arch_spin_trylock(&rw->lock)) { | |
99 | rw->counter++; | |
100 | arch_spin_unlock(&rw->lock); | |
101 | local_irq_restore(flags); | |
102 | return 1; | |
103 | } | |
104 | ||
105 | local_irq_restore(flags); | |
106 | /* If write-locked, we fail to acquire the lock */ | |
107 | if (rw->counter < 0) | |
108 | return 0; | |
109 | ||
110 | /* Wait until we have a realistic chance at the lock */ | |
111 | while (arch_spin_is_locked(&rw->lock) && rw->counter >= 0) | |
112 | cpu_relax(); | |
113 | ||
114 | goto retry; | |
115 | } | |
116 | ||
117 | /* Note that we have to ensure interrupts are disabled in case we're | |
118 | * interrupted by some other code that wants to read_trylock() this lock */ | |
119 | static __inline__ void arch_write_lock(arch_rwlock_t *rw) | |
120 | { | |
121 | unsigned long flags; | |
122 | retry: | |
123 | local_irq_save(flags); | |
124 | arch_spin_lock_flags(&rw->lock, flags); | |
125 | ||
126 | if (rw->counter != 0) { | |
127 | arch_spin_unlock(&rw->lock); | |
128 | local_irq_restore(flags); | |
129 | ||
130 | while (rw->counter != 0) | |
131 | cpu_relax(); | |
132 | ||
133 | goto retry; | |
134 | } | |
135 | ||
136 | rw->counter = -1; /* mark as write-locked */ | |
137 | mb(); | |
138 | local_irq_restore(flags); | |
139 | } | |
140 | ||
141 | static __inline__ void arch_write_unlock(arch_rwlock_t *rw) | |
142 | { | |
143 | rw->counter = 0; | |
144 | arch_spin_unlock(&rw->lock); | |
145 | } | |
146 | ||
147 | /* Note that we have to ensure interrupts are disabled in case we're | |
148 | * interrupted by some other code that wants to read_trylock() this lock */ | |
149 | static __inline__ int arch_write_trylock(arch_rwlock_t *rw) | |
150 | { | |
151 | unsigned long flags; | |
152 | int result = 0; | |
153 | ||
154 | local_irq_save(flags); | |
155 | if (arch_spin_trylock(&rw->lock)) { | |
156 | if (rw->counter == 0) { | |
157 | rw->counter = -1; | |
158 | result = 1; | |
159 | } else { | |
160 | /* Read-locked. Oh well. */ | |
161 | arch_spin_unlock(&rw->lock); | |
162 | } | |
163 | } | |
164 | local_irq_restore(flags); | |
165 | ||
166 | return result; | |
167 | } | |
168 | ||
169 | #endif /* __ASM_SPINLOCK_H */ |