1 /***************************************************************************//**
2 * \file cy_lvd_ht.h
3 * \version 1.10
4 *
5 * The header file of the LVD HT driver.
6 *
7 ********************************************************************************
8 * \copyright
9 * Copyright 2017-2020 Cypress Semiconductor Corporation
10 * SPDX-License-Identifier: Apache-2.0
11 *
12 * Licensed under the Apache License, Version 2.0 (the "License");
13 * you may not use this file except in compliance with the License.
14 * You may obtain a copy of the License at
15 *
16 *     http://www.apache.org/licenses/LICENSE-2.0
17 *
18 * Unless required by applicable law or agreed to in writing, software
19 * distributed under the License is distributed on an "AS IS" BASIS,
20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 * See the License for the specific language governing permissions and
22 * limitations under the License.
23 *******************************************************************************/
24 
25 /**
26 * \addtogroup group_lvd_ht
27 * \{
28 * The LVD HT driver provides an API to manage the Low Voltage Detection HT block.
29 *
30 * The functions and other declarations used in this driver are in cy_lvd_ht.h.
31 * You can include cy_pdl.h to get access to all functions
32 * and declarations in the PDL.
33 *
34 * The LVD block provides a status of currently observed VDDD voltage
35 * and triggers an interrupt or fault when the observed voltage crosses an adjusted
36 * threshold.
37 *
38 * \section group_lvd_ht_configuration_considerations Configuration Considerations
39 * To set up an LVD, configure the voltage threshold by the
40 * \ref Cy_LVD_HT_SetThreshold function, ensure that the LVD block itself and LVD
41 * interrupt are disabled (by the \ref Cy_LVD_HT_Disable and
42 * \ref Cy_LVD_HT_ClearInterruptMask functions correspondingly) before changing the
43 * threshold to prevent propagating a false interrupt.
44 * Then configure interrupts by the \ref Cy_LVD_HT_SetInterruptConfig function, do
45 * not forget to initialize an interrupt handler (the interrupt source number
46 * is srss_interrupt_IRQn).
47 * Then enable LVD by the \ref Cy_LVD_HT_Enable function, then wait for at least 25us
48 * to get the circuit stabilized and clear the possible false interrupts by the
49 * \ref Cy_LVD_HT_ClearInterrupt, and finally the LVD interrupt can be enabled by
50 * the \ref Cy_LVD_HT_SetInterruptMask function.
51 *
52 * Note : If an LVD is required in Deep Sleep mode, then \ref Cy_LVD_HT_DeepSleepEnable
53 * should be used to enable LVD during Deep Sleep.
54 *
55 * \section group_lvd_ht_more_information More Information
56 * See the LVD chapter of the device technical reference manual (TRM).
57 *
58 * \section group_lvd_ht_changelog Changelog
59 * <table class="doxtable">
60 *   <tr><th>Version</th><th>Changes</th><th>Reason of Change</th></tr>
61 *   <tr>
62 *     <td>1.10</td>
63 *     <td>Added support for TRAVEO&trade; II Body Entry devices.<br>
64 *       Changed pre-processor logic so SRSS version 2 is grouped with version 3 instead of version 1.</td>
65 *     <td>Code enhancement and support for new devices.</td>
66 *   </tr>
67 *   <tr>
68 *     <td>1.0</td>
69 *     <td>Initial Version</td>
70 *     <td></td>
71 *   </tr>
72 * </table>
73 *
74 * \defgroup group_lvd_ht_macros Macros
75 * \defgroup group_lvd_ht_functions Functions
76 *   \{
77 *       \defgroup group_lvd_ht_functions_syspm_callback  Low Power Callback
78 *   \}
79 * \defgroup group_lvd_ht_enums Enumerated Types
80 */
81 
82 
83 #if !defined(CY_LVD_HT_H)
84 #define CY_LVD_HT_H
85 
86 #include "cy_device.h"
87 
88 #if (defined (CY_IP_MXS40SRSS) && (CY_IP_MXS40SRSS_VERSION >= 2))
89 
90 #include "cy_pra.h"
91 #include "cy_syspm.h"
92 
93 #ifdef __cplusplus
94 extern "C" {
95 #endif
96 
97 /** \addtogroup group_lvd_ht_macros
98 * \{
99 */
100 
101 /** The driver major version */
102 #define CY_LVD_HT_DRV_VERSION_MAJOR       1
103 
104 /** The driver minor version */
105 #define CY_LVD_HT_DRV_VERSION_MINOR       10
106 
107 /** The LVD driver identifier */
108 #define CY_LVD_HT_ID                      (CY_PDL_DRV_ID(0x78U))
109 
110 
111 /** \} group_lvd_ht_macros */
112 
113 
114 /** \addtogroup group_lvd_ht_enums
115 * \{
116 */
117 
118 /**
119  * LVD Selection.
120  */
121 typedef enum
122 {
123     CY_LVD_HT_SELECT_LVD_1   = 0x1u,  /**<Select HT LVD-1 */
124     CY_LVD_HT_SELECT_LVD_2   = 0x2u,  /**<Select HT LVD-2 */
125 } cy_en_lvd_ht_select_t;
126 
127 /**
128  * LVD reference voltage select.
129  */
130 typedef enum
131 {
132     CY_LVD_HT_THRESHOLD_2_8_V    = 0x0U, /**<Select LVD reference voltage: 2.8V */
133     CY_LVD_HT_THRESHOLD_2_9_V    = 0x1U, /**<Select LVD reference voltage: 2.9V */
134     CY_LVD_HT_THRESHOLD_3_0_V    = 0x2U, /**<Select LVD reference voltage: 3.0V */
135     CY_LVD_HT_THRESHOLD_3_1_V    = 0x3U, /**<Select LVD reference voltage: 3.1V */
136     CY_LVD_HT_THRESHOLD_3_2_V    = 0x4U, /**<Select LVD reference voltage: 3.2V */
137     CY_LVD_HT_THRESHOLD_3_3_V    = 0x5U, /**<Select LVD reference voltage: 3.3V */
138     CY_LVD_HT_THRESHOLD_3_4_V    = 0x6U, /**<Select LVD reference voltage: 3.4V */
139     CY_LVD_HT_THRESHOLD_3_5_V    = 0x7U, /**<Select LVD reference voltage: 3.5V */
140     CY_LVD_HT_THRESHOLD_3_6_V    = 0x8U, /**<Select LVD reference voltage: 3.6V */
141     CY_LVD_HT_THRESHOLD_3_7_V    = 0x9U, /**<Select LVD reference voltage: 3.7V */
142     CY_LVD_HT_THRESHOLD_3_8_V    = 0xAU, /**<Select LVD reference voltage: 3.8V */
143     CY_LVD_HT_THRESHOLD_3_9_V    = 0xBU, /**<Select LVD reference voltage: 3.9V */
144     CY_LVD_HT_THRESHOLD_4_0_V    = 0xCU, /**<Select LVD reference voltage: 4.0V */
145     CY_LVD_HT_THRESHOLD_4_1_V    = 0xDU, /**<Select LVD reference voltage: 4.1V */
146     CY_LVD_HT_THRESHOLD_4_2_V    = 0xEU, /**<Select LVD reference voltage: 4.2V */
147     CY_LVD_HT_THRESHOLD_4_3_V    = 0xFU,  /**<Select LVD reference voltage: 4.3V */
148     CY_LVD_HT_THRESHOLD_4_4_V    = 0x10U, /**<Select LVD reference voltage: 4.4V */
149     CY_LVD_HT_THRESHOLD_4_5_V    = 0x11U, /**<Select LVD reference voltage: 4.5V */
150     CY_LVD_HT_THRESHOLD_4_6_V    = 0x12U, /**<Select LVD reference voltage: 4.6V */
151     CY_LVD_HT_THRESHOLD_4_7_V    = 0x13U, /**<Select LVD reference voltage: 4.7V */
152     CY_LVD_HT_THRESHOLD_4_8_V    = 0x14U, /**<Select LVD reference voltage: 4.8V */
153     CY_LVD_HT_THRESHOLD_4_9_V    = 0x15U, /**<Select LVD reference voltage: 4.9V */
154     CY_LVD_HT_THRESHOLD_5_0_V    = 0x16U, /**<Select LVD reference voltage: 5.0V */
155     CY_LVD_HT_THRESHOLD_5_1_V    = 0x17U, /**<Select LVD reference voltage: 5.1V */
156     CY_LVD_HT_THRESHOLD_5_2_V    = 0x18U, /**<Select LVD reference voltage: 5.2V */
157     CY_LVD_HT_THRESHOLD_5_3_V    = 0x19U, /**<Select LVD reference voltage: 5.3V */
158 } cy_en_lvd_ht_tripsel_t;
159 
160 /**
161  * LVD interrupt configuration select.
162  */
163 typedef enum
164 {
165     CY_LVD_HT_INTR_DISABLE    = 0x0U,  /**<Select LVD interrupt: disabled */
166     CY_LVD_HT_INTR_RISING     = 0x1U,  /**<Select LVD interrupt: rising edge */
167     CY_LVD_HT_INTR_FALLING    = 0x2U,  /**<Select LVD interrupt: falling edge */
168     CY_LVD_HT_INTR_BOTH       = 0x3U,  /**<Select LVD interrupt: both edges */
169 } cy_en_lvd_ht_intr_config_t;
170 
171 /**
172  * LVD Action
173  */
174 typedef enum
175 {
176     CY_LVD_HT_ACTION_INTERRUPT    = 0x0U,  /**<Select LVD Action : Interrupt */
177     CY_LVD_HT_ACTION_FAULT        = 0x1U,  /**<Select LVD Action : Fault */
178 } cy_en_lvd_ht_action_config_t;
179 
180 /**
181  * LVD output status.
182  */
183 typedef enum
184 {
185     CY_LVD_HT_STATUS_BELOW   = 0x0U,  /**<The voltage is below the threshold */
186     CY_LVD_HT_STATUS_ABOVE   = 0x1U,  /**<The voltage is above the threshold */
187 } cy_en_lvd_ht_status_t;
188 
189 /** \} group_lvd_ht_enums */
190 
191 /** \cond internal */
192 /* Macros for conditions used by CY_ASSERT calls */
193 #define CY_LVD_HT_CHECK_TRIPSEL(threshold)  (((threshold) == CY_LVD_HT_THRESHOLD_2_8_V) || \
194                                           ((threshold) == CY_LVD_HT_THRESHOLD_2_9_V) || \
195                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_0_V) || \
196                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_1_V) || \
197                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_2_V) || \
198                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_3_V) || \
199                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_4_V) || \
200                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_5_V) || \
201                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_6_V) || \
202                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_7_V) || \
203                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_8_V) || \
204                                           ((threshold) == CY_LVD_HT_THRESHOLD_3_9_V) || \
205                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_0_V) || \
206                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_1_V) || \
207                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_2_V) || \
208                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_3_V) || \
209                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_4_V) || \
210                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_5_V) || \
211                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_6_V) || \
212                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_7_V) || \
213                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_8_V) || \
214                                           ((threshold) == CY_LVD_HT_THRESHOLD_4_9_V) || \
215                                           ((threshold) == CY_LVD_HT_THRESHOLD_5_0_V) || \
216                                           ((threshold) == CY_LVD_HT_THRESHOLD_5_1_V) || \
217                                           ((threshold) == CY_LVD_HT_THRESHOLD_5_2_V) || \
218                                           ((threshold) == CY_LVD_HT_THRESHOLD_5_3_V))
219 
220 #define CY_LVD_HT_CHECK_INTR_CFG(intrCfg)   (((intrCfg) == CY_LVD_HT_INTR_DISABLE) || \
221                                           ((intrCfg) == CY_LVD_HT_INTR_RISING) || \
222                                           ((intrCfg) == CY_LVD_HT_INTR_FALLING) || \
223                                           ((intrCfg) == CY_LVD_HT_INTR_BOTH))
224 
225 #define CY_LVD_HT_CHECK_ACTION_CFG(actionCfg)   (((actionCfg) == CY_LVD_HT_ACTION_INTERRUPT) || \
226                                               ((actionCfg) == CY_LVD_HT_ACTION_FAULT))
227 
228 #define CY_LVD_HT_CHECK_LVD_SELECT(lvdNum)   (((lvdNum) == CY_LVD_HT_SELECT_LVD_1) || \
229                                               ((lvdNum) == CY_LVD_HT_SELECT_LVD_2))
230 
231 /** \endcond */
232 
233 /**
234 * \addtogroup group_lvd_ht_functions
235 * \{
236 */
237 __STATIC_INLINE void Cy_LVD_HT_Enable(cy_en_lvd_ht_select_t lvdNum);
238 __STATIC_INLINE void Cy_LVD_HT_Disable(cy_en_lvd_ht_select_t lvdNum);
239 __STATIC_INLINE void Cy_LVD_HT_SetThreshold(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_tripsel_t threshold);
240 __STATIC_INLINE cy_en_lvd_ht_status_t Cy_LVD_HT_GetStatus(cy_en_lvd_ht_select_t lvdNum);
241 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptStatus(cy_en_lvd_ht_select_t lvdNum);
242 __STATIC_INLINE void Cy_LVD_HT_ClearInterrupt(cy_en_lvd_ht_select_t lvdNum);
243 __STATIC_INLINE void Cy_LVD_HT_SetInterrupt(cy_en_lvd_ht_select_t lvdNum);
244 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptMask(cy_en_lvd_ht_select_t lvdNum);
245 __STATIC_INLINE void Cy_LVD_HT_SetInterruptMask(cy_en_lvd_ht_select_t lvdNum);
246 __STATIC_INLINE void Cy_LVD_HT_ClearInterruptMask(cy_en_lvd_ht_select_t lvdNum);
247 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptStatusMasked(cy_en_lvd_ht_select_t lvdNum);
248 __STATIC_INLINE void Cy_LVD_HT_SetInterruptConfig(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_intr_config_t lvdInterruptConfig);
249 __STATIC_INLINE void Cy_LVD_HT_DeepSleepEnable(cy_en_lvd_ht_select_t lvdNum);
250 __STATIC_INLINE void Cy_LVD_HT_DeepSleepDisable(cy_en_lvd_ht_select_t lvdNum);
251 __STATIC_INLINE void Cy_LVD_HT_SetActionConfig(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_action_config_t lvdActionConfig);
252 __STATIC_INLINE cy_en_lvd_ht_action_config_t Cy_LVD_HT_GetActionConfig(cy_en_lvd_ht_select_t lvdNum);
253 __STATIC_INLINE bool Cy_LVD_HT_IsDeepSleepEnabled(cy_en_lvd_ht_select_t lvdNum);
254 
255 /** \addtogroup group_lvd_ht_functions_syspm_callback
256 * The driver supports SysPm callback for Deep Sleep transition.
257 * \{
258 */
259 cy_en_syspm_status_t Cy_LVD_HT_DeepSleepCallback(cy_stc_syspm_callback_params_t * callbackParams, cy_en_syspm_callback_mode_t mode);
260 /** \} */
261 
262 /*******************************************************************************
263 * Function Name: Cy_LVD_HT_Enable
264 ****************************************************************************//**
265 *
266 *  Enables the output of the LVD block when the VDDD voltage crosses the
267 * threshold.
268 *  See the Configuration Considerations section for details.
269 *
270 *  \param lvdNum
271 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
272 *
273 *******************************************************************************/
Cy_LVD_HT_Enable(cy_en_lvd_ht_select_t lvdNum)274 __STATIC_INLINE void Cy_LVD_HT_Enable(cy_en_lvd_ht_select_t lvdNum)
275 {
276     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
277 
278     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
279     {
280         SRSS_PWR_LVD_CTL |= SRSS_PWR_LVD_CTL_HVLVD1_EN_HT_Msk;
281     }
282     else
283     {
284         SRSS_PWR_LVD_CTL2 |= SRSS_PWR_LVD_CTL2_HVLVD2_EN_HT_Msk;
285     }
286 }
287 
288 
289 /*******************************************************************************
290 * Function Name: Cy_LVD_HT_Disable
291 ****************************************************************************//**
292 *
293 *  Disables a particular LVD. A low voltage detection interrupt is disabled.
294 *
295 *  \param lvdNum
296 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
297 *
298 *******************************************************************************/
Cy_LVD_HT_Disable(cy_en_lvd_ht_select_t lvdNum)299 __STATIC_INLINE void Cy_LVD_HT_Disable(cy_en_lvd_ht_select_t lvdNum)
300 {
301     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
302 
303     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
304     {
305         SRSS_PWR_LVD_CTL &= (uint32_t) ~SRSS_PWR_LVD_CTL_HVLVD1_EN_HT_Msk;
306     }
307     else
308     {
309         SRSS_PWR_LVD_CTL2 &= (uint32_t) ~SRSS_PWR_LVD_CTL2_HVLVD2_EN_HT_Msk;
310     }
311 }
312 
313 
314 /*******************************************************************************
315 * Function Name: Cy_LVD_HT_SetThreshold
316 ****************************************************************************//**
317 *
318 *  Sets a threshold for monitoring the VDDD voltage.
319 *  To prevent propagating a false interrupt, before changing the threshold
320 *  ensure that the LVD block itself and LVD interrupt are disabled by the
321 *  \ref Cy_LVD_HT_Disable and \ref Cy_LVD_HT_ClearInterruptMask functions
322 *  correspondingly.
323 *
324 *  \param lvdNum
325 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
326 *
327 *  \param threshold
328 *  Threshold selection for Low Voltage Detect circuit, \ref cy_en_lvd_ht_tripsel_t.
329 *
330 *******************************************************************************/
Cy_LVD_HT_SetThreshold(cy_en_lvd_ht_select_t lvdNum,cy_en_lvd_ht_tripsel_t threshold)331 __STATIC_INLINE void Cy_LVD_HT_SetThreshold(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_tripsel_t threshold)
332 {
333     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
334     CY_ASSERT_L3(CY_LVD_HT_CHECK_TRIPSEL(threshold));
335 
336     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
337     {
338         SRSS_PWR_LVD_CTL = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL, SRSS_PWR_LVD_CTL_HVLVD1_TRIPSEL_HT, threshold);
339     }
340     else
341     {
342         SRSS_PWR_LVD_CTL2 = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL2, SRSS_PWR_LVD_CTL2_HVLVD2_TRIPSEL_HT, threshold);
343     }
344 }
345 
346 
347 /*******************************************************************************
348 * Function Name: Cy_LVD_HT_GetStatus
349 ****************************************************************************//**
350 *
351 *  Returns the status of selected LVD.
352 *  SRSS LVD Status Register (PWR_LVD_STATUS).
353 *
354 *  \param lvdNum
355 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
356 *
357 *  \return LVD status, \ref cy_en_lvd_ht_status_t.
358 *
359 *******************************************************************************/
Cy_LVD_HT_GetStatus(cy_en_lvd_ht_select_t lvdNum)360 __STATIC_INLINE cy_en_lvd_ht_status_t Cy_LVD_HT_GetStatus(cy_en_lvd_ht_select_t lvdNum)
361 {
362     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
363 
364     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
365     {
366         CY_MISRA_DEVIATE_LINE('MISRA C-2012 Rule 10.8','SRSS_PWR_LVD_STATUS_HVLVD1_OUT_Msk extracts only 1 bit value');
367         return ((cy_en_lvd_ht_status_t) _FLD2VAL(SRSS_PWR_LVD_STATUS_HVLVD1_OUT, SRSS_PWR_LVD_STATUS));
368     }
369     else
370     {
371         CY_MISRA_DEVIATE_LINE('MISRA C-2012 Rule 10.8','SRSS_PWR_LVD_STATUS2_HVLVD2_OUT_Msk extracts only 1 bit value');
372         return ((cy_en_lvd_ht_status_t) _FLD2VAL(SRSS_PWR_LVD_STATUS2_HVLVD2_OUT, SRSS_PWR_LVD_STATUS2));
373 
374     }
375 }
376 
377 
378 /*******************************************************************************
379 * Function Name: Cy_LVD_HT_GetInterruptStatus
380 ****************************************************************************//**
381 *
382 *  Returns the status of selected LVD's interrupt.
383 *  SRSS Interrupt Register (SRSS_INTR).
384 *
385 *  \param lvdNum
386 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
387 *
388 *  \return SRSS Interrupt status
389 *
390 *******************************************************************************/
Cy_LVD_HT_GetInterruptStatus(cy_en_lvd_ht_select_t lvdNum)391 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptStatus(cy_en_lvd_ht_select_t lvdNum)
392 {
393     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
394 
395     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
396     {
397         return (SRSS_SRSS_INTR & SRSS_SRSS_INTR_HVLVD1_Msk);
398     }
399     else
400     {
401         return (SRSS_SRSS_INTR & SRSS_SRSS_INTR_HVLVD2_Msk);
402     }
403 }
404 
405 
406 /*******************************************************************************
407 * Function Name: Cy_LVD_HT_ClearInterrupt
408 ****************************************************************************//**
409 *
410 *  Clears LVD interrupt.
411 *  SRSS Interrupt Register (SRSS_INTR).
412 *
413 *  \param lvdNum
414 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
415 *
416 *******************************************************************************/
Cy_LVD_HT_ClearInterrupt(cy_en_lvd_ht_select_t lvdNum)417 __STATIC_INLINE void Cy_LVD_HT_ClearInterrupt(cy_en_lvd_ht_select_t lvdNum)
418 {
419     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
420 
421     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
422     {
423         SRSS_SRSS_INTR = SRSS_SRSS_INTR_HVLVD1_Msk;
424     }
425     else
426     {
427         SRSS_SRSS_INTR = SRSS_SRSS_INTR_HVLVD2_Msk;
428     }
429     /* This dummy reading is necessary here. It provides a guarantee that interrupt is cleared at returning from this function. */
430     (void) SRSS_SRSS_INTR;
431 }
432 
433 
434 /*******************************************************************************
435 * Function Name: Cy_LVD_HT_SetInterrupt
436 ****************************************************************************//**
437 *
438 *  Triggers the device to generate interrupt for LVD.
439 *  SRSS Interrupt Set Register (SRSS_INTR_SET).
440 *
441 *  \param lvdNum
442 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
443 *
444 *******************************************************************************/
Cy_LVD_HT_SetInterrupt(cy_en_lvd_ht_select_t lvdNum)445 __STATIC_INLINE void Cy_LVD_HT_SetInterrupt(cy_en_lvd_ht_select_t lvdNum)
446 {
447     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
448 
449     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
450     {
451         SRSS_SRSS_INTR_SET |= SRSS_SRSS_INTR_SET_HVLVD1_Msk;
452     }
453     else
454     {
455         SRSS_SRSS_INTR_SET |= SRSS_SRSS_INTR_SET_HVLVD2_Msk;
456     }
457 }
458 
459 
460 /*******************************************************************************
461 * Function Name:  Cy_LVD_HT_GetInterruptMask
462 ****************************************************************************//**
463 *
464 *  Returns the mask value of LVD interrupts.
465 *  SRSS Interrupt Mask Register (SRSS_INTR_MASK).
466 *
467 *  \param lvdNum
468 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
469 *
470 *  \return SRSS Interrupt Mask value
471 *
472 *******************************************************************************/
Cy_LVD_HT_GetInterruptMask(cy_en_lvd_ht_select_t lvdNum)473 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptMask(cy_en_lvd_ht_select_t lvdNum)
474 {
475     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
476 
477     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
478     {
479         return (SRSS_SRSS_INTR_MASK & SRSS_SRSS_INTR_MASK_HVLVD1_Msk);
480     }
481     else
482     {
483         return (SRSS_SRSS_INTR_MASK & SRSS_SRSS_INTR_MASK_HVLVD2_Msk);
484     }
485 }
486 
487 
488 /*******************************************************************************
489 * Function Name: Cy_LVD_HT_SetInterruptMask
490 ****************************************************************************//**
491 *
492 * Enables LVD interrupts.
493 * Sets the LVD interrupt mask in the SRSS_INTR_MASK register.
494 *
495 *  \param lvdNum
496 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
497 *
498 *******************************************************************************/
Cy_LVD_HT_SetInterruptMask(cy_en_lvd_ht_select_t lvdNum)499 __STATIC_INLINE void Cy_LVD_HT_SetInterruptMask(cy_en_lvd_ht_select_t lvdNum)
500 {
501     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
502 
503     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
504     {
505         SRSS_SRSS_INTR_MASK |= SRSS_SRSS_INTR_MASK_HVLVD1_Msk;
506     }
507     else
508     {
509         SRSS_SRSS_INTR_MASK |= SRSS_SRSS_INTR_MASK_HVLVD2_Msk;
510     }
511 }
512 
513 
514 /*******************************************************************************
515 * Function Name: Cy_LVD_HT_ClearInterruptMask
516 ****************************************************************************//**
517 *
518 * Disables LVD interrupts.
519 * Clears the LVD interrupt mask in the SRSS_INTR_MASK register.
520 *
521 *  \param lvdNum
522 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
523 *
524 *******************************************************************************/
Cy_LVD_HT_ClearInterruptMask(cy_en_lvd_ht_select_t lvdNum)525 __STATIC_INLINE void Cy_LVD_HT_ClearInterruptMask(cy_en_lvd_ht_select_t lvdNum)
526 {
527     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
528 
529     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
530     {
531         SRSS_SRSS_INTR_MASK &= (uint32_t) ~SRSS_SRSS_INTR_MASK_HVLVD1_Msk;
532     }
533     else
534     {
535         SRSS_SRSS_INTR_MASK &= (uint32_t) ~SRSS_SRSS_INTR_MASK_HVLVD2_Msk;
536     }
537 }
538 
539 
540 /*******************************************************************************
541 * Function Name: Cy_LVD_HT_GetInterruptStatusMasked
542 ****************************************************************************//**
543 *
544 *  Returns the masked interrupt status which is a bitwise AND between the
545 *  interrupt status and interrupt mask registers.
546 *  SRSS Interrupt Masked Register (SRSS_INTR_MASKED).
547 *
548 *  \param lvdNum
549 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
550 *
551 *  \return SRSS Interrupt Masked value
552 *
553 *******************************************************************************/
Cy_LVD_HT_GetInterruptStatusMasked(cy_en_lvd_ht_select_t lvdNum)554 __STATIC_INLINE uint32_t Cy_LVD_HT_GetInterruptStatusMasked(cy_en_lvd_ht_select_t lvdNum)
555 {
556     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
557 
558     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
559     {
560         return (SRSS_SRSS_INTR_MASKED & SRSS_SRSS_INTR_MASK_HVLVD1_Msk);
561     }
562     else
563     {
564         return (SRSS_SRSS_INTR_MASKED & SRSS_SRSS_INTR_MASK_HVLVD2_Msk);
565     }
566 }
567 
568 
569 /*******************************************************************************
570 * Function Name: Cy_LVD_HT_SetInterruptConfig
571 ****************************************************************************//**
572 *
573 *  Sets a configuration for specified LVD interrupt.
574 *  HVLVD Configuration Register (PWR_LVD_CTL or PWR_LVD_CTL2).
575 *
576 *  \param lvdNum
577 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
578 *
579 *  \param lvdInterruptConfig \ref cy_en_lvd_ht_intr_config_t.
580 *
581 *******************************************************************************/
Cy_LVD_HT_SetInterruptConfig(cy_en_lvd_ht_select_t lvdNum,cy_en_lvd_ht_intr_config_t lvdInterruptConfig)582 __STATIC_INLINE void Cy_LVD_HT_SetInterruptConfig(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_intr_config_t lvdInterruptConfig)
583 {
584     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
585     CY_ASSERT_L3(CY_LVD_HT_CHECK_INTR_CFG(lvdInterruptConfig));
586 
587     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
588     {
589         SRSS_PWR_LVD_CTL = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL, SRSS_PWR_LVD_CTL_HVLVD1_EDGE_SEL, lvdInterruptConfig);
590     }
591     else
592     {
593         SRSS_PWR_LVD_CTL2 = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL2, SRSS_PWR_LVD_CTL2_HVLVD2_EDGE_SEL, lvdInterruptConfig);
594     }
595 }
596 
597 /*******************************************************************************
598 * Function Name: Cy_LVD_HT_SetActionConfig
599 ****************************************************************************//**
600 *
601 *  Sets a action configuration after LVD block reaches threshold.
602 *
603 *  \param lvdNum
604 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
605 *
606 *  \param lvdActionConfig \ref cy_en_lvd_ht_action_config_t.
607 *
608 *******************************************************************************/
Cy_LVD_HT_SetActionConfig(cy_en_lvd_ht_select_t lvdNum,cy_en_lvd_ht_action_config_t lvdActionConfig)609 __STATIC_INLINE void Cy_LVD_HT_SetActionConfig(cy_en_lvd_ht_select_t lvdNum, cy_en_lvd_ht_action_config_t lvdActionConfig)
610 {
611     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
612     CY_ASSERT_L3(CY_LVD_HT_CHECK_ACTION_CFG(lvdActionConfig));
613 
614     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
615     {
616         SRSS_PWR_LVD_CTL = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL, SRSS_PWR_LVD_CTL_HVLVD1_ACTION, lvdActionConfig);
617     }
618     else
619     {
620         SRSS_PWR_LVD_CTL2 = _CLR_SET_FLD32U(SRSS_PWR_LVD_CTL2, SRSS_PWR_LVD_CTL2_HVLVD2_ACTION, lvdActionConfig);
621     }
622 }
623 
624 /*******************************************************************************
625 * Function Name: Cy_LVD_HT_GetActionConfig
626 ****************************************************************************//**
627 *
628 *  Gets the action configured after LVD reaches threshold.
629 *
630 *  \param lvdNum
631 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
632 *
633 *  \return \ref cy_en_lvd_ht_action_config_t
634 *
635 *******************************************************************************/
Cy_LVD_HT_GetActionConfig(cy_en_lvd_ht_select_t lvdNum)636 __STATIC_INLINE cy_en_lvd_ht_action_config_t Cy_LVD_HT_GetActionConfig(cy_en_lvd_ht_select_t lvdNum)
637 {
638     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
639 
640     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
641     {
642         return (((SRSS_PWR_LVD_CTL & SRSS_PWR_LVD_CTL_HVLVD1_ACTION_Msk) != 0UL) ? CY_LVD_HT_ACTION_FAULT : CY_LVD_HT_ACTION_INTERRUPT);
643     }
644     else
645     {
646         return (((SRSS_PWR_LVD_CTL2 & SRSS_PWR_LVD_CTL2_HVLVD2_ACTION_Msk) != 0UL) ? CY_LVD_HT_ACTION_FAULT : CY_LVD_HT_ACTION_INTERRUPT);
647     }
648 }
649 
650 /*******************************************************************************
651 * Function Name: Cy_LVD_HT_DeepSleepEnable
652 ****************************************************************************//**
653 *
654 *  Enables selected LVD block during Deep Sleep.
655 *
656 *  \param lvdNum
657 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
658 *
659 * \note
660 * For enabling, call this API before the system enters first DEEPSLEEP entry,
661 * else if we enable in the second or subsequent DEEPSLEEP entries then it might
662 * not wake the system from DEEPSLEEP through LVD.
663 *
664 *******************************************************************************/
Cy_LVD_HT_DeepSleepEnable(cy_en_lvd_ht_select_t lvdNum)665 __STATIC_INLINE void Cy_LVD_HT_DeepSleepEnable(cy_en_lvd_ht_select_t lvdNum)
666 {
667     CY_ASSERT_L3(CY_LVD_HT_CHECK_LVD_SELECT(lvdNum));
668 
669     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
670     {
671         SRSS_PWR_LVD_CTL |= SRSS_PWR_LVD_CTL_HVLVD1_DPSLP_EN_HT_Msk;
672     }
673     else
674     {
675         SRSS_PWR_LVD_CTL2 |= SRSS_PWR_LVD_CTL2_HVLVD2_DPSLP_EN_HT_Msk;
676     }
677 }
678 
679 
680 /*******************************************************************************
681 * Function Name: Cy_LVD_HT_DeepSleepDisable
682 ****************************************************************************//**
683 *
684 *  Disables selected LVD block during Deep Sleep.
685 *
686 *  \param lvdNum
687 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
688 *
689 * \note
690 * After Cy_LVD_HT_DeepSleepDisable call, you have to reinitialize LVD according
691 * to recommended LVD Init sequence, else it might not wake the system from
692 * DEEPSLEEP through LVD after calling Cy_LVD_HT_DeepSleepEnable.
693 *
694 *******************************************************************************/
Cy_LVD_HT_DeepSleepDisable(cy_en_lvd_ht_select_t lvdNum)695 __STATIC_INLINE void Cy_LVD_HT_DeepSleepDisable(cy_en_lvd_ht_select_t lvdNum)
696 {
697     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
698     {
699         SRSS_PWR_LVD_CTL &= (uint32_t) ~SRSS_PWR_LVD_CTL_HVLVD1_DPSLP_EN_HT_Msk;
700     }
701     else
702     {
703         SRSS_PWR_LVD_CTL2 &= (uint32_t) ~SRSS_PWR_LVD_CTL2_HVLVD2_DPSLP_EN_HT_Msk;
704     }
705 }
706 
707 /*******************************************************************************
708 * Function Name: Cy_LVD_HT_IsDeepSleepEnabled
709 ****************************************************************************//**
710 *
711 *  Checks if LVD HT is enabled during Deep Sleep or not.
712 *
713 *  \param lvdNum
714 *   Selects the LVD, \ref cy_en_lvd_ht_select_t
715 *
716 *  \return - True if LVD HT is enabled during Deep Sleep, otherwise False.
717 *
718 *******************************************************************************/
Cy_LVD_HT_IsDeepSleepEnabled(cy_en_lvd_ht_select_t lvdNum)719 __STATIC_INLINE bool Cy_LVD_HT_IsDeepSleepEnabled(cy_en_lvd_ht_select_t lvdNum)
720 {
721     if(lvdNum == CY_LVD_HT_SELECT_LVD_1)
722     {
723         return (((SRSS_PWR_LVD_CTL & SRSS_PWR_LVD_CTL_HVLVD1_DPSLP_EN_HT_Msk) != 0UL) ? true : false);
724     }
725     else
726     {
727         return (((SRSS_PWR_LVD_CTL2 & SRSS_PWR_LVD_CTL2_HVLVD2_DPSLP_EN_HT_Msk) != 0UL) ? true : false);
728     }
729 }
730 
731 
732 /** \} group_lvd_ht_functions */
733 
734 #ifdef __cplusplus
735 }
736 #endif
737 
738 #endif /* CY_IP_MXS40SRSS) && (CY_IP_MXS40SRSS_VERSION >= 2) */
739 
740 #endif /* CY_LVD_HT_H */
741 
742 /** \} group_lvd_ht */
743 
744 
745 /* [] END OF FILE */
746