Subversion Repositories openrisc_me

#ifndef CYGONCE_COMPAT_UITRON_UIT_TYPE_H

#define CYGONCE_COMPAT_UITRON_UIT_TYPE_H

//===========================================================================

//

//      uit_type.h

//

//      uITRON specific data types as required by the API

//

//===========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//===========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   hmt

// Contributors:        hmt

// Date:        1998-03-13

// Purpose:     uITRON specific data types as required by the API

// Description: 

//

//####DESCRIPTIONEND####

//

//===========================================================================

#include <pkgconf/uitron.h>             // uITRON setup CYGNUM_UITRON_SEMAS

                                        // CYGPKG_UITRON et al

#ifdef CYGPKG_UITRON

// ------------------------------------------------------------------------

// uITRON types

//

// from this section of the uITRON 3.02 manual:

// ***********************************************************************

// ***    6.4 Data Types                                               ***

// ***********************************************************************

//

// ***  General-Purpose Data Types ***************************************

typedef cyg_int8    B;          // signed 8-bit integer

typedef cyg_int16   H;          // signed 16-bit integer

typedef cyg_int32   W;          // signed 32-bit integer

typedef cyg_uint8   UB;         // unsigned 8-bit integer

typedef cyg_uint16  UH;         // unsigned 16-bit integer

typedef cyg_uint32  UW;         // unsigned 32-bit integer

                                // 

typedef cyg_uint32  VW;         // unpredictable data type (32-bit size)

typedef cyg_uint16  VH;         // unpredictable data type (16-bit size)

typedef cyg_uint8   VB;         // unpredictable data type (8-bit size)

typedef void *      VP;         // pointer to an unpredictable data type

typedef CYG_ADDRWORD FP;        // program start address

// * The difference between VB, VH and VW and B, H and W is that only the

//   number of bits is known for the former, not the data type of the

//   contents.  The latter clearly represent integers.

//

// ***  Data Types Dependent on ITRON Specification ***

//

// In order to clarify the meanings of certain parameters, the following

// names are used for data types which appear frequently and/or have

// special meanings.

typedef cyg_int32  INT; // Signed integer (bit width of processor)

typedef cyg_uint32 UINT;   // Unsigned integer (bit width of processor)

typedef cyg_int32  BOOL;   // Boolean value.  TRUE (1) or FALSE (0).

typedef cyg_uint16 FN;     // Function code.  Signed integer.  Maximum 2 bytes.

typedef INT        ID;     // Object ID number (???id)

typedef INT        BOOL_ID;// Boolean value or ID number

typedef INT        HNO;    // Handler number

typedef INT        RNO;    // Rendezvous number

typedef INT        NODE;   // Node Number.  Usually a signed integer.

typedef UINT       ATR;    // Object or handler attribute.  An unsigned integer.

typedef INT        ER;     // Error code.  A signed integer.

typedef INT        PRI;    // Task priority.  A signed integer.

typedef UB         T_MSG;  // Message packet data structure used for mailboxes

typedef INT        TMO;    // Timeout value.  A signed integer.

                           // TMO_POL = 0 indicates polling,

                           // while TMO_FEVR = -1 indicates wait forever.

typedef cyg_uint64 CYGTM;

typedef CYGTM      SYSTIME;// Data types used for specifying times.

typedef CYGTM      CYCTIME;// Often split into upper and lower sections.

typedef CYGTM      ALMTIME;// For details, see the chapter giving system

typedef CYGTM      DLYTIME;// call descriptions;.

// ***********************************************************************

// ***    6.7 Error Codes                                              ***

// ***********************************************************************

enum {

//------------------------------------------------------

//Mnemonic Value      Description

//------------------------------------------------------

E_OK     = 0,      // Normal completion

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_SYS    = (-5),   // System error

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_NOMEM  = (-10),  // Insufficient memory

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_NOSPT  = (-17),  // Feature not supported

E_INOSPT = (-18),  // Feature not supported by ITRON/FILE specification

E_RSFN   = (-20),  // Reserved function code number

E_RSATR  = (-24),  // Reserved attribute

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_PAR    = (-33),  // Parameter error

E_ID     = (-35),  // Invalid ID number

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_NOEXS  = (-52),  // Object does not exist

E_OBJ    = (-63),  // Invalid object state

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_MACV   = (-65),  // Memory access disabled or memory access violation

E_OACV   = (-66),  // Object access violation

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_CTX    = (-69),  // Context error

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_QOVR   = (-73),  // Queuing or nesting overflow

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_DLT    = (-81),  // Object being waited for was deleted

// - - - - - - - - // - - - - - - - - - - - - - - - - - -

E_TMOUT  = (-85),  // Polling failure or timeout exceeded

E_RLWAI  = (-86),  // WAIT state was forcibly released

// - - - - - - - - // - - - - - - - - - - - - - - - - - - -

#if 0 // CONNECTION FUNCTIONS ARE NOT SUPPORTED

EN_NOND  = (-113), // Target node does not exist or cannot be accessed

EN_OBJNO = (-114), // Specifies an object number which could not be

