]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - include/asm-parisc/spinlock.h
1 #ifndef __ASM_SPINLOCK_H
2 #define __ASM_SPINLOCK_H
4 #include <asm/system.h>
5 #include <asm/processor.h>
6 #include <asm/spinlock_types.h>
8 /* Note that PA-RISC has to use `1' to mean unlocked and `0' to mean locked
9 * since it only has load-and-zero. Moreover, at least on some PA processors,
10 * the semaphore address has to be 16-byte aligned.
13 static inline int __raw_spin_is_locked(raw_spinlock_t
*x
)
15 volatile unsigned int *a
= __ldcw_align(x
);
19 #define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
20 #define __raw_spin_unlock_wait(x) \
21 do { cpu_relax(); } while (__raw_spin_is_locked(x))
23 static inline void __raw_spin_lock(raw_spinlock_t
*x
)
25 volatile unsigned int *a
;
29 while (__ldcw(a
) == 0)
34 static inline void __raw_spin_unlock(raw_spinlock_t
*x
)
36 volatile unsigned int *a
;
43 static inline int __raw_spin_trylock(raw_spinlock_t
*x
)
45 volatile unsigned int *a
;
57 * Read-write spinlocks, allowing multiple readers
58 * but only one writer.
61 #define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
63 /* read_lock, read_unlock are pretty straightforward. Of course it somehow
64 * sucks we end up saving/restoring flags twice for read_lock_irqsave aso. */
66 static __inline__
void __raw_read_lock(raw_rwlock_t
*rw
)
69 local_irq_save(flags
);
70 __raw_spin_lock(&rw
->lock
);
74 __raw_spin_unlock(&rw
->lock
);
75 local_irq_restore(flags
);
78 static __inline__
void __raw_read_unlock(raw_rwlock_t
*rw
)
81 local_irq_save(flags
);
82 __raw_spin_lock(&rw
->lock
);
86 __raw_spin_unlock(&rw
->lock
);
87 local_irq_restore(flags
);
90 /* write_lock is less trivial. We optimistically grab the lock and check
91 * if we surprised any readers. If so we release the lock and wait till
92 * they're all gone before trying again
94 * Also note that we don't use the _irqsave / _irqrestore suffixes here.
95 * If we're called with interrupts enabled and we've got readers (or other
96 * writers) in interrupt handlers someone fucked up and we'd dead-lock
97 * sooner or later anyway. prumpf */
99 static __inline__
void __raw_write_lock(raw_rwlock_t
*rw
)
102 __raw_spin_lock(&rw
->lock
);
104 if(rw
->counter
!= 0) {
105 /* this basically never happens */
106 __raw_spin_unlock(&rw
->lock
);
108 while (rw
->counter
!= 0)
114 /* got it. now leave without unlocking */
115 rw
->counter
= -1; /* remember we are locked */
118 /* write_unlock is absolutely trivial - we don't have to wait for anything */
120 static __inline__
void __raw_write_unlock(raw_rwlock_t
*rw
)
123 __raw_spin_unlock(&rw
->lock
);
126 static __inline__
int __raw_write_trylock(raw_rwlock_t
*rw
)
128 __raw_spin_lock(&rw
->lock
);
129 if (rw
->counter
!= 0) {
130 /* this basically never happens */
131 __raw_spin_unlock(&rw
->lock
);
136 /* got it. now leave without unlocking */
137 rw
->counter
= -1; /* remember we are locked */
141 static __inline__
int __raw_is_read_locked(raw_rwlock_t
*rw
)
143 return rw
->counter
> 0;
146 static __inline__
int __raw_is_write_locked(raw_rwlock_t
*rw
)
148 return rw
->counter
< 0;
151 #endif /* __ASM_SPINLOCK_H */