em_timer.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_TIMER_H
#define EM_TIMER_H

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

#include <stdbool.h>
#include "em_assert.h"

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 *******************************   DEFINES   ***********************************
 ******************************************************************************/

#define TIMER_REF_VALID(ref)  TIMER_Valid(ref)

#if defined(_SILICON_LABS_32B_SERIES_0)
#define TIMER_CH_VALID(ch)    ((ch) < 3)
#elif defined(_SILICON_LABS_32B_SERIES_1)
#define TIMER_CH_VALID(ch)    ((ch) < 4)
#else
#error "Unknown device. Undefined number of channels."
#endif

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

typedef enum
{
  timerCCModeOff     = _TIMER_CC_CTRL_MODE_OFF,           
  timerCCModeCapture = _TIMER_CC_CTRL_MODE_INPUTCAPTURE,  
  timerCCModeCompare = _TIMER_CC_CTRL_MODE_OUTPUTCOMPARE, 
  timerCCModePWM     = _TIMER_CC_CTRL_MODE_PWM            
} TIMER_CCMode_TypeDef;


typedef enum
{
  timerClkSelHFPerClk = _TIMER_CTRL_CLKSEL_PRESCHFPERCLK,

  timerClkSelCC1      = _TIMER_CTRL_CLKSEL_CC1,

  timerClkSelCascade  = _TIMER_CTRL_CLKSEL_TIMEROUF
} TIMER_ClkSel_TypeDef;


typedef enum
{
  timerEdgeRising  = _TIMER_CC_CTRL_ICEDGE_RISING,

  timerEdgeFalling = _TIMER_CC_CTRL_ICEDGE_FALLING,

  timerEdgeBoth    = _TIMER_CC_CTRL_ICEDGE_BOTH,

  timerEdgeNone    = _TIMER_CC_CTRL_ICEDGE_NONE
} TIMER_Edge_TypeDef;


typedef enum
{
  timerEventEveryEdge    = _TIMER_CC_CTRL_ICEVCTRL_EVERYEDGE,
  timerEventEvery2ndEdge = _TIMER_CC_CTRL_ICEVCTRL_EVERYSECONDEDGE,
  timerEventRising       = _TIMER_CC_CTRL_ICEVCTRL_RISING,
  timerEventFalling      = _TIMER_CC_CTRL_ICEVCTRL_FALLING
} TIMER_Event_TypeDef;


typedef enum
{
  timerInputActionNone        = _TIMER_CTRL_FALLA_NONE,

  timerInputActionStart       = _TIMER_CTRL_FALLA_START,

  timerInputActionStop        = _TIMER_CTRL_FALLA_STOP,

  timerInputActionReloadStart = _TIMER_CTRL_FALLA_RELOADSTART
} TIMER_InputAction_TypeDef;


typedef enum
{
  timerModeUp     = _TIMER_CTRL_MODE_UP,     
  timerModeDown   = _TIMER_CTRL_MODE_DOWN,   
  timerModeUpDown = _TIMER_CTRL_MODE_UPDOWN, 
  timerModeQDec   = _TIMER_CTRL_MODE_QDEC    
} TIMER_Mode_TypeDef;


typedef enum
{
  timerOutputActionNone   = _TIMER_CC_CTRL_CUFOA_NONE,

  timerOutputActionToggle = _TIMER_CC_CTRL_CUFOA_TOGGLE,

  timerOutputActionClear  = _TIMER_CC_CTRL_CUFOA_CLEAR,

  timerOutputActionSet    = _TIMER_CC_CTRL_CUFOA_SET
} TIMER_OutputAction_TypeDef;


typedef enum
{
  timerPrescale1    = _TIMER_CTRL_PRESC_DIV1,     
  timerPrescale2    = _TIMER_CTRL_PRESC_DIV2,     
  timerPrescale4    = _TIMER_CTRL_PRESC_DIV4,     
  timerPrescale8    = _TIMER_CTRL_PRESC_DIV8,     
  timerPrescale16   = _TIMER_CTRL_PRESC_DIV16,    
  timerPrescale32   = _TIMER_CTRL_PRESC_DIV32,    
  timerPrescale64   = _TIMER_CTRL_PRESC_DIV64,    
  timerPrescale128  = _TIMER_CTRL_PRESC_DIV128,   
  timerPrescale256  = _TIMER_CTRL_PRESC_DIV256,   
  timerPrescale512  = _TIMER_CTRL_PRESC_DIV512,   
  timerPrescale1024 = _TIMER_CTRL_PRESC_DIV1024   
} TIMER_Prescale_TypeDef;