                   // accessed on the target node

EN_PROTO = (-115), // Protocol not supported on target node

EN_RSFN  = (-116), // System call or function not supported on target node

EN_COMM  = (-117), // No response from target node

EN_RLWAI = (-118), // Connection function response wait state was forcibly

                   // released

EN_PAR   = (-119), // A value outside the range supported by the target

                   // node and/or transmission packet format was specified

                   // as a parameter

EN_RPAR  = (-120), // A value outside the range supported by the issuing

                   // node and/or transmission packet format was returned

                   // as a return parameter

EN_CTXID = (-121), // An object on another node was specified to a system

                   // call issued from a task in dispatch disabled state

                   // or from a task-independent portion

EN_EXEC  = (-122), // System call could not be executed due to

                   // insufficient resources on the target node

EN_NOSPT = (-123), // Connection function not supported

#endif // 0 CONNECTION FUNCTIONS ARE NOT SUPPORTED

// - - - - - - - - // - - - - - - - - - - - - - - - - - - -

};

// *******************************************************************

// ***    6.6 Common Constants and Data Structure Packet Formats   ***

// *******************************************************************

/* --- overall ----------------------- */

/* invalid address or pointer value */

#define NADR      ((void *)(-1)) 

enum {

        TRUE  =   1,    /* true */

        FALSE =   0,    /* false */

};

/*    TMO tmout:   */

enum {

        TMO_POL  =    0,    /* polling */

        TMO_FEVR =  (-1)    /* wait forever */

};

/* --- for task management functions ----------------------- */

// cre_tsk:

        typedef struct t_ctsk {

                VP    exinf;     /* extended information */

                ATR   tskatr;    /* task attributes */

                FP    task;      /* task start address */

                PRI   itskpri;   /* initial task priority */

                INT   stksz;     /* stack size */

                // ...

            /* additional information may be included depending on the

               implementation */

                // ...

        } T_CTSK;

//    tskatr:

enum {

        TA_ASM    = 0x00,     /* program written in assembly language */

        TA_HLNG   = 0x01,     /* program written in high-level language */

        TA_COP0   = 0x8000,   /* uses coprocessor having ID = 0 */

        TA_COP1   = 0x4000,   /* uses coprocessor having ID = 1 */

        TA_COP2   = 0x2000,   /* uses coprocessor having ID = 2 */

        TA_COP3   = 0x1000,   /* uses coprocessor having ID = 3 */

        TA_COP4   = 0x0800,   /* uses coprocessor having ID = 4 */

        TA_COP5   = 0x0400,   /* uses coprocessor having ID = 5 */

        TA_COP6   = 0x0200,   /* uses coprocessor having ID = 6 */

        TA_COP7   = 0x0100,   /* uses coprocessor having ID = 7 */

};

//    tskid:

enum {

        TSK_SELF  = 0,  /* task specifies itself */

        /* FALSE     = 0, */ /* indicates a task-independent portion (return

                          parameters only) */

};

//    tskpri:

enum {

        TPRI_INI  = 0,  /* specifies the initial priority on task startup

                          (chg_pri) */

        TPRI_RUN  = 0,  /* specifies the highest priority during execution

                          (rot_rdq) */

};

    /* ref_tsk */

        typedef struct t_rtsk {

                VP     exinf;     /* extended information */

                PRI    tskpri;    /* current priority */

                UINT   tskstat;   /* task state */

            /* the following are represent extended features of support

               [level X] (implementation-dependent) */

#if 0 // NOT SUPPORTED

                UINT   tskwait;   /* cause of wait */

                ID     wid;       /* ID of object being waited for */

                INT    wupcnt;    /* wakeup request count */

                INT    suscnt;    /* SUSPEND request count */

                ATR    tskatr;    /* task attributes */

                FP     task;      /* task start address */

                PRI    itskpri;   /* initial task priority */

                INT    stksz;     /* stack size */

                        // ...

#endif

        } T_RTSK;

