jiangyunsong
/
TrainCamp-Jiangyunsong-PLSR
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 1 Вики Activity
训练营PLSR题目
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Комити
1 Грана
115 MiB
 
 
 
 
 
 
Дрво: a76d8e5656
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from 'a76d8e5656'
${ noResults }
TrainCamp-Jiangyunsong-PLSR/cmsis/uC-CPU/cpu_core.h

1032 lines
46 KiB
Датотека Blame Историја 

  1. /*

  2. *********************************************************************************************************

  3. *                                                uC/CPU

  4. *                                    CPU CONFIGURATION & PORT LAYER

  5. *

  6. *                          (c) Copyright 2004-2013; Micrium, Inc.; Weston, FL

  7. *

  8. *               All rights reserved.  Protected by international copyright laws.

  9. *

  10. *               uC/CPU is provided in source form to registered licensees ONLY.  It is 

  11. *               illegal to distribute this source code to any third party unless you receive 

  12. *               written permission by an authorized Micrium representative.  Knowledge of 

  13. *               the source code may NOT be used to develop a similar product.

  14. *

  15. *               Please help us continue to provide the Embedded community with the finest 

  16. *               software available.  Your honesty is greatly appreciated.

  17. *

  18. *               You can find our product's user manual, API reference, release notes and

  19. *               more information at https://doc.micrium.com.

  20. *               You can contact us at www.micrium.com.

  21. *********************************************************************************************************

  22. */

  23. 

  24. /*

  25. *********************************************************************************************************

  26. *

  27. *                                           CORE CPU MODULE

  28. *

  29. * Filename      : cpu_core.h

  30. * Version       : V1.30.01

  31. * Programmer(s) : SR

  32. *                 ITJ

  33. *********************************************************************************************************

  34. * Note(s)       : (1) Assumes the following versions (or more recent) of software modules are included in 

  35. *                     the project build :

  36. *

  37. *                     (a) uC/LIB V1.35.00

  38. *********************************************************************************************************

  39. */

  40. 

  41. 

  42. /*

  43. *********************************************************************************************************

  44. *                                               MODULE

  45. *

  46. * Note(s) : (1) This core CPU header file is protected from multiple pre-processor inclusion through use of 

  47. *               the  core CPU module present pre-processor macro definition.

  48. *********************************************************************************************************

  49. */

  50. 

  51. #ifndef  CPU_CORE_MODULE_PRESENT                                /* See Note #1.                                         */

  52. #define  CPU_CORE_MODULE_PRESENT

  53. 

  54. 

  55. /*

  56. *********************************************************************************************************

  57. *                                               EXTERNS

  58. *********************************************************************************************************

  59. */

  60. 

  61. #ifdef   CPU_CORE_MODULE

  62. #define  CPU_CORE_EXT

  63. #else

  64. #define  CPU_CORE_EXT  extern

  65. #endif

  66. 

  67. 

  68. /*

  69. *********************************************************************************************************

  70. *                                            INCLUDE FILES

  71. *

  72. * Note(s) : (1) CPU-configuration software files are located in the following directories :

  73. *

  74. *               (a) \<Your Product Application>\cpu_cfg.h

  75. *

  76. *               (b) (1) \<CPU-Compiler Directory>\cpu_*.*

  77. *                   (2) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*

  78. *

  79. *                       where

  80. *                               <Your Product Application>      directory path for Your Product's Application

  81. *                               <CPU-Compiler Directory>        directory path for common CPU-compiler software

  82. *                               <cpu>                           directory name for specific processor (CPU)

  83. *                               <compiler>                      directory name for specific compiler

  84. *

  85. *           (2) NO compiler-supplied standard library functions SHOULD be used.

  86. *

  87. *               (a) Standard library functions are implemented in the custom library module(s) :

  88. *

  89. *                       \<Custom Library Directory>\lib_*.*

  90. *

  91. *                           where

  92. *                                   <Custom Library Directory>      directory path for custom library software

  93. *

  94. *           (3) Compiler MUST be configured to include as additional include path directories :

  95. *

  96. *               (a) '\<Your Product Application>\' directory                            See Note #1a

  97. *

  98. *               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #1b1

  99. *                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #1b2

  100. *

  101. *               (c) '\<Custom Library Directory>\' directory                            See Note #2a

  102. *********************************************************************************************************

  103. */

  104. 

  105. #include  <cpu.h>

  106. #include  <lib_def.h>

  107. #include  <cpu_cfg.h>

  108. 

  109. #if (CPU_CFG_NAME_EN == DEF_ENABLED)

  110. #include  <lib_mem.h>

  111. #include  <lib_str.h>

  112. #endif

  113. 

  114. 

  115. /*

  116. *********************************************************************************************************

  117. *                                          CPU CONFIGURATION

  118. *

  119. * Note(s) : (1) The following pre-processor directives correctly configure CPU parameters.  DO NOT MODIFY.

  120. *

  121. *           (2) CPU timestamp timer feature is required for :

  122. *

  123. *               (a) CPU timestamps

  124. *               (b) CPU interrupts disabled time measurement

  125. *

  126. *               See also 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'

  127. *                      & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1'.

  128. *********************************************************************************************************

  129. */

  130. 

  131. #ifdef   CPU_CFG_TS_EN

  132. #undef   CPU_CFG_TS_EN

  133. #endif

  134. 

  135. 

  136. #if    ((CPU_CFG_TS_32_EN == DEF_ENABLED) || \

  137.         (CPU_CFG_TS_64_EN == DEF_ENABLED))

  138. #define  CPU_CFG_TS_EN                          DEF_ENABLED

  139. #else

  140. #define  CPU_CFG_TS_EN                          DEF_DISABLED

  141. #endif

  142. 

  143. #if    ((CPU_CFG_TS_EN == DEF_ENABLED) || \

  144. (defined(CPU_CFG_INT_DIS_MEAS_EN)))

  145. #define  CPU_CFG_TS_TMR_EN                      DEF_ENABLED

  146. #else

  147. #define  CPU_CFG_TS_TMR_EN                      DEF_DISABLED

  148. #endif

  149. 

  150. 

  151. /*

  152. *********************************************************************************************************

  153. *                                               DEFINES

  154. *********************************************************************************************************

  155. */

  156. 

  157. #define  CPU_TIME_MEAS_NBR_MIN                             1u

  158. #define  CPU_TIME_MEAS_NBR_MAX                           128u

  159. 

  160. 

  161. /*

  162. *********************************************************************************************************

  163. *                                             DATA TYPES

  164. *********************************************************************************************************

  165. */

  166. 

  167. 

  168. /*

  169. *********************************************************************************************************

  170. *                                           CPU ERROR CODES

  171. *********************************************************************************************************

  172. */

  173. 

  174. typedef enum cpu_err {

  175. 

  176.     CPU_ERR_NONE                            =         0u,

  177.     CPU_ERR_NULL_PTR                        =        10u,

  178. 

  179.     CPU_ERR_NAME_SIZE                       =      1000u,

  180. 

  181.     CPU_ERR_TS_FREQ_INVALID                 =      2000u

  182. 

  183. } CPU_ERR;

  184. 

  185. 

  186. /*

  187. *********************************************************************************************************

  188. *                                      CPU TIMESTAMP DATA TYPES

  189. *

  190. * Note(s) : (1) CPU timestamp timer data type defined to the binary-multiple of 8-bit octets as configured 

  191. *               by 'CPU_CFG_TS_TMR_SIZE' (see 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #2').

  192. *********************************************************************************************************

  193. */

  194. 

  195. typedef  CPU_INT32U  CPU_TS32;

  196. typedef  CPU_INT64U  CPU_TS64;

  197. 

  198. typedef  CPU_TS32    CPU_TS;                                    /* Req'd for backwards-compatibility.                   */

  199. 

  200. 

  201. #if     (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)                    /* CPU ts tmr defined to cfg'd word size (see Note #1). */

  202. #if     (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_08)

  203. typedef  CPU_INT08U  CPU_TS_TMR;

  204. #elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_16)

  205. typedef  CPU_INT16U  CPU_TS_TMR;

  206. #elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_64)

  207. typedef  CPU_INT64U  CPU_TS_TMR;

  208. #else                                                           /* CPU ts tmr dflt size = 32-bits.                      */

  209. typedef  CPU_INT32U  CPU_TS_TMR;

  210. #endif

  211. #endif

  212. 

  213. 

  214. /*

  215. *********************************************************************************************************

  216. *                               CPU TIMESTAMP TIMER FREQUENCY DATA TYPE

  217. *********************************************************************************************************

  218. */

  219. 

  220. typedef  CPU_INT32U  CPU_TS_TMR_FREQ;

  221. 

  222. 

  223. /*

  224. *********************************************************************************************************

  225. *                                          GLOBAL VARIABLES

  226. *********************************************************************************************************

  227. */

  228. 

  229. #if    (CPU_CFG_NAME_EN   == DEF_ENABLED)

  230. CPU_CORE_EXT  CPU_CHAR         CPU_Name[CPU_CFG_NAME_SIZE];     /* CPU host name.                                       */

  231. #endif

  232. 

  233. 

  234. #if ((CPU_CFG_TS_32_EN    == DEF_ENABLED)  && \

  235.      (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_32))

  236. CPU_CORE_EXT  CPU_TS32         CPU_TS_32_Accum;                 /* 32-bit accum'd ts  (in ts tmr cnts).                 */

  237. CPU_CORE_EXT  CPU_TS_TMR       CPU_TS_32_TmrPrev;               /* 32-bit ts prev tmr (in ts tmr cnts).                 */

  238. #endif

  239. 

  240. #if ((CPU_CFG_TS_64_EN    == DEF_ENABLED)  && \

  241.      (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_64))

  242. CPU_CORE_EXT  CPU_TS64         CPU_TS_64_Accum;                 /* 64-bit accum'd ts  (in ts tmr cnts).                 */

  243. CPU_CORE_EXT  CPU_TS_TMR       CPU_TS_64_TmrPrev;               /* 64-bit ts prev tmr (in ts tmr cnts).                 */

  244. #endif

  245. 

  246. #if  (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)

  247. CPU_CORE_EXT  CPU_TS_TMR_FREQ  CPU_TS_TmrFreq_Hz;               /* CPU ts tmr freq (in Hz).                             */

  248. #endif

  249. 

  250. 

  251. #ifdef  CPU_CFG_INT_DIS_MEAS_EN

  252. CPU_CORE_EXT  CPU_INT16U       CPU_IntDisMeasCtr;               /* Nbr tot    ints dis'd ctr.                           */

  253. CPU_CORE_EXT  CPU_INT16U       CPU_IntDisNestCtr;               /* Nbr nested ints dis'd ctr.                           */

  254.                                                                 /* Ints dis'd time (in ts tmr cnts) : ...               */

  255. CPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStart_cnts;        /* ...  start time.                                     */

  256. CPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStop_cnts;         /* ...  stop  time.                                     */

  257. CPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasOvrhd_cnts;        /* ...        time meas ovrhd.                          */

  258. CPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMaxCur_cnts;       /* ...     resetable max time dis'd.                    */

  259. CPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMax_cnts;          /* ... non-resetable max time dis'd.                    */

  260. #endif

  261. 

  262. 

  263. /*

  264. *********************************************************************************************************

  265. *                                               MACRO'S

  266. *********************************************************************************************************

  267. */

  268. 

  269. /*

  270. *********************************************************************************************************

  271. *                                         CPU_SW_EXCEPTION()

  272. *

  273. * Description : Trap unrecoverable software exception.

  274. *

  275. * Argument(s) : err_rtn_val     Error type &/or value of the calling function to return (see Note #2b).

  276. *

  277. * Return(s)   : none.

  278. *

  279. * Caller(s)   : various.

  280. *

  281. * Note(s)     : (1) CPU_SW_EXCEPTION() deadlocks the current code execution -- whether multi-tasked/

  282. *                   -processed/-threaded or single-threaded -- when the current code execution cannot 

  283. *                   gracefully recover or report a fault or exception condition.

  284. *

  285. *                   Example CPU_SW_EXCEPTION() call :

  286. *

  287. *                       void  Fnct (CPU_ERR  *p_err)

  288. *                       {

  289. *                           :

  290. *

  291. *                           if (p_err == (CPU_ERR *)0) {        If 'p_err' NULL, cannot return error ...

  292. *                               CPU_SW_EXCEPTION(;);            ... so trap invalid argument exception.

  293. *                           }

  294. *

  295. *                           :

  296. *                       }

  297. *

  298. *                   See also 'cpu_core.c  CPU_SW_Exception()  Note #1'.

  299. *

  300. *               (2) (a) CPU_SW_EXCEPTION()  MAY be developer-implemented to output &/or handle any error or 

  301. *                       exception conditions; but since CPU_SW_EXCEPTION() is intended to trap unrecoverable 

  302. *                       software  conditions, it is recommended that developer-implemented versions prevent 

  303. *                       execution of any code following calls to CPU_SW_EXCEPTION() by deadlocking the code 

  304. *                       (see Note #1).

  305. *

  306. *                           Example CPU_SW_EXCEPTION() :

  307. *

  308. *                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \

  309. *                                                                               Log(__FILE__, __LINE__); \

  310. *                                                                               CPU_SW_Exception();      \

  311. *                                                                           } while (0)

  312. *

  313. *                   (b) (1) However, if execution of code following calls to CPU_SW_EXCEPTION() is required 

  314. *                           (e.g. for automated testing); it is recommended that the last statement in 

  315. *                           developer-implemented versions be to return from the current function to prevent 

  316. *                           possible software exception(s) in the current function from triggering CPU &/or 

  317. *                           hardware exception(s).

  318. *

  319. *                           Example CPU_SW_EXCEPTION() :

  320. *

  321. *                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \

  322. *                                                                               Log(__FILE__, __LINE__); \

  323. *                                                                               return  err_rtn_val;     \

  324. *                                                                           } while (0)

  325. *

  326. *                           (A) Note that 'err_rtn_val' in the return statement MUST NOT be enclosed in 

  327. *                               parentheses.  This allows CPU_SW_EXCEPTION() to return from functions that 

  328. *                               return 'void', i.e. NO return type or value (see also Note #2b2A).

  329. *

  330. *                       (2) In order for CPU_SW_EXCEPTION() to return from functions with various return 

  331. *                           types/values, each caller function MUST pass an appropriate error return type 

  332. *                           & value to CPU_SW_EXCEPTION().

  333. *

  334. *                           (A) Note that CPU_SW_EXCEPTION()  MUST NOT be passed any return type or value 

  335. *                               for functions that return 'void', i.e. NO return type or value; but SHOULD 

  336. *                               instead be passed a single semicolon.  This prevents possible compiler 

  337. *                               warnings that CPU_SW_EXCEPTION() is passed too few arguments.  However, 

  338. *                               the compiler may warn that CPU_SW_EXCEPTION() does NOT prevent creating 

  339. *                               null statements on lines with NO other code statements.

  340. *

  341. *                           Example CPU_SW_EXCEPTION() calls :

  342. *

  343. *                               void  Fnct (CPU_ERR  *p_err)

  344. *                               {

  345. *                                   :

  346. *

  347. *                                   if (p_err == (CPU_ERR *)0) {

  348. *                                       CPU_SW_EXCEPTION(;);            Exception macro returns NO value

  349. *                                   }                                       (see Note #2b2A)

  350. *

  351. *                                   :

  352. *                               }

  353. *

  354. *                               CPU_BOOLEAN  Fnct (CPU_ERR  *p_err)

  355. *                               {

  356. *                                   :

  357. *

  358. *                                   if (p_err == (CPU_ERR *)0) {

  359. *                                       CPU_SW_EXCEPTION(DEF_FAIL);     Exception macro returns 'DEF_FAIL'

  360. *                                   }

  361. *

  362. *                                   :

  363. *                               }

  364. *

  365. *                               OBJ  *Fnct (CPU_ERR  *p_err)

  366. *                               {

  367. *                                   :

  368. *

  369. *                                   if (p_err == (CPU_ERR *)0) {

  370. *                                       CPU_SW_EXCEPTION((OBJ *)0);     Exception macro returns NULL 'OBJ *'

  371. *                                   }

  372. *

  373. *                                   :

  374. *                               }

  375. *

  376. *********************************************************************************************************

  377. */

  378. 

  379. #ifndef  CPU_SW_EXCEPTION                                                       /* See Note #2.                         */

  380. #define  CPU_SW_EXCEPTION(err_rtn_val)              do {                    \

  381.                                                         CPU_SW_Exception(); \

  382.                                                     } while (0)

  383. #endif

  384. 

  385. 

  386. /*

  387. *********************************************************************************************************

  388. *                                           CPU_VAL_UNUSED()

  389. *

  390. * Description : 

  391. *

  392. * Argument(s) : none.

  393. *

  394. * Return(s)   : none.

  395. *

  396. * Caller(s)   : #### various.

  397. *

  398. * Note(s)     : none.

  399. *********************************************************************************************************

  400. */

  401. 

  402. 

  403. #define  CPU_VAL_UNUSED(val)        ((void)&(val));

  404. 

  405. 

  406. #define  CPU_VAL_IGNORED(val)       CPU_VAL_UNUSED(val)

  407. 

  408. 

  409. /*

  410. *********************************************************************************************************

  411. *                                          CPU_TYPE_CREATE()

  412. *

  413. * Description : Creates a generic type value.

  414. *

  415. * Argument(s) : char_1      1st ASCII character to create generic type value.

  416. *

  417. *               char_2      2nd ASCII character to create generic type value.

  418. *

  419. *               char_3      3rd ASCII character to create generic type value.

  420. *

  421. *               char_4      4th ASCII character to create generic type value.

  422. *

  423. * Return(s)   : 32-bit generic type value.

  424. *

  425. * Caller(s)   : various.

  426. *

  427. * Note(s)     : (1) (a) Generic type values should be #define'd with large, non-trivial values to trap 

  428. *                       & discard invalid/corrupted objects based on type value.

  429. *

  430. *                       In other words, by assigning large, non-trivial values to valid objects' type 

  431. *                       fields; the likelihood that an object with an unassigned &/or corrupted type 

  432. *                       field will contain a value is highly improbable & therefore the object itself 

  433. *                       will be trapped as invalid.

  434. *

  435. *                   (b) (1) CPU_TYPE_CREATE()  creates a 32-bit type value from four values.

  436. *

  437. *                       (2) Ideally, generic type values SHOULD be created from 'CPU_CHAR' characters to 

  438. *                           represent ASCII string abbreviations of the specific object types.  Memory 

  439. *                           displays of object type values will display the specific object types with 

  440. *                           their chosen ASCII names.

  441. *

  442. *                           Examples :

  443. *

  444. *                               #define  FILE_TYPE  CPU_TYPE_CREATE('F', 'I', 'L', 'E')

  445. *                               #define  BUF_TYPE   CPU_TYPE_CREATE('B', 'U', 'F', ' ')

  446. *********************************************************************************************************

  447. */

  448. 

  449. #if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)

  450. #define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \

  451.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \

  452.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \

  453.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))

  454. 

  455. #else

  456. 

  457. #if    ((CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_64) || \

  458.         (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_32))

  459. #define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (0u * DEF_OCTET_NBR_BITS)) | \

  460.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (1u * DEF_OCTET_NBR_BITS)) | \

  461.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (2u * DEF_OCTET_NBR_BITS)) | \

  462.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (3u * DEF_OCTET_NBR_BITS)))

  463. 

  464. 

  465. #elif   (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_16)

  466. #define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (2u * DEF_OCTET_NBR_BITS)) | \

  467.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (3u * DEF_OCTET_NBR_BITS)) | \

  468.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (0u * DEF_OCTET_NBR_BITS)) | \

  469.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (1u * DEF_OCTET_NBR_BITS)))

  470. 

  471. #else                                                           /* Dflt CPU_WORD_SIZE_08.                               */

  472. #define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \

  473.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \

  474.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \

  475.                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))

  476. #endif

  477. #endif

  478. 

  479. 

  480. /*

  481. *********************************************************************************************************

  482. *                                         FUNCTION PROTOTYPES

  483. *

  484. * Note(s) : (1) CPU interrupts disabled time measurement functions prototyped/defined only if 

  485. *               CPU_CFG_INT_DIS_MEAS_EN  #define'd in 'cpu_cfg.h'.

  486. *

  487. *           (2) (a) CPU_CntLeadZeros()  defined in :

  488. *

  489. *                   (1) 'cpu_a.asm',  if CPU_CFG_LEAD_ZEROS_ASM_PRESENT       #define'd in 'cpu.h'/

  490. *                                         'cpu_cfg.h' to enable assembly-optimized function(s)

  491. *

  492. *                   (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT   NOT #define'd in 'cpu.h'/

  493. *                                         'cpu_cfg.h' to enable C-source-optimized function(s)

  494. *

  495. *               (b) CPU_CntTrailZeros() defined in :

  496. *

  497. *                   (1) 'cpu_a.asm',  if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT      #define'd in 'cpu.h'/

  498. *                                         'cpu_cfg.h' to enable assembly-optimized function(s)

  499. *

  500. *                   (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT  NOT #define'd in 'cpu.h'/

  501. *                                         'cpu_cfg.h' to enable C-source-optimized function(s)

  502. *********************************************************************************************************

  503. */

  504. 

  505. void             CPU_Init                 (void);

  506. 

  507. void             CPU_SW_Exception         (void);

  508. 

  509. 

  510. 

  511. #if (CPU_CFG_NAME_EN == DEF_ENABLED)                                    /* -------------- CPU NAME FNCTS -------------- */

  512. void             CPU_NameClr              (void);

  513. 

  514. void             CPU_NameGet              (       CPU_CHAR  *p_name,

  515.                                                   CPU_ERR   *p_err);

  516. 

  517. void             CPU_NameSet              (const  CPU_CHAR  *p_name,

  518.                                                   CPU_ERR   *p_err);

  519. #endif

  520. 

  521. 

  522. 

  523.                                                                         /* --------------- CPU TS FNCTS --------------- */

  524. #if (CPU_CFG_TS_32_EN == DEF_ENABLED)

  525. CPU_TS32         CPU_TS_Get32             (void);

  526. #endif

  527. 

  528. #if (CPU_CFG_TS_64_EN == DEF_ENABLED)

  529. CPU_TS64         CPU_TS_Get64             (void);

  530. #endif

  531. 

  532. #if (CPU_CFG_TS_EN    == DEF_ENABLED)

  533. void             CPU_TS_Update            (void);

  534. #endif

  535. 

  536. 

  537. #if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)                                  /* ------------- CPU TS TMR FNCTS ------------- */

  538. CPU_TS_TMR_FREQ  CPU_TS_TmrFreqGet        (CPU_ERR          *p_err);

  539. 

  540. void             CPU_TS_TmrFreqSet        (CPU_TS_TMR_FREQ   freq_hz);

  541. #endif

  542. 

  543. 

  544. 

  545. #ifdef  CPU_CFG_INT_DIS_MEAS_EN                                         /* -------- CPU INT DIS TIME MEAS FNCTS ------- */

  546.                                                                         /* See Note #1.                                 */

  547. CPU_TS_TMR       CPU_IntDisMeasMaxCurReset(void);

  548. 

  549. CPU_TS_TMR       CPU_IntDisMeasMaxCurGet  (void);

  550. 

  551. CPU_TS_TMR       CPU_IntDisMeasMaxGet     (void);

  552. 

  553. 

  554. void             CPU_IntDisMeasStart      (void);

  555. 

  556. void             CPU_IntDisMeasStop       (void);

  557. #endif

  558. 

  559. 

  560. 

  561.                                                                         /* ----------- CPU CNT ZEROS FNCTS ------------ */

  562. #ifdef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT

  563. #ifdef __cplusplus

  564. extern  "C" {

  565. #endif

  566. #endif

  567. 

  568. CPU_DATA         CPU_CntLeadZeros         (CPU_DATA    val);

  569. 

  570. #ifdef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT

  571. #ifdef __cplusplus

  572. }

  573. #endif

  574. #endif

  575. 

  576. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)

  577. CPU_DATA         CPU_CntLeadZeros08       (CPU_INT08U  val);

  578. #endif

  579. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)

  580. CPU_DATA         CPU_CntLeadZeros16       (CPU_INT16U  val);

  581. #endif

  582. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)

  583. CPU_DATA         CPU_CntLeadZeros32       (CPU_INT32U  val);

  584. #endif

  585. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)

  586. CPU_DATA         CPU_CntLeadZeros64       (CPU_INT64U  val);

  587. #endif

  588. 

  589. 

  590. #ifdef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT

  591. #ifdef __cplusplus

  592. extern  "C" {

  593. #endif

  594. #endif

  595.   

  596. CPU_DATA         CPU_CntTrailZeros        (CPU_DATA    val);

  597. 

  598. #ifdef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT

  599. #ifdef __cplusplus

  600. }

  601. #endif

  602. #endif

  603. 

  604. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)

  605. CPU_DATA         CPU_CntTrailZeros08      (CPU_INT08U  val);

  606. #endif

  607. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)

  608. CPU_DATA         CPU_CntTrailZeros16      (CPU_INT16U  val);

  609. #endif

  610. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)

  611. CPU_DATA         CPU_CntTrailZeros32      (CPU_INT32U  val);

  612. #endif

  613. #if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)

  614. CPU_DATA         CPU_CntTrailZeros64      (CPU_INT64U  val);

  615. #endif

  616. 

  617. 

  618. /*

  619. *********************************************************************************************************

  620. *                                         FUNCTION PROTOTYPES

  621. *                                      DEFINED IN PRODUCT'S BSP

  622. *********************************************************************************************************

  623. */

  624. 

  625. /*

  626. *********************************************************************************************************

  627. *                                          CPU_TS_TmrInit()

  628. *

  629. * Description : Initialize & start CPU timestamp timer.

  630. *

  631. * Argument(s) : none.

  632. *

  633. * Return(s)   : none.

  634. *

  635. * Caller(s)   : CPU_TS_Init().

  636. *

  637. *               This function is an INTERNAL CPU module function & MUST be implemented by application/

  638. *               BSP function(s) [see Note #1] but MUST NOT be called by application function(s).

  639. *

  640. * Note(s)     : (1) CPU_TS_TmrInit() is an application/BSP function that MUST be defined by the developer 

  641. *                   if either of the following CPU features is enabled :

  642. *

  643. *                   (a) CPU timestamps

  644. *                   (b) CPU interrupts disabled time measurements

  645. *

  646. *                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'

  647. *                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.

  648. *

  649. *               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR' 

  650. *                       data type.

  651. *

  652. *                       (1) If timer has more bits, truncate timer values' higher-order bits greater 

  653. *                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.

  654. *

  655. *                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR' 

  656. *                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be 

  657. *                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.

  658. *

  659. *                           In other words, if timer size is not a binary-multiple of 8-bit octets 

  660. *                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple 

  661. *                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the 

  662. *                           minimum supported word size for CPU timestamp timers is 8-bits.

  663. *

  664. *                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'

  665. *                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.

  666. *

  667. *                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.

  668. *

  669. *                   (c) When applicable, timer period SHOULD be less than the typical measured time 

  670. *                       but MUST be less than the maximum measured time; otherwise, timer resolution 

  671. *                       inadequate to measure desired times.

  672. *

  673. *                   See also 'CPU_TS_TmrRd()  Note #2'.

  674. *********************************************************************************************************

  675. */

  676. 

  677. #if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)

  678. void  CPU_TS_TmrInit(void);

  679. #endif

  680. 

  681. 

  682. /*

  683. *********************************************************************************************************

  684. *                                           CPU_TS_TmrRd()

  685. *

  686. * Description : Get current CPU timestamp timer count value.

  687. *

  688. * Argument(s) : none.

  689. *

  690. * Return(s)   : Timestamp timer count (see Notes #2a & #2b).

  691. *

  692. * Caller(s)   : CPU_TS_Init(),

  693. *               CPU_TS_Get32(),

  694. *               CPU_TS_Get64(),

  695. *               CPU_IntDisMeasStart(),

  696. *               CPU_IntDisMeasStop().

  697. *

  698. *               This function is an INTERNAL CPU module function & MUST be implemented by application/

  699. *               BSP function(s) [see Note #1] but SHOULD NOT be called by application function(s).

  700. *

  701. * Note(s)     : (1) CPU_TS_TmrRd() is an application/BSP function that MUST be defined by the developer 

  702. *                   if either of the following CPU features is enabled :

  703. *

  704. *                   (a) CPU timestamps

  705. *                   (b) CPU interrupts disabled time measurements

  706. *

  707. *                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'

  708. *                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.

  709. *

  710. *               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR' 

  711. *                       data type.

  712. *

  713. *                       (1) If timer has more bits, truncate timer values' higher-order bits greater 

  714. *                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.

  715. *

  716. *                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR' 

  717. *                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be 

  718. *                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.

  719. *

  720. *                           In other words, if timer size is not a binary-multiple of 8-bit octets 

  721. *                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple 

  722. *                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the 

  723. *                           minimum supported word size for CPU timestamp timers is 8-bits.

  724. *

  725. *                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'

  726. *                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.

  727. *

  728. *                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.

  729. *

  730. *                       (1) If timer is a 'down' counter whose values decrease with each time count,

  731. *                           then the returned timer value MUST be ones-complemented.

  732. *

  733. *                   (c) (1) When applicable, the amount of time measured by CPU timestamps is 

  734. *                           calculated by either of the following equations :

  735. *

  736. *                           (A) Time measured  =  Number timer counts  *  Timer period

  737. *

  738. *                                   where

  739. *

  740. *                                       Number timer counts     Number of timer counts measured 

  741. *                                       Timer period            Timer's period in some units of 

  742. *                                                                   (fractional) seconds

  743. *                                       Time measured           Amount of time measured, in same 

  744. *                                                                   units of (fractional) seconds 

  745. *                                                                   as the Timer period

  746. *

  747. *                                                  Number timer counts

  748. *                           (B) Time measured  =  ---------------------

  749. *                                                    Timer frequency

  750. *

  751. *                                   where

  752. *

  753. *                                       Number timer counts     Number of timer counts measured

  754. *                                       Timer frequency         Timer's frequency in some units 

  755. *                                                                   of counts per second

  756. *                                       Time measured           Amount of time measured, in seconds

  757. *

  758. *                       (2) Timer period SHOULD be less than the typical measured time but MUST be less 

  759. *                           than the maximum measured time; otherwise, timer resolution inadequate to 

  760. *                           measure desired times.

  761. *********************************************************************************************************

  762. */

  763. 

  764. #if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)

  765. CPU_TS_TMR  CPU_TS_TmrRd(void);

  766. #endif

  767. 

  768. 

  769. /*

  770. *********************************************************************************************************

  771. *                                         CPU_TSxx_to_uSec()

  772. *

  773. * Description : Convert a 32-/64-bit CPU timestamp from timer counts to microseconds.

  774. *

  775. * Argument(s) : ts_cnts   CPU timestamp (in timestamp timer counts [see Note #2aA]).

  776. *

  777. * Return(s)   : Converted CPU timestamp (in microseconds           [see Note #2aD]).

  778. *

  779. * Caller(s)   : Application.

  780. *

  781. *               This function is an (optional) CPU module application programming interface (API) 

  782. *               function which MAY be implemented by application/BSP function(s) [see Note #1] & 

  783. *               MAY be called by application function(s).

  784. *

  785. * Note(s)     : (1) CPU_TS32_to_uSec()/CPU_TS64_to_uSec() are application/BSP functions that MAY be 

  786. *                   optionally defined by the developer when either of the following CPU features is 

  787. *                   enabled :

  788. *

  789. *                   (a) CPU timestamps

  790. *                   (b) CPU interrupts disabled time measurements

  791. *

  792. *                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'

  793. *                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.

  794. *

  795. *               (2) (a) The amount of time measured by CPU timestamps is calculated by either of 

  796. *                       the following equations :

  797. *

  798. *                                                                        10^6 microseconds

  799. *                       (1) Time measured  =   Number timer counts   *  -------------------  *  Timer period

  800. *                                                                            1 second

  801. *

  802. *                                              Number timer counts       10^6 microseconds

  803. *                       (2) Time measured  =  ---------------------  *  -------------------

  804. *                                                Timer frequency             1 second

  805. *

  806. *                               where

  807. *

  808. *                                   (A) Number timer counts     Number of timer counts measured

  809. *                                   (B) Timer frequency         Timer's frequency in some units 

  810. *                                                                   of counts per second

  811. *                                   (C) Timer period            Timer's period in some units of 

  812. *                                                                   (fractional)  seconds

  813. *                                   (D) Time measured           Amount of time measured, 

  814. *                                                                   in microseconds

  815. *

  816. *                   (b) Timer period SHOULD be less than the typical measured time but MUST be less 

  817. *                       than the maximum measured time; otherwise, timer resolution inadequate to 

  818. *                       measure desired times.

  819. *

  820. *                   (c) Specific implementations may convert any number of CPU_TS32 or CPU_TS64 bits 

  821. *                       -- up to 32 or 64, respectively -- into microseconds.

  822. *********************************************************************************************************

  823. */

  824. 

  825. #if (CPU_CFG_TS_32_EN == DEF_ENABLED)

  826. CPU_INT64U  CPU_TS32_to_uSec(CPU_TS32  ts_cnts);

  827. #endif

  828. 

  829. #if (CPU_CFG_TS_64_EN == DEF_ENABLED)

  830. CPU_INT64U  CPU_TS64_to_uSec(CPU_TS64  ts_cnts);

  831. #endif

  832. 

  833. 

  834. /*

  835. *********************************************************************************************************

  836. *                                        CONFIGURATION ERRORS

  837. *********************************************************************************************************

  838. */

  839. 

  840. #ifndef  CPU_CFG_NAME_EN

  841. #error  "CPU_CFG_NAME_EN                       not #define'd in 'cpu_cfg.h'"

  842. #error  "                                [MUST be  DEF_ENABLED ]           "

  843. #error  "                                [     ||  DEF_DISABLED]           "

  844. 

  845. #elif  ((CPU_CFG_NAME_EN != DEF_ENABLED ) && \

  846.         (CPU_CFG_NAME_EN != DEF_DISABLED))

  847. #error  "CPU_CFG_NAME_EN                 illegally #define'd in 'cpu_cfg.h'"

  848. #error  "                                [MUST be  DEF_ENABLED ]           "

  849. #error  "                                [     ||  DEF_DISABLED]           "

  850. 

  851. 

  852. #elif   (CPU_CFG_NAME_EN == DEF_ENABLED)

  853. 

  854. #ifndef  CPU_CFG_NAME_SIZE

  855. #error  "CPU_CFG_NAME_SIZE                     not #define'd in 'cpu_cfg.h'"

  856. #error  "                                [MUST be  >=   1]                 "

  857. #error  "                                [     &&  <= 255]                 "

  858. 

  859. #elif   (DEF_CHK_VAL(CPU_CFG_NAME_SIZE,            \

  860.                      1,                            \

  861.                      DEF_INT_08U_MAX_VAL) != DEF_OK)

  862. #error  "CPU_CFG_NAME_SIZE               illegally #define'd in 'cpu_cfg.h'"

  863. #error  "                                [MUST be  >=   1]                 "

  864. #error  "                                [     &&  <= 255]                 "

  865. #endif

  866. 

  867. #endif

  868. 

  869. 

  870. 

  871. 

  872. #ifndef  CPU_CFG_TS_32_EN

  873. #error  "CPU_CFG_TS_32_EN                      not #define'd in 'cpu_cfg.h'"

  874. #error  "                                [MUST be  DEF_DISABLED]           "

  875. #error  "                                [     ||  DEF_ENABLED ]           "

  876. 

  877. #elif  ((CPU_CFG_TS_32_EN != DEF_DISABLED) && \

  878.         (CPU_CFG_TS_32_EN != DEF_ENABLED ))

  879. #error  "CPU_CFG_TS_32_EN                illegally #define'd in 'cpu_cfg.h'"

  880. #error  "                                [MUST be  DEF_DISABLED]           "

  881. #error  "                                [     ||  DEF_ENABLED ]           "

  882. 

  883. #endif

  884. 

  885. 

  886. #ifndef  CPU_CFG_TS_64_EN

  887. #error  "CPU_CFG_TS_64_EN                      not #define'd in 'cpu_cfg.h'"

  888. #error  "                                [MUST be  DEF_DISABLED]           "

  889. #error  "                                [     ||  DEF_ENABLED ]           "

  890. 

  891. #elif  ((CPU_CFG_TS_64_EN != DEF_DISABLED) && \

  892.         (CPU_CFG_TS_64_EN != DEF_ENABLED ))

  893. #error  "CPU_CFG_TS_64_EN                illegally #define'd in 'cpu_cfg.h'"

  894. #error  "                                [MUST be  DEF_DISABLED]           "

  895. #error  "                                [     ||  DEF_ENABLED ]           "

  896. 

  897. #endif

  898. 

  899.                                                                 /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */

  900. #ifndef  CPU_CFG_TS_EN

  901. #error  "CPU_CFG_TS_EN                         not #define'd in 'cpu_core.h'"

  902. #error  "                                [MUST be  DEF_DISABLED]            "

  903. #error  "                                [     ||  DEF_ENABLED ]            "

  904. 

  905. #elif  ((CPU_CFG_TS_EN != DEF_DISABLED) && \

  906.         (CPU_CFG_TS_EN != DEF_ENABLED ))

  907. #error  "CPU_CFG_TS_EN                   illegally #define'd in 'cpu_core.h'"

  908. #error  "                                [MUST be  DEF_DISABLED]            "

  909. #error  "                                [     ||  DEF_ENABLED ]            "

  910. 

  911. #endif

  912. 

  913. 

  914.                                                                 /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */

  915. #ifndef  CPU_CFG_TS_TMR_EN

  916. #error  "CPU_CFG_TS_TMR_EN                     not #define'd in 'cpu_core.h'"

  917. #error  "                                [MUST be  DEF_DISABLED]            "

  918. #error  "                                [     ||  DEF_ENABLED ]            "

  919. 

  920. #elif  ((CPU_CFG_TS_TMR_EN != DEF_DISABLED) && \

  921.         (CPU_CFG_TS_TMR_EN != DEF_ENABLED ))

  922. #error  "CPU_CFG_TS_TMR_EN               illegally #define'd in 'cpu_core.h'"

  923. #error  "                                [MUST be  DEF_DISABLED]            "

  924. #error  "                                [     ||  DEF_ENABLED ]            "

  925. 

  926. 

  927. #elif   (CPU_CFG_TS_TMR_EN == DEF_ENABLED)

  928. 

  929. #ifndef  CPU_CFG_TS_TMR_SIZE

  930. #error  "CPU_CFG_TS_TMR_SIZE                   not #define'd in 'cpu_cfg.h'       "

  931. #error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"

  932. #error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"

  933. #error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"

  934. #error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"

  935. 

  936. #elif  ((CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_08) && \

  937.         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_16) && \

  938.         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_32) && \

  939.         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_64))

  940. #error  "CPU_CFG_TS_TMR_SIZE             illegally #define'd in 'cpu_cfg.h'       "

  941. #error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"

  942. #error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"

  943. #error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"

  944. #error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"

  945. #endif

  946. 

  947. #endif

  948. 

  949. 

  950. 

  951. #ifndef  CPU_CFG_INT_DIS_MEAS_EN

  952. #if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */

  953. #error  "CPU_CFG_INT_DIS_MEAS_EN               not #define'd in 'cpu_cfg.h'"

  954. #endif

  955. 

  956. #else

  957. 

  958. #ifndef  CPU_CFG_INT_DIS_MEAS_OVRHD_NBR

  959. #error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR        not #define'd in 'cpu_cfg.h' "

  960. #error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"

  961. #error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"

  962. 

  963. #elif   (DEF_CHK_VAL(CPU_CFG_INT_DIS_MEAS_OVRHD_NBR, \

  964.                      CPU_TIME_MEAS_NBR_MIN,          \

  965.                      CPU_TIME_MEAS_NBR_MAX) != DEF_OK)

  966. #error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR  illegally #define'd in 'cpu_cfg.h' "

  967. #error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"

  968. #error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"

  969. 

  970. #endif

  971. 

  972. #endif

  973. 

  974. 

  975. 

  976. 

  977. #ifndef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT

  978. #if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */

  979. #error  "CPU_CFG_LEAD_ZEROS_ASM_PRESENT        not #define'd in 'cpu.h'/'cpu_cfg.h'"

  980. #endif

  981. #endif

  982. 

  983. 

  984. #ifndef  CPU_CFG_TRAIL_ZEROS_ASM_PRESENT

  985. #if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */

  986. #error  "CPU_CFG_TRAIL_ZEROS_ASM_PRESENT       not #define'd in 'cpu.h'/'cpu_cfg.h'"

  987. #endif

  988. #endif

  989. 

  990. 

  991. /*

  992. *********************************************************************************************************

  993. *                                    CPU PORT CONFIGURATION ERRORS

  994. *********************************************************************************************************

  995. */

  996. 

  997. #ifndef  CPU_CFG_ADDR_SIZE

  998. #error  "CPU_CFG_ADDR_SIZE      not #define'd in 'cpu.h'"

  999. #endif

  1000. 

  1001. #ifndef  CPU_CFG_DATA_SIZE

  1002. #error  "CPU_CFG_DATA_SIZE      not #define'd in 'cpu.h'"

  1003. #endif

  1004. 

  1005. #ifndef  CPU_CFG_DATA_SIZE_MAX

  1006. #error  "CPU_CFG_DATA_SIZE_MAX  not #define'd in 'cpu.h'"

  1007. #endif

  1008. 

  1009. 

  1010. /*

  1011. *********************************************************************************************************

  1012. *                                    LIBRARY CONFIGURATION ERRORS

  1013. *********************************************************************************************************

  1014. */

  1015. 

  1016.                                                                 /* See 'cpu_core.h  Note #1a'.                          */

  1017. #if     (LIB_VERSION < 13500u)

  1018. #error  "LIB_VERSION  [SHOULD be >= V1.35.00]"

  1019. #endif

  1020. 

  1021. 

  1022. /*

  1023. *********************************************************************************************************

  1024. *                                             MODULE END

  1025. *

  1026. * Note(s) : (1) See 'cpu_core.h  MODULE'.

  1027. *********************************************************************************************************

  1028. */

  1029. 

  1030. #endif                                                          /* End of CPU core module include.                      */