arch/parisc/include/asm/spinlock.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __ASM_SPINLOCK_H
   3 #define __ASM_SPINLOCK_H
   4
   5 #include <asm/barrier.h>
   6 #include <asm/ldcw.h>
   7 #include <asm/processor.h>
   8 #include <asm/spinlock_types.h>
   9
  10 static inline int arch_spin_is_locked(arch_spinlock_t *x)
  11 {
  12         volatile unsigned int *a = __ldcw_align(x);
  13         return *a == 0;
  14 }
  15
  16 #define arch_spin_lock(lock) arch_spin_lock_flags(lock, 0)
  17
  18 static inline void arch_spin_lock_flags(arch_spinlock_t *x,
  19                                          unsigned long flags)
  20 {
  21         volatile unsigned int *a;
  22
  23         a = __ldcw_align(x);
  24         while (__ldcw(a) == 0)
  25                 while (*a == 0)
  26                         if (flags & PSW_SM_I) {
  27                                 local_irq_enable();
  28                                 cpu_relax();
  29                                 local_irq_disable();
  30                         } else
  31                                 cpu_relax();
  32 }
  33 #define arch_spin_lock_flags arch_spin_lock_flags
  34
  35 static inline void arch_spin_unlock(arch_spinlock_t *x)
  36 {
  37         volatile unsigned int *a;
  38
  39         a = __ldcw_align(x);
  40         /* Release with ordered store. */
  41         __asm__ __volatile__("stw,ma %0,0(%1)" : : "r"(1), "r"(a) : "memory");
  42 }
  43
  44 static inline int arch_spin_trylock(arch_spinlock_t *x)
  45 {
  46         volatile unsigned int *a;
  47         int ret;
  48
  49         a = __ldcw_align(x);
  50         ret = __ldcw(a) != 0;
  51
  52         return ret;
  53 }
  54
  55 /*
  56  * Read-write spinlocks, allowing multiple readers but only one writer.
  57  * Linux rwlocks are unfair to writers; they can be starved for an indefinite
  58  * time by readers.  With care, they can also be taken in interrupt context.
  59  *
  60  * In the PA-RISC implementation, we have a spinlock and a counter.
  61  * Readers use the lock to serialise their access to the counter (which
  62  * records how many readers currently hold the lock).
  63  * Writers hold the spinlock, preventing any readers or other writers from
  64  * grabbing the rwlock.
  65  */
  66
  67 /* Note that we have to ensure interrupts are disabled in case we're
  68  * interrupted by some other code that wants to grab the same read lock */
  69 static  __inline__ void arch_read_lock(arch_rwlock_t *rw)
  70 {
  71         unsigned long flags;
  72         local_irq_save(flags);
  73         arch_spin_lock_flags(&rw->lock, flags);
  74         rw->counter++;
  75         arch_spin_unlock(&rw->lock);
  76         local_irq_restore(flags);
  77 }
  78
  79 /* Note that we have to ensure interrupts are disabled in case we're
  80  * interrupted by some other code that wants to grab the same read lock */
  81 static  __inline__ void arch_read_unlock(arch_rwlock_t *rw)
  82 {
  83         unsigned long flags;
  84         local_irq_save(flags);
  85         arch_spin_lock_flags(&rw->lock, flags);
  86         rw->counter--;
  87         arch_spin_unlock(&rw->lock);
  88         local_irq_restore(flags);
  89 }
  90
  91 /* Note that we have to ensure interrupts are disabled in case we're
  92  * interrupted by some other code that wants to grab the same read lock */
  93 static __inline__ int arch_read_trylock(arch_rwlock_t *rw)
  94 {
  95         unsigned long flags;
  96  retry:
  97         local_irq_save(flags);
  98         if (arch_spin_trylock(&rw->lock)) {
  99                 rw->counter++;
 100                 arch_spin_unlock(&rw->lock);
 101                 local_irq_restore(flags);
 102                 return 1;
 103         }
 104
 105         local_irq_restore(flags);
 106         /* If write-locked, we fail to acquire the lock */
 107         if (rw->counter < 0)
 108                 return 0;
 109
 110         /* Wait until we have a realistic chance at the lock */
 111         while (arch_spin_is_locked(&rw->lock) && rw->counter >= 0)
 112                 cpu_relax();
 113
 114         goto retry;
 115 }
 116
 117 /* Note that we have to ensure interrupts are disabled in case we're
 118  * interrupted by some other code that wants to read_trylock() this lock */
 119 static __inline__ void arch_write_lock(arch_rwlock_t *rw)
 120 {
 121         unsigned long flags;
 122 retry:
 123         local_irq_save(flags);
 124         arch_spin_lock_flags(&rw->lock, flags);
 125
 126         if (rw->counter != 0) {
 127                 arch_spin_unlock(&rw->lock);
 128                 local_irq_restore(flags);
 129
 130                 while (rw->counter != 0)
 131                         cpu_relax();
 132
 133                 goto retry;
 134         }
 135
 136         rw->counter = -1; /* mark as write-locked */
 137         mb();
 138         local_irq_restore(flags);
 139 }
 140
 141 static __inline__ void arch_write_unlock(arch_rwlock_t *rw)
 142 {
 143         rw->counter = 0;
 144         arch_spin_unlock(&rw->lock);
 145 }
 146
 147 /* Note that we have to ensure interrupts are disabled in case we're
 148  * interrupted by some other code that wants to read_trylock() this lock */
 149 static __inline__ int arch_write_trylock(arch_rwlock_t *rw)
 150 {
 151         unsigned long flags;
 152         int result = 0;
 153
 154         local_irq_save(flags);
 155         if (arch_spin_trylock(&rw->lock)) {
 156                 if (rw->counter == 0) {
 157                         rw->counter = -1;
 158                         result = 1;
 159                 } else {
 160                         /* Read-locked.  Oh well. */
 161                         arch_spin_unlock(&rw->lock);
 162                 }
 163         }
 164         local_irq_restore(flags);
 165
 166         return result;
 167 }
 168
 169 #endif /* __ASM_SPINLOCK_H */