g32r4xx_ddl_pmu.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef G32R4xx_DDL_PMU_H
#define G32R4xx_DDL_PMU_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Includes ------------------------------------------------------------------*/
#include "g32r4xx.h"

 
#if defined(PMU)

 
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/

#define DDL_PMU_WAKEUP_PIN1  PMU_WKPCR_WKUPEN0  /* PC1-WUIO */
#define DDL_PMU_WAKEUP_PIN2  PMU_WKPCR_WKUPEN1  /* PC2-WUIO */
#define DDL_PMU_WAKEUP_PIN3  PMU_WKPCR_WKUPEN2  /* PD0-WUIO */
#define DDL_PMU_WAKEUP_PIN4  PMU_WKPCR_WKUPEN3  /* PD9-WUIO */


#define DDL_PMU_WAKEUP_PIN_POLARITY_RISING              (0x0U)
#define DDL_PMU_WAKEUP_PIN_POLARITY_FALLING             (0x1U)
#define DDL_PMU_WAKEUP_PIN_POLARITY_RISING_AND_FALLING  (0x2U)

#define DDL_PMU_STANDBY_PINMODE_ANALOG  (0x0U)
#define DDL_PMU_STANDBY_PINMODE_PU      (0x1U)
#define DDL_PMU_STANDBY_PINMODE_PD      (0x2U)

#define DDL_PMU_EVS_FILTER_NONE     (0x00000000UL)
#define DDL_PMU_EVS_FILTER_2LSICLK  (PMU_EVSCR_VDCPVDFILTER_0)
#define DDL_PMU_EVS_FILTER_4LSICLK  (PMU_EVSCR_VDCPVDFILTER_1)
#define DDL_PMU_EVS_FILTER_8LSICLK  (PMU_EVSCR_VDCPVDFILTER)

 
/* Exported macro ------------------------------------------------------------*/


#define DDL_PMU_WriteReg(__REG__,  __VALUE__) WRITE_REG(PMU->__REG__, (__VALUE__))

#define DDL_PMU_ReadReg(__REG__)  READ_REG(PMU->__REG__)

 
/* Exported functions --------------------------------------------------------*/


__STATIC_INLINE void DDL_PMU_EnableWakeUpPin(uint32_t Pin)
{
  SET_BIT(PMU->WKPCR, Pin);
}

__STATIC_INLINE void DDL_PMU_DisableWakeUpPin(uint32_t Pin)
{
  CLEAR_BIT(PMU->WKPCR, Pin);
}

__STATIC_INLINE void DDL_PMU_SetWakeUpPinPolarity(uint32_t Pin, uint32_t Polarity)
{
  MODIFY_REG(PMU->WKPCR, (PMU_WKPCR_WKUPPOL0 << ((POSITION_VAL(Pin) * 2))), (Polarity << (4 + POSITION_VAL(Pin) * 2)));
}

__STATIC_INLINE uint32_t DDL_PMU_GetWakeUpPinPolarity(uint32_t Pin)
{
  return (uint32_t)(READ_BIT(PMU->WKPCR, (PMU_WKPCR_WKUPPOL0 << (POSITION_VAL(Pin) * 2))) >> (4 + POSITION_VAL(Pin) * 2));
}



__STATIC_INLINE void DDL_PMU_SetPinModeInStandby(uint32_t Pin, uint32_t Mode)
{
  MODIFY_REG(PMU->WKPCR, PMU_WKPCR_APC, ((!!Mode) << PMU_WKPCR_APC_Pos));
  if(Mode == DDL_PMU_STANDBY_PINMODE_PU)
  {
    SET_BIT(PMU->PUCRA, Pin);
    CLEAR_BIT(PMU->PDCRA, Pin);
  }
  else if(Mode == DDL_PMU_STANDBY_PINMODE_PD)
  {
    CLEAR_BIT(PMU->PUCRA, Pin);
    SET_BIT(PMU->PDCRA, Pin);
  }
  else
  {
    CLEAR_BIT(PMU->PUCRA, Pin);
    CLEAR_BIT(PMU->PDCRA, Pin);
  }
}

__STATIC_INLINE uint32_t DDL_PMU_GetPinModeInStandby(uint32_t Pin)
{
  return (uint32_t)((READ_BIT(PMU->WKPCR, PMU_WKPCR_APC) ==  PMU_WKPCR_APC ? 1UL : 0UL) *
                    ((READ_BIT(PMU->PUCRA, Pin) > 0U ? DDL_PMU_STANDBY_PINMODE_PU : 0UL) |
                    (READ_BIT(PMU->PDCRA, Pin) > 0U ? DDL_PMU_STANDBY_PINMODE_PD : 0UL)));
}

