uitron.h

ecos为实时嵌入式操作系统

#ifdef CYGPKG_UITRON_MEMPOOLFIXED
#if 0 < CYGNUM_UITRON_MEMPOOLFIXED

#define CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE

#ifdef  CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
#define CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY 3
#endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE

#define CYGDAT_UITRON_MEMPOOLFIXED_EXTERNS \
static char fpool1[ 2000 ], \
            fpool2[ 2000 ], \
            fpool3[ 2000 ];

// in terms of CYG_UIT_MEMPOOLFIXED( addr, size, blocksize );
// [or CYG_UIT_MEMPOOLFIXED_NOEXS( addr, size ) if cre/del supported]
#define CYGDAT_UITRON_MEMPOOLFIXED_INITIALIZERS \
   CYG_UIT_MEMPOOLFIXED( fpool1, 2000,  20 ), \
   CYG_UIT_MEMPOOLFIXED( fpool2, 2000, 100 ), \
   CYG_UIT_MEMPOOLFIXED( fpool3, 2000, 500 ), \

#endif
#endif // do we have fixed memory pools?

// Variable block memory pools:

/* {{CFG_DATA
   cdl_component CYGPKG_UITRON_MEMPOOLVAR {
       display "Variable-size memorypools"
       type    boolean
       parent  CYGPKG_UITRON
       description "uITRON supports memory pools for dynamic, task-safe
                memory allocation.
                Two kinds are supported, fixed-size and variable-size.
                There may be multiple of each
                type of pool, each with differing characteristics.
                This option controls whether there are any variable-size
                memorypools in the system.
                A variable-size memorypool allocates blocks of memory of
                any size requested, resources permitting."
   }
   cdl_option CYGNUM_UITRON_MEMPOOLVAR {
       display          "Number of variable-size memory pools"
       parent           CYGPKG_UITRON_MEMPOOLVAR
       type             count
       legal_values     1 to 65535
       description "The number of uITRON Variable-Size
                Memorypools present in the system.
                Valid Variable-Size Memorypool IDs will range
                from 1 to this value."
   }
   cdl_component CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE {
       display "Support create and delete"
       parent  CYGPKG_UITRON_MEMPOOLVAR
       type    boolean
       description "Support
                variable-size memory pool
                create and delete operations
                (cre_mpl, del_mpl).
                Otherwise all variable-size mempools are created,
                up to the number specified above."
   }
   cdl_option CYGNUM_UITRON_MEMPOOLVAR_INITIALLY {
       display          "Number of variable-size mempools created initially"
       parent           CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
       type             count
       legal_values     0 to 65535
       description "The number of variable-size mempools initially created.
                This number should not be more than the number
                of variable mempools in the system, though setting
                it to a large value to mean 'all' is acceptable.
                Initially, only variable mempools numbered from
                1 to this number exist;
                higher numbered ones must be created before use.
                All mempools must be initialized to tell
                the system what memory to use for each pool."
   }
   cdl_option CYGDAT_UITRON_MEMPOOLVAR_EXTERNS {
       display          "Externs for initialization"
       parent           CYGPKG_UITRON_MEMPOOLVAR
       type             multiline
       description "Variable mempool initializers may refer to external
                objects such as memory for the pool to manage.
                Use this option to define or declare any external
                objects needed by the pool's static initializer below.
                Example: create some memory for a mempool using
                 'static char vpool1[2000];'
                to set up a chunk of memory of 2000 bytes.
                Note: this option is invoked in the 'outermost' context
                of C++ source, where global/static objects are created;
                it should contain valid, self-contained, C++ source."
   }
   cdl_option CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS {
       display          "Static initializers"
       parent           CYGPKG_UITRON_MEMPOOLVAR
       type             multiline
       description "Variable block memory pools should be statically
                initialized: enter a list of initializers
                separated by commas, one per line.
                An initializer is
                'CYG_UIT_MEMPOOLVAR(ADDR,SIZE)'
                where addr is the address of memory to manage, and
                size is the total size of that memory.
                If create and delete operations are supported,
                initializers of the form
                'CYG_UIT_MEMPOOLVAR_NOEXS(ADDR,SIZE)' should be
                used for pools which are not initially created, to tell
                the system what memory to use for each pool.
                Note: this option is invoked in the context of a
                C++ array initializer, between curly brackets.
                Ensure that the number of initializers here exactly
                matches the total number of variable pools specified."
   }
   }}CFG_DATA */

