Update lp ticker to be consistent with the new standards.

Provide the following modifications for lp ticker driver:
- According to NRF51_DK reference manual rtc interrupt cannot be controlled by rtc event. In the previous implementation interrupts were enabled permanently and specific interrupt was enabled/disabled by enabling/disabling the specific event. If event is enabled, then event signal is provided to Programmable Peripheral Interconnect (PPI). If interrupt is enabled, then interrupt signal is provided to Nested Vector Interrupt Controller (NVIC). Disable all events permanently. Enable lp ticker overflow interrupt permanently(needed for RTC), disable lp ticker capture/compare interrupt on init (lp_ticker_init) , enable lp ticker interrupt when lp ticker interrupt is set (lp_ticker_set_interrupt), disable lp ticker interrupt on disable request(lp_ticker_disable_interrupt).
- Provide lp ticker data for higher level (freq: 32kHz / len: 24 bits),
- Add the following features to init routine: disable lp ticker interrupt.
- Make ticker driver to operate on ticks instead of us.
- Simplify lp ticker read and set interrupt routines (upper layers handle conversion to us and interrupt scheduling).

Author: mprse

targets/TARGET_NORDIC/TARGET_NRF5/common_rtc.c

@@ -47,19 +47,22 @@
     #include "softdevice_handler.h"
 #endif
 
+
 //------------------------------------------------------------------------------
 // Common stuff used also by lp_ticker and rtc_api (see "common_rtc.h").
 //
 #include "app_util_platform.h"
 
 bool              m_common_rtc_enabled = false;
 uint32_t volatile m_common_rtc_overflows = 0;
+bool     volatile lp_ticker_interrupt_fire = false;
 
 __STATIC_INLINE void rtc_ovf_event_check(void)
 {
     if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW)) {
         nrf_rtc_event_clear(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW);
-        // Don't disable this event. It shall occur periodically.
+        /* Don't disable this event. It shall occur periodically.
+         * It is needed for RTC. */
 
         ++m_common_rtc_overflows;
     }
@@ -74,14 +77,19 @@ void COMMON_RTC_IRQ_HANDLER(void)
     rtc_ovf_event_check();
 
 #if DEVICE_LOWPOWERTIMER
-    if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, LP_TICKER_EVENT)) {
+    if (nrf_rtc_event_pending(COMMON_RTC_INSTANCE, LP_TICKER_EVENT) ||
+        lp_ticker_interrupt_fire) {
+
+        if (lp_ticker_interrupt_fire) {
+            lp_ticker_interrupt_fire = false;
+        }
 
         lp_ticker_irq_handler();
     }
 #endif
 }
 
