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