#define CYGPKG_UITRON_MEMPOOLVAR
#define CYGNUM_UITRON_MEMPOOLVAR 3

#ifdef CYGPKG_UITRON_MEMPOOLVAR   
#if 0 < CYGNUM_UITRON_MEMPOOLVAR

#define CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE

#ifdef  CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
#define CYGNUM_UITRON_MEMPOOLVAR_INITIALLY 3
#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE

#define CYGDAT_UITRON_MEMPOOLVAR_EXTERNS \
static char vpool1[ 2000 ], \
            vpool2[ 2000 ], \
            vpool3[ 2000 ];

// in terms of CYG_UIT_MEMPOOLVAR( addr, size );
// [or CYG_UIT_MEMPOOLVAR_NOEXS( addr, size ) if cre/del supported]
#define CYGDAT_UITRON_MEMPOOLVAR_INITIALIZERS \
   CYG_UIT_MEMPOOLVAR( vpool1, 2000 ), \
   CYG_UIT_MEMPOOLVAR( vpool2, 2000 ), \
   CYG_UIT_MEMPOOLVAR( vpool3, 2000 ), \

#endif   
#endif // do we have variable memory pools?

// ------------------------------------------------------------------------
// One-shot Alarm and Cyclic Alarm handlers:
//
// These are declared without uninitialization; they must be defined in
// order to use them.


/* {{CFG_DATA
   cdl_component CYGPKG_UITRON_ALARMS {
       display "Alarm handlers"
       type    boolean
       parent  CYGPKG_UITRON
       requires CYGVAR_KERNEL_COUNTERS_CLOCK
       description "uITRON Alarm Handlers are used with functions
                named def_alm() and ref_alm(); they support
                simple timing, with a function callback
                at the end of the timed period."
   }
   cdl_option CYGNUM_UITRON_ALARMS {
       display          "Number of alarm handlers"
       parent           CYGPKG_UITRON_ALARMS
       type             count
       legal_values     1 to 65535
       description "The number of uITRON alarm
                handlers present in the system.
                Valid alarm handler numbers will range
                from 1 to this value."
   }
   }}CFG_DATA */
#define CYGPKG_UITRON_ALARMS
#define CYGNUM_UITRON_ALARMS   3
#if 0 // initializers not supported
#if 0 < CYGNUM_UITRON_ALARMS
//#define CYGDAT_UITRON_ALARM_EXTERNS
// in terms of ALARM( ... )
//#define CYGDAT_UITRON_ALARM_INITIALIZERS
#endif
#endif // NOT SUPPORTED 


/* {{CFG_DATA
   cdl_component CYGPKG_UITRON_CYCLICS {
       display "Cyclic handlers"
       type    boolean
       parent  CYGPKG_UITRON
       requires CYGVAR_KERNEL_COUNTERS_CLOCK
       description "uITRON Cyclic Handlers are used with functions
                named xxx_cyc(); they support timing
                with a periodic function callback that
                can be dynamically turned on or off, and
                resynchronized with external events."
   }
   cdl_option CYGNUM_UITRON_CYCLICS {
       display          "Number cyclic handlers"
       parent           CYGPKG_UITRON_CYCLICS
       type             count
       legal_values     1 to 65535
       description "The number of uITRON cyclics
                handlers present in the system.
                Valid cyclic handler numbers will range
                from 1 to this value."
   }
   }}CFG_DATA */
