em_wdog.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_WDOG_H
#define EM_WDOG_H

#include "em_device.h"
#if defined(WDOG_COUNT) && (WDOG_COUNT > 0)

#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 ********************************   ENUMS   ************************************
 ******************************************************************************/

typedef enum
{
  wdogClkSelULFRCO = _WDOG_CTRL_CLKSEL_ULFRCO,   
  wdogClkSelLFRCO  = _WDOG_CTRL_CLKSEL_LFRCO,    
  wdogClkSelLFXO   = _WDOG_CTRL_CLKSEL_LFXO      
} WDOG_ClkSel_TypeDef;

typedef enum
{
  wdogPeriod_9    = 0x0, 
  wdogPeriod_17   = 0x1, 
  wdogPeriod_33   = 0x2, 
  wdogPeriod_65   = 0x3, 
  wdogPeriod_129  = 0x4, 
  wdogPeriod_257  = 0x5, 
  wdogPeriod_513  = 0x6, 
  wdogPeriod_1k   = 0x7, 
  wdogPeriod_2k   = 0x8, 
  wdogPeriod_4k   = 0x9, 
  wdogPeriod_8k   = 0xA, 
  wdogPeriod_16k  = 0xB, 
  wdogPeriod_32k  = 0xC, 
  wdogPeriod_64k  = 0xD, 
  wdogPeriod_128k = 0xE, 
  wdogPeriod_256k = 0xF  
} WDOG_PeriodSel_TypeDef;


#if defined( _WDOG_CTRL_WARNSEL_MASK )

typedef enum
{
  wdogWarnDisable   = 0,
  wdogWarnTime25pct = 1,
  wdogWarnTime50pct = 2,
  wdogWarnTime75pct = 3,
} WDOG_WarnSel_TypeDef;
#endif

#if defined( _WDOG_CTRL_WINSEL_MASK )

typedef enum
{
  wdogIllegalWindowDisable     = 0,
  wdogIllegalWindowTime12_5pct = 1,
  wdogIllegalWindowTime25_0pct = 2,
  wdogIllegalWindowTime37_5pct = 3,
  wdogIllegalWindowTime50_0pct = 4,
  wdogIllegalWindowTime62_5pct = 5,
  wdogIllegalWindowTime75_0pct = 6,
  wdogIllegalWindowTime87_5pct = 7,
} WDOG_WinSel_TypeDef;
#endif

/*******************************************************************************
 *******************************   STRUCTS   ***********************************
 ******************************************************************************/

typedef struct
{
  bool                   enable;

  bool                   debugRun;

  bool                   em2Run;

  bool                   em3Run;

  bool                   em4Block;

  bool                   swoscBlock;

  bool                   lock;

  WDOG_ClkSel_TypeDef    clkSel;

  WDOG_PeriodSel_TypeDef perSel;

#if defined( _WDOG_CTRL_WARNSEL_MASK )

  WDOG_WarnSel_TypeDef   warnSel;
#endif

#if defined( _WDOG_CTRL_WINSEL_MASK )

  WDOG_WinSel_TypeDef    winSel;
#endif

#if defined( _WDOG_CTRL_WDOGRSTDIS_MASK )

  bool                   resetDisable;
#endif

} WDOG_Init_TypeDef;

#if defined( _WDOG_CTRL_WARNSEL_MASK )          \
    && defined( _WDOG_CTRL_WDOGRSTDIS_MASK )    \
    && defined( _WDOG_CTRL_WINSEL_MASK )
