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 __DECLARE_SEMAPHORE_GENERIC(name,count) \
  53         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
  54
  55 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
  56
  57 static inline void sema_init (struct semaphore *sem, int val)
  58 {
  59         *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val);
  60 }
  61
  62 static inline void init_MUTEX (struct semaphore *sem)
  63 {
  64         sema_init(sem, 1);
  65 }
  66
  67 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
  68 {
  69         sema_init(sem, 0);
  70 }
  71
  72 static inline int sem_getcount(struct semaphore *sem)
  73 {
  74         return sem->count;
  75 }
  76
  77 asmlinkage void __down(struct semaphore * sem);
  78 asmlinkage int  __down_interruptible(struct semaphore * sem);
  79 asmlinkage void __up(struct semaphore * sem);
  80
  81 /* Semaphores can be `tried' from irq context.  So we have to disable
  82  * interrupts while we're messing with the semaphore.  Sorry.
  83  */
  84
  85 static inline void down(struct semaphore * sem)
  86 {
  87         might_sleep();
  88         spin_lock_irq(&sem->sentry);
  89         if (sem->count > 0) {
  90                 sem->count--;
  91         } else {
  92                 __down(sem);
  93         }
  94         spin_unlock_irq(&sem->sentry);
  95 }
  96
  97 static inline int down_interruptible(struct semaphore * sem)
  98 {
  99         int ret = 0;
 100         might_sleep();
 101         spin_lock_irq(&sem->sentry);
 102         if (sem->count > 0) {
 103                 sem->count--;
 104         } else {
 105                 ret = __down_interruptible(sem);
 106         }
 107         spin_unlock_irq(&sem->sentry);
 108         return ret;
 109 }
 110
 111 /*
 112  * down_trylock returns 0 on success, 1 if we failed to get the lock.
 113  * May not sleep, but must preserve irq state
 114  */
 115 static inline int down_trylock(struct semaphore * sem)
 116 {
 117         unsigned long flags;
 118         int count;
 119
 120         spin_lock_irqsave(&sem->sentry, flags);
 121         count = sem->count - 1;
 122         if (count >= 0)
 123                 sem->count = count;
 124         spin_unlock_irqrestore(&sem->sentry, flags);
 125         return (count < 0);
 126 }
 127
 128 /*
 129  * Note! This is subtle. We jump to wake people up only if
 130  * the semaphore was negative (== somebody was waiting on it).
 131  */
 132 static inline void up(struct semaphore * sem)
 133 {
 134         unsigned long flags;
 135
 136         spin_lock_irqsave(&sem->sentry, flags);
 137         if (sem->count < 0) {
 138                 __up(sem);
 139         } else {
 140                 sem->count++;
 141         }
 142         spin_unlock_irqrestore(&sem->sentry, flags);
 143 }
 144
 145 #endif /* _ASM_PARISC_SEMAPHORE_H */