Write performance improvements.
[SCSI2SD-V6.git] / software / SCSI2SD / SCSI2SD.cydsn / Generated_Source / PSoC5 / CyLib.c
1 /*******************************************************************************\r
2 * File Name: CyLib.c\r
3 * Version 4.0\r
4 *\r
5 *  Description:\r
6 *   Provides system API for the clocking, interrupts and watchdog timer.\r
7 *\r
8 *  Note:\r
9 *   Documentation of the API's in this file is located in the\r
10 *   System Reference Guide provided with PSoC Creator.\r
11 *\r
12 ********************************************************************************\r
13 * Copyright 2008-2013, Cypress Semiconductor Corporation.  All rights reserved.\r
14 * You may use this file only in accordance with the license, terms, conditions,\r
15 * disclaimers, and limitations in the end user license agreement accompanying\r
16 * the software package with which this file was provided.\r
17 *******************************************************************************/\r
18 \r
19 #include "CyLib.h"\r
20 \r
21 \r
22 /*******************************************************************************\r
23 * The CyResetStatus variable is used to obtain value of RESET_SR0 register after\r
24 * a device reset. It is set from initialize_psoc() at the early initialization\r
25 * stage. In case of IAR EW IDE, initialize_psoc() is executed before the data\r
26 * sections are initialized. To avoid zeroing, CyResetStatus should be placed\r
27 * to the .noinit section.\r
28 *******************************************************************************/\r
29 CY_NOINIT uint8 CYXDATA CyResetStatus;\r
30 \r
31 \r
32 /* Variable Vdda */\r
33 #if(CYDEV_VARIABLE_VDDA == 1)\r
34 \r
35     uint8 CyScPumpEnabled = (uint8)(CYDEV_VDDA_MV < 2700);\r
36 \r
37 #endif  /* (CYDEV_VARIABLE_VDDA == 1) */\r
38 \r
39 \r
40 /* Do not use these definitions directly in your application */\r
41 uint32 cydelay_freq_hz  = BCLK__BUS_CLK__HZ;\r
42 uint32 cydelay_freq_khz = (BCLK__BUS_CLK__HZ + 999u) / 1000u;\r
43 uint8  cydelay_freq_mhz = (uint8)((BCLK__BUS_CLK__HZ + 999999u) / 1000000u);\r
44 uint32 cydelay_32k_ms   = 32768u * ((BCLK__BUS_CLK__HZ + 999u) / 1000u);\r
45 \r
46 \r
47 /* Function Prototypes */\r
48 static uint8 CyUSB_PowerOnCheck(void)  ;\r
49 static void CyIMO_SetTrimValue(uint8 freq) ;\r
50 static void CyBusClk_Internal_SetDivider(uint16 divider);\r
51 \r
52 \r
53 /*******************************************************************************\r
54 * Function Name: CyPLL_OUT_Start\r
55 ********************************************************************************\r
56 *\r
57 * Summary:\r
58 *   Enables the PLL.  Optionally waits for it to become stable.\r
59 *   Waits at least 250 us or until it is detected that the PLL is stable.\r
60 *\r
61 * Parameters:\r
62 *   wait:\r
63 *    0: Return immediately after configuration\r
64 *    1: Wait for PLL lock or timeout.\r
65 *\r
66 * Return:\r
67 *   Status\r
68 *    CYRET_SUCCESS - Completed successfully\r
69 *    CYRET_TIMEOUT - Timeout occurred without detecting a stable clock.\r
70 *     If the input source of the clock is jittery, then the lock indication\r
71 *     may not occur.  However, after the timeout has expired the generated PLL\r
72 *     clock can still be used.\r
73 *\r
74 * Side Effects:\r
75 *  If wait is enabled: This function wses the Fast Time Wheel to time the wait.\r
76 *  Any other use of the Fast Time Wheel will be stopped during the period of\r
77 *  this function and then restored. This function also uses the 100 KHz ILO.\r
78 *  If not enabled, this function will enable the 100 KHz ILO for the period of\r
79 *  this function.\r
80 *\r
81 *  No changes to the setup of the ILO, Fast Time Wheel, Central Time Wheel or\r
82 *  Once Per Second interrupt may be made by interrupt routines during the period\r
83 *  of this function execution. The current operation of the ILO, Central Time\r
84 *  Wheel and Once Per Second interrupt are maintained during the operation of\r
85 *  this function provided the reading of the Power Manager Interrupt Status\r
86 *  Register is only done using the CyPmReadStatus() function.\r
87 *\r
88 *******************************************************************************/\r
89 cystatus CyPLL_OUT_Start(uint8 wait) \r
90 {\r
91     cystatus status = CYRET_SUCCESS;\r
92 \r
93     uint8 iloEnableState;\r
94     uint8 pmTwCfg0State;\r
95     uint8 pmTwCfg2State;\r
96 \r
97 \r
98     /* Enables the PLL circuit  */\r
99     CY_CLK_PLL_CFG0_REG |= CY_CLK_PLL_ENABLE;\r
100 \r
101     if(wait != 0u)\r
102     {\r
103         /* Save 100 KHz ILO, FTW interval, enable and interrupt enable */\r
104         iloEnableState = CY_LIB_SLOWCLK_ILO_CR0_REG & CY_LIB_SLOWCLK_ILO_CR0_EN_100KHZ;\r
105         pmTwCfg0State = CY_LIB_PM_TW_CFG0_REG;\r
106         pmTwCfg2State = CY_LIB_PM_TW_CFG2_REG;\r
107 \r
108         CyPmFtwSetInterval(CY_CLK_PLL_FTW_INTERVAL);\r
109 \r
110         status = CYRET_TIMEOUT;\r
111 \r
112         while(0u == (CY_PM_FTW_INT & CyPmReadStatus(CY_PM_FTW_INT)))\r
113         {\r
114             /* Wait for the interrupt status */\r
115             if(0u != (CY_CLK_PLL_SR_REG & CY_CLK_PLL_LOCK_STATUS))\r
116             {\r
117                 if(0u != (CY_CLK_PLL_SR_REG & CY_CLK_PLL_LOCK_STATUS))\r
118                 {\r
119                     status = CYRET_SUCCESS;\r
120                     break;\r
121                 }\r
122             }\r
123         }\r
124 \r
125         /* Restore 100 KHz ILO, FTW interval, enable and interrupt enable */\r
126         if(0u == iloEnableState)\r
127         {\r
128             CyILO_Stop100K();\r
129         }\r
130 \r
131         CY_LIB_PM_TW_CFG0_REG = pmTwCfg0State;\r
132         CY_LIB_PM_TW_CFG2_REG = pmTwCfg2State;\r
133     }\r
134 \r
135     return(status);\r
136 }\r
137 \r
138 \r
139 /*******************************************************************************\r
140 * Function Name: CyPLL_OUT_Stop\r
141 ********************************************************************************\r
142 *\r
143 * Summary:\r
144 *  Disables the PLL.\r
145 *\r
146 * Parameters:\r
147 *  None\r
148 *\r
149 * Return:\r
150 *  None\r
151 *\r
152 *******************************************************************************/\r
153 void CyPLL_OUT_Stop(void) \r
154 {\r
155     CY_CLK_PLL_CFG0_REG &= ((uint8)(~CY_CLK_PLL_ENABLE));\r
156 }\r
157 \r
158 \r
159 /*******************************************************************************\r
160 * Function Name: CyPLL_OUT_SetPQ\r
161 ********************************************************************************\r
162 *\r
163 * Summary:\r
164 *  Sets the P and Q dividers and the charge pump current.\r
165 *  The Frequency Out will be P/Q * Frequency In.\r
166 *  The PLL must be disabled before calling this function.\r
167 *\r
168 * Parameters:\r
169 *  uint8 pDiv:\r
170 *   Valid range [8 - 255].\r
171 *\r
172 *  uint8 qDiv:\r
173 *   Valid range [1 - 16]. Input Frequency / Q must be in range of 1 to 3 MHz.\r
174 \r
175 *  uint8 current:\r
176 *   Valid range [1 - 7]. Charge pump current in uA. Refer to the device TRM and\r
177 *   datasheet for more information.\r
178 *\r
179 * Return:\r
180 *  None\r
181 *\r
182 * Side Effects:\r
183 *  If as result of this function execution the CPU clock frequency is increased\r
184 *  then the number of clock cycles the cache will wait before it samples data\r
185 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
186 *  with appropriate parameter. It can be optionally called if CPU clock\r
187 *  frequency is lowered in order to improve CPU performance.\r
188 *  See CyFlash_SetWaitCycles() description for more information.\r
189 *\r
190 *******************************************************************************/\r
191 void CyPLL_OUT_SetPQ(uint8 pDiv, uint8 qDiv, uint8 current) \r
192 {\r
193     /* Halt CPU in debug mode if PLL is enabled */\r
194     CYASSERT(0u == (CY_CLK_PLL_CFG0_REG & CY_CLK_PLL_ENABLE));\r
195 \r
196     if((pDiv    >= CY_CLK_PLL_MIN_P_VALUE  ) &&\r
197        (qDiv    <= CY_CLK_PLL_MAX_Q_VALUE  ) && (qDiv    >= CY_CLK_PLL_MIN_Q_VALUE  ) &&\r
198        (current >= CY_CLK_PLL_MIN_CUR_VALUE) && (current <= CY_CLK_PLL_MAX_CUR_VALUE))\r
199     {\r
200         /* Set new values */\r
201         CY_CLK_PLL_P_REG = pDiv;\r
202         CY_CLK_PLL_Q_REG = ((uint8)(qDiv - 1u));\r
203         CY_CLK_PLL_CFG1_REG = (CY_CLK_PLL_CFG1_REG & CY_CLK_PLL_CURRENT_MASK) |\r
204                                 ((uint8)(((uint8)(current - 1u)) << CY_CLK_PLL_CURRENT_POSITION));\r
205     }\r
206     else\r
207     {\r
208         /***********************************************************************\r
209         * Halt CPU in debug mode if:\r
210         * - P divider is less than required\r
211         * - Q divider is out of range\r
212         * - pump current is out of range\r
213         ***********************************************************************/\r
214         CYASSERT(0u != 0u);\r
215     }\r
216 \r
217 }\r
218 \r
219 \r
220 /*******************************************************************************\r
221 * Function Name: CyPLL_OUT_SetSource\r
222 ********************************************************************************\r
223 *\r
224 * Summary:\r
225 *  Sets the input clock source to the PLL. The PLL must be disabled before\r
226 *  calling this function.\r
227 *\r
228 * Parameters:\r
229 *   source: One of the three available PLL clock sources\r
230 *    CY_PLL_SOURCE_IMO  :   IMO\r
231 *    CY_PLL_SOURCE_XTAL :   MHz Crystal\r
232 *    CY_PLL_SOURCE_DSI  :   DSI\r
233 *\r
234 * Return:\r
235 *  None\r
236 *\r
237 * Side Effects:\r
238 *  If as result of this function execution the CPU clock frequency is increased\r
239 *  then the number of clock cycles the cache will wait before it samples data\r
240 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
241 *  with appropriate parameter. It can be optionally called if CPU clock\r
242 *  frequency is lowered in order to improve CPU performance.\r
243 *  See CyFlash_SetWaitCycles() description for more information.\r
244 *\r
245 *******************************************************************************/\r
246 void CyPLL_OUT_SetSource(uint8 source) \r
247 {\r
248     /* Halt CPU in debug mode if PLL is enabled */\r
249     CYASSERT(0u == (CY_CLK_PLL_CFG0_REG & CY_CLK_PLL_ENABLE));\r
250 \r
251     switch(source)\r
252     {\r
253         case CY_PLL_SOURCE_IMO:\r
254         case CY_PLL_SOURCE_XTAL:\r
255         case CY_PLL_SOURCE_DSI:\r
256             CY_LIB_CLKDIST_CR_REG = ((CY_LIB_CLKDIST_CR_REG & CY_LIB_CLKDIST_CR_PLL_SCR_MASK) | source);\r
257         break;\r
258 \r
259         default:\r
260             CYASSERT(0u != 0u);\r
261         break;\r
262     }\r
263 }\r
264 \r
265 \r
266 /*******************************************************************************\r
267 * Function Name: CyIMO_Start\r
268 ********************************************************************************\r
269 *\r
270 * Summary:\r
271 *  Enables the IMO. Optionally waits at least 6 us for it to settle.\r
272 *\r
273 * Parameters:\r
274 *  uint8 wait:\r
275 *   0: Return immediately after configuration\r
276 *   1: Wait for at least 6 us for the IMO to settle.\r
277 *\r
278 * Return:\r
279 *  None\r
280 *\r
281 * Side Effects:\r
282 *  If wait is enabled: This function wses the Fast Time Wheel to time the wait.\r
283 *  Any other use of the Fast Time Wheel will be stopped during the period of\r
284 *  this function and then restored. This function also uses the 100 KHz ILO.\r
285 *  If not enabled, this function will enable the 100 KHz ILO for the period of\r
286 *  this function.\r
287 *\r
288 *  No changes to the setup of the ILO, Fast Time Wheel, Central Time Wheel or\r
289 *  Once Per Second interrupt may be made by interrupt routines during the period\r
290 *  of this function execution. The current operation of the ILO, Central Time\r
291 *  Wheel and Once Per Second interrupt are maintained during the operation of\r
292 *  this function provided the reading of the Power Manager Interrupt Status\r
293 *  Register is only done using the CyPmReadStatus() function.\r
294 *\r
295 *******************************************************************************/\r
296 void CyIMO_Start(uint8 wait) \r
297 {\r
298     uint8 pmFtwCfg2Reg;\r
299     uint8 pmFtwCfg0Reg;\r
300     uint8 ilo100KhzEnable;\r
301 \r
302 \r
303     CY_LIB_PM_ACT_CFG0_REG  |= CY_LIB_PM_ACT_CFG0_IMO_EN;\r
304     CY_LIB_PM_STBY_CFG0_REG |= CY_LIB_PM_STBY_CFG0_IMO_EN;\r
305 \r
306     if(0u != wait)\r
307     {\r
308         /* Need to turn on the 100KHz ILO if it happens to not already be running.*/\r
309         ilo100KhzEnable = CY_LIB_SLOWCLK_ILO_CR0_REG & CY_LIB_SLOWCLK_ILO_CR0_EN_100KHZ;\r
310         pmFtwCfg0Reg = CY_LIB_PM_TW_CFG0_REG;\r
311         pmFtwCfg2Reg = CY_LIB_PM_TW_CFG2_REG;\r
312 \r
313         CyPmFtwSetInterval(CY_LIB_CLK_IMO_FTW_TIMEOUT);\r
314 \r
315         while (0u == (CY_PM_FTW_INT & CyPmReadStatus(CY_PM_FTW_INT)))\r
316         {\r
317             /* Wait for the interrupt status */\r
318         }\r
319 \r
320         if(0u == ilo100KhzEnable)\r
321         {\r
322             CyILO_Stop100K();\r
323         }\r
324 \r
325         CY_LIB_PM_TW_CFG0_REG = pmFtwCfg0Reg;\r
326         CY_LIB_PM_TW_CFG2_REG = pmFtwCfg2Reg;\r
327     }\r
328 }\r
329 \r
330 \r
331 /*******************************************************************************\r
332 * Function Name: CyIMO_Stop\r
333 ********************************************************************************\r
334 *\r
335 * Summary:\r
336 *   Disables the IMO.\r
337 *\r
338 * Parameters:\r
339 *  None\r
340 *\r
341 * Return:\r
342 *  None\r
343 *\r
344 *******************************************************************************/\r
345 void CyIMO_Stop(void) \r
346 {\r
347     CY_LIB_PM_ACT_CFG0_REG  &= ((uint8) (~CY_LIB_PM_ACT_CFG0_IMO_EN));\r
348     CY_LIB_PM_STBY_CFG0_REG &= ((uint8) (~CY_LIB_PM_STBY_CFG0_IMO_EN));\r
349 }\r
350 \r
351 \r
352 /*******************************************************************************\r
353 * Function Name: CyUSB_PowerOnCheck\r
354 ********************************************************************************\r
355 *\r
356 * Summary:\r
357 *  Returns the USB power status value. A private function to cy_boot.\r
358 *\r
359 * Parameters:\r
360 *   None\r
361 *\r
362 * Return:\r
363 *   uint8: one if the USB is enabled, 0 if not enabled.\r
364 *\r
365 *******************************************************************************/\r
366 static uint8 CyUSB_PowerOnCheck(void)  \r
367 {\r
368     uint8 poweredOn = 0u;\r
369 \r
370     /* Check whether device is in Active or AltActiv and if USB is powered on */\r
371     if((((CY_PM_MODE_CSR_REG & CY_PM_MODE_CSR_MASK) == CY_PM_MODE_CSR_ACTIVE ) &&\r
372        (0u != (CY_LIB_PM_ACT_CFG5_REG & CY_ACT_USB_ENABLED     )))  ||\r
373        (((CY_PM_MODE_CSR_REG & CY_PM_MODE_CSR_MASK) == CY_PM_MODE_CSR_ALT_ACT) &&\r
374        (0u != (CY_LIB_PM_STBY_CFG5_REG & CY_ALT_ACT_USB_ENABLED))))\r
375     {\r
376         poweredOn = 1u;\r
377     }\r
378 \r
379     return (poweredOn);\r
380 }\r
381 \r
382 \r
383 /*******************************************************************************\r
384 * Function Name: CyIMO_SetTrimValue\r
385 ********************************************************************************\r
386 *\r
387 * Summary:\r
388 *  Sets the IMO factory trim values.\r
389 *\r
390 * Parameters:\r
391 *  uint8 freq - frequency for which trims must be set\r
392 *\r
393 * Return:\r
394 *  None\r
395 *\r
396 *******************************************************************************/\r
397 static void CyIMO_SetTrimValue(uint8 freq) \r
398 {\r
399     uint8 usbPowerOn = CyUSB_PowerOnCheck();\r
400 \r
401     /* If USB is powered */\r
402     if(usbPowerOn == 1u)\r
403     {\r
404         /* Unlock USB write */\r
405         CY_LIB_USB_CR1_REG &= ((uint8)(~CY_LIB_USB_CLK_EN));\r
406     }\r
407     switch(freq)\r
408     {\r
409     case CY_IMO_FREQ_3MHZ:\r
410         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_3MHZ_PTR);\r
411         break;\r
412 \r
413     case CY_IMO_FREQ_6MHZ:\r
414         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_6MHZ_PTR);\r
415         break;\r
416 \r
417     case CY_IMO_FREQ_12MHZ:\r
418         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_12MHZ_PTR);\r
419         break;\r
420 \r
421     case CY_IMO_FREQ_24MHZ:\r
422         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_24MHZ_PTR);\r
423         break;\r
424 \r
425     case CY_IMO_FREQ_48MHZ:\r
426         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_TR1_PTR);\r
427         break;\r
428 \r
429     case CY_IMO_FREQ_62MHZ:\r
430         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_67MHZ_PTR);\r
431         break;\r
432 \r
433 #if(CY_PSOC5)\r
434     case CY_IMO_FREQ_74MHZ:\r
435         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_80MHZ_PTR);\r
436         break;\r
437 #endif  /* (CY_PSOC5) */\r
438 \r
439     case CY_IMO_FREQ_USB:\r
440         CY_LIB_IMO_TR1_REG = CY_GET_XTND_REG8(CY_LIB_TRIM_IMO_USB_PTR);\r
441 \r
442         /* If USB is powered */\r
443         if(usbPowerOn == 1u)\r
444         {\r
445             /* Lock the USB Oscillator */\r
446             CY_LIB_USB_CR1_REG |= CY_LIB_USB_CLK_EN;\r
447         }\r
448         break;\r
449 \r
450     default:\r
451             CYASSERT(0u != 0u);\r
452         break;\r
453     }\r
454 \r
455 }\r
456 \r
457 \r
458 /*******************************************************************************\r
459 * Function Name: CyIMO_SetFreq\r
460 ********************************************************************************\r
461 *\r
462 * Summary:\r
463 *  Sets the frequency of the IMO. Changes may be made while the IMO is running.\r
464 *\r
465 * Parameters:\r
466 *  freq: Frequency of IMO operation\r
467 *       CY_IMO_FREQ_3MHZ  to set  3   MHz\r
468 *       CY_IMO_FREQ_6MHZ  to set  6   MHz\r
469 *       CY_IMO_FREQ_12MHZ to set 12   MHz\r
470 *       CY_IMO_FREQ_24MHZ to set 24   MHz\r
471 *       CY_IMO_FREQ_48MHZ to set 48   MHz\r
472 *       CY_IMO_FREQ_62MHZ to set 62.6 MHz\r
473 *       CY_IMO_FREQ_74MHZ to set 74.7 MHz (not applicable for PSoC 3)\r
474 *       CY_IMO_FREQ_USB   to set 24   MHz (Trimmed for USB operation)\r
475 *\r
476 * Return:\r
477 *  None\r
478 *\r
479 * Side Effects:\r
480 *  If as result of this function execution the CPU clock frequency is increased\r
481 *  then the number of clock cycles the cache will wait before it samples data\r
482 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
483 *  with appropriate parameter. It can be optionally called if CPU clock\r
484 *  frequency is lowered in order to improve CPU performance.\r
485 *  See CyFlash_SetWaitCycles() description for more information.\r
486 *\r
487 *  When the USB setting is chosen, the USB clock locking circuit is enabled.\r
488 *  Otherwise this circuit is disabled. The USB block must be powered before\r
489 *  selecting the USB setting.\r
490 *\r
491 *******************************************************************************/\r
492 void CyIMO_SetFreq(uint8 freq) \r
493 {\r
494     uint8 currentFreq;\r
495     uint8 nextFreq;\r
496 \r
497     /***************************************************************************\r
498     * When changing the IMO frequency the Trim values must also be set\r
499     * accordingly.This requires reading the current frequency. If the new\r
500     * frequency is faster, then set the new trim and then change the frequency,\r
501     * otherwise change the frequency and then set the new trim values.\r
502     ***************************************************************************/\r
503 \r
504     currentFreq = CY_LIB_FASTCLK_IMO_CR_REG & ((uint8)(~CY_LIB_FASTCLK_IMO_CR_RANGE_MASK));\r
505 \r
506     /* Check if the requested frequency is USB. */\r
507     nextFreq = (freq == CY_IMO_FREQ_USB) ? CY_IMO_FREQ_24MHZ : freq;\r
508 \r
509     switch (currentFreq)\r
510     {\r
511     case 0u:\r
512         currentFreq = CY_IMO_FREQ_12MHZ;\r
513         break;\r
514 \r
515     case 1u:\r
516         currentFreq = CY_IMO_FREQ_6MHZ;\r
517         break;\r
518 \r
519     case 2u:\r
520         currentFreq = CY_IMO_FREQ_24MHZ;\r
521         break;\r
522 \r
523     case 3u:\r
524         currentFreq = CY_IMO_FREQ_3MHZ;\r
525         break;\r
526 \r
527     case 4u:\r
528         currentFreq = CY_IMO_FREQ_48MHZ;\r
529         break;\r
530 \r
531     case 5u:\r
532         currentFreq = CY_IMO_FREQ_62MHZ;\r
533         break;\r
534 \r
535 #if(CY_PSOC5)\r
536     case 6u:\r
537         currentFreq = CY_IMO_FREQ_74MHZ;\r
538         break;\r
539 #endif  /* (CY_PSOC5) */\r
540 \r
541     default:\r
542         CYASSERT(0u != 0u);\r
543         break;\r
544     }\r
545 \r
546     if (nextFreq >= currentFreq)\r
547     {\r
548         /* Set the new trim first */\r
549         CyIMO_SetTrimValue(freq);\r
550     }\r
551 \r
552     /* Set the usbclk_on bit when using CY_IMO_FREQ_USB, if not clear it */\r
553     switch(freq)\r
554     {\r
555     case CY_IMO_FREQ_3MHZ:\r
556         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
557             CY_LIB_IMO_3MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
558         break;\r
559 \r
560     case CY_IMO_FREQ_6MHZ:\r
561         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
562             CY_LIB_IMO_6MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
563         break;\r
564 \r
565     case CY_IMO_FREQ_12MHZ:\r
566         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
567             CY_LIB_IMO_12MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
568         break;\r
569 \r
570     case CY_IMO_FREQ_24MHZ:\r
571         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
572             CY_LIB_IMO_24MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
573         break;\r
574 \r
575     case CY_IMO_FREQ_48MHZ:\r
576         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
577             CY_LIB_IMO_48MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
578         break;\r
579 \r
580     case CY_IMO_FREQ_62MHZ:\r
581         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
582             CY_LIB_IMO_62MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
583         break;\r
584 \r
585 #if(CY_PSOC5)\r
586     case CY_IMO_FREQ_74MHZ:\r
587         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
588             CY_LIB_IMO_74MHZ_VALUE) & ((uint8)(~CY_LIB_IMO_USBCLK_ON_SET));\r
589         break;\r
590 #endif  /* (CY_PSOC5) */\r
591 \r
592     case CY_IMO_FREQ_USB:\r
593         CY_LIB_FASTCLK_IMO_CR_REG = ((CY_LIB_FASTCLK_IMO_CR_REG & CY_LIB_FASTCLK_IMO_CR_RANGE_MASK) |\r
594             CY_LIB_IMO_24MHZ_VALUE) | CY_LIB_IMO_USBCLK_ON_SET;\r
595         break;\r
596 \r
597     default:\r
598         CYASSERT(0u != 0u);\r
599         break;\r
600     }\r
601 \r
602     /* Turn on the IMO Doubler, if switching to CY_IMO_FREQ_USB */\r
603     if (freq == CY_IMO_FREQ_USB)\r
604     {\r
605         CyIMO_EnableDoubler();\r
606     }\r
607     else\r
608     {\r
609         CyIMO_DisableDoubler();\r
610     }\r
611 \r
612     if (nextFreq < currentFreq)\r
613     {\r
614         /* Set the new trim after setting the frequency */\r
615         CyIMO_SetTrimValue(freq);\r
616     }\r
617 }\r
618 \r
619 \r
620 /*******************************************************************************\r
621 * Function Name: CyIMO_SetSource\r
622 ********************************************************************************\r
623 *\r
624 * Summary:\r
625 *  Sets the source of the clock output from the IMO block.\r
626 *\r
627 *  The output from the IMO is by default the IMO itself. Optionally the MHz\r
628 *  Crystal or a DSI input can be the source of the IMO output instead.\r
629 *\r
630 * Parameters:\r
631 *   source: CY_IMO_SOURCE_DSI to set the DSI as source.\r
632 *           CY_IMO_SOURCE_XTAL to set the MHz as source.\r
633 *           CY_IMO_SOURCE_IMO to set the IMO itself.\r
634 *\r
635 * Return:\r
636 *  None\r
637 *\r
638 * Side Effects:\r
639 *  If as result of this function execution the CPU clock frequency is increased\r
640 *  then the number of clock cycles the cache will wait before it samples data\r
641 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
642 *  with appropriate parameter. It can be optionally called if CPU clock\r
643 *  frequency is lowered in order to improve CPU performance.\r
644 *  See CyFlash_SetWaitCycles() description for more information.\r
645 *\r
646 *******************************************************************************/\r
647 void CyIMO_SetSource(uint8 source) \r
648 {\r
649     switch(source)\r
650     {\r
651     case CY_IMO_SOURCE_DSI:\r
652         CY_LIB_CLKDIST_CR_REG     &= ((uint8)(~CY_LIB_CLKDIST_CR_IMO2X));\r
653         CY_LIB_FASTCLK_IMO_CR_REG |= CY_LIB_FASTCLK_IMO_IMO;\r
654         break;\r
655 \r
656     case CY_IMO_SOURCE_XTAL:\r
657         CY_LIB_CLKDIST_CR_REG     |= CY_LIB_CLKDIST_CR_IMO2X;\r
658         CY_LIB_FASTCLK_IMO_CR_REG |= CY_LIB_FASTCLK_IMO_IMO;\r
659         break;\r
660 \r
661     case CY_IMO_SOURCE_IMO:\r
662         CY_LIB_FASTCLK_IMO_CR_REG &= ((uint8)(~CY_LIB_FASTCLK_IMO_IMO));\r
663         break;\r
664 \r
665     default:\r
666         /* Incorrect source value */\r
667         CYASSERT(0u != 0u);\r
668         break;\r
669     }\r
670 }\r
671 \r
672 \r
673 /*******************************************************************************\r
674 * Function Name: CyIMO_EnableDoubler\r
675 ********************************************************************************\r
676 *\r
677 * Summary:\r
678 *  Enables the IMO doubler.  The 2x frequency clock is used to convert a 24 MHz\r
679 *  input to a 48 MHz output for use by the USB block.\r
680 *\r
681 * Parameters:\r
682 *  None\r
683 *\r
684 * Return:\r
685 *  None\r
686 *\r
687 *******************************************************************************/\r
688 void CyIMO_EnableDoubler(void) \r
689 {\r
690     /* Set the FASTCLK_IMO_CR_PTR regigster's 4th bit */\r
691     CY_LIB_FASTCLK_IMO_CR_REG |= CY_LIB_FASTCLK_IMO_DOUBLER;\r
692 }\r
693 \r
694 \r
695 /*******************************************************************************\r
696 * Function Name: CyIMO_DisableDoubler\r
697 ********************************************************************************\r
698 *\r
699 * Summary:\r
700 *   Disables the IMO doubler.\r
701 *\r
702 * Parameters:\r
703 *  None\r
704 *\r
705 * Return:\r
706 *  None\r
707 *\r
708 *******************************************************************************/\r
709 void CyIMO_DisableDoubler(void) \r
710 {\r
711     CY_LIB_FASTCLK_IMO_CR_REG &= ((uint8)(~CY_LIB_FASTCLK_IMO_DOUBLER));\r
712 }\r
713 \r
714 \r
715 /*******************************************************************************\r
716 * Function Name: CyMasterClk_SetSource\r
717 ********************************************************************************\r
718 *\r
719 * Summary:\r
720 *  Sets the source of the master clock.\r
721 *\r
722 * Parameters:\r
723 *   source: One of the four available Master clock sources.\r
724 *     CY_MASTER_SOURCE_IMO\r
725 *     CY_MASTER_SOURCE_PLL\r
726 *     CY_MASTER_SOURCE_XTAL\r
727 *     CY_MASTER_SOURCE_DSI\r
728 *\r
729 * Return:\r
730 *  None\r
731 *\r
732 * Side Effects:\r
733 *  The current source and the new source must both be running and stable before\r
734 *  calling this function.\r
735 *\r
736 *  If as result of this function execution the CPU clock frequency is increased\r
737 *  then the number of clock cycles the cache will wait before it samples data\r
738 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
739 *  with appropriate parameter. It can be optionally called if CPU clock\r
740 *  frequency is lowered in order to improve CPU performance.\r
741 *  See CyFlash_SetWaitCycles() description for more information.\r
742 *\r
743 *******************************************************************************/\r
744 void CyMasterClk_SetSource(uint8 source) \r
745 {\r
746     CY_LIB_CLKDIST_MSTR1_REG = (CY_LIB_CLKDIST_MSTR1_REG & MASTER_CLK_SRC_CLEAR) |\r
747                                 (source & ((uint8)(~MASTER_CLK_SRC_CLEAR)));\r
748 }\r
749 \r
750 \r
751 /*******************************************************************************\r
752 * Function Name: CyMasterClk_SetDivider\r
753 ********************************************************************************\r
754 *\r
755 * Summary:\r
756 *  Sets the divider value used to generate Master Clock.\r
757 *\r
758 * Parameters:\r
759 *  uint8 divider:\r
760 *   Valid range [0-255]. The clock will be divided by this value + 1.\r
761 *   For example to divide by 2 this parameter should be set to 1.\r
762 *\r
763 * Return:\r
764 *  None\r
765 *\r
766 * Side Effects:\r
767 *  If as result of this function execution the CPU clock frequency is increased\r
768 *  then the number of clock cycles the cache will wait before it samples data\r
769 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
770 *  with appropriate parameter. It can be optionally called if CPU clock\r
771 *  frequency is lowered in order to improve CPU performance.\r
772 *  See CyFlash_SetWaitCycles() description for more information.\r
773 *\r
774 *  When changing the Master or Bus clock divider value from div-by-n to div-by-1\r
775 *  the first clock cycle output after the div-by-1 can be up to 4 ns shorter\r
776 *  than the final/expected div-by-1 period.\r
777 *\r
778 *******************************************************************************/\r
779 void CyMasterClk_SetDivider(uint8 divider) \r
780 {\r
781     CY_LIB_CLKDIST_MSTR0_REG = divider;\r
782 }\r
783 \r
784 \r
785 /*******************************************************************************\r
786 * Function Name: CyBusClk_Internal_SetDivider\r
787 ********************************************************************************\r
788 *\r
789 * Summary:\r
790 *  Function used by CyBusClk_SetDivider(). For internal use only.\r
791 *\r
792 * Parameters:\r
793 *   divider: Valid range [0-65535].\r
794 *   The clock will be divided by this value + 1.\r
795 *   For example to divide by 2 this parameter should be set to 1.\r
796 *\r
797 * Return:\r
798 *  None\r
799 *\r
800 *******************************************************************************/\r
801 static void CyBusClk_Internal_SetDivider(uint16 divider)\r
802 {\r
803     /* Mask bits to enable shadow loads  */\r
804     CY_LIB_CLKDIST_AMASK_REG &= CY_LIB_CLKDIST_AMASK_MASK;\r
805     CY_LIB_CLKDIST_DMASK_REG  = CY_LIB_CLKDIST_DMASK_MASK;\r
806 \r
807     /* Enable mask bits to enable shadow loads */\r
808     CY_LIB_CLKDIST_BCFG2_REG |= CY_LIB_CLKDIST_BCFG2_MASK;\r
809 \r
810     /* Update Shadow Divider Value Register with the new divider */\r
811     CY_LIB_CLKDIST_WRK_LSB_REG = LO8(divider);\r
812     CY_LIB_CLKDIST_WRK_MSB_REG = HI8(divider);\r
813 \r
814 \r
815     /***************************************************************************\r
816     * Copy shadow value defined in Shadow Divider Value Register\r
817     * (CY_LIB_CLKDIST_WRK_LSB_REG and CY_LIB_CLKDIST_WRK_MSB_REG) to all\r
818     * dividers selected in Analog and Digital Clock Mask Registers\r
819     * (CY_LIB_CLKDIST_AMASK_REG and CY_LIB_CLKDIST_DMASK_REG).\r
820     ***************************************************************************/\r
821     CY_LIB_CLKDIST_LD_REG |= CY_LIB_CLKDIST_LD_LOAD;\r
822 }\r
823 \r
824 \r
825 /*******************************************************************************\r
826 * Function Name: CyBusClk_SetDivider\r
827 ********************************************************************************\r
828 *\r
829 * Summary:\r
830 *  Sets the divider value used to generate Bus Clock.\r
831 *\r
832 * Parameters:\r
833 *  divider: Valid range [0-65535]. The clock will be divided by this value + 1.\r
834 *  For example to divide by 2 this parameter should be set to 1.\r
835 *\r
836 * Return:\r
837 *  None\r
838 *\r
839 * Side Effects:\r
840 *  If as result of this function execution the CPU clock frequency is increased\r
841 *  then the number of clock cycles the cache will wait before it samples data\r
842 *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
843 *  with appropriate parameter. It can be optionally called if CPU clock\r
844 *  frequency is lowered in order to improve CPU performance.\r
845 *  See CyFlash_SetWaitCycles() description for more information.\r
846 *\r
847 *******************************************************************************/\r
848 void CyBusClk_SetDivider(uint16 divider) \r
849 {\r
850     uint8  masterClkDiv;\r
851     uint16 busClkDiv;\r
852     uint8 interruptState;\r
853 \r
854     interruptState = CyEnterCriticalSection();\r
855 \r
856     /* Work around to set the bus clock divider value */\r
857     busClkDiv = (uint16)((uint16)CY_LIB_CLKDIST_BCFG_MSB_REG << 8u);\r
858     busClkDiv |= CY_LIB_CLKDIST_BCFG_LSB_REG;\r
859 \r
860     if ((divider == 0u) || (busClkDiv == 0u))\r
861     {\r
862         /* Save away the master clock divider value */\r
863         masterClkDiv = CY_LIB_CLKDIST_MSTR0_REG;\r
864 \r
865         if (masterClkDiv < CY_LIB_CLKDIST_MASTERCLK_DIV)\r
866         {\r
867             /* Set master clock divider to 7 */\r
868             CyMasterClk_SetDivider(CY_LIB_CLKDIST_MASTERCLK_DIV);\r
869         }\r
870 \r
871         if (divider == 0u)\r
872         {\r
873             /* Set the SSS bit and the divider register desired value */\r
874             CY_LIB_CLKDIST_BCFG2_REG |= CY_LIB_CLKDIST_BCFG2_SSS;\r
875             CyBusClk_Internal_SetDivider(divider);\r
876         }\r
877         else\r
878         {\r
879             CyBusClk_Internal_SetDivider(divider);\r
880             CY_LIB_CLKDIST_BCFG2_REG &= ((uint8)(~CY_LIB_CLKDIST_BCFG2_SSS));\r
881         }\r
882 \r
883         /* Restore the master clock */\r
884         CyMasterClk_SetDivider(masterClkDiv);\r
885     }\r
886     else\r
887     {\r
888         CyBusClk_Internal_SetDivider(divider);\r
889     }\r
890 \r
891     CyExitCriticalSection(interruptState);\r
892 }\r
893 \r
894 \r
895 #if(CY_PSOC3)\r
896 \r
897     /*******************************************************************************\r
898     * Function Name: CyCpuClk_SetDivider\r
899     ********************************************************************************\r
900     *\r
901     * Summary:\r
902     *  Sets the divider value used to generate the CPU Clock. Only applicable for\r
903     *  PSoC 3 parts.\r
904     *\r
905     * Parameters:\r
906     *  divider: Valid range [0-15]. The clock will be divided by this value + 1.\r
907     *  For example to divide by 2 this parameter should be set to 1.\r
908     *\r
909     * Return:\r
910     *  None\r
911     *\r
912     * Side Effects:\r
913     *  If as result of this function execution the CPU clock frequency is increased\r
914     *  then the number of clock cycles the cache will wait before it samples data\r
915     *  coming back from Flash must be adjusted by calling CyFlash_SetWaitCycles()\r
916     *  with appropriate parameter. It can be optionally called if CPU clock\r
917     *  frequency is lowered in order to improve CPU performance.\r
918     *  See CyFlash_SetWaitCycles() description for more information.\r
919     *\r
920     *******************************************************************************/\r
921     void CyCpuClk_SetDivider(uint8 divider) \r
922     {\r
923             CY_LIB_CLKDIST_MSTR1_REG = (CY_LIB_CLKDIST_MSTR1_REG & CY_LIB_CLKDIST_MSTR1_DIV_MASK) |\r
924                                 ((uint8)(divider << CY_LIB_CLKDIST_DIV_POSITION));\r
925     }\r
926 \r
927 #endif /* (CY_PSOC3) */\r
928 \r
929 \r
930 /*******************************************************************************\r
931 * Function Name: CyUsbClk_SetSource\r
932 ********************************************************************************\r
933 *\r
934 * Summary:\r
935 *  Sets the source of the USB clock.\r
936 *\r
937 * Parameters:\r
938 *  source: One of the four available USB clock sources\r
939 *    CY_LIB_USB_CLK_IMO2X     - IMO 2x\r
940 *    CY_LIB_USB_CLK_IMO       - IMO\r
941 *    CY_LIB_USB_CLK_PLL       - PLL\r
942 *    CY_LIB_USB_CLK_DSI       - DSI\r
943 *\r
944 * Return:\r
945 *  None\r
946 *\r
947 *******************************************************************************/\r
948 void CyUsbClk_SetSource(uint8 source) \r
949 {\r
950     CY_LIB_CLKDIST_UCFG_REG = (CY_LIB_CLKDIST_UCFG_REG & ((uint8)(~CY_LIB_CLKDIST_UCFG_SRC_SEL_MASK))) |\r
951                         (CY_LIB_CLKDIST_UCFG_SRC_SEL_MASK & source);\r
952 }\r
953 \r
954 \r
955 /*******************************************************************************\r
956 * Function Name: CyILO_Start1K\r
957 ********************************************************************************\r
958 *\r
959 * Summary:\r
960 *  Enables the ILO 1 KHz oscillator.\r
961 *\r
962 *  Note The ILO 1 KHz oscillator is always enabled by default, regardless of the\r
963 *  selection in the Clock Editor. Therefore, this API is only needed if the\r
964 *  oscillator was turned off manually.\r
965 *\r
966 * Parameters:\r
967 *  None\r
968 *\r
969 * Return:\r
970 *  None\r
971 *\r
972 *******************************************************************************/\r
973 void CyILO_Start1K(void) \r
974 {\r
975     /* Set the bit 1 of ILO RS */\r
976     CY_LIB_SLOWCLK_ILO_CR0_REG |= CY_LIB_SLOWCLK_ILO_CR0_EN_1KHZ;\r
977 }\r
978 \r
979 \r
980 /*******************************************************************************\r
981 * Function Name: CyILO_Stop1K\r
982 ********************************************************************************\r
983 *\r
984 * Summary:\r
985 *  Disables the ILO 1 KHz oscillator.\r
986 *\r
987 *  Note The ILO 1 KHz oscillator must be enabled if Sleep or Hibernate low power\r
988 *  mode APIs are expected to be used. For more information, refer to the Power\r
989 *  Management section of this document.\r
990 *\r
991 * Parameters:\r
992 *  None\r
993 *\r
994 * Return:\r
995 *  None\r
996 *\r
997 * Side Effects:\r
998 *  PSoC5: Stopping the ILO 1 kHz could break the active WDT functionality.\r
999 *\r
1000 *******************************************************************************/\r
1001 void CyILO_Stop1K(void) \r
1002 {\r
1003     /* Clear the bit 1 of ILO RS */\r
1004     CY_LIB_SLOWCLK_ILO_CR0_REG &= ((uint8)(~CY_LIB_SLOWCLK_ILO_CR0_EN_1KHZ));\r
1005 }\r
1006 \r
1007 \r
1008 /*******************************************************************************\r
1009 * Function Name: CyILO_Start100K\r
1010 ********************************************************************************\r
1011 *\r
1012 * Summary:\r
1013 *  Enables the ILO 100 KHz oscillator.\r
1014 *\r
1015 * Parameters:\r
1016 *  None\r
1017 *\r
1018 * Return:\r
1019 *  None\r
1020 *\r
1021 *******************************************************************************/\r
1022 void CyILO_Start100K(void) \r
1023 {\r
1024     CY_LIB_SLOWCLK_ILO_CR0_REG |= CY_LIB_SLOWCLK_ILO_CR0_EN_100KHZ;\r
1025 }\r
1026 \r
1027 \r
1028 /*******************************************************************************\r
1029 * Function Name: CyILO_Stop100K\r
1030 ********************************************************************************\r
1031 *\r
1032 * Summary:\r
1033 *  Disables the ILO 100 KHz oscillator.\r
1034 *\r
1035 * Parameters:\r
1036 *  None\r
1037 *\r
1038 * Return:\r
1039 *  None\r
1040 *\r
1041 *******************************************************************************/\r
1042 void CyILO_Stop100K(void) \r
1043 {\r
1044     CY_LIB_SLOWCLK_ILO_CR0_REG &= ((uint8)(~CY_LIB_SLOWCLK_ILO_CR0_EN_100KHZ));\r
1045 }\r
1046 \r
1047 \r
1048 /*******************************************************************************\r
1049 * Function Name: CyILO_Enable33K\r
1050 ********************************************************************************\r
1051 *\r
1052 * Summary:\r
1053 *  Enables the ILO 33 KHz divider.\r
1054 *\r
1055 *  Note that the 33 KHz clock is generated from the 100 KHz oscillator,\r
1056 *  so it must also be running in order to generate the 33 KHz output.\r
1057 *\r
1058 * Parameters:\r
1059 *  None\r
1060 *\r
1061 * Return:\r
1062 *  None\r
1063 *\r
1064 *******************************************************************************/\r
1065 void CyILO_Enable33K(void) \r
1066 {\r
1067     /* Set the bit 5 of ILO RS */\r
1068     CY_LIB_SLOWCLK_ILO_CR0_REG |= CY_LIB_SLOWCLK_ILO_CR0_EN_33KHZ;\r
1069 }\r
1070 \r
1071 \r
1072 /*******************************************************************************\r
1073 * Function Name: CyILO_Disable33K\r
1074 ********************************************************************************\r
1075 *\r
1076 * Summary:\r
1077 *  Disables the ILO 33 KHz divider.\r
1078 *\r
1079 *  Note that the 33 KHz clock is generated from the 100 KHz oscillator, but this\r
1080 *  API does not disable the 100 KHz clock.\r
1081 *\r
1082 * Parameters:\r
1083 *  None\r
1084 *\r
1085 * Return:\r
1086 *  None\r
1087 *\r
1088 *******************************************************************************/\r
1089 void CyILO_Disable33K(void) \r
1090 {\r
1091     CY_LIB_SLOWCLK_ILO_CR0_REG &= ((uint8)(~CY_LIB_SLOWCLK_ILO_CR0_EN_33KHZ));\r
1092 }\r
1093 \r
1094 \r
1095 /*******************************************************************************\r
1096 * Function Name: CyILO_SetSource\r
1097 ********************************************************************************\r
1098 *\r
1099 * Summary:\r
1100 *  Sets the source of the clock output from the ILO block.\r
1101 *\r
1102 * Parameters:\r
1103 *  source: One of the three available ILO output sources\r
1104 *       Value        Define                Source\r
1105 *       0            CY_ILO_SOURCE_100K    ILO 100 KHz\r
1106 *       1            CY_ILO_SOURCE_33K     ILO 33 KHz\r
1107 *       2            CY_ILO_SOURCE_1K      ILO 1 KHz\r
1108 *\r
1109 * Return:\r
1110 *  None\r
1111 *\r
1112 *******************************************************************************/\r
1113 void CyILO_SetSource(uint8 source) \r
1114 {\r
1115     CY_LIB_CLKDIST_CR_REG = (CY_LIB_CLKDIST_CR_REG & CY_ILO_SOURCE_BITS_CLEAR) |\r
1116                     (((uint8) (source << 2u)) & ((uint8)(~CY_ILO_SOURCE_BITS_CLEAR)));\r
1117 }\r
1118 \r
1119 \r
1120 /*******************************************************************************\r
1121 * Function Name: CyILO_SetPowerMode\r
1122 ********************************************************************************\r
1123 *\r
1124 * Summary:\r
1125 *  Sets the power mode used by the ILO during power down. Allows for lower power\r
1126 *  down power usage resulting in a slower startup time.\r
1127 *\r
1128 * Parameters:\r
1129 *  uint8 mode\r
1130 *   CY_ILO_FAST_START - Faster start-up, internal bias left on when powered down\r
1131 *   CY_ILO_SLOW_START - Slower start-up, internal bias off when powered down\r
1132 *\r
1133 * Return:\r
1134 *   Prevous power mode state.\r
1135 *\r
1136 *******************************************************************************/\r
1137 uint8 CyILO_SetPowerMode(uint8 mode) \r
1138 {\r
1139     uint8 state;\r
1140 \r
1141     /* Get current state. */\r
1142     state = CY_LIB_SLOWCLK_ILO_CR0_REG;\r
1143 \r
1144     /* Set the the oscillator power mode. */\r
1145     if(mode != CY_ILO_FAST_START)\r
1146     {\r
1147         CY_LIB_SLOWCLK_ILO_CR0_REG = (state | CY_ILO_CONTROL_PD_MODE);\r
1148     }\r
1149     else\r
1150     {\r
1151         CY_LIB_SLOWCLK_ILO_CR0_REG = (state & ((uint8)(~CY_ILO_CONTROL_PD_MODE)));\r
1152     }\r
1153 \r
1154     /* Return the old mode. */\r
1155     return ((state & CY_ILO_CONTROL_PD_MODE) >> CY_ILO_CONTROL_PD_POSITION);\r
1156 }\r
1157 \r
1158 \r
1159 /*******************************************************************************\r
1160 * Function Name: CyXTAL_32KHZ_Start\r
1161 ********************************************************************************\r
1162 *\r
1163 * Summary:\r
1164 *  Enables the 32 KHz Crystal Oscillator.\r
1165 *\r
1166 * Parameters:\r
1167 *  None\r
1168 *\r
1169 * Return:\r
1170 *  None\r
1171 *\r
1172 *******************************************************************************/\r
1173 void CyXTAL_32KHZ_Start(void) \r
1174 {\r
1175     volatile uint16 i;\r
1176 \r
1177     CY_CLK_XTAL32_TST_REG = CY_CLK_XTAL32_TST_DEFAULT;\r
1178     CY_CLK_XTAL32_TR_REG  = CY_CLK_XTAL32_TR_STARTUP;\r
1179     CY_CLK_XTAL32_CFG_REG = (CY_CLK_XTAL32_CFG_REG & ((uint8)(~CY_CLK_XTAL32_CFG_LP_MASK))) |\r
1180                                 CY_CLK_XTAL32_CFG_LP_DEFAULT;\r
1181 \r
1182     #if(CY_PSOC3)\r
1183         CY_CLK_XTAL32_CR_REG |= CY_CLK_XTAL32_CR_PDBEN;\r
1184     #endif  /* (CY_PSOC3) */\r
1185 \r
1186     /* Enable operation of the 32K Crystal Oscillator */\r
1187     CY_CLK_XTAL32_CR_REG |= CY_CLK_XTAL32_CR_EN;\r
1188 \r
1189     for (i = 1000u; i > 0u; i--)\r
1190     {\r
1191         if(0u != (CyXTAL_32KHZ_ReadStatus() & CY_XTAL32K_ANA_STAT))\r
1192         {\r
1193             /* Ready - switch to the hign power mode */\r
1194             (void) CyXTAL_32KHZ_SetPowerMode(0u);\r
1195 \r
1196             break;\r
1197         }\r
1198         CyDelayUs(1u);\r
1199     }\r
1200 }\r
1201 \r
1202 \r
1203 /*******************************************************************************\r
1204 * Function Name: CyXTAL_32KHZ_Stop\r
1205 ********************************************************************************\r
1206 *\r
1207 * Summary:\r
1208 *  Disables the 32KHz Crystal Oscillator.\r
1209 *\r
1210 * Parameters:\r
1211 *  None\r
1212 *\r
1213 * Return:\r
1214 *  None\r
1215 *\r
1216 *******************************************************************************/\r
1217 void CyXTAL_32KHZ_Stop(void) \r
1218 {\r
1219     CY_CLK_XTAL32_TST_REG  = CY_CLK_XTAL32_TST_DEFAULT;\r
1220     CY_CLK_XTAL32_TR_REG   = CY_CLK_XTAL32_TR_POWERDOWN;\r
1221     CY_CLK_XTAL32_CFG_REG = (CY_CLK_XTAL32_CFG_REG & ((uint8)(~CY_CLK_XTAL32_CFG_LP_MASK))) |\r
1222                              CY_CLK_XTAL32_CFG_LP_DEFAULT;\r
1223     CY_CLK_XTAL32_CR_REG &= ((uint8)(~(CY_CLK_XTAL32_CR_EN | CY_CLK_XTAL32_CR_LPM)));\r
1224 \r
1225     #if(CY_PSOC3)\r
1226         CY_CLK_XTAL32_CR_REG &= ((uint8)(~CY_CLK_XTAL32_CR_PDBEN));\r
1227     #endif  /* (CY_PSOC3) */\r
1228 }\r
1229 \r
1230 \r
1231 /*******************************************************************************\r
1232 * Function Name: CyXTAL_32KHZ_ReadStatus\r
1233 ********************************************************************************\r
1234 *\r
1235 * Summary:\r
1236 *  Returns status of the 32 KHz oscillator.\r
1237 *\r
1238 * Parameters:\r
1239 *  None\r
1240 *\r
1241 * Return:\r
1242 *  Value     Define                    Source\r
1243 *  20        CY_XTAL32K_ANA_STAT       Analog measurement\r
1244 *                                       1: Stable\r
1245 *                                       0: Not stable\r
1246 *\r
1247 *******************************************************************************/\r
1248 uint8 CyXTAL_32KHZ_ReadStatus(void) \r
1249 {\r
1250     return(CY_CLK_XTAL32_CR_REG & CY_XTAL32K_ANA_STAT);\r
1251 }\r
1252 \r
1253 \r
1254 /*******************************************************************************\r
1255 * Function Name: CyXTAL_32KHZ_SetPowerMode\r
1256 ********************************************************************************\r
1257 *\r
1258 * Summary:\r
1259 *  Sets the power mode for the 32 KHz oscillator used during sleep mode.\r
1260 *  Allows for lower power during sleep when there are fewer sources of noise.\r
1261 *  During active mode the oscillator is always run in high power mode.\r
1262 *\r
1263 * Parameters:\r
1264 *  uint8 mode\r
1265 *       0: High power mode\r
1266 *       1: Low power mode during sleep\r
1267 *\r
1268 * Return:\r
1269 *  Previous power mode.\r
1270 *\r
1271 *******************************************************************************/\r
1272 uint8 CyXTAL_32KHZ_SetPowerMode(uint8 mode) \r
1273 {\r
1274     uint8 state = (0u != (CY_CLK_XTAL32_CR_REG & CY_CLK_XTAL32_CR_LPM)) ? 1u : 0u;\r
1275 \r
1276     CY_CLK_XTAL32_TST_REG = CY_CLK_XTAL32_TST_DEFAULT;\r
1277 \r
1278     if(1u == mode)\r
1279     {\r
1280         /* Low power mode during Sleep */\r
1281         CY_CLK_XTAL32_TR_REG  = CY_CLK_XTAL32_TR_LOW_POWER;\r
1282         CyDelayUs(10u);\r
1283         CY_CLK_XTAL32_CFG_REG = (CY_CLK_XTAL32_CFG_REG & ((uint8)(~CY_CLK_XTAL32_CFG_LP_MASK))) |\r
1284                                 CY_CLK_XTAL32_CFG_LP_LOWPOWER;\r
1285         CyDelayUs(20u);\r
1286         CY_CLK_XTAL32_CR_REG |= CY_CLK_XTAL32_CR_LPM;\r
1287     }\r
1288     else\r
1289     {\r
1290         /* High power mode */\r
1291         CY_CLK_XTAL32_TR_REG  = CY_CLK_XTAL32_TR_HIGH_POWER;\r
1292         CyDelayUs(10u);\r
1293         CY_CLK_XTAL32_CFG_REG = (CY_CLK_XTAL32_CFG_REG & ((uint8)(~CY_CLK_XTAL32_CFG_LP_MASK))) |\r
1294                                 CY_CLK_XTAL32_CFG_LP_DEFAULT;\r
1295         CY_CLK_XTAL32_CR_REG &= ((uint8)(~CY_CLK_XTAL32_CR_LPM));\r
1296     }\r
1297 \r
1298     return(state);\r
1299 }\r
1300 \r
1301 \r
1302 /*******************************************************************************\r
1303 * Function Name: CyXTAL_Start\r
1304 ********************************************************************************\r
1305 *\r
1306 * Summary:\r
1307 *  Enables the megahertz crystal.\r
1308 *\r
1309 *  PSoC 3:\r
1310 *  Waits until the XERR bit is low (no error) for a millisecond or until the\r
1311 *  number of milliseconds specified by the wait parameter has expired.\r
1312 *\r
1313 * Parameters:\r
1314 *   wait: Valid range [0-255].\r
1315 *   This is the timeout value in milliseconds.\r
1316 *   The appropriate value is crystal specific.\r
1317 *\r
1318 * Return:\r
1319 *   CYRET_SUCCESS - Completed successfully\r
1320 *   CYRET_TIMEOUT - Timeout occurred without detecting a low value on XERR.\r
1321 *\r
1322 * Side Effects and Restrictions:\r
1323 *  If wait is enabled (non-zero wait). Uses the Fast Timewheel to time the wait.\r
1324 *  Any other use of the Fast Timewheel (FTW) will be stopped during the period\r
1325 *  of this function and then restored.\r
1326 *\r
1327 *  Uses the 100KHz ILO.  If not enabled, this function will enable the 100KHz\r
1328 *  ILO for the period of this function. No changes to the setup of the ILO,\r
1329 *  Fast Timewheel, Central Timewheel or Once Per Second interrupt may be made\r
1330 *  by interrupt routines during the period of this function.\r
1331 *\r
1332 *  The current operation of the ILO, Central Timewheel and Once Per Second\r
1333 *  interrupt are maintained during the operation of this function provided the\r
1334 *  reading of the Power Manager Interrupt Status Register is only done using the\r
1335 *  CyPmReadStatus() function.\r
1336 *\r
1337 *******************************************************************************/\r
1338 cystatus CyXTAL_Start(uint8 wait) \r
1339 {\r
1340     cystatus status = CYRET_SUCCESS;\r
1341     volatile uint8  timeout = wait;\r
1342     volatile uint8 count;\r
1343     uint8 iloEnableState;\r
1344     uint8 pmTwCfg0Tmp;\r
1345     uint8 pmTwCfg2Tmp;\r
1346 \r
1347 \r
1348     /* Enables the MHz crystal oscillator circuit  */\r
1349     CY_CLK_XMHZ_CSR_REG |= CY_CLK_XMHZ_CSR_ENABLE;\r
1350 \r
1351 \r
1352     if(wait > 0u)\r
1353     {\r
1354         /* Save 100 KHz ILO, FTW interval, enable and interrupt enable */\r
1355         iloEnableState = CY_LIB_SLOWCLK_ILO_CR0_REG;\r
1356         pmTwCfg0Tmp = CY_LIB_PM_TW_CFG0_REG;\r
1357         pmTwCfg2Tmp = CY_LIB_PM_TW_CFG2_REG;\r
1358 \r
1359         /* Set 250 us interval */\r
1360         CyPmFtwSetInterval(CY_CLK_XMHZ_FTW_INTERVAL);\r
1361         status = CYRET_TIMEOUT;\r
1362 \r
1363 \r
1364         for( ; timeout > 0u; timeout--)\r
1365         {\r
1366             /* Read XERR bit to clear it */\r
1367             (void) CY_CLK_XMHZ_CSR_REG;\r
1368 \r
1369             /* Wait for a millisecond - 4 x 250 us */\r
1370             for(count = 4u; count > 0u; count--)\r
1371             {\r
1372                 while(0u == (CY_PM_FTW_INT & CyPmReadStatus(CY_PM_FTW_INT)))\r
1373                 {\r
1374                     /* Wait for the FTW interrupt event */\r
1375                 }\r
1376             }\r
1377 \r
1378 \r
1379             /*******************************************************************\r
1380             * High output indicates oscillator failure.\r
1381             * Only can be used after start-up interval (1 ms) is completed.\r
1382             *******************************************************************/\r
1383             if(0u == (CY_CLK_XMHZ_CSR_REG & CY_CLK_XMHZ_CSR_XERR))\r
1384             {\r
1385                 status = CYRET_SUCCESS;\r
1386                 break;\r
1387             }\r
1388         }\r
1389 \r
1390 \r
1391         /* Restore 100 KHz ILO, FTW interval, enable and interrupt enable */\r
1392         if(0u == (iloEnableState & CY_LIB_SLOWCLK_ILO_CR0_EN_100KHZ))\r
1393         {\r
1394             CyILO_Stop100K();\r
1395         }\r
1396         CY_LIB_PM_TW_CFG0_REG = pmTwCfg0Tmp;\r
1397         CY_LIB_PM_TW_CFG2_REG = pmTwCfg2Tmp;\r
1398     }\r
1399 \r
1400     return(status);\r
1401 }\r
1402 \r
1403 \r
1404 /*******************************************************************************\r
1405 * Function Name: CyXTAL_Stop\r
1406 ********************************************************************************\r
1407 *\r
1408 * Summary:\r
1409 *  Disables the megahertz crystal oscillator.\r
1410 *\r
1411 * Parameters:\r
1412 *  None\r
1413 *\r
1414 * Return:\r
1415 *  None\r
1416 *\r
1417 *******************************************************************************/\r
1418 void CyXTAL_Stop(void) \r
1419 {\r
1420     /* Disable the the oscillator. */\r
1421     FASTCLK_XMHZ_CSR &= ((uint8)(~XMHZ_CONTROL_ENABLE));\r
1422 }\r
1423 \r
1424 \r
1425 /*******************************************************************************\r
1426 * Function Name: CyXTAL_EnableErrStatus\r
1427 ********************************************************************************\r
1428 *\r
1429 * Summary:\r
1430 *  Enables the generation of the XERR status bit for the megahertz crystal.\r
1431 *  This function is not available for PSoC5.\r
1432 *\r
1433 * Parameters:\r
1434 *  None\r
1435 *\r
1436 * Return:\r
1437 *  None\r
1438 *\r
1439 *******************************************************************************/\r
1440 void CyXTAL_EnableErrStatus(void) \r
1441 {\r
1442     /* If oscillator has insufficient amplitude, XERR bit will be high. */\r
1443     CY_CLK_XMHZ_CSR_REG &= ((uint8)(~CY_CLK_XMHZ_CSR_XFB));\r
1444 }\r
1445 \r
1446 \r
1447 /*******************************************************************************\r
1448 * Function Name: CyXTAL_DisableErrStatus\r
1449 ********************************************************************************\r
1450 *\r
1451 * Summary:\r
1452 *  Disables the generation of the XERR status bit for the megahertz crystal.\r
1453 *  This function is not available for PSoC5.\r
1454 *\r
1455 * Parameters:\r
1456 *  None\r
1457 *\r
1458 * Return:\r
1459 *  None\r
1460 *\r
1461 *******************************************************************************/\r
1462 void CyXTAL_DisableErrStatus(void) \r
1463 {\r
1464     /* If oscillator has insufficient amplitude, XERR bit will be high. */\r
1465     CY_CLK_XMHZ_CSR_REG |= CY_CLK_XMHZ_CSR_XFB;\r
1466 }\r
1467 \r
1468 \r
1469 /*******************************************************************************\r
1470 * Function Name: CyXTAL_ReadStatus\r
1471 ********************************************************************************\r
1472 *\r
1473 * Summary:\r
1474 *  Reads the XERR status bit for the megahertz crystal. This status bit is a\r
1475 *  sticky clear on read value. This function is not available for PSoC5.\r
1476 *\r
1477 * Parameters:\r
1478 *  None\r
1479 *\r
1480 * Return:\r
1481 *   Status\r
1482 *    0: No error\r
1483 *    1: Error\r
1484 *\r
1485 *******************************************************************************/\r
1486 uint8 CyXTAL_ReadStatus(void) \r
1487 {\r
1488     /***************************************************************************\r
1489     * High output indicates oscillator failure. Only use this after start-up\r
1490     * interval is completed. This can be used for status and failure recovery.\r
1491     ***************************************************************************/\r
1492     return((0u != (CY_CLK_XMHZ_CSR_REG & CY_CLK_XMHZ_CSR_XERR)) ? 1u : 0u);\r
1493 }\r
1494 \r
1495 \r
1496 /*******************************************************************************\r
1497 * Function Name: CyXTAL_EnableFaultRecovery\r
1498 ********************************************************************************\r
1499 *\r
1500 * Summary:\r
1501 *  Enables the fault recovery circuit which will switch to the IMO in the case\r
1502 *  of a fault in the megahertz crystal circuit. The crystal must be up and\r
1503 *  running with the XERR bit at 0, before calling this function to prevent\r
1504 *  immediate fault switchover. This function is not available for PSoC5.\r
1505 *\r
1506 * Parameters:\r
1507 *  None\r
1508 *\r
1509 * Return:\r
1510 *  None\r
1511 *\r
1512 *******************************************************************************/\r
1513 void CyXTAL_EnableFaultRecovery(void) \r
1514 {\r
1515     CY_CLK_XMHZ_CSR_REG |= CY_CLK_XMHZ_CSR_XPROT;\r
1516 }\r
1517 \r
1518 \r
1519 /*******************************************************************************\r
1520 * Function Name: CyXTAL_DisableFaultRecovery\r
1521 ********************************************************************************\r
1522 *\r
1523 * Summary:\r
1524 *  Disables the fault recovery circuit which will switch to the IMO in the case\r
1525 *  of a fault in the megahertz crystal circuit. This function is not available\r
1526 *  for PSoC5.\r
1527 *\r
1528 * Parameters:\r
1529 *  None\r
1530 *\r
1531 * Return:\r
1532 *  None\r
1533 *\r
1534 *******************************************************************************/\r
1535 void CyXTAL_DisableFaultRecovery(void) \r
1536 {\r
1537     CY_CLK_XMHZ_CSR_REG &= ((uint8)(~CY_CLK_XMHZ_CSR_XPROT));\r
1538 }\r
1539 \r
1540 \r
1541 /*******************************************************************************\r
1542 * Function Name: CyXTAL_SetStartup\r
1543 ********************************************************************************\r
1544 *\r
1545 * Summary:\r
1546 *  Sets the startup settings for the crystal. Logic model outputs a frequency\r
1547 *  (setting + 4) MHz when enabled.\r
1548 *\r
1549 *  This is artificial as the actual frequency is determined by an attached\r
1550 *  external crystal.\r
1551 *\r
1552 * Parameters:\r
1553 *  setting: Valid range [0-31].\r
1554 *   Value is dependent on the frequency and quality of the crystal being used.\r
1555 *   Refer to the device TRM and datasheet for more information.\r
1556 *\r
1557 * Return:\r
1558 *  None\r
1559 *\r
1560 *******************************************************************************/\r
1561 void CyXTAL_SetStartup(uint8 setting) \r
1562 {\r
1563     CY_CLK_XMHZ_CFG0_REG = (CY_CLK_XMHZ_CFG0_REG & ((uint8)(~CY_CLK_XMHZ_CFG0_XCFG_MASK))) |\r
1564                            (setting & CY_CLK_XMHZ_CFG0_XCFG_MASK);\r
1565 }\r
1566 \r
1567 \r
1568 \r
1569 /*******************************************************************************\r
1570 * Function Name: CyXTAL_SetFbVoltage\r
1571 ********************************************************************************\r
1572 *\r
1573 * Summary:\r
1574 *  Sets the feedback reference voltage to use for the crystal circuit.\r
1575 *  This function is only available for PSoC3 and PSoC 5LP.\r
1576 *\r
1577 * Parameters:\r
1578 *  setting: Valid range [0-15].\r
1579 *  Refer to the device TRM and datasheet for more information.\r
1580 *\r
1581 * Return:\r
1582 *  None\r
1583 *\r
1584 *******************************************************************************/\r
1585 void CyXTAL_SetFbVoltage(uint8 setting) \r
1586 {\r
1587     CY_CLK_XMHZ_CFG1_REG = ((CY_CLK_XMHZ_CFG1_REG & ((uint8)(~CY_CLK_XMHZ_CFG1_VREF_FB_MASK))) |\r
1588                             (setting & CY_CLK_XMHZ_CFG1_VREF_FB_MASK));\r
1589 }\r
1590 \r
1591 \r
1592 /*******************************************************************************\r
1593 * Function Name: CyXTAL_SetWdVoltage\r
1594 ********************************************************************************\r
1595 *\r
1596 * Summary:\r
1597 *  Sets the reference voltage used by the watchdog to detect a failure in the\r
1598 *  crystal circuit. This function is only available for PSoC3 and PSoC 5LP.\r
1599 *\r
1600 * Parameters:\r
1601 *  setting: Valid range [0-7].\r
1602 *  Refer to the device TRM and datasheet for more information.\r
1603 *\r
1604 * Return:\r
1605 *  None\r
1606 *\r
1607 *******************************************************************************/\r
1608 void CyXTAL_SetWdVoltage(uint8 setting) \r
1609 {\r
1610     CY_CLK_XMHZ_CFG1_REG = ((CY_CLK_XMHZ_CFG1_REG & ((uint8)(~CY_CLK_XMHZ_CFG1_VREF_WD_MASK))) |\r
1611                             (((uint8)(setting << 4u)) & CY_CLK_XMHZ_CFG1_VREF_WD_MASK));\r
1612 }\r
1613 \r
1614 \r
1615 /*******************************************************************************\r
1616 * Function Name: CyHalt\r
1617 ********************************************************************************\r
1618 *\r
1619 * Summary:\r
1620 *  Halts the CPU.\r
1621 *\r
1622 * Parameters:\r
1623 *  uint8 reason: Value to be used during debugging.\r
1624 *\r
1625 * Return:\r
1626 *  None\r
1627 *\r
1628 *******************************************************************************/\r
1629 void CyHalt(uint8 reason) CYREENTRANT\r
1630 {\r
1631     if(0u != reason)\r
1632     {\r
1633         /* To remove unreferenced local variable warning */\r
1634     }\r
1635 \r
1636     #if defined (__ARMCC_VERSION)\r
1637         __breakpoint(0x0);\r
1638     #elif defined(__GNUC__) || defined (__ICCARM__)\r
1639         __asm("    bkpt    1");\r
1640     #elif defined(__C51__)\r
1641         CYDEV_HALT_CPU;\r
1642     #endif  /* (__ARMCC_VERSION) */\r
1643 }\r
1644 \r
1645 \r
1646 /*******************************************************************************\r
1647 * Function Name: CySoftwareReset\r
1648 ********************************************************************************\r
1649 *\r
1650 * Summary:\r
1651 *  Forces a software reset of the device.\r
1652 *\r
1653 * Parameters:\r
1654 *  None\r
1655 *\r
1656 * Return:\r
1657 *  None\r
1658 *\r
1659 *******************************************************************************/\r
1660 void CySoftwareReset(void) \r
1661 {\r
1662     CY_LIB_RESET_CR2_REG |= CY_LIB_RESET_CR2_RESET;\r
1663 }\r
1664 \r
1665 \r
1666 /*******************************************************************************\r
1667 * Function Name: CyDelay\r
1668 ********************************************************************************\r
1669 *\r
1670 * Summary:\r
1671 *  Blocks for milliseconds.\r
1672 *\r
1673 *  Note:\r
1674 *  CyDelay has been implemented with the instruction cache assumed enabled. When\r
1675 *  instruction cache is disabled on PSoC5, CyDelay will be two times larger. For\r
1676 *  example, with instruction cache disabled CyDelay(100) would result in about\r
1677 *  200 ms delay instead of 100 ms.\r
1678 *\r
1679 * Parameters:\r
1680 *  milliseconds: number of milliseconds to delay.\r
1681 *\r
1682 * Return:\r
1683 *   None\r
1684 *\r
1685 *******************************************************************************/\r
1686 void CyDelay(uint32 milliseconds) CYREENTRANT\r
1687 {\r
1688     while (milliseconds > 32768u)\r
1689     {\r
1690         /***********************************************************************\r
1691         * This loop prevents overflow.At 100MHz, milliseconds * delay_freq_khz\r
1692         * overflows at about 42 seconds.\r
1693         ***********************************************************************/\r
1694         CyDelayCycles(cydelay_32k_ms);\r
1695         milliseconds = ((uint32)(milliseconds - 32768u));\r
1696     }\r
1697 \r
1698     CyDelayCycles(milliseconds * cydelay_freq_khz);\r
1699 }\r
1700 \r
1701 \r
1702 #if(!CY_PSOC3)\r
1703 \r
1704     /* For PSoC3 devices function is defined in CyBootAsmKeil.a51 file */\r
1705 \r
1706     /*******************************************************************************\r
1707     * Function Name: CyDelayUs\r
1708     ********************************************************************************\r
1709     *\r
1710     * Summary:\r
1711     *  Blocks for microseconds.\r
1712     *\r
1713     *  Note:\r
1714     *   CyDelay has been implemented with the instruction cache assumed enabled.\r
1715     *   When instruction cache is disabled on PSoC5, CyDelayUs will be two times\r
1716     *   larger. Ex: With instruction cache disabled CyDelayUs(100) would result\r
1717     *   in about 200us delay instead of 100us.\r
1718     *\r
1719     * Parameters:\r
1720     *  uint16 microseconds: number of microseconds to delay.\r
1721     *\r
1722     * Return:\r
1723     *  None\r
1724     *\r
1725     * Side Effects:\r
1726     *  CyDelayUS has been implemented with the instruction cache assumed enabled.\r
1727     *  When instruction cache is disabled on PSoC 5, CyDelayUs will be two times\r
1728     *  larger. For example, with instruction cache disabled CyDelayUs(100) would\r
1729     *  result in about 200 us delay instead of 100 us.\r
1730     *\r
1731     *  If the bus clock frequency is a small non-integer number, the actual delay\r
1732     *  can be up to twice as long as the nominal value. The actual delay cannot be\r
1733     *  shorter than the nominal one.\r
1734     *******************************************************************************/\r
1735     void CyDelayUs(uint16 microseconds) CYREENTRANT\r
1736     {\r
1737         CyDelayCycles((uint32)microseconds * cydelay_freq_mhz);\r
1738     }\r
1739 \r
1740 #endif  /* (!CY_PSOC3) */\r
1741 \r
1742 \r
1743 /*******************************************************************************\r
1744 * Function Name: CyDelayFreq\r
1745 ********************************************************************************\r
1746 *\r
1747 * Summary:\r
1748 *  Sets clock frequency for CyDelay.\r
1749 *\r
1750 * Parameters:\r
1751 *  freq: Frequency of bus clock in Hertz.\r
1752 *\r
1753 * Return:\r
1754 *  None\r
1755 *\r
1756 *******************************************************************************/\r
1757 void CyDelayFreq(uint32 freq) CYREENTRANT\r
1758 {\r
1759     if (freq != 0u)\r
1760     {\r
1761         cydelay_freq_hz = freq;\r
1762     }\r
1763     else\r
1764     {\r
1765         cydelay_freq_hz = BCLK__BUS_CLK__HZ;\r
1766     }\r
1767 \r
1768     cydelay_freq_mhz = (uint8)((cydelay_freq_hz + 999999u) / 1000000u);\r
1769     cydelay_freq_khz = (cydelay_freq_hz + 999u) / 1000u;\r
1770     cydelay_32k_ms   = 32768u * cydelay_freq_khz;\r
1771 }\r
1772 \r
1773 \r
1774 /*******************************************************************************\r
1775 * Function Name: CyWdtStart\r
1776 ********************************************************************************\r
1777 *\r
1778 * Summary:\r
1779 *  Enables the watchdog timer.\r
1780 *\r
1781 *  The timer is configured for the specified count interval, the central\r
1782 *  timewheel is cleared, the setting for low power mode is configured and the\r
1783 *  watchdog timer is enabled.\r
1784 *\r
1785 *  Once enabled the watchdog cannot be disabled. The watchdog counts each time\r
1786 *  the Central Time Wheel (CTW) reaches the period specified. The watchdog must\r
1787 *  be cleared using the CyWdtClear() function before three ticks of the watchdog\r
1788 *  timer occur. The CTW is free running, so this will occur after between 2 and\r
1789 *  3 timer periods elapse.\r
1790 *\r
1791 *  PSoC5: The watchdog timer should not be used during sleep modes. Since the\r
1792 *  WDT cannot be disabled after it is enabled, the WDT timeout period can be\r
1793 *  set to be greater than the sleep wakeup period, then feed the dog on each\r
1794 *  wakeup from Sleep.\r
1795 *\r
1796 * Parameters:\r
1797 *  ticks: One of the four available timer periods. Once WDT enabled, the\r
1798    interval cannot be changed.\r
1799 *         CYWDT_2_TICKS     -     4 - 6     ms\r
1800 *         CYWDT_16_TICKS    -    32 - 48    ms\r
1801 *         CYWDT_128_TICKS   -   256 - 384   ms\r
1802 *         CYWDT_1024_TICKS  - 2.048 - 3.072 s\r
1803 *\r
1804 *  lpMode: Low power mode configuration. This parameter is ignored for PSoC 5.\r
1805 *          The WDT always acts as if CYWDT_LPMODE_NOCHANGE is passed.\r
1806 *\r
1807 *          CYWDT_LPMODE_NOCHANGE - No Change\r
1808 *          CYWDT_LPMODE_MAXINTER - Switch to longest timer mode during low power\r
1809 *                                 mode\r
1810 *          CYWDT_LPMODE_DISABLED - Disable WDT during low power mode\r
1811 *\r
1812 * Return:\r
1813 *  None\r
1814 *\r
1815 * Side Effects:\r
1816 *  PSoC5: The ILO 1 KHz must be enabled for proper WDT operation. Stopping the\r
1817 *  ILO 1 kHz could break the active WDT functionality.\r
1818 *\r
1819 *******************************************************************************/\r
1820 void CyWdtStart(uint8 ticks, uint8 lpMode) \r
1821 {\r
1822     /* Set WDT interval */\r
1823     CY_WDT_CFG_REG = (CY_WDT_CFG_REG & ((uint8)(~CY_WDT_CFG_INTERVAL_MASK))) | (ticks & CY_WDT_CFG_INTERVAL_MASK);\r
1824 \r
1825     /* Reset CTW to ensure that first watchdog period is full */\r
1826     CY_WDT_CFG_REG |= CY_WDT_CFG_CTW_RESET;\r
1827     CY_WDT_CFG_REG &= ((uint8)(~CY_WDT_CFG_CTW_RESET));\r
1828 \r
1829     /* Setting the low power mode */\r
1830     CY_WDT_CFG_REG = (((uint8)(lpMode << CY_WDT_CFG_LPMODE_SHIFT)) & CY_WDT_CFG_LPMODE_MASK) |\r
1831                        (CY_WDT_CFG_REG & ((uint8)(~CY_WDT_CFG_LPMODE_MASK)));\r
1832 \r
1833     /* Enables the watchdog reset */\r
1834     CY_WDT_CFG_REG |= CY_WDT_CFG_WDR_EN;\r
1835 }\r
1836 \r
1837 \r
1838 /*******************************************************************************\r
1839 * Function Name: CyWdtClear\r
1840 ********************************************************************************\r
1841 *\r
1842 * Summary:\r
1843 *  Clears (feeds) the watchdog timer.\r
1844 *\r
1845 * Parameters:\r
1846 *  None\r
1847 *\r
1848 * Return:\r
1849 *  None\r
1850 *\r
1851 *******************************************************************************/\r
1852 void CyWdtClear(void) \r
1853 {\r
1854     CY_WDT_CR_REG = CY_WDT_CR_FEED;\r
1855 }\r
1856 \r
1857 \r
1858 \r
1859 /*******************************************************************************\r
1860 * Function Name: CyVdLvDigitEnable\r
1861 ********************************************************************************\r
1862 *\r
1863 * Summary:\r
1864 *  Enables the digital low voltage monitors to generate interrupt on Vddd\r
1865 *   archives specified threshold and optionally resets device.\r
1866 *\r
1867 * Parameters:\r
1868 *  reset: Option to reset device at a specified Vddd threshold:\r
1869 *           0 - Device is not reset.\r
1870 *           1 - Device is reset.\r
1871 *\r
1872 *  threshold: Sets the trip level for the voltage monitor.\r
1873 *  Values from 1.70 V to 5.45 V are accepted with the approximately 250 mV\r
1874 *  interval.\r
1875 *\r
1876 * Return:\r
1877 *  None\r
1878 *\r
1879 *******************************************************************************/\r
1880 void CyVdLvDigitEnable(uint8 reset, uint8 threshold) \r
1881 {\r
1882     *CY_INT_CLEAR_PTR = 0x01u;\r
1883 \r
1884     CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESD_EN));\r
1885 \r
1886     CY_VD_LVI_TRIP_REG = (threshold & CY_VD_LVI_TRIP_LVID_MASK) |\r
1887                             (CY_VD_LVI_TRIP_REG & ((uint8)(~CY_VD_LVI_TRIP_LVID_MASK)));\r
1888     CY_VD_LVI_HVI_CONTROL_REG |= CY_VD_LVID_EN;\r
1889 \r
1890     /* Timeout to eliminate glitches on the LVI/HVI when enabling */\r
1891     CyDelayUs(1u);\r
1892 \r
1893     (void)CY_VD_PERSISTENT_STATUS_REG;\r
1894 \r
1895     if(0u != reset)\r
1896     {\r
1897         CY_VD_PRES_CONTROL_REG |= CY_VD_PRESD_EN;\r
1898     }\r
1899     else\r
1900     {\r
1901         CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESD_EN));\r
1902     }\r
1903 \r
1904     *CY_INT_CLR_PEND_PTR = 0x01u;\r
1905     *CY_INT_ENABLE_PTR   = 0x01u;\r
1906 }\r
1907 \r
1908 \r
1909 /*******************************************************************************\r
1910 * Function Name: CyVdLvAnalogEnable\r
1911 ********************************************************************************\r
1912 *\r
1913 * Summary:\r
1914 *  Enables the analog low voltage monitors to generate interrupt on Vdda\r
1915 *   archives specified threshold and optionally resets device.\r
1916 *\r
1917 * Parameters:\r
1918 *  reset: Option to reset device at a specified Vdda threshold:\r
1919 *           0 - Device is not reset.\r
1920 *           1 - Device is reset.\r
1921 *\r
1922 *  threshold: Sets the trip level for the voltage monitor.\r
1923 *  Values from 1.70 V to 5.45 V are accepted with the approximately 250 mV\r
1924 *  interval.\r
1925 *\r
1926 * Return:\r
1927 *  None\r
1928 *\r
1929 *******************************************************************************/\r
1930 void CyVdLvAnalogEnable(uint8 reset, uint8 threshold) \r
1931 {\r
1932     *CY_INT_CLEAR_PTR = 0x01u;\r
1933 \r
1934     CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESA_EN));\r
1935 \r
1936     CY_VD_LVI_TRIP_REG = ((uint8)(threshold << 4u)) | (CY_VD_LVI_TRIP_REG & 0x0Fu);\r
1937     CY_VD_LVI_HVI_CONTROL_REG |= CY_VD_LVIA_EN;\r
1938 \r
1939     /* Timeout to eliminate glitches on the LVI/HVI when enabling */\r
1940     CyDelayUs(1u);\r
1941 \r
1942     (void)CY_VD_PERSISTENT_STATUS_REG;\r
1943 \r
1944     if(0u != reset)\r
1945     {\r
1946         CY_VD_PRES_CONTROL_REG |= CY_VD_PRESA_EN;\r
1947     }\r
1948     else\r
1949     {\r
1950         CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESA_EN));\r
1951     }\r
1952 \r
1953     *CY_INT_CLR_PEND_PTR = 0x01u;\r
1954     *CY_INT_ENABLE_PTR   = 0x01u;\r
1955 }\r
1956 \r
1957 \r
1958 /*******************************************************************************\r
1959 * Function Name: CyVdLvDigitDisable\r
1960 ********************************************************************************\r
1961 *\r
1962 * Summary:\r
1963 *  Disables the digital low voltage monitor (interrupt and device reset are\r
1964 *  disabled).\r
1965 *\r
1966 * Parameters:\r
1967 *  None\r
1968 *\r
1969 * Return:\r
1970 *  None\r
1971 *\r
1972 *******************************************************************************/\r
1973 void CyVdLvDigitDisable(void) \r
1974 {\r
1975     CY_VD_LVI_HVI_CONTROL_REG &= ((uint8)(~CY_VD_LVID_EN));\r
1976 \r
1977     CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESD_EN));\r
1978 \r
1979     while(0u != (CY_VD_PERSISTENT_STATUS_REG & 0x07u))\r
1980     {\r
1981 \r
1982     }\r
1983 }\r
1984 \r
1985 \r
1986 /*******************************************************************************\r
1987 * Function Name: CyVdLvAnalogDisable\r
1988 ********************************************************************************\r
1989 *\r
1990 * Summary:\r
1991 *  Disables the analog low voltage monitor (interrupt and device reset are\r
1992 *  disabled).\r
1993 *\r
1994 * Parameters:\r
1995 *  None\r
1996 *\r
1997 * Return:\r
1998 *  None\r
1999 *\r
2000 *******************************************************************************/\r
2001 void CyVdLvAnalogDisable(void) \r
2002 {\r
2003     CY_VD_LVI_HVI_CONTROL_REG &= ((uint8)(~CY_VD_LVIA_EN));\r
2004 \r
2005     CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESA_EN));\r
2006 \r
2007     while(0u != (CY_VD_PERSISTENT_STATUS_REG & 0x07u))\r
2008     {\r
2009 \r
2010     }\r
2011 }\r
2012 \r
2013 \r
2014 /*******************************************************************************\r
2015 * Function Name: CyVdHvAnalogEnable\r
2016 ********************************************************************************\r
2017 *\r
2018 * Summary:\r
2019 *  Enables the analog high voltage monitors to generate interrupt on\r
2020 *  Vdda archives 5.75 V threshold and optionally resets device.\r
2021 *\r
2022 * Parameters:\r
2023 *  None\r
2024 *\r
2025 * Return:\r
2026 *  None\r
2027 *\r
2028 *******************************************************************************/\r
2029 void CyVdHvAnalogEnable(void) \r
2030 {\r
2031     *CY_INT_CLEAR_PTR = 0x01u;\r
2032 \r
2033     CY_VD_PRES_CONTROL_REG &= ((uint8)(~CY_VD_PRESA_EN));\r
2034 \r
2035     CY_VD_LVI_HVI_CONTROL_REG |= CY_VD_HVIA_EN;\r
2036 \r
2037     /* Timeout to eliminate glitches on the LVI/HVI when enabling */\r
2038     CyDelayUs(1u);\r
2039 \r
2040     (void) CY_VD_PERSISTENT_STATUS_REG;\r
2041 \r
2042     *CY_INT_CLR_PEND_PTR = 0x01u;\r
2043     *CY_INT_ENABLE_PTR   = 0x01u;\r
2044 }\r
2045 \r
2046 \r
2047 /*******************************************************************************\r
2048 * Function Name: CyVdHvAnalogDisable\r
2049 ********************************************************************************\r
2050 *\r
2051 * Summary:\r
2052 *  Disables the analog low voltage monitor\r
2053 *  (interrupt and device reset are disabled).\r
2054 *\r
2055 * Parameters:\r
2056 *  None\r
2057 *\r
2058 * Return:\r
2059 *  None\r
2060 *\r
2061 *******************************************************************************/\r
2062 void CyVdHvAnalogDisable(void) \r
2063 {\r
2064     CY_VD_LVI_HVI_CONTROL_REG &= ((uint8)(~CY_VD_HVIA_EN));\r
2065 }\r
2066 \r
2067 \r
2068 /*******************************************************************************\r
2069 * Function Name: CyVdStickyStatus\r
2070 ********************************************************************************\r
2071 *\r
2072 * Summary:\r
2073 *  Manages the Reset and Voltage Detection Status Register 0.\r
2074 *  This register has the interrupt status for the HVIA, LVID and LVIA.\r
2075 *  This hardware register clears on read.\r
2076 *\r
2077 * Parameters:\r
2078 *  mask: Bits in the shadow register to clear.\r
2079 *   Define                  Definition\r
2080 *   CY_VD_LVID            Persistent status of digital LVI.\r
2081 *   CY_VD_LVIA            Persistent status of analog LVI.\r
2082 *   CY_VD_HVIA            Persistent status of analog HVI.\r
2083 *\r
2084 * Return:\r
2085 *  Status.  Same enumerated bit values as used for the mask parameter.\r
2086 *\r
2087 *******************************************************************************/\r
2088 uint8 CyVdStickyStatus(uint8 mask) \r
2089 {\r
2090     uint8 status;\r
2091 \r
2092     status = CY_VD_PERSISTENT_STATUS_REG;\r
2093     CY_VD_PERSISTENT_STATUS_REG &= ((uint8)(~mask));\r
2094 \r
2095     return(status);\r
2096 }\r
2097 \r
2098 \r
2099 /*******************************************************************************\r
2100 * Function Name: CyVdRealTimeStatus\r
2101 ********************************************************************************\r
2102 *\r
2103 * Summary:\r
2104 *  Returns the real time voltage detection status.\r
2105 *\r
2106 * Parameters:\r
2107 *  None\r
2108 *\r
2109 * Return:\r
2110 *  Status:\r
2111 *   Define                  Definition\r
2112 *   CY_VD_LVID            Persistent status of digital LVI.\r
2113 *   CY_VD_LVIA            Persistent status of analog LVI.\r
2114 *   CY_VD_HVIA            Persistent status of analog HVI.\r
2115 *\r
2116 *******************************************************************************/\r
2117 uint8 CyVdRealTimeStatus(void) \r
2118 {\r
2119     uint8 interruptState;\r
2120     uint8 vdFlagsState;\r
2121 \r
2122     interruptState = CyEnterCriticalSection();\r
2123     vdFlagsState = CY_VD_RT_STATUS_REG;\r
2124     CyExitCriticalSection(interruptState);\r
2125 \r
2126     return(vdFlagsState);\r
2127 }\r
2128 \r
2129 \r
2130 /*******************************************************************************\r
2131 * Function Name: CyDisableInts\r
2132 ********************************************************************************\r
2133 *\r
2134 * Summary:\r
2135 *  Disables the interrupt enable for each interrupt.\r
2136 *\r
2137 * Parameters:\r
2138 *  None\r
2139 *\r
2140 * Return:\r
2141 *  32 bit mask of previously enabled interrupts.\r
2142 *\r
2143 *******************************************************************************/\r
2144 uint32 CyDisableInts(void) \r
2145 {\r
2146     uint32 intState;\r
2147     uint8 interruptState;\r
2148 \r
2149     interruptState = CyEnterCriticalSection();\r
2150 \r
2151     #if(CY_PSOC3)\r
2152 \r
2153         /* Get the current interrupt state. */\r
2154         intState  = ((uint32) CY_GET_REG8(CY_INT_CLR_EN0_PTR));\r
2155         intState |= ((uint32) (((uint32) CY_GET_REG8(CY_INT_CLR_EN1_PTR)) << 8u));\r
2156         intState |= ((uint32) (((uint32) CY_GET_REG8(CY_INT_CLR_EN2_PTR)) << 16u));\r
2157         intState |= ((uint32) (((uint32) CY_GET_REG8(CY_INT_CLR_EN3_PTR)) << 24u));\r
2158 \r
2159 \r
2160         /* Disable all of the interrupts. */\r
2161         CY_SET_REG8(CY_INT_CLR_EN0_PTR, 0xFFu);\r
2162         CY_SET_REG8(CY_INT_CLR_EN1_PTR, 0xFFu);\r
2163         CY_SET_REG8(CY_INT_CLR_EN2_PTR, 0xFFu);\r
2164         CY_SET_REG8(CY_INT_CLR_EN3_PTR, 0xFFu);\r
2165 \r
2166     #else\r
2167 \r
2168         /* Get the current interrupt state. */\r
2169         intState = CY_GET_REG32(CY_INT_CLEAR_PTR);\r
2170 \r
2171         /* Disable all of the interrupts. */\r
2172         CY_SET_REG32(CY_INT_CLEAR_PTR, 0xFFFFFFFFu);\r
2173 \r
2174     #endif /* (CY_PSOC3) */\r
2175 \r
2176     CyExitCriticalSection(interruptState);\r
2177 \r
2178     return (intState);\r
2179 }\r
2180 \r
2181 \r
2182 /*******************************************************************************\r
2183 * Function Name: CyEnableInts\r
2184 ********************************************************************************\r
2185 *\r
2186 * Summary:\r
2187 *  Enables interrupts to a given state.\r
2188 *\r
2189 * Parameters:\r
2190 *  uint32 mask: 32 bit mask of interrupts to enable.\r
2191 *\r
2192 * Return:\r
2193 *  None\r
2194 *\r
2195 *******************************************************************************/\r
2196 void CyEnableInts(uint32 mask) \r
2197 {\r
2198 \r
2199     uint8 interruptState;\r
2200 \r
2201     interruptState = CyEnterCriticalSection();\r
2202 \r
2203     #if(CY_PSOC3)\r
2204 \r
2205         /* Set interrupts as enabled. */\r
2206         CY_SET_REG8(CY_INT_SET_EN3_PTR, ((uint8) (mask >> 24u)));\r
2207         CY_SET_REG8(CY_INT_SET_EN2_PTR, ((uint8) (mask >> 16u)));\r
2208         CY_SET_REG8(CY_INT_SET_EN1_PTR, ((uint8) (mask >> 8u )));\r
2209         CY_SET_REG8(CY_INT_SET_EN0_PTR, ((uint8) (mask )));\r
2210 \r
2211     #else\r
2212 \r
2213         CY_SET_REG32(CY_INT_ENABLE_PTR, mask);\r
2214 \r
2215     #endif /* (CY_PSOC3) */\r
2216 \r
2217     CyExitCriticalSection(interruptState);\r
2218 \r
2219 }\r
2220 \r
2221 #if(CY_PSOC5)\r
2222 \r
2223     /*******************************************************************************\r
2224     * Function Name: CyFlushCache\r
2225     ********************************************************************************\r
2226     * Summary:\r
2227     *  Flushes the PSoC 5/5LP cache by invalidating all entries.\r
2228     *\r
2229     * Parameters:\r
2230     *  None\r
2231     *\r
2232     * Return:\r
2233     *  None\r
2234     *\r
2235     *******************************************************************************/\r
2236     void CyFlushCache(void)\r
2237     {\r
2238         uint8 interruptState;\r
2239 \r
2240         /* Save current global interrupt enable and disable it */\r
2241         interruptState = CyEnterCriticalSection();\r
2242 \r
2243         /* Fill instruction prefectch unit to insure data integrity */\r
2244         CY_NOP;\r
2245         CY_NOP;\r
2246         CY_NOP;\r
2247         CY_NOP;\r
2248         CY_NOP;\r
2249         CY_NOP;\r
2250         CY_NOP;\r
2251         CY_NOP;\r
2252         CY_NOP;\r
2253         CY_NOP;\r
2254         CY_NOP;\r
2255         CY_NOP;\r
2256         CY_NOP;\r
2257         CY_NOP;\r
2258         CY_NOP;\r
2259         CY_NOP;\r
2260 \r
2261         /* All entries in the cache are invalidated on the next clock cycle. */\r
2262         CY_CACHE_CONTROL_REG |= CY_CACHE_CONTROL_FLUSH;\r
2263 \r
2264 \r
2265         /***********************************************************************\r
2266         * The prefetch unit could/would be filled with the instructions that\r
2267         * succeed the flush. Since a flush is desired then theoretically those\r
2268         * instructions might be considered stale/invalid.\r
2269         ***********************************************************************/\r
2270         CY_NOP;\r
2271         CY_NOP;\r
2272         CY_NOP;\r
2273         CY_NOP;\r
2274         CY_NOP;\r
2275         CY_NOP;\r
2276         CY_NOP;\r
2277         CY_NOP;\r
2278         CY_NOP;\r
2279         CY_NOP;\r
2280         CY_NOP;\r
2281         CY_NOP;\r
2282         CY_NOP;\r
2283         CY_NOP;\r
2284         CY_NOP;\r
2285         CY_NOP;\r
2286 \r
2287         /* Restore global interrupt enable state */\r
2288         CyExitCriticalSection(interruptState);\r
2289     }\r
2290 \r
2291 \r
2292     /*******************************************************************************\r
2293     * Function Name: CyIntSetSysVector\r
2294     ********************************************************************************\r
2295     * Summary:\r
2296     *  Sets the interrupt vector of the specified system interrupt number. System\r
2297     *  interrupts are present only for the ARM platform. These interrupts are for\r
2298     *  SysTick, PendSV and others.\r
2299     *\r
2300     * Parameters:\r
2301     *  number: Interrupt number, valid range [0-15].\r
2302        address: Pointer to an interrupt service routine.\r
2303     *\r
2304     * Return:\r
2305     *   The old ISR vector at this location.\r
2306     *\r
2307     *******************************************************************************/\r
2308     cyisraddress CyIntSetSysVector(uint8 number, cyisraddress address)\r
2309     {\r
2310         cyisraddress oldIsr;\r
2311         cyisraddress *ramVectorTable = *CY_INT_VECT_TABLE;\r
2312 \r
2313         CYASSERT(number <= CY_INT_SYS_NUMBER_MAX);\r
2314 \r
2315         /* Save old Interrupt service routine. */\r
2316         oldIsr = ramVectorTable[number & CY_INT_SYS_NUMBER_MASK];\r
2317 \r
2318         /* Set new Interrupt service routine. */\r
2319         ramVectorTable[number & CY_INT_SYS_NUMBER_MASK] = address;\r
2320 \r
2321         return (oldIsr);\r
2322     }\r
2323 \r
2324 \r
2325     /*******************************************************************************\r
2326     * Function Name: CyIntGetSysVector\r
2327     ********************************************************************************\r
2328     *\r
2329     * Summary:\r
2330     *  Gets the interrupt vector of the specified system interrupt number. System\r
2331     *  interrupts are present only for the ARM platform. These interrupts are for\r
2332     *  SysTick, PendSV and others.\r
2333     *\r
2334     * Parameters:\r
2335     *   number: The interrupt number, valid range [0-15].\r
2336     *\r
2337     * Return:\r
2338     *   Address of the ISR in the interrupt vector table.\r
2339     *\r
2340     *******************************************************************************/\r
2341     cyisraddress CyIntGetSysVector(uint8 number)\r
2342     {\r
2343         cyisraddress *ramVectorTable = *CY_INT_VECT_TABLE;\r
2344         CYASSERT(number <= CY_INT_SYS_NUMBER_MAX);\r
2345 \r
2346         return ramVectorTable[number & CY_INT_SYS_NUMBER_MASK];\r
2347     }\r
2348 \r
2349 \r
2350     /*******************************************************************************\r
2351     * Function Name: CyIntSetVector\r
2352     ********************************************************************************\r
2353     *\r
2354     * Summary:\r
2355     *  Sets the interrupt vector of the specified interrupt number.\r
2356     *\r
2357     * Parameters:\r
2358     *  number: Valid range [0-31].  Interrupt number\r
2359     *  address: Pointer to an interrupt service routine\r
2360     *\r
2361     * Return:\r
2362     *   Previous interrupt vector value.\r
2363     *\r
2364     *******************************************************************************/\r
2365     cyisraddress CyIntSetVector(uint8 number, cyisraddress address)\r
2366     {\r
2367         cyisraddress oldIsr;\r
2368         cyisraddress *ramVectorTable = *CY_INT_VECT_TABLE;\r
2369 \r
2370         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2371 \r
2372         /* Save old Interrupt service routine. */\r
2373         oldIsr = ramVectorTable[CY_INT_IRQ_BASE + (number & CY_INT_NUMBER_MASK)];\r
2374 \r
2375         /* Set new Interrupt service routine. */\r
2376         ramVectorTable[CY_INT_IRQ_BASE + (number & CY_INT_NUMBER_MASK)] = address;\r
2377 \r
2378         return (oldIsr);\r
2379     }\r
2380 \r
2381 \r
2382     /*******************************************************************************\r
2383     * Function Name: CyIntGetVector\r
2384     ********************************************************************************\r
2385     *\r
2386     * Summary:\r
2387     *  Gets the interrupt vector of the specified interrupt number.\r
2388     *\r
2389     * Parameters:\r
2390     *  number: Valid range [0-31].  Interrupt number\r
2391     *\r
2392     * Return:\r
2393     *  Address of the ISR in the interrupt vector table.\r
2394     *\r
2395     *******************************************************************************/\r
2396     cyisraddress CyIntGetVector(uint8 number)\r
2397     {\r
2398         cyisraddress *ramVectorTable = *CY_INT_VECT_TABLE;\r
2399         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2400 \r
2401         return (ramVectorTable[CY_INT_IRQ_BASE + (number & CY_INT_NUMBER_MASK)]);\r
2402     }\r
2403 \r
2404 \r
2405     /*******************************************************************************\r
2406     * Function Name: CyIntSetPriority\r
2407     ********************************************************************************\r
2408     *\r
2409     * Summary:\r
2410     *  Sets the Priority of the Interrupt.\r
2411     *\r
2412     * Parameters:\r
2413     *  priority: Priority of the interrupt. 0 - 7, 0 being the highest.\r
2414     *  number: The number of the interrupt, 0 - 31.\r
2415     *\r
2416     * Return:\r
2417     *  None\r
2418     *\r
2419     *******************************************************************************/\r
2420     void CyIntSetPriority(uint8 number, uint8 priority)\r
2421     {\r
2422         CYASSERT(priority <= CY_INT_PRIORITY_MAX);\r
2423         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2424         CY_INT_PRIORITY_PTR[number & CY_INT_NUMBER_MASK] = (priority & CY_INT_PRIORITY_MASK)<< 5;\r
2425     }\r
2426 \r
2427 \r
2428     /*******************************************************************************\r
2429     * Function Name: CyIntGetPriority\r
2430     ********************************************************************************\r
2431     *\r
2432     * Summary:\r
2433     *  Gets the Priority of the Interrupt.\r
2434     *\r
2435     * Parameters:\r
2436     *  number: The number of the interrupt, 0 - 31.\r
2437     *\r
2438     * Return:\r
2439     *  Priority of the interrupt. 0 - 7, 0 being the highest.\r
2440     *\r
2441     *******************************************************************************/\r
2442     uint8 CyIntGetPriority(uint8 number)\r
2443     {\r
2444         uint8 priority;\r
2445 \r
2446         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2447 \r
2448         priority = CY_INT_PRIORITY_PTR[number & CY_INT_NUMBER_MASK] >> 5;\r
2449 \r
2450         return (priority);\r
2451     }\r
2452 \r
2453 \r
2454     /*******************************************************************************\r
2455     * Function Name: CyIntGetState\r
2456     ********************************************************************************\r
2457     *\r
2458     * Summary:\r
2459     *   Gets the enable state of the specified interrupt number.\r
2460     *\r
2461     * Parameters:\r
2462     *   number: Valid range [0-31].  Interrupt number.\r
2463     *\r
2464     * Return:\r
2465     *   Enable status: 1 if enabled, 0 if disabled\r
2466     *\r
2467     *******************************************************************************/\r
2468     uint8 CyIntGetState(uint8 number)\r
2469     {\r
2470         reg32 * stateReg;\r
2471 \r
2472         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2473 \r
2474         /* Get a pointer to the Interrupt enable register. */\r
2475         stateReg = CY_INT_ENABLE_PTR;\r
2476 \r
2477         /* Get the state of the interrupt. */\r
2478         return (0u != (*stateReg & (((uint32) 1u) << (0x1Fu & number)))) ? ((uint8)(1u)) : ((uint8)(0u));\r
2479     }\r
2480 \r
2481 \r
2482 #else   /* PSoC3 */\r
2483 \r
2484 \r
2485     /*******************************************************************************\r
2486     * Function Name: CyIntSetVector\r
2487     ********************************************************************************\r
2488     *\r
2489     * Summary:\r
2490     *  Sets the interrupt vector of the specified interrupt number.\r
2491     *\r
2492     * Parameters:\r
2493     *  number:  Valid range [0-31].  Interrupt number\r
2494     *  address: Pointer to an interrupt service routine\r
2495     *\r
2496     * Return:\r
2497     *  Previous interrupt vector value.\r
2498     *\r
2499     *******************************************************************************/\r
2500     cyisraddress CyIntSetVector(uint8 number, cyisraddress address) \r
2501     {\r
2502         cyisraddress oldIsr;\r
2503 \r
2504         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2505 \r
2506         /* Save old Interrupt service routine. */\r
2507         oldIsr = (cyisraddress) \\r
2508                     CY_GET_REG16(&CY_INT_VECT_TABLE[number & CY_INT_NUMBER_MASK]);\r
2509 \r
2510         /* Set new Interrupt service routine. */\r
2511         CY_SET_REG16(&CY_INT_VECT_TABLE[number], (uint16) address);\r
2512 \r
2513         return (oldIsr);\r
2514     }\r
2515 \r
2516 \r
2517     /*******************************************************************************\r
2518     * Function Name: CyIntGetVector\r
2519     ********************************************************************************\r
2520     *\r
2521     * Summary:\r
2522     *  Gets the interrupt vector of the specified interrupt number.\r
2523     *\r
2524     * Parameters:\r
2525     *  number: Valid range [0-31].  Interrupt number\r
2526     *\r
2527     * Return:\r
2528     *  Address of the ISR in the interrupt vector table.\r
2529     *\r
2530     *******************************************************************************/\r
2531     cyisraddress CyIntGetVector(uint8 number) \r
2532     {\r
2533         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2534 \r
2535         return ((cyisraddress) \\r
2536                 CY_GET_REG16(&CY_INT_VECT_TABLE[number & CY_INT_NUMBER_MASK]));\r
2537     }\r
2538 \r
2539 \r
2540     /*******************************************************************************\r
2541     * Function Name: CyIntSetPriority\r
2542     ********************************************************************************\r
2543     *\r
2544     * Summary:\r
2545     *  Sets the Priority of the Interrupt.\r
2546     *\r
2547     * Parameters:\r
2548     *  priority: Priority of the interrupt. 0 - 7, 0 being the highest.\r
2549     *  number:   The number of the interrupt, 0 - 31.\r
2550     *\r
2551     * Return:\r
2552     *  None\r
2553     *\r
2554     *******************************************************************************/\r
2555     void CyIntSetPriority(uint8 number, uint8 priority) \r
2556     {\r
2557         CYASSERT(priority <= CY_INT_PRIORITY_MAX);\r
2558 \r
2559         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2560 \r
2561         CY_INT_PRIORITY_PTR[number & CY_INT_NUMBER_MASK] =\r
2562                     (priority & CY_INT_PRIORITY_MASK) << 5;\r
2563     }\r
2564 \r
2565 \r
2566     /*******************************************************************************\r
2567     * Function Name: CyIntGetPriority\r
2568     ********************************************************************************\r
2569     *\r
2570     * Summary:\r
2571     *  Gets the Priority of the Interrupt.\r
2572     *\r
2573     * Parameters:\r
2574     *  number: The number of the interrupt, 0 - 31.\r
2575     *\r
2576     * Return:\r
2577     *  Priority of the interrupt. 0 - 7, 0 being the highest.\r
2578     *\r
2579     *******************************************************************************/\r
2580     uint8 CyIntGetPriority(uint8 number) \r
2581     {\r
2582         uint8 priority;\r
2583 \r
2584         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2585 \r
2586         priority = CY_INT_PRIORITY_PTR[number & CY_INT_NUMBER_MASK] >> 5;\r
2587 \r
2588         return (priority);\r
2589     }\r
2590 \r
2591 \r
2592     /*******************************************************************************\r
2593     * Function Name: CyIntGetState\r
2594     ********************************************************************************\r
2595     *\r
2596     * Summary:\r
2597     *   Gets the enable state of the specified interrupt number.\r
2598     *\r
2599     * Parameters:\r
2600     *   number: Valid range [0-31].  Interrupt number.\r
2601     *\r
2602     * Return:\r
2603     *   Enable status: 1 if enabled, 0 if disabled\r
2604     *\r
2605     *******************************************************************************/\r
2606     uint8 CyIntGetState(uint8 number) \r
2607     {\r
2608         reg8 * stateReg;\r
2609 \r
2610         CYASSERT(number <= CY_INT_NUMBER_MAX);\r
2611 \r
2612         /* Get a pointer to the Interrupt enable register. */\r
2613         stateReg = CY_INT_ENABLE_PTR + ((number & CY_INT_NUMBER_MASK) >> 3u);\r
2614 \r
2615         /* Get the state of the interrupt. */\r
2616         return ((0u != (*stateReg & ((uint8)(1u << (0x07u & number))))) ? ((uint8)(1u)) : ((uint8)(0u)));\r
2617     }\r
2618 \r
2619 \r
2620 #endif  /* (CY_PSOC5) */\r
2621 \r
2622 \r
2623 #if(CYDEV_VARIABLE_VDDA == 1)\r
2624 \r
2625     /*******************************************************************************\r
2626     * Function Name: CySetScPumps\r
2627     ********************************************************************************\r
2628     *\r
2629     * Summary:\r
2630     *  If 1 is passed as a parameter:\r
2631     *   - if any of the SC blocks are used - enable pumps for the SC blocks and\r
2632     *     start boost clock.\r
2633     *   - For the each enabled SC block set boost clock index and enable boost\r
2634     *     clock.\r
2635     *\r
2636     *  If non-1 value is passed as a parameter:\r
2637     *   - If all SC blocks are not used - disable pumps for the SC blocks and\r
2638     *     stop boost clock.\r
2639     *   - For the each enabled SC block clear boost clock index and disable boost\r
2640     *     clock.\r
2641     *\r
2642     *  The global variable CyScPumpEnabled is updated to be equal to passed\r
2643     *  parameter.\r
2644     *\r
2645     * Parameters:\r
2646     *   uint8 enable: Enable/disable SC pumps and boost clock for enabled SC block.\r
2647     *                 1 - Enable\r
2648     *                 0 - Disable\r
2649     *\r
2650     * Return:\r
2651     *   None\r
2652     *\r
2653     *******************************************************************************/\r
2654     void CySetScPumps(uint8 enable) \r
2655     {\r
2656         if(1u == enable)\r
2657         {\r
2658             /* The SC pumps should be enabled */\r
2659             CyScPumpEnabled = 1u;\r
2660             /* Enable pumps if any of SC blocks are used */\r
2661             if(0u != (CY_LIB_ACT_CFG9_REG & CY_LIB_ACT_CFG9_SWCAPS_MASK))\r
2662             {\r
2663                 CY_LIB_SC_MISC_REG |= CY_LIB_SC_MISC_PUMP_FORCE;\r
2664                 CyScBoostClk_Start();\r
2665             }\r
2666             /* Set positive pump for each enabled SC block: set clock index and enable it */\r
2667             if(0u != (CY_LIB_ACT_CFG9_REG & CY_LIB_ACT_CFG9_SWCAP0_EN))\r
2668             {\r
2669                 CY_LIB_SC0_BST_REG = (CY_LIB_SC0_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK) | CyScBoostClk__INDEX;\r
2670                 CY_LIB_SC0_BST_REG |= CY_LIB_SC_BST_CLK_EN;\r
2671             }\r
2672             if(0u != (CY_LIB_ACT_CFG9_REG & CY_LIB_ACT_CFG9_SWCAP1_EN))\r
2673             {\r
2674                 CY_LIB_SC1_BST_REG = (CY_LIB_SC1_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK) | CyScBoostClk__INDEX;\r
2675                 CY_LIB_SC1_BST_REG |= CY_LIB_SC_BST_CLK_EN;\r
2676             }\r
2677             if(0u != (CY_LIB_ACT_CFG9_REG & CY_LIB_ACT_CFG9_SWCAP2_EN))\r
2678             {\r
2679                 CY_LIB_SC2_BST_REG = (CY_LIB_SC2_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK) | CyScBoostClk__INDEX;\r
2680                 CY_LIB_SC2_BST_REG |= CY_LIB_SC_BST_CLK_EN;\r
2681             }\r
2682             if(0u != (CY_LIB_ACT_CFG9_REG & CY_LIB_ACT_CFG9_SWCAP3_EN))\r
2683             {\r
2684                 CY_LIB_SC3_BST_REG = (CY_LIB_SC3_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK) | CyScBoostClk__INDEX;\r
2685                 CY_LIB_SC3_BST_REG |= CY_LIB_SC_BST_CLK_EN;\r
2686             }\r
2687         }\r
2688         else\r
2689         {\r
2690             /* The SC pumps should be disabled */\r
2691             CyScPumpEnabled = 0u;\r
2692             /* Disable pumps for all SC blocks and stop boost clock */\r
2693             CY_LIB_SC_MISC_REG &= ((uint8)(~CY_LIB_SC_MISC_PUMP_FORCE));\r
2694             CyScBoostClk_Stop();\r
2695             /* Disable boost clock and clear clock index for each SC block */\r
2696             CY_LIB_SC0_BST_REG &= ((uint8)(~CY_LIB_SC_BST_CLK_EN));\r
2697             CY_LIB_SC0_BST_REG = CY_LIB_SC0_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK;\r
2698             CY_LIB_SC1_BST_REG &= ((uint8)(~CY_LIB_SC_BST_CLK_EN));\r
2699             CY_LIB_SC1_BST_REG = CY_LIB_SC1_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK;\r
2700             CY_LIB_SC2_BST_REG &= ((uint8)(~CY_LIB_SC_BST_CLK_EN));\r
2701             CY_LIB_SC2_BST_REG = CY_LIB_SC2_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK;\r
2702             CY_LIB_SC3_BST_REG &= ((uint8)(~CY_LIB_SC_BST_CLK_EN));\r
2703             CY_LIB_SC3_BST_REG = CY_LIB_SC3_BST_REG & CY_LIB_SC_BST_CLK_INDEX_MASK;\r
2704         }\r
2705     }\r
2706 \r
2707 #endif  /* (CYDEV_VARIABLE_VDDA == 1) */\r
2708 \r
2709 \r
2710 /* [] END OF FILE */\r