#define WDOG_INIT_DEFAULT                                                       \
{                                                                               \
  true,                         /* Start watchdog when init done */             \
  false,                        /* WDOG not counting during debug halt */       \
  false,                        /* WDOG not counting when in EM2 */             \
  false,                        /* WDOG not counting when in EM3 */             \
  false,                        /* EM4 can be entered */                        \
  false,                        /* Do not block disabling LFRCO/LFXO in CMU */  \
  false,                        /* Do not lock WDOG configuration (if locked,
                                   reset needed to unlock) */                   \
  wdogClkSelULFRCO,             /* Select 1kHZ WDOG oscillator */               \
  wdogPeriod_256k,              /* Set longest possible timeout period */       \
  wdogWarnDisable,              /* Disable warning interrupt */                 \
  wdogIllegalWindowDisable,     /* Disable illegal window interrupt */          \
  false                         /* Do not disable reset */                      \
}
#else
#define WDOG_INIT_DEFAULT                                                       \
{                                                                               \
  true,                         /* Start watchdog when init done */             \
  false,                        /* WDOG not counting during debug halt */       \
  false,                        /* WDOG not counting when in EM2 */             \
  false,                        /* WDOG not counting when in EM3 */             \
  false,                        /* EM4 can be entered */                        \
  false,                        /* Do not block disabling LFRCO/LFXO in CMU */  \
  false,                        /* Do not lock WDOG configuration (if locked,
                                   reset needed to unlock) */                   \
  wdogClkSelULFRCO,             /* Select 1kHZ WDOG oscillator */               \
  wdogPeriod_256k               /* Set longest possible timeout period */       \
}
#endif


/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/

void WDOGn_Enable(WDOG_TypeDef *wdog, bool enable);
void WDOGn_Feed(WDOG_TypeDef *wdog);
void WDOGn_Init(WDOG_TypeDef *wdog, const WDOG_Init_TypeDef *init);
void WDOGn_Lock(WDOG_TypeDef *wdog);


#if defined( _WDOG_IF_MASK )
/***************************************************************************/
__STATIC_INLINE void WDOGn_IntClear(WDOG_TypeDef *wdog, uint32_t flags)
{
  wdog->IFC = flags;
}

/***************************************************************************/
__STATIC_INLINE void WDOGn_IntDisable(WDOG_TypeDef *wdog, uint32_t flags)
{
  wdog->IEN &= ~flags;
}

/***************************************************************************/
__STATIC_INLINE void WDOGn_IntEnable(WDOG_TypeDef *wdog, uint32_t flags)
{
  wdog->IEN |= flags;
}

/***************************************************************************/
__STATIC_INLINE uint32_t WDOGn_IntGet(WDOG_TypeDef *wdog)
{
  return wdog->IF;
}

/***************************************************************************/
__STATIC_INLINE uint32_t WDOGn_IntGetEnabled(WDOG_TypeDef *wdog)
{
  uint32_t tmp;

  tmp = wdog->IEN;

  /* Bitwise AND of pending and enabled interrupt flags. */
  return wdog->IF & tmp;
}

/***************************************************************************/
__STATIC_INLINE void WDOGn_IntSet(WDOG_TypeDef *wdog, uint32_t flags)
{
  wdog->IFS = flags;
}
#endif


#if !defined(DEFAULT_WDOG)
#if defined(WDOG)
#define DEFAULT_WDOG WDOG
#elif defined(WDOG0)
#define DEFAULT_WDOG WDOG0
#endif
#endif

/***************************************************************************/
__STATIC_INLINE void WDOG_Enable(bool enable)
{
  WDOGn_Enable(DEFAULT_WDOG, enable);
}


/***************************************************************************/
__STATIC_INLINE void WDOG_Feed(void)
{
  WDOGn_Feed(DEFAULT_WDOG);
}


/***************************************************************************/
__STATIC_INLINE void WDOG_Init(const WDOG_Init_TypeDef *init)
{
  WDOGn_Init(DEFAULT_WDOG, init);
}


/***************************************************************************/
__STATIC_INLINE void WDOG_Lock(void)
{
  WDOGn_Lock(DEFAULT_WDOG);
}


#ifdef __cplusplus
}
#endif

#endif /* defined(WDOG_COUNT) && (WDOG_COUNT > 0) */
#endif /* EM_WDOG_H */