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