release/src-rt-6.x/linux/linux-2.6/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  * 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(raw_rwlock_t *rw)
  73 {
  74         unsigned long flags;
  75         local_irq_save(flags);
  76         __raw_spin_lock_flags(&rw->lock, flags);
  77         rw->counter++;
  78         __raw_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(raw_rwlock_t *rw)
  85 {
  86         unsigned long flags;
  87         local_irq_save(flags);
  88         __raw_spin_lock_flags(&rw->lock, flags);
  89         rw->counter--;
  90         __raw_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(raw_rwlock_t *rw)
  97 {
  98         unsigned long flags;
  99  retry:
 100         local_irq_save(flags);
 101         if (__raw_spin_trylock(&rw->lock)) {
 102                 rw->counter++;
 103                 __raw_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 (__raw_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(raw_rwlock_t *rw)
 123 {
 124         unsigned long flags;
 125 retry:
 126         local_irq_save(flags);
 127         __raw_spin_lock_flags(&rw->lock, flags);
 128
 129         if (rw->counter != 0) {
 130                 __raw_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(raw_rwlock_t *rw)
 145 {
 146         rw->counter = 0;
 147         __raw_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(raw_rwlock_t *rw)
 153 {
 154         unsigned long flags;
 155         int result = 0;
 156
 157         local_irq_save(flags);
 158         if (__raw_spin_trylock(&rw->lock)) {
 159                 if (rw->counter == 0) {
 160                         rw->counter = -1;
 161                         result = 1;
 162                 } else {
 163                         /* Read-locked.  Oh well. */
 164                         __raw_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(raw_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(raw_rwlock_t *rw)
 186 {
 187         return !rw->counter;
 188 }
 189
 190 #define _raw_spin_relax(lock)   cpu_relax()
 191 #define _raw_read_relax(lock)   cpu_relax()
 192 #define _raw_write_relax(lock)  cpu_relax()
 193
 194 #endif /* __ASM_SPINLOCK_H */