kill DECLARE_MUTEX_LOCKED
[linux-2.6.git] / include / asm-frv / semaphore.h
1 /* semaphore.h: semaphores for the FR-V
2  *
3  * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11 #ifndef _ASM_SEMAPHORE_H
12 #define _ASM_SEMAPHORE_H
13
14 #define RW_LOCK_BIAS             0x01000000
15
16 #ifndef __ASSEMBLY__
17
18 #include <linux/linkage.h>
19 #include <linux/wait.h>
20 #include <linux/spinlock.h>
21 #include <linux/rwsem.h>
22
23 /*
24  * the semaphore definition
25  * - if counter is >0 then there are tokens available on the semaphore for down to collect
26  * - if counter is <=0 then there are no spare tokens, and anyone that wants one must wait
27  * - if wait_list is not empty, then there are processes waiting for the semaphore
28  */
29 struct semaphore {
30         unsigned                counter;
31         spinlock_t              wait_lock;
32         struct list_head        wait_list;
33 #ifdef CONFIG_DEBUG_SEMAPHORE
34         unsigned                __magic;
35 #endif
36 };
37
38 #ifdef CONFIG_DEBUG_SEMAPHORE
39 # define __SEM_DEBUG_INIT(name) , (long)&(name).__magic
40 #else
41 # define __SEM_DEBUG_INIT(name)
42 #endif
43
44
45 #define __SEMAPHORE_INITIALIZER(name,count) \
46 { count, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) __SEM_DEBUG_INIT(name) }
47
48 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
49         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
50
51 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
52
53 static inline void sema_init (struct semaphore *sem, int val)
54 {
55         *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
56 }
57
58 static inline void init_MUTEX (struct semaphore *sem)
59 {
60         sema_init(sem, 1);
61 }
62
63 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
64 {
65         sema_init(sem, 0);
66 }
67
68 extern void __down(struct semaphore *sem, unsigned long flags);
69 extern int  __down_interruptible(struct semaphore *sem, unsigned long flags);
70 extern void __up(struct semaphore *sem);
71
72 static inline void down(struct semaphore *sem)
73 {
74         unsigned long flags;
75
76 #ifdef CONFIG_DEBUG_SEMAPHORE
77         CHECK_MAGIC(sem->__magic);
78 #endif
79
80         spin_lock_irqsave(&sem->wait_lock, flags);
81         if (likely(sem->counter > 0)) {
82                 sem->counter--;
83                 spin_unlock_irqrestore(&sem->wait_lock, flags);
84         }
85         else {
86                 __down(sem, flags);
87         }
88 }
89
90 static inline int down_interruptible(struct semaphore *sem)
91 {
92         unsigned long flags;
93         int ret = 0;
94
95 #ifdef CONFIG_DEBUG_SEMAPHORE
96         CHECK_MAGIC(sem->__magic);
97 #endif
98
99         spin_lock_irqsave(&sem->wait_lock, flags);
100         if (likely(sem->counter > 0)) {
101                 sem->counter--;
102                 spin_unlock_irqrestore(&sem->wait_lock, flags);
103         }
104         else {
105                 ret = __down_interruptible(sem, flags);
106         }
107         return ret;
108 }
109
110 /*
111  * non-blockingly attempt to down() a semaphore.
112  * - returns zero if we acquired it
113  */
114 static inline int down_trylock(struct semaphore *sem)
115 {
116         unsigned long flags;
117         int success = 0;
118
119 #ifdef CONFIG_DEBUG_SEMAPHORE
120         CHECK_MAGIC(sem->__magic);
121 #endif
122
123         spin_lock_irqsave(&sem->wait_lock, flags);
124         if (sem->counter > 0) {
125                 sem->counter--;
126                 success = 1;
127         }
128         spin_unlock_irqrestore(&sem->wait_lock, flags);
129         return !success;
130 }
131
132 static inline void up(struct semaphore *sem)
133 {
134         unsigned long flags;
135
136 #ifdef CONFIG_DEBUG_SEMAPHORE
137         CHECK_MAGIC(sem->__magic);
138 #endif
139
140         spin_lock_irqsave(&sem->wait_lock, flags);
141         if (!list_empty(&sem->wait_list))
142                 __up(sem);
143         else
144                 sem->counter++;
145         spin_unlock_irqrestore(&sem->wait_lock, flags);
146 }
147
148 static inline int sem_getcount(struct semaphore *sem)
149 {
150         return sem->counter;
151 }
152
153 #endif /* __ASSEMBLY__ */
154
155 #endif