URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
Compare Revisions
- This comparison shows the changes necessary to convert path
/or1k/trunk/ecos-2.0/packages/compat/uitron
- from Rev 1254 to Rev 1765
- ↔ Reverse comparison
Rev 1254 → Rev 1765
/v2_0/cdl/uitron.cdl
0,0 → 1,437
# ==================================================================== |
# |
# uitron.cdl |
# |
# uITRON configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): bartv |
# Original data: hmt |
# Contributors: |
# Date: 1999-06-13 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_package CYGPKG_UITRON { |
display "uITRON compatibility layer" |
include_dir cyg/compat/uitron |
doc ref/compat-uitron.html |
requires CYGPKG_KERNEL |
description " |
eCos supports a uITRON Compatibility Layer, providing |
full Level S (Standard) compliance with Version 3.02 of |
the uITRON Standard, plus many Level E (Extended) features. |
uITRON is the premier Japanese embedded RTOS standard." |
|
compile uit_func.cxx uit_ifnc.cxx uit_objs.cxx |
|
# ------------------------------------------------------------------------ |
# Conformance check |
# ------------------------------------------------------------------------ |
cdl_interface CYGINT_UITRON_CONFORMANCE { |
requires 1 == CYGINT_UITRON_CONFORMANCE |
} |
|
cdl_option CYGIMP_UITRON_STRICT_CONFORMANCE { |
display "Check strict uITRON standards conformance" |
default_value 0 |
requires CYGVAR_KERNEL_COUNTERS_CLOCK |
requires CYGSEM_KERNEL_SCHED_MLQUEUE |
requires !CYGSEM_KERNEL_SCHED_TIMESLICE |
requires CYGFUN_KERNEL_THREADS_TIMER |
implements CYGINT_UITRON_CONFORMANCE |
description " |
Require the rest of the system configuration |
to match the needs of strict uITRON standards conformance. |
This option can only be set if the rest of the system is |
configured correctly for uITRON semantics, for example |
there must be a realtime clock, a suitable scheduler, and no |
timeslicing. |
Of course a system without this selected can be completely |
conformant; this is here to help you check." |
} |
cdl_option CYGIMP_UITRON_LOOSE_CONFORMANCE { |
display "System configuration overrides uITRON" |
default_value 1 |
implements CYGINT_UITRON_CONFORMANCE |
description " |
Do not require the rest of the system configuration |
to match the needs of strict uITRON standards conformance. |
For example a bitmap scheduler, or timeslicing, can be used |
with the uITRON functions, but such an environment is not |
strictly conformant with the uITRON specification. |
Of course a system with this selected can be completely |
conformant; but it is up to you to configure it correctly." |
} |
|
# ------------------------------------------------------------------------ |
# uITRON FUNCTION CALLS |
# ------------------------------------------------------------------------ |
cdl_option CYGIMP_UITRON_INLINE_FUNCS { |
display "Inline functions" |
default_value 0 |
description " |
If compiling your application with a C++ compiler, |
uITRON functions can be inline: set this to make it so. |
Inlining functions often increases execution speed, |
though possibly at the cost of a larger executable, |
depending on what functions are used. |
Do NOT set this if compiling your application |
in plain C." |
} |
|
cdl_option CYGIMP_UITRON_CPP_OUTLINE_FUNCS { |
display "C++ function names" |
default_value 0 |
description " |
If compiling your application with a C++ compiler, |
uITRON functions can be given C++ style mangled names: |
set this to make it so. |
This option may make debugging your program easier, |
depending on your development environment. |
Do NOT set this if compiling your application |
in plain C." |
} |
|
cdl_option CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS { |
display "Return error codes for bad params" |
default_value 1 |
description " |
When an application is fully debugged there is no need |
to check for bad parameters on every system call, for those |
parameters which are typically pointers or constants. |
Removing the checking code saves space |
and improves performance: set this to make it so. |
When this option is set, the correctness of parameters |
is asserted using CYG_ASSERT() which compiles to |
nothing in a non-debug configuration." |
} |
|
cdl_option CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR { |
display "NULL is a good pointer" |
default_value 0 |
description " |
uITRON deliberately defines the constant NADR (-1) for |
use as an invalid memory address. |
The value -1 is chosen to allow working in microcontrollers |
which have real memory at address zero, the traditional 'C' |
NULL pointer. |
By default, uITRON functions check for both NULL and NADR as |
bad addresses: set this option to prevent checking for |
NULL and allow pointers to address zero to be used." |
} |
|
# ------------------------------------------------------------------------ |
# uITRON KERNEL OBJECTS |
# ------------------------------------------------------------------------ |
cdl_component CYGPKG_UITRON_SEMAS { |
display "Semaphores" |
flavor bool |
default_value 1 |
description " |
uITRON Semaphore objects are used with functions |
named xxx_sem(); they support traditional semaphore |
semantics." |
|
script semas.cdl |
} |
|
cdl_component CYGPKG_UITRON_MBOXES { |
display "Mailboxes" |
flavor bool |
default_value 1 |
description " |
uITRON Mailbox objects are used with functions |
named xxx_msg() and xxx_mbx(); they support |
passing addresses (of 'messages') between tasks |
in a safe manner." |
|
script mboxes.cdl |
} |
|
cdl_component CYGPKG_UITRON_FLAGS { |
display "Eventflags" |
flavor bool |
default_value 1 |
description " |
uITRON Eventflag objects are used with functions |
named xxx_flg(); they support communication between |
tasks by means of setting and clearing bits in a word |
or flag value. |
Waiting for all or any of a set of bits is supported." |
|
script flags.cdl |
} |
|
# ------------------------------------------------------------------------ |
# uITRON TASKS |
# ------------------------------------------------------------------------ |
cdl_component CYGPKG_UITRON_TASKS { |
display "Tasks" |
flavor none |
description " |
uITRON Tasks are the basic blocks of multi-tasking |
in the uITRON world; they are threads or lightweight |
processes, sharing the address space and the CPU. |
They communicate using the primitives outlined above. |
Each has a stack, an entry point (a C or C++ function), |
and (where appropriate) a scheduling priority." |
|
script tasks.cdl |
} |
|
# ------------------------------------------------------------------------ |
# Memory Pools, both fixed and variable block |
# ------------------------------------------------------------------------ |
cdl_component CYGPKG_UITRON_MEMPOOLFIXED { |
display "Fixed-size memorypools" |
flavor bool |
default_value 1 |
requires CYGPKG_MEMALLOC |
description " |
uITRON supports memory pools for dynamic, task-safe |
memory allocation. |
Two kinds are supported, fixed-size and variable-size. |
There may be multiple of each |
type of pool, each with differing characteristics. |
This option controls whether there are any fixed-size |
memorypools in the system. |
A fixed-size memorypool allocates blocks of memory of |
its preset fixed size and none other." |
|
script mempoolfixed.cdl |
} |
|
cdl_component CYGPKG_UITRON_MEMPOOLVAR { |
display "Variable-size memorypools" |
flavor bool |
default_value 1 |
requires CYGPKG_MEMALLOC |
description " |
uITRON supports memory pools for dynamic, task-safe |
memory allocation. |
Two kinds are supported, fixed-size and variable-size. |
There may be multiple of each |
type of pool, each with differing characteristics. |
This option controls whether there are any variable-size |
memorypools in the system. |
A variable-size memorypool allocates blocks of memory of |
any size requested, resources permitting." |
|
script mempoolvar.cdl |
} |
|
# ------------------------------------------------------------------------ |
# One-shot Alarm and Cyclic Alarm handlers: |
# ------------------------------------------------------------------------ |
|
cdl_option CYGSEM_UITRON_TIME_IS_MILLISECONDS { |
display "uITRON time unit is mS" |
flavor bool |
default_value 0 |
active_if CYGVAR_KERNEL_COUNTERS_CLOCK |
description " |
Setting this option enables a conversion feature so that |
time parameters to uITRON APIs are converted from milliSeconds |
to whatever the eCos kernel real-time clock's units are, |
or vice versa. |
If this option is not set, time parameters are expressed in |
kernel clock ticks." |
} |
|
cdl_component CYGPKG_UITRON_ALARMS { |
display "Alarm handlers" |
flavor bool |
default_value 1 |
requires CYGVAR_KERNEL_COUNTERS_CLOCK |
description " |
uITRON Alarm Handlers are used with functions |
named def_alm() and ref_alm(); they support |
simple timing, with a function callback |
at the end of the timed period." |
|
|
cdl_option CYGNUM_UITRON_ALARMS { |
display "Number of alarm handlers" |
flavor data |
legal_values 1 to 65535 |
default_value 3 |
description " |
The number of uITRON alarm |
handlers present in the system. |
Valid alarm handler numbers will range |
from 1 to this value." |
} |
} |
|
cdl_component CYGPKG_UITRON_CYCLICS { |
display "Cyclic handlers" |
flavor bool |
default_value 1 |
requires CYGVAR_KERNEL_COUNTERS_CLOCK |
description " |
uITRON Cyclic Handlers are used with functions |
named xxx_cyc(); they support timing |
with a periodic function callback that |
can be dynamically turned on or off, and |
resynchronized with external events." |
|
cdl_option CYGNUM_UITRON_CYCLICS { |
display "Number cyclic handlers" |
flavor data |
legal_values 1 to 65535 |
default_value 3 |
description " |
The number of uITRON cyclics |
handlers present in the system. |
Valid cyclic handler numbers will range |
from 1 to this value." |
} |
} |
|
# ------------------------------------------------------------------------ |
# Interrupt-safe functions [ixxx_yyy()]: |
# ------------------------------------------------------------------------ |
cdl_component CYGPKG_UITRON_INTERRUPT_FUNCTIONS { |
display "Interrupt-safe functions" |
flavor none |
description "The uITRON system provides some functions which may |
safely be used within interrupt handlers. In eCos, this |
means within ISRs, providing that the corresponding DSR is |
associated with that interrupt. These functions are |
typically named ixxx_yyy(), according to the uITRON |
specification, for example isig_sem() corresponds to normal |
function sig_sem()." |
|
cdl_option CYGSEM_UITRON_ISRFUNCS_TRY_IMMEDIATE_EXECUTION { |
display "Execute in ISR if safe" |
parent CYGPKG_UITRON_INTERRUPT_FUNCTIONS |
flavor bool |
default_value 1 |
description " |
These functions of necessity maintain a queue of |
operations requested for deferred execution. However, |
during an interrupt, it may be safe to perform scheduling |
operations. If this option is set, the interrupt-safe |
functions will have effect there and then if it is indeed |
safe, rather than queueing a request to perform the |
operation in the DSR." |
} |
cdl_option CYGNUM_UITRON_ISR_ACTION_QUEUESIZE { |
display "Deferred operation queue size" |
parent CYGPKG_UITRON_INTERRUPT_FUNCTIONS |
flavor data |
legal_values 4 8 16 32 64 128 256 |
default_value 32 |
description "These functions of necessity maintain a queue of |
operations requested for deferred execution. This option |
controls the queue size. It must be a power of two for |
implementation reasons." |
} |
} |
|
# ------------------------------------------------------------------------ |
# uITRON VERSION INFORMATION |
# ------------------------------------------------------------------------ |
cdl_component CYGPKG_UITRON_VERSION { |
display "Version information" |
flavor none |
description " |
The get_ver() uITRON system call returns |
several version related values describing |
the vendor, product and CPU in question |
as well as the version of the uITRON |
standard supported. |
These values may be specified here." |
|
script version.cdl |
} |
|
define_proc { |
puts $::cdl_header "/***** proc output start *****/" |
puts $::cdl_header "#include <pkgconf/system.h>" |
puts $::cdl_header "#include <pkgconf/kernel.h>" |
puts $::cdl_header "/***** proc output end *****/" |
} |
|
cdl_component CYGPKG_UITRON_OPTIONS { |
display "uITRON build options" |
flavor none |
description " |
Package specific build options including control over |
compiler flags used only in building this package, |
and details of which tests are built." |
|
cdl_option CYGPKG_UITRON_CFLAGS_ADD { |
display "Additional compiler flags" |
flavor data |
no_define |
default_value { "" } |
description " |
This option modifies the set of compiler flags for |
building the uITRON compatibility layer. These flags are used in addition |
to the set of global flags." |
} |
|
cdl_option CYGPKG_UITRON_CFLAGS_REMOVE { |
display "Suppressed compiler flags" |
flavor data |
no_define |
default_value { "" } |
description " |
This option modifies the set of compiler flags for |
building the uITRON compatibility layer. These flags are removed from |
the set of global flags if present." |
} |
|
cdl_option CYGPKG_UITRON_TESTS { |
display "uITRON tests" |
flavor data |
no_define |
calculated { |
"tests/testcxx tests/testcx2 tests/testcx3 tests/testcx4 tests/testcx5 tests/testcx6 tests/testcx7 tests/testcx8 tests/testcx9" |
. ((!CYGIMP_UITRON_INLINE_FUNCS && !CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ? |
" tests/test1 tests/test2 tests/test3 tests/test4 tests/test5 tests/test6 tests/test7 tests/test8 tests/test9 tests/testintr" : "") |
} |
description " |
This option specifies the set of tests for the uITRON compatibility layer." |
} |
} |
} |
/v2_0/cdl/mempoolvar.cdl
0,0 → 1,129
# ==================================================================== |
# |
# mempoolvar.cdl |
# |
# uITRON variable memory pool related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_MEMPOOLVAR { |
display "Number of variable-size memory pools" |
flavor data |
legal_values 1 to 65535 |
default_value 3 |
description " |
The number of uITRON Variable-Size Memorypools present in the system. |
Valid Variable-Size Memorypool IDs will range from 1 to this value." |
} |
cdl_component CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
active_if (0 < CYGNUM_UITRON_MEMPOOLVAR) |
description " |
Support variable-size memory pool create and delete operations |
(cre_mpl, del_mpl). Otherwise all variable-size mempools are created, |
up to the number specified above." |
|
cdl_option CYGNUM_UITRON_MEMPOOLVAR_INITIALLY { |
display "Number of variable-size mempools created initially" |
flavor data |
legal_values 0 to 65535 |
default_value 3 |
description " |
The number of variable-size mempools initially created. |
This number should not be more than the number |
of variable mempools in the system, though setting |
it to a large value to mean 'all' is acceptable. |
Initially, only variable mempools numbered from |
1 to this number exist; |
higher numbered ones must be created before use. |
All mempools must be initialized to tell |
the system what memory to use for each pool." |
} |
} |
cdl_option CYGDAT_UITRON_MEMPOOLVAR_EXTERNS { |
display "Externs for initialization" |
flavor data |
default_value {"static char vpool1[ 2000 ], \\\n\ |
vpool2[ 2000 ], \\\n\ |
vpool3[ 2000 ];"} |
description " |
Variable mempool initializers may refer to external |
objects such as memory for the pool to manage. |
Use this option to define or declare any external |
objects needed by the pool's static initializer below. |
Example: create some memory for a mempool using |
'static char vpool1\[2000\];' |
to set up a chunk of memory of 2000 bytes. |
Note: this option is invoked in the 'outermost' context |
of C++ source, where global/static objects are created; |
it should contain valid, self-contained, C++ source." |
} |
cdl_option CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS { |
display "Static initializers" |
flavor data |
default_value {"CYG_UIT_MEMPOOLVAR( vpool1, 2000 ), \\\n\ |
CYG_UIT_MEMPOOLVAR( vpool2, 2000 ), \\\n\ |
CYG_UIT_MEMPOOLVAR( vpool3, 2000 ),"} |
description " |
Variable block memory pools should be statically |
initialized: enter a list of initializers |
separated by commas, one per line. |
An initializer is |
'CYG_UIT_MEMPOOLVAR(ADDR,SIZE)' |
where addr is the address of memory to manage, and |
size is the total size of that memory. |
If create and delete operations are supported, |
initializers of the form |
'CYG_UIT_MEMPOOLVAR_NOEXS(ADDR,SIZE)' should be |
used for pools which are not initially created, to tell |
the system what memory to use for each pool. |
Note: this option is invoked in the context of a |
C++ array initializer, between curly brackets. |
Ensure that the number of initializers here exactly |
matches the total number of variable pools specified." |
} |
/v2_0/cdl/tasks.cdl
0,0 → 1,164
# ==================================================================== |
# |
# tasks.cdl |
# |
# uITRON task related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_TASKS { |
display "Number of tasks" |
flavor data |
legal_values 1 to 65535 |
default_value 4 |
description " |
The number of uITRON tasks present in the system. |
Valid task object IDs will range from 1 to this value." |
} |
cdl_option CYGNUM_UITRON_START_TASKS { |
display "Start tasks" |
flavor data |
legal_values 0 to 65535 |
default_value 1 |
description " |
The number of uITRON tasks to start automatically. |
Tasks from 1 to this value will be started |
at the beginning of application execution. |
A value of zero here means to start them all. |
Tasks started in this way have a start code of |
zero, as if they were started by sta_tsk(i,0). |
If create and delete operations are supported, |
this number should be no greater than the number |
of tasks created initially." |
} |
cdl_component CYGPKG_UITRON_TASKS_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
description " |
Support task create and delete operations (cre_tsk, del_tsk). |
Otherwise all tasks are created, up to the number specified above." |
|
cdl_option CYGNUM_UITRON_TASKS_INITIALLY { |
display "Number of tasks created initially" |
flavor data |
legal_values 1 to 65535 |
default_value 4 |
description " |
The number of uITRON tasks initially created. |
This number should not be more than the number |
of tasks in the system, though setting it to a large |
value to mean 'all' is acceptable. |
Initially, only tasks numbered 1 to this number exist; |
higher numbered ones must be created before use." |
} |
} |
cdl_option CYGNUM_UITRON_STACK_SIZE { |
display "Default stack size" |
flavor data |
legal_values 128 to 0x7FFFFFFF |
default_value 2048 |
description " |
Define a default stack size for uITRON tasks, |
for use in the initialization options below. |
This will be overridden where it is used if the |
architectural HAL requires a minimum stack size |
to handle interrupts correctly." |
} |
cdl_option CYGDAT_UITRON_TASK_EXTERNS { |
display "Externs for initialization" |
flavor data |
default_value {"extern \"C\" void task1( unsigned int ); \\\n\ |
extern \"C\" void task2( unsigned int ); \\\n\ |
extern \"C\" void task3( unsigned int ); \\\n\ |
extern \"C\" void task4( unsigned int ); \\\n\ |
static char stack1[ MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ], \\\n\ |
stack2[ MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ], \\\n\ |
stack3[ MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ], \\\n\ |
stack4[ MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ];"} |
description " |
Task initializers may refer to external objects |
such as memory for stack or functions to call. |
Use this option to define or declare any external |
objects needed by the task static initializer below. |
Example: create some memory for a stack using |
'static char stack1\[CYGNUM_UITRON_STACK_SIZE\];' |
to set up a chunk of memory of the default stack size. |
Note: this option is invoked in the 'outermost' context |
of C++ source, where global/static objects are created; |
it should contain valid, self-contained, C++ source." |
} |
cdl_option CYGDAT_UITRON_TASK_INITIALIZERS { |
display "Static initializers" |
flavor data |
default_value {"CYG_UIT_TASK( \"t1\", 1, task1, &stack1, MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ), \\\n\ |
CYG_UIT_TASK( \"t2\", 2, task2, &stack2, MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ), \\\n\ |
CYG_UIT_TASK( \"t3\", 3, task3, &stack3, MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ), \\\n\ |
CYG_UIT_TASK( \"t4\", 4, task4, &stack4, MAX(CYGNUM_UITRON_STACK_SIZE, CYGNUM_HAL_STACK_SIZE_MINIMUM) ),"} |
description " |
Tasks must be statically |
initialized: enter a list of initializers |
separated by commas, one per line. |
An initializer is |
'CYG_UIT_TASK(NAME,PRIO,FUNC,STACK,SIZE)' |
where name is a quoted string to name the task, |
prio is the initial priority of the task, |
func is the name of the entry point, |
stack is the address of the task's stack, |
and size is the size of the task's stack. |
When create and delete operations are supported, |
'CYG_UIT_TASK_NOEXS(NAME,STACK,SIZE)' should be |
used for tasks which are not initially created, |
in order to tell the system what memory to use |
for stacks when these tasks are created later on. |
Using 'CYGNUM_UITRON_STACK_SIZE' for size |
is recommended, to use the option defined above, |
so long as that truly is the size of your stack(s). |
Note: this option is invoked in the context of a |
C++ array initializer, between curly brackets. |
Ensure that the number of initializers here exactly |
matches the number of tasks specified." |
} |
/v2_0/cdl/version.cdl
0,0 → 1,167
# ==================================================================== |
# |
# verion.cdl |
# |
# uITRON version related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_VER_MAKER { |
display "OS maker" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'maker' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_ID { |
display "OS identification" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'id' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_SPVER { |
display "ITRON specification" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0x5302 |
description " |
This value is returned in the 'spver' |
field of the T_VER structure in |
response to a get_ver() system call. |
Do NOT change this value." |
} |
cdl_option CYGNUM_UITRON_VER_PRVER { |
display "OS product version" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0x0100 |
description " |
This value is returned in the 'prver' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
# PRNO fields in own folder |
cdl_component CYGPKG_UITRON_VERSION_PRNO { |
display "Product info" |
flavor none |
description " |
The get_ver() uITRON system call returns |
several version related values describing |
the vendor, product and CPU in question |
as well as the version of the uITRON |
standard supported. |
These values may be specified here." |
|
cdl_option CYGNUM_UITRON_VER_PRNO_0 { |
display "Field 0" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'prno\[0\]' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_PRNO_1 { |
display "Field 1" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'prno\[1\]' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_PRNO_2 { |
display "Field 2" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'prno\[2\]' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_PRNO_3 { |
display "Field 3" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'prno\[3\]' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
} |
|
cdl_option CYGNUM_UITRON_VER_CPU { |
display "CPU information" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0 |
description " |
This value is returned in the 'cpu' |
field of the T_VER structure in |
response to a get_ver() system call." |
} |
cdl_option CYGNUM_UITRON_VER_VAR { |
display "System variant" |
flavor data |
legal_values 0 to 0xFFFF |
default_value 0x8000 |
description " |
This value is returned in the 'var' |
field of the T_VER structure in |
response to a get_ver() system call. |
Do NOT change this value." |
} |
/v2_0/cdl/semas.cdl
0,0 → 1,115
# ==================================================================== |
# |
# semas.cdl |
# |
# uITRON semaphore related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_SEMAS { |
display "Number of semaphores" |
flavor data |
legal_values 1 to 65535 |
default_value 3 |
description " |
The number of uITRON semaphores present in the system. |
Valid semaphore object IDs will range from 1 to this value." |
} |
cdl_component CYGPKG_UITRON_SEMAS_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
description " |
Support semaphore create and delete operations (cre_sem, del_sem). |
Otherwise all semaphores are created, up to the number specified |
above." |
|
cdl_option CYGNUM_UITRON_SEMAS_INITIALLY { |
display "Number of semaphores created initially" |
flavor data |
legal_values 0 to 65535 |
default_value 3 |
description " |
The number of uITRON semaphores initially created. |
This number should not be more than the number |
of semaphores in the system, though setting it to a large |
value to mean 'all' is acceptable. |
Initially, only semaphores numbered 1 to this number exist; |
higher numbered ones must be created before use. |
It is only useful to initialize semaphores up to this number; |
higher numbered ones must be created in order to use them, |
and so they will be re-initialized." |
} |
} |
cdl_component CYGPKG_UITRON_SEMAS_ARE_INITIALIZED { |
display "Initialize semaphore counts" |
flavor bool |
default_value 0 |
description " |
Initialize semaphores to specific count values. |
Otherwise semaphores are initialized with the count |
set to zero." |
|
cdl_option CYGDAT_UITRON_SEMA_INITIALIZERS { |
display "Static initializers" |
parent CYGPKG_UITRON_SEMAS_ARE_INITIALIZED |
flavor data |
default_value {"CYG_UIT_SEMA( 0 ),\ |
CYG_UIT_SEMA( 0 ),\ |
CYG_UIT_SEMA( 0 )"} |
description " |
A list of initializers separated by commas, |
one per line. |
An initializer is 'CYG_UIT_SEMA(INITIAL-COUNT)' |
or 'CYG_UIT_SEMA_NOEXS' for slots above the number |
initially to be created, when create and delete |
operations are supported. |
Note: this option is invoked in the context of a |
C++ array initializer, between curly brackets. |
Ensure that the number of initializers here exactly |
matches the total number of semaphores specified." |
} |
} |
/v2_0/cdl/mempoolfixed.cdl
0,0 → 1,138
# ==================================================================== |
# |
# mempoolfixed.cdl |
# |
# uITRON fixed memory pool related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_MEMPOOLFIXED { |
display "Number of fixed-size memorypools" |
flavor data |
legal_values 1 to 65535 |
default_value 3 |
description " |
The number of uITRON Fixed-Size |
Memorypools present in the system. |
Valid Fixed-Size Memorypool IDs will range |
from 1 to this value." |
} |
cdl_component CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
active_if (0 < CYGNUM_UITRON_MEMPOOLFIXED) |
description " |
Support fixed-size memory pool |
create and delete operations |
(cre_mpf, del_mpf). |
Otherwise all fixed mempools are created, |
up to the number specified above." |
|
cdl_option CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY { |
display "Number of fixed mempools created initially" |
flavor data |
legal_values 0 to 65535 |
default_value 3 |
description " |
The number of fixed mempools initially created. |
This number should not be more than the number |
of fixed mempools in the system, though setting |
it to a large value to mean 'all' is acceptable. |
Initially, only fixed mempools numbered from |
1 to this number exist; |
higher numbered ones must be created before use. |
Whilst all mempools must be initialized to tell |
the system what memory to use for each pool, |
it is only useful to initialize the blocksize of |
fixed mempools up to this number; |
the blocksize for higher numbered ones |
will be defined when they are created." |
} |
} |
cdl_option CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS { |
display "Externs for initialization" |
flavor data |
default_value {"static char fpool1[ 2000 ], \\\n\ |
fpool2[ 2000 ], \\\n\ |
fpool3[ 2000 ];"} |
description " |
Fixed mempool initializers may refer to external |
objects such as memory for the pool to manage. |
Use this option to define or declare any external |
objects needed by the pool's static initializer below. |
Example: create some memory for a mempool using |
'static char fpool1\[2000\];' |
to set up a chunk of memory of 2000 bytes. |
Note: this option is invoked in the 'outermost' context |
of C++ source, where global/static objects are created; |
it should contain valid, self-contained, C++ source." |
} |
cdl_option CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS { |
display "Static initializers" |
flavor data |
default_value {"CYG_UIT_MEMPOOLFIXED( fpool1, 2000, 20 ), \\\n\ |
CYG_UIT_MEMPOOLFIXED( fpool2, 2000, 100 ), \\\n\ |
CYG_UIT_MEMPOOLFIXED( fpool3, 2000, 500 ),"} |
description " |
Fixed block memory pools should be statically |
initialized: enter a list of initializers |
separated by commas, one per line. |
An initializer is |
'CYG_UIT_MEMPOOLFIXED(ADDR,SIZE,BLOCK)' |
where addr is the address of memory to manage, |
size is the total size of that memory, and |
block is the block size for allocation by the pool. |
If create and delete operations are supported, |
initializers of the form |
'CYG_UIT_MEMPOOLFIXED_NOEXS(ADDR,SIZE)' should be |
used for pools which are not initially created, to tell |
the system what memory to use for each pool. |
Note: this option is invoked in the context of a |
C++ array initializer, between curly brackets. |
Ensure that the number of initializers here exactly |
matches the total number of fixed pools specified." |
} |
/v2_0/cdl/flags.cdl
0,0 → 1,82
# ==================================================================== |
# |
# flags.cdl |
# |
# uITRON flags related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_FLAGS { |
display "Number of eventflags" |
flavor data |
legal_values 1 to 65535 |
default_value 5 |
description " |
The number of uITRON eventflag objects present in the system. |
Valid eventflag object IDs will range from 1 to this value." |
} |
cdl_component CYGPKG_UITRON_FLAGS_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
description " |
Support eventflag create and delete operations (cre_flg, del_flg). |
Otherwise all eventflags are created, up to the number specified above." |
|
cdl_option CYGNUM_UITRON_FLAGS_INITIALLY { |
display "Number of eventflags created initially" |
flavor data |
legal_values 0 to 65535 |
default_value 5 |
description " |
The number of uITRON eventflags initially created. |
This number should not be more than the number |
of eventflags in the system, though setting it to a large |
value to mean 'all' is acceptable. |
Initially, only eventflags numbered 1 to this number exist; |
higher numbered ones must be created before use." |
} |
} |
/v2_0/cdl/mboxes.cdl
0,0 → 1,82
# ==================================================================== |
# |
# mboxes.cdl |
# |
# uITRON mbox related configuration data |
# |
# ==================================================================== |
#####ECOSGPLCOPYRIGHTBEGIN#### |
## ------------------------------------------- |
## This file is part of eCos, the Embedded Configurable Operating System. |
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
## |
## eCos is free software; you can redistribute it and/or modify it under |
## the terms of the GNU General Public License as published by the Free |
## Software Foundation; either version 2 or (at your option) any later version. |
## |
## eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
## WARRANTY; without even the implied warranty of MERCHANTABILITY or |
## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
## for more details. |
## |
## You should have received a copy of the GNU General Public License along |
## with eCos; if not, write to the Free Software Foundation, Inc., |
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
## |
## As a special exception, if other files instantiate templates or use macros |
## or inline functions from this file, or you compile this file and link it |
## with other works to produce a work based on this file, this file does not |
## by itself cause the resulting work to be covered by the GNU General Public |
## License. However the source code for this file must still be made available |
## in accordance with section (3) of the GNU General Public License. |
## |
## This exception does not invalidate any other reasons why a work based on |
## this file might be covered by the GNU General Public License. |
## |
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
## at http://sources.redhat.com/ecos/ecos-license/ |
## ------------------------------------------- |
#####ECOSGPLCOPYRIGHTEND#### |
# ==================================================================== |
######DESCRIPTIONBEGIN#### |
# |
# Author(s): jskov |
# Original data: hmt |
# Contributors: |
# Date: 1999-07-07 |
# |
#####DESCRIPTIONEND#### |
# |
# ==================================================================== |
|
cdl_option CYGNUM_UITRON_MBOXES { |
display "Number of mailboxes" |
flavor data |
legal_values 1 to 65535 |
default_value 4 |
description " |
The number of uITRON mailboxes present in the system. |
Valid mailbox object IDs will range from 1 to this value." |
} |
cdl_component CYGPKG_UITRON_MBOXES_CREATE_DELETE { |
display "Support create and delete" |
flavor bool |
default_value 1 |
description " |
Support mailbox create and delete operations (cre_mbx, del_mbx). |
Otherwise all mailboxes are created, up to the number specified above." |
|
cdl_option CYGNUM_UITRON_MBOXES_INITIALLY { |
display "Number of mailboxes created initially" |
flavor data |
legal_values 0 to 65535 |
default_value 4 |
description " |
The number of uITRON mailboxes initially created. |
This number should not be more than the number |
of mailboxes in the system, though setting it to a large |
value to mean 'all' is acceptable. |
Initially, only mailboxes numbered 1 to this number exist; |
higher numbered ones must be created before use." |
} |
} |
/v2_0/tests/test1.c
0,0 → 1,815
//=========================================================================== |
// |
// test1.c |
// |
// uITRON "C" test program one |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercom = 0; |
volatile int intercount = 0; |
INT scratch = 0; |
|
#ifndef CYGSEM_KERNEL_SCHED_TIMESLICE |
#define TIMESLICEMSG "Assuming no kernel timeslicing" |
#define TSGO() (1) |
#define TSRELEASE() CYG_EMPTY_STATEMENT |
#define TSSTOP() CYG_EMPTY_STATEMENT |
#define TSLOCK() CYG_EMPTY_STATEMENT |
#define TSUNLOCK() CYG_EMPTY_STATEMENT |
#define ICWAIT( _i_ ) CYG_EMPTY_STATEMENT |
|
#else |
// Now follow some nasty bodges to control the scheduling when basically it |
// isn't controlled ie. timeslicing is on. It's bodgy because we're |
// testing normal synchronization methods, so we shouldn't rely on them for |
// comms between threads here. Instead there's a mixture of communicating |
// via a flag (ts_interlock) which stops the "controlled" thread running |
// away, and waiting for the controlled thread to run enough for us. |
// |
// Tasks 3 and 4 are waited for by the control task: task 3 locks the |
// scheduler so is immediately descheduled when it unlocks it, task 4 does |
// waiting-type operations, so we must give it chance to run by yielding a |
// few times ourselves. Note the plain constant in ICWAIT() below. |
|
#define TIMESLICEMSG "Assuming kernel timeslicing ENABLED" |
volatile int ts_interlock = 0; |
#define TSGO() (ts_interlock) |
#define TSRELEASE() ts_interlock = 1 |
#define TSSTOP() ts_interlock = 0 |
|
#define TSLOCK() CYG_MACRO_START \ |
ER ercd2 = dis_dsp(); \ |
CYG_TEST_CHECK( E_OK == ercd2, "dis_dsp (TSLOCK) bad ercd2" ); \ |
CYG_MACRO_END |
|
#define TSUNLOCK() CYG_MACRO_START \ |
ER ercd3 = ena_dsp(); \ |
CYG_TEST_CHECK( E_OK == ercd3, "ena_dsp (TSUNLOCK) bad ercd3" ); \ |
CYG_MACRO_END |
|
#define ICWAIT( _i_ ) CYG_MACRO_START \ |
int loops; \ |
for ( loops = 3; (0 < loops) || ((_i_) > intercount); loops-- ) { \ |
ER ercd4 = rot_rdq( 0 ); /* yield */ \ |
CYG_TEST_CHECK( E_OK == ercd4, "rot_rdq (ICWAIT) bad ercd4" ); \ |
} \ |
CYG_MACRO_END |
#endif // CYGSEM_KERNEL_SCHED_TIMESLICE |
|
/* |
#define IC() \ |
CYG_MACRO_START \ |
static char *msgs[] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "LOTS" }; \ |
CYG_TEST_INFO( msgs[ intercount > 5 ? 5 : intercount ] ); \ |
CYG_MACRO_END |
*/ |
|
// #define CYG_TEST_UITRON_TEST1_LOOPING 1 |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
T_RTSK ref_tskd; |
|
#ifdef CYG_TEST_UITRON_TEST1_LOOPING |
while ( 1 ) { |
#endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
CYG_TEST_INFO( "Task 1 running" ); |
CYG_TEST_INFO( TIMESLICEMSG ); |
|
intercom = 0; |
intercount = 0; |
|
CYG_TEST_INFO( "Testing get_tid and ref_tsk" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_tid( NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_tid bad ercd !E_PAR" ); |
#endif |
ercd = get_tid( NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_tid bad ercd !E_PAR" ); |
ercd = ref_tsk( &ref_tskd, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
ercd = ref_tsk( &ref_tskd, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_tsk( NULL, 1 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_tsk bad ercd !E_PAR" ); |
#endif |
ercd = ref_tsk( NADR, 1 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_tsk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = ref_tsk( &ref_tskd, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 1" ); |
ercd = ref_tsk( &ref_tskd, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 0" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
CYG_TEST_PASS( "get_tid, ref_tsk" ); |
|
CYG_TEST_INFO( "Testing prio change and start task" ); |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
// drop pri of task 2 |
ercd = chg_pri( 2, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RDY == ref_tskd.tskstat, "Bad task status 2" ); |
CYG_TEST_CHECK( 4 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
// drop our pri below task 2 |
ercd = chg_pri( 0, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
ercd = ref_tsk( &ref_tskd, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 1" ); |
ercd = ref_tsk( &ref_tskd, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 0" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
// it will have run to completion and regained its original prio |
CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
|
// retest these now that the task has executed once |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = chg_pri( -6, 9 ); |
CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
ercd = chg_pri( 99, 9 ); |
CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
ercd = sta_tsk( -6, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
ercd = sta_tsk( 99, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "sta_tsk, chg_pri" ); |
|
CYG_TEST_INFO( "Testing delay and dispatch disabling" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_PASS( "dly_tsk, ena_dsp, dis_dsp" ); |
|
CYG_TEST_INFO( "Testing ready queue manipulation" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = rot_rdq( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = rot_rdq( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rot_rdq( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
ercd = rot_rdq( 99 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "rot_rdq" ); |
|
CYG_TEST_INFO( "Testing suspend/resume" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = sus_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
ercd = sus_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
ercd = rsm_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
ercd = rsm_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
ercd = frsm_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
ercd = frsm_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// drop task 3 pri to same as us |
CYG_TEST_CHECK( 0 == intercount, "intercount != 0" ); |
|
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 3, 66 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 3, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 1 ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
ercd = sus_tsk( 3 ); |
TSRELEASE(); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 2 ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
CYG_TEST_INFO( "Command task 3 inner loop stop" ); |
intercom = 2 + 4; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
ercd = sus_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = sus_tsk( 3 ); // suspend AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = sus_tsk( 3 ); // AND AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = rsm_tsk( 3 ); // expect restart this time |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 3 ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
CYG_TEST_INFO( "Command task 3 inner loop stop 2" ); |
intercom = 2 + 4; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
ercd = sus_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
ercd = sus_tsk( 3 ); // suspend AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = sus_tsk( 3 ); // AND AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = frsm_tsk( 3 ); // expect restart this time |
CYG_TEST_CHECK( E_OK == ercd, "frsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 4 ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
TSRELEASE(); |
ercd = rsm_tsk( 3 ); // try it again |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk bad ercd !E_OBJ" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 5 ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
|
TSRELEASE(); |
ercd = frsm_tsk( 3 ); // try it again |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk bad ercd !E_OBJ" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 6 ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
CYG_TEST_INFO( "Command task 3 all loops stop" ); |
intercom = 4 + 8; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
intercom = intercount = 0; |
|
CYG_TEST_PASS( "sus_tsk, rsm_tsk, frsm_tsk" ); |
|
CYG_TEST_INFO( "Testing sleep/wakeup stuff" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wup_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = wup_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = can_wup( &scratch, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
ercd = can_wup( &scratch, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = can_wup( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "can_wup bad ercd !E_PAR" ); |
#endif |
ercd = can_wup( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "can_wup bad ercd !E_PAR" ); |
|
ercd = wup_tsk( 0 ); // not ourself |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = wup_tsk( 1 ); // ourself |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk bad ercd !E_OBJ" ); |
#endif // we can test bad param error returns |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = tslp_tsk( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = tslp_tsk( TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = tslp_tsk( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
// drop task 4 pri to same as us |
intercount = 0; |
intercom = 1; // test plain slp_tsk |
TSRELEASE(); |
ercd = chg_pri( 4, 5 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "chg_pri bad ercd" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 4, 77 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 4, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
ercd = wup_tsk( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 1 ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
intercom = 2; // test tslp_tsk |
TSRELEASE(); |
ercd = wup_tsk( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 2 ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 3; // test tslp_tsk |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 1; // test slp_tsk next... |
ercd = dly_tsk( 20 ); // without a wup |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ICWAIT( 3 ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
intercom = 1; // ...test slp_tsk |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // without a wup (yet) |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = tslp_tsk( 20 ); // yield again |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // and again |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); // and yield |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 4 ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
intercom = 1; // test slp_tsk |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // without a wup (yet) |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
// this wup will restart it when we yield: |
TSLOCK(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
// these will count up: |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
scratch = -1; |
ercd = can_wup( &scratch, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "Cancelled wups not 2" ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
TSUNLOCK(); |
|
intercom = 4; // do nothing |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // and yield |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 5 ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // let it do nothing |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // lots of wups but no sleep |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
scratch = -1; |
ercd = can_wup( &scratch, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "Cancelled wups not 3" ); |
// now check that they are cancelled by doing a wait again |
intercom = 1; // test slp_tsk |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
intercom = 4; // do nothing next |
TSRELEASE(); |
ICWAIT( 6 ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); // it will run now |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // it will run now |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 7 ); |
CYG_TEST_CHECK( 7 == intercount, "intercount != 7" ); |
|
TSRELEASE(); |
intercom = 99; // exit, all done |
ercd = rot_rdq( 0 ); // let it run |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 8 ); |
CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
TSRELEASE(); |
ercd = rot_rdq( 0 ); // let it run |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
CYG_TEST_PASS( "wup_tsk, can_wup, slp_tsk, tslp_tsk" ); |
|
#ifdef CYG_TEST_UITRON_TEST1_LOOPING |
chg_pri( 1, 1 ); |
rot_rdq( 0 ); |
ter_tsk( 2 ); |
rot_rdq( 0 ); |
ter_tsk( 3 ); |
rot_rdq( 0 ); |
ter_tsk( 4 ); |
rot_rdq( 0 ); |
} |
#endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_PASS( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 99 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 99" ); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 2 failed to exit" ); |
} |
|
void task3( unsigned int arg ) |
{ |
ER ercd; |
TSLOCK(); |
CYG_TEST_PASS("Task3 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
if ( 66 != arg ) |
CYG_TEST_FAIL( "Task 3 arg not 66" ); |
|
while ( 2 & intercom ) { |
while ( 1 & intercom ) { |
intercount++; |
TSSTOP(); |
do { |
TSUNLOCK(); |
ercd = rot_rdq( 0 ); // yield() |
TSLOCK(); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 1 (task3) bad ercd" ); |
} while ( !TSGO() ); |
} |
CYG_TEST_CHECK( 4 & intercom, "should not have got here yet 1" ); |
TSSTOP(); |
do { |
TSUNLOCK(); |
ercd = rot_rdq( 0 ); // yield() |
TSLOCK(); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 2 (task3) bad ercd" ); |
} while ( !TSGO() ); |
} |
CYG_TEST_CHECK( 8 & intercom, "should not have got here yet 2" ); |
|
TSUNLOCK(); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 3 failed to exit" ); |
} |
|
void task4( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_PASS("Task4 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
if ( 77 != arg ) |
CYG_TEST_FAIL( "Task 4 arg not 77" ); |
while ( 1 ) { |
switch ( intercom ) { |
case 1: |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
break; |
case 2: |
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
break; |
case 3: |
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, |
"slp_tsk (task4) bad ercd !E_TMOUT" ); |
break; |
case 4: |
// busily do nothing |
while ( 4 == intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, |
"rot_rdq (task4 idle) bad ercd" ); |
} |
break; |
case 99: |
goto out; |
default: |
CYG_TEST_FAIL( "Task 4 bad intercom" ); |
goto out; |
} |
intercount++; |
TSSTOP(); |
do { |
ercd = rot_rdq( 0 ); // yield() |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq (task4) bad ercd" ); |
} while ( !TSGO() ); |
} |
out: |
ext_tsk(); |
CYG_TEST_FAIL( "Task 4 failed to exit" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test1.c |
/v2_0/tests/test2.c
0,0 → 1,970
//=========================================================================== |
// |
// test2.c |
// |
// uITRON "C" test program two |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
int intercom = 0; |
int intercount = 0; |
INT scratch = 0; |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
T_RSEM sem_info; |
T_RFLG flg_info; |
T_RMBX mbx_info; |
T_RMPF mpf_info; |
T_RMPL mpl_info; |
UINT flagptn; |
static char foo[] = "Test message"; |
T_MSG *msgptr = foo; |
T_MSG *rxptr = NULL; |
VP blfptr = (VP)foo; |
VP blkptr = (VP)foo; |
|
int delay = 10; |
if (cyg_test_is_simulator) |
delay = 3; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
// start a lower prio task to interact with |
intercom = 1; |
ercd = sta_tsk( 2, 222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// Semaphores; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing semaphore ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = sig_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
ercd = sig_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
ercd = wai_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
ercd = wai_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
ercd = preq_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
ercd = preq_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
ercd = twai_sem( -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
ercd = twai_sem( 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
ercd = twai_sem( 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_sem bad ercd !E_PAR" ); |
ercd = ref_sem( &sem_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
ercd = ref_sem( &sem_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_sem( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_sem bad ercd !E_PAR" ); |
#endif |
ercd = ref_sem( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_sem bad ercd !E_PAR" ); |
CYG_TEST_PASS( "bad calls: sig_sem, [t]wai_sem, preq_sem, ref_sem" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "wai_sem bad ercd !E_CTX" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_sem bad ercd !E_CTX" ); |
ercd = twai_sem( 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_sem(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: wai_sem, twai_sem with dis_dsp" ); |
|
// check ref_sem with various states |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 2 == sem_info.semcnt, "semcnt should be 2" ); |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 != sem_info.wtsk, "sem.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be non0" ); |
#if 1 |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
#endif |
ercd = dly_tsk( delay ); // let task 2 pick up the signal |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
CYG_TEST_PASS( "good calls: sig_sem, [t]wai,preq_sem with ref_sem" ); |
|
// Flags; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing flag ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = set_flg( -6, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
ercd = set_flg( 99, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
ercd = clr_flg( -6, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "clr_flg bad ercd !E_ID" ); |
ercd = clr_flg( 99, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_flg bad ercd !E_ID" ); |
ercd = wai_flg( &flagptn, -6, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
ercd = wai_flg( &flagptn, 99, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = wai_flg( NULL, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
#endif |
ercd = wai_flg( NADR, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
ercd = wai_flg( &flagptn, 2, 7, 34657 ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
ercd = wai_flg( &flagptn, 2, 0, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
ercd = pol_flg( &flagptn, -6, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
ercd = pol_flg( &flagptn, 99, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pol_flg( NULL, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
#endif |
ercd = pol_flg( NADR, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
ercd = pol_flg( &flagptn, 2, 7, 34657 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
ercd = pol_flg( &flagptn, 2, 0, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, -6, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
ercd = twai_flg( &flagptn, 99, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = twai_flg( NULL, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
#endif |
ercd = twai_flg( NADR, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, 2, 7, 34657, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, 2, 0, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = ref_flg( &flg_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
ercd = ref_flg( &flg_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_flg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_flg bad ercd !E_PAR" ); |
#endif |
ercd = ref_flg( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_flg bad ercd !E_PAR" ); |
CYG_TEST_PASS( "bad calls: set_flg, clr_flg, [t]wai,pol_flg, ref_flg" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wai_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_CTX == ercd, "wai_flg bad ercd !E_CTX" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_flg bad ercd !E_CTX" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_flg(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: wai_flg, twai_flg with dis_dsp" ); |
|
// check ref_flg with various states |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
ercd = set_flg( 2, 0x5555 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0x5555 == flg_info.flgptn, "flgptn should be 0x5555" ); |
ercd = clr_flg( 2, 0xF0F0 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0x5050 == flg_info.flgptn, "flgptn should be 0x5050" ); |
ercd = set_flg( 2, 0xFFFF ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be 0" ); |
CYG_TEST_CHECK( 0xFFFF == flg_info.flgptn, "flgptn should be 0xFFFF" ); |
CYG_TEST_PASS( "good calls: clr_flg, set_flg, wai_flg with ref_flg" ); |
|
// Mailboxes; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing mailbox ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = snd_msg( -6, msgptr ); |
CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
ercd = snd_msg( 99, msgptr ); |
CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = snd_msg( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "snd_msg bad ercd !E_PAR" ); |
#endif |
ercd = snd_msg( 2, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "snd_msg bad ercd !E_PAR" ); |
ercd = rcv_msg( &rxptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
ercd = rcv_msg( &rxptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rcv_msg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = rcv_msg( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rcv_msg bad ercd !E_PAR" ); |
ercd = prcv_msg( &rxptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
ercd = prcv_msg( &rxptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = prcv_msg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "prcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = prcv_msg( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "prcv_msg bad ercd !E_PAR" ); |
ercd = trcv_msg( &rxptr, -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
ercd = trcv_msg( &rxptr, 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
ercd = trcv_msg( &rxptr, 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = trcv_msg( NULL, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = trcv_msg( NADR, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
ercd = ref_mbx( &mbx_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
ercd = ref_mbx( &mbx_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mbx( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mbx bad ercd !E_PAR" ); |
#endif |
ercd = ref_mbx( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mbx bad ercd !E_PAR" ); |
CYG_TEST_PASS( "bad calls: snd_msg, [pt]rcv_msg, ref_mbx" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "rcv_msg bad ercd !E_CTX" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg bad ercd !E_CTX" ); |
ercd = trcv_msg( &rxptr, 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rcv_msg, trcv_msg with dis_dsp" ); |
|
// check ref_mbx with various states |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 != mbx_info.wtsk, "mbx.wtsk should be non0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
ercd = snd_msg( 2, msgptr ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
#if 1 |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( msgptr == mbx_info.pk_msg, "mbx peek should be msgptr" ); |
#endif |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
// fill the message box, expect E_QOVR |
for ( scratch = 0 ; scratch < 100 ; scratch++ ) { |
if ( E_OK != ( ercd = snd_msg( 2, msgptr ) ) ) |
break; |
} |
CYG_TEST_CHECK( (100 == scratch) || (E_QOVR == ercd), |
"snd_msg bad ercd !E_QOVR/E_OK" ); |
// empty the message box, expect the right number and E_TMOUT |
for ( ; 1 ; scratch-- ) { |
if ( E_OK != ( ercd = prcv_msg( &rxptr, 2 ) ) ) |
break; |
} |
CYG_TEST_CHECK( 0 == scratch, "rcv_msg count bad scratch!=0" ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "rcv_msg bad ercd !E_TMOUT" ); |
|
CYG_TEST_PASS( "good calls: rcv_msg, snd_msg with ref_msg" ); |
|
// Fixed block memory pools: all the illegal argument combinations first |
CYG_TEST_INFO( "Testing fixed block memory ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_blf( -6, blfptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
ercd = rel_blf( 99, blfptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rel_blf( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
#endif |
ercd = rel_blf( 2, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = rel_blf( 2, blfptr ); // it did not come from a mpf |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
ercd = get_blf( &blfptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_blf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blf bad ercd !E_PAR" ); |
#endif |
ercd = get_blf( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blf bad ercd !E_PAR" ); |
ercd = pget_blf( &blfptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
ercd = pget_blf( &blfptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pget_blf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blf bad ercd !E_PAR" ); |
#endif |
ercd = pget_blf( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blf bad ercd !E_PAR" ); |
ercd = tget_blf( &blfptr, -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
ercd = tget_blf( &blfptr, 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
ercd = tget_blf( &blfptr, 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = tget_blf( NULL, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
#endif |
ercd = tget_blf( NADR, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
ercd = ref_mpf( &mpf_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
ercd = ref_mpf( &mpf_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mpf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpf bad ercd !E_PAR" ); |
#endif |
ercd = ref_mpf( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpf bad ercd !E_PAR" ); |
CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf, ref_mpf " ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
// consume the whole thing then do it again, expecting E_TMOUT |
while ( E_OK == (ercd = pget_blf( &blfptr, 2 ) ) ) |
continue; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf with ena_dsp" ); |
|
// check ref_mpf with various states |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 != mpf_info.wtsk, "mpf.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
#if 1 |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( 0 != mpf_info.frbcnt, "mpf.frbcnt should be non0" ); |
#endif |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
CYG_TEST_PASS( "good calls: rel_blf, get_blf with ref_mpf" ); |
|
// Variable block memory pools; illegal arguments |
CYG_TEST_INFO( "Testing variable block memory ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_blk( -6, blkptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
ercd = rel_blk( 99, blkptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rel_blk( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
#endif |
ercd = rel_blk( 2, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = rel_blk( 2, blkptr ); // it did not come from a mpl |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, -6, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
ercd = get_blk( &blkptr, 99, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_blk( NULL, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blk bad ercd !E_PAR" ); |
#endif |
ercd = get_blk( NADR, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blk bad ercd !E_PAR" ); |
ercd = pget_blk( &blkptr, -6, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
ercd = pget_blk( &blkptr, 99, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pget_blk( NULL, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blk bad ercd !E_PAR" ); |
#endif |
ercd = pget_blk( NADR, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blk bad ercd !E_PAR" ); |
ercd = tget_blk( &blkptr, -6, 100, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
ercd = tget_blk( &blkptr, 99, 100, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
ercd = tget_blk( &blkptr, 2, 100, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = tget_blk( NULL, 2, 100, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
#endif |
ercd = tget_blk( NADR, 2, 100, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
ercd = ref_mpl( &mpl_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
ercd = ref_mpl( &mpl_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mpl( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpl bad ercd !E_PAR" ); |
#endif |
ercd = ref_mpl( NADR, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpl bad ercd !E_PAR" ); |
CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk, ref_mpl " ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
// consume the whole thing then do it again, expecting E_TMOUT |
while ( E_OK == (ercd = pget_blk( &blkptr, 2, 100 ) ) ) |
continue; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk with ena_dsp" ); |
|
// check ref_mpl with various states |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
CYG_TEST_CHECK( mpl_info.maxsz <= mpl_info.frsz, |
"mpl.maxsz not < mpl.frsz" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 != mpl_info.wtsk, "mpl.wtsk should be non0" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
CYG_TEST_PASS( "good calls: rel_blk, get_blk with ref_mpl" ); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
T_MSG *msgp = NULL; |
UINT flgval = 0; |
VP blfp = NULL; |
VP blkp = NULL; |
|
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 222" ); |
|
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = wai_flg( &flgval, 2, 99, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
CYG_TEST_CHECK( 99 == (99 & flgval), "flg value no good" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = rcv_msg( &msgp, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
CYG_TEST_CHECK( NULL != msgp, "no msg received" ); |
CYG_TEST_CHECK( NADR != msgp, "no msg received" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = get_blf( &blfp, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); |
CYG_TEST_CHECK( NULL != blfp, "no blf allocated" ); |
CYG_TEST_CHECK( NADR != blfp, "no blf allocated" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = get_blk( &blkp, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" ); |
CYG_TEST_CHECK( NULL != blkp, "no blk allocated" ); |
CYG_TEST_CHECK( NADR != blkp, "no blk allocated" ); |
|
ext_tsk(); |
CYG_TEST_FAIL( "Task 2 failed to exit" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test2.c |
/v2_0/tests/test3.c
0,0 → 1,255
//=========================================================================== |
// |
// test3.c |
// |
// uITRON "C" test program three |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
int t2done = 0; |
int t3done = 0; |
int t4done = 0; |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
// start lower prio tasks to interact with |
ercd = sta_tsk( 2, 222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = sta_tsk( 3, 333 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = sta_tsk( 4, 444 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
// now start the test |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
CYG_TEST_INFO( "T1 awoken" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
CYG_TEST_INFO( "T1 signalled" ); |
|
// let the others complete, so we get the status back |
ercd = dly_tsk( 50 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_CHECK( t2done, "t2 not done" ); |
CYG_TEST_CHECK( t3done, "t3 not done" ); |
CYG_TEST_CHECK( t4done, "t4 not done" ); |
|
CYG_TEST_PASS( "Immediate-dispatch producer/consumer test OK" ); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 222" ); |
|
// now start the test |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
CYG_TEST_INFO( "T2 awoken" ); |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = wup_tsk( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
CYG_TEST_INFO( "T2 completing" ); |
t2done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 2 sleep came back" ); |
} |
|
void task3( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 3 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
if ( 333 != arg ) |
CYG_TEST_FAIL( "Task 3 arg not 333" ); |
|
// now start the test |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
CYG_TEST_INFO( "T3 awoken" ); |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
CYG_TEST_INFO( "T3 completing" ); |
t3done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 3 sleep came back" ); |
} |
|
void task4( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 4 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
if ( 444 != arg ) |
CYG_TEST_FAIL( "Task 4 arg not 444" ); |
|
// now start the test |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
CYG_TEST_INFO( "T4 completing" ); |
t4done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 4 sleep came back" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test3.c |
/v2_0/tests/test4.c
0,0 → 1,403
//=========================================================================== |
// |
// test4.c |
// |
// uITRON "C" test program four |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): dsm |
// Contributors: dsm |
// Date: 1998-06-12 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough cyclic handlers */ \ |
defined( CYGPKG_UITRON_CYCLICS ) && \ |
(CYGNUM_UITRON_CYCLICS >= 3) && \ |
(CYGNUM_UITRON_CYCLICS < 90) && \ |
\ |
/* test configuration for enough alarm handlers */ \ |
defined( CYGPKG_UITRON_ALARMS ) && \ |
(CYGNUM_UITRON_ALARMS >= 3) && \ |
(CYGNUM_UITRON_ALARMS < 90) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
INT scratch; |
|
void hand1(void) |
{ |
CYG_TEST_INFO("Handler 1 called"); |
intercount++; |
} |
|
void hand2(void) |
{ |
CYG_TEST_CHECK( 2 == intercount, "handler out of sync" ); |
CYG_TEST_INFO("Handler 2 called"); |
intercount++; |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
T_DCYC dcyc; |
T_DALM dalm; |
T_RCYC rcyc; |
T_RALM ralm; |
|
unsigned int tm; |
|
static char foo[] = "Test message"; |
VP info = (VP)foo; |
|
// Increase times when running on HW since overhead of GDB packet |
// acknowledgements may cause tests of timing to fail. |
if (cyg_test_is_simulator) |
tm = 1; |
else |
tm = 4; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
dcyc.exinf = (VP)info; |
dcyc.cycatr = TA_HLNG; |
dcyc.cychdr = (FP)&hand1; |
dcyc.cycact = TCY_INI; // bad |
dcyc.cyctim = 2; |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dcyc.cycact = TCY_OFF; // make good |
dcyc.cyctim = 0; // bad |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dcyc.cyctim = 1; // make good |
|
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(-6, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
ercd = def_cyc(99, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
|
ercd = act_cyc(-6, TCY_OFF); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
ercd = act_cyc(99, TCY_OFF); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
ercd = act_cyc( 3, ~0); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
|
ercd = ref_cyc(&rcyc, -6); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
ercd = ref_cyc(&rcyc, 99); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_cyc(NULL, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
#endif |
ercd = ref_cyc(NADR, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
ercd = def_cyc(3, (T_DCYC *)NADR); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_cyc bad ercd !E_NOEXS" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "bad calls: def_cyc, act_cyc, ref_cyc" ); |
|
dalm.exinf = (VP)info; |
dalm.almatr = TA_HLNG; |
dalm.almhdr = (FP)&hand2; |
dalm.tmmode = ~0; // bad |
dalm.almtim = 20; |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_PAR == ercd, "def_alm bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dalm.tmmode = TTM_REL; // make good |
dalm.almtim = 0; // bad |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_PAR == ercd, "def_alm bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dalm.almtim = 1000; // make good |
|
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_OK == ercd, "def_alm bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_alm(&ralm, -6); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
ercd = ref_alm(&ralm, 99); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_alm(NULL, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
#endif |
ercd = ref_alm(NADR, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
|
#endif // we can test bad param error returns |
ercd = def_alm(3, (T_DALM *)NADR); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_alm(&ralm, 3); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_cyc bad ercd !E_NOEXS" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "bad calls: def_alm, act_alm, ref_alm" ); |
|
dcyc.exinf = (VP)info; |
dcyc.cycatr = TA_HLNG; |
dcyc.cychdr = (FP)&hand1; |
dcyc.cycact = TCY_ON; |
dcyc.cyctim = 50*tm; |
|
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_OFF == rcyc.cycact, "rcyc.cycact should be TCY_OFF" ); |
ercd = act_cyc(3, TCY_ON); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc bad ercd" ); |
|
CYG_TEST_PASS("good calls: def_cyc, act_cyc, ref_cyc"); |
|
dalm.exinf = (VP)info; |
dalm.almatr = TA_HLNG; |
dalm.almhdr = (FP)&hand2; |
dalm.tmmode = TTM_REL; |
dalm.almtim = 120*tm; |
|
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_OK == ercd, "def_alm bad ercd" ); |
ercd = ref_alm(&ralm, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_alm bad ercd" ); |
CYG_TEST_CHECK( info == ralm.exinf, "ralm.exinf should be info" ); |
CYG_TEST_CHECK( 115*tm < ralm.lfttim, "ralm.lfttim too small" ); |
CYG_TEST_CHECK( ralm.lfttim <= 120*tm, "ralm.lfttim too big" ); |
|
// Expect handlers to be called at approximate times |
// time intercount |
// tm*50 hand1 0 |
// tm*100 hand1 1 |
// tm*120 hand2 2 |
// tm*150 hand1 3 |
|
ercd = dly_tsk(160*tm); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "handlers not both called" ); |
|
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(off) bad ercd" ); |
|
ercd = dly_tsk(60*tm); // enough for at least one tick |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "cyclic not disabled" ); |
|
// approx time now 220, so we expect a cycle in about 30 ticks |
ercd = act_cyc(3, TCY_ON); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 25*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 35*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// now resynchronize with right now: |
ercd = act_cyc(3, TCY_ON|TCY_INI); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// wait a bit and check that time marches on, or even down |
ercd = dly_tsk(10*tm); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 35*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 45*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// now turn it off and re-synch with right now: |
ercd = act_cyc(3, TCY_OFF|TCY_INI); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_OFF == rcyc.cycact, "rcyc.cycact should be TCY_OFF" ); |
|
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
|
CYG_TEST_PASS("good calls: def_cyc, act_cyc, ref_cyc, def_alm, ref_alm"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test4.c |
/v2_0/tests/test5.c
0,0 → 1,353
//=========================================================================== |
// |
// test5.c |
// |
// uITRON "C" test program five |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): dsm |
// Contributors: dsm |
// Date: 1998-06-12 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
UINT scratch; |
T_MSG *t_msg; |
VP vp; |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int i; |
T_RSYS rsys; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
// check initial state |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
// disable intrs and check state |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// try an illegal op |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// enable intrs and check state and a legal sleep |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
ercd = dly_tsk( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// disable intrs and try scheduler illegal ops |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_CTX == ercd, "dis_dsp bad ercd !E_CTX" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_CTX == ercd, "ena_dsp bad ercd !E_CTX" ); |
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// enable again and check state |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
// disable the scheduler and check state |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_DDSP == rsys.sysstat, "system state not TSS_DDSP" ); |
// disable intrs and check state |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
// then unlock and check state |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
|
CYG_TEST_PASS( "Interrupt dis/enabling and interactions" ); |
|
// and now we can do the rest of the test |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); |
ercd = rel_wai( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); |
ercd = rel_wai( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); |
#endif // we can test bad param error returns |
|
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_sem bad ercd !E_RLWAI" ); |
|
ercd = twai_sem( 1, 20 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_sem bad ercd !E_RLWAI" ); |
|
ercd = wai_flg( &scratch, 1, 9999, 0 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_flg bad ercd !E_RLWAI" ); |
|
ercd = twai_flg( &scratch, 1, 9999, 0, 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_flg bad ercd !E_RLWAI" ); |
|
ercd = rcv_msg( &t_msg, 1 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "rcv_msg bad ercd !E_RLWAI" ); |
|
ercd = trcv_msg( &t_msg, 1, 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "trcv_msg bad ercd !E_RLWAI" ); |
|
// these are loops so as to consume the whole of the mempool |
// in order to wait at the end |
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = get_blf( &vp, 3 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blf bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = tget_blf( &vp, 3, 10 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blf bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = get_blk( &vp, 1, 1000 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blk bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = tget_blk( &vp, 1, 1000, 10 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blk bad ercd !E_RLWAI" ); |
|
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "dly_tsk bad ercd !E_RLWAI" ); |
|
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "tslp_tsk bad ercd !E_RLWAI" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_RLWAI == ercd, "slp_tsk bad ercd !E_RLWAI" ); |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_PASS("release wait: various waiting calls"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
for ( i = 0 ; i < 100; i++ ) { |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
} |
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test5.c |
/v2_0/tests/test6.c
0,0 → 1,599
//=========================================================================== |
// |
// test6.c |
// |
// uITRON "C" test program six |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-01 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
UINT scratch; |
T_MSG *t_msg = (T_MSG *)&scratch; |
T_MSG *msg; |
VP vp; |
|
T_CSEM t_csem = { NULL, 0, 0 }; |
T_CMBX t_cmbx = { NULL, 0 }; |
T_CFLG t_cflg = { NULL, 0, 0 }; |
T_RSEM t_rsem; |
T_RMBX t_rmbx; |
T_RFLG t_rflg; |
|
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int tests = 0; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); |
ercd = del_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); |
ercd = cre_sem( -6, &t_csem ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); |
ercd = cre_sem( 99, &t_csem ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
// check it is deleted |
ercd = sig_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = preq_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" ); |
ercd = twai_sem( 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" ); |
ercd = wai_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" ); |
ercd = ref_sem( &t_rsem, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_sem( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" ); |
#endif |
ercd = cre_sem( 3, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" ); |
t_csem.sematr = 0xfff; |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" ); |
t_csem.sematr = 0; |
#endif // we can test bad param error returns |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
// and check we can use it |
ercd = sig_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = wai_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = preq_sem( 3 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 3, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = ref_sem( &t_rsem, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_sem( 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
// re-create and do it again |
ercd = cre_sem( 1, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
ercd = cre_sem( 2, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_sem( 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete semaphores"); |
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_flg( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); |
ercd = del_flg( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); |
ercd = cre_flg( -6, &t_cflg ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); |
ercd = cre_flg( 99, &t_cflg ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_flg( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
// check it is deleted |
ercd = set_flg( 3, 0x6789 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
ercd = clr_flg( 3, 0x9876 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" ); |
ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" ); |
ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_flg( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" ); |
#endif |
ercd = cre_flg( 3, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" ); |
t_cflg.flgatr = 0xfff; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
// now create it well |
t_cflg.flgatr = 0; |
t_cflg.iflgptn = 0; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
// and check we can use it |
ercd = clr_flg( 3, 0x7256 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); |
ercd = set_flg( 3, 0xff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" ); |
ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" ); |
// now create it again with a preset pattern and check that we can |
// detect that pattern: |
ercd = del_flg( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
t_cflg.flgatr = 0; |
t_cflg.iflgptn = 0x1234; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
// and check we can use it |
ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" ); |
ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" ); |
ercd = clr_flg( 3, 0 ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_flg( &scratch, 1, 0xaa, TWF_ANDW ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = set_flg( 1, 0x22 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
ercd = clr_flg( 2, 0xdd ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
// re-create and do it again |
t_cflg.iflgptn = 0x5555; |
ercd = cre_flg( 1, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
t_cflg.iflgptn = 0; |
ercd = cre_flg( 2, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = clr_flg( 1, 0xd00d ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
ercd = set_flg( 2, 0xfff00 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete flags"); |
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mbx( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); |
ercd = del_mbx( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); |
ercd = cre_mbx( -6, &t_cmbx ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" ); |
ercd = cre_mbx( 99, &t_cmbx ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mbx( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
// check it is deleted |
ercd = snd_msg( 3, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = rcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" ); |
ercd = trcv_msg( &msg, 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" ); |
ercd = prcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" ); |
ercd = ref_mbx( &t_rmbx, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mbx( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" ); |
#endif |
ercd = cre_mbx( 3, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" ); |
t_cmbx.mbxatr = 0xfff; |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" ); |
t_cmbx.mbxatr = 0; |
#endif // we can test bad param error returns |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
// and check we can use it |
ercd = snd_msg( 3, t_msg ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
ercd = rcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
ercd = trcv_msg( &msg, 3, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = prcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = ref_mbx( &t_rmbx, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rcv_msg( &msg, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = trcv_msg( &msg, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = snd_msg( 1, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = snd_msg( 2, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
// re-create and do it again |
ercd = cre_mbx( 1, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
ercd = cre_mbx( 2, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rcv_msg( &msg, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = trcv_msg( &msg, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = snd_msg( 1, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = snd_msg( 2, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete mboxes"); |
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// all done |
if ( 0 == tests ) { |
CYG_TEST_NA( "No objects have create/delete enabled" ); |
} |
else { |
CYG_TEST_EXIT( "All done" ); |
} |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test6.c |
/v2_0/tests/test7.c
0,0 → 1,1013
//=========================================================================== |
// |
// test7.c |
// |
// uITRON "C" test program seven |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-01 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
// ======================================================================== |
|
typedef enum { |
START_WAITOP = 0, |
SLEEP = 0, |
DELAY, |
SEMGET, |
FLAGWAIT, |
MSGGET, |
MEMFIXEDGET, |
MEMVARGET, |
DONE_WAITOP |
} WAITOP; |
|
typedef enum { |
START_TYPE = 0, |
PLAIN = 0, |
TIMED = 1, |
DONE_TYPE |
} WAITTYPE; |
|
typedef enum { |
START_KILLOP = 0, |
|
// These are the 5 ways out of a wait that we perm |
// with other circumstances: |
SIGNAL = 0, // do the appropriate producer op |
TIMEOUT, // wait for the timeout to fire |
RELEASE, // do a rel_wai() |
DELETE, // delete the object; del_xxx() |
KILL, // do a ter_tsk() on the waiter |
|
SUSPEND_SIGNAL_RESUME, |
SUSPEND_TIMEOUT_RESUME, |
SUSPEND_RELEASE_RESUME, |
SUSPEND_DELETE_RESUME, |
SUSPEND_KILL, // resume not applicable |
|
SUSPEND_SIGNAL_KILL, |
SUSPEND_TIMEOUT_KILL, |
SUSPEND_RELEASE_KILL, |
SUSPEND_DELETE_KILL, |
// SUSPEND_KILL_KILL not applicable |
|
#if 0 |
// support these later if _really_ keen. |
SUSPEND_SIGNAL_DELETE_RESUME, |
SUSPEND_TIMEOUT_DELETE_RESUME, |
SUSPEND_RELEASE_DELETE_RESUME, |
// SUSPEND_DELETE_DELETE_RESUME not applicable |
// SUSPEND_KILL_DELETE_RESUME not applicable |
|
SUSPEND_SIGNAL_DELETE_KILL, |
SUSPEND_TIMEOUT_DELETE_KILL, |
SUSPEND_RELEASE_DELETE_KILL, |
// SUSPEND_DELETE_DELETE_KILL, |
SUSPEND_KILL_DELETE // 2nd kill not applicable |
#endif |
|
DONE_KILLOP |
} KILLOP; |
|
// ======================================================================== |
|
char * waitstrings[] = |
{ "Sleep ", "Delay ", "Sema ", "Flag ", "Mbox ", "MemFix", "MemVar" }; |
|
char * typestrings[] = |
{ " (Plain) : ", " (Timed) : " }; |
|
char * killstrings[] = |
{ "Signal", |
"Wait-for-timeout", |
"Release-wait", |
"Delete-object", |
"Kill-task", |
|
"Suspend/Signal/Resume", |
"Suspend/Wait-for-timeout/Resume", |
"Suspend/Release-wait/Resume", |
"Suspend/Delete-object/Resume", |
"Suspend/Kill-task", |
|
"Suspend/Signal/Kill-task", |
"Suspend/Wait-for-timeout/Kill-task", |
"Suspend/Release-wait/Kill-task", |
"Suspend/Delete-object/Kill-task", |
|
|
}; |
|
// ======================================================================== |
|
inline int task2arg( WAITOP wait, WAITTYPE waittype, KILLOP kill ) |
{ |
return waittype + (wait << 1) + (kill << 8); |
} |
|
inline void decodearg( int arg, WAITOP *pwait, WAITTYPE *pwaittype, KILLOP *pkill ) |
{ |
*pwaittype = (arg & 1) ? TIMED : PLAIN; |
*pwait = (arg >> 1) & 0x7f; |
*pkill = (arg >> 8); |
} |
|
static char *strdog( char *p, char *q ) |
{ |
while ( 0 != (*p++ = *q++) ); |
return p - 1; |
} |
|
static char * |
makemsg( char *z, WAITOP wait, WAITTYPE waittype, KILLOP kill ) |
{ |
static char buf[ 1000 ]; |
char *p = buf; |
p = strdog( p, z ); |
p = strdog( p, waitstrings[ wait ] ); |
p = strdog( p, typestrings[ waittype ] ); |
p = strdog( p, killstrings[ kill ] ); |
*p = 0; |
return buf; |
} |
|
// ======================================================================== |
|
volatile int intercom = 0; |
|
// ======================================================================== |
|
T_RTSK rtsk; |
|
void |
do_suspend( void ) |
{ |
ER ercd; |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAI == rtsk.tskstat, "bad tskstat !TTS_WAI" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAS == rtsk.tskstat, "bad tskstat !TTS_WAS" ); |
} |
|
void |
do_resume( void ) |
{ |
ER ercd; |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_SUS == rtsk.tskstat, "bad tskstat !TTS_SUS" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RDY == rtsk.tskstat, "bad tskstat !TTS_RDY" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
} |
|
// ======================================================================== |
|
#define T1_WAIT (7) |
#define T2_WAIT (5) |
|
#define T1_MALLOC (110) |
#ifdef CYGSEM_KERNEL_MEMORY_COALESCE |
#define T2_MALLOC (100) |
#else |
#define T2_MALLOC T1_MALLOC |
#endif |
|
VP vptmp; |
VP vp = NULL; |
VP vp1 = NULL; |
VP t2vp = NULL; |
VP t2vp_backup = NULL; |
|
UINT scratch; |
|
T_MSG *msg = (T_MSG *)&scratch; |
T_MSG *msg1; |
|
void |
do_prep( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
case SEMGET: |
case FLAGWAIT: |
case MSGGET: |
// do nothing for all of those |
break; |
case MEMFIXEDGET: |
// allocate all the memory in the pool; remember a couple |
// for freeing as the signalling operation: |
t2vp = NULL; |
vp = vptmp = NULL; |
do { |
vp1 = vptmp; |
vptmp = vp; |
ercd = pget_blf( &vp, 1 ); |
} while ( E_OK == ercd ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "get_blf bad ercd" ); |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
break; |
case MEMVARGET: |
// allocate all the memory in the pool; remember a couple |
// for freeing as the signalling operation: |
t2vp = NULL; |
vp = vptmp = NULL; |
do { |
vp1 = vptmp; |
vptmp = vp; |
ercd = pget_blk( &vp, 1, T1_MALLOC ); |
} while ( E_OK == ercd ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "get_blk bad ercd" ); |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_tidyup( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
case SEMGET: |
case MSGGET: |
// do nothing for all of those |
break; |
case FLAGWAIT: |
// clear the flag variable |
ercd = clr_flg( 1, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd, tidy vp" ); |
break; |
case MEMFIXEDGET: |
if ( NULL != vp ) { |
ercd = rel_blf( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp" ); |
} |
if ( NULL != vp1 ) { |
ercd = rel_blf( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp1" ); |
} |
if ( NULL != t2vp ) { |
ercd = rel_blf( 1, t2vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy t2vp" ); |
} |
break; |
case MEMVARGET: |
if ( NULL != vp ) { |
ercd = rel_blk( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp" ); |
} |
if ( NULL != vp1 ) { |
ercd = rel_blk( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp1" ); |
} |
if ( NULL != t2vp ) { |
ercd = rel_blk( 1, t2vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy t2vp" ); |
} |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_recreate( WAITOP wait ) |
{ |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
static T_CSEM t_csem = { NULL, 0, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
static T_CMBX t_cmbx = { NULL, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
static T_CFLG t_cflg = { NULL, 0, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
static T_CMPF t_cmpf = { NULL, 0, 20, 95 }; |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
static T_CMPL t_cmpl = { NULL, 0, 2000 }; |
#endif |
ER ercd = E_OK; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
// do nothing for all of those |
break; |
case SEMGET: |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
// create the semaphore |
ercd = cre_sem( 1, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate SEMGET" ); |
#endif |
break; |
case FLAGWAIT: |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
// create the flag |
ercd = cre_flg( 1, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate FLAGWAIT" ); |
#endif |
break; |
case MSGGET: |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
// create the mbox |
ercd = cre_mbx( 1, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MSGGET" ); |
#endif |
break; |
case MEMFIXEDGET: |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
// create the mempool |
ercd = cre_mpf( 1, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MEMFIXEDGET" ); |
#endif |
break; |
case MEMVARGET: |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
// create the mempool |
ercd = cre_mpl( 1, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MEMVARGET" ); |
#endif |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
// this is just to use ercd to prevent warnings |
CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" ); |
} |
|
|
|
void |
do_signal( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
// send a wakeup |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
break; |
case DELAY: |
// simply wait for task 2's delay to complete |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
break; |
case SEMGET: |
// signal the semaphore |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
break; |
case FLAGWAIT: |
// set the flag bits |
ercd = set_flg( 1, 0xff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" ); |
break; |
case MSGGET: |
// send a message |
ercd = snd_msg( 1, msg ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
break; |
case MEMFIXEDGET: |
// release a couple of blocks we allocated earlier. I hope. |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
ercd = rel_blf( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
vp = NULL; |
ercd = rel_blf( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd1" ); |
vp1 = NULL; |
break; |
case MEMVARGET: |
// release a couple of blocks we allocated earlier. I hope. |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
ercd = rel_blk( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
vp = NULL; |
ercd = rel_blk( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd1" ); |
vp1 = NULL; |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_delete( WAITOP wait ) |
{ |
ER ercd = E_OK; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
CYG_TEST_FAIL( "bad call to do_delete( SLEEP or DELAY )" ); |
break; |
case SEMGET: |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
// delete the semaphore |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( SEMGET )" ); |
#endif |
break; |
case FLAGWAIT: |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
// delete the flag |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( FLAGWAIT )" ); |
#endif |
break; |
case MSGGET: |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
// delete the mbox |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MSGGET )" ); |
#endif |
break; |
case MEMFIXEDGET: |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
// delete the mempool |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MEMFIXEDGET )" ); |
#endif |
break; |
case MEMVARGET: |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
// delete the mempool |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MEMVARGET )" ); |
#endif |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
// this is just to use ercd to prevent warnings |
CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" ); |
} |
|
|
|
ER |
do_wait( WAITOP wait, WAITTYPE type ) |
{ |
switch ( wait ) { |
case SLEEP: |
return ( PLAIN == type ) ? slp_tsk() : tslp_tsk( T2_WAIT ); |
case DELAY: |
return dly_tsk( T2_WAIT ); // forget the type |
case SEMGET: |
return ( PLAIN == type ) ? wai_sem( 1 ) : twai_sem( 1, T2_WAIT ); |
case FLAGWAIT: |
return ( PLAIN == type ) ? |
wai_flg( &scratch, 1, 0x55, TWF_ANDW ) : |
twai_flg( &scratch, 1, 0xaa, TWF_ANDW, T2_WAIT ); |
case MSGGET: |
return ( PLAIN == type ) ? |
rcv_msg( &msg1, 1 ) : |
trcv_msg( &msg1, 1, T2_WAIT ); |
case MEMFIXEDGET: |
return ( PLAIN == type ) ? |
get_blf( &t2vp, 1 ) : |
tget_blf( &t2vp, 1, T2_WAIT ); |
case MEMVARGET: |
return ( PLAIN == type ) ? |
get_blk( &t2vp, 1, T2_MALLOC ) : |
tget_blk( &t2vp, 1, T2_MALLOC, T2_WAIT ); |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
CYG_TEST_FAIL( "Bad wait in do_wait" ); |
return E_SYS; |
} |
|
// ======================================================================== |
void task1( unsigned int arg ) |
{ |
ER ercd; |
WAITOP wait; |
WAITTYPE type; |
KILLOP kill; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
ercd = chg_pri( 1, 8 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
for ( wait = START_WAITOP; wait < DONE_WAITOP ; wait++) { |
for ( type = START_TYPE; type < DONE_TYPE ; type++ ) { |
for ( kill = START_KILLOP; kill < DONE_KILLOP ; kill++ ) { |
|
// These clauses deal with a couple of special cases: |
// [doing it this way helps keep the rest of the code |
// nicely general and orthogonal] |
// |
// 1) DELAY: dly_tsk(): when this times out, the retcode is |
// E_OK rather than E_TMOUT, and it always times out. The |
// "signalling" method here is just to wait yourself. So we |
// do not test DELAY with TIMED type. |
// |
// 2) PLAIN tests with TIMEOUT kill operations: a PLAIN test |
// will not time out, it'll wait forever, so waiting for it |
// so to do is pointless; further, we would check for the |
// wrong error code. So we do not test PLAIN tests with |
// TIMOUT kill operations. |
// |
// 3) SLEEP or DELAY tests with DELETE operations: there is |
// no synchronization to delete in those cases. |
// 3a) Individual object types are tested for delete support, |
// and if there is none, the test is skipped. |
|
if ( DELAY == wait && TIMED == type ) |
continue; |
|
if ( PLAIN == type && |
( ( TIMEOUT == kill) || |
(SUSPEND_TIMEOUT_RESUME == kill) || |
(SUSPEND_TIMEOUT_KILL == kill) ) ) |
continue; |
|
if ( ( |
#ifndef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
(SEMGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
(FLAGWAIT == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
(MSGGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
(MEMFIXEDGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
(MEMVARGET == wait) || |
#endif |
(SLEEP == wait) || |
(DELAY == wait) |
) && |
((DELETE == kill) || |
(SUSPEND_DELETE_RESUME == kill) || |
(SUSPEND_DELETE_KILL == kill)) ) |
continue; |
|
|
CYG_TEST_INFO( makemsg( "T1: ", wait, type, kill ) ); |
|
intercom = 0; |
|
// prepare the synchronization objects |
// (actually, just empty the mempools) |
do_prep( wait ); |
|
// start task 2 at a higher priority than myself |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, task2arg( wait, type, kill ) ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
// task 2 should run now, until it waits. |
|
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAI == rtsk.tskstat, "bad tskstat" ); |
CYG_TEST_CHECK( 5 == rtsk.tskpri, "bad tskpri" ); |
|
switch ( kill ) { |
case SIGNAL: |
// signal the task appropriately |
do_signal( wait ); |
// it should now have run to completion |
break; |
case TIMEOUT: |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// it should now have run to completion |
break; |
case RELEASE: |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// it should now have run to completion |
break; |
case DELETE: |
// delete the object appropriately |
do_delete( wait ); |
// it should now have run to completion |
break; |
case KILL: |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_SIGNAL_RESUME: |
// suspend the task |
do_suspend(); |
// signal the task appropriately |
do_signal( wait ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_TIMEOUT_RESUME: |
// suspend the task |
do_suspend(); |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_RELEASE_RESUME: |
// suspend the task |
do_suspend(); |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_DELETE_RESUME: |
// suspend the task |
do_suspend(); |
// delete the object appropriately |
do_delete( wait ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_KILL: |
// suspend the task |
do_suspend(); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_SIGNAL_KILL: |
// suspend the task |
do_suspend(); |
// signal the task appropriately |
do_signal( wait ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_TIMEOUT_KILL: |
// suspend the task |
do_suspend(); |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_RELEASE_KILL: |
// suspend the task |
do_suspend(); |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_DELETE_KILL: |
// suspend the task |
do_suspend(); |
// delete the object appropriately |
do_delete( wait ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
|
// task 2 should be dormant now, however it got there |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_DMT == rtsk.tskstat, "bad tskstat" ); |
|
if ( (SUSPEND_SIGNAL_KILL == kill) && |
((MEMFIXEDGET == wait) || (MEMVARGET == wait)) ) { |
// it was a killed successful memory alloc, so we have |
// lost the pointer to memory allocated; there is an |
// implicit storeleak problem when the task trying |
// to allocate is signalled then killed. |
// Recreate the pointer from an old version: |
CYG_TEST_CHECK( NULL == t2vp, "t2vp WAS allocated!" ); |
t2vp = t2vp_backup; |
} |
|
switch ( kill ) { |
case KILL: |
case SUSPEND_KILL: |
case SUSPEND_SIGNAL_KILL: |
case SUSPEND_TIMEOUT_KILL: |
case SUSPEND_RELEASE_KILL: |
case SUSPEND_DELETE_KILL: |
// if task 2 was killed, expect only one increment |
CYG_TEST_CHECK( 1 == intercom, "intercom bad value !1" ); |
break; |
default: |
// otherwise expect two increments |
CYG_TEST_CHECK( 2 == intercom, "intercom bad value !2" ); |
break; |
} |
|
// tidy up or recreate the synchronization objects |
if ( (DELETE == kill) || |
(SUSPEND_DELETE_RESUME == kill) || |
(SUSPEND_DELETE_KILL == kill) ) |
do_recreate( wait ); |
else |
do_tidyup( wait ); |
} |
} |
} |
CYG_TEST_PASS("synchronization interaction tests"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
WAITOP wait; |
WAITTYPE waittype; |
KILLOP kill; |
|
decodearg( arg, &wait, &waittype, &kill ); |
|
// CYG_TEST_INFO( makemsg( " 2: ", wait, waittype, kill ) ); |
|
intercom++; |
ercd = do_wait( wait, waittype ); |
intercom++; |
|
switch ( kill ) { |
case SIGNAL: |
case SUSPEND_SIGNAL_RESUME: |
// we expect to have been signalled correctly |
CYG_TEST_CHECK( E_OK == ercd, "T2 wait bad ercd" ); |
// here we know that the op completed OK |
if ( (MEMFIXEDGET == wait) || (MEMVARGET == wait) ) { |
// it was a successful memory alloc of whichever type, |
// so we can save away a copy of t2vp for working round an |
// implicit storeleak problem when the task trying to allocate |
// is signalled then killed: |
CYG_TEST_CHECK( NULL != t2vp, "No t2vp allocated!" ); |
t2vp_backup = t2vp; |
} |
break; |
case TIMEOUT: |
case SUSPEND_TIMEOUT_RESUME: |
// we expect to have timed out - if it's a timeout op. |
CYG_TEST_CHECK( E_TMOUT == ercd, "T2 timeout bad ercd, !E_TMOUT" ); |
break; |
case RELEASE: |
case SUSPEND_RELEASE_RESUME: |
// we expect to have suffered a release wait. |
CYG_TEST_CHECK( E_RLWAI == ercd, "T2 release bad ercd, !E_RLWAI" ); |
break; |
case DELETE: |
case SUSPEND_DELETE_RESUME: |
// we expect to be told the object is gone |
CYG_TEST_CHECK( E_DLT == ercd, "T2 release bad ercd, !E_DLT" ); |
break; |
case KILL: |
case SUSPEND_KILL: |
case SUSPEND_SIGNAL_KILL: |
case SUSPEND_TIMEOUT_KILL: |
case SUSPEND_RELEASE_KILL: |
case SUSPEND_DELETE_KILL: |
// we expect to have been killed here, ie. this won't execute! |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test7.c |
/v2_0/tests/test8.c
0,0 → 1,393
//=========================================================================== |
// |
// test8.c |
// |
// uITRON "C" test program eight |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-12 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
INT scratch; |
|
void newtask( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
|
T_CTSK t_ctsk = { NULL, 0, (FP)&newtask, 1, CYGNUM_UITRON_STACK_SIZE }; |
T_RTSK t_rtsk; |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
// change us to prio 3 for flexibility |
ercd = chg_pri( 0, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
// first, check that we can delete a task: |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_tsk bad ercd !E_ID" ); |
ercd = del_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_tsk bad ercd !E_ID" ); |
ercd = cre_tsk( -6, &t_ctsk ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_tsk bad ercd !E_ID" ); |
ercd = cre_tsk( 99, &t_ctsk ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try a pre-existing object - ourselves! |
ercd = cre_tsk( 1, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try deleting an active task |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
// Task 2 is now ready-to-run, lower prio than us |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// Task 2 is now sleeping |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// try deleting a running task - ourselves! |
ercd = del_tsk( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// terminate task 2; should then be OK to delete it |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
// and check it is deleted |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sta_tsk bad ercd !E_NOEXS" ); |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ter_tsk bad ercd !E_NOEXS" ); |
ercd = chg_pri( 2, 6 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "chg_pri bad ercd !E_NOEXS" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_wai bad ercd !E_NOEXS" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sus_tsk bad ercd !E_NOEXS" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rsm_tsk bad ercd !E_NOEXS" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "frsm_tsk bad ercd !E_NOEXS" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wup_tsk bad ercd !E_NOEXS" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "can_wup bad ercd !E_NOEXS" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "del_tsk bad ercd !E_NOEXS" ); |
// recreate task2, with the same function |
t_ctsk.task = (FP)&task2; |
t_ctsk.itskpri = 7; |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 7 == t_rtsk.tskpri, "Bad tskpri in new task2 !7" ); |
CYG_TEST_CHECK( TTS_DMT == t_rtsk.tskstat, |
"Bad tskstat in new task2 !TTS_DMT" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
// now start the task and do the same lot again... |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try deleting an active task |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
// Task 2 is now ready-to-run, lower prio than us |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "bad intercount !2" ); |
// Task 2 is now sleeping |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 7 == t_rtsk.tskpri, "Bad tskpri in new task2 !7" ); |
CYG_TEST_CHECK( TTS_WAI == t_rtsk.tskstat, |
"Bad tskstat in new task2 !TTS_WAI" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// up its priority |
ercd = chg_pri( 2, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
// awaken task 2; it will then exit-and-delete itself: |
CYG_TEST_CHECK( 2 == intercount, "bad intercount !2" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
// and check it is deleted |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sta_tsk bad ercd !E_NOEXS" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ter_tsk bad ercd !E_NOEXS" ); |
ercd = chg_pri( 2, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "chg_pri bad ercd !E_NOEXS" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_wai bad ercd !E_NOEXS" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sus_tsk bad ercd !E_NOEXS" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rsm_tsk bad ercd !E_NOEXS" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "frsm_tsk bad ercd !E_NOEXS" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wup_tsk bad ercd !E_NOEXS" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "can_wup bad ercd !E_NOEXS" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "del_tsk bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_tsk( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_tsk bad ercd !E_PAR" ); |
#endif |
ercd = cre_tsk( 2, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_tsk bad ercd !E_PAR" ); |
t_ctsk.stksz = 0x40000000; |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_tsk bad ercd !E_NOMEM" ); |
t_ctsk.stksz = CYGNUM_UITRON_STACK_SIZE; |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
#endif // we can test bad param error returns |
|
ercd = del_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
t_ctsk.task = (FP)&task4; |
t_ctsk.itskpri = 9; |
ercd = cre_tsk( 3, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// check we can delete it again immediately |
ercd = del_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
ercd = ref_tsk( &t_rtsk, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
t_ctsk.task = (FP)&newtask; |
t_ctsk.itskpri = 1; |
ercd = cre_tsk( 3, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = sta_tsk( 3, 999 ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// it should have run now, and exited |
CYG_TEST_CHECK( 5 == intercount, "bad intercount !5" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
// and check that it will just run again... |
ercd = sta_tsk( 3, 999 ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// it should have run now, and exited |
CYG_TEST_CHECK( 7 == intercount, "bad intercount !7" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
// all done. |
|
CYG_TEST_PASS("create/delete tasks"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
#else // ! CYGPKG_UITRON_TASKS_CREATE_DELETE |
CYG_TEST_NA( "Tasks do not have create/delete enabled" ); |
#endif // ! CYGPKG_UITRON_TASKS_CREATE_DELETE |
ext_tsk(); |
} |
|
|
|
void newtask( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Newtask running" ); |
CYG_TEST_CHECK( 999 == arg, "Bad arg to newtask() !999" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == i, "tid not 3" ); |
intercount++; |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
intercount++; |
// and just return |
} |
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
intercount++; |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
intercount++; |
|
exd_tsk(); // if we are not killed first |
|
intercount++; // shouldn't happen |
} |
|
void task3( unsigned int arg ) |
{ |
CYG_TEST_FAIL( "How come I'm being run?" ); |
} |
|
void task4( unsigned int arg ) |
{ |
CYG_TEST_FAIL( "How come I'm being run?" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test8.c |
/v2_0/tests/test9.c
0,0 → 1,489
//=========================================================================== |
// |
// test9.c |
// |
// uITRON "C" test program nine |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-16 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
VP vp; |
|
T_CMPL t_cmpl = { NULL, 0, 1000 }; |
T_RMPL t_rmpl; |
T_CMPF t_cmpf = { NULL, 0, 10, 100 }; |
T_RMPF t_rmpf; |
|
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int tests = 0; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mpf( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); |
ercd = del_mpf( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); |
ercd = cre_mpf( -6, &t_cmpf ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); |
ercd = cre_mpf( 99, &t_cmpf ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
// [first get a valid block from it for the freeing test later] |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpf bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mpf( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
// check it is deleted |
ercd = rel_blf( 3, vp ); // vp did come from this pool |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blf bad ercd !E_NOEXS" ); |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
ercd = tget_blf( &vp, 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blf bad ercd !E_NOEXS" ); |
ercd = get_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = ref_mpf( &t_rmpf, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpf bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mpf( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" ); |
#endif |
ercd = cre_mpf( 3, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" ); |
t_cmpf.mpfatr = 0xfff; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpf bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
t_cmpf.mpfatr = 0; |
t_cmpf.mpfcnt = 10000; |
t_cmpf.blfsz = 100; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); |
t_cmpf.mpfcnt = 100; |
t_cmpf.blfsz = 100000; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); |
// now create it well |
t_cmpf.mpfatr = 0; |
t_cmpf.mpfcnt = 10; |
t_cmpf.blfsz = 100; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
// and check we can use it |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = tget_blf( &vp, 3, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = get_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); |
ercd = rel_blf( 3, vp ); // vp did come from new pool |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = rel_blf( 3, vp ); // vp already freed |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
ercd = ref_mpf( &t_rmpf, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blf( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); |
// check they are deleted |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = pget_blf( &vp, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
|
// re-create and do it again |
t_cmpf.mpfcnt = 90; |
t_cmpf.blfsz = 20; |
ercd = cre_mpf( 1, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
t_cmpf.mpfcnt = 5; |
t_cmpf.blfsz = 200; |
ercd = cre_mpf( 2, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blf( &vp, 2, 10 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); |
// check they are deleted |
ercd = tget_blf( &vp, 1, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = get_blf( &vp, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete fixed mempools"); |
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mpl( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); |
ercd = del_mpl( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); |
ercd = cre_mpl( -6, &t_cmpl ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); |
ercd = cre_mpl( 99, &t_cmpl ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
// [first get a valid block from it for the freeing test later] |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpl bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mpl( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
// check it is deleted |
ercd = rel_blk( 3, vp ); // vp did come from this pool |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blk bad ercd !E_NOEXS" ); |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
ercd = tget_blk( &vp, 3, 100, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blk bad ercd !E_NOEXS" ); |
ercd = get_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = ref_mpl( &t_rmpl, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpl bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mpl( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" ); |
#endif |
ercd = cre_mpl( 3, NADR ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" ); |
t_cmpl.mplatr = 0xfff; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpl bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
t_cmpl.mplatr = 0; |
t_cmpl.mplsz = 100000000; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpl bad ercd" ); |
// now create it well |
t_cmpl.mplatr = 0; |
t_cmpl.mplsz = 1000; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
// and check we can use it |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = pget_blk( &vp, 3, 100000000 ); // way too large |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &vp, 3, 100, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = get_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" ); |
ercd = rel_blk( 3, vp ); // vp did come from new pool |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = rel_blk( 3, vp ); // vp already freed |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
ercd = ref_mpl( &t_rmpl, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blk( &vp, 1, 100 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blk( &vp, 2, 100, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blk( &vp, 2, 100, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" ); |
// check they are deleted |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = pget_blk( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
|
// re-create and do it again |
ercd = cre_mpl( 1, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
ercd = cre_mpl( 2, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blk( &vp, 1, 20 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blk( &vp, 2, 400, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blk( &vp, 2, 500, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" ); |
// check they are deleted |
ercd = tget_blk( &vp, 1, 200, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = get_blk( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete variable mempools"); |
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// all done |
if ( 0 == tests ) { |
CYG_TEST_NA( "No objects have create/delete enabled" ); |
} |
else { |
CYG_TEST_EXIT( "All done" ); |
} |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF test9.c |
/v2_0/tests/testcx2.cxx
0,0 → 1,937
//=========================================================================== |
// |
// testcx2.cxx |
// |
// uITRON "C++" test program two |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
int intercom = 0; |
int intercount = 0; |
INT scratch = 0; |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
T_RSEM sem_info; |
T_RFLG flg_info; |
T_RMBX mbx_info; |
T_RMPF mpf_info; |
T_RMPL mpl_info; |
UINT flagptn; |
static char foo[] = "Test message"; |
T_MSG *msgptr = (T_MSG *)foo; |
T_MSG *rxptr = NULL; |
VP blfptr = (VP)foo; |
VP blkptr = (VP)foo; |
|
int delay = 10; |
if (cyg_test_is_simulator) |
delay = 3; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
// start a lower prio task to interact with |
intercom = 1; |
ercd = sta_tsk( 2, 222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// Semaphores; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing semaphore ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = sig_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
ercd = sig_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
ercd = wai_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
ercd = wai_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
ercd = preq_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
ercd = preq_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
ercd = twai_sem( -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
ercd = twai_sem( 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
ercd = twai_sem( 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_sem bad ercd !E_PAR" ); |
ercd = ref_sem( &sem_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
ercd = ref_sem( &sem_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_sem( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_sem bad ercd !E_PAR" ); |
#endif |
CYG_TEST_PASS( "bad calls: sig_sem, [t]wai_sem, preq_sem, ref_sem" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "wai_sem bad ercd !E_CTX" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_sem bad ercd !E_CTX" ); |
ercd = twai_sem( 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_sem(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: wai_sem, twai_sem with dis_dsp" ); |
|
// check ref_sem with various states |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
ercd = preq_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 2 == sem_info.semcnt, "semcnt should be 2" ); |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
ercd = twai_sem( 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 != sem_info.wtsk, "sem.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be non0" ); |
#if 1 |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
#endif |
ercd = dly_tsk( delay ); // let task 2 pick up the signal |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_sem( &sem_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
CYG_TEST_PASS( "good calls: sig_sem, [t]wai,preq_sem with ref_sem" ); |
|
// Flags; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing flag ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = set_flg( -6, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
ercd = set_flg( 99, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
ercd = clr_flg( -6, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "clr_flg bad ercd !E_ID" ); |
ercd = clr_flg( 99, 1 ); |
CYG_TEST_CHECK( E_ID == ercd, "sig_flg bad ercd !E_ID" ); |
ercd = wai_flg( &flagptn, -6, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
ercd = wai_flg( &flagptn, 99, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = wai_flg( NULL, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
#endif |
ercd = wai_flg( &flagptn, 2, 7, 34657 ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
ercd = wai_flg( &flagptn, 2, 0, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
ercd = pol_flg( &flagptn, -6, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
ercd = pol_flg( &flagptn, 99, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pol_flg( NULL, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
#endif |
ercd = pol_flg( &flagptn, 2, 7, 34657 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
ercd = pol_flg( &flagptn, 2, 0, TWF_ANDW ); |
CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, -6, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
ercd = twai_flg( &flagptn, 99, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = twai_flg( NULL, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
#endif |
ercd = twai_flg( &flagptn, 2, 7, 34657, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = twai_flg( &flagptn, 2, 0, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
ercd = ref_flg( &flg_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
ercd = ref_flg( &flg_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_flg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_flg bad ercd !E_PAR" ); |
#endif |
CYG_TEST_PASS( "bad calls: set_flg, clr_flg, [t]wai,pol_flg, ref_flg" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wai_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_CTX == ercd, "wai_flg bad ercd !E_CTX" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_flg bad ercd !E_CTX" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "twai_flg(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: wai_flg, twai_flg with dis_dsp" ); |
|
// check ref_flg with various states |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
ercd = set_flg( 2, 0x5555 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0x5555 == flg_info.flgptn, "flgptn should be 0x5555" ); |
ercd = clr_flg( 2, 0xF0F0 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
CYG_TEST_CHECK( 0x5050 == flg_info.flgptn, "flgptn should be 0x5050" ); |
ercd = set_flg( 2, 0xFFFF ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_flg( &flg_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be 0" ); |
CYG_TEST_CHECK( 0xFFFF == flg_info.flgptn, "flgptn should be 0xFFFF" ); |
CYG_TEST_PASS( "good calls: clr_flg, set_flg, wai_flg with ref_flg" ); |
|
// Mailboxes; all the illegal argument combinations first |
CYG_TEST_INFO( "Testing mailbox ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = snd_msg( -6, msgptr ); |
CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
ercd = snd_msg( 99, msgptr ); |
CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = snd_msg( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "snd_msg bad ercd !E_PAR" ); |
#endif |
ercd = rcv_msg( &rxptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
ercd = rcv_msg( &rxptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rcv_msg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = prcv_msg( &rxptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
ercd = prcv_msg( &rxptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = prcv_msg( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "prcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = trcv_msg( &rxptr, -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
ercd = trcv_msg( &rxptr, 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
ercd = trcv_msg( &rxptr, 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = trcv_msg( NULL, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
#endif |
ercd = ref_mbx( &mbx_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
ercd = ref_mbx( &mbx_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mbx( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mbx bad ercd !E_PAR" ); |
#endif |
CYG_TEST_PASS( "bad calls: snd_msg, [pt]rcv_msg, ref_mbx" ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "rcv_msg bad ercd !E_CTX" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg bad ercd !E_CTX" ); |
ercd = trcv_msg( &rxptr, 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = prcv_msg( &rxptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rcv_msg, trcv_msg with dis_dsp" ); |
|
// check ref_mbx with various states |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 != mbx_info.wtsk, "mbx.wtsk should be non0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
ercd = snd_msg( 2, msgptr ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
#if 1 |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( msgptr == mbx_info.pk_msg, "mbx peek should be msgptr" ); |
#endif |
ercd = dly_tsk( delay ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mbx( &mbx_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
// fill the message box, expect E_QOVR |
for ( scratch = 0 ; scratch < 100 ; scratch++ ) { |
if ( E_OK != ( ercd = snd_msg( 2, msgptr ) ) ) |
break; |
} |
CYG_TEST_CHECK( (100 == scratch) || (E_QOVR == ercd), |
"snd_msg bad ercd !E_QOVR/E_OK" ); |
// empty the message box, expect the right number and E_TMOUT |
for ( ; 1 ; scratch-- ) { |
if ( E_OK != ( ercd = prcv_msg( &rxptr, 2 ) ) ) |
break; |
} |
CYG_TEST_CHECK( 0 == scratch, "rcv_msg count bad scratch!=0" ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "rcv_msg bad ercd !E_TMOUT" ); |
|
CYG_TEST_PASS( "good calls: rcv_msg, snd_msg with ref_msg" ); |
|
// Fixed block memory pools: all the illegal argument combinations first |
CYG_TEST_INFO( "Testing fixed block memory ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_blf( -6, blfptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
ercd = rel_blf( 99, blfptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rel_blf( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
#endif |
#endif // we can test bad param error returns |
ercd = rel_blf( 2, blfptr ); // it did not come from a mpf |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
ercd = get_blf( &blfptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_blf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blf bad ercd !E_PAR" ); |
#endif |
ercd = pget_blf( &blfptr, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
ercd = pget_blf( &blfptr, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pget_blf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blf bad ercd !E_PAR" ); |
#endif |
ercd = tget_blf( &blfptr, -6, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
ercd = tget_blf( &blfptr, 99, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
ercd = tget_blf( &blfptr, 2, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = tget_blf( NULL, 2, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
#endif |
ercd = ref_mpf( &mpf_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
ercd = ref_mpf( &mpf_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mpf( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpf bad ercd !E_PAR" ); |
#endif |
CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf, ref_mpf " ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
// consume the whole thing then do it again, expecting E_TMOUT |
while ( E_OK == (ercd = pget_blf( &blfptr, 2 ) ) ) |
continue; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
ercd = tget_blf( &blfptr, 2, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blf(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blf( &blfptr, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
ercd = tget_blf( &blfptr, 2, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf with ena_dsp" ); |
|
// check ref_mpf with various states |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 != mpf_info.wtsk, "mpf.wtsk should be non0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
ercd = rel_blf( 2, blfptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
#if 1 |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
#else // old, non-uITRON semantics |
CYG_TEST_CHECK( 0 != mpf_info.frbcnt, "mpf.frbcnt should be non0" ); |
#endif |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mpf( &mpf_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
CYG_TEST_PASS( "good calls: rel_blf, get_blf with ref_mpf" ); |
|
// Variable block memory pools; illegal arguments |
CYG_TEST_INFO( "Testing variable block memory ops" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_blk( -6, blkptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
ercd = rel_blk( 99, blkptr ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = rel_blk( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
#endif |
#endif // we can test bad param error returns |
ercd = rel_blk( 2, blkptr ); // it did not come from a mpl |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, -6, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
ercd = get_blk( &blkptr, 99, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_blk( NULL, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_blk bad ercd !E_PAR" ); |
#endif |
ercd = pget_blk( &blkptr, -6, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
ercd = pget_blk( &blkptr, 99, 100 ); |
CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = pget_blk( NULL, 2, 100 ); |
CYG_TEST_CHECK( E_PAR == ercd, "pget_blk bad ercd !E_PAR" ); |
#endif |
ercd = tget_blk( &blkptr, -6, 100, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
ercd = tget_blk( &blkptr, 99, 100, delay ); |
CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
ercd = tget_blk( &blkptr, 2, 100, -999 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = tget_blk( NULL, 2, 100, delay ); |
CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
#endif |
ercd = ref_mpl( &mpl_info, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
ercd = ref_mpl( &mpl_info, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_mpl( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_mpl bad ercd !E_PAR" ); |
#endif |
CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk, ref_mpl " ); |
#endif // we can test bad param error returns |
|
// check the waitable functions versus dispatch disable |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
// consume the whole thing then do it again, expecting E_TMOUT |
while ( E_OK == (ercd = pget_blk( &blkptr, 2, 100 ) ) ) |
continue; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = get_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tget_blk(FEVR) bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = pget_blk( &blkptr, 2, 100 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, delay ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk with ena_dsp" ); |
|
// check ref_mpl with various states |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
CYG_TEST_CHECK( mpl_info.maxsz <= mpl_info.frsz, |
"mpl.maxsz not < mpl.frsz" ); |
intercom = 0; |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
intercom = 1; |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 != mpl_info.wtsk, "mpl.wtsk should be non0" ); |
ercd = rel_blk( 2, blkptr ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
ercd = dly_tsk( delay ); // let task 2 start waiting |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_mpl( &mpl_info, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
CYG_TEST_PASS( "good calls: rel_blk, get_blk with ref_mpl" ); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
T_MSG *msgp = NULL; |
UINT flgval = 0; |
VP blfp = NULL; |
VP blkp = NULL; |
|
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 222" ); |
|
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = wai_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = wai_flg( &flgval, 2, 99, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
CYG_TEST_CHECK( 99 == (99 & flgval), "flg value no good" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = rcv_msg( &msgp, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
CYG_TEST_CHECK( NULL != msgp, "no msg received" ); |
CYG_TEST_CHECK( NADR != msgp, "no msg received" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = get_blf( &blfp, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); |
CYG_TEST_CHECK( NULL != blfp, "no blf allocated" ); |
CYG_TEST_CHECK( NADR != blfp, "no blf allocated" ); |
while ( intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
} |
ercd = get_blk( &blkp, 2, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" ); |
CYG_TEST_CHECK( NULL != blkp, "no blk allocated" ); |
CYG_TEST_CHECK( NADR != blkp, "no blk allocated" ); |
|
ext_tsk(); |
CYG_TEST_FAIL( "Task 2 failed to exit" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK " |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx2.cxx |
/v2_0/tests/testcx3.cxx
0,0 → 1,262
//=========================================================================== |
// |
// testcx3.cxx |
// |
// uITRON "C++" test program three |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
int t2done = 0; |
int t3done = 0; |
int t4done = 0; |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
// start lower prio tasks to interact with |
ercd = sta_tsk( 2, 222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = sta_tsk( 3, 333 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = sta_tsk( 4, 444 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
// now start the test |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
CYG_TEST_INFO( "T1 awoken" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
CYG_TEST_INFO( "T1 signalled" ); |
|
// let the others complete, so we get the status back |
ercd = dly_tsk( 50 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_CHECK( t2done, "t2 not done" ); |
CYG_TEST_CHECK( t3done, "t3 not done" ); |
CYG_TEST_CHECK( t4done, "t4 not done" ); |
|
CYG_TEST_PASS( "Immediate-dispatch producer/consumer test OK" ); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 222" ); |
|
// now start the test |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
CYG_TEST_INFO( "T2 awoken" ); |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = wup_tsk( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
CYG_TEST_INFO( "T2 completing" ); |
t2done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 2 sleep came back" ); |
} |
|
void task3( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 3 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
if ( 333 != arg ) |
CYG_TEST_FAIL( "Task 3 arg not 333" ); |
|
// now start the test |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
CYG_TEST_INFO( "T3 awoken" ); |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
CYG_TEST_INFO( "T3 completing" ); |
t3done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 3 sleep came back" ); |
} |
|
void task4( unsigned int arg ) |
{ |
ER ercd; |
INT scratch; |
|
CYG_TEST_INFO( "Task 4 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
if ( 444 != arg ) |
CYG_TEST_FAIL( "Task 4 arg not 444" ); |
|
// now start the test |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
CYG_TEST_INFO( "T4 completing" ); |
t4done++; |
|
ercd = slp_tsk(); |
CYG_TEST_FAIL( "Task 4 sleep came back" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx3.cxx |
/v2_0/tests/testcx4.cxx
0,0 → 1,406
//=========================================================================== |
// |
// testcx4.cxx |
// |
// uITRON "C++" test program four |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): dsm |
// Contributors: dsm |
// Date: 1998-06-12 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough cyclic handlers */ \ |
defined( CYGPKG_UITRON_CYCLICS ) && \ |
(CYGNUM_UITRON_CYCLICS >= 3) && \ |
(CYGNUM_UITRON_CYCLICS < 90) && \ |
\ |
/* test configuration for enough alarm handlers */ \ |
defined( CYGPKG_UITRON_ALARMS ) && \ |
(CYGNUM_UITRON_ALARMS >= 3) && \ |
(CYGNUM_UITRON_ALARMS < 90) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
INT scratch; |
|
void hand1(void) |
{ |
CYG_TEST_INFO("Handler 1 called"); |
intercount++; |
} |
|
void hand2(void) |
{ |
CYG_TEST_CHECK( 2 == intercount, "handler out of sync" ); |
CYG_TEST_INFO("Handler 2 called"); |
intercount++; |
} |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
T_DCYC dcyc; |
T_DALM dalm; |
T_RCYC rcyc; |
T_RALM ralm; |
|
unsigned int tm; |
|
static char foo[] = "Test message"; |
VP info = (VP)foo; |
|
// Increase times when running on HW since overhead of GDB packet |
// acknowledgements may cause tests of timing to fail. |
if (cyg_test_is_simulator) |
tm = 1; |
else |
tm = 4; |
|
CYG_TEST_INFO( "Task 1 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
dcyc.exinf = (VP)info; |
dcyc.cycatr = TA_HLNG; |
dcyc.cychdr = (FP)&hand1; |
dcyc.cycact = TCY_INI; // bad |
dcyc.cyctim = 2; |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dcyc.cycact = TCY_OFF; // make good |
dcyc.cyctim = 0; // bad |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dcyc.cyctim = 1; // make good |
|
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_cyc(-6, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
ercd = def_cyc(99, &dcyc); |
CYG_TEST_CHECK( E_PAR == ercd, "def_cyc bad ercd !E_PAR" ); |
|
ercd = act_cyc(-6, TCY_OFF); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
ercd = act_cyc(99, TCY_OFF); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
ercd = act_cyc( 3, ~0); |
CYG_TEST_CHECK( E_PAR == ercd, "act_cyc bad ercd !E_PAR" ); |
|
ercd = ref_cyc(&rcyc, -6); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
ercd = ref_cyc(&rcyc, 99); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_cyc(NULL, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_cyc bad ercd !E_PAR" ); |
#endif |
#endif // we can test bad param error returns |
|
ercd = def_cyc(3, (T_DCYC *)NADR); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_cyc bad ercd !E_NOEXS" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "bad calls: def_cyc, act_cyc, ref_cyc" ); |
|
dalm.exinf = (VP)info; |
dalm.almatr = TA_HLNG; |
dalm.almhdr = (FP)&hand2; |
dalm.tmmode = ~0; // bad |
dalm.almtim = 20; |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_PAR == ercd, "def_alm bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dalm.tmmode = TTM_REL; // make good |
dalm.almtim = 0; // bad |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_PAR == ercd, "def_alm bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
dalm.almtim = 1000; // make good |
|
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_OK == ercd, "def_alm bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_alm(&ralm, -6); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
ercd = ref_alm(&ralm, 99); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_alm(NULL, 3); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_alm bad ercd !E_PAR" ); |
#endif |
|
#endif // we can test bad param error returns |
ercd = def_alm(3, (T_DALM *)NADR); |
CYG_TEST_CHECK( E_OK == ercd, "def_cyc bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ref_alm(&ralm, 3); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_cyc bad ercd !E_NOEXS" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "bad calls: def_alm, act_alm, ref_alm" ); |
|
dcyc.exinf = (VP)info; |
dcyc.cycatr = TA_HLNG; |
dcyc.cychdr = (FP)&hand1; |
dcyc.cycact = TCY_ON; |
dcyc.cyctim = 50*tm; |
|
ercd = def_cyc(3, &dcyc); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_OFF == rcyc.cycact, "rcyc.cycact should be TCY_OFF" ); |
ercd = act_cyc(3, TCY_ON); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc bad ercd" ); |
|
CYG_TEST_PASS("good calls: def_cyc, act_cyc, ref_cyc"); |
|
dalm.exinf = (VP)info; |
dalm.almatr = TA_HLNG; |
dalm.almhdr = (FP)&hand2; |
dalm.tmmode = TTM_REL; |
dalm.almtim = 120*tm; |
|
ercd = def_alm(3, &dalm); |
CYG_TEST_CHECK( E_OK == ercd, "def_alm bad ercd" ); |
ercd = ref_alm(&ralm, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_alm bad ercd" ); |
CYG_TEST_CHECK( info == ralm.exinf, "ralm.exinf should be info" ); |
CYG_TEST_CHECK( 115*tm < ralm.lfttim, "ralm.lfttim too small" ); |
CYG_TEST_CHECK( ralm.lfttim <= 120*tm, "ralm.lfttim too big" ); |
|
// Expect handlers to be called at approximate times |
// time intercount |
// tm*50 hand1 0 |
// tm*100 hand1 1 |
// tm*120 hand2 2 |
// tm*150 hand1 3 |
|
ercd = dly_tsk(160*tm); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "handlers not both called" ); |
|
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(off) bad ercd" ); |
|
ercd = dly_tsk(60*tm); // enough for at least one tick |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "cyclic not disabled" ); |
|
// approx time now 220, so we expect a cycle in about 30 ticks |
ercd = act_cyc(3, TCY_ON); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 25*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 35*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// now resynchronize with right now: |
ercd = act_cyc(3, TCY_ON|TCY_INI); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// wait a bit and check that time marches on, or even down |
ercd = dly_tsk(10*tm); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 35*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 45*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_ON == rcyc.cycact, "rcyc.cycact should be TCY_ON" ); |
|
// now turn it off and re-synch with right now: |
ercd = act_cyc(3, TCY_OFF|TCY_INI); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
ercd = ref_cyc(&rcyc, 3); |
CYG_TEST_CHECK( E_OK == ercd, "ref_cyc bad ercd" ); |
CYG_TEST_CHECK( info == rcyc.exinf, "rcyc.exinf should be info" ); |
CYG_TEST_CHECK( 45*tm < rcyc.lfttim, "rcyc.lfttim too small" ); |
CYG_TEST_CHECK( rcyc.lfttim <= 50*tm, "rcyc.lfttim too big" ); |
CYG_TEST_CHECK( TCY_OFF == rcyc.cycact, "rcyc.cycact should be TCY_OFF" ); |
|
ercd = act_cyc(3, TCY_OFF); |
CYG_TEST_CHECK( E_OK == ercd, "act_cyc(on) bad ercd" ); |
|
CYG_TEST_PASS("good calls: def_cyc, act_cyc, ref_cyc, def_alm, ref_alm"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx4.cxx |
/v2_0/tests/testcx5.cxx
0,0 → 1,363
//=========================================================================== |
// |
// testcx5.cxx |
// |
// uITRON "C++" test program five |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): dsm |
// Contributors: dsm |
// Date: 1998-06-12 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
|
UINT scratch; |
T_MSG *t_msg; |
VP vp; |
|
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int i; |
T_RSYS rsys; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
// check initial state |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
// disable intrs and check state |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// try an illegal op |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// enable intrs and check state and a legal sleep |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
ercd = dly_tsk( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// disable intrs and try scheduler illegal ops |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_CTX == ercd, "dis_dsp bad ercd !E_CTX" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_CTX == ercd, "ena_dsp bad ercd !E_CTX" ); |
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// enable again and check state |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
// disable the scheduler and check state |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_DDSP == rsys.sysstat, "system state not TSS_DDSP" ); |
// disable intrs and check state |
ercd = loc_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); |
// then unlock and check state |
ercd = unl_cpu(); |
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); |
ercd = ref_sys( &rsys ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); |
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); |
|
CYG_TEST_PASS( "Interrupt dis/enabling and interactions" ); |
|
// and now we can do the rest of the test |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); |
ercd = rel_wai( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); |
ercd = rel_wai( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); |
#endif // we can test bad param error returns |
|
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_sem bad ercd !E_RLWAI" ); |
|
ercd = twai_sem( 1, 20 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_sem bad ercd !E_RLWAI" ); |
|
ercd = wai_flg( &scratch, 1, 9999, 0 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_flg bad ercd !E_RLWAI" ); |
|
ercd = twai_flg( &scratch, 1, 9999, 0, 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_flg bad ercd !E_RLWAI" ); |
|
ercd = rcv_msg( &t_msg, 1 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "rcv_msg bad ercd !E_RLWAI" ); |
|
ercd = trcv_msg( &t_msg, 1, 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "trcv_msg bad ercd !E_RLWAI" ); |
|
// these are loops so as to consume the whole of the mempool |
// in order to wait at the end |
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = get_blf( &vp, 3 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blf bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = tget_blf( &vp, 3, 10 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blf bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = get_blk( &vp, 1, 1000 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blk bad ercd !E_RLWAI" ); |
|
for ( i = 0; i < 10; i++ ) |
if ( E_OK != (ercd = tget_blk( &vp, 1, 1000, 10 ) ) ) |
break; |
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blk bad ercd !E_RLWAI" ); |
|
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "dly_tsk bad ercd !E_RLWAI" ); |
|
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_RLWAI == ercd, "tslp_tsk bad ercd !E_RLWAI" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_RLWAI == ercd, "slp_tsk bad ercd !E_RLWAI" ); |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_PASS("release wait: various waiting calls"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
for ( i = 0 ; i < 100; i++ ) { |
ercd = rel_wai( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
} |
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx5.cxx |
/v2_0/tests/testcx6.cxx
0,0 → 1,600
//=========================================================================== |
// |
// testcx6.cxx |
// |
// uITRON "C++" test program six |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-14 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
UINT scratch; |
T_MSG *t_msg = (T_MSG *)&scratch; |
T_MSG *msg; |
VP vp; |
|
T_CSEM t_csem = { NULL, 0, 0 }; |
T_CMBX t_cmbx = { NULL, 0 }; |
T_CFLG t_cflg = { NULL, 0, 0 }; |
T_RSEM t_rsem; |
T_RMBX t_rmbx; |
T_RFLG t_rflg; |
|
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int tests = 0; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_sem( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); |
ercd = del_sem( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); |
ercd = cre_sem( -6, &t_csem ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); |
ercd = cre_sem( 99, &t_csem ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
// check it is deleted |
ercd = sig_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = preq_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" ); |
ercd = twai_sem( 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" ); |
ercd = wai_sem( 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" ); |
ercd = ref_sem( &t_rsem, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_sem( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" ); |
#endif |
t_csem.sematr = 0xfff; |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" ); |
t_csem.sematr = 0; |
#endif // we can test bad param error returns |
ercd = cre_sem( 3, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
// and check we can use it |
ercd = sig_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
ercd = wai_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
ercd = preq_sem( 3 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
ercd = twai_sem( 3, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
ercd = ref_sem( &t_rsem, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_sem( 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
// re-create and do it again |
ercd = cre_sem( 1, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
ercd = cre_sem( 2, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_sem( 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete semaphores"); |
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_flg( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); |
ercd = del_flg( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); |
ercd = cre_flg( -6, &t_cflg ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); |
ercd = cre_flg( 99, &t_cflg ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_flg( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
// check it is deleted |
ercd = set_flg( 3, 0x6789 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
ercd = clr_flg( 3, 0x9876 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" ); |
ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" ); |
ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_flg( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" ); |
#endif |
t_cflg.flgatr = 0xfff; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
// now create it well |
t_cflg.flgatr = 0; |
t_cflg.iflgptn = 0; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
// and check we can use it |
ercd = clr_flg( 3, 0x7256 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); |
ercd = set_flg( 3, 0xff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" ); |
ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" ); |
// now create it again with a preset pattern and check that we can |
// detect that pattern: |
ercd = del_flg( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
t_cflg.flgatr = 0; |
t_cflg.iflgptn = 0x1234; |
ercd = cre_flg( 3, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
// and check we can use it |
ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" ); |
ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" ); |
ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" ); |
ercd = clr_flg( 3, 0 ); |
ercd = ref_flg( &t_rflg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_flg( &scratch, 1, 0xaa, TWF_ANDW ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = set_flg( 1, 0x22 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
ercd = clr_flg( 2, 0xdd ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
// re-create and do it again |
t_cflg.iflgptn = 0x5555; |
ercd = cre_flg( 1, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
t_cflg.iflgptn = 0; |
ercd = cre_flg( 2, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = clr_flg( 1, 0xd00d ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); |
ercd = set_flg( 2, 0xfff00 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete flags"); |
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mbx( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); |
ercd = del_mbx( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); |
ercd = cre_mbx( -6, &t_cmbx ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" ); |
ercd = cre_mbx( 99, &t_cmbx ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mbx( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
// check it is deleted |
ercd = snd_msg( 3, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = rcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" ); |
ercd = trcv_msg( &msg, 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" ); |
ercd = prcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" ); |
ercd = ref_mbx( &t_rmbx, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mbx( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" ); |
#endif |
t_cmbx.mbxatr = 0xfff; |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" ); |
t_cmbx.mbxatr = 0; |
#endif // we can test bad param error returns |
ercd = cre_mbx( 3, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
// and check we can use it |
ercd = snd_msg( 3, t_msg ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
ercd = rcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
ercd = trcv_msg( &msg, 3, 2 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
ercd = prcv_msg( &msg, 3 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
ercd = ref_mbx( &t_rmbx, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rcv_msg( &msg, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = trcv_msg( &msg, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = snd_msg( 1, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = snd_msg( 2, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
// re-create and do it again |
ercd = cre_mbx( 1, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
ercd = cre_mbx( 2, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" ); |
|
// now wait while task 2 deletes the wait objects again |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rcv_msg( &msg, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = trcv_msg( &msg, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" ); |
|
// check they are deleted |
ercd = snd_msg( 1, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
ercd = snd_msg( 2, t_msg ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete mboxes"); |
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// all done |
if ( 0 == tests ) { |
CYG_TEST_NA( "No objects have create/delete enabled" ); |
} |
else { |
CYG_TEST_EXIT( "All done" ); |
} |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_flg( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mbx( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx6.cxx |
/v2_0/tests/testcx7.cxx
0,0 → 1,1101
//=========================================================================== |
// |
// testcx7.cxx |
// |
// uITRON "C++" test program seven |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-14 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough flag objects */ \ |
defined( CYGPKG_UITRON_FLAGS ) && \ |
(CYGNUM_UITRON_FLAGS >= 3) && \ |
(CYGNUM_UITRON_FLAGS < 90) && \ |
( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough message boxes */ \ |
defined( CYGPKG_UITRON_MBOXES ) && \ |
(CYGNUM_UITRON_MBOXES >= 3) && \ |
(CYGNUM_UITRON_MBOXES < 90) && \ |
( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
#include <cyg/kernel/test/stackmon.h> // stack analysis tools |
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
// ======================================================================== |
|
enum { |
START_WAITOP = 0, |
SLEEP = 0, |
DELAY, |
SEMGET, |
FLAGWAIT, |
MSGGET, |
MEMFIXEDGET, |
MEMVARGET, |
DONE_WAITOP |
}; |
typedef int WAITOP; |
|
enum { |
START_TYPE = 0, |
PLAIN = 0, |
TIMED = 1, |
DONE_TYPE |
}; |
typedef int WAITTYPE; |
|
enum { |
START_KILLOP = 0, |
|
// These are the 5 ways out of a wait that we perm |
// with other circumstances: |
SIGNAL = 0, // do the appropriate producer op |
TIMEOUT, // wait for the timeout to fire |
RELEASE, // do a rel_wai() |
DELETE, // delete the object; del_xxx() |
KILL, // do a ter_tsk() on the waiter |
|
SUSPEND_SIGNAL_RESUME, |
SUSPEND_TIMEOUT_RESUME, |
SUSPEND_RELEASE_RESUME, |
SUSPEND_DELETE_RESUME, |
SUSPEND_KILL, // resume not applicable |
|
SUSPEND_SIGNAL_KILL, |
SUSPEND_TIMEOUT_KILL, |
SUSPEND_RELEASE_KILL, |
SUSPEND_DELETE_KILL, |
// SUSPEND_KILL_KILL not applicable |
|
#if 0 |
// support these later if _really_ keen. |
SUSPEND_SIGNAL_DELETE_RESUME, |
SUSPEND_TIMEOUT_DELETE_RESUME, |
SUSPEND_RELEASE_DELETE_RESUME, |
// SUSPEND_DELETE_DELETE_RESUME not applicable |
// SUSPEND_KILL_DELETE_RESUME not applicable |
|
SUSPEND_SIGNAL_DELETE_KILL, |
SUSPEND_TIMEOUT_DELETE_KILL, |
SUSPEND_RELEASE_DELETE_KILL, |
// SUSPEND_DELETE_DELETE_KILL, |
SUSPEND_KILL_DELETE // 2nd kill not applicable |
#endif |
|
DONE_KILLOP |
}; |
typedef int KILLOP; |
|
// ======================================================================== |
|
char * waitstrings[] = |
{ "Sleep ", "Delay ", "Sema ", "Flag ", "Mbox ", "MemFix", "MemVar" }; |
|
char * typestrings[] = |
{ " (Plain) : ", " (Timed) : " }; |
|
char * killstrings[] = |
{ "Signal", |
"Wait-for-timeout", |
"Release-wait", |
"Delete-object", |
"Kill-task", |
|
"Suspend/Signal/Resume", |
"Suspend/Wait-for-timeout/Resume", |
"Suspend/Release-wait/Resume", |
"Suspend/Delete-object/Resume", |
"Suspend/Kill-task", |
|
"Suspend/Signal/Kill-task", |
"Suspend/Wait-for-timeout/Kill-task", |
"Suspend/Release-wait/Kill-task", |
"Suspend/Delete-object/Kill-task", |
|
|
}; |
|
// ======================================================================== |
|
inline int task2arg( WAITOP wait, WAITTYPE waittype, KILLOP kill ) |
{ |
return waittype + (wait << 1) + (kill << 8); |
} |
|
inline void decodearg( int arg, WAITOP *pwait, WAITTYPE *pwaittype, KILLOP *pkill ) |
{ |
*pwaittype = (arg & 1) ? TIMED : PLAIN; |
*pwait = (arg >> 1) & 0x7f; |
*pkill = (arg >> 8); |
} |
|
static char *strdog( char *p, char *q ) |
{ |
while ( 0 != (*p++ = *q++) ); |
return p - 1; |
} |
|
static char * |
makemsg( char *z, WAITOP wait, WAITTYPE waittype, KILLOP kill ) |
{ |
static char buf[ 1000 ]; |
char *p = buf; |
p = strdog( p, z ); |
p = strdog( p, waitstrings[ wait ] ); |
p = strdog( p, typestrings[ waittype ] ); |
p = strdog( p, killstrings[ kill ] ); |
*p = 0; |
return buf; |
} |
|
// ======================================================================== |
|
volatile int intercom = 0; |
|
// ======================================================================== |
|
T_RTSK rtsk; |
|
void |
do_suspend( void ) |
{ |
ER ercd; |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAI == rtsk.tskstat, "bad tskstat !TTS_WAI" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAS == rtsk.tskstat, "bad tskstat !TTS_WAS" ); |
} |
|
void |
do_resume( void ) |
{ |
ER ercd; |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_SUS == rtsk.tskstat, "bad tskstat !TTS_SUS" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RDY == rtsk.tskstat, "bad tskstat !TTS_RDY" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
} |
|
// ======================================================================== |
|
#define T1_WAIT (7) |
#define T2_WAIT (5) |
|
#define T1_MALLOC (110) |
#ifdef CYGSEM_KERNEL_MEMORY_COALESCE |
#define T2_MALLOC (100) |
#else |
#define T2_MALLOC T1_MALLOC |
#endif |
|
VP vptmp; |
VP vp = NULL; |
VP vp1 = NULL; |
VP t2vp = NULL; |
VP t2vp_backup = NULL; |
|
UINT scratch; |
|
T_MSG *msg = (T_MSG *)&scratch; |
T_MSG *msg1; |
|
void |
do_prep( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
case SEMGET: |
case FLAGWAIT: |
case MSGGET: |
// do nothing for all of those |
break; |
case MEMFIXEDGET: |
// allocate all the memory in the pool; remember a couple |
// for freeing as the signalling operation: |
t2vp = NULL; |
vp = vptmp = NULL; |
do { |
vp1 = vptmp; |
vptmp = vp; |
ercd = pget_blf( &vp, 1 ); |
} while ( E_OK == ercd ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "get_blf bad ercd" ); |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
break; |
case MEMVARGET: |
// allocate all the memory in the pool; remember a couple |
// for freeing as the signalling operation: |
t2vp = NULL; |
vp = vptmp = NULL; |
do { |
vp1 = vptmp; |
vptmp = vp; |
ercd = pget_blk( &vp, 1, T1_MALLOC ); |
} while ( E_OK == ercd ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "get_blk bad ercd" ); |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_tidyup( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
case SEMGET: |
case MSGGET: |
// do nothing for all of those |
break; |
case FLAGWAIT: |
// clear the flag variable |
ercd = clr_flg( 1, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd, tidy vp" ); |
break; |
case MEMFIXEDGET: |
if ( NULL != vp ) { |
ercd = rel_blf( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp" ); |
} |
if ( NULL != vp1 ) { |
ercd = rel_blf( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp1" ); |
} |
if ( NULL != t2vp ) { |
ercd = rel_blf( 1, t2vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy t2vp" ); |
} |
break; |
case MEMVARGET: |
if ( NULL != vp ) { |
ercd = rel_blk( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp" ); |
} |
if ( NULL != vp1 ) { |
ercd = rel_blk( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp1" ); |
} |
if ( NULL != t2vp ) { |
ercd = rel_blk( 1, t2vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy t2vp" ); |
} |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_recreate( WAITOP wait ) |
{ |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
static T_CSEM t_csem = { NULL, 0, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
static T_CMBX t_cmbx = { NULL, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
static T_CFLG t_cflg = { NULL, 0, 0 }; |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
static T_CMPF t_cmpf = { NULL, 0, 20, 95 }; |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
static T_CMPL t_cmpl = { NULL, 0, 2000 }; |
#endif |
ER ercd = E_OK; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
// do nothing for all of those |
break; |
case SEMGET: |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
// create the semaphore |
ercd = cre_sem( 1, &t_csem ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate SEMGET" ); |
#endif |
break; |
case FLAGWAIT: |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
// create the flag |
ercd = cre_flg( 1, &t_cflg ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate FLAGWAIT" ); |
#endif |
break; |
case MSGGET: |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
// create the mbox |
ercd = cre_mbx( 1, &t_cmbx ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MSGGET" ); |
#endif |
break; |
case MEMFIXEDGET: |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
// create the mempool |
ercd = cre_mpf( 1, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MEMFIXEDGET" ); |
#endif |
break; |
case MEMVARGET: |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
// create the mempool |
ercd = cre_mpl( 1, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_recreate MEMVARGET" ); |
#endif |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
// this is just to use ercd to prevent warnings |
CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" ); |
} |
|
|
|
void |
do_signal( WAITOP wait ) |
{ |
ER ercd; |
switch ( wait ) { |
case SLEEP: |
// send a wakeup |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
break; |
case DELAY: |
// simply wait for task 2's delay to complete |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
break; |
case SEMGET: |
// signal the semaphore |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
break; |
case FLAGWAIT: |
// set the flag bits |
ercd = set_flg( 1, 0xff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" ); |
break; |
case MSGGET: |
// send a message |
ercd = snd_msg( 1, msg ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
break; |
case MEMFIXEDGET: |
// release a couple of blocks we allocated earlier. I hope. |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
ercd = rel_blf( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
vp = NULL; |
ercd = rel_blf( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd1" ); |
vp1 = NULL; |
break; |
case MEMVARGET: |
// release a couple of blocks we allocated earlier. I hope. |
CYG_TEST_CHECK( NULL != vp, "no allocated block to free" ); |
CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" ); |
ercd = rel_blk( 1, vp ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
vp = NULL; |
ercd = rel_blk( 1, vp1 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd1" ); |
vp1 = NULL; |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void |
do_delete( WAITOP wait ) |
{ |
ER ercd = E_OK; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
CYG_TEST_FAIL( "bad call to do_delete( SLEEP or DELAY )" ); |
break; |
case SEMGET: |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
// delete the semaphore |
ercd = del_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( SEMGET )" ); |
#endif |
break; |
case FLAGWAIT: |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
// delete the flag |
ercd = del_flg( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( FLAGWAIT )" ); |
#endif |
break; |
case MSGGET: |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
// delete the mbox |
ercd = del_mbx( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MSGGET )" ); |
#endif |
break; |
case MEMFIXEDGET: |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
// delete the mempool |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MEMFIXEDGET )" ); |
#endif |
break; |
case MEMVARGET: |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
// delete the mempool |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
#else |
CYG_TEST_FAIL( "bad call to do_delete( MEMVARGET )" ); |
#endif |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
// this is just to use ercd to prevent warnings |
CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" ); |
} |
|
|
|
ER |
do_wait( WAITOP wait, WAITTYPE type ) |
{ |
switch ( wait ) { |
case SLEEP: |
return ( PLAIN == type ) ? slp_tsk() : tslp_tsk( T2_WAIT ); |
case DELAY: |
return dly_tsk( T2_WAIT ); // forget the type |
case SEMGET: |
return ( PLAIN == type ) ? wai_sem( 1 ) : twai_sem( 1, T2_WAIT ); |
case FLAGWAIT: |
return ( PLAIN == type ) ? |
wai_flg( &scratch, 1, 0x55, TWF_ANDW ) : |
twai_flg( &scratch, 1, 0xaa, TWF_ANDW, T2_WAIT ); |
case MSGGET: |
return ( PLAIN == type ) ? |
rcv_msg( &msg1, 1 ) : |
trcv_msg( &msg1, 1, T2_WAIT ); |
case MEMFIXEDGET: |
return ( PLAIN == type ) ? |
get_blf( &t2vp, 1 ) : |
tget_blf( &t2vp, 1, T2_WAIT ); |
case MEMVARGET: |
return ( PLAIN == type ) ? |
get_blk( &t2vp, 1, T2_MALLOC ) : |
tget_blk( &t2vp, 1, T2_MALLOC, T2_WAIT ); |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
CYG_TEST_FAIL( "Bad wait in do_wait" ); |
return E_SYS; |
} |
|
void |
check_waitstate( WAITOP wait, int waiting ) |
{ |
ER ercd; |
int waity = 0; |
switch ( wait ) { |
case SLEEP: |
case DELAY: |
return; // do nothing for these |
case SEMGET: { |
T_RSEM rsem; |
ercd = ref_sem( &rsem, 1 ); |
waity = rsem.wtsk; |
break; |
} |
case FLAGWAIT: { |
T_RFLG rflg; |
ercd = ref_flg( &rflg, 1 ); |
waity = rflg.wtsk; |
break; |
} |
case MSGGET: { |
T_RMBX rmbx; |
ercd = ref_mbx( &rmbx, 1 ); |
waity = rmbx.wtsk; |
break; |
} |
case MEMFIXEDGET: { |
T_RMPF rmpf; |
ercd = ref_mpf( &rmpf, 1 ); |
waity = rmpf.wtsk; |
break; |
} |
case MEMVARGET: { |
T_RMPL rmpl; |
ercd = ref_mpl( &rmpl, 1 ); |
waity = rmpl.wtsk; |
break; |
} |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
if ( waiting ) |
CYG_TEST_CHECK( waity, "Object has no task waiting!" ); |
else |
CYG_TEST_CHECK( !waity, "Object had a task waiting!" ); |
} |
|
// ======================================================================== |
void task1( unsigned int arg ) |
{ |
ER ercd; |
WAITOP wait; |
WAITTYPE type; |
KILLOP kill; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
{ |
extern Cyg_Thread cyg_uitron_TASKS[]; |
cyg_test_dump_thread_stack_stats( |
"Startup, task1", &cyg_uitron_TASKS[ 0 ] ); |
cyg_test_dump_thread_stack_stats( |
"Startup, task2", &cyg_uitron_TASKS[ 1 ] ); |
cyg_test_dump_interrupt_stack_stats( "Startup" ); |
cyg_test_dump_idlethread_stack_stats( "Startup" ); |
cyg_test_clear_interrupt_stack(); |
} |
|
ercd = chg_pri( 1, 8 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
for ( wait = START_WAITOP; wait < DONE_WAITOP ; wait++) { |
for ( type = START_TYPE; type < DONE_TYPE ; type++ ) { |
for ( kill = START_KILLOP; kill < DONE_KILLOP ; kill++ ) { |
|
// These clauses deal with a couple of special cases: |
// [doing it this way helps keep the rest of the code |
// nicely general and orthogonal] |
// |
// 1) DELAY: dly_tsk(): when this times out, the retcode is |
// E_OK rather than E_TMOUT, and it always times out. The |
// "signalling" method here is just to wait yourself. So we |
// do not test DELAY with TIMED type. |
// |
// 2) PLAIN tests with TIMEOUT kill operations: a PLAIN test |
// will not time out, it'll wait forever, so waiting for it |
// so to do is pointless; further, we would check for the |
// wrong error code. So we do not test PLAIN tests with |
// TIMOUT kill operations. |
// |
// 3) SLEEP or DELAY tests with DELETE operations: there is |
// no synchronization to delete in those cases. |
// 3a) Individual object types are tested for delete support, |
// and if there is none, the test is skipped. |
|
if ( DELAY == wait && TIMED == type ) |
continue; |
|
if ( PLAIN == type && |
( ( TIMEOUT == kill) || |
(SUSPEND_TIMEOUT_RESUME == kill) || |
(SUSPEND_TIMEOUT_KILL == kill) ) ) |
continue; |
|
if ( ( |
#ifndef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
(SEMGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
(FLAGWAIT == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
(MSGGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
(MEMFIXEDGET == wait) || |
#endif |
#ifndef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
(MEMVARGET == wait) || |
#endif |
(SLEEP == wait) || |
(DELAY == wait) |
) && |
((DELETE == kill) || |
(SUSPEND_DELETE_RESUME == kill) || |
(SUSPEND_DELETE_KILL == kill)) ) |
continue; |
|
|
CYG_TEST_INFO( makemsg( "T1: ", wait, type, kill ) ); |
|
intercom = 0; |
|
// prepare the synchronization objects |
// (actually, just empty the mempools) |
do_prep( wait ); |
|
// start task 2 at a higher priority than myself |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, task2arg( wait, type, kill ) ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
// task 2 should run now, until it waits. |
|
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_WAI == rtsk.tskstat, "bad tskstat" ); |
CYG_TEST_CHECK( 5 == rtsk.tskpri, "bad tskpri" ); |
|
switch ( kill ) { |
case SIGNAL: |
// signal the task appropriately |
do_signal( wait ); |
// it should now have run to completion |
break; |
case TIMEOUT: |
check_waitstate( wait, 1 ); |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
check_waitstate( wait, 0 ); |
// it should now have run to completion |
break; |
case RELEASE: |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// it should now have run to completion |
break; |
case DELETE: |
// delete the object appropriately |
do_delete( wait ); |
// it should now have run to completion |
break; |
case KILL: |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_SIGNAL_RESUME: |
// suspend the task |
do_suspend(); |
// signal the task appropriately |
do_signal( wait ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_TIMEOUT_RESUME: |
check_waitstate( wait, 1 ); |
// suspend the task |
do_suspend(); |
check_waitstate( wait, 1 ); |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
check_waitstate( wait, 0 ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_RELEASE_RESUME: |
// suspend the task |
do_suspend(); |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_DELETE_RESUME: |
// suspend the task |
do_suspend(); |
// delete the object appropriately |
do_delete( wait ); |
// resume the task |
do_resume(); |
// it should now have run to completion |
break; |
case SUSPEND_KILL: |
// suspend the task |
do_suspend(); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_SIGNAL_KILL: |
// suspend the task |
do_suspend(); |
// signal the task appropriately |
do_signal( wait ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_TIMEOUT_KILL: |
check_waitstate( wait, 1 ); |
// suspend the task |
do_suspend(); |
check_waitstate( wait, 1 ); |
// wait for the timeout to occur |
ercd = dly_tsk( T1_WAIT ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
check_waitstate( wait, 0 ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_RELEASE_KILL: |
// suspend the task |
do_suspend(); |
// hit the task with a release-wait |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "rel_wai bad ercd" ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
case SUSPEND_DELETE_KILL: |
// suspend the task |
do_suspend(); |
// delete the object appropriately |
do_delete( wait ); |
// kill the task |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
// it should now have terminated without running |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
|
// task 2 should be dormant now, however it got there |
ercd = ref_tsk( &rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_DMT == rtsk.tskstat, "bad tskstat" ); |
|
if ( (SUSPEND_SIGNAL_KILL == kill) && |
((MEMFIXEDGET == wait) || (MEMVARGET == wait)) ) { |
// it was a killed successful memory alloc, so we have |
// lost the pointer to memory allocated; there is an |
// implicit storeleak problem when the task trying |
// to allocate is signalled then killed. |
// Recreate the pointer from an old version: |
CYG_TEST_CHECK( NULL == t2vp, "t2vp WAS allocated!" ); |
t2vp = t2vp_backup; |
} |
|
switch ( kill ) { |
case KILL: |
case SUSPEND_KILL: |
case SUSPEND_SIGNAL_KILL: |
case SUSPEND_TIMEOUT_KILL: |
case SUSPEND_RELEASE_KILL: |
case SUSPEND_DELETE_KILL: |
// if task 2 was killed, expect only one increment |
CYG_TEST_CHECK( 1 == intercom, "intercom bad value !1" ); |
break; |
default: |
// otherwise expect two increments |
CYG_TEST_CHECK( 2 == intercom, "intercom bad value !2" ); |
break; |
} |
|
// tidy up or recreate the synchronization objects |
if ( (DELETE == kill) || |
(SUSPEND_DELETE_RESUME == kill) || |
(SUSPEND_DELETE_KILL == kill) ) |
do_recreate( wait ); |
else |
do_tidyup( wait ); |
} |
} |
} |
CYG_TEST_PASS("synchronization interaction tests"); |
|
{ |
extern Cyg_Thread cyg_uitron_TASKS[]; |
cyg_test_dump_thread_stack_stats( |
"All done, task1", &cyg_uitron_TASKS[ 0 ] ); |
cyg_test_dump_thread_stack_stats( |
"All done, task2", &cyg_uitron_TASKS[ 1 ] ); |
cyg_test_dump_interrupt_stack_stats( "All done" ); |
cyg_test_dump_idlethread_stack_stats( "All done" ); |
} |
// all done |
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
WAITOP wait; |
WAITTYPE waittype; |
KILLOP kill; |
|
decodearg( arg, &wait, &waittype, &kill ); |
|
// CYG_TEST_INFO( makemsg( " 2: ", wait, waittype, kill ) ); |
|
intercom++; |
ercd = do_wait( wait, waittype ); |
intercom++; |
|
switch ( kill ) { |
case SIGNAL: |
case SUSPEND_SIGNAL_RESUME: |
// we expect to have been signalled correctly |
CYG_TEST_CHECK( E_OK == ercd, "T2 wait bad ercd" ); |
// here we know that the op completed OK |
if ( (MEMFIXEDGET == wait) || (MEMVARGET == wait) ) { |
// it was a successful memory alloc of whichever type, |
// so we can save away a copy of t2vp for working round an |
// implicit storeleak problem when the task trying to allocate |
// is signalled then killed: |
CYG_TEST_CHECK( NULL != t2vp, "No t2vp allocated!" ); |
t2vp_backup = t2vp; |
} |
break; |
case TIMEOUT: |
case SUSPEND_TIMEOUT_RESUME: |
// we expect to have timed out - if it's a timeout op. |
CYG_TEST_CHECK( E_TMOUT == ercd, "T2 timeout bad ercd, !E_TMOUT" ); |
break; |
case RELEASE: |
case SUSPEND_RELEASE_RESUME: |
// we expect to have suffered a release wait. |
CYG_TEST_CHECK( E_RLWAI == ercd, "T2 release bad ercd, !E_RLWAI" ); |
break; |
case DELETE: |
case SUSPEND_DELETE_RESUME: |
// we expect to be told the object is gone |
CYG_TEST_CHECK( E_DLT == ercd, "T2 release bad ercd, !E_DLT" ); |
break; |
case KILL: |
case SUSPEND_KILL: |
case SUSPEND_SIGNAL_KILL: |
case SUSPEND_TIMEOUT_KILL: |
case SUSPEND_RELEASE_KILL: |
case SUSPEND_DELETE_KILL: |
// we expect to have been killed here, ie. this won't execute! |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
break; |
default: |
CYG_TEST_FAIL( "bad switch" ); |
break; |
} |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx7.cxx |
/v2_0/tests/testcxx.cxx
0,0 → 1,817
//=========================================================================== |
// |
// testcxx.cxx |
// |
// uITRON "C++" test program |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercom = 0; |
volatile int intercount = 0; |
INT scratch = 0; |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
|
#ifndef CYGSEM_KERNEL_SCHED_TIMESLICE |
#define TIMESLICEMSG "Assuming no kernel timeslicing" |
#define TSGO() (1) |
#define TSRELEASE() CYG_EMPTY_STATEMENT |
#define TSSTOP() CYG_EMPTY_STATEMENT |
#define TSLOCK() CYG_EMPTY_STATEMENT |
#define TSUNLOCK() CYG_EMPTY_STATEMENT |
#define ICWAIT( _i_ ) CYG_EMPTY_STATEMENT |
|
#else |
// Now follow some nasty bodges to control the scheduling when basically it |
// isn't controlled ie. timeslicing is on. It's bodgy because we're |
// testing normal synchronization methods, so we shouldn't rely on them for |
// comms between threads here. Instead there's a mixture of communicating |
// via a flag (ts_interlock) which stops the "controlled" thread running |
// away, and waiting for the controlled thread to run enough for us. |
// |
// Tasks 3 and 4 are waited for by the control task: task 3 locks the |
// scheduler so is immediately descheduled when it unlocks it, task 4 does |
// waiting-type operations, so we must give it chance to run by yielding a |
// few times ourselves. Note the plain constant in ICWAIT() below. |
|
#define TIMESLICEMSG "Assuming kernel timeslicing ENABLED" |
volatile int ts_interlock = 0; |
#define TSGO() (ts_interlock) |
#define TSRELEASE() ts_interlock = 1 |
#define TSSTOP() ts_interlock = 0 |
|
#define TSLOCK() CYG_MACRO_START \ |
ER ercd2 = dis_dsp(); \ |
CYG_TEST_CHECK( E_OK == ercd2, "dis_dsp (TSLOCK) bad ercd2" ); \ |
CYG_MACRO_END |
|
#define TSUNLOCK() CYG_MACRO_START \ |
ER ercd3 = ena_dsp(); \ |
CYG_TEST_CHECK( E_OK == ercd3, "ena_dsp (TSUNLOCK) bad ercd3" ); \ |
CYG_MACRO_END |
|
#define ICWAIT( _i_ ) CYG_MACRO_START \ |
int loops; \ |
for ( loops = 3; (0 < loops) || ((_i_) > intercount); loops-- ) { \ |
ER ercd4 = rot_rdq( 0 ); /* yield */ \ |
CYG_TEST_CHECK( E_OK == ercd4, "rot_rdq (ICWAIT) bad ercd4" ); \ |
} \ |
CYG_MACRO_END |
#endif // CYGSEM_KERNEL_SCHED_TIMESLICE |
|
/* |
#define IC() \ |
CYG_MACRO_START \ |
static char *msgs[] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "LOTS" }; \ |
CYG_TEST_INFO( msgs[ intercount > 5 ? 5 : intercount ] ); \ |
CYG_MACRO_END |
*/ |
|
// #define CYG_TEST_UITRON_TEST1_LOOPING 1 |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
T_RTSK ref_tskd; |
|
#ifdef CYG_TEST_UITRON_TEST1_LOOPING |
while ( 1 ) { |
#endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
CYG_TEST_INFO( "Task 1 running" ); |
CYG_TEST_INFO( TIMESLICEMSG ); |
|
intercom = 0; |
intercount = 0; |
|
CYG_TEST_INFO( "Testing get_tid and ref_tsk" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = get_tid( NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "get_tid bad ercd !E_PAR" ); |
#endif |
ercd = ref_tsk( &ref_tskd, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
ercd = ref_tsk( &ref_tskd, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = ref_tsk( NULL, 1 ); |
CYG_TEST_CHECK( E_PAR == ercd, "ref_tsk bad ercd !E_PAR" ); |
#endif |
#endif // we can test bad param error returns |
ercd = ref_tsk( &ref_tskd, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 1" ); |
ercd = ref_tsk( &ref_tskd, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 0" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
CYG_TEST_PASS( "get_tid, ref_tsk" ); |
|
CYG_TEST_INFO( "Testing prio change and start task" ); |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
// drop pri of task 2 |
ercd = chg_pri( 2, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( TTS_RDY == ref_tskd.tskstat, "Bad task status 2" ); |
CYG_TEST_CHECK( 4 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
// drop our pri below task 2 |
ercd = chg_pri( 0, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
ercd = ref_tsk( &ref_tskd, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 1" ); |
ercd = ref_tsk( &ref_tskd, 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 0" ); |
ercd = ref_tsk( &ref_tskd, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
// it will have run to completion and regained its original prio |
CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
|
// retest these now that the task has executed once |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = chg_pri( -6, 9 ); |
CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
ercd = chg_pri( 99, 9 ); |
CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
ercd = sta_tsk( -6, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
ercd = sta_tsk( 99, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "sta_tsk, chg_pri" ); |
|
CYG_TEST_INFO( "Testing delay and dispatch disabling" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
#endif // we can test bad param error returns |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
CYG_TEST_PASS( "dly_tsk, ena_dsp, dis_dsp" ); |
|
CYG_TEST_INFO( "Testing ready queue manipulation" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = rot_rdq( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = rot_rdq( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = rot_rdq( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
ercd = rot_rdq( 99 ); |
CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
|
CYG_TEST_PASS( "rot_rdq" ); |
|
CYG_TEST_INFO( "Testing suspend/resume" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = sus_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
ercd = sus_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
ercd = rsm_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
ercd = rsm_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
ercd = frsm_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
ercd = frsm_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// drop task 3 pri to same as us |
CYG_TEST_CHECK( 0 == intercount, "intercount != 0" ); |
|
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 3, 66 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 3, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 1 ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
ercd = sus_tsk( 3 ); |
TSRELEASE(); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 2 ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
CYG_TEST_INFO( "Command task 3 inner loop stop" ); |
intercom = 2 + 4; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
ercd = sus_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ercd = sus_tsk( 3 ); // suspend AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = sus_tsk( 3 ); // AND AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rsm_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = rsm_tsk( 3 ); // expect restart this time |
CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 3 ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
CYG_TEST_INFO( "Command task 3 inner loop stop 2" ); |
intercom = 2 + 4; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
ercd = sus_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
intercom = 0; // bad data to T3 |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
ercd = sus_tsk( 3 ); // suspend AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
ercd = sus_tsk( 3 ); // AND AGAIN |
CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
intercom = 3; // tell T3 to loop |
TSRELEASE(); |
ercd = frsm_tsk( 3 ); // expect restart this time |
CYG_TEST_CHECK( E_OK == ercd, "frsm_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 4 ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
TSRELEASE(); |
ercd = rsm_tsk( 3 ); // try it again |
CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk bad ercd !E_OBJ" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 5 ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
|
TSRELEASE(); |
ercd = frsm_tsk( 3 ); // try it again |
CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk bad ercd !E_OBJ" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 6 ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
CYG_TEST_INFO( "Command task 3 all loops stop" ); |
intercom = 4 + 8; |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
intercom = intercount = 0; |
|
CYG_TEST_PASS( "sus_tsk, rsm_tsk, frsm_tsk" ); |
|
CYG_TEST_INFO( "Testing sleep/wakeup stuff" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = wup_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = wup_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = can_wup( &scratch, -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
ercd = can_wup( &scratch, 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = can_wup( NULL, 2 ); |
CYG_TEST_CHECK( E_PAR == ercd, "can_wup bad ercd !E_PAR" ); |
#endif |
|
ercd = wup_tsk( 0 ); // not ourself |
CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
ercd = wup_tsk( 1 ); // ourself |
CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk bad ercd !E_OBJ" ); |
#endif // we can test bad param error returns |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = tslp_tsk( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = tslp_tsk( TMO_FEVR ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = tslp_tsk( -6 ); |
CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
#endif // we can test bad param error returns |
ercd = tslp_tsk( TMO_POL ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
ercd = tslp_tsk( 5 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
// drop task 4 pri to same as us |
intercount = 0; |
intercom = 1; // test plain slp_tsk |
TSRELEASE(); |
ercd = chg_pri( 4, 5 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "chg_pri bad ercd" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 4, 77 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 4, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
ercd = wup_tsk( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 1 ); |
CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
intercom = 2; // test tslp_tsk |
TSRELEASE(); |
ercd = wup_tsk( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 2 ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 3; // test tslp_tsk |
TSRELEASE(); |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
intercom = 1; // test slp_tsk next... |
ercd = dly_tsk( 20 ); // without a wup |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
ICWAIT( 3 ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
intercom = 1; // ...test slp_tsk |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // without a wup (yet) |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = tslp_tsk( 20 ); // yield again |
CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // and again |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); // and yield |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 4 ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
intercom = 1; // test slp_tsk |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // without a wup (yet) |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
// this wup will restart it when we yield: |
TSLOCK(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
// these will count up: |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
scratch = -1; |
ercd = can_wup( &scratch, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "Cancelled wups not 2" ); |
CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
TSUNLOCK(); |
|
intercom = 4; // do nothing |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // and yield |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 5 ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // let it do nothing |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = dly_tsk( 20 ); // lots of wups but no sleep |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
scratch = -1; |
ercd = can_wup( &scratch, 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "Cancelled wups not 3" ); |
// now check that they are cancelled by doing a wait again |
intercom = 1; // test slp_tsk |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
intercom = 4; // do nothing next |
TSRELEASE(); |
ICWAIT( 6 ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
ercd = rot_rdq( 0 ); // still without a wup |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
TSRELEASE(); |
ercd = wup_tsk( 4 ); // now issue a wup |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = rot_rdq( 0 ); // it will run now |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
TSRELEASE(); |
ercd = rot_rdq( 0 ); // it will run now |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 7 ); |
CYG_TEST_CHECK( 7 == intercount, "intercount != 7" ); |
|
TSRELEASE(); |
intercom = 99; // exit, all done |
ercd = rot_rdq( 0 ); // let it run |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
ICWAIT( 8 ); |
CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
TSRELEASE(); |
ercd = rot_rdq( 0 ); // let it run |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
CYG_TEST_PASS( "wup_tsk, can_wup, slp_tsk, tslp_tsk" ); |
|
#ifdef CYG_TEST_UITRON_TEST1_LOOPING |
chg_pri( 1, 1 ); |
rot_rdq( 0 ); |
ter_tsk( 2 ); |
rot_rdq( 0 ); |
ter_tsk( 3 ); |
rot_rdq( 0 ); |
ter_tsk( 4 ); |
rot_rdq( 0 ); |
} |
#endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_PASS( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 99 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 99" ); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 2 failed to exit" ); |
} |
|
void task3( unsigned int arg ) |
{ |
ER ercd; |
TSLOCK(); |
CYG_TEST_PASS("Task3 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
if ( 66 != arg ) |
CYG_TEST_FAIL( "Task 3 arg not 66" ); |
|
while ( 2 & intercom ) { |
while ( 1 & intercom ) { |
intercount++; |
TSSTOP(); |
do { |
TSUNLOCK(); |
ercd = rot_rdq( 0 ); // yield() |
TSLOCK(); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 1 (task3) bad ercd" ); |
} while ( !TSGO() ); |
} |
CYG_TEST_CHECK( 4 & intercom, "should not have got here yet 1" ); |
TSSTOP(); |
do { |
TSUNLOCK(); |
ercd = rot_rdq( 0 ); // yield() |
TSLOCK(); |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 2 (task3) bad ercd" ); |
} while ( !TSGO() ); |
} |
CYG_TEST_CHECK( 8 & intercom, "should not have got here yet 2" ); |
|
TSUNLOCK(); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 3 failed to exit" ); |
} |
|
void task4( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_PASS("Task4 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
if ( 77 != arg ) |
CYG_TEST_FAIL( "Task 4 arg not 77" ); |
while ( 1 ) { |
switch ( intercom ) { |
case 1: |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
break; |
case 2: |
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
break; |
case 3: |
ercd = tslp_tsk( 10 ); |
CYG_TEST_CHECK( E_TMOUT == ercd, |
"slp_tsk (task4) bad ercd !E_TMOUT" ); |
break; |
case 4: |
// busily do nothing |
while ( 4 == intercom ) { |
ercd = rot_rdq( 0 ); |
CYG_TEST_CHECK( E_OK == ercd, |
"rot_rdq (task4 idle) bad ercd" ); |
} |
break; |
case 99: |
goto out; |
default: |
CYG_TEST_FAIL( "Task 4 bad intercom" ); |
goto out; |
} |
intercount++; |
TSSTOP(); |
do { |
ercd = rot_rdq( 0 ); // yield() |
CYG_TEST_CHECK( E_OK == ercd, "rot_rdq (task4) bad ercd" ); |
} while ( !TSGO() ); |
} |
out: |
ext_tsk(); |
CYG_TEST_FAIL( "Task 4 failed to exit" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcxx.cxx |
/v2_0/tests/testcx8.cxx
0,0 → 1,395
//=========================================================================== |
// |
// testcx8.cxx |
// |
// uITRON "C++" test program eight |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-14 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough semaphores */ \ |
defined( CYGPKG_UITRON_SEMAS ) && \ |
(CYGNUM_UITRON_SEMAS >= 3) && \ |
(CYGNUM_UITRON_SEMAS < 90) && \ |
( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
volatile int intercount = 0; |
INT scratch; |
|
void newtask( unsigned int arg ); |
|
T_CTSK t_ctsk = { NULL, 0, (FP)&newtask, 1, CYGNUM_UITRON_STACK_SIZE }; |
T_RTSK t_rtsk; |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
// change us to prio 3 for flexibility |
ercd = chg_pri( 0, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
// first, check that we can delete a task: |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_tsk( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_tsk bad ercd !E_ID" ); |
ercd = del_tsk( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_tsk bad ercd !E_ID" ); |
ercd = cre_tsk( -6, &t_ctsk ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_tsk bad ercd !E_ID" ); |
ercd = cre_tsk( 99, &t_ctsk ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_tsk bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try a pre-existing object - ourselves! |
ercd = cre_tsk( 1, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try deleting an active task |
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
// Task 2 is now ready-to-run, lower prio than us |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
// Task 2 is now sleeping |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// try deleting a running task - ourselves! |
ercd = del_tsk( 1 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// terminate task 2; should then be OK to delete it |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
// and check it is deleted |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sta_tsk bad ercd !E_NOEXS" ); |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ter_tsk bad ercd !E_NOEXS" ); |
ercd = chg_pri( 2, 6 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "chg_pri bad ercd !E_NOEXS" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_wai bad ercd !E_NOEXS" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sus_tsk bad ercd !E_NOEXS" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rsm_tsk bad ercd !E_NOEXS" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "frsm_tsk bad ercd !E_NOEXS" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wup_tsk bad ercd !E_NOEXS" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "can_wup bad ercd !E_NOEXS" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "del_tsk bad ercd !E_NOEXS" ); |
// recreate task2, with the same function |
t_ctsk.task = (FP)&task2; |
t_ctsk.itskpri = 7; |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 7 == t_rtsk.tskpri, "Bad tskpri in new task2 !7" ); |
CYG_TEST_CHECK( TTS_DMT == t_rtsk.tskstat, |
"Bad tskstat in new task2 !TTS_DMT" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
// now start the task and do the same lot again... |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_tsk bad ercd !E_OBJ" ); |
// try deleting an active task |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
// Task 2 is now ready-to-run, lower prio than us |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
CYG_TEST_CHECK( 1 == intercount, "bad intercount !1" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
CYG_TEST_CHECK( 2 == intercount, "bad intercount !2" ); |
// Task 2 is now sleeping |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
CYG_TEST_CHECK( 7 == t_rtsk.tskpri, "Bad tskpri in new task2 !7" ); |
CYG_TEST_CHECK( TTS_WAI == t_rtsk.tskstat, |
"Bad tskstat in new task2 !TTS_WAI" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_OBJ == ercd, "del_tsk bad ercd !E_OBJ" ); |
// up its priority |
ercd = chg_pri( 2, 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
// awaken task 2; it will then exit-and-delete itself: |
CYG_TEST_CHECK( 2 == intercount, "bad intercount !2" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
// and check it is deleted |
ercd = sta_tsk( 2, 99 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sta_tsk bad ercd !E_NOEXS" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ter_tsk bad ercd !E_NOEXS" ); |
ercd = chg_pri( 2, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "chg_pri bad ercd !E_NOEXS" ); |
ercd = rel_wai( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_wai bad ercd !E_NOEXS" ); |
ercd = sus_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "sus_tsk bad ercd !E_NOEXS" ); |
ercd = rsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "rsm_tsk bad ercd !E_NOEXS" ); |
ercd = frsm_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "frsm_tsk bad ercd !E_NOEXS" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "wup_tsk bad ercd !E_NOEXS" ); |
ercd = can_wup( &scratch, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "can_wup bad ercd !E_NOEXS" ); |
ercd = ref_tsk( &t_rtsk, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = del_tsk( 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "del_tsk bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_tsk( 2, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_tsk bad ercd !E_PAR" ); |
#endif |
t_ctsk.stksz = 0x40000000; |
ercd = cre_tsk( 2, &t_ctsk ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_tsk bad ercd !E_NOMEM" ); |
t_ctsk.stksz = CYGNUM_UITRON_STACK_SIZE; |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
#endif // we can test bad param error returns |
|
ercd = del_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
t_ctsk.task = (FP)&task4; |
t_ctsk.itskpri = 9; |
ercd = cre_tsk( 3, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// check we can delete it again immediately |
ercd = del_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_tsk bad ercd" ); |
ercd = ref_tsk( &t_rtsk, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_tsk bad ercd !E_NOEXS" ); |
t_ctsk.task = (FP)&newtask; |
t_ctsk.itskpri = 1; |
ercd = cre_tsk( 3, &t_ctsk ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
CYG_TEST_CHECK( 3 == intercount, "bad intercount !3" ); |
ercd = sta_tsk( 3, 999 ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// it should have run now, and exited |
CYG_TEST_CHECK( 5 == intercount, "bad intercount !5" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
// and check that it will just run again... |
ercd = sta_tsk( 3, 999 ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_tsk bad ercd" ); |
// it should have run now, and exited |
CYG_TEST_CHECK( 7 == intercount, "bad intercount !7" ); |
ercd = wai_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
// all done. |
|
CYG_TEST_PASS("create/delete tasks"); |
|
// all done |
CYG_TEST_EXIT( "All done" ); |
#else // ! CYGPKG_UITRON_TASKS_CREATE_DELETE |
CYG_TEST_NA( "Tasks do not have create/delete enabled" ); |
#endif // ! CYGPKG_UITRON_TASKS_CREATE_DELETE |
ext_tsk(); |
} |
|
|
|
void newtask( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Newtask running" ); |
CYG_TEST_CHECK( 999 == arg, "Bad arg to newtask() !999" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == i, "tid not 3" ); |
intercount++; |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
intercount++; |
// and just return |
} |
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
intercount++; |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
intercount++; |
|
exd_tsk(); // if we are not killed first |
|
intercount++; // shouldn't happen |
} |
|
void task3( unsigned int arg ) |
{ |
CYG_TEST_FAIL( "How come I'm being run?" ); |
} |
|
void task4( unsigned int arg ) |
{ |
CYG_TEST_FAIL( "How come I'm being run?" ); |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx8.cxx |
/v2_0/tests/testcx9.cxx
0,0 → 1,492
//=========================================================================== |
// |
// testcx9.cxx |
// |
// uITRON "C++" test program nine |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-10-16 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* test configuration for enough fixed memory pools */ \ |
defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
\ |
/* test configuration for enough variable mempools */ \ |
defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
(CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
(CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
|
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
cyg_uitron_start(); |
} |
|
VP vp; |
|
T_CMPL t_cmpl = { NULL, 0, 1000 }; |
T_RMPL t_rmpl; |
T_CMPF t_cmpf = { NULL, 0, 10, 100 }; |
T_RMPF t_rmpf; |
|
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int tests = 0; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
ercd = dis_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
ercd = sta_tsk( 2, 22222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
ercd = ena_dsp(); |
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
ercd = dly_tsk( 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mpf( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); |
ercd = del_mpf( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); |
ercd = cre_mpf( -6, &t_cmpf ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); |
ercd = cre_mpf( 99, &t_cmpf ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
// [first get a valid block from it for the freeing test later] |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpf bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mpf( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
// check it is deleted |
ercd = rel_blf( 3, vp ); // vp did come from this pool |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blf bad ercd !E_NOEXS" ); |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
ercd = tget_blf( &vp, 3, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blf bad ercd !E_NOEXS" ); |
ercd = get_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = ref_mpf( &t_rmpf, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpf bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mpf( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" ); |
#endif |
t_cmpf.mpfatr = 0xfff; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpf bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
t_cmpf.mpfatr = 0; |
t_cmpf.mpfcnt = 10000; |
t_cmpf.blfsz = 100; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); |
t_cmpf.mpfcnt = 100; |
t_cmpf.blfsz = 100000; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); |
// now create it well |
t_cmpf.mpfatr = 0; |
t_cmpf.mpfcnt = 10; |
t_cmpf.blfsz = 100; |
ercd = cre_mpf( 3, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
// and check we can use it |
ercd = pget_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
ercd = tget_blf( &vp, 3, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
ercd = get_blf( &vp, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); |
ercd = rel_blf( 3, vp ); // vp did come from new pool |
CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
ercd = rel_blf( 3, vp ); // vp already freed |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
ercd = ref_mpf( &t_rmpf, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blf( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); |
// check they are deleted |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = pget_blf( &vp, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
|
// re-create and do it again |
t_cmpf.mpfcnt = 90; |
t_cmpf.blfsz = 20; |
ercd = cre_mpf( 1, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
t_cmpf.mpfcnt = 5; |
t_cmpf.blfsz = 200; |
ercd = cre_mpf( 2, &t_cmpf ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blf( &vp, 1 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blf( &vp, 2, 10 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); |
// check they are deleted |
ercd = tget_blf( &vp, 1, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); |
ercd = get_blf( &vp, 2 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete fixed mempools"); |
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
tests++; |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = del_mpl( -6 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); |
ercd = del_mpl( 99 ); |
CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); |
ercd = cre_mpl( -6, &t_cmpl ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); |
ercd = cre_mpl( 99, &t_cmpl ); |
CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); |
#endif // we can test bad param error returns |
// try a pre-existing object |
// [first get a valid block from it for the freeing test later] |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpl bad ercd !E_OBJ" ); |
// delete it so we can play |
ercd = del_mpl( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
// check it is deleted |
ercd = rel_blk( 3, vp ); // vp did come from this pool |
CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blk bad ercd !E_NOEXS" ); |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
ercd = tget_blk( &vp, 3, 100, 10 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blk bad ercd !E_NOEXS" ); |
ercd = get_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = ref_mpl( &t_rmpl, 3 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpl bad ercd !E_NOEXS" ); |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// now try creating it (badly) |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
ercd = cre_mpl( 3, NULL ); |
CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" ); |
#endif |
t_cmpl.mplatr = 0xfff; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpl bad ercd !E_RSATR" ); |
#endif // we can test bad param error returns |
t_cmpl.mplatr = 0; |
t_cmpl.mplsz = 100000000; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpl bad ercd" ); |
// now create it well |
t_cmpl.mplatr = 0; |
t_cmpl.mplsz = 1000; |
ercd = cre_mpl( 3, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
// and check we can use it |
ercd = pget_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
ercd = pget_blk( &vp, 3, 100000000 ); // way too large |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
ercd = tget_blk( &vp, 3, 100, 10 ); |
CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
ercd = get_blk( &vp, 3, 100 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" ); |
ercd = rel_blk( 3, vp ); // vp did come from new pool |
CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
ercd = rel_blk( 3, vp ); // vp already freed |
CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
ercd = ref_mpl( &t_rmpl, 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blk( &vp, 1, 100 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blk( &vp, 2, 100, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blk( &vp, 2, 100, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" ); |
// check they are deleted |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = pget_blk( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
|
// re-create and do it again |
ercd = cre_mpl( 1, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
ercd = cre_mpl( 2, &t_cmpl ); |
CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" ); |
|
// In order to wait on the pools, we must first consume all they have: |
while ( E_OK == (ercd = pget_blk( &vp, 1, 20 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
while ( E_OK == (ercd = tget_blk( &vp, 2, 400, 1 )) ) /* nothing */; |
CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
// now wait while task 2 deletes the wait objects |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = get_blk( &vp, 1, 200 ); |
CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" ); |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
ercd = tget_blk( &vp, 2, 500, 20 ); |
CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" ); |
// check they are deleted |
ercd = tget_blk( &vp, 1, 200, 1 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); |
ercd = get_blk( &vp, 2, 20 ); |
CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); |
|
CYG_TEST_PASS("create/delete variable mempools"); |
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
ercd = ter_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); |
ercd = dly_tsk( 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
// all done |
if ( 0 == tests ) { |
CYG_TEST_NA( "No objects have create/delete enabled" ); |
} |
else { |
CYG_TEST_EXIT( "All done" ); |
} |
ext_tsk(); |
} |
|
|
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
int i; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &i ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == i, "tid not 2" ); |
if ( 22222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 22222" ); |
|
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpf( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
ercd = del_mpl( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
// we expect task2 to be killed here |
CYG_TEST_FAIL( "Task 2 ran to completion!" ); |
} |
|
void task3( unsigned int arg ) |
{ |
} |
|
void task4( unsigned int arg ) |
{ |
} |
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testcx9.cxx |
/v2_0/tests/testintr.cxx
0,0 → 1,892
//=========================================================================== |
// |
// testintr.c |
// |
// uITRON "C" test program for ixxx_yyy interrupt safe operators |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors:hmt |
// Date: 1998-08-20 |
// Purpose: uITRON API testing |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/system.h> |
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
#include <cyg/infra/testcase.h> // testing infrastructure |
|
#ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
#ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
// we're OK if it's C++ or neither of those two is defined: |
#if defined( __cplusplus ) || \ |
(!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
!defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
// =================== TEST CONFIGURATION =================== |
#if \ |
/* test configuration for enough tasks */ \ |
(CYGNUM_UITRON_TASKS >= 4) && \ |
(CYGNUM_UITRON_TASKS < 90) && \ |
(CYGNUM_UITRON_START_TASKS == 1) && \ |
( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
\ |
/* the end of the large #if statement */ \ |
1 |
|
// ============================ END ============================ |
|
#include <cyg/hal/hal_arch.h> |
#include <cyg/hal/hal_intr.h> |
|
#include <cyg/infra/diag.h> |
|
#include <cyg/compat/uitron/uit_func.h> // uITRON |
#include <cyg/compat/uitron/uit_ifnc.h> // uITRON interrupt funcs |
|
void set_interrupt_number( void ); |
|
unsigned int clock_interrupt = 0; |
|
externC void |
cyg_package_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
set_interrupt_number(); |
cyg_uitron_start(); |
} |
|
extern "C" { |
void task1( unsigned int arg ); |
void task2( unsigned int arg ); |
void task3( unsigned int arg ); |
void task4( unsigned int arg ); |
} |
|
volatile int intercom = 0; |
INT scratch = 0; |
|
// Plan: replace (by direct intervention) the ISR and DSR of the regular |
// timer interrupt; be sure to ack the clock intr using the appropriate hal |
// macros. |
// |
// The new ISR(s) will simply use the interrupt-safe signalling functions |
// to control a 2nd task. Main task will check on the state thereof. |
// |
// We must test the ixxx_yyy() funcs with the scheduler already locked |
// also, by direct sched calls on the KAPI. This must verify that the |
// signal only happens when the scheduler unlocks. |
// |
// The 4 producer ops are: |
// iwup_tsk ( ID tskid ); |
// isig_sem ( ID semid ); |
// iset_flg ( ID flgid, UINT setptn ); |
// isnd_msg ( ID mbxid, T_MSG *pk_msg ); |
// |
// and return macros are: |
// ret_wup( ID tskid ); |
// ret_int(); |
// |
// These ISRs perform the producer ops on all available objects in turn. |
// Tasks 2-4 |
// Semas 1-4 |
// Flags 1-4 with marching bit data; they'll all be set to 0x1ff eventually |
// Mboxes 1-4 with an arbitrary pointer |
|
enum { |
NOTHING = 0, |
SLP, |
SEM, |
FLG, |
MBX, |
EXIT |
}; |
|
#define ACK_CLOCK() CYG_MACRO_START \ |
HAL_CLOCK_RESET( CYGNUM_HAL_INTERRUPT_RTC, \ |
CYGNUM_KERNEL_COUNTERS_RTC_PERIOD ); \ |
HAL_INTERRUPT_ACKNOWLEDGE( CYGNUM_HAL_INTERRUPT_RTC ); \ |
CYG_MACRO_END |
|
#define CHECK_TID() CYG_MACRO_START \ |
int my_tid; \ |
ER ercd; \ |
ercd = get_tid( &my_tid ); \ |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); \ |
CYG_TEST_CHECK( 0 == my_tid, "tid not 0 in ISR" ); \ |
CYG_MACRO_END |
|
|
unsigned int |
isr_wup_tsk( unsigned int vector, unsigned int data ) |
{ |
// Hit TASKS in range 2..4 |
static int wtid = 2; |
ACK_CLOCK(); |
CHECK_TID(); |
iwup_tsk( wtid ); |
wtid++; |
if ( 5 == wtid ) wtid = 2; |
ret_int(); |
} |
|
unsigned int |
isr_ret_wup( unsigned int vector, unsigned int data ) |
{ |
// Hit TASKS in range 2..4 |
static int rwid = 2; |
ACK_CLOCK(); |
CHECK_TID(); |
rwid++; |
if ( 6 == rwid ) rwid = 3; |
ret_wup( rwid - 1 ); |
} |
|
unsigned int |
isr_sig_sem( unsigned int vector, unsigned int data ) |
{ |
// Hit SEMAS in range 1..3 |
static int ssid = 1; |
ACK_CLOCK(); |
CHECK_TID(); |
isig_sem( ssid ); |
ssid++; |
if ( ssid == 4 ) ssid = 1; |
ret_int(); |
} |
|
unsigned int |
isr_set_flg( unsigned int vector, unsigned int data ) |
{ |
// Hit FLAGS in range 1..4 |
static int sfid = 1; |
static int sfdata = 0xff; |
ACK_CLOCK(); |
CHECK_TID(); |
iset_flg( sfid, sfdata ); |
sfid++; |
if ( sfid == 5 ) sfid = 1; |
// sfdata <<= 1; |
// if ( sfdata == 0x20 ) sfdata = 1; // so that eventually all 0x1f set |
ret_int(); |
} |
|
unsigned int |
isr_snd_msg( unsigned int vector, unsigned int data ) |
{ |
// Hit MBOXES in range 1..4 |
static int smid = 1; |
ACK_CLOCK(); |
CHECK_TID(); |
isnd_msg( smid, (T_MSG *)&smid ); |
smid++; |
if ( smid == 5 ) smid = 1; |
ret_int(); |
} |
|
|
void attach_isr( unsigned int (*isr)(unsigned int, unsigned int) ); |
void detach_isr( unsigned int (*isr)(unsigned int, unsigned int) ); |
|
void lock_sched( void ); |
void unlock_sched( void ); |
|
volatile int count = -1; |
|
/* |
#define BIGDELAY 50000000 |
#define SMALLDELAY (BIGDELAY/SMALLLOOPS) |
#define SMALLLOOPS 3 |
|
#define xxxLONGDELAY() \ |
do { \ |
int i; \ |
for ( i = 0; i < BIGDELAY; i++ ) \ |
if ( wakeups[ 4 ] > prewups[ 4 ] + 99 ) break; \ |
} while ( 0 ) |
|
#define xxxDELAYLOCKSCHED() \ |
do { \ |
int i,j; \ |
for ( j = 0; j < SMALLLOOPS; j++ ) { \ |
lock_sched(); \ |
for ( i = 0; i < SMALLDELAY; i++ ) \ |
if ( wakeups[ 4 ] > prewups[ 4 ] + 99 ) break; \ |
unlock_sched(); \ |
if ( wakeups[ 4 ] > prewups[ 4 ] + 99 ) break; \ |
} \ |
} while ( 0 ) |
*/ |
|
#define SMALLDELAYHW (5000000) |
#define EVENTSHW ( 20) |
#define SMALLDELAYSIM ( 100000) |
#define EVENTSSIM ( 4) |
|
#define SMALLDELAY (smalldelay) |
#define EVENTS (events) |
|
static int smalldelay = SMALLDELAYHW; |
static int events = EVENTSHW; |
|
#define LONGDELAY() do { \ |
count = 0; \ |
do count++; while ( wakeups[ 4 ] < prewups[ 4 ] + EVENTS ); \ |
} while ( 0 ) |
|
|
#define DELAYLOCKSCHED() \ |
do { \ |
count = 0; \ |
int i; \ |
do { \ |
lock_sched(); \ |
for ( i = 0; i < SMALLDELAY; i++ ) { \ |
count++; \ |
if ( wakeups[ 4 ] >= prewups[ 4 ] + EVENTS ) \ |
break; \ |
} \ |
unlock_sched(); \ |
CYG_TEST_INFO(" [Still iterating, please wait....] "); \ |
} while ( wakeups[ 4 ] < prewups[ 4 ] + EVENTS ); \ |
} while ( 0 ) |
|
#define DELAY() \ |
if ( 1 & loops ) \ |
DELAYLOCKSCHED(); \ |
else \ |
LONGDELAY(); |
|
|
volatile int wakeups[ 5 ] = { 0,0,0,0,0 }; |
volatile int prewups[ 5 ] = { 0,0,0,0,0 }; |
|
|
void task1( unsigned int arg ) |
{ |
ER ercd; |
int loops; |
|
CYG_TEST_INFO( "Task 1 running" ); |
|
if ( cyg_test_is_simulator ) { |
// take less time |
events = EVENTSSIM; |
} |
|
|
// First test that dis_int() and ena_int() work for the clock interrupt |
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
ercd = ena_int( 123456789 ); // Hope this is large enough to error |
CYG_TEST_CHECK( E_PAR == ercd, "ena_int bad ercd !E_PAR" ); |
ercd = dis_int( 123456789 ); |
CYG_TEST_CHECK( E_PAR == ercd, "dis_int bad ercd !E_PAR" ); |
#endif |
|
// This may take too long on a sim... |
// On the synthetic target this test cannot run reliably - the |
// loop counting assumes exclusive access to the processor. |
#ifndef CYGPKG_HAL_SYNTH |
if ( ! cyg_test_is_simulator ) { |
SYSTIME t1, t2; |
|
CYG_TEST_INFO( "Testing masking of clock interrupt" ); |
|
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
|
// Wait for a tick. This loop acts as a synchronizer for the loop |
// below, ensuring that it starts just after a tick. |
for ( loops = 0; loops < 10000000; loops++ ) { |
ercd = get_tim( &t2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
// Wait for next tick. Reset loops counter so we get the |
// approximate loop count of one clock tick. |
for ( loops = 0; loops < 10000000; loops++ ) { |
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
|
// save how many loops could be executed in one tick. Multiply |
// with 3 : we run loops in pairs below and add the time of |
// one extra to avoid small variations to trigger failures. |
intercom = loops * 3; |
|
ercd = ena_int( clock_interrupt ); // was initialized already |
CYG_TEST_CHECK( E_OK == ercd, "ena_int bad ercd" ); |
|
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
|
// Wait for a tick |
for ( loops = intercom; loops > 0; loops-- ) { |
ercd = get_tim( &t2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
CYG_TEST_CHECK( 0 < loops, "No first tick" ); |
// and a second one |
for ( ; loops > 0; loops-- ) { |
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
CYG_TEST_CHECK( 0 < loops, "No second tick" ); |
|
// The PowerPC cannot disable the timer interrupt (separately). |
#ifndef CYGPKG_HAL_POWERPC |
ercd = dis_int( clock_interrupt ); // was initialized already |
CYG_TEST_CHECK( E_OK == ercd, "dis_int bad ercd" ); |
|
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
|
// Wait for a tick (should not happen) |
for ( loops = intercom; loops > 0; loops-- ) { |
ercd = get_tim( &t2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
CYG_TEST_CHECK( 0 == loops, "A tick occured - should be masked" ); |
CYG_TEST_CHECK( t1 == t2, "Times are different" ); |
|
// Now enable it again and ensure all is well: |
ercd = ena_int( clock_interrupt ); |
CYG_TEST_CHECK( E_OK == ercd, "ena_int bad ercd" ); |
#endif |
|
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
|
// Wait for a tick |
for ( loops = intercom; loops > 0; loops-- ) { |
ercd = get_tim( &t2 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
CYG_TEST_CHECK( 0 < loops, "No first tick" ); |
// and a second one |
for ( ; loops > 0; loops-- ) { |
ercd = get_tim( &t1 ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tim bad ercd" ); |
if ( t2 != t1 ) |
break; |
} |
CYG_TEST_CHECK( 0 < loops, "No second tick" ); |
|
CYG_TEST_PASS( "dis_int(), ena_int() OK" ); |
} |
#endif |
|
intercom = 0; |
|
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
// start all other tasks (our prio is 1 by default) |
ercd = sta_tsk( 2, 222 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk 2 bad ercd" ); |
ercd = sta_tsk( 3, 333 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk 3 bad ercd" ); |
ercd = sta_tsk( 4, 444 ); |
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk 4 bad ercd" ); |
// drop pri of other tasks all to 5 |
ercd = chg_pri( 2, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri 2 bad ercd" ); |
ercd = chg_pri( 3, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri 3 bad ercd" ); |
ercd = chg_pri( 4, 5 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri 4 bad ercd" ); |
|
// Test sleep/wakeup |
intercom = SLP; |
// Drop our prio to lower; they will run in turn until asleep |
ercd = chg_pri( 1, 6 ); |
CYG_TEST_CHECK( E_OK == ercd, "chg_pri 1 (self) bad ercd" ); |
|
loops = 4; |
do { |
|
if ( 1 & loops ) |
CYG_TEST_INFO( " (toggling scheduler lock) " ); |
else |
CYG_TEST_INFO( " (unlocked scheduler) " ); |
|
|
CYG_TEST_CHECK( 0 == wakeups[0], "init: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "init: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] == wakeups[2], "init: Wakeups[2] hit" ); |
CYG_TEST_CHECK( prewups[3] == wakeups[3], "init: Wakeups[3] hit" ); |
CYG_TEST_CHECK( prewups[4] == wakeups[4], "init: Wakeups[4] hit" ); |
|
// -------- TIMERS AND TIMESLICING DISABLED --------- |
// install an isr that will wake them all up in turn |
attach_isr( isr_wup_tsk ); |
DELAY(); |
detach_isr( isr_wup_tsk ); |
// -------- timers and timeslicing ENABLED --------- |
|
CYG_TEST_CHECK( 0 == wakeups[0], "iwup_tsk: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "iwup_tsk: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] < wakeups[2], "iwup_tsk: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] < wakeups[3], "iwup_tsk: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] < wakeups[4], "iwup_tsk: Wakeups[4] not hit" ); |
diag_printf( "INFO:<(fg loops %10d) thread wakeups : %2d %2d %2d >\n", count, |
wakeups[2] - prewups[2], |
wakeups[3] - prewups[3], |
wakeups[4] - prewups[4] ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// -------- TIMERS AND TIMESLICING DISABLED --------- |
// install an isr that will wake them all up in turn |
attach_isr( isr_ret_wup ); |
DELAY(); |
detach_isr( isr_ret_wup ); |
// -------- timers and timeslicing ENABLED --------- |
|
CYG_TEST_CHECK( 0 == wakeups[0], "ret_wup: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "ret_wup: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] < wakeups[2], "ret_wup: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] < wakeups[3], "ret_wup: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] < wakeups[4], "ret_wup: Wakeups[4] not hit" ); |
diag_printf( "INFO:<(fg loops %10d) thread ret_wups: %2d %2d %2d >\n", count, |
wakeups[2] - prewups[2], |
wakeups[3] - prewups[3], |
wakeups[4] - prewups[4] ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// move them on to waiting for a semaphore |
intercom = SEM; |
ercd = wup_tsk( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk(2) bad ercd" ); |
ercd = wup_tsk( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk(3) bad ercd" ); |
ercd = wup_tsk( 4 ); |
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk(4) bad ercd" ); |
|
CYG_TEST_CHECK( 0 == wakeups[0], "wup_tsk: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "wup_tsk: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "wup_tsk: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "wup_tsk: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "wup_tsk: Wakeups[4] not hit" ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// -------- TIMERS AND TIMESLICING DISABLED --------- |
// install an isr that will wake them all up in turn |
attach_isr( isr_sig_sem ); |
DELAY(); |
detach_isr( isr_sig_sem ); |
// -------- timers and timeslicing ENABLED --------- |
|
CYG_TEST_CHECK( 0 == wakeups[0], "isig_sem: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "isig_sem: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] < wakeups[2], "isig_sem: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] < wakeups[3], "isig_sem: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] < wakeups[4], "isig_sem: Wakeups[4] not hit" ); |
diag_printf( "INFO:<(fg loops %10d) semaphore waits: %2d %2d %2d >\n", count, |
wakeups[2] - prewups[2], |
wakeups[3] - prewups[3], |
wakeups[4] - prewups[4] ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// move them on to waiting for a flag |
intercom = FLG; |
ercd = sig_sem( 1 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem(1) bad ercd" ); |
ercd = sig_sem( 2 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem(2) bad ercd" ); |
ercd = sig_sem( 3 ); |
CYG_TEST_CHECK( E_OK == ercd, "sig_sem(3) bad ercd" ); |
|
CYG_TEST_CHECK( 0 == wakeups[0], "sig_sem: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "sig_sem: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "sig_sem: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "sig_sem: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "sig_sem: Wakeups[4] not hit" ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// -------- TIMERS AND TIMESLICING DISABLED --------- |
// install an isr that will wake them all up in turn |
attach_isr( isr_set_flg ); |
DELAY(); |
detach_isr( isr_set_flg ); |
// -------- timers and timeslicing ENABLED --------- |
|
CYG_TEST_CHECK( 0 == wakeups[0], "iset_flg: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "iset_flg: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] < wakeups[2], "iset_flg: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] < wakeups[3], "iset_flg: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] < wakeups[4], "iset_flg: Wakeups[4] not hit" ); |
diag_printf( "INFO:<(fg loops %10d) flag waits/sets: %2d %2d %2d >\n", count, |
wakeups[2] - prewups[2], |
wakeups[3] - prewups[3], |
wakeups[4] - prewups[4] ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// move them on to waiting for a message box |
intercom = MBX; |
ercd = set_flg( 2, 0xfff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg(2) bad ercd" ); |
ercd = set_flg( 3, 0xfff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg(3) bad ercd" ); |
ercd = set_flg( 4, 0xfff ); |
CYG_TEST_CHECK( E_OK == ercd, "set_flg(4) bad ercd" ); |
|
CYG_TEST_CHECK( 0 == wakeups[0], "set_flg: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "set_flg: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "set_flg: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "set_flg: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "set_flg: Wakeups[4] not hit" ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// -------- TIMERS AND TIMESLICING DISABLED --------- |
// install an isr that will wake them all up in turn |
attach_isr( isr_snd_msg ); |
DELAY(); |
detach_isr( isr_snd_msg ); |
// -------- timers and timeslicing ENABLED --------- |
|
CYG_TEST_CHECK( 0 == wakeups[0], "isnd_msg: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "isnd_msg: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] < wakeups[2], "isnd_msg: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] < wakeups[3], "isnd_msg: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] < wakeups[4], "isnd_msg: Wakeups[4] not hit" ); |
diag_printf( "INFO:<(fg loops %10d) message rec'pts: %2d %2d %2d >\n", count, |
wakeups[2] - prewups[2], |
wakeups[3] - prewups[3], |
wakeups[4] - prewups[4] ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
// move them on to exiting, all done |
if ( 1 == loops ) |
// then we are about to exit |
intercom = EXIT; |
else |
intercom = SLP; |
ercd = snd_msg( 2, (T_MSG *)&intercom ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg(2) bad ercd" ); |
ercd = snd_msg( 3, (T_MSG *)&intercom ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg(3) bad ercd" ); |
ercd = snd_msg( 4, (T_MSG *)&intercom ); |
CYG_TEST_CHECK( E_OK == ercd, "snd_msg(4) bad ercd" ); |
|
CYG_TEST_CHECK( 0 == wakeups[0], "snd_msg: Wakeups[0] hit" ); |
CYG_TEST_CHECK( 0 == wakeups[1], "snd_msg: Wakeups[1] hit" ); |
CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "snd_msg: Wakeups[2] not hit" ); |
CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "snd_msg: Wakeups[3] not hit" ); |
CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "snd_msg: Wakeups[4] not hit" ); |
prewups[2] = wakeups[2]; |
prewups[3] = wakeups[3]; |
prewups[4] = wakeups[4]; |
|
CYG_TEST_PASS( "Tested ISR invoked uITRON functions" ); |
|
} while ( 0 < --loops ); |
|
CYG_TEST_EXIT( "All done" ); |
ext_tsk(); |
} |
|
|
void body( int n ) |
{ |
unsigned int z; |
ER ercd; |
T_MSG *pk_msg; |
|
do { |
switch ( intercom ) { |
case NOTHING: |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (doing nothing)" ); |
continue; |
case SLP: |
ercd = slp_tsk(); |
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" ); |
wakeups[ n ]++; |
break; |
case SEM: |
ercd = wai_sem( n-1 ); // 1..3 for semas |
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
wakeups[ n ]++; |
break; |
case FLG: |
ercd = wai_flg( &z, n, (1<<n), TWF_CLR | TWF_ANDW ); |
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
CYG_TEST_CHECK( z & (1<<n), "Flag bit not set" ); |
wakeups[ n ]++; |
break; |
case MBX: |
ercd = rcv_msg( &pk_msg, n ); |
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
CYG_TEST_CHECK( pk_msg, "rcv_msg NULL msg" ); |
wakeups[ n ]++; |
break; |
case EXIT: |
return; |
} |
} while ( 1 ); |
} |
|
void task2( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_INFO( "Task 2 running" ); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
if ( 222 != arg ) |
CYG_TEST_FAIL( "Task 2 arg not 222" ); |
body(2); |
CYG_TEST_INFO( "Task 2 exiting" ); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 2 failed to exit" ); |
} |
|
void task3( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_INFO("Task 3 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
if ( 333 != arg ) |
CYG_TEST_FAIL( "Task 3 arg not 333" ); |
body(3); |
CYG_TEST_INFO( "Task 3 exiting" ); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 3 failed to exit" ); |
} |
|
void task4( unsigned int arg ) |
{ |
ER ercd; |
CYG_TEST_INFO("Task 4 running"); |
ercd = get_tid( &scratch ); |
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
if ( 444 != arg ) |
CYG_TEST_FAIL( "Task 4 arg not 444" ); |
body(4); |
CYG_TEST_INFO( "Task 4 exiting" ); |
ext_tsk(); |
CYG_TEST_FAIL( "Task 4 failed to exit" ); |
} |
|
// ------------------------------------------------------------------------ |
// Start of C++ aware portion, so to speak. |
// |
|
#include <cyg/hal/hal_intr.h> |
#include <cyg/kernel/intr.hxx> |
#include <cyg/kernel/clock.hxx> |
#include <cyg/kernel/sched.hxx> |
#include <cyg/kernel/sched.inl> |
|
void set_interrupt_number( void ) |
{ |
clock_interrupt = CYGNUM_HAL_INTERRUPT_RTC; |
} |
|
// This snippet stolen from kernel/.../clock.cxx to be able to detach |
// the RTC from its interrupt source. |
class Cyg_RealTimeClock |
: public Cyg_Clock |
{ |
public: |
Cyg_Interrupt interrupt; |
|
static cyg_uint32 isr(cyg_vector vector, CYG_ADDRWORD data); |
|
static void dsr(cyg_vector vector, cyg_ucount32 count, CYG_ADDRWORD data); |
|
Cyg_RealTimeClock(); |
}; |
|
|
static Cyg_Interrupt uit_intr( |
(unsigned)CYGNUM_HAL_INTERRUPT_RTC, // Vector to attach to |
0, // Queue priority |
(unsigned)0, // Data pointer |
&isr_wup_tsk, // Interrupt Service Routine |
&cyg_uitron_dsr // Deferred Service Routine |
); |
|
void |
attach_isr( unsigned int (*isr)(unsigned int, unsigned int) ) |
{ |
int inuse; |
int old_ints; |
Cyg_RealTimeClock *prtc = (Cyg_RealTimeClock *)Cyg_Clock::real_time_clock; |
HAL_DISABLE_INTERRUPTS(old_ints); |
HAL_INTERRUPT_MASK( CYGNUM_HAL_INTERRUPT_RTC ); |
prtc->interrupt.detach(); |
#ifndef CYGIMP_KERNEL_INTERRUPTS_CHAIN |
// Only check that the vector was cleared when there's a specific |
// vector for the RTC. In chain mode, other interrupt handlers |
// may prevent the shared vector from being cleared when detaching |
// the RTC ISR, and this assertion fails. |
HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse ); |
CYG_TEST_CHECK( !inuse, "Failed to detach clock ISR" ); |
#endif |
uit_intr = Cyg_Interrupt( |
CYGNUM_HAL_INTERRUPT_RTC, // Vector to attach to |
1, // Queue priority |
0, // Data pointer |
isr, // Interrupt Service Routine |
cyg_uitron_dsr // Deferred Service Routine |
); |
uit_intr.attach(); |
HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse ); |
CYG_TEST_CHECK( inuse, "Failed to attach new ISR" ); |
ACK_CLOCK(); |
HAL_INTERRUPT_UNMASK( CYGNUM_HAL_INTERRUPT_RTC ); |
HAL_RESTORE_INTERRUPTS(old_ints); |
} |
|
void |
detach_isr( unsigned int (*isr)(unsigned int, unsigned int) ) |
{ |
int inuse; |
int old_ints; |
Cyg_RealTimeClock *prtc = (Cyg_RealTimeClock *)Cyg_Clock::real_time_clock; |
HAL_DISABLE_INTERRUPTS(old_ints); |
HAL_INTERRUPT_MASK( CYGNUM_HAL_INTERRUPT_RTC ); |
uit_intr.detach(); |
#ifndef CYGIMP_KERNEL_INTERRUPTS_CHAIN |
// See comment above in attach_isr. |
HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse ); |
CYG_TEST_CHECK( !inuse, "Failed to detach my ISR" ); |
#endif |
prtc->interrupt.attach(); |
HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse ); |
CYG_TEST_CHECK( inuse, "Failed to attach clock ISR" ); |
ACK_CLOCK(); |
HAL_INTERRUPT_UNMASK( CYGNUM_HAL_INTERRUPT_RTC ); |
HAL_RESTORE_INTERRUPTS(old_ints); |
} |
|
|
void |
lock_sched( void ) |
{ |
cyg_uint32 l; |
Cyg_Scheduler::lock(); |
l = Cyg_Scheduler::get_sched_lock(); |
CYG_TEST_CHECK( 0 < l, "lock: Sched not locked" ); |
CYG_TEST_CHECK( 2 > l, "lock: Sched already locked" ); |
} |
|
void |
unlock_sched( void ) |
{ |
cyg_uint32 l; |
l = Cyg_Scheduler::get_sched_lock(); |
CYG_TEST_CHECK( 0 < l, "unlock: Sched not locked" ); |
CYG_TEST_CHECK( 2 > l, "unlock: Sched already locked" ); |
Cyg_Scheduler::unlock(); |
} |
|
|
#else // not enough (or too many) uITRON objects configured in |
#define N_A_MSG "not enough uITRON objects to run test" |
#endif // not enough (or too many) uITRON objects configured in |
#else // not C++ and some C++ specific options enabled |
#define N_A_MSG "C++ specific options selected but this is C" |
#endif // not C++ and some C++ specific options enabled |
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
#else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
#endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
#else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
#else // ! CYGPKG_UITRON |
#define N_A_MSG "uITRON Compatibility layer disabled" |
#endif // CYGPKG_UITRON |
|
#ifdef N_A_MSG |
externC void |
cyg_start( void ) |
{ |
CYG_TEST_INIT(); |
CYG_TEST_NA( N_A_MSG ); |
} |
#endif // N_A_MSG defined ie. we are N/A. |
|
// EOF testintr.c |
/v2_0/include/uit_ifnc.inl
0,0 → 1,218
#ifndef CYGONCE_COMPAT_UITRON_UIT_IFNC_INL |
#define CYGONCE_COMPAT_UITRON_UIT_IFNC_INL |
//=========================================================================== |
// |
// uit_ifnc.inl |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1999-08-16 |
// Purpose: uITRON compatibility functions |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#ifdef CYGPKG_UITRON |
|
#ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
class Cyg_Uit_Action { |
public: |
typedef enum { |
WUP_TSK, |
SIG_SEM, |
SET_FLG, |
SND_MSG |
} action; |
}; |
|
extern volatile int cyg_uit_dsr_actions_head; |
extern volatile int cyg_uit_dsr_actions_tail; |
|
#define CYGNUM_UITRON_ISR_ACTION_QUEUEMASK (CYGNUM_UITRON_ISR_ACTION_QUEUESIZE-1) |
|
#if ((~CYGNUM_UITRON_ISR_ACTION_QUEUEMASK) & \ |
~((~CYGNUM_UITRON_ISR_ACTION_QUEUEMASK)-1)) \ |
!= CYGNUM_UITRON_ISR_ACTION_QUEUESIZE |
#error CYGNUM_UITRON_ISR_ACTION_QUEUESIZE not a power of 2 |
#endif |
|
extern Cyg_Uit_Action::action |
cyg_uit_dsr_actions[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
extern ID |
cyg_uit_dsr_act_ids[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
extern CYG_ADDRWORD |
cyg_uit_dsr_act_a1s[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
CYG_UIT_FUNC_INLINE |
ER |
iwup_tsk ( ID tskid ) |
{ |
#ifdef CYGSEM_UITRON_ISRFUNCS_TRY_IMMEDIATE_EXECUTION |
if ( 1 >= Cyg_Scheduler::get_sched_lock() ) { |
// then this ISR is the first one, and the sched was locked by the |
// interrupt code. So this is safe. |
return wup_tsk( tskid ); |
} |
#endif |
|
register int i, head; |
i = cyg_uit_dsr_actions_head; |
head = CYGNUM_UITRON_ISR_ACTION_QUEUEMASK & ( 1 + i ); |
// If interrupts can be recursive, then there is a race here where a |
// slot may be overwritten by a recursive interrupt, or actions from |
// such lost; better though than having a slot contain *mixed* data |
// from two intermingled interrupts. |
if ( head != cyg_uit_dsr_actions_tail ) { |
cyg_uit_dsr_actions_head = head; |
cyg_uit_dsr_actions[ i ] = Cyg_Uit_Action::WUP_TSK; |
cyg_uit_dsr_act_ids[ i ] = tskid; |
} |
return E_OK; |
} |
|
#ifdef CYGPKG_UITRON_SEMAS |
#if 0 < CYG_UITRON_NUM( SEMAS ) |
CYG_UIT_FUNC_INLINE |
ER |
isig_sem ( ID semid ) |
{ |
#ifdef CYGSEM_UITRON_ISRFUNCS_TRY_IMMEDIATE_EXECUTION |
if ( 1 >= Cyg_Scheduler::get_sched_lock() ) { |
// then this ISR is the first one, and the sched was locked by the |
// interrupt code. So this is safe. |
return sig_sem( semid ); |
} |
#endif |
|
register int i, head; |
i = cyg_uit_dsr_actions_head; |
head = CYGNUM_UITRON_ISR_ACTION_QUEUEMASK & ( 1 + i ); |
// If interrupts can be recursive, then there is a race here where a |
// slot may be overwritten by a recursive interrupt, or actions from |
// such lost; better though than having a slot contain *mixed* data |
// from two intermingled interrupts. |
if ( head != cyg_uit_dsr_actions_tail ) { |
cyg_uit_dsr_actions_head = head; |
cyg_uit_dsr_actions[ i ] = Cyg_Uit_Action::SIG_SEM; |
cyg_uit_dsr_act_ids[ i ] = semid; |
} |
return E_OK; |
} |
#endif // 0 < CYG_UITRON_NUM( SEMAS ) |
#endif // CYGPKG_UITRON_SEMAS |
|
#ifdef CYGPKG_UITRON_FLAGS |
#if 0 < CYG_UITRON_NUM( FLAGS ) |
CYG_UIT_FUNC_INLINE |
ER |
iset_flg ( ID flgid, UINT setptn ) |
{ |
#ifdef CYGSEM_UITRON_ISRFUNCS_TRY_IMMEDIATE_EXECUTION |
if ( 1 >= Cyg_Scheduler::get_sched_lock() ) { |
// then this ISR is the first one, and the sched was locked by the |
// interrupt code. So this is safe. |
return set_flg( flgid, setptn ); |
} |
#endif |
|
register int i, head; |
i = cyg_uit_dsr_actions_head; |
head = CYGNUM_UITRON_ISR_ACTION_QUEUEMASK & ( 1 + i ); |
// If interrupts can be recursive, then there is a race here where a |
// slot may be overwritten by a recursive interrupt, or actions from |
// such lost; better though than having a slot contain *mixed* data |
// from two intermingled interrupts. |
if ( head != cyg_uit_dsr_actions_tail ) { |
cyg_uit_dsr_actions_head = head; |
cyg_uit_dsr_actions[ i ] = Cyg_Uit_Action::SET_FLG; |
cyg_uit_dsr_act_ids[ i ] = flgid; |
cyg_uit_dsr_act_a1s[ i ] = (CYG_ADDRWORD)setptn; |
} |
return E_OK; |
} |
#endif // 0 < CYG_UITRON_NUM( FLAGS ) |
#endif // CYGPKG_UITRON_FLAGS |
|
#ifdef CYGPKG_UITRON_MBOXES |
#if 0 < CYG_UITRON_NUM( MBOXES ) |
CYG_UIT_FUNC_INLINE |
ER |
isnd_msg ( ID mbxid, T_MSG *pk_msg ) |
{ |
#ifdef CYGSEM_UITRON_ISRFUNCS_TRY_IMMEDIATE_EXECUTION |
if ( 1 >= Cyg_Scheduler::get_sched_lock() ) { |
// then this ISR is the first one, and the sched was locked by the |
// interrupt code. So this is safe. |
return snd_msg( mbxid, pk_msg ); |
} |
#endif |
|
register int i, head; |
i = cyg_uit_dsr_actions_head; |
head = CYGNUM_UITRON_ISR_ACTION_QUEUEMASK & ( 1 + i ); |
// If interrupts can be recursive, then there is a race here where a |
// slot may be overwritten by a recursive interrupt, or actions from |
// such lost; better though than having a slot contain *mixed* data |
// from two intermingled interrupts. |
if ( head != cyg_uit_dsr_actions_tail ) { |
cyg_uit_dsr_actions_head = head; |
cyg_uit_dsr_actions[ i ] = Cyg_Uit_Action::SND_MSG; |
cyg_uit_dsr_act_ids[ i ] = mbxid; |
cyg_uit_dsr_act_a1s[ i ] = (CYG_ADDRWORD)pk_msg; |
} |
return E_OK; |
} |
#endif // 0 < CYG_UITRON_NUM( MBOXES ) |
#endif // CYGPKG_UITRON_MBOXES |
|
// ======================================================================== |
|
#endif // CYGPKG_UITRON |
|
#endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_IFNC_INL |
//EOF uit_ifnc.inl |
/v2_0/include/uit_func.h
0,0 → 1,402
#ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_H |
#define CYGONCE_COMPAT_UITRON_UIT_FUNC_H |
//=========================================================================== |
// |
// uit_func.h |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON compatibility functions |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
// ------------------------------------------------------------------------ |
// Source Code Organization |
// |
// First, see pkgconf/uitron.h for details of applicable configuration |
// options. |
// |
// This file uit_func.h provides prototypes for the uITRON API. All the |
// uITRON functions are listed here. The prototypes are configurable |
// either to have C or C++ linkage, and if being compiled in a C++ |
// environment, to be inline. |
// |
// The function prototypes are all in terms of uITRON type definitions from |
// uit_type.h, which is included at the head of uit_func.h. |
// |
// The implementations of the uITRON functions are in uit_func.inl, which |
// is either included at the end of uit_func.h (if functions are inline) or |
// in uit_func.cxx (if outline). |
// |
// uit_func.cxx provides some startup functions plus, if the uITRON |
// functions are out of line, uit_func.inl is included to instantiate those |
// functions. |
// |
// uITRON system objects (tasks, semaphores...) are described in |
// uit_obj.hxx. This is a C++ file and is used by the implementation of |
// the uITRON functions. |
// |
// The uITRON system objects are instantiated in uit_obj.cxx, which uses |
// uit_obj.hxx to define the objects, and the configuration file |
// pkgconf/uitron.h to construct them as required. |
// |
// The include graph from an application, which should only include |
// uit_func.h, is similar to the following: |
// |
// |
// [inline uITRON functions:] |
// |
// <your_app.c> |
// . uit_func.h ; prototypes for funcs |
// . . pkgconf/uitron.h ; configuration info |
// . . uit_type.h ; typedefs for func args |
// . (function prototypes) |
// . . uit_func.inl ; full function bodies |
// . . . uit_objs.hxx ; defs of uITRON data |
// . . (function implementations) |
// |
// |
// [out-of-line uITRON functions:] |
// |
// <your_app.c> |
// . uit_func.h ; prototypes for funcs |
// . . pkgconf/uitron.h ; configuration info |
// . . uit_type.h ; typedefs for func args |
// . (function prototypes) |
// |
// |
// [other uITRON compilation units:] |
// |
// uit_func.cxx ; out-of-line functions |
// . pkgconf/uitron.h ; configuration info |
// . uit_func.h ; prototypes for funcs |
// . . uit_type.h ; typedefs for func args |
// . (function prototypes) |
// . . uit_func.inl ; full function bodies |
// . . . uit_objs.hxx ; defs of uITRON data |
// . . (function implementations) |
// |
// |
// uit_objs.cxx ; static uITRON data objects |
// . pkgconf/uitron.h ; configuration info |
// . uit_objs.hxx ; defs of uITRON data |
// (static uITRON system objects) |
// |
// |
// The various include files are protected against multiple inclusion and |
// so may be safely re-included as convenient. |
// |
// ------------------------------------------------------------------------ |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
#include <cyg/infra/cyg_type.h> // types; cyg_int32, CYG_ADDRWORD |
|
#include <cyg/compat/uitron/uit_type.h> // uITRON types; ER ID TMO T_MSG |
|
// ------------------------------------------------------------------------ |
// Object operations: |
// |
// The functions can be inlined in C compiled by C++, or C++ of course, |
// and also outlined in extern "C" functions, eg. for taking the address |
// of, or for use by a pure C program, or of course outlined in C++ for |
// Code size reasons. |
// |
// |
// Summary: |
// |
// IF compiling in C |
// THEN functions must be C linkage and out of line: |
// do NOT specify CYGIMP_UITRON_INLINE_FUNCS nor |
// CYGIMP_UITRON_CPP_OUTLINE_FUNCS. |
// IF compiling in C++ |
// THEN functions can be inline: specify CYGIMP_UITRON_INLINE_FUNCS |
// OR by default, functions are out of line: |
// outline functions can have C++ linkage: |
// specify CYGIMP_UITRON_CPP_OUTLINE_FUNCS |
// OR by default, outline functions have C linkage. |
|
|
#ifdef __cplusplus |
// C++ environment; functions can be inline or not as we please. |
// If not inline they might as well be "C" linkage for sharing with |
// any pure "C" code present. |
|
#ifdef CYGIMP_UITRON_INLINE_FUNCS |
|
#define CYG_UIT_FUNC_EXTERN_BEGIN |
#define CYG_UIT_FUNC_EXTERN_END |
#define CYG_UIT_FUNC_INLINE inline |
#ifndef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
#define CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
#endif |
|
#else |
|
#ifdef CYGIMP_UITRON_CPP_OUTLINE_FUNCS |
#define CYG_UIT_FUNC_EXTERN_BEGIN extern "C++" { |
#define CYG_UIT_FUNC_EXTERN_END } |
#else |
#define CYG_UIT_FUNC_EXTERN_BEGIN extern "C" { |
#define CYG_UIT_FUNC_EXTERN_END } |
#endif |
|
#define CYG_UIT_FUNC_INLINE |
#endif |
|
#else // !__cplusplus |
// Vanilla "C" environment; external "C" linkage, no inline functions |
|
#ifdef CYGIMP_UITRON_INLINE_FUNCS |
#error "Cannot inline uITRON functions in pure C environment" |
#endif |
#ifdef CYGIMP_UITRON_CPP_OUTLINE_FUNCS |
#error "Cannot use C++ linkage of outline fns in pure C environment" |
#endif |
|
#define CYG_UIT_FUNC_EXTERN_BEGIN |
#define CYG_UIT_FUNC_EXTERN_END |
#define CYG_UIT_FUNC_INLINE |
|
#endif // !__cplusplus |
|
// ======================================================================== |
// u I T R O N F U N C T I O N S |
// The function declarations themselves: |
|
CYG_UIT_FUNC_EXTERN_BEGIN |
|
// this routine is outside the uITRON specification; call it from main() to |
// start the uITRON tasks and scheduler. It does not return. |
|
#ifdef CYGNUM_UITRON_START_TASKS |
void cyg_uitron_start( void ); |
#endif |
|
// ****************************************************** |
// *** 6.5 C Language Interfaces *** |
// ****************************************************** |
|
// - Task Management Functions |
|
ER cre_tsk ( ID tskid, T_CTSK *pk_ctsk ); |
ER del_tsk ( ID tskid ); |
ER sta_tsk ( ID tskid, INT stacd ); |
void ext_tsk ( void ); |
void exd_tsk ( void ); |
ER ter_tsk ( ID tskid ); |
|
ER dis_dsp ( void ); |
ER ena_dsp ( void ); |
ER chg_pri ( ID tskid, PRI tskpri ); |
ER rot_rdq ( PRI tskpri ); |
ER rel_wai ( ID tskid ); |
ER get_tid ( ID *p_tskid ); |
ER ref_tsk ( T_RTSK *pk_rtsk, ID tskid ); |
|
// - Task-Dependent Synchronization Functions |
|
ER sus_tsk ( ID tskid ); |
ER rsm_tsk ( ID tskid ); |
ER frsm_tsk ( ID tskid ); |
ER slp_tsk ( void ); |
ER tslp_tsk ( TMO tmout ); |
ER wup_tsk ( ID tskid ); |
ER can_wup ( INT *p_wupcnt, ID tskid ); |
|
// - Synchronization and Communication Functions |
|
ER cre_sem ( ID semid, T_CSEM *pk_csem ); |
ER del_sem ( ID semid ); |
ER sig_sem ( ID semid ); |
ER wai_sem ( ID semid ); |
ER preq_sem ( ID semid ); |
ER twai_sem ( ID semid, TMO tmout ); |
ER ref_sem ( T_RSEM *pk_rsem, ID semid ); |
|
ER cre_flg ( ID flgid, T_CFLG *pk_cflg ); |
ER del_flg ( ID flgid ); |
ER set_flg ( ID flgid, UINT setptn ); |
ER clr_flg ( ID flgid, UINT clrptn ); |
ER wai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ); |
ER pol_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ); |
ER twai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode, |
TMO tmout ); |
ER ref_flg ( T_RFLG *pk_rflg, ID flgid ); |
|
ER cre_mbx ( ID mbxid, T_CMBX* pk_cmbx ); |
ER del_mbx ( ID mbxid ); |
ER snd_msg ( ID mbxid, T_MSG *pk_msg ); |
ER rcv_msg ( T_MSG **ppk_msg, ID mbxid ); |
ER prcv_msg ( T_MSG **ppk_msg, ID mbxid ); |
ER trcv_msg ( T_MSG **ppk_msg, ID mbxid, TMO tmout ); |
ER ref_mbx ( T_RMBX *pk_rmbx, ID mbxid ); |
|
// - Extended Synchronization and Communication Functions |
|
#if 0 // NOT SUPPORTED |
ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf ); |
ER del_mbf ( ID mbfid ); |
ER snd_mbf ( ID mbfid, VP msg, INT msgsz ); |
ER psnd_mbf ( ID mbfid, VP msg, INT msgsz ); |
ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout ); |
ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout ); |
ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid ); |
ER cre_por ( ID porid, T_CPOR *pk_cpor ); |
ER del_por ( ID porid ); |
ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz ); |
ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz ); |
ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz, TMO tmout ); |
ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn ); |
ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn ); |
ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn, TMO tmout ); |
ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz |
); |
ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz ); |
ER ref_por ( T_RPOR *pk_rpor, ID porid ); |
#endif |
|
// - Interrupt Management Functions |
|
#if 0 // NOT SUPPORTED |
ER def_int ( UINT dintno, T_DINT *pk_dint ); |
void ret_wup ( ID tskid ); |
#endif |
#if 0 |
void ret_int ( void ); |
#endif |
#define ret_int() return |
ER loc_cpu ( void ); |
ER unl_cpu ( void ); |
|
ER dis_int ( UINT eintno ); |
ER ena_int ( UINT eintno ); |
|
#if 0 // NOT SUPPORTED |
ER chg_iXX ( UINT iXXXX ); |
ER ref_iXX ( UINT *p_iXXXX ); |
#endif |
|
// - Memorypool Management Functions |
|
ER cre_mpl ( ID mplid, T_CMPL *pk_cmpl ); |
ER del_mpl ( ID mplid ); |
ER get_blk ( VP *p_blk, ID mplid, INT blksz ); |
ER pget_blk ( VP *p_blk, ID mplid, INT blksz ); |
ER tget_blk ( VP *p_blk, ID mplid, INT blksz, TMO tmout ); |
ER rel_blk ( ID mplid, VP blk ); |
ER ref_mpl ( T_RMPL *pk_rmpl, ID mplid ); |
|
ER cre_mpf ( ID mpfid, T_CMPF *pk_cmpf ); |
ER del_mpf ( ID mpfid ); |
ER get_blf ( VP *p_blf, ID mpfid ); |
ER pget_blf ( VP *p_blf, ID mpfid ); |
ER tget_blf ( VP *p_blf, ID mpfid, TMO tmout ); |
ER rel_blf ( ID mpfid, VP blf ); |
ER ref_mpf ( T_RMPF *pk_rmpf, ID mpfid ); |
|
// - Time Management Functions |
|
ER set_tim ( SYSTIME *pk_tim ); |
ER get_tim ( SYSTIME *pk_tim ); |
ER dly_tsk ( DLYTIME dlytim ); |
ER def_cyc ( HNO cycno, T_DCYC *pk_dcyc ); |
ER act_cyc ( HNO cycno, UINT cycact ); |
ER ref_cyc ( T_RCYC *pk_rcyc, HNO cycno ); |
ER def_alm ( HNO almno, T_DALM *pk_dalm ); |
ER ref_alm ( T_RALM *pk_ralm, HNO almno ); |
#if 0 |
void ret_tmr ( void ); |
#endif |
#define ret_tmr() return |
|
// - System Management Functions |
|
ER get_ver ( T_VER *pk_ver ); |
ER ref_sys ( T_RSYS *pk_rsys ); |
ER ref_cfg ( T_RCFG *pk_rcfg ); |
#if 0 // NOT SUPPORTED |
ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc ); |
ER def_exc ( UINT exckind, T_DEXC *pk_dexc ); |
#endif |
|
// - Network Support Functions |
|
#if 0 // NOT SUPPORTED |
ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr, |
INT datsz ); |
ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr, |
INT datsz ); |
ER nget_nod ( NODE *p_node ); |
ER nget_ver ( T_VER *pk_ver, NODE node ); |
#endif |
|
CYG_UIT_FUNC_EXTERN_END |
|
// ======================================================================== |
|
#ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
// functions are inline OR we are in the outline implementation, so define |
// the functions as inlines or plain functions depending on the value of |
// CYG_UIT_FUNC_INLINE from above. |
#include <cyg/compat/uitron/uit_func.inl> |
#endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
// ------------------------------------------------------------------------ |
#endif // CYGPKG_UITRON |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_FUNC_H |
// EOF uit_func.h |
/v2_0/include/uit_objs.hxx
0,0 → 1,177
#ifndef CYGONCE_COMPAT_UITRON_UIT_OBJS_HXX |
#define CYGONCE_COMPAT_UITRON_UIT_OBJS_HXX |
//=========================================================================== |
// |
// uit_objs.hxx |
// |
// uITRON static objects |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON static system objects |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
#include <cyg/infra/cyg_type.h> // types; cyg_int32, CYG_ADDRWORD |
|
#include <pkgconf/kernel.h> |
|
#include <cyg/kernel/ktypes.h> |
|
#include <cyg/kernel/thread.hxx> // Cyg_Thread |
#include <cyg/kernel/mbox.hxx> // Cyg_Mbox |
#include <cyg/kernel/flag.hxx> // Cyg_Flag |
#include <cyg/kernel/sema2.hxx> // Cyg_Counting_Semaphore2 |
#include <cyg/memalloc/memfixed.hxx> // Cyg_Mempool_Fixed |
#include <cyg/memalloc/memvar.hxx> // Cyg_Mempool_Variable |
#include <cyg/kernel/timer.hxx> // Cyg_Timer |
|
// ------------------------------------------------------------------------ |
// Some pasting macros to create names of the config macro and the |
// static data resulting: |
|
#define CYG_UITRON_NUM( _which_ ) (CYGNUM_UITRON_ ## _which_) |
#define CYG_UITRON_OBJS( _which_ ) cyg_uitron_ ## _which_ |
#define CYG_UITRON_PTRS( _which_ ) cyg_uitron_ ## _which_ ## _ptrs |
// ------------------------------------------------------------------------ |
// CYG_UITRON_DECL |
// |
// Macro to declare static uitron static objects; uses the appropriate |
// config define for the number of them to have. |
|
#define CYG_UITRON_OBJS_INIT_PRIORITY CYG_INIT_PRIORITY( COMPAT ) |
|
#define CYG_UITRON_DECL( _which_ ) \ |
CYG_UITRON_OBJS( _which_ ) [ CYG_UITRON_NUM( _which_ ) ] \ |
CYG_UITRON_OBJS_INIT_PRIORITY |
|
// and the array of pointers to them for those with dynamic existence: |
#define CYG_UITRON_DECL_PTRS( _which_ ) \ |
CYG_UITRON_PTRS( _which_ ) [ CYG_UITRON_NUM( _which_ ) ] |
|
|
// ------------------------------------------------------------------------ |
// The external system objects themselves. |
|
#ifdef CYGPKG_UITRON_SEMAS |
extern |
Cyg_Counting_Semaphore2 CYG_UITRON_OBJS( SEMAS ) []; |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
extern |
Cyg_Counting_Semaphore2 *CYG_UITRON_PTRS( SEMAS ) []; |
#endif |
#endif |
#ifdef CYGPKG_UITRON_MBOXES |
extern |
Cyg_Mbox CYG_UITRON_OBJS( MBOXES ) []; |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
extern |
Cyg_Mbox *CYG_UITRON_PTRS( MBOXES ) []; |
#endif |
#endif |
#ifdef CYGPKG_UITRON_FLAGS |
extern |
Cyg_Flag CYG_UITRON_OBJS( FLAGS ) []; |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
extern |
Cyg_Flag *CYG_UITRON_PTRS( FLAGS ) []; |
#endif |
#endif |
// there must always be tasks |
extern |
Cyg_Thread CYG_UITRON_OBJS( TASKS ) []; |
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
extern |
Cyg_Thread *CYG_UITRON_PTRS( TASKS ) []; |
#endif |
// no endif |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED |
extern |
Cyg_Mempool_Fixed CYG_UITRON_OBJS( MEMPOOLFIXED ) []; |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
extern |
Cyg_Mempool_Fixed *CYG_UITRON_PTRS( MEMPOOLFIXED )[]; |
#endif |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLVAR |
extern |
Cyg_Mempool_Variable CYG_UITRON_OBJS( MEMPOOLVAR ) []; |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
extern |
Cyg_Mempool_Variable *CYG_UITRON_PTRS( MEMPOOLVAR ) []; |
#endif |
#endif |
#ifdef CYGPKG_UITRON_CYCLICS |
extern |
Cyg_Timer CYG_UITRON_OBJS( CYCLICS ) []; |
#endif |
#ifdef CYGPKG_UITRON_ALARMS |
extern |
Cyg_Timer CYG_UITRON_OBJS( ALARMS ) []; |
#endif |
|
// ------------------------------------------------------------------------ |
// Ancillary system objects - cleaner than extending the basic class |
|
#ifdef CYGIMP_THREAD_PRIORITY |
// An array of priorities, for resetting back to the "created" prio when a |
// task cycles though exit, dormancy, restart. |
extern cyg_priority |
cyg_uitron_task_initial_priorities[ CYG_UITRON_NUM( TASKS ) ]; |
// and an accessor macro, for the addressing of this is naturally |
// from 1..N also: |
#define CYG_UITRON_TASK_INITIAL_PRIORITY( _tskid_ ) \ |
(cyg_uitron_task_initial_priorities[ (_tskid_) - 1 ]) |
#endif // CYGIMP_THREAD_PRIORITY |
|
// ------------------------------------------------------------------------ |
|
#endif // CYGPKG_UITRON |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_OBJS_HXX |
// EOF uit_objs.hxx |
/v2_0/include/uit_ifnc.h
0,0 → 1,182
#ifndef CYGONCE_COMPAT_UITRON_UIT_IFNC_H |
#define CYGONCE_COMPAT_UITRON_UIT_IFNC_H |
//=========================================================================== |
// |
// uit_ifnc.h |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1999-08-16 |
// Purpose: uITRON compatibility functions |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
// ------------------------------------------------------------------------ |
// Source Code Organization |
// |
// First, see pkgconf/uitron.h for details of applicable configuration |
// options. |
// |
// This file uit_ifnc.h provides prototypes for the task-independent parts |
// of the uITRON API, that is functions named ixxx_yyy() for calling in |
// ISRs. We also define the uitron helper DSR that is needed to despool |
// stored up requests. |
// ------------------------------------------------------------------------ |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
#include <cyg/infra/cyg_type.h> // types; cyg_int32, CYG_ADDRWORD |
|
#include <cyg/compat/uitron/uit_type.h> // uITRON types; ER ID TMO T_MSG |
#include <cyg/compat/uitron/uit_func.h> // uITRON funcs and control macros. |
|
// ======================================================================== |
// u I T R O N F U N C T I O N S |
// The function declarations themselves: |
|
// ------------------- These functions can be inline if so configured |
CYG_UIT_FUNC_EXTERN_BEGIN |
|
// ****************************************************** |
// *** 6.5 C Language Interfaces *** |
// ****************************************************** |
|
// - Task Management Functions |
|
// (None) |
|
// - Task-Dependent Synchronization Functions |
|
//ER irsm_tsk ( ID tskid ); |
//ER ifrsm_tsk ( ID tskid ); |
|
ER iwup_tsk ( ID tskid ); |
|
// - Synchronization and Communication Functions |
|
ER isig_sem ( ID semid ); |
|
ER iset_flg ( ID flgid, UINT setptn ); |
|
ER isnd_msg ( ID mbxid, T_MSG *pk_msg ); |
|
// - Extended Synchronization and Communication Functions |
|
// - Interrupt Management Functions |
|
// (None) |
|
// --------------------------------------------------------------- |
|
#define CYGPRI_UITRON_SET_RETCODE( _z_ ) do { \ |
extern volatile int cyg_uit_dsr_actions_head; \ |
extern volatile int cyg_uit_dsr_actions_tail; \ |
(_z_) = (cyg_uit_dsr_actions_head == cyg_uit_dsr_actions_tail) ? 1 : 3; \ |
} while ( 0 ) |
|
//void ret_wup ( ID tskid ); |
// Awaken the task (safely) and return Cyg_Interrupt::CALL_DSR |
#define ret_wup( _id_ ) do { \ |
register int retcode; \ |
(void)iwup_tsk( (_id_) ); \ |
CYGPRI_UITRON_SET_RETCODE( retcode ); \ |
return retcode; \ |
} while ( 0 ) |
|
// Subsitute a version of ret_int that returns Cyg_Interrupt::CALL_DSR |
#undef ret_int |
#define ret_int() do { \ |
register int retcode; \ |
CYGPRI_UITRON_SET_RETCODE( retcode ); \ |
return retcode; \ |
} while ( 0 ) |
|
|
// - Memorypool Management Functions |
|
// (None) |
|
// - Time Management Functions |
|
// (None) |
|
// - System Management Functions |
|
// (None) |
|
// - Network Support Functions |
|
// (None) |
|
CYG_UIT_FUNC_EXTERN_END |
// ------------------- End of functions that can be inlined |
|
|
// ======================================================================== |
// DSR: use this DSR with the uITRON-type ISR that uses the functions above |
// to get delayed/safe execution of the wakeup-type functions above. |
|
#ifdef __cplusplus |
extern "C" |
#endif |
void cyg_uitron_dsr( unsigned int vector, unsigned int count, unsigned int data ); |
|
|
// ======================================================================== |
|
#ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
// functions are inline OR we are in the outline implementation, so define |
// the functions as inlines or plain functions depending on the value of |
// CYG_UIT_FUNC_INLINE from above. |
#include <cyg/compat/uitron/uit_ifnc.inl> |
#endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
// ------------------------------------------------------------------------ |
#endif // CYGPKG_UITRON |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_IFNC_H |
// EOF uit_ifnc.h |
/v2_0/include/uit_type.h
0,0 → 1,687
#ifndef CYGONCE_COMPAT_UITRON_UIT_TYPE_H |
#define CYGONCE_COMPAT_UITRON_UIT_TYPE_H |
//=========================================================================== |
// |
// uit_type.h |
// |
// uITRON specific data types as required by the API |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON specific data types as required by the API |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
// ------------------------------------------------------------------------ |
// uITRON types |
// |
|
// from this section of the uITRON 3.02 manual: |
// *********************************************************************** |
// *** 6.4 Data Types *** |
// *********************************************************************** |
// |
// *** General-Purpose Data Types *************************************** |
|
typedef cyg_int8 B; // signed 8-bit integer |
typedef cyg_int16 H; // signed 16-bit integer |
typedef cyg_int32 W; // signed 32-bit integer |
typedef cyg_uint8 UB; // unsigned 8-bit integer |
typedef cyg_uint16 UH; // unsigned 16-bit integer |
typedef cyg_uint32 UW; // unsigned 32-bit integer |
// |
typedef cyg_uint32 VW; // unpredictable data type (32-bit size) |
typedef cyg_uint16 VH; // unpredictable data type (16-bit size) |
typedef cyg_uint8 VB; // unpredictable data type (8-bit size) |
|
typedef void * VP; // pointer to an unpredictable data type |
|
typedef CYG_ADDRWORD FP; // program start address |
|
// * The difference between VB, VH and VW and B, H and W is that only the |
// number of bits is known for the former, not the data type of the |
// contents. The latter clearly represent integers. |
// |
// *** Data Types Dependent on ITRON Specification *** |
// |
// In order to clarify the meanings of certain parameters, the following |
// names are used for data types which appear frequently and/or have |
// special meanings. |
|
typedef cyg_int32 INT; // Signed integer (bit width of processor) |
typedef cyg_uint32 UINT; // Unsigned integer (bit width of processor) |
typedef cyg_int32 BOOL; // Boolean value. TRUE (1) or FALSE (0). |
typedef cyg_uint16 FN; // Function code. Signed integer. Maximum 2 bytes. |
typedef INT ID; // Object ID number (???id) |
typedef INT BOOL_ID;// Boolean value or ID number |
typedef INT HNO; // Handler number |
typedef INT RNO; // Rendezvous number |
typedef INT NODE; // Node Number. Usually a signed integer. |
typedef UINT ATR; // Object or handler attribute. An unsigned integer. |
typedef INT ER; // Error code. A signed integer. |
typedef INT PRI; // Task priority. A signed integer. |
typedef UB T_MSG; // Message packet data structure used for mailboxes |
typedef INT TMO; // Timeout value. A signed integer. |
// TMO_POL = 0 indicates polling, |
// while TMO_FEVR = -1 indicates wait forever. |
|
typedef cyg_uint64 CYGTM; |
typedef CYGTM SYSTIME;// Data types used for specifying times. |
typedef CYGTM CYCTIME;// Often split into upper and lower sections. |
typedef CYGTM ALMTIME;// For details, see the chapter giving system |
typedef CYGTM DLYTIME;// call descriptions;. |
|
// *********************************************************************** |
// *** 6.7 Error Codes *** |
// *********************************************************************** |
|
enum { |
//------------------------------------------------------ |
//Mnemonic Value Description |
//------------------------------------------------------ |
E_OK = 0, // Normal completion |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_SYS = (-5), // System error |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_NOMEM = (-10), // Insufficient memory |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_NOSPT = (-17), // Feature not supported |
E_INOSPT = (-18), // Feature not supported by ITRON/FILE specification |
E_RSFN = (-20), // Reserved function code number |
E_RSATR = (-24), // Reserved attribute |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_PAR = (-33), // Parameter error |
E_ID = (-35), // Invalid ID number |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_NOEXS = (-52), // Object does not exist |
E_OBJ = (-63), // Invalid object state |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_MACV = (-65), // Memory access disabled or memory access violation |
E_OACV = (-66), // Object access violation |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_CTX = (-69), // Context error |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_QOVR = (-73), // Queuing or nesting overflow |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_DLT = (-81), // Object being waited for was deleted |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - |
E_TMOUT = (-85), // Polling failure or timeout exceeded |
E_RLWAI = (-86), // WAIT state was forcibly released |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - - |
#if 0 // CONNECTION FUNCTIONS ARE NOT SUPPORTED |
EN_NOND = (-113), // Target node does not exist or cannot be accessed |
EN_OBJNO = (-114), // Specifies an object number which could not be |
// accessed on the target node |
EN_PROTO = (-115), // Protocol not supported on target node |
EN_RSFN = (-116), // System call or function not supported on target node |
EN_COMM = (-117), // No response from target node |
EN_RLWAI = (-118), // Connection function response wait state was forcibly |
// released |
EN_PAR = (-119), // A value outside the range supported by the target |
// node and/or transmission packet format was specified |
// as a parameter |
EN_RPAR = (-120), // A value outside the range supported by the issuing |
// node and/or transmission packet format was returned |
// as a return parameter |
EN_CTXID = (-121), // An object on another node was specified to a system |
// call issued from a task in dispatch disabled state |
// or from a task-independent portion |
EN_EXEC = (-122), // System call could not be executed due to |
// insufficient resources on the target node |
EN_NOSPT = (-123), // Connection function not supported |
#endif // 0 CONNECTION FUNCTIONS ARE NOT SUPPORTED |
// - - - - - - - - // - - - - - - - - - - - - - - - - - - - |
}; |
|
|
// ******************************************************************* |
// *** 6.6 Common Constants and Data Structure Packet Formats *** |
// ******************************************************************* |
|
/* --- overall ----------------------- */ |
|
/* invalid address or pointer value */ |
#define NADR ((void *)(-1)) |
|
enum { |
TRUE = 1, /* true */ |
FALSE = 0, /* false */ |
}; |
|
/* TMO tmout: */ |
enum { |
TMO_POL = 0, /* polling */ |
TMO_FEVR = (-1) /* wait forever */ |
}; |
|
/* --- for task management functions ----------------------- */ |
|
// cre_tsk: |
typedef struct t_ctsk { |
VP exinf; /* extended information */ |
ATR tskatr; /* task attributes */ |
FP task; /* task start address */ |
PRI itskpri; /* initial task priority */ |
INT stksz; /* stack size */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CTSK; |
|
// tskatr: |
enum { |
TA_ASM = 0x00, /* program written in assembly language */ |
TA_HLNG = 0x01, /* program written in high-level language */ |
TA_COP0 = 0x8000, /* uses coprocessor having ID = 0 */ |
TA_COP1 = 0x4000, /* uses coprocessor having ID = 1 */ |
TA_COP2 = 0x2000, /* uses coprocessor having ID = 2 */ |
TA_COP3 = 0x1000, /* uses coprocessor having ID = 3 */ |
TA_COP4 = 0x0800, /* uses coprocessor having ID = 4 */ |
TA_COP5 = 0x0400, /* uses coprocessor having ID = 5 */ |
TA_COP6 = 0x0200, /* uses coprocessor having ID = 6 */ |
TA_COP7 = 0x0100, /* uses coprocessor having ID = 7 */ |
}; |
|
// tskid: |
enum { |
TSK_SELF = 0, /* task specifies itself */ |
/* FALSE = 0, */ /* indicates a task-independent portion (return |
parameters only) */ |
}; |
// tskpri: |
enum { |
TPRI_INI = 0, /* specifies the initial priority on task startup |
(chg_pri) */ |
TPRI_RUN = 0, /* specifies the highest priority during execution |
(rot_rdq) */ |
}; |
/* ref_tsk */ |
typedef struct t_rtsk { |
VP exinf; /* extended information */ |
PRI tskpri; /* current priority */ |
UINT tskstat; /* task state */ |
/* the following are represent extended features of support |
[level X] (implementation-dependent) */ |
#if 0 // NOT SUPPORTED |
UINT tskwait; /* cause of wait */ |
ID wid; /* ID of object being waited for */ |
INT wupcnt; /* wakeup request count */ |
INT suscnt; /* SUSPEND request count */ |
ATR tskatr; /* task attributes */ |
FP task; /* task start address */ |
PRI itskpri; /* initial task priority */ |
INT stksz; /* stack size */ |
// ... |
#endif |
} T_RTSK; |
|
// tskstat: |
enum { |
TTS_RUN = 0x01, /* RUN */ |
TTS_RDY = 0x02, /* READY */ |
TTS_WAI = 0x04, /* WAIT */ |
TTS_SUS = 0x08, /* SUSPEND */ |
TTS_WAS = 0x0C, /* WAIT-SUSPEND */ |
TTS_DMT = 0x10, /* DORMANT */ |
}; |
// tskwait: |
enum { |
TTW_SLP = 0x0001, /* wait due to slp_tsk or tslp_tsk */ |
TTW_DLY = 0x0002, /* wait due to dly_tsk */ |
TTW_NOD = 0x0008, /* connection function response wait */ |
TTW_FLG = 0x0010, /* wait due to wai_flg or twai_flg */ |
TTW_SEM = 0x0020, /* wait due to wai_sem or twai_sem */ |
TTW_MBX = 0x0040, /* wait due to rcv_msg or trcv_msg */ |
TTW_SMBF = 0x0080, /* wait due to snd_mbf or tsnd_mbf */ |
TTW_MBF = 0x0100, /* wait due to rcv_mbf or trcv_mbf */ |
TTW_CAL = 0x0200, /* wait for rendezvous call */ |
TTW_ACP = 0x0400, /* wait for rendezvous accept */ |
TTW_RDV = 0x0800, /* wait for rendezvous completion */ |
TTW_MPL = 0x1000, /* wait due to get_blk or tget_blk */ |
TTW_MPF = 0x2000, /* wait due to get_blf or tget_blf */ |
}; |
/* Since the task states given by tskstat and tskwait are expressed |
by bit correspondences, they are convenient when looking for OR |
conditions (such as whether a task is in WAIT or READY state). |
*/ |
|
/* --- for semaphore functions ----------------------- */ |
|
/* cre_sem */ |
typedef struct t_csem { |
VP exinf; /* extended information */ |
ATR sematr; /* semaphore attributes */ |
/* Following is the extended function for [level X]. */ |
INT isemcnt; /* initial semaphore count */ |
/* INT maxsem; NOT SUPPORTED maximum semaphore count */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CSEM; |
|
/* ref_sem */ |
typedef struct t_rsem { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there is a |
waiting task */ |
INT semcnt; /* current semaphore count */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RSEM; |
|
/* --- for eventflag functions ----------------------- */ |
|
/* cre_flg */ |
typedef struct t_cflg { |
VP exinf; /* extended information */ |
ATR flgatr; /* eventflag attribute */ |
UINT iflgptn; /* initial eventflag */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CFLG; |
|
// flgatr: |
enum { |
TA_WSGL = 0x00, /* multiple tasks are not allowed to wait (Wait |
Single Task) */ |
TA_WMUL = 0x08, /* multiple tasks are allowed to wait (Wait |
Multiple Task) */ |
}; |
// wfmode: |
enum { |
TWF_ANDW = 0x00, /* AND wait */ |
TWF_ORW = 0x02, /* OR wait */ |
TWF_CLR = 0x01, /* clear specification */ |
}; |
/* ref_flg */ |
typedef struct t_rflg { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there is a |
waiting task */ |
UINT flgptn; /* eventflag bit pattern */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RFLG; |
|
/* --- for mailbox functions ----------------------- */ |
|
/* cre_mbx */ |
typedef struct t_cmbx { |
VP exinf; /* extended information */ |
ATR mbxatr; /* mailbox attributes */ |
/* Following is implementation-dependent function */ |
/* INT bufcnt; NOT SUPPORTED ring buffer size IS FIXED */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CMBX; |
|
// mbxatr: |
enum { |
TA_TFIFO = 0x00, /* waiting tasks are handled by FIFO */ |
TA_TPRI = 0x01, /* waiting tasks are handled by priority */ |
TA_MFIFO = 0x00, /* messages are handled by FIFO */ |
TA_MPRI = 0x02, /* messages are handled by priority */ |
}; |
|
/* ref_mbx */ |
typedef struct t_rmbx { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there is a |
waiting task */ |
T_MSG* pk_msg; /* message to be sent next */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RMBX; |
|
/* --- for messagebuffer functions ----------------------- */ |
|
#if 0 // NOT SUPPORTED |
/* cre_mbf */ |
typedef struct t_cmbf { |
VP exinf; /* extended information */ |
ATR mbfatr; /* messagebuffer attributes */ |
INT bufsz; /* messagebuffer size */ |
INT maxmsz; /* maximum size of messages */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CMBF; |
|
// mbfatr: |
// mbfid: |
enum { |
TMBF_OS = (-4), /* messagebuffer used for OS error log */ |
TMBF_DB = (-3), /* messagebuffer used for debugging */ |
}; |
/* ref_mbf */ |
typedef struct t_rmbf { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there is a |
task waiting to receive a message */ |
BOOL_ID stsk; /* indicates whether or not there is a |
task waiting to send a message */ |
INT msgsz; /* size of message to be sent next */ |
INT frbufsz; /* size of free buffer */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RMBF; |
|
#endif |
/* --- for port or rendezvous functions ----------------------- */ |
|
#if 0 // NOT SUPPORTED |
|
/* cre_por */ |
typedef struct t_cpor { |
VP exinf; /* extended information */ |
ATR poratr; /* port attributes */ |
INT maxcmsz; /* maximum call message size */ |
INT maxrmsz; /* maximum reply message size */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CPOR; |
|
// poratr: |
enum { |
TA_NULL = 0, /* specifies no particular attributes */ |
/* TA_NULL should be used in place of zeroes to turn off all |
attribute features. */ |
}; |
/* ref_por */ |
typedef struct t_rpor { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there is a task |
waiting to call a rendezvous */ |
BOOL_ID atsk; /* indicates whether or not there is a task |
waiting to accept a rendezvous */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RPOR; |
#endif |
|
/* --- for interrupt management functions ----------------------- */ |
|
#if 0 // NOT SUPPORTED |
/* def_int */ |
typedef struct t_dint { |
ATR intatr; /* interrupt handler attributes */ |
FP inthdr; /* interrupt handler address */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_DINT; |
#endif |
|
/* --- for memorypool management functions ----------------------- */ |
|
/* cre_mpl */ |
typedef struct t_cmpl { |
VP exinf; /* extended information */ |
ATR mplatr; /* memorypool attributes */ |
INT mplsz; /* memorypool size */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CMPL; |
|
// mplatr: |
// mplid: |
enum { |
TMPL_OS = (-4) /* memorypool used by OS */ |
}; |
/* ref_mpl */ |
typedef struct t_rmpl { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there are |
waiting tasks */ |
INT frsz; /* total size of free memory */ |
INT maxsz; /* size of largest contiguous memory */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RMPL; |
|
/* cre_mpf */ |
typedef struct t_cmpf { |
VP exinf; /* extended information */ |
ATR mpfatr; /* memorypool attributes */ |
INT mpfcnt; /* block count for entire memorypool */ |
INT blfsz; /* fixed-size memory block size */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_CMPF; |
|
// mpfatr: |
/* ref_mpf */ |
typedef struct t_rmpf { |
VP exinf; /* extended information */ |
BOOL_ID wtsk; /* indicates whether or not there are |
waiting tasks */ |
INT frbcnt; /* free block count */ |
/* additional information may be included depending on the |
implementation */ |
INT numbcnt; /* total number of blocks */ |
INT bsize; /* block size */ |
|
} T_RMPF; |
|
/* --- for time management functions ----------------------- */ |
|
#if 0 // native definition is at head of this file |
/* example for 32-bit CPUs */ |
typedef struct t_systime { |
H utime; /* upper 16 bits */ |
UW ltime; /* lower 32 bits */ |
} SYSTIME, CYCTIME, ALMTIME; |
|
/* example for 16-bit CPUs */ |
typedef struct t_systime { |
H utime; /* upper 16 bits */ |
UH mtime; /* middle 16 bits */ |
UH ltime; /* lower 16 bits */ |
} SYSTIME, CYCTIME, ALMTIME; |
#endif |
/* Member configuration depends on the bit width of the processor and |
on the implementation. A total of 48 bits is recommended. */ |
|
/* def_cyc */ |
typedef struct t_dcyc { |
VP exinf; /* extended information */ |
ATR cycatr; /* cyclic handler attributes */ |
FP cychdr; /* cyclic handler address */ |
UINT cycact; /* cyclic handler activation */ |
CYCTIME cyctim; /* cyclic startup period */ |
} T_DCYC; |
|
// cycact: |
enum { |
TCY_OFF = 0x00, /* do not invoke cyclic handler */ |
TCY_ON = 0x01, /* invoke cyclic handler */ |
TCY_INT = 0x02, /* initialize cycle count */ |
/* Following changed from TCY_INT to TCY_INI to match |
description in the body of the standard. I assume TCY_INT |
is a hypercorrection/typo; keep both */ |
TCY_INI = 0x02, /* initialize cycle count */ |
}; |
/* ref_cyc */ |
typedef struct t_rcyc { |
VP exinf; /* extended information */ |
CYCTIME lfttim; /* time left before next handler startup */ |
UINT cycact; /* cyclic handler activation */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RCYC; |
|
/* def_alm */ |
typedef struct t_dalm { |
VP exinf; /* extended information */ |
ATR almatr; /* alarm handler attributes */ |
FP almhdr; /* alarm handler address */ |
UINT tmmode; /* start time specification mode */ |
ALMTIME almtim; /* handler startup time */ |
} T_DALM; |
|
// tmmode: |
enum { |
TTM_ABS = 0x00, /* specified as an absolute time */ |
TTM_REL = 0x01, /* specified as a relative time */ |
}; |
/* ref_alm */ |
typedef struct t_ralm { |
VP exinf; /* extended information */ |
ALMTIME lfttim; /* time left before next handler startup */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RALM; |
|
/* --- for system management functions ----------------------- */ |
|
/* get_ver */ |
typedef struct t_ver { |
UH maker; /* vendor */ |
UH id; /* format number */ |
UH spver; /* specification version */ |
UH prver; /* product version */ |
UH prno[4]; /* product control information */ |
UH cpu; /* CPU information */ |
UH var; /* variation descriptor */ |
} T_VER; |
|
/* ref_sys */ |
typedef struct t_rsys { |
INT sysstat; /* system state */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_RSYS; |
|
// sysstat: |
enum { |
TSS_TSK = 0, /* normal state in which dispatching is enabled during |
task portion execution */ |
TSS_DDSP = 1, /* state after dis_dsp has been executed during task |
portion execution (dispatch disabled) */ |
TSS_LOC = 3, /* state after loc_cpu has been executed during task |
portion execution (interrupt and dispatch disabled) |
*/ |
TSS_INDP = 4, /* state during execution of task-independent portions |
(interrupt and timer handlers) */ |
}; |
/* ref_cfg */ |
typedef struct t_rcfg { |
/* details concerning members are implementation dependent */ |
} T_RCFG; |
|
#if 0 // NOT SUPPORTED |
/* def_svc */ |
typedef struct t_dsvc { |
ATR svcatr; /* extended SVC handler attributes */ |
FP svchdr; /* extended SVC handler address */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_DSVC; |
|
/* def_exc */ |
typedef struct t_dexc { |
ATR excatr; /* exception handler attributes */ |
FP exchdr; /* exception handler address */ |
// ... |
/* additional information may be included depending on the |
implementation */ |
// ... |
} T_DEXC; |
#endif |
|
/* --- for network management functions ----------------------- */ |
|
#if 0 // NOT SUPPORTED |
// NODE srcnode, dstnode, node: |
enum { |
TND_SELF = 0, /* specifies the local node */ |
TND_OTHR = (-1) /* specifies default remote node */ |
}; |
#endif |
/* ------------------------------------------------------ */ |
|
|
|
#endif // CYGPKG_UITRON |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_TYPE_H |
// EOF uit_type.h |
/v2_0/include/uit_func.inl
0,0 → 1,1950
#ifndef CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
#define CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
//=========================================================================== |
// |
// uit_func.inl |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON compatibility functions |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#ifdef CYGPKG_UITRON |
|
#ifdef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
#include <cyg/compat/uitron/uit_objs.hxx> // uITRON setup CYGNUM_UITRON_SEMAS |
|
// kernel facilities only needed here |
#include <cyg/kernel/intr.hxx> |
#include <cyg/kernel/sched.hxx> |
|
// and the implementations of other kernel facilities |
#include <cyg/kernel/thread.inl> |
#include <cyg/kernel/sched.inl> |
#include <cyg/kernel/clock.inl> |
|
|
// ------------------------------------------------------------------------ |
// The variable where dis_dsp/ena_dsp state is held: |
extern cyg_uint32 cyg_uitron_dis_dsp_old_priority; |
|
// ------------------------------------------------------------------------ |
// Parameter checking; either check the expression and return an error code |
// if not true, or assert the truth with a made-up message. |
|
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
// default: uitron error codes are returned |
#define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ |
if ( ! (_true_) ) return (_error_); \ |
CYG_MACRO_END |
#else |
// ...but they are asserted if asserts are on |
#define CYG_UIT_PARAMCHECK( _true_, _error_ ) CYG_MACRO_START \ |
CYG_ASSERT( (_true_), "CYG_UIT_PARAMCHECK fail: " #_true_ ); \ |
CYG_MACRO_END |
#endif // else !CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
// ------------------------------------------------------------------------ |
// CYG_UITRON_CHECK_AND_GETP |
// |
// Macro to rangecheck and do the addressing of a static uitron system |
// object; _which_ sort of object is given, and token pasting is used |
// horribly to get the static array, limits and the like. |
// |
// Usage: |
// INT snd_msg( ID mbxid, ... ) { |
// Cyg_Mbox *p; |
// CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
// p->...(...); |
|
// internal: plain assignment to the object pointer, from static array |
#define CYG_UIT_SPTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ |
(_ptr_) = CYG_UITRON_OBJS( _which_ ) + ((_idx_) - 1); \ |
CYG_MACRO_END |
|
// internal: plain assignment to the object pointer, from pointer array |
// with error checking. |
#define CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ) CYG_MACRO_START \ |
(_ptr_) = CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ]; \ |
if ( NULL == (_ptr_) ) return E_NOEXS; \ |
CYG_MACRO_END |
|
#define CYG_UITRON_CHECK_AND_GETP_DIRECT( _which_, _idx_, _ptr_ ) \ |
CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
CYG_UIT_SPTR( _which_, _idx_, _ptr_ ); \ |
CYG_MACRO_END |
|
#define CYG_UITRON_CHECK_AND_GETP_INDIRECT( _which_, _idx_, _ptr_ ) \ |
CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
CYG_UIT_SPTR_PTR( _which_, _idx_, _ptr_ ); \ |
CYG_MACRO_END |
|
// As above but for handler numbers which return E_PAR when out of range |
#define CYG_UITRON_CHECK_AND_GETHDLR( _which_, _num_, _ptr_ ) \ |
CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( 0 < (_num_), E_PAR ); \ |
CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_num_), E_PAR ); \ |
CYG_UIT_SPTR( _which_, _num_, _ptr_ ); \ |
CYG_MACRO_END |
|
// And a macro to check that creation of an object is OK |
#define CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( _which_, _idx_ ) \ |
CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( 0 < (_idx_), E_ID ); \ |
CYG_UIT_PARAMCHECK( CYG_UITRON_NUM( _which_ ) >= (_idx_), E_ID ); \ |
Cyg_Scheduler::lock(); \ |
if ( NULL != CYG_UITRON_PTRS( _which_ )[ ((_idx_) - 1) ] ) { \ |
Cyg_Scheduler::unlock(); \ |
return E_OBJ; \ |
} \ |
CYG_MACRO_END |
|
// define a magic new operator in order to call constructors |
#define CYG_UITRON_NEWFUNCTION( _class_ ) \ |
inline void *operator new(size_t size, _class_ *ptr) \ |
{ \ |
CYG_CHECK_DATA_PTR( ptr, "Bad pointer" ); \ |
return ptr; \ |
} |
|
// now configury to support selectable create/delete support ie. an |
// array of pointers to the objects themselves. |
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( TASKS, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_TASKS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( TASKS, _idx_, _ptr_ ) |
#endif |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( SEMAS, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_SEMAS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( SEMAS, _idx_, _ptr_ ) |
#endif |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( MBOXES, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_MBOXES( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( MBOXES, _idx_, _ptr_ ) |
#endif |
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( FLAGS, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_FLAGS( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( FLAGS, _idx_, _ptr_ ) |
#endif |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLFIXED, _idx_, _ptr_ ) |
#endif |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
#define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_INDIRECT( MEMPOOLVAR, _idx_, _ptr_ ) |
#else |
#define CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( _idx_, _ptr_ ) \ |
CYG_UITRON_CHECK_AND_GETP_DIRECT( MEMPOOLVAR, _idx_, _ptr_ ) |
#endif |
|
// ------------------------------------------------------------------------ |
// Common error checking macros |
|
#if !defined( CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ) && \ |
!defined( CYGDBG_USE_ASSERTS ) |
// if not checking and not asserted, these are removed to avoid usused |
// variable warnings. |
#define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_EMPTY_STATEMENT |
#define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_EMPTY_STATEMENT |
#define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_EMPTY_STATEMENT |
#define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( _tmout_ ) CYG_EMPTY_STATEMENT |
|
#else |
// the default: |
// Check a task is actually a uITRON task |
#define CYG_UITRON_CHECK_TASK_CONTEXT_SELF( _self_ ) CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( \ |
(&cyg_uitron_TASKS[0] <= (_self_)) && \ |
((_self_) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]), \ |
E_CTX ); \ |
CYG_MACRO_END |
|
#define CYG_UITRON_CHECK_TASK_CONTEXT() CYG_MACRO_START \ |
Cyg_Thread *self = Cyg_Thread::self(); \ |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); \ |
CYG_MACRO_END |
|
// Check dispatching is enabled for calls which might wait |
#define CYG_UITRON_CHECK_DISPATCH_ENABLED() CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( 0 == cyg_uitron_dis_dsp_old_priority, E_CTX ); \ |
CYG_MACRO_END |
|
#define CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO(_tmout_) CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( -1 <= (_tmout_), E_PAR ); \ |
if ( TMO_POL != (_tmout_) ) \ |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); \ |
CYG_MACRO_END |
|
#endif |
|
#ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
#define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ |
CYG_MACRO_END |
#else // do check for NULL |
#define CYG_UIT_PARAMCHECK_PTR( _p_ ) CYG_MACRO_START \ |
CYG_UIT_PARAMCHECK( NADR != (_p_), E_PAR ); \ |
CYG_UIT_PARAMCHECK( NULL != (_p_), E_PAR ); \ |
CYG_MACRO_END |
#endif // !CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
// ------------------------------------------------------------------------ |
// CYG_UITRON_FAIL_RETURN |
// |
// After a call which waits, it might return with success, or due to a |
// timeout or a release wait (a forced escape from the waiting condition). |
// This macro examines context and finds out which, then executes a return |
// with the correct uITRON condition code. |
|
#define CYG_UITRON_FAIL_RETURN_SELF( _self_ ) CYG_MACRO_START \ |
Cyg_Thread::cyg_reason reason = (_self_)->get_wake_reason(); \ |
if ( Cyg_Thread::TIMEOUT == reason ) \ |
return E_TMOUT; \ |
if ( Cyg_Thread::BREAK == reason ) \ |
return E_RLWAI; \ |
if ( Cyg_Thread::DESTRUCT == reason ) \ |
return E_DLT; \ |
return E_SYS; /* if no plausible reason was found */ \ |
CYG_MACRO_END |
|
#define CYG_UITRON_FAIL_RETURN() CYG_MACRO_START \ |
Cyg_Thread *self = Cyg_Thread::self(); \ |
CYG_UITRON_FAIL_RETURN_SELF( self ); \ |
CYG_MACRO_END |
|
// ------------------------------------------------------------------------ |
// Interrupts disabled? |
#define CYG_UITRON_CHECK_CPU_UNLOC() \ |
CYG_UIT_PARAMCHECK( (Cyg_Interrupt::interrupts_enabled()), E_CTX ) |
|
// ------------------------------------------------------------------------ |
// Timing: is it in eCos clock ticks or milliSeconds (or something else?) |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
|
#ifdef CYGSEM_UITRON_TIME_IS_MILLISECONDS |
extern Cyg_Clock::converter uit_clock_to_system; |
extern Cyg_Clock::converter uit_clock_from_system; |
|
#define CYG_UITRON_TIME_UIT_TO_SYS32( t ) \ |
Cyg_Clock::convert( (cyg_uint64)(t), &uit_clock_to_system ) |
|
#define CYG_UITRON_TIME_SYS_TO_UIT32( t ) \ |
Cyg_Clock::convert( (cyg_uint64)(t), &uit_clock_from_system ) |
|
// long (cyg_uint64) versions: |
#define CYG_UITRON_TIME_UIT_TO_SYS64( t ) \ |
Cyg_Clock::convert( (t), &uit_clock_to_system ) |
|
#define CYG_UITRON_TIME_SYS_TO_UIT64( t ) \ |
Cyg_Clock::convert( (t), &uit_clock_from_system ) |
|
#else // Time is whatever the system clock is doing: |
|
// Straight through - int (cyg_int32) argument versions: |
#define CYG_UITRON_TIME_UIT_TO_SYS32( t ) ( t ) |
#define CYG_UITRON_TIME_SYS_TO_UIT32( t ) ( t ) |
// long (cyg_uint64) versions: |
#define CYG_UITRON_TIME_UIT_TO_SYS64( t ) ( t ) |
#define CYG_UITRON_TIME_SYS_TO_UIT64( t ) ( t ) |
#endif |
|
#endif // CYGVAR_KERNEL_COUNTERS_CLOCK - otherwise these should not be used. |
|
// ------------------------------------------------------------------------ |
// the function definitions themselves: |
|
// ****************************************************** |
// *** 6.5 C Language Interfaces *** |
// ****************************************************** |
|
// - Task Management Functions |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
CYG_UITRON_NEWFUNCTION( Cyg_Thread ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_tsk ( ID tskid, T_CTSK *pk_ctsk ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_ctsk ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( TASKS, tskid ); |
|
Cyg_Thread *p = &(CYG_UITRON_OBJS( TASKS )[ tskid - 1 ]); |
cyg_uint32 state = p->get_state(); |
if ( 0 == (state & Cyg_Thread::EXITED) ) |
ret = E_OBJ; // how did it get to be running? |
else if ( ((INT)p->get_stack_size()) < pk_ctsk->stksz ) |
ret = E_NOMEM; // more stack requested than available |
else { |
CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = |
new( p ) Cyg_Thread( |
(CYG_ADDRWORD) pk_ctsk->itskpri, |
(cyg_thread_entry *)pk_ctsk->task, |
(CYG_ADDRWORD) 0, |
// preserve the original name and stack: |
#ifdef CYGVAR_KERNEL_THREADS_NAME |
p->get_name(), |
#else |
NULL, |
#endif |
p->get_stack_base(), |
p->get_stack_size() ); |
// but ensure the task state is dormant: |
// (it is not constructed dormant, but suspended) |
p->kill(); |
#ifdef CYGIMP_THREAD_PRIORITY |
// and record the initial priority outside the task too. |
CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) = pk_ctsk->itskpri; |
#endif |
} |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
cyg_uint32 state = p->get_state(); |
if ( state & Cyg_Thread::EXITED ) |
// just disconnect the pointer from its object |
CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL; |
else |
ret = E_OBJ; |
Cyg_Scheduler::unlock(); |
return ret; |
} |
#endif // CYGPKG_UITRON_TASKS_CREATE_DELETE |
|
CYG_UIT_FUNC_INLINE |
ER |
sta_tsk ( ID tskid, INT stacd ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
Cyg_Scheduler::lock(); |
cyg_uint32 state = p->get_state(); |
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
// there is a race condition with deleting the task |
// so test it now that we have the scheduler locked |
if ( p != CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] ) |
ret = E_NOEXS; |
else // NOTE dangling else to the next line: |
#endif |
if ( state & Cyg_Thread::EXITED ) { |
p->reinitialize(); |
#ifdef CYGIMP_THREAD_PRIORITY |
p->set_priority( CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ) ); |
#endif |
p->set_entry_data( (CYG_ADDRWORD)stacd ); |
p->force_resume(); |
} |
else |
ret = E_OBJ; |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
void |
ext_tsk ( void ) |
{ |
Cyg_Thread::exit(); |
} |
|
CYG_UIT_FUNC_INLINE |
void |
exd_tsk ( void ) |
{ |
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
Cyg_Thread *p; |
|
Cyg_Scheduler::lock(); |
p = Cyg_Thread::self(); |
ID tskid = (p - (&cyg_uitron_TASKS[0])) + 1; |
// just disconnect the pointer from its object |
CYG_UITRON_PTRS( TASKS )[ tskid - 1 ] = NULL; |
// Any associated storage management, and possibly calling the task |
// destructor, is for future versions. |
#else |
// do nothing - deletion not supported so just exit... |
#endif |
Cyg_Thread::exit(); |
// does not return, does unlock the scheduler for us |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ter_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); |
if ( (0 != (Cyg_Thread::EXITED & p->get_state())) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
// already dormant |
ret = E_OBJ; |
else { |
p->force_resume(); // let it run |
p->kill(); // and set prio high so it runs RIGHT NOW!! |
#ifdef CYGIMP_THREAD_PRIORITY |
#if CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES != 0 |
// see if we are already at prio 0: |
if ( 0 == cyg_uitron_dis_dsp_old_priority ) |
// then dispatch is enabled, we are not at prio 0 |
#endif |
p->set_priority( (cyg_priority) 0 ); |
// if we do not do this, then we are not running a strictly |
// uITRON compatible scheduler - so just hope for the best. |
#endif |
} |
Cyg_Scheduler::unlock(); |
#ifdef CYGIMP_THREAD_PRIORITY |
#if CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES == 0 |
if ( (E_OK == ret) && (0 != cyg_uitron_dis_dsp_old_priority) ) { |
// then dispatching is disabled, so our prio is 0 too |
Cyg_Thread::yield(); // so let the dying thread run; |
Cyg_Thread::yield(); // no cost here of making sure. |
} |
#endif |
#endif |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
dis_dsp ( void ) |
{ |
CYG_UITRON_CHECK_TASK_CONTEXT(); |
CYG_UITRON_CHECK_CPU_UNLOC(); |
Cyg_Scheduler::lock(); |
// Prevent preemption by going up to prio 0 |
if ( 0 == cyg_uitron_dis_dsp_old_priority ) { |
#ifdef CYGIMP_THREAD_PRIORITY |
Cyg_Thread *p = Cyg_Thread::self(); |
cyg_uitron_dis_dsp_old_priority = p->get_priority(); |
p->set_priority( 0 ); |
#else |
cyg_uitron_dis_dsp_old_priority = 1; |
#endif |
} |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ena_dsp ( void ) |
{ |
CYG_UITRON_CHECK_TASK_CONTEXT(); |
CYG_UITRON_CHECK_CPU_UNLOC(); |
Cyg_Scheduler::lock(); |
// Enable dispatching (if disabled) and maybe switch threads |
if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
// We had prevented preemption by going up to prio 0 |
#ifdef CYGIMP_THREAD_PRIORITY |
Cyg_Thread *p = Cyg_Thread::self(); |
p->set_priority( cyg_uitron_dis_dsp_old_priority ); |
p->to_queue_head(); // to ensure we continue to run |
// if nobody higher pri |
#endif |
cyg_uitron_dis_dsp_old_priority = 0; |
} |
Cyg_Scheduler::unlock(); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards! |
return E_OK; |
} |
|
|
CYG_UIT_FUNC_INLINE |
ER |
chg_pri ( ID tskid, PRI tskpri ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
if ( 0 == tskid ) { |
p = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
} |
else |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
#ifdef CYGIMP_THREAD_PRIORITY |
if ( 0 == tskpri ) |
// then use the initial priority [Level X] |
tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ); |
#endif |
CYG_UIT_PARAMCHECK( 0 < tskpri, E_PAR ); |
#ifdef CYGIMP_THREAD_PRIORITY |
#if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY |
CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri && |
tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
#else |
CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && |
tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
#endif |
// Handle changing our own prio specially, if dispatch disabled: |
if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
// our actual prio is 0 now and must remain so: |
if ( Cyg_Thread::self() == p ) { // by whichever route p was set |
// set the priority we will return to when dispatch is enabled: |
cyg_uitron_dis_dsp_old_priority = (cyg_uint32)tskpri; |
return E_OK; |
} |
} |
Cyg_Scheduler::lock(); |
if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
ret = E_OBJ; // task is dormant |
else |
p->set_priority( (cyg_priority)tskpri ); |
Cyg_Scheduler::unlock(); |
#endif // CYGIMP_THREAD_PRIORITY got priorities at all? |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
rot_rdq ( PRI tskpri ) |
{ |
// zero means our level; easiet way is to yield() the CPU. |
if ( 0 == tskpri ) { |
Cyg_Thread::yield(); |
return E_OK; |
} |
#ifdef CYGIMP_THREAD_PRIORITY |
#if CYG_THREAD_MAX_PRIORITY < CYG_THREAD_MIN_PRIORITY |
CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY <= tskpri && |
tskpri <= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
#else |
CYG_UIT_PARAMCHECK( CYG_THREAD_MAX_PRIORITY >= tskpri && |
tskpri >= CYG_THREAD_MIN_PRIORITY, E_PAR ); |
#endif |
Cyg_Thread::rotate_queue( tskpri ); |
#endif // CYGIMP_THREAD_PRIORITY got priorities at all? |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
rel_wai ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
ret = E_OBJ; // task is dormant |
else { |
p->release(); |
// return E_OBJ if the thread was not sleeping |
if ( Cyg_Thread::BREAK != p->get_wake_reason() ) |
ret = E_OBJ; |
} |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
get_tid ( ID *p_tskid ) |
{ |
Cyg_Thread *self = Cyg_Thread::self(); |
CYG_UIT_PARAMCHECK_PTR( p_tskid ); |
if ( (&cyg_uitron_TASKS[0] <= (self)) && |
((self) < &cyg_uitron_TASKS[CYGNUM_UITRON_TASKS]) && |
(0 == Cyg_Scheduler::get_sched_lock()) ) |
// then I am a uITRON task and not in an interrupt or DSR |
*p_tskid = (self - (&cyg_uitron_TASKS[0])) + 1; |
else |
*p_tskid = 0; // Otherwise, non-task portion |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_tsk ( T_RTSK *pk_rtsk, ID tskid ) |
{ |
Cyg_Thread *p; |
if ( 0 == tskid ) { |
p = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
tskid = (p - (&cyg_uitron_TASKS[0])) + 1; // it gets used below |
} |
else |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
|
CYG_UIT_PARAMCHECK_PTR( pk_rtsk ); |
pk_rtsk->exinf = NADR; |
Cyg_Scheduler::lock(); // get an atomic view of the task |
cyg_uint32 state = p->get_state(); |
if ( (state & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
pk_rtsk->tskstat = TTS_DMT; |
else if ( state == Cyg_Thread::RUNNING ) |
// If it's us, it's running, else it's ready |
pk_rtsk->tskstat = (Cyg_Thread::self() == p) |
? TTS_RUN // RUN state (we are it) |
: TTS_RDY; // READY state |
else if ( state & Cyg_Thread::SUSPENDED ) |
pk_rtsk->tskstat = |
(state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING)) |
? TTS_WAS // WAIT-SUSPEND state |
: TTS_SUS; // SUSPEND state |
else |
pk_rtsk->tskstat = |
(state & (Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING)) |
? TTS_WAI // WAIT state |
: 0; // Not sure what's happening here! |
#ifdef CYGIMP_THREAD_PRIORITY |
if ( TTS_DMT == pk_rtsk->tskstat ) |
pk_rtsk->tskpri = CYG_UITRON_TASK_INITIAL_PRIORITY( tskid ); |
else if ( (TTS_RUN == pk_rtsk->tskstat) && |
(0 != cyg_uitron_dis_dsp_old_priority) ) |
// then we are it and dispatching is disabled, so |
// report our "real" priority - it is 0 in the kernel at the moment |
pk_rtsk->tskpri = cyg_uitron_dis_dsp_old_priority; |
else |
pk_rtsk->tskpri = p->get_priority(); |
#else |
pk_rtsk->tskpri = -1; // Not applicable |
#endif |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
|
// - Task-Dependent Synchronization Functions |
|
CYG_UIT_FUNC_INLINE |
ER |
sus_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
ret = E_OBJ; // task is dormant |
else |
p->suspend(); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
rsm_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
cyg_uint32 state = p->get_state(); |
if ( 0 == (Cyg_Thread::SUSPENDED & state) ) |
ret = E_OBJ; // thread is not suspended |
else |
p->resume(); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
frsm_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
cyg_uint32 state = p->get_state(); |
if ( 0 == (Cyg_Thread::SUSPENDED & state) ) |
ret = E_OBJ; // thread is not suspended |
else |
p->force_resume(); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
slp_tsk ( void ) |
{ |
Cyg_Thread *self = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
// do this now for the case when no sleeping actually occurs |
self->set_wake_reason( Cyg_Thread::DONE ); |
Cyg_Thread::counted_sleep(); |
if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
tslp_tsk ( TMO tmout ) |
{ |
Cyg_Thread *self = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
CYG_UIT_PARAMCHECK( -1 <= tmout, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
// do this now for the case when no sleeping actually occurs |
self->set_wake_reason( Cyg_Thread::DONE ); |
// note that TMO_POL is not treated specially, though it |
// happens to work almost as a poll (some sleeping may occur) |
if ( TMO_FEVR == tmout ) |
Cyg_Thread::counted_sleep(); |
else |
Cyg_Thread::counted_sleep( |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
wup_tsk ( ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK( Cyg_Thread::self() != p, E_OBJ ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
ret = E_OBJ; // task is dormant |
else |
p->counted_wake(); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
can_wup ( INT *p_wupcnt, ID tskid ) |
{ |
Cyg_Thread *p; |
ER ret = E_OK; |
if ( 0 == tskid ) { |
p = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( p ); |
} |
else |
CYG_UITRON_CHECK_AND_GETP_TASKS( tskid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_wupcnt ); |
Cyg_Scheduler::lock(); // get an atomic view of the task |
if ( (p->get_state() & (Cyg_Thread::EXITED | Cyg_Thread::CREATING)) || |
(Cyg_Thread::EXIT == p->get_wake_reason()) ) |
ret = E_OBJ; // task is dormant |
else { |
cyg_uint32 result = p->cancel_counted_wake(); |
*p_wupcnt = result; |
} |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
// - Synchronization and Communication Functions |
|
#ifdef CYGPKG_UITRON_SEMAS |
#if 0 < CYG_UITRON_NUM( SEMAS ) |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
CYG_UITRON_NEWFUNCTION( Cyg_Counting_Semaphore2 ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_sem ( ID semid, T_CSEM *pk_csem ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_csem ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( SEMAS, semid ); |
if ( TA_TFIFO != pk_csem->sematr ) |
ret = E_RSATR; |
else |
CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = |
new( &(CYG_UITRON_OBJS( SEMAS )[ semid - 1 ]) ) |
Cyg_Counting_Semaphore2( (cyg_count32)pk_csem->isemcnt ); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_sem ( ID semid ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
CYG_UITRON_PTRS( SEMAS )[ semid - 1 ] = NULL; |
p->~Cyg_Counting_Semaphore2(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE |
|
CYG_UIT_FUNC_INLINE |
ER |
sig_sem( ID semid ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
p->post(); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
wai_sem( ID semid ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
cyg_bool result = p->wait(); |
if ( !result ) |
CYG_UITRON_FAIL_RETURN(); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
preq_sem ( ID semid ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
cyg_bool result = p->trywait(); |
if ( !result ) |
return E_TMOUT; |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
twai_sem ( ID semid, TMO tmout ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
// do this now for the case when no sleeping actually occurs |
Cyg_Thread *self = Cyg_Thread::self(); |
self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
cyg_bool result; |
if ( TMO_FEVR == tmout ) |
result = p->wait(); |
else if ( TMO_POL == tmout ) |
result = p->trywait(); |
else |
result = p->wait( |
Cyg_Clock::real_time_clock->current_value() + |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
return E_OK; |
|
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_sem ( T_RSEM *pk_rsem, ID semid ) |
{ |
Cyg_Counting_Semaphore2 *p; |
CYG_UITRON_CHECK_AND_GETP_SEMAS( semid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_rsem ); |
pk_rsem->exinf = NADR; |
pk_rsem->wtsk = p->waiting(); |
pk_rsem->semcnt = p->peek(); |
return E_OK; |
} |
|
#endif // 0 < CYG_UITRON_NUM( SEMAS ) |
#endif // CYGPKG_UITRON_SEMAS |
|
#ifdef CYGPKG_UITRON_FLAGS |
#if 0 < CYG_UITRON_NUM( FLAGS ) |
|
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
CYG_UITRON_NEWFUNCTION( Cyg_Flag ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_flg ( ID flgid, T_CFLG *pk_cflg ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_cflg ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( FLAGS, flgid ); |
if ( 0 != ((~(TA_WMUL | TA_WSGL)) & pk_cflg->flgatr) ) |
ret = E_RSATR; |
else |
CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = |
new( &(CYG_UITRON_OBJS( FLAGS )[ flgid - 1 ]) ) |
Cyg_Flag( (Cyg_FlagValue) pk_cflg->iflgptn ); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_flg ( ID flgid ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
CYG_UITRON_PTRS( FLAGS )[ flgid - 1 ] = NULL; |
p->~Cyg_Flag(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE |
|
CYG_UIT_FUNC_INLINE |
ER |
set_flg ( ID flgid, UINT setptn ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
p->setbits( setptn ); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
clr_flg ( ID flgid, UINT clrptn ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
p->maskbits( clrptn ); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
wai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
// check we can use the wfmode value unchanged |
CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
UINT result = p->wait( waiptn, wfmode ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN(); |
*p_flgptn = result; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
pol_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
// check we can use the wfmode value unchanged |
CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
UINT result = p->poll( waiptn, wfmode ); |
if ( ! result ) |
return E_TMOUT; |
*p_flgptn = result; |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
twai_flg ( UINT *p_flgptn, ID flgid, UINT waiptn, UINT wfmode, |
TMO tmout ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_flgptn ); |
CYG_UIT_PARAMCHECK( 0 == (wfmode & ~Cyg_Flag::MASK), E_PAR ); |
CYG_UIT_PARAMCHECK( 0 != waiptn, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
// check we can use the wfmode value unchanged |
CYG_ASSERT( Cyg_Flag::AND == TWF_ANDW, "Flag AND value bad" ); |
CYG_ASSERT( Cyg_Flag::OR == TWF_ORW, "Flag OR value bad" ); |
CYG_ASSERT( Cyg_Flag::CLR == TWF_CLR, "Flag CLR value bad" ); |
|
// do this now for the case when no sleeping actually occurs |
Cyg_Thread *self = Cyg_Thread::self(); |
self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
UINT result; |
if ( TMO_FEVR == tmout ) |
result = p->wait( waiptn, wfmode ); |
else if ( TMO_POL == tmout ) |
result = p->poll( waiptn, wfmode ); |
else |
result = p->wait( waiptn, wfmode, |
Cyg_Clock::real_time_clock->current_value() + |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
*p_flgptn = result; |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_flg ( T_RFLG *pk_rflg, ID flgid ) |
{ |
Cyg_Flag *p; |
CYG_UITRON_CHECK_AND_GETP_FLAGS( flgid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_rflg ); |
pk_rflg->exinf = NADR; |
pk_rflg->wtsk = p->waiting(); |
pk_rflg->flgptn = p->peek(); |
return E_OK; |
} |
|
#endif // 0 < CYG_UITRON_NUM( FLAGS ) |
#endif // CYGPKG_UITRON_FLAGS |
|
#ifdef CYGPKG_UITRON_MBOXES |
#if 0 < CYG_UITRON_NUM( MBOXES ) |
|
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
CYG_UITRON_NEWFUNCTION( Cyg_Mbox ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_mbx ( ID mbxid, T_CMBX* pk_cmbx ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_cmbx ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MBOXES, mbxid ); |
if ( ((ATR)(TA_TFIFO + TA_MFIFO)) != pk_cmbx->mbxatr ) |
ret = E_RSATR; |
else |
CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = |
new( &(CYG_UITRON_OBJS( MBOXES )[ mbxid - 1 ]) ) |
Cyg_Mbox(); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_mbx ( ID mbxid ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
CYG_UITRON_PTRS( MBOXES )[ mbxid - 1 ] = NULL; |
p->~Cyg_Mbox(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE |
|
// This bit of unpleasantness is to allow uITRON programs to send a NULL |
// message - if permitted by the parameter checking. |
// |
// NULL is used internally to mean no message; but -1 is fine. So we send |
// a NULL as a NADR and if we see a NULL coming back, change it to a NADR. |
// |
// One hopes that often this will be optimized out, since the one or both |
// of these being true has been detected and errored out just above. |
|
#ifdef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
// represent a NULL as NADR internally |
#define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_MACRO_START \ |
if ( NULL == (_p_) ) \ |
(_p_) = (T_MSG *)NADR; \ |
CYG_MACRO_END |
|
// we get a NADR back sometimes, meaning NULL |
#define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_MACRO_START \ |
if ( NADR == (_p_) ) \ |
(_p_) = (T_MSG *)NULL; \ |
CYG_MACRO_END |
|
#else |
// NULL is checked for and makes an error |
#define CYG_UIT_TMSG_FIXUP_IN( _p_ ) CYG_EMPTY_STATEMENT |
#define CYG_UIT_TMSG_FIXUP_OUT( _p_ ) CYG_EMPTY_STATEMENT |
#endif |
|
// and sometimes either in status enquiries |
#define CYG_UIT_TMSG_FIXUP_ALL( _p_ ) CYG_MACRO_START \ |
if ( NULL == (_p_) ) \ |
(_p_) = (T_MSG *)NADR; \ |
else if ( NADR == (_p_) ) \ |
(_p_) = (T_MSG *)NULL; \ |
CYG_MACRO_END |
|
CYG_UIT_FUNC_INLINE |
ER |
snd_msg ( ID mbxid, T_MSG *pk_msg ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_msg ); |
CYG_UIT_TMSG_FIXUP_IN( pk_msg ); |
cyg_bool result = p->tryput( (void *)pk_msg ); |
if ( ! result ) |
return E_QOVR; |
return E_OK; |
} |
|
|
CYG_UIT_FUNC_INLINE |
ER |
rcv_msg ( T_MSG **ppk_msg, ID mbxid ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
T_MSG *result = (T_MSG *)p->get(); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN(); |
CYG_UIT_TMSG_FIXUP_OUT( result ); |
*ppk_msg = result; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
prcv_msg ( T_MSG **ppk_msg, ID mbxid ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
T_MSG *result = (T_MSG *)p->tryget(); |
if ( ! result ) |
return E_TMOUT; |
CYG_UIT_TMSG_FIXUP_OUT( result ); |
*ppk_msg = result; |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
trcv_msg ( T_MSG **ppk_msg, ID mbxid, TMO tmout ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
CYG_UIT_PARAMCHECK_PTR( ppk_msg ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
// do this now for the case when no sleeping actually occurs |
Cyg_Thread *self = Cyg_Thread::self(); |
self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
T_MSG *result; |
if ( TMO_FEVR == tmout ) |
result = (T_MSG *)p->get(); |
else if ( TMO_POL == tmout ) |
result = (T_MSG *)p->tryget(); |
else |
result = (T_MSG *)p->get( |
Cyg_Clock::real_time_clock->current_value() + |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
CYG_UIT_TMSG_FIXUP_OUT( result ); |
*ppk_msg = result; |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_mbx ( T_RMBX *pk_rmbx, ID mbxid ) |
{ |
Cyg_Mbox *p; |
CYG_UITRON_CHECK_AND_GETP_MBOXES( mbxid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_rmbx ); |
pk_rmbx->exinf = NADR; |
pk_rmbx->wtsk = p->waiting_to_get(); |
pk_rmbx->pk_msg = (T_MSG *)p->peek_item(); |
CYG_UIT_TMSG_FIXUP_ALL( pk_rmbx->pk_msg ); |
return E_OK; |
} |
|
#undef CYG_UIT_TMSG_FIXUP_IN |
#undef CYG_UIT_TMSG_FIXUP_OUT |
#undef CYG_UIT_TMSG_FIXUP_ALL |
|
#endif // 0 < CYG_UITRON_NUM( MBOXES ) |
#endif // CYGPKG_UITRON_MBOXES |
|
// - Extended Synchronization and Communication Functions |
|
#if 0 // NOT SUPPORTED |
ER cre_mbf ( ID mbfid, T_CMBF *pk_cmbf ); |
ER del_mbf ( ID mbfid ); |
ER snd_mbf ( ID mbfid, VP msg, INT msgsz ); |
ER psnd_mbf ( ID mbfid, VP msg, INT msgsz ); |
ER tsnd_mbf ( ID mbfid, VP msg, INT msgsz, TMO tmout ); |
ER rcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
ER prcv_mbf ( VP msg, INT *p_msgsz, ID mbfid ); |
ER trcv_mbf ( VP msg, INT *p_msgsz, ID mbfid, TMO tmout ); |
ER ref_mbf ( T_RMBF *pk_rmbf, ID mbfid ); |
ER cre_por ( ID porid, T_CPOR *pk_cpor ); |
ER del_por ( ID porid ); |
ER cal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz ); |
ER pcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz ); |
ER tcal_por ( VP msg, INT *p_rmsgsz, ID porid, UINT calptn, INT |
cmsgsz, TMO tmout ); |
ER acp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn ); |
ER pacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn ); |
ER tacp_por ( RNO *p_rdvno, VP msg, INT *p_cmsgsz, ID porid, UINT |
acpptn, TMO tmout ); |
ER fwd_por ( ID porid, UINT calptn, RNO rdvno, VP msg, INT cmsgsz |
); |
ER rpl_rdv ( RNO rdvno, VP msg, INT rmsgsz ); |
ER ref_por ( T_RPOR *pk_rpor, ID porid ); |
#endif |
|
// - Interrupt Management Functions |
|
#if 0 // NOT SUPPORTED |
ER def_int ( UINT dintno, T_DINT *pk_dint ); |
void ret_wup ( ID tskid ); |
#endif |
|
CYG_UIT_FUNC_INLINE |
ER |
loc_cpu ( void ) |
{ |
CYG_UITRON_CHECK_TASK_CONTEXT(); |
Cyg_Scheduler::lock(); |
// Prevent preemption by going up to prio 0 |
if ( 0 == cyg_uitron_dis_dsp_old_priority ) { |
#ifdef CYGIMP_THREAD_PRIORITY |
Cyg_Thread *p = Cyg_Thread::self(); |
cyg_uitron_dis_dsp_old_priority = p->get_priority(); |
p->set_priority( 0 ); |
#else |
cyg_uitron_dis_dsp_old_priority = 1; |
#endif |
} |
Cyg_Interrupt::disable_interrupts(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
unl_cpu ( void ) |
{ |
CYG_UITRON_CHECK_TASK_CONTEXT(); |
Cyg_Scheduler::lock(); |
// Enable dispatching (if disabled) and maybe switch threads |
if ( 0 != cyg_uitron_dis_dsp_old_priority ) { |
// We had prevented preemption by going up to prio 0 |
#ifdef CYGIMP_THREAD_PRIORITY |
Cyg_Thread *p = Cyg_Thread::self(); |
p->set_priority( cyg_uitron_dis_dsp_old_priority ); |
#endif |
cyg_uitron_dis_dsp_old_priority = 0; |
} |
Cyg_Interrupt::enable_interrupts(); |
Cyg_Scheduler::unlock(); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); // NB: afterwards! |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
dis_int ( UINT eintno ) |
{ |
CYG_INTERRUPT_STATE old_ints; |
|
#if 0 < CYGNUM_HAL_ISR_MIN |
CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MIN <= eintno, E_PAR ); |
#endif |
CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MAX >= eintno, E_PAR ); |
HAL_DISABLE_INTERRUPTS(old_ints); |
HAL_INTERRUPT_MASK( eintno ); |
HAL_RESTORE_INTERRUPTS(old_ints); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ena_int ( UINT eintno ) |
{ |
CYG_INTERRUPT_STATE old_ints; |
|
#if 0 < CYGNUM_HAL_ISR_MIN |
CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MIN <= eintno, E_PAR ); |
#endif |
CYG_UIT_PARAMCHECK( CYGNUM_HAL_ISR_MAX >= eintno, E_PAR ); |
HAL_DISABLE_INTERRUPTS(old_ints); |
HAL_INTERRUPT_UNMASK( eintno ); |
HAL_RESTORE_INTERRUPTS(old_ints); |
return E_OK; |
} |
|
#if 0 // NOT SUPPORTED |
ER chg_iXX ( UINT iXXXX ); |
ER ref_iXX ( UINT *p_iXXXX ); |
#endif |
|
// - Memorypool Management Functions |
#ifdef CYGPKG_UITRON_MEMPOOLVAR |
#if 0 < CYG_UITRON_NUM( MEMPOOLVAR ) |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Variable ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_mpl ( ID mplid, T_CMPL *pk_cmpl ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_cmpl ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLVAR, mplid ); |
Cyg_Mempool_Variable *p = &(CYG_UITRON_OBJS( MEMPOOLVAR )[ mplid - 1 ]); |
Cyg_Mempool_Status stat; |
|
// preserve the original memory area to use |
p->get_status( CYG_MEMPOOL_STAT_ORIGBASE|CYG_MEMPOOL_STAT_ORIGSIZE, stat ); |
|
if ( stat.origsize < pk_cmpl->mplsz ) |
ret = E_NOMEM; |
else if ( TA_TFIFO != pk_cmpl->mplatr ) |
ret = E_RSATR; |
else |
CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = |
new( p ) Cyg_Mempool_Variable( |
const_cast<cyg_uint8 *>(stat.origbase), stat.origsize ); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_mpl ( ID mplid ) |
{ |
Cyg_Mempool_Variable *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
CYG_UITRON_PTRS( MEMPOOLVAR )[ mplid - 1 ] = NULL; |
p->~Cyg_Mempool_Variable(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
|
CYG_UIT_FUNC_INLINE |
ER |
get_blk ( VP *p_blk, ID mplid, INT blksz ) |
{ |
Cyg_Mempool_Variable *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blk ); |
CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
VP result = (VP)p->alloc(blksz); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN(); |
*p_blk = result; |
return E_OK; |
} |
|
|
CYG_UIT_FUNC_INLINE |
ER |
pget_blk ( VP *p_blk, ID mplid, INT blksz ) |
{ |
Cyg_Mempool_Variable *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blk ); |
CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
VP result = (VP)p->try_alloc(blksz); |
if ( ! result ) |
return E_TMOUT; |
*p_blk = result; |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
tget_blk ( VP *p_blk, ID mplid, INT blksz, TMO tmout ) |
{ |
Cyg_Mempool_Variable *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blk ); |
CYG_UIT_PARAMCHECK( blksz > 0, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
// do this now for the case when no sleeping actually occurs |
Cyg_Thread *self = Cyg_Thread::self(); |
self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
VP result; |
if ( TMO_FEVR == tmout ) |
result = p->alloc(blksz); |
else if ( TMO_POL == tmout ) |
result = p->try_alloc(blksz); |
else |
result = p->alloc( blksz, |
Cyg_Clock::real_time_clock->current_value() + |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
*p_blk = result; |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
rel_blk ( ID mplid, VP blk ) |
{ |
Cyg_Mempool_Variable *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
CYG_UIT_PARAMCHECK_PTR( blk ); |
cyg_bool result = p->free( (cyg_uint8 *)blk ); |
if ( ! result ) |
return E_PAR; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_mpl ( T_RMPL *pk_rmpl, ID mplid ) |
{ |
Cyg_Mempool_Variable *p; |
Cyg_Mempool_Status stat; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLVAR( mplid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_rmpl ); |
p->get_status( CYG_MEMPOOL_STAT_WAITING| |
CYG_MEMPOOL_STAT_TOTALFREE| |
CYG_MEMPOOL_STAT_MAXFREE, stat ); |
|
pk_rmpl->exinf = NADR; |
pk_rmpl->wtsk = stat.waiting; |
pk_rmpl->frsz = stat.totalfree; |
pk_rmpl->maxsz = stat.maxfree; |
|
return E_OK; |
} |
|
#endif // 0 < CYG_UITRON_NUM( MEMPOOLVAR ) |
#endif // CYGPKG_UITRON_MEMPOOLVAR |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED |
#if 0 < CYG_UITRON_NUM( MEMPOOLFIXED ) |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
CYG_UITRON_NEWFUNCTION( Cyg_Mempool_Fixed ) |
|
CYG_UIT_FUNC_INLINE |
ER |
cre_mpf ( ID mpfid, T_CMPF *pk_cmpf ) |
{ |
ER ret = E_OK; |
CYG_UIT_PARAMCHECK_PTR( pk_cmpf ); |
CYG_UITRON_CHECK_NO_OBJ_LOCK_SCHED( MEMPOOLFIXED, mpfid ); |
Cyg_Mempool_Fixed *p = &(CYG_UITRON_OBJS( MEMPOOLFIXED )[ mpfid - 1 ]); |
Cyg_Mempool_Status stat; |
|
// preserve the original memory area to use |
p->get_status( CYG_MEMPOOL_STAT_ORIGBASE|CYG_MEMPOOL_STAT_ORIGSIZE, stat ); |
|
if ( stat.origsize < (pk_cmpf->blfsz * (pk_cmpf->mpfcnt + 1)) ) |
ret = E_NOMEM; |
else if ( TA_TFIFO != pk_cmpf->mpfatr ) |
ret = E_RSATR; |
else |
CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = |
new( p ) |
Cyg_Mempool_Fixed( const_cast<cyg_uint8 *>(stat.origbase), |
stat.origsize, (CYG_ADDRWORD)pk_cmpf->blfsz ); |
Cyg_Scheduler::unlock(); |
return ret; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
del_mpf ( ID mpfid ) |
{ |
Cyg_Mempool_Fixed *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
Cyg_Scheduler::lock(); |
// deal with the race condition here |
if ( p != CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] ) { |
Cyg_Scheduler::unlock(); |
return E_NOEXS; |
} |
CYG_UITRON_PTRS( MEMPOOLFIXED )[ mpfid - 1 ] = NULL; |
p->~Cyg_Mempool_Fixed(); |
Cyg_Scheduler::unlock(); |
return E_OK; |
} |
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
|
CYG_UIT_FUNC_INLINE |
ER |
get_blf ( VP *p_blf, ID mpfid ) |
{ |
Cyg_Mempool_Fixed *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blf ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
VP result = (VP)p->alloc(); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN(); |
*p_blf = result; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
pget_blf ( VP *p_blf, ID mpfid ) |
{ |
Cyg_Mempool_Fixed *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blf ); |
VP result = (VP)p->try_alloc(); |
if ( ! result ) |
return E_TMOUT; |
*p_blf = result; |
return E_OK; |
} |
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
tget_blf ( VP *p_blf, ID mpfid, TMO tmout ) |
{ |
Cyg_Mempool_Fixed *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
CYG_UIT_PARAMCHECK_PTR( p_blf ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED_TMO( tmout ); |
// do this now for the case when no sleeping actually occurs |
Cyg_Thread *self = Cyg_Thread::self(); |
self->set_wake_reason( Cyg_Thread::TIMEOUT ); |
VP result; |
if ( TMO_FEVR == tmout ) |
result = p->alloc(); |
else if ( TMO_POL == tmout ) |
result = p->try_alloc(); |
else |
result = p->alloc( |
Cyg_Clock::real_time_clock->current_value() + |
(cyg_tick_count)CYG_UITRON_TIME_UIT_TO_SYS32( tmout ) ); |
if ( ! result ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
*p_blf = result; |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
CYG_UIT_FUNC_INLINE |
ER |
rel_blf ( ID mpfid, VP blf ) |
{ |
Cyg_Mempool_Fixed *p; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
CYG_UIT_PARAMCHECK_PTR( blf ); |
cyg_bool result = p->free( (cyg_uint8 *)blf ); |
if ( ! result ) |
return E_PAR; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_mpf ( T_RMPF *pk_rmpf, ID mpfid ) |
{ |
Cyg_Mempool_Fixed *p; |
Cyg_Mempool_Status stat; |
CYG_UITRON_CHECK_AND_GETP_MEMPOOLFIXED( mpfid, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_rmpf ); |
|
p->get_status( CYG_MEMPOOL_STAT_WAITING| |
CYG_MEMPOOL_STAT_TOTALFREE| |
CYG_MEMPOOL_STAT_TOTALALLOCATED| |
CYG_MEMPOOL_STAT_BLOCKSIZE, stat ); |
|
pk_rmpf->exinf = NADR; |
pk_rmpf->wtsk = stat.waiting; |
|
pk_rmpf->frbcnt = stat.totalfree / stat.blocksize; |
// these two are "implementation dependent" ie. eCos only |
pk_rmpf->numbcnt = stat.totalallocated / stat.blocksize; |
pk_rmpf->bsize = stat.blocksize; |
|
return E_OK; |
} |
|
#endif // 0 < CYG_UITRON_NUM( MEMPOOLFIXED ) |
#endif // CYGPKG_UITRON_MEMPOOLFIXED |
|
// - Time Management Functions |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
CYG_UIT_FUNC_INLINE |
ER |
set_tim ( SYSTIME *pk_tim ) |
{ |
CYG_UIT_PARAMCHECK_PTR( pk_tim ); |
Cyg_Clock::real_time_clock->set_value( |
CYG_UITRON_TIME_UIT_TO_SYS64( *pk_tim ) ); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
get_tim ( SYSTIME *pk_tim ) |
{ |
CYG_UIT_PARAMCHECK_PTR( pk_tim ); |
*pk_tim = CYG_UITRON_TIME_SYS_TO_UIT64( |
Cyg_Clock::real_time_clock->current_value() ); |
return E_OK; |
} |
#endif // CYGVAR_KERNEL_COUNTERS_CLOCK |
|
|
#ifdef CYGFUN_KERNEL_THREADS_TIMER |
CYG_UIT_FUNC_INLINE |
ER |
dly_tsk ( DLYTIME dlytim ) |
{ |
CYG_UIT_PARAMCHECK( 0 <= dlytim, E_PAR ); |
CYG_UITRON_CHECK_DISPATCH_ENABLED(); |
if ( 0 >= dlytim ) |
return E_OK; |
Cyg_Thread *self = Cyg_Thread::self(); |
CYG_UITRON_CHECK_TASK_CONTEXT_SELF( self ); |
self->delay( CYG_UITRON_TIME_UIT_TO_SYS64( dlytim ) ); |
if ( Cyg_Thread::DONE != self->get_wake_reason() ) |
CYG_UITRON_FAIL_RETURN_SELF( self ); |
return E_OK; |
} |
#endif // CYGFUN_KERNEL_THREADS_TIMER |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
#ifdef CYGPKG_UITRON_CYCLICS |
#if 0 < CYG_UITRON_NUM( CYCLICS ) |
CYG_UIT_FUNC_INLINE |
ER |
def_cyc ( HNO cycno, T_DCYC *pk_dcyc ) |
{ |
// pk_dcyc->cycatr is ignored |
// The only relevant attribute is TA_HLNG/TA_ASM. |
// This can be ignored as assembler routines are defined to be |
// more conservative with registers than the procedure call standard. |
cyg_tick_count t; |
Cyg_Timer *p; |
CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
CYG_UIT_PARAMCHECK( NULL != pk_dcyc, E_PAR ); |
#endif |
if( NADR == pk_dcyc ) { |
p->~Cyg_Timer(); |
return E_OK; |
} |
CYG_UIT_PARAMCHECK( 0 == (pk_dcyc->cycact & ~TCY_ON), E_PAR ); |
CYG_UIT_PARAMCHECK( 0 < pk_dcyc->cyctim, E_PAR ); |
t = CYG_UITRON_TIME_UIT_TO_SYS64( pk_dcyc->cyctim ); |
p->initialize( |
Cyg_Clock::real_time_clock, |
(cyg_alarm_fn *)pk_dcyc->cychdr, |
(CYG_ADDRWORD)pk_dcyc->exinf, |
Cyg_Clock::real_time_clock->current_value() + t, |
t, |
pk_dcyc->cycact); |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
act_cyc ( HNO cycno, UINT cycact ) |
{ |
Cyg_Timer *p; |
CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
CYG_UIT_PARAMCHECK( 0 == (cycact & ~(TCY_ON | TCY_INI)), E_PAR ); |
p->activate(cycact); |
return E_OK; |
} |
|
|
CYG_UIT_FUNC_INLINE |
ER |
ref_cyc ( T_RCYC *pk_rcyc, HNO cycno ) |
{ |
Cyg_Timer *p; |
cyg_tick_count t; |
CYG_UITRON_CHECK_AND_GETHDLR( CYCLICS, cycno, p ); |
CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
CYG_UIT_PARAMCHECK_PTR( pk_rcyc ); |
|
pk_rcyc->exinf = (VP)p->get_data(); |
Cyg_Scheduler::lock(); |
t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value(); |
Cyg_Scheduler::unlock(); |
pk_rcyc->lfttim = CYG_UITRON_TIME_SYS_TO_UIT64( t ); |
pk_rcyc->cycact = (UINT)p->is_enabled(); |
return E_OK; |
} |
#endif // 0 < CYG_UITRON_NUM( CYCLICS ) |
#endif // CYGPKG_UITRON_CYCLICS |
|
#ifdef CYGPKG_UITRON_ALARMS |
#if 0 < CYG_UITRON_NUM( ALARMS ) |
CYG_UIT_FUNC_INLINE |
ER |
def_alm ( HNO almno, T_DALM *pk_dalm ) |
{ |
Cyg_Timer *p; |
cyg_tick_count t, now; |
CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p ); |
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
CYG_UIT_PARAMCHECK( NULL != pk_dalm, E_PAR ); |
#endif |
if( NADR == pk_dalm ) { |
p->~Cyg_Timer(); |
return E_OK; |
} |
|
CYG_UIT_PARAMCHECK( 0 == (pk_dalm->tmmode & ~TTM_REL), E_PAR ); |
CYG_UIT_PARAMCHECK( 0 < pk_dalm->almtim, E_PAR ); |
|
// make the time arithmetic safe without locking |
now = Cyg_Clock::real_time_clock->current_value(); |
t = CYG_UITRON_TIME_UIT_TO_SYS64( pk_dalm->almtim ); |
if( TTM_REL & pk_dalm->tmmode ) |
t += now; |
|
CYG_UIT_PARAMCHECK( now < t, E_PAR ); |
|
p->initialize(Cyg_Clock::real_time_clock, |
(cyg_alarm_fn *)pk_dalm->almhdr, |
(CYG_ADDRWORD)pk_dalm->exinf, |
t, 0, Cyg_Timer::ENABLE); |
|
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_alm ( T_RALM *pk_ralm, HNO almno ) |
{ |
Cyg_Timer *p; |
cyg_tick_count t; |
|
CYG_UITRON_CHECK_AND_GETHDLR( ALARMS, almno, p ); |
CYG_UIT_PARAMCHECK_PTR( pk_ralm ); |
CYG_UIT_PARAMCHECK( p->is_initialized(), E_NOEXS); |
|
Cyg_Scheduler::lock(); |
t = p->get_trigger() - Cyg_Clock::real_time_clock->current_value(); |
Cyg_Scheduler::unlock(); |
pk_ralm->exinf = (VP)p->get_data(); |
pk_ralm->lfttim = CYG_UITRON_TIME_SYS_TO_UIT64( t ); |
return E_OK; |
} |
#endif // 0 < CYG_UITRON_NUM( ALARMS ) |
#endif // CYGPKG_UITRON_ALARMS |
|
#endif // CYGVAR_KERNEL_COUNTERS_CLOCK |
|
// - System Management Functions |
|
CYG_UIT_FUNC_INLINE |
ER |
get_ver ( T_VER *pk_ver ) |
{ |
CYG_UIT_PARAMCHECK_PTR( pk_ver ); |
|
pk_ver->maker = CYGNUM_UITRON_VER_MAKER; |
pk_ver->id = CYGNUM_UITRON_VER_ID; |
pk_ver->spver = CYGNUM_UITRON_VER_SPVER; |
pk_ver->prver = CYGNUM_UITRON_VER_PRVER; |
pk_ver->prno[0] = CYGNUM_UITRON_VER_PRNO_0; |
pk_ver->prno[1] = CYGNUM_UITRON_VER_PRNO_1; |
pk_ver->prno[2] = CYGNUM_UITRON_VER_PRNO_2; |
pk_ver->prno[3] = CYGNUM_UITRON_VER_PRNO_3; |
pk_ver->cpu = CYGNUM_UITRON_VER_CPU; |
pk_ver->var = CYGNUM_UITRON_VER_VAR; |
|
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_sys ( T_RSYS *pk_rsys ) |
{ |
CYG_UIT_PARAMCHECK_PTR( pk_rsys ); |
if ( ! Cyg_Interrupt::interrupts_enabled() ) |
// CPU is locked |
pk_rsys->sysstat = TSS_LOC; |
else |
pk_rsys->sysstat = |
(0 == cyg_uitron_dis_dsp_old_priority) ? TSS_TSK : TSS_DDSP; |
return E_OK; |
} |
|
CYG_UIT_FUNC_INLINE |
ER |
ref_cfg ( T_RCFG *pk_rcfg ) |
{ |
CYG_UIT_PARAMCHECK_PTR( pk_rcfg ); |
// no details here yet |
return E_OK; |
} |
|
#if 0 // NOT SUPPORTED |
ER def_svc ( FN s_fncd, T_DSVC *pk_dsvc ); |
ER def_exc ( UINT exckind, T_DEXC *pk_dexc ); |
#endif |
|
// - Network Support Functions |
|
#if 0 // NOT SUPPORTED |
ER nrea_dat ( INT *p_reasz, VP dstadr, NODE srcnode, VP srcadr, |
INT datsz ); |
ER nwri_dat ( INT *p_wrisz, NODE dstnode, VP dstadr, VP srcadr, |
INT datsz ); |
ER nget_nod ( NODE *p_node ); |
ER nget_ver ( T_VER *pk_ver, NODE node ); |
#endif |
|
// ======================================================================== |
|
#endif // CYGPKG_UITRON |
|
#endif // CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
|
#endif // CYGONCE_COMPAT_UITRON_UIT_FUNC_INL |
//EOF uit_func.inl |
/v2_0/doc/uitron.sgml
0,0 → 1,1385
<!-- {{{ Banner --> |
|
<!-- =============================================================== --> |
<!-- --> |
<!-- uitron.sgml --> |
<!-- --> |
<!-- uITRON Compatibility --> |
<!-- --> |
<!-- =============================================================== --> |
<!-- ####COPYRIGHTBEGIN#### --> |
<!-- --> |
<!-- =============================================================== --> |
<!-- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. --> |
<!-- This material may be distributed only subject to the terms --> |
<!-- and conditions set forth in the Open Publication License, v1.0 --> |
<!-- or later (the latest version is presently available at --> |
<!-- http://www.opencontent.org/openpub/) --> |
<!-- Distribution of the work or derivative of the work in any --> |
<!-- standard (paper) book form is prohibited unless prior --> |
<!-- permission obtained from the copyright holder --> |
<!-- =============================================================== --> |
<!-- --> |
<!-- ####COPYRIGHTEND#### --> |
<!-- =============================================================== --> |
<!-- #####DESCRIPTIONBEGIN#### --> |
<!-- --> |
<!-- ####DESCRIPTIONEND#### --> |
<!-- =============================================================== --> |
|
<!-- }}} --> |
|
<part id="compat-uitron"> |
<title>µITRON</title> |
<CHAPTER id="compat-uitron-microitron-api"> |
<TITLE><!-- <xref> -->µITRON API</TITLE> |
<SECT1 id="compat-uitron-introduction"> |
<TITLE><!-- <index></index> -->Introduction to µITRON</TITLE> |
<PARA>The <!-- <index></index> -->µITRON specification |
defines a highly flexible operating system architecture designed |
specifically for application in embedded systems. The specification addresses |
features which are common to the majority of processor architectures and |
deliberately avoids virtualization which would adversely impact |
real-time performance. The µITRON specification |
may be implemented on many hardware platforms and provides significant |
advantages by reducing the effort involved in understanding and |
porting application software to new processor architectures. </PARA> |
<PARA>Several revisions of the µITRON specification exist. |
In this release, <EMPHASIS>eCos</EMPHASIS> supports the |
µITRON version 3.02 specification, with complete |
“Standard functionality” (level S), plus many |
“Extended” (level E) functions. The definitive |
reference on µITRON is Dr. Sakamura’s book: |
<CITETITLE>µITRON 3.0, An Open and Portable Real-Time Operating |
System for Embedded Systems</CITETITLE>. |
The book can be purchased from the IEEE Press, and |
an ASCII version of the standard can be found online at |
<ulink url="http://www.itron.gr.jp/">http://www.itron.gr.jp/</ulink>. |
The old address |
<ulink url="http://tron.um.u-tokyo.ac.jp/TRON/ITRON/"> |
http://tron.um.u-tokyo.ac.jp/TRON/ITRON/</ulink> |
still exists as a mirror site. </PARA> |
</SECT1> |
<SECT1 id="compat-uitron-over-ecos"> |
<TITLE><!-- <index></index> -->µITRON and <EMPHASIS>eCos</EMPHASIS></TITLE> |
<PARA>The <EMPHASIS>eCos</EMPHASIS> kernel implements the functionality |
used by the µITRON compatibility subsystem. |
The configuration of the kernel influences the behavior of µITRON |
programs.</PARA> |
<PARA>In particular, the default configuration has time slicing |
(also known as round-robin scheduling) switched on; this means that |
a task can be moved from <varname>RUN</varname> state |
to <varname>READY</varname> state at any time, in |
order that one of its peers may run. This is not strictly conformant |
to the µITRON specification, which |
states that timeslicing may be implemented by periodically issuing |
a <literal>rot_rdq(0)</literal> call from |
within a periodic task or cyclic handler; otherwise it is expected |
that a task runs until it is pre-empted in consequence of synchronization |
or communication calls it makes, or the effects of an interrupt |
or other external event on a higher priority task cause that task |
to become <varname>READY</varname>. To disable timeslicing |
functionality in the kernel and µITRON |
compatibility environment, please disable the |
<LITERAL>CYGSEM_KERNEL_SCHED_TIMESLICE</LITERAL> |
configuration option in the kernel package. A description of kernel |
scheduling is in <xref linkend="kernel-overview">. </PARA> |
<PARA>For another example, the semantics of task queueing when waiting |
on a synchronization object depend solely on the way the underlying |
kernel is configured. As discussed above, the multi-level queue |
scheduler is the only one which is µITRON |
compliant, and it queues waiting tasks in FIFO order. Future releases |
of that scheduler might be configurable to support priority ordering |
of task queues. Other schedulers might be different again: for example |
the bitmap scheduler can be used with the µITRON |
compatibility layer, even though it only allows one task at each |
priority and as such is not µITRON |
compliant, but it supports only priority ordering of task queues. |
So which queueing scheme is supported is not really a property of |
the µITRON compatibility layer; it |
depends on the kernel. </PARA> |
<PARA>In this version of the µITRON |
compatibility layer, the calls to disable and enable scheduling |
and interrupts (<FUNCTION>dis_dsp()</FUNCTION>, |
<FUNCTION>ena_dsp()</FUNCTION>, <FUNCTION>loc_cpu()</FUNCTION> |
and <FUNCTION>unl_cpu()</FUNCTION>) |
call underlying kernel functions; in particular, the <FUNCTION>xxx_dsp()</FUNCTION> functions |
lock the scheduler entirely, which prevents dispatching of DSRs; functions |
implemented by DSRs include clock counters and alarm timers. Thus time “stops” while |
dispatching is disabled with <FUNCTION>dis_dsp()</FUNCTION>. </PARA> |
<PARA>Like all parts of the <EMPHASIS>eCos</EMPHASIS> system, the |
detailed semantics of the µITRON layer |
are dependent on its configuration and the configuration of other components |
that it uses. The µITRON configuration |
options are all defined in the file <filename>pkgconf/uitron.h</filename>, |
and can be set using the configuration tool or editing the |
<filename>.ecc</filename> |
file in your build directory by hand. </PARA> |
<PARA>An important configuration option for the µITRON |
compatibility layer is “Option: Return Error Codes for Bad Params” |
( |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
), which allows a lot of the error |
checking code in the µITRON compatibility layer to |
be removed. Of course this leaves a program open to undetected errors, |
so it should only be used once an application is fully debugged and |
tested. Its benefits include reduced code size and faster execution. |
However, it affects the API significantly, in that with this option |
enabled, bad calls do not return errors, but cause an assert |
failure (if that is itself enabled) or malfunction internally. There |
is discussion in more detail about this in each section below.</PARA> |
<PARA>We now give a brief description of the µITRON |
functions which are implemented in this release. Note that all C |
and C++ source files should have the following <literal>#include</literal> statement: </PARA> |
<PROGRAMLISTING>#include <cyg/compat/uitron/uit_func.h></PROGRAMLISTING> |
</SECT1> |
<SECT1 id="compat-uitron-task-management-functions"> |
<TITLE><!-- <index></index> -->Task Management Functions</TITLE> |
<PARA>The following functions are fully supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>sta_tsk</FUNCTION>( |
ID <EMPHASIS>tskid,</EMPHASIS> |
INT <EMPHASIS>stacd</EMPHASIS> )</programlisting> |
<programlisting> |
void <FUNCTION>ext_tsk</FUNCTION>( void )</programlisting> |
<programlisting> |
void <FUNCTION>exd_tsk</FUNCTION>( void )</programlisting> |
<programlisting> |
ER <FUNCTION>dis_dsp</FUNCTION>( void )</programlisting> |
<programlisting> |
ER <FUNCTION>ena_dsp</FUNCTION>( void )</programlisting> |
<programlisting> |
ER <FUNCTION>chg_pri</FUNCTION>( |
ID <EMPHASIS>tskid,</EMPHASIS> |
PRI <EMPHASIS>tskpri</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>rot_rdq</FUNCTION>( |
PRI <EMPHASIS>tskpri</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>get_tid</FUNCTION>( |
ID *<EMPHASIS>p_tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>ref_tsk</FUNCTION>( |
T_RTSK *<EMPHASIS>pk_rtsk,</EMPHASIS> |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>ter_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>rel_wai</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</PROGRAMLISTING> |
<PARA>The following two functions are supported in this release, |
when enabled with the configuration option |
<LITERAL>CYGPKG_UITRON_TASKS_CREATE_DELETE</LITERAL> |
with some restrictions:</PARA> |
<PROGRAMLISTING>ER <FUNCTION>cre_tsk</FUNCTION>( |
ID <EMPHASIS>tskid,</EMPHASIS> |
T_CTSK *<EMPHASIS>pk_ctsk</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>del_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</PROGRAMLISTING> |
<PARA>These functions are restricted as follows:</PARA> |
<PARA>Because of the static initialization facilities provided for |
system objects, a task is allocated stack space statically in the |
configuration. So while tasks can be created and deleted, the same |
stack space is used for that task (task ID number) each time. Thus |
the stack size (pk_ctsk->stksz) requested in <FUNCTION>cre_tsk()</FUNCTION> is |
checked for being less than that which was statically allocated, |
and otherwise ignored. This ensures that the new task will have |
enough stack to run. For this reason <FUNCTION>del_tsk()</FUNCTION> does |
not in any sense free the memory that was in use for the task's |
stack. </PARA> |
<PARA>The task attributes (pk_ctsk->tskatr) are |
ignored; current versions of <EMPHASIS>eCos</EMPHASIS> do not need |
to know whether a task is written in assembler or C/C++ so |
long as the procedure call standard appropriate to the CPU is followed.</PARA> |
<PARA>Extended information (pk_ctsk->exinf) is |
ignored.</PARA> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>For all these calls, an invalid task id (tskid) (less than |
1 or greater than the number of configured tasks) only returns E_ID |
when bad params return errors ( |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled, see above).</PARA> |
<PARA>Similarly, the following conditions are only checked for, |
and only return errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>pk_crtk in |
<FUNCTION>cre_tsk()</FUNCTION> |
is a valid pointer, otherwise return E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>ter_tsk()</FUNCTION> |
or |
<FUNCTION>rel_wai()</FUNCTION> |
on the calling task returns E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>the CPU is not locked already in |
<FUNCTION>dis_dsp()</FUNCTION> |
and |
<FUNCTION>ena_dsp()</FUNCTION> |
; returns E_CTX</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>priority level in |
<FUNCTION>chg_pri()</FUNCTION> |
and |
<FUNCTION>rot_rdq()</FUNCTION> |
is checked for validity, E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in |
<FUNCTION>get_tid()</FUNCTION> |
and |
<FUNCTION>ref_tsk()</FUNCTION> |
is a valid pointer, or E_PAR</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
<PARA>The following conditions are checked for, and return |
error codes if appropriate, regardless of the setting of |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>When create and delete functions |
<FUNCTION>cre_tsk()</FUNCTION> |
and |
<FUNCTION>del_tsk()</FUNCTION> |
are supported, all calls which use a valid task ID number check |
that the task exists; if not, E_NOEXS is returned</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>When supported, |
<FUNCTION>cre_tsk()</FUNCTION> |
: the task must not already exist; otherwise E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>When supported, |
<FUNCTION>cre_tsk()</FUNCTION> |
: the requested stack size must not be larger than that statically |
configured for the task; see the configuration options |
“Static initializers”, and “Default stack size”. |
Else E_NOMEM</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>When supported, |
<FUNCTION>del_tsk()</FUNCTION> |
: the underlying |
<EMPHASIS>eCos</EMPHASIS> |
thread must not be running - this would imply either a bug or some |
program bypassing the |
µITRON compatibility layer and manipulating the thread directly. |
E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>sta_tsk()</FUNCTION> |
: the task must be dormant, else E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>ter_tsk()</FUNCTION> |
: the task must not be dormant, else E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>chg_pri()</FUNCTION> |
: the task must not be dormant, else E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>rel_wai()</FUNCTION> |
: the task must be in |
<varname>WAIT</varname> or <varname>WAIT-SUSPEND</varname> |
state, else E_OBJ</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-task-dependent-synch-functions"> |
<TITLE><!-- <index></index> -->Task-Dependent Synchronization Functions</TITLE> |
<PARA>These functions are fully supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>sus_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>rsm_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>frsm_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>slp_tsk</FUNCTION>( void )</programlisting> |
<programlisting> |
ER <FUNCTION>tslp_tsk</FUNCTION>( |
TMO <EMPHASIS>tmout</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>wup_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>can_wup</FUNCTION>( |
INT *<EMPHASIS>p_wupcnt,</EMPHASIS> ID <EMPHASIS>tskid</EMPHASIS> )</PROGRAMLISTING> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>The following conditions are only checked for, and only return |
errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled (see the configuration option “Return Error Codes for Bad |
Params”):</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>invalid tskid; less than 1 or greater than |
<LITERAL>CYGNUM_UITRON_TASKS</LITERAL> |
returns E_ID</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>wup_tsk()</FUNCTION> |
, |
<FUNCTION>sus_tsk()</FUNCTION> |
, |
<FUNCTION>rsm_tsk()</FUNCTION> |
, |
<FUNCTION>frsm_tsk()</FUNCTION> |
on the calling task returns E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>dispatching is enabled in |
<FUNCTION>tslp_tsk()</FUNCTION> |
and |
<FUNCTION>slp_tsk()</FUNCTION> |
, or E_CTX</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>tmout must be positive, otherwise E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in |
<FUNCTION>can_wup()</FUNCTION> |
is a valid pointer, or E_PAR</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
<PARA>The following conditions are checked for, and can |
return error codes, regardless of the setting of |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL>: |
</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>When create and delete functions |
<FUNCTION>cre_tsk()</FUNCTION> |
and |
<FUNCTION>del_tsk()</FUNCTION> |
are supported, all calls which use a valid task ID number check |
that the task exists; if not, E_NOEXS is returned</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>sus_tsk()</FUNCTION> |
: the task must not be dormant, else E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>frsm/rsm_tsk()</FUNCTION> |
: the task must be suspended, else E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>tslp/slp_tsk()</FUNCTION> |
: return codes E_TMOUT, E_RLWAI and E_DLT |
are returned depending on the reason for terminating the sleep</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>wup_tsk()</FUNCTION> |
and |
<FUNCTION>can_wup()</FUNCTION> |
: the task must not be dormant, or E_OBJ is returned</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-sync-and-comm-functions"> |
<TITLE><!-- <index></index> --> Synchronization and Communication Functions</TITLE> |
<PARA>These functions are fully supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>sig_sem</FUNCTION>( |
ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>wai_sem</FUNCTION>( |
ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>preq_sem</FUNCTION>( |
ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>twai_sem</FUNCTION>( |
ID <EMPHASIS>semid,</EMPHASIS> TMO <EMPHASIS>tmout</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_sem</FUNCTION>( |
T_RSEM *<EMPHASIS>pk_rsem ,</EMPHASIS> ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>set_flg</FUNCTION>( |
ID <EMPHASIS>flgid,</EMPHASIS> UINT <EMPHASIS>setptn</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>clr_flg</FUNCTION>( |
ID <EMPHASIS>flgid,</EMPHASIS> UINT <EMPHASIS>clrptn</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>wai_flg</FUNCTION>( |
UINT *<EMPHASIS>p_flgptn,</EMPHASIS> ID <EMPHASIS>flgid ,</EMPHASIS> |
UINT <EMPHASIS>waiptn ,</EMPHASIS> UINT <EMPHASIS>wfmode</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>pol_flg</FUNCTION>( |
UINT *<EMPHASIS>p_flgptn,</EMPHASIS> ID <EMPHASIS>flgid ,</EMPHASIS> |
UINT <EMPHASIS>waiptn ,</EMPHASIS> UINT <EMPHASIS>wfmode</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>twai_flg</FUNCTION>( |
UINT *<EMPHASIS>p_flgptn</EMPHASIS> ID <EMPHASIS>flgid ,</EMPHASIS> |
UINT <EMPHASIS>waiptn ,</EMPHASIS> UINT <EMPHASIS>wfmode,</EMPHASIS> TMO <EMPHASIS>tmout</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_flg</FUNCTION>( |
T_RFLG *<EMPHASIS>pk_rflg,</EMPHASIS> ID <EMPHASIS>flgid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>snd_msg</FUNCTION>( |
ID <EMPHASIS>mbxid,</EMPHASIS> T_MSG <EMPHASIS>*pk_msg</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>rcv_msg</FUNCTION>( |
T_MSG **<EMPHASIS>ppk_msg,</EMPHASIS> ID <EMPHASIS>mbxid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>prcv_msg</FUNCTION>( |
T_MSG **<EMPHASIS>ppk_msg,</EMPHASIS> ID <EMPHASIS>mbxid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>trcv_msg</FUNCTION>( |
T_MSG **<EMPHASIS>ppk_msg,</EMPHASIS> ID <EMPHASIS>mbxid ,</EMPHASIS> TMO <EMPHASIS>tmout</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_mbx</FUNCTION>( |
T_RMBX *<EMPHASIS>pk_rmbx,</EMPHASIS> ID <EMPHASIS>mbxid</EMPHASIS> )</PROGRAMLISTING> |
<PARA>The following functions are supported in this release (with |
some restrictions) if enabled with the appropriate configuration |
option for the object type (for example |
<LITERAL>CYGPKG_UITRON_SEMAS_CREATE_DELETE</LITERAL>): |
</PARA> |
<PROGRAMLISTING>ER <FUNCTION>cre_sem</FUNCTION>( |
ID <EMPHASIS>semid,</EMPHASIS> T_CSEM *<EMPHASIS>pk_csem</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>del_sem</FUNCTION>( |
ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>cre_flg</FUNCTION>( |
ID <EMPHASIS>flgid,</EMPHASIS> T_CFLG *<EMPHASIS>pk_cflg</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>del_flg</FUNCTION>( |
ID <EMPHASIS>flgid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>cre_mbx</FUNCTION>( |
ID <EMPHASIS>mbxid,</EMPHASIS> T_CMBX *<EMPHASIS>pk_cmbx</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>del_mbx</FUNCTION>( |
ID <EMPHASIS>mbxid</EMPHASIS> )</PROGRAMLISTING> |
<PARA>In general the queueing order when waiting on a synchronization |
object depends on the underlying kernel configuration. The multi-level |
queue scheduler is required for strict µITRON |
conformance and it queues tasks in FIFO order, so requests to create |
an object with priority queueing of tasks (<literal>pk_cxxx->xxxatr = TA_TPRI</literal>) |
are rejected with E_RSATR. Additional undefined bits in |
the attributes fields must be zero. </PARA> |
<PARA>In general, extended information (pk_cxxx->exinf) |
is ignored. </PARA> |
<PARA>For semaphores, the initial semaphore count (pk_csem->isemcnt) |
is supported; the new semaphore's count is set. The maximum |
count is not supported, and is not in fact defined in type pk_csem. </PARA> |
<PARA>For flags, multiple tasks are allowed to wait. Because single |
task waiting is a subset of this, the W bit (TA_WMUL) of |
the flag attributes is ignored; all other bits must be zero. The |
initial flag value is supported. </PARA> |
<PARA>For mailboxes, the buffer count is defined statically by kernel |
configuration option |
<LITERAL>CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE</LITERAL>; |
therefore the buffer count field is not supported and is not in |
fact defined in type pk_cmbx. Queueing of messages is FIFO |
ordered only, so TA_MPRI (in pk_cmbx->mbxatr) |
is not supported. </PARA> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>The following conditions are only checked for, and only return |
errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>invalid object id; less than 1 or greater than |
<LITERAL>CYGNUM_UITRON_TASKS/SEMAS/MBOXES</LITERAL> |
as appropriate returns E_ID</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>dispatching is enabled in any call which can sleep, or |
E_CTX</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>tmout must be positive, otherwise E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>pk_cxxx pointers in |
<FUNCTION>cre_xxx()</FUNCTION> |
must be valid pointers, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in |
<FUNCTION>ref_xxx()</FUNCTION> |
is valid pointer, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>flag wait pattern must be non-zero, and mode must be valid, |
or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in flag wait calls is a valid pointer, |
or E_PAR</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
<PARA>The following conditions are checked for, and can return error |
codes, regardless of the setting of |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>When create and delete functions |
<FUNCTION>cre_xxx()</FUNCTION> |
and |
<FUNCTION>del_xxx()</FUNCTION> |
are supported, all calls which use a valid object ID number check |
that the object exists. If not, E_NOEXS is returned.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In create functions |
<FUNCTION>cre_xxx()</FUNCTION> |
, when supported, if the object already exists, then E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In any call which can sleep, such as |
<FUNCTION>twai_sem()</FUNCTION> |
: return codes E_TMOUT, E_RLWAI, E_DLT |
or of course E_OK are returned depending on the reason |
for terminating the sleep</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In polling functions such as |
<FUNCTION>preq_sem()</FUNCTION> |
return codes E_TMOUT or E_OK are returned depending |
on the state of the synchronization object</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In creation functions, the attributes must be compatible |
with the selected underlying kernel configuration: in |
<FUNCTION>cre_sem()</FUNCTION> |
<literal>pk_csem->sematr</literal> |
must be equal to |
<literal>TA_TFIFO</literal> |
else E_RSATR.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In |
<FUNCTION>cre_flg()</FUNCTION> |
<literal>pk_cflg->flgatr</literal> |
must be either |
<varname>TA_WMUL</varname> |
or |
<varname>TA_WSGL</varname> |
else <varname>E_RSATR</varname>.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In |
<FUNCTION>cre_mbx()</FUNCTION> |
|
<LITERAL>pk_cmbx->mbxatr</LITERAL> |
must be |
<LITERAL>TA_TFIFO + TA_MFIFO</LITERAL> |
else E_RSATR.</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-extended-sync-comm-functions"> |
<TITLE><!-- <index></index> -->Extended Synchronization and Communication Functions</TITLE> |
<PARA>None of these functions are supported in this release. </PARA> |
</SECT1> |
<SECT1 id="compat-uitron-interrupt-management-functions"> |
<TITLE><!-- <index></index> -->Interrupt management functions</TITLE> |
<PARA>These functions are fully supported in this release:</PARA> |
<PROGRAMLISTING>void <FUNCTION> ret_int</FUNCTION>( void ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>loc_cpu</FUNCTION>( void ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>unl_cpu</FUNCTION>( void ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>dis_int</FUNCTION>( |
UINT <EMPHASIS>eintno</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ena_int</FUNCTION>( |
UINT <EMPHASIS>eintno</EMPHASIS> ) |
</programlisting> |
<programlisting> |
void <FUNCTION>ret_wup</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>iwup_tsk</FUNCTION>( |
ID <EMPHASIS>tskid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>isig_sem</FUNCTION>( |
ID <EMPHASIS>semid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>iset_flg</FUNCTION>( |
ID <EMPHASIS>flgid ,</EMPHASIS> |
UID<EMPHASIS> setptn</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>isend_msg</FUNCTION>( |
ID <EMPHASIS>mbxid ,</EMPHASIS> |
T_MSG<EMPHASIS> *pk_msg</EMPHASIS> )</PROGRAMLISTING> |
<PARA>Note that <FUNCTION>ret_int()</FUNCTION> and |
the <FUNCTION>ret_wup()</FUNCTION> are implemented |
as macros, containing a “return” statement.</PARA> |
<PARA>Also note that <FUNCTION>ret_wup()</FUNCTION> and |
the <FUNCTION>ixxx_yyy()</FUNCTION> style functions |
will only work when called from an ISR whose associated DSR is <FUNCTION>cyg_uitron_dsr()</FUNCTION>, |
as specified in include file <filename><cyg/compat/uitron/uit_ifnc.h></filename>, |
which defines the <FUNCTION>ixxx_yyy()</FUNCTION> style |
functions also.</PARA> |
<PARA>If you are writing interrupt handlers more in the |
<EMPHASIS>eCos</EMPHASIS> style, with separate ISR and DSR routines both of |
your own devising, do not use these special functions from a DSR: use plain |
<FUNCTION>xxx_yyy()</FUNCTION> style functions (with no ‘i’ prefix) |
instead, and do not call any µITRON functions from the ISR at |
all.</PARA> |
<PARA>The following functions are not supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>def_int</FUNCTION>( |
UINT <EMPHASIS>dintno,</EMPHASIS> |
T_DINT *<EMPHASIS>pk_dint</EMPHASIS> )</programlisting> |
<programlisting> |
ER <FUNCTION>chg_iXX</FUNCTION>( |
UINT <EMPHASIS>iXXXX</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_iXX</FUNCTION>( |
UINT * <EMPHASIS>p_iXXXX</EMPHASIS> )</PROGRAMLISTING> |
<PARA>These unsupported functions are all Level C (CPU dependent). |
Equivalent functionality is available via other <EMPHASIS>eCos</EMPHASIS>-specific |
APIs. </PARA> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>The following conditions are only checked for, and only return |
errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA><FUNCTION>loc/unl_cpu()</FUNCTION> |
: these must only be called in a |
µITRON task context, else E_CTX.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA><FUNCTION>dis/ena_int()</FUNCTION> |
: the interrupt number must be in range as specified by the platform |
HAL in qustion, else E_PAR.</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-memory-pool-mgmt-functions"> |
<TITLE><!-- <index></index> --> Memory pool Management Functions</TITLE> |
<PARA>These functions are fully supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>get_blf</FUNCTION>( |
VP *<EMPHASIS>p_blf,</EMPHASIS> ID <EMPHASIS>mpfid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>pget_blf</FUNCTION>( |
VP *<EMPHASIS>p_blf,</EMPHASIS> ID <EMPHASIS>mpfid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>tget_blf</FUNCTION>( |
VP *<EMPHASIS>p_blf,</EMPHASIS> ID <EMPHASIS>mpfid,</EMPHASIS> TMO <EMPHASIS>tmout</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>rel_blf</FUNCTION>( |
ID <EMPHASIS>mpfid,</EMPHASIS> VP <EMPHASIS>blf</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_mpf</FUNCTION>( |
T_RMPF *<EMPHASIS>pk_rmpf,</EMPHASIS> ID <EMPHASIS>mpfid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>get_blk</FUNCTION>( |
VP *<EMPHASIS>p_blk,</EMPHASIS> ID <EMPHASIS>mplid,</EMPHASIS> INT <EMPHASIS>blksz</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>pget_blk</FUNCTION>( |
VP *<EMPHASIS>p_blk,</EMPHASIS> ID <EMPHASIS>mplid,</EMPHASIS> INT <EMPHASIS>blksz</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>tget_blk</FUNCTION>( |
VP *<EMPHASIS>p_blk,</EMPHASIS> ID <EMPHASIS>mplid,</EMPHASIS> INT <EMPHASIS>blksz,</EMPHASIS> TMO <EMPHASIS>tmout</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>rel_blk</FUNCTION>( |
ID <EMPHASIS>mplid,</EMPHASIS> VP <EMPHASIS>blk</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_mpl</FUNCTION>( |
T_RMPL *<EMPHASIS>pk_rmpl,</EMPHASIS> ID <EMPHASIS>mplid ) |
</EMPHASIS></programlisting> |
|
<PARA>Note that of the memory provided for a particular pool to |
manage in the static initialization of the memory pool objects, |
some memory will be used to manage the pool itself. Therefore the |
number of blocks * the blocksize will be less than the total |
memory size. </PARA> |
<PARA>The following functions are supported in this release, when |
enabled with |
<LITERAL>CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE</LITERAL> |
or |
<LITERAL>CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE</LITERAL> |
as appropriate, with some restrictions: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>cre_mpl</FUNCTION>( |
ID <EMPHASIS>mplid,</EMPHASIS> T_CMPL *<EMPHASIS>pk_cmpl</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>del_mpl</FUNCTION>( |
ID <EMPHASIS>mplid</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>cre_mpf</FUNCTION>( |
ID <EMPHASIS>mpfid,</EMPHASIS> T_CMPF *<EMPHASIS>pk_cmpf</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>del_mpf</FUNCTION>( |
ID <EMPHASIS>mpfid</EMPHASIS> )</PROGRAMLISTING> |
<PARA>Because of the static initialization facilities provided for |
system objects, a memory pool is allocated a region of memory to |
manage statically in the configuration. So while memory pools can |
be created and deleted, the same area of memory is used for that |
memory pool (memory pool ID number) each time. The requested variable pool |
size (pk_cmpl->mplsz) or the number of fixed-size |
blocks (pk_cmpf->mpfcnt) times the block size |
(pk_cmpf->blfsz) are checked for fitting within |
the statically allocated memory area, so if a create call succeeds, |
the resulting pool will be at least as large as that requested. |
For this reason <FUNCTION>del_mpl()</FUNCTION> and <FUNCTION>del_mpf()</FUNCTION> do |
not in any sense free the memory that was managed by the deleted |
pool for use by other pools; it may only be managed by a pool of |
the same object id. </PARA> |
<PARA>For both fixed and variable memory pools, the queueing order |
when waiting on a synchronization object depends on the underlying |
kernel configuration. The multi-level queue scheduler is required |
for strict µITRON conformance and |
it queues tasks in FIFO order, so requests to create an object with |
priority queueing of tasks (pk_cxxx->xxxatr = TA_TPRI) |
are rejected with E_RSATR. Additional undefined bits in |
the attributes fields must be zero. </PARA> |
<PARA>In general, extended information (pk_cxxx->exinf) |
is ignored. </PARA> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>The following conditions are only checked for, and only return |
errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>invalid object id; less than 1 or greater than |
<LITERAL>CYGNUM_UITRON_MEMPOOLVAR/MEMPOOLFIXED</LITERAL> |
as appropriate returns E_ID</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>dispatching is enabled in any call which can sleep, or |
E_CTX</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>tmout must be positive, otherwise E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>pk_cxxx pointers in |
<FUNCTION>cre_xxx()</FUNCTION> |
must be valid pointers, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in |
<FUNCTION>ref_xxx()</FUNCTION> |
is a valid pointer, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointers in get block routines is a valid |
pointer, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>blocksize request in get variable block routines is greater |
than zero, or E_PAR</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
<PARA>The following conditions are checked for, and can return error |
codes, regardless of the setting of |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL>: |
</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>When create and delete functions |
<FUNCTION>cre_xxx()</FUNCTION> |
and |
<FUNCTION>del_xxx()</FUNCTION> |
are supported, all calls which use a valid object ID number check |
that the object exists. If not, E_NOEXS is returned.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>When create functions |
<FUNCTION>cre_xxx()</FUNCTION> |
are supported, if the object already exists, then E_OBJ</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In any call which can sleep, such as |
<FUNCTION>get_blk()</FUNCTION> |
: return codes E_TMOUT, E_RLWAI, E_DLT |
or of course E_OK are returned depending on the reason |
for terminating the sleep</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In polling functions such as |
<FUNCTION>pget_blk()</FUNCTION> |
return codes E_TMOUT or E_OK are returned depending |
on the state of the synchronization object</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In creation functions, the attributes must be compatible |
with the selected underlying kernel configuration: in |
<FUNCTION>cre_mpl()</FUNCTION> |
|
<LITERAL>pk_cmpl->mplatr</LITERAL> |
must be equal to |
<LITERAL>TA_TFIFO</LITERAL> |
else E_RSATR.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In |
<FUNCTION>cre_mpf()</FUNCTION> |
|
<LITERAL>pk_cmpf->mpfatr</LITERAL> |
must be equal to |
<LITERAL>TA_TFIFO</LITERAL> |
else E_RSATR.</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In creation functions, the requested size of the memory |
pool must not be larger than that statically configured for the |
pool else E_RSATR; see the configuration option |
“Option: Static initializers”. |
In |
<FUNCTION>cre_mpl()</FUNCTION> |
|
<LITERAL>pk_cmpl->mplsz</LITERAL> |
is the field of interest</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In |
<FUNCTION>cre_mpf()</FUNCTION> |
the product of |
<LITERAL>pk_cmpf->blfsz</LITERAL> |
and |
<LITERAL>pk_cmpf->mpfcnt</LITERAL> |
must be smaller than the memory statically configured for the pool |
else E_RSATR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>In functions which return memory to the pool |
<FUNCTION>rel_blk()</FUNCTION> |
and |
<FUNCTION>rel_blf()</FUNCTION> |
, if the free fails, for example because the memory did not come |
from that pool originally, then E_PAR is returned</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-time-mgmt-functions"> |
<TITLE><!-- <index></index> -->Time Management Functions</TITLE> |
<PARA>These functions are fully supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>set_tim</FUNCTION>( |
SYSTIME *<EMPHASIS>pk_tim</EMPHASIS> )</PROGRAMLISTING> |
<CAUTION> |
<PARA> Setting the time may cause erroneous operation of the |
kernel, for example a task performing a wait with a |
time-out may never awaken.</PARA> |
</CAUTION> |
<PROGRAMLISTING>ER <FUNCTION>get_tim</FUNCTION>( |
SYSTIME *<EMPHASIS>pk_tim</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>dly_tsk</FUNCTION>( |
DLYTIME <EMPHASIS>dlytim</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>def_cyc</FUNCTION>( |
HNO <EMPHASIS>cycno,</EMPHASIS> T_DCYC *<EMPHASIS>pk_dcyc</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>act_cyc</FUNCTION>( |
HNO <EMPHASIS>cycno,</EMPHASIS> UINT <EMPHASIS>cycact</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_cyc</FUNCTION>( |
T_RCYC *<EMPHASIS>pk_rcyc,</EMPHASIS> HNO <EMPHASIS>cycno</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>def_alm</FUNCTION>( |
HNO <EMPHASIS>almno,</EMPHASIS> T_DALM *<EMPHASIS>pk_dalm</EMPHASIS> ) |
</programlisting> |
<programlisting> |
ER <FUNCTION>ref_alm</FUNCTION>( |
T_RALM *<EMPHASIS>pk_ralm,</EMPHASIS> HNO <EMPHASIS>almno</EMPHASIS> ) |
</programlisting> |
<programlisting> |
void <FUNCTION>ret_tmr</FUNCTION>( void )</programlisting> |
<sect2> |
<title>Error checking</title> |
<PARA>The following conditions are only checked for, and only return |
errors if |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>invalid handler number; less than 1 or greater than |
<LITERAL>CYGNUM_UITRON_CYCLICS/ALARMS</LITERAL> |
as appropriate, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>dispatching is enabled in |
<FUNCTION>dly_tsk()</FUNCTION> |
, or E_CTX</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>dlytim must be positive or zero, otherwise E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>return value pointer in |
<FUNCTION>ref_xxx()</FUNCTION> |
is a valid pointer, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>params within pk_dalm and pk_dcyc must |
be valid, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>cycact in |
<FUNCTION>act_cyc()</FUNCTION> |
must be valid, or E_PAR</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>handler must be defined in |
<FUNCTION>ref_xxx()</FUNCTION> |
and |
<FUNCTION>act_cyc()</FUNCTION> |
, or E_NOEXS</PARA> |
</LISTITEM> |
<LISTITEM> |
<PARA>parameter pointer must be a good pointer in |
<FUNCTION>get_tim()</FUNCTION> |
and |
<FUNCTION>set_tim()</FUNCTION> |
, otherwise E_PAR is returned</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
<PARA>The following conditions are checked for, and can return |
error codes, regardless of the setting of |
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
:</PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA><FUNCTION>dly_tsk()</FUNCTION> |
: return code E_RLWAI is returned depending on the reason |
for terminating the sleep</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</sect2> |
</SECT1> |
<SECT1 id="compat-uitron-system-mgmt-functions"> |
<TITLE><!-- <index></index> --> System Management Functions</TITLE> |
<PARA>These functions are fully supported in this release: |
</PARA> |
<PROGRAMLISTING>ER <FUNCTION>get_ver</FUNCTION>( |
T_VER *<EMPHASIS>pk_ver</EMPHASIS> ) |
</PROGRAMLISTING> |
<PROGRAMLISTING>ER <FUNCTION>ref_sys</FUNCTION>( |
T_RSYS *<EMPHASIS>pk_rsys</EMPHASIS> ) |
</PROGRAMLISTING> |
<PROGRAMLISTING>ER <FUNCTION>ref_cfg</FUNCTION>( |
T_RCFG *<EMPHASIS>pk_rcfg</EMPHASIS> ) |
</PROGRAMLISTING> |
<PARA>Note that the information returned by each of these calls |
may be configured to match the user's own versioning system, |
and the values supplied by the default configuration may be inappropriate. </PARA> |
<PARA>These functions are not supported in this release: </PARA> |
<PROGRAMLISTING>ER <FUNCTION>def_svc</FUNCTION>( |
FN <EMPHASIS>s_fncd,</EMPHASIS> |
T_DSVC *<EMPHASIS>pk_dsvc</EMPHASIS> ) |
</PROGRAMLISTING> |
<PROGRAMLISTING>ER <FUNCTION>def_exc</FUNCTION>( |
UINT <EMPHASIS>exckind,</EMPHASIS> |
T_DEXC *<EMPHASIS>pk_dexc</EMPHASIS> ) |
</PROGRAMLISTING> |
<SECT2> |
<TITLE>Error checking</TITLE> |
<PARA>The following conditions are only checked for, and |
only return errors if |
|
<LITERAL>CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS</LITERAL> |
is enabled: </PARA> |
<ITEMIZEDLIST> |
<LISTITEM> |
<PARA>return value pointer in all calls is a valid |
pointer, or E_PAR</PARA> |
</LISTITEM> |
</ITEMIZEDLIST> |
</SECT2> |
</SECT1> |
<SECT1 id="compat-uitron-network-support-functions"> |
<TITLE><!-- <index></index> --> Network Support Functions</TITLE> |
<PARA>None of these functions are supported in this release. |
</PARA> |
</SECT1> |
<SECT1 id="compat-uitron-configuration-faq"> |
<TITLE><!-- <index></index> -->µITRON Configuration FAQ</TITLE> |
<PARA><EMPHASIS>Q: How are µITRON objects created?</EMPHASIS> |
</PARA> |
<PARA> |
For each type of uITRON object (tasks, semaphores, flags, mboxes, mpf, mpl) |
these two quantities are controlled by configuration: |
</PARA> |
<ITEMIZEDLIST> |
<LISTITEM><PARA> |
The <EMPHASIS>maximum</EMPHASIS> number of this type of object. |
</PARA></LISTITEM> |
<LISTITEM><PARA> |
The number of these objects which exist <EMPHASIS>initially</EMPHASIS>. |
</PARA></LISTITEM> |
</ITEMIZEDLIST> |
<PARA> |
This is assuming that for the relevant object type, |
<EMPHASIS>create</EMPHASIS> and <EMPHASIS>delete</EMPHASIS> |
operations are enabled; enabled is the default. For example, the option |
<LITERAL>CYGPKG_UITRON_MBOXES_CREATE_DELETE</LITERAL> |
controls whether the functions |
<FUNCTION>cre_mbx()</FUNCTION> |
and |
<FUNCTION>del_mbx()</FUNCTION> |
exist in the API. If not, then the maximum number of |
mboxes is the same as the initial number of mboxes, and so on for all |
µITRON object types. |
</PARA> |
<PARA> |
Mboxes have no initialization, so there are only a few, simple |
configuration options: |
</PARA> |
<ITEMIZEDLIST> |
<LISTITEM><PARA> |
<LITERAL>CYGNUM_UITRON_MBOXES</LITERAL> |
is the total number of mboxes that you can have in the |
system. By default this is 4, so you can use mboxes 1,2,3 and 4. You |
cannot create mboxes outside this range; trying to |
<FUNCTION>cre_mbx(5,...)</FUNCTION> |
will return an error. |
</PARA></LISTITEM> |
<LISTITEM><PARA> |
<LITERAL>CYGNUM_UITRON_MBOXES_INITIALLY</LITERAL> |
is the number of mboxes created |
automatically for you, during startup. By default this is 4, so all 4 |
mboxes exist already, and an attempt to create one of these |
eg. <FUNCTION>cre_mbx(3,...)</FUNCTION> |
will return an error because the mbox in quesion already |
exists. You can delete a pre-existing mbox, and then re-create it. |
</PARA></LISTITEM> |
</ITEMIZEDLIST> |
<PARA> |
If you change |
<LITERAL>CYGNUM_UITRON_MBOXES_INITIALLY</LITERAL>, |
for example to 0, no mboxes |
are created automatically for you during startup. Any attempt to use an |
mbox without creating it will return E_NOEXS because the mbox does not |
exist. You can create an mbox, say <FUNCTION>cre_mbx(3,...)</FUNCTION> |
and then use it, say |
<FUNCTION>snd_msg(3,&foo)</FUNCTION>, and all will be well. |
</PARA> |
<PARA><EMPHASIS>Q: How are µITRON objects initialized?</EMPHASIS> |
</PARA> |
<PARA> |
Some object types have optional initialization. Semaphores are an |
example. You could have |
<LITERAL>CYGNUM_UITRON_SEMAS</LITERAL>=10 and |
<LITERAL>CYGNUM_UITRON_SEMAS_INITIALLY</LITERAL>=5 |
which means you can use semaphores 1-5 |
straight off, but you must create semaphores 6-10 before you can use them. |
If you decide not to initialize semaphores, semaphores 1-5 will have an |
initial count of zero. If you decide to initialize them, you must supply |
a dummy initializer for semaphores 6-10 also. For example, |
in terms of the configuration output in |
<filename>pkgconf/uitron.h</filename>: |
</PARA> |
<PROGRAMLISTING> |
#define CYGDAT_UITRON_SEMA_INITIALIZERS \ |
CYG_UIT_SEMA( 1 ), \ |
CYG_UIT_SEMA( 0 ), \ |
CYG_UIT_SEMA( 0 ), \ |
CYG_UIT_SEMA( 99 ), \ |
CYG_UIT_SEMA( 1 ), \ |
CYG_UIT_SEMA_NOEXS, \ |
CYG_UIT_SEMA_NOEXS, \ |
CYG_UIT_SEMA_NOEXS, \ |
CYG_UIT_SEMA_NOEXS, \ |
CYG_UIT_SEMA_NOEXS |
</PROGRAMLISTING> |
<PARA> |
Semaphore 1 will have initial count 1, semaphores 2 and 3 will be zero, |
number 4 will be 99 initially, 5 will be one and numbers 6 though 10 do not |
exist initially. |
</PARA> |
<PARA> |
Aside: this is how the definition of the symbol would appear in the |
configuration header file <filename>pkgconf/uitron.h</filename> — |
unfortunately editing such a long, multi-line definition is somewhat |
cumbersome in the GUI config tool in current releases. The macros |
<LITERAL>CYG_UIT_SEMA()</LITERAL> |
— to create a semaphore initializer — and |
<LITERAL>CYG_UIT_SEMA_NOEXS</LITERAL> |
— to invoke a dummy initializer — |
are provided in in the environment to help with this. Similar macros are |
provided for other object types. The resulting #define symbol is used in |
the context of a C++ array initializer, such as: |
<PROGRAMLISTING> |
Cyg_Counting_Semaphore2 cyg_uitron_SEMAS[ CYGNUM_UITRON_SEMAS ] = { |
CYGDAT_UITRON_SEMA_INITIALIZERS |
}; |
</PROGRAMLISTING> |
which is eventually macro-processed to give |
<PROGRAMLISTING> |
Cyg_Counting_Semaphore2 cyg_uitron_SEMAS[ 10 ] = { |
Cyg_Counting_Semaphore2( ( 1 ) ), |
Cyg_Counting_Semaphore2( ( 0 ) ), |
Cyg_Counting_Semaphore2( ( 0 ) ), |
Cyg_Counting_Semaphore2( ( 99 ) ), |
Cyg_Counting_Semaphore2( ( 1 ) ), |
Cyg_Counting_Semaphore2(0), |
Cyg_Counting_Semaphore2(0), |
Cyg_Counting_Semaphore2(0), |
Cyg_Counting_Semaphore2(0), |
Cyg_Counting_Semaphore2(0), |
}; |
</PROGRAMLISTING> |
so you can see how it is necessary to include the dummy entries in that |
definition, otherwise the resulting code will not compile correctly. |
</PARA> |
<PARA> |
If you choose |
<LITERAL>CYGNUM_UITRON_SEMAS_INITIALLY</LITERAL>=0 |
it is meaningless to initialize them, for they must be created and so |
initialized then, before use. |
</PARA> |
<PARA><EMPHASIS>Q: What about µITRON tasks?</EMPHASIS> |
</PARA> |
<PARA> |
Some object types require initialization. Tasks are an example of this. |
You must provide a task with a priority, a function to enter when the task |
starts, a name (for debugging purposes), and some memory to use for the stack. |
For example (again in terms of the resulting |
definitions in <filename>pkgconf/uitron.h</filename>): |
</PARA> |
<PROGRAMLISTING> |
#define CYGNUM_UITRON_TASKS 4 // valid task ids are 1,2,3,4 |
#define CYGNUM_UITRON_TASKS_INITIALLY 4 // they all exist at start |
|
#define CYGDAT_UITRON_TASK_EXTERNS \ |
extern "C" void startup( unsigned int ); \ |
extern "C" void worktask( unsigned int ); \ |
extern "C" void lowtask( unsigned int ); \ |
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack2[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack3[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack4[ CYGNUM_UITRON_STACK_SIZE ]; |
|
#define CYGDAT_UITRON_TASK_INITIALIZERS \ |
CYG_UIT_TASK("main task", 8, startup, &stack1, sizeof( stack1 )), \ |
CYG_UIT_TASK("worker 2" , 9, worktask, &stack2, sizeof( stack2 )), \ |
CYG_UIT_TASK("worker 3" , 9, worktask, &stack3, sizeof( stack3 )), \ |
CYG_UIT_TASK("low task" ,20, lowtask, &stack4, sizeof( stack4 )), \ |
|
</PROGRAMLISTING> |
<PARA> |
So this example has all four tasks statically configured to exist, ready to |
run, from the start of time. The “main task” runs a routine |
called <FUNCTION>startup()</FUNCTION> at priority 8. Two |
“worker” tasks run both a priority 9, and a “low |
priority” task runs at priority 20 to do useful non-urgent background |
work. |
</PARA> |
<screen> |
Task ID | Exists at | Function | Priority | Stack | Stack |
number | startup | entry | | address | size |
--------+-----------+----------+----------+---------+---------- |
1 | Yes | startup | 8 | &stack1 | CYGNUM... |
2 | Yes | worktask | 9 | &stack2 | CYGNUM... |
3 | Yes | worktask | 9 | &stack3 | CYGNUM... |
4 | Yes | lowtask | 20 | &stack4 | CYGNUM... |
--------+-----------+----------+----------+---------+---------- |
</screen> |
<PARA><EMPHASIS>Q: How can I create µITRON tasks in the program?</EMPHASIS> |
</PARA> |
<PARA> |
You must provide free slots in the task table in which to create new tasks, |
by configuring the number of tasks existing initially to be smaller than |
the total. |
For a task ID which does not initially exist, it will be told what routine |
to call, and what priority it is, when the task is created. But you must |
still set aside memory for the task to use for its stack, and give it a |
name during initialization. For example: |
</PARA> |
|
<PROGRAMLISTING> |
#define CYGNUM_UITRON_TASKS 4 // valid task ids are 1-4 |
#define CYGNUM_UITRON_TASKS_INITIALLY 1 // only task #1 exists |
|
#define CYGDAT_UITRON_TASK_EXTERNS \ |
extern "C" void startup( unsigned int ); \ |
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack2[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack3[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack4[ CYGNUM_UITRON_STACK_SIZE ]; |
|
#define CYGDAT_UITRON_TASK_INITIALIZERS \ |
CYG_UIT_TASK( "main", 8, startup, &stack1, sizeof( stack1 ) ), \ |
CYG_UIT_TASK_NOEXS( "slave", &stack2, sizeof( stack2 ) ), \ |
CYG_UIT_TASK_NOEXS( "slave2", &stack3, sizeof( stack3 ) ), \ |
CYG_UIT_TASK_NOEXS( "slave3", &stack4, sizeof( stack4 ) ), \ |
|
</PROGRAMLISTING> |
<PARA> |
So tasks numbered 2,3 and 4 have been given their stacks during startup, |
though they do not yet exist in terms of <FUNCTION>cre_tsk()</FUNCTION> and |
<FUNCTION>del_tsk()</FUNCTION> so you can create tasks 2–4 at |
runtime. |
</PARA> |
<screen> |
Task ID | Exists at | Function | Priority | Stack | Stack |
number | startup | entry | | address | size |
--------+-----------+----------+----------+---------+---------- |
1 | Yes | startup | 8 | &stack1 | CYGNUM... |
2 | No | N/A | N/A | &stack2 | CYGNUM... |
3 | No | N/A | N/A | &stack3 | CYGNUM... |
4 | No | N/A | N/A | &stack4 | CYGNUM... |
--------+-----------+----------+----------+---------+---------- |
</screen> |
<PARA> |
(you must have at least one task at startup in order that the system can |
actually run; this is not so for other uITRON object types) |
</PARA> |
<PARA><EMPHASIS>Q: Can I have different stack sizes for µITRON tasks?</EMPHASIS> |
</PARA> |
<PARA> |
Simply set aside different amounts of memory for each task to use for its |
stack. Going back to a typical default setting for the µITRON tasks, |
the definitions in <filename>pkgconf/uitron.h</filename> might look like this: |
</PARA> |
<PROGRAMLISTING> |
#define CYGDAT_UITRON_TASK_EXTERNS \ |
extern "C" void task1( unsigned int ); \ |
extern "C" void task2( unsigned int ); \ |
extern "C" void task3( unsigned int ); \ |
extern "C" void task4( unsigned int ); \ |
static char stack1[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack2[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack3[ CYGNUM_UITRON_STACK_SIZE ], \ |
stack4[ CYGNUM_UITRON_STACK_SIZE ]; |
|
#define CYGDAT_UITRON_TASK_INITIALIZERS \ |
CYG_UIT_TASK( "t1", 1, task1, &stack1, CYGNUM_UITRON_STACK_SIZE ), \ |
CYG_UIT_TASK( "t2", 2, task2, &stack2, CYGNUM_UITRON_STACK_SIZE ), \ |
CYG_UIT_TASK( "t3", 3, task3, &stack3, CYGNUM_UITRON_STACK_SIZE ), \ |
CYG_UIT_TASK( "t4", 4, task4, &stack4, CYGNUM_UITRON_STACK_SIZE ) |
|
</PROGRAMLISTING> |
<PARA> |
Note that |
<LITERAL>CYGNUM_UITRON_STACK_SIZE</LITERAL> |
is used to control the size of the stack |
objects themselves, and to tell the system what size stack is being provided. |
</PARA> |
<PARA> |
Suppose instead stack sizes of 2000, 1000, 800 and 800 were required: |
this could be achieved by using the GUI config tool to edit these |
options, or editting the <filename>.ecc</filename> file to get these |
results in <filename>pkgconf/uitron.h</filename>: |
</PARA> |
<PROGRAMLISTING> |
#define CYGDAT_UITRON_TASK_EXTERNS \ |
extern "C" void task1( unsigned int ); \ |
extern "C" void task2( unsigned int ); \ |
extern "C" void task3( unsigned int ); \ |
extern "C" void task4( unsigned int ); \ |
static char stack1[ 2000 ], \ |
stack2[ 1000 ], \ |
stack3[ 800 ], \ |
stack4[ 800 ]; |
|
#define CYGDAT_UITRON_TASK_INITIALIZERS \ |
CYG_UIT_TASK( "t1", 1, task1, &stack1, sizeof( stack1 ) ), \ |
CYG_UIT_TASK( "t2", 2, task2, &stack2, sizeof( stack2 ) ), \ |
CYG_UIT_TASK( "t3", 3, task3, &stack3, sizeof( stack3 ) ), \ |
CYG_UIT_TASK( "t4", 4, task4, &stack4, sizeof( stack4 ) ) |
</PROGRAMLISTING> |
<PARA> |
Note that the sizeof() operator has been used to tell the system what size |
stacks are provided, rather than quoting a number (which is difficult for |
maintenance) or the symbol |
<LITERAL>CYGNUM_UITRON_STACK_SIZE</LITERAL> |
(which is wrong). |
</PARA> |
<PARA> |
We recommend using (if available in your release) the stacksize symbols |
provided in the architectural HAL for your target, called |
<LITERAL>CYGNUM_HAL_STACK_SIZE_TYPICAL</LITERAL> |
and |
<LITERAL>CYGNUM_HAL_STACK_SIZE_MINIMUM</LITERAL>. |
So a better (more portable) version of the above might be: |
</PARA> |
<PROGRAMLISTING> |
#define CYGDAT_UITRON_TASK_EXTERNS \ |
extern "C" void task1( unsigned int ); \ |
extern "C" void task2( unsigned int ); \ |
extern "C" void task3( unsigned int ); \ |
extern "C" void task4( unsigned int ); \ |
static char stack1[ CYGNUM_HAL_STACK_SIZE_TYPICAL + 1200 ], \ |
stack2[ CYGNUM_HAL_STACK_SIZE_TYPICAL + 200 ], \ |
stack3[ CYGNUM_HAL_STACK_SIZE_TYPICAL ], \ |
stack4[ CYGNUM_HAL_STACK_SIZE_TYPICAL ]; |
|
#define CYGDAT_UITRON_TASK_INITIALIZERS \ |
CYG_UIT_TASK( "t1", 1, task1, &stack1, sizeof( stack1 ) ), \ |
CYG_UIT_TASK( "t2", 2, task2, &stack2, sizeof( stack2 ) ), \ |
CYG_UIT_TASK( "t3", 3, task3, &stack3, sizeof( stack3 ) ), \ |
CYG_UIT_TASK( "t4", 4, task4, &stack4, sizeof( stack4 ) ) |
</PROGRAMLISTING> |
</SECT1> |
</CHAPTER> |
</part> |
/v2_0/src/uit_objs.cxx
0,0 → 1,382
//=========================================================================== |
// |
// uit_objs.cxx |
// |
// uITRON static objects |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON static system objects |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
#include <cyg/compat/uitron/uit_objs.hxx> |
// declarations of the objects |
// we define below, and everything |
// we need to specify them. |
|
#include <cyg/hal/hal_arch.h> // for CYGNUM_HAL_STACK_SIZE_MINIMUM |
|
// ------------------------------------------------------------------------ |
// Mboxes have no initializer. |
#ifdef CYGPKG_UITRON_MBOXES |
#if 0 < CYGNUM_UITRON_MBOXES |
Cyg_Mbox CYG_UITRON_DECL( MBOXES ); |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
Cyg_Mbox *CYG_UITRON_DECL_PTRS( MBOXES ); |
#endif |
#endif |
#endif // CYGPKG_UITRON_MBOXES |
|
// ------------------------------------------------------------------------ |
// Flags have no initializer. |
#ifdef CYGPKG_UITRON_FLAGS |
#if 0 < CYGNUM_UITRON_FLAGS |
Cyg_Flag CYG_UITRON_DECL( FLAGS ); |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
Cyg_Flag *CYG_UITRON_DECL_PTRS( FLAGS ); |
#endif |
#endif |
#endif // CYGPKG_UITRON_FLAGS |
|
// ------------------------------------------------------------------------ |
// Semaphores have an optional initializer. |
#ifdef CYGPKG_UITRON_SEMAS |
#if (0 < CYGNUM_UITRON_SEMAS) || \ |
defined( CYGDAT_UITRON_SEMA_INITIALIZERS ) |
|
#ifndef CYGNUM_UITRON_SEMAS |
#error You must define CYGNUM_UITRON_SEMAS |
#endif |
|
Cyg_Counting_Semaphore2 CYG_UITRON_DECL( SEMAS ) |
|
#ifdef CYGDAT_UITRON_SEMA_INITIALIZERS |
// a Macro to ease the construction: |
#define CYG_UIT_SEMA( _count_ ) Cyg_Counting_Semaphore2( (cyg_count32)(_count_) ) |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
#define CYG_UIT_SEMA_NOEXS Cyg_Counting_Semaphore2( (cyg_count32) 0 ) |
#endif |
= { |
CYGDAT_UITRON_SEMA_INITIALIZERS |
} |
#undef CYG_UIT_SEMA |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
#undef CYG_UIT_SEMA_NOEXS |
#endif |
#endif // do we have initializers? |
; // the end of the declaration, with or without initializer |
|
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
Cyg_Counting_Semaphore2 *CYG_UITRON_DECL_PTRS( SEMAS ); |
#endif |
#endif |
#endif // CYGPKG_UITRON_SEMAS |
|
// ------------------------------------------------------------------------ |
// tasks MUST be initialized, you must have some. |
#ifndef CYGDAT_UITRON_TASK_EXTERNS |
#error You must define CYGDAT_UITRON_TASK_EXTERNS |
#endif |
#ifndef CYGDAT_UITRON_TASK_INITIALIZERS |
#error You must define CYGDAT_UITRON_TASK_INITIALIZERS |
#endif |
#ifndef CYGNUM_UITRON_TASKS |
#error You must define CYGNUM_UITRON_TASKS |
#endif |
|
// a Macro to ease the construction: |
// "name", priority, proc, stackbase, stacksize |
#define CYG_UIT_TASK( _name_, _prio_, _func_, _sb_, _ss_ ) \ |
Cyg_Thread( \ |
(CYG_ADDRWORD)(_prio_), \ |
(_func_), \ |
(CYG_ADDRWORD)0, \ |
_name_, \ |
(CYG_ADDRESS)(_sb_), \ |
(cyg_ucount32)(_ss_) ) |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
#define CYG_UIT_TASK_NOEXS( _name_, _sb_, _ss_ ) \ |
Cyg_Thread( \ |
(CYG_ADDRWORD)(CYG_SCHED_DEFAULT_INFO), \ |
(cyg_thread_entry *)(0), \ |
(CYG_ADDRWORD)0, \ |
_name_, \ |
(CYG_ADDRESS)(_sb_), \ |
(cyg_ucount32)(_ss_) ) |
#endif |
|
// FIXME: Xscale tools currently in use have a preprocessor bug causing |
// the below #ifs to be misinterpreted. Therefore a *temporary* |
// workaround is included to define a MAX macro, and change |
// CYGDAT_UITRON_TASK_EXTERNS and CYGDAT_UITRON_TASK_INITIALISERS in |
// the CDL to use it. |
#ifdef XSCALECPPFIXEDSOMETIME |
|
#ifdef CYGNUM_HAL_STACK_SIZE_MINIMUM |
# ifdef CYGNUM_UITRON_STACK_SIZE |
# if CYGNUM_UITRON_STACK_SIZE < CYGNUM_HAL_STACK_SIZE_MINIMUM |
|
// then override the configured stack size |
# undef CYGNUM_UITRON_STACK_SIZE |
# define CYGNUM_UITRON_STACK_SIZE CYGNUM_HAL_STACK_SIZE_MINIMUM |
|
# endif // CYGNUM_UITRON_STACK_SIZE < CYGNUM_HAL_STACK_SIZE_MINIMUM |
# endif // CYGNUM_UITRON_STACK_SIZE |
#endif // CYGNUM_HAL_STACK_SIZE_MINIMUM |
|
#else |
#define MAX(_x_,_y_) ((_x_) > (_y_) ? (_x_) : (_y_)) |
#endif |
|
// declare the symbols used in the initializer |
CYGDAT_UITRON_TASK_EXTERNS |
|
Cyg_Thread CYG_UITRON_DECL( TASKS ) = |
{ |
CYGDAT_UITRON_TASK_INITIALIZERS |
}; |
|
#undef CYG_UIT_TASK |
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
#undef CYG_UIT_TASK_NOEXS |
#endif |
|
#ifdef CYGIMP_THREAD_PRIORITY |
// An ancillary array of priorities, for managing the "original" prio |
cyg_priority |
cyg_uitron_task_initial_priorities[ CYG_UITRON_NUM( TASKS ) ]; |
#endif |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
Cyg_Thread *CYG_UITRON_DECL_PTRS( TASKS ); |
#endif |
|
// ------------------------------------------------------------------------ |
// fixed memory pools MUST be initialized, IF you have some. |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED |
#if (0 < CYGNUM_UITRON_MEMPOOLFIXED) || \ |
defined (CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS) || \ |
defined (CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS) |
|
#ifndef CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS |
#error You must define CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS |
#endif |
#ifndef CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS |
#error You must define CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS |
#endif |
#ifndef CYGNUM_UITRON_MEMPOOLFIXED |
#error You must define CYGNUM_UITRON_MEMPOOLFIXED |
#endif |
|
// declare the symbols used in the initializer |
CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS |
|
// a Macro to ease the construction: addr, size, blocksize |
#define CYG_UIT_MEMPOOLFIXED( _a_, _s_, _bs_ ) Cyg_Mempool_Fixed( \ |
(cyg_uint8 *)(_a_), (cyg_int32)(_s_), (CYG_ADDRWORD)(_bs_) ) |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
// note that this just picks a suitable size for the initialization, which |
// should not be too inefficient |
#define CYG_UIT_MEMPOOLFIXED_NOEXS( _a_, _s_ ) Cyg_Mempool_Fixed( \ |
(cyg_uint8 *)(_a_), (cyg_int32)(_s_), (CYG_ADDRWORD) ((~7)&((_s_)/2)) ) |
#endif |
|
Cyg_Mempool_Fixed CYG_UITRON_DECL( MEMPOOLFIXED ) = |
{ |
CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS |
}; |
#undef CYG_UIT_MEMPOOLFIXED |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
#undef CYG_UIT_MEMPOOLFIXED_NOEXS |
#endif |
|
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
Cyg_Mempool_Fixed *CYG_UITRON_DECL_PTRS( MEMPOOLFIXED ); |
#endif |
#endif // do we have fixed memory pools at all? |
#endif // CYGPKG_UITRON_MEMPOOLFIXED |
|
// ------------------------------------------------------------------------ |
// variable memory pools MUST be initialized, IF you have some. |
#ifdef CYGPKG_UITRON_MEMPOOLVAR |
#if (0 < CYGNUM_UITRON_MEMPOOLVAR) || \ |
defined (CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS) || \ |
defined (CYGDAT_UITRON_MEMPOOLVAR_EXTERNS) |
|
#ifndef CYGDAT_UITRON_MEMPOOLVAR_EXTERNS |
#error You must define CYGDAT_UITRON_MEMPOOLVAR_EXTERNS |
#endif |
#ifndef CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS |
#error You must define CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS |
#endif |
#ifndef CYGNUM_UITRON_MEMPOOLVAR |
#error You must define CYGNUM_UITRON_MEMPOOLVAR |
#endif |
|
// declare the symbols used in the initializer |
CYGDAT_UITRON_MEMPOOLVAR_EXTERNS |
|
// a Macro to ease the construction: addr, size |
#define CYG_UIT_MEMPOOLVAR( _a_, _s_ ) Cyg_Mempool_Variable( \ |
(cyg_uint8 *)(_a_),(cyg_int32)(_s_)) |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
#define CYG_UIT_MEMPOOLVAR_NOEXS( _a_, _s_ ) Cyg_Mempool_Variable( \ |
(cyg_uint8 *)(_a_),(cyg_int32)(_s_)) |
#endif |
|
Cyg_Mempool_Variable CYG_UITRON_DECL( MEMPOOLVAR ) = |
{ |
CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS |
}; |
#undef CYG_UIT_MEMPOOLVAR |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
#undef CYG_UIT_MEMPOOLVAR_NOEXS |
#endif |
|
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
Cyg_Mempool_Variable *CYG_UITRON_DECL_PTRS( MEMPOOLVAR ); |
#endif |
#endif // do we have variable memory pools at all? |
#endif // CYGPKG_UITRON_MEMPOOLVAR |
|
// ------------------------------------------------------------------------ |
// Cyclic alarm handlers might be initialized, if you have some. |
// |
#ifdef CYGPKG_UITRON_CYCLICS |
#if (0 < CYGNUM_UITRON_CYCLICS) || \ |
defined( CYGDAT_UITRON_CYCLIC_EXTERNS ) || \ |
defined( CYGDAT_UITRON_CYCLIC_INITIALIZERS ) |
|
#ifndef CYGNUM_UITRON_CYCLICS |
#error You must define CYGNUM_UITRON_CYCLICS |
#endif |
|
#if defined( CYGDAT_UITRON_CYCLIC_INITIALIZERS ) || \ |
defined( CYGDAT_UITRON_CYCLIC_EXTERNS ) |
|
#ifndef CYGDAT_UITRON_CYCLIC_INITIALIZERS |
#error You must define CYGDAT_UITRON_CYCLIC_INITIALIZERS |
#endif |
#ifndef CYGDAT_UITRON_CYCLIC_EXTERNS |
#error You must define CYGDAT_UITRON_CYCLIC_EXTERNS |
#endif |
|
// declare the symbols used in the initializer |
CYGDAT_UITRON_CYCLIC_EXTERNS |
|
#endif // have externs or initializers |
|
Cyg_Timer CYG_UITRON_DECL( CYCLICS ) |
|
#ifdef CYGDAT_UITRON_CYCLIC_INITIALIZERS |
|
#error *** CYCLIC INITIALIZERS ARE NOT SUPPORTED IN THIS RELEASE*** |
|
// a Macro to ease the construction: proc, arg, time |
#define CYG_UIT_CYCLIC( ... ) Cyg_Timer() |
= { |
CYGDAT_UITRON_CYCLIC_INITIALIZERS |
} |
#undef CYG_UIT_CYCLIC |
#endif // do we have initializers? |
; // the end of the declaration, with or without initializer |
|
#endif // do we have cyclic alarms at all? |
#endif // CYGPKG_UITRON_CYCLICS |
|
// ------------------------------------------------------------------------ |
// Oneshot alarm handlers might be initialized, if you have some. |
// |
#ifdef CYGPKG_UITRON_ALARMS |
#if (0 < CYGNUM_UITRON_ALARMS) || \ |
defined( CYGDAT_UITRON_ALARM_EXTERNS ) || \ |
defined( CYGDAT_UITRON_ALARM_INITIALIZERS ) |
|
#ifndef CYGNUM_UITRON_ALARMS |
#error You must define CYGNUM_UITRON_ALARMS |
#endif |
|
#if defined( CYGDAT_UITRON_ALARM_INITIALIZERS ) || \ |
defined( CYGDAT_UITRON_ALARM_EXTERNS ) |
|
#ifndef CYGDAT_UITRON_ALARM_INITIALIZERS |
#error You must define CYGDAT_UITRON_ALARM_INITIALIZERS |
#endif |
#ifndef CYGDAT_UITRON_ALARM_EXTERNS |
#error You must define CYGDAT_UITRON_ALARM_EXTERNS |
#endif |
|
// declare the symbols used in the initializer |
CYGDAT_UITRON_ALARM_EXTERNS |
|
#endif // have externs or initializers |
|
Cyg_Timer CYG_UITRON_DECL( ALARMS ) |
|
#ifdef CYGDAT_UITRON_ALARM_INITIALIZERS |
|
#error *** ALARM INITIALIZERS ARE NOT SUPPORTED IN THIS RELEASE*** |
|
// a Macro to ease the construction: proc, arg, time |
#define CYG_UIT_ALARM( ... ) Cyg_Timer() |
= { |
CYGDAT_UITRON_ALARM_INITIALIZERS |
} |
#undef CYG_UIT_ALARM |
#endif // do we have initializers? |
; // the end of the declaration, with or without initializer |
|
#endif // do we have oneshot alarms at all? |
#endif // CYGPKG_UITRON_ALARMS |
|
// ------------------------------------------------------------------------ |
#endif // CYGPKG_UITRON |
|
// EOF uit_objs.cxx |
/v2_0/src/uit_ifnc.cxx
0,0 → 1,140
//=========================================================================== |
// |
// uit_ifnc.cxx |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON compatibility functions for use in ISRs |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
// invoke the inline function definition to create static C linkage |
// functions here: |
#define CYGIMP_UITRON_INLINE_FUNCS 1 |
#include <cyg/compat/uitron/uit_func.h> |
|
// Now ensure that we create *outline* funcs for the ixxx_yyy() functions |
// here, with C names or whatever, as required. |
|
#undef CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
#undef CYGIMP_UITRON_INLINE_FUNCS |
#undef CYG_UIT_FUNC_EXTERN_BEGIN |
#undef CYG_UIT_FUNC_EXTERN_END |
|
#ifdef CYGIMP_UITRON_CPP_OUTLINE_FUNCS |
#define CYG_UIT_FUNC_EXTERN_BEGIN extern "C++" { |
#define CYG_UIT_FUNC_EXTERN_END } |
#else |
#define CYG_UIT_FUNC_EXTERN_BEGIN extern "C" { |
#define CYG_UIT_FUNC_EXTERN_END } |
#endif |
|
// Get extern C prototypes (or whatever uit_func.h above did) |
#include <cyg/compat/uitron/uit_ifnc.h> |
|
#undef CYG_UIT_FUNC_INLINE |
#define CYG_UIT_FUNC_INLINE /* blank */ |
#define CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
#include <cyg/compat/uitron/uit_ifnc.inl> |
|
volatile int cyg_uit_dsr_actions_head = 0; |
volatile int cyg_uit_dsr_actions_tail = 0; |
|
Cyg_Uit_Action::action |
cyg_uit_dsr_actions[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
ID |
cyg_uit_dsr_act_ids[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
CYG_ADDRWORD |
cyg_uit_dsr_act_a1s[ CYGNUM_UITRON_ISR_ACTION_QUEUESIZE ]; |
|
void |
cyg_uitron_dsr( unsigned int vector, unsigned int count, unsigned int data ) |
{ |
while ( cyg_uit_dsr_actions_tail != cyg_uit_dsr_actions_head ) { |
switch ( cyg_uit_dsr_actions[ cyg_uit_dsr_actions_tail ] ) { |
case Cyg_Uit_Action::WUP_TSK: |
(void)wup_tsk( cyg_uit_dsr_act_ids[ cyg_uit_dsr_actions_tail ] ); |
break; |
#ifdef CYGPKG_UITRON_SEMAS |
#if 0 < CYG_UITRON_NUM( SEMAS ) |
case Cyg_Uit_Action::SIG_SEM: |
(void)sig_sem( cyg_uit_dsr_act_ids[ cyg_uit_dsr_actions_tail ] ); |
break; |
#endif // 0 < CYG_UITRON_NUM( SEMAS ) |
#endif // CYGPKG_UITRON_SEMAS |
#ifdef CYGPKG_UITRON_FLAGS |
#if 0 < CYG_UITRON_NUM( FLAGS ) |
case Cyg_Uit_Action::SET_FLG: |
(void)set_flg( cyg_uit_dsr_act_ids[ cyg_uit_dsr_actions_tail ], |
(UINT)cyg_uit_dsr_act_a1s[ cyg_uit_dsr_actions_tail ] ); |
break; |
#endif // 0 < CYG_UITRON_NUM( FLAGS ) |
#endif // CYGPKG_UITRON_FLAGS |
#ifdef CYGPKG_UITRON_MBOXES |
#if 0 < CYG_UITRON_NUM( MBOXES ) |
case Cyg_Uit_Action::SND_MSG: |
(void)snd_msg( cyg_uit_dsr_act_ids[ cyg_uit_dsr_actions_tail ], |
(T_MSG *)cyg_uit_dsr_act_a1s[ cyg_uit_dsr_actions_tail ] ); |
break; |
#endif // 0 < CYG_UITRON_NUM( MBOXES ) |
#endif // CYGPKG_UITRON_MBOXES |
default: |
CYG_FAIL( "enum Cyg_Uit_Action out of range!" ); |
} |
cyg_uit_dsr_actions_tail = |
CYGNUM_UITRON_ISR_ACTION_QUEUEMASK & (1+cyg_uit_dsr_actions_tail); |
} |
} |
|
#endif // CYGPKG_UITRON |
|
// EOF uit_ifnc.cxx |
/v2_0/src/uit_func.cxx
0,0 → 1,192
//=========================================================================== |
// |
// uit_func.cxx |
// |
// uITRON compatibility functions |
// |
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): hmt |
// Contributors: hmt |
// Date: 1998-03-13 |
// Purpose: uITRON compatibility functions |
// Description: |
// |
//####DESCRIPTIONEND#### |
// |
//=========================================================================== |
|
#include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
// CYGPKG_UITRON et al |
|
#ifdef CYGPKG_UITRON |
|
// invoke the inline function definition to create static C linkage |
// functions here: |
#define CYGPRI_UITRON_FUNCS_HERE_AND_NOW |
#include <cyg/compat/uitron/uit_func.h> |
|
cyg_uint32 cyg_uitron_dis_dsp_old_priority = 0; |
|
// ------------------------------------------------------------------------ |
// STARTUP |
// this routine is outside the uITRON specification; call it from |
// cyg_start(), cyg_package_start(), cyg_prestart() or cyg_user_start() |
// to start the uITRON tasks and scheduler. |
|
#if CYGNUM_UITRON_START_TASKS < 0 |
#error CYGNUM_UITRON_START_TASKS should be >= 0 |
#endif |
|
#if CYGNUM_UITRON_START_TASKS == 0 |
#define START_TASKS CYGNUM_UITRON_TASKS |
#else |
#define START_TASKS CYGNUM_UITRON_START_TASKS |
#endif |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
#if START_TASKS > CYGNUM_UITRON_TASKS_INITIALLY |
#undef START_TASKS |
#define START_TASKS CYGNUM_UITRON_TASKS_INITIALLY |
#endif |
#endif |
|
#if START_TASKS > CYGNUM_UITRON_TASKS |
#undef START_TASKS |
#define START_TASKS CYGNUM_UITRON_TASKS |
#endif |
|
#if START_TASKS <= 0 |
#error Number of uITRON tasks to start initially must be >= 0 |
#endif |
|
|
#define SET_UP_PTRS( _which_ ) CYG_MACRO_START \ |
for ( i = 0; \ |
(i < CYGNUM_UITRON_ ## _which_ ## _INITIALLY) && \ |
(i < CYGNUM_UITRON_ ## _which_ ) ; \ |
i++ ) { \ |
CYG_UITRON_PTRS( _which_ )[ i ] = CYG_UITRON_OBJS( _which_ ) + i; \ |
} \ |
if ( (CYGNUM_UITRON_ ## _which_ ## _INITIALLY) \ |
< (CYGNUM_UITRON_ ## _which_) ) \ |
for ( /* i as is */; i < CYGNUM_UITRON_ ## _which_ ; i++ ) { \ |
CYG_UITRON_PTRS( _which_ )[ i ] = NULL; \ |
} \ |
CYG_MACRO_END |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
#ifdef CYGSEM_UITRON_TIME_IS_MILLISECONDS |
Cyg_Clock::converter uit_clock_to_system; |
Cyg_Clock::converter uit_clock_from_system; |
#endif |
#endif |
|
void cyg_uitron_start( void ) |
{ |
cyg_int32 i; |
|
#ifdef CYGVAR_KERNEL_COUNTERS_CLOCK |
#ifdef CYGSEM_UITRON_TIME_IS_MILLISECONDS |
// initialize the clock converters |
Cyg_Clock::real_time_clock-> |
get_other_to_clock_converter( 1000000, &uit_clock_to_system ); |
Cyg_Clock::real_time_clock-> |
get_clock_to_other_converter( 1000000, &uit_clock_from_system ); |
#endif |
#endif |
|
for ( i = 0; i < START_TASKS; i++ ) { |
#ifdef CYGIMP_THREAD_PRIORITY |
// save the initial priority in our private array |
cyg_uitron_task_initial_priorities[ i ] = |
cyg_uitron_TASKS[ i ].get_priority(); |
#endif |
// and awaken the task: |
cyg_uitron_TASKS[ i ].resume(); |
} |
for ( /* i as is */; i < CYGNUM_UITRON_TASKS; i++ ) { |
#ifdef CYGIMP_THREAD_PRIORITY |
// save the initial priority in our private array |
cyg_uitron_task_initial_priorities[ i ] = |
cyg_uitron_TASKS[ i ].get_priority(); |
#endif |
// but ensure the task state is dormant. |
cyg_uitron_TASKS[ i ].kill(); |
} |
|
#ifdef CYGPKG_UITRON_TASKS_CREATE_DELETE |
SET_UP_PTRS( TASKS ); |
#endif |
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE |
SET_UP_PTRS( SEMAS ); |
#endif |
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE |
SET_UP_PTRS( MBOXES ); |
#endif |
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE |
SET_UP_PTRS( FLAGS ); |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE |
SET_UP_PTRS( MEMPOOLFIXED ); |
#endif |
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE |
SET_UP_PTRS( MEMPOOLVAR ); |
#endif |
} |
|
// These allow programs to link when cyg_uitron_start() is called |
// (often because of CYGSEM_START_UITRON_COMPATIBILITY from infra, |
// though we define these regardless just in case) |
// even when there is no interest in uITRON and so the tasks are |
// not externally defined; the reference to cyg_uitron_start() |
// ensures the tasks array et al are still included... |
extern "C" { |
void task1( unsigned int arg ) CYGBLD_ATTRIB_WEAK; |
void task2( unsigned int arg ) CYGBLD_ATTRIB_WEAK; |
void task3( unsigned int arg ) CYGBLD_ATTRIB_WEAK; |
void task4( unsigned int arg ) CYGBLD_ATTRIB_WEAK; |
} |
|
void task1( unsigned int arg ) {} |
void task2( unsigned int arg ) {} |
void task3( unsigned int arg ) {} |
void task4( unsigned int arg ) {} |
|
#endif // CYGPKG_UITRON |
|
// EOF uit_func.cxx |
/v2_0/ChangeLog
0,0 → 1,873
2003-02-24 Jonathan Larmour <jifl@eCosCentric.com> |
|
* cdl/uitron.cdl: Update doc link. |
|
2002-05-27 Jesper Skov <jskov@redhat.com> |
|
* cdl/uitron.cdl: Don't build C tests when C++ options selected. |
|
2002-05-22 Nick Garnett <nickg@redhat.com> |
|
* doc/uitron.sgml: Fixed dangling xref. |
|
2002-02-19 Mark Salter <msalter@redhat.com> |
|
* doc/uitron.sgml: Fixed typos and such. |
|
2002-02-14 Hugo Tyson <hmt@redhat.com> |
|
* doc/uitron.sgml: General polishing... Tidied up broken emPHAsis |
on closing parentheses of function lists. Reduced line length of |
same to fit real paper, I hope. Added LITERAL tags all over |
config option mentions. |
|
New stuff... Added a whole new section "[u]ITRON Configuration |
FAQ" based on some email answers I have given in the past in |
support of customers. |
|
2002-02-13 Hugo Tyson <hmt@redhat.com> |
|
* doc/uitron.sgml: NEW FILE: Make id tags qualified with |
compat-uitron- and add a couple of tags; tidy up formatting of |
some function listings; correct comment on using functions in your |
own DSRs and ISRs. |
|
2002-01-24 Jesper Skov <jskov@redhat.com> |
|
* include/uit_func.inl (ena_int, dis_int): Wrap |
HAL_MASK_INTERRUPT/HAL_UNMASK_INTERRUPT in interrupt |
disable/restore pairs. |
* tests/testintr.cxx (detach_isr, attach_isr): Change order of |
mask/unmask and disable/restore. |
|
2001-04-30 Jonathan Larmour <jlarmour@redhat.com> |
|
* src/uit_objs.cxx: Workaround xscale tools preprocessor bug |
by avoiding determining the stack size with the preprocessor. |
* cdl/tasks.cdl (CYGDAT_UITRON_TASK_EXTERNS and |
CYGDAT_UITRON_TASK_INITIALISERS): Ditto |
|
2001-04-21 Bart Veer <bartv@redhat.com> |
|
* tests/testintr.cxx (task1): |
Disable one of the tests on the synthetic target, it requires |
consistent cpu timing that cannot be guaranteed. |
|
2000-11-01 Jesper Skov <jskov@redhat.com> |
|
* include/uit_func.inl: CYG_SCHED_UNIQUE_PRIORITIES changed to |
CYGINT_KERNEL_SCHEDULER_UNIQUE_PRIORITIES |
|
2000-09-13 Jonathan Larmour <jlarmour@redhat.com> |
|
* include/uit_objs.hxx (CYG_UITRON_OBJS_INIT_PRIORITY): Define |
with correct priority now. |
|
2000-08-03 Jonathan Larmour <jlarmour@redhat.co.uk> |
|
* include/uit_func.inl (ref_mpf): Compute used blocks from |
bytes used / blocks size rather than now obsolete blockcount member |
|
2000-07-04 Jonathan Larmour <jlarmour@redhat.co.uk> |
|
* include/uit_func.inl: Update all memory pool related functions to |
reflect the new interface to memory pools, and that they come from |
the new CYGPKG_MEMALLOC package |
|
* cdl/uitron.cdl: CYGPKG_UITRON_MEMPOOLFIXED and |
CYGPKG_UITRON_MEMPOOLVAR require the CYGPKG_MEMALLOC package |
|
* include/uit_objs.hxx: Update includes - memory pool implementations |
are now in CYGPKG_MEMALLOC |
|
2000-06-15 Gary Thomas <gthomas@redhat.com> |
|
* include/uit_ifnc.h (CYGPRI_UITRON_SET_RETCODE): Always return |
'HANDLED'. This fixes some confusion when interrupt chaining. |
|
2000-05-15 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_ifnc.h (cyg_uitron_dsr): make this be extern "C" |
always; it went wrong when uitron funcs are inline or C++. |
|
* src/uit_ifnc.cxx (CYGIMP_UITRON_INLINE_FUNCS): When [re]defining |
this, match what CDL defined. Warnings--; |
|
2000-05-08 Jesper Skov <jskov@redhat.com> |
|
* tests/testintr.cxx (attach_isr, detach_isr): Don't check for |
clean vector after a detach when chaining is enabled. |
|
2000-03-28 Jesper Skov <jskov@redhat.com> |
|
* tests/testintr.cxx: Synchronize with clock before making timer |
measurement. |
|
2000-03-28 John Dallaway <jld@cygnus.co.uk> |
|
* cdl/uitron.cdl: |
|
Adjust documentation URLs. |
|
2000-03-22 Jesper Skov <jskov@redhat.com> |
|
* include/uit_ifnc.h (ret_int): Fix compiler warning. |
|
2000-03-13 Jesper Skov <jskov@redhat.com> |
|
* tests/testintr.cxx: Don't try to disable clock on PowerPC. |
|
2000-03-03 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testintr.cxx (task1): Only test ena_int() and dis_int() |
for E_PAR if CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS. |
|
2000-02-28 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.h: add ena_int() and dis_int(). |
|
* include/uit_func.inl (dis_int): New function added. |
(ena_int): New function added. |
|
* tests/testintr.cxx (task1): Add a test of ena_int() and |
dis_int(); easiest done here because we have an interrupt number - |
for the clock - in our hands here already for the rest of the |
test. |
|
2000-02-02 Jesper Skov <jskov@redhat.com> |
|
* tests/testintr.cxx: Don't output DELAYLOCKSCHED quite so often |
on synthetic target. |
|
2000-01-31 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testintr.cxx (CHECK_TID): Test that get_tid() returns 0 in |
ISR context ie. non-task portion. |
|
* include/uit_func.inl (get_tid): Check the sched lock for |
non-task portions, ie. ISR/DSR will have the scheduler locked. |
|
2000-01-31 Simon FitzMaurice <sdf@cygnus.co.uk> |
* compat/uitron/current/cdl/uitron.cdl |
|
Adjust help URLs in line with new doc layout. |
|
2000-01-28 Simon FitzMaurice <sdf@cygnus.co.uk> |
* compat/uitron/current/cdl/uitron.cdl |
|
Adjust help URLs in line with new doc layout. |
|
2000-01-28 Jonathan Larmour <jlarmour@redhat.co.uk> |
|
* tests/testintr.cxx (DELAYLOCKSCHED): When in long testing loops, |
occasionally output a message to show the test is still alive |
|
2000-01-26 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: Add new option |
CYGSEM_UITRON_TIME_IS_MILLISECONDS to control just what it says. |
|
* include/uit_func.inl (CYG_UITRON_TIME_UIT_TO_SYS32): et al; new |
macros optionally to convert to/from milliSeconds if option |
CYGSEM_UITRON_TIME_IS_MILLISECONDS is set. |
|
* src/uit_func.cxx: Initialize Cyg_Clock::converter type objects |
if the time unit is set to milliSeconds. |
|
* cdl/uitron.cdl: Add new option |
CYGSEM_UITRON_TIME_IS_MILLISECONDS to control just what it says. |
|
Add an include of the kernel config file to the generated |
pkgconf/uitron.h: tests at the very least need it! This is a |
correct thing to do because the kernel config defines a lot of the |
semantics of the uITRON layer, as well as being needed for |
backward compatibility. |
|
Also add uit_ifnc.cxx to the files that need compiling. Due to |
the previous screwup, no testing has been applied to the uITRON |
system under CDL, because it thought the kernel was absent, so |
this had not been detected. Doh. |
|
2000-01-25 Jesper Skov <jskov@cygnus.co.uk> |
|
* tests/testintr.cxx (cyg_start): externC addded. |
|
2000-01-19 Hugo Tyson <hmt@cygnus.co.uk> |
|
* cdl/*.cdl: Add descriptions to a number of options &c which were |
lacking same, also tidied up other typos as noticed en passant. |
|
1999-11-09 Jonathan Larmour <jlarmour@cygnus.co.uk> |
|
* src/uit_objs.cxx: Make the stack size failsafe be tested against |
the minimum stack size, not the typical one. |
|
1999-11-03 John Dallaway <jld@cygnus.co.uk> |
|
* cdl/uitron.cdl: Define tests. |
|
1999-10-07 John Dallaway <jld@cygnus.co.uk> |
|
* cdl/uitron.cdl: Specify radio buttons using CDL interfaces. |
|
1999-09-06 Jonathan Larmour <jlarmour@cygnus.co.uk> |
|
* include/uit_objs.hxx (CYG_UITRON_OBJS_INIT_PRIORITY): Revert the |
below change - we may still be shipping antiquated compilers to |
customers. Sigh. |
|
1999-09-02 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_objs.hxx (CYG_UITRON_OBJS_INIT_PRIORITY): Enable |
using init priority on uitron objects, now that the compilers all |
support it fully. AFAI can tell from a quite broad experiment. |
|
1999-09-01 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testintr.cxx (attach_isr): Make it all work: my chosen |
default interrupt "level" of 0 means make no interrupts on the |
tx39 ;-( oh well. Made the whole test simulator-friendly ie. much |
shorter, made the output more friendly to me. |
|
1999-08-26 Hugo Tyson <hmt@cygnus.co.uk> |
|
* cdl/uitron.cdl (CYGNUM_UITRON_ISR_ACTION_QUEUESIZE): add a |
"default_value 32" - ooops. |
|
1999-08-26 Hugo Tyson <hmt@cygnus.co.uk> |
|
* cdl/uitron.cdl: Add configury for lovely new interrupt-safe |
functions: just "try immediate execution" [is the sched lock one?] |
and queue size. |
|
* include/pkgconf/uitron.h: Add configury for lovely new |
interrupt-safe functions: just "try immediate execution" [ie. if |
the sched lock is one] and queue size. |
|
* include/uit_ifnc.inl: Respond to general configury wrt the |
presence of semas, flags, mboxes: only define the ixxx_yyy() |
function if the corresponding xxx_yyy() func exists. Remove the |
static definitions of the configuration symbols. |
|
* src/uit_ifnc.cxx: Respond to general configury wrt the presence |
of semas, flags, mboxes: the functions called may not exist! |
|
1999-08-25 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_ifnc.h: New file. Prototypes of interrupt-safe |
ixxx_yyy() style functions as a porting/backwards-compatibility |
aid. Prototype of a suitable DSR to mate with an ISR that uses |
them too. |
|
* include/uit_ifnc.inl: New file. Bodies for possible inlining of |
the ixxx_yyy() style functions; organized much like the standard |
uITRON functions. |
|
* src/uit_ifnc.cxx: New file. Implementation of the DSR provided, |
plus concrete instantiations of the ixxx_yyy() style functions. |
|
* tests/testintr.cxx: New file. Test for the ixxx_yyy() functions |
newly provided above. Rather unpleasant: it is necessary to break |
type-safety to get access to the kernel's interrupt object that |
drives the realtime clock. Perhaps a neater way will follow. |
|
* tests/PKGconf.mak (TESTS): Add new testcase testintr.cxx |
* src/PKGconf.mak (COMPILE): Add new source file uit_ifnc.cxx |
|
1999-08-17 John Dallaway <jld@cygnus.co.uk> |
|
* cdl/uitron.cdl: Implement radio buttons using |
"FIXME radio" hack in description field for now. |
|
1999-07-30 John Dallaway <jld@cygnus.co.uk> |
|
* cdl/uitron.cdl: Tidy display string capitalisation. |
|
1999-05-26 Jesper Skov <jskov@cygnus.co.uk> |
|
* tests/testcx7.cxx: Include new stackmon header. |
|
1999-05-20 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testcx7.cxx (task1): Add some statistics dumping about |
stack usage; since this is quite a long and arduous test. This |
just helps en passant with testing the interrupt stack work that's |
been happening recently. C++ only, so not for test7. |
|
1999-05-17 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/uit_func.inl (ter_tsk): Only up the priority of the |
killee if priorities are not unique or we are not already |
elevated. This is to prevent asserts with the bitmap scheduler. |
(chg_pri): Support a level X feature, pri zero => reset to the |
thread's initial priority. |
|
1999-05-14 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/uit_objs.hxx: object array declaration macro now |
contains constructor priority ordering rune; if 0'd out pending |
99r1 compiler cutover. |
|
1999-04-23 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testcx7.cxx: T2_MALLOC definition; only make it smaller |
than the main consumer malloc if coaleasing is enabled, otherwise |
the mempool cannot allocate blocks for the consumer for next time. |
Fixes PR 18817 - only a random perm disable coalescence. |
|
* tests/test7.c: Ditto. |
|
1999-04-15 John Dallaway <jld@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: Tidy display string capitalization. |
|
1999-04-09 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl (dis_dsp): Remove bad old code which used |
to lock the scheduler to implement dis_dsp() and ena_dsp() - which |
also stopped the clock, for example. Instead change the calling |
thread's priority to 0 internally so that it cannot be preempted |
by uITRON threads at least, whose priorities are 1--N. Same |
applies to loc/unl_cpu(). Save the "real" priority in a static, |
and take notice of it everywhere relevant, such as thread and |
system state inquiries, changing (our own) priority, checking for |
dispatch enabled in sleeping calls, and so on. |
|
* src/uit_func.cxx: New variable cyg_uitron_dis_dsp_old_priority |
for holding the "real" priority of a thread whilst we change our |
priority to zero (the highest) to prevent dispatching in dis_dsp() |
or loc_cpu(). |
|
* include/uit_func.inl (get_tid): Return 0 for the task id if not |
in a uITRON thread, this is better conformance to the spec. |
|
1999-03-22 Hugo Tyson <hmt@cygnus.co.uk> |
|
* src/uit_objs.cxx: |
Use CYGNUM_HAL_STACK_SIZE_TYPICAL for the stack size instead of |
CYGNUM_HAL_MINIMUM_STACK_SIZE. |
|
1999-02-23 Jonathan Larmour <jlarmour@cygnus.co.uk> |
|
* tests/test1.c, tests/test2.c, tests/test3.c, tests/test4.c, |
tests/test5.c, tests/test6.c, tests/test7.c, tests/test8.c, |
tests/test9.c, tests/testcxx.cxx, tests/testcx2.cxx, |
tests/testcx3.cxx, tests/testcx4.cxx, tests/testcx5.cxx, |
tests/testcx6.cxx, tests/testcx7.cxx, tests/testcx8.cxx, |
tests/testcx9.cxx: |
Change all non-applicable cases to use CYG_TEST_NA rather than |
CYG_TEST_PASS/CYG_TEST_EXIT |
|
1999-02-22 Hugo Tyson <hmt@cygnus.co.uk> |
|
* src/uit_objs.cxx: Eeeek! Previous fix was bogus: the override |
was too late in the file to take effect. The declaration of the |
objects (including stacks) is moved to below the override CPP |
runes. |
|
1999-02-12 Hugo Tyson <hmt@cygnus.co.uk> |
|
* src/uit_objs.cxx (CYG_UITRON_DECL): |
Override CYGNUM_UITRON_STACK_SIZE if CYGNUM_HAL_MINIMUM_STACK_SIZE |
demands it. |
|
* include/pkgconf/uitron.h (CYGNUM_UITRON_STACK_SIZE): |
Document that this option can be overridden by HALs demands. |
|
1999-02-02 Jesper Skov <jskov@cygnus.co.uk> |
PR 18968 |
* tests/test2.c (task1): |
* tests/testcx2.cxx (task1): |
Reduce run time on SIM. |
|
1999-01-26 Jesper Skov <jskov@cygnus.co.uk> |
PR 18788 |
* tests/test4.c (task1): |
* tests/testcx4.cxx (task1): |
Extend timeouts when running on HW to avoid failures due to |
overhead of GDB interaction. |
|
1999-01-25 Jesper Skov <jskov@cygnus.co.uk> |
PR 18576 |
* include/pkgconf/uitron.h (CYGDAT_UITRON_SEMA_INITIALIZERS): |
Let default initializers have values that don't cause tests to |
fail. |
|
1998-11-25 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl (del_xxx &c): |
Make error returns more consistent; E_NOEXS rather than E_OBJ if |
the object disappeared during a race. |
|
1998-11-19 Hugo Tyson <hmt@cygnus.co.uk> |
|
* src/uit_func.cxx (SET_UP_PTRS): |
PR 17999; work around codegen bug on tx39 with -Os. |
The code is better with the fix regardless, so it's got no |
downside. Explicitly condition whether to run a follow-on loop |
rather than letting the for-loop sort it out itself. |
|
1998-11-16 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testcx7.cxx (check_waitstate): |
Add a routine to check the reported waiting state of the synch |
object in question, and call it as necessary. This only added to |
the C++ version of the test for enhanced coverage, in case the |
enquiry call perturbs the object state; having both versions |
present is better. This checks a very recent fix to |
kernel...thread.cxx (1998-10-27). |
|
1998-10-21 Hugo Tyson <hmt@cygnus.co.uk> |
|
* src/uit_func.cxx: |
Provide weakly named dummies for task[1-4], which are the defaults |
referred to by the task array, so that the uITRON system can be |
initialized even when no uITRON tasks have been provided (so long |
as no other changes to the task init configury have been made) |
This does not pollute the namespace, for these are weak symbols. |
Changing them to cyg_uitron_task... would be possible, but it |
carries the false implication that those are cygnus names, when |
they are really entirely up to the user. |
|
* tests/test[123456789].c: |
* tests/testcxx.cxx: |
* tests/testcx[23456789].cxx: |
Undo the previous change: remove dummies for task[1-4] when we |
decide not to test anything, they will be provided with weak names |
regardles in src/uit_func.cxx. |
|
1998-10-20 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/test[123456789].c: |
* tests/testcxx.cxx: |
* tests/testcx[23456789].cxx: |
Provide dummies for task[1-4] when we decide not to test anything, |
to encourage correct linking. |
|
1998-10-16 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testcx*.cxx (cyg_start): |
[all the C++ tests] |
changed cyg_start to externC so that it truly does override the |
default one; this is needed for handling the "I cannot test in |
this configuration" failures. Of course the C ones were C to |
start with. |
|
1998-10-16 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/test[123456789].c: |
* tests/testcxx.cxx: |
* tests/testcx[23456789].cxx: |
All tests are now much more self-configuring wrt turning off |
if there are no uITRON objects of the right type to manipulate. |
The huge (50-line) #if statement is arranged the way it is so that |
clauses checking on each feature can be pasted in and out easily. |
So yes, the "&& 1" at the end has a purpose. |
|
Here for the record is a table of feature versus test-used-in: |
tsk :: 1 2 3 4 5 6 7 8 9 |
sem :: 2 3 5 6 7 8 |
flg :: 2 5 6 7 |
mbx :: 2 5 6 7 |
mpl :: 2 5 7 9 |
mpf :: 2 5 7 9 |
alm :: 4 |
cyc :: 4 |
|
|
1998-10-16 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/test9.c: |
* tests/testcx9.cxx: |
New tests, test create and delete of memory pools |
|
1998-10-15 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Add configury for create/delete of memory pools. |
Tidy up naming of initializer macros to use for non-existent |
(initially) uITRON objects. |
Improve comments in CDL-- info fields. |
|
* include/uit_func.h: |
Add prototypes for cre/del_mpf/mpl(). |
|
* include/uit_func.inl: |
Implement cre/del_mpf/mpl(). |
|
* src/uit_objs.cxx: |
Support CYG_UIT_MEMPOOLFIXED_NOEXS/CYG_UIT_MEMPOOLVAR_NOEXS(...) |
mempool construction macros for non-existent (initially) mempools. |
Rename _NONE construction macros to _NOEXS which will make a lot |
more sense to uITRON folks. |
|
1998-10-14 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Add configury for create/delete of tasks. |
|
* include/uit_func.h: |
Add prototypes for cre/del_tsk(); correct comment in exd_tsk(). |
|
* include/uit_func.inl: |
Implement cre/del_tsk() and complete exd_tsk(). |
Improve NULL/NADR checking on other cre/del calls. |
|
* src/uit_func.cxx (cyg_uitron_start): |
Deal better with start tasks stuff, for task create/delete. |
|
* src/uit_objs.cxx: |
Support CYG_UIT_TASK_NONE(...) task constructor for those tasks |
which do not initially exist |
|
* tests/PKGconf.mak: |
Add new tests test8.c, testcx[678].cxx to the build. |
|
* tests/test6.c: |
Tidy comments, untabify. |
|
* tests/test7.c: |
Tidy comments, untabify, test creation with NADR record pointer. |
No impact from the new cre/del_tsk() functionality on test7, since |
a task may only be deleted when it is dormant, so deletion is NOT |
another way out of a waiting state. |
|
* tests/test8.c: |
New test, tests cre_tsk() and del_tsk() and exd_tsk() ie. the |
creation and deletion of tasks. |
|
* tests/testcx6.cxx: |
* tests/testcx7.cxx: |
* tests/testcx8.cxx: |
New tests, C++ versions of tests 6, 7, and 8. |
|
1998-10-09 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/test7.c: |
Test interactions with deleting objects (as applicable) and |
killing, signalling and the like. Also test killing the task |
after other treatments more generically. |
|
* tests/test6.c (task1): |
Change "N/A:" to "N/A" in the exit message when we didn't actually |
do any testing due to create/delete being disabled for all object |
types. |
|
1998-10-08 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
In general, these changes are to support create/delete of uITRON |
objects; this requires that an object can be destroyed whilst |
there are threads waiting on it, and that they shall be awoken |
with a specific return code E_DLT. The implementation uses an |
array of pointers in addition to the array of objects: ptrs[N] |
should either be NULL or &objs[N] in this version. That |
restriction is not checked, in order that in future, true dynamic |
allocation can be used, and ptrs[N] could point anywhere. The |
implications of this are mainly in the area of getting the |
addresses of objects, via the ptr array or from the object array? |
The config of whether there is a ptr array is per object type. |
|
* include/pkgconf/uitron.h: |
Configury of the existence or not of create/delete for object |
type: initially only SEMAS, MBOXES, FLAGS. |
Configury of the number of objects created initially, if cre/del |
are enabled. |
|
* tests/test6.c: |
* tests/test7.c: |
* tests/PKGconf.mak: |
Two new test programs (duh!): test6 tests create and delete of |
SEMAS, MBOXES, FLAGS explicitly, for bad params handling, ability |
to use after deletion and recreation &c &c. test7 tests the |
semantics of sleeping on some synchronization primitive, permed |
with suspension, signalling, killing, releasing and so forth. |
Both will migrate into C++ versions also in future. |
|
* include/uit_func.h: |
Enable cre/del_{mbx,flg,sem} prototypes. |
|
* include/uit_func.inl: |
Implement cre/del_{mbx,flg,sem} depending on configury, and handle |
the pointer arrays generally in other client routines. |
|
* include/uit_objs.hxx: |
Define the pointer arrays for access to created objects. |
|
* include/uit_type.h: |
Enable definitions of the structures used in create calls. |
|
* src/uit_func.cxx: |
Initialization code for the pointer arrays, akin to the task |
startup code. |
|
* src/uit_objs.cxx: |
Instantiate the pointer arrays themselves. |
|
|
1998-09-25 Bart Veer <bartv@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
PR 17482: added #ifdef protection. If CYGPKG_UITRON_MEMPOOLFIXED |
is not defined then the contained option |
CYGNUM_UITRON_MEMPOOLFIXED may not be defined either. Ditto for |
CYGNUM_UITRON_MEMPOOLVAR which suffers from the same problem. |
And ditto for CYGPKG_UITRON_SEMAS |
|
1998-09-20 Mark Galassi <rosalia@cygnus.com> |
|
* include/pkgconf/uitron.h: added one or two CDL doc strings. |
|
Tue Sep 15 19:12:28 1998 David Moore <dsm@keema.cygnus.co.uk> |
|
* include/pkgconf/uitron.h: Cleaned up comments. |
|
1998-09-12 Mark Galassi <rosalia@cygnus.com> |
small changes to the descriptive information in the uITRON CDL |
|
1998-09-12 Mark Galassi <rosalia@cygnus.com> |
|
* include/pkgconf/uitron.h: small editing of the description |
fields: renamed things like <name> to NAME, so that it does not |
confuse SGML when incorporated into the documentation. |
Also added various "doc" fields to the CFG_DATA comments. |
|
Wed Sep 9 18:36:15 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl: |
* include/uit_objs.hxx: |
* src/uit_objs.cxx: |
Condition features on CYGPKG_UITRON_SEMAS [for example] as well as |
0 < CYG_UITRON_NUM( SEMAS ) so that we get warning free |
compilation with no semas enabled. Ditto for flags, mboxes, |
mempools fixed and variable, alarms and cyclics. |
|
* include/pkgconf/uitron.h: |
Add a couple of requires statements from cyclics and alarms on the |
kernel clock. |
Also change some grammar after review. |
Add an option (actually a pair, makes it better documentation IMO) |
to require strict semantics from the kernel setup. |
Add an option to control the optional sema initializer; it was |
omitted since the editor way of configury used a #if 0. |
|
Fri Sep 4 17:54:29 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Remove redundant and now unnecessary defs of CYGPKG_UITRON. |
|
Wed Sep 2 19:06:17 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl: |
Memory pools and message boxes and flags |
and cnt_sem2-type semaphores now all have absolute timeouts |
instead of relative ones in the timely wait functions. |
We add in the current time here first. |
|
Wed Sep 2 16:45:40 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/pkgconf/uitron.h (CYGDAT_UITRON_TASK_INITIALIZERS): |
Use the new kernel thread initializer with priority and thread |
name in it. |
|
* include/uit_func.inl: |
* include/uit_objs.hxx: |
* src/uit_func.cxx (cyg_uitron_start): |
* src/uit_objs.cxx: |
Our tasks are now Cyg_Threads rather than a derived class. |
Original priorities of tasks are held in an array. An accessor |
macro is used for the off-by-one nature of uitron IDs. The array |
of original priorities is set up in cyg_uitron_start(), and |
created in uit_objs.cxx. |
|
Wed Sep 2 15:15:26 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Comment more strongly in the 'description' that the number of |
initializers better match the number of things specified. |
|
Tue Sep 1 19:00:02 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/uit_objs.hxx: |
Do not include <cyg/kernel/kernel.h>; it is deprecated. |
Instead, include only kernel headers that are needed. |
|
* include/uit_func.inl (ref_sys): |
Use new kernel function Cyg_Interrupt::interrupts_enabled() |
instead of a state variable. Tidy up associated code. |
Include kernel headers that are needed because they were not |
included in uit_objs.hxx for tidiness. |
|
* src/uit_func.cxx: |
Elide state variable that used to be used for tracking interrupt |
enabledness state. |
|
* tests/testcx5.cxx (task1): |
* tests/test5.c (task1): |
Test interrupt enable and disable stuff, and status reporting. |
|
Tue Sep 1 15:12:29 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl (ref_mpf): |
Change comment "ECC" to "eCos". |
|
1998-08-28 Bart Veer <bartv@cygnus.co.uk> |
|
* include/uit_func.inl: |
* tests/test1.c, tests/test2.c, tests/test3.c, tests/test4.c, |
tests/test5.c, tests/testcxx.cxx, tests/testcx2.cxx, |
tests/testcx3.cxx, tests/testcx4.cxx, tests/testcx5.cxx: |
|
Updated for new kernel configuration option symbol names |
|
|
Fri Aug 28 09:21:55 1998 Jonathan Larmour <jlarmour@cygnus.co.uk> |
|
* src/uit_func.cxx (cyg_uitron_start): |
Remove call to Cyg_Scheduler::start() and adjust comments to |
explain where to call it from |
|
* tests/test1.c, tests/test2.c, tests/test3.c, tests/test4.c, |
tests/test5.c, tests/testcxx.cxx, tests/testcx2.cxx, |
tests/testcx3.cxx, tests/testcx4.cxx, tests/testcx5.cxx: |
Change the normal entry point at the top to be cyg_package_start() |
under the new startup scheme. This overrides the default package |
configuration and ensure cyg_uitron_start() gets called. |
Change the "default" entry point at the bottom (when the test is |
N/A for some reason) to cyg_start() under the new startup scheme. |
|
Wed Aug 26 18:20:47 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Initial version of cdl control statements for config options. |
All very groovy, and looking good IMO. |
A few FIX-MEs remain, no big deal. |
|
Mon Aug 24 19:05:52 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Change the names of config options to helpful, positive sense, and |
tidy some of the names for inclusion in the GUI tool. Clean up |
the namespace too. |
|
* include/uit_func.h: |
* include/uit_func.inl: |
* src/uit_func.cxx: |
* src/uit_objs.cxx: |
Configure according to new option names and object construction |
macros. Simple changes but widespread. |
|
* tests/test[12345].c: |
* tests/testcx[x2345].cxx: |
Configure according to new option names. |
Make it main( void ) to avoid a warning. |
|
Fri Aug 21 18:45:16 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* tests/testcx4.cxx (task1): |
* tests/test4.c (task1): |
* include/uit_func.inl (def_alm): |
Tidy the alarm and timer funcs in the course of fixing a kernel |
bug actually. Test the functionality affected by the kernel |
change a bit more. |
|
Thu Aug 20 14:33:36 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/uit_func.inl (ref_alm): |
Elide an unused variable following the previous change. |
|
Mon Aug 17 15:45:07 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
* include/pkgconf/uitron.h: |
Add the config option CYGSEM_UITRON_PARAMS_CHECK_NADR_ONLY. |
|
* tests/testcxx.cxx: |
* tests/testcx2.cxx: |
* tests/testcx4.cxx: |
Avoid testing with NULL as a bad parameter when only NADR is |
checked. (NADR does not cast to any-pointer in C++ so we don't |
test it in these programs) Check for NADR various places as well |
as NULL. |
|
* tests/test1.c (task1): |
* tests/test2.c (task1): |
* tests/test4.c (task1): |
Avoid testing with NULL as a bad parameter when only NADR is |
checked. Check for NADR various places as well as NULL, and test |
NADR as a bad param as well as NULL. |
|
|
Mon Aug 17 14:45:30 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl: |
PR# 16536: Check for dormant tasks various places; E_OBJ |
must be returned. All this error checking rather bloats the code, |
unfortunately. |
|
* tests/testcxx.cxx: |
* tests/test1.c: |
Test the new checks above. |
|
Fri Aug 14 17:41:35 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* include/uit_func.inl ([t]wai/pol_flg): |
Check for zero in a wait-for-flag operation; such a wait can never |
be awakened, and so should return E_PAR. |
|
* tests/testcx2.cxx (task1): |
* tests/test2.c (task1): |
Test the above new checking. |
|
Fri Jul 24 17:12:54 1998 Hugo Tyson <hmt@masala.cygnus.co.uk> |
|
PR#15865 |
* include/uit_func.inl: return a bool (strictly 1 or 0) for wtsk |
rather than -1 or zero as the spec implies. |
ref_flg() ref_sem() only affected. |
|
Fri Jul 24 13:26:51 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
PR#16531 |
* include/uit_func.inl: return E_OBJ when (force)resuming a |
non-suspended task. |
* tests/test1.c: test for that error code. |
* tests/testcxx.cxx: test for that error code. |
|
Fri Jul 24 13:02:46 1998 Hugo Tyson <hmt@cygnus.co.uk> |
|
* Changelog: Initial ChangeLog entry. |
|
|
//=========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//=========================================================================== |