2 files changed, 103 insertions, 141 deletions

diff --git a/arch/tile/include/asm/spinlock_32.h b/arch/tile/include/asm/spinlock_32.h
index 88efdde8dd2b..a8f2c6e31a87 100644
--- a/arch/tile/include/asm/spinlock_32.h
+++ b/arch/tile/include/asm/spinlock_32.h
@@ -78,13 +78,6 @@ void arch_spin_unlock_wait(arch_spinlock_t *lock);
 #define _RD_COUNT_SHIFT 24
 #define _RD_COUNT_WIDTH 8
 
-/* Internal functions; do not use. */
-void arch_read_lock_slow(arch_rwlock_t *, u32);
-int arch_read_trylock_slow(arch_rwlock_t *);
-void arch_read_unlock_slow(arch_rwlock_t *);
-void arch_write_lock_slow(arch_rwlock_t *, u32);
-void arch_write_unlock_slow(arch_rwlock_t *, u32);
-
 /**
  * arch_read_can_lock() - would read_trylock() succeed?
  */
@@ -104,94 +97,32 @@ static inline int arch_write_can_lock(arch_rwlock_t *rwlock)
 /**
  * arch_read_lock() - acquire a read lock.
  */
-static inline void arch_read_lock(arch_rwlock_t *rwlock)
-{
-        u32 val = __insn_tns((int *)&rwlock->lock);
-        if (unlikely(val << _RD_COUNT_WIDTH)) {
-                arch_read_lock_slow(rwlock, val);
-                return;
-        }
-        rwlock->lock = val + (1 << _RD_COUNT_SHIFT);
-}
+void arch_read_lock(arch_rwlock_t *rwlock);
 
 /**
- * arch_read_lock() - acquire a write lock.
+ * arch_write_lock() - acquire a write lock.
  */
-static inline void arch_write_lock(arch_rwlock_t *rwlock)
-{
-        u32 val = __insn_tns((int *)&rwlock->lock);
-        if (unlikely(val != 0)) {
-                arch_write_lock_slow(rwlock, val);
-                return;
-        }
-        rwlock->lock = 1 << _WR_NEXT_SHIFT;
-}
+void arch_write_lock(arch_rwlock_t *rwlock);
 
 /**
  * arch_read_trylock() - try to acquire a read lock.
  */
-static inline int arch_read_trylock(arch_rwlock_t *rwlock)
-{
-        int locked;
-        u32 val = __insn_tns((int *)&rwlock->lock);
-        if (unlikely(val & 1))
-                return arch_read_trylock_slow(rwlock);
-        locked = (val << _RD_COUNT_WIDTH) == 0;
-        rwlock->lock = val + (locked << _RD_COUNT_SHIFT);
-        return locked;
-}
+int arch_read_trylock(arch_rwlock_t *rwlock);
 
 /**
  * arch_write_trylock() - try to acquire a write lock.
  */
-static inline int arch_write_trylock(arch_rwlock_t *rwlock)
-{
-        u32 val = __insn_tns((int *)&rwlock->lock);
-
-        /*
-         * If a tns is in progress, or there's a waiting or active locker,
-         * or active readers, we can't take the lock, so give up.
-         */
-        if (unlikely(val != 0)) {
-                if (!(val & 1))
-                        rwlock->lock = val;
-                return 0;
-        }
-
-        /* Set the "next" field to mark it locked. */
-        rwlock->lock = 1 << _WR_NEXT_SHIFT;
-        return 1;
-}
+int arch_write_trylock(arch_rwlock_t *rwlock);
 
 /**
  * arch_read_unlock() - release a read lock.
  */
-static inline void arch_read_unlock(arch_rwlock_t *rwlock)
-{
-        u32 val;
-        mb();  /* guarantee anything modified under the lock is visible */
-        val = __insn_tns((int *)&rwlock->lock);
-        if (unlikely(val & 1)) {
-                arch_read_unlock_slow(rwlock);
-                return;
-        }
-        rwlock->lock = val - (1 << _RD_COUNT_SHIFT);
-}
+void arch_read_unlock(arch_rwlock_t *rwlock);
 
 /**
  * arch_write_unlock() - release a write lock.
  */
-static inline void arch_write_unlock(arch_rwlock_t *rwlock)
-{
-        u32 val;
-        mb();  /* guarantee anything modified under the lock is visible */
-        val = __insn_tns((int *)&rwlock->lock);
-        if (unlikely(val != (1 << _WR_NEXT_SHIFT))) {
-                arch_write_unlock_slow(rwlock, val);
-                return;
-        }
-        rwlock->lock = 0;
-}
+void arch_write_unlock(arch_rwlock_t *rwlock);
 
 #define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
 #define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
diff --git a/arch/tile/lib/spinlock_32.c b/arch/tile/lib/spinlock_32.c
index 5cd1c4004eca..cb0999fb64b4 100644
--- a/arch/tile/lib/spinlock_32.c
+++ b/arch/tile/lib/spinlock_32.c
@@ -15,6 +15,7 @@
 #include <linux/spinlock.h>
 #include <linux/module.h>
 #include <asm/processor.h>
+#include <arch/spr_def.h>
 
 #include "spinlock_common.h"
 
@@ -91,75 +92,75 @@ EXPORT_SYMBOL(arch_spin_unlock_wait);
 #define RD_COUNT_MASK   ((1 << RD_COUNT_WIDTH) - 1)
 
 
-/* Lock the word, spinning until there are no tns-ers. */
-static inline u32 get_rwlock(arch_rwlock_t *rwlock)
-{
-        u32 iterations = 0;
-        for (;;) {
-                u32 val = __insn_tns((int *)&rwlock->lock);
-                if (unlikely(val & 1)) {
-                        delay_backoff(iterations++);
-                        continue;
-                }
-                return val;
-        }
-}
-
-int arch_read_trylock_slow(arch_rwlock_t *rwlock)
-{
-        u32 val = get_rwlock(rwlock);
-        int locked = (val << RD_COUNT_WIDTH) == 0;
-        rwlock->lock = val + (locked << RD_COUNT_SHIFT);
-        return locked;
-}
-EXPORT_SYMBOL(arch_read_trylock_slow);
-
-void arch_read_unlock_slow(arch_rwlock_t *rwlock)
-{
-        u32 val = get_rwlock(rwlock);
-        rwlock->lock = val - (1 << RD_COUNT_SHIFT);
-}
-EXPORT_SYMBOL(arch_read_unlock_slow);
-
-void arch_write_unlock_slow(arch_rwlock_t *rwlock, u32 val)
+/*
+ * We can get the read lock if everything but the reader bits (which
+ * are in the high part of the word) is zero, i.e. no active or
+ * waiting writers, no tns.
+ *
+ * We guard the tns/store-back with an interrupt critical section to
+ * preserve the semantic that the same read lock can be acquired in an
+ * interrupt context.
+ */
+inline int arch_read_trylock(arch_rwlock_t *rwlock)
 {
-        u32 eq, mask = 1 << WR_CURR_SHIFT;
-        while (unlikely(val & 1)) {
-                /* Limited backoff since we are the highest-priority task. */
-                relax(4);
-                val = __insn_tns((int *)&rwlock->lock);
+        u32 val;
+        __insn_mtspr(SPR_INTERRUPT_CRITICAL_SECTION, 1);
+        val = __insn_tns((int *)&rwlock->lock);
+        if (likely((val << _RD_COUNT_WIDTH) == 0)) {
+                val += 1 << RD_COUNT_SHIFT;
+                rwlock->lock = val;
+                __insn_mtspr(SPR_INTERRUPT_CRITICAL_SECTION, 0);