change(gptimer): optimize the registers to be backup

Author: suda-morris

components/esp_driver_gptimer/include/driver/gptimer.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -28,9 +28,9 @@ typedef struct {
                                               if set to 0, the driver will try to allocate an interrupt with a relative low priority (1,2,3) */
     struct {
         uint32_t intr_shared: 1;         /*!< Set true, the timer interrupt number can be shared with other peripherals */
-        uint32_t backup_before_sleep: 1; /*!< If set, the driver will backup/restore the GPTimer registers before/after entering/exist sleep mode.
-                                              By this approach, the system can power off GPTimer's power domain.
-                                              This can save power, but at the expense of more RAM being consumed */
+        uint32_t allow_pd: 1;            /*!< If set, driver allows the power domain to be powered off when system enters sleep mode.
+                                              This can save power, but at the expense of more RAM being consumed to save register context. */
+        uint32_t backup_before_sleep: 1; /*!< @deprecated, same meaning as allow_pd */
     } flags;                             /*!< GPTimer config flags*/
 } gptimer_config_t;
 

components/esp_driver_gptimer/src/gptimer.c

@@ -94,8 +94,9 @@ esp_err_t gptimer_new_timer(const gptimer_config_t *config, gptimer_handle_t *re
                             TAG, "invalid interrupt priority:%d", config->intr_priority);
     }
 
+    bool allow_pd = (config->flags.allow_pd == 1) || (config->flags.backup_before_sleep == 1);
 #if !SOC_TIMER_SUPPORT_SLEEP_RETENTION
-    ESP_RETURN_ON_FALSE(config->flags.backup_before_sleep == 0, ESP_ERR_NOT_SUPPORTED, TAG, "register back up is not supported");
+    ESP_RETURN_ON_FALSE(allow_pd == false, ESP_ERR_NOT_SUPPORTED, TAG, "not able to power down in light sleep");
 #endif // SOC_TIMER_SUPPORT_SLEEP_RETENTION
 
     timer = heap_caps_calloc(1, sizeof(gptimer_t), GPTIMER_MEM_ALLOC_CAPS);
@@ -106,11 +107,11 @@ esp_err_t gptimer_new_timer(const gptimer_config_t *config, gptimer_handle_t *re
     int group_id = group->group_id;
     int timer_id = timer->timer_id;
 
+    if (allow_pd) {
 #if GPTIMER_USE_RETENTION_LINK
-    if (config->flags.backup_before_sleep != 0) {
         gptimer_create_retention_module(group);
-    }
 #endif // GPTIMER_USE_RETENTION_LINK
+    }
 
     // initialize HAL layer
     timer_hal_init(&timer->hal, group_id, timer_id);

components/esp_driver_gptimer/src/gptimer_common.c

@@ -87,7 +87,7 @@ gptimer_group_t *gptimer_acquire_group_handle(int group_id)
             }
         }
 #if GPTIMER_USE_RETENTION_LINK
