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