[FL-667] Power saving: deep sleep in tickless state (#300)

* SYSTEM: tickless mode with deep sleep.
* Move FreeRTOS ticks to lptim2.
* API: move all sumbodules init routines to one place.
* Timebase: working lptim2 at tick source.
* API Timebase: lp-timer routines, timer access safe zones prediction and synchronization. 
* FreeRTOS: adjust configuration for tickless mode.
* NFC: support for tickless mode.
* API Timebase: improve tick error handling in IRQ. 
* Apploader: use insomnia mode to run applications.
* BLE: prevent sleep while core2 starting.
* HAL: nap while in insomnia mode.

Co-authored-by: coreglitch <mail@s3f.ru>

firmware/targets/f4/api-hal/api-hal-timebase-timer.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <stm32wbxx_ll_lptim.h>
+#include <stdbool.h>
+
+static inline void assert(bool value) {
+    if (!value) asm("bkpt 1");
+}
+
+// Timer used for system ticks
+#define API_HAL_TIMEBASE_TIMER_MAX  0xFFFF
+#define API_HAL_TIMEBASE_TIMER_REG_LOAD_DLY 0x1
+#define API_HAL_TIMEBASE_TIMER       LPTIM2
+#define API_HAL_TIMEBASE_TIMER_IRQ   LPTIM2_IRQn
+#define API_HAL_TIMEBASE_TIMER_CLOCK_INIT() \
+{ \
+    LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_LSE); \
+    LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_LPTIM2); \
+} \
+
+static inline void api_hal_timebase_timer_init() {
+    API_HAL_TIMEBASE_TIMER_CLOCK_INIT();
+
+    LL_LPTIM_Enable(API_HAL_TIMEBASE_TIMER);
+    while(!LL_LPTIM_IsEnabled(API_HAL_TIMEBASE_TIMER)) {}
+
+    LL_LPTIM_SetClockSource(API_HAL_TIMEBASE_TIMER, LL_LPTIM_CLK_SOURCE_INTERNAL);
+    LL_LPTIM_SetPrescaler(API_HAL_TIMEBASE_TIMER, LL_LPTIM_PRESCALER_DIV1);
+    LL_LPTIM_SetPolarity(API_HAL_TIMEBASE_TIMER, LL_LPTIM_OUTPUT_POLARITY_REGULAR);
+    LL_LPTIM_SetUpdateMode(API_HAL_TIMEBASE_TIMER, LL_LPTIM_UPDATE_MODE_IMMEDIATE);
+    LL_LPTIM_SetCounterMode(API_HAL_TIMEBASE_TIMER, LL_LPTIM_COUNTER_MODE_INTERNAL);
+    LL_LPTIM_TrigSw(API_HAL_TIMEBASE_TIMER);
+    LL_LPTIM_SetInput1Src(API_HAL_TIMEBASE_TIMER, LL_LPTIM_INPUT1_SRC_GPIO);
+    LL_LPTIM_SetInput2Src(API_HAL_TIMEBASE_TIMER, LL_LPTIM_INPUT2_SRC_GPIO);
+
+    NVIC_SetPriority(API_HAL_TIMEBASE_TIMER_IRQ, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
+    NVIC_EnableIRQ(API_HAL_TIMEBASE_TIMER_IRQ);
+}
+
+static inline uint32_t api_hal_timebase_timer_get_cnt() {
+    uint32_t counter = LL_LPTIM_GetCounter(API_HAL_TIMEBASE_TIMER);
+    uint32_t counter_shadow = LL_LPTIM_GetCounter(API_HAL_TIMEBASE_TIMER);
+    while(counter != counter_shadow) {
+        counter = counter_shadow;
+        counter_shadow = LL_LPTIM_GetCounter(API_HAL_TIMEBASE_TIMER);
+    }
+    return counter;
+}
+
+static inline bool api_hal_timebase_timer_arr_is_ok() {
+    return LL_LPTIM_IsActiveFlag_ARROK(API_HAL_TIMEBASE_TIMER);
+}
+
+static inline uint32_t api_hal_timebase_timer_get_arr() {
+    return LL_LPTIM_GetAutoReload(API_HAL_TIMEBASE_TIMER);;
+}
+
+static inline void api_hal_timebase_timer_set_arr(uint32_t value) {
+    value &= API_HAL_TIMEBASE_TIMER_MAX;
+    if (value != api_hal_timebase_timer_get_arr()) {
+        assert(api_hal_timebase_timer_arr_is_ok());
+        LL_LPTIM_ClearFlag_ARROK(API_HAL_TIMEBASE_TIMER);
+        LL_LPTIM_SetAutoReload(API_HAL_TIMEBASE_TIMER, value);
+    }
+}
+
+static inline bool api_hal_timebase_timer_cmp_is_ok() {
+    return LL_LPTIM_IsActiveFlag_CMPOK(API_HAL_TIMEBASE_TIMER);
+}
+
+static inline uint32_t api_hal_timebase_timer_get_cmp() {
+    return LL_LPTIM_GetCompare(API_HAL_TIMEBASE_TIMER);;
+}
+
+static inline void api_hal_timebase_timer_set_cmp(uint32_t value) {
+    value &= API_HAL_TIMEBASE_TIMER_MAX;
+    if (value != api_hal_timebase_timer_get_cmp()) {
+        assert(api_hal_timebase_timer_cmp_is_ok());
+        LL_LPTIM_ClearFlag_CMPOK(API_HAL_TIMEBASE_TIMER);
+        LL_LPTIM_SetCompare(API_HAL_TIMEBASE_TIMER, value);
+    }
+}
+
+static inline bool api_hal_timebase_timer_is_safe() {
+    uint16_t cmp = api_hal_timebase_timer_get_cmp();
+    uint16_t cnt = api_hal_timebase_timer_get_cnt();
+    uint16_t margin = (cmp > cnt) ? cmp - cnt : cnt - cmp;
+    if (margin < 8) {
+        return false;
+    }
+    if (!api_hal_timebase_timer_cmp_is_ok()) {
+        return false;
+    }
+    return true;
+}

firmware/targets/f4/api-hal/api-hal-timebase.c

@@ -0,0 +1,174 @@
+#include <api-hal-timebase.h>
+#include <api-hal-timebase-timer.h>
+
+#include <stm32wbxx_hal.h>
+#include <stm32wbxx_ll_gpio.h>
+#include <FreeRTOS.h>
+#include <cmsis_os.h>
+
+#define API_HAL_TIMEBASE_CLK_FREQUENCY 32768
+#define API_HAL_TIMEBASE_TICK_PER_SECOND 1024
+#define API_HAL_TIMEBASE_CLK_PER_TICK (API_HAL_TIMEBASE_CLK_FREQUENCY / API_HAL_TIMEBASE_TICK_PER_SECOND)
+#define API_HAL_TIMEBASE_TICK_PER_EPOCH (API_HAL_TIMEBASE_TIMER_MAX / API_HAL_TIMEBASE_CLK_PER_TICK)
+#define API_HAL_TIMEBASE_MAX_SLEEP (API_HAL_TIMEBASE_TICK_PER_EPOCH - 1)
+
+typedef struct {
+    // Sleep control
+    volatile uint16_t insomnia;
+    // Tick counters
+    volatile uint32_t in_sleep;
+    volatile uint32_t in_awake;
+    // Error counters
+    volatile uint32_t sleep_error;
+    volatile uint32_t awake_error;
+} ApiHalTimbase;
+
+ApiHalTimbase api_hal_timebase = {
+    .insomnia = 0,
+    .in_sleep = 0,
+    .in_awake = 0,
+    .sleep_error = 0,
+    .awake_error = 0,
+};
+
+void api_hal_timebase_init() {
+    api_hal_timebase_timer_init();
+    LL_DBGMCU_APB1_GRP2_FreezePeriph(LL_DBGMCU_APB1_GRP2_LPTIM2_STOP);
+
+    LL_LPTIM_EnableIT_CMPM(API_HAL_TIMEBASE_TIMER);
+    LL_LPTIM_EnableIT_ARRM(API_HAL_TIMEBASE_TIMER);
+
+    LL_LPTIM_SetAutoReload(API_HAL_TIMEBASE_TIMER, API_HAL_TIMEBASE_TIMER_MAX);
+    LL_LPTIM_SetCompare(API_HAL_TIMEBASE_TIMER, API_HAL_TIMEBASE_CLK_PER_TICK);
+
+    LL_LPTIM_StartCounter(API_HAL_TIMEBASE_TIMER, LL_LPTIM_OPERATING_MODE_CONTINUOUS);
+}
+
+uint16_t api_hal_timebase_insomnia_level() {
+    return api_hal_timebase.insomnia;
+}
+
+void api_hal_timebase_insomnia_enter() {
+    api_hal_timebase.insomnia++;
+}
+
+void api_hal_timebase_insomnia_exit() {
+    api_hal_timebase.insomnia--;
+}
+
+void LPTIM2_IRQHandler(void) {
+    // Autoreload
+    const bool arrm_flag = LL_LPTIM_IsActiveFlag_ARRM(API_HAL_TIMEBASE_TIMER);
+    if(arrm_flag) {
+        LL_LPTIM_ClearFLAG_ARRM(API_HAL_TIMEBASE_TIMER);
+    }
+    if(LL_LPTIM_IsActiveFlag_CMPM(API_HAL_TIMEBASE_TIMER)) {
+        LL_LPTIM_ClearFLAG_CMPM(API_HAL_TIMEBASE_TIMER);
+
+        // Store important value
+        uint16_t cnt = api_hal_timebase_timer_get_cnt();
+        uint16_t cmp = api_hal_timebase_timer_get_cmp();
+        uint16_t current_tick = cnt / API_HAL_TIMEBASE_CLK_PER_TICK;
+        uint16_t compare_tick = cmp / API_HAL_TIMEBASE_CLK_PER_TICK;
+
+        // Calculate error
+        // happens when HAL or other high priority IRQ takes our time
+        int32_t error = (int32_t)compare_tick - current_tick;
+        api_hal_timebase.awake_error += ((error>0) ? error : -error);
+
+        // Calculate and set next tick 
+        uint16_t next_tick = current_tick + 1;
+        api_hal_timebase_timer_set_cmp(next_tick * API_HAL_TIMEBASE_CLK_PER_TICK);
+
+        // Notify OS
+        api_hal_timebase.in_awake ++;
+        if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+            xPortSysTickHandler();
+        }
+    }
+}
+
+static inline uint32_t api_hal_timebase_nap(TickType_t expected_idle_ticks) {
+    __WFI();
+    return 0;
+}
+
+static inline uint32_t api_hal_timebase_sleep(TickType_t expected_idle_ticks) {
+    // Store important value before going to sleep
+    const uint16_t before_cnt = api_hal_timebase_timer_get_cnt();
+    const uint16_t before_tick = before_cnt / API_HAL_TIMEBASE_CLK_PER_TICK;
+
+    // Calculate and set next wakeup compare value
+    const uint16_t expected_cnt = (before_tick + expected_idle_ticks - 2) * API_HAL_TIMEBASE_CLK_PER_TICK;
+    api_hal_timebase_timer_set_cmp(expected_cnt);
+
+    // Go to stop2 mode
+    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
+
+    // Spin till we are in timer safe zone
+    while(!api_hal_timebase_timer_is_safe()) {}
+
+    // Store current counter value, calculate current tick
+    const uint16_t after_cnt = api_hal_timebase_timer_get_cnt();
+    const uint16_t after_tick = after_cnt / API_HAL_TIMEBASE_CLK_PER_TICK;
+
+    // Store and clear interrupt flags
+    // we don't want handler to be called after renabling IRQ
+    bool cmpm_flag = LL_LPTIM_IsActiveFlag_CMPM(API_HAL_TIMEBASE_TIMER);
+    if (cmpm_flag) LL_LPTIM_ClearFLAG_CMPM(API_HAL_TIMEBASE_TIMER);
+    bool arrm_flag = LL_LPTIM_IsActiveFlag_ARRM(API_HAL_TIMEBASE_TIMER);
+    if (arrm_flag) LL_LPTIM_ClearFLAG_ARRM(API_HAL_TIMEBASE_TIMER);
+
+    // Calculate and set next wakeup compare value
+    const uint16_t next_cmp = (after_tick + 1) * API_HAL_TIMEBASE_CLK_PER_TICK;
+    api_hal_timebase_timer_set_cmp(next_cmp);
+
+    // Calculate ticks count spent in sleep and perform sanity checks
+    int32_t completed_ticks = arrm_flag ? (int32_t)before_tick - after_tick : (int32_t)after_tick - before_tick;
+
+    return completed_ticks;
+}
+
+void vPortSuppressTicksAndSleep(TickType_t expected_idle_ticks) {
+    // Limit mount of ticks to maximum that timer can count
+    if (expected_idle_ticks > API_HAL_TIMEBASE_MAX_SLEEP) {
+        expected_idle_ticks = API_HAL_TIMEBASE_MAX_SLEEP;
+    }
+    
+    // Stop IRQ handling, no one should disturb us till we finish 
+    __disable_irq();
+
+    // Confirm OS that sleep is still possible
+    // And check if timer is in safe zone
+    // (8 clocks till any IRQ event or ongoing synchronization)
+    if (eTaskConfirmSleepModeStatus() == eAbortSleep
+        || !api_hal_timebase_timer_is_safe()) {
+        __enable_irq();
+        return;
+    }
+
+    uint32_t completed_ticks;
+    if (api_hal_timebase.insomnia) {
+        completed_ticks = api_hal_timebase_nap(expected_idle_ticks);
+    } else {
+        completed_ticks = api_hal_timebase_sleep(expected_idle_ticks);
+    }
+    assert(completed_ticks >= 0);
+
+    // Reenable IRQ
+    __enable_irq();
+
+    // Notify system about time spent in sleep
+    if (completed_ticks > 0) {
+        api_hal_timebase.in_sleep += completed_ticks;
+        if (completed_ticks > expected_idle_ticks) {
+            // We are late, count error
+            api_hal_timebase.sleep_error += (completed_ticks - expected_idle_ticks);
+            // Freertos is not happy when we overleep
+            // But we are not going to tell her
+            vTaskStepTick(expected_idle_ticks);
+        } else {
+            vTaskStepTick(completed_ticks);
+        }
+    }
+}

firmware/targets/f4/api-hal/api-hal-timebase.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+
+/* Initialize timebase
+ * Configure and start tick timer
+ */
+void api_hal_timebase_init();
+
+/* Get current insomnia level
+ * @return insomnia level: 0 - no insomnia, >0 - insomnia, bearer count.
+ */
+uint16_t api_hal_timebase_insomnia_level();
+
+/* Enter insomnia mode
+ * Prevents device from going to sleep
+ * @warning Internally increases insomnia level
+ * Must be paired with api_hal_timebase_insomnia_exit
+ */
+void api_hal_timebase_insomnia_enter();
+
+/* Exit insomnia mode
+ * Allow device to go to sleep
+ * @warning Internally decreases insomnia level.
+ * Must be paired with api_hal_timebase_insomnia_enter
+ */
+void api_hal_timebase_insomnia_exit();

firmware/targets/f4/api-hal/api-hal.c

@@ -0,0 +1,7 @@
+#include <api-hal.h>
+
+void api_hal_init() {
+    api_hal_timebase_init();
+    api_hal_vcp_init();
+    api_hal_spi_init();
+}