kill DECLARE_MUTEX_LOCKED
[linux-2.6.git] / 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 extern 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 extern __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 extern __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 extern __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 extern __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 */