Re-implement RTC for Silicon Labs targets

mbed RTC specifications now dictate that the RTC needs to retain and keep on counting through reset. On Silicon Labs parts, this means the RTC API can not be backed by the Silicon Labs RTC peripheral, since that doesn't provide retention functionality.
Therefore:
* On EFM32GG, EFM32WG, EFM32LG: mbed RTC API is now backed by BURTC.
* On EFM32PG, EFR32MG, EFM32PG12, EFR32MG12: mbed RTC API is now backed by RTCC.
* On EFM32ZG, EFM32HG: mbed RTC API is sadly no longer supported, since these chips don't have retained memory.

# Conflicts:
#	targets/TARGET_Silicon_Labs/TARGET_EFM32/lp_ticker.c
#	targets/TARGET_Silicon_Labs/TARGET_EFM32/rtc_api.c
#	targets/targets.json

Author: stevew817

targets/TARGET_Silicon_Labs/TARGET_EFM32/burtc.c

@@ -0,0 +1,106 @@
+/***************************************************************************//**
+ * @file rtc_burtc.c
+ *******************************************************************************
+ * @section License
+ * <b>(C) Copyright 2018 Silicon Labs, http://www.silabs.com</b>
+ *******************************************************************************
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************************/
+
+#include "device.h"
+#if DEVICE_RTC
+
+/* Use BURTC on devices that have it, and don't use the RTCC abstraction */
+#if defined(BURTC_PRESENT) && !defined(RTCC_PRESENT)
+
+#include "clocking.h"
+#include "em_cmu.h"
+#include "em_emu.h"
+#include "em_burtc.h"
+#include "rtc_api.h"
+
+void rtc_init(void)
+{
+    /* Only reset & configure the RTC if it has never run before */
+    if(BUS_RegBitRead(&BURTC->CTRL, _BURTC_CTRL_RSTEN_SHIFT)) {
+        EMU_EM4Init_TypeDef em4_init = EMU_EM4INIT_DEFAULT;
+#if (LOW_ENERGY_CLOCK_SOURCE == LFXO)
+        em4_init.osc = emuEM4Osc_LFXO;
+#elif (LOW_ENERGY_CLOCK_SOURCE == LFRCO)
+        em4_init.osc = emuEM4Osc_LFRCO;
+#else
+#error "Can't use BURTC on mbed with ULFRCO"
+#endif
+        EMU_EM4Init(&em4_init);
+
+        BURTC_Init_TypeDef burtc_init = BURTC_INIT_DEFAULT;
+        burtc_init.mode = burtcModeEM4;
+#if (LOW_ENERGY_CLOCK_SOURCE == LFXO)
+        burtc_init.clkSel = burtcClkSelLFXO;
+#elif (LOW_ENERGY_CLOCK_SOURCE == LFRCO)
+        burtc_init.clkSel = burtcClkSelLFRCO;
+#else
+#error "Can't use BURTC on mbed with ULFRCO"
+#endif
+        burtc_init.clkDiv = burtcClkDiv_128;
+        burtc_init.lowPowerMode = burtcLPEnable;
+
+        BURTC_Reset();
+        BUS_RegBitWrite(&RMU->CTRL, _RMU_CTRL_BURSTEN_SHIFT, 0);
+        BURTC_Init(&burtc_init);
+        BURTC_RetRegSet(0, 0);
+        BURTC_RetRegSet(1, 0);
+    }
+}
+
+void rtc_free(void)
+{
+    /* Nothing to release here */
+}
+
+int rtc_isenabled(void)
+{
+    return (BUS_RegBitRead(&BURTC->CTRL, _BURTC_CTRL_RSTEN_SHIFT) == 0);
+}
+
+time_t rtc_read(void)
+{
+    uint32_t ts = 0;
+    uint32_t ts2 = 1;
+    do {
+        if (BURTC->IF & BURTC_IF_OF) {
+            BURTC_RetRegSet(1, BURTC_RetRegGet(1)+1);
+            BURTC->IFC = BURTC_IFC_OF;
+        }
+
+        ts = ts2;
+        ts2 = (BURTC_CounterGet() >> 8) + BURTC_RetRegGet(0) + (BURTC_RetRegGet(1) << 16);
+    } while (ts != ts2);
+    return ts2;
+}
+
+void rtc_write(time_t t)
+{
+    BURTC_RetRegSet(0, t - (BURTC_CounterGet() >> 8));
+    BURTC_RetRegSet(1, 0);
+    if (BURTC->IF & BURTC_IF_OF) {
+        BURTC->IFC = BURTC_IFC_OF;
+    }
+}
+
+#endif /* BURTC_PRESENT && !RTCC_PRESENT */
+#endif /* DEVICE_RTC */

targets/TARGET_Silicon_Labs/TARGET_EFM32/common/mbed_overrides.c

@@ -117,6 +117,11 @@ void mbed_sdk_init()
 # error "Low energy clock selection not valid"
 #endif
 
