Added support for v4.2 boards
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / cyPm.c
1 /*******************************************************************************
2 * File Name: cyPm.c
3 * Version 4.0
4 *
5 * Description:
6 *  Provides an API for the power management.
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 "cyPm.h"
20
21
22 /*******************************************************************
23 * Place your includes, defines and code here. Do not use merge
24 * region below unless any component datasheet suggest to do so.
25 *******************************************************************/
26 /* `#START CY_PM_HEADER_INCLUDE` */
27
28 /* `#END` */
29
30
31 static CY_PM_BACKUP_STRUCT          cyPmBackup;
32 static CY_PM_CLOCK_BACKUP_STRUCT    cyPmClockBackup;
33
34 /* Convertion table between register's values and frequency in MHz  */
35 static const uint8 CYCODE cyPmImoFreqReg2Mhz[7u] = {12u, 6u, 24u, 3u, 48u, 62u, 74u};
36
37 /* Function Prototypes */
38 static void CyPmHibSaveSet(void);
39 static void CyPmHibRestore(void) ;
40
41 static void CyPmHibSlpSaveSet(void) ;
42 static void CyPmHibSlpRestore(void) ;
43
44 static void CyPmHviLviSaveDisable(void) ;
45 static void CyPmHviLviRestore(void) ;
46
47
48 /*******************************************************************************
49 * Function Name: CyPmSaveClocks
50 ********************************************************************************
51 *
52 * Summary:
53 *  This function is called in preparation for entering sleep or hibernate low
54 *  power modes. Saves all state of the clocking system that does not persist
55 *  during sleep/hibernate or that needs to be altered in preparation for
56 *  sleep/hibernate. Shutdowns all the digital and analog clock dividers for the
57 *  active power mode configuration.
58 *
59 *  Switches the master clock over to the IMO and shuts down the PLL and MHz
60 *  Crystal. The IMO frequency is set to either 12 MHz or 48 MHz to match the
61 *  Design-Wide Resources System Editor "Enable Fast IMO During Startup" setting.
62 *  The ILO and 32 KHz oscillators are not impacted. The current Flash wait state
63 *  setting is saved and the Flash wait state setting is set for the current IMO
64 *  speed.
65 *
66 *  Note If the Master Clock source is routed through the DSI inputs, then it
67 *  must be set manually to another source before using the
68 *  CyPmSaveClocks()/CyPmRestoreClocks() functions.
69 *
70 * Parameters:
71 *  None
72 *
73 * Return:
74 *  None
75 *
76 * Side Effects:
77 *  All peripheral clocks are going to be off after this API method call.
78 *
79 *******************************************************************************/
80 void CyPmSaveClocks(void) 
81 {
82     /* Digital and analog clocks - save enable state and disable them all */
83     cyPmClockBackup.enClkA = CY_PM_ACT_CFG1_REG & CY_PM_ACT_EN_CLK_A_MASK;
84     cyPmClockBackup.enClkD = CY_PM_ACT_CFG2_REG;
85     CY_PM_ACT_CFG1_REG &= ((uint8)(~CY_PM_ACT_EN_CLK_A_MASK));
86     CY_PM_ACT_CFG2_REG &= ((uint8)(~CY_PM_ACT_EN_CLK_D_MASK));
87
88     /* Save current flash wait cycles and set the maximum value */
89     cyPmClockBackup.flashWaitCycles = CY_PM_CACHE_CR_CYCLES_MASK & CY_PM_CACHE_CR_REG;
90     CyFlash_SetWaitCycles(CY_PM_MAX_FLASH_WAIT_CYCLES);
91
92     /* IMO - save current IMO MHz OSC frequency and USB mode is on bit */
93     cyPmClockBackup.imoFreq = CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_FREQ_MASK;
94     cyPmClockBackup.imoUsbClk = CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_USB;
95
96     /* IMO doubler - save enable state */
97     if(0u != (CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_F2XON))
98     {
99         /* IMO doubler enabled - save and disable */
100         cyPmClockBackup.imo2x = CY_PM_ENABLED;
101     }
102     else
103     {
104         /* IMO doubler disabled */
105         cyPmClockBackup.imo2x = CY_PM_DISABLED;
106     }
107
108     /* IMO - set appropriate frequency for LPM */
109     CyIMO_SetFreq(CY_PM_IMO_FREQ_LPM);
110
111     /* IMO - save enable state and enable without wait to settle */
112     if(0u != (CY_PM_ACT_CFG0_IMO & CY_PM_ACT_CFG0_REG))
113     {
114         /* IMO - save enabled state */
115         cyPmClockBackup.imoEnable = CY_PM_ENABLED;
116     }
117     else
118     {
119         /* IMO - save disabled state */
120         cyPmClockBackup.imoEnable = CY_PM_DISABLED;
121
122         /* IMO - enable */
123         CyIMO_Start(CY_PM_IMO_NO_WAIT_TO_SETTLE);
124     }
125
126     /* IMO - save the current IMOCLK source and set to IMO if not yet */
127     if(0u != (CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_XCLKEN))
128     {
129         /* DSI or XTAL CLK */
130         cyPmClockBackup.imoClkSrc =
131             (0u == (CY_PM_CLKDIST_CR_REG & CY_PM_CLKDIST_IMO2X_SRC)) ? CY_IMO_SOURCE_DSI : CY_IMO_SOURCE_XTAL;
132
133         /* IMO -  set IMOCLK source to MHz OSC */
134         CyIMO_SetSource(CY_IMO_SOURCE_IMO);
135     }
136     else
137     {
138         /* IMO */
139         cyPmClockBackup.imoClkSrc = CY_IMO_SOURCE_IMO;
140     }
141
142     /* Save clk_imo source */
143     cyPmClockBackup.clkImoSrc = CY_PM_CLKDIST_CR_REG & CY_PM_CLKDIST_IMO_OUT_MASK;
144
145     /* If IMOCLK2X or SPC OSC is source for clk_imo, set it to IMOCLK */
146     if(CY_PM_CLKDIST_IMO_OUT_IMO != cyPmClockBackup.clkImoSrc)
147     {
148         /* Set IMOCLK to source for clk_imo */
149         CY_PM_CLKDIST_CR_REG = (CY_PM_CLKDIST_CR_REG & ((uint8)(~CY_PM_CLKDIST_IMO_OUT_MASK))) |
150                                 CY_PM_CLKDIST_IMO_OUT_IMO;
151     }    /* Need to change nothing if IMOCLK is source clk_imo */
152
153     /* IMO doubler - disable it (saved above) */
154     if(0u != (CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_F2XON))
155     {
156         CyIMO_DisableDoubler();
157     }
158
159     /* Master clock - save divider and set it to divide-by-one (if no yet) */
160     cyPmClockBackup.clkSyncDiv = CY_PM_CLKDIST_MSTR0_REG;
161     if(CY_PM_DIV_BY_ONE != cyPmClockBackup.clkSyncDiv)
162     {
163         CyMasterClk_SetDivider(CY_PM_DIV_BY_ONE);
164     }    /* Need to change nothing if master clock divider is 1 */
165
166     /* Master clock - save current source */
167     cyPmClockBackup.masterClkSrc = CY_PM_CLKDIST_MSTR1_REG & CY_PM_MASTER_CLK_SRC_MASK;
168
169     /* Master clock source - set it to IMO if not yet. */
170     if(CY_MASTER_SOURCE_IMO != cyPmClockBackup.masterClkSrc)
171     {
172         CyMasterClk_SetSource(CY_MASTER_SOURCE_IMO);
173     }    /* Need to change nothing if master clock source is IMO */
174
175     /* Bus clock - save divider and set it, if needed, to divide-by-one */
176     cyPmClockBackup.clkBusDiv = (uint16) ((uint16) CY_PM_CLK_BUS_MSB_DIV_REG << 8u);
177     cyPmClockBackup.clkBusDiv |= CY_PM_CLK_BUS_LSB_DIV_REG;
178     if(CY_PM_BUS_CLK_DIV_BY_ONE != cyPmClockBackup.clkBusDiv)
179     {
180         CyBusClk_SetDivider(CY_PM_BUS_CLK_DIV_BY_ONE);
181     }    /* Do nothing if saved and actual values are equal */
182
183     /* Set number of wait cycles for the flash according CPU frequency in MHz */
184     CyFlash_SetWaitCycles((uint8)CY_PM_GET_CPU_FREQ_MHZ);
185
186     /* PLL - check enable state, disable if needed */
187     if(0u != (CY_PM_FASTCLK_PLL_CFG0_REG & CY_PM_PLL_CFG0_ENABLE))
188     {
189         /* PLL is enabled - save state and disable */
190         cyPmClockBackup.pllEnableState = CY_PM_ENABLED;
191         CyPLL_OUT_Stop();
192     }
193     else
194     {
195         /* PLL is disabled - save state */
196         cyPmClockBackup.pllEnableState = CY_PM_DISABLED;
197     }
198
199     /* MHz ECO - check enable state and disable if needed */
200     if(0u != (CY_PM_FASTCLK_XMHZ_CSR_REG & CY_PM_XMHZ_CSR_ENABLE))
201     {
202         /* MHz ECO is enabled - save state and disable */
203         cyPmClockBackup.xmhzEnableState = CY_PM_ENABLED;
204         CyXTAL_Stop();
205     }
206     else
207     {
208         /* MHz ECO is disabled - save state */
209         cyPmClockBackup.xmhzEnableState = CY_PM_DISABLED;
210     }
211
212
213     /***************************************************************************
214     * Save enable state of delay between the system bus clock and each of the
215     * 4 individual analog clocks. This bit non-retention and it's value should
216     * be restored on wakeup.
217     ***************************************************************************/
218     if(0u != (CY_PM_CLKDIST_DELAY_REG & CY_PM_CLKDIST_DELAY_EN))
219     {
220         cyPmClockBackup.clkDistDelay = CY_PM_ENABLED;
221     }
222     else
223     {
224         cyPmClockBackup.clkDistDelay = CY_PM_DISABLED;
225     }
226 }
227
228
229 /*******************************************************************************
230 * Function Name: CyPmRestoreClocks
231 ********************************************************************************
232 *
233 * Summary:
234 *  Restores any state that was preserved by the last call to CyPmSaveClocks().
235 *  The Flash wait state setting is also restored.
236 *
237 *  Note If the Master Clock source is routed through the DSI inputs, then it
238 *  must be set manually to another source before using the
239 *  CyPmSaveClocks()/CyPmRestoreClocks() functions.
240 *
241 *  PSoC 3 and PSoC 5LP:
242 *  The merge region could be used to process state when the megahertz crystal is
243 *  not ready after the hold-off timeout.
244 *
245 *  PSoC 5:
246 *  The 130 ms is given for the megahertz crystal to stabilize. It's readiness is
247 *  not verified after the hold-off timeout.
248 *
249 * Parameters:
250 *  None
251 *
252 * Return:
253 *  None
254 *
255 *******************************************************************************/
256 void CyPmRestoreClocks(void) 
257 {
258     cystatus status = CYRET_TIMEOUT;
259     uint16 i;
260     uint16 clkBusDivTmp;
261
262
263     /* Convertion table between CyIMO_SetFreq() parameters and register's value */
264     const uint8 CYCODE cyPmImoFreqMhz2Reg[7u] = {
265         CY_IMO_FREQ_12MHZ, CY_IMO_FREQ_6MHZ,  CY_IMO_FREQ_24MHZ, CY_IMO_FREQ_3MHZ,
266         CY_IMO_FREQ_48MHZ, 5u, 6u};
267
268     /* Restore enable state of delay between the system bus clock and ACLKs. */
269     if(CY_PM_ENABLED == cyPmClockBackup.clkDistDelay)
270     {
271         /* Delay for both the bandgap and the delay line to settle out */
272         CyDelayCycles((uint32)(CY_PM_CLK_DELAY_BANDGAP_SETTLE_US + CY_PM_CLK_DELAY_BIAS_SETTLE_US) *
273                         CY_PM_GET_CPU_FREQ_MHZ);
274
275         CY_PM_CLKDIST_DELAY_REG |= CY_PM_CLKDIST_DELAY_EN;
276     }
277
278     /* MHz ECO restore state */
279     if(CY_PM_ENABLED == cyPmClockBackup.xmhzEnableState)
280     {
281         /***********************************************************************
282         * Enabling XMHZ XTAL. The actual CyXTAL_Start() with non zero wait
283         * period uses FTW for period measurement. This could cause a problem
284         * if CTW/FTW is used as a wake up time in the low power modes APIs.
285         * So, the XTAL wait procedure is implemented with a software delay.
286         ***********************************************************************/
287
288         /* Enable XMHZ XTAL with no wait */
289         (void) CyXTAL_Start(CY_PM_XTAL_MHZ_NO_WAIT);
290
291         /* Read XERR bit to clear it */
292         (void) CY_PM_FASTCLK_XMHZ_CSR_REG;
293
294         /* Wait */
295         for(i = CY_PM_MHZ_XTAL_WAIT_NUM_OF_200_US; i > 0u; i--)
296         {
297             /* Make a 200 microseconds delay */
298             CyDelayCycles((uint32)CY_PM_WAIT_200_US * CY_PM_GET_CPU_FREQ_MHZ);
299
300             /* High output indicates oscillator failure */
301             if(0u == (CY_PM_FASTCLK_XMHZ_CSR_REG & CY_PM_XMHZ_CSR_XERR))
302             {
303                 status = CYRET_SUCCESS;
304                 break;
305             }
306         }
307
308         if(CYRET_TIMEOUT == status)
309         {
310             /*******************************************************************
311             * Process the situation when megahertz crystal is not ready.
312             * Time to stabialize value is crystal specific.
313             *******************************************************************/
314            /* `#START_MHZ_ECO_TIMEOUT` */
315
316            /* `#END` */
317         }
318     }   /* (CY_PM_ENABLED == cyPmClockBackup.xmhzEnableState) */
319
320
321     /* Temprorary set the maximum flash wait cycles */
322     CyFlash_SetWaitCycles(CY_PM_MAX_FLASH_WAIT_CYCLES);
323
324     /* The XTAL and DSI clocks are ready to be source for Master clock. */
325     if((CY_PM_MASTER_CLK_SRC_XTAL == cyPmClockBackup.masterClkSrc) ||
326        (CY_PM_MASTER_CLK_SRC_DSI  == cyPmClockBackup.masterClkSrc))
327     {
328         /* Restore Master clock's divider */
329         if(CY_PM_CLKDIST_MSTR0_REG != cyPmClockBackup.clkSyncDiv)
330         {
331             /* Restore Master clock divider */
332             CyMasterClk_SetDivider(cyPmClockBackup.clkSyncDiv);
333         }
334
335         /* Restore Master clock source */
336         CyMasterClk_SetSource(cyPmClockBackup.masterClkSrc);
337     }
338
339     /* IMO - restore IMO frequency */
340     if((0u != (cyPmClockBackup.imoUsbClk & CY_PM_FASTCLK_IMO_CR_USB)) &&
341         (CY_IMO_FREQ_24MHZ == cyPmImoFreqMhz2Reg[cyPmClockBackup.imoFreq]))
342     {
343         /* Restore IMO frequency (24 MHz) and trim it for USB */
344         CyIMO_SetFreq(CY_IMO_FREQ_USB);
345     }
346     else
347     {
348         /* Restore IMO frequency */
349         CyIMO_SetFreq(cyPmImoFreqMhz2Reg[cyPmClockBackup.imoFreq]);
350
351         if(0u != (cyPmClockBackup.imoUsbClk & CY_PM_FASTCLK_IMO_CR_USB))
352         {
353             CY_PM_FASTCLK_IMO_CR_REG |= CY_PM_FASTCLK_IMO_CR_USB;
354         }
355         else
356         {
357             CY_PM_FASTCLK_IMO_CR_REG &= ((uint8)(~CY_PM_FASTCLK_IMO_CR_USB));
358         }
359     }
360
361     /* IMO - restore enable state if needed */
362     if((CY_PM_ENABLED == cyPmClockBackup.imoEnable) &&
363        (0u == (CY_PM_ACT_CFG0_IMO & CY_PM_ACT_CFG0_REG)))
364     {
365         /* IMO - restore enabled state */
366         CyIMO_Start(CY_PM_IMO_NO_WAIT_TO_SETTLE);
367     }
368
369     /* IMO - restore disable state if needed */
370     if((CY_PM_DISABLED == cyPmClockBackup.imoEnable) &&
371        (0u != (CY_PM_ACT_CFG0_IMO & CY_PM_ACT_CFG0_REG)))
372     {
373         CyIMO_Stop();
374     }
375
376     /* IMO - restore IMOCLK source */
377     CyIMO_SetSource(cyPmClockBackup.imoClkSrc);
378
379     /* Restore IMO doubler enable state (turned off by CyPmSaveClocks()) */
380     if(CY_PM_ENABLED == cyPmClockBackup.imo2x)
381     {
382         CyIMO_EnableDoubler();
383     }
384
385     /* IMO - restore clk_imo source, if needed */
386     if(cyPmClockBackup.clkImoSrc != (CY_PM_CLKDIST_CR_REG & CY_PM_CLKDIST_IMO_OUT_MASK))
387     {
388         CY_PM_CLKDIST_CR_REG = (CY_PM_CLKDIST_CR_REG & ((uint8)(~CY_PM_CLKDIST_IMO_OUT_MASK))) |
389                                 cyPmClockBackup.clkImoSrc;
390     }
391
392     /* PLL restore state */
393     if(CY_PM_ENABLED == cyPmClockBackup.pllEnableState)
394     {
395         /***********************************************************************
396         * Enable PLL. The actual CyPLL_OUT_Start() without wait period uses FTW
397         * for period measurement. This could cause a problem if CTW/FTW is used
398         * as a wakeup time in the low power modes APIs. To omit this issue PLL
399         * wait procedure is implemented with a software delay.
400         ***********************************************************************/
401
402         /* Enable PLL */
403         (void) CyPLL_OUT_Start(CY_PM_PLL_OUT_NO_WAIT);
404
405         /* Make a 250 us delay */
406         CyDelayCycles((uint32)CY_PM_WAIT_250_US * CY_PM_GET_CPU_FREQ_MHZ);
407     }   /* (CY_PM_ENABLED == cyPmClockBackup.pllEnableState) */
408
409
410     /* PLL and IMO is ready to be source for Master clock */
411     if((CY_PM_MASTER_CLK_SRC_IMO == cyPmClockBackup.masterClkSrc) ||
412        (CY_PM_MASTER_CLK_SRC_PLL == cyPmClockBackup.masterClkSrc))
413     {
414         /* Restore Master clock divider */
415         if(CY_PM_CLKDIST_MSTR0_REG != cyPmClockBackup.clkSyncDiv)
416         {
417             CyMasterClk_SetDivider(cyPmClockBackup.clkSyncDiv);
418         }
419
420         /* Restore Master clock source */
421         CyMasterClk_SetSource(cyPmClockBackup.masterClkSrc);
422     }
423
424     /* Bus clock - restore divider, if needed */
425     clkBusDivTmp = (uint16) ((uint16)CY_PM_CLK_BUS_MSB_DIV_REG << 8u);
426     clkBusDivTmp |= CY_PM_CLK_BUS_LSB_DIV_REG;
427     if(cyPmClockBackup.clkBusDiv != clkBusDivTmp)
428     {
429         CyBusClk_SetDivider(cyPmClockBackup.clkBusDiv);
430     }
431
432     /* Restore flash wait cycles */
433     CY_PM_CACHE_CR_REG = ((CY_PM_CACHE_CR_REG & ((uint8)(~CY_PM_CACHE_CR_CYCLES_MASK))) |
434                            cyPmClockBackup.flashWaitCycles);
435
436     /* Digital and analog clocks - restore state */
437     CY_PM_ACT_CFG1_REG = cyPmClockBackup.enClkA;
438     CY_PM_ACT_CFG2_REG = cyPmClockBackup.enClkD;
439 }
440
441
442 /*******************************************************************************
443 * Function Name: CyPmAltAct
444 ********************************************************************************
445 *
446 * Summary:
447 *  Puts the part into the Alternate Active (Standby) state. The Alternate Active
448 *  state can allow for any of the capabilities of the device to be active, but
449 *  the operation of this function is dependent on the CPU being disabled during
450 *  the Alternate Active state. The configuration code and the component APIs
451 *  will configure the template for the Alternate Active state to be the same as
452 *  the Active state with the exception that the CPU will be disabled during
453 *  Alternate Active.
454 *
455 *  Note Before calling this function, you must manually configure the power mode
456 *  of the source clocks for the timer that is used as the wakeup timer.
457 *
458 *  PSoC 3:
459 *  Before switching to Alternate Active, if a wakeupTime other than NONE is
460 *  specified, then the appropriate timer state is configured as specified with
461 *  the interrupt for that timer disabled.  The wakeup source will be the
462 *  combination of the values specified in the wakeupSource and any timer
463 *  specified in the wakeupTime argument.  Once the wakeup condition is
464 *  satisfied, then all saved state is restored and the function returns in the
465 *  Active state.
466 *
467 *  Note that if the wakeupTime is made with a different value, the period before
468 *  the wakeup occurs can be significantly shorter than the specified time.  If
469 *  the next call is made with the same wakeupTime value, then the wakeup will
470 *  occur the specified period after the previous wakeup occurred.
471 *
472 *  If a wakeupTime other than NONE is specified, then upon exit the state of the
473 *  specified timer will be left as specified by wakeupTime with the timer
474 *  enabled and the interrupt disabled.  If the CTW, FTW or One PPS is already
475 *  configured for wakeup, for example with the SleepTimer or RTC components,
476 *  then specify NONE for the wakeupTime and include the appropriate source for
477 *  wakeupSource.
478 *
479 *  PSoC 5LP:
480 *  This function is used to both enter the Alternate Active mode and halt the
481 *  processor.  For PSoC 3 these two actions must be paired together.  With PSoC
482 *  5LP the processor can be halted independently with the __WFI() function from
483 *  the CMSIS library that is included in Creator.  This function should be used
484 *  instead when the action required is just to halt the processor until an
485 *  enabled interrupt occurs.
486 *
487 *  The wakeupTime parameter is not used for this device. It must be set to zero
488 *  (PM_ALT_ACT_TIME_NONE). The wake up time configuration can be done by a
489 *  separate component: the CTW wakeup interval should be configured with the
490 *  Sleep Timer component and one second interval should be configured with the
491 *  RTC component.
492 *
493 *  The wakeup behavior depends on wakeupSource parameter in the following
494 *  manner: upon function execution the device will be switched from Active to
495 *  Alternate Active mode and then the CPU will be halted. When an enabled wakeup
496 *  event occurs the device will return to Active mode.  Similarly when an
497 *  enabled interrupt occurs the CPU will be started. These two actions will
498 *  occur together provided that the event that occurs is an enabled wakeup
499 *  source and also generates an interrupt. If just the wakeup event occurs then
500 *  the device will be in Active mode, but the CPU will remain halted waiting for
501 *  an interrupt. If an interrupt occurs from something other than a wakeup
502 *  source, then the CPU will restart with the device in Alternate Active mode
503 *  until a wakeup event occurs.
504 *
505 *  For example, if CyPmAltAct(PM_ALT_ACT_TIME_NONE, PM_ALT_ACT_SRC_PICU) is
506 *  called and PICU interrupt occurs, the CPU will be started and device will be
507 *  switched into Active mode. And if CyPmAltAct(PM_ALT_ACT_TIME_NONE,
508 *  PM_ALT_ACT_SRC_NONE) is called and PICU interrupt occurs, the CPU will be
509 *  started while device remains in Alternate Active mode.
510 *
511 * Parameters:
512 *  wakeupTime: Specifies a timer wakeup source and the frequency of that
513 *              source. For PSoC 5LP this parameter is ignored.
514 *
515 *           Define                      Time
516 *  PM_ALT_ACT_TIME_NONE             None
517 *  PM_ALT_ACT_TIME_ONE_PPS          One PPS: 1 second
518 *  PM_ALT_ACT_TIME_CTW_2MS          CTW: 2 ms
519 *  PM_ALT_ACT_TIME_CTW_4MS          CTW: 4 ms
520 *  PM_ALT_ACT_TIME_CTW_8MS          CTW: 8 ms
521 *  PM_ALT_ACT_TIME_CTW_16MS         CTW: 16 ms
522 *  PM_ALT_ACT_TIME_CTW_32MS         CTW: 32 ms
523 *  PM_ALT_ACT_TIME_CTW_64MS         CTW: 64 ms
524 *  PM_ALT_ACT_TIME_CTW_128MS        CTW: 128 ms
525 *  PM_ALT_ACT_TIME_CTW_256MS        CTW: 256 ms
526 *  PM_ALT_ACT_TIME_CTW_512MS        CTW: 512 ms
527 *  PM_ALT_ACT_TIME_CTW_1024MS       CTW: 1024 ms
528 *  PM_ALT_ACT_TIME_CTW_2048MS       CTW: 2048 ms
529 *  PM_ALT_ACT_TIME_CTW_4096MS       CTW: 4096 ms
530 *  PM_ALT_ACT_TIME_FTW(1-256)*       FTW: 10us to 2.56 ms
531 *
532 *  *Note:   PM_ALT_ACT_TIME_FTW() is a macro that takes an argument that
533 *           specifies how many increments of 10 us to delay.
534             For PSoC 3 silicon the valid range of  values is 1 to 256.
535 *
536 *  wakeUpSource:    Specifies a bitwise mask of wakeup sources. In addition, if
537 *                   a wakeupTime has been specified the associated timer will be
538 *                   included as a wakeup source.
539 *
540 *           Define                      Source
541 *  PM_ALT_ACT_SRC_NONE              None
542 *  PM_ALT_ACT_SRC_COMPARATOR0       Comparator 0
543 *  PM_ALT_ACT_SRC_COMPARATOR1       Comparator 1
544 *  PM_ALT_ACT_SRC_COMPARATOR2       Comparator 2
545 *  PM_ALT_ACT_SRC_COMPARATOR3       Comparator 3
546 *  PM_ALT_ACT_SRC_INTERRUPT         Interrupt
547 *  PM_ALT_ACT_SRC_PICU              PICU
548 *  PM_ALT_ACT_SRC_I2C               I2C
549 *  PM_ALT_ACT_SRC_BOOSTCONVERTER    Boost Converter
550 *  PM_ALT_ACT_SRC_FTW               Fast Timewheel*
551 *  PM_ALT_ACT_SRC_VD                High and Low Voltage Detection (HVI, LVI)*
552 *  PM_ALT_ACT_SRC_CTW               Central Timewheel**
553 *  PM_ALT_ACT_SRC_ONE_PPS           One PPS**
554 *  PM_ALT_ACT_SRC_LCD               LCD
555 *
556 *  *Note : FTW and HVI/LVI wakeup signals are in the same mask bit.
557 *  **Note: CTW and One PPS wakeup signals are in the same mask bit.
558 *
559 *  When specifying a Comparator as the wakeupSource an instance specific define
560 *  should be used that will track with the specific comparator that the instance
561 *  is placed into. As an example, for a Comparator instance named MyComp the
562 *  value to OR into the mask is: MyComp_ctComp__CMP_MASK.
563 *
564 *  When CTW, FTW or One PPS is used as a wakeup source, the CyPmReadStatus()
565 *  function must be called upon wakeup with corresponding parameter. Please
566 *  refer to the CyPmReadStatus() API in the System Reference Guide for more
567 *  information.
568 *
569 * Return:
570 *  None
571 *
572 * Reentrant:
573 *  No
574 *
575 * Side Effects:
576 *  If a wakeupTime other than NONE is specified, then upon exit the state of the
577 *  specified timer will be left as specified by wakeupTime with the timer
578 *  enabled and the interrupt disabled.  Also, the ILO 1 KHz (if CTW timer is
579 *  used as wakeup time) or ILO 100 KHz (if FTW timer is used as wakeup time)
580 *  will be left started.
581 *
582 *******************************************************************************/
583 void CyPmAltAct(uint16 wakeupTime, uint16 wakeupSource) 
584 {
585     #if(CY_PSOC5)
586
587         /* Arguments expected to be 0 */
588         CYASSERT(PM_ALT_ACT_TIME_NONE == wakeupTime);
589
590         if(0u != wakeupTime)
591         {
592             /* To remove unreferenced local variable warning */
593         }
594
595     #endif /* (CY_PSOC5) */
596
597
598     #if(CY_PSOC3)
599
600         /* FTW - save current and set new configuration */
601         if((wakeupTime >= PM_ALT_ACT_TIME_FTW(1u)) && (wakeupTime <= PM_ALT_ACT_TIME_FTW(256u)))
602         {
603             CyPmFtwSetInterval(PM_ALT_ACT_FTW_INTERVAL(wakeupTime));
604
605             /* Include associated timer to the wakeupSource */
606             wakeupSource |= PM_ALT_ACT_SRC_FTW;
607         }
608
609         /* CTW - save current and set new configuration */
610         if((wakeupTime >= PM_ALT_ACT_TIME_CTW_2MS) && (wakeupTime <= PM_ALT_ACT_TIME_CTW_4096MS))
611         {
612             /* Save current CTW configuration and set new one */
613             CyPmCtwSetInterval((uint8)(wakeupTime - 1u));
614
615             /* Include associated timer to the wakeupSource */
616             wakeupSource |= PM_ALT_ACT_SRC_CTW;
617         }
618
619         /* 1PPS - save current and set new configuration */
620         if(PM_ALT_ACT_TIME_ONE_PPS == wakeupTime)
621         {
622             /* Save current 1PPS configuration and set new one */
623             CyPmOppsSet();
624
625             /* Include associated timer to the wakeupSource */
626             wakeupSource |= PM_ALT_ACT_SRC_ONE_PPS;
627         }
628
629     #endif /* (CY_PSOC3) */
630
631
632     /* Save and set new wake up configuration */
633
634     /* Interrupt, PICU, I2C, Boost converter, CTW/1PPS */
635     cyPmBackup.wakeupCfg0 = CY_PM_WAKEUP_CFG0_REG;
636     CY_PM_WAKEUP_CFG0_REG = (uint8) (wakeupSource >> 4u);
637
638     /* Comparators */
639     cyPmBackup.wakeupCfg1 = CY_PM_WAKEUP_CFG1_REG;
640     CY_PM_WAKEUP_CFG1_REG = (((uint8) wakeupSource) & CY_PM_WAKEUP_SRC_CMPS_MASK);
641
642     /* LCD */
643     cyPmBackup.wakeupCfg2 = CY_PM_WAKEUP_CFG2_REG;
644     CY_PM_WAKEUP_CFG2_REG = ((uint8) ((wakeupSource >> 12u) & 0x01u));
645
646
647     /* Switch to the Alternate Active mode */
648     CY_PM_MODE_CSR_REG = ((CY_PM_MODE_CSR_REG & ((uint8)(~CY_PM_MODE_CSR_MASK))) | CY_PM_MODE_CSR_ALT_ACT);
649
650     /* Recommended readback. */
651     (void) CY_PM_MODE_CSR_REG;
652
653     /* Two recommended NOPs to get into the mode. */
654     CY_NOP;
655     CY_NOP;
656
657     /* Execute WFI instruction (for ARM-based devices only) */
658     CY_PM_WFI;
659
660     /* Point of return from Alternate Active Mode */
661
662     /* Restore wake up configuration */
663     CY_PM_WAKEUP_CFG0_REG = cyPmBackup.wakeupCfg0;
664     CY_PM_WAKEUP_CFG1_REG = cyPmBackup.wakeupCfg1;
665     CY_PM_WAKEUP_CFG2_REG = cyPmBackup.wakeupCfg2;
666 }
667
668
669 /*******************************************************************************
670 * Function Name: CyPmSleep
671 ********************************************************************************
672 *
673 * Summary:
674 *  Puts the part into the Sleep state.
675 *
676 *  Note Before calling this function, you must manually configure the power
677 *  mode of the source clocks for the timer that is used as wakeup timer.
678 *
679 *  Note Before calling this function, you must prepare clock tree configuration
680 *  for the low power mode by calling CyPmSaveClocks(). And restore clock
681 *  configuration after CyPmSleep() execution by calling CyPmRestoreClocks(). See
682 *  Power Management section, Clock Configuration subsection of the System
683 *  Reference Guide for more information.
684 *
685 *  PSoC 3:
686 *  Before switching to Sleep, if a wakeupTime other than NONE is specified,
687 *  then the appropriate timer state is configured as specified with the
688 *  interrupt for that timer disabled.  The wakeup source will be the combination
689 *  of the values specified in the wakeupSource and any timer specified in the
690 *  wakeupTime argument.  Once the wakeup condition is satisfied, then all saved
691 *  state is restored and the function returns in the Active state.
692 *
693 *  Note that if the wakeupTime is made with a different value, the period before
694 *  the wakeup occurs can be significantly shorter than the specified time.  If
695 *  the next call is made with the same wakeupTime value, then the wakeup will
696 *  occur the specified period after the previous wakeup occurred.
697 *
698 *  If a wakeupTime other than NONE is specified, then upon exit the state of the
699 *  specified timer will be left as specified by wakeupTime with the timer
700 *  enabled and the interrupt disabled.  If the CTW or One PPS is already
701 *  configured for wakeup, for example with the SleepTimer or RTC components,
702 *  then specify NONE for the wakeupTime and include the appropriate source for
703 *  wakeupSource.
704 *
705 *  PSoC 5LP:
706 *  The wakeupTime parameter is not used and the only NONE can be specified.
707 *  The wakeup time must be configured with the component, SleepTimer for CTW
708 *  intervals and RTC for 1PPS interval. The component must be configured to
709 *  generate an interrrupt.
710 *
711 * Parameters:
712 *  wakeupTime:      Specifies a timer wakeup source and the frequency of that
713 *                   source. For PSoC 5LP, this parameter is ignored.
714 *
715 *           Define                      Time
716 *  PM_SLEEP_TIME_NONE               None
717 *  PM_SLEEP_TIME_ONE_PPS            One PPS: 1 second
718 *  PM_SLEEP_TIME_CTW_2MS            CTW: 2 ms
719 *  PM_SLEEP_TIME_CTW_4MS            CTW: 4 ms
720 *  PM_SLEEP_TIME_CTW_8MS            CTW: 8 ms
721 *  PM_SLEEP_TIME_CTW_16MS           CTW: 16 ms
722 *  PM_SLEEP_TIME_CTW_32MS           CTW: 32 ms
723 *  PM_SLEEP_TIME_CTW_64MS           CTW: 64 ms
724 *  PM_SLEEP_TIME_CTW_128MS          CTW: 128 ms
725 *  PM_SLEEP_TIME_CTW_256MS          CTW: 256 ms
726 *  PM_SLEEP_TIME_CTW_512MS          CTW: 512 ms
727 *  PM_SLEEP_TIME_CTW_1024MS         CTW: 1024 ms
728 *  PM_SLEEP_TIME_CTW_2048MS         CTW: 2048 ms
729 *  PM_SLEEP_TIME_CTW_4096MS         CTW: 4096 ms
730 *
731 *  wakeUpSource:    Specifies a bitwise mask of wakeup sources. In addition, if
732 *                   a wakeupTime has been specified the associated timer will be
733 *                   included as a wakeup source.
734 *
735 *           Define                      Source
736 *  PM_SLEEP_SRC_NONE                None
737 *  PM_SLEEP_SRC_COMPARATOR0         Comparator 0
738 *  PM_SLEEP_SRC_COMPARATOR1         Comparator 1
739 *  PM_SLEEP_SRC_COMPARATOR2         Comparator 2
740 *  PM_SLEEP_SRC_COMPARATOR3         Comparator 3
741 *  PM_SLEEP_SRC_PICU                PICU
742 *  PM_SLEEP_SRC_I2C                 I2C
743 *  PM_SLEEP_SRC_BOOSTCONVERTER      Boost Converter
744 *  PM_SLEEP_SRC_VD                  High and Low Voltage Detection (HVI, LVI)
745 *  PM_SLEEP_SRC_CTW                 Central Timewheel*
746 *  PM_SLEEP_SRC_ONE_PPS             One PPS*
747 *  PM_SLEEP_SRC_LCD                 LCD
748 *
749 *  *Note:   CTW and One PPS wakeup signals are in the same mask bit.
750 *
751 *  When specifying a Comparator as the wakeupSource an instance specific define
752 *  should be used that will track with the specific comparator that the instance
753 *  is placed into. As an example for a Comparator instance named MyComp the
754 *  value to OR into the mask is: MyComp_ctComp__CMP_MASK.
755 *
756 *  When CTW or One PPS is used as a wakeup source, the CyPmReadStatus()
757 *  function must be called upon wakeup with corresponding parameter. Please
758 *  refer to the CyPmReadStatus() API in the System Reference Guide for more
759 *  information.
760 *
761 * Return:
762 *  None
763 *
764 * Reentrant:
765 *  No
766 *
767 * Side Effects and Restrictions:
768 *  If a wakeupTime other than NONE is specified, then upon exit the state of the
769 *  specified timer will be left as specified by wakeupTime with the timer
770 *  enabled and the interrupt disabled. Also, the ILO 1 KHz (if CTW timer is
771 *  used as wake up time) will be left started.
772 *
773 *  The 1 kHz ILO clock is expected to be enabled for PSoC 3 and PSoC 5LP to
774 *  measure Hibernate/Sleep regulator settling time after a reset. The holdoff
775 *  delay is measured using rising edges of the 1 kHz ILO.
776 *
777 *  For PSoC 3 silicon hardware buzz should be disabled before entering a sleep
778 *  power mode. It is disabled by PSoC Creator during startup.
779 *  If a Low Voltage Interrupt (LVI), High Voltage Interrupt (HVI) or Brown Out
780 *  detect (power supply supervising capabilities) are required in a design
781 *  during sleep, use the Central Time Wheel (CTW) to periodically wake the
782 *  device, perform software buzz, and refresh the supervisory services. If LVI,
783 *  HVI, or Brown Out is not required, then use of the CTW is not required.
784 *  Refer to the device errata for more information.
785 *
786 *******************************************************************************/
787 void CyPmSleep(uint8 wakeupTime, uint16 wakeupSource) 
788 {
789     uint8 interruptState;
790
791     /* Save current global interrupt enable and disable it */
792     interruptState = CyEnterCriticalSection();
793
794
795     /***********************************************************************
796     * The Hibernate/Sleep regulator has a settling time after a reset.
797     * During this time, the system ignores requests to enter Sleep and
798     * Hibernate modes. The holdoff delay is measured using rising edges of
799     * the 1 kHz ILO.
800     ***********************************************************************/
801     if(0u == (CY_PM_MODE_CSR_REG & CY_PM_MODE_CSR_PWRUP_PULSE_Q))
802     {
803         /* Disable hold off - no action on restore */
804         CY_PM_PWRSYS_SLP_TR_REG &= CY_PM_PWRSYS_SLP_TR_HIBSLP_HOLDOFF_MASK;
805     }
806     else
807     {
808         /* Abort, device is not ready for low power mode entry */
809
810         /* Restore global interrupt enable state */
811         CyExitCriticalSection(interruptState);
812
813         return;
814     }
815
816
817     /***********************************************************************
818     * PSoC3 < TO6:
819     * - Hardware buzz must be disabled before sleep mode entry.
820     * - Voltage supervision (HVI/LVI) requires hardware buzz, so they must
821     *   be aslo disabled.
822     *
823     * PSoC3 >= TO6:
824     * - Voltage supervision (HVI/LVI) requires hardware buzz, so hardware buzz must be
825     *   enabled before sleep mode entry and restored on wakeup.
826     ***********************************************************************/
827     #if(CY_PSOC3)
828
829         /* Silicon Revision ID is below TO6 */
830         if(CYDEV_CHIP_REV_ACTUAL < 5u)
831         {
832             /* Hardware buzz expected to be disabled in Sleep mode */
833             CYASSERT(0u == (CY_PM_PWRSYS_WAKE_TR2_REG & CY_PM_PWRSYS_WAKE_TR2_EN_BUZZ));
834         }
835
836
837         if(0u != (CY_PM_RESET_CR1_REG & (CY_PM_RESET_CR1_HVIA_EN |
838             CY_PM_RESET_CR1_LVIA_EN | CY_PM_RESET_CR1_LVID_EN)))
839         {
840             if(CYDEV_CHIP_REV_ACTUAL < 5u)
841             {
842                 /* LVI/HVI requires hardware buzz to be enabled */
843                 CYASSERT(0u != 0u);
844             }
845             else
846             {
847                 if (0u == (CY_PM_PWRSYS_WAKE_TR2_REG & CY_PM_PWRSYS_WAKE_TR2_EN_BUZZ))
848                 {
849                     cyPmBackup.hardwareBuzz = CY_PM_DISABLED;
850                     CY_PM_PWRSYS_WAKE_TR2_REG |= CY_PM_PWRSYS_WAKE_TR2_EN_BUZZ;
851                 }
852                 else
853                 {
854                     cyPmBackup.hardwareBuzz = CY_PM_ENABLED;
855                 }
856             }
857         }
858
859     #endif /* (CY_PSOC3) */
860
861
862     /*******************************************************************************
863     * For ARM-based devices, an interrupt is required for the CPU to wake up. The
864     * Power Management implementation assumes that wakeup time is configured with a
865     * separate component (component-based wakeup time configuration) for an
866     * interrupt to be issued on terminal count. For more information, refer to the
867     * Wakeup Time Configuration section of System Reference Guide.
868     *******************************************************************************/
869     #if(CY_PSOC5)
870
871         /* Arguments expected to be 0 */
872         CYASSERT(PM_SLEEP_TIME_NONE == wakeupTime);
873
874         if(0u != wakeupTime)
875         {
876             /* To remove unreferenced local variable warning */
877         }
878
879     #endif /* (CY_PSOC5) */
880
881
882     CyPmHibSlpSaveSet();
883
884
885     #if(CY_PSOC3)
886
887         /* CTW - save current and set new configuration */
888         if((wakeupTime >= PM_SLEEP_TIME_CTW_2MS) && (wakeupTime <= PM_SLEEP_TIME_CTW_4096MS))
889         {
890             /* Save current and set new configuration of the CTW */
891             CyPmCtwSetInterval((uint8)(wakeupTime - 1u));
892
893             /* Include associated timer to the wakeupSource */
894             wakeupSource |= PM_SLEEP_SRC_CTW;
895         }
896
897         /* 1PPS - save current and set new configuration */
898         if(PM_SLEEP_TIME_ONE_PPS == wakeupTime)
899         {
900             /* Save current and set new configuration of the 1PPS */
901             CyPmOppsSet();
902
903             /* Include associated timer to the wakeupSource */
904             wakeupSource |= PM_SLEEP_SRC_ONE_PPS;
905         }
906
907     #endif /* (CY_PSOC3) */
908
909
910     /* Save and set new wake up configuration */
911
912     /* Interrupt, PICU, I2C, Boost converter, CTW/1PPS */
913     cyPmBackup.wakeupCfg0 = CY_PM_WAKEUP_CFG0_REG;
914     CY_PM_WAKEUP_CFG0_REG = (uint8) (wakeupSource >> 4u);
915
916     /* Comparators */
917     cyPmBackup.wakeupCfg1 = CY_PM_WAKEUP_CFG1_REG;
918     CY_PM_WAKEUP_CFG1_REG = (((uint8) wakeupSource) & CY_PM_WAKEUP_SRC_CMPS_MASK);
919
920     /* LCD */
921     cyPmBackup.wakeupCfg2 = CY_PM_WAKEUP_CFG2_REG;
922     CY_PM_WAKEUP_CFG2_REG = ((uint8) ((wakeupSource >> 12u) & 0x01u));
923
924
925     /*******************************************************************
926     * Do not use merge region below unless any component datasheet
927     * suggest to do so.
928     *******************************************************************/
929     /* `#START CY_PM_JUST_BEFORE_SLEEP` */
930
931     /* `#END` */
932
933
934     /* Last moment IMO frequency change */
935     if(0u == (CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_FREQ_MASK))
936     {
937         /* IMO frequency is 12 MHz */
938         cyPmBackup.imoActFreq12Mhz = CY_PM_ENABLED;
939     }
940     else
941     {
942         /* IMO frequency is not 12 MHz */
943         cyPmBackup.imoActFreq12Mhz = CY_PM_DISABLED;
944
945         /* Save IMO frequency */
946         cyPmBackup.imoActFreq = CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_FREQ_MASK;
947
948         /* Set IMO frequency to 12 MHz */
949         CY_PM_FASTCLK_IMO_CR_REG &= ((uint8) (~CY_PM_FASTCLK_IMO_CR_FREQ_MASK));
950     }
951
952     /* Switch to the Sleep mode */
953     CY_PM_MODE_CSR_REG = ((CY_PM_MODE_CSR_REG & ((uint8)(~CY_PM_MODE_CSR_MASK))) | CY_PM_MODE_CSR_SLEEP);
954
955     /* Recommended readback. */
956     (void) CY_PM_MODE_CSR_REG;
957
958     /* Two recommended NOPs to get into the mode. */
959     CY_NOP;
960     CY_NOP;
961
962     /* Execute WFI instruction (for ARM-based devices only) */
963     CY_PM_WFI;
964
965     /* Point of return from Sleep Mode */
966
967     /* Restore last moment IMO frequency change */
968     if(CY_PM_ENABLED != cyPmBackup.imoActFreq12Mhz)
969     {
970         CY_PM_FASTCLK_IMO_CR_REG  = (CY_PM_FASTCLK_IMO_CR_REG & ((uint8)(~CY_PM_FASTCLK_IMO_CR_FREQ_MASK))) |
971                                     cyPmBackup.imoActFreq;
972     }
973
974
975     /*******************************************************************
976     * Do not use merge region below unless any component datasheet
977     * suggest to do so.
978     *******************************************************************/
979     /* `#START CY_PM_JUST_AFTER_WAKEUP_FROM_SLEEP` */
980
981     /* `#END` */
982
983
984     /* Restore hardware configuration */
985     CyPmHibSlpRestore();
986
987
988     /* Disable hardware buzz, if it was previously enabled */
989     #if(CY_PSOC3)
990
991         if(0u != (CY_PM_RESET_CR1_REG & (CY_PM_RESET_CR1_HVIA_EN |
992             CY_PM_RESET_CR1_LVIA_EN | CY_PM_RESET_CR1_LVID_EN)))
993         {
994             if(CYDEV_CHIP_REV_ACTUAL >= 5u)
995             {
996                 if (CY_PM_DISABLED == cyPmBackup.hardwareBuzz)
997                 {
998                     CY_PM_PWRSYS_WAKE_TR2_REG &= (uint8)(~CY_PM_PWRSYS_WAKE_TR2_EN_BUZZ);
999                 }
1000             }
1001         }
1002
1003     #endif /* (CY_PSOC3) */
1004
1005
1006     /* Restore current wake up configuration */
1007     CY_PM_WAKEUP_CFG0_REG = cyPmBackup.wakeupCfg0;
1008     CY_PM_WAKEUP_CFG1_REG = cyPmBackup.wakeupCfg1;
1009     CY_PM_WAKEUP_CFG2_REG = cyPmBackup.wakeupCfg2;
1010
1011     /* Restore global interrupt enable state */
1012     CyExitCriticalSection(interruptState);
1013 }
1014
1015
1016 /*******************************************************************************
1017 * Function Name: CyPmHibernate
1018 ********************************************************************************
1019 *
1020 * Summary:
1021 *  Puts the part into the Hibernate state.
1022 *
1023 *  PSoC 3 and PSoC 5LP:
1024 *  Before switching to Hibernate, the current status of the PICU wakeup source
1025 *  bit is saved and then set. This configures the device to wake up from the
1026 *  PICU. Make sure you have at least one pin configured to generate a PICU
1027 *  interrupt. For pin Px.y, the register "PICU_INTTYPE_PICUx_INTTYPEy" controls
1028 *  the PICU behavior. In the TRM, this register is "PICU[0..15]_INTTYPE[0..7]."
1029 *  In the Pins component datasheet, this register is referred to as the IRQ
1030 *  option. Once the wakeup occurs, the PICU wakeup source bit is restored and
1031 *  the PSoC returns to the Active state.
1032 *
1033 * Parameters:
1034 *  None
1035 *
1036 * Return:
1037 *  None
1038 *
1039 * Reentrant:
1040 *  No
1041 *
1042 * Side Effects:
1043 *  Applications must wait 20 us before re-entering hibernate or sleep after
1044 *  waking up from hibernate. The 20 us allows the sleep regulator time to
1045 *  stabilize before the next hibernate / sleep event occurs. The 20 us
1046 *  requirement begins when the device wakes up. There is no hardware check that
1047 *  this requirement is met. The specified delay should be done on ISR entry.
1048 *
1049 *  After wakeup PICU interrupt occurs, the Pin_ClearInterrupt() (where Pin is
1050 *  instance name of the Pins component) function must be called to clear the
1051 *  latched pin events to allow proper Hibernate mode entry andd to enable
1052 *  detection of future events.
1053 *
1054 *  The 1 kHz ILO clock is expected to be enabled for PSoC 3 and PSoC 5LP to
1055 *  measure Hibernate/Sleep regulator settling time after a reset. The holdoff
1056 *  delay is measured using rising edges of the 1 kHz ILO.
1057 *
1058 *******************************************************************************/
1059 void CyPmHibernate(void) 
1060 {
1061     uint8 interruptState;
1062
1063     /* Save current global interrupt enable and disable it */
1064     interruptState = CyEnterCriticalSection();
1065
1066         /***********************************************************************
1067         * The Hibernate/Sleep regulator has a settling time after a reset.
1068         * During this time, the system ignores requests to enter Sleep and
1069         * Hibernate modes. The holdoff delay is measured using rising edges of
1070         * the 1 kHz ILO.
1071         ***********************************************************************/
1072         if(0u == (CY_PM_MODE_CSR_REG & CY_PM_MODE_CSR_PWRUP_PULSE_Q))
1073         {
1074             /* Disable hold off - no action on restore */
1075             CY_PM_PWRSYS_SLP_TR_REG &= CY_PM_PWRSYS_SLP_TR_HIBSLP_HOLDOFF_MASK;
1076         }
1077         else
1078         {
1079             /* Abort, device is not ready for low power mode entry */
1080
1081             /* Restore global interrupt enable state */
1082             CyExitCriticalSection(interruptState);
1083
1084             return;
1085         }
1086
1087     CyPmHibSaveSet();
1088
1089
1090     /* Save and enable only wakeup on PICU */
1091     cyPmBackup.wakeupCfg0 = CY_PM_WAKEUP_CFG0_REG;
1092     CY_PM_WAKEUP_CFG0_REG = CY_PM_WAKEUP_PICU;
1093
1094     cyPmBackup.wakeupCfg1 = CY_PM_WAKEUP_CFG1_REG;
1095     CY_PM_WAKEUP_CFG1_REG = 0x00u;
1096
1097     cyPmBackup.wakeupCfg2 = CY_PM_WAKEUP_CFG2_REG;
1098     CY_PM_WAKEUP_CFG2_REG = 0x00u;
1099
1100
1101     /* Last moment IMO frequency change */
1102     if(0u == (CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_FREQ_MASK))
1103     {
1104         /* IMO frequency is 12 MHz */
1105         cyPmBackup.imoActFreq12Mhz = CY_PM_ENABLED;
1106     }
1107     else
1108     {
1109         /* IMO frequency is not 12 MHz */
1110         cyPmBackup.imoActFreq12Mhz = CY_PM_DISABLED;
1111
1112         /* Save IMO frequency */
1113         cyPmBackup.imoActFreq = CY_PM_FASTCLK_IMO_CR_REG & CY_PM_FASTCLK_IMO_CR_FREQ_MASK;
1114
1115         /* Set IMO frequency to 12 MHz */
1116         CY_PM_FASTCLK_IMO_CR_REG &= ((uint8) (~CY_PM_FASTCLK_IMO_CR_FREQ_MASK));
1117     }
1118
1119
1120     /* Switch to Hibernate Mode */
1121     CY_PM_MODE_CSR_REG = (CY_PM_MODE_CSR_REG & ((uint8) (~CY_PM_MODE_CSR_MASK))) | CY_PM_MODE_CSR_HIBERNATE;
1122
1123     /* Recommended readback. */
1124     (void) CY_PM_MODE_CSR_REG;
1125
1126     /* Two recommended NOPs to get into the mode. */
1127     CY_NOP;
1128     CY_NOP;
1129
1130     /* Execute WFI instruction (for ARM-based devices only) */
1131     CY_PM_WFI;
1132
1133
1134     /* Point of return from Hibernate mode */
1135
1136
1137     /* Restore last moment IMO frequency change */
1138     if(CY_PM_ENABLED != cyPmBackup.imoActFreq12Mhz)
1139     {
1140         CY_PM_FASTCLK_IMO_CR_REG  = (CY_PM_FASTCLK_IMO_CR_REG & ((uint8)(~CY_PM_FASTCLK_IMO_CR_FREQ_MASK))) |
1141                                     cyPmBackup.imoActFreq;
1142     }
1143
1144
1145     /* Restore device for proper Hibernate mode exit*/
1146     CyPmHibRestore();
1147
1148     /* Restore current wake up configuration */
1149     CY_PM_WAKEUP_CFG0_REG = cyPmBackup.wakeupCfg0;
1150     CY_PM_WAKEUP_CFG1_REG = cyPmBackup.wakeupCfg1;
1151     CY_PM_WAKEUP_CFG2_REG = cyPmBackup.wakeupCfg2;
1152
1153     /* Restore global interrupt enable state */
1154     CyExitCriticalSection(interruptState);
1155 }
1156
1157
1158 /*******************************************************************************
1159 * Function Name: CyPmReadStatus
1160 ********************************************************************************
1161 *
1162 * Summary:
1163 *  Manages the Power Manager Interrupt Status Register.  This register has the
1164 *  interrupt status for the one pulse per second, central timewheel and fast
1165 *  timewheel timers.  This hardware register clears on read.  To allow for only
1166 *  clearing the bits of interest and preserving the other bits, this function
1167 *  uses a shadow register that retains the state.  This function reads the
1168 *  status register and ORs that value with the shadow register.  That is the
1169 *  value that is returned.  Then the bits in the mask that are set are cleared
1170 *  from this value and written back to the shadow register.
1171 *
1172 *  Note You must call this function within 1 ms (1 clock cycle of the ILO)
1173 *  after a CTW event has occurred.
1174 *
1175 * Parameters:
1176 *  mask: Bits in the shadow register to clear.
1177 *
1178 *       Define                      Source
1179 *  CY_PM_FTW_INT                Fast Timewheel
1180 *  CY_PM_CTW_INT                Central Timewheel
1181 *  CY_PM_ONEPPS_INT             One Pulse Per Second
1182 *
1183 * Return:
1184 *  Status.  Same bits values as the mask parameter.
1185 *
1186 *******************************************************************************/
1187 uint8 CyPmReadStatus(uint8 mask) 
1188 {
1189     static uint8 interruptStatus;
1190     uint8 interruptState;
1191     uint8 tmpStatus;
1192
1193     /* Enter critical section */
1194     interruptState = CyEnterCriticalSection();
1195
1196     /* Save value of the register, copy it and clear desired bit */
1197     interruptStatus |= CY_PM_INT_SR_REG;
1198     tmpStatus = interruptStatus;
1199     interruptStatus &= ((uint8)(~mask));
1200
1201     /* Exit critical section */
1202     CyExitCriticalSection(interruptState);
1203
1204     return(tmpStatus);
1205 }
1206
1207
1208 /*******************************************************************************
1209 * Function Name: CyPmHibSaveSet
1210 ********************************************************************************
1211 *
1212 * Summary:
1213 *  Prepare device for proper Hibernate low power mode entry:
1214 *  - Disables I2C backup regulator
1215 *  - Saves ILO power down mode state and enable it
1216 *  - Saves state of 1 kHz and 100 kHz ILO and disable them
1217 *  - Disables sleep regulator and shorts vccd to vpwrsleep
1218 *  - Save LVI/HVI configuration and disable them - CyPmHviLviSaveDisable()
1219 *  - CyPmHibSlpSaveSet() function is called
1220 *
1221 * Parameters:
1222 *  None
1223 *
1224 * Return:
1225 *  None
1226 *
1227 * Reentrant:
1228 *  No
1229 *
1230 *******************************************************************************/
1231 static void CyPmHibSaveSet(void) 
1232 {
1233     /* I2C backup reg must be off when the sleep regulator is unavailable */
1234     if(0u != (CY_PM_PWRSYS_CR1_REG & CY_PM_PWRSYS_CR1_I2CREG_BACKUP))
1235     {
1236         /***********************************************************************
1237         * If I2C backup regulator is enabled, all the fixed-function registers
1238         * store their values while device is in low power mode, otherwise their
1239         * configuration is lost. The I2C API makes a decision to restore or not
1240         * to restore I2C registers based on this. If this regulator will be
1241         * disabled and then enabled, I2C API will suppose that I2C block
1242         * registers preserved their values, while this is not true. So, the
1243         * backup regulator is disabled. The I2C sleep APIs is responsible for
1244         * restoration.
1245         ***********************************************************************/
1246
1247         /* Disable I2C backup register */
1248         CY_PM_PWRSYS_CR1_REG &= ((uint8)(~CY_PM_PWRSYS_CR1_I2CREG_BACKUP));
1249     }
1250
1251
1252     /* Save current ILO power mode and ensure low power mode */
1253     cyPmBackup.iloPowerMode = CyILO_SetPowerMode(CY_PM_POWERDOWN_MODE);
1254
1255     /* Save current 1kHz ILO enable state. Disabled automatically. */
1256     cyPmBackup.ilo1kEnable = (0u == (CY_PM_SLOWCLK_ILO_CR0_REG & CY_PM_ILO_CR0_EN_1K)) ?
1257                                 CY_PM_DISABLED : CY_PM_ENABLED;
1258
1259     /* Save current 100kHz ILO enable state. Disabled automatically. */
1260     cyPmBackup.ilo100kEnable = (0u == (CY_PM_SLOWCLK_ILO_CR0_REG & CY_PM_ILO_CR0_EN_100K)) ?
1261                                 CY_PM_DISABLED : CY_PM_ENABLED;
1262
1263
1264     /* Disable the sleep regulator and shorts vccd to vpwrsleep */
1265     if(0u == (CY_PM_PWRSYS_SLP_TR_REG & CY_PM_PWRSYS_SLP_TR_BYPASS))
1266     {
1267         /* Save current bypass state */
1268         cyPmBackup.slpTrBypass = CY_PM_DISABLED;
1269         CY_PM_PWRSYS_SLP_TR_REG |= CY_PM_PWRSYS_SLP_TR_BYPASS;
1270     }
1271     else
1272     {
1273         cyPmBackup.slpTrBypass = CY_PM_ENABLED;
1274     }
1275
1276     /* LPCOMPs are always enabled (even when BOTH ext_vccd=1 and ext_vcca=1)*/
1277
1278
1279     /***************************************************************************
1280     * LVI/HVI must be disabled in Hibernate
1281     ***************************************************************************/
1282
1283     /* Save LVI/HVI configuration and disable them */
1284     CyPmHviLviSaveDisable();
1285
1286
1287     /* Make the same preparations for Hibernate and Sleep modes */
1288     CyPmHibSlpSaveSet();
1289
1290
1291     /***************************************************************************
1292     * Save and set power mode wakeup trim registers
1293     ***************************************************************************/
1294     cyPmBackup.wakeupTrim0 = CY_PM_PWRSYS_WAKE_TR0_REG;
1295     cyPmBackup.wakeupTrim1 = CY_PM_PWRSYS_WAKE_TR1_REG;
1296
1297     CY_PM_PWRSYS_WAKE_TR0_REG = CY_PM_PWRSYS_WAKE_TR0;
1298     CY_PM_PWRSYS_WAKE_TR1_REG = CY_PM_PWRSYS_WAKE_TR1;
1299 }
1300
1301
1302 /*******************************************************************************
1303 * Function Name: CyPmHibRestore
1304 ********************************************************************************
1305 *
1306 * Summary:
1307 *  Restore device for proper Hibernate mode exit:
1308 *  - Restore LVI/HVI configuration - call CyPmHviLviRestore()
1309 *  - CyPmHibSlpSaveRestore() function is called
1310 *  - Restores ILO power down mode state and enable it
1311 *  - Restores state of 1 kHz and 100 kHz ILO and disable them
1312 *  - Restores sleep regulator settings
1313 *
1314 * Parameters:
1315 *  None
1316 *
1317 * Return:
1318 *  None
1319 *
1320 *******************************************************************************/
1321 static void CyPmHibRestore(void) 
1322 {
1323     /* Restore LVI/HVI configuration */
1324     CyPmHviLviRestore();
1325
1326     /* Restore the same configuration for Hibernate and Sleep modes */
1327     CyPmHibSlpRestore();
1328
1329     /* Restore 1kHz ILO enable state */
1330     if(CY_PM_ENABLED == cyPmBackup.ilo1kEnable)
1331     {
1332         /* Enable 1kHz ILO */
1333         CyILO_Start1K();
1334     }
1335
1336     /* Restore 100kHz ILO enable state */
1337     if(CY_PM_ENABLED == cyPmBackup.ilo100kEnable)
1338     {
1339         /* Enable 100kHz ILO */
1340         CyILO_Start100K();
1341     }
1342
1343     /* Restore ILO power mode */
1344     (void) CyILO_SetPowerMode(cyPmBackup.iloPowerMode);
1345
1346
1347     if(CY_PM_DISABLED == cyPmBackup.slpTrBypass)
1348     {
1349         /* Enable the sleep regulator */
1350         CY_PM_PWRSYS_SLP_TR_REG &= ((uint8)(~CY_PM_PWRSYS_SLP_TR_BYPASS));
1351     }
1352
1353
1354     /***************************************************************************
1355     * Restore power mode wakeup trim registers
1356     ***************************************************************************/
1357     CY_PM_PWRSYS_WAKE_TR0_REG = cyPmBackup.wakeupTrim0;
1358     CY_PM_PWRSYS_WAKE_TR1_REG = cyPmBackup.wakeupTrim1;
1359 }
1360
1361
1362 /*******************************************************************************
1363 * Function Name: CyPmCtwSetInterval
1364 ********************************************************************************
1365 *
1366 * Summary:
1367 *  Performs CTW configuration:
1368 *  - Disables CTW interrupt
1369 *  - Enables 1 kHz ILO
1370 *  - Sets new CTW interval
1371 *
1372 * Parameters:
1373 *  ctwInterval: the CTW interval to be set.
1374 *
1375 * Return:
1376 *  None
1377 *
1378 * Side Effects:
1379 *  Enables ILO 1 KHz clock and leaves it enabled.
1380 *
1381 *******************************************************************************/
1382 void CyPmCtwSetInterval(uint8 ctwInterval) 
1383 {
1384     /* Disable CTW interrupt enable */
1385     CY_PM_TW_CFG2_REG &= ((uint8)(~CY_PM_CTW_IE));
1386
1387     /* Enable 1kHz ILO (required for CTW operation) */
1388     CyILO_Start1K();
1389
1390     /* Interval could be set only while CTW is disabled */
1391     if(0u != (CY_PM_TW_CFG2_REG & CY_PM_CTW_EN))
1392     {
1393         /* Set CTW interval if needed */
1394         if(CY_PM_TW_CFG1_REG != ctwInterval)
1395         {
1396             /* Disable the CTW, set new CTW interval and enable it again */
1397             CY_PM_TW_CFG2_REG &= ((uint8)(~CY_PM_CTW_EN));
1398             CY_PM_TW_CFG1_REG = ctwInterval;
1399             CY_PM_TW_CFG2_REG |= CY_PM_CTW_EN;
1400         }   /* Required interval is already set */
1401     }
1402     else
1403     {
1404         /* Set CTW interval if needed */
1405         if(CY_PM_TW_CFG1_REG != ctwInterval)
1406         {
1407             /* Set the new CTW interval. Could be changed if CTW is disabled */
1408             CY_PM_TW_CFG1_REG = ctwInterval;
1409         }   /* Required interval is already set */
1410
1411         /* Enable the CTW */
1412         CY_PM_TW_CFG2_REG |= CY_PM_CTW_EN;
1413     }
1414 }
1415
1416
1417 /*******************************************************************************
1418 * Function Name: CyPmOppsSet
1419 ********************************************************************************
1420 *
1421 * Summary:
1422 *  Performs 1PPS configuration:
1423 *  - Starts 32 KHz XTAL
1424 *  - Disables 1PPS interupts
1425 *  - Enables 1PPS
1426 *
1427 * Parameters:
1428 *  None
1429 *
1430 * Return:
1431 *  None
1432 *
1433 *******************************************************************************/
1434 void CyPmOppsSet(void) 
1435 {
1436     /* Enable 32kHz XTAL if needed */
1437     if(0u == (CY_PM_SLOWCLK_X32_CR_REG & CY_PM_X32_CR_X32EN))
1438     {
1439         /* Enable 32kHz XTAL */
1440         CyXTAL_32KHZ_Start();
1441     }
1442
1443     /* Disable 1PPS interrupt enable */
1444     CY_PM_TW_CFG2_REG &= ((uint8)(~CY_PM_1PPS_IE));
1445
1446     /* Enable 1PPS operation */
1447     CY_PM_TW_CFG2_REG |= CY_PM_1PPS_EN;
1448 }
1449
1450
1451 /*******************************************************************************
1452 * Function Name: CyPmFtwSetInterval
1453 ********************************************************************************
1454 *
1455 * Summary:
1456 *  Performs FTW configuration:
1457 *  - Disables FTW interrupt
1458 *  - Enables 100 kHz ILO
1459 *  - Sets new FTW interval.
1460 *
1461 * Parameters:
1462 *  ftwInterval - FTW counter interval.
1463 *
1464 * Return:
1465 *  None
1466 *
1467 * Side Effects:
1468 *  Enables ILO 100 KHz clock and leaves it enabled.
1469 *
1470 *******************************************************************************/
1471 void CyPmFtwSetInterval(uint8 ftwInterval) 
1472 {
1473     /* Disable FTW interrupt enable */
1474     CY_PM_TW_CFG2_REG &= ((uint8)(~CY_PM_FTW_IE));
1475
1476     /* Enable 100kHz ILO */
1477     CyILO_Start100K();
1478
1479     /* Iterval could be set only while FTW is disabled */
1480     if(0u != (CY_PM_TW_CFG2_REG & CY_PM_FTW_EN))
1481     {
1482         /* Disable FTW, set new FTW interval if needed and enable it again */
1483         if(CY_PM_TW_CFG0_REG != ftwInterval)
1484         {
1485             /* Disable the CTW, set new CTW interval and enable it again */
1486             CY_PM_TW_CFG2_REG &= ((uint8)(~CY_PM_FTW_EN));
1487             CY_PM_TW_CFG0_REG = ftwInterval;
1488             CY_PM_TW_CFG2_REG |= CY_PM_FTW_EN;
1489         }   /* Required interval is already set */
1490     }
1491     else
1492     {
1493         /* Set new FTW counter interval if needed. FTW is disabled. */
1494         if(CY_PM_TW_CFG0_REG != ftwInterval)
1495         {
1496             /* Set the new CTW interval. Could be changed if CTW is disabled */
1497             CY_PM_TW_CFG0_REG = ftwInterval;
1498         }   /* Required interval is already set */
1499
1500         /* Enable the FTW */
1501         CY_PM_TW_CFG2_REG |= CY_PM_FTW_EN;
1502     }
1503 }
1504
1505
1506 /*******************************************************************************
1507 * Function Name: CyPmHibSlpSaveSet
1508 ********************************************************************************
1509 *
1510 * Summary:
1511 *  This API is used for preparing device for Sleep and Hibernate low power
1512 *  modes entry:
1513 *  - Saves COMP, VIDAC, DSM and SAR routing connections (PSoC 5)
1514 *  - Saves SC/CT routing connections (PSoC 3/5/5LP)
1515 *  - Disables Serial Wire Viewer (SWV) (PSoC 3)
1516 *  - Save boost reference selection and set it to internal
1517 *
1518 * Parameters:
1519 *  None
1520 *
1521 * Return:
1522 *  None
1523 *
1524 * Reentrant:
1525 *  No
1526 *
1527 *******************************************************************************/
1528 static void CyPmHibSlpSaveSet(void) 
1529 {
1530     /* Save SC/CT routing registers */
1531     cyPmBackup.scctData[0u]   = CY_GET_REG8(CYREG_SC0_SW0 );
1532     cyPmBackup.scctData[1u]   = CY_GET_REG8(CYREG_SC0_SW2 );
1533     cyPmBackup.scctData[2u]   = CY_GET_REG8(CYREG_SC0_SW3 );
1534     cyPmBackup.scctData[3u]   = CY_GET_REG8(CYREG_SC0_SW4 );
1535     cyPmBackup.scctData[4u]   = CY_GET_REG8(CYREG_SC0_SW6 );
1536     cyPmBackup.scctData[5u]   = CY_GET_REG8(CYREG_SC0_SW8 );
1537     cyPmBackup.scctData[6u]   = CY_GET_REG8(CYREG_SC0_SW10);
1538
1539     cyPmBackup.scctData[7u]   = CY_GET_REG8(CYREG_SC1_SW0 );
1540     cyPmBackup.scctData[8u]   = CY_GET_REG8(CYREG_SC1_SW2 );
1541     cyPmBackup.scctData[9u]   = CY_GET_REG8(CYREG_SC1_SW3 );
1542     cyPmBackup.scctData[10u]  = CY_GET_REG8(CYREG_SC1_SW4 );
1543     cyPmBackup.scctData[11u]  = CY_GET_REG8(CYREG_SC1_SW6 );
1544     cyPmBackup.scctData[12u]  = CY_GET_REG8(CYREG_SC1_SW8 );
1545     cyPmBackup.scctData[13u]  = CY_GET_REG8(CYREG_SC1_SW10);
1546
1547     cyPmBackup.scctData[14u]  = CY_GET_REG8(CYREG_SC2_SW0 );
1548     cyPmBackup.scctData[15u]  = CY_GET_REG8(CYREG_SC2_SW2 );
1549     cyPmBackup.scctData[16u]  = CY_GET_REG8(CYREG_SC2_SW3 );
1550     cyPmBackup.scctData[17u]  = CY_GET_REG8(CYREG_SC2_SW4 );
1551     cyPmBackup.scctData[18u]  = CY_GET_REG8(CYREG_SC2_SW6 );
1552     cyPmBackup.scctData[19u]  = CY_GET_REG8(CYREG_SC2_SW8 );
1553     cyPmBackup.scctData[20u]  = CY_GET_REG8(CYREG_SC2_SW10);
1554
1555     cyPmBackup.scctData[21u]  = CY_GET_REG8(CYREG_SC3_SW0 );
1556     cyPmBackup.scctData[22u]  = CY_GET_REG8(CYREG_SC3_SW2 );
1557     cyPmBackup.scctData[23u]  = CY_GET_REG8(CYREG_SC3_SW3 );
1558     cyPmBackup.scctData[24u]  = CY_GET_REG8(CYREG_SC3_SW4 );
1559     cyPmBackup.scctData[25u]  = CY_GET_REG8(CYREG_SC3_SW6 );
1560     cyPmBackup.scctData[26u]  = CY_GET_REG8(CYREG_SC3_SW8 );
1561     cyPmBackup.scctData[27u]  = CY_GET_REG8(CYREG_SC3_SW10);
1562
1563     CY_SET_REG8(CYREG_SC0_SW0 , 0u);
1564     CY_SET_REG8(CYREG_SC0_SW2 , 0u);
1565     CY_SET_REG8(CYREG_SC0_SW3 , 0u);
1566     CY_SET_REG8(CYREG_SC0_SW4 , 0u);
1567     CY_SET_REG8(CYREG_SC0_SW6 , 0u);
1568     CY_SET_REG8(CYREG_SC0_SW8 , 0u);
1569     CY_SET_REG8(CYREG_SC0_SW10, 0u);
1570
1571     CY_SET_REG8(CYREG_SC1_SW0 , 0u);
1572     CY_SET_REG8(CYREG_SC1_SW2 , 0u);
1573     CY_SET_REG8(CYREG_SC1_SW3 , 0u);
1574     CY_SET_REG8(CYREG_SC1_SW4 , 0u);
1575     CY_SET_REG8(CYREG_SC1_SW6 , 0u);
1576     CY_SET_REG8(CYREG_SC1_SW8 , 0u);
1577     CY_SET_REG8(CYREG_SC1_SW10, 0u);
1578
1579     CY_SET_REG8(CYREG_SC2_SW0 , 0u);
1580     CY_SET_REG8(CYREG_SC2_SW2 , 0u);
1581     CY_SET_REG8(CYREG_SC2_SW3 , 0u);
1582     CY_SET_REG8(CYREG_SC2_SW4 , 0u);
1583     CY_SET_REG8(CYREG_SC2_SW6 , 0u);
1584     CY_SET_REG8(CYREG_SC2_SW8 , 0u);
1585     CY_SET_REG8(CYREG_SC2_SW10, 0u);
1586
1587     CY_SET_REG8(CYREG_SC3_SW0 , 0u);
1588     CY_SET_REG8(CYREG_SC3_SW2 , 0u);
1589     CY_SET_REG8(CYREG_SC3_SW3 , 0u);
1590     CY_SET_REG8(CYREG_SC3_SW4 , 0u);
1591     CY_SET_REG8(CYREG_SC3_SW6 , 0u);
1592     CY_SET_REG8(CYREG_SC3_SW8 , 0u);
1593     CY_SET_REG8(CYREG_SC3_SW10, 0u);
1594
1595
1596     #if(CY_PSOC3)
1597
1598         /* Serial Wire Viewer (SWV) workaround */
1599
1600         /* Disable SWV before entering low power mode */
1601         if(0u != (CY_PM_MLOGIC_DBG_REG & CY_PM_MLOGIC_DBG_SWV_CLK_EN))
1602         {
1603             /* Save SWV clock enabled state */
1604             cyPmBackup.swvClkEnabled = CY_PM_ENABLED;
1605
1606             /* Save current ports drive mode settings */
1607             cyPmBackup.prt1Dm = CY_PM_PRT1_PC3_REG & ((uint8)(~CY_PM_PRT1_PC3_DM_MASK));
1608
1609             /* Set drive mode to strong output */
1610             CY_PM_PRT1_PC3_REG = (CY_PM_PRT1_PC3_REG & CY_PM_PRT1_PC3_DM_MASK) |
1611                                 CY_PM_PRT1_PC3_DM_STRONG;
1612
1613             /* Disable SWV clocks */
1614             CY_PM_MLOGIC_DBG_REG &= ((uint8)(~CY_PM_MLOGIC_DBG_SWV_CLK_EN));
1615         }
1616         else
1617         {
1618             /* Save SWV clock disabled state */
1619             cyPmBackup.swvClkEnabled = CY_PM_DISABLED;
1620         }
1621
1622     #endif  /* (CY_PSOC3) */
1623
1624
1625     /***************************************************************************
1626     * Save boost reference and set it to boost's internal by clearing the bit.
1627     * External (chip bandgap) reference is not available in Sleep and Hibernate.
1628     ***************************************************************************/
1629     if(0u != (CY_PM_BOOST_CR2_REG & CY_PM_BOOST_CR2_EREFSEL_EXT))
1630     {
1631         cyPmBackup.boostRefExt = CY_PM_ENABLED;
1632         CY_PM_BOOST_CR2_REG &= ((uint8)(~CY_PM_BOOST_CR2_EREFSEL_EXT));
1633     }
1634     else
1635     {
1636         cyPmBackup.boostRefExt = CY_PM_DISABLED;
1637     }
1638 }
1639
1640
1641 /*******************************************************************************
1642 * Function Name: CyPmHibSlpRestore
1643 ********************************************************************************
1644 *
1645 * Summary:
1646 *  This API is used for restoring device configurations after wakeup from Sleep
1647 *  and Hibernate low power modes:
1648 *  - Restores SC/CT routing connections
1649 *  - Restores enable state of Serial Wire Viewer (SWV) (PSoC 3)
1650 *  - Restore boost reference selection
1651 *
1652 * Parameters:
1653 *  None
1654 *
1655 * Return:
1656 *  None
1657 *
1658 *******************************************************************************/
1659 static void CyPmHibSlpRestore(void) 
1660 {
1661     /* Restore SC/CT routing registers */
1662     CY_SET_REG8(CYREG_SC0_SW0 , cyPmBackup.scctData[0u] );
1663     CY_SET_REG8(CYREG_SC0_SW2 , cyPmBackup.scctData[1u] );
1664     CY_SET_REG8(CYREG_SC0_SW3 , cyPmBackup.scctData[2u] );
1665     CY_SET_REG8(CYREG_SC0_SW4 , cyPmBackup.scctData[3u] );
1666     CY_SET_REG8(CYREG_SC0_SW6 , cyPmBackup.scctData[4u] );
1667     CY_SET_REG8(CYREG_SC0_SW8 , cyPmBackup.scctData[5u] );
1668     CY_SET_REG8(CYREG_SC0_SW10, cyPmBackup.scctData[6u] );
1669
1670     CY_SET_REG8(CYREG_SC1_SW0 , cyPmBackup.scctData[7u] );
1671     CY_SET_REG8(CYREG_SC1_SW2 , cyPmBackup.scctData[8u] );
1672     CY_SET_REG8(CYREG_SC1_SW3 , cyPmBackup.scctData[9u] );
1673     CY_SET_REG8(CYREG_SC1_SW4 , cyPmBackup.scctData[10u]);
1674     CY_SET_REG8(CYREG_SC1_SW6 , cyPmBackup.scctData[11u]);
1675     CY_SET_REG8(CYREG_SC1_SW8 , cyPmBackup.scctData[12u]);
1676     CY_SET_REG8(CYREG_SC1_SW10, cyPmBackup.scctData[13u]);
1677
1678     CY_SET_REG8(CYREG_SC2_SW0 , cyPmBackup.scctData[14u]);
1679     CY_SET_REG8(CYREG_SC2_SW2 , cyPmBackup.scctData[15u]);
1680     CY_SET_REG8(CYREG_SC2_SW3 , cyPmBackup.scctData[16u]);
1681     CY_SET_REG8(CYREG_SC2_SW4 , cyPmBackup.scctData[17u]);
1682     CY_SET_REG8(CYREG_SC2_SW6 , cyPmBackup.scctData[18u]);
1683     CY_SET_REG8(CYREG_SC2_SW8 , cyPmBackup.scctData[19u]);
1684     CY_SET_REG8(CYREG_SC2_SW10, cyPmBackup.scctData[20u]);
1685
1686     CY_SET_REG8(CYREG_SC3_SW0 , cyPmBackup.scctData[21u]);
1687     CY_SET_REG8(CYREG_SC3_SW2 , cyPmBackup.scctData[22u]);
1688     CY_SET_REG8(CYREG_SC3_SW3 , cyPmBackup.scctData[23u]);
1689     CY_SET_REG8(CYREG_SC3_SW4 , cyPmBackup.scctData[24u]);
1690     CY_SET_REG8(CYREG_SC3_SW6 , cyPmBackup.scctData[25u]);
1691     CY_SET_REG8(CYREG_SC3_SW8 , cyPmBackup.scctData[26u]);
1692     CY_SET_REG8(CYREG_SC3_SW10, cyPmBackup.scctData[27u]);
1693
1694
1695     #if(CY_PSOC3)
1696
1697         /* Serial Wire Viewer (SWV) workaround */
1698         if(CY_PM_ENABLED == cyPmBackup.swvClkEnabled)
1699         {
1700             /* Restore ports drive mode */
1701             CY_PM_PRT1_PC3_REG = (CY_PM_PRT1_PC3_REG & CY_PM_PRT1_PC3_DM_MASK) |
1702                                     cyPmBackup.prt1Dm;
1703
1704             /* Enable SWV clocks */
1705             CY_PM_MLOGIC_DBG_REG |= CY_PM_MLOGIC_DBG_SWV_CLK_EN;
1706         }
1707
1708     #endif /* (CY_PSOC3) */
1709
1710
1711     /* Restore boost reference */
1712     if(CY_PM_ENABLED == cyPmBackup.boostRefExt)
1713     {
1714         CY_PM_BOOST_CR2_REG |= CY_PM_BOOST_CR2_EREFSEL_EXT;
1715     }
1716 }
1717
1718
1719 /*******************************************************************************
1720 * Function Name: CyPmHviLviSaveDisable
1721 ********************************************************************************
1722 *
1723 * Summary:
1724 *  Saves analog and digital LVI and HVI configuration and disables them.
1725 *
1726 * Parameters:
1727 *  None
1728 *
1729 * Return:
1730 *  None
1731 *
1732 * Reentrant:
1733 *  No
1734 *
1735 *******************************************************************************/
1736 static void CyPmHviLviSaveDisable(void) 
1737 {
1738     if(0u != (CY_VD_LVI_HVI_CONTROL_REG & CY_VD_LVID_EN))
1739     {
1740         cyPmBackup.lvidEn = CY_PM_ENABLED;
1741         cyPmBackup.lvidTrip = CY_VD_LVI_TRIP_REG & CY_VD_LVI_TRIP_LVID_MASK;
1742
1743         /* Save state of reset device at a specified Vddd threshold */
1744         cyPmBackup.lvidRst = (0u == (CY_VD_PRES_CONTROL_REG & CY_VD_PRESD_EN)) ? \
1745                              CY_PM_DISABLED : CY_PM_ENABLED;
1746
1747         CyVdLvDigitDisable();
1748     }
1749     else
1750     {
1751         cyPmBackup.lvidEn = CY_PM_DISABLED;
1752     }
1753
1754     if(0u != (CY_VD_LVI_HVI_CONTROL_REG & CY_VD_LVIA_EN))
1755     {
1756         cyPmBackup.lviaEn = CY_PM_ENABLED;
1757         cyPmBackup.lviaTrip = CY_VD_LVI_TRIP_REG >> 4u;
1758
1759         /* Save state of reset device at a specified Vdda threshold */
1760         cyPmBackup.lviaRst = (0u == (CY_VD_PRES_CONTROL_REG & CY_VD_PRESA_EN)) ? \
1761                              CY_PM_DISABLED : CY_PM_ENABLED;
1762
1763         CyVdLvAnalogDisable();
1764     }
1765     else
1766     {
1767         cyPmBackup.lviaEn = CY_PM_DISABLED;
1768     }
1769
1770     if(0u != (CY_VD_LVI_HVI_CONTROL_REG & CY_VD_HVIA_EN))
1771     {
1772         cyPmBackup.hviaEn = CY_PM_ENABLED;
1773         CyVdHvAnalogDisable();
1774     }
1775     else
1776     {
1777         cyPmBackup.hviaEn = CY_PM_DISABLED;
1778     }
1779 }
1780
1781
1782 /*******************************************************************************
1783 * Function Name: CyPmHviLviRestore
1784 ********************************************************************************
1785 *
1786 * Summary:
1787 *  Restores analog and digital LVI and HVI configuration.
1788 *
1789 * Parameters:
1790 *  None
1791 *
1792 * Return:
1793 *  None
1794 *
1795 * Reentrant:
1796 *  No
1797 *
1798 *******************************************************************************/
1799 static void CyPmHviLviRestore(void) 
1800 {
1801     /* Restore LVI/HVI configuration */
1802     if(CY_PM_ENABLED == cyPmBackup.lvidEn)
1803     {
1804         CyVdLvDigitEnable(cyPmBackup.lvidRst, cyPmBackup.lvidTrip);
1805     }
1806
1807     if(CY_PM_ENABLED == cyPmBackup.lviaEn)
1808     {
1809         CyVdLvAnalogEnable(cyPmBackup.lviaRst, cyPmBackup.lviaTrip);
1810     }
1811
1812     if(CY_PM_ENABLED == cyPmBackup.hviaEn)
1813     {
1814         CyVdHvAnalogEnable();
1815     }
1816 }
1817
1818
1819 /* [] END OF FILE */