include/asm-parisc/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 __raw_spin_is_locked(raw_spinlock_t *x)
   9 {
  10         volatile unsigned int *a = __ldcw_align(x);
  11         return *a == 0;
  12 }
  13
  14 #define __raw_spin_lock(lock) __raw_spin_lock_flags(lock, 0)
  15 #define __raw_spin_unlock_wait(x) \
  16                 do { cpu_relax(); } while (__raw_spin_is_locked(x))
  17
  18 static inline void __raw_spin_lock_flags(raw_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 __raw_spin_unlock(raw_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 __raw_spin_trylock(raw_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
  60  * but only one writer.
  61  */
  62
  63 #define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
  64
  65 /* read_lock, read_unlock are pretty straightforward.  Of course it somehow
  66  * sucks we end up saving/restoring flags twice for read_lock_irqsave aso. */
  67
  68 static  __inline__ void __raw_read_lock(raw_rwlock_t *rw)
  69 {
  70         __raw_spin_lock(&rw->lock);
  71
  72         rw->counter++;
  73
  74         __raw_spin_unlock(&rw->lock);
  75 }
  76
  77 static  __inline__ void __raw_read_unlock(raw_rwlock_t *rw)
  78 {
  79         __raw_spin_lock(&rw->lock);
  80
  81         rw->counter--;
  82
  83         __raw_spin_unlock(&rw->lock);
  84 }
  85
  86 /* write_lock is less trivial.  We optimistically grab the lock and check
  87  * if we surprised any readers.  If so we release the lock and wait till
  88  * they're all gone before trying again
  89  *
  90  * Also note that we don't use the _irqsave / _irqrestore suffixes here.
  91  * If we're called with interrupts enabled and we've got readers (or other
  92  * writers) in interrupt handlers someone fucked up and we'd dead-lock
  93  * sooner or later anyway.   prumpf */
  94
  95 static  __inline__ void __raw_write_lock(raw_rwlock_t *rw)
  96 {
  97 retry:
  98         __raw_spin_lock(&rw->lock);
  99
 100         if(rw->counter != 0) {
 101                 /* this basically never happens */
 102                 __raw_spin_unlock(&rw->lock);
 103
 104                 while (rw->counter != 0)
 105                         cpu_relax();
 106
 107                 goto retry;
 108         }
 109
 110         /* got it.  now leave without unlocking */
 111         rw->counter = -1; /* remember we are locked */
 112 }
 113
 114 /* write_unlock is absolutely trivial - we don't have to wait for anything */
 115
 116 static  __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
 117 {
 118         rw->counter = 0;
 119         __raw_spin_unlock(&rw->lock);
 120 }
 121
 122 static  __inline__ int __raw_write_trylock(raw_rwlock_t *rw)
 123 {
 124         __raw_spin_lock(&rw->lock);
 125         if (rw->counter != 0) {
 126                 /* this basically never happens */
 127                 __raw_spin_unlock(&rw->lock);
 128
 129                 return 0;
 130         }
 131
 132         /* got it.  now leave without unlocking */
 133         rw->counter = -1; /* remember we are locked */
 134         return 1;
 135 }
 136
 137 /*
 138  * read_can_lock - would read_trylock() succeed?
 139  * @lock: the rwlock in question.
 140  */
 141 static __inline__ int __raw_read_can_lock(raw_rwlock_t *rw)
 142 {
 143         return rw->counter >= 0;
 144 }
 145
 146 /*
 147  * write_can_lock - would write_trylock() succeed?
 148  * @lock: the rwlock in question.
 149  */
 150 static __inline__ int __raw_write_can_lock(raw_rwlock_t *rw)
 151 {
 152         return !rw->counter;
 153 }
 154
 155 #endif /* __ASM_SPINLOCK_H */