[deliverable/linux.git] / include / asm-ia64 / semaphore.h

#ifndef _ASM_IA64_SEMAPHORE_H
#define _ASM_IA64_SEMAPHORE_H

/*
 * Copyright (C) 1998-2000 Hewlett-Packard Co
 * Copyright (C) 1998-2000 David Mosberger-Tang <davidm@hpl.hp.com>
 */

#include <linux/wait.h>
#include <linux/rwsem.h>

#include <asm/atomic.h>

struct semaphore {
	atomic_t count;
	int sleepers;
	wait_queue_head_t wait;
};

#define __SEMAPHORE_INITIALIZER(name, n)				\
{									\
	.count		= ATOMIC_INIT(n),				\
	.sleepers	= 0,						\
	.wait		= __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)	\
}

#define __DECLARE_SEMAPHORE_GENERIC(name,count)					\
	struct semaphore name = __SEMAPHORE_INITIALIZER(name, count)

#define DECLARE_MUTEX(name)		__DECLARE_SEMAPHORE_GENERIC(name, 1)

static inline void
sema_init (struct semaphore *sem, int val)
{
	*sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
}

static inline void
init_MUTEX (struct semaphore *sem)
{
	sema_init(sem, 1);
}

static inline void
init_MUTEX_LOCKED (struct semaphore *sem)
{
	sema_init(sem, 0);
}

extern void __down (struct semaphore * sem);
extern int  __down_interruptible (struct semaphore * sem);
extern int  __down_trylock (struct semaphore * sem);
extern void __up (struct semaphore * sem);

/*
 * Atomically decrement the semaphore's count.  If it goes negative,
 * block the calling thread in the TASK_UNINTERRUPTIBLE state.
 */
static inline void
down (struct semaphore *sem)
{
	might_sleep();
	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
		__down(sem);
}

/*
 * Atomically decrement the semaphore's count.  If it goes negative,
 * block the calling thread in the TASK_INTERRUPTIBLE state.
 */
static inline int
down_interruptible (struct semaphore * sem)
{
	int ret = 0;

	might_sleep();
	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
		ret = __down_interruptible(sem);
	return ret;
}

static inline int
down_trylock (struct semaphore *sem)
{
	int ret = 0;

	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
		ret = __down_trylock(sem);
	return ret;
}

static inline void
up (struct semaphore * sem)
{
	if (ia64_fetchadd(1, &sem->count.counter, rel) <= -1)
		__up(sem);
}

#endif /* _ASM_IA64_SEMAPHORE_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _ASM_IA64_SEMAPHORE_H
	2	#define _ASM_IA64_SEMAPHORE_H
	3
	4	/*
	5	* Copyright (C) 1998-2000 Hewlett-Packard Co
	6	* Copyright (C) 1998-2000 David Mosberger-Tang <davidm@hpl.hp.com>
	7	*/
	8
	9	#include <linux/wait.h>
	10	#include <linux/rwsem.h>
	11
	12	#include <asm/atomic.h>
	13
	14	struct semaphore {
	15	atomic_t count;
	16	int sleepers;
	17	wait_queue_head_t wait;
	18	};
	19
	20	#define __SEMAPHORE_INITIALIZER(name, n) \
	21	{ \
	22	.count = ATOMIC_INIT(n), \
	23	.sleepers = 0, \
	24	.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
	25	}
	26
1da177e4 LT	27	#define __DECLARE_SEMAPHORE_GENERIC(name,count) \
	28	struct semaphore name = __SEMAPHORE_INITIALIZER(name, count)
	29
	30	#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name, 1)
1da177e4 LT	31
	32	static inline void
	33	sema_init (struct semaphore *sem, int val)
	34	{
	35	sem = (struct semaphore) __SEMAPHORE_INITIALIZER(sem, val);
	36	}
	37
	38	static inline void
	39	init_MUTEX (struct semaphore *sem)
	40	{
	41	sema_init(sem, 1);
	42	}
	43
	44	static inline void
	45	init_MUTEX_LOCKED (struct semaphore *sem)
	46	{
	47	sema_init(sem, 0);
	48	}
	49
	50	extern void __down (struct semaphore * sem);
	51	extern int __down_interruptible (struct semaphore * sem);
	52	extern int __down_trylock (struct semaphore * sem);
	53	extern void __up (struct semaphore * sem);
	54
	55	/*
	56	* Atomically decrement the semaphore's count. If it goes negative,
	57	* block the calling thread in the TASK_UNINTERRUPTIBLE state.
	58	*/
	59	static inline void
	60	down (struct semaphore *sem)
	61	{
	62	might_sleep();
4b16bfbf	63	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
1da177e4 LT	64	__down(sem);
	65	}
	66
	67	/*
	68	* Atomically decrement the semaphore's count. If it goes negative,
	69	* block the calling thread in the TASK_INTERRUPTIBLE state.
	70	*/
	71	static inline int
	72	down_interruptible (struct semaphore * sem)
	73	{
	74	int ret = 0;
	75
	76	might_sleep();
4b16bfbf	77	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
1da177e4 LT	78	ret = __down_interruptible(sem);
	79	return ret;
	80	}
	81
	82	static inline int
	83	down_trylock (struct semaphore *sem)
	84	{
	85	int ret = 0;
	86
4b16bfbf	87	if (ia64_fetchadd(-1, &sem->count.counter, acq) < 1)
1da177e4 LT	88	ret = __down_trylock(sem);
	89	return ret;
	90	}
	91
	92	static inline void
	93	up (struct semaphore * sem)
	94	{
4b16bfbf	95	if (ia64_fetchadd(1, &sem->count.counter, rel) <= -1)
1da177e4 LT	96	__up(sem);
	97	}
	98
	99	#endif /* _ASM_IA64_SEMAPHORE_H */