开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
lib_mem.h
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：51k
源码类别：

uCOS

开发平台：

C/C++

lib_mem.h：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                               uC/LIB
  4. *                                       CUSTOM LIBRARY MODULES
  5. *
  6. *                          (c) Copyright 2004-2008; Micrium, Inc.; Weston, FL
  7. *
  8. *               All rights reserved.  Protected by international copyright laws.
  9. *
  10. *               uC/LIB is provided in source form for FREE evaluation, for educational
  11. *               use or peaceful research.  If you plan on using uC/LIB in a commercial
  12. *               product you need to contact Micrium to properly license its use in your
  13. *               product.  We provide ALL the source code for your convenience and to
  14. *               help you experience uC/LIB.  The fact that the source code is provided
  15. *               does NOT mean that you can use it without paying a licensing fee.
  16. *
  17. *               Knowledge of the source code may NOT be used to develop a similar product.
  18. *
  19. *               Please help us continue to provide the Embedded community with the finest
  20. *               software available.  Your honesty is greatly appreciated.
  21. *********************************************************************************************************
  22. */
  24. /*
  25. *********************************************************************************************************
  26. *
  27. *                                     STANDARD MEMORY OPERATIONS
  28. *
  29. * Filename      : lib_mem.h
  30. * Version       : V1.25
  31. * Programmer(s) : ITJ
  32. *********************************************************************************************************
  33. * Note(s)       : (1) NO compiler-supplied standard library functions are used in library or product software.
  34. *
  35. *                     (a) ALL standard library functions are implemented in the custom library modules :
  36. *
  37. *                         (1) <Custom Library Directory>lib*.*
  38. *
  39. *                         (2) <Custom Library Directory>Ports<cpu><compiler>lib*_a.*
  40. *
  41. *                               where
  42. *                                       <Custom Library Directory>      directory path for custom library software
  43. *                                       <cpu>                           directory name for specific processor (CPU)
  44. *                                       <compiler>                      directory name for specific compiler
  45. *
  46. *                     (b) Product-specific library functions are implemented in individual products.
  47. *********************************************************************************************************
  48. */
  51. /*
  52. *********************************************************************************************************
  53. *                                               MODULE
  54. *********************************************************************************************************
  55. */
  57. #ifndef  LIB_MEM_MODULE_PRESENT
  58. #define  LIB_MEM_MODULE_PRESENT
  61. /*$PAGE*/
  62. /*
  63. *********************************************************************************************************
  64. *                                            INCLUDE FILES
  65. *
  66. * Note(s) : (1) The following common software files are located in the following directories :
  67. *
  68. *               (a) <Custom Library Directory>lib*.*
  69. *
  70. *               (b) (1) <CPU-Compiler Directory>cpu_def.h
  71. *
  72. *                   (2) <CPU-Compiler Directory><cpu><compiler>cpu*.*
  73. *
  74. *                           where
  75. *                                   <Custom Library Directory>      directory path for custom   library      software
  76. *                                   <CPU-Compiler Directory>        directory path for common   CPU-compiler software
  77. *                                   <cpu>                           directory name for specific processor (CPU)
  78. *                                   <compiler>                      directory name for specific compiler
  79. *
  80. *           (2) Compiler MUST be configured to include the '<Custom Library Directory>uC-LIB',
  81. *               '<CPU-Compiler Directory>' directory, & the specific CPU-compiler directory as
  82. *               additional include path directories.
  83. *
  84. *           (3) NO compiler-supplied standard library functions SHOULD be used.
  85. *********************************************************************************************************
  86. */
  88. #include  <cpu.h>
  89. #include  <lib_def.h>
  90. #include  <app_cfg.h>
  93. /*
  94. *********************************************************************************************************
  95. *                                               EXTERNS
  96. *********************************************************************************************************
  97. */
  99. #ifdef   LIB_MEM_MODULE
  100. #define  LIB_MEM_EXT
  101. #else
  102. #define  LIB_MEM_EXT  extern
  103. #endif
  106. /*$PAGE*/
  107. /*
  108. *********************************************************************************************************
  109. *                                        DEFAULT CONFIGURATION
  110. *********************************************************************************************************
  111. */
  113. /*
  114. *********************************************************************************************************
  115. *                             MEMORY LIBRARY ARGUMENT CHECK CONFIGURATION
  116. *
  117. * Note(s) : (1) Configure LIB_MEM_CFG_ARG_CHK_EXT_EN to enable/disable the memory libray suite external
  118. *               argument check feature :
  119. *
  120. *               (a) When ENABLED,      arguments received from any port interface provided by the developer
  121. *                   or application are checked/validated.
  122. *
  123. *               (b) When DISABLED, NO  arguments received from any port interface provided by the developer
  124. *                   or application are checked/validated.
  125. *********************************************************************************************************
  126. */
  127.                                                         /* Configure external argument check feature (see Note #1) :    */
  128. #ifndef  LIB_MEM_CFG_ARG_CHK_EXT_EN
  129. #define  LIB_MEM_CFG_ARG_CHK_EXT_EN     DEF_DISABLED
  130.                                                         /*   DEF_DISABLED     Argument check DISABLED                   */
  131.                                                         /*   DEF_ENABLED      Argument check ENABLED                    */
  132. #endif
  135. /*
  136. *********************************************************************************************************
  137. *                                      MEMORY POOL CONFIGURATION
  138. *
  139. * Note(s) : (1) Configure LIB_MEM_CFG_POOL_EN to enable/disable memory pool functions.
  140. *********************************************************************************************************
  141. */
  142.                                                         /* Configure memory pool feature (see Note #1) :                */
  143. #ifndef  LIB_MEM_CFG_POOL_EN
  144. #define  LIB_MEM_CFG_POOL_EN            DEF_DISABLED
  145.                                                         /*   DEF_DISABLED     Memory pool(s) DISABLED                   */
  146.                                                         /*   DEF_ENABLED      Memory pool(s) ENABLED                    */
  147. #endif
  150. /*$PAGE*/
  151. /*
  152. *********************************************************************************************************
  153. *                                               DEFINES
  154. *********************************************************************************************************
  155. */
  157. /*
  158. *********************************************************************************************************
  159. *                                      LIBRARY MEMORY ERROR CODES
  160. *********************************************************************************************************
  161. */
  163. #define  LIB_MEM_ERR_NONE                              10000
  164. #define  LIB_MEM_ERR_NULL_PTR                          10001    /* Ptr arg(s) passed NULL ptr(s).                       */
  165. #define  LIB_MEM_ERR_NONE_AVAIL                        10010    /* NO avail mem rsrc's.                                 */
  167. #define  LIB_MEM_ERR_INVALID_SEG_SIZE                  10100    /* Invalid mem seg size.                                */
  168. #define  LIB_MEM_ERR_INVALID_SEG_OVERLAP               10101    /* Invalid mem seg overlaps other mem seg(s).           */
  169. #define  LIB_MEM_ERR_INVALID_POOL                      10102    /* Invalid mem pool.                                    */
  170. #define  LIB_MEM_ERR_INVALID_ADDR                      10103    /* Invalid mem pool addr.                               */
  171. #define  LIB_MEM_ERR_INVALID_BLK_NBR                   10104    /* Invalid mem pool blk nbr.                            */
  172. #define  LIB_MEM_ERR_INVALID_BLK_SIZE                  10105    /* Invalid mem pool blk size.                           */
  173. #define  LIB_MEM_ERR_INVALID_BLK_IX                    10106    /* Invalid mem pool ix.                                 */
  175. #define  LIB_MEM_ERR_SEG_EMPTY                         10110    /* Mem seg  empty; i.e. NO avail mem for mem pools.     */
  176. #define  LIB_MEM_ERR_POOL_FULL                         10111    /* Mem pool full;  i.e. All mem blks avail in mem pool. */
  178. #define  LIB_MEM_ERR_HEAP_NOT_FOUND                    10115    /* Heap seg NOT found.                                  */
  179. #define  LIB_MEM_ERR_HEAP_EMPTY                        10116    /* Heap seg empty; i.e. NO avail mem in heap.           */
  182. /*$PAGE*/
  183. /*
  184. *********************************************************************************************************
  185. *                                     MEMORY LIBRARY TYPE DEFINES
  186. *
  187. * Note(s) : (1) LIB_MEM_TYPE_??? #define values specifically chosen as ASCII representations of the memory
  188. *               library types.  Memory displays of memory library objects will display the library TYPEs
  189. *               with their chosen ASCII names.
  190. **********************************************************************************************************/
  192.                                                                 /* ------------------- LIB_MEM TYPES ------------------ */
  193. #if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
  194. #define  LIB_MEM_TYPE_NONE                        0x4E4F4E45    /* "NONE" in ASCII.                                     */
  195. #define  LIB_MEM_TYPE_HEAP                        0x48454150    /* "HEAP" in ASCII.                                     */
  196. #define  LIB_MEM_TYPE_POOL                        0x504F4F4C    /* "POOL" in ASCII.                                     */
  198. #else
  200. #if     (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_32)
  201. #define  LIB_MEM_TYPE_NONE                        0x454E4F4E    /* "NONE" in ASCII.                                     */
  202. #define  LIB_MEM_TYPE_HEAP                        0x50414548    /* "HEAP" in ASCII.                                     */
  203. #define  LIB_MEM_TYPE_POOL                        0x4C4F4F50    /* "POOL" in ASCII.                                     */
  205. #elif   (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_16)
  206. #define  LIB_MEM_TYPE_NONE                        0x4F4E454E    /* "NONE" in ASCII.                                     */
  207. #define  LIB_MEM_TYPE_HEAP                        0x45485041    /* "HEAP" in ASCII.                                     */
  208. #define  LIB_MEM_TYPE_POOL                        0x4F504C4F    /* "POOL" in ASCII.                                     */
  210. #else                                                           /* Dflt CPU_WORD_SIZE_08.                               */
  211. #define  LIB_MEM_TYPE_NONE                        0x4E4F4E45    /* "NONE" in ASCII.                                     */
  212. #define  LIB_MEM_TYPE_HEAP                        0x48454150    /* "HEAP" in ASCII.                                     */
  213. #define  LIB_MEM_TYPE_POOL                        0x504F4F4C    /* "POOL" in ASCII.                                     */
  215. #endif
  216. #endif
  219. /*$PAGE*/
  220. /*
  221. *********************************************************************************************************
  222. *                                             DATA TYPES
  223. *********************************************************************************************************
  224. */
  226. /*
  227. *********************************************************************************************************
  228. *                                            LIB MEM TYPE
  229. *
  230. * Note(s) : (1) 'LIB_MEM_TYPE' declared as 'CPU_INT32U' & all 'LIB_MEM_TYPE's #define'd with large, non-trivial
  231. *               values to trap & discard invalid/corrupted library memory objects based on 'LIB_MEM_TYPE'.
  232. *********************************************************************************************************
  233. */
  235. typedef  CPU_INT32U  LIB_MEM_TYPE;
  238. /*
  239. *********************************************************************************************************
  240. *                                      MEMORY POOL TABLE IX TYPE
  241. *
  242. * Note(s) : (1) MEM_POOL_IX_NONE  SHOULD be #define'd based on 'MEM_POOL_IX' data type declared.
  243. *********************************************************************************************************
  244. */
  246. typedef  CPU_INT16U   MEM_POOL_IX;
  248. #define  MEM_POOL_IX_NONE                DEF_INT_16U_MAX_VAL    /* Define as max unsigned val (see Note #1).            */
  249. #define  MEM_POOL_IX_MIN                                   1
  250. #define  MEM_POOL_IX_MAX               (MEM_POOL_IX_NONE - 1)
  253. /*$PAGE*/
  254. /*
  255. *********************************************************************************************************
  256. *                                        MEMORY POOL DATA TYPES
  257. *
  258. *                                                                      MEMORY SEGMENT
  259. *                                                                     ----------------
  260. *                                            MEMORY POOL'S            |              | <----
  261. *                                             POINTERS TO             |    MEMORY    |     |
  262. *                    MEM_POOL                MEMORY BLOCKS            |    BLOCKS    |     |
  263. *               |----------------|            |---------|             |   --------   |     |
  264. *               |        O------------------> |    O--------------------> |      |   |     |
  265. *               |----------------|            |---------|             |   |      |   |     |
  266. *               | Pool Addr Ptrs |            |    O-------------     |   --------   |     |
  267. *               | Pool Size      |            |---------|       |     |              |     |
  268. *               |----------------|            |         |       |     |   --------   |     |
  269. *               |    Blk Size    |            |         |       --------> |      |   |     |
  270. *               |    Blk Nbr     |            |         |             |   |      |   |     |
  271. *               |    Blk Ix      |            |    .    |             |   --------   |     |
  272. *               |----------------|            |    .    |             |              |     |
  273. *               |----------------|            |    .    |             |      .       |     |
  274. *               |        O-----------------   |         |             |      .       |     |
  275. *               |----------------|        |   |         |             |      .       |     |
  276. *               |        O------------    |   |         |             |              |     |
  277. *               |----------------|   |    |   |---------|             |   --------   |     |
  278. *               |  Seg Size Tot  |   |    |   |    O--------------------> |      |   |     |
  279. *               |  Seg Size Rem  |   |    |   |---------|             |   |      |   |     |
  280. *               |----------------|   |    |   |         |             |   --------   |     |
  281. *               | Seg List Ptrs  |   |    |   |---------|             |              |     |
  282. *               |----------------|   |    |                           | ------------ |     |
  283. *                                    |    |                           |              | <--------
  284. *                                    |    |                           |              |     |   |
  285. *                                    |    |                           |              |     |   |
  286. *                                    |    |                           |              |     |   |
  287. *                                    |    |                           |              |     |   |
  288. *                                    |    |                           |              |     |   |
  289. *                                    |    |                           ----------------     |   |
  290. *                                    |    |                                                |   |
  291. *                                    |    --------------------------------------------------   |
  292. *                                    |                                                         |
  293. *                                    -----------------------------------------------------------
  294. *
  295. *********************************************************************************************************
  296. */
  298. typedef  struct  mem_pool  MEM_POOL;
  300.                                                                 /* --------------------- MEM POOL --------------------- */
  301. struct  mem_pool {
  302.     LIB_MEM_TYPE    Type;                                       /* Pool type : LIB_TYPE_POOL or LIB_TYPE_HEAP.          */
  304.     MEM_POOL       *SegPrevPtr;                                 /* Ptr to PREV mem seg.                                 */
  305.     MEM_POOL       *SegNextPtr;                                 /* Ptr to NEXT mem seg.                                 */
  306.     MEM_POOL       *PoolPrevPtr;                                /* Ptr to PREV mem pool.                                */
  307.     MEM_POOL       *PoolNextPtr;                                /* Ptr to NEXT mem pool.                                */
  309.     void           *PoolAddrStart;                              /* Ptr   to start of mem seg for mem pool blks.         */
  310.     void           *PoolAddrEnd;                                /* Ptr   to end   of mem seg for mem pool blks.         */
  311.     void          **PoolPtrs;                                   /* Ptr   to mem pool's array of blk ptrs.               */
  312.     MEM_POOL_IX     BlkIx;                                      /* Ix  into mem pool's array of blk ptrs.               */
  313.     CPU_SIZE_T      PoolSize;                                   /* Size  of mem pool        (in octets).                */
  314.     CPU_SIZE_T      BlkNbr;                                     /* Nbr   of mem pool   blks.                            */
  315.     CPU_SIZE_T      BlkSize;                                    /* Size  of mem pool   blks (in octets).                */
  316.     CPU_SIZE_T      BlkAlign;                                   /* Align of mem pool   blks (in octets).                */
  318.                                                                 /* --------------------- MEM SEG ---------------------- */
  319.     void           *SegAddr;                                    /* Ptr      to mem seg's base/start addr.               */
  320.     void           *SegAddrNextAvail;                           /* Ptr      to mem seg's next avail addr.               */
  321.     CPU_SIZE_T      SegSizeTot;                                 /* Tot size of mem seg (in octets).                     */
  322.     CPU_SIZE_T      SegSizeRem;                                 /* Rem size of mem seg (in octets).                     */
  323. };
  326. /*$PAGE*/
  327. /*
  328. *********************************************************************************************************
  329. *                                          GLOBAL VARIABLES
  330. *********************************************************************************************************
  331. */
  334. /*$PAGE*/
  335. /*
  336. *********************************************************************************************************
  337. *                                              MACRO'S
  338. *********************************************************************************************************
  339. */
  341. /*
  342. *********************************************************************************************************
  343. *                                      MEMORY DATA VALUE MACRO'S
  344. *
  345. * Note(s) : (1) (a) Some variables & variable buffers to pass & receive data values MUST start on appropriate
  346. *                   CPU word-aligned addresses.  This is required because most word-aligned processors are more
  347. *                   efficient & may even REQUIRE that multi-octet words start on CPU word-aligned addresses.
  348. *
  349. *                   (1) For 16-bit word-aligned processors, this means that
  350. *
  351. *                           all 16- & 32-bit words MUST start on addresses that are multiples of 2 octets
  352. *
  353. *                   (2) For 32-bit word-aligned processors, this means that
  354. *
  355. *                           all 16-bit       words MUST start on addresses that are multiples of 2 octets
  356. *                           all 32-bit       words MUST start on addresses that are multiples of 4 octets
  357. *
  358. *               (b) However, some data values macro's appropriately access data values from any CPU addresses,
  359. *                   word-aligned or not.  Thus for processors that require data word alignment, data words can
  360. *                   be accessed to/from any CPU address, word-aligned or not, without generating data-word-
  361. *                   alignment exceptions/faults.
  362. *********************************************************************************************************
  363. */
  366. /*$PAGE*/
  367. /*
  368. *********************************************************************************************************
  369. *                                          MEM_VAL_GET_xxx()
  370. *
  371. * Description : Decode data values from any CPU memory address.
  372. *
  373. * Argument(s) : addr        Lowest CPU memory address of data value to decode (see Notes #2 & #3a).
  374. *
  375. * Return(s)   : Decoded data value from CPU memory address (see Notes #1 & #3b).
  376. *
  377. * Caller(s)   : Application.
  378. *
  379. * Note(s)     : (1) Decode data values based on the values' data-word order in CPU memory :
  380. *
  381. *                       MEM_VAL_GET_xxx_BIG()           Decode big-   endian data values -- data words' most
  382. *                                                           significant octet @ lowest memory address
  383. *                       MEM_VAL_GET_xxx_LITTLE()        Decode little-endian data values -- data words' least
  384. *                                                           significant octet @ lowest memory address
  385. *                       MEM_VAL_GET_xxx()               Decode data values using CPU's native or configured
  386. *                                                           data-word order
  387. *
  388. *                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
  389. *
  390. *               (2) CPU memory addresses/pointers NOT checked for NULL.
  391. *
  392. *               (3) (a) MEM_VAL_GET_xxx() macro's decode data values without regard to CPU word-aligned addresses.
  393. *                       Thus for processors that require data word alignment, data words can be decoded from any
  394. *                       CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
  395. *
  396. *                   (b) However, any variable to receive the returned data value MUST start on an appropriate CPU
  397. *                       word-aligned address.
  398. *
  399. *                   See also 'MEMORY DATA VALUE MACRO'S  Note #1'.
  400. *
  401. *               (4) MEM_VAL_COPY_GET_xxx() macro's are more efficient than MEM_VAL_GET_xxx() macro's & are
  402. *                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
  403. *
  404. *                   See also 'MEM_VAL_COPY_GET_xxx()  Note #4'.
  405. *
  406. *               (5) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
  407. *                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
  408. *                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
  409. *                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
  410. *                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
  411. *********************************************************************************************************
  412. */
  414. #define  MEM_VAL_GET_INT08U_BIG(addr)             (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS))
  416. #define  MEM_VAL_GET_INT16U_BIG(addr)            ((((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (1 * DEF_OCTET_NBR_BITS)) + 
  417.                                                   (((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (0 * DEF_OCTET_NBR_BITS)))
  419. #define  MEM_VAL_GET_INT32U_BIG(addr)            ((((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (3 * DEF_OCTET_NBR_BITS)) + 
  420.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (2 * DEF_OCTET_NBR_BITS)) + 
  421.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (1 * DEF_OCTET_NBR_BITS)) + 
  422.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (0 * DEF_OCTET_NBR_BITS)))
  426. #define  MEM_VAL_GET_INT08U_LITTLE(addr)          (((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS))
  428. #define  MEM_VAL_GET_INT16U_LITTLE(addr)         ((((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)) + 
  429.                                                   (((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (1 * DEF_OCTET_NBR_BITS)))
  431. #define  MEM_VAL_GET_INT32U_LITTLE(addr)         ((((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (0 * DEF_OCTET_NBR_BITS)) + 
  432.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (1 * DEF_OCTET_NBR_BITS)) + 
  433.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (2 * DEF_OCTET_NBR_BITS)) + 
  434.                                                   (((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (3 * DEF_OCTET_NBR_BITS)))
  438. #if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
  440. #define  MEM_VAL_GET_INT08U(addr)                               MEM_VAL_GET_INT08U_BIG(addr)
  441. #define  MEM_VAL_GET_INT16U(addr)                               MEM_VAL_GET_INT16U_BIG(addr)
  442. #define  MEM_VAL_GET_INT32U(addr)                               MEM_VAL_GET_INT32U_BIG(addr)
  444. #elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
  446. #define  MEM_VAL_GET_INT08U(addr)                               MEM_VAL_GET_INT08U_LITTLE(addr)
  447. #define  MEM_VAL_GET_INT16U(addr)                               MEM_VAL_GET_INT16U_LITTLE(addr)
  448. #define  MEM_VAL_GET_INT32U(addr)                               MEM_VAL_GET_INT32U_LITTLE(addr)
  450. #else                                                                           /* See Note #5.                         */
  452. #error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
  453. #error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
  455. #endif
  458. /*$PAGE*/
  459. /*
  460. *********************************************************************************************************
  461. *                                          MEM_VAL_SET_xxx()
  462. *
  463. * Description : Encode data values to any CPU memory address.
  464. *
  465. * Argument(s) : addr        Lowest CPU memory address to encode data value (see Notes #2 & #3a).
  466. *
  467. *               val         Data value to encode (see Notes #1 & #3b).
  468. *
  469. * Return(s)   : none.
  470. *
  471. * Caller(s)   : Application.
  472. *
  473. * Note(s)     : (1) Encode data values into CPU memory based on the values' data-word order :
  474. *
  475. *                       MEM_VAL_SET_xxx_BIG()           Encode big-   endian data values -- data words' most
  476. *                                                           significant octet @ lowest memory address
  477. *                       MEM_VAL_SET_xxx_LITTLE()        Encode little-endian data values -- data words' least
  478. *                                                           significant octet @ lowest memory address
  479. *                       MEM_VAL_SET_xxx()               Encode data values using CPU's native or configured
  480. *                                                           data-word order
  481. *
  482. *                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
  483. *
  484. *               (2) CPU memory addresses/pointers NOT checked for NULL.
  485. *
  486. *               (3) (a) MEM_VAL_SET_xxx() macro's encode data values without regard to CPU word-aligned addresses.
  487. *                       Thus for processors that require data word alignment, data words can be encoded to any
  488. *                       CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
  489. *
  490. *                   (b) However, 'val' data value to encode MUST start on an appropriate CPU word-aligned address.
  491. *
  492. *                   See also 'MEMORY DATA VALUE MACRO'S  Note #1'.
  493. *
  494. *               (4) MEM_VAL_COPY_SET_xxx() macro's are more efficient than MEM_VAL_SET_xxx() macro's & are
  495. *                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
  496. *
  497. *                   See also 'MEM_VAL_COPY_SET_xxx()  Note #4'.
  498. *
  499. *               (5) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
  500. *                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
  501. *                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
  502. *                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
  503. *                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
  504. *********************************************************************************************************
  505. */
  507. #define  MEM_VAL_SET_INT08U_BIG(addr, val)                    { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) &       0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }
  509. #define  MEM_VAL_SET_INT16U_BIG(addr, val)                    { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) &     0xFF00) >> (1 * DEF_OCTET_NBR_BITS))); 
  510.                                                                 (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) &     0x00FF) >> (0 * DEF_OCTET_NBR_BITS))); }
  512. #define  MEM_VAL_SET_INT32U_BIG(addr, val)                    { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0xFF000000) >> (3 * DEF_OCTET_NBR_BITS))); 
  513.                                                                 (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x00FF0000) >> (2 * DEF_OCTET_NBR_BITS))); 
  514.                                                                 (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x0000FF00) >> (1 * DEF_OCTET_NBR_BITS))); 
  515.                                                                 (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x000000FF) >> (0 * DEF_OCTET_NBR_BITS))); }
  519. #define  MEM_VAL_SET_INT08U_LITTLE(addr, val)                 { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) &       0xFF) >> (0 * DEF_OCTET_NBR_BITS))); }
  521. #define  MEM_VAL_SET_INT16U_LITTLE(addr, val)                 { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) &     0x00FF) >> (0 * DEF_OCTET_NBR_BITS))); 
  522.                                                                 (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) &     0xFF00) >> (1 * DEF_OCTET_NBR_BITS))); }
  524. #define  MEM_VAL_SET_INT32U_LITTLE(addr, val)                 { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x000000FF) >> (0 * DEF_OCTET_NBR_BITS))); 
  525.                                                                 (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x0000FF00) >> (1 * DEF_OCTET_NBR_BITS))); 
  526.                                                                 (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0x00FF0000) >> (2 * DEF_OCTET_NBR_BITS))); 
  527.                                                                 (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & 0xFF000000) >> (3 * DEF_OCTET_NBR_BITS))); }
  531. #if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
  533. #define  MEM_VAL_SET_INT08U(addr, val)                          MEM_VAL_SET_INT08U_BIG(addr, val)
  534. #define  MEM_VAL_SET_INT16U(addr, val)                          MEM_VAL_SET_INT16U_BIG(addr, val)
  535. #define  MEM_VAL_SET_INT32U(addr, val)                          MEM_VAL_SET_INT32U_BIG(addr, val)
  537. #elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
  539. #define  MEM_VAL_SET_INT08U(addr, val)                          MEM_VAL_SET_INT08U_LITTLE(addr, val)
  540. #define  MEM_VAL_SET_INT16U(addr, val)                          MEM_VAL_SET_INT16U_LITTLE(addr, val)
  541. #define  MEM_VAL_SET_INT32U(addr, val)                          MEM_VAL_SET_INT32U_LITTLE(addr, val)
  543. #else                                                                           /* See Note #5.                         */
  545. #error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
  546. #error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
  548. #endif
  551. /*$PAGE*/
  552. /*
  553. *********************************************************************************************************
  554. *                                       MEM_VAL_COPY_GET_xxx()
  555. *
  556. * Description : Copy & decode data values from any CPU memory address to any CPU memory address.
  557. *
  558. * Argument(s) : addr_dest       Lowest CPU memory address to copy/decode source address's data value
  559. *                                   (see Notes #2 & #3).
  560. *
  561. *               addr_src        Lowest CPU memory address of data value to copy/decode
  562. *                                   (see Notes #2 & #3).
  563. *
  564. * Return(s)   : none.
  565. *
  566. * Caller(s)   : Application.
  567. *
  568. * Note(s)     : (1) Copy/decode data values based on the values' data-word order :
  569. *
  570. *                       MEM_VAL_COPY_GET_xxx_BIG()      Decode big-   endian data values -- data words' most
  571. *                                                           significant octet @ lowest memory address
  572. *                       MEM_VAL_COPY_GET_xxx_LITTLE()   Decode little-endian data values -- data words' least
  573. *                                                           significant octet @ lowest memory address
  574. *                       MEM_VAL_COPY_GET_xxx()          Decode data values using CPU's native or configured
  575. *                                                           data-word order
  576. *
  577. *                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
  578. *
  579. *               (2) CPU memory addresses/pointers NOT checked for NULL.
  580. *
  581. *               (3) MEM_VAL_COPY_GET_xxx() macro's copy/decode data values without regard to CPU word-aligned
  582. *                   addresses.  Thus for processors that require data word alignment, data words can be copied/
  583. *                   decoded to/from any CPU address, word-aligned or not, without generating data-word-alignment
  584. *                   exceptions/faults.
  585. *
  586. *               (4) MEM_VAL_COPY_GET_xxx() macro's are more efficient than MEM_VAL_GET_xxx() macro's & are
  587. *                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
  588. *
  589. *                   See also 'MEM_VAL_GET_xxx()  Note #4'.
  590. *
  591. *               (5) Since octet-order copy/conversion are inverse operations, memory data value gets/sets are
  592. *                   inverse operations.
  593. *
  594. *                   See also 'MEM_VAL_COPY_SET_xxx()  Note #5'.
  595. *
  596. *               (6) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
  597. *                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
  598. *                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
  599. *                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
  600. *                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
  601. *********************************************************************************************************
  602. */
  603. /*$PAGE*/
  605. #if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
  608. #define  MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  610. #define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  611.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); }
  613. #define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  614.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  615.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); 
  616.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); }
  620. #define  MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  622. #define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  623.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  625. #define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3)); 
  626.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2)); 
  627.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  628.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  632. #define  MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)
  633. #define  MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
  634. #define  MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
  639. #elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
  642. #define  MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  644. #define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  645.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  647. #define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)     { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3)); 
  648.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2)); 
  649.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  650.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  654. #define  MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  656. #define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  657.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); }
  659. #define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)  { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  660.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  661.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); 
  662.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); }
  666. #define  MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
  667. #define  MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
  668. #define  MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
  673. #else                                                                           /* See Note #6.                         */
  675. #error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
  676. #error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
  678. #endif
  681. /*$PAGE*/
  682. /*
  683. *********************************************************************************************************
  684. *                                       MEM_VAL_COPY_SET_xxx()
  685. *
  686. * Description : Copy & encode data values from any CPU memory address to any CPU memory address.
  687. *
  688. * Argument(s) : addr_dest       Lowest CPU memory address to copy/encode source address's data value
  689. *                                   (see Notes #2 & #3).
  690. *
  691. *               addr_src        Lowest CPU memory address of data value to copy/encode
  692. *                                   (see Notes #2 & #3).
  693. *
  694. * Return(s)   : none.
  695. *
  696. * Caller(s)   : Application.
  697. *
  698. * Note(s)     : (1) Copy/encode data values based on the values' data-word order :
  699. *
  700. *                       MEM_VAL_COPY_SET_xxx_BIG()      Encode big-   endian data values -- data words' most
  701. *                                                           significant octet @ lowest memory address
  702. *                       MEM_VAL_COPY_SET_xxx_LITTLE()   Encode little-endian data values -- data words' least
  703. *                                                           significant octet @ lowest memory address
  704. *                       MEM_VAL_COPY_SET_xxx()          Encode data values using CPU's native or configured
  705. *                                                           data-word order
  706. *
  707. *                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
  708. *
  709. *               (2) CPU memory addresses/pointers NOT checked for NULL.
  710. *
  711. *               (3) MEM_VAL_COPY_SET_xxx() macro's copy/encode data values without regard to CPU word-aligned
  712. *                   addresses.  Thus for processors that require data word alignment, data words can be copied/
  713. *                   encoded to/from any CPU address, word-aligned or not, without generating data-word-alignment
  714. *                   exceptions/faults.
  715. *
  716. *               (4) MEM_VAL_COPY_SET_xxx() macro's are more efficient than MEM_VAL_SET_xxx() macro's & are
  717. *                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
  718. *
  719. *                   See also 'MEM_VAL_SET_xxx()  Note #4'.
  720. *
  721. *               (5) Since octet-order copy/conversion are inverse operations, memory data value gets/sets
  722. *                   are inverse operations.
  723. *
  724. *                   See also 'MEM_VAL_COPY_GET_xxx()  Note #5'.
  725. *********************************************************************************************************
  726. */
  728.                                                                                 /* See Note #5.                         */
  729. #define  MEM_VAL_COPY_SET_INT08U_BIG(addr_dest, addr_src)       MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)
  730. #define  MEM_VAL_COPY_SET_INT16U_BIG(addr_dest, addr_src)       MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
  731. #define  MEM_VAL_COPY_SET_INT32U_BIG(addr_dest, addr_src)       MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
  733. #define  MEM_VAL_COPY_SET_INT08U_LITTLE(addr_dest, addr_src)    MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
  734. #define  MEM_VAL_COPY_SET_INT16U_LITTLE(addr_dest, addr_src)    MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
  735. #define  MEM_VAL_COPY_SET_INT32U_LITTLE(addr_dest, addr_src)    MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
  738. #define  MEM_VAL_COPY_SET_INT08U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)
  739. #define  MEM_VAL_COPY_SET_INT16U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)
  740. #define  MEM_VAL_COPY_SET_INT32U(addr_dest, addr_src)           MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)
  743. /*$PAGE*/
  744. /*
  745. *********************************************************************************************************
  746. *                                         MEM_VAL_COPY_xxx()
  747. *
  748. * Description : Copy data values from any CPU memory address to any CPU memory address.
  749. *
  750. * Argument(s) : addr_dest       Lowest CPU memory address to copy source address's data value
  751. *                                   (see Notes #2 & #3).
  752. *
  753. *               addr_src        Lowest CPU memory address of data value to copy
  754. *                                   (see Notes #2 & #3).
  755. *
  756. * Return(s)   : none.
  757. *
  758. * Caller(s)   : Application.
  759. *
  760. * Note(s)     : (1) MEM_VAL_COPY_xxx() macro's copy data values based on CPU's native data-word order.
  761. *
  762. *                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
  763. *
  764. *               (2) CPU memory addresses/pointers NOT checked for NULL.
  765. *
  766. *               (3) MEM_VAL_COPY_xxx() macro's copy data values without regard to CPU word-aligned addresses.
  767. *                   Thus for processors that require data word alignment, data words can be copied to/from any
  768. *                   CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
  769. *********************************************************************************************************
  770. */
  772. #define  MEM_VAL_COPY_08(addr_dest, addr_src)                 { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); }
  774. #define  MEM_VAL_COPY_16(addr_dest, addr_src)                 { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  775.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); }
  777. #define  MEM_VAL_COPY_32(addr_dest, addr_src)                 { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); 
  778.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); 
  779.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); 
  780.                                                                 (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); }
  783. /*$PAGE*/
  784. /*
  785. *********************************************************************************************************
  786. *                                         FUNCTION PROTOTYPES
  787. *********************************************************************************************************
  788. */
  790. void          Mem_Init       (void);
  792.                                                                         /* -------------- MEM API  FNCTS -------------- */
  793. void          Mem_Clr        (void        *pmem,
  794.                               CPU_SIZE_T   size);
  796. void          Mem_Set        (void        *pmem,
  797.                               CPU_INT08U   data_val,
  798.                               CPU_SIZE_T   size);
  800. void          Mem_Copy       (void        *pdest,
  801.                               void        *psrc,
  802.                               CPU_SIZE_T   size);
  804. CPU_BOOLEAN   Mem_Cmp        (void        *p1_mem,
  805.                               void        *p2_mem,
  806.                               CPU_SIZE_T   size);
  810. #if (LIB_MEM_CFG_POOL_EN == DEF_ENABLED)                                /* -------------- MEM POOL FNCTS -------------- */
  812. void          Mem_PoolCreate (MEM_POOL    *pmem_pool,
  813.                               void        *pmem_base_addr,
  814.                               CPU_SIZE_T   mem_size,
  815.                               CPU_SIZE_T   blk_nbr,
  816.                               CPU_SIZE_T   blk_size,
  817.                               CPU_SIZE_T   blk_align,
  818.                               CPU_SIZE_T  *poctets_reqd,
  819.                               LIB_ERR     *perr);
  821. void         *Mem_PoolBlkGet (MEM_POOL    *pmem_pool,
  822.                               CPU_SIZE_T   size,
  823.                               LIB_ERR     *perr);
  825. void          Mem_PoolBlkFree(MEM_POOL    *pmem_pool,
  826.                               void        *pmem_blk,
  827.                               LIB_ERR     *perr);
  829. #endif
  832. /*$PAGE*/
  833. /*
  834. *********************************************************************************************************
  835. *                                        CONFIGURATION ERRORS
  836. *********************************************************************************************************
  837. */
  839. #ifndef  LIB_MEM_CFG_ARG_CHK_EXT_EN
  840. #error  "LIB_MEM_CFG_ARG_CHK_EXT_EN        not #define'd in 'app_cfg.h'"
  841. #error  "                            [MUST be  DEF_DISABLED]           "
  842. #error  "                            [     ||  DEF_ENABLED ]           "
  844. #elif  ((LIB_MEM_CFG_ARG_CHK_EXT_EN != DEF_DISABLED) && 
  845.         (LIB_MEM_CFG_ARG_CHK_EXT_EN != DEF_ENABLED ))
  846. #error  "LIB_MEM_CFG_ARG_CHK_EXT_EN  illegally #define'd in 'app_cfg.h'"
  847. #error  "                            [MUST be  DEF_DISABLED]           "
  848. #error  "                            [     ||  DEF_ENABLED ]           "
  849. #endif
  853. #ifndef  LIB_MEM_CFG_POOL_EN
  854. #error  "LIB_MEM_CFG_POOL_EN               not #define'd in 'app_cfg.h'"
  855. #error  "                            [MUST be  DEF_DISABLED]           "
  856. #error  "                            [     ||  DEF_ENABLED ]           "
  858. #elif  ((LIB_MEM_CFG_POOL_EN != DEF_DISABLED) && 
  859.         (LIB_MEM_CFG_POOL_EN != DEF_ENABLED ))
  860. #error  "LIB_MEM_CFG_POOL_EN         illegally #define'd in 'app_cfg.h'"
  861. #error  "                            [MUST be  DEF_DISABLED]           "
  862. #error  "                            [     ||  DEF_ENABLED ]           "
  865. #elif   (LIB_MEM_CFG_POOL_EN == DEF_ENABLED)
  867. #ifndef  LIB_MEM_CFG_HEAP_SIZE
  868. #error  "LIB_MEM_CFG_HEAP_SIZE             not #define'd in 'app_cfg.h'"
  869. #error  "                            [MUST be  > 0]                    "
  871. #elif   (LIB_MEM_CFG_HEAP_SIZE < 1)
  873. #error  "LIB_MEM_CFG_HEAP_SIZE       illegally #define'd in 'app_cfg.h'"
  874. #error  "                            [MUST be  > 0]                    "
  875. #endif
  877. #endif
  880. /*$PAGE*/
  881. /*
  882. *********************************************************************************************************
  883. *                                             MODULE END
  884. *********************************************************************************************************
  885. */
  887. #endif                                                          /* End of lib mem module include.                       */