__STATIC_INLINE uint32_t DDL_PMU_IsActiveFlag_WakeUp(uint32_t Pin)
{
  return (uint32_t)(READ_BIT(PMU->SR, Pin));
}

__STATIC_INLINE void DDL_PMU_ClearFlag_WakeUp(uint32_t Pin)
{
  WRITE_REG(PMU->SR, Pin);
}

__STATIC_INLINE uint32_t DDL_PMU_IsActiveFlag_Standby(void)
{
  return (uint32_t)(READ_BIT(PMU->SR, PMU_SR_SBF));
}

__STATIC_INLINE void DDL_PMU_ClearFlag_Standby(void)
{
  WRITE_REG(PMU->SR, PMU_SR_SBF);
}



__STATIC_INLINE void DDL_PMU_EnableEVSWakeUp(void)
{
  SET_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDWKPEN);
}

__STATIC_INLINE void DDL_PMU_DisableEVSWakeUp(void)
{
  CLEAR_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDWKPEN);
}

__STATIC_INLINE void DDL_PMU_EnableEVS(void)
{
  SET_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDEN);
}

__STATIC_INLINE void DDL_PMU_DisableEVS(void)
{
  CLEAR_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDEN);
}

__STATIC_INLINE void DDL_PMU_SetEVSFilter(uint32_t Filter)
{
  MODIFY_REG(PMU->EVSCR, PMU_EVSCR_VDCPVDFILTER, Filter);
}

__STATIC_INLINE uint32_t DDL_PMU_GetEVSFilter(void)
{
  return (uint32_t)(READ_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDFILTER));
}

__STATIC_INLINE void DDL_PMU_SetEVSThreshold(uint32_t threshold)
{
  MODIFY_REG(PMU->EVSCR, PMU_EVSCR_VDCPVDSEL, threshold << PMU_EVSCR_VDCPVDSEL_Pos);
}

__STATIC_INLINE uint32_t DDL_PMU_GetEVSThreshold(void)
{
  return (uint32_t)(READ_BIT(PMU->EVSCR, PMU_EVSCR_VDCPVDSEL) >> PMU_EVSCR_VDCPVDSEL_Pos);
}

__STATIC_INLINE uint32_t DDL_PMU_IsActiveFlag_EVS(void)
{
  return (uint32_t)(READ_BIT(PMU->SR, PMU_SR_EVSWKF) == PMU_SR_EVSWKF ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_PMU_ClearFlag_EVS(void)
{
  WRITE_REG(PMU->SR, PMU_SR_EVSWKF);
}



__STATIC_INLINE void DDL_PMU_EnablePVD(void)
{
  SET_BIT(PMU->PVDCR, PMU_PVDCR_PVDEN);
}

__STATIC_INLINE void DDL_PMU_DisablePVD(void)
{
  CLEAR_BIT(PMU->PVDCR, PMU_PVDCR_PVDEN);
}

__STATIC_INLINE void DDL_PMU_SetPVDThreshold(uint32_t Threshold)
{
  MODIFY_REG(PMU->PVDCR, PMU_PVDCR_PVDTHSEL, (Threshold << PMU_PVDCR_PVDTHSEL_Pos));
}

__STATIC_INLINE uint32_t DDL_PMU_GetPVDThreshold(void)
{
  return (uint32_t)(READ_BIT(PMU->PVDCR, PMU_PVDCR_PVDTHSEL) >> PMU_PVDCR_PVDTHSEL_Pos);
}

__STATIC_INLINE uint32_t DDL_PMU_IsActiveFlag_PVDOutput(void)
{
  return (uint32_t)(READ_BIT(PMU->SR, PMU_SR_PVDO) == PMU_SR_PVDO ? 1UL : 0UL);
}

 
#if defined(USE_FULL_DDL_DRIVER)
void DDL_PMU_EnterStandbyModeWFI(void);
void DDL_PMU_EnterStopModeWFI(void);
void DDL_PMU_EnterStandbyModeWFE(void);
void DDL_PMU_EnterStopModeWFE(void);
#endif /* USE_FULL_DDL_DRIVER */


 
#endif /* PMU */

 
#ifdef __cplusplus
}
#endif
 
#endif /* G32R4xx_DDL_PMU_H */