+#if defined(RTCC_PRESENT)
+    /* Turn RTCC clock gate back on to keep RTC time correct */
+    CMU_ClockEnable(cmuClock_RTCC, true);
+#endif
+
 #if defined(EFM_BC_EN)
     /* Enable BC line driver to avoid garbage on CDC port */
     gpio_init_out_ex(&bc_enable, EFM_BC_EN, 1);

targets/TARGET_Silicon_Labs/TARGET_EFM32/lp_ticker.c

@@ -32,6 +32,17 @@
  * for the low power timer, which should be good enough for a low power use
  * case.
  *
+ * Mapping of mbed APIs to Silicon Labs peripherals:
+ *  ---: Does not meet mbed API requirements
+ *   X : Implemented to provide mbed API functionality
+ *
+ *  --------------------------------------------
+ * | ------------- | RTCC | BURTC | RTC | TIMER |
+ * | rtc_api       |  X   |   X   | --- | ----- |
+ * | lp_ticker_api |  X   |       |  X  | ----- |
+ * | us_ticker_api | ---  | ----- | --- |   X   |
+ *  --------------------------------------------
+ *
  * On Silicon Labs devices, the lowest width RTC implementation has a 24-bit
  * counter, which gets extended with a further 32-bit software counter. This
  * gives 56 bits of actual width, which with the default speed maps to
@@ -40,32 +51,122 @@
  * (At max speed the wraparound is at 69730 years, which is unlikely as well)
  ******************************************************************************/
 
-#include "rtc_api.h"
-#include "rtc_api_HAL.h"
+#if defined(RTC_PRESENT)
+#include "em_rtc.h"
+#include "em_cmu.h"
 #include "lp_ticker_api.h"
 #include "mbed_critical.h"
 
-static int rtc_reserved = 0;
+#if RTC_CLOCKDIV_INT > 16
+#error invalid prescaler value RTC_CLOCKDIV_INT, since LP ticker resolution will exceed 1ms.
+#endif
+
+#define RTC_BITS (24U)
+#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;
+
+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) {
+        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();
+    }
+    while ( (ticks & RTC_MAX_VALUE) != RTC_CounterGet() );
+
+    return ticks;
+}
 
 void lp_ticker_init()
 {
-    if(!rtc_reserved) {
-        core_util_critical_section_enter();
-        rtc_init_real(RTC_INIT_LPTIMER);
-        rtc_set_comp0_handler((uint32_t)lp_ticker_irq_handler);
-        rtc_reserved = 1;
-        core_util_critical_section_exit();
+    core_util_critical_section_enter();
+    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;
+
+        /* Enable Interrupt from RTC */
+        RTC_IntEnable(RTC_IEN_OF);
+        NVIC_SetVector(RTC_IRQn, (uint32_t)RTC_IRQHandler);
+        NVIC_EnableIRQ(RTC_IRQn);
+
+        /* Initialize */
+        RTC_Init(&init);
+
+        rtc_inited = true;
     }
+    core_util_critical_section_exit();
 }
 
 void lp_ticker_free()
 {
-    if(rtc_reserved) {
-        core_util_critical_section_enter();
-        rtc_free_real(RTC_INIT_LPTIMER);
-        rtc_reserved = 0;
-        core_util_critical_section_exit();
+    /* Disable the RTC if it was inited and is no longer in use by anyone. */
+    if (rtc_inited) {
+        NVIC_DisableIRQ(RTC_IRQn);
+        RTC_Reset();
+        CMU_ClockEnable(cmuClock_RTC, false);
+        rtc_inited = false;
+    }
+}
+
+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)
+{
+    rtc_enable_comp0(false);
+
+    /* Set callback */
+    RTC_FreezeEnable(true);
+    extended_comp0 = (uint32_t) (value >> RTC_BITS);
+    RTC_CompareSet(0, (uint32_t) (value & RTC_MAX_VALUE));
+    RTC_FreezeEnable(false);
+
+    rtc_enable_comp0(enable);
 }
 
 void lp_ticker_set_interrupt(timestamp_t timestamp)
@@ -96,17 +197,17 @@ void lp_ticker_set_interrupt(timestamp_t timestamp)
     rtc_set_comp0_value(rtc_compare_value, true);
 }
 
-inline void lp_ticker_fire_interrupt(void)
+void lp_ticker_fire_interrupt(void)
 {
-    rtc_force_comp0();
+    RTC_IntSet(RTC_IFS_COMP0);
 }
 
-inline void lp_ticker_disable_interrupt()
+void lp_ticker_disable_interrupt()
 {
     rtc_enable_comp0(false);
 }
 
-inline void lp_ticker_clear_interrupt()
+void lp_ticker_clear_interrupt()
 {
     /* No need to clear interrupt flag, since that already happens at RTC level */
 }
@@ -127,4 +228,7 @@ timestamp_t lp_ticker_read()
     return (timestamp_t) (ticks_temp & 0xFFFFFFFF);
 }
 
-#endif
+#elif defined(RTCC_PRESENT)
+/* lp_ticker api is implemented in rtc_rtcc.c */
+#endif /* RTC_PRESENT */
+#endif /* DEVICE_LOWPOWERTIMER */