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