From 352c9b2035e32e56f10f261d94955d97f4ab0f1c Mon Sep 17 00:00:00 2001 From: Joel Sherrill Date: Tue, 9 Nov 1999 22:07:23 +0000 Subject: This patch adds the basic framework for the ITRON 3.0 API implementation for RTEMS. --- c/src/exec/itron/inline/Makefile.am | 10 ++ c/src/exec/itron/inline/rtems/Makefile.am | 10 ++ c/src/exec/itron/inline/rtems/itron/Makefile.am | 27 ++++ c/src/exec/itron/inline/rtems/itron/eventflags.inl | 148 +++++++++++++++++ c/src/exec/itron/inline/rtems/itron/fmempool.inl | 155 ++++++++++++++++++ c/src/exec/itron/inline/rtems/itron/intr.inl | 27 ++++ c/src/exec/itron/inline/rtems/itron/mbox.inl | 148 +++++++++++++++++ c/src/exec/itron/inline/rtems/itron/msgbuffer.inl | 153 ++++++++++++++++++ c/src/exec/itron/inline/rtems/itron/network.inl | 27 ++++ c/src/exec/itron/inline/rtems/itron/port.inl | 148 +++++++++++++++++ c/src/exec/itron/inline/rtems/itron/semaphore.inl | 180 +++++++++++++++++++++ c/src/exec/itron/inline/rtems/itron/sysmgmt.inl | 27 ++++ c/src/exec/itron/inline/rtems/itron/task.inl | 160 ++++++++++++++++++ c/src/exec/itron/inline/rtems/itron/time.inl | 27 ++++ c/src/exec/itron/inline/rtems/itron/vmempool.inl | 158 ++++++++++++++++++ 15 files changed, 1405 insertions(+) create mode 100644 c/src/exec/itron/inline/Makefile.am create mode 100644 c/src/exec/itron/inline/rtems/Makefile.am create mode 100644 c/src/exec/itron/inline/rtems/itron/Makefile.am create mode 100644 c/src/exec/itron/inline/rtems/itron/eventflags.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/fmempool.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/intr.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/mbox.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/msgbuffer.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/network.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/port.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/semaphore.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/sysmgmt.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/task.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/time.inl create mode 100644 c/src/exec/itron/inline/rtems/itron/vmempool.inl (limited to 'c/src/exec/itron/inline') diff --git a/c/src/exec/itron/inline/Makefile.am b/c/src/exec/itron/inline/Makefile.am new file mode 100644 index 0000000000..32269fcdcd --- /dev/null +++ b/c/src/exec/itron/inline/Makefile.am @@ -0,0 +1,10 @@ +## +## $Id$ +## + +AUTOMAKE_OPTIONS = foreign 1.4 + +SUBDIRS = rtems + +include $(top_srcdir)/../../../../automake/subdirs.am +include $(top_srcdir)/../../../../automake/local.am diff --git a/c/src/exec/itron/inline/rtems/Makefile.am b/c/src/exec/itron/inline/rtems/Makefile.am new file mode 100644 index 0000000000..d6766c8306 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/Makefile.am @@ -0,0 +1,10 @@ +## +## $Id$ +## + +AUTOMAKE_OPTIONS = foreign 1.4 + +SUBDIRS = itron + +include $(top_srcdir)/../../../../automake/subdirs.am +include $(top_srcdir)/../../../../automake/local.am diff --git a/c/src/exec/itron/inline/rtems/itron/Makefile.am b/c/src/exec/itron/inline/rtems/itron/Makefile.am new file mode 100644 index 0000000000..52a0ec2de6 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/Makefile.am @@ -0,0 +1,27 @@ +## +## $Id$ +## + +AUTOMAKE_OPTIONS = foreign 1.4 +if INLINE +I_PIECES = eventflags.inl fmempool.inl intr.inl mbox.inl msgbuffer.inl \ + network.inl port.inl semaphore.inl sysmgmt.inl task.inl \ + time.inl vmempool.inl + +noinst_HEADERS = $(I_PIECES) + +TMPINSTALL_FILES = \ +$(PROJECT_INCLUDE)/rtems/itron \ +$(I_PIECES:%=$(PROJECT_INCLUDE)/rtems/itron/%) + +$(PROJECT_INCLUDE)/rtems/itron: + @$(mkinstalldirs) $@ +$(PROJECT_INCLUDE)/rtems/itron/%.inl: %.inl + $(INSTALL_DATA) $< $@ +endif + +all-am: $(TMPINSTALL_FILES) +debug-am: $(TMPINSTALL_FILES) +profile-am: $(TMPINSTALL_FILES) + +include $(top_srcdir)/../../../../automake/local.am diff --git a/c/src/exec/itron/inline/rtems/itron/eventflags.inl b/c/src/exec/itron/inline/rtems/itron/eventflags.inl new file mode 100644 index 0000000000..af6665915c --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/eventflags.inl @@ -0,0 +1,148 @@ +/* + * 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$ + */ + +#ifndef __ITRON_EVENTFLAGS_inl_ +#define __ITRON_EVENTFLAGS_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Eventflags_Allocate + * + * DESCRIPTION: + * + * This routine allocates the eventflags associated with the specified + * eventflags ID from the pool of inactive eventflagss. + * + * Input parameters: + * flgid - id of eventflags to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the eventflags control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Eventflags_Control *_ITRON_Eventflags_Allocate( + ID flgid +) +{ + return (ITRON_Eventflags_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Eventflags_Information, + flgid, + sizeof(ITRON_Eventflags_Control) + ); +} + +/* + * _ITRON_Eventflags_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Eventflags_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Eventflags_Information, (_id) ) + +/* + * _ITRON_Eventflags_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Eventflags_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Eventflags_Information, (_id) ) + +/* + * _ITRON_Eventflags_Free + * + * DESCRIPTION: + * + * This routine frees a eventflags control block to the + * inactive chain of free eventflags control blocks. + * + * Input parameters: + * the_eventflags - pointer to eventflags control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Eventflags_Free ( + ITRON_Eventflags_Control *the_eventflags +) +{ + _ITRON_Objects_Free( &_ITRON_Eventflags_Information, &the_eventflags->Object ); +} + +/*PAGE + * + * _ITRON_Eventflags_Get + * + * DESCRIPTION: + * + * This function maps eventflags IDs to eventflags control blocks. + * If ID corresponds to a local eventflags, then it returns + * the_eventflags control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the eventflags ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_eventflags is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_eventflags is undefined. + * + * Input parameters: + * id - ITRON eventflags ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Eventflags_Control *_ITRON_Eventflags_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Eventflags_Control *) + _ITRON_Objects_Get( &_ITRON_Eventflags_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Eventflags_Is_null + * + * This function returns TRUE if the_eventflags is NULL and FALSE otherwise. + * + * Input parameters: + * the_eventflags - pointer to eventflags control block + * + * Output parameters: + * TRUE - if the_eventflags is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Eventflags_Is_null ( + ITRON_Eventflags_Control *the_eventflags +) +{ + return ( the_eventflags == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/fmempool.inl b/c/src/exec/itron/inline/rtems/itron/fmempool.inl new file mode 100644 index 0000000000..38056b6671 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/fmempool.inl @@ -0,0 +1,155 @@ +/* + * 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$ + */ + +#ifndef __ITRON_FIXED_MEMORY_POOL_inl_ +#define __ITRON_FIXED_MEMORY_POOL_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Fixed_memory_pool_Allocate + * + * DESCRIPTION: + * + * This routine allocates the fixed_memory_pool associated with the specified + * fixed_memory_pool ID from the pool of inactive fixed_memory_pools. + * + * Input parameters: + * mpfid - id of fixed_memory_pool to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the fixed_memory_pool control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Fixed_memory_pool_Control + *_ITRON_Fixed_memory_pool_Allocate( + ID mpfid +) +{ + return (ITRON_Fixed_memory_pool_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Fixed_memory_pool_Information, + mpfid, + sizeof(ITRON_Fixed_memory_pool_Control) + ); +} + +/* + * _ITRON_Fixed_memory_pool_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Fixed_memory_pool_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Fixed_memory_pool_Information, (_id) ) + +/* + * _ITRON_Fixed_memory_pool_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Fixed_memory_pool_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( \ + &_ITRON_Fixed_memory_pool_Information, (_id) ) + +/* + * _ITRON_Fixed_memory_pool_Free + * + * DESCRIPTION: + * + * This routine frees a fixed_memory_pool control block to the + * inactive chain of free fixed_memory_pool control blocks. + * + * Input parameters: + * the_fixed_memory_pool - pointer to fixed_memory_pool control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Fixed_memory_pool_Free ( + ITRON_Fixed_memory_pool_Control *the_fixed_memory_pool +) +{ + _ITRON_Objects_Free( + &_ITRON_Fixed_memory_pool_Information, + &the_fixed_memory_pool->Object + ); +} + +/*PAGE + * + * _ITRON_Fixed_memory_pool_Get + * + * DESCRIPTION: + * + * This function maps fixed memory pool IDs to control blocks. + * If ID corresponds to a local fixed memory pool, then it returns + * the_fixed memory pool control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the fixed memory pool ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the fixed memory pool is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the fixed memory pool is undefined. + * + * Input parameters: + * id - ITRON fixed memory pool ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Fixed_memory_pool_Control + *_ITRON_Fixed_memory_pool_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Fixed_memory_pool_Control *) + _ITRON_Objects_Get( &_ITRON_Fixed_memory_pool_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Fixed_memory_pool_Is_null + * + * This function returns TRUE if the_fixed_memory_pool is NULL + * and FALSE otherwise. + * + * Input parameters: + * the_fixed_memory_pool - pointer to fixed_memory_pool control block + * + * Output parameters: + * TRUE - if the_fixed_memory_pool is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Fixed_memory_pool_Is_null ( + ITRON_Fixed_memory_pool_Control *the_fixed_memory_pool +) +{ + return ( the_fixed_memory_pool == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/intr.inl b/c/src/exec/itron/inline/rtems/itron/intr.inl new file mode 100644 index 0000000000..a991e03365 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/intr.inl @@ -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$ + */ + +#ifndef __ITRON_INTERRUPT_inl_ +#define __ITRON_INTERRUPT_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * XXX insert inline routines here + */ + + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/mbox.inl b/c/src/exec/itron/inline/rtems/itron/mbox.inl new file mode 100644 index 0000000000..d6666d6435 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/mbox.inl @@ -0,0 +1,148 @@ +/* + * 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$ + */ + +#ifndef __ITRON_MAILBOX_inl_ +#define __ITRON_MAILBOX_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Mailbox_Allocate + * + * DESCRIPTION: + * + * This routine allocates the mailbox associated with the specified + * mailbox ID from the pool of inactive mailboxs. + * + * Input parameters: + * mbxid - id of mailbox to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the mailbox control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Mailbox_Control *_ITRON_Mailbox_Allocate( + ID mbxid +) +{ + return (ITRON_Mailbox_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Mailbox_Information, + mbxid, + sizeof(ITRON_Mailbox_Control) + ); +} + +/* + * _ITRON_Mailbox_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Mailbox_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Mailbox_Information, (_id) ) + +/* + * _ITRON_Mailbox_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Mailbox_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Mailbox_Information, (_id) ) + +/* + * _ITRON_Mailbox_Free + * + * DESCRIPTION: + * + * This routine frees a mailbox control block to the + * inactive chain of free mailbox control blocks. + * + * Input parameters: + * the_mailbox - pointer to mailbox control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Mailbox_Free ( + ITRON_Mailbox_Control *the_mailbox +) +{ + _ITRON_Objects_Free( &_ITRON_Mailbox_Information, &the_mailbox->Object ); +} + +/*PAGE + * + * _ITRON_Mailbox_Get + * + * DESCRIPTION: + * + * This function maps mailbox IDs to mailbox control blocks. + * If ID corresponds to a local mailbox, then it returns + * the_mailbox control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the mailbox ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_mailbox is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_mailbox is undefined. + * + * Input parameters: + * id - ITRON mailbox ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Mailbox_Control *_ITRON_Mailbox_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Mailbox_Control *) + _ITRON_Objects_Get( &_ITRON_Mailbox_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Mailbox_Is_null + * + * This function returns TRUE if the_mailbox is NULL and FALSE otherwise. + * + * Input parameters: + * the_mailbox - pointer to mailbox control block + * + * Output parameters: + * TRUE - if the_mailbox is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Mailbox_Is_null ( + ITRON_Mailbox_Control *the_mailbox +) +{ + return ( the_mailbox == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/msgbuffer.inl b/c/src/exec/itron/inline/rtems/itron/msgbuffer.inl new file mode 100644 index 0000000000..fcdca8edf7 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/msgbuffer.inl @@ -0,0 +1,153 @@ +/* + * 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$ + */ + +#ifndef __ITRON_MESSAGE_BUFFER_inl_ +#define __ITRON_MESSAGE_BUFFER_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Message_buffer_Allocate + * + * DESCRIPTION: + * + * This routine allocates the message buffer associated with the specified + * message buffer ID from the pool of inactive message buffers. + * + * Input parameters: + * mbfid - id of message buffer to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the message buffer control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Message_buffer_Control + *_ITRON_Message_buffer_Allocate( + ID mbfid +) +{ + return (ITRON_Message_buffer_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Message_buffer_Information, + mbfid, + sizeof(ITRON_Message_buffer_Control) + ); +} + +/* + * _ITRON_Message_buffer_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Message_buffer_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Message_buffer_Information, (_id) ) + +/* + * _ITRON_Message_buffer_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Message_buffer_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Message_buffer_Information, (_id) ) + +/* + * _ITRON_Message_buffer_Free + * + * DESCRIPTION: + * + * This routine frees a message buffer control block to the + * inactive chain of free message buffer control blocks. + * + * Input parameters: + * the_message_buffer - pointer to message_buffer control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Message_buffer_Free ( + ITRON_Message_buffer_Control *the_message_buffer +) +{ + _ITRON_Objects_Free( + &_ITRON_Message_buffer_Information, + &the_message_buffer->Object + ); +} + +/*PAGE + * + * _ITRON_Message_buffer_Get + * + * DESCRIPTION: + * + * This function maps message buffer IDs to message buffer control blocks. + * If ID corresponds to a local message buffer, then it returns + * the message buffer control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the message buffer ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the message buffer is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the message buffer is undefined. + * + * Input parameters: + * id - ITRON message_buffer ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Message_buffer_Control *_ITRON_Message_buffer_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Message_buffer_Control *) + _ITRON_Objects_Get( &_ITRON_Message_buffer_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Message_buffer_Is_null + * + * This function returns TRUE if the_message_buffer is NULL + * and FALSE otherwise. + * + * Input parameters: + * the_message_buffer - pointer to message buffer control block + * + * Output parameters: + * TRUE - if the_message_buffer is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Message_buffer_Is_null ( + ITRON_Message_buffer_Control *the_message_buffer +) +{ + return ( the_message_buffer == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/network.inl b/c/src/exec/itron/inline/rtems/itron/network.inl new file mode 100644 index 0000000000..d4932383fc --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/network.inl @@ -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$ + */ + +#ifndef __ITRON_NETWORK_inl_ +#define __ITRON_NETWORK_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * XXX insert inline routines here + */ + + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/port.inl b/c/src/exec/itron/inline/rtems/itron/port.inl new file mode 100644 index 0000000000..5004761487 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/port.inl @@ -0,0 +1,148 @@ +/* + * 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$ + */ + +#ifndef __ITRON_PORT_inl_ +#define __ITRON_PORT_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Port_Allocate + * + * DESCRIPTION: + * + * This routine allocates the port associated with the specified + * port ID from the pool of inactive ports. + * + * Input parameters: + * porid - id of port to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the port control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Port_Control *_ITRON_Port_Allocate( + ID porid +) +{ + return (ITRON_Port_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Port_Information, + porid, + sizeof(ITRON_Port_Control) + ); +} + +/* + * _ITRON_Port_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Port_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Port_Information, (_id) ) + +/* + * _ITRON_Port_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Port_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Port_Information, (_id) ) + +/* + * _ITRON_Port_Free + * + * DESCRIPTION: + * + * This routine frees a port control block to the + * inactive chain of free port control blocks. + * + * Input parameters: + * the_port - pointer to port control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Port_Free ( + ITRON_Port_Control *the_port +) +{ + _ITRON_Objects_Free( &_ITRON_Port_Information, &the_port->Object ); +} + +/*PAGE + * + * _ITRON_Port_Get + * + * DESCRIPTION: + * + * This function maps port IDs to port control blocks. + * If ID corresponds to a local port, then it returns + * the_port control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the port ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_port is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_port is undefined. + * + * Input parameters: + * id - ITRON port ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Port_Control *_ITRON_Port_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Port_Control *) + _ITRON_Objects_Get( &_ITRON_Port_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Port_Is_null + * + * This function returns TRUE if the_port is NULL and FALSE otherwise. + * + * Input parameters: + * the_port - pointer to port control block + * + * Output parameters: + * TRUE - if the_port is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Port_Is_null ( + ITRON_Port_Control *the_port +) +{ + return ( the_port == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/semaphore.inl b/c/src/exec/itron/inline/rtems/itron/semaphore.inl new file mode 100644 index 0000000000..6e6595fcdc --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/semaphore.inl @@ -0,0 +1,180 @@ +/* + * 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$ + */ + +#ifndef __ITRON_SEMAPHORE_inl_ +#define __ITRON_SEMAPHORE_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Semaphore_Allocate + * + * DESCRIPTION: + * + * This routine allocates the semaphore associated with the specified + * semaphore ID from the pool of inactive semaphores. + * + * Input parameters: + * semid - id of semaphore to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the semaphore control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Semaphore_Control *_ITRON_Semaphore_Allocate( + ID semid +) +{ + return (ITRON_Semaphore_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Semaphore_Information, + semid, + sizeof(ITRON_Semaphore_Control) + ); +} + +/* + * _ITRON_Semaphore_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Semaphore_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Semaphore_Information, (_id) ) + +/* + * _ITRON_Semaphore_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Semaphore_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Semaphore_Information, (_id) ) + +/* + * _ITRON_Semaphore_Free + * + * DESCRIPTION: + * + * This routine frees a semaphore control block to the + * inactive chain of free semaphore control blocks. + * + * Input parameters: + * the_semaphore - pointer to semaphore control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Semaphore_Free ( + ITRON_Semaphore_Control *the_semaphore +) +{ + _ITRON_Objects_Free( &_ITRON_Semaphore_Information, &the_semaphore->Object ); +} + +/*PAGE + * + * _ITRON_Semaphore_Get + * + * DESCRIPTION: + * + * This function maps semaphore IDs to semaphore control blocks. + * If ID corresponds to a local semaphore, then it returns + * the_semaphore control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the semaphore ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_semaphore is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_semaphore is undefined. + * + * Input parameters: + * id - ITRON semaphore ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Semaphore_Control *_ITRON_Semaphore_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Semaphore_Control *) + _ITRON_Objects_Get( &_ITRON_Semaphore_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Semaphore_Is_null + * + * This function returns TRUE if the_semaphore is NULL and FALSE otherwise. + * + * Input parameters: + * the_semaphore - pointer to semaphore control block + * + * Output parameters: + * TRUE - if the_semaphore is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Semaphore_Is_null ( + ITRON_Semaphore_Control *the_semaphore +) +{ + return ( the_semaphore == NULL ); +} + +/* + * _ITRON_Semaphore_Translate_core_semaphore_return_code + * + * This function returns a ITRON status code based on the semaphore + * status code specified. + * + * Input parameters: + * the_semaphore_status - semaphore status code to translate + * + * Output parameters: + * ITRON status code - translated ITRON status code + * + */ + +RTEMS_INLINE_ROUTINE ER _ITRON_Semaphore_Translate_core_semaphore_return_code ( + unsigned32 the_semaphore_status +) +{ +/* XXX need to be able to return "E_RLWAI" */ + switch ( the_semaphore_status ) { + case CORE_SEMAPHORE_STATUS_SUCCESSFUL: + return E_OK; + case CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT: + return E_TMOUT; + case CORE_SEMAPHORE_WAS_DELETED: + return E_DLT; + case CORE_SEMAPHORE_TIMEOUT: + return E_TMOUT; + case CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED: + return E_QOVR; + case THREAD_STATUS_PROXY_BLOCKING: + return THREAD_STATUS_PROXY_BLOCKING; + } + return E_OK; /* unreached - only to remove warnings */ +} + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/sysmgmt.inl b/c/src/exec/itron/inline/rtems/itron/sysmgmt.inl new file mode 100644 index 0000000000..2a2eb76c6e --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/sysmgmt.inl @@ -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$ + */ + +#ifndef __ITRON_TIME_inl_ +#define __ITRON_TIME_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * XXX insert inline routines here + */ + + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/task.inl b/c/src/exec/itron/inline/rtems/itron/task.inl new file mode 100644 index 0000000000..1833fee84a --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/task.inl @@ -0,0 +1,160 @@ +/* + * 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$ + */ + +#ifndef __ITRON_TASK_inl_ +#define __ITRON_TASK_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Task_Allocate + * + * DESCRIPTION: + * + * This routine allocates the task associated with the specified + * task ID from the pool of inactive tasks. + * + * Input parameters: + * tskid - id of task to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the task control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE Thread_Control *_ITRON_Task_Allocate( + ID tskid +) +{ + return (Thread_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Task_Information, + tskid, + sizeof(Thread_Control) + ); +} + +/* + * _ITRON_Task_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Task_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Task_Information, (_id) ) + +/* + * _ITRON_Task_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Task_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Task_Information, (_id) ) + +/* + * _ITRON_Task_Free + * + * DESCRIPTION: + * + * This routine frees a task control block to the + * inactive chain of free task control blocks. + * + * Input parameters: + * the_task - pointer to task control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Task_Free ( + Thread_Control *the_task +) +{ + _ITRON_Objects_Free( &_ITRON_Task_Information, &the_task->Object ); +} + +/*PAGE + * + * _ITRON_Task_Get + * + * DESCRIPTION: + * + * This function maps task IDs to task control blocks. + * If ID corresponds to a local task, then it returns + * the_task control pointer which maps to ID and location + * is set to OBJECTS_LOCAL. if the task ID is global and + * resides on a remote node, then location is set to OBJECTS_REMOTE, + * and the_task is undefined. Otherwise, location is set + * to OBJECTS_ERROR and the_task is undefined. + * + * Input parameters: + * id - ITRON task ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE Thread_Control *_ITRON_Task_Get ( + ID id, + Objects_Locations *location +) +{ + return (Thread_Control *) + _ITRON_Objects_Get( &_ITRON_Task_Information, id, location ); +} + +/*PAGE + * + * _ITRON_Task_Is_null + * + * This function returns TRUE if the_task is NULL and FALSE otherwise. + * + * Input parameters: + * the_task - pointer to task control block + * + * Output parameters: + * TRUE - if the_task is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Task_Is_null ( + Thread_Control *the_task +) +{ + return ( the_task == NULL ); +} + +/* + * XXX insert inline routines here + */ + +/*PAGE + * + * _ITRON_tasks_Priority_to_Core + */ + +RTEMS_INLINE_ROUTINE Priority_Control _ITRON_Task_Priority_to_Core( + PRI _priority +) +{ + return ((Priority_Control) (_priority)); +} + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/time.inl b/c/src/exec/itron/inline/rtems/itron/time.inl new file mode 100644 index 0000000000..2a2eb76c6e --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/time.inl @@ -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$ + */ + +#ifndef __ITRON_TIME_inl_ +#define __ITRON_TIME_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * XXX insert inline routines here + */ + + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + diff --git a/c/src/exec/itron/inline/rtems/itron/vmempool.inl b/c/src/exec/itron/inline/rtems/itron/vmempool.inl new file mode 100644 index 0000000000..eec2931fb2 --- /dev/null +++ b/c/src/exec/itron/inline/rtems/itron/vmempool.inl @@ -0,0 +1,158 @@ +/* + * 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$ + */ + +#ifndef __ITRON_VARIABLE_MEMORY_POOL_inl_ +#define __ITRON_VARIABLE_MEMORY_POOL_inl_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * _ITRON_Variable_memory_pool_Allocate + * + * DESCRIPTION: + * + * This routine allocates the variable memory pool associated with + * the specified variable memory pool ID from the pool of inactive + * variable memory pools. + * + * Input parameters: + * mplid - id of variable memory pool to allocate + * status - pointer to status variable + * + * Output parameters: + * returns - pointer to the variable memory pool control block + * *status - status + */ + +RTEMS_INLINE_ROUTINE ITRON_Variable_memory_pool_Control + *_ITRON_Variable_memory_pool_Allocate( + ID mplid +) +{ + return (ITRON_Variable_memory_pool_Control *)_ITRON_Objects_Allocate_by_index( + &_ITRON_Variable_memory_pool_Information, + mplid, + sizeof(ITRON_Variable_memory_pool_Control) + ); +} + +/* + * _ITRON_Variable_memory_pool_Clarify_allocation_id_error + * + * This function is invoked when an object allocation ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Variable_memory_pool_Clarify_allocation_id_error( _id ) \ + _ITRON_Objects_Clarify_allocation_id_error( \ + &_ITRON_Variable_memory_pool_Information, (_id) ) + +/* + * _ITRON_Variable_memory_pool_Clarify_get_id_error + * + * This function is invoked when an object get ID error + * occurs to determine the specific ITRON error code to return. + */ + +#define _ITRON_Variable_memory_pool_Clarify_get_id_error( _id ) \ + _ITRON_Objects_Clarify_get_id_error( &_ITRON_Variable_memory_pool_Information, (_id) ) + +/* + * _ITRON_Variable_memory_pool_Free + * + * DESCRIPTION: + * + * This routine frees a variable memory pool control block to the + * inactive chain of free variable memory pool control blocks. + * + * Input parameters: + * the_variable_memory_pool - pointer to variable memory pool control block + * + * Output parameters: NONE + */ + +RTEMS_INLINE_ROUTINE void _ITRON_Variable_memory_pool_Free ( + ITRON_Variable_memory_pool_Control *the_variable_memory_pool +) +{ + _ITRON_Objects_Free( + &_ITRON_Variable_memory_pool_Information, + &the_variable_memory_pool->Object + ); +} + +/*PAGE + * + * _ITRON_Variable_memory_pool_Get + * + * DESCRIPTION: + * + * This function maps variable memory pool IDs to variable memory pool + * control blocks. If ID corresponds to a local variable memory pool, + * then it returns the variable memory pool control pointer which maps + * to ID and location is set to OBJECTS_LOCAL. if the variable memory + * pool ID is global and resides on a remote node, then location is set + * to OBJECTS_REMOTE, and the variable memory pool is undefined. Otherwise, + * location is set to OBJECTS ERROR and the variable memory pool is undefined. + * + * Input parameters: + * id - ITRON variable memory pool ID. + * the_location - pointer to a location variable + * + * Output parameters: + * *the_location - location of the object + */ + +RTEMS_INLINE_ROUTINE ITRON_Variable_memory_pool_Control + *_ITRON_Variable_memory_pool_Get ( + ID id, + Objects_Locations *location +) +{ + return (ITRON_Variable_memory_pool_Control *) _ITRON_Objects_Get( + &_ITRON_Variable_memory_pool_Information, + id, + location + ); +} + +/*PAGE + * + * _ITRON_Variable_memory_pool_Is_null + * + * This function returns TRUE if the_variable_memory_pool is NULL + * and FALSE otherwise. + * + * Input parameters: + * the_variable_memory_pool - pointer to variable memory pool control block + * + * Output parameters: + * TRUE - if the_variable_memory_pool is NULL + * FALSE - otherwise + */ + +RTEMS_INLINE_ROUTINE boolean _ITRON_Variable_memory_pool_Is_null ( + ITRON_Variable_memory_pool_Control *the_variable_memory_pool +) +{ + return ( the_variable_memory_pool == NULL ); +} + +/* + * XXX insert inline routines here + */ + +#ifdef __cplusplus +} +#endif + +#endif +/* end of include file */ + -- cgit v1.2.3