-        sleep_retention_module_t module = TIMER_LL_SLEEP_RETENTION_MODULE_ID(group_id);
+        sleep_retention_module_t module = tg_timer_reg_retention_info[group_id].module;
         sleep_retention_module_init_param_t init_param = {
             .cbs = {
                 .create = {

components/esp_driver_gptimer/test_apps/gptimer/main/CMakeLists.txt

@@ -1,6 +1,5 @@
 set(srcs "test_app_main.c"
-         "test_gptimer.c"
-         "test_gptimer_sleep.c")
+         "test_gptimer.c")
 
 if(CONFIG_GPTIMER_ISR_IRAM_SAFE)
     list(APPEND srcs "test_gptimer_iram.c")
@@ -10,6 +9,10 @@ if(CONFIG_SOC_TIMER_SUPPORT_ETM)
     list(APPEND srcs "test_gptimer_etm.c")
 endif()
 
+if(CONFIG_SOC_LIGHT_SLEEP_SUPPORTED AND CONFIG_PM_ENABLE)
+    list(APPEND srcs "test_gptimer_sleep.c")
+endif()
+
 # In order for the cases defined by `TEST_CASE` to be linked into the final elf,
 # the component can be registered as WHOLE_ARCHIVE
 idf_component_register(SRCS ${srcs}

components/esp_driver_gptimer/test_apps/gptimer/main/test_gptimer_sleep.c

@@ -15,20 +15,8 @@
 #include "esp_private/sleep_cpu.h"
 #include "esp_private/esp_sleep_internal.h"
 #include "esp_private/esp_pmu.h"
-#if !SOC_LIGHT_SLEEP_SUPPORTED
-#include "esp_private/gptimer.h"
-#include "esp_private/sleep_retention.h"
-#include "hal/timer_ll.h"
-#include "hal/wdt_hal.h"
-#endif
-
-#if CONFIG_GPTIMER_ISR_IRAM_SAFE
-#define TEST_ALARM_CALLBACK_ATTR IRAM_ATTR
-#else
-#define TEST_ALARM_CALLBACK_ATTR
-#endif // CONFIG_GPTIMER_ISR_IRAM_SAFE
 
-static TEST_ALARM_CALLBACK_ATTR bool test_gptimer_alarm_stop_callback(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data)
+static bool test_gptimer_alarm_stop_callback(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data)
 {
     TaskHandle_t task_handle = (TaskHandle_t)user_data;
     BaseType_t high_task_wakeup;
@@ -37,75 +25,19 @@ static TEST_ALARM_CALLBACK_ATTR bool test_gptimer_alarm_stop_callback(gptimer_ha
     return high_task_wakeup == pdTRUE;
 }
 
-/**
- * @brief This function abstracts the behavior of performing the Backup-Reset-Restore process on the specified
- *        Timer group and is used as a helper function to test the retention function of the driver.
- *        If light-sleep feature is supported, this function will enter and exit a real light sleep or PD_TOP
- *        light sleep. Otherwise, it will trigger retention by software and reset the timer module to simulate
- *        a light-sleep in/out process to verify the driver's support for GPTimer sleep retention.
- *
- * @param timer Timer handle to be reset, created by `gptimer_new_timer()`
- * @param back_up_before_sleep Whether to back up GPTimer registers before sleep
- */
-static void test_gptimer_survival_after_sleep_helper(gptimer_handle_t timer, bool back_up_before_sleep)
-{
-#if SOC_LIGHT_SLEEP_SUPPORTED
-    esp_sleep_context_t sleep_ctx;
-    esp_sleep_set_sleep_context(&sleep_ctx);
-    printf("go to light sleep for 2 seconds\r\n");
-#if ESP_SLEEP_POWER_DOWN_CPU
-    TEST_ESP_OK(sleep_cpu_configure(true));
-#endif
-    TEST_ESP_OK(esp_sleep_enable_timer_wakeup(2 * 1000 * 1000));
-    TEST_ESP_OK(esp_light_sleep_start());
-
-    printf("Waked up! Let's see if GPTimer driver can still work...\r\n");
-#if ESP_SLEEP_POWER_DOWN_CPU
-    TEST_ESP_OK(sleep_cpu_configure(false));
-#endif
-
-    printf("check if the sleep happened as expected\r\n");
-    TEST_ASSERT_EQUAL(0, sleep_ctx.sleep_request_result);
-#if SOC_TIMER_SUPPORT_SLEEP_RETENTION && CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
-    if (back_up_before_sleep) {
-        // Verify that when GPTimer retention is configured and sleep is requested,
-        // the TOP power domain should be allowed to power down.
-        TEST_ASSERT_EQUAL(PMU_SLEEP_PD_TOP, sleep_ctx.sleep_flags & PMU_SLEEP_PD_TOP);
-    } else {
-        // Verify that when GPTimer retention is not configured and sleep is requested, the TOP power
-        // domain should not be allowed to power down to ensure the peripheral context is not lost.
-        TEST_ASSERT_EQUAL(0, sleep_ctx.sleep_flags & PMU_SLEEP_PD_TOP);
-    }
-#endif
-    esp_sleep_set_sleep_context(NULL);
-#elif SOC_TIMER_SUPPORT_SLEEP_RETENTION && CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
-    if (back_up_before_sleep) {
-        printf("Back up the timer group context in use and then reset it\r\n");
-        sleep_retention_do_extra_retention(true);
-
-        int group_id;
-        gptimer_get_group_id(timer, &group_id);
-        _timer_ll_reset_register(group_id);
-
-        printf("Reset done! Let's restore its context and see if its driver can still work...\r\n");
-        sleep_retention_do_extra_retention(false);
-    }
-#endif
-}
-
 /**
  * @brief Test the GPTimer driver can still work after light sleep
  *
- * @param back_up_before_sleep Whether to back up GPTimer registers before sleep
+ * @param allow_pd Whether to allow power down the peripheral in light sleep
  */
-static void test_gptimer_sleep_retention(bool back_up_before_sleep)
+static void test_gptimer_sleep_retention(bool allow_pd)
 {
     TaskHandle_t task_handle =  xTaskGetCurrentTaskHandle();
     gptimer_config_t timer_config = {
         .resolution_hz = 10000, // 10KHz, 1 tick = 0.1ms
         .clk_src = GPTIMER_CLK_SRC_DEFAULT,
         .direction = GPTIMER_COUNT_UP,
-        .flags.backup_before_sleep = back_up_before_sleep,
+        .flags.allow_pd = allow_pd,
     };
     gptimer_handle_t timer = NULL;
     TEST_ESP_OK(gptimer_new_timer(&timer_config, &timer));
@@ -135,7 +67,27 @@ static void test_gptimer_sleep_retention(bool back_up_before_sleep)
     // Note: don't enable the gptimer before going to sleep, ensure no power management lock is acquired by it
     TEST_ESP_OK(gptimer_disable(timer));
 
-    test_gptimer_survival_after_sleep_helper(timer, back_up_before_sleep);
+    esp_sleep_context_t sleep_ctx;
+    esp_sleep_set_sleep_context(&sleep_ctx);
+    printf("go to light sleep for 2 seconds\r\n");
+#if ESP_SLEEP_POWER_DOWN_CPU
+    TEST_ESP_OK(sleep_cpu_configure(true));
+#endif
+    TEST_ESP_OK(esp_sleep_enable_timer_wakeup(2 * 1000 * 1000));
+    TEST_ESP_OK(esp_light_sleep_start());
+
+    printf("Waked up! Let's see if GPTimer driver can still work...\r\n");
+#if ESP_SLEEP_POWER_DOWN_CPU
+    TEST_ESP_OK(sleep_cpu_configure(false));
+#endif
+
+    printf("check if the sleep happened as expected\r\n");
+    TEST_ASSERT_EQUAL(0, sleep_ctx.sleep_request_result);
+#if SOC_RMT_SUPPORT_SLEEP_RETENTION
+    // check if the power domain also is powered down
+    TEST_ASSERT_EQUAL(allow_pd ? PMU_SLEEP_PD_TOP : 0, (sleep_ctx.sleep_flags) & PMU_SLEEP_PD_TOP);
+#endif
+    esp_sleep_set_sleep_context(NULL);
 
     uint64_t count_value_after_sleep = 0;
     TEST_ESP_OK(gptimer_get_raw_count(timer, &count_value_after_sleep));

components/esp_driver_rmt/test_apps/rmt/main/test_rmt_sleep.c

@@ -113,7 +113,7 @@ static void test_rmt_tx_rx_sleep_retention(bool allow_pd)
 #endif
     esp_sleep_set_sleep_context(NULL);
 
-    // enable both channels, pm lock will be acquired, so no light sleep will event happen during the transaction
+    // enable both channels, pm lock will be acquired, so no light sleep will even happen during the transaction
     TEST_ESP_OK(rmt_enable(tx_channel));
     TEST_ESP_OK(rmt_enable(rx_channel));
 

components/hal/esp32c5/include/hal/timer_ll.h

@@ -24,7 +24,6 @@ extern "C" {
 // Get timer group register base address with giving group number
 #define TIMER_LL_GET_HW(group_id) ((group_id == 0) ? (&TIMERG0) : (&TIMERG1))
 #define TIMER_LL_EVENT_ALARM(timer_id) (1 << (timer_id))
-#define TIMER_LL_SLEEP_RETENTION_MODULE_ID(group_id) ((group_id == 0) ? SLEEP_RETENTION_MODULE_TG0_TIMER: SLEEP_RETENTION_MODULE_TG1_TIMER)
 
 #define TIMER_LL_ETM_TASK_TABLE(group, timer, task)                                     \
     (uint32_t [2][1][GPTIMER_ETM_TASK_MAX]){{{                                          \

components/hal/esp32c6/include/hal/timer_ll.h

@@ -24,7 +24,6 @@ extern "C" {
 // Get timer group register base address with giving group number
 #define TIMER_LL_GET_HW(group_id) ((group_id == 0) ? (&TIMERG0) : (&TIMERG1))
 #define TIMER_LL_EVENT_ALARM(timer_id) (1 << (timer_id))
-#define TIMER_LL_SLEEP_RETENTION_MODULE_ID(group_id) ((group_id == 0) ? SLEEP_RETENTION_MODULE_TG0_TIMER: SLEEP_RETENTION_MODULE_TG1_TIMER)
 
 #define TIMER_LL_ETM_TASK_TABLE(group, timer, task)                                        \
     (uint32_t [2][1][GPTIMER_ETM_TASK_MAX]){{{                                             \

components/hal/esp32c61/include/hal/timer_ll.h

@@ -24,7 +24,6 @@ extern "C" {
 // Get timer group register base address with giving group number
 #define TIMER_LL_GET_HW(group_id) ((group_id == 0) ? (&TIMERG0) : (&TIMERG1))
 #define TIMER_LL_EVENT_ALARM(timer_id) (1 << (timer_id))
-#define TIMER_LL_SLEEP_RETENTION_MODULE_ID(group_id) ((group_id == 0) ? SLEEP_RETENTION_MODULE_TG0_TIMER: SLEEP_RETENTION_MODULE_TG1_TIMER)
 
 #define TIMER_LL_ETM_TASK_TABLE(group, timer, task)                                        \
     (uint32_t [2][1][GPTIMER_ETM_TASK_MAX]){{{                                             \

components/hal/esp32h2/include/hal/timer_ll.h

@@ -24,7 +24,6 @@ extern "C" {
 // Get timer group register base address with giving group number
 #define TIMER_LL_GET_HW(group_id) ((group_id == 0) ? (&TIMERG0) : (&TIMERG1))
 #define TIMER_LL_EVENT_ALARM(timer_id) (1 << (timer_id))
-#define TIMER_LL_SLEEP_RETENTION_MODULE_ID(group_id) ((group_id == 0) ? SLEEP_RETENTION_MODULE_TG0_TIMER: SLEEP_RETENTION_MODULE_TG1_TIMER)
 
 #define TIMER_LL_ETM_TASK_TABLE(group, timer, task)                                        \
     (uint32_t [2][1][GPTIMER_ETM_TASK_MAX]){{{                                             \