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