ustimer.c

Go to the documentation of this file.

/**************************************************************************/
#include <stdbool.h>
#include "em_device.h"
#include "em_common.h"
#include "em_cmu.h"
#include "em_emu.h"
#include "em_core.h"
#include "em_timer.h"

#include "ustimer.h"

#define USTIMER_TIMER0 0
#define USTIMER_TIMER1 1
#define USTIMER_TIMER2 2
#define USTIMER_TIMER3 3
#define USTIMER_TIMER4 4
#define USTIMER_TIMER5 5
#define USTIMER_TIMER6 6

#define USTIMER_WTIMER0 10
#define USTIMER_WTIMER1 11
#define USTIMER_WTIMER2 12
#define USTIMER_WTIMER3 13

#ifndef USTIMER_TIMER
#define USTIMER_TIMER USTIMER_TIMER0
#endif

#if ( USTIMER_TIMER == USTIMER_TIMER0 ) && ( TIMER_COUNT >= 1 )
  #define TIMER             TIMER0
  #define TIMER_CLK         cmuClock_TIMER0
  #define TIMER_IRQ         TIMER0_IRQn
  #define TIMER_IRQHandler  TIMER0_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER1 ) && ( TIMER_COUNT >= 2 )
  #define TIMER             TIMER1
  #define TIMER_CLK         cmuClock_TIMER1
  #define TIMER_IRQ         TIMER1_IRQn
  #define TIMER_IRQHandler  TIMER1_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER2 ) && ( TIMER_COUNT >= 3 )
  #define TIMER             TIMER2
  #define TIMER_CLK         cmuClock_TIMER2
  #define TIMER_IRQ         TIMER2_IRQn
  #define TIMER_IRQHandler  TIMER2_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER3 ) && ( TIMER_COUNT >= 4 )
  #define TIMER             TIMER3
  #define TIMER_CLK         cmuClock_TIMER3
  #define TIMER_IRQ         TIMER3_IRQn
  #define TIMER_IRQHandler  TIMER3_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER4 ) && ( TIMER_COUNT >= 5 )
  #define TIMER             TIMER4
  #define TIMER_CLK         cmuClock_TIMER4
  #define TIMER_IRQ         TIMER4_IRQn
  #define TIMER_IRQHandler  TIMER4_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER5 ) && ( TIMER_COUNT >= 6 )
  #define TIMER             TIMER5
  #define TIMER_CLK         cmuClock_TIMER5
  #define TIMER_IRQ         TIMER5_IRQn
  #define TIMER_IRQHandler  TIMER5_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_TIMER6 ) && ( TIMER_COUNT >= 7 )
  #define TIMER             TIMER6
  #define TIMER_CLK         cmuClock_TIMER6
  #define TIMER_IRQ         TIMER6_IRQn
  #define TIMER_IRQHandler  TIMER6_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_WTIMER0 ) && ( WTIMER_COUNT >= 1 )
  #define TIMER             WTIMER0
  #define TIMER_CLK         cmuClock_WTIMER0
  #define TIMER_IRQ         WTIMER0_IRQn
  #define TIMER_IRQHandler  WTIMER0_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_WTIMER1 ) && ( WTIMER_COUNT >= 2 )
  #define TIMER             WTIMER1
  #define TIMER_CLK         cmuClock_WTIMER1
  #define TIMER_IRQ         WTIMER1_IRQn
  #define TIMER_IRQHandler  WTIMER1_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_WTIMER2 ) && ( WTIMER_COUNT >= 3 )
  #define TIMER             WTIMER2
  #define TIMER_CLK         cmuClock_WTIMER2
  #define TIMER_IRQ         WTIMER2_IRQn
  #define TIMER_IRQHandler  WTIMER2_IRQHandler

#elif ( USTIMER_TIMER == USTIMER_WTIMER3 ) && ( WTIMER_COUNT >= 4 )
  #define TIMER             WTIMER3
  #define TIMER_CLK         cmuClock_WTIMER3
  #define TIMER_IRQ         WTIMER3_IRQn
  #define TIMER_IRQHandler  WTIMER3_IRQHandler

#else
#error "Illegal USTIMER TIMER selection"
#endif

// Use 16-bit TOP value for timer, independent of the width of the timer
#define TIMER_MAX   0xFFFF

static uint32_t freq;
static uint32_t minTicks;
static volatile bool timeElapsed = false;

static void DelayTicksEM1( uint16_t ticks );
static void DelayTicksPolled( uint16_t ticks );