//    tskstat:

enum {

        TTS_RUN   = 0x01,  /* RUN */

        TTS_RDY   = 0x02,  /* READY */

        TTS_WAI   = 0x04,  /* WAIT */

        TTS_SUS   = 0x08,  /* SUSPEND */

        TTS_WAS   = 0x0C,  /* WAIT-SUSPEND */

        TTS_DMT   = 0x10,  /* DORMANT */

};

//    tskwait:

enum {

        TTW_SLP   = 0x0001,  /* wait due to slp_tsk or tslp_tsk */

        TTW_DLY   = 0x0002,  /* wait due to dly_tsk */

        TTW_NOD   = 0x0008,  /* connection function response wait */

        TTW_FLG   = 0x0010,  /* wait due to wai_flg or twai_flg */

        TTW_SEM   = 0x0020,  /* wait due to wai_sem or twai_sem */

        TTW_MBX   = 0x0040,  /* wait due to rcv_msg or trcv_msg */

        TTW_SMBF  = 0x0080,  /* wait due to snd_mbf or tsnd_mbf */

        TTW_MBF   = 0x0100,  /* wait due to rcv_mbf or trcv_mbf */

        TTW_CAL   = 0x0200,  /* wait for rendezvous call */

        TTW_ACP   = 0x0400,  /* wait for rendezvous accept */

        TTW_RDV   = 0x0800,  /* wait for rendezvous completion */

        TTW_MPL   = 0x1000,  /* wait due to get_blk or tget_blk */

        TTW_MPF   = 0x2000,  /* wait due to get_blf or tget_blf */

};

         /* Since the task states given by tskstat and tskwait are expressed

            by bit correspondences, they are convenient when looking for OR

            conditions (such as whether a task is in WAIT or READY state).

            */

