include/asm-m68k/semaphore.h

   1 #ifndef _M68K_SEMAPHORE_H
   2 #define _M68K_SEMAPHORE_H
   3
   4 #include <linux/linkage.h>
   5 #include <linux/wait.h>
   6 #include <linux/spinlock.h>
   7
   8 #include <asm/system.h>
   9 #include <asm/atomic.h>
  10
  11 /*
  12  * SMP- and interrupt-safe semaphores..
  13  *
  14  * (C) Copyright 1996 Linus Torvalds
  15  *
  16  * m68k version by Andreas Schwab
  17  */
  18
  19 struct semaphore {
  20         atomic_t count;
  21         atomic_t waking;
  22         wait_queue_head_t wait;
  23 #if WAITQUEUE_DEBUG
  24         long __magic;
  25 #endif
  26 };
  27
  28 #if WAITQUEUE_DEBUG
  29 # define __SEM_DEBUG_INIT(name) \
  30                 , (long)&(name).__magic
  31 #else
  32 # define __SEM_DEBUG_INIT(name)
  33 #endif
  34
  35 #define __SEMAPHORE_INITIALIZER(name,count) \
  36 { ATOMIC_INIT(count), ATOMIC_INIT(0), __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
  37         __SEM_DEBUG_INIT(name) }
  38
  39 #define __MUTEX_INITIALIZER(name) \
  40         __SEMAPHORE_INITIALIZER(name,1)
  41
  42 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
  43         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
  44
  45 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
  46 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
  47
  48 extern inline void sema_init (struct semaphore *sem, int val)
  49 {
  50         *sem = (struct semaphore)__SEMAPHORE_INITIALIZER(*sem, val);
  51 }
  52
  53 static inline void init_MUTEX (struct semaphore *sem)
  54 {
  55         sema_init(sem, 1);
  56 }
  57
  58 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
  59 {
  60         sema_init(sem, 0);
  61 }
  62
  63 asmlinkage void __down_failed(void /* special register calling convention */);
  64 asmlinkage int  __down_failed_interruptible(void  /* params in registers */);
  65 asmlinkage int  __down_failed_trylock(void  /* params in registers */);
  66 asmlinkage void __up_wakeup(void /* special register calling convention */);
  67
  68 asmlinkage void __down(struct semaphore * sem);
  69 asmlinkage int  __down_interruptible(struct semaphore * sem);
  70 asmlinkage int  __down_trylock(struct semaphore * sem);
  71 asmlinkage void __up(struct semaphore * sem);
  72
  73 /*
  74  * This is ugly, but we want the default case to fall through.
  75  * "down_failed" is a special asm handler that calls the C
  76  * routine that actually waits. See arch/m68k/lib/semaphore.S
  77  */
  78 extern inline void down(struct semaphore * sem)
  79 {
  80         register struct semaphore *sem1 __asm__ ("%a1") = sem;
  81
  82 #if WAITQUEUE_DEBUG
  83         CHECK_MAGIC(sem->__magic);
  84 #endif
  85
  86         __asm__ __volatile__(
  87                 "| atomic down operation\n\t"
  88                 "subql #1,%0@\n\t"
  89                 "jmi 2f\n\t"
  90                 "1:\n"
  91                 ".section .text.lock,\"ax\"\n"
  92                 ".even\n"
  93                 "2:\tpea 1b\n\t"
  94                 "jbra __down_failed\n"
  95                 ".previous"
  96                 : /* no outputs */
  97                 : "a" (sem1)
  98                 : "memory");
  99 }
 100
 101 extern inline int down_interruptible(struct semaphore * sem)
 102 {
 103         register struct semaphore *sem1 __asm__ ("%a1") = sem;
 104         register int result __asm__ ("%d0");
 105
 106 #if WAITQUEUE_DEBUG
 107         CHECK_MAGIC(sem->__magic);
 108 #endif
 109
 110         __asm__ __volatile__(
 111                 "| atomic interruptible down operation\n\t"
 112                 "subql #1,%1@\n\t"
 113                 "jmi 2f\n\t"
 114                 "clrl %0\n"
 115                 "1:\n"
 116                 ".section .text.lock,\"ax\"\n"
 117                 ".even\n"
 118                 "2:\tpea 1b\n\t"
 119                 "jbra __down_failed_interruptible\n"
 120                 ".previous"
 121                 : "=d" (result)
 122                 : "a" (sem1)
 123                 : "%d0", "memory");
 124         return result;
 125 }
 126
 127 extern inline int down_trylock(struct semaphore * sem)
 128 {
 129         register struct semaphore *sem1 __asm__ ("%a1") = sem;
 130         register int result __asm__ ("%d0");
 131
 132 #if WAITQUEUE_DEBUG
 133         CHECK_MAGIC(sem->__magic);
 134 #endif
 135
 136         __asm__ __volatile__(
 137                 "| atomic down trylock operation\n\t"
 138                 "subql #1,%1@\n\t"
 139                 "jmi 2f\n\t"
 140                 "clrl %0\n"
 141                 "1:\n"
 142                 ".section .text.lock,\"ax\"\n"
 143                 ".even\n"
 144                 "2:\tpea 1b\n\t"
 145                 "jbra __down_failed_trylock\n"
 146                 ".previous"
 147                 : "=d" (result)
 148                 : "a" (sem1)
 149                 : "%d0", "memory");
 150         return result;
 151 }
 152
 153 /*
 154  * Note! This is subtle. We jump to wake people up only if
 155  * the semaphore was negative (== somebody was waiting on it).
 156  * The default case (no contention) will result in NO
 157  * jumps for both down() and up().
 158  */
 159 extern inline void up(struct semaphore * sem)
 160 {
 161         register struct semaphore *sem1 __asm__ ("%a1") = sem;
 162
 163 #if WAITQUEUE_DEBUG
 164         CHECK_MAGIC(sem->__magic);
 165 #endif
 166
 167         __asm__ __volatile__(
 168                 "| atomic up operation\n\t"
 169                 "addql #1,%0@\n\t"
 170                 "jle 2f\n"
 171                 "1:\n"
 172                 ".section .text.lock,\"ax\"\n"
 173                 ".even\n"
 174                 "2:\t"
 175                 "pea 1b\n\t"
 176                 "jbra __up_wakeup\n"
 177                 ".previous"
 178                 : /* no outputs */
 179                 : "a" (sem1)
 180                 : "memory");
 181 }
 182
 183 #endif