Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 019
020 #include <hwcore/irq.h> 020 #include <hwcore/irq.h>
021 021
022 022
023 #include "ksynch.h" 023 #include "ksynch.h"
024 024
025 025
026 sos_ret_t sos_ksema_init(struct sos_ksema *sem 026 sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
027 int initial_value, !! 027 int initial_value)
028 sos_kwaitq_ordering_t <<
029 { 028 {
030 sema->value = initial_value; 029 sema->value = initial_value;
031 return sos_kwaitq_init(& sema->kwaitq, name, !! 030 return sos_kwaitq_init(& sema->kwaitq, name);
032 } 031 }
033 032
034 033
035 sos_ret_t sos_ksema_dispose(struct sos_ksema * 034 sos_ret_t sos_ksema_dispose(struct sos_ksema *sema)
036 { 035 {
037 return sos_kwaitq_dispose(& sema->kwaitq); 036 return sos_kwaitq_dispose(& sema->kwaitq);
038 } 037 }
039 038
040 039
041 sos_ret_t sos_ksema_down(struct sos_ksema *sem 040 sos_ret_t sos_ksema_down(struct sos_ksema *sema,
042 struct sos_time *time 041 struct sos_time *timeout)
043 { 042 {
044 sos_ui32_t flags; 043 sos_ui32_t flags;
045 sos_ret_t retval; 044 sos_ret_t retval;
046 045
047 sos_disable_IRQs(flags); 046 sos_disable_IRQs(flags);
048 retval = SOS_OK; 047 retval = SOS_OK;
049 048
050 sema->value --; 049 sema->value --;
051 if (sema->value < 0) 050 if (sema->value < 0)
052 { 051 {
053 052
054 retval = sos_kwaitq_wait(& sema->kwaitq, 053 retval = sos_kwaitq_wait(& sema->kwaitq, timeout);
055 054
056 055
057 if (SOS_OK != retval) 056 if (SOS_OK != retval)
058 { 057 {
059 058
060 sema->value ++; 059 sema->value ++;
061 } 060 }
062 } 061 }
063 062
064 sos_restore_IRQs(flags); 063 sos_restore_IRQs(flags);
065 return retval; 064 return retval;
066 } 065 }
067 066
068 067
069 sos_ret_t sos_ksema_trydown(struct sos_ksema * 068 sos_ret_t sos_ksema_trydown(struct sos_ksema *sema)
070 { 069 {
071 sos_ui32_t flags; 070 sos_ui32_t flags;
072 sos_ret_t retval; 071 sos_ret_t retval;
073 072
074 sos_disable_IRQs(flags); 073 sos_disable_IRQs(flags);
075 074
076 075
077 if (sema->value >= 1) 076 if (sema->value >= 1)
078 { 077 {
079 078
080 sema->value --; 079 sema->value --;
081 retval = SOS_OK; 080 retval = SOS_OK;
082 } 081 }
083 else 082 else
084 { 083 {
085 084
086 retval = -SOS_EBUSY; 085 retval = -SOS_EBUSY;
087 } 086 }
088 087
089 sos_restore_IRQs(flags); 088 sos_restore_IRQs(flags);
090 return retval; 089 return retval;
091 } 090 }
092 091
093 092
094 sos_ret_t sos_ksema_up(struct sos_ksema *sema) 093 sos_ret_t sos_ksema_up(struct sos_ksema *sema)
095 { 094 {
096 sos_ui32_t flags; 095 sos_ui32_t flags;
097 sos_ret_t retval; 096 sos_ret_t retval;
098 097
099 sos_disable_IRQs(flags); 098 sos_disable_IRQs(flags);
100 099
101 sema->value ++; 100 sema->value ++;
102 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1 101 retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK);
103 102
104 sos_restore_IRQs(flags); 103 sos_restore_IRQs(flags);
105 return retval; 104 return retval;
106 } 105 }
107 106
108 107
109 sos_ret_t sos_kmutex_init(struct sos_kmutex *m !! 108 sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name)
110 sos_kwaitq_ordering_ <<
111 { 109 {
112 mutex->owner = NULL; 110 mutex->owner = NULL;
113 return sos_kwaitq_init(& mutex->kwaitq, name !! 111 return sos_kwaitq_init(& mutex->kwaitq, name);
114 } 112 }
115 113
116 114
117 sos_ret_t sos_kmutex_dispose(struct sos_kmutex 115 sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex)
118 { 116 {
119 return sos_kwaitq_dispose(& mutex->kwaitq); 117 return sos_kwaitq_dispose(& mutex->kwaitq);
120 } 118 }
121 119
122 120
123 121
124 122
125 123
126 124
127 125
128 126
129 127
130 128
131 129
132 sos_ret_t sos_kmutex_lock(struct sos_kmutex *m 130 sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
133 struct sos_time *tim 131 struct sos_time *timeout)
134 { 132 {
135 __label__ exit_kmutex_lock; 133 __label__ exit_kmutex_lock;
136 sos_ui32_t flags; 134 sos_ui32_t flags;
137 sos_ret_t retval; 135 sos_ret_t retval;
138 136
139 sos_disable_IRQs(flags); 137 sos_disable_IRQs(flags);
140 retval = SOS_OK; 138 retval = SOS_OK;
141 139
142 140
143 if (NULL != mutex->owner) 141 if (NULL != mutex->owner)
144 { 142 {
145 143
146 if (sos_thread_get_current() == mutex->o 144 if (sos_thread_get_current() == mutex->owner)
147 { 145 {
148 146
149 retval = -SOS_EBUSY; 147 retval = -SOS_EBUSY;
150 goto exit_kmutex_lock; 148 goto exit_kmutex_lock;
151 } 149 }
152 150
153 151
154 retval = sos_kwaitq_wait(& mutex->kwaitq 152 retval = sos_kwaitq_wait(& mutex->kwaitq, timeout);
155 153
156 154
157 if (SOS_OK != retval) 155 if (SOS_OK != retval)
158 { 156 {
159 goto exit_kmutex_lock; 157 goto exit_kmutex_lock;
160 } 158 }
161 } 159 }
162 160
163 161
164 mutex->owner = sos_thread_get_current(); 162 mutex->owner = sos_thread_get_current();
165 163
166 exit_kmutex_lock: 164 exit_kmutex_lock:
167 sos_restore_IRQs(flags); 165 sos_restore_IRQs(flags);
168 return retval; 166 return retval;
169 } 167 }
170 168
171 169
172 sos_ret_t sos_kmutex_trylock(struct sos_kmutex 170 sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex)
173 { 171 {
174 sos_ui32_t flags; 172 sos_ui32_t flags;
175 sos_ret_t retval; 173 sos_ret_t retval;
176 174
177 sos_disable_IRQs(flags); 175 sos_disable_IRQs(flags);
178 176
179 177
180 if (NULL == mutex->owner) 178 if (NULL == mutex->owner)
181 { 179 {
182 180
183 mutex->owner = sos_thread_get_current(); 181 mutex->owner = sos_thread_get_current();
184 182
185 retval = SOS_OK; 183 retval = SOS_OK;
186 } 184 }
187 else 185 else
188 { 186 {
189 187
190 retval = -SOS_EBUSY; 188 retval = -SOS_EBUSY;
191 } 189 }
192 190
193 sos_restore_IRQs(flags); 191 sos_restore_IRQs(flags);
194 return retval; 192 return retval;
195 } 193 }
196 194
197 195
198 sos_ret_t sos_kmutex_unlock(struct sos_kmutex 196 sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex)
199 { 197 {
200 sos_ui32_t flags; 198 sos_ui32_t flags;
201 sos_ret_t retval; 199 sos_ret_t retval;
202 200
203 sos_disable_IRQs(flags); 201 sos_disable_IRQs(flags);
204 202
205 if (sos_thread_get_current() != mutex->owner 203 if (sos_thread_get_current() != mutex->owner)
206 retval = -SOS_EPERM; 204 retval = -SOS_EPERM;
207 205
208 else if (sos_kwaitq_is_empty(& mutex->kwaitq 206 else if (sos_kwaitq_is_empty(& mutex->kwaitq))
209 { 207 {
210 208
211 209
212 210
213 211
214 mutex->owner = NULL; 212 mutex->owner = NULL;
215 retval = SOS_OK; 213 retval = SOS_OK;
216 } 214 }
217 else 215 else
218 { 216 {
219 217
220 218
221 219
222 220
223 221
224 222
225 223
226 224
227 225
228 226
229 227
230 retval = sos_kwaitq_wakeup(& mutex->kwai 228 retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK);
231 } 229 }
232 230
233 sos_restore_IRQs(flags); 231 sos_restore_IRQs(flags);
234 return retval; 232 return retval;
235 } 233 }