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