/* --- for semaphore functions ----------------------- */

    /* cre_sem */

        typedef struct t_csem {

                VP    exinf;    /* extended information */

                ATR   sematr;   /* semaphore attributes */

            /* Following is the extended function for [level X]. */

                INT   isemcnt;   /* initial semaphore count */

            /*  INT   maxsem;  NOT SUPPORTED maximum semaphore count */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CSEM;

    /* ref_sem */

        typedef struct t_rsem {

                VP      exinf;    /* extended information */

                BOOL_ID wtsk;     /* indicates whether or not there is a

                                     waiting task */

                INT     semcnt;   /* current semaphore count */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RSEM;

/* --- for eventflag functions ----------------------- */

    /* cre_flg */

        typedef struct t_cflg {

                VP     exinf;     /* extended information */

                ATR    flgatr;    /* eventflag attribute */

                UINT   iflgptn;   /* initial eventflag */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CFLG;

//    flgatr:

enum {

        TA_WSGL   = 0x00,  /* multiple tasks are not allowed to wait (Wait

                                Single Task) */

        TA_WMUL   = 0x08,  /* multiple tasks are allowed to wait (Wait

                                Multiple Task) */

};

//    wfmode:

enum {

        TWF_ANDW   = 0x00,  /* AND wait */

        TWF_ORW    = 0x02,  /* OR wait */

        TWF_CLR    = 0x01,  /* clear specification */

};

    /* ref_flg */

        typedef struct t_rflg {

                VP        exinf;      /* extended information */

                BOOL_ID   wtsk;       /* indicates whether or not there is a

                                         waiting task */

                UINT      flgptn;     /* eventflag bit pattern */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RFLG;

/* --- for mailbox functions ----------------------- */

   /* cre_mbx */

        typedef struct t_cmbx {

                VP    exinf;    /* extended information */

                ATR   mbxatr;   /* mailbox attributes */

            /* Following is implementation-dependent function */

            /*  INT   bufcnt; NOT SUPPORTED ring buffer size IS FIXED */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CMBX;

//    mbxatr:

enum {

        TA_TFIFO   = 0x00,  /* waiting tasks are handled by FIFO */

        TA_TPRI    = 0x01,  /* waiting tasks are handled by priority */

        TA_MFIFO   = 0x00,  /* messages are handled by FIFO */

        TA_MPRI    = 0x02,  /* messages are handled by priority */

};

    /* ref_mbx */

        typedef struct t_rmbx {

                VP        exinf;    /* extended information */

                BOOL_ID   wtsk;     /* indicates whether or not there is a

                                       waiting task */

                T_MSG*    pk_msg;   /* message to be sent next */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RMBX;

/* --- for messagebuffer functions ----------------------- */

#if 0 // NOT SUPPORTED

    /* cre_mbf */

        typedef struct t_cmbf {

                VP    exinf;    /* extended information */

                ATR   mbfatr;   /* messagebuffer attributes */

                INT   bufsz;    /* messagebuffer size */

                INT   maxmsz;   /* maximum size of messages */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CMBF;

//    mbfatr:

//    mbfid:

enum {

        TMBF_OS  = (-4),   /* messagebuffer used for OS error log */

        TMBF_DB  = (-3),   /* messagebuffer used for debugging */

};

    /* ref_mbf */

        typedef struct t_rmbf {

                VP        exinf;     /* extended information */

                BOOL_ID   wtsk;      /* indicates whether or not there is a

                                        task waiting to receive a message */

                BOOL_ID   stsk;      /* indicates whether or not there is a

                                        task waiting to send a message */

                INT       msgsz;     /* size of message to be sent next */

                INT       frbufsz;   /* size of free buffer */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RMBF;

#endif

/* --- for port or rendezvous functions ----------------------- */

#if 0 // NOT SUPPORTED

    /* cre_por */

        typedef struct t_cpor {

                VP    exinf;     /* extended information */

                ATR   poratr;    /* port attributes */

                INT   maxcmsz;   /* maximum call message size */

                INT   maxrmsz;   /* maximum reply message size */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CPOR;

//    poratr:

enum {

        TA_NULL  = 0,  /* specifies no particular attributes */

         /* TA_NULL should be used in place of zeroes to turn off all

            attribute features. */

};

    /* ref_por */

        typedef struct t_rpor {

                VP        exinf;   /* extended information */

                BOOL_ID   wtsk;    /* indicates whether or not there is a task

                                      waiting to call a rendezvous */

                BOOL_ID   atsk;    /* indicates whether or not there is a task

                                      waiting to accept a rendezvous */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RPOR;

#endif

/* --- for interrupt management functions ----------------------- */

#if 0 // NOT SUPPORTED

    /* def_int */

        typedef struct t_dint {

                ATR   intatr;   /* interrupt handler attributes */

                FP    inthdr;   /* interrupt handler address */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_DINT;

#endif

/* --- for memorypool management functions ----------------------- */

    /* cre_mpl */

        typedef struct t_cmpl {

                VP    exinf;    /* extended information */

                ATR   mplatr;   /* memorypool attributes */

                INT   mplsz;    /* memorypool size */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CMPL;

//    mplatr:

//    mplid:

enum {

        TMPL_OS  = (-4)   /* memorypool used by OS */

};

    /* ref_mpl */

        typedef struct t_rmpl {

                VP        exinf;    /* extended information */

                BOOL_ID   wtsk;     /* indicates whether or not there are

                                       waiting tasks */

                INT       frsz;     /* total size of free memory */

                INT       maxsz;    /* size of largest contiguous memory */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RMPL;

    /* cre_mpf */

        typedef struct t_cmpf {

                VP    exinf;     /* extended information */

                ATR   mpfatr;    /* memorypool attributes */

                INT   mpfcnt;    /* block count for entire memorypool */

                INT   blfsz;     /* fixed-size memory block size */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_CMPF;

//    mpfatr:

    /* ref_mpf */

        typedef struct t_rmpf {

                VP        exinf;    /* extended information */

                BOOL_ID   wtsk;     /* indicates whether or not there are

                                       waiting tasks */

                INT       frbcnt;   /* free block count */

            /* additional information may be included depending on the

               implementation */

                INT       numbcnt;  /* total number of blocks */

                INT       bsize;    /* block size */

        } T_RMPF;

/* --- for time management functions ----------------------- */

#if 0 // native definition is at head of this file

    /* example for 32-bit CPUs */

        typedef struct t_systime {

                H    utime;   /* upper 16 bits */

                UW   ltime;   /* lower 32 bits */

        } SYSTIME, CYCTIME, ALMTIME;

    /* example for 16-bit CPUs */

        typedef struct t_systime {

                H    utime;   /* upper 16 bits */

                UH   mtime;   /* middle 16 bits */

                UH   ltime;   /* lower 16 bits */

        } SYSTIME, CYCTIME, ALMTIME;

#endif

         /* Member configuration depends on the bit width of the processor and

            on the implementation.  A total of 48 bits is recommended. */

    /* def_cyc */

        typedef struct t_dcyc {

                VP        exinf;    /* extended information */

                ATR       cycatr;   /* cyclic handler attributes */

                FP        cychdr;   /* cyclic handler address */

                UINT      cycact;   /* cyclic handler activation */

                CYCTIME   cyctim;   /* cyclic startup period */

        } T_DCYC;

//    cycact:

enum {

        TCY_OFF   = 0x00,  /* do not invoke cyclic handler */

        TCY_ON    = 0x01,  /* invoke cyclic handler */

        TCY_INT   = 0x02,  /* initialize cycle count */

        /* Following changed from TCY_INT to TCY_INI to match

           description in the body of the standard.  I assume TCY_INT

           is a hypercorrection/typo; keep both */

        TCY_INI   = 0x02,  /* initialize cycle count */

};

    /* ref_cyc */

        typedef struct t_rcyc {

                VP        exinf;    /* extended information */

                CYCTIME   lfttim;   /* time left before next handler startup */

                UINT      cycact;   /* cyclic handler activation */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RCYC;

    /* def_alm */

        typedef struct t_dalm {

                VP        exinf;    /* extended information */

                ATR       almatr;   /* alarm handler attributes */

                FP        almhdr;   /* alarm handler address */

                UINT      tmmode;   /* start time specification mode */

                ALMTIME   almtim;   /* handler startup time */

        } T_DALM;

//    tmmode:

enum {

        TTM_ABS   = 0x00,  /* specified as an absolute time */

        TTM_REL   = 0x01,  /* specified as a relative time */

};

    /* ref_alm */

        typedef struct t_ralm {

                VP        exinf;    /* extended information */

                ALMTIME   lfttim;   /* time left before next handler startup */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RALM;

/* --- for system management functions ----------------------- */

    /* get_ver */

        typedef struct t_ver {

                UH   maker;     /* vendor */

                UH   id;        /* format number */

                UH   spver;     /* specification version */

                UH   prver;     /* product version */

                UH   prno[4];   /* product control information */

                UH   cpu;       /* CPU information */

                UH   var;       /* variation descriptor */

        } T_VER;

    /* ref_sys */

        typedef struct t_rsys {

                INT   sysstat;   /* system state */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_RSYS;

//    sysstat:

enum {

        TSS_TSK   = 0,  /* normal state in which dispatching is enabled during

                          task portion execution */

        TSS_DDSP  = 1,   /* state after dis_dsp has been executed during task

                          portion execution (dispatch disabled) */

        TSS_LOC   = 3,   /* state after loc_cpu has been executed during task

                          portion execution (interrupt and dispatch disabled)

                          */

        TSS_INDP  = 4,   /* state during execution of task-independent portions

                          (interrupt and timer handlers) */

};

    /* ref_cfg */

        typedef struct t_rcfg {

            /* details concerning members are implementation dependent */

        } T_RCFG;

#if 0 // NOT SUPPORTED

    /* def_svc */

        typedef struct t_dsvc {

                ATR   svcatr;   /* extended SVC handler attributes */

                FP    svchdr;   /* extended SVC handler address */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_DSVC;

    /* def_exc */

        typedef struct t_dexc {

                ATR   excatr;   /* exception handler attributes */

                FP    exchdr;   /* exception handler address */

                        // ...

            /* additional information may be included depending on the

               implementation */

                        // ...

        } T_DEXC;

#endif

/* --- for network management functions ----------------------- */

#if 0 // NOT SUPPORTED

//    NODE srcnode, dstnode, node:

enum {

        TND_SELF  = 0,     /* specifies the local node */

        TND_OTHR  = (-1)   /* specifies default remote node */

};

#endif

/* ------------------------------------------------------ */

#endif // CYGPKG_UITRON

#endif // CYGONCE_COMPAT_UITRON_UIT_TYPE_H

// EOF uit_type.h