Merge branch 'master' of /home/sam/kernel/linux-2.6/
[linux-2.6] / 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 #define SEMAPHORE_DEBUG         0
24
25 /*
26  * the semaphore definition
27  * - if counter is >0 then there are tokens available on the semaphore for down to collect
28  * - if counter is <=0 then there are no spare tokens, and anyone that wants one must wait
29  * - if wait_list is not empty, then there are processes waiting for the semaphore
30  */
31 struct semaphore {
32         unsigned                counter;
33         spinlock_t              wait_lock;
34         struct list_head        wait_list;
35 #if SEMAPHORE_DEBUG
36         unsigned                __magic;
37 #endif
38 };
39
40 #if SEMAPHORE_DEBUG
41 # define __SEM_DEBUG_INIT(name) , (long)&(name).__magic
42 #else
43 # define __SEM_DEBUG_INIT(name)
44 #endif
45
46
47 #define __SEMAPHORE_INITIALIZER(name,count) \
48 { count, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) __SEM_DEBUG_INIT(name) }
49
50 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
51         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
52
53 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
54 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
55
56 static inline void sema_init (struct semaphore *sem, int val)
57 {
58         *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
59 }
60
61 static inline void init_MUTEX (struct semaphore *sem)
62 {
63         sema_init(sem, 1);
64 }
65
66 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
67 {
68         sema_init(sem, 0);
69 }
70
71 extern void __down(struct semaphore *sem, unsigned long flags);
72 extern int  __down_interruptible(struct semaphore *sem, unsigned long flags);
73 extern void __up(struct semaphore *sem);
74
75 static inline void down(struct semaphore *sem)
76 {
77         unsigned long flags;
78
79 #if SEMAPHORE_DEBUG
80         CHECK_MAGIC(sem->__magic);
81 #endif
82
83         spin_lock_irqsave(&sem->wait_lock, flags);
84         if (likely(sem->counter > 0)) {
85                 sem->counter--;
86                 spin_unlock_irqrestore(&sem->wait_lock, flags);
87         }
88         else {
89                 __down(sem, flags);
90         }
91 }
92
93 static inline int down_interruptible(struct semaphore *sem)
94 {
95         unsigned long flags;
96         int ret = 0;
97
98 #if SEMAPHORE_DEBUG
99         CHECK_MAGIC(sem->__magic);
100 #endif
101
102         spin_lock_irqsave(&sem->wait_lock, flags);
103         if (likely(sem->counter > 0)) {
104                 sem->counter--;
105                 spin_unlock_irqrestore(&sem->wait_lock, flags);
106         }
107         else {
108                 ret = __down_interruptible(sem, flags);
109         }
110         return ret;
111 }
112
113 /*
114  * non-blockingly attempt to down() a semaphore.
115  * - returns zero if we acquired it
116  */
117 static inline int down_trylock(struct semaphore *sem)
118 {
119         unsigned long flags;
120         int success = 0;
121
122 #if SEMAPHORE_DEBUG
123         CHECK_MAGIC(sem->__magic);
124 #endif
125
126         spin_lock_irqsave(&sem->wait_lock, flags);
127         if (sem->counter > 0) {
128                 sem->counter--;
129                 success = 1;
130         }
131         spin_unlock_irqrestore(&sem->wait_lock, flags);
132         return !success;
133 }
134
135 static inline void up(struct semaphore *sem)
136 {
137         unsigned long flags;
138
139 #if SEMAPHORE_DEBUG
140         CHECK_MAGIC(sem->__magic);
141 #endif
142
143         spin_lock_irqsave(&sem->wait_lock, flags);
144         if (!list_empty(&sem->wait_list))
145                 __up(sem);
146         else
147                 sem->counter++;
148         spin_unlock_irqrestore(&sem->wait_lock, flags);
149 }
150
151 static inline int sem_getcount(struct semaphore *sem)
152 {
153         return sem->counter;
154 }
155
156 #endif /* __ASSEMBLY__ */
157
158 #endif