#define CYGPKG_UITRON_CYCLICS
#define CYGNUM_UITRON_CYCLICS  3
#if 0 // initializers not supported
#if 0 < CYGNUM_UITRON_CYCLICS
//#define CYGDAT_UITRON_CYCLIC_EXTERNS
// in terms of CYCLIC( ... )
//#define CYGDAT_UITRON_CYCLIC_INITIALIZERS
#endif
#endif // NOT SUPPORTED 

// ========================================================================
// ------------------------------------------------------------------------
//                      uITRON VERSION INFORMATION
// ------------------------------------------------------------------------

/* {{CFG_DATA
   cdl_component CYGPKG_UITRON_VERSION {
       display "Version information"
       type    dummy
       parent  CYGPKG_UITRON
       description "The get_ver() uITRON system call returns
                several version related values describing
                the vendor, product and CPU in question
                as well as the version of the uITRON
                standard supported.
                These values may be specified here."
   }
   cdl_option CYGNUM_UITRON_VER_MAKER {
       display          "OS maker"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'maker'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_ID     {
       display          "OS identification"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'id'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_SPVER  {
       display          "ITRON specification"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'spver'
                field of the T_VER structure in
                response to a get_ver() system call.
                Do NOT change this value."
   }
   cdl_option CYGNUM_UITRON_VER_PRVER  {
       display          "OS product version"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'prver'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   # PRNO fields in own folder
   cdl_component CYGPKG_UITRON_VERSION_PRNO {
       display "Product info"
       type    dummy
       parent  CYGPKG_UITRON_VERSION
       description "The get_ver() uITRON system call returns
                several version related values describing
                the vendor, product and CPU in question
                as well as the version of the uITRON
                standard supported.
                These values may be specified here."
   }
   cdl_option CYGNUM_UITRON_VER_PRNO_0 {
       display          "Field 0"
       parent           CYGPKG_UITRON_VERSION_PRNO
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'prno[0]'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_PRNO_1 {
       display          "Field 1"
       parent           CYGPKG_UITRON_VERSION_PRNO
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'prno[1]'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_PRNO_2 {
       display          "Field 2"
       parent           CYGPKG_UITRON_VERSION_PRNO
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'prno[2]'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_PRNO_3 {
       display          "Field 3"
       parent           CYGPKG_UITRON_VERSION_PRNO
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'prno[3]'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   # up a level
   cdl_option CYGNUM_UITRON_VER_CPU    {
       display          "CPU information"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'cpu'
                field of the T_VER structure in
                response to a get_ver() system call."
   }
   cdl_option CYGNUM_UITRON_VER_VAR    {
       display          "System variant"
       parent           CYGPKG_UITRON_VERSION
       type             count
       legal_values     0 to 0xFFFF
       description "This value is returned in the 'var'
                field of the T_VER structure in
                response to a get_ver() system call.
                Do NOT change this value."
   }
   }}CFG_DATA
 */

// these constants are returned by the get_ver API call.

#define CYGNUM_UITRON_VER_MAKER          0 /* vendor */
#define CYGNUM_UITRON_VER_ID             0 /* format number */
#define CYGNUM_UITRON_VER_SPVER   0x5302   /* specification version */
#define CYGNUM_UITRON_VER_PRVER   0x0100   /* product version */
#define CYGNUM_UITRON_VER_PRNO_0         0 /* product control information */
#define CYGNUM_UITRON_VER_PRNO_1         0
#define CYGNUM_UITRON_VER_PRNO_2         0
#define CYGNUM_UITRON_VER_PRNO_3         0
#define CYGNUM_UITRON_VER_CPU            0 /* CPU information */
#define CYGNUM_UITRON_VER_VAR     0x8000   /* variation descriptor */


#endif // CYGPKG_UITRON

#endif // CYGONCE_PKGCONF_UITRON_H
// EOF pgkconf/uitron.h