typedef enum
{
  timerPRSSELCh0 = _TIMER_CC_CTRL_PRSSEL_PRSCH0,        
  timerPRSSELCh1 = _TIMER_CC_CTRL_PRSSEL_PRSCH1,        
  timerPRSSELCh2 = _TIMER_CC_CTRL_PRSSEL_PRSCH2,        
  timerPRSSELCh3 = _TIMER_CC_CTRL_PRSSEL_PRSCH3,        
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH4)
  timerPRSSELCh4 = _TIMER_CC_CTRL_PRSSEL_PRSCH4,        
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH5)
  timerPRSSELCh5 = _TIMER_CC_CTRL_PRSSEL_PRSCH5,        
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH6)
  timerPRSSELCh6 = _TIMER_CC_CTRL_PRSSEL_PRSCH6,        
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH7)
  timerPRSSELCh7 = _TIMER_CC_CTRL_PRSSEL_PRSCH7,        
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH8)
  timerPRSSELCh8  = _TIMER_CC_CTRL_PRSSEL_PRSCH8,       
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH9)
  timerPRSSELCh9  = _TIMER_CC_CTRL_PRSSEL_PRSCH9,       
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH10)
  timerPRSSELCh10 = _TIMER_CC_CTRL_PRSSEL_PRSCH10,      
#endif
#if defined(_TIMER_CC_CTRL_PRSSEL_PRSCH11)
  timerPRSSELCh11 = _TIMER_CC_CTRL_PRSSEL_PRSCH11,      
#endif
} TIMER_PRSSEL_TypeDef;

#if defined(_TIMER_DTFC_DTFA_NONE)

typedef enum
{
  timerDtiFaultActionNone     = _TIMER_DTFC_DTFA_NONE,     
  timerDtiFaultActionInactive = _TIMER_DTFC_DTFA_INACTIVE, 
  timerDtiFaultActionClear    = _TIMER_DTFC_DTFA_CLEAR,    
  timerDtiFaultActionTristate = _TIMER_DTFC_DTFA_TRISTATE  
} TIMER_DtiFaultAction_TypeDef;
#endif

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

typedef struct
{
  bool                      enable;

  bool                      debugRun;

  TIMER_Prescale_TypeDef    prescale;

  TIMER_ClkSel_TypeDef      clkSel;

#if defined(TIMER_CTRL_X2CNT) && defined(TIMER_CTRL_ATI)

  bool                      count2x;

  bool                      ati;
#endif

  TIMER_InputAction_TypeDef fallAction;

  TIMER_InputAction_TypeDef riseAction;

  TIMER_Mode_TypeDef        mode;

  bool                      dmaClrAct;

  bool                      quadModeX4;

  bool                      oneShot;

  bool                      sync;
} TIMER_Init_TypeDef;

#if defined(TIMER_CTRL_X2CNT) && defined(TIMER_CTRL_ATI)
#define TIMER_INIT_DEFAULT                                                            \
{                                                                                     \
  true,                   /* Enable timer when init complete. */                      \
  false,                  /* Stop counter during debug halt. */                       \
  timerPrescale1,         /* No prescaling. */                                        \
  timerClkSelHFPerClk,    /* Select HFPER clock. */                                   \
  false,                  /* Not 2x count mode. */                                    \
  false,                  /* No ATI. */                                               \
  timerInputActionNone,   /* No action on falling input edge. */                      \
  timerInputActionNone,   /* No action on rising input edge. */                       \
  timerModeUp,            /* Up-counting. */                                          \
  false,                  /* Do not clear DMA requests when DMA channel is active. */ \
  false,                  /* Select X2 quadrature decode mode (if used). */           \
  false,                  /* Disable one shot. */                                     \
  false                   /* Not started/stopped/reloaded by other timers. */         \
}
#else
#define TIMER_INIT_DEFAULT                                                            \
{                                                                                     \
  true,                   /* Enable timer when init complete. */                      \
  false,                  /* Stop counter during debug halt. */                       \
  timerPrescale1,         /* No prescaling. */                                        \
  timerClkSelHFPerClk,    /* Select HFPER clock. */                                   \
  timerInputActionNone,   /* No action on falling input edge. */                      \
  timerInputActionNone,   /* No action on rising input edge. */                       \
  timerModeUp,            /* Up-counting. */                                          \
  false,                  /* Do not clear DMA requests when DMA channel is active. */ \
  false,                  /* Select X2 quadrature decode mode (if used). */           \
  false,                  /* Disable one shot. */                                     \
  false                   /* Not started/stopped/reloaded by other timers. */         \
}
#endif

