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