include/asm-parisc/semaphore.h

   1 /*    SMP- and interrupt-safe semaphores.
   2  *    PA-RISC version by Matthew Wilcox
   3  *
   4  *    Linux/PA-RISC Project (http://www.parisc-linux.org/)
   5  *    Copyright (C) 1996 Linus Torvalds
   6  *    Copyright (C) 1999-2001 Matthew Wilcox < willy at debian d0T org >
   7  *    Copyright (C) 2000 Grant Grundler < grundler a debian org >
   8  *
   9  *    This program is free software; you can redistribute it and/or modify
  10  *    it under the terms of the GNU General Public License as published by
  11  *    the Free Software Foundation; either version 2 of the License, or
  12  *    (at your option) any later version.
  13  *
  14  *    This program is distributed in the hope that it will be useful,
  15  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *    GNU General Public License for more details.
  18  *
  19  *    You should have received a copy of the GNU General Public License
  20  *    along with this program; if not, write to the Free Software
  21  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #ifndef _ASM_PARISC_SEMAPHORE_H
  25 #define _ASM_PARISC_SEMAPHORE_H
  26
  27 #include <linux/spinlock.h>
  28 #include <linux/wait.h>
  29 #include <linux/rwsem.h>
  30
  31 #include <asm/system.h>
  32
  33 /*
  34  * The `count' is initialised to the number of people who are allowed to
  35  * take the lock.  (Normally we want a mutex, so this is `1').  if
  36  * `count' is positive, the lock can be taken.  if it's 0, no-one is
  37  * waiting on it.  if it's -1, at least one task is waiting.
  38  */
  39 struct semaphore {
  40         spinlock_t      sentry;
  41         int             count;
  42         wait_queue_head_t wait;
  43 };
  44
  45 #define __SEMAPHORE_INITIALIZER(name, n)                                \
  46 {                                                                       \
  47         .sentry         = SPIN_LOCK_UNLOCKED,                           \
  48         .count          = n,                                            \
  49         .wait           = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)    \
  50 }
  51
  52 #define __MUTEX_INITIALIZER(name) \
  53         __SEMAPHORE_INITIALIZER(name,1)
  54
  55 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
  56         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
  57
  58 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
  59 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
  60
  61 extern inline void sema_init (struct semaphore *sem, int val)
  62 {
  63         *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val);
  64 }
  65
  66 static inline void init_MUTEX (struct semaphore *sem)
  67 {
  68         sema_init(sem, 1);
  69 }
  70
  71 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
  72 {
  73         sema_init(sem, 0);
  74 }
  75
  76 static inline int sem_getcount(struct semaphore *sem)
  77 {
  78         return sem->count;
  79 }
  80
  81 asmlinkage void __down(struct semaphore * sem);
  82 asmlinkage int  __down_interruptible(struct semaphore * sem);
  83 asmlinkage void __up(struct semaphore * sem);
  84
  85 /* Semaphores can be `tried' from irq context.  So we have to disable
  86  * interrupts while we're messing with the semaphore.  Sorry.
  87  */
  88
  89 extern __inline__ void down(struct semaphore * sem)
  90 {
  91         might_sleep();
  92         spin_lock_irq(&sem->sentry);
  93         if (sem->count > 0) {
  94                 sem->count--;
  95         } else {
  96                 __down(sem);
  97         }
  98         spin_unlock_irq(&sem->sentry);
  99 }
 100
 101 extern __inline__ int down_interruptible(struct semaphore * sem)
 102 {
 103         int ret = 0;
 104         might_sleep();
 105         spin_lock_irq(&sem->sentry);
 106         if (sem->count > 0) {
 107                 sem->count--;
 108         } else {
 109                 ret = __down_interruptible(sem);
 110         }
 111         spin_unlock_irq(&sem->sentry);
 112         return ret;
 113 }
 114
 115 /*
 116  * down_trylock returns 0 on success, 1 if we failed to get the lock.
 117  * May not sleep, but must preserve irq state
 118  */
 119 extern __inline__ int down_trylock(struct semaphore * sem)
 120 {
 121         int flags, count;
 122
 123         spin_lock_irqsave(&sem->sentry, flags);
 124         count = sem->count - 1;
 125         if (count >= 0)
 126                 sem->count = count;
 127         spin_unlock_irqrestore(&sem->sentry, flags);
 128         return (count < 0);
 129 }
 130
 131 /*
 132  * Note! This is subtle. We jump to wake people up only if
 133  * the semaphore was negative (== somebody was waiting on it).
 134  */
 135 extern __inline__ void up(struct semaphore * sem)
 136 {
 137         int flags;
 138         spin_lock_irqsave(&sem->sentry, flags);
 139         if (sem->count < 0) {
 140                 __up(sem);
 141         } else {
 142                 sem->count++;
 143         }
 144         spin_unlock_irqrestore(&sem->sentry, flags);
 145 }
 146
 147 #endif /* _ASM_PARISC_SEMAPHORE_H */