Mercurial > flash_v2

comparison packages/compat/uitron/current/include/uit_func.inl @ 2:443894e2e912 ecos-v1_2_1-release

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Block commit of eCos version 1.2.1
author jlarmour
date Tue, 11 May 1999 12:24:34 +0000
parents 3111d98ba7b3
children ece80412419a
comparison
equal deleted inserted replaced
1:72f549f0d891 2:443894e2e912
1 #ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_INL 1 #ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_INL
2 #define CYGONCE_COMPAT_UITRON_UIT_FUNC_INL 2 #define CYGONCE_COMPAT_UITRON_UIT_FUNC_INL
3 //=========================================================================== 3 //===========================================================================
4 // 4 //
5 // uit_func.inl 5 // uit_func.inl
6 // 6 //
7 // uITRON compatibility functions 7 // uITRON compatibility functions
8 // 8 //
9 //=========================================================================== 9 //===========================================================================
10 //####COPYRIGHTBEGIN#### 10 //####COPYRIGHTBEGIN####
11 // 11 //
12 // ------------------------------------------- 12 // -------------------------------------------
22 // 22 //
23 // The Original Code is eCos - Embedded Cygnus Operating System, released 23 // The Original Code is eCos - Embedded Cygnus Operating System, released
24 // September 30, 1998. 24 // September 30, 1998.
25 // 25 //
26 // The Initial Developer of the Original Code is Cygnus. Portions created 26 // The Initial Developer of the Original Code is Cygnus. Portions created
27 // by Cygnus are Copyright (C) 1998 Cygnus Solutions. All Rights Reserved. 27 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved.
28 // ------------------------------------------- 28 // -------------------------------------------
29 // 29 //
30 //####COPYRIGHTEND#### 30 //####COPYRIGHTEND####
31 //=========================================================================== 31 //===========================================================================
32 //#####DESCRIPTIONBEGIN#### 32 //#####DESCRIPTIONBEGIN####
33 // 33 //
34 // Author(s): hmt 34 // Author(s): hmt
35 // Contributors: hmt 35 // Contributors: hmt
36 // Date: 1998-03-13 36 // Date: 1998-03-13
37 // Purpose: uITRON compatibility functions 37 // Purpose: uITRON compatibility functions
38 // Description: 38 // Description:
39 // 39 //
40 //####DESCRIPTIONEND#### 40 //####DESCRIPTIONEND####
41 // 41 //
42 //=========================================================================== 42 //===========================================================================
43 43
54 // and the implementations of other kernel facilities 54 // and the implementations of other kernel facilities
55 #include <cyg/kernel/thread.inl> 55 #include <cyg/kernel/thread.inl>
56 #include <cyg/kernel/sched.inl> 56 #include <cyg/kernel/sched.inl>
57 #include <cyg/kernel/clock.inl> 57 #include <cyg/kernel/clock.inl>
58 58
59
60 // ------------------------------------------------------------------------
61 // The variable where dis_dsp/ena_dsp state is held:
62 extern cyg_uint32 cyg_uitron_dis_dsp_old_priority;
63
59 // ------------------------------------------------------------------------ 64 // ------------------------------------------------------------------------
60 // Parameter checking; either check the expression and return an error code 65 // Parameter checking; either check the expression and return an error code
61 // if not true, or assert the truth with a made-up message. 66 // if not true, or assert the truth with a made-up message.
62 67
63 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS 68 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
64 // default: uitron error codes are returned 69 // default: uitron error codes are returned
65 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ 70 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \
66 if ( ! (_true_) ) return (_error_); \ 71 if ( ! (_true_) ) return (_error_); \
67 CYG_MACRO_END 72 CYG_MACRO_END
68 #else 73 #else
69 // ...but they are asserted if asserts are on 74 // ...but they are asserted if asserts are on
70 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ 75 #define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \
71 CYG_ASSERT( (_true_), "CYG_UIT_PARAMCHECK fail: " #_true_ ); \ 76 CYG_ASSERT( (_true_), "CYG_UIT_PARAMCHECK fail: " #_true_ ); \
72 CYG_MACRO_END 77 CYG_MACRO_END
73 #endif // else !CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS 78 #endif // else !CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
74 79
75 // ------------------------------------------------------------------------ 80 // ------------------------------------------------------------------------
76 // CYG_UITRON_CHECK_AND_GETP 81 // CYG_UITRON_CHECK_AND_GETP
79 // object; _which_ sort of object is given, and token pasting is used 84 // object; _which_ sort of object is given, and token pasting is used
80 // horribly to get the static array, limits and the like. 85 // horribly to get the static array, limits and the like.
81 // 86 //
82 // Usage: 87 // Usage:
83 // INT snd_msg( ID mbxid, ... ) { 88 // INT snd_msg( ID mbxid, ... ) {
84 // Cyg_Mbox *p; 89 // Cyg_Mbox *p;
85 // CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); 90 // CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
86 // p->...(...); 91 // p->...(...);
87 92
88 // internal: plain assignment to the object pointer, from static array 93 // internal: plain assignment to the object pointer, from static array
89 #define CYG_UIT_SPTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ 94 #define CYG_UIT_SPTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \
90 (_ptr_) = CYG_UITRON_OBJS( _which_ ) + ((_idx_) - 1); \ 95 (_ptr_) = CYG_UITRON_OBJS( _which_ ) + ((_idx_) - 1); \
91 CYG_MACRO_END 96 CYG_MACRO_END
92 97
93 // internal: plain assignment to the object pointer, from pointer array 98 // internal: plain assignment to the object pointer, from pointer array
94 // with error checking. 99 // with error checking.
95 #define CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ 100 #define CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \
96 (_ptr_) = CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ]; \ 101 (_ptr_) = CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ]; \
97 if ( NULL == (_ptr_) ) return E_NOEXS; \ 102 if ( NULL == (_ptr_) ) return E_NOEXS; \
98 CYG_MACRO_END 103 CYG_MACRO_END
99 104
100 #define CYG_UITRON_CHECK_AND_GETP_DIRECT( _which_, _idx_, _ptr_ ) \ 105 #define CYG_UITRON_CHECK_AND_GETP_DIRECT( _which_, _idx_, _ptr_ ) \
101 CYG_MACRO_START \ 106 CYG_MACRO_START \
102 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ 107 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
103 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ 108 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
104 CYG_UIT_SPTR( _which_, _idx_, _ptr_ ); \ 109 CYG_UIT_SPTR( _which_, _idx_, _ptr_ ); \
105 CYG_MACRO_END 110 CYG_MACRO_END
106 111
107 #define CYG_UITRON_CHECK_AND_GETP_INDIRECT( _which_, _idx_, _ptr_ ) \ 112 #define CYG_UITRON_CHECK_AND_GETP_INDIRECT( _which_, _idx_, _ptr_ ) \
108 CYG_MACRO_START \ 113 CYG_MACRO_START \
109 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ 114 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
110 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ 115 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
111 CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ); \ 116 CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ); \
112 CYG_MACRO_END 117 CYG_MACRO_END
113 118
114 // As above but for handler numbers which return E_PAR when out of range 119 // As above but for handler numbers which return E_PAR when out of range
115 #define CYG_UITRON_CHECK_AND_GETHDLR( _which_, _num_, _ptr_ ) \ 120 #define CYG_UITRON_CHECK_AND_GETHDLR( _which_, _num_, _ptr_ ) \
116 CYG_MACRO_START \ 121 CYG_MACRO_START \
117 CYG_UIT_PARAMCHECK( 0 < (_num_), E_PAR ); \ 122 CYG_UIT_PARAMCHECK( 0 < (_num_), E_PAR ); \
118 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_num_), E_PAR ); \ 123 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_num_), E_PAR ); \
119 CYG_UIT_SPTR( _which_, _num_, _ptr_ ); \ 124 CYG_UIT_SPTR( _which_, _num_, _ptr_ ); \
120 CYG_MACRO_END 125 CYG_MACRO_END
121 126
122 // And a macro to check that creation of an object is OK 127 // And a macro to check that creation of an object is OK
123 #define CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( _which_, _idx_ ) \ 128 #define CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( _which_, _idx_ ) \
124 CYG_MACRO_START \ 129 CYG_MACRO_START \
125 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ 130 CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \
126 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ 131 CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \
127 Cyg_Scheduler::lock(); \ 132 Cyg_Scheduler::lock(); \
128 if ( NULL != CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ] ) { \ 133 if ( NULL != CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ] ) { \
129 Cyg_Scheduler::unlock(); \ 134 Cyg_Scheduler::unlock(); \
130 return E_OBJ; \ 135 return E_OBJ; \
131 } \ 136 } \
132 CYG_MACRO_END 137 CYG_MACRO_END
133 138
134 // define a magic new operator in order to call constructors 139 // define a magic new operator in order to call constructors
135 #define CYG_UITRON_NEWFUNCTION( _class_ ) \ 140 #define CYG_UITRON_NEWFUNCTION( _class_ ) \
136 inline void *operator new(size_t size, _class_ *ptr) \ 141 inline void *operator new(size_t size, _class_ *ptr) \
137 { \ 142 { \
138 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); \ 143 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); \
139 return ptr; \ 144 return ptr; \
140 } 145 }
141 146
142 // now configury to support selectable create/delete support ie. an 147 // now configury to support selectable create/delete support ie. an
143 // array of pointers to the objects themselves. 148 // array of pointers to the objects themselves.
144 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE 149 #ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE
145 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ 150 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \
146 CYG_UITRON_CHECK_AND_GETP_INDIRECT( TASKS, _idx_, _ptr_ ) 151 CYG_UITRON_CHECK_AND_GETP_INDIRECT( TASKS, _idx_, _ptr_ )
147 #else 152 #else
148 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ 153 #define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \
149 CYG_UITRON_CHECK_AND_GETP_DIRECT( TASKS, _idx_, _ptr_ ) 154 CYG_UITRON_CHECK_AND_GETP_DIRECT( TASKS, _idx_, _ptr_ )
150 #endif 155 #endif
151 156
152 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE 157 #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
153 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ 158 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \
154 CYG_UITRON_CHECK_AND_GETP_INDIRECT( SEMAS, _idx_, _ptr_ ) 159 CYG_UITRON_CHECK_AND_GETP_INDIRECT( SEMAS, _idx_, _ptr_ )
155 #else 160 #else
156 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ 161 #define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \
157 CYG_UITRON_CHECK_AND_GETP_DIRECT( SEMAS, _idx_, _ptr_ ) 162 CYG_UITRON_CHECK_AND_GETP_DIRECT( SEMAS, _idx_, _ptr_ )
158 #endif 163 #endif
159 164
160 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE 165 #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
161 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ 166 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \
162 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MBOXES, _idx_, _ptr_ ) 167 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MBOXES, _idx_, _ptr_ )
163 #else 168 #else
164 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ 169 #define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \
165 CYG_UITRON_CHECK_AND_GETP_DIRECT( MBOXES, _idx_, _ptr_ ) 170 CYG_UITRON_CHECK_AND_GETP_DIRECT( MBOXES, _idx_, _ptr_ )
166 #endif 171 #endif
167 172
168 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE 173 #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
169 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ 174 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \
170 CYG_UITRON_CHECK_AND_GETP_INDIRECT( FLAGS, _idx_, _ptr_ ) 175 CYG_UITRON_CHECK_AND_GETP_INDIRECT( FLAGS, _idx_, _ptr_ )
171 #else 176 #else
172 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ 177 #define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \
173 CYG_UITRON_CHECK_AND_GETP_DIRECT( FLAGS, _idx_, _ptr_ ) 178 CYG_UITRON_CHECK_AND_GETP_DIRECT( FLAGS, _idx_, _ptr_ )
174 #endif 179 #endif
175 180
176 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE 181 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
177 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ 182 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \
178 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) 183 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLFIXED, _idx_, _ptr_ )
179 #else 184 #else
180 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ 185 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \
181 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) 186 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLFIXED, _idx_, _ptr_ )
182 #endif 187 #endif
183 188
184 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE 189 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
185 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ 190 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \
186 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLVAR, _idx_, _ptr_ ) 191 CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLVAR, _idx_, _ptr_ )
187 #else 192 #else
188 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ 193 #define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \
189 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLVAR, _idx_, _ptr_ ) 194 CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLVAR, _idx_, _ptr_ )
190 #endif 195 #endif
191 196
192 // ------------------------------------------------------------------------ 197 // ------------------------------------------------------------------------
193 // Common error checking macros 198 // Common error checking macros
195 #if !defined( CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ) && \ 200 #if !defined( CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ) && \
196 !defined( CYGDBG_USE_ASSERTS ) 201 !defined( CYGDBG_USE_ASSERTS )
197 // if not checking and not asserted, these are removed to avoid usused 202 // if not checking and not asserted, these are removed to avoid usused
198 // variable warnings. 203 // variable warnings.
199 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_EMPTY_STATEMENT 204 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_EMPTY_STATEMENT
200 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_EMPTY_STATEMENT 205 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_EMPTY_STATEMENT
201 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_EMPTY_STATEMENT 206 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_EMPTY_STATEMENT
202 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( _tmout_ ) CYG_EMPTY_STATEMENT 207 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( _tmout_ ) CYG_EMPTY_STATEMENT
203 208
204 #else 209 #else
205 // the default: 210 // the default:
206 // Check a task is actually a uITRON task 211 // Check a task is actually a uITRON task
207 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_MACRO_START \ 212 #define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_MACRO_START \
208 CYG_UIT_PARAMCHECK( \ 213 CYG_UIT_PARAMCHECK( \
209 (&cyg_uitron_TASKS[0] <= (_self_)) && \ 214 (&cyg_uitron_TASKS[0] <= (_self_)) && \
210 ((_self_) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]), \ 215 ((_self_) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]), \
211 E_CTX ); \ 216 E_CTX ); \
212 CYG_MACRO_END 217 CYG_MACRO_END
213 218
214 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_MACRO_START \ 219 #define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_MACRO_START \
215 Cyg_Thread *self = Cyg_Thread::self(); \ 220 Cyg_Thread *self = Cyg_Thread::self(); \
216 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); \ 221 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); \
217 CYG_MACRO_END 222 CYG_MACRO_END
218 223
219 // Check dispatching is enabled for calls which might wait 224 // Check dispatching is enabled for calls which might wait
220 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_MACRO_START \ 225 #define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_MACRO_START \
221 CYG_UIT_PARAMCHECK( 0 == Cyg_Scheduler::get_sched_lock(), E_CTX ); \ 226 CYG_UIT_PARAMCHECK( 0 == cyg_uitron_dis_dsp_old_priority, E_CTX ); \
222 CYG_MACRO_END 227 CYG_MACRO_END
223 228
224 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO(_tmout_) CYG_MACRO_START \ 229 #define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO(_tmout_) CYG_MACRO_START \
225 CYG_UIT_PARAMCHECK( -1 <= (_tmout_), E_PAR ); \ 230 CYG_UIT_PARAMCHECK( -1 <= (_tmout_), E_PAR ); \
226 if ( TMO_POL != (_tmout_) ) \ 231 if ( TMO_POL != (_tmout_) ) \
227 CYG_UITRON_CHECK_DISPATCH_ENABLED(); \ 232 CYG_UITRON_CHECK_DISPATCH_ENABLED(); \
228 CYG_MACRO_END 233 CYG_MACRO_END
229 234
230 #endif 235 #endif
231 236
232 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR 237 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
233 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ 238 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \
234 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ 239 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \
235 CYG_MACRO_END 240 CYG_MACRO_END
236 #else // do check for NULL 241 #else // do check for NULL
237 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ 242 #define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \
238 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ 243 CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \
239 CYG_UIT_PARAMCHECK( NULL != (_p_), E_PAR ); \ 244 CYG_UIT_PARAMCHECK( NULL != (_p_), E_PAR ); \
240 CYG_MACRO_END 245 CYG_MACRO_END
241 #endif // !CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR 246 #endif // !CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
242 247
243 // ------------------------------------------------------------------------ 248 // ------------------------------------------------------------------------
244 // CYG_UITRON_FAIL_RETURN 249 // CYG_UITRON_FAIL_RETURN
246 // After a call which waits, it might return with success, or due to a 251 // After a call which waits, it might return with success, or due to a
247 // timeout or a release wait (a forced escape from the waiting condition). 252 // timeout or a release wait (a forced escape from the waiting condition).
248 // This macro examines context and finds out which, then executes a return 253 // This macro examines context and finds out which, then executes a return
249 // with the correct uITRON condition code. 254 // with the correct uITRON condition code.
250 255
251 #define CYG_UITRON_FAIL_RETURN_SELF( _self_ ) CYG_MACRO_START \ 256 #define CYG_UITRON_FAIL_RETURN_SELF( _self_ ) CYG_MACRO_START \
252 Cyg_Thread::cyg_reason reason = (_self_)->get_wake_reason(); \ 257 Cyg_Thread::cyg_reason reason = (_self_)->get_wake_reason(); \
253 if ( Cyg_Thread::TIMEOUT == reason ) \ 258 if ( Cyg_Thread::TIMEOUT == reason ) \
254 return E_TMOUT; \ 259 return E_TMOUT; \
255 if ( Cyg_Thread::BREAK == reason ) \ 260 if ( Cyg_Thread::BREAK == reason ) \
256 return E_RLWAI; \ 261 return E_RLWAI; \
257 if ( Cyg_Thread::DESTRUCT == reason ) \ 262 if ( Cyg_Thread::DESTRUCT == reason ) \
258 return E_DLT; \ 263 return E_DLT; \
259 return E_SYS; /* if no plausible reason was found */ \ 264 return E_SYS; /* if no plausible reason was found */ \
260 CYG_MACRO_END 265 CYG_MACRO_END
261 266
262 #define CYG_UITRON_FAIL_RETURN() CYG_MACRO_START \ 267 #define CYG_UITRON_FAIL_RETURN() CYG_MACRO_START \
263 Cyg_Thread *self = Cyg_Thread::self(); \ 268 Cyg_Thread *self = Cyg_Thread::self(); \
264 CYG_UITRON_FAIL_RETURN_SELF( self ); \ 269 CYG_UITRON_FAIL_RETURN_SELF( self ); \
265 CYG_MACRO_END 270 CYG_MACRO_END
266 271
267 // ------------------------------------------------------------------------ 272 // ------------------------------------------------------------------------
268 // Interrupts disabled? 273 // Interrupts disabled?
269 #define CYG_UITRON_CHECK_CPU_UNLOC() \ 274 #define CYG_UITRON_CHECK_CPU_UNLOC() \
270 CYG_UIT_PARAMCHECK( (Cyg_Interrupt::interrupts_enabled()), E_CTX ) 275 CYG_UIT_PARAMCHECK( (Cyg_Interrupt::interrupts_enabled()), E_CTX )
271 276
272 // ------------------------------------------------------------------------ 277 // ------------------------------------------------------------------------
273 // the function definitions themselves: 278 // the function definitions themselves:
274 279
326 Cyg_Thread *p; 331 Cyg_Thread *p;
327 ER ret = E_OK; 332 ER ret = E_OK;
328 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); 333 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
329 334
330 Cyg_Scheduler::lock(); 335 Cyg_Scheduler::lock();
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 }
331 cyg_uint32 state = p->get_state(); 341 cyg_uint32 state = p->get_state();
332 if ( state & Cyg_Thread::EXITED ) 342 if ( state & Cyg_Thread::EXITED )
333 // just disconnect the pointer from its object 343 // just disconnect the pointer from its object
334 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL; 344 CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL;
335 else 345 else
417 #ifdef CYGIMP_THREAD_PRIORITY 427 #ifdef CYGIMP_THREAD_PRIORITY
418 p->set_priority( (cyg_priority) 0 ); 428 p->set_priority( (cyg_priority) 0 );
419 #endif 429 #endif
420 } 430 }
421 Cyg_Scheduler::unlock(); 431 Cyg_Scheduler::unlock();
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
422 return ret; 439 return ret;
423 } 440 }
424 441
425 CYG_UIT_FUNC_INLINE 442 CYG_UIT_FUNC_INLINE
426 ER 443 ER
427 dis_dsp ( void ) 444 dis_dsp ( void )
428 { 445 {
429 CYG_UITRON_CHECK_TASK_CONTEXT(); 446 CYG_UITRON_CHECK_TASK_CONTEXT();
430 CYG_UITRON_CHECK_CPU_UNLOC(); 447 CYG_UITRON_CHECK_CPU_UNLOC();
431 // Prevent preemption 448 Cyg_Scheduler::lock();
432 if ( 0 == Cyg_Scheduler::get_sched_lock() ) 449 // Prevent preemption by going up to prio 0
433 Cyg_Scheduler::lock(); 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();
434 return E_OK; 460 return E_OK;
435 } 461 }
436 462
437 CYG_UIT_FUNC_INLINE 463 CYG_UIT_FUNC_INLINE
438 ER 464 ER
439 ena_dsp ( void ) 465 ena_dsp ( void )
440 { 466 {
441 CYG_UITRON_CHECK_TASK_CONTEXT(); 467 CYG_UITRON_CHECK_TASK_CONTEXT();
442 CYG_UITRON_CHECK_CPU_UNLOC(); 468 CYG_UITRON_CHECK_CPU_UNLOC();
443 // Unlock the scheduler (if locked) and maybe switch threads 469 Cyg_Scheduler::lock();
444 if ( 0 < Cyg_Scheduler::get_sched_lock() ) 470 // Enable dispatching (if disabled) and maybe switch threads
445 Cyg_Scheduler::unlock(); 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();
446 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards! 482 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards!
447 return E_OK; 483 return E_OK;
448 } 484 }
449 485
450 486
458 p = Cyg_Thread::self(); 494 p = Cyg_Thread::self();
459 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); 495 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p );
460 } 496 }
461 else 497 else
462 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); 498 CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p );
499
500 CYG_UIT_PARAMCHECK( 0 < tskpri, E_PAR );
463 #ifdef CYGIMP_THREAD_PRIORITY 501 #ifdef CYGIMP_THREAD_PRIORITY
464 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY 502 #if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY
465 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri && 503 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri &&
466 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); 504 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR );
467 #else 505 #else
468 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && 506 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri &&
469 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); 507 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR );
470 #endif 508 #endif
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 }
471 Cyg_Scheduler::lock(); 518 Cyg_Scheduler::lock();
472 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || 519 if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) ||
473 (Cyg_Thread::EXIT == p->get_wake_reason()) ) 520 (Cyg_Thread::EXIT == p->get_wake_reason()) )
474 ret = E_OBJ; // task is dormant 521 ret = E_OBJ; // task is dormant
475 else 522 else
494 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); 541 tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR );
495 #else 542 #else
496 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && 543 CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri &&
497 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); 544 tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR );
498 #endif 545 #endif
499 #ifdef CYGSEM_KERNEL_SCHED_MLQUEUE
500 Cyg_Thread::rotate_queue( tskpri ); 546 Cyg_Thread::rotate_queue( tskpri );
501 #endif
502 #endif // CYGIMP_THREAD_PRIORITY got priorities at all? 547 #endif // CYGIMP_THREAD_PRIORITY got priorities at all?
503 return E_OK; 548 return E_OK;
504 } 549 }
505 550
506 CYG_UIT_FUNC_INLINE 551 CYG_UIT_FUNC_INLINE
528 CYG_UIT_FUNC_INLINE 573 CYG_UIT_FUNC_INLINE
529 ER 574 ER
530 get_tid ( ID *p_tskid ) 575 get_tid ( ID *p_tskid )
531 { 576 {
532 Cyg_Thread *self = Cyg_Thread::self(); 577 Cyg_Thread *self = Cyg_Thread::self();
533 CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self );
534 CYG_UIT_PARAMCHECK_PTR( p_tskid ); 578 CYG_UIT_PARAMCHECK_PTR( p_tskid );
535 *p_tskid = (self - (&cyg_uitron_TASKS[0])) + 1; 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
536 return E_OK; 585 return E_OK;
537 } 586 }
538 587
539 CYG_UIT_FUNC_INLINE 588 CYG_UIT_FUNC_INLINE
540 ER 589 ER
572 ? TTS_WAI // WAIT state 621 ? TTS_WAI // WAIT state
573 : 0; // Not sure what's happening here! 622 : 0; // Not sure what's happening here!
574 #ifdef CYGIMP_THREAD_PRIORITY 623 #ifdef CYGIMP_THREAD_PRIORITY
575 if ( TTS_DMT == pk_rtsk->tskstat ) 624 if ( TTS_DMT == pk_rtsk->tskstat )
576 pk_rtsk->tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ); 625 pk_rtsk->tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid );
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;
577 else 631 else
578 pk_rtsk->tskpri = p->get_priority(); 632 pk_rtsk->tskpri = p->get_priority();
579 #else 633 #else
580 pk_rtsk->tskpri = -1; // Not applicable 634 pk_rtsk->tskpri = -1; // Not applicable
581 #endif 635 #endif
754 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); 808 CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p );
755 Cyg_Scheduler::lock(); 809 Cyg_Scheduler::lock();
756 // deal with the race condition here 810 // deal with the race condition here
757 if ( p != CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] ) { 811 if ( p != CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] ) {
758 Cyg_Scheduler::unlock(); 812 Cyg_Scheduler::unlock();
759 return E_OBJ; 813 return E_NOEXS;
760 } 814 }
761 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = NULL; 815 CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = NULL;
762 p->~Cyg_Counting_Semaphore2(); 816 p->~Cyg_Counting_Semaphore2();
763 Cyg_Scheduler::unlock(); 817 Cyg_Scheduler::unlock();
764 return E_OK; 818 return E_OK;
875 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); 929 CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p );
876 Cyg_Scheduler::lock(); 930 Cyg_Scheduler::lock();
877 // deal with the race condition here 931 // deal with the race condition here
878 if ( p != CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] ) { 932 if ( p != CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] ) {
879 Cyg_Scheduler::unlock(); 933 Cyg_Scheduler::unlock();
880 return E_OBJ; 934 return E_NOEXS;
881 } 935 }
882 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = NULL; 936 CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = NULL;
883 p->~Cyg_Flag(); 937 p->~Cyg_Flag();
884 Cyg_Scheduler::unlock(); 938 Cyg_Scheduler::unlock();
885 return E_OK; 939 return E_OK;
1032 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); 1086 CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p );
1033 Cyg_Scheduler::lock(); 1087 Cyg_Scheduler::lock();
1034 // deal with the race condition here 1088 // deal with the race condition here
1035 if ( p != CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] ) { 1089 if ( p != CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] ) {
1036 Cyg_Scheduler::unlock(); 1090 Cyg_Scheduler::unlock();
1037 return E_OBJ; 1091 return E_NOEXS;
1038 } 1092 }
1039 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = NULL; 1093 CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = NULL;
1040 p->~Cyg_Mbox(); 1094 p->~Cyg_Mbox();
1041 Cyg_Scheduler::unlock(); 1095 Cyg_Scheduler::unlock();
1042 return E_OK; 1096 return E_OK;
1052 // One hopes that often this will be optimized out, since the one or both 1106 // One hopes that often this will be optimized out, since the one or both
1053 // of these being true has been detected and errored out just above. 1107 // of these being true has been detected and errored out just above.
1054 1108
1055 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR 1109 #ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
1056 // represent a NULL as NADR internally 1110 // represent a NULL as NADR internally
1057 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_MACRO_START \ 1111 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_MACRO_START \
1058 if ( NULL == (_p_) ) \ 1112 if ( NULL == (_p_) ) \
1059 (_p_) = (T_MSG *)NADR; \ 1113 (_p_) = (T_MSG *)NADR; \
1060 CYG_MACRO_END 1114 CYG_MACRO_END
1061 1115
1062 // we get a NADR back sometimes, meaning NULL 1116 // we get a NADR back sometimes, meaning NULL
1063 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_MACRO_START \ 1117 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_MACRO_START \
1064 if ( NADR == (_p_) ) \ 1118 if ( NADR == (_p_) ) \
1065 (_p_) = (T_MSG *)NULL; \ 1119 (_p_) = (T_MSG *)NULL; \
1066 CYG_MACRO_END 1120 CYG_MACRO_END
1067 1121
1068 #else 1122 #else
1069 // NULL is checked for and makes an error 1123 // NULL is checked for and makes an error
1070 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_EMPTY_STATEMENT 1124 #define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_EMPTY_STATEMENT
1071 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_EMPTY_STATEMENT 1125 #define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_EMPTY_STATEMENT
1072 #endif 1126 #endif
1073 1127
1074 // and sometimes either in status enquiries 1128 // and sometimes either in status enquiries
1075 #define CYG_UIT_TMSG_FIXUP_ALL( _p_ ) CYG_MACRO_START \ 1129 #define CYG_UIT_TMSG_FIXUP_ALL( _p_ ) CYG_MACRO_START \
1076 if ( NULL == (_p_) ) \ 1130 if ( NULL == (_p_) ) \
1077 (_p_) = (T_MSG *)NADR; \ 1131 (_p_) = (T_MSG *)NADR; \
1078 else if ( NADR == (_p_) ) \ 1132 else if ( NADR == (_p_) ) \
1079 (_p_) = (T_MSG *)NULL; \ 1133 (_p_) = (T_MSG *)NULL; \
1080 CYG_MACRO_END 1134 CYG_MACRO_END
1081 1135
1082 CYG_UIT_FUNC_INLINE 1136 CYG_UIT_FUNC_INLINE
1083 ER 1137 ER
1084 snd_msg ( ID mbxid, T_MSG *pk_msg ) 1138 snd_msg ( ID mbxid, T_MSG *pk_msg )
1176 #endif // CYGPKG_UITRON_MBOXES 1230 #endif // CYGPKG_UITRON_MBOXES
1177 1231
1178 // - Extended Synchronization and Communication Functions 1232 // - Extended Synchronization and Communication Functions
1179 1233
1180 #if 0 // NOT SUPPORTED 1234 #if 0 // NOT SUPPORTED
1181 ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf ); 1235 ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf );
1182 ER del_mbf ( ID mbfid ); 1236 ER del_mbf ( ID mbfid );
1183 ER snd_mbf ( ID mbfid, VP msg, INT msgsz ); 1237 ER snd_mbf ( ID mbfid, VP msg, INT msgsz );
1184 ER psnd_mbf ( ID mbfid, VP msg, INT msgsz ); 1238 ER psnd_mbf ( ID mbfid, VP msg, INT msgsz );
1185 ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout ); 1239 ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout );
1186 ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); 1240 ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid );
1187 ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); 1241 ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid );
1188 ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout ); 1242 ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout );
1189 ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid ); 1243 ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid );
1190 ER cre_por ( ID porid, T_CPOR *pk_cpor ); 1244 ER cre_por ( ID porid, T_CPOR *pk_cpor );
1191 ER del_por ( ID porid ); 1245 ER del_por ( ID porid );
1192 ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT 1246 ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1193 cmsgsz ); 1247 cmsgsz );
1194 ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT 1248 ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1195 cmsgsz ); 1249 cmsgsz );
1196 ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT 1250 ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT
1197 cmsgsz, TMO tmout ); 1251 cmsgsz, TMO tmout );
1198 ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT 1252 ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1199 acpptn ); 1253 acpptn );
1200 ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT 1254 ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1201 acpptn ); 1255 acpptn );
1202 ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT 1256 ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT
1203 acpptn, TMO tmout ); 1257 acpptn, TMO tmout );
1204 ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz 1258 ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz
1205 ); 1259 );
1206 ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz ); 1260 ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz );
1207 ER ref_por ( T_RPOR *pk_rpor, ID porid ); 1261 ER ref_por ( T_RPOR *pk_rpor, ID porid );
1208 #endif 1262 #endif
1209 1263
1210 // - Interrupt Management Functions 1264 // - Interrupt Management Functions
1211 1265
1212 #if 0 // NOT SUPPORTED 1266 #if 0 // NOT SUPPORTED
1213 ER def_int ( UINT dintno, T_DINT *pk_dint ); 1267 ER def_int ( UINT dintno, T_DINT *pk_dint );
1214 void ret_wup ( ID tskid ); 1268 void ret_wup ( ID tskid );
1215 #endif 1269 #endif
1216 1270
1217 CYG_UIT_FUNC_INLINE 1271 CYG_UIT_FUNC_INLINE
1218 ER 1272 ER
1219 loc_cpu ( void ) 1273 loc_cpu ( void )
1220 { 1274 {
1221 CYG_UITRON_CHECK_TASK_CONTEXT(); 1275 CYG_UITRON_CHECK_TASK_CONTEXT();
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 }
1222 Cyg_Interrupt::disable_interrupts(); 1287 Cyg_Interrupt::disable_interrupts();
1223 if ( 0 == Cyg_Scheduler::get_sched_lock() ) 1288 Cyg_Scheduler::unlock();
1224 Cyg_Scheduler::lock();
1225 return E_OK; 1289 return E_OK;
1226 } 1290 }
1227 1291
1228 CYG_UIT_FUNC_INLINE 1292 CYG_UIT_FUNC_INLINE
1229 ER 1293 ER
1230 unl_cpu ( void ) 1294 unl_cpu ( void )
1231 { 1295 {
1232 CYG_UITRON_CHECK_TASK_CONTEXT(); 1296 CYG_UITRON_CHECK_TASK_CONTEXT();
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 }
1233 Cyg_Interrupt::enable_interrupts(); 1307 Cyg_Interrupt::enable_interrupts();
1234 if ( 0 < Cyg_Scheduler::get_sched_lock() ) 1308 Cyg_Scheduler::unlock();
1235 Cyg_Scheduler::unlock(); 1309 CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards!
1236 return E_OK; 1310 return E_OK;
1237 } 1311 }
1238 1312
1239 #if 0 // NOT SUPPORTED 1313 #if 0 // NOT SUPPORTED
1240 ER dis_int ( UINT eintno ); 1314 ER dis_int ( UINT eintno );
1241 ER ena_int ( UINT eintno ); 1315 ER ena_int ( UINT eintno );
1242 ER chg_iXX ( UINT iXXXX ); 1316 ER chg_iXX ( UINT iXXXX );
1243 ER ref_iXX ( UINT *p_iXXXX ); 1317 ER ref_iXX ( UINT *p_iXXXX );
1244 #endif 1318 #endif
1245 1319
1246 // - Memorypool Management Functions 1320 // - Memorypool Management Functions
1247 #ifdef CYGPKG_UITRON_MEMPOOLVAR 1321 #ifdef CYGPKG_UITRON_MEMPOOLVAR
1248 #if 0 < CYG_UITRON_NUM( MEMPOOLVAR ) 1322 #if 0 < CYG_UITRON_NUM( MEMPOOLVAR )
1284 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); 1358 CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p );
1285 Cyg_Scheduler::lock(); 1359 Cyg_Scheduler::lock();
1286 // deal with the race condition here 1360 // deal with the race condition here
1287 if ( p != CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] ) { 1361 if ( p != CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] ) {
1288 Cyg_Scheduler::unlock(); 1362 Cyg_Scheduler::unlock();
1289 return E_OBJ; 1363 return E_NOEXS;
1290 } 1364 }
1291 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = NULL; 1365 CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = NULL;
1292 p->~Cyg_Mempool_Variable(); 1366 p->~Cyg_Mempool_Variable();
1293 Cyg_Scheduler::unlock(); 1367 Cyg_Scheduler::unlock();
1294 return E_OK; 1368 return E_OK;
1434 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); 1508 CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p );
1435 Cyg_Scheduler::lock(); 1509 Cyg_Scheduler::lock();
1436 // deal with the race condition here 1510 // deal with the race condition here
1437 if ( p != CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] ) { 1511 if ( p != CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] ) {
1438 Cyg_Scheduler::unlock(); 1512 Cyg_Scheduler::unlock();
1439 return E_OBJ; 1513 return E_NOEXS;
1440 } 1514 }
1441 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = NULL; 1515 CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = NULL;
1442 p->~Cyg_Mempool_Fixed(); 1516 p->~Cyg_Mempool_Fixed();
1443 Cyg_Scheduler::unlock(); 1517 Cyg_Scheduler::unlock();
1444 return E_OK; 1518 return E_OK;
1709 ER 1783 ER
1710 get_ver ( T_VER *pk_ver ) 1784 get_ver ( T_VER *pk_ver )
1711 { 1785 {
1712 CYG_UIT_PARAMCHECK_PTR( pk_ver ); 1786 CYG_UIT_PARAMCHECK_PTR( pk_ver );
1713 1787
1714 pk_ver->maker = CYGNUM_UITRON_VER_MAKER; 1788 pk_ver->maker = CYGNUM_UITRON_VER_MAKER;
1715 pk_ver->id = CYGNUM_UITRON_VER_ID; 1789 pk_ver->id = CYGNUM_UITRON_VER_ID;
1716 pk_ver->spver = CYGNUM_UITRON_VER_SPVER; 1790 pk_ver->spver = CYGNUM_UITRON_VER_SPVER;
1717 pk_ver->prver = CYGNUM_UITRON_VER_PRVER; 1791 pk_ver->prver = CYGNUM_UITRON_VER_PRVER;
1718 pk_ver->prno[0] = CYGNUM_UITRON_VER_PRNO_0; 1792 pk_ver->prno[0] = CYGNUM_UITRON_VER_PRNO_0;
1719 pk_ver->prno[1] = CYGNUM_UITRON_VER_PRNO_1; 1793 pk_ver->prno[1] = CYGNUM_UITRON_VER_PRNO_1;
1720 pk_ver->prno[2] = CYGNUM_UITRON_VER_PRNO_2; 1794 pk_ver->prno[2] = CYGNUM_UITRON_VER_PRNO_2;
1721 pk_ver->prno[3] = CYGNUM_UITRON_VER_PRNO_3; 1795 pk_ver->prno[3] = CYGNUM_UITRON_VER_PRNO_3;
1722 pk_ver->cpu = CYGNUM_UITRON_VER_CPU; 1796 pk_ver->cpu = CYGNUM_UITRON_VER_CPU;
1723 pk_ver->var = CYGNUM_UITRON_VER_VAR; 1797 pk_ver->var = CYGNUM_UITRON_VER_VAR;
1724 1798
1725 return E_OK; 1799 return E_OK;
1726 } 1800 }
1727 1801
1728 CYG_UIT_FUNC_INLINE 1802 CYG_UIT_FUNC_INLINE
1733 if ( ! Cyg_Interrupt::interrupts_enabled() ) 1807 if ( ! Cyg_Interrupt::interrupts_enabled() )
1734 // CPU is locked 1808 // CPU is locked
1735 pk_rsys->sysstat = TSS_LOC; 1809 pk_rsys->sysstat = TSS_LOC;
1736 else 1810 else
1737 pk_rsys->sysstat = 1811 pk_rsys->sysstat =
1738 (Cyg_Scheduler::get_sched_lock() == 0) ? TSS_TSK : TSS_DDSP; 1812 (0 == cyg_uitron_dis_dsp_old_priority) ? TSS_TSK : TSS_DDSP;
1739 return E_OK; 1813 return E_OK;
1740 } 1814 }
1741 1815
1742 CYG_UIT_FUNC_INLINE 1816 CYG_UIT_FUNC_INLINE
1743 ER 1817 ER
1747 // no details here yet 1821 // no details here yet
1748 return E_OK; 1822 return E_OK;
1749 } 1823 }
1750 1824
1751 #if 0 // NOT SUPPORTED 1825 #if 0 // NOT SUPPORTED
1752 ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc ); 1826 ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc );
1753 ER def_exc ( UINT exckind, T_DEXC *pk_dexc ); 1827 ER def_exc ( UINT exckind, T_DEXC *pk_dexc );
1754 #endif 1828 #endif
1755 1829
1756 // - Network Support Functions 1830 // - Network Support Functions
1757 1831
1758 #if 0 // NOT SUPPORTED 1832 #if 0 // NOT SUPPORTED
1759 ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr, 1833 ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr,
1760 INT datsz ); 1834 INT datsz );
1761 ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr, 1835 ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr,
1762 INT datsz ); 1836 INT datsz );
1763 ER nget_nod ( NODE *p_node ); 1837 ER nget_nod ( NODE *p_node );
1764 ER nget_ver ( T_VER *pk_ver, NODE node ); 1838 ER nget_ver ( T_VER *pk_ver, NODE node );
1765 #endif 1839 #endif
1766 1840
1767 // ======================================================================== 1841 // ========================================================================
1768 1842
1769 #endif // CYGPKG_UITRON 1843 #endif // CYGPKG_UITRON