|
0
|
1 #ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
|
|
2 #define CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
|
|
3 //=========================================================================== |
|
|
4 // |
|
2
|
5 // uit_func.inl |
|
0
|
6 // |
|
2
|
7 // uITRON compatibility functions |
|
0
|
8 // |
|
|
9 //=========================================================================== |
|
|
10 //####COPYRIGHTBEGIN#### |
|
|
11 // |
|
|
12 // ------------------------------------------- |
|
|
13 // The contents of this file are subject to the Cygnus eCos Public License |
|
|
14 // Version 1.0 (the "License"); you may not use this file except in |
|
|
15 // compliance with the License. You may obtain a copy of the License at |
|
|
16 // http://sourceware.cygnus.com/ecos |
|
|
17 // |
|
|
18 // Software distributed under the License is distributed on an "AS IS" |
|
|
19 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the |
|
|
20 // License for the specific language governing rights and limitations under |
|
|
21 // the License. |
|
|
22 // |
|
|
23 // The Original Code is eCos - Embedded Cygnus Operating System, released |
|
|
24 // September 30, 1998. |
|
|
25 // |
|
|
26 // The Initial Developer of the Original Code is Cygnus. Portions created |
|
2
|
27 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. |
|
0
|
28 // ------------------------------------------- |
|
|
29 // |
|
|
30 //####COPYRIGHTEND#### |
|
|
31 //=========================================================================== |
|
|
32 //#####DESCRIPTIONBEGIN#### |
|
|
33 // |
|
2
|
34 // Author(s): hmt |
|
|
35 // Contributors: hmt |
|
|
36 // Date: 1998-03-13 |
|
|
37 // Purpose: uITRON compatibility functions |
|
|
38 // Description: |
|
0
|
39 // |
|
|
40 //####DESCRIPTIONEND#### |
|
|
41 // |
|
|
42 //=========================================================================== |
|
|
43 |
|
|
44 #ifdef CYGPKG_UITRON |
|
|
45 |
|
|
46 #ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
|
47 |
|
|
48 #include <cyg/compat/uitron/uit_objs.hxx> // uITRON setup CYGNUM_UITRON_SEMAS |
|
|
49 |
|
|
50 // kernel facilities only needed here |
|
|
51 #include <cyg/kernel/intr.hxx> |
|
|
52 #include <cyg/kernel/sched.hxx> |
|
|
53 |
|
|
54 // and the implementations of other kernel facilities |
|
|
55 #include <cyg/kernel/thread.inl> |
|
|
56 #include <cyg/kernel/sched.inl> |
|
|
57 #include <cyg/kernel/clock.inl> |
|
|
58 |
|
2
|
59 |
|
|
60 // ------------------------------------------------------------------------ |
|
|
61 // The variable where dis_dsp/ena_dsp state is held: |
|
|
62 extern cyg_uint32 cyg_uitron_dis_dsp_old_priority; |
|
|
63 |
|
0
|
64 // ------------------------------------------------------------------------ |
|
|
65 // Parameter checking; either check the expression and return an error code |
|
|
66 // if not true, or assert the truth with a made-up message. |
|
|
67 |
|
|
68 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
69 // default: uitron error codes are returned |
|
2
|
70 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ |
|
|
71 if ( ! (_true_) ) return (_error_); \ |
|
0
|
72 CYG_MACRO_END |
|
|
73 #else |
|
|
74 // ...but they are asserted if asserts are on |
|
2
|
75 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ |
|
|
76 CYG_ASSERT( (_true_), "CYG_UIT_PARAMCHECK fail: " #_true_ ); \ |
|
0
|
77 CYG_MACRO_END |
|
|
78 #endif // else !CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
79 |
|
|
80 // ------------------------------------------------------------------------ |
|
|
81 // CYG_UITRON_CHECK_AND_GETP |
|
|
82 // |
|
|
83 // Macro to rangecheck and do the addressing of a static uitron system |
|
|
84 // object; _which_ sort of object is given, and token pasting is used |
|
|
85 // horribly to get the static array, limits and the like. |
|
|
86 // |
|
|
87 // Usage: |
|
|
88 // INT snd_msg( ID mbxid, ... ) { |
|
2
|
89 // Cyg_Mbox *p; |
|
|
90 // CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
91 // p->...(...); |
|
0
|
92 |
|
|
93 // internal: plain assignment to the object pointer, from static array |
|
2
|
94 #define CYG_UIT_SPTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ |
|
|
95 (_ptr_) = CYG_UITRON_OBJS( _which_ ) + ((_idx_) - 1); \ |
|
0
|
96 CYG_MACRO_END |
|
|
97 |
|
|
98 // internal: plain assignment to the object pointer, from pointer array |
|
|
99 // with error checking. |
|
2
|
100 #define CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ |
|
|
101 (_ptr_) = CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ]; \ |
|
|
102 if ( NULL == (_ptr_) ) return E_NOEXS; \ |
|
0
|
103 CYG_MACRO_END |
|
|
104 |
|
2
|
105 #define CYG_UITRON_CHECK_AND_GETP_DIRECT( _which_, _idx_, _ptr_ ) \ |
|
|
106 CYG_MACRO_START \ |
|
|
107 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
|
|
108 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
|
|
109 CYG_UIT_SPTR( _which_, _idx_, _ptr_ ); \ |
|
0
|
110 CYG_MACRO_END |
|
|
111 |
|
2
|
112 #define CYG_UITRON_CHECK_AND_GETP_INDIRECT( _which_, _idx_, _ptr_ ) \ |
|
|
113 CYG_MACRO_START \ |
|
|
114 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
|
|
115 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
|
|
116 CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ); \ |
|
0
|
117 CYG_MACRO_END |
|
|
118 |
|
|
119 // As above but for handler numbers which return E_PAR when out of range |
|
2
|
120 #define CYG_UITRON_CHECK_AND_GETHDLR( _which_, _num_, _ptr_ ) \ |
|
|
121 CYG_MACRO_START \ |
|
|
122 CYG_UIT_PARAMCHECK( 0 < (_num_), E_PAR ); \ |
|
0
|
123 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_num_), E_PAR ); \ |
|
2
|
124 CYG_UIT_SPTR( _which_, _num_, _ptr_ ); \ |
|
0
|
125 CYG_MACRO_END |
|
|
126 |
|
|
127 // And a macro to check that creation of an object is OK |
|
2
|
128 #define CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( _which_, _idx_ ) \ |
|
|
129 CYG_MACRO_START \ |
|
|
130 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
|
|
131 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
|
|
132 Cyg_Scheduler::lock(); \ |
|
|
133 if ( NULL != CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ] ) { \ |
|
|
134 Cyg_Scheduler::unlock(); \ |
|
|
135 return E_OBJ; \ |
|
|
136 } \ |
|
0
|
137 CYG_MACRO_END |
|
|
138 |
|
|
139 // define a magic new operator in order to call constructors |
|
2
|
140 #define CYG_UITRON_NEWFUNCTION( _class_ ) \ |
|
|
141 inline void *operator new(size_t size, _class_ *ptr) \ |
|
|
142 { \ |
|
|
143 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); \ |
|
|
144 return ptr; \ |
|
0
|
145 } |
|
|
146 |
|
|
147 // now configury to support selectable create/delete support ie. an |
|
|
148 // array of pointers to the objects themselves. |
|
|
149 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
2
|
150 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ |
|
0
|
151 CYG_UITRON_CHECK_AND_GETP_INDIRECT( TASKS, _idx_, _ptr_ ) |
|
|
152 #else |
|
2
|
153 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ |
|
0
|
154 CYG_UITRON_CHECK_AND_GETP_DIRECT( TASKS, _idx_, _ptr_ ) |
|
|
155 #endif |
|
|
156 |
|
|
157 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
2
|
158 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ |
|
0
|
159 CYG_UITRON_CHECK_AND_GETP_INDIRECT( SEMAS, _idx_, _ptr_ ) |
|
|
160 #else |
|
2
|
161 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ |
|
0
|
162 CYG_UITRON_CHECK_AND_GETP_DIRECT( SEMAS, _idx_, _ptr_ ) |
|
|
163 #endif |
|
|
164 |
|
|
165 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
2
|
166 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ |
|
0
|
167 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MBOXES, _idx_, _ptr_ ) |
|
|
168 #else |
|
2
|
169 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ |
|
0
|
170 CYG_UITRON_CHECK_AND_GETP_DIRECT( MBOXES, _idx_, _ptr_ ) |
|
|
171 #endif |
|
|
172 |
|
|
173 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
2
|
174 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ |
|
0
|
175 CYG_UITRON_CHECK_AND_GETP_INDIRECT( FLAGS, _idx_, _ptr_ ) |
|
|
176 #else |
|
2
|
177 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ |
|
0
|
178 CYG_UITRON_CHECK_AND_GETP_DIRECT( FLAGS, _idx_, _ptr_ ) |
|
|
179 #endif |
|
|
180 |
|
|
181 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
2
|
182 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ |
|
0
|
183 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) |
|
|
184 #else |
|
2
|
185 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ |
|
0
|
186 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) |
|
|
187 #endif |
|
|
188 |
|
|
189 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
2
|
190 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ |
|
0
|
191 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLVAR, _idx_, _ptr_ ) |
|
|
192 #else |
|
2
|
193 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ |
|
0
|
194 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLVAR, _idx_, _ptr_ ) |
|
|
195 #endif |
|
|
196 |
|
|
197 // ------------------------------------------------------------------------ |
|
|
198 // Common error checking macros |
|
|
199 |
|
|
200 #if !defined( CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ) && \ |
|
|
201 !defined( CYGDBG_USE_ASSERTS ) |
|
|
202 // if not checking and not asserted, these are removed to avoid usused |
|
|
203 // variable warnings. |
|
|
204 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_EMPTY_STATEMENT |
|
2
|
205 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_EMPTY_STATEMENT |
|
|
206 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_EMPTY_STATEMENT |
|
0
|
207 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( _tmout_ ) CYG_EMPTY_STATEMENT |
|
|
208 |
|
|
209 #else |
|
|
210 // the default: |
|
|
211 // Check a task is actually a uITRON task |
|
2
|
212 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_MACRO_START \ |
|
|
213 CYG_UIT_PARAMCHECK( \ |
|
|
214 (&cyg_uitron_TASKS[0] <= (_self_)) && \ |
|
|
215 ((_self_) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]), \ |
|
|
216 E_CTX ); \ |
|
0
|
217 CYG_MACRO_END |
|
|
218 |
|
2
|
219 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_MACRO_START \ |
|
|
220 Cyg_Thread *self = Cyg_Thread::self(); \ |
|
|
221 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); \ |
|
0
|
222 CYG_MACRO_END |
|
|
223 |
|
|
224 // Check dispatching is enabled for calls which might wait |
|
2
|
225 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_MACRO_START \ |
|
|
226 CYG_UIT_PARAMCHECK( 0 == cyg_uitron_dis_dsp_old_priority, E_CTX ); \ |
|
0
|
227 CYG_MACRO_END |
|
|
228 |
|
|
229 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO(_tmout_) CYG_MACRO_START \ |
|
2
|
230 CYG_UIT_PARAMCHECK( -1 <= (_tmout_), E_PAR ); \ |
|
|
231 if ( TMO_POL != (_tmout_) ) \ |
|
|
232 CYG_UITRON_CHECK_DISPATCH_ENABLED(); \ |
|
0
|
233 CYG_MACRO_END |
|
|
234 |
|
|
235 #endif |
|
|
236 |
|
|
237 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
2
|
238 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ |
|
|
239 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ |
|
0
|
240 CYG_MACRO_END |
|
|
241 #else // do check for NULL |
|
2
|
242 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ |
|
|
243 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ |
|
|
244 CYG_UIT_PARAMCHECK( NULL != (_p_), E_PAR ); \ |
|
0
|
245 CYG_MACRO_END |
|
|
246 #endif // !CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
247 |
|
|
248 // ------------------------------------------------------------------------ |
|
|
249 // CYG_UITRON_FAIL_RETURN |
|
|
250 // |
|
|
251 // After a call which waits, it might return with success, or due to a |
|
|
252 // timeout or a release wait (a forced escape from the waiting condition). |
|
|
253 // This macro examines context and finds out which, then executes a return |
|
|
254 // with the correct uITRON condition code. |
|
|
255 |
|
2
|
256 #define CYG_UITRON_FAIL_RETURN_SELF( _self_ ) CYG_MACRO_START \ |
|
|
257 Cyg_Thread::cyg_reason reason = (_self_)->get_wake_reason(); \ |
|
|
258 if ( Cyg_Thread::TIMEOUT == reason ) \ |
|
|
259 return E_TMOUT; \ |
|
|
260 if ( Cyg_Thread::BREAK == reason ) \ |
|
|
261 return E_RLWAI; \ |
|
|
262 if ( Cyg_Thread::DESTRUCT == reason ) \ |
|
|
263 return E_DLT; \ |
|
|
264 return E_SYS; /* if no plausible reason was found */ \ |
|
0
|
265 CYG_MACRO_END |
|
|
266 |
|
2
|
267 #define CYG_UITRON_FAIL_RETURN() CYG_MACRO_START \ |
|
|
268 Cyg_Thread *self = Cyg_Thread::self(); \ |
|
|
269 CYG_UITRON_FAIL_RETURN_SELF( self ); \ |
|
0
|
270 CYG_MACRO_END |
|
|
271 |
|
|
272 // ------------------------------------------------------------------------ |
|
|
273 // Interrupts disabled? |
|
2
|
274 #define CYG_UITRON_CHECK_CPU_UNLOC() \ |
|
0
|
275 CYG_UIT_PARAMCHECK( (Cyg_Interrupt::interrupts_enabled()), E_CTX ) |
|
|
276 |
|
|
277 // ------------------------------------------------------------------------ |
|
|
278 // the function definitions themselves: |
|
|
279 |
|
|
280 // ****************************************************** |
|
|
281 // *** 6.5 C Language Interfaces *** |
|
|
282 // ****************************************************** |
|
|
283 |
|
|
284 // - Task Management Functions |
|
|
285 |
|
|
286 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
|
287 CYG_UITRON_NEWFUNCTION( Cyg_Thread ) |
|
|
288 |
|
|
289 CYG_UIT_FUNC_INLINE |
|
|
290 ER |
|
|
291 cre_tsk ( ID tskid, T_CTSK *pk_ctsk ) |
|
|
292 { |
|
|
293 ER ret = E_OK; |
|
|
294 CYG_UIT_PARAMCHECK_PTR( pk_ctsk ); |
|
|
295 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( TASKS, tskid ); |
|
|
296 |
|
|
297 Cyg_Thread *p = &(CYG_UITRON_OBJS( TASKS )[ tskid - 1 ]); |
|
|
298 cyg_uint32 state = p->get_state(); |
|
|
299 if ( 0 == (state & Cyg_Thread::EXITED) ) |
|
|
300 ret = E_OBJ; // how did it get to be running? |
|
|
301 else if ( ((INT)p->get_stack_size()) < pk_ctsk->stksz ) |
|
|
302 ret = E_NOMEM; // more stack requested than available |
|
|
303 else { |
|
|
304 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = |
|
|
305 new( p ) Cyg_Thread( |
|
|
306 (CYG_ADDRWORD) pk_ctsk->itskpri, |
|
|
307 (cyg_thread_entry *)pk_ctsk->task, |
|
|
308 (CYG_ADDRWORD) 0, |
|
|
309 // preserve the original name and stack: |
|
|
310 #ifdef CYGVAR_KERNEL_THREADS_NAME |
|
|
311 p->get_name(), |
|
|
312 #else |
|
|
313 NULL, |
|
|
314 #endif |
|
|
315 p->get_stack_base(), |
|
|
316 p->get_stack_size() ); |
|
|
317 // but ensure the task state is dormant: |
|
|
318 // (it is not constructed dormant, but suspended) |
|
|
319 p->kill(); |
|
|
320 // and record the initial priority outside the task too. |
|
|
321 CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) = pk_ctsk->itskpri; |
|
|
322 } |
|
|
323 Cyg_Scheduler::unlock(); |
|
|
324 return ret; |
|
|
325 } |
|
|
326 |
|
|
327 CYG_UIT_FUNC_INLINE |
|
|
328 ER |
|
|
329 del_tsk ( ID tskid ) |
|
|
330 { |
|
|
331 Cyg_Thread *p; |
|
|
332 ER ret = E_OK; |
|
|
333 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
334 |
|
|
335 Cyg_Scheduler::lock(); |
|
2
|
336 // deal with the race condition here |
|
|
337 if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] ) { |
|
|
338 Cyg_Scheduler::unlock(); |
|
|
339 return E_NOEXS; |
|
|
340 } |
|
0
|
341 cyg_uint32 state = p->get_state(); |
|
|
342 if ( state & Cyg_Thread::EXITED ) |
|
|
343 // just disconnect the pointer from its object |
|
|
344 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL; |
|
|
345 else |
|
|
346 ret = E_OBJ; |
|
|
347 Cyg_Scheduler::unlock(); |
|
|
348 return ret; |
|
|
349 } |
|
|
350 #endif // CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
|
351 |
|
|
352 CYG_UIT_FUNC_INLINE |
|
|
353 ER |
|
|
354 sta_tsk ( ID tskid, INT stacd ) |
|
|
355 { |
|
|
356 Cyg_Thread *p; |
|
|
357 ER ret = E_OK; |
|
|
358 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
359 |
|
|
360 Cyg_Scheduler::lock(); |
|
|
361 cyg_uint32 state = p->get_state(); |
|
|
362 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
|
363 // there is a race condition with deleting the task |
|
|
364 // so test it now that we have the scheduler locked |
|
|
365 if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] ) |
|
|
366 ret = E_NOEXS; |
|
|
367 else // NOTE dangling else to the next line: |
|
|
368 #endif |
|
|
369 if ( state & Cyg_Thread::EXITED ) { |
|
|
370 p->reinitialize(); |
|
|
371 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
372 p->set_priority( CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) ); |
|
|
373 #endif |
|
|
374 p->set_entry_data( (CYG_ADDRWORD)stacd ); |
|
|
375 p->force_resume(); |
|
|
376 } |
|
|
377 else |
|
|
378 ret = E_OBJ; |
|
|
379 Cyg_Scheduler::unlock(); |
|
|
380 return ret; |
|
|
381 } |
|
|
382 |
|
|
383 CYG_UIT_FUNC_INLINE |
|
|
384 void |
|
|
385 ext_tsk ( void ) |
|
|
386 { |
|
|
387 Cyg_Thread::exit(); |
|
|
388 } |
|
|
389 |
|
|
390 CYG_UIT_FUNC_INLINE |
|
|
391 void |
|
|
392 exd_tsk ( void ) |
|
|
393 { |
|
|
394 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
|
395 Cyg_Thread *p; |
|
|
396 |
|
|
397 Cyg_Scheduler::lock(); |
|
|
398 p = Cyg_Thread::self(); |
|
|
399 ID tskid = (p - (&cyg_uitron_TASKS[0])) + 1; |
|
|
400 // just disconnect the pointer from its object |
|
|
401 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL; |
|
|
402 // Any associated storage management, and possibly calling the task |
|
|
403 // destructor, is for future versions. |
|
|
404 #else |
|
|
405 // do nothing - deletion not supported so just exit... |
|
|
406 #endif |
|
|
407 Cyg_Thread::exit(); |
|
|
408 // does not return, does unlock the scheduler for us |
|
|
409 } |
|
|
410 |
|
|
411 CYG_UIT_FUNC_INLINE |
|
|
412 ER |
|
|
413 ter_tsk ( ID tskid ) |
|
|
414 { |
|
|
415 Cyg_Thread *p; |
|
|
416 ER ret = E_OK; |
|
|
417 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
418 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
419 Cyg_Scheduler::lock(); |
|
|
420 if ( (0 != (Cyg_Thread::EXITED & p->get_state())) || |
|
|
421 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
422 // already dormant |
|
|
423 ret = E_OBJ; |
|
|
424 else { |
|
|
425 p->force_resume(); // let it run |
|
|
426 p->kill(); // and set prio high so it runs RIGHT NOW!! |
|
|
427 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
428 p->set_priority( (cyg_priority) 0 ); |
|
|
429 #endif |
|
|
430 } |
|
|
431 Cyg_Scheduler::unlock(); |
|
2
|
432 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
433 if ( (E_OK == ret) && (0 != cyg_uitron_dis_dsp_old_priority) ) { |
|
|
434 // then dispatching is disabled, so our prio is 0 too |
|
|
435 Cyg_Thread::yield(); // so let the dying thread run; |
|
|
436 Cyg_Thread::yield(); // no cost here of making sure. |
|
|
437 } |
|
|
438 #endif |
|
0
|
439 return ret; |
|
|
440 } |
|
|
441 |
|
|
442 CYG_UIT_FUNC_INLINE |
|
|
443 ER |
|
|
444 dis_dsp ( void ) |
|
|
445 { |
|
|
446 CYG_UITRON_CHECK_TASK_CONTEXT(); |
|
|
447 CYG_UITRON_CHECK_CPU_UNLOC(); |
|
2
|
448 Cyg_Scheduler::lock(); |
|
|
449 // Prevent preemption by going up to prio 0 |
|
|
450 if ( 0 == cyg_uitron_dis_dsp_old_priority ) { |
|
|
451 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
452 Cyg_Thread *p = Cyg_Thread::self(); |
|
|
453 cyg_uitron_dis_dsp_old_priority = p->get_priority(); |
|
|
454 p->set_priority( 0 ); |
|
|
455 #else |
|
|
456 cyg_uitron_dis_dsp_old_priority = 1; |
|
|
457 #endif |
|
|
458 } |
|
|
459 Cyg_Scheduler::unlock(); |
|
0
|
460 return E_OK; |
|
|
461 } |
|
|
462 |
|
|
463 CYG_UIT_FUNC_INLINE |
|
|
464 ER |
|
|
465 ena_dsp ( void ) |
|
|
466 { |
|
|
467 CYG_UITRON_CHECK_TASK_CONTEXT(); |
|
|
468 CYG_UITRON_CHECK_CPU_UNLOC(); |
|
2
|
469 Cyg_Scheduler::lock(); |
|
|
470 // Enable dispatching (if disabled) and maybe switch threads |
|
|
471 if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
|
|
472 // We had prevented preemption by going up to prio 0 |
|
|
473 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
474 Cyg_Thread *p = Cyg_Thread::self(); |
|
|
475 p->set_priority( cyg_uitron_dis_dsp_old_priority ); |
|
|
476 p->to_queue_head(); // to ensure we continue to run |
|
|
477 // if nobody higher pri |
|
|
478 #endif |
|
|
479 cyg_uitron_dis_dsp_old_priority = 0; |
|
|
480 } |
|
|
481 Cyg_Scheduler::unlock(); |
|
0
|
482 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards! |
|
|
483 return E_OK; |
|
|
484 } |
|
|
485 |
|
|
486 |
|
|
487 CYG_UIT_FUNC_INLINE |
|
|
488 ER |
|
|
489 chg_pri ( ID tskid, PRI tskpri ) |
|
|
490 { |
|
|
491 Cyg_Thread *p; |
|
|
492 ER ret = E_OK; |
|
|
493 if ( 0 == tskid ) { |
|
|
494 p = Cyg_Thread::self(); |
|
|
495 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
|
|
496 } |
|
|
497 else |
|
|
498 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
2
|
499 |
|
|
500 CYG_UIT_PARAMCHECK( 0 < tskpri, E_PAR ); |
|
0
|
501 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
502 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY |
|
|
503 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri && |
|
|
504 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
|
|
505 #else |
|
|
506 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && |
|
|
507 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
|
|
508 #endif |
|
2
|
509 // Handle changing our own prio specially, if dispatch disabled: |
|
|
510 if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
|
|
511 // our actual prio is 0 now and must remain so: |
|
|
512 if ( Cyg_Thread::self() == p ) { // by whichever route p was set |
|
|
513 // set the priority we will return to when dispatch is enabled: |
|
|
514 cyg_uitron_dis_dsp_old_priority = (cyg_uint32)tskpri; |
|
|
515 return E_OK; |
|
|
516 } |
|
|
517 } |
|
0
|
518 Cyg_Scheduler::lock(); |
|
|
519 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
520 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
521 ret = E_OBJ; // task is dormant |
|
|
522 else |
|
|
523 p->set_priority( (cyg_priority)tskpri ); |
|
|
524 Cyg_Scheduler::unlock(); |
|
|
525 #endif // CYGIMP_THREAD_PRIORITY got priorities at all? |
|
|
526 return ret; |
|
|
527 } |
|
|
528 |
|
|
529 CYG_UIT_FUNC_INLINE |
|
|
530 ER |
|
|
531 rot_rdq ( PRI tskpri ) |
|
|
532 { |
|
|
533 // zero means our level; easiet way is to yield() the CPU. |
|
|
534 if ( 0 == tskpri ) { |
|
|
535 Cyg_Thread::yield(); |
|
|
536 return E_OK; |
|
|
537 } |
|
|
538 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
539 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY |
|
|
540 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri && |
|
|
541 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
|
|
542 #else |
|
|
543 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && |
|
|
544 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
|
|
545 #endif |
|
|
546 Cyg_Thread::rotate_queue( tskpri ); |
|
|
547 #endif // CYGIMP_THREAD_PRIORITY got priorities at all? |
|
|
548 return E_OK; |
|
|
549 } |
|
|
550 |
|
|
551 CYG_UIT_FUNC_INLINE |
|
|
552 ER |
|
|
553 rel_wai ( ID tskid ) |
|
|
554 { |
|
|
555 Cyg_Thread *p; |
|
|
556 ER ret = E_OK; |
|
|
557 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
558 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
559 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
560 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
561 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
562 ret = E_OBJ; // task is dormant |
|
|
563 else { |
|
|
564 p->release(); |
|
|
565 // return E_OBJ if the thread was not sleeping |
|
|
566 if ( Cyg_Thread::BREAK != p->get_wake_reason() ) |
|
|
567 ret = E_OBJ; |
|
|
568 } |
|
|
569 Cyg_Scheduler::unlock(); |
|
|
570 return ret; |
|
|
571 } |
|
|
572 |
|
|
573 CYG_UIT_FUNC_INLINE |
|
|
574 ER |
|
|
575 get_tid ( ID *p_tskid ) |
|
|
576 { |
|
|
577 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
578 CYG_UIT_PARAMCHECK_PTR( p_tskid ); |
|
2
|
579 if ( (&cyg_uitron_TASKS[0] <= (self)) && |
|
|
580 ((self) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]) ) |
|
|
581 // then I am a uITRON task |
|
|
582 *p_tskid = (self - (&cyg_uitron_TASKS[0])) + 1; |
|
|
583 else |
|
|
584 *p_tskid = 0; // Otherwise, non-task portion |
|
0
|
585 return E_OK; |
|
|
586 } |
|
|
587 |
|
|
588 CYG_UIT_FUNC_INLINE |
|
|
589 ER |
|
|
590 ref_tsk ( T_RTSK *pk_rtsk, ID tskid ) |
|
|
591 { |
|
|
592 Cyg_Thread *p; |
|
|
593 if ( 0 == tskid ) { |
|
|
594 p = Cyg_Thread::self(); |
|
|
595 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
|
|
596 tskid = (p - (&cyg_uitron_TASKS[0])) + 1; // it gets used below |
|
|
597 } |
|
|
598 else |
|
|
599 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
600 |
|
|
601 CYG_UIT_PARAMCHECK_PTR( pk_rtsk ); |
|
|
602 pk_rtsk->exinf = NADR; |
|
|
603 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
604 cyg_uint32 state = p->get_state(); |
|
|
605 if ( (state & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
606 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
607 pk_rtsk->tskstat = TTS_DMT; |
|
|
608 else if ( state == Cyg_Thread::RUNNING ) |
|
|
609 // If it's us, it's running, else it's ready |
|
|
610 pk_rtsk->tskstat = (Cyg_Thread::self() == p) |
|
|
611 ? TTS_RUN // RUN state (we are it) |
|
|
612 : TTS_RDY; // READY state |
|
|
613 else if ( state & Cyg_Thread::SUSPENDED ) |
|
|
614 pk_rtsk->tskstat = |
|
|
615 (state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING)) |
|
|
616 ? TTS_WAS // WAIT-SUSPEND state |
|
|
617 : TTS_SUS; // SUSPEND state |
|
|
618 else |
|
|
619 pk_rtsk->tskstat = |
|
|
620 (state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING)) |
|
|
621 ? TTS_WAI // WAIT state |
|
|
622 : 0; // Not sure what's happening here! |
|
|
623 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
624 if ( TTS_DMT == pk_rtsk->tskstat ) |
|
|
625 pk_rtsk->tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ); |
|
2
|
626 else if ( (TTS_RUN == pk_rtsk->tskstat) && |
|
|
627 (0 != cyg_uitron_dis_dsp_old_priority) ) |
|
|
628 // then we are it and dispatching is disabled, so |
|
|
629 // report our "real" priority - it is 0 in the kernel at the moment |
|
|
630 pk_rtsk->tskpri = cyg_uitron_dis_dsp_old_priority; |
|
0
|
631 else |
|
|
632 pk_rtsk->tskpri = p->get_priority(); |
|
|
633 #else |
|
|
634 pk_rtsk->tskpri = -1; // Not applicable |
|
|
635 #endif |
|
|
636 Cyg_Scheduler::unlock(); |
|
|
637 return E_OK; |
|
|
638 } |
|
|
639 |
|
|
640 // - Task-Dependent Synchronization Functions |
|
|
641 |
|
|
642 CYG_UIT_FUNC_INLINE |
|
|
643 ER |
|
|
644 sus_tsk ( ID tskid ) |
|
|
645 { |
|
|
646 Cyg_Thread *p; |
|
|
647 ER ret = E_OK; |
|
|
648 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
649 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
650 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
651 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
652 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
653 ret = E_OBJ; // task is dormant |
|
|
654 else |
|
|
655 p->suspend(); |
|
|
656 Cyg_Scheduler::unlock(); |
|
|
657 return ret; |
|
|
658 } |
|
|
659 |
|
|
660 CYG_UIT_FUNC_INLINE |
|
|
661 ER |
|
|
662 rsm_tsk ( ID tskid ) |
|
|
663 { |
|
|
664 Cyg_Thread *p; |
|
|
665 ER ret = E_OK; |
|
|
666 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
667 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
668 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
669 cyg_uint32 state = p->get_state(); |
|
|
670 if ( 0 == (Cyg_Thread::SUSPENDED & state) ) |
|
|
671 ret = E_OBJ; // thread is not suspended |
|
|
672 else |
|
|
673 p->resume(); |
|
|
674 Cyg_Scheduler::unlock(); |
|
|
675 return ret; |
|
|
676 } |
|
|
677 |
|
|
678 CYG_UIT_FUNC_INLINE |
|
|
679 ER |
|
|
680 frsm_tsk ( ID tskid ) |
|
|
681 { |
|
|
682 Cyg_Thread *p; |
|
|
683 ER ret = E_OK; |
|
|
684 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
685 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
686 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
687 cyg_uint32 state = p->get_state(); |
|
|
688 if ( 0 == (Cyg_Thread::SUSPENDED & state) ) |
|
|
689 ret = E_OBJ; // thread is not suspended |
|
|
690 else |
|
|
691 p->force_resume(); |
|
|
692 Cyg_Scheduler::unlock(); |
|
|
693 return ret; |
|
|
694 } |
|
|
695 |
|
|
696 CYG_UIT_FUNC_INLINE |
|
|
697 ER |
|
|
698 slp_tsk ( void ) |
|
|
699 { |
|
|
700 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
701 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
|
|
702 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
703 // do this now for the case when no sleeping actually occurs |
|
|
704 self->set_wake_reason( Cyg_Thread::DONE ); |
|
|
705 Cyg_Thread::counted_sleep(); |
|
|
706 if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
|
|
707 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
708 return E_OK; |
|
|
709 } |
|
|
710 |
|
|
711 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
712 CYG_UIT_FUNC_INLINE |
|
|
713 ER |
|
|
714 tslp_tsk ( TMO tmout ) |
|
|
715 { |
|
|
716 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
717 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
|
|
718 CYG_UIT_PARAMCHECK( -1 <= tmout, E_PAR ); |
|
|
719 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
720 // do this now for the case when no sleeping actually occurs |
|
|
721 self->set_wake_reason( Cyg_Thread::DONE ); |
|
|
722 // note that TMO_POL is not treated specially, though it |
|
|
723 // happens to work almost as a poll (some sleeping may occur) |
|
|
724 if ( TMO_FEVR == tmout ) |
|
|
725 Cyg_Thread::counted_sleep(); |
|
|
726 else |
|
|
727 Cyg_Thread::counted_sleep( (cyg_tick_count)tmout ); |
|
|
728 if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
|
|
729 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
730 return E_OK; |
|
|
731 } |
|
|
732 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
733 |
|
|
734 CYG_UIT_FUNC_INLINE |
|
|
735 ER |
|
|
736 wup_tsk ( ID tskid ) |
|
|
737 { |
|
|
738 Cyg_Thread *p; |
|
|
739 ER ret = E_OK; |
|
|
740 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
741 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
|
|
742 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
743 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
744 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
745 ret = E_OBJ; // task is dormant |
|
|
746 else |
|
|
747 p->counted_wake(); |
|
|
748 Cyg_Scheduler::unlock(); |
|
|
749 return ret; |
|
|
750 } |
|
|
751 |
|
|
752 CYG_UIT_FUNC_INLINE |
|
|
753 ER |
|
|
754 can_wup ( INT *p_wupcnt, ID tskid ) |
|
|
755 { |
|
|
756 Cyg_Thread *p; |
|
|
757 ER ret = E_OK; |
|
|
758 if ( 0 == tskid ) { |
|
|
759 p = Cyg_Thread::self(); |
|
|
760 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
|
|
761 } |
|
|
762 else |
|
|
763 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
|
764 CYG_UIT_PARAMCHECK_PTR( p_wupcnt ); |
|
|
765 Cyg_Scheduler::lock(); // get an atomic view of the task |
|
|
766 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
|
|
767 (Cyg_Thread::EXIT == p->get_wake_reason()) ) |
|
|
768 ret = E_OBJ; // task is dormant |
|
|
769 else { |
|
|
770 cyg_uint32 result = p->cancel_counted_wake(); |
|
|
771 *p_wupcnt = result; |
|
|
772 } |
|
|
773 Cyg_Scheduler::unlock(); |
|
|
774 return ret; |
|
|
775 } |
|
|
776 |
|
|
777 // - Synchronization and Communication Functions |
|
|
778 |
|
|
779 #ifdef CYGPKG_UITRON_SEMAS |
|
|
780 #if 0 < CYG_UITRON_NUM( SEMAS ) |
|
|
781 |
|
|
782 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
|
783 |
|
|
784 CYG_UITRON_NEWFUNCTION( Cyg_Counting_Semaphore2 ) |
|
|
785 |
|
|
786 CYG_UIT_FUNC_INLINE |
|
|
787 ER |
|
|
788 cre_sem ( ID semid, T_CSEM *pk_csem ) |
|
|
789 { |
|
|
790 ER ret = E_OK; |
|
|
791 CYG_UIT_PARAMCHECK_PTR( pk_csem ); |
|
|
792 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( SEMAS, semid ); |
|
|
793 if ( TA_TFIFO != pk_csem->sematr ) |
|
|
794 ret = E_RSATR; |
|
|
795 else |
|
|
796 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = |
|
|
797 new( &(CYG_UITRON_OBJS( SEMAS )[ semid - 1 ]) ) |
|
|
798 Cyg_Counting_Semaphore2( (cyg_count32)pk_csem->isemcnt ); |
|
|
799 Cyg_Scheduler::unlock(); |
|
|
800 return ret; |
|
|
801 } |
|
|
802 |
|
|
803 CYG_UIT_FUNC_INLINE |
|
|
804 ER |
|
|
805 del_sem ( ID semid ) |
|
|
806 { |
|
|
807 Cyg_Counting_Semaphore2 *p; |
|
|
808 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
809 Cyg_Scheduler::lock(); |
|
|
810 // deal with the race condition here |
|
|
811 if ( p != CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] ) { |
|
|
812 Cyg_Scheduler::unlock(); |
|
2
|
813 return E_NOEXS; |
|
0
|
814 } |
|
|
815 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = NULL; |
|
|
816 p->~Cyg_Counting_Semaphore2(); |
|
|
817 Cyg_Scheduler::unlock(); |
|
|
818 return E_OK; |
|
|
819 } |
|
|
820 #endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
|
821 |
|
|
822 CYG_UIT_FUNC_INLINE |
|
|
823 ER |
|
|
824 sig_sem( ID semid ) |
|
|
825 { |
|
|
826 Cyg_Counting_Semaphore2 *p; |
|
|
827 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
828 p->post(); |
|
|
829 return E_OK; |
|
|
830 } |
|
|
831 |
|
|
832 CYG_UIT_FUNC_INLINE |
|
|
833 ER |
|
|
834 wai_sem( ID semid ) |
|
|
835 { |
|
|
836 Cyg_Counting_Semaphore2 *p; |
|
|
837 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
838 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
839 cyg_bool result = p->wait(); |
|
|
840 if ( !result ) |
|
|
841 CYG_UITRON_FAIL_RETURN(); |
|
|
842 return E_OK; |
|
|
843 } |
|
|
844 |
|
|
845 CYG_UIT_FUNC_INLINE |
|
|
846 ER |
|
|
847 preq_sem ( ID semid ) |
|
|
848 { |
|
|
849 Cyg_Counting_Semaphore2 *p; |
|
|
850 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
851 cyg_bool result = p->trywait(); |
|
|
852 if ( !result ) |
|
|
853 return E_TMOUT; |
|
|
854 return E_OK; |
|
|
855 } |
|
|
856 |
|
|
857 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
858 CYG_UIT_FUNC_INLINE |
|
|
859 ER |
|
|
860 twai_sem ( ID semid, TMO tmout ) |
|
|
861 { |
|
|
862 Cyg_Counting_Semaphore2 *p; |
|
|
863 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
864 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
|
|
865 // do this now for the case when no sleeping actually occurs |
|
|
866 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
867 self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
|
|
868 cyg_bool result; |
|
|
869 if ( TMO_FEVR == tmout ) |
|
|
870 result = p->wait(); |
|
|
871 else if ( TMO_POL == tmout ) |
|
|
872 result = p->trywait(); |
|
|
873 else |
|
|
874 result = p->wait( |
|
|
875 Cyg_Clock::real_time_clock->current_value() + |
|
|
876 (cyg_tick_count)tmout ); |
|
|
877 if ( ! result ) |
|
|
878 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
879 return E_OK; |
|
|
880 |
|
|
881 } |
|
|
882 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
883 |
|
|
884 CYG_UIT_FUNC_INLINE |
|
|
885 ER |
|
|
886 ref_sem ( T_RSEM *pk_rsem, ID semid ) |
|
|
887 { |
|
|
888 Cyg_Counting_Semaphore2 *p; |
|
|
889 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
|
|
890 CYG_UIT_PARAMCHECK_PTR( pk_rsem ); |
|
|
891 pk_rsem->exinf = NADR; |
|
|
892 pk_rsem->wtsk = p->waiting(); |
|
|
893 pk_rsem->semcnt = p->peek(); |
|
|
894 return E_OK; |
|
|
895 } |
|
|
896 |
|
|
897 #endif // 0 < CYG_UITRON_NUM( SEMAS ) |
|
|
898 #endif // CYGPKG_UITRON_SEMAS |
|
|
899 |
|
|
900 #ifdef CYGPKG_UITRON_FLAGS |
|
|
901 #if 0 < CYG_UITRON_NUM( FLAGS ) |
|
|
902 |
|
|
903 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
|
904 |
|
|
905 CYG_UITRON_NEWFUNCTION( Cyg_Flag ) |
|
|
906 |
|
|
907 CYG_UIT_FUNC_INLINE |
|
|
908 ER |
|
|
909 cre_flg ( ID flgid, T_CFLG *pk_cflg ) |
|
|
910 { |
|
|
911 ER ret = E_OK; |
|
|
912 CYG_UIT_PARAMCHECK_PTR( pk_cflg ); |
|
|
913 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( FLAGS, flgid ); |
|
|
914 if ( 0 != ((~(TA_WMUL | TA_WSGL)) & pk_cflg->flgatr) ) |
|
|
915 ret = E_RSATR; |
|
|
916 else |
|
|
917 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = |
|
|
918 new( &(CYG_UITRON_OBJS( FLAGS )[ flgid - 1 ]) ) |
|
|
919 Cyg_Flag( (Cyg_FlagValue) pk_cflg->iflgptn ); |
|
|
920 Cyg_Scheduler::unlock(); |
|
|
921 return ret; |
|
|
922 } |
|
|
923 |
|
|
924 CYG_UIT_FUNC_INLINE |
|
|
925 ER |
|
|
926 del_flg ( ID flgid ) |
|
|
927 { |
|
|
928 Cyg_Flag *p; |
|
|
929 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
930 Cyg_Scheduler::lock(); |
|
|
931 // deal with the race condition here |
|
|
932 if ( p != CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] ) { |
|
|
933 Cyg_Scheduler::unlock(); |
|
2
|
934 return E_NOEXS; |
|
0
|
935 } |
|
|
936 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = NULL; |
|
|
937 p->~Cyg_Flag(); |
|
|
938 Cyg_Scheduler::unlock(); |
|
|
939 return E_OK; |
|
|
940 } |
|
|
941 #endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
|
942 |
|
|
943 CYG_UIT_FUNC_INLINE |
|
|
944 ER |
|
|
945 set_flg ( ID flgid, UINT setptn ) |
|
|
946 { |
|
|
947 Cyg_Flag *p; |
|
|
948 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
949 p->setbits( setptn ); |
|
|
950 return E_OK; |
|
|
951 } |
|
|
952 |
|
|
953 CYG_UIT_FUNC_INLINE |
|
|
954 ER |
|
|
955 clr_flg ( ID flgid, UINT clrptn ) |
|
|
956 { |
|
|
957 Cyg_Flag *p; |
|
|
958 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
959 p->maskbits( clrptn ); |
|
|
960 return E_OK; |
|
|
961 } |
|
|
962 |
|
|
963 CYG_UIT_FUNC_INLINE |
|
|
964 ER |
|
|
965 wai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ) |
|
|
966 { |
|
|
967 Cyg_Flag *p; |
|
|
968 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
969 CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
|
|
970 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
|
|
971 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
|
|
972 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
973 // check we can use the wfmode value unchanged |
|
|
974 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
|
|
975 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
|
|
976 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
|
977 |
|
|
978 UINT result = p->wait( waiptn, wfmode ); |
|
|
979 if ( ! result ) |
|
|
980 CYG_UITRON_FAIL_RETURN(); |
|
|
981 *p_flgptn = result; |
|
|
982 return E_OK; |
|
|
983 } |
|
|
984 |
|
|
985 CYG_UIT_FUNC_INLINE |
|
|
986 ER |
|
|
987 pol_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ) |
|
|
988 { |
|
|
989 Cyg_Flag *p; |
|
|
990 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
991 CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
|
|
992 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
|
|
993 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
|
|
994 // check we can use the wfmode value unchanged |
|
|
995 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
|
|
996 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
|
|
997 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
|
998 |
|
|
999 UINT result = p->poll( waiptn, wfmode ); |
|
|
1000 if ( ! result ) |
|
|
1001 return E_TMOUT; |
|
|
1002 *p_flgptn = result; |
|
|
1003 return E_OK; |
|
|
1004 } |
|
|
1005 |
|
|
1006 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
1007 CYG_UIT_FUNC_INLINE |
|
|
1008 ER |
|
|
1009 twai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode, |
|
|
1010 TMO tmout ) |
|
|
1011 { |
|
|
1012 Cyg_Flag *p; |
|
|
1013 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
1014 CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
|
|
1015 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
|
|
1016 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
|
|
1017 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
|
|
1018 // check we can use the wfmode value unchanged |
|
|
1019 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
|
|
1020 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
|
|
1021 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
|
1022 |
|
|
1023 // do this now for the case when no sleeping actually occurs |
|
|
1024 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
1025 self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
|
|
1026 UINT result; |
|
|
1027 if ( TMO_FEVR == tmout ) |
|
|
1028 result = p->wait( waiptn, wfmode ); |
|
|
1029 else if ( TMO_POL == tmout ) |
|
|
1030 result = p->poll( waiptn, wfmode ); |
|
|
1031 else |
|
|
1032 result = p->wait( waiptn, wfmode, |
|
|
1033 Cyg_Clock::real_time_clock->current_value() + |
|
|
1034 (cyg_tick_count)tmout ); |
|
|
1035 if ( ! result ) |
|
|
1036 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
1037 *p_flgptn = result; |
|
|
1038 return E_OK; |
|
|
1039 } |
|
|
1040 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
1041 |
|
|
1042 CYG_UIT_FUNC_INLINE |
|
|
1043 ER |
|
|
1044 ref_flg ( T_RFLG *pk_rflg, ID flgid ) |
|
|
1045 { |
|
|
1046 Cyg_Flag *p; |
|
|
1047 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
|
|
1048 CYG_UIT_PARAMCHECK_PTR( pk_rflg ); |
|
|
1049 pk_rflg->exinf = NADR; |
|
|
1050 pk_rflg->wtsk = p->waiting(); |
|
|
1051 pk_rflg->flgptn = p->peek(); |
|
|
1052 return E_OK; |
|
|
1053 } |
|
|
1054 |
|
|
1055 #endif // 0 < CYG_UITRON_NUM( FLAGS ) |
|
|
1056 #endif // CYGPKG_UITRON_FLAGS |
|
|
1057 |
|
|
1058 #ifdef CYGPKG_UITRON_MBOXES |
|
|
1059 #if 0 < CYG_UITRON_NUM( MBOXES ) |
|
|
1060 |
|
|
1061 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
|
1062 CYG_UITRON_NEWFUNCTION( Cyg_Mbox ) |
|
|
1063 |
|
|
1064 CYG_UIT_FUNC_INLINE |
|
|
1065 ER |
|
|
1066 cre_mbx ( ID mbxid, T_CMBX* pk_cmbx ) |
|
|
1067 { |
|
|
1068 ER ret = E_OK; |
|
|
1069 CYG_UIT_PARAMCHECK_PTR( pk_cmbx ); |
|
|
1070 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MBOXES, mbxid ); |
|
|
1071 if ( ((ATR)(TA_TFIFO + TA_MFIFO)) != pk_cmbx->mbxatr ) |
|
|
1072 ret = E_RSATR; |
|
|
1073 else |
|
|
1074 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = |
|
|
1075 new( &(CYG_UITRON_OBJS( MBOXES )[ mbxid - 1 ]) ) |
|
|
1076 Cyg_Mbox(); |
|
|
1077 Cyg_Scheduler::unlock(); |
|
|
1078 return ret; |
|
|
1079 } |
|
|
1080 |
|
|
1081 CYG_UIT_FUNC_INLINE |
|
|
1082 ER |
|
|
1083 del_mbx ( ID mbxid ) |
|
|
1084 { |
|
|
1085 Cyg_Mbox *p; |
|
|
1086 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1087 Cyg_Scheduler::lock(); |
|
|
1088 // deal with the race condition here |
|
|
1089 if ( p != CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] ) { |
|
|
1090 Cyg_Scheduler::unlock(); |
|
2
|
1091 return E_NOEXS; |
|
0
|
1092 } |
|
|
1093 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = NULL; |
|
|
1094 p->~Cyg_Mbox(); |
|
|
1095 Cyg_Scheduler::unlock(); |
|
|
1096 return E_OK; |
|
|
1097 } |
|
|
1098 #endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
|
1099 |
|
|
1100 // This bit of unpleasantness is to allow uITRON programs to send a NULL |
|
|
1101 // message - if permitted by the parameter checking. |
|
|
1102 // |
|
|
1103 // NULL is used internally to mean no message; but -1 is fine. So we send |
|
|
1104 // a NULL as a NADR and if we see a NULL coming back, change it to a NADR. |
|
|
1105 // |
|
|
1106 // One hopes that often this will be optimized out, since the one or both |
|
|
1107 // of these being true has been detected and errored out just above. |
|
|
1108 |
|
|
1109 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
1110 // represent a NULL as NADR internally |
|
2
|
1111 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_MACRO_START \ |
|
|
1112 if ( NULL == (_p_) ) \ |
|
|
1113 (_p_) = (T_MSG *)NADR; \ |
|
0
|
1114 CYG_MACRO_END |
|
|
1115 |
|
|
1116 // we get a NADR back sometimes, meaning NULL |
|
2
|
1117 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_MACRO_START \ |
|
|
1118 if ( NADR == (_p_) ) \ |
|
|
1119 (_p_) = (T_MSG *)NULL; \ |
|
0
|
1120 CYG_MACRO_END |
|
|
1121 |
|
|
1122 #else |
|
|
1123 // NULL is checked for and makes an error |
|
2
|
1124 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_EMPTY_STATEMENT |
|
|
1125 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_EMPTY_STATEMENT |
|
0
|
1126 #endif |
|
|
1127 |
|
|
1128 // and sometimes either in status enquiries |
|
2
|
1129 #define CYG_UIT_TMSG_FIXUP_ALL( _p_ ) CYG_MACRO_START \ |
|
|
1130 if ( NULL == (_p_) ) \ |
|
|
1131 (_p_) = (T_MSG *)NADR; \ |
|
|
1132 else if ( NADR == (_p_) ) \ |
|
|
1133 (_p_) = (T_MSG *)NULL; \ |
|
0
|
1134 CYG_MACRO_END |
|
|
1135 |
|
|
1136 CYG_UIT_FUNC_INLINE |
|
|
1137 ER |
|
|
1138 snd_msg ( ID mbxid, T_MSG *pk_msg ) |
|
|
1139 { |
|
|
1140 Cyg_Mbox *p; |
|
|
1141 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1142 CYG_UIT_PARAMCHECK_PTR( pk_msg ); |
|
|
1143 CYG_UIT_TMSG_FIXUP_IN( pk_msg ); |
|
|
1144 cyg_bool result = p->tryput( (void *)pk_msg ); |
|
|
1145 if ( ! result ) |
|
|
1146 return E_QOVR; |
|
|
1147 return E_OK; |
|
|
1148 } |
|
|
1149 |
|
|
1150 |
|
|
1151 CYG_UIT_FUNC_INLINE |
|
|
1152 ER |
|
|
1153 rcv_msg ( T_MSG **ppk_msg, ID mbxid ) |
|
|
1154 { |
|
|
1155 Cyg_Mbox *p; |
|
|
1156 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1157 CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
|
|
1158 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
1159 T_MSG *result = (T_MSG *)p->get(); |
|
|
1160 if ( ! result ) |
|
|
1161 CYG_UITRON_FAIL_RETURN(); |
|
|
1162 CYG_UIT_TMSG_FIXUP_OUT( result ); |
|
|
1163 *ppk_msg = result; |
|
|
1164 return E_OK; |
|
|
1165 } |
|
|
1166 |
|
|
1167 CYG_UIT_FUNC_INLINE |
|
|
1168 ER |
|
|
1169 prcv_msg ( T_MSG **ppk_msg, ID mbxid ) |
|
|
1170 { |
|
|
1171 Cyg_Mbox *p; |
|
|
1172 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1173 CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
|
|
1174 T_MSG *result = (T_MSG *)p->tryget(); |
|
|
1175 if ( ! result ) |
|
|
1176 return E_TMOUT; |
|
|
1177 CYG_UIT_TMSG_FIXUP_OUT( result ); |
|
|
1178 *ppk_msg = result; |
|
|
1179 return E_OK; |
|
|
1180 } |
|
|
1181 |
|
|
1182 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
1183 CYG_UIT_FUNC_INLINE |
|
|
1184 ER |
|
|
1185 trcv_msg ( T_MSG **ppk_msg, ID mbxid, TMO tmout ) |
|
|
1186 { |
|
|
1187 Cyg_Mbox *p; |
|
|
1188 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1189 CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
|
|
1190 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
|
|
1191 // do this now for the case when no sleeping actually occurs |
|
|
1192 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
1193 self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
|
|
1194 T_MSG *result; |
|
|
1195 if ( TMO_FEVR == tmout ) |
|
|
1196 result = (T_MSG *)p->get(); |
|
|
1197 else if ( TMO_POL == tmout ) |
|
|
1198 result = (T_MSG *)p->tryget(); |
|
|
1199 else |
|
|
1200 result = (T_MSG *)p->get( |
|
|
1201 Cyg_Clock::real_time_clock->current_value() + |
|
|
1202 (cyg_tick_count)tmout ); |
|
|
1203 if ( ! result ) |
|
|
1204 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
1205 CYG_UIT_TMSG_FIXUP_OUT( result ); |
|
|
1206 *ppk_msg = result; |
|
|
1207 return E_OK; |
|
|
1208 } |
|
|
1209 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
1210 |
|
|
1211 CYG_UIT_FUNC_INLINE |
|
|
1212 ER |
|
|
1213 ref_mbx ( T_RMBX *pk_rmbx, ID mbxid ) |
|
|
1214 { |
|
|
1215 Cyg_Mbox *p; |
|
|
1216 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
|
|
1217 CYG_UIT_PARAMCHECK_PTR( pk_rmbx ); |
|
|
1218 pk_rmbx->exinf = NADR; |
|
|
1219 pk_rmbx->wtsk = p->waiting_to_get(); |
|
|
1220 pk_rmbx->pk_msg = (T_MSG *)p->peek_item(); |
|
|
1221 CYG_UIT_TMSG_FIXUP_ALL( pk_rmbx->pk_msg ); |
|
|
1222 return E_OK; |
|
|
1223 } |
|
|
1224 |
|
|
1225 #undef CYG_UIT_TMSG_FIXUP_IN |
|
|
1226 #undef CYG_UIT_TMSG_FIXUP_OUT |
|
|
1227 #undef CYG_UIT_TMSG_FIXUP_ALL |
|
|
1228 |
|
|
1229 #endif // 0 < CYG_UITRON_NUM( MBOXES ) |
|
|
1230 #endif // CYGPKG_UITRON_MBOXES |
|
|
1231 |
|
|
1232 // - Extended Synchronization and Communication Functions |
|
|
1233 |
|
|
1234 #if 0 // NOT SUPPORTED |
|
2
|
1235 ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf ); |
|
|
1236 ER del_mbf ( ID mbfid ); |
|
|
1237 ER snd_mbf ( ID mbfid, VP msg, INT msgsz ); |
|
|
1238 ER psnd_mbf ( ID mbfid, VP msg, INT msgsz ); |
|
|
1239 ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout ); |
|
|
1240 ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
|
|
1241 ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
|
|
1242 ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout ); |
|
|
1243 ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid ); |
|
|
1244 ER cre_por ( ID porid, T_CPOR *pk_cpor ); |
|
|
1245 ER del_por ( ID porid ); |
|
|
1246 ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
|
0
|
1247 cmsgsz ); |
|
2
|
1248 ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
|
0
|
1249 cmsgsz ); |
|
2
|
1250 ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
|
0
|
1251 cmsgsz, TMO tmout ); |
|
2
|
1252 ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
|
0
|
1253 acpptn ); |
|
2
|
1254 ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
|
0
|
1255 acpptn ); |
|
2
|
1256 ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
|
0
|
1257 acpptn, TMO tmout ); |
|
2
|
1258 ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz |
|
0
|
1259 ); |
|
2
|
1260 ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz ); |
|
|
1261 ER ref_por ( T_RPOR *pk_rpor, ID porid ); |
|
0
|
1262 #endif |
|
|
1263 |
|
|
1264 // - Interrupt Management Functions |
|
|
1265 |
|
|
1266 #if 0 // NOT SUPPORTED |
|
2
|
1267 ER def_int ( UINT dintno, T_DINT *pk_dint ); |
|
|
1268 void ret_wup ( ID tskid ); |
|
0
|
1269 #endif |
|
|
1270 |
|
|
1271 CYG_UIT_FUNC_INLINE |
|
|
1272 ER |
|
|
1273 loc_cpu ( void ) |
|
|
1274 { |
|
|
1275 CYG_UITRON_CHECK_TASK_CONTEXT(); |
|
2
|
1276 Cyg_Scheduler::lock(); |
|
|
1277 // Prevent preemption by going up to prio 0 |
|
|
1278 if ( 0 == cyg_uitron_dis_dsp_old_priority ) { |
|
|
1279 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
1280 Cyg_Thread *p = Cyg_Thread::self(); |
|
|
1281 cyg_uitron_dis_dsp_old_priority = p->get_priority(); |
|
|
1282 p->set_priority( 0 ); |
|
|
1283 #else |
|
|
1284 cyg_uitron_dis_dsp_old_priority = 1; |
|
|
1285 #endif |
|
|
1286 } |
|
0
|
1287 Cyg_Interrupt::disable_interrupts(); |
|
2
|
1288 Cyg_Scheduler::unlock(); |
|
0
|
1289 return E_OK; |
|
|
1290 } |
|
|
1291 |
|
|
1292 CYG_UIT_FUNC_INLINE |
|
|
1293 ER |
|
|
1294 unl_cpu ( void ) |
|
|
1295 { |
|
|
1296 CYG_UITRON_CHECK_TASK_CONTEXT(); |
|
2
|
1297 Cyg_Scheduler::lock(); |
|
|
1298 // Enable dispatching (if disabled) and maybe switch threads |
|
|
1299 if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
|
|
1300 // We had prevented preemption by going up to prio 0 |
|
|
1301 #ifdef CYGIMP_THREAD_PRIORITY |
|
|
1302 Cyg_Thread *p = Cyg_Thread::self(); |
|
|
1303 p->set_priority( cyg_uitron_dis_dsp_old_priority ); |
|
|
1304 #endif |
|
|
1305 cyg_uitron_dis_dsp_old_priority = 0; |
|
|
1306 } |
|
0
|
1307 Cyg_Interrupt::enable_interrupts(); |
|
2
|
1308 Cyg_Scheduler::unlock(); |
|
|
1309 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards! |
|
0
|
1310 return E_OK; |
|
|
1311 } |
|
|
1312 |
|
|
1313 #if 0 // NOT SUPPORTED |
|
2
|
1314 ER dis_int ( UINT eintno ); |
|
|
1315 ER ena_int ( UINT eintno ); |
|
|
1316 ER chg_iXX ( UINT iXXXX ); |
|
|
1317 ER ref_iXX ( UINT *p_iXXXX ); |
|
0
|
1318 #endif |
|
|
1319 |
|
|
1320 // - Memorypool Management Functions |
|
|
1321 #ifdef CYGPKG_UITRON_MEMPOOLVAR |
|
|
1322 #if 0 < CYG_UITRON_NUM( MEMPOOLVAR ) |
|
|
1323 |
|
|
1324 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
|
1325 |
|
|
1326 CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Variable ) |
|
|
1327 |
|
|
1328 CYG_UIT_FUNC_INLINE |
|
|
1329 ER |
|
|
1330 cre_mpl ( ID mplid, T_CMPL *pk_cmpl ) |
|
|
1331 { |
|
|
1332 ER ret = E_OK; |
|
|
1333 CYG_UIT_PARAMCHECK_PTR( pk_cmpl ); |
|
|
1334 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLVAR, mplid ); |
|
|
1335 Cyg_Mempool_Variable *p = &(CYG_UITRON_OBJS( MEMPOOLVAR )[ mplid - 1 ]); |
|
|
1336 cyg_uint8 *base; |
|
|
1337 cyg_int32 size; |
|
|
1338 CYG_ADDRWORD scratch; |
|
|
1339 // preserve the original memory area to use |
|
|
1340 p->get_arena( base, size, scratch ); |
|
|
1341 |
|
|
1342 if ( size < pk_cmpl->mplsz ) |
|
|
1343 ret = E_NOMEM; |
|
|
1344 else if ( TA_TFIFO != pk_cmpl->mplatr ) |
|
|
1345 ret = E_RSATR; |
|
|
1346 else |
|
|
1347 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = |
|
|
1348 new( p ) Cyg_Mempool_Variable( base, size ); |
|
|
1349 Cyg_Scheduler::unlock(); |
|
|
1350 return ret; |
|
|
1351 } |
|
|
1352 |
|
|
1353 CYG_UIT_FUNC_INLINE |
|
|
1354 ER |
|
|
1355 del_mpl ( ID mplid ) |
|
|
1356 { |
|
|
1357 Cyg_Mempool_Variable *p; |
|
|
1358 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1359 Cyg_Scheduler::lock(); |
|
|
1360 // deal with the race condition here |
|
|
1361 if ( p != CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] ) { |
|
|
1362 Cyg_Scheduler::unlock(); |
|
2
|
1363 return E_NOEXS; |
|
0
|
1364 } |
|
|
1365 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = NULL; |
|
|
1366 p->~Cyg_Mempool_Variable(); |
|
|
1367 Cyg_Scheduler::unlock(); |
|
|
1368 return E_OK; |
|
|
1369 } |
|
|
1370 #endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
|
1371 |
|
|
1372 CYG_UIT_FUNC_INLINE |
|
|
1373 ER |
|
|
1374 get_blk ( VP *p_blk, ID mplid, INT blksz ) |
|
|
1375 { |
|
|
1376 Cyg_Mempool_Variable *p; |
|
|
1377 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1378 CYG_UIT_PARAMCHECK_PTR( p_blk ); |
|
|
1379 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
|
|
1380 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
1381 VP result = (VP)p->alloc(blksz); |
|
|
1382 if ( ! result ) |
|
|
1383 CYG_UITRON_FAIL_RETURN(); |
|
|
1384 *p_blk = result; |
|
|
1385 return E_OK; |
|
|
1386 } |
|
|
1387 |
|
|
1388 |
|
|
1389 CYG_UIT_FUNC_INLINE |
|
|
1390 ER |
|
|
1391 pget_blk ( VP *p_blk, ID mplid, INT blksz ) |
|
|
1392 { |
|
|
1393 Cyg_Mempool_Variable *p; |
|
|
1394 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1395 CYG_UIT_PARAMCHECK_PTR( p_blk ); |
|
|
1396 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
|
|
1397 VP result = (VP)p->try_alloc(blksz); |
|
|
1398 if ( ! result ) |
|
|
1399 return E_TMOUT; |
|
|
1400 *p_blk = result; |
|
|
1401 return E_OK; |
|
|
1402 } |
|
|
1403 |
|
|
1404 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
1405 CYG_UIT_FUNC_INLINE |
|
|
1406 ER |
|
|
1407 tget_blk ( VP *p_blk, ID mplid, INT blksz, TMO tmout ) |
|
|
1408 { |
|
|
1409 Cyg_Mempool_Variable *p; |
|
|
1410 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1411 CYG_UIT_PARAMCHECK_PTR( p_blk ); |
|
|
1412 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
|
|
1413 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
|
|
1414 // do this now for the case when no sleeping actually occurs |
|
|
1415 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
1416 self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
|
|
1417 VP result; |
|
|
1418 if ( TMO_FEVR == tmout ) |
|
|
1419 result = p->alloc(blksz); |
|
|
1420 else if ( TMO_POL == tmout ) |
|
|
1421 result = p->try_alloc(blksz); |
|
|
1422 else |
|
|
1423 result = p->alloc( blksz, |
|
|
1424 Cyg_Clock::real_time_clock->current_value() + |
|
|
1425 (cyg_tick_count)tmout ); |
|
|
1426 if ( ! result ) |
|
|
1427 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
1428 *p_blk = result; |
|
|
1429 return E_OK; |
|
|
1430 } |
|
|
1431 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
1432 |
|
|
1433 CYG_UIT_FUNC_INLINE |
|
|
1434 ER |
|
|
1435 rel_blk ( ID mplid, VP blk ) |
|
|
1436 { |
|
|
1437 Cyg_Mempool_Variable *p; |
|
|
1438 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1439 CYG_UIT_PARAMCHECK_PTR( blk ); |
|
|
1440 cyg_bool result = p->free( (cyg_uint8 *)blk, 0 ); |
|
|
1441 if ( ! result ) |
|
|
1442 return E_PAR; |
|
|
1443 return E_OK; |
|
|
1444 } |
|
|
1445 |
|
|
1446 CYG_UIT_FUNC_INLINE |
|
|
1447 ER |
|
|
1448 ref_mpl ( T_RMPL *pk_rmpl, ID mplid ) |
|
|
1449 { |
|
|
1450 Cyg_Mempool_Variable *p; |
|
|
1451 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
|
|
1452 CYG_UIT_PARAMCHECK_PTR( pk_rmpl ); |
|
|
1453 pk_rmpl->exinf = NADR; |
|
|
1454 pk_rmpl->wtsk = p->waiting(); |
|
|
1455 pk_rmpl->frsz = p->get_freemem(); |
|
|
1456 |
|
|
1457 cyg_uint8 *base; |
|
|
1458 cyg_int32 size; |
|
|
1459 CYG_ADDRWORD maxfree; |
|
|
1460 p->get_arena(base, size, maxfree); |
|
|
1461 pk_rmpl->maxsz = maxfree; |
|
|
1462 |
|
|
1463 return E_OK; |
|
|
1464 } |
|
|
1465 |
|
|
1466 #endif // 0 < CYG_UITRON_NUM( MEMPOOLVAR ) |
|
|
1467 #endif // CYGPKG_UITRON_MEMPOOLVAR |
|
|
1468 |
|
|
1469 #ifdef CYGPKG_UITRON_MEMPOOLFIXED |
|
|
1470 #if 0 < CYG_UITRON_NUM( MEMPOOLFIXED ) |
|
|
1471 |
|
|
1472 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
|
1473 |
|
|
1474 CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Fixed ) |
|
|
1475 |
|
|
1476 CYG_UIT_FUNC_INLINE |
|
|
1477 ER |
|
|
1478 cre_mpf ( ID mpfid, T_CMPF *pk_cmpf ) |
|
|
1479 { |
|
|
1480 ER ret = E_OK; |
|
|
1481 CYG_UIT_PARAMCHECK_PTR( pk_cmpf ); |
|
|
1482 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLFIXED, mpfid ); |
|
|
1483 Cyg_Mempool_Fixed *p = &(CYG_UITRON_OBJS( MEMPOOLFIXED )[ mpfid - 1 ]); |
|
|
1484 cyg_uint8 *base; |
|
|
1485 cyg_int32 size; |
|
|
1486 CYG_ADDRWORD scratch; |
|
|
1487 // preserve the original memory area to use |
|
|
1488 p->get_arena( base, size, scratch ); |
|
|
1489 |
|
|
1490 if ( size < (pk_cmpf->blfsz * (pk_cmpf->mpfcnt + 1)) ) |
|
|
1491 ret = E_NOMEM; |
|
|
1492 else if ( TA_TFIFO != pk_cmpf->mpfatr ) |
|
|
1493 ret = E_RSATR; |
|
|
1494 else |
|
|
1495 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = |
|
|
1496 new( p ) |
|
|
1497 Cyg_Mempool_Fixed( base, size, |
|
|
1498 (CYG_ADDRWORD)pk_cmpf->blfsz ); |
|
|
1499 Cyg_Scheduler::unlock(); |
|
|
1500 return ret; |
|
|
1501 } |
|
|
1502 |
|
|
1503 CYG_UIT_FUNC_INLINE |
|
|
1504 ER |
|
|
1505 del_mpf ( ID mpfid ) |
|
|
1506 { |
|
|
1507 Cyg_Mempool_Fixed *p; |
|
|
1508 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1509 Cyg_Scheduler::lock(); |
|
|
1510 // deal with the race condition here |
|
|
1511 if ( p != CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] ) { |
|
|
1512 Cyg_Scheduler::unlock(); |
|
2
|
1513 return E_NOEXS; |
|
0
|
1514 } |
|
|
1515 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = NULL; |
|
|
1516 p->~Cyg_Mempool_Fixed(); |
|
|
1517 Cyg_Scheduler::unlock(); |
|
|
1518 return E_OK; |
|
|
1519 } |
|
|
1520 #endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
|
1521 |
|
|
1522 CYG_UIT_FUNC_INLINE |
|
|
1523 ER |
|
|
1524 get_blf ( VP *p_blf, ID mpfid ) |
|
|
1525 { |
|
|
1526 Cyg_Mempool_Fixed *p; |
|
|
1527 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1528 CYG_UIT_PARAMCHECK_PTR( p_blf ); |
|
|
1529 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
1530 VP result = (VP)p->alloc(); |
|
|
1531 if ( ! result ) |
|
|
1532 CYG_UITRON_FAIL_RETURN(); |
|
|
1533 *p_blf = result; |
|
|
1534 return E_OK; |
|
|
1535 } |
|
|
1536 |
|
|
1537 CYG_UIT_FUNC_INLINE |
|
|
1538 ER |
|
|
1539 pget_blf ( VP *p_blf, ID mpfid ) |
|
|
1540 { |
|
|
1541 Cyg_Mempool_Fixed *p; |
|
|
1542 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1543 CYG_UIT_PARAMCHECK_PTR( p_blf ); |
|
|
1544 VP result = (VP)p->try_alloc(); |
|
|
1545 if ( ! result ) |
|
|
1546 return E_TMOUT; |
|
|
1547 *p_blf = result; |
|
|
1548 return E_OK; |
|
|
1549 } |
|
|
1550 |
|
|
1551 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
1552 CYG_UIT_FUNC_INLINE |
|
|
1553 ER |
|
|
1554 tget_blf ( VP *p_blf, ID mpfid, TMO tmout ) |
|
|
1555 { |
|
|
1556 Cyg_Mempool_Fixed *p; |
|
|
1557 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1558 CYG_UIT_PARAMCHECK_PTR( p_blf ); |
|
|
1559 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
|
|
1560 // do this now for the case when no sleeping actually occurs |
|
|
1561 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
1562 self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
|
|
1563 VP result; |
|
|
1564 if ( TMO_FEVR == tmout ) |
|
|
1565 result = p->alloc(); |
|
|
1566 else if ( TMO_POL == tmout ) |
|
|
1567 result = p->try_alloc(); |
|
|
1568 else |
|
|
1569 result = p->alloc( |
|
|
1570 Cyg_Clock::real_time_clock->current_value() + |
|
|
1571 (cyg_tick_count)tmout ); |
|
|
1572 if ( ! result ) |
|
|
1573 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
1574 *p_blf = result; |
|
|
1575 return E_OK; |
|
|
1576 } |
|
|
1577 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
1578 |
|
|
1579 CYG_UIT_FUNC_INLINE |
|
|
1580 ER |
|
|
1581 rel_blf ( ID mpfid, VP blf ) |
|
|
1582 { |
|
|
1583 Cyg_Mempool_Fixed *p; |
|
|
1584 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1585 CYG_UIT_PARAMCHECK_PTR( blf ); |
|
|
1586 cyg_bool result = p->free( (cyg_uint8 *)blf ); |
|
|
1587 if ( ! result ) |
|
|
1588 return E_PAR; |
|
|
1589 return E_OK; |
|
|
1590 } |
|
|
1591 |
|
|
1592 CYG_UIT_FUNC_INLINE |
|
|
1593 ER |
|
|
1594 ref_mpf ( T_RMPF *pk_rmpf, ID mpfid ) |
|
|
1595 { |
|
|
1596 Cyg_Mempool_Fixed *p; |
|
|
1597 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
|
|
1598 CYG_UIT_PARAMCHECK_PTR( pk_rmpf ); |
|
|
1599 pk_rmpf->exinf = NADR; |
|
|
1600 pk_rmpf->wtsk = p->waiting(); |
|
|
1601 |
|
|
1602 cyg_int32 blocksize = p->get_blocksize(); |
|
|
1603 pk_rmpf->frbcnt = p->get_freemem() / blocksize; |
|
|
1604 // these two are "implementation dependent" ie. eCos only |
|
|
1605 pk_rmpf->numbcnt = p->get_totalmem() / blocksize; |
|
|
1606 pk_rmpf->bsize = blocksize; |
|
|
1607 |
|
|
1608 return E_OK; |
|
|
1609 } |
|
|
1610 |
|
|
1611 #endif // 0 < CYG_UITRON_NUM( MEMPOOLFIXED ) |
|
|
1612 #endif // CYGPKG_UITRON_MEMPOOLFIXED |
|
|
1613 |
|
|
1614 // - Time Management Functions |
|
|
1615 |
|
|
1616 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
|
|
1617 CYG_UIT_FUNC_INLINE |
|
|
1618 ER |
|
|
1619 set_tim ( SYSTIME *pk_tim ) |
|
|
1620 { |
|
|
1621 CYG_UIT_PARAMCHECK_PTR( pk_tim ); |
|
|
1622 Cyg_Clock::real_time_clock->set_value( *pk_tim ); |
|
|
1623 return E_OK; |
|
|
1624 } |
|
|
1625 |
|
|
1626 CYG_UIT_FUNC_INLINE |
|
|
1627 ER |
|
|
1628 get_tim ( SYSTIME *pk_tim ) |
|
|
1629 { |
|
|
1630 CYG_UIT_PARAMCHECK_PTR( pk_tim ); |
|
|
1631 *pk_tim = Cyg_Clock::real_time_clock->current_value(); |
|
|
1632 return E_OK; |
|
|
1633 } |
|
|
1634 #endif // CYGVAR_KERNEL_COUNTERS_CLOCK |
|
|
1635 |
|
|
1636 |
|
|
1637 #ifdef CYGFUN_KERNEL_THREADS_TIMER |
|
|
1638 CYG_UIT_FUNC_INLINE |
|
|
1639 ER |
|
|
1640 dly_tsk ( DLYTIME dlytim ) |
|
|
1641 { |
|
|
1642 CYG_UIT_PARAMCHECK( 0 <= dlytim, E_PAR ); |
|
|
1643 CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
|
|
1644 if ( 0 >= dlytim ) |
|
|
1645 return E_OK; |
|
|
1646 Cyg_Thread *self = Cyg_Thread::self(); |
|
|
1647 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
|
|
1648 self->delay( dlytim ); |
|
|
1649 if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
|
|
1650 CYG_UITRON_FAIL_RETURN_SELF( self ); |
|
|
1651 return E_OK; |
|
|
1652 } |
|
|
1653 #endif // CYGFUN_KERNEL_THREADS_TIMER |
|
|
1654 |
|
|
1655 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
|
|
1656 #ifdef CYGPKG_UITRON_CYCLICS |
|
|
1657 #if 0 < CYG_UITRON_NUM( CYCLICS ) |
|
|
1658 CYG_UIT_FUNC_INLINE |
|
|
1659 ER |
|
|
1660 def_cyc ( HNO cycno, T_DCYC *pk_dcyc ) |
|
|
1661 { |
|
|
1662 // pk_dcyc->cycatr is ignored |
|
|
1663 // The only relevant attribute is TA_HLNG/TA_ASM. |
|
|
1664 // This can be ignored as assembler routines are defined to be |
|
|
1665 // more conservative with registers than the procedure call standard. |
|
|
1666 |
|
|
1667 Cyg_Timer *p; |
|
|
1668 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
|
|
1669 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
1670 CYG_UIT_PARAMCHECK( NULL != pk_dcyc, E_PAR ); |
|
|
1671 #endif |
|
|
1672 if( NADR == pk_dcyc ) { |
|
|
1673 p->~Cyg_Timer(); |
|
|
1674 return E_OK; |
|
|
1675 } |
|
|
1676 CYG_UIT_PARAMCHECK( 0 == (pk_dcyc->cycact & ~TCY_ON), E_PAR ); |
|
|
1677 CYG_UIT_PARAMCHECK( 0 < pk_dcyc->cyctim, E_PAR ); |
|
|
1678 p->initialize( |
|
|
1679 Cyg_Clock::real_time_clock, |
|
|
1680 (cyg_alarm_fn *)pk_dcyc->cychdr, |
|
|
1681 (CYG_ADDRWORD)pk_dcyc->exinf, |
|
|
1682 Cyg_Clock::real_time_clock->current_value() + pk_dcyc->cyctim, |
|
|
1683 pk_dcyc->cyctim, |
|
|
1684 pk_dcyc->cycact); |
|
|
1685 return E_OK; |
|
|
1686 } |
|
|
1687 |
|
|
1688 CYG_UIT_FUNC_INLINE |
|
|
1689 ER |
|
|
1690 act_cyc ( HNO cycno, UINT cycact ) |
|
|
1691 { |
|
|
1692 Cyg_Timer *p; |
|
|
1693 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
|
|
1694 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
|
|
1695 CYG_UIT_PARAMCHECK( 0 == (cycact & ~(TCY_ON | TCY_INI)), E_PAR ); |
|
|
1696 p->activate(cycact); |
|
|
1697 return E_OK; |
|
|
1698 } |
|
|
1699 |
|
|
1700 |
|
|
1701 CYG_UIT_FUNC_INLINE |
|
|
1702 ER |
|
|
1703 ref_cyc ( T_RCYC *pk_rcyc, HNO cycno ) |
|
|
1704 { |
|
|
1705 Cyg_Timer *p; |
|
|
1706 cyg_tick_count t; |
|
|
1707 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
|
|
1708 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
|
|
1709 CYG_UIT_PARAMCHECK_PTR( pk_rcyc ); |
|
|
1710 |
|
|
1711 pk_rcyc->exinf = (VP)p->get_data(); |
|
|
1712 Cyg_Scheduler::lock(); |
|
|
1713 t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value(); |
|
|
1714 Cyg_Scheduler::unlock(); |
|
|
1715 pk_rcyc->lfttim = t; |
|
|
1716 pk_rcyc->cycact = (UINT)p->is_enabled(); |
|
|
1717 return E_OK; |
|
|
1718 } |
|
|
1719 #endif // 0 < CYG_UITRON_NUM( CYCLICS ) |
|
|
1720 #endif // CYGPKG_UITRON_CYCLICS |
|
|
1721 |
|
|
1722 #ifdef CYGPKG_UITRON_ALARMS |
|
|
1723 #if 0 < CYG_UITRON_NUM( ALARMS ) |
|
|
1724 CYG_UIT_FUNC_INLINE |
|
|
1725 ER |
|
|
1726 def_alm ( HNO almno, T_DALM *pk_dalm ) |
|
|
1727 { |
|
|
1728 Cyg_Timer *p; |
|
|
1729 cyg_tick_count t, now; |
|
|
1730 CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p ); |
|
|
1731 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
1732 CYG_UIT_PARAMCHECK( NULL != pk_dalm, E_PAR ); |
|
|
1733 #endif |
|
|
1734 if( NADR == pk_dalm ) { |
|
|
1735 p->~Cyg_Timer(); |
|
|
1736 return E_OK; |
|
|
1737 } |
|
|
1738 |
|
|
1739 CYG_UIT_PARAMCHECK( 0 == (pk_dalm->tmmode & ~TTM_REL), E_PAR ); |
|
|
1740 |
|
|
1741 // make the time arithmetic safe without locking |
|
|
1742 now = Cyg_Clock::real_time_clock->current_value(); |
|
|
1743 t = pk_dalm->almtim; |
|
|
1744 if( TTM_REL & pk_dalm->tmmode ) |
|
|
1745 t += now; |
|
|
1746 |
|
|
1747 CYG_UIT_PARAMCHECK( now < t, E_PAR ); |
|
|
1748 |
|
|
1749 p->initialize(Cyg_Clock::real_time_clock, |
|
|
1750 (cyg_alarm_fn *)pk_dalm->almhdr, |
|
|
1751 (CYG_ADDRWORD)pk_dalm->exinf, |
|
|
1752 t, 0, Cyg_Timer::ENABLE); |
|
|
1753 |
|
|
1754 return E_OK; |
|
|
1755 } |
|
|
1756 |
|
|
1757 CYG_UIT_FUNC_INLINE |
|
|
1758 ER |
|
|
1759 ref_alm ( T_RALM *pk_ralm, HNO almno ) |
|
|
1760 { |
|
|
1761 Cyg_Timer *p; |
|
|
1762 cyg_tick_count t; |
|
|
1763 |
|
|
1764 CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p ); |
|
|
1765 CYG_UIT_PARAMCHECK_PTR( pk_ralm ); |
|
|
1766 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
|
|
1767 |
|
|
1768 Cyg_Scheduler::lock(); |
|
|
1769 t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value(); |
|
|
1770 Cyg_Scheduler::unlock(); |
|
|
1771 pk_ralm->exinf = (VP)p->get_data(); |
|
|
1772 pk_ralm->lfttim = t; |
|
|
1773 return E_OK; |
|
|
1774 } |
|
|
1775 #endif // 0 < CYG_UITRON_NUM( ALARMS ) |
|
|
1776 #endif // CYGPKG_UITRON_ALARMS |
|
|
1777 |
|
|
1778 #endif // CYGVAR_KERNEL_COUNTERS_CLOCK |
|
|
1779 |
|
|
1780 // - System Management Functions |
|
|
1781 |
|
|
1782 CYG_UIT_FUNC_INLINE |
|
|
1783 ER |
|
|
1784 get_ver ( T_VER *pk_ver ) |
|
|
1785 { |
|
|
1786 CYG_UIT_PARAMCHECK_PTR( pk_ver ); |
|
|
1787 |
|
2
|
1788 pk_ver->maker = CYGNUM_UITRON_VER_MAKER; |
|
|
1789 pk_ver->id = CYGNUM_UITRON_VER_ID; |
|
|
1790 pk_ver->spver = CYGNUM_UITRON_VER_SPVER; |
|
|
1791 pk_ver->prver = CYGNUM_UITRON_VER_PRVER; |
|
|
1792 pk_ver->prno[0] = CYGNUM_UITRON_VER_PRNO_0; |
|
|
1793 pk_ver->prno[1] = CYGNUM_UITRON_VER_PRNO_1; |
|
|
1794 pk_ver->prno[2] = CYGNUM_UITRON_VER_PRNO_2; |
|
|
1795 pk_ver->prno[3] = CYGNUM_UITRON_VER_PRNO_3; |
|
|
1796 pk_ver->cpu = CYGNUM_UITRON_VER_CPU; |
|
|
1797 pk_ver->var = CYGNUM_UITRON_VER_VAR; |
|
0
|
1798 |
|
|
1799 return E_OK; |
|
|
1800 } |
|
|
1801 |
|
|
1802 CYG_UIT_FUNC_INLINE |
|
|
1803 ER |
|
|
1804 ref_sys ( T_RSYS *pk_rsys ) |
|
|
1805 { |
|
|
1806 CYG_UIT_PARAMCHECK_PTR( pk_rsys ); |
|
|
1807 if ( ! Cyg_Interrupt::interrupts_enabled() ) |
|
|
1808 // CPU is locked |
|
|
1809 pk_rsys->sysstat = TSS_LOC; |
|
|
1810 else |
|
|
1811 pk_rsys->sysstat = |
|
2
|
1812 (0 == cyg_uitron_dis_dsp_old_priority) ? TSS_TSK : TSS_DDSP; |
|
0
|
1813 return E_OK; |
|
|
1814 } |
|
|
1815 |
|
|
1816 CYG_UIT_FUNC_INLINE |
|
|
1817 ER |
|
|
1818 ref_cfg ( T_RCFG *pk_rcfg ) |
|
|
1819 { |
|
|
1820 CYG_UIT_PARAMCHECK_PTR( pk_rcfg ); |
|
|
1821 // no details here yet |
|
|
1822 return E_OK; |
|
|
1823 } |
|
|
1824 |
|
|
1825 #if 0 // NOT SUPPORTED |
|
2
|
1826 ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc ); |
|
|
1827 ER def_exc ( UINT exckind, T_DEXC *pk_dexc ); |
|
0
|
1828 #endif |
|
|
1829 |
|
|
1830 // - Network Support Functions |
|
|
1831 |
|
|
1832 #if 0 // NOT SUPPORTED |
|
2
|
1833 ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr, |
|
0
|
1834 INT datsz ); |
|
2
|
1835 ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr, |
|
0
|
1836 INT datsz ); |
|
2
|
1837 ER nget_nod ( NODE *p_node ); |
|
|
1838 ER nget_ver ( T_VER *pk_ver, NODE node ); |
|
0
|
1839 #endif |
|
|
1840 |
|
|
1841 // ======================================================================== |
|
|
1842 |
|
|
1843 #endif // CYGPKG_UITRON |
|
|
1844 |
|
|
1845 #endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
|
1846 |
|
|
1847 #endif // CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
|
|
1848 //EOF uit_func.inl |
