Add the rt linux 4.1.3-rt3 as base

[kvmfornfv.git] / kernel / arch / sh / include / asm / mutex-llsc.h

diff --git a/kernel/arch/sh/include/asm/mutex-llsc.h b/kernel/arch/sh/include/asm/mutex-llsc.h
new file mode 100644 (file)
index 0000000..dad29b6
--- /dev/null
+++ b/kernel/arch/sh/include/asm/mutex-llsc.h
@@ -0,0 +1,109 @@
+/*
+ * arch/sh/include/asm/mutex-llsc.h
+ *
+ * SH-4A optimized mutex locking primitives
+ *
+ * Please look into asm-generic/mutex-xchg.h for a formal definition.
+ */
+#ifndef __ASM_SH_MUTEX_LLSC_H
+#define __ASM_SH_MUTEX_LLSC_H
+
+/*
+ * Attempting to lock a mutex on SH4A is done like in ARMv6+ architecure.
+ * with a bastardized atomic decrement (it is not a reliable atomic decrement
+ * but it satisfies the defined semantics for our purpose, while being
+ * smaller and faster than a real atomic decrement or atomic swap.
+ * The idea is to attempt  decrementing the lock value only once. If once
+ * decremented it isn't zero, or if its store-back fails due to a dispute
+ * on the exclusive store, we simply bail out immediately through the slow
+ * path where the lock will be reattempted until it succeeds.
+ */
+static inline void
+__mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *))
+{
+       int __done, __res;
+
+       __asm__ __volatile__ (
+               "movli.l        @%2, %0 \n"
+               "add            #-1, %0 \n"
+               "movco.l        %0, @%2 \n"
+               "movt           %1      \n"
+               : "=&z" (__res), "=&r" (__done)
+               : "r" (&(count)->counter)
+               : "t");
+
+       if (unlikely(!__done || __res != 0))
+               fail_fn(count);
+}
+
+static inline int
+__mutex_fastpath_lock_retval(atomic_t *count)
+{
+       int __done, __res;
+
+       __asm__ __volatile__ (
+               "movli.l        @%2, %0 \n"
+               "add            #-1, %0 \n"
+               "movco.l        %0, @%2 \n"
+               "movt           %1      \n"
+               : "=&z" (__res), "=&r" (__done)
+               : "r" (&(count)->counter)
+               : "t");
+
+       if (unlikely(!__done || __res != 0))
+               __res = -1;
+
+       return __res;
+}
+
+static inline void
+__mutex_fastpath_unlock(atomic_t *count, void (*fail_fn)(atomic_t *))
+{
+       int __done, __res;
+
+       __asm__ __volatile__ (
+               "movli.l        @%2, %0 \n\t"
+               "add            #1, %0  \n\t"
+               "movco.l        %0, @%2 \n\t"
+               "movt           %1      \n\t"
+               : "=&z" (__res), "=&r" (__done)
+               : "r" (&(count)->counter)
+               : "t");
+
+       if (unlikely(!__done || __res <= 0))
+               fail_fn(count);
+}
+
+/*
+ * If the unlock was done on a contended lock, or if the unlock simply fails
+ * then the mutex remains locked.
+ */
+#define __mutex_slowpath_needs_to_unlock()     1
+
+/*
+ * For __mutex_fastpath_trylock we do an atomic decrement and check the
+ * result and put it in the __res variable.
+ */
+static inline int
+__mutex_fastpath_trylock(atomic_t *count, int (*fail_fn)(atomic_t *))
+{
+       int __res, __orig;
+
+       __asm__ __volatile__ (
+               "1: movli.l     @%2, %0         \n\t"
+               "dt             %0              \n\t"
+               "movco.l        %0,@%2          \n\t"
+               "bf             1b              \n\t"
+               "cmp/eq         #0,%0           \n\t"
+               "bt             2f              \n\t"
+               "mov            #0, %1          \n\t"
+               "bf             3f              \n\t"
+               "2: mov         #1, %1          \n\t"
+               "3:                             "
+               : "=&z" (__orig), "=&r" (__res)
+               : "r" (&count->counter)
+               : "t");
+
+       return __res;
+}
+#endif /* __ASM_SH_MUTEX_LLSC_H */