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