arch/parisc/include/asm/spinlock.h

   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
   9 static 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
  19 static 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
  37 static 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
  46 static 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 */
  73 static  __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 */
  85 static  __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 */
  97 static __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 */
 123 static __inline__ void arch_write_lock(arch_rwlock_t *rw)
 124 {
 125         unsigned long flags;
 126 retry:
 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
 145 static __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 */
 153 static __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  */
 177 static __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  */
 186 static __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 */