#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