uit_type.h

ecos为实时嵌入式操作系统

                                         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