typedef struct
{
  TIMER_Event_TypeDef        eventCtrl;

  TIMER_Edge_TypeDef         edge;

  TIMER_PRSSEL_TypeDef       prsSel;

  TIMER_OutputAction_TypeDef cufoa;

  TIMER_OutputAction_TypeDef cofoa;

  TIMER_OutputAction_TypeDef cmoa;

  TIMER_CCMode_TypeDef       mode;

  bool                       filter;

  bool                       prsInput;

  bool                       coist;

  bool                       outInvert;
} TIMER_InitCC_TypeDef;

#define TIMER_INITCC_DEFAULT                                                 \
{                                                                            \
  timerEventEveryEdge,      /* Event on every capture. */                    \
  timerEdgeRising,          /* Input capture edge on rising edge. */         \
  timerPRSSELCh0,           /* Not used by default, select PRS channel 0. */ \
  timerOutputActionNone,    /* No action on underflow. */                    \
  timerOutputActionNone,    /* No action on overflow. */                     \
  timerOutputActionNone,    /* No action on match. */                        \
  timerCCModeOff,           /* Disable compare/capture channel. */           \
  false,                    /* Disable filter. */                            \
  false,                    /* Select TIMERnCCx input. */                    \
  false,                    /* Clear output when counter disabled. */        \
  false                     /* Do not invert output. */                      \
}

#if defined(_TIMER_DTCTRL_MASK)

typedef struct
{
  bool                          enable;

  bool                          activeLowOut;

  bool                          invertComplementaryOut;

  bool                          autoRestart;

  bool                          enablePrsSource;

  TIMER_PRSSEL_TypeDef          prsSel;

  TIMER_Prescale_TypeDef        prescale;

  unsigned int                  riseTime;

  unsigned int                  fallTime;

  uint32_t                      outputsEnableMask;

  bool                          enableFaultSourceCoreLockup;

  bool                          enableFaultSourceDebugger;

  bool                          enableFaultSourcePrsSel0;

  TIMER_PRSSEL_TypeDef          faultSourcePrsSel0;

  bool                          enableFaultSourcePrsSel1;

  TIMER_PRSSEL_TypeDef          faultSourcePrsSel1;

  TIMER_DtiFaultAction_TypeDef  faultAction;

} TIMER_InitDTI_TypeDef;


#define TIMER_INITDTI_DEFAULT                                                \
{                                                                            \
  true,                     /* Enable the DTI. */                            \
  false,                    /* CC[0|1|2] outputs are active high. */         \
  false,                    /* CDTI[0|1|2] outputs are not inverted. */      \
  false,                    /* No auto restart when debugger exits. */       \
  false,                    /* No PRS source selected. */                    \
  timerPRSSELCh0,           /* Not used by default, select PRS channel 0. */ \
  timerPrescale1,           /* No prescaling.  */                            \
  0,                        /* No rise time. */                              \
  0,                        /* No fall time. */                              \
  TIMER_DTOGEN_DTOGCC0EN|TIMER_DTOGEN_DTOGCDTI0EN, /* Enable CC0 and CDTI0 */\
  true,                     /* Enable core lockup as fault source */         \
  true,                     /* Enable debugger as fault source */            \
  false,                    /* Disable PRS fault source 0 */                 \
  timerPRSSELCh0,           /* Not used by default, select PRS channel 0. */ \
  false,                    /* Disable PRS fault source 1 */                 \
  timerPRSSELCh0,           /* Not used by default, select PRS channel 0. */ \
  timerDtiFaultActionInactive, /* No fault action. */                        \
}
#endif /* _TIMER_DTCTRL_MASK */


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


/***************************************************************************/
__STATIC_INLINE bool TIMER_Valid(const TIMER_TypeDef *ref)
{
  return (ref == TIMER0)
#if defined(TIMER1)
         || (ref == TIMER1)
#endif
#if defined(TIMER2)
         || (ref == TIMER2)
#endif
#if defined(TIMER3)
         || (ref == TIMER3)
#endif
#if defined(WTIMER0)
         || (ref == WTIMER0)
#endif
#if defined(WTIMER1)
         || (ref == WTIMER1)
#endif
         ;
}

/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_MaxCount(const TIMER_TypeDef *ref)
{
#if defined(WTIMER_PRESENT)
  if ((ref == WTIMER0)
#if defined(WTIMER1)
      || (ref == WTIMER1)
#endif
      )
  {
    return 0xFFFFFFFFUL;
  }
#else
  (void) ref;
#endif
  return 0xFFFFUL;
}

