1 #ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_INL
2 #define CYGONCE_COMPAT_UITRON_UIT_FUNC_INL
3 //===========================================================================
7 // uITRON compatibility functions
9 //===========================================================================
10 //####ECOSGPLCOPYRIGHTBEGIN####
11 // -------------------------------------------
12 // This file is part of eCos, the Embedded Configurable Operating System.
13 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
15 // eCos is free software; you can redistribute it and/or modify it under
16 // the terms of the GNU General Public License as published by the Free
17 // Software Foundation; either version 2 or (at your option) any later version.
19 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
20 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24 // You should have received a copy of the GNU General Public License along
25 // with eCos; if not, write to the Free Software Foundation, Inc.,
26 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
28 // As a special exception, if other files instantiate templates or use macros
29 // or inline functions from this file, or you compile this file and link it
30 // with other works to produce a work based on this file, this file does not
31 // by itself cause the resulting work to be covered by the GNU General Public
32 // License. However the source code for this file must still be made available
33 // in accordance with section (3) of the GNU General Public License.
35 // This exception does not invalidate any other reasons why a work based on
36 // this file might be covered by the GNU General Public License.
38 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
39 // at http://sources.redhat.com/ecos/ecos-license/
40 // -------------------------------------------
41 //####ECOSGPLCOPYRIGHTEND####
42 //===========================================================================
43 //#####DESCRIPTIONBEGIN####
48 // Purpose: uITRON compatibility functions
51 //####DESCRIPTIONEND####
53 //===========================================================================
57 #ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW
59 #include <cyg/compat/uitron/uit_objs.hxx> // uITRON setup CYGNUM_UITRON_SEMAS
61 // kernel facilities only needed here
62 #include <cyg/kernel/intr.hxx>
63 #include <cyg/kernel/sched.hxx>
65 // and the implementations of other kernel facilities
66 #include <cyg/kernel/thread.inl>
67 #include <cyg/kernel/sched.inl>
68 #include <cyg/kernel/clock.inl>
71 // ------------------------------------------------------------------------
72 // The variable where dis_dsp/ena_dsp state is held:
73 extern cyg_uint32 cyg_uitron_dis_dsp_old_priority;
75 // ------------------------------------------------------------------------
76 // Parameter checking; either check the expression and return an error code
77 // if not true, or assert the truth with a made-up message.
79 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
80 // default: uitron error codes are returned
81 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \
82 if ( ! (_true_) ) return (_error_); \
85 // ...but they are asserted if asserts are on
86 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \
87 CYG_ASSERT( (_true_), "CYG_UIT_PARAMCHECK fail: " #_true_ ); \
89 #endif // else !CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
91 // ------------------------------------------------------------------------
92 // CYG_UITRON_CHECK_AND_GETP
94 // Macro to rangecheck and do the addressing of a static uitron system
95 // object; _which_ sort of object is given, and token pasting is used
96 // horribly to get the static array, limits and the like.
99 // INT snd_msg( ID mbxid, ... ) {
101 // CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
104 // internal: plain assignment to the object pointer, from static array
105 #define CYG_UIT_SPTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \
106 (_ptr_) = CYG_UITRON_OBJS( _which_ ) + ((_idx_) - 1); \
109 // internal: plain assignment to the object pointer, from pointer array
110 // with error checking.
111 #define CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \
112 (_ptr_) = CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ]; \
113 if ( NULL == (_ptr_) ) return E_NOEXS; \
116 #define CYG_UITRON_CHECK_AND_GETP_DIRECT( _which_, _idx_, _ptr_ ) \
118 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
119 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
120 CYG_UIT_SPTR( _which_, _idx_, _ptr_ ); \
123 #define CYG_UITRON_CHECK_AND_GETP_INDIRECT( _which_, _idx_, _ptr_ ) \
125 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
126 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
127 CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ); \
130 // As above but for handler numbers which return E_PAR when out of range
131 #define CYG_UITRON_CHECK_AND_GETHDLR( _which_, _num_, _ptr_ ) \
133 CYG_UIT_PARAMCHECK( 0 < (_num_), E_PAR ); \
134 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_num_), E_PAR ); \
135 CYG_UIT_SPTR( _which_, _num_, _ptr_ ); \
138 // And a macro to check that creation of an object is OK
139 #define CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( _which_, _idx_ ) \
141 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
142 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
143 Cyg_Scheduler::lock(); \
144 if ( NULL != CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ] ) { \
145 Cyg_Scheduler::unlock(); \
150 // define a magic new operator in order to call constructors
151 #define CYG_UITRON_NEWFUNCTION( _class_ ) \
152 inline void *operator new(size_t size, _class_ *ptr) \
154 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); \
158 // now configury to support selectable create/delete support ie. an
159 // array of pointers to the objects themselves.
160 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE
161 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \
162 CYG_UITRON_CHECK_AND_GETP_INDIRECT( TASKS, _idx_, _ptr_ )
164 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \
165 CYG_UITRON_CHECK_AND_GETP_DIRECT( TASKS, _idx_, _ptr_ )
168 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
169 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \
170 CYG_UITRON_CHECK_AND_GETP_INDIRECT( SEMAS, _idx_, _ptr_ )
172 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \
173 CYG_UITRON_CHECK_AND_GETP_DIRECT( SEMAS, _idx_, _ptr_ )
176 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
177 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \
178 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MBOXES, _idx_, _ptr_ )
180 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \
181 CYG_UITRON_CHECK_AND_GETP_DIRECT( MBOXES, _idx_, _ptr_ )
184 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
185 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \
186 CYG_UITRON_CHECK_AND_GETP_INDIRECT( FLAGS, _idx_, _ptr_ )
188 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \
189 CYG_UITRON_CHECK_AND_GETP_DIRECT( FLAGS, _idx_, _ptr_ )
192 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
193 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \
194 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLFIXED, _idx_, _ptr_ )
196 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \
197 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLFIXED, _idx_, _ptr_ )
200 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
201 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \
202 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLVAR, _idx_, _ptr_ )
204 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \
205 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLVAR, _idx_, _ptr_ )
208 // ------------------------------------------------------------------------
209 // Common error checking macros
211 #if !defined( CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ) && \
212 !defined( CYGDBG_USE_ASSERTS )
213 // if not checking and not asserted, these are removed to avoid usused
214 // variable warnings.
215 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_EMPTY_STATEMENT
216 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_EMPTY_STATEMENT
217 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_EMPTY_STATEMENT
218 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( _tmout_ ) CYG_EMPTY_STATEMENT
222 // Check a task is actually a uITRON task
223 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_MACRO_START \
224 CYG_UIT_PARAMCHECK( \
225 (&cyg_uitron_TASKS[0] <= (_self_)) && \
226 ((_self_) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]), \
230 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_MACRO_START \
231 Cyg_Thread *self = Cyg_Thread::self(); \
232 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); \
235 // Check dispatching is enabled for calls which might wait
236 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_MACRO_START \
237 CYG_UIT_PARAMCHECK( 0 == cyg_uitron_dis_dsp_old_priority, E_CTX ); \
240 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO(_tmout_) CYG_MACRO_START \
241 CYG_UIT_PARAMCHECK( -1 <= (_tmout_), E_PAR ); \
242 if ( TMO_POL != (_tmout_) ) \
243 CYG_UITRON_CHECK_DISPATCH_ENABLED(); \
248 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
249 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \
250 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \
252 #else // do check for NULL
253 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \
254 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \
255 CYG_UIT_PARAMCHECK( NULL != (_p_), E_PAR ); \
257 #endif // !CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
259 // ------------------------------------------------------------------------
260 // CYG_UITRON_FAIL_RETURN
262 // After a call which waits, it might return with success, or due to a
263 // timeout or a release wait (a forced escape from the waiting condition).
264 // This macro examines context and finds out which, then executes a return
265 // with the correct uITRON condition code.
267 #define CYG_UITRON_FAIL_RETURN_SELF( _self_ ) CYG_MACRO_START \
268 Cyg_Thread::cyg_reason reason = (_self_)->get_wake_reason(); \
269 if ( Cyg_Thread::TIMEOUT == reason ) \
271 if ( Cyg_Thread::BREAK == reason ) \
273 if ( Cyg_Thread::DESTRUCT == reason ) \
275 return E_SYS; /* if no plausible reason was found */ \
278 #define CYG_UITRON_FAIL_RETURN() CYG_MACRO_START \
279 Cyg_Thread *self = Cyg_Thread::self(); \
280 CYG_UITRON_FAIL_RETURN_SELF( self ); \
283 // ------------------------------------------------------------------------
284 // Interrupts disabled?
285 #define CYG_UITRON_CHECK_CPU_UNLOC() \
286 CYG_UIT_PARAMCHECK( (Cyg_Interrupt::interrupts_enabled()), E_CTX )
288 // ------------------------------------------------------------------------
289 // Timing: is it in eCos clock ticks or milliSeconds (or something else?)
291 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK
293 #ifdef CYGSEM_UITRON_TIME_IS_MILLISECONDS
294 extern Cyg_Clock::converter uit_clock_to_system;
295 extern Cyg_Clock::converter uit_clock_from_system;
297 #define CYG_UITRON_TIME_UIT_TO_SYS32( t ) \
298 Cyg_Clock::convert( (cyg_uint64)(t), &uit_clock_to_system )
300 #define CYG_UITRON_TIME_SYS_TO_UIT32( t ) \
301 Cyg_Clock::convert( (cyg_uint64)(t), &uit_clock_from_system )
303 // long (cyg_uint64) versions:
304 #define CYG_UITRON_TIME_UIT_TO_SYS64( t ) \
305 Cyg_Clock::convert( (t), &uit_clock_to_system )
307 #define CYG_UITRON_TIME_SYS_TO_UIT64( t ) \
308 Cyg_Clock::convert( (t), &uit_clock_from_system )
310 #else // Time is whatever the system clock is doing:
312 // Straight through - int (cyg_int32) argument versions:
313 #define CYG_UITRON_TIME_UIT_TO_SYS32( t ) ( t )
314 #define CYG_UITRON_TIME_SYS_TO_UIT32( t ) ( t )
315 // long (cyg_uint64) versions:
316 #define CYG_UITRON_TIME_UIT_TO_SYS64( t ) ( t )
317 #define CYG_UITRON_TIME_SYS_TO_UIT64( t ) ( t )
320 #endif // CYGVAR_KERNEL_COUNTERS_CLOCK - otherwise these should not be used.
322 // ------------------------------------------------------------------------
323 // the function definitions themselves:
325 // ******************************************************
326 // *** 6.5 C Language Interfaces ***
327 // ******************************************************
329 // - Task Management Functions
331 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE
332 CYG_UITRON_NEWFUNCTION( Cyg_Thread )
336 cre_tsk ( ID tskid, T_CTSK *pk_ctsk )
339 CYG_UIT_PARAMCHECK_PTR( pk_ctsk );
340 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( TASKS, tskid );
342 Cyg_Thread *p = &(CYG_UITRON_OBJS( TASKS )[ tskid - 1 ]);
343 cyg_uint32 state = p->get_state();
344 if ( 0 == (state & Cyg_Thread::EXITED) )
345 ret = E_OBJ; // how did it get to be running?
346 else if ( ((INT)p->get_stack_size()) < pk_ctsk->stksz )
347 ret = E_NOMEM; // more stack requested than available
349 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] =
351 (CYG_ADDRWORD) pk_ctsk->itskpri,
352 (cyg_thread_entry *)pk_ctsk->task,
354 // preserve the original name and stack:
355 #ifdef CYGVAR_KERNEL_THREADS_NAME
361 p->get_stack_size() );
362 // but ensure the task state is dormant:
363 // (it is not constructed dormant, but suspended)
365 #ifdef CYGIMP_THREAD_PRIORITY
366 // and record the initial priority outside the task too.
367 CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) = pk_ctsk->itskpri;
370 Cyg_Scheduler::unlock();
380 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
382 Cyg_Scheduler::lock();
383 // deal with the race condition here
384 if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] ) {
385 Cyg_Scheduler::unlock();
388 cyg_uint32 state = p->get_state();
389 if ( state & Cyg_Thread::EXITED )
390 // just disconnect the pointer from its object
391 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL;
394 Cyg_Scheduler::unlock();
397 #endif // CYGPKG_UITRON_TASKS_CREATE_DELETE
401 sta_tsk ( ID tskid, INT stacd )
405 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
407 Cyg_Scheduler::lock();
408 cyg_uint32 state = p->get_state();
409 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE
410 // there is a race condition with deleting the task
411 // so test it now that we have the scheduler locked
412 if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] )
414 else // NOTE dangling else to the next line:
416 if ( state & Cyg_Thread::EXITED ) {
418 #ifdef CYGIMP_THREAD_PRIORITY
419 p->set_priority( CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) );
421 p->set_entry_data( (CYG_ADDRWORD)stacd );
426 Cyg_Scheduler::unlock();
441 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE
444 Cyg_Scheduler::lock();
445 p = Cyg_Thread::self();
446 ID tskid = (p - (&cyg_uitron_TASKS[0])) + 1;
447 // just disconnect the pointer from its object
448 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL;
449 // Any associated storage management, and possibly calling the task
450 // destructor, is for future versions.
452 // do nothing - deletion not supported so just exit...
455 // does not return, does unlock the scheduler for us
464 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
465 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
466 Cyg_Scheduler::lock();
467 if ( (0 != (Cyg_Thread::EXITED & p->get_state())) ||
468 (Cyg_Thread::EXIT == p->get_wake_reason()) )
472 p->force_resume(); // let it run
473 p->kill(); // and set prio high so it runs RIGHT NOW!!
474 #ifdef CYGIMP_THREAD_PRIORITY
475 #if CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES != 0
476 // see if we are already at prio 0:
477 if ( 0 == cyg_uitron_dis_dsp_old_priority )
478 // then dispatch is enabled, we are not at prio 0
480 p->set_priority( (cyg_priority) 0 );
481 // if we do not do this, then we are not running a strictly
482 // uITRON compatible scheduler - so just hope for the best.
485 Cyg_Scheduler::unlock();
486 #ifdef CYGIMP_THREAD_PRIORITY
487 #if CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0
488 if ( (E_OK == ret) && (0 != cyg_uitron_dis_dsp_old_priority) ) {
489 // then dispatching is disabled, so our prio is 0 too
490 Cyg_Thread::yield(); // so let the dying thread run;
491 Cyg_Thread::yield(); // no cost here of making sure.
502 CYG_UITRON_CHECK_TASK_CONTEXT();
503 CYG_UITRON_CHECK_CPU_UNLOC();
504 Cyg_Scheduler::lock();
505 // Prevent preemption by going up to prio 0
506 if ( 0 == cyg_uitron_dis_dsp_old_priority ) {
507 #ifdef CYGIMP_THREAD_PRIORITY
508 Cyg_Thread *p = Cyg_Thread::self();
509 cyg_uitron_dis_dsp_old_priority = p->get_priority();
510 p->set_priority( 0 );
512 cyg_uitron_dis_dsp_old_priority = 1;
515 Cyg_Scheduler::unlock();
523 CYG_UITRON_CHECK_TASK_CONTEXT();
524 CYG_UITRON_CHECK_CPU_UNLOC();
525 Cyg_Scheduler::lock();
526 // Enable dispatching (if disabled) and maybe switch threads
527 if ( 0 != cyg_uitron_dis_dsp_old_priority ) {
528 // We had prevented preemption by going up to prio 0
529 #ifdef CYGIMP_THREAD_PRIORITY
530 Cyg_Thread *p = Cyg_Thread::self();
531 p->set_priority( cyg_uitron_dis_dsp_old_priority );
532 p->to_queue_head(); // to ensure we continue to run
533 // if nobody higher pri
535 cyg_uitron_dis_dsp_old_priority = 0;
537 Cyg_Scheduler::unlock();
538 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards!
545 chg_pri ( ID tskid, PRI tskpri )
550 p = Cyg_Thread::self();
551 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p );
554 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
556 #ifdef CYGIMP_THREAD_PRIORITY
558 // then use the initial priority [Level X]
559 tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid );
561 CYG_UIT_PARAMCHECK( 0 < tskpri, E_PAR );
562 #ifdef CYGIMP_THREAD_PRIORITY
563 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY
564 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri &&
565 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR );
567 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri &&
568 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR );
570 // Handle changing our own prio specially, if dispatch disabled:
571 if ( 0 != cyg_uitron_dis_dsp_old_priority ) {
572 // our actual prio is 0 now and must remain so:
573 if ( Cyg_Thread::self() == p ) { // by whichever route p was set
574 // set the priority we will return to when dispatch is enabled:
575 cyg_uitron_dis_dsp_old_priority = (cyg_uint32)tskpri;
579 Cyg_Scheduler::lock();
580 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
581 (Cyg_Thread::EXIT == p->get_wake_reason()) )
582 ret = E_OBJ; // task is dormant
584 p->set_priority( (cyg_priority)tskpri );
585 Cyg_Scheduler::unlock();
586 #endif // CYGIMP_THREAD_PRIORITY got priorities at all?
592 rot_rdq ( PRI tskpri )
594 // zero means our level; easiet way is to yield() the CPU.
599 #ifdef CYGIMP_THREAD_PRIORITY
600 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY
601 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri &&
602 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR );
604 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri &&
605 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR );
607 Cyg_Thread::rotate_queue( tskpri );
608 #endif // CYGIMP_THREAD_PRIORITY got priorities at all?
618 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
619 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
620 Cyg_Scheduler::lock(); // get an atomic view of the task
621 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
622 (Cyg_Thread::EXIT == p->get_wake_reason()) )
623 ret = E_OBJ; // task is dormant
626 // return E_OBJ if the thread was not sleeping
627 if ( Cyg_Thread::BREAK != p->get_wake_reason() )
630 Cyg_Scheduler::unlock();
636 get_tid ( ID *p_tskid )
638 Cyg_Thread *self = Cyg_Thread::self();
639 CYG_UIT_PARAMCHECK_PTR( p_tskid );
640 if ( (&cyg_uitron_TASKS[0] <= (self)) &&
641 ((self) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]) &&
642 (0 == Cyg_Scheduler::get_sched_lock()) )
643 // then I am a uITRON task and not in an interrupt or DSR
644 *p_tskid = (self - (&cyg_uitron_TASKS[0])) + 1;
646 *p_tskid = 0; // Otherwise, non-task portion
652 ref_tsk ( T_RTSK *pk_rtsk, ID tskid )
656 p = Cyg_Thread::self();
657 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p );
658 tskid = (p - (&cyg_uitron_TASKS[0])) + 1; // it gets used below
661 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
663 CYG_UIT_PARAMCHECK_PTR( pk_rtsk );
664 pk_rtsk->exinf = NADR;
665 Cyg_Scheduler::lock(); // get an atomic view of the task
666 cyg_uint32 state = p->get_state();
667 if ( (state & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
668 (Cyg_Thread::EXIT == p->get_wake_reason()) )
669 pk_rtsk->tskstat = TTS_DMT;
670 else if ( state == Cyg_Thread::RUNNING )
671 // If it's us, it's running, else it's ready
672 pk_rtsk->tskstat = (Cyg_Thread::self() == p)
673 ? TTS_RUN // RUN state (we are it)
674 : TTS_RDY; // READY state
675 else if ( state & Cyg_Thread::SUSPENDED )
677 (state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING))
678 ? TTS_WAS // WAIT-SUSPEND state
679 : TTS_SUS; // SUSPEND state
682 (state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING))
683 ? TTS_WAI // WAIT state
684 : 0; // Not sure what's happening here!
685 #ifdef CYGIMP_THREAD_PRIORITY
686 if ( TTS_DMT == pk_rtsk->tskstat )
687 pk_rtsk->tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid );
688 else if ( (TTS_RUN == pk_rtsk->tskstat) &&
689 (0 != cyg_uitron_dis_dsp_old_priority) )
690 // then we are it and dispatching is disabled, so
691 // report our "real" priority - it is 0 in the kernel at the moment
692 pk_rtsk->tskpri = cyg_uitron_dis_dsp_old_priority;
694 pk_rtsk->tskpri = p->get_priority();
696 pk_rtsk->tskpri = -1; // Not applicable
698 Cyg_Scheduler::unlock();
702 // - Task-Dependent Synchronization Functions
710 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
711 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
712 Cyg_Scheduler::lock(); // get an atomic view of the task
713 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
714 (Cyg_Thread::EXIT == p->get_wake_reason()) )
715 ret = E_OBJ; // task is dormant
718 Cyg_Scheduler::unlock();
728 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
729 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
730 Cyg_Scheduler::lock(); // get an atomic view of the task
731 cyg_uint32 state = p->get_state();
732 if ( 0 == (Cyg_Thread::SUSPENDED & state) )
733 ret = E_OBJ; // thread is not suspended
736 Cyg_Scheduler::unlock();
742 frsm_tsk ( ID tskid )
746 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
747 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
748 Cyg_Scheduler::lock(); // get an atomic view of the task
749 cyg_uint32 state = p->get_state();
750 if ( 0 == (Cyg_Thread::SUSPENDED & state) )
751 ret = E_OBJ; // thread is not suspended
754 Cyg_Scheduler::unlock();
762 Cyg_Thread *self = Cyg_Thread::self();
763 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self );
764 CYG_UITRON_CHECK_DISPATCH_ENABLED();
765 // do this now for the case when no sleeping actually occurs
766 self->set_wake_reason( Cyg_Thread::DONE );
767 Cyg_Thread::counted_sleep();
768 if ( Cyg_Thread::DONE != self->get_wake_reason() )
769 CYG_UITRON_FAIL_RETURN_SELF( self );
773 #ifdef CYGFUN_KERNEL_THREADS_TIMER
776 tslp_tsk ( TMO tmout )
778 Cyg_Thread *self = Cyg_Thread::self();
779 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self );
780 CYG_UIT_PARAMCHECK( -1 <= tmout, E_PAR );
781 CYG_UITRON_CHECK_DISPATCH_ENABLED();
782 // do this now for the case when no sleeping actually occurs
783 self->set_wake_reason( Cyg_Thread::DONE );
784 // note that TMO_POL is not treated specially, though it
785 // happens to work almost as a poll (some sleeping may occur)
786 if ( TMO_FEVR == tmout )
787 Cyg_Thread::counted_sleep();
789 Cyg_Thread::counted_sleep(
790 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
791 if ( Cyg_Thread::DONE != self->get_wake_reason() )
792 CYG_UITRON_FAIL_RETURN_SELF( self );
795 #endif // CYGFUN_KERNEL_THREADS_TIMER
803 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
804 CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ );
805 Cyg_Scheduler::lock(); // get an atomic view of the task
806 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
807 (Cyg_Thread::EXIT == p->get_wake_reason()) )
808 ret = E_OBJ; // task is dormant
811 Cyg_Scheduler::unlock();
817 can_wup ( INT *p_wupcnt, ID tskid )
822 p = Cyg_Thread::self();
823 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p );
826 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
827 CYG_UIT_PARAMCHECK_PTR( p_wupcnt );
828 Cyg_Scheduler::lock(); // get an atomic view of the task
829 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
830 (Cyg_Thread::EXIT == p->get_wake_reason()) )
831 ret = E_OBJ; // task is dormant
833 cyg_uint32 result = p->cancel_counted_wake();
836 Cyg_Scheduler::unlock();
840 // - Synchronization and Communication Functions
842 #ifdef CYGPKG_UITRON_SEMAS
843 #if 0 < CYG_UITRON_NUM( SEMAS )
845 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
847 CYG_UITRON_NEWFUNCTION( Cyg_Counting_Semaphore2 )
851 cre_sem ( ID semid, T_CSEM *pk_csem )
854 CYG_UIT_PARAMCHECK_PTR( pk_csem );
855 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( SEMAS, semid );
856 if ( TA_TFIFO != pk_csem->sematr )
859 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] =
860 new( &(CYG_UITRON_OBJS( SEMAS )[ semid - 1 ]) )
861 Cyg_Counting_Semaphore2( (cyg_count32)pk_csem->isemcnt );
862 Cyg_Scheduler::unlock();
870 Cyg_Counting_Semaphore2 *p;
871 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
872 Cyg_Scheduler::lock();
873 // deal with the race condition here
874 if ( p != CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] ) {
875 Cyg_Scheduler::unlock();
878 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = NULL;
879 p->~Cyg_Counting_Semaphore2();
880 Cyg_Scheduler::unlock();
883 #endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE
889 Cyg_Counting_Semaphore2 *p;
890 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
899 Cyg_Counting_Semaphore2 *p;
900 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
901 CYG_UITRON_CHECK_DISPATCH_ENABLED();
902 cyg_bool result = p->wait();
904 CYG_UITRON_FAIL_RETURN();
910 preq_sem ( ID semid )
912 Cyg_Counting_Semaphore2 *p;
913 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
914 cyg_bool result = p->trywait();
920 #ifdef CYGFUN_KERNEL_THREADS_TIMER
923 twai_sem ( ID semid, TMO tmout )
925 Cyg_Counting_Semaphore2 *p;
926 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
927 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout );
928 // do this now for the case when no sleeping actually occurs
929 Cyg_Thread *self = Cyg_Thread::self();
930 self->set_wake_reason( Cyg_Thread::TIMEOUT );
932 if ( TMO_FEVR == tmout )
934 else if ( TMO_POL == tmout )
935 result = p->trywait();
938 Cyg_Clock::real_time_clock->current_value() +
939 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
941 CYG_UITRON_FAIL_RETURN_SELF( self );
945 #endif // CYGFUN_KERNEL_THREADS_TIMER
949 ref_sem ( T_RSEM *pk_rsem, ID semid )
951 Cyg_Counting_Semaphore2 *p;
952 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
953 CYG_UIT_PARAMCHECK_PTR( pk_rsem );
954 pk_rsem->exinf = NADR;
955 pk_rsem->wtsk = p->waiting();
956 pk_rsem->semcnt = p->peek();
960 #endif // 0 < CYG_UITRON_NUM( SEMAS )
961 #endif // CYGPKG_UITRON_SEMAS
963 #ifdef CYGPKG_UITRON_FLAGS
964 #if 0 < CYG_UITRON_NUM( FLAGS )
966 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
968 CYG_UITRON_NEWFUNCTION( Cyg_Flag )
972 cre_flg ( ID flgid, T_CFLG *pk_cflg )
975 CYG_UIT_PARAMCHECK_PTR( pk_cflg );
976 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( FLAGS, flgid );
977 if ( 0 != ((~(TA_WMUL | TA_WSGL)) & pk_cflg->flgatr) )
980 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] =
981 new( &(CYG_UITRON_OBJS( FLAGS )[ flgid - 1 ]) )
982 Cyg_Flag( (Cyg_FlagValue) pk_cflg->iflgptn );
983 Cyg_Scheduler::unlock();
992 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
993 Cyg_Scheduler::lock();
994 // deal with the race condition here
995 if ( p != CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] ) {
996 Cyg_Scheduler::unlock();
999 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = NULL;
1001 Cyg_Scheduler::unlock();
1004 #endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE
1008 set_flg ( ID flgid, UINT setptn )
1011 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1012 p->setbits( setptn );
1018 clr_flg ( ID flgid, UINT clrptn )
1021 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1022 p->maskbits( clrptn );
1028 wai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode )
1031 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1032 CYG_UIT_PARAMCHECK_PTR( p_flgptn );
1033 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR );
1034 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR );
1035 CYG_UITRON_CHECK_DISPATCH_ENABLED();
1036 // check we can use the wfmode value unchanged
1037 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" );
1038 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" );
1039 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" );
1041 UINT result = p->wait( waiptn, wfmode );
1043 CYG_UITRON_FAIL_RETURN();
1050 pol_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode )
1053 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1054 CYG_UIT_PARAMCHECK_PTR( p_flgptn );
1055 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR );
1056 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR );
1057 // check we can use the wfmode value unchanged
1058 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" );
1059 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" );
1060 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" );
1062 UINT result = p->poll( waiptn, wfmode );
1069 #ifdef CYGFUN_KERNEL_THREADS_TIMER
1072 twai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode,
1076 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1077 CYG_UIT_PARAMCHECK_PTR( p_flgptn );
1078 CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR );
1079 CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR );
1080 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout );
1081 // check we can use the wfmode value unchanged
1082 CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" );
1083 CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" );
1084 CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" );
1086 // do this now for the case when no sleeping actually occurs
1087 Cyg_Thread *self = Cyg_Thread::self();
1088 self->set_wake_reason( Cyg_Thread::TIMEOUT );
1090 if ( TMO_FEVR == tmout )
1091 result = p->wait( waiptn, wfmode );
1092 else if ( TMO_POL == tmout )
1093 result = p->poll( waiptn, wfmode );
1095 result = p->wait( waiptn, wfmode,
1096 Cyg_Clock::real_time_clock->current_value() +
1097 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
1099 CYG_UITRON_FAIL_RETURN_SELF( self );
1103 #endif // CYGFUN_KERNEL_THREADS_TIMER
1107 ref_flg ( T_RFLG *pk_rflg, ID flgid )
1110 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
1111 CYG_UIT_PARAMCHECK_PTR( pk_rflg );
1112 pk_rflg->exinf = NADR;
1113 pk_rflg->wtsk = p->waiting();
1114 pk_rflg->flgptn = p->peek();
1118 #endif // 0 < CYG_UITRON_NUM( FLAGS )
1119 #endif // CYGPKG_UITRON_FLAGS
1121 #ifdef CYGPKG_UITRON_MBOXES
1122 #if 0 < CYG_UITRON_NUM( MBOXES )
1124 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
1125 CYG_UITRON_NEWFUNCTION( Cyg_Mbox )
1129 cre_mbx ( ID mbxid, T_CMBX* pk_cmbx )
1132 CYG_UIT_PARAMCHECK_PTR( pk_cmbx );
1133 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MBOXES, mbxid );
1134 if ( ((ATR)(TA_TFIFO + TA_MFIFO)) != pk_cmbx->mbxatr )
1137 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] =
1138 new( &(CYG_UITRON_OBJS( MBOXES )[ mbxid - 1 ]) )
1140 Cyg_Scheduler::unlock();
1146 del_mbx ( ID mbxid )
1149 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1150 Cyg_Scheduler::lock();
1151 // deal with the race condition here
1152 if ( p != CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] ) {
1153 Cyg_Scheduler::unlock();
1156 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = NULL;
1158 Cyg_Scheduler::unlock();
1161 #endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE
1163 // This bit of unpleasantness is to allow uITRON programs to send a NULL
1164 // message - if permitted by the parameter checking.
1166 // NULL is used internally to mean no message; but -1 is fine. So we send
1167 // a NULL as a NADR and if we see a NULL coming back, change it to a NADR.
1169 // One hopes that often this will be optimized out, since the one or both
1170 // of these being true has been detected and errored out just above.
1172 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
1173 // represent a NULL as NADR internally
1174 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_MACRO_START \
1175 if ( NULL == (_p_) ) \
1176 (_p_) = (T_MSG *)NADR; \
1179 // we get a NADR back sometimes, meaning NULL
1180 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_MACRO_START \
1181 if ( NADR == (_p_) ) \
1182 (_p_) = (T_MSG *)NULL; \
1186 // NULL is checked for and makes an error
1187 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_EMPTY_STATEMENT
1188 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_EMPTY_STATEMENT
1191 // and sometimes either in status enquiries
1192 #define CYG_UIT_TMSG_FIXUP_ALL( _p_ ) CYG_MACRO_START \
1193 if ( NULL == (_p_) ) \
1194 (_p_) = (T_MSG *)NADR; \
1195 else if ( NADR == (_p_) ) \
1196 (_p_) = (T_MSG *)NULL; \
1201 snd_msg ( ID mbxid, T_MSG *pk_msg )
1204 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1205 CYG_UIT_PARAMCHECK_PTR( pk_msg );
1206 CYG_UIT_TMSG_FIXUP_IN( pk_msg );
1207 cyg_bool result = p->tryput( (void *)pk_msg );
1216 rcv_msg ( T_MSG **ppk_msg, ID mbxid )
1219 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1220 CYG_UIT_PARAMCHECK_PTR( ppk_msg );
1221 CYG_UITRON_CHECK_DISPATCH_ENABLED();
1222 T_MSG *result = (T_MSG *)p->get();
1224 CYG_UITRON_FAIL_RETURN();
1225 CYG_UIT_TMSG_FIXUP_OUT( result );
1232 prcv_msg ( T_MSG **ppk_msg, ID mbxid )
1235 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1236 CYG_UIT_PARAMCHECK_PTR( ppk_msg );
1237 T_MSG *result = (T_MSG *)p->tryget();
1240 CYG_UIT_TMSG_FIXUP_OUT( result );
1245 #ifdef CYGFUN_KERNEL_THREADS_TIMER
1248 trcv_msg ( T_MSG **ppk_msg, ID mbxid, TMO tmout )
1251 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1252 CYG_UIT_PARAMCHECK_PTR( ppk_msg );
1253 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout );
1254 // do this now for the case when no sleeping actually occurs
1255 Cyg_Thread *self = Cyg_Thread::self();
1256 self->set_wake_reason( Cyg_Thread::TIMEOUT );
1258 if ( TMO_FEVR == tmout )
1259 result = (T_MSG *)p->get();
1260 else if ( TMO_POL == tmout )
1261 result = (T_MSG *)p->tryget();
1263 result = (T_MSG *)p->get(
1264 Cyg_Clock::real_time_clock->current_value() +
1265 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
1267 CYG_UITRON_FAIL_RETURN_SELF( self );
1268 CYG_UIT_TMSG_FIXUP_OUT( result );
1272 #endif // CYGFUN_KERNEL_THREADS_TIMER
1276 ref_mbx ( T_RMBX *pk_rmbx, ID mbxid )
1279 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1280 CYG_UIT_PARAMCHECK_PTR( pk_rmbx );
1281 pk_rmbx->exinf = NADR;
1282 pk_rmbx->wtsk = p->waiting_to_get();
1283 pk_rmbx->pk_msg = (T_MSG *)p->peek_item();
1284 CYG_UIT_TMSG_FIXUP_ALL( pk_rmbx->pk_msg );
1288 #undef CYG_UIT_TMSG_FIXUP_IN
1289 #undef CYG_UIT_TMSG_FIXUP_OUT
1290 #undef CYG_UIT_TMSG_FIXUP_ALL
1292 #endif // 0 < CYG_UITRON_NUM( MBOXES )
1293 #endif // CYGPKG_UITRON_MBOXES
1295 // - Extended Synchronization and Communication Functions
1297 #if 0 // NOT SUPPORTED
1298 ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf );
1299 ER del_mbf ( ID mbfid );
1300 ER snd_mbf ( ID mbfid, VP msg, INT msgsz );
1301 ER psnd_mbf ( ID mbfid, VP msg, INT msgsz );
1302 ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout );
1303 ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid );
1304 ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid );
1305 ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout );
1306 ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid );
1307 ER cre_por ( ID porid, T_CPOR *pk_cpor );
1308 ER del_por ( ID porid );
1309 ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1311 ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1313 ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1314 cmsgsz, TMO tmout );
1315 ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1317 ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1319 ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1320 acpptn, TMO tmout );
1321 ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz
1323 ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz );
1324 ER ref_por ( T_RPOR *pk_rpor, ID porid );
1327 // - Interrupt Management Functions
1329 #if 0 // NOT SUPPORTED
1330 ER def_int ( UINT dintno, T_DINT *pk_dint );
1331 void ret_wup ( ID tskid );
1338 CYG_UITRON_CHECK_TASK_CONTEXT();
1339 Cyg_Scheduler::lock();
1340 // Prevent preemption by going up to prio 0
1341 if ( 0 == cyg_uitron_dis_dsp_old_priority ) {
1342 #ifdef CYGIMP_THREAD_PRIORITY
1343 Cyg_Thread *p = Cyg_Thread::self();
1344 cyg_uitron_dis_dsp_old_priority = p->get_priority();
1345 p->set_priority( 0 );
1347 cyg_uitron_dis_dsp_old_priority = 1;
1350 Cyg_Interrupt::disable_interrupts();
1351 Cyg_Scheduler::unlock();
1359 CYG_UITRON_CHECK_TASK_CONTEXT();
1360 Cyg_Scheduler::lock();
1361 // Enable dispatching (if disabled) and maybe switch threads
1362 if ( 0 != cyg_uitron_dis_dsp_old_priority ) {
1363 // We had prevented preemption by going up to prio 0
1364 #ifdef CYGIMP_THREAD_PRIORITY
1365 Cyg_Thread *p = Cyg_Thread::self();
1366 p->set_priority( cyg_uitron_dis_dsp_old_priority );
1368 cyg_uitron_dis_dsp_old_priority = 0;
1370 Cyg_Interrupt::enable_interrupts();
1371 Cyg_Scheduler::unlock();
1372 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards!
1378 dis_int ( UINT eintno )
1380 CYG_INTERRUPT_STATE old_ints;
1382 #if 0 < CYGNUM_HAL_ISR_MIN
1383 CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MIN <= eintno, E_PAR );
1385 CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MAX >= eintno, E_PAR );
1386 HAL_DISABLE_INTERRUPTS(old_ints);
1387 HAL_INTERRUPT_MASK( eintno );
1388 HAL_RESTORE_INTERRUPTS(old_ints);
1394 ena_int ( UINT eintno )
1396 CYG_INTERRUPT_STATE old_ints;
1398 #if 0 < CYGNUM_HAL_ISR_MIN
1399 CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MIN <= eintno, E_PAR );
1401 CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MAX >= eintno, E_PAR );
1402 HAL_DISABLE_INTERRUPTS(old_ints);
1403 HAL_INTERRUPT_UNMASK( eintno );
1404 HAL_RESTORE_INTERRUPTS(old_ints);
1408 #if 0 // NOT SUPPORTED
1409 ER chg_iXX ( UINT iXXXX );
1410 ER ref_iXX ( UINT *p_iXXXX );
1413 // - Memorypool Management Functions
1414 #ifdef CYGPKG_UITRON_MEMPOOLVAR
1415 #if 0 < CYG_UITRON_NUM( MEMPOOLVAR )
1417 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
1419 CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Variable )
1423 cre_mpl ( ID mplid, T_CMPL *pk_cmpl )
1426 CYG_UIT_PARAMCHECK_PTR( pk_cmpl );
1427 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLVAR, mplid );
1428 Cyg_Mempool_Variable *p = &(CYG_UITRON_OBJS( MEMPOOLVAR )[ mplid - 1 ]);
1429 Cyg_Mempool_Status stat;
1431 // preserve the original memory area to use
1432 p->get_status( CYG_MEMPOOL_STAT_ORIGBASE|CYG_MEMPOOL_STAT_ORIGSIZE, stat );
1434 if ( stat.origsize < pk_cmpl->mplsz )
1436 else if ( TA_TFIFO != pk_cmpl->mplatr )
1439 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] =
1440 new( p ) Cyg_Mempool_Variable(
1441 const_cast<cyg_uint8 *>(stat.origbase), stat.origsize );
1442 Cyg_Scheduler::unlock();
1448 del_mpl ( ID mplid )
1450 Cyg_Mempool_Variable *p;
1451 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1452 Cyg_Scheduler::lock();
1453 // deal with the race condition here
1454 if ( p != CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] ) {
1455 Cyg_Scheduler::unlock();
1458 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = NULL;
1459 p->~Cyg_Mempool_Variable();
1460 Cyg_Scheduler::unlock();
1463 #endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
1467 get_blk ( VP *p_blk, ID mplid, INT blksz )
1469 Cyg_Mempool_Variable *p;
1470 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1471 CYG_UIT_PARAMCHECK_PTR( p_blk );
1472 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR );
1473 CYG_UITRON_CHECK_DISPATCH_ENABLED();
1474 VP result = (VP)p->alloc(blksz);
1476 CYG_UITRON_FAIL_RETURN();
1484 pget_blk ( VP *p_blk, ID mplid, INT blksz )
1486 Cyg_Mempool_Variable *p;
1487 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1488 CYG_UIT_PARAMCHECK_PTR( p_blk );
1489 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR );
1490 VP result = (VP)p->try_alloc(blksz);
1497 #ifdef CYGFUN_KERNEL_THREADS_TIMER
1500 tget_blk ( VP *p_blk, ID mplid, INT blksz, TMO tmout )
1502 Cyg_Mempool_Variable *p;
1503 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1504 CYG_UIT_PARAMCHECK_PTR( p_blk );
1505 CYG_UIT_PARAMCHECK( blksz > 0, E_PAR );
1506 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout );
1507 // do this now for the case when no sleeping actually occurs
1508 Cyg_Thread *self = Cyg_Thread::self();
1509 self->set_wake_reason( Cyg_Thread::TIMEOUT );
1511 if ( TMO_FEVR == tmout )
1512 result = p->alloc(blksz);
1513 else if ( TMO_POL == tmout )
1514 result = p->try_alloc(blksz);
1516 result = p->alloc( blksz,
1517 Cyg_Clock::real_time_clock->current_value() +
1518 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
1520 CYG_UITRON_FAIL_RETURN_SELF( self );
1524 #endif // CYGFUN_KERNEL_THREADS_TIMER
1528 rel_blk ( ID mplid, VP blk )
1530 Cyg_Mempool_Variable *p;
1531 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1532 CYG_UIT_PARAMCHECK_PTR( blk );
1533 cyg_bool result = p->free( (cyg_uint8 *)blk );
1541 ref_mpl ( T_RMPL *pk_rmpl, ID mplid )
1543 Cyg_Mempool_Variable *p;
1544 Cyg_Mempool_Status stat;
1545 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1546 CYG_UIT_PARAMCHECK_PTR( pk_rmpl );
1547 p->get_status( CYG_MEMPOOL_STAT_WAITING|
1548 CYG_MEMPOOL_STAT_TOTALFREE|
1549 CYG_MEMPOOL_STAT_MAXFREE, stat );
1551 pk_rmpl->exinf = NADR;
1552 pk_rmpl->wtsk = stat.waiting;
1553 pk_rmpl->frsz = stat.totalfree;
1554 pk_rmpl->maxsz = stat.maxfree;
1559 #endif // 0 < CYG_UITRON_NUM( MEMPOOLVAR )
1560 #endif // CYGPKG_UITRON_MEMPOOLVAR
1562 #ifdef CYGPKG_UITRON_MEMPOOLFIXED
1563 #if 0 < CYG_UITRON_NUM( MEMPOOLFIXED )
1565 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
1567 CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Fixed )
1571 cre_mpf ( ID mpfid, T_CMPF *pk_cmpf )
1574 CYG_UIT_PARAMCHECK_PTR( pk_cmpf );
1575 CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLFIXED, mpfid );
1576 Cyg_Mempool_Fixed *p = &(CYG_UITRON_OBJS( MEMPOOLFIXED )[ mpfid - 1 ]);
1577 Cyg_Mempool_Status stat;
1579 // preserve the original memory area to use
1580 p->get_status( CYG_MEMPOOL_STAT_ORIGBASE|CYG_MEMPOOL_STAT_ORIGSIZE, stat );
1582 if ( stat.origsize < (pk_cmpf->blfsz * (pk_cmpf->mpfcnt + 1)) )
1584 else if ( TA_TFIFO != pk_cmpf->mpfatr )
1587 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] =
1589 Cyg_Mempool_Fixed( const_cast<cyg_uint8 *>(stat.origbase),
1590 stat.origsize, (CYG_ADDRWORD)pk_cmpf->blfsz );
1591 Cyg_Scheduler::unlock();
1597 del_mpf ( ID mpfid )
1599 Cyg_Mempool_Fixed *p;
1600 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1601 Cyg_Scheduler::lock();
1602 // deal with the race condition here
1603 if ( p != CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] ) {
1604 Cyg_Scheduler::unlock();
1607 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = NULL;
1608 p->~Cyg_Mempool_Fixed();
1609 Cyg_Scheduler::unlock();
1612 #endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
1616 get_blf ( VP *p_blf, ID mpfid )
1618 Cyg_Mempool_Fixed *p;
1619 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1620 CYG_UIT_PARAMCHECK_PTR( p_blf );
1621 CYG_UITRON_CHECK_DISPATCH_ENABLED();
1622 VP result = (VP)p->alloc();
1624 CYG_UITRON_FAIL_RETURN();
1631 pget_blf ( VP *p_blf, ID mpfid )
1633 Cyg_Mempool_Fixed *p;
1634 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1635 CYG_UIT_PARAMCHECK_PTR( p_blf );
1636 VP result = (VP)p->try_alloc();
1643 #ifdef CYGFUN_KERNEL_THREADS_TIMER
1646 tget_blf ( VP *p_blf, ID mpfid, TMO tmout )
1648 Cyg_Mempool_Fixed *p;
1649 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1650 CYG_UIT_PARAMCHECK_PTR( p_blf );
1651 CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout );
1652 // do this now for the case when no sleeping actually occurs
1653 Cyg_Thread *self = Cyg_Thread::self();
1654 self->set_wake_reason( Cyg_Thread::TIMEOUT );
1656 if ( TMO_FEVR == tmout )
1657 result = p->alloc();
1658 else if ( TMO_POL == tmout )
1659 result = p->try_alloc();
1662 Cyg_Clock::real_time_clock->current_value() +
1663 (cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) );
1665 CYG_UITRON_FAIL_RETURN_SELF( self );
1669 #endif // CYGFUN_KERNEL_THREADS_TIMER
1673 rel_blf ( ID mpfid, VP blf )
1675 Cyg_Mempool_Fixed *p;
1676 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1677 CYG_UIT_PARAMCHECK_PTR( blf );
1678 cyg_bool result = p->free( (cyg_uint8 *)blf );
1686 ref_mpf ( T_RMPF *pk_rmpf, ID mpfid )
1688 Cyg_Mempool_Fixed *p;
1689 Cyg_Mempool_Status stat;
1690 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1691 CYG_UIT_PARAMCHECK_PTR( pk_rmpf );
1693 p->get_status( CYG_MEMPOOL_STAT_WAITING|
1694 CYG_MEMPOOL_STAT_TOTALFREE|
1695 CYG_MEMPOOL_STAT_TOTALALLOCATED|
1696 CYG_MEMPOOL_STAT_BLOCKSIZE, stat );
1698 pk_rmpf->exinf = NADR;
1699 pk_rmpf->wtsk = stat.waiting;
1701 pk_rmpf->frbcnt = stat.totalfree / stat.blocksize;
1702 // these two are "implementation dependent" ie. eCos only
1703 pk_rmpf->numbcnt = stat.totalallocated / stat.blocksize;
1704 pk_rmpf->bsize = stat.blocksize;
1709 #endif // 0 < CYG_UITRON_NUM( MEMPOOLFIXED )
1710 #endif // CYGPKG_UITRON_MEMPOOLFIXED
1712 // - Time Management Functions
1714 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK
1717 set_tim ( SYSTIME *pk_tim )
1719 CYG_UIT_PARAMCHECK_PTR( pk_tim );
1720 Cyg_Clock::real_time_clock->set_value(
1721 CYG_UITRON_TIME_UIT_TO_SYS64( *pk_tim ) );
1727 get_tim ( SYSTIME *pk_tim )
1729 CYG_UIT_PARAMCHECK_PTR( pk_tim );
1730 *pk_tim = CYG_UITRON_TIME_SYS_TO_UIT64(
1731 Cyg_Clock::real_time_clock->current_value() );
1734 #endif // CYGVAR_KERNEL_COUNTERS_CLOCK
1737 #ifdef CYGFUN_KERNEL_THREADS_TIMER
1740 dly_tsk ( DLYTIME dlytim )
1742 CYG_UIT_PARAMCHECK( 0 <= dlytim, E_PAR );
1743 CYG_UITRON_CHECK_DISPATCH_ENABLED();
1746 Cyg_Thread *self = Cyg_Thread::self();
1747 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self );
1748 self->delay( CYG_UITRON_TIME_UIT_TO_SYS64( dlytim ) );
1749 if ( Cyg_Thread::DONE != self->get_wake_reason() )
1750 CYG_UITRON_FAIL_RETURN_SELF( self );
1753 #endif // CYGFUN_KERNEL_THREADS_TIMER
1755 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK
1756 #ifdef CYGPKG_UITRON_CYCLICS
1757 #if 0 < CYG_UITRON_NUM( CYCLICS )
1760 def_cyc ( HNO cycno, T_DCYC *pk_dcyc )
1762 // pk_dcyc->cycatr is ignored
1763 // The only relevant attribute is TA_HLNG/TA_ASM.
1764 // This can be ignored as assembler routines are defined to be
1765 // more conservative with registers than the procedure call standard.
1768 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p );
1769 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
1770 CYG_UIT_PARAMCHECK( NULL != pk_dcyc, E_PAR );
1772 if( NADR == pk_dcyc ) {
1776 CYG_UIT_PARAMCHECK( 0 == (pk_dcyc->cycact & ~TCY_ON), E_PAR );
1777 CYG_UIT_PARAMCHECK( 0 < pk_dcyc->cyctim, E_PAR );
1778 t = CYG_UITRON_TIME_UIT_TO_SYS64( pk_dcyc->cyctim );
1780 Cyg_Clock::real_time_clock,
1781 (cyg_alarm_fn *)pk_dcyc->cychdr,
1782 (CYG_ADDRWORD)pk_dcyc->exinf,
1783 Cyg_Clock::real_time_clock->current_value() + t,
1791 act_cyc ( HNO cycno, UINT cycact )
1794 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p );
1795 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS);
1796 CYG_UIT_PARAMCHECK( 0 == (cycact & ~(TCY_ON | TCY_INI)), E_PAR );
1797 p->activate(cycact);
1804 ref_cyc ( T_RCYC *pk_rcyc, HNO cycno )
1808 CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p );
1809 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS);
1810 CYG_UIT_PARAMCHECK_PTR( pk_rcyc );
1812 pk_rcyc->exinf = (VP)p->get_data();
1813 Cyg_Scheduler::lock();
1814 t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value();
1815 Cyg_Scheduler::unlock();
1816 pk_rcyc->lfttim = CYG_UITRON_TIME_SYS_TO_UIT64( t );
1817 pk_rcyc->cycact = (UINT)p->is_enabled();
1820 #endif // 0 < CYG_UITRON_NUM( CYCLICS )
1821 #endif // CYGPKG_UITRON_CYCLICS
1823 #ifdef CYGPKG_UITRON_ALARMS
1824 #if 0 < CYG_UITRON_NUM( ALARMS )
1827 def_alm ( HNO almno, T_DALM *pk_dalm )
1830 cyg_tick_count t, now;
1831 CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p );
1832 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
1833 CYG_UIT_PARAMCHECK( NULL != pk_dalm, E_PAR );
1835 if( NADR == pk_dalm ) {
1840 CYG_UIT_PARAMCHECK( 0 == (pk_dalm->tmmode & ~TTM_REL), E_PAR );
1841 CYG_UIT_PARAMCHECK( 0 < pk_dalm->almtim, E_PAR );
1843 // make the time arithmetic safe without locking
1844 now = Cyg_Clock::real_time_clock->current_value();
1845 t = CYG_UITRON_TIME_UIT_TO_SYS64( pk_dalm->almtim );
1846 if( TTM_REL & pk_dalm->tmmode )
1849 CYG_UIT_PARAMCHECK( now < t, E_PAR );
1851 p->initialize(Cyg_Clock::real_time_clock,
1852 (cyg_alarm_fn *)pk_dalm->almhdr,
1853 (CYG_ADDRWORD)pk_dalm->exinf,
1854 t, 0, Cyg_Timer::ENABLE);
1861 ref_alm ( T_RALM *pk_ralm, HNO almno )
1866 CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p );
1867 CYG_UIT_PARAMCHECK_PTR( pk_ralm );
1868 CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS);
1870 Cyg_Scheduler::lock();
1871 t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value();
1872 Cyg_Scheduler::unlock();
1873 pk_ralm->exinf = (VP)p->get_data();
1874 pk_ralm->lfttim = CYG_UITRON_TIME_SYS_TO_UIT64( t );
1877 #endif // 0 < CYG_UITRON_NUM( ALARMS )
1878 #endif // CYGPKG_UITRON_ALARMS
1880 #endif // CYGVAR_KERNEL_COUNTERS_CLOCK
1882 // - System Management Functions
1886 get_ver ( T_VER *pk_ver )
1888 CYG_UIT_PARAMCHECK_PTR( pk_ver );
1890 pk_ver->maker = CYGNUM_UITRON_VER_MAKER;
1891 pk_ver->id = CYGNUM_UITRON_VER_ID;
1892 pk_ver->spver = CYGNUM_UITRON_VER_SPVER;
1893 pk_ver->prver = CYGNUM_UITRON_VER_PRVER;
1894 pk_ver->prno[0] = CYGNUM_UITRON_VER_PRNO_0;
1895 pk_ver->prno[1] = CYGNUM_UITRON_VER_PRNO_1;
1896 pk_ver->prno[2] = CYGNUM_UITRON_VER_PRNO_2;
1897 pk_ver->prno[3] = CYGNUM_UITRON_VER_PRNO_3;
1898 pk_ver->cpu = CYGNUM_UITRON_VER_CPU;
1899 pk_ver->var = CYGNUM_UITRON_VER_VAR;
1906 ref_sys ( T_RSYS *pk_rsys )
1908 CYG_UIT_PARAMCHECK_PTR( pk_rsys );
1909 if ( ! Cyg_Interrupt::interrupts_enabled() )
1911 pk_rsys->sysstat = TSS_LOC;
1914 (0 == cyg_uitron_dis_dsp_old_priority) ? TSS_TSK : TSS_DDSP;
1920 ref_cfg ( T_RCFG *pk_rcfg )
1922 CYG_UIT_PARAMCHECK_PTR( pk_rcfg );
1923 // no details here yet
1927 #if 0 // NOT SUPPORTED
1928 ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc );
1929 ER def_exc ( UINT exckind, T_DEXC *pk_dexc );
1932 // - Network Support Functions
1934 #if 0 // NOT SUPPORTED
1935 ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr,
1937 ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr,
1939 ER nget_nod ( NODE *p_node );
1940 ER nget_ver ( T_VER *pk_ver, NODE node );
1943 // ========================================================================
1945 #endif // CYGPKG_UITRON
1947 #endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW
1949 #endif // CYGONCE_COMPAT_UITRON_UIT_FUNC_INL