diff options
Diffstat (limited to '')
32 files changed, 2992 insertions, 0 deletions
diff --git a/cpukit/itron/src/can_wup.c b/cpukit/itron/src/can_wup.c new file mode 100644 index 0000000000..d75d379de9 --- /dev/null +++ b/cpukit/itron/src/can_wup.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * can_wup - Cancel Wakeup Request + */ + +ER can_wup( + INT *p_wupcnt, + ID tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/chg_pri.c b/cpukit/itron/src/chg_pri.c new file mode 100644 index 0000000000..b2d42905e5 --- /dev/null +++ b/cpukit/itron/src/chg_pri.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * chg_pri - Change Task Priority + */ + +ER chg_pri( + ID tskid, + PRI tskpri +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/cre_tsk.c b/cpukit/itron/src/cre_tsk.c new file mode 100644 index 0000000000..76bcd75eda --- /dev/null +++ b/cpukit/itron/src/cre_tsk.c @@ -0,0 +1,127 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * cre_tsk - Create Task + */ + +/* + * XXX - How do I return these errors ??? Do I have to validate the ID + prior to calling the ID routine ?? + E_NOMEM Insufficient memory (Memory for control block and/or user stack + cannot be allocated) + E_ID Invalid ID Number (tskid was invalid or could not be used) + E_RSATR Reserved attribute (tskatr was invalid or could not be used) + E_OBJ Invalid object state (a task of the same ID already exists) + E_OACV Object access violation (A tskid less than -4 was specified from + a user task. This is implementation dependent.) + E_PAR Parameter error (pk_ctsk, task, itskpri and/or stksz is invalid) + EN_OBJNO An object number which could not be accessed on the target node + is specified. + EN_CTXID Specified an object on another node when the system call was + issued from a task in dispatch disabled state or from a task- + independent portion + EN_PAR A value outside the range supported by the target node and/or + transmission packet format was specified as a parameter (a value + outside supported range was specified for exinf, tskatr, task, + itskpri and/or stksz) + */ + +ER cre_tsk( + ID tskid, + T_CTSK *pk_ctsk +) +{ + register Thread_Control *the_thread; + char *name = "trn"; + boolean status; + Priority_Control core_priority; + + /* + * Disable dispatching. + */ + + _Thread_Disable_dispatch(); + + /* + * allocate the thread. + */ + + the_thread = _ITRON_Task_Allocate( tskid ); + if ( !the_thread ) { + ena_dsp(); + return _ITRON_Task_Clarify_allocation_id_error( tskid ); + } + + /* + * XXX - FIX THE VARIABLES TO THE CORRECT VALUES!!! + */ + + /* + * Initialize the core thread for this task. + */ + + core_priority = _ITRON_Task_Priority_to_Core( pk_ctsk->itskpri ); + status = _Thread_Initialize( + &_ITRON_Task_Information, + the_thread, + NULL, + pk_ctsk->stksz, + TRUE, /* XXX - All tasks FP ??? */ + core_priority, + TRUE, + THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE, + NULL, /* no budget algorithm callout */ + 0, + &name + ); + + if ( !status ) { + _ITRON_Task_Free( the_thread ); + _Thread_Enable_dispatch(); + return -1; +#if (0) +/* XXX */ +#endif + } + +#if (0) /* XXX We have any thing else to set per API structure? */ + api = the_thread->API_Extensions[ THREAD_API_ITRON ]; + asr = &api->Signal; + + asr->is_enabled = FALSE; + + *id = the_thread->Object.id; +#endif + + /* + * This insures we evaluate the process-wide signals pending when we + * first run. + * + * NOTE: Since the thread starts with all unblocked, this is necessary. + */ + + the_thread->do_post_task_switch_extension = TRUE; + + the_thread->Start.entry_point = (Thread_Entry) pk_ctsk->task; + + _Thread_Enable_dispatch(); + return E_OK; +} + diff --git a/cpukit/itron/src/del_tsk.c b/cpukit/itron/src/del_tsk.c new file mode 100644 index 0000000000..5230acddca --- /dev/null +++ b/cpukit/itron/src/del_tsk.c @@ -0,0 +1,50 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * del_tsk - Delete Task + */ + +ER del_tsk( + ID tskid +) +{ + register Thread_Control *the_thread; + Objects_Locations location; + ER result; + + /* XXX - Fix Documentation and error checking for this error on self */ + + the_thread = _ITRON_Task_Get( tskid, &location ); + _Thread_Disable_dispatch(); + + switch ( location ) { + case OBJECTS_REMOTE: + case OBJECTS_ERROR: + _Thread_Enable_dispatch(); + return _ITRON_Task_Clarify_get_id_error( tskid ); + + case OBJECTS_LOCAL: + result = _ITRON_Delete_task( the_thread ); + } + + _Thread_Enable_dispatch(); + return E_OK; +} + diff --git a/cpukit/itron/src/dis_dsp.c b/cpukit/itron/src/dis_dsp.c new file mode 100644 index 0000000000..348a3d64af --- /dev/null +++ b/cpukit/itron/src/dis_dsp.c @@ -0,0 +1,35 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * dis_dsp - Disable Dispatch + */ + +ER dis_dsp( void ) +{ + /* + * Disable dispatch for protection + */ + + _Thread_Disable_dispatch(); + + return E_OK; +} + + diff --git a/cpukit/itron/src/ena_dsp.c b/cpukit/itron/src/ena_dsp.c new file mode 100644 index 0000000000..7c4d86f4d5 --- /dev/null +++ b/cpukit/itron/src/ena_dsp.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * ena_dsp - Enable Dispatch + */ + +ER ena_dsp( void ) +{ + _Thread_Enable_dispatch(); + + return E_OK; +} + diff --git a/cpukit/itron/src/eventflags.c b/cpukit/itron/src/eventflags.c new file mode 100644 index 0000000000..6855593391 --- /dev/null +++ b/cpukit/itron/src/eventflags.c @@ -0,0 +1,152 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/eventflags.h> + +/* + * _ITRON_Eventflags_Manager_initialization + * + * This routine initializes all event flags manager related data structures. + * + * Input parameters: + * maximum_eventflags - maximum configured eventflags + * + * Output parameters: NONE + */ + +void _ITRON_Eventflags_Manager_initialization( + unsigned32 maximum_eventflags +) +{ + _Objects_Initialize_information( + &_ITRON_Eventflags_Information, /* object information table */ + OBJECTS_ITRON_EVENTFLAGS, /* object class */ + FALSE, /* TRUE if this is a global */ + /* object class */ + maximum_eventflags, /* maximum objects of this class */ + sizeof( ITRON_Eventflags_Control ), /* size of this object's */ + /* control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's */ + /* name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_flg - Create Eventflag + */ + +ER cre_flg( + ID flgid, + T_CFLG *pk_cflg +) +{ + return E_OK; +} + +/* + * del_flg - Delete Eventflag + */ + +ER del_flg( + ID flgid +) +{ + return E_OK; +} + +/* + * set_flg - Set Eventflag + */ + +ER set_flg( + ID flgid, + UINT setptn +) +{ + return E_OK; +} + +/* + * clr_flg - Clear Eventflag + */ + +ER clr_flg( + ID flgid, + UINT clrptn +) +{ + return E_OK; +} + +/* + * wai_flg - Wait on Eventflag + */ + +ER wai_flg( + UINT *p_flgptn, + ID flgid, + UINT waiptn, + UINT wfmode +) +{ + return E_OK; +} + +/* + * pol_flg - Wait for Eventflag(Polling) + */ + +ER pol_flg( + UINT *p_flgptn, + ID flgid, + UINT waiptn, + UINT wfmode +) +{ + return E_OK; +} + +/* + * twai_flg - Wait on Eventflag with Timeout + */ + +ER twai_flg( + UINT *p_flgptn, + ID flgid, + UINT waiptn, + UINT wfmode, + TMO tmout +) +{ + return E_OK; +} + +/* + * ref_flg - Reference Eventflag Status + */ + +ER ref_flg( + T_RFLG *pk_rflg, + ID flgid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/exd_tsk.c b/cpukit/itron/src/exd_tsk.c new file mode 100644 index 0000000000..c2b86f3126 --- /dev/null +++ b/cpukit/itron/src/exd_tsk.c @@ -0,0 +1,40 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> +#include <assert.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * exd_tsk - Exit and Delete Task + */ + +void exd_tsk( void ) +{ + Objects_Information *the_information; + + the_information = _Objects_Get_information( _Thread_Executing->Object.id ); + + /* This should never happen if _Thread_Get() works right */ + assert( the_information ); + + _Thread_Disable_dispatch(); + + _Thread_Set_state( _Thread_Executing, STATES_DORMANT ); + _ITRON_Delete_task( _Thread_Executing ); + + _Thread_Enable_dispatch(); +} + diff --git a/cpukit/itron/src/ext_tsk.c b/cpukit/itron/src/ext_tsk.c new file mode 100644 index 0000000000..a8a3b0ec23 --- /dev/null +++ b/cpukit/itron/src/ext_tsk.c @@ -0,0 +1,27 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * ext_tsk - Exit Issuing Task + */ + +void ext_tsk( void ) +{ + _Thread_Set_state( _Thread_Executing, STATES_DORMANT ); +} diff --git a/cpukit/itron/src/fmempool.c b/cpukit/itron/src/fmempool.c new file mode 100644 index 0000000000..af4b931791 --- /dev/null +++ b/cpukit/itron/src/fmempool.c @@ -0,0 +1,135 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/fmempool.h> + +/* + * _ITRON_Fixed_memory_pool_Manager_initialization + * + * This routine initializes all fixed memory pool manager related + * data structures. + * + * Input parameters: + * maximum_fixed_memory_pools - maximum configured fixed memory pools + * + * Output parameters: NONE + */ + +void _ITRON_Fixed_memory_pool_Manager_initialization( + unsigned32 maximum_fixed_memory_pools +) +{ + _Objects_Initialize_information( + &_ITRON_Fixed_memory_pool_Information, /* object information table */ + OBJECTS_ITRON_FIXED_MEMORY_POOLS, /* object class */ + FALSE, /* TRUE if this is a global */ + /* object class */ + maximum_fixed_memory_pools, /* maximum objects of this class */ + sizeof( ITRON_Fixed_memory_pool_Control ), + /* size of this object's control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's */ + /* name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_mpf - Create Fixed-Size Memorypool + */ + +ER cre_mpf( + ID mpfid, + T_CMPF *pk_cmpf +) +{ + return E_OK; +} + +/* + * del_mpf - Delete Fixed-Size Memorypool + */ + +ER del_mpf( + ID mpfid +) +{ + return E_OK; +} + +/* + * get_blf - Get Fixed-Size Memory Block + */ + +ER get_blf( + VP *p_blf, + ID mpfid +) +{ + return E_OK; +} + +/* + * pget_blf - Poll and Get Fixed-Size Memory Block + */ + +ER pget_blf( + VP *p_blf, + ID mpfid +) +{ + return E_OK; +} + +/* + * tget_blf - Get Fixed-Size Memory Block with Timeout + */ + +ER tget_blf( + VP *p_blf, + ID mpfid, + TMO tmout +) +{ + return E_OK; +} + +/* + * rel_blf - Release Fixed-Size Memory Block + */ + +ER rel_blf( + ID mpfid, + VP blf +) +{ + return E_OK; +} + +/* + * ref_mpf - Reference Fixed-Size Memorypool Status + */ + +ER ref_mpf( + T_RMPF *pk_rmpf, + ID mpfid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/frsm_tsk.c b/cpukit/itron/src/frsm_tsk.c new file mode 100644 index 0000000000..8fe5e9e6fc --- /dev/null +++ b/cpukit/itron/src/frsm_tsk.c @@ -0,0 +1,31 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * frsm_tsk - Forcibly Resume Suspended Task + */ + +ER frsm_tsk( + ID tskid +) +{ + return E_OK; +} + + diff --git a/cpukit/itron/src/get_tid.c b/cpukit/itron/src/get_tid.c new file mode 100644 index 0000000000..1c5175052a --- /dev/null +++ b/cpukit/itron/src/get_tid.c @@ -0,0 +1,29 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * get_tid - Get Task Identifier + */ + +ER get_tid( + ID *p_tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/itronintr.c b/cpukit/itron/src/itronintr.c new file mode 100644 index 0000000000..14e1d6d67e --- /dev/null +++ b/cpukit/itron/src/itronintr.c @@ -0,0 +1,104 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/intr.h> + +/* + * def_int - Define Interrupt Handler + */ + +ER def_int( + UINT dintno, + T_DINT *pk_dint +) +{ + return E_OK; +} + +/* + * ret_int - Return from Interrupt Handler + */ + +void ret_int( void ) +{ +} + +/* + * ret_wup - Return and Wakeup Task + */ + +void ret_wup( + ID tskid +) +{ +} + +/* + * loc_cpu - Lock CPU + */ + +ER loc_cpu( void ) +{ + return E_OK; +} + +/* + * unl_cpu - Unlock CPU + */ + +ER unl_cpu( void ) +{ + return E_OK; +} + +/* + * dis_int - Disable Interrupt + */ + +ER dis_int( + UINT eintno +) +{ + return E_OK; +} + +/* + * ena_int - Enable Interrupt + */ + +ER ena_int( + UINT eintno +) +{ + return E_OK; +} + +/* + * chg_iXX - Change Interrupt Mask(Level or Priority) + */ + +ER chg_iXX( + UINT iXXXX +) +{ + return E_OK; +} + +/* + * ref_iXX - Reference Interrupt Mask(Level or Priority) + */ + +ER ref_iXX( + UINT *p_iXXXX +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/itronsem.c b/cpukit/itron/src/itronsem.c new file mode 100644 index 0000000000..a41775f0f6 --- /dev/null +++ b/cpukit/itron/src/itronsem.c @@ -0,0 +1,337 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/semaphore.h> +#include <rtems/itron/task.h> +#include <rtems/score/tod.h> + +/* + * _ITRON_Semaphore_Manager_initialization + * + * DESCRIPTION: + * + * This routine initializes all semaphore manager related data structures. + * + * Input parameters: + * maximum_semaphores - maximum configured semaphores + * + * Output parameters: NONE + */ + +void _ITRON_Semaphore_Manager_initialization( + unsigned32 maximum_semaphores +) +{ + _Objects_Initialize_information( + &_ITRON_Semaphore_Information, /* object information table */ + OBJECTS_ITRON_SEMAPHORES, /* object class */ + FALSE, /* TRUE if this is a global */ + /* object class */ + maximum_semaphores, /* maximum objects of this class */ + sizeof( ITRON_Semaphore_Control ), /* size of this object's control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's */ + /* name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_sem - Create Semaphore + * + * This function implements the ITRON 3.0 cre_sem() service. + */ + +ER cre_sem( + ID semid, + T_CSEM *pk_csem +) +{ + CORE_semaphore_Attributes the_semaphore_attributes; + ITRON_Semaphore_Control *the_semaphore; + + /* + * Bad pointer to the attributes structure + */ + + if ( !pk_csem ) + return E_PAR; + + /* + * Bits were set that were note defined. + */ + + if ( pk_csem->sematr & _ITRON_SEMAPHORE_UNUSED_ATTRIBUTES ) + return E_RSATR; + + /* + * Initial semaphore count exceeds the maximum. + */ + + if ( pk_csem->isemcnt > pk_csem->maxsem ) + return E_PAR; + + /* + * This error is not in the specification but this condition + * does not make sense. + */ + + if ( pk_csem->maxsem == 0 ) + return E_PAR; + + _Thread_Disable_dispatch(); /* prevents deletion */ + + the_semaphore = _ITRON_Semaphore_Allocate( semid ); + if ( !the_semaphore ) { + _Thread_Enable_dispatch(); + return _ITRON_Semaphore_Clarify_allocation_id_error( semid ); + } + + if ( pk_csem->sematr & TA_TPRI ) + the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; + else + the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; + + the_semaphore_attributes.maximum_count = pk_csem->maxsem; + + _CORE_semaphore_Initialize( + &the_semaphore->semaphore, + OBJECTS_ITRON_SEMAPHORES, + &the_semaphore_attributes, + pk_csem->isemcnt, + NULL /* Multiprocessing not supported */ + ); + + _ITRON_Objects_Open( &_ITRON_Semaphore_Information, &the_semaphore->Object ); + + /* + * If multiprocessing were supported, this is where we would announce + * the existence of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + + _Thread_Enable_dispatch(); + return E_OK; +} + +/* + * del_sem - Delete Semaphore + * + * This function implements the ITRON 3.0 del_sem() service. + */ + +ER del_sem( + ID semid +) +{ + ITRON_Semaphore_Control *the_semaphore; + Objects_Locations location; + + the_semaphore = _ITRON_Semaphore_Get( semid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: /* Multiprocessing not supported */ + case OBJECTS_ERROR: + return _ITRON_Semaphore_Clarify_get_id_error( semid ); + + case OBJECTS_LOCAL: + _CORE_semaphore_Flush( + &the_semaphore->semaphore, + NULL, /* Multiprocessing not supported */ + CORE_SEMAPHORE_WAS_DELETED + ); + + _ITRON_Objects_Close( + &_ITRON_Semaphore_Information, + &the_semaphore->Object + ); + + _ITRON_Semaphore_Free( the_semaphore ); + + /* + * If multiprocessing were supported, this is where we would announce + * the destruction of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + + _Thread_Enable_dispatch(); + return E_OK; + + } + return E_OK; +} + +/* + * sig_sem - Signal Semaphore + * + * This function implements the ITRON 3.0 sig_sem() service. + */ + +ER sig_sem( + ID semid +) +{ + ITRON_Semaphore_Control *the_semaphore; + Objects_Locations location; + CORE_semaphore_Status status; + + the_semaphore = _ITRON_Semaphore_Get( semid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: /* Multiprocessing not supported */ + case OBJECTS_ERROR: + return _ITRON_Semaphore_Clarify_get_id_error( semid ); + + case OBJECTS_LOCAL: + /* + * XXX maxsemcnt + */ + + status = _CORE_semaphore_Surrender( + &the_semaphore->semaphore, + the_semaphore->Object.id, + NULL /* Multiprocessing not supported */ + ); + _Thread_Enable_dispatch(); + return _ITRON_Semaphore_Translate_core_semaphore_return_code( status ); + } + return E_OK; +} + +/* + * wai_sem - Wait on Semaphore + * + * This function implements the ITRON 3.0 wai_sem() service. + */ + +ER wai_sem( + ID semid +) +{ + return twai_sem( semid, TMO_FEVR ); +} + +/* + * preq_sem - Poll and Request Semaphore + * + * This function implements the ITRON 3.0 preq_sem() service. + */ + +ER preq_sem( + ID semid +) +{ + return twai_sem( semid, TMO_POL ); +} + +/* + * twai_sem - Wait on Semaphore with Timeout + * + * This function implements the ITRON 3.0 twai_sem() service. + */ + +ER twai_sem( + ID semid, + TMO tmout +) +{ + ITRON_Semaphore_Control *the_semaphore; + Objects_Locations location; + Watchdog_Interval interval; + boolean wait; + CORE_semaphore_Status status; + + interval = 0; + if ( tmout == TMO_POL ) { + wait = FALSE; + } else { + wait = TRUE; + if ( tmout != TMO_FEVR ) + interval = TOD_MILLISECONDS_TO_TICKS(tmout); + } + + if ( wait && _ITRON_Is_in_non_task_state() ) + return E_CTX; + + the_semaphore = _ITRON_Semaphore_Get( semid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: /* Multiprocessing not supported */ + case OBJECTS_ERROR: + return _ITRON_Semaphore_Clarify_get_id_error( semid ); + + case OBJECTS_LOCAL: + _CORE_semaphore_Seize( + &the_semaphore->semaphore, + the_semaphore->Object.id, + wait, /* wait for a timeout */ + interval /* timeout value */ + ); + _Thread_Enable_dispatch(); + status = (CORE_semaphore_Status) _Thread_Executing->Wait.return_code; + return _ITRON_Semaphore_Translate_core_semaphore_return_code( status ); + } + return E_OK; +} + +/* + * ref_sem - Reference Semaphore Status + * + * This function implements the ITRON 3.0 ref_sem() service. + */ + +ER ref_sem( + ID semid, + T_RSEM *pk_rsem +) +{ + ITRON_Semaphore_Control *the_semaphore; + Objects_Locations location; + + if ( !pk_rsem ) + return E_PAR; /* XXX check this error code */ + + the_semaphore = _ITRON_Semaphore_Get( semid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: /* Multiprocessing not supported */ + case OBJECTS_ERROR: + return _ITRON_Semaphore_Clarify_get_id_error( semid ); + + case OBJECTS_LOCAL: + /* + * Fill in the current semaphore count + */ + + pk_rsem->semcnt = _CORE_semaphore_Get_count( &the_semaphore->semaphore ); + + /* + * Fill in whether or not there is a waiting task + */ + + if ( !_Thread_queue_First( &the_semaphore->semaphore.Wait_queue ) ) + pk_rsem->wtsk = FALSE; + else + pk_rsem->wtsk = TRUE; + + _Thread_Enable_dispatch(); + return E_OK; + } + return E_OK; +} + diff --git a/cpukit/itron/src/itrontime.c b/cpukit/itron/src/itrontime.c new file mode 100644 index 0000000000..13621a9e6a --- /dev/null +++ b/cpukit/itron/src/itrontime.c @@ -0,0 +1,241 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/tod.h> + +#include <rtems/itron/time.h> + +/* + * set_tim - Set System Clock + */ + +void converTime(SYSTIME ms, TOD_Control *time) +{ + int millisecond; + +/* XXX need to dereference structure */ +#if 0 + milisecond = ms % 1000; + tempSecond = ms / 1000; +#else + millisecond = 0; +#endif +} + + +/* + * set_tim - Set System Clock + */ + +ER set_tim( + SYSTIME *pk_tim +) +{ + Watchdog_Interval temp; /* an integer in seconds after conversion from SYSTIME */ + TOD_Control the_tod; + +/* convert *pk_tim which is 48 bits integer in binary into an ordinary + integer in milliseconds */ + +/* XXX */ temp = 0; + if(temp > 0) { + _Thread_Disable_dispatch(); + _TOD_Set(&the_tod, temp); + _Thread_Enable_dispatch(); + if(_TOD_Validate(&the_tod)){ + return E_OK; + } + } + return E_SYS; +} + +/* + * get_tim - Get System Clock + */ + +ER get_tim( + SYSTIME *pk_tim +) +{ + return E_OK; +} + +/* + * dly_tsk - Delay Task + */ + +ER dly_tsk( + DLYTIME dlytim +) +{ + Watchdog_Interval ticks; + + ticks = TOD_MILLISECONDS_TO_TICKS(dlytim); + + _Thread_Disable_dispatch(); + if ( ticks == 0 ) { + _Thread_Yield_processor(); + } else { + _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); + _Watchdog_Initialize( + &_Thread_Executing->Timer, + _Thread_Delay_ended, + _Thread_Executing->Object.id, + NULL + ); + _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); + } + _Thread_Enable_dispatch(); + return E_OK; +} + +/* + * def_cyc - Define Cyclic Handler + */ + +ER def_cyc( + HNO cycno, + T_DCYC *pk_dcyc +) +{ + Watchdog_Control *object; +#if 0 + Watchdog_Interval timeInterval; +#endif + +/* XXX */ object = 0; + if ( pk_dcyc->cycatr != TA_HLNG) + return E_RSATR; +#if 0 + timeInterval = pk_dcyc->cyctim / 1000; + object->delta_interval = timeInterval; +#endif + _Watchdog_Initialize( + object, + pk_dcyc->cychdr, + cycno, + pk_dcyc->exinf); + _Watchdog_Deactivate(object); + + return E_OK; +} + +/* + * act_cyc - Activate Cyclic Handler + */ + +ER act_cyc( + HNO cycno, + UINT cycact +) +{ + Watchdog_Control *object; + + if(cycact != TCY_OFF || cycact != TCY_ON) + return E_PAR; + +#if 0 + if( object->Object_ID != cycno) + return E_NOEXS; +#endif + + _Watchdog_Activate(object); + + return E_OK; +} + +/* + * ref_cyc - Reference Cyclic Handler Status + */ + +ER ref_cyc( + T_RCYC *pk_rcyc, + HNO cycno +) +{ +#if 0 + int timeElapse_since_actCyclic; +#endif + T_DCYC *pk_dcyc; +#if 0 + Watchdog_Control *object; +#endif + +/* XXX */ pk_dcyc = 0; + +/* XXX will to use a "get" routine to map from id to object pointer */ +/* XXX and the object pointer should be of type specific to this manager */ +#if 0 + if( object->Object_ID == cycno)) +#else + if ( 1 ) +#endif + { + pk_rcyc->exinf = pk_dcyc->exinf; + pk_rcyc->cycact = pk_dcyc->cycact; +#if 0 + pk_rcyc->lfttim = pk_dcyc->cyctim - timeElapse_since_actCyclic; +#endif + + return E_OK; + } + else + return E_NOEXS; +} + +/* + * def_alm - Define Alarm Handler + */ + +ER def_alm( + HNO almno, + T_DALM *pk_dalm +) +{ +#if 0 + Objects_Control *objectAlrm; + Watchdog_Interval timeInterval; + + timeInterval = pk_dalm->almtim / 1000; + (void) _Watchdog_Remove(&objectAlrm); + _Watchdog_Initialize( + objectAlrm, + pk_dalm->almhdr, + almno, + pk_dalm->exinf); + _Watchdong_Insert_seconds(objectAlrm,timeInterval); + _Thread_Enable_dispatch(); +#endif + + return E_OK; +} + +/* + * ref_alm - Reference Alarm Handler Status + */ + +ER ref_alm( + T_RALM *pk_ralm, + HNO almno +) +{ + + return E_OK; +} + +/* + * ret_tmr - Return from Timer Handler + */ + +void ret_tmr( void ) +{ +} + diff --git a/cpukit/itron/src/mbox.c b/cpukit/itron/src/mbox.c new file mode 100644 index 0000000000..c2cc11ec31 --- /dev/null +++ b/cpukit/itron/src/mbox.c @@ -0,0 +1,133 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/mbox.h> + +/* + * _ITRON_Mailbox_Manager_initialization + * + * This routine initializes all mailboxes manager related data structures. + * + * Input parameters: + * maximum_mailboxes - maximum configured mailboxes + * + * Output parameters: NONE + */ + +void _ITRON_Mailbox_Manager_initialization( + unsigned32 maximum_mailboxes +) +{ + _Objects_Initialize_information( + &_ITRON_Mailbox_Information, /* object information table */ + OBJECTS_ITRON_MAILBOXES, /* object class */ + FALSE, /* TRUE if this is a global */ + /* object class */ + maximum_mailboxes, /* maximum objects of this class */ + sizeof( ITRON_Mailbox_Control ), /* size of this object's control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's */ + /* name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_mbx - Create Mailbox + */ + +ER cre_mbx( + ID mbxid, + T_CMBX *pk_cmbx +) +{ + return E_OK; +} + +/* + * del_mbx - Delete Mailbox + */ + +ER del_mbx( + ID mbxid +) +{ + return E_OK; +} + +/* + * snd_msg - Send Message to Mailbox + */ + +ER snd_msg( + ID mbxid, + T_MSG *pk_msg +) +{ + return E_OK; +} + +/* + * rcv_msg - Receive Message from Mailbox + */ + +ER rcv_msg( + T_MSG **ppk_msg, + ID mbxid +) +{ + return E_OK; +} + +/* + * prcv_msg - Poll and Receive Message from Mailbox + */ + +ER prcv_msg( + T_MSG **ppk_msg, + ID mbxid +) +{ + return E_OK; +} + +/* + * trcv_msg - Receive Message from Mailbox with Timeout + */ + +ER trcv_msg( + T_MSG **ppk_msg, + ID mbxid, + TMO tmout +) +{ + return E_OK; +} + +/* + * ref_mbx - Reference Mailbox Status + */ + +ER ref_mbx( + T_RMBX *pk_rmbx, + ID mbxid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/msgbuffer.c b/cpukit/itron/src/msgbuffer.c new file mode 100644 index 0000000000..4711ddbea9 --- /dev/null +++ b/cpukit/itron/src/msgbuffer.c @@ -0,0 +1,412 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/msgbuffer.h> +#include <rtems/itron/task.h> + +ER _ITRON_Message_buffer_Translate_core_message_buffer_return_code( + CORE_message_queue_Status status) +{ + switch (status) { + case CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL: + return E_OK; + case CORE_MESSAGE_QUEUE_STATUS_TOO_MANY: + return E_TMOUT; + case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: + return E_PAR; + case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT: + return E_TMOUT; + case CORE_MESSAGE_QUEUE_STATUS_TIMEOUT: + return E_TMOUT; + default: + return E_ID; + } +} + +/* + * _ITRON_Message_buffer_Manager_initialization + * + * This routine initializes all message buffer manager related data + * structures. + * + * Input parameters: + * maximum_message_buffers - maximum configured message buffers + * + * Output parameters: NONE + */ + +void _ITRON_Message_buffer_Manager_initialization( + unsigned32 maximum_message_buffers + ) +{ + _Objects_Initialize_information( + &_ITRON_Message_buffer_Information, /* object information table */ + OBJECTS_ITRON_MESSAGE_BUFFERS, /* object class */ + FALSE, /* TRUE if this is a + global object class */ + maximum_message_buffers, /* maximum objects of this class */ + sizeof( ITRON_Message_buffer_Control ), /* size of this + object's control + block */ + FALSE, /* TRUE if names for this + object are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each + object's name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_mbf - Create MessageBuffer + */ + +ER cre_mbf( + ID mbfid, + T_CMBF *pk_cmbf + ) +{ + CORE_message_queue_Attributes the_message_queue_attributes; + ITRON_Message_buffer_Control *the_message_buffer; + + /* + * Bad pointer to the attributes structure + */ + + if ( !pk_cmbf ) + return E_PAR; + + /* + * Bits were set that were note defined. + */ + + if (pk_cmbf->mbfatr & ~(TA_TPRI)) + return E_RSATR; + + if (pk_cmbf->bufsz < 0 || pk_cmbf->maxmsz < 0) + return E_PAR; + + if (pk_cmbf->bufsz < pk_cmbf->maxmsz) + return E_PAR; + + _Thread_Disable_dispatch(); /* prevents deletion */ + + the_message_buffer = _ITRON_Message_buffer_Allocate(mbfid); + if ( !the_message_buffer ) { + _Thread_Enable_dispatch(); + return _ITRON_Message_buffer_Clarify_allocation_id_error(mbfid); + } + + if ( pk_cmbf->mbfatr & TA_TPRI ) + the_message_queue_attributes.discipline = + CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; + else + the_message_queue_attributes.discipline = + CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; + + _CORE_message_queue_Initialize( + &the_message_buffer->message_queue, + OBJECTS_ITRON_MESSAGE_BUFFERS, + &the_message_queue_attributes, + pk_cmbf->bufsz / pk_cmbf->maxmsz, + pk_cmbf->maxmsz, + NULL /* Multiprocessing not supported */ + ); + + _ITRON_Objects_Open( &_ITRON_Message_buffer_Information, + &the_message_buffer->Object ); + + /* + * If multiprocessing were supported, this is where we would announce + * the existence of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + + _Thread_Enable_dispatch(); + + return E_OK; +} + +/* + * del_mbf - Delete MessageBuffer + */ + +ER del_mbf( + ID mbfid + ) +{ + ITRON_Message_buffer_Control *the_message_buffer; + Objects_Locations location; + + the_message_buffer = _ITRON_Message_buffer_Get(mbfid, &location); + + switch (location) { + case OBJECTS_REMOTE: + case OBJECTS_ERROR: /* Multiprocessing not supported */ + return _ITRON_Message_buffer_Clarify_get_id_error(mbfid); + + case OBJECTS_LOCAL: + _CORE_message_queue_Flush(&the_message_buffer->message_queue); + _ITRON_Objects_Close( + &_ITRON_Message_buffer_Information, + &the_message_buffer->Object); + _ITRON_Message_buffer_Free(the_message_buffer); + /* + * If multiprocessing were supported, this is where we would announce + * the existence of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + _Thread_Enable_dispatch(); + return E_OK; + } + + return E_OK; +} + +/* + * snd_mbf - Send Message to MessageBuffer + */ + +ER snd_mbf( + ID mbfid, + VP msg, + INT msgsz + ) +{ + return E_OK; +} + +/* + * psnd_mbf - Poll and Send Message to MessageBuffer + */ + +ER psnd_mbf( + ID mbfid, + VP msg, + INT msgsz + ) +{ + ITRON_Message_buffer_Control *the_message_buffer; + Objects_Locations location; + CORE_message_queue_Status status; + + if (msgsz <= 0 || !msg) + return E_PAR; + + the_message_buffer = _ITRON_Message_buffer_Get(mbfid, &location); + switch (location) { + case OBJECTS_REMOTE: + case OBJECTS_ERROR: /* Multiprocessing not supported */ + return _ITRON_Message_buffer_Clarify_get_id_error(mbfid); + + case OBJECTS_LOCAL: + status = _CORE_message_queue_Submit( + &the_message_buffer->message_queue, + msg, + msgsz, + the_message_buffer->Object.id, + NULL, + CORE_MESSAGE_QUEUE_SEND_REQUEST); + _Thread_Enable_dispatch(); + return + _ITRON_Message_buffer_Translate_core_message_buffer_return_code( + status); + } + + /* + * If multiprocessing were supported, this is where we would announce + * the existence of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + + return E_OK; +} + +/* + * tsnd_mbf - Send Message to MessageBuffer with Timeout + */ + +ER tsnd_mbf( + ID mbfid, + VP msg, + INT msgsz, + TMO tmout + ) +{ + return E_OK; +} + +/* + * rcv_mbf - Receive Message from MessageBuffer + */ + +ER rcv_mbf( + VP msg, + INT *p_msgsz, + ID mbfid + ) +{ + return trcv_mbf(msg, p_msgsz, mbfid, TMO_FEVR); +} + +/* + * prcv_mbf - Poll and Receive Message from MessageBuffer + */ + +ER prcv_mbf( + VP msg, + INT *p_msgsz, + ID mbfid + ) +{ + return trcv_mbf(msg, p_msgsz, mbfid, TMO_POL); +} + +/* + * trcv_mbf - Receive Message from MessageBuffer with Timeout + */ + +ER trcv_mbf( + VP msg, + INT *p_msgsz, + ID mbfid, + TMO tmout + ) +{ + ITRON_Message_buffer_Control *the_message_buffer; + Objects_Locations location; + CORE_message_queue_Status status; + boolean wait; + Watchdog_Interval interval; + + interval = 0; + if (tmout == TMO_POL) { + wait = FALSE; + } else { + wait = TRUE; + if (tmout != TMO_FEVR) + interval = TOD_MILLISECONDS_TO_TICKS(tmout); + } + + if (wait && _ITRON_Is_in_non_task_state() ) + return E_CTX; + + if (!p_msgsz || !msg || tmout <= -2) + return E_PAR; + + the_message_buffer = _ITRON_Message_buffer_Get(mbfid, &location); + switch (location) { + case OBJECTS_REMOTE: + case OBJECTS_ERROR: /* Multiprocessing not supported */ + return _ITRON_Message_buffer_Clarify_get_id_error(mbfid); + + case OBJECTS_LOCAL: + _CORE_message_queue_Seize( + &the_message_buffer->message_queue, + the_message_buffer->Object.id, + msg, + p_msgsz, + wait, + interval); + _Thread_Enable_dispatch(); + status = + (CORE_message_queue_Status)_Thread_Executing->Wait.return_code; + return + _ITRON_Message_buffer_Translate_core_message_buffer_return_code + (status); + + } + + /* + * If multiprocessing were supported, this is where we would announce + * the existence of the semaphore to the rest of the system. + */ + +#if defined(RTEMS_MULTIPROCESSING) +#endif + return E_OK; +} + +/* + * ref_mbf - Reference MessageBuffer Status + */ + +ER ref_mbf( + T_RMBF *pk_rmbf, + ID mbfid + ) +{ + ITRON_Message_buffer_Control *the_message_buffer; + Objects_Locations location; + + if ( !pk_rmbf ) + return E_PAR; /* XXX check this error code */ + + the_message_buffer = _ITRON_Message_buffer_Get( mbfid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: /* Multiprocessing not supported */ + case OBJECTS_ERROR: + return _ITRON_Message_buffer_Clarify_get_id_error( mbfid ); + + case OBJECTS_LOCAL: + /* + * Fill in the size of message to be sent + */ + + if(the_message_buffer->message_queue. + number_of_pending_messages == 0) { + pk_rmbf->msgsz = 0; + } + else { + CORE_message_queue_Buffer_control *the_message; + the_message = (CORE_message_queue_Buffer_control*) + the_message_buffer->message_queue. + Pending_messages.first; + pk_rmbf->msgsz = the_message->Contents.size; + } + + /* + * Fill in the size of free buffer + */ + + pk_rmbf->frbufsz = + (the_message_buffer->message_queue.maximum_pending_messages- + the_message_buffer->message_queue.number_of_pending_messages)* + the_message_buffer->message_queue.maximum_message_size; + + + /* + * Fill in whether or not there is a waiting task + */ + + if ( !_Thread_queue_First( + &the_message_buffer->message_queue.Wait_queue ) ) + pk_rmbf->wtsk = FALSE; + else + pk_rmbf->wtsk = TRUE; + + pk_rmbf->stsk = FALSE; + _Thread_Enable_dispatch(); + return E_OK; + } + return E_OK; +} diff --git a/cpukit/itron/src/network.c b/cpukit/itron/src/network.c new file mode 100644 index 0000000000..82a57ac1a1 --- /dev/null +++ b/cpukit/itron/src/network.c @@ -0,0 +1,65 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/network.h> + +/* + * nrea_dat - Read Data from another Node + */ + +ER nrea_dat( + INT *p_reasz, + VP dstadr, + NODE srcnode, + VP srcadr, + INT datsz +) +{ + return E_OK; +} + +/* + * nwri_dat - Write Data to another Node + */ + +ER nwri_dat( + INT *p_wrisz, + NODE dstnode, + VP dstadr, + VP srcadr, + INT datsz +) +{ + return E_OK; +} + +/* + * nget_nod - Get Local Node Number + */ + +ER nget_nod( + NODE *p_node +) +{ + return E_OK; +} + +/* + * nget_ver - Get Version Information of another Node + */ + +ER nget_ver( + T_VER *pk_ver, + NODE node +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/port.c b/cpukit/itron/src/port.c new file mode 100644 index 0000000000..4d95638f7b --- /dev/null +++ b/cpukit/itron/src/port.c @@ -0,0 +1,202 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/port.h> + +/* + * _ITRON_Port_Manager_initialization + * + * This routine initializes all ports manager related data structures. + * + * Input parameters: + * maximum_ports - maximum configured ports + * + * Output parameters: NONE + */ + +void _ITRON_Port_Manager_initialization( + unsigned32 maximum_ports +) +{ + _Objects_Initialize_information( + &_ITRON_Port_Information, /* object information table */ + OBJECTS_ITRON_PORTS, /* object class */ + FALSE, /* TRUE if this is a global object class */ + maximum_ports, /* maximum objects of this class */ + sizeof( ITRON_Port_Control ), /* size of this object's control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_por - Create Port for Rendezvous + */ + +ER cre_por( + ID porid, + T_CPOR *pk_cpor +) +{ + return E_OK; +} + +/* + * del_por - Delete Port for Rendezvous + */ + +ER del_por( + ID porid +) +{ + return E_OK; +} + +/* + * cal_por - Call Port for Rendezvous Poll + */ + +ER cal_por( + VP msg, + INT *p_rmsgsz, + ID porid, + UINT calptn, + INT cmsgsz +) +{ + return E_OK; +} + +/* + * pcal_por - Poll and Call Port for Rendezvous + */ + +ER pcal_por( + VP msg, + INT *p_rmsgsz, + ID porid, + UINT calptn, + INT cmsgsz +) +{ + return E_OK; +} + +/* + * tcal_por - Call Port for Rendezvous with Timeout + */ + +ER tcal_por( + VP msg, + INT *p_rmsgsz, + ID porid, + UINT calptn, + INT cmsgsz, + TMO tmout +) +{ + return E_OK; +} + +/* + * acp_por - Accept Port for Rendezvous Poll + */ + +ER acp_por( + RNO *p_rdvno, + VP msg, + INT *p_cmsgsz, + ID porid, + UINT acpptn +) +{ + return E_OK; +} + +/* + * pacp_por - Poll and Accept Port for Rendezvous + */ + +ER pacp_por( + RNO *p_rdvno, + VP msg, + INT *p_cmsgsz, + ID porid, + UINT acpptn +) +{ + return E_OK; +} + +/* + * tacp_por - Accept Port for Rendezvous with Timeout + */ + +ER tacp_por( + RNO *p_rdvno, + VP msg, + INT *p_cmsgsz, + ID porid, + UINT acpptn, + TMO tmout +) +{ + return E_OK; +} + +/* + * fwd_por - Forward Rendezvous to Other Port + */ + +ER fwd_por( + ID porid, + UINT calptn, + RNO rdvno, + VP msg, + INT cmsgsz +) +{ + return E_OK; +} + +/* + * rpl_rdv - Reply Rendezvous + */ + +ER rpl_rdv( + RNO rdvno, + VP msg, + INT rmsgsz +) +{ + return E_OK; +} + +/* + * ref_por - Reference Port Status + */ + +ER ref_por( + T_RPOR *pk_rpor, + ID porid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/ref_tsk.c b/cpukit/itron/src/ref_tsk.c new file mode 100644 index 0000000000..50ce76e8ed --- /dev/null +++ b/cpukit/itron/src/ref_tsk.c @@ -0,0 +1,31 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * ref_tsk - Reference Task Status + */ + +ER ref_tsk( + T_RTSK *pk_rtsk, + ID tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/rel_wai.c b/cpukit/itron/src/rel_wai.c new file mode 100644 index 0000000000..390433ec0c --- /dev/null +++ b/cpukit/itron/src/rel_wai.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * rel_wai - Release Wait of Other Task + */ + +ER rel_wai( + ID tskid +) +{ + return E_OK; +} + + diff --git a/cpukit/itron/src/rot_rdq.c b/cpukit/itron/src/rot_rdq.c new file mode 100644 index 0000000000..b329313946 --- /dev/null +++ b/cpukit/itron/src/rot_rdq.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * rot_rdq - Rotate Tasks on the Ready Queue + */ + +ER rot_rdq( + PRI tskpri +) +{ + return E_OK; +} + + diff --git a/cpukit/itron/src/rsm_tsk.c b/cpukit/itron/src/rsm_tsk.c new file mode 100644 index 0000000000..a19842f8da --- /dev/null +++ b/cpukit/itron/src/rsm_tsk.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * rsm_tsk - Resume Suspended Task + */ + +ER rsm_tsk( + ID tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/slp_tsk.c b/cpukit/itron/src/slp_tsk.c new file mode 100644 index 0000000000..00562dda92 --- /dev/null +++ b/cpukit/itron/src/slp_tsk.c @@ -0,0 +1,28 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + + +/* + * slp_tsk - Sleep Task Sleep Task with Timeout + */ + +ER slp_tsk( void ) +{ + return E_OK; +} diff --git a/cpukit/itron/src/sta_tsk.c b/cpukit/itron/src/sta_tsk.c new file mode 100644 index 0000000000..91a6586c0e --- /dev/null +++ b/cpukit/itron/src/sta_tsk.c @@ -0,0 +1,84 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * sta_tsk - Start Task + */ + +/* + * XXX - How Do I know when these happen ??? + E_NOEXS Object does not exist (the task specified by tskid does not exist) + E_OACV Object access violation (A tskid less than -4 was specified from + a user task. This is implementation dependent.) + E_OBJ Invalid object state (the target task is not in DORMANT state) + EN_OBJNO An object number which could not be accessed on the target node + is specified. XXX Should never get on a single processor?? + EN_CTXID Specified an object on another node when the system call was + issued from a task in dispatch disabled state or from a task- + independent portionXXX Should never get on a single processor?? + EN_PAR A value outside the range supported by the target node and/or + transmission packet format was specified as a parameter (a value + outside supported range was specified for stacd) +XXX- What does _ITRON_Task_Get return on an invalid id and how do you know + if it is E_ID, E_NOEXS, E_OACV +*/ + +ER sta_tsk( + ID tskid, + INT stacd +) +{ + register Thread_Control *the_thread; + Objects_Locations location; + boolean status; + + the_thread = _ITRON_Task_Get( tskid, &location ); + switch ( location ) { + case OBJECTS_REMOTE: + case OBJECTS_ERROR: + return E_ID; /* XXX */ + + case OBJECTS_LOCAL: + status = _Thread_Start( + the_thread, + THREAD_START_NUMERIC, /* XXX should be able to say we have no arg */ + the_thread->Start.entry_point, + 0, /* XXX supercore forces us to have an arg */ + 0 /* unused */ + ); + + /* + * Wrong state XXX + */ + + if ( !status ) { + _Thread_Enable_dispatch(); + return E_OBJ; + } + + _Thread_Enable_dispatch(); + return E_OK; + } + + return E_OBJ; /* unreached - only to remove warnings */ +} + + + + diff --git a/cpukit/itron/src/sus_tsk.c b/cpukit/itron/src/sus_tsk.c new file mode 100644 index 0000000000..f4a5d5b851 --- /dev/null +++ b/cpukit/itron/src/sus_tsk.c @@ -0,0 +1,34 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * Task-Dependent Synchronization Functions + */ + +/* + * sus_tsk - Suspend Other Task + */ + +ER sus_tsk( + ID tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/sysmgmt.c b/cpukit/itron/src/sysmgmt.c new file mode 100644 index 0000000000..24d9075154 --- /dev/null +++ b/cpukit/itron/src/sysmgmt.c @@ -0,0 +1,69 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/sysmgmt.h> + +/* + * get_ver - Get Version Information + */ + +ER get_ver( + T_VER *pk_ver +) +{ + return E_OK; +} + +/* + * ref_sys - Reference System Status + */ + +ER ref_sys( + T_RSYS *pk_rsys +) +{ + return E_OK; +} + +/* + * ref_cfg - Reference Configuration Information + */ + +ER ref_cfg( + T_RCFG *pk_rcfg +) +{ + return E_OK; +} + +/* + * def_svc - Define Extended SVC Handler + */ + +ER def_svc( + FN s_fncd, + T_DSVC *pk_dsvc +) +{ + return E_OK; +} + +/* + * def_exc - Define Exception Handler + */ + +ER def_exc( + UINT exckind, + T_DEXC *pk_dexc +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/task.c b/cpukit/itron/src/task.c new file mode 100644 index 0000000000..f646b29d49 --- /dev/null +++ b/cpukit/itron/src/task.c @@ -0,0 +1,217 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + +/* + * _ITRON_Task_Create_extension + * + * This routine is an extension routine that is invoked as part + * of creating any type of task or thread in the system. If the + * task is created via another API, then this routine is invoked + * and this API given the opportunity to initialize its extension + * area. + */ + +boolean _ITRON_Task_Create_extension( + Thread_Control *executing, + Thread_Control *created +) +{ + ITRON_API_Control *api; + + api = _Workspace_Allocate( sizeof( ITRON_API_Control ) ); + + if ( !api ) + return FALSE; + + created->API_Extensions[ THREAD_API_ITRON ] = api; + + /* + * Initialize the ITRON API extension + */ + + return TRUE; +} + +/* + * _ITRON_Task_Delete_extension + * + * This extension routine is invoked when a task is deleted. + */ + +User_extensions_routine _ITRON_Task_Delete_extension( + Thread_Control *executing, + Thread_Control *deleted +) +{ + (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_ITRON ] ); + + deleted->API_Extensions[ THREAD_API_ITRON ] = NULL; +} + +/* + * _ITRON_Task_Initialize_user_tasks + * + * This routine creates and starts all configured user + * initialzation threads. + */ + +void _ITRON_Task_Initialize_user_tasks( void ) +{ + unsigned32 index; + unsigned32 maximum; + ER return_value; + itron_initialization_tasks_table *user_tasks; + + /* + * NOTE: This is slightly different from the Ada implementation. + */ + + user_tasks = _ITRON_Task_User_initialization_tasks; + maximum = _ITRON_Task_Number_of_initialization_tasks; + + if ( !user_tasks || maximum == 0 ) + return; + + for ( index=0 ; index < maximum ; index++ ) { + + return_value = cre_tsk( + user_tasks[ index ].id, + &user_tasks[ index ].attributes + ); + + if ( return_value != E_OK ) + _Internal_error_Occurred( INTERNAL_ERROR_ITRON_API, TRUE, return_value ); + + return_value = sta_tsk( user_tasks[ index ].id, 0 ); + + if ( return_value != E_OK ) + _Internal_error_Occurred( INTERNAL_ERROR_ITRON_API, TRUE, return_value ); + + } +} + +/*PAGE + * + * _ITRON_Delete_task + */ + +ER _ITRON_Delete_task( + Thread_Control *the_thread +) +{ + Objects_Information *the_information; + + the_information = _Objects_Get_information( the_thread->Object.id ); + + if ( !the_information ) { + return -1; /* XXX */ + /* This should never happen if _Thread_Get() works right */ + } + + _Thread_Close( the_information, the_thread ); + + _ITRON_Task_Free( the_thread ); + + return E_OK; +} + +/* + * At this point in time, the ITRON API does not need any other + * extensions. See the POSIX and RTEMS API extensions for + * examples of how they can be used. + */ + +/* + * Extension Tables + */ + +API_extensions_Control _ITRON_Task_API_extensions = { + { NULL, NULL }, + NULL, /* predriver */ + _ITRON_Task_Initialize_user_tasks, /* postdriver */ + NULL /* post switch */ +}; + +User_extensions_Control _ITRON_Task_User_extensions = { + { NULL, NULL }, + { _ITRON_Task_Create_extension, /* create */ + NULL, /* start */ + NULL, /* restart */ + _ITRON_Task_Delete_extension, /* delete */ + NULL, /* switch */ + NULL, /* begin */ + NULL, /* exitted */ + NULL /* fatal */ + } +}; + +/* + * _ITRON_Task_Manager_initialization + * + * This routine initializes all Task Manager related data structures. + * + * Input parameters: + * maximum_tasks - number of tasks to initialize + * + * Output parameters: NONE + */ + +void _ITRON_Task_Manager_initialization( + unsigned32 maximum_tasks, + unsigned32 number_of_initialization_tasks, + itron_initialization_tasks_table *user_tasks +) +{ + + _ITRON_Task_Number_of_initialization_tasks = number_of_initialization_tasks; + _ITRON_Task_User_initialization_tasks = user_tasks; + + /* + * There may not be any ITRON_initialization tasks configured. + */ + +#if 0 + if ( user_tasks == NULL || number_of_initialization_tasks == 0 ) + _Internal_error_Occurred( INTERNAL_ERROR_ITRON_API, TRUE, -1 ); +#endif + + _Objects_Initialize_information( + &_ITRON_Task_Information, /* object information table */ + OBJECTS_ITRON_TASKS, /* object class */ + FALSE, /* TRUE if this is a global object class */ + maximum_tasks, /* maximum objects of this class */ + sizeof( Thread_Control ), /* size of this object's control block */ + FALSE, /* TRUE if names for this object are strings */ + ITRON_MAXIMUM_NAME_LENGTH, /* maximum length of each object's name */ + TRUE /* TRUE if this class is threads */ + ); + + /* + * Add all the extensions for this API + */ + + _User_extensions_Add_API_set( &_ITRON_Task_User_extensions ); + + _API_extensions_Add( &_ITRON_Task_API_extensions ); + + /* + * XXX MP not supported + * Register the MP Process Packet routine. + */ + +} diff --git a/cpukit/itron/src/ter_tsk.c b/cpukit/itron/src/ter_tsk.c new file mode 100644 index 0000000000..c0d05c1fec --- /dev/null +++ b/cpukit/itron/src/ter_tsk.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * ter_tsk - Terminate Other Task + */ + +ER ter_tsk( + ID tskid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/tslp_tsk.c b/cpukit/itron/src/tslp_tsk.c new file mode 100644 index 0000000000..b8556f0f68 --- /dev/null +++ b/cpukit/itron/src/tslp_tsk.c @@ -0,0 +1,31 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * tslp_tsk - Sleep Task with Timeout + */ + +ER tslp_tsk( + TMO tmout +) +{ + return E_OK; +} + + diff --git a/cpukit/itron/src/vmempool.c b/cpukit/itron/src/vmempool.c new file mode 100644 index 0000000000..726d9c8c68 --- /dev/null +++ b/cpukit/itron/src/vmempool.c @@ -0,0 +1,138 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/itron/vmempool.h> + +/* + * _ITRON_Variable_memory_pool_Manager_initialization + * + * This routine initializes all variable memory pool manager related + * data structures. + * + * Input parameters: + * maximum_variable_memory_pools - maximum configured variable memory pools + * + * Output parameters: NONE + */ + +void _ITRON_Variable_memory_pool_Manager_initialization( + unsigned32 maximum_variable_memory_pools +) +{ + _Objects_Initialize_information( + &_ITRON_Variable_memory_pool_Information, /* object information table */ + OBJECTS_ITRON_VARIABLE_MEMORY_POOLS, /* object class */ + FALSE, /* TRUE if this is a global */ + /* object class */ + maximum_variable_memory_pools, /* maximum objects of this class */ + sizeof( ITRON_Variable_memory_pool_Control ), + /* size of this object's control block */ + FALSE, /* TRUE if names for this object */ + /* are strings */ + RTEMS_MAXIMUM_NAME_LENGTH, /* maximum length of each object's */ + /* name */ + FALSE /* TRUE if this class is threads */ + ); + + /* + * Register the MP Process Packet routine. + * + * NOTE: No MP Support YET in RTEMS ITRON implementation. + */ + +} + +/* + * cre_mpl - Create Variable-Size Memorypool + */ + +ER cre_mpl( + ID mplid, + T_CMPL *pk_cmpl +) +{ + return E_OK; +} + +/* + * del_mpl - Delete Variable-Size Memorypool + */ + +ER del_mpl( + ID mplid +) +{ + return E_OK; +} + +/* + * get_blk - Get Variable-Size Memory Block + */ + +ER get_blk( + VP *p_blk, + ID mplid, + INT blksz +) +{ + return E_OK; +} + +/* + * pget_blk - Poll and Get Variable-Size Memory Block + */ + +ER pget_blk( + VP *p_blk, + ID mplid, + INT blksz +) +{ + return E_OK; +} + +/* + * tget_blk - Get Variable-Size Memory Block with Timeout + */ + +ER tget_blk( + VP *p_blk, + ID mplid, + INT blksz, + TMO tmout +) +{ + return E_OK; +} + +/* + * rel_blk - Release Variable-Size Memory Block + */ + +ER rel_blk( + ID mplid, + VP blk +) +{ + return E_OK; +} + +/* + * ref_mpl - Reference Variable-Size Memorypool Status + */ + +ER ref_mpl( + T_RMPL *pk_rmpl, + ID mplid +) +{ + return E_OK; +} + diff --git a/cpukit/itron/src/wup_tsk.c b/cpukit/itron/src/wup_tsk.c new file mode 100644 index 0000000000..bc0ca0edb9 --- /dev/null +++ b/cpukit/itron/src/wup_tsk.c @@ -0,0 +1,30 @@ +/* + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.OARcorp.com/rtems/license.html. + * + * $Id$ + */ + +#include <itron.h> + +#include <rtems/score/thread.h> +#include <rtems/score/userext.h> +#include <rtems/score/wkspace.h> +#include <rtems/score/apiext.h> +#include <rtems/score/sysstate.h> + +#include <rtems/itron/task.h> + + +/* + * wup_tsk - Wakeup Other Task + */ + +ER wup_tsk( + ID tskid +) +{ + return E_OK; +} + |