/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_CaptureGet(TIMER_TypeDef *timer, unsigned int ch)
{
  return timer->CC[ch].CCV;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_CompareBufSet(TIMER_TypeDef *timer,
                                         unsigned int ch,
                                         uint32_t val)
{
  EFM_ASSERT(val <= TIMER_MaxCount(timer));
  timer->CC[ch].CCVB = val;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_CompareSet(TIMER_TypeDef *timer,
                                      unsigned int ch,
                                      uint32_t val)
{
  EFM_ASSERT(val <= TIMER_MaxCount(timer));
  timer->CC[ch].CCV = val;
}


/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_CounterGet(TIMER_TypeDef *timer)
{
  return timer->CNT;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_CounterSet(TIMER_TypeDef *timer, uint32_t val)
{
  EFM_ASSERT(val <= TIMER_MaxCount(timer));
  timer->CNT = val;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_Enable(TIMER_TypeDef *timer, bool enable)
{
  EFM_ASSERT(TIMER_REF_VALID(timer));

  if (enable)
  {
    timer->CMD = TIMER_CMD_START;
  }
  else
  {
    timer->CMD = TIMER_CMD_STOP;
  }
}


void TIMER_Init(TIMER_TypeDef *timer, const TIMER_Init_TypeDef *init);
void TIMER_InitCC(TIMER_TypeDef *timer,
                  unsigned int ch,
                  const TIMER_InitCC_TypeDef *init);

#if defined(_TIMER_DTCTRL_MASK)
void TIMER_InitDTI(TIMER_TypeDef *timer, const TIMER_InitDTI_TypeDef *init);

/***************************************************************************/
__STATIC_INLINE void TIMER_EnableDTI(TIMER_TypeDef *timer, bool enable)
{
  EFM_ASSERT(TIMER0 == timer);

  if (enable)
  {
    timer->DTCTRL |= TIMER_DTCTRL_DTEN;
  }
  else
  {
    timer->DTCTRL &= ~TIMER_DTCTRL_DTEN;
  }
}


/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_GetDTIFault(TIMER_TypeDef *timer)
{
  EFM_ASSERT(TIMER0 == timer);
  return timer->DTFAULT;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_ClearDTIFault(TIMER_TypeDef *timer, uint32_t flags)

{
  EFM_ASSERT(TIMER0 == timer);
  timer->DTFAULTC = flags;
}
#endif /* _TIMER_DTCTRL_MASK */


/***************************************************************************/
__STATIC_INLINE void TIMER_IntClear(TIMER_TypeDef *timer, uint32_t flags)
{
  timer->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_IntDisable(TIMER_TypeDef *timer, uint32_t flags)
{
  timer->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_IntEnable(TIMER_TypeDef *timer, uint32_t flags)
{
  timer->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_IntGet(TIMER_TypeDef *timer)
{
  return timer->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_IntGetEnabled(TIMER_TypeDef *timer)
{
  uint32_t ien;

  /* Store TIMER->IEN in temporary variable in order to define explicit order
   * of volatile accesses. */
  ien = timer->IEN;

  /* Bitwise AND of pending and enabled interrupts */
  return timer->IF & ien;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_IntSet(TIMER_TypeDef *timer, uint32_t flags)
{
  timer->IFS = flags;
}

#if defined(_TIMER_DTLOCK_LOCKKEY_LOCK)
/***************************************************************************/
__STATIC_INLINE void TIMER_Lock(TIMER_TypeDef *timer)
{
  EFM_ASSERT(TIMER0 == timer);

  timer->DTLOCK = TIMER_DTLOCK_LOCKKEY_LOCK;
}
#endif

void TIMER_Reset(TIMER_TypeDef *timer);

/***************************************************************************/
__STATIC_INLINE void TIMER_TopBufSet(TIMER_TypeDef *timer, uint32_t val)
{
  EFM_ASSERT(val <= TIMER_MaxCount(timer));
  timer->TOPB = val;
}


/***************************************************************************/
__STATIC_INLINE uint32_t TIMER_TopGet(TIMER_TypeDef *timer)
{
  return timer->TOP;
}


/***************************************************************************/
__STATIC_INLINE void TIMER_TopSet(TIMER_TypeDef *timer, uint32_t val)
{
  EFM_ASSERT(val <= TIMER_MaxCount(timer));
  timer->TOP = val;
}


#if defined(TIMER_DTLOCK_LOCKKEY_UNLOCK)
/***************************************************************************/
__STATIC_INLINE void TIMER_Unlock(TIMER_TypeDef *timer)
{
  EFM_ASSERT(TIMER0 == timer);

  timer->DTLOCK = TIMER_DTLOCK_LOCKKEY_UNLOCK;
}
#endif

#ifdef __cplusplus
}
#endif

#endif /* defined(TIMER_COUNT) && (TIMER_COUNT > 0) */
#endif /* EM_TIMER_H */