Mercurial > ecos-v2_0-branch
annotate packages/kernel/current/src/common/kapi.cxx @ 10:d3fbcdfa1b2f ecos-sw-1999-05-29
Merge from eCos master repository on 1999-05-29-00:13:11-BST
| author | jlarmour |
|---|---|
| date | Fri, 28 May 1999 16:43:09 +0000 |
| parents | ece80412419a |
| children | e7ba79f6d3a8 |
| rev | line source |
|---|---|
| 0 | 1 //========================================================================== |
| 2 // | |
| 2 | 3 // common/kapi.cxx |
| 0 | 4 // |
| 2 | 5 // C API Implementation |
| 0 | 6 // |
| 7 //========================================================================== | |
| 8 //####COPYRIGHTBEGIN#### | |
| 9 // | |
| 10 // ------------------------------------------- | |
| 11 // The contents of this file are subject to the Cygnus eCos Public License | |
| 12 // Version 1.0 (the "License"); you may not use this file except in | |
| 13 // compliance with the License. You may obtain a copy of the License at | |
| 14 // http://sourceware.cygnus.com/ecos | |
| 15 // | |
| 16 // Software distributed under the License is distributed on an "AS IS" | |
| 17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the | |
| 18 // License for the specific language governing rights and limitations under | |
| 19 // the License. | |
| 20 // | |
| 21 // The Original Code is eCos - Embedded Cygnus Operating System, released | |
| 22 // September 30, 1998. | |
| 23 // | |
| 24 // The Initial Developer of the Original Code is Cygnus. Portions created | |
| 2 | 25 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. |
| 0 | 26 // ------------------------------------------- |
| 27 // | |
| 28 //####COPYRIGHTEND#### | |
| 29 //========================================================================== | |
| 30 //#####DESCRIPTIONBEGIN#### | |
| 31 // | |
| 2 | 32 // Author(s): nickg, dsm |
| 33 // Contributors: nickg | |
| 34 // Date: 1998-03-02 | |
| 35 // Purpose: C API Implementation | |
| 36 // Description: C++ implementation of the C API | |
| 0 | 37 // |
| 38 // | |
| 39 //####DESCRIPTIONEND#### | |
| 40 // | |
| 41 //========================================================================== | |
| 42 | |
| 43 #include <pkgconf/kernel.h> | |
| 44 | |
| 45 #ifdef CYGFUN_KERNEL_API_C | |
| 46 | |
| 47 #include <cyg/kernel/ktypes.h> // base kernel types | |
| 48 #include <cyg/infra/cyg_trac.h> // tracing macros | |
| 49 #include <cyg/infra/cyg_ass.h> // assertion macros | |
| 50 #include <cyg/kernel/instrmnt.h> // instrumentation | |
| 51 #include <cyg/kernel/diag.h> | |
| 52 | |
| 53 #include <cyg/kernel/thread.hxx> | |
| 54 #include <cyg/kernel/thread.inl> // thread inlines | |
| 55 #include <cyg/kernel/sched.hxx> | |
| 56 #include <cyg/kernel/intr.hxx> | |
| 57 #include <cyg/kernel/clock.hxx> | |
| 58 | |
| 59 #include <cyg/kernel/memfixed.hxx> | |
| 60 #include <cyg/kernel/memvar.hxx> | |
| 61 | |
| 62 #include <cyg/kernel/sema.hxx> | |
| 63 #include <cyg/kernel/flag.hxx> | |
| 64 #include <cyg/kernel/mutex.hxx> | |
| 65 #include <cyg/kernel/mbox.hxx> | |
| 66 | |
| 67 #include <cyg/kernel/sched.inl> // scheduler inlines | |
| 68 #include <cyg/kernel/clock.inl> // clock inlines | |
| 69 | |
| 70 #include <cyg/kernel/kapi.h> // C API | |
| 71 | |
| 72 // ------------------------------------------------------------------------- | |
| 73 // Magic new function | |
| 74 | |
| 75 inline void *operator new(size_t size, void *ptr) | |
| 76 { | |
| 77 CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); | |
| 78 return ptr; | |
| 79 } | |
| 80 | |
| 81 // ------------------------------------------------------------------------- | |
| 82 | |
| 83 #ifdef CYGDBG_USE_ASSERTS | |
| 84 | |
| 85 #define CYG_ASSERT_SIZES(cstruct, cxxstruct) \ | |
| 86 CYG_MACRO_START \ | |
| 87 char *msg = "Size of C struct " #cstruct \ | |
| 88 " != size of C++ struct " #cxxstruct ; \ | |
| 89 CYG_ASSERT( sizeof(cstruct) == sizeof(cxxstruct) , msg ); \ | |
| 90 CYG_MACRO_END | |
| 91 | |
| 92 #else | |
| 93 | |
| 94 #define CYG_ASSERT_SIZES(cstruct, cxxstruct) | |
| 95 | |
| 96 #endif | |
| 97 | |
| 98 /*---------------------------------------------------------------------------*/ | |
| 99 /* Scheduler operations */ | |
| 100 | |
| 101 /* Starts scheduler with created threads. Never returns. */ | |
| 102 externC void cyg_scheduler_start(void) | |
| 103 { | |
| 104 Cyg_Scheduler::start(); | |
| 105 } | |
| 106 | |
|
4
1d7f19c9e4d1
Merge from eCos master repository on 1999-05-11-21:11:10-BST
jlarmour
parents:
2
diff
changeset
|
107 /* Lock the scheduler. */ |
| 0 | 108 externC void cyg_scheduler_lock(void) |
| 109 { | |
| 110 Cyg_Scheduler::lock(); | |
| 111 } | |
| 112 | |
|
4
1d7f19c9e4d1
Merge from eCos master repository on 1999-05-11-21:11:10-BST
jlarmour
parents:
2
diff
changeset
|
113 /* Unlock the scheduler. */ |
| 0 | 114 externC void cyg_scheduler_unlock(void) |
| 115 { | |
|
4
1d7f19c9e4d1
Merge from eCos master repository on 1999-05-11-21:11:10-BST
jlarmour
parents:
2
diff
changeset
|
116 Cyg_Scheduler::unlock(); |
| 0 | 117 } |
| 118 | |
| 119 /*---------------------------------------------------------------------------*/ | |
| 120 /* Thread operations */ | |
| 121 | |
| 122 externC void cyg_thread_create( | |
| 2 | 123 cyg_addrword_t sched_info, /* scheduling info (eg pri) */ |
| 0 | 124 cyg_thread_entry_t *entry, /* entry point function */ |
| 2 | 125 cyg_addrword_t entry_data, /* entry data */ |
| 0 | 126 char *name, /* optional thread name */ |
| 127 void *stack_base, /* stack base, NULL = alloc */ | |
| 128 cyg_ucount32 stack_size, /* stack size, 0 = default */ | |
| 129 cyg_handle_t *handle, /* returned thread handle */ | |
| 130 cyg_thread *thread /* put thread here */ | |
| 131 ) | |
| 132 { | |
| 133 CYG_ASSERT_SIZES( cyg_thread, Cyg_Thread ); | |
| 134 | |
| 135 Cyg_Thread *t = new((void *)thread) Cyg_Thread ( | |
| 136 (CYG_ADDRWORD) sched_info, | |
| 137 (cyg_thread_entry *)entry, | |
| 138 (CYG_ADDRWORD) entry_data, | |
| 139 name, | |
| 2 | 140 (CYG_ADDRWORD) stack_base, |
| 141 stack_size | |
| 0 | 142 ); |
| 143 t=t; | |
| 144 | |
| 145 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 146 *handle = (cyg_handle_t)thread; | |
| 147 } | |
| 148 | |
| 149 externC void cyg_thread_exit() | |
| 150 { | |
| 151 Cyg_Thread::exit(); | |
| 152 } | |
| 153 | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
154 externC cyg_bool_t cyg_thread_delete( cyg_handle_t thread ) |
| 2 | 155 { |
| 156 Cyg_Thread *th = (Cyg_Thread *)thread; | |
| 157 if( th->get_state() != Cyg_Thread::EXITED ) | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
158 th->kill(); // encourage it to terminate |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
159 if( th->get_state() != Cyg_Thread::EXITED ) |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
160 return false; // it didn't run yet, leave it up to the app to fix |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
161 th->~Cyg_Thread(); |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
162 return true; |
| 2 | 163 } |
| 164 | |
| 0 | 165 externC void cyg_thread_suspend(cyg_handle_t thread) |
| 166 { | |
| 167 ((Cyg_Thread *)thread)->suspend(); | |
| 168 } | |
| 169 | |
| 170 externC void cyg_thread_resume(cyg_handle_t thread) | |
| 171 { | |
| 172 Cyg_Thread *th = (Cyg_Thread *)thread; | |
| 173 | |
| 174 // If we are resuming an exited thread then | |
| 175 // reinitialize it. | |
| 176 | |
| 177 if( th->get_state() == Cyg_Thread::EXITED ) | |
| 178 th->reinitialize(); | |
| 179 | |
| 180 th->resume(); | |
| 181 } | |
| 182 | |
| 183 externC void cyg_thread_kill( cyg_handle_t thread) | |
| 184 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
185 ((Cyg_Thread *)thread)->kill(); |
| 0 | 186 } |
| 187 | |
| 2 | 188 externC void cyg_thread_release( cyg_handle_t thread) |
| 189 { | |
| 190 ((Cyg_Thread *)thread)->release(); | |
| 191 } | |
| 192 | |
| 0 | 193 externC void cyg_thread_yield() |
| 194 { | |
| 195 Cyg_Thread::yield(); | |
| 196 } | |
| 197 | |
| 198 externC cyg_handle_t cyg_thread_self() | |
| 199 { | |
| 200 return (cyg_handle_t)Cyg_Thread::self(); | |
| 201 } | |
| 202 | |
|
10
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
203 // idle thread is not really a plain CygThread; danger. |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
204 externC cyg_handle_t cyg_thread_idle_thread() |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
205 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
206 extern Cyg_Thread idle_thread; |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
207 return (cyg_handle_t)&idle_thread; |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
208 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
209 |
| 0 | 210 /* Priority manipulation */ |
| 211 externC void cyg_thread_set_priority( | |
| 212 cyg_handle_t thread, cyg_priority_t priority ) | |
| 213 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
214 #ifdef CYGIMP_THREAD_PRIORITY |
| 0 | 215 ((Cyg_Thread *)thread)->set_priority(priority); |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
216 #endif |
| 0 | 217 } |
| 218 | |
| 219 externC cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread) | |
| 220 { | |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
221 #ifdef CYGIMP_THREAD_PRIORITY |
| 0 | 222 return ((Cyg_Thread *)thread)->get_priority(); |
|
8
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
223 #else |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
224 return 0; |
|
ece80412419a
Merge from eCos master repository on 1999-05-21-22:05:54-BST
jlarmour
parents:
4
diff
changeset
|
225 #endif |
| 0 | 226 } |
| 227 | |
| 228 /* Deadline scheduling control (optional) */ | |
| 229 | |
| 230 externC void cyg_thread_deadline_wait( | |
| 231 cyg_tick_count_t start_time, /* abs earliest start time */ | |
| 232 cyg_tick_count_t run_time, /* worst case execution time */ | |
| 233 cyg_tick_count_t deadline /* absolute deadline */ | |
| 234 ) | |
| 235 { | |
| 236 CYG_ASSERT(0,"Not implemented"); | |
| 237 } | |
| 238 | |
| 239 externC void cyg_thread_delay(cyg_tick_count_t delay) | |
| 240 { | |
| 241 Cyg_Thread::self()->delay(delay); | |
| 242 } | |
| 243 | |
|
10
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
244 /* Stack information */ |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
245 externC cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread) |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
246 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
247 return ((Cyg_Thread *)thread)->get_stack_base(); |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
248 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
249 |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
250 externC cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread) |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
251 { |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
252 return ((Cyg_Thread *)thread)->get_stack_size(); |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
253 } |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
254 |
|
d3fbcdfa1b2f
Merge from eCos master repository on 1999-05-29-00:13:11-BST
jlarmour
parents:
8
diff
changeset
|
255 |
| 2 | 256 /*---------------------------------------------------------------------------*/ |
| 257 /* Per-thread data */ | |
| 258 | |
| 259 #ifdef CYGVAR_KERNEL_THREADS_DATA | |
| 260 | |
| 261 externC cyg_ucount32 cyg_thread_new_data_index() | |
| 262 { | |
| 263 return Cyg_Thread::new_data_index(); | |
| 264 } | |
| 265 | |
| 266 externC void cyg_thread_free_data_index(cyg_ucount32 index) | |
| 267 { | |
| 268 Cyg_Thread::free_data_index(index); | |
| 269 } | |
| 270 | |
| 271 externC CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index) | |
| 272 { | |
| 273 return Cyg_Thread::get_data(index); | |
| 274 } | |
| 275 | |
| 276 externC CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index) | |
| 277 { | |
| 278 return Cyg_Thread::get_data_ptr(index); | |
| 279 } | |
| 280 | |
| 281 externC void cyg_thread_set_data(cyg_ucount32 index, CYG_ADDRWORD | |
| 282 data) | |
| 283 { | |
| 284 Cyg_Thread::self()->set_data(index, data); | |
| 285 } | |
| 286 #endif | |
| 0 | 287 |
| 288 /*---------------------------------------------------------------------------*/ | |
| 289 /* Exception handling. */ | |
| 290 | |
| 291 #ifdef CYGPKG_KERNEL_EXCEPTIONS | |
| 292 externC void cyg_exception_set_handler( | |
| 293 cyg_code_t exception_number, | |
| 294 cyg_exception_handler_t *new_handler, | |
| 2 | 295 cyg_addrword_t new_data, |
| 0 | 296 cyg_exception_handler_t **old_handler, |
| 2 | 297 cyg_addrword_t *old_data |
| 0 | 298 ) |
| 299 { | |
| 300 Cyg_Thread::register_exception( | |
| 301 exception_number, | |
| 302 (cyg_exception_handler *)new_handler, | |
| 303 (CYG_ADDRWORD)new_data, | |
| 304 (cyg_exception_handler **)old_handler, | |
| 305 (CYG_ADDRWORD *)old_data | |
| 306 ); | |
| 307 } | |
| 308 | |
| 309 /* Clear exception handler to default */ | |
| 310 externC void cyg_exception_clear_handler( | |
| 311 cyg_code_t exception_number | |
| 312 ) | |
| 313 { | |
| 314 Cyg_Thread::deregister_exception( exception_number ); | |
| 315 } | |
| 316 | |
| 317 /* Invoke exception handler */ | |
| 318 externC void cyg_exception_call_handler( | |
| 319 cyg_handle_t thread, | |
| 320 cyg_code_t exception_number, | |
| 2 | 321 cyg_addrword_t error_code |
| 0 | 322 ) |
| 323 { | |
| 324 Cyg_Thread *t = (Cyg_Thread *)thread; | |
| 325 | |
| 326 t->deliver_exception( exception_number, error_code ); | |
| 327 } | |
| 328 #endif | |
| 329 | |
| 330 /*---------------------------------------------------------------------------*/ | |
| 331 /* Interrupt handling */ | |
| 332 | |
| 333 externC void cyg_interrupt_create( | |
| 334 cyg_vector_t vector, /* Vector to attach to */ | |
| 335 cyg_priority_t priority, /* Queue priority */ | |
| 2 | 336 cyg_addrword_t data, /* Data pointer */ |
| 0 | 337 cyg_ISR_t *isr, /* Interrupt Service Routine */ |
| 338 cyg_DSR_t *dsr, /* Deferred Service Routine */ | |
| 339 cyg_handle_t *handle, /* returned handle */ | |
| 340 cyg_interrupt *intr /* put interrupt here */ | |
| 341 ) | |
| 342 { | |
| 343 CYG_ASSERT_SIZES( cyg_interrupt, Cyg_Interrupt ); | |
| 344 | |
| 345 Cyg_Interrupt *t = new((void *)intr) Cyg_Interrupt ( | |
| 346 (cyg_vector)vector, | |
| 347 (cyg_priority)priority, | |
| 348 (CYG_ADDRWORD)data, | |
| 349 (cyg_ISR *)isr, | |
| 350 (cyg_DSR *)dsr ); | |
| 351 t=t; | |
| 352 | |
| 353 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 354 *handle = (cyg_handle_t)intr; | |
| 355 } | |
| 356 | |
| 357 externC void cyg_interrupt_delete( cyg_handle_t interrupt) | |
| 358 { | |
| 359 ((Cyg_Interrupt *)interrupt)->~Cyg_Interrupt(); | |
| 360 } | |
| 361 | |
| 362 void cyg_interrupt_attach( cyg_handle_t interrupt ) | |
| 363 { | |
| 364 ((Cyg_Interrupt *)interrupt)->attach(); | |
| 365 } | |
| 366 | |
| 367 void cyg_interrupt_detach( cyg_handle_t interrupt ) | |
| 368 { | |
| 369 ((Cyg_Interrupt *)interrupt)->detach(); | |
| 370 } | |
| 371 | |
| 372 /* VSR manipulation */ | |
| 373 | |
| 374 externC void cyg_interrupt_get_vsr( | |
| 375 cyg_vector_t vector, /* vector to get */ | |
| 376 cyg_VSR_t **vsr /* vsr got */ | |
| 377 ) | |
| 378 { | |
| 379 Cyg_Interrupt::get_vsr( (cyg_vector)vector, (cyg_VSR **)vsr); | |
| 380 } | |
| 381 | |
| 382 externC void cyg_interrupt_set_vsr( | |
| 383 cyg_vector_t vector, /* vector to set */ | |
| 384 cyg_VSR_t *vsr /* vsr to set */ | |
| 385 ) | |
| 386 { | |
| 387 Cyg_Interrupt::set_vsr( (cyg_vector)vector, (cyg_VSR *)vsr); | |
| 388 } | |
| 389 | |
| 390 /* CPU level interrupt mask */ | |
| 391 externC void cyg_interrupt_disable() | |
| 392 { | |
| 393 Cyg_Interrupt::disable_interrupts(); | |
| 394 } | |
| 395 | |
| 396 externC void cyg_interrupt_enable() | |
| 397 { | |
| 398 Cyg_Interrupt::enable_interrupts(); | |
| 399 } | |
| 400 | |
| 401 /* Interrupt controller access */ | |
| 402 externC void cyg_interrupt_mask(cyg_vector_t vector) | |
| 403 { | |
| 404 Cyg_Interrupt::mask_interrupt( (cyg_vector)vector); | |
| 405 } | |
| 406 | |
| 407 externC void cyg_interrupt_unmask(cyg_vector_t vector) | |
| 408 { | |
| 409 Cyg_Interrupt::unmask_interrupt( (cyg_vector)vector); | |
| 410 } | |
| 411 | |
| 412 | |
| 413 externC void cyg_interrupt_acknowledge(cyg_vector_t vector) | |
| 414 { | |
| 415 Cyg_Interrupt::acknowledge_interrupt( (cyg_vector)vector); | |
| 416 } | |
| 417 | |
| 418 | |
| 419 externC void cyg_interrupt_configure( | |
| 420 cyg_vector_t vector, /* vector to configure */ | |
| 421 cyg_bool_t level, /* level or edge triggered */ | |
| 422 cyg_bool_t up /* rising/faling edge, high/low level*/ | |
| 423 ) | |
| 424 { | |
| 425 Cyg_Interrupt::configure_interrupt( (cyg_vector)vector, level, up ); | |
| 426 } | |
| 427 | |
| 428 | |
| 429 /*---------------------------------------------------------------------------*/ | |
| 430 /* Counters, Clocks and Alarms */ | |
| 431 | |
| 432 externC void cyg_counter_create( | |
| 433 cyg_handle_t *handle, /* returned counter handle */ | |
| 434 cyg_counter *counter /* put counter here */ | |
| 435 ) | |
| 436 { | |
| 437 CYG_ASSERT_SIZES( cyg_counter, Cyg_Counter ); | |
| 438 | |
| 439 Cyg_Counter *t = new((void *)counter) Cyg_Counter (); | |
| 440 t=t; | |
| 441 | |
| 442 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 443 *handle = (cyg_handle_t)counter; | |
| 444 } | |
| 445 | |
| 446 externC void cyg_counter_delete(cyg_handle_t counter) | |
| 447 { | |
| 448 ((Cyg_Counter *)counter)->~Cyg_Counter(); | |
| 449 } | |
| 450 | |
| 451 /* Return current value of counter */ | |
| 452 externC cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) | |
| 453 { | |
| 454 return ((Cyg_Counter *)counter)->current_value(); | |
| 455 } | |
| 456 | |
| 457 /* Set new current value */ | |
| 458 externC void cyg_counter_set_value( | |
| 459 cyg_handle_t counter, | |
| 460 cyg_tick_count_t new_value | |
| 461 ) | |
| 462 { | |
| 463 ((Cyg_Counter *)counter)->set_value( new_value ); | |
| 464 } | |
| 465 | |
| 466 /* Advance counter by one tick */ | |
| 467 externC void cyg_counter_tick(cyg_handle_t counter) | |
| 468 { | |
| 469 ((Cyg_Counter *)counter)->tick(); | |
| 470 } | |
| 471 | |
| 472 /* Create a clock object */ | |
| 473 externC void cyg_clock_create( | |
| 474 cyg_resolution_t resolution, /* Initial resolution */ | |
| 475 cyg_handle_t *handle, /* Returned clock handle */ | |
| 476 cyg_clock *clock /* put clock here */ | |
| 477 ) | |
| 478 { | |
| 479 CYG_ASSERT_SIZES( cyg_clock, Cyg_Clock ); | |
| 480 | |
| 481 Cyg_Clock::cyg_resolution res; | |
| 482 | |
| 483 res.dividend = resolution.dividend; | |
| 484 res.divisor = resolution.divisor; | |
| 485 | |
| 486 Cyg_Clock *t = new((void *)clock) Cyg_Clock ( res ); | |
| 487 t=t; | |
| 488 | |
| 489 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 490 *handle = (cyg_handle_t)clock; | |
| 491 } | |
| 492 | |
| 493 externC void cyg_clock_delete(cyg_handle_t clock) | |
| 494 { | |
| 495 ((Cyg_Clock *)clock)->~Cyg_Clock(); | |
| 496 } | |
| 497 | |
| 498 /* convert a clock handle to a counter handle so we can use the */ | |
| 499 /* counter API on it. */ | |
| 500 externC void cyg_clock_to_counter( | |
| 501 cyg_handle_t clock, | |
| 502 cyg_handle_t *counter | |
| 503 ) | |
| 504 { | |
| 505 CYG_CHECK_DATA_PTR( counter, "Bad counter handle pointer" ); | |
| 506 *counter = (cyg_handle_t)(Cyg_Counter *)clock; | |
| 507 } | |
| 508 | |
| 509 externC void cyg_clock_set_resolution( | |
| 510 cyg_handle_t clock, | |
| 511 cyg_resolution_t resolution /* New resolution */ | |
| 512 ) | |
| 513 { | |
| 514 Cyg_Clock::cyg_resolution res; | |
| 515 | |
| 516 res.dividend = resolution.dividend; | |
| 517 res.divisor = resolution.divisor; | |
| 518 | |
| 519 ((Cyg_Clock *)clock)->set_resolution( res ); | |
| 520 } | |
| 521 | |
| 522 externC cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) | |
| 523 { | |
| 524 Cyg_Clock::cyg_resolution res = | |
| 525 ((Cyg_Clock *)clock)->get_resolution(); | |
| 526 | |
| 527 cyg_resolution_t resolution; | |
| 528 | |
| 529 resolution.dividend = res.dividend; | |
| 530 resolution.divisor = res.divisor; | |
| 531 | |
| 532 return resolution; | |
| 533 } | |
| 534 | |
| 535 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK | |
| 536 externC cyg_handle_t cyg_real_time_clock(void) | |
| 537 { | |
| 538 return (cyg_handle_t)Cyg_Clock::real_time_clock; | |
| 539 } | |
| 540 | |
| 541 externC cyg_tick_count_t cyg_current_time(void) | |
| 542 { | |
| 543 return Cyg_Clock::real_time_clock->current_value(); | |
| 544 } | |
| 545 #endif | |
| 546 | |
| 547 externC void cyg_alarm_create( | |
| 548 cyg_handle_t counter, /* Attached to this counter */ | |
| 549 cyg_alarm_t *alarmfn, /* Call-back function */ | |
| 2 | 550 cyg_addrword_t data, /* Call-back data */ |
| 0 | 551 cyg_handle_t *handle, /* Returned alarm object */ |
| 552 cyg_alarm *alarm /* put alarm here */ | |
| 553 ) | |
| 554 { | |
| 555 CYG_ASSERT_SIZES( cyg_alarm, Cyg_Alarm ); | |
| 556 | |
| 557 Cyg_Alarm *t = new((void *)alarm) Cyg_Alarm ( | |
| 558 (Cyg_Counter *)counter, | |
| 2 | 559 (cyg_alarm_fn *)alarmfn, |
| 560 (CYG_ADDRWORD)data | |
| 0 | 561 ); |
| 562 t=t; | |
| 563 | |
| 564 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 565 *handle = (cyg_handle_t)alarm; | |
| 566 } | |
| 567 | |
| 568 /* Disable alarm, detach from counter and invalidate handles */ | |
| 569 externC void cyg_alarm_delete( cyg_handle_t alarm) | |
| 570 { | |
| 571 ((Cyg_Alarm *)alarm)->~Cyg_Alarm(); | |
| 572 } | |
| 573 | |
| 574 externC void cyg_alarm_initialize( | |
| 575 cyg_handle_t alarm, | |
| 576 cyg_tick_count_t trigger, /* Absolute trigger time */ | |
| 577 cyg_tick_count_t interval /* Relative retrigger interval */ | |
| 578 ) | |
| 579 { | |
| 580 ((Cyg_Alarm *)alarm)->initialize( | |
| 2 | 581 (cyg_tick_count)trigger, |
| 582 (cyg_tick_count)interval); | |
| 0 | 583 } |
| 584 | |
| 585 externC void cyg_alarm_enable( cyg_handle_t alarm ) | |
| 586 { | |
| 587 ((Cyg_Alarm *)alarm)->enable(); | |
| 588 } | |
| 589 | |
| 590 externC void cyg_alarm_disable( cyg_handle_t alarm ) | |
| 591 { | |
| 592 ((Cyg_Alarm *)alarm)->disable(); | |
| 593 } | |
| 594 | |
| 595 /*---------------------------------------------------------------------------*/ | |
| 596 /* Mail boxes */ | |
| 597 | |
| 598 externC void cyg_mbox_create( | |
| 599 cyg_handle_t *handle, | |
| 600 cyg_mbox *mbox | |
| 601 ) | |
| 602 { | |
| 603 CYG_ASSERT_SIZES( cyg_mbox, Cyg_Mbox ); | |
| 604 | |
| 605 Cyg_Mbox *t = new((void *)mbox) Cyg_Mbox(); | |
| 606 t=t; | |
| 607 | |
| 608 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 609 *handle = (cyg_handle_t)mbox; | |
| 610 } | |
| 611 | |
| 612 externC void cyg_mbox_delete(cyg_handle_t mbox) | |
| 613 { | |
| 614 ((Cyg_Mbox *)mbox)->~Cyg_Mbox(); | |
| 615 } | |
| 616 | |
| 617 externC void *cyg_mbox_get(cyg_handle_t mbox) | |
| 618 { | |
| 619 return ((Cyg_Mbox *)mbox)->get(); | |
| 620 } | |
| 621 | |
| 622 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 623 void *cyg_mbox_timed_get( | |
| 624 cyg_handle_t mbox, | |
| 625 cyg_tick_count_t abstime | |
| 626 ) | |
| 627 { | |
| 628 return ((Cyg_Mbox *)mbox)->get(abstime); | |
| 629 } | |
| 630 #endif | |
| 631 | |
| 632 externC void *cyg_mbox_tryget(cyg_handle_t mbox) | |
| 633 { | |
| 634 return ((Cyg_Mbox *)mbox)->tryget(); | |
| 635 } | |
| 636 | |
| 637 externC void *cyg_mbox_peek_item(cyg_handle_t mbox) | |
| 638 { | |
| 639 return ((Cyg_Mbox *)mbox)->peek_item(); | |
| 640 } | |
| 641 | |
| 642 #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT | |
| 643 externC cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) | |
| 644 { | |
| 645 return ((Cyg_Mbox *)mbox)->put(item); | |
| 646 } | |
| 647 | |
| 648 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 649 externC cyg_bool_t cyg_mbox_timed_put( | |
| 650 cyg_handle_t mbox, | |
| 651 void *item, | |
| 652 cyg_tick_count_t abstime | |
| 653 ) | |
| 654 { | |
| 655 return ((Cyg_Mbox *)mbox)->put(item, abstime); | |
| 656 } | |
| 657 #endif | |
| 658 #endif | |
| 659 | |
| 660 externC cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) | |
| 661 { | |
| 662 return ((Cyg_Mbox *)mbox)->tryput(item); | |
| 663 } | |
| 664 | |
| 665 externC cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) | |
| 666 { | |
| 667 return ((Cyg_Mbox *)mbox)->peek(); | |
| 668 } | |
| 669 | |
| 670 externC cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) | |
| 671 { | |
| 672 return ((Cyg_Mbox *)mbox)->waiting_to_get(); | |
| 673 } | |
| 674 | |
| 675 externC cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) | |
| 676 { | |
| 677 return ((Cyg_Mbox *)mbox)->waiting_to_put(); | |
| 678 } | |
| 679 | |
| 680 | |
| 681 /*-----------------------------------------------------------------------*/ | |
| 682 /* Memory pools */ | |
| 683 | |
| 684 /* Create a variable size memory pool */ | |
| 685 externC void cyg_mempool_var_create( | |
| 686 void *base, /* base of memory to use for pool */ | |
| 687 cyg_int32 size, /* size of memory in bytes */ | |
| 688 cyg_handle_t *handle, /* returned handle of memory pool */ | |
| 689 cyg_mempool_var *var /* space to put pool structure in */ | |
| 690 ) | |
| 691 { | |
| 692 CYG_ASSERT_SIZES( cyg_mempool_var, Cyg_Mempool_Variable ); | |
| 693 | |
| 694 Cyg_Mempool_Variable *t = new((void *)var) Cyg_Mempool_Variable ( | |
| 695 (cyg_uint8 *)base, | |
| 2 | 696 size |
| 0 | 697 ); |
| 698 t=t; | |
| 699 | |
| 700 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 701 *handle = (cyg_handle_t)var; | |
| 702 } | |
| 703 | |
| 704 /* Delete variable size memory pool */ | |
| 705 externC void cyg_mempool_var_delete(cyg_handle_t varpool) | |
| 706 { | |
| 707 ((Cyg_Mempool_Variable *)varpool)->~Cyg_Mempool_Variable(); | |
| 708 } | |
| 709 | |
| 710 /* Allocates a block of length size. This waits if the memory is not | |
| 711 currently available. */ | |
| 712 externC void *cyg_mempool_var_alloc(cyg_handle_t varpool, cyg_int32 size) | |
| 713 { | |
| 714 return ((Cyg_Mempool_Variable *)varpool)->alloc(size); | |
| 715 } | |
| 716 | |
| 717 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 718 | |
| 719 /* Allocates a block of length size. This waits for up to delay | |
| 720 ticks, if the memory is not already available. NULL is returned if | |
| 721 no memory is available. */ | |
| 722 externC void *cyg_mempool_var_timed_alloc( | |
| 723 cyg_handle_t varpool, | |
| 724 cyg_int32 size, | |
| 725 cyg_tick_count_t abstime) | |
| 726 { | |
| 727 return ((Cyg_Mempool_Variable *)varpool)->alloc(size, abstime); | |
| 728 } | |
| 729 | |
| 730 #endif | |
| 731 | |
| 732 /* Allocates a block of length size. NULL is returned if no memory is | |
| 733 available. */ | |
| 734 externC void *cyg_mempool_var_try_alloc( | |
| 735 cyg_handle_t varpool, | |
| 736 cyg_int32 size) | |
| 737 { | |
| 738 return ((Cyg_Mempool_Variable *)varpool)->try_alloc(size); | |
| 739 } | |
| 740 | |
| 741 /* Frees memory back into variable size pool. */ | |
| 742 externC void cyg_mempool_var_free(cyg_handle_t varpool, void *p) | |
| 743 { | |
| 744 cyg_bool b; | |
| 745 b = ((Cyg_Mempool_Variable *)varpool)->free((cyg_uint8 *)p, 0); | |
| 746 CYG_ASSERT( b, "Bad free"); | |
| 747 } | |
| 748 | |
| 749 | |
| 750 /* Returns true if there are any threads waiting for memory in the | |
| 751 given memory pool. */ | |
| 752 externC cyg_bool_t cyg_mempool_var_waiting(cyg_handle_t varpool) | |
| 753 { | |
| 754 return ((Cyg_Mempool_Variable *)varpool)->waiting(); | |
| 755 } | |
| 756 | |
| 757 /* Puts information about a variable memory pool into the structure | |
| 758 provided. */ | |
| 759 externC void cyg_mempool_var_get_info( | |
| 760 cyg_handle_t varpool, | |
| 761 cyg_mempool_info *info) | |
| 762 { | |
| 763 Cyg_Mempool_Variable *v = (Cyg_Mempool_Variable *)varpool; | |
| 764 cyg_uint8 *base; | |
| 765 CYG_ADDRWORD maxfree; | |
| 766 | |
| 767 info->totalmem = v->get_totalmem(); | |
| 768 info->freemem = v->get_freemem(); | |
| 769 v->get_arena(base, info->size, maxfree); | |
| 770 info->base = (void *)base; | |
| 771 info->blocksize = -1; | |
| 772 info->maxfree = maxfree; | |
| 773 } | |
| 774 | |
| 775 | |
| 776 /* Create a fixed size memory pool */ | |
| 777 externC void cyg_mempool_fix_create( | |
| 778 void *base, // base of memory to use for pool | |
| 779 cyg_int32 size, // size of memory in byte | |
| 780 cyg_int32 blocksize, // size of allocation in bytes | |
| 781 cyg_handle_t *handle, // handle of memory pool | |
| 782 cyg_mempool_fix *fix // space to put pool structure in | |
| 783 ) | |
| 784 { | |
| 785 CYG_ASSERT_SIZES( cyg_mempool_fix, Cyg_Mempool_Fixed ); | |
| 786 | |
| 787 Cyg_Mempool_Fixed *t = new((void *)fix) Cyg_Mempool_Fixed ( | |
| 788 (cyg_uint8 *)base, | |
| 2 | 789 size, |
| 0 | 790 blocksize |
| 791 ); | |
| 792 t=t; | |
| 793 | |
| 794 CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" ); | |
| 795 *handle = (cyg_handle_t)fix; | |
| 796 } | |
| 797 | |
| 798 /* Delete fixed size memory pool */ | |
| 799 externC void cyg_mempool_fix_delete(cyg_handle_t fixpool) | |
| 800 { | |
| 801 ((Cyg_Mempool_Fixed *)fixpool)->~Cyg_Mempool_Fixed(); | |
| 802 } | |
| 803 | |
| 804 /* Allocates a block. This waits if the memory is not | |
| 805 currently available. */ | |
| 806 externC void *cyg_mempool_fix_alloc(cyg_handle_t fixpool) | |
| 807 { | |
| 808 return ((Cyg_Mempool_Fixed *)fixpool)->alloc(); | |
| 809 } | |
| 810 | |
| 811 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 812 | |
| 813 /* Allocates a block. This waits for up to delay ticks, if the memory | |
| 814 is not already available. NULL is returned if no memory is | |
| 815 available. */ | |
| 816 externC void *cyg_mempool_fix_timed_alloc( | |
| 817 cyg_handle_t fixpool, | |
| 818 cyg_tick_count_t abstime) | |
| 819 { | |
| 820 return ((Cyg_Mempool_Fixed *)fixpool)->alloc(abstime); | |
| 821 } | |
| 822 | |
| 823 #endif | |
| 824 | |
| 825 /* Allocates a block. NULL is returned if no memory is available. */ | |
| 826 externC void *cyg_mempool_fix_try_alloc(cyg_handle_t fixpool) | |
| 827 { | |
| 828 return ((Cyg_Mempool_Fixed *)fixpool)->try_alloc(); | |
| 829 } | |
| 830 | |
| 831 /* Frees memory back into fixed size pool. */ | |
| 832 externC void cyg_mempool_fix_free(cyg_handle_t fixpool, void *p) | |
| 833 { | |
| 834 cyg_bool b; | |
| 835 b = ((Cyg_Mempool_Fixed *)fixpool)->free((cyg_uint8 *)p); | |
| 836 CYG_ASSERT( b, "Bad free"); | |
| 837 } | |
| 838 | |
| 839 /* Returns true if there are any threads waiting for memory in the | |
| 840 given memory pool. */ | |
| 841 externC cyg_bool_t cyg_mempool_fix_waiting(cyg_handle_t fixpool) | |
| 842 { | |
| 843 return ((Cyg_Mempool_Fixed *)fixpool)->waiting(); | |
| 844 } | |
| 845 | |
| 846 /* Puts information about a variable memory pool into the structure | |
| 847 provided. */ | |
| 848 externC void cyg_mempool_fix_get_info( | |
| 849 cyg_handle_t fixpool, | |
| 850 cyg_mempool_info *info) | |
| 851 { | |
| 852 Cyg_Mempool_Fixed *f = (Cyg_Mempool_Fixed *)fixpool; | |
| 853 cyg_uint8 *base; | |
| 854 cyg_addrword_t blocksize; | |
| 855 | |
| 856 info->totalmem = f->get_totalmem(); | |
| 857 info->freemem = f->get_freemem(); | |
| 858 f->get_arena(base, info->size, blocksize); | |
| 859 info->base = (void *)base; | |
| 860 info->maxfree = info->blocksize = (cyg_int32)blocksize; | |
| 861 } | |
| 862 | |
| 863 /*---------------------------------------------------------------------------*/ | |
| 864 /* Semaphores */ | |
| 865 | |
| 866 externC void cyg_semaphore_init( | |
| 867 cyg_sem_t *sem, /* Semaphore to init */ | |
| 2 | 868 cyg_count32 val /* Initial semaphore value */ |
| 0 | 869 ) |
| 870 { | |
| 871 CYG_ASSERT_SIZES( cyg_sem_t, Cyg_Counting_Semaphore ); | |
| 872 | |
| 873 Cyg_Counting_Semaphore *t = new((void *)sem) Cyg_Counting_Semaphore(val); | |
| 874 t=t; | |
| 875 } | |
| 876 | |
| 877 externC void cyg_semaphore_destroy( cyg_sem_t *sem ) | |
| 878 { | |
| 879 ((Cyg_Counting_Semaphore *)sem)->~Cyg_Counting_Semaphore(); | |
| 880 } | |
| 881 | |
| 882 externC void cyg_semaphore_wait( cyg_sem_t *sem ) | |
| 883 { | |
| 884 ((Cyg_Counting_Semaphore *)sem)->wait(); | |
| 885 } | |
| 886 | |
| 887 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 888 externC cyg_bool_t cyg_semaphore_timed_wait( | |
| 889 cyg_sem_t *sem, | |
| 890 cyg_tick_count_t abstime | |
| 891 ) | |
| 892 { | |
| 893 return ((Cyg_Counting_Semaphore *)sem)->wait(abstime); | |
| 894 } | |
| 895 #endif | |
| 896 | |
| 897 | |
| 898 externC int cyg_semaphore_trywait( cyg_sem_t *sem ) | |
| 899 { | |
| 900 return ((Cyg_Counting_Semaphore *)sem)->trywait(); | |
| 901 } | |
| 902 | |
| 903 externC void cyg_semaphore_post( cyg_sem_t *sem ) | |
| 904 { | |
| 905 ((Cyg_Counting_Semaphore *)sem)->post(); | |
| 906 } | |
| 907 | |
| 2 | 908 externC void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) |
| 0 | 909 { |
| 910 CYG_CHECK_DATA_PTR( val, "Bad val parameter" ); | |
| 911 | |
| 912 *val = ((Cyg_Counting_Semaphore *)sem)->peek(); | |
| 913 } | |
| 914 | |
| 915 | |
| 916 /*---------------------------------------------------------------------------*/ | |
| 917 /* Flags */ | |
| 918 | |
| 919 void cyg_flag_init( | |
| 920 cyg_flag_t *flag /* Flag to init */ | |
| 921 ) | |
| 922 { | |
| 923 CYG_ASSERT_SIZES( cyg_flag_t, Cyg_Flag ); | |
| 924 CYG_ASSERT( | |
| 925 ( Cyg_Flag::AND == CYG_FLAG_WAITMODE_AND ) && | |
| 926 ( Cyg_Flag::OR == CYG_FLAG_WAITMODE_OR ) && | |
| 927 ( Cyg_Flag::CLR == CYG_FLAG_WAITMODE_CLR ), | |
| 928 "CYG_FLAG_WAITMODE_xxx definition != C++ Cyg_Flag::xxx" ); | |
| 929 | |
| 930 Cyg_Flag *t = new((void *)flag) Cyg_Flag(); | |
| 931 t=t; | |
| 932 } | |
| 933 | |
| 934 void cyg_flag_destroy( cyg_flag_t *flag ) | |
| 935 { | |
| 936 ((Cyg_Flag *)flag)->~Cyg_Flag(); | |
| 937 } | |
| 938 | |
| 939 void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) | |
| 940 { | |
| 941 ((Cyg_Flag *)flag)->setbits( value ); | |
| 942 } | |
| 943 | |
| 944 void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) | |
| 945 { | |
| 946 ((Cyg_Flag *)flag)->maskbits( value ); | |
| 947 } | |
| 948 | |
| 949 cyg_flag_value_t cyg_flag_wait( cyg_flag_t *flag, | |
| 950 cyg_flag_value_t pattern, | |
| 951 cyg_flag_mode_t mode ) | |
| 952 { | |
| 953 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 954 return 0; | |
| 955 return ((Cyg_Flag *)flag)->wait( pattern, mode ); | |
| 956 | |
| 957 } | |
| 958 | |
| 959 #ifdef CYGFUN_KERNEL_THREADS_TIMER | |
| 960 cyg_flag_value_t cyg_flag_timed_wait( cyg_flag_t *flag, | |
| 961 cyg_flag_value_t pattern, | |
| 962 cyg_flag_mode_t mode, | |
| 963 cyg_tick_count_t abstime ) | |
| 964 { | |
| 965 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 966 return 0; | |
| 967 return ((Cyg_Flag *)flag)->wait( pattern, mode, abstime ); | |
| 968 | |
| 969 } | |
| 970 #endif | |
| 971 | |
| 972 cyg_flag_value_t cyg_flag_poll( cyg_flag_t *flag, | |
| 973 cyg_flag_value_t pattern, | |
| 974 cyg_flag_mode_t mode ) | |
| 975 { | |
| 976 if ( 0 == pattern || 0 != (mode & ~3) ) | |
| 977 return 0; | |
| 978 return ((Cyg_Flag *)flag)->poll( pattern, mode ); | |
| 979 | |
| 980 } | |
| 981 | |
| 982 cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) | |
| 983 { | |
| 984 return ((Cyg_Flag *)flag)->peek(); | |
| 985 } | |
| 986 | |
| 987 cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) | |
| 988 { | |
| 989 return ((Cyg_Flag *)flag)->waiting(); | |
| 990 } | |
| 991 | |
| 992 /*---------------------------------------------------------------------------*/ | |
| 993 /* Mutex */ | |
| 994 | |
| 995 externC void cyg_mutex_init( | |
| 996 cyg_mutex_t *mutex /* Mutex to init */ | |
| 997 ) | |
| 998 { | |
| 999 CYG_ASSERT_SIZES( cyg_mutex_t, Cyg_Mutex ); | |
| 1000 | |
| 1001 Cyg_Mutex *m = new((void *)mutex) Cyg_Mutex; | |
| 1002 | |
| 1003 m=m; | |
| 1004 } | |
| 1005 | |
| 1006 externC void cyg_mutex_destroy( cyg_mutex_t *mutex ) | |
| 1007 { | |
| 1008 // no need to do anything here | |
| 1009 } | |
| 1010 | |
| 2 | 1011 externC cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) |
| 0 | 1012 { |
| 2 | 1013 return ((Cyg_Mutex *)mutex)->lock(); |
| 0 | 1014 } |
| 1015 | |
| 1016 externC cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) | |
| 1017 { | |
| 1018 return ((Cyg_Mutex *)mutex)->trylock(); | |
| 1019 } | |
| 1020 | |
| 1021 externC void cyg_mutex_unlock( cyg_mutex_t *mutex ) | |
| 1022 { | |
| 1023 ((Cyg_Mutex *)mutex)->unlock(); | |
| 1024 } | |
| 1025 | |
| 2 | 1026 externC void cyg_mutex_release( cyg_mutex_t *mutex ) |
| 1027 { | |
| 1028 ((Cyg_Mutex *)mutex)->release(); | |
| 1029 } | |
| 1030 | |
| 0 | 1031 /*---------------------------------------------------------------------------*/ |
| 1032 /* Condition Variables */ | |
| 1033 | |
| 1034 externC void cyg_cond_init( | |
| 1035 cyg_cond_t *cond, /* condition variable to init */ | |
| 1036 cyg_mutex_t *mutex /* associated mutex */ | |
| 1037 ) | |
| 1038 { | |
| 1039 CYG_ASSERT_SIZES( cyg_cond_t, Cyg_Condition_Variable ); | |
| 1040 | |
| 1041 Cyg_Condition_Variable *t = new((void *)cond) Cyg_Condition_Variable( | |
| 1042 *(Cyg_Mutex *)mutex); | |
| 1043 t=t; | |
| 1044 } | |
| 1045 | |
| 1046 externC void cyg_cond_destroy( cyg_cond_t *cond ) | |
| 1047 { | |
| 1048 ((Cyg_Counting_Semaphore *)cond)->~Cyg_Counting_Semaphore(); | |
| 1049 } | |
| 1050 | |
| 1051 externC void cyg_cond_wait( cyg_cond_t *cond ) | |
| 1052 { | |
| 1053 ((Cyg_Condition_Variable *)cond)->wait(); | |
| 1054 } | |
| 1055 | |
| 1056 externC void cyg_cond_signal( cyg_cond_t *cond ) | |
| 1057 { | |
| 1058 ((Cyg_Condition_Variable *)cond)->signal(); | |
| 1059 } | |
| 1060 | |
| 1061 externC void cyg_cond_broadcast( cyg_cond_t *cond ) | |
| 1062 { | |
| 1063 ((Cyg_Condition_Variable *)cond)->broadcast(); | |
| 1064 } | |
| 1065 | |
| 1066 #ifdef CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT | |
| 1067 externC cyg_bool_t cyg_cond_timed_wait( | |
| 1068 cyg_cond_t *cond, | |
| 1069 cyg_tick_count_t abstime | |
| 1070 ) | |
| 1071 { | |
| 1072 return ((Cyg_Condition_Variable *)cond)->wait(abstime); | |
| 1073 } | |
| 1074 | |
| 1075 #endif | |
| 1076 | |
| 1077 // ------------------------------------------------------------------------- | |
| 1078 // Check structure sizes. | |
| 1079 // This class and constructor get run automatically in debug versions | |
| 1080 // of the kernel and check that the structures configured in the C | |
| 1081 // code are the same size as the C++ classes they should match. | |
| 1082 | |
| 1083 #ifdef CYGPKG_INFRA_DEBUG | |
| 1084 | |
| 1085 class Cyg_Check_Structure_Sizes | |
| 1086 { | |
| 1087 int dummy; | |
| 1088 public: | |
| 1089 Cyg_Check_Structure_Sizes( int x ); | |
| 1090 | |
| 1091 }; | |
| 1092 | |
| 1093 #define CYG_CHECK_SIZES(cstruct, cxxstruct) \ | |
| 1094 if( sizeof(cstruct) != sizeof(cxxstruct) ) \ | |
| 1095 { \ | |
| 1096 char *fmt = "Size of C struct " #cstruct \ | |
| 1097 " != size of C++ struct " #cxxstruct ; \ | |
| 1098 CYG_TRACE2(1, fmt, sizeof(cstruct) , sizeof(cxxstruct) ); \ | |
| 1099 fail = true; \ | |
| 1100 fmt = fmt; \ | |
| 1101 } | |
| 1102 | |
| 1103 Cyg_Check_Structure_Sizes::Cyg_Check_Structure_Sizes(int x) | |
| 1104 { | |
| 1105 cyg_bool fail = false; | |
| 1106 | |
| 1107 dummy = x+1; | |
| 1108 | |
| 1109 CYG_CHECK_SIZES( cyg_thread, Cyg_Thread ); | |
| 1110 CYG_CHECK_SIZES( cyg_interrupt, Cyg_Interrupt ); | |
| 1111 CYG_CHECK_SIZES( cyg_counter, Cyg_Counter ); | |
| 1112 CYG_CHECK_SIZES( cyg_clock, Cyg_Clock ); | |
| 1113 CYG_CHECK_SIZES( cyg_alarm, Cyg_Alarm ); | |
| 1114 CYG_CHECK_SIZES( cyg_mbox, Cyg_Mbox ); | |
| 1115 CYG_CHECK_SIZES( cyg_mempool_var, Cyg_Mempool_Variable ); | |
| 1116 CYG_CHECK_SIZES( cyg_mempool_fix, Cyg_Mempool_Fixed ); | |
| 1117 CYG_CHECK_SIZES( cyg_sem_t, Cyg_Counting_Semaphore ); | |
| 1118 CYG_CHECK_SIZES( cyg_flag_t, Cyg_Flag ); | |
| 1119 CYG_CHECK_SIZES( cyg_mutex_t, Cyg_Mutex ); | |
| 1120 CYG_CHECK_SIZES( cyg_cond_t, Cyg_Condition_Variable ); | |
| 1121 | |
| 1122 CYG_ASSERT( !fail, "Size checks failed"); | |
| 1123 } | |
| 1124 | |
| 1125 Cyg_Check_Structure_Sizes check_structure_sizes(1); | |
| 1126 | |
| 1127 #endif | |
| 1128 | |
| 1129 | |
| 1130 // ------------------------------------------------------------------------- | |
| 1131 | |
| 1132 #endif | |
| 1133 // EOF common/kapi.cxx |