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 but only one writer.
  60  * The spinlock is held by the writer, preventing any readers or other
  61  * writers from grabbing the rwlock.  Readers use the lock to serialise their
  62  * access to the counter (which records how many readers currently hold the
  63  * lock).  Linux rwlocks are unfair to writers; they can be starved for
  64  * an indefinite time by readers.  They can also be taken in interrupt context,
  65  * so we have to disable interrupts when acquiring the spin lock to be sure
  66  * that an interrupting reader doesn't get an inconsistent view of the lock.
  67  */
  68
  69 static  __inline__ void __raw_read_lock(raw_rwlock_t *rw)
  70 {
  71         unsigned long flags;
  72         local_irq_save(flags);
  73         __raw_spin_lock(&rw->lock);
  74         rw->counter++;
  75         __raw_spin_unlock(&rw->lock);
  76         local_irq_restore(flags);
  77 }
  78
  79 static  __inline__ void __raw_read_unlock(raw_rwlock_t *rw)
  80 {
  81         unsigned long flags;
  82         local_irq_save(flags);
  83         __raw_spin_lock(&rw->lock);
  84         rw->counter--;
  85         __raw_spin_unlock(&rw->lock);
  86         local_irq_restore(flags);
  87 }
  88
  89 static __inline__ int __raw_read_trylock(raw_rwlock_t *rw)
  90 {
  91         unsigned long flags;
  92  retry:
  93         local_irq_save(flags);
  94         if (__raw_spin_trylock(&rw->lock)) {
  95                 rw->counter++;
  96                 __raw_spin_unlock(&rw->lock);
  97                 local_irq_restore(flags);
  98                 return 1;
  99         }
 100
 101         local_irq_restore(flags);
 102         /* If write-locked, we fail to acquire the lock */
 103         if (rw->counter < 0)
 104                 return 0;
 105
 106         /* Wait until we have a realistic chance at the lock */
 107         while (__raw_spin_is_locked(&rw->lock) && rw->counter >= 0)
 108                 cpu_relax();
 109
 110         goto retry;
 111 }
 112
 113 static __inline__ void __raw_write_lock(raw_rwlock_t *rw)
 114 {
 115         unsigned long flags;
 116 retry:
 117         local_irq_save(flags);
 118         __raw_spin_lock(&rw->lock);
 119
 120         if (rw->counter != 0) {
 121                 __raw_spin_unlock(&rw->lock);
 122                 local_irq_restore(flags);
 123
 124                 while (rw->counter != 0)
 125                         cpu_relax();
 126
 127                 goto retry;
 128         }
 129
 130         rw->counter = -1; /* mark as write-locked */
 131         mb();
 132         local_irq_restore(flags);
 133 }
 134
 135 static __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
 136 {
 137         rw->counter = 0;
 138         __raw_spin_unlock(&rw->lock);
 139 }
 140
 141 static __inline__ int __raw_write_trylock(raw_rwlock_t *rw)
 142 {
 143         unsigned long flags;
 144         int result = 0;
 145
 146         local_irq_save(flags);
 147         if (__raw_spin_trylock(&rw->lock)) {
 148                 if (rw->counter == 0) {
 149                         rw->counter = -1;
 150                         result = 1;
 151                 } else {
 152                         /* Read-locked.  Oh well. */
 153                         __raw_spin_unlock(&rw->lock);
 154                 }
 155         }
 156         local_irq_restore(flags);
 157
 158         return result;
 159 }
 160
 161 /*
 162  * read_can_lock - would read_trylock() succeed?
 163  * @lock: the rwlock in question.
 164  */
 165 static __inline__ int __raw_read_can_lock(raw_rwlock_t *rw)
 166 {
 167         return rw->counter >= 0;
 168 }
 169
 170 /*
 171  * write_can_lock - would write_trylock() succeed?
 172  * @lock: the rwlock in question.
 173  */
 174 static __inline__ int __raw_write_can_lock(raw_rwlock_t *rw)
 175 {
 176         return !rw->counter;
 177 }
 178
 179 #define _raw_spin_relax(lock)   cpu_relax()
 180 #define _raw_read_relax(lock)   cpu_relax()
 181 #define _raw_write_relax(lock)  cpu_relax()
 182
 183 #endif /* __ASM_SPINLOCK_H */