kernel/arch/metag/include/asm/global_lock.h

   1 #ifndef __ASM_METAG_GLOBAL_LOCK_H
   2 #define __ASM_METAG_GLOBAL_LOCK_H
   3
   4 #include <asm/metag_mem.h>
   5
   6 /**
   7  * __global_lock1() - Acquire global voluntary lock (LOCK1).
   8  * @flags:      Variable to store flags into.
   9  *
  10  * Acquires the Meta global voluntary lock (LOCK1), also taking care to disable
  11  * all triggers so we cannot be interrupted, and to enforce a compiler barrier
  12  * so that the compiler cannot reorder memory accesses across the lock.
  13  *
  14  * No other hardware thread will be able to acquire the voluntary or exclusive
  15  * locks until the voluntary lock is released with @__global_unlock1, but they
  16  * may continue to execute as long as they aren't trying to acquire either of
  17  * the locks.
  18  */
  19 #define __global_lock1(flags) do {                                      \
  20         unsigned int __trval;                                           \
  21         asm volatile("MOV       %0,#0\n\t"                              \
  22                      "SWAP      %0,TXMASKI\n\t"                         \
  23                      "LOCK1"                                            \
  24                      : "=r" (__trval)                                   \
  25                      :                                                  \
  26                      : "memory");                                       \
  27         (flags) = __trval;                                              \
  28 } while (0)
  29
  30 /**
  31  * __global_unlock1() - Release global voluntary lock (LOCK1).
  32  * @flags:      Variable to restore flags from.
  33  *
  34  * Releases the Meta global voluntary lock (LOCK1) acquired with
  35  * @__global_lock1, also taking care to re-enable triggers, and to enforce a
  36  * compiler barrier so that the compiler cannot reorder memory accesses across
  37  * the unlock.
  38  *
  39  * This immediately allows another hardware thread to acquire the voluntary or
  40  * exclusive locks.
  41  */
  42 #define __global_unlock1(flags) do {                                    \
  43         unsigned int __trval = (flags);                                 \
  44         asm volatile("LOCK0\n\t"                                        \
  45                      "MOV       TXMASKI,%0"                             \
  46                      :                                                  \
  47                      : "r" (__trval)                                    \
  48                      : "memory");                                       \
  49 } while (0)
  50
  51 /**
  52  * __global_lock2() - Acquire global exclusive lock (LOCK2).
  53  * @flags:      Variable to store flags into.
  54  *
  55  * Acquires the Meta global voluntary lock and global exclusive lock (LOCK2),
  56  * also taking care to disable all triggers so we cannot be interrupted, to take
  57  * the atomic lock (system event) and to enforce a compiler barrier so that the
  58  * compiler cannot reorder memory accesses across the lock.
  59  *
  60  * No other hardware thread will be able to execute code until the locks are
  61  * released with @__global_unlock2.
  62  */
  63 #define __global_lock2(flags) do {                                      \
  64         unsigned int __trval;                                           \
  65         unsigned int __aloc_hi = LINSYSEVENT_WR_ATOMIC_LOCK & 0xFFFF0000; \
  66         asm volatile("MOV       %0,#0\n\t"                              \
  67                      "SWAP      %0,TXMASKI\n\t"                         \
  68                      "LOCK2\n\t"                                        \
  69                      "SETD      [%1+#0x40],D1RtP"                       \
  70                      : "=r&" (__trval)                                  \
  71                      : "u" (__aloc_hi)                                  \
  72                      : "memory");                                       \
  73         (flags) = __trval;                                              \
  74 } while (0)
  75
  76 /**
  77  * __global_unlock2() - Release global exclusive lock (LOCK2).
  78  * @flags:      Variable to restore flags from.
  79  *
  80  * Releases the Meta global exclusive lock (LOCK2) and global voluntary lock
  81  * acquired with @__global_lock2, also taking care to release the atomic lock
  82  * (system event), re-enable triggers, and to enforce a compiler barrier so that
  83  * the compiler cannot reorder memory accesses across the unlock.
  84  *
  85  * This immediately allows other hardware threads to continue executing and one
  86  * of them to acquire locks.
  87  */
  88 #define __global_unlock2(flags) do {                                    \
  89         unsigned int __trval = (flags);                                 \
  90         unsigned int __alock_hi = LINSYSEVENT_WR_ATOMIC_LOCK & 0xFFFF0000; \
  91         asm volatile("SETD      [%1+#0x00],D1RtP\n\t"                   \
  92                      "LOCK0\n\t"                                        \
  93                      "MOV       TXMASKI,%0"                             \
  94                      :                                                  \
  95                      : "r" (__trval),                                   \
  96                        "u" (__alock_hi)                                 \
  97                      : "memory");                                       \
  98 } while (0)
  99
 100 #endif /* __ASM_METAG_GLOBAL_LOCK_H */