/***************************************************************************/
Ecode_t USTIMER_Init( void )
{
  TIMER_Init_TypeDef timerInit     = TIMER_INIT_DEFAULT;
  TIMER_InitCC_TypeDef timerCCInit = TIMER_INITCC_DEFAULT;
  uint32_t coreClockScale;

  timerCCInit.mode = timerCCModeCompare;
  CMU_ClockEnable( TIMER_CLK, true );
  TIMER_TopSet( TIMER, TIMER_MAX );
  TIMER_InitCC( TIMER, 0, &timerCCInit );

  /* Run timer at slowest frequency that still gives less than 1 us per tick */
  timerInit.prescale = (TIMER_Prescale_TypeDef)_TIMER_CTRL_PRESC_DIV1;
  do
  {
    TIMER_Init( TIMER, &timerInit );

    freq = CMU_ClockFreqGet( cmuClock_HFPER );
    freq /= 1 << timerInit.prescale;
    timerInit.prescale++;
  }
  while ( ( timerInit.prescale <= _TIMER_CTRL_PRESC_DIV1024 )
          && ( freq > 2000000 ) );

  /* Figure out the minimum delay we can have when using timer interrupt
   * to avoid that actual delay become a full timer counter lap.
   * We are assuming that this number scales with mcu core clock.
   * The number is found by trial and err on a GG running at 14MHz.
   */
  coreClockScale = ( 4 * 48000000 ) / CMU_ClockFreqGet( cmuClock_CORE );
  minTicks = ( ( (uint64_t)freq * coreClockScale ) + 500000 ) / 1000000;
  timeElapsed = false;

  TIMER_IntDisable( TIMER, TIMER_IEN_CC0 );
  NVIC_ClearPendingIRQ( TIMER_IRQ );
  NVIC_EnableIRQ( TIMER_IRQ );

  return ECODE_EMDRV_USTIMER_OK;
}

/***************************************************************************/
Ecode_t USTIMER_DeInit( void )
{
  NVIC_DisableIRQ( TIMER_IRQ );
  TIMER_IntDisable( TIMER, TIMER_IEN_CC0 );

  TIMER_IntClear( TIMER, TIMER_IFC_CC0 );
  NVIC_ClearPendingIRQ( TIMER_IRQ );

  TIMER_Enable( TIMER, false );
  CMU_ClockEnable( TIMER_CLK, false );

  return ECODE_EMDRV_USTIMER_OK;
}

/***************************************************************************/
Ecode_t USTIMER_Delay( uint32_t usec )
{
  uint64_t totalTicks;

  totalTicks = ( ( (uint64_t)freq * usec ) + 500000 ) / 1000000;

  /* The timer counter is 16 bits wide, split the total wait up in chunks */
  /* of a little less than 2^16.                                          */
  while ( totalTicks > 65000 )
  {
    DelayTicksEM1( 65000 );
    totalTicks -= 65000;
  }
  DelayTicksEM1( (uint16_t)totalTicks );

  return ECODE_EMDRV_USTIMER_OK;
}

/***************************************************************************/
Ecode_t USTIMER_DelayIntSafe( uint32_t usec )
{
  uint64_t totalTicks;

  totalTicks = ( ( (uint64_t)freq * usec ) + 500000 ) / 1000000;

  /* The timer counter is 16 bits wide, split the total wait up in chunks */
  /* of a little less than 2^16.                                          */
  while ( totalTicks > 65000 )
  {
    DelayTicksPolled( 65000 );
    totalTicks -= 65000;
  }
  DelayTicksPolled( (uint16_t)totalTicks );

  return ECODE_EMDRV_USTIMER_OK;
}


void TIMER_IRQHandler( void )
{
  uint32_t flags;

  flags = TIMER_IntGet( TIMER );

  if ( flags & TIMER_IF_CC0 )
  {
    TIMER_IntClear( TIMER, TIMER_IFC_CC0 );
    timeElapsed = true;
  }
}

static void DelayTicksPolled( uint16_t ticks )
{
  uint16_t startTime;
  volatile uint16_t now;

  if ( ticks )
  {
    startTime = TIMER_CounterGet( TIMER );
    do
    {
      now = TIMER_CounterGet( TIMER );
    } while ( (uint16_t)( now - startTime ) < ticks );
  }
}

static void DelayTicksEM1( uint16_t ticks )
{
  uint32_t cmp;

  if ( ticks )
  {
    /* Arm TIMER compare interrupt */

    CORE_ATOMIC_SECTION(
      /* The following lines costs 2.7us@48MHz and 7.5us@14MHz (measured with GG)*/
      cmp = (TIMER_CounterGet( TIMER ) + SL_MAX( minTicks, ticks )) & TIMER_MAX;
      TIMER_CompareSet( TIMER, 0, cmp );
      TIMER_IntClear( TIMER, TIMER_IFC_CC0 );
      TIMER_IntEnable( TIMER, TIMER_IEN_CC0 );
    )

    while ( ! timeElapsed )
    {
      EMU_EnterEM1();
    }
    timeElapsed = false;

    TIMER_IntDisable( TIMER, TIMER_IEN_CC0 );
  }
}

/******** THE REST OF THE FILE IS DOCUMENTATION ONLY !**********************/