Re-implement us_ticker and lp_ticker for Silicon Labs targets

Re-implemented both us_ticker and lp_ticker to match the new API and specifications.
Details:
* On EFM32GG, EFM32WG, EFM32LG, EFM32HG, EFM32ZG: Use the RTC peripheral to back lp_ticker, and a TIMER to back us_ticker.
* On EFM32PG, EFR32MG, EFM32PG12, EFR32MG12: Use the RTCC peripheral to back lp_ticker (dual-purpose, also used to back RTC), and a TIMER to back us_ticker.

Author: stevew817

targets/TARGET_Silicon_Labs/TARGET_EFM32/common/clocking.h

@@ -106,12 +106,12 @@
 #endif
 
 /* Adjust this to change speed of RTC and LP ticker ticks */
-#define RTC_CLOCKDIV        cmuClkDiv_8
+#define RTC_CLOCKDIV        cmuClkDiv_1
 /* Adjust this to match RTC_CLOCKDIV as integer value */
-#define RTC_CLOCKDIV_INT    8U
+#define RTC_CLOCKDIV_INT    1U
 /* Adjust this to match RTC_CLOCKDIV as shift for 1 second worth of ticks.
  * E.g. with 32768 Hz crystal and CLOCKDIV of 8, 1 second is 4096 ticks.
  * 4096 equals 1 << 12, so RTC_FREQ_SHIFT needs to be 12. */
-#define RTC_FREQ_SHIFT      12U
+#define RTC_FREQ_SHIFT      15U
 
 #endif

targets/TARGET_Silicon_Labs/TARGET_EFM32/lp_ticker.c

@@ -65,45 +65,24 @@
 #define RTC_MAX_VALUE (0xFFFFFFUL)
 
 static bool         rtc_inited  = false;
-static time_t       time_base   = 0;
-static uint32_t     time_extend = 0;
-static uint32_t     extended_comp0 = 0;
+
+const ticker_info_t* lp_ticker_get_info(void)
+{
+    static const ticker_info_t rtc_info = {
+        LOW_ENERGY_CLOCK_FREQUENCY,
+        RTC_BITS
+    };
+    return &rtc_info;
+}
 
 void RTC_IRQHandler(void)
 {
     uint32_t flags;
     flags = RTC_IntGet();
-    if (flags & RTC_IF_OF) {
-        RTC_IntClear(RTC_IF_OF);
-        /* RTC has overflowed (24 bits). Use time_extend as software counter for 32 more bits. */
-        time_extend += 1;
-    }
-    if (flags & RTC_IF_COMP0) {
+    if ((flags & RTC_IF_COMP0) && rtc_inited) {
         RTC_IntClear(RTC_IF_COMP0);
-        if (lp_ticker_irq_handler != NULL && time_extend == extended_comp0) {
-            lp_ticker_irq_handler();
-        }
-    }
-}
-
-uint64_t rtc_get_full(void)
-{
-    uint64_t ticks = 0;
-
-    do
-    {
-        /* In case someone's trying to read time in a critical section */
-        if (RTC_IntGet() & RTC_IF_OF) {
-            RTC_IntClear(RTC_IF_OF);
-            time_extend += 1;
-        }
-
-        ticks = (uint64_t)time_extend << RTC_BITS;
-        ticks += RTC_CounterGet();
+        lp_ticker_irq_handler();
     }
-    while ( (ticks & RTC_MAX_VALUE) != RTC_CounterGet() );
-
-    return ticks;
 }
 
 void lp_ticker_init()
@@ -112,24 +91,27 @@ void lp_ticker_init()
     if (!rtc_inited) {
         CMU_ClockEnable(cmuClock_RTC, true);
 
-        /* Scale clock to save power */
-        CMU_ClockDivSet(cmuClock_RTC, RTC_CLOCKDIV);
-
         /* Initialize RTC */
         RTC_Init_TypeDef init = RTC_INIT_DEFAULT;
         init.enable = 1;
         /* Don't use compare register 0 as top value */
         init.comp0Top = 0;
 
+        /* Initialize */
+        RTC_Init(&init);
+        RTC_CounterSet(20);
+
         /* Enable Interrupt from RTC */
-        RTC_IntEnable(RTC_IEN_OF);
+        RTC_IntDisable(RTC_IF_COMP0);
+        RTC_IntClear(RTC_IF_COMP0);
         NVIC_SetVector(RTC_IRQn, (uint32_t)RTC_IRQHandler);
         NVIC_EnableIRQ(RTC_IRQn);
 
-        /* Initialize */
-        RTC_Init(&init);
-
         rtc_inited = true;
+    } else {
+        /* Cancel current interrupt by virtue of calling init again */
+        RTC_IntDisable(RTC_IF_COMP0);
+        RTC_IntClear(RTC_IF_COMP0);
     }
     core_util_critical_section_exit();
 }
@@ -145,90 +127,38 @@ void lp_ticker_free()
     }
 }
 
