ncs36510: Adopt 16-bit ticker/timer

Author: geky

targets/TARGET_ONSEMI/TARGET_NCS36510/ncs36510_us_ticker_api.c

@@ -30,16 +30,9 @@
 #include <stddef.h>
 #include "timer.h"
 
-#define US_TIMER  TIMER0
-#define US_TICKER TIMER1
-
-static int us_ticker_inited = 0;
-
+static bool us_ticker_inited = false;
 static void us_timer_init(void);
 
-static uint32_t us_ticker_target = 0;
-static volatile uint32_t msb_counter = 0;
-
 void us_ticker_init(void)
 {
     if (!us_ticker_inited) {
@@ -54,15 +47,12 @@ void us_ticker_init(void)
  * The NCS36510 does not have a 32 bit timer nor the option to chain timers,
  * which is why a software timer is required to get 32-bit word length.
  ******************************************************************************/
-/* TODO - Need some sort of load value/prescale calculation for non-32MHz clock */
-/* TODO - Add msb_counter rollover protection at 16 bits count? */
-/* TODO - How is overflow handled? */
 
-/* Timer 0 for free running time */
+/* TImer 0 - timer ISR */
 extern void us_timer_isr(void)
 {
+    /* Clear IRQ flag */
     TIM0REG->CLEAR = 0;
-    msb_counter++;
 }
 
 /* Initializing TIMER 0(TImer) and TIMER 1(Ticker) */
@@ -87,8 +77,7 @@ static void us_timer_init(void)
     TIM1REG->LOAD = 0xFFFF;
 
     /* set timer prescale 32 (1 us), mode & enable */
-    TIM1REG->CONTROL.WORD = ((CLK_DIVIDER_32        << TIMER_PRESCALE_BIT_POS) |
-                             (TIME_MODE_PERIODIC    << TIMER_MODE_BIT_POS));
+    TIM1REG->CONTROL.WORD = ((CLK_DIVIDER_32        << TIMER_PRESCALE_BIT_POS));
 
     /* Register & enable interrupt associated with the timer */
     NVIC_SetVector(Tim0_IRQn,(uint32_t)us_timer_isr);
@@ -108,36 +97,22 @@ static void us_timer_init(void)
 /* Reads 32 bit timer's current value (16 bit s/w timer | 16 bit h/w timer) */
 uint32_t us_ticker_read()
 {
-    uint32_t retval, tim0cval;
-
     if (!us_ticker_inited) {
         us_timer_init();
     }
 
     /* Get the current tick from the hw and sw timers */
-    tim0cval = TIM0REG->VALUE;         /* read current time */
-    retval = (0xFFFF - tim0cval);      /* subtract down count */
-
-    NVIC_DisableIRQ(Tim0_IRQn);
-    if (TIM0REG->CONTROL.BITS.INT) {
-        TIM0REG->CLEAR = 0;
-        msb_counter++;
-        tim0cval = TIM0REG->VALUE;    /* read current time again after interrupt */
-        retval = (0xFFFF - tim0cval);
-    }
-    retval |= msb_counter << 16;      /* add software bits */
-    NVIC_EnableIRQ(Tim0_IRQn);
-    return retval;
+    uint32_t tim0cval = TIM0REG->VALUE;         /* read current time */
+    return (0xFFFF - tim0cval);      /* subtract down count */
 }
 
 /*******************************************************************************
  * Event Timer
  *
- * Schedules interrupts at given (32bit)us interval of time.  It uses TIMER1.
+ * Schedules interrupts at given (16bit)us interval of time.  It uses TIMER1.
  * The NCS36510 does not have a 32 bit timer nor the option to chain timers,
  * which is why a software timer is required to get 32-bit word length.
  *******************************************************************************/
-/* TODO - Need some sort of load value/prescale calculation for non-32MHz clock */
 
 /* TImer 1 disbale interrupt */
 void us_ticker_disable_interrupt(void)
@@ -153,57 +128,35 @@ void us_ticker_clear_interrupt(void)
     TIM1REG->CLEAR = 0;
 }
 
-/* Setting TImer 1 (ticker) */
-inline static void ticker_set(uint32_t count)
-{
-    /* Disable TIMER1, load the new value, and re-enable */
-    TIM1REG->CONTROL.BITS.ENABLE = 0;
-    TIM1REG->LOAD = count;
-    TIM1REG->CONTROL.BITS.ENABLE = 1;
-}
-
 /* TImer 1 - ticker ISR */
 extern void us_ticker_isr(void)
 {
     /* Clear IRQ flag */
     TIM1REG->CLEAR = 0;
-
-    int32_t delta = us_ticker_target - us_ticker_read();
-    if (delta <= 0) {
-        TIM1REG->CONTROL.BITS.ENABLE = False;
-        us_ticker_irq_handler();
-    } else {
-        // Clamp at max value of timer
-        if (delta > 0xFFFF) {
-            delta = 0xFFFF;
-        }
-
-        ticker_set(delta);
-    }
+    us_ticker_irq_handler();
 }
 
 /* Set timer 1 ticker interrupt */
 void us_ticker_set_interrupt(timestamp_t timestamp)
 {
-    us_ticker_target = (uint32_t)timestamp;
-    int32_t delta = us_ticker_target - us_ticker_read();
+    int32_t delta = timestamp - us_ticker_read();
 
+    // This event was in the past.
+    // Set the interrupt as pending, but don't process it here.
+    // This prevents a recurive loop under heavy load
+    // which can lead to a stack overflow.
     if (delta <= 0) {
-        /* This event was in the past */
-        //us_ticker_irq_handler();
-        // This event was in the past.
-        // Set the interrupt as pending, but don't process it here.
-        // This prevents a recurive loop under heavy load
-        // which can lead to a stack overflow.
         NVIC_SetPendingIRQ(Tim1_IRQn);
-
         return;
     }
 
-    // Clamp at max value of timer
-    if (delta > 0xFFFF) {
-        delta = 0xFFFF;
+    /* Clamp to 16 bits */
+    if (delta > 0xffff) {
+        delta = 0xffff;
     }
 
-    ticker_set(delta);
+    /* Disable TIMER1, load the new value, and re-enable */
+    TIM1REG->CONTROL.BITS.ENABLE = 0;
+    TIM1REG->LOAD = (uint16_t)delta;
+    TIM1REG->CONTROL.BITS.ENABLE = 1;
 }