-// Function for fix errata 20: RTC Register values are invalid
+/* Function for fix errata 20: RTC Register values are invalid. */
 __STATIC_INLINE void errata_20(void)
 {
 #if defined(NRF52_ERRATA_20)
@@ -103,20 +111,28 @@ void RTC1_IRQHandler(void);
 void common_rtc_init(void)
 {
     if (m_common_rtc_enabled) {
+#if DEVICE_LOWPOWERTIMER
+        nrf_rtc_event_clear(COMMON_RTC_INSTANCE, LP_TICKER_EVENT);
+        nrf_rtc_int_disable(COMMON_RTC_INSTANCE, LP_TICKER_INT_MASK);
+#endif
         return;
     }
 
     errata_20();
 
+    nrf_rtc_task_trigger(COMMON_RTC_INSTANCE, NRF_RTC_TASK_STOP);
+
     NVIC_SetVector(RTC1_IRQn, (uint32_t)RTC1_IRQHandler);
 
-    // RTC is driven by the low frequency (32.768 kHz) clock, a proper request
-    // must be made to have it running.
-    // Currently this clock is started in 'SystemInit' (see "system_nrf51.c"
-    // or "system_nrf52.c", respectively).
+    /* RTC is driven by the low frequency (32.768 kHz) clock, a proper request
+     * must be made to have it running.
+     * Currently this clock is started in 'SystemInit' (see "system_nrf51.c"
+     * or "system_nrf52.c", respectively).
+     */
 
     nrf_rtc_prescaler_set(COMMON_RTC_INSTANCE, 0);
 
+    /* Clear all RTC events. */
 #if defined(TARGET_MCU_NRF51822)
     nrf_rtc_event_clear(COMMON_RTC_INSTANCE, OS_TICK_EVENT);
 #endif
@@ -125,27 +141,29 @@ void common_rtc_init(void)
 #endif
     nrf_rtc_event_clear(COMMON_RTC_INSTANCE, NRF_RTC_EVENT_OVERFLOW);
 
-    // Interrupts on all related events are enabled permanently. Particular
-    // events will be enabled or disabled as needed (such approach is more
-    // energy efficient).
-    nrf_rtc_int_enable(COMMON_RTC_INSTANCE,
-#if DEVICE_LOWPOWERTIMER
-        LP_TICKER_INT_MASK |
-#endif
-        NRF_RTC_INT_OVERFLOW_MASK);
+    /* Disable all RTC events (According to NRF_51 Reference Manual
+     * RTC events can not be used to control RTC interrupts).
+     * IRQ signal to NVIC is provided if interrupt is enabled.
+     */
 
-    // This event is enabled permanently, since overflow indications are needed
-    // continuously.
-    nrf_rtc_event_enable(COMMON_RTC_INSTANCE, NRF_RTC_INT_OVERFLOW_MASK);
-    // All other relevant events are initially disabled.
-    nrf_rtc_event_disable(COMMON_RTC_INSTANCE, 0 |
+    nrf_rtc_event_disable(COMMON_RTC_INSTANCE, NRF_RTC_INT_OVERFLOW_MASK
 #if defined(TARGET_MCU_NRF51822)
-        OS_TICK_INT_MASK |
+        | OS_TICK_INT_MASK
 #endif
 #if DEVICE_LOWPOWERTIMER
-        LP_TICKER_INT_MASK
+        | LP_TICKER_INT_MASK
+#endif
+     );
+
+    /* This interrupt is enabled permanently, since overflow indications are needed
+     * continuously.
+     */
+    nrf_rtc_int_enable(COMMON_RTC_INSTANCE, NRF_RTC_INT_OVERFLOW_MASK);
+
+    /* Disable LP ticker interrupt for now. */
+#if DEVICE_LOWPOWERTIMER
+    nrf_rtc_int_disable(COMMON_RTC_INSTANCE, LP_TICKER_INT_MASK);
 #endif
-        );
 
     nrf_drv_common_irq_enable(nrf_drv_get_IRQn(COMMON_RTC_INSTANCE),
 #ifdef NRF51
@@ -160,93 +178,38 @@ void common_rtc_init(void)
     m_common_rtc_enabled = true;
 }
 
-__STATIC_INLINE void rtc_ovf_event_safe_check(void)
-{
-    core_util_critical_section_enter();
-
-    rtc_ovf_event_check();
-
-    core_util_critical_section_exit();
-}
-
-
-uint32_t common_rtc_32bit_ticks_get(void)
+void common_rtc_set_interrupt(uint32_t ticks_count, uint32_t cc_channel,
+                              uint32_t int_mask)
 {
-    uint32_t ticks;
-    uint32_t prev_overflows;
-
-    do {
-        prev_overflows = m_common_rtc_overflows;
-
-        ticks = nrf_rtc_counter_get(COMMON_RTC_INSTANCE);
-        // The counter used for time measurements is less than 32 bit wide,
-        // so its value is complemented with the number of registered overflows
-        // of the counter.
-        ticks += (m_common_rtc_overflows << RTC_COUNTER_BITS);
-
-        // Check in case that OVF occurred during execution of a RTC handler (apply if call was from RTC handler)
-        // m_common_rtc_overflows might been updated in this call.
-        rtc_ovf_event_safe_check();
-
-        // If call was made from a low priority level m_common_rtc_overflows might have been updated in RTC handler.
-    } while (m_common_rtc_overflows != prev_overflows);
+    /* Set ticks value when interrupt should be fired.
+     * Interrupt scheduling is performed in upper layers. */
 
-    return ticks;
-}
+    core_util_critical_section_enter();
 
-uint64_t common_rtc_64bit_us_get(void)
-{
-    uint32_t ticks = common_rtc_32bit_ticks_get();
-    // [ticks -> microseconds]
-    return ROUNDED_DIV(((uint64_t)ticks) * 1000000, RTC_INPUT_FREQ);
-}
+    /* COMPARE occurs when a CC register is N and the COUNTER value transitions from N-1 to N.
+     * If the COUNTER is N, writing N+2 to a CC register is guaranteed to trigger a
+     * COMPARE event at N+2.
+     */
+    const uint32_t now = nrf_rtc_counter_get(COMMON_RTC_INSTANCE);
 
-void common_rtc_set_interrupt(uint32_t us_timestamp, uint32_t cc_channel,
-                              uint32_t int_mask)
-{
-    // The internal counter is clocked with a frequency that cannot be easily
-    // multiplied to 1 MHz, therefore besides the translation of values
-    // (microsecond <-> ticks) a special care of overflows handling must be
-    // taken. Here the 32-bit timestamp value is complemented with information
-    // about current the system up time of (ticks + number of overflows of tick
-    // counter on upper bits, converted to microseconds), and such 64-bit value
-    // is then translated to counter ticks. Finally, the lower 24 bits of thus
-    // calculated value is written to the counter compare register to prepare
-    // the interrupt generation.
-    uint64_t current_time64 = common_rtc_64bit_us_get();
-    // [add upper 32 bits from the current time to the timestamp value]
-    uint64_t timestamp64 = us_timestamp +
-        (current_time64 & ~(uint64_t)0xFFFFFFFF);
-    // [if the original timestamp value happens to be after the 32 bit counter
-    //  of microsends overflows, correct the upper 32 bits accordingly]
-    if (us_timestamp < (uint32_t)(current_time64 & 0xFFFFFFFF)) {
-        timestamp64 += ((uint64_t)1 << 32);
+    if (now == ticks_count ||
+        RTC_WRAP(now + 1) == ticks_count) {
+        ticks_count += 2;
     }
-    // [microseconds -> ticks, always round the result up to avoid too early
-    //  interrupt generation]
-    uint32_t compare_value =
-        (uint32_t)CEIL_DIV((timestamp64) * RTC_INPUT_FREQ, 1000000);
 
+    nrf_rtc_cc_set(COMMON_RTC_INSTANCE, cc_channel, RTC_WRAP(ticks_count));
 
-    core_util_critical_section_enter();
-    // The COMPARE event occurs when the value in compare register is N and
-    // the counter value changes from N-1 to N. Therefore, the minimal safe
-    // difference between the compare value to be set and the current counter
-    // value is 2 ticks. This guarantees that the compare trigger is properly
-    // setup before the compare condition occurs.
-    uint32_t closest_safe_compare = common_rtc_32bit_ticks_get() + 2;
-    if ((int)(compare_value - closest_safe_compare) <= 0) {
-        compare_value = closest_safe_compare;
+    if (!nrf_rtc_int_is_enabled(COMMON_RTC_INSTANCE, int_mask)) {
+        nrf_rtc_event_clear(COMMON_RTC_INSTANCE, LP_TICKER_EVENT);
+        nrf_rtc_int_enable(COMMON_RTC_INSTANCE, int_mask);
     }
 
-    nrf_rtc_cc_set(COMMON_RTC_INSTANCE, cc_channel, RTC_WRAP(compare_value));
-    nrf_rtc_event_enable(COMMON_RTC_INSTANCE, int_mask);
-
     core_util_critical_section_exit();
 }
 
-// Since there is no SysTick on NRF51, the RTC1 channel 1 is used as an
-// alternative source of RTOS ticks.
+/* Since there is no SysTick on NRF51, the RTC1 channel 0 is used as an
+ * alternative source of RTOS ticks.
+ */
 #if defined(TARGET_MCU_NRF51822)
 
 #include "mbed_toolchain.h"

targets/TARGET_NORDIC/TARGET_NRF5/common_rtc.h

@@ -20,6 +20,7 @@
 #include "nrf_rtc.h"
 
 #define RTC_COUNTER_BITS        24u
+#define RTC_FREQ                32768u
 
 // Instance 0 is reserved for SoftDevice.
 // Instance 1 is used as a common one for lp_ticker and (in case
@@ -29,9 +30,6 @@
 #define OS_TICK_CC_CHANNEL      0
 #define LP_TICKER_CC_CHANNEL    1
 
-#define US_TICKER_SW_IRQ_MASK 0x1
-#define LP_TICKER_SW_IRQ_MASK 0x2
-
 #define COMMON_RTC_EVENT_COMPARE(channel) \
     CONCAT_2(NRF_RTC_EVENT_COMPARE_, channel)
 #define COMMON_RTC_INT_COMPARE_MASK(channel) \
@@ -44,7 +42,7 @@
 
 extern bool              m_common_rtc_enabled;
 extern uint32_t volatile m_common_rtc_overflows;
-extern uint8_t volatile m_common_sw_irq_flag; 
+extern bool volatile     lp_ticker_interrupt_fire;
 
 void     common_rtc_init(void);
 uint32_t common_rtc_32bit_ticks_get(void);

targets/TARGET_NORDIC/TARGET_NRF5/lp_ticker.c

@@ -14,11 +14,20 @@
  * limitations under the License.
  */
 #include "lp_ticker_api.h"
+#include "common_rtc.h"
+#include "platform/mbed_critical.h"
 
 #if DEVICE_LPTICKER
 
-#include "common_rtc.h"
-#include "mbed_critical.h"
+/* LP ticker is driven by 32kHz clock and counter length is 24 bits. */
+const ticker_info_t* lp_ticker_get_info()
+{
+    static const ticker_info_t info = {
+        RTC_FREQ,
+        RTC_COUNTER_BITS
+    };
+    return &info;
+}
 
 void lp_ticker_init(void)
 {
@@ -33,7 +42,7 @@ void lp_ticker_free(void)
 
 uint32_t lp_ticker_read()
 {
-    return (uint32_t)common_rtc_64bit_us_get();
+    return nrf_rtc_counter_get(COMMON_RTC_INSTANCE);
 }
 
 void lp_ticker_set_interrupt(timestamp_t timestamp)
@@ -45,14 +54,17 @@ void lp_ticker_set_interrupt(timestamp_t timestamp)
 void lp_ticker_fire_interrupt(void)
 {
     core_util_critical_section_enter();
-    m_common_sw_irq_flag |= LP_TICKER_SW_IRQ_MASK;
+
+    lp_ticker_interrupt_fire = true;
+
     NVIC_SetPendingIRQ(RTC1_IRQn);
+
     core_util_critical_section_exit();
 }
 
 void lp_ticker_disable_interrupt(void)
 {
-    nrf_rtc_event_disable(COMMON_RTC_INSTANCE, LP_TICKER_INT_MASK);
+    nrf_rtc_int_disable(COMMON_RTC_INSTANCE, LP_TICKER_INT_MASK);
 }
 
 void lp_ticker_clear_interrupt(void)