-void rtc_enable_comp0(bool enable)
-{
-    RTC_FreezeEnable(true);
-    if (!enable) {
-        RTC_IntDisable(RTC_IF_COMP0);
-    } else {
-        RTC_IntEnable(RTC_IF_COMP0);
-    }
-    RTC_FreezeEnable(false);
-}
-
-void rtc_set_comp0_value(uint64_t value, bool enable)
+void lp_ticker_set_interrupt(timestamp_t timestamp)
 {
-    rtc_enable_comp0(false);
-
-    /* Set callback */
+    RTC_IntDisable(RTC_IF_COMP0);
+    RTC_IntClear(RTC_IF_COMP0);
     RTC_FreezeEnable(true);
-    extended_comp0 = (uint32_t) (value >> RTC_BITS);
-    RTC_CompareSet(0, (uint32_t) (value & RTC_MAX_VALUE));
+    RTC_CompareSet(0, (uint32_t) (timestamp & RTC_MAX_VALUE));
     RTC_FreezeEnable(false);
-
-    rtc_enable_comp0(enable);
-}
-
-void lp_ticker_set_interrupt(timestamp_t timestamp)
-{
-    uint64_t rtc_compare_value;
-    uint64_t current_ticks = rtc_get_full();
-    timestamp_t current_time = lp_ticker_read();
-
-    /* calculate offset value */
-    timestamp_t offset = timestamp - current_time;
-
-    /* If the requested timestamp is too far in the future, we might not be able
-     * to set the interrupt accurately due to potentially having ticked between
-     * calculating the timestamp to set and us calculating the offset. */
-    if(offset > 0xFFFF0000) offset = 100;
-
-    /* map offset to RTC value */
-    // ticks = offset * RTC frequency div 1000000
-    rtc_compare_value = ((uint64_t)offset * (LOW_ENERGY_CLOCK_FREQUENCY / RTC_CLOCKDIV_INT)) / 1000000;
-
-    /* If RTC offset is less then 2 RTC ticks, the interrupt won't fire */
-    if(rtc_compare_value < 2) {
-        rtc_compare_value = 2;
-    }
-
-    rtc_compare_value += current_ticks;
-
-    rtc_set_comp0_value(rtc_compare_value, true);
+    RTC_IntEnable(RTC_IF_COMP0);
 }
 
 void lp_ticker_fire_interrupt(void)
 {
-    RTC_IntSet(RTC_IFS_COMP0);
+    RTC_IntEnable(RTC_IF_COMP0);
+    RTC_IntSet(RTC_IF_COMP0);
 }
 
 void lp_ticker_disable_interrupt()
 {
-    rtc_enable_comp0(false);
+    RTC_IntDisable(RTC_IF_COMP0);
 }
 
 void lp_ticker_clear_interrupt()
 {
-    /* No need to clear interrupt flag, since that already happens at RTC level */
+    RTC_IntClear(RTC_IF_COMP0);
 }
 
 timestamp_t lp_ticker_read()
 {
-    lp_ticker_init();
-
-    uint64_t ticks_temp;
-    uint64_t ticks = rtc_get_full();
-
-    /* ticks = counter tick value
-     * timestamp = value in microseconds
-     * timestamp = ticks * 1.000.000 / RTC frequency
-     */
-
-    ticks_temp = (ticks * 1000000) / (LOW_ENERGY_CLOCK_FREQUENCY / RTC_CLOCKDIV_INT);
-    return (timestamp_t) (ticks_temp & 0xFFFFFFFF);
+    return (timestamp_t) RTC_CounterGet();
 }
 
 #elif defined(RTCC_PRESENT)
 /* lp_ticker api is implemented in rtc_rtcc.c */
 #endif /* RTC_PRESENT */
-#endif /* DEVICE_LOWPOWERTIMER */
+#endif /* DEVICE_LPTICKER */

targets/TARGET_Silicon_Labs/TARGET_EFM32/rtcc.c

@@ -36,7 +36,6 @@
 
 static bool lptick_inited = false;
 static uint32_t lptick_offset = 0;
-static uint32_t extended_comp0 = 0;
 
 void rtc_init(void)
 {
@@ -79,30 +78,32 @@ void rtc_write(time_t t)
 {
     core_util_critical_section_enter();
     uint32_t diff = t - RTCC_CounterGet();
-    if (extended_comp0 != 0xFFFFFFFFUL) {
-        extended_comp0 += diff;
-    }
     lptick_offset += diff;
 
+    if(RTCC_IntGetEnabled() & RTCC_IF_CC0) {
+        RTCC->CC[0].CCV += diff << 15;
+    }
+
     RTCC_CounterSet(t);
     core_util_critical_section_exit();
 }
 
 /************************* LP_TICKER **************************/
+const ticker_info_t* lp_ticker_get_info(void)
+{
+    static const ticker_info_t rtc_info = {
+        LOW_ENERGY_CLOCK_FREQUENCY,
+        32
+    };
+    return &rtc_info;
+}
+
 void RTCC_IRQHandler(void)
 {
     uint32_t flags;
     flags = RTCC_IntGet();
     if (flags & RTCC_IF_CC0) {
-        RTCC_IntClear(RTCC_IF_CC0);
-        if ((RTCC_CounterGet() - lptick_offset) == extended_comp0) {
-            RTCC_IntDisable(RTCC_IF_CC0);
-            lp_ticker_irq_handler();
-        }
-        if (0xFFFFFFFFUL == extended_comp0) {
-            RTCC_IntDisable(RTCC_IF_CC0);
-            lp_ticker_irq_handler();
-        }
+        lp_ticker_irq_handler();
     }
 }
 
@@ -113,12 +114,17 @@ void lp_ticker_init()
         lptick_offset = RTCC_CounterGet();
         RTCC_CCChConf_TypeDef lp_chan_init = RTCC_CH_INIT_COMPARE_DEFAULT;
         lp_chan_init.compBase = rtccCompBasePreCnt;
-        lp_chan_init.compMask = 17;
+        lp_chan_init.compMask = 0;
         RTCC_ChannelInit(0, &lp_chan_init);
         lptick_inited = true;
 
-        /* Enable Interrupt from RTCC */
+        /* Enable Interrupt from RTCC in NVIC, but don't start generating them */
+        RTCC_IntDisable(RTCC_IF_CC0);
+        RTCC_IntClear(RTCC_IF_CC0);
         NVIC_EnableIRQ(RTCC_IRQn);
+    } else {
+        RTCC_IntDisable(RTCC_IF_CC0);
+        RTCC_IntClear(RTCC_IF_CC0);
     }
 }
 
@@ -133,45 +139,13 @@ void lp_ticker_free()
 
 void lp_ticker_set_interrupt(timestamp_t timestamp)
 {
-    uint64_t rtc_compare_value;
-    uint64_t current_ticks = 0;
-    do
-    {
-        current_ticks = (uint64_t)((uint64_t)RTCC_CounterGet() - lptick_offset) << 15;
-        current_ticks += RTCC_PreCounterGet();
-    }
-    while ( (current_ticks & 0x7FFF) != RTCC_PreCounterGet() );
-
-    uint64_t ticks_temp = (current_ticks * 1000000) / LOW_ENERGY_CLOCK_FREQUENCY;
-    timestamp_t current_time = ticks_temp & 0xFFFFFFFF;
-
-    /* calculate offset value */
-    timestamp_t offset = timestamp - current_time;
-
-    /* If the requested timestamp is too far in the future, we might not be able
-     * to set the interrupt accurately due to potentially having ticked between
-     * calculating the timestamp to set and us calculating the offset. */
-    if(offset > 0xFFFF0000) offset = 100;
-
-    /* map offset to RTC value */
-    // ticks = offset * RTC frequency div 1000000
-    rtc_compare_value = ((uint64_t)offset * LOW_ENERGY_CLOCK_FREQUENCY) / 1000000;
-
-    /* If RTC offset is less then 2 RTC ticks, the interrupt won't fire */
-    if(rtc_compare_value < 2) {
-        rtc_compare_value = 2;
-    }
-
-    rtc_compare_value += current_ticks;
-
-    extended_comp0 = rtc_compare_value >> 15;
-    RTCC_ChannelCCVSet(0, rtc_compare_value & 0xFFFFFFFFUL);
+    RTCC_ChannelCCVSet(0, timestamp + (lptick_offset << 15));
     RTCC_IntEnable(RTCC_IF_CC0);
 }
 
 void lp_ticker_fire_interrupt(void)
 {
-    extended_comp0 = 0xFFFFFFFFUL;
+    RTCC_IntEnable(RTCC_IF_CC0);
     RTCC_IntSet(RTCC_IF_CC0);
 }
 
@@ -187,25 +161,11 @@ void lp_ticker_clear_interrupt()
 
 timestamp_t lp_ticker_read()
 {
-    lp_ticker_init();
-
-    uint64_t ticks_temp;
-    uint64_t ticks = 0;
-
-    do
-    {
-        ticks = (uint64_t)((uint64_t)RTCC_CounterGet() - lptick_offset) << 15;
-        ticks += RTCC_PreCounterGet();
-    }
-    while ( (ticks & 0x7FFF) != RTCC_PreCounterGet() );
-
-    /* ticks = counter tick value
-     * timestamp = value in microseconds
-     * timestamp = ticks * 1.000.000 / RTC frequency
-     */
+    core_util_critical_section_enter();
+    uint32_t ticks = RTCC_CombinedCounterGet() - (lptick_offset << 15);
+    core_util_critical_section_exit();
 
-    ticks_temp = (ticks * 1000000) / LOW_ENERGY_CLOCK_FREQUENCY;
-    return (timestamp_t) (ticks_temp & 0xFFFFFFFF);
+    return (timestamp_t) (ticks);
 }
 #endif /* RTCC_PRESENT */
 #endif /* DEVICE_RTC */