#include "esp_pm.h"
#include "esp_log.h"
#include "esp_crosscore_int.h"
+#include "esp_clk.h"
#include "soc/rtc.h"
#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
#include "freertos/xtensa_timer.h"
#include "xtensa/core-macros.h"
*/
#define CCOMPARE_UPDATE_TIMEOUT 1000000
+/* When changing CCOMPARE, don't allow changes if the difference is less
+ * than this. This is to prevent setting CCOMPARE below CCOUNT.
+ */
+#define CCOMPARE_MIN_CYCLES_IN_FUTURE 1000
+
+/* When light sleep is used, wake this number of microseconds earlier than
+ * the next tick.
+ */
+#define LIGHT_SLEEP_EARLY_WAKEUP_US 100
+
#ifdef CONFIG_PM_PROFILING
#define WITH_PROFILING
#endif
[RTC_CPU_FREQ_2M] = "2"
};
-/* Whether automatic light sleep is enabled. Currently always false */
+/* Whether automatic light sleep is enabled */
static bool s_light_sleep_en = false;
/* When configuration is changed, current frequency may not match the
#endif
const esp_pm_config_esp32_t* config = (const esp_pm_config_esp32_t*) vconfig;
+#ifndef CONFIG_FREERTOS_USE_TICKLESS_IDLE
if (config->light_sleep_enable) {
return ESP_ERR_NOT_SUPPORTED;
}
+#endif
if (config->min_cpu_freq == RTC_CPU_FREQ_2M) {
/* Minimal APB frequency to achieve 1MHz REF_TICK frequency is 5 MHz */
*/
static void IRAM_ATTR update_ccompare()
{
- const uint32_t ccompare_min_cycles_in_future = 1000;
uint32_t ccount = XTHAL_GET_CCOUNT();
uint32_t ccompare = XTHAL_GET_CCOMPARE(XT_TIMER_INDEX);
- if ((ccompare - ccompare_min_cycles_in_future) - ccount < UINT32_MAX / 2) {
+ if ((ccompare - CCOMPARE_MIN_CYCLES_IN_FUTURE) - ccount < UINT32_MAX / 2) {
uint32_t diff = ccompare - ccount;
uint32_t diff_scaled = (diff * s_ccount_mul + s_ccount_div - 1) / s_ccount_div;
if (diff_scaled < _xt_tick_divisor) {
ESP_PM_TRACE_EXIT(ISR_HOOK, core_id);
}
+#if CONFIG_FREERTOS_USE_TICKLESS_IDLE
+
+bool IRAM_ATTR vApplicationSleep( TickType_t xExpectedIdleTime )
+{
+ bool result = false;
+ portENTER_CRITICAL(&s_switch_lock);
+ if (s_mode == PM_MODE_LIGHT_SLEEP && !s_is_switching) {
+ /* Calculate how much we can sleep */
+ int64_t next_esp_timer_alarm = esp_timer_get_next_alarm();
+ int64_t now = esp_timer_get_time();
+ int64_t time_until_next_alarm = next_esp_timer_alarm - now;
+ int64_t wakeup_delay_us = portTICK_PERIOD_MS * 1000LL * xExpectedIdleTime;
+ int64_t sleep_time_us = MIN(wakeup_delay_us, time_until_next_alarm);
+ if (sleep_time_us >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP * portTICK_PERIOD_MS * 1000LL) {
+ esp_sleep_enable_timer_wakeup(sleep_time_us - LIGHT_SLEEP_EARLY_WAKEUP_US);
+#ifdef CONFIG_PM_TRACE
+ /* to force tracing GPIOs to keep state */
+ esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
+#endif
+ /* Enter sleep */
+ int core_id = xPortGetCoreID();
+ ESP_PM_TRACE_ENTER(SLEEP, core_id);
+ int64_t sleep_start = esp_timer_get_time();
+ esp_light_sleep_start();
+ int64_t slept_us = esp_timer_get_time() - sleep_start;
+ ESP_PM_TRACE_EXIT(SLEEP, core_id);
+
+ uint32_t slept_ticks = slept_us / (portTICK_PERIOD_MS * 1000LL);
+ if (slept_ticks > 0) {
+ /* Adjust RTOS tick count based on the amount of time spent in sleep */
+ vTaskStepTick(slept_ticks);
+
+ /* Trigger tick interrupt, since sleep time was longer
+ * than portTICK_PERIOD_MS. Note that setting INTSET does not
+ * work for timer interrupt, and changing CCOMPARE would clear
+ * the interrupt flag.
+ */
+ XTHAL_SET_CCOUNT(XTHAL_GET_CCOMPARE(XT_TIMER_INDEX) - 16);
+ while (!(XTHAL_GET_INTERRUPT() & BIT(XT_TIMER_INTNUM))) {
+ ;
+ }
+ }
+ result = true;
+ }
+ }
+ portEXIT_CRITICAL(&s_switch_lock);
+ return result;
+}
+#endif //CONFIG_FREERTOS_USE_TICKLESS_IDLE
+
#ifdef WITH_PROFILING
void esp_pm_impl_dump_stats(FILE* out)
{
#include "esp_clk.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
+#include "freertos/semphr.h"
#include "esp_log.h"
+#include "driver/timer.h"
+#include "driver/rtc_io.h"
+#include "esp32/ulp.h"
+#include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
+#include "soc/rtc_gpio_channel.h"
TEST_CASE("Can dump power management lock stats", "[pm]")
{
switch_freq(orig_freq_mhz);
}
+#if CONFIG_FREERTOS_USE_TICKLESS_IDLE
+
+static void light_sleep_enable()
+{
+ const esp_pm_config_esp32_t pm_config = {
+ .max_cpu_freq = rtc_clk_cpu_freq_get(),
+ .min_cpu_freq = RTC_CPU_FREQ_XTAL,
+ .light_sleep_enable = true
+ };
+ ESP_ERROR_CHECK( esp_pm_configure(&pm_config) );
+}
+
+static void light_sleep_disable()
+{
+ const esp_pm_config_esp32_t pm_config = {
+ .max_cpu_freq = rtc_clk_cpu_freq_get(),
+ .min_cpu_freq = rtc_clk_cpu_freq_get(),
+ };
+ ESP_ERROR_CHECK( esp_pm_configure(&pm_config) );
+}
+
+TEST_CASE("Automatic light occurs when tasks are suspended", "[pm]")
+{
+ /* To figure out if light sleep takes place, use Timer Group timer.
+ * It will stop working while in light sleep.
+ */
+ timer_config_t config = {
+ .counter_dir = TIMER_COUNT_UP,
+ .divider = 80 /* 1 us per tick */
+ };
+ timer_init(TIMER_GROUP_0, TIMER_0, &config);
+ timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0);
+ timer_start(TIMER_GROUP_0, TIMER_0);
+
+ light_sleep_enable();
+
+ for (int ticks_to_delay = CONFIG_FREERTOS_IDLE_TIME_BEFORE_SLEEP;
+ ticks_to_delay < CONFIG_FREERTOS_IDLE_TIME_BEFORE_SLEEP * 10;
+ ++ticks_to_delay) {
+
+ /* Wait until next tick */
+ vTaskDelay(1);
+
+ /* The following delay should cause light sleep to start */
+ uint64_t count_start;
+ timer_get_counter_value(TIMER_GROUP_0, TIMER_0, &count_start);
+ vTaskDelay(ticks_to_delay);
+ uint64_t count_end;
+ timer_get_counter_value(TIMER_GROUP_0, TIMER_0, &count_end);
+
+
+ int timer_diff_us = (int) (count_end - count_start);
+ const int us_per_tick = 1 * portTICK_PERIOD_MS * 1000;
+
+ printf("%d %d\n", ticks_to_delay * us_per_tick, timer_diff_us);
+ TEST_ASSERT(timer_diff_us < ticks_to_delay * us_per_tick);
+ }
+
+ light_sleep_disable();
+}
+
+
+TEST_CASE("Can wake up from automatic light sleep by GPIO", "[pm]")
+{
+ assert(CONFIG_ULP_COPROC_RESERVE_MEM >= 16 && "this test needs ULP_COPROC_RESERVE_MEM option set in menuconfig");
+
+ /* Set up GPIO used to wake up RTC */
+ const int ext1_wakeup_gpio = 25;
+ const int ext_rtc_io = RTCIO_GPIO25_CHANNEL;
+ TEST_ESP_OK(rtc_gpio_init(ext1_wakeup_gpio));
+ rtc_gpio_set_direction(ext1_wakeup_gpio, RTC_GPIO_MODE_INPUT_OUTPUT);
+ rtc_gpio_set_level(ext1_wakeup_gpio, 0);
+
+ /* Enable wakeup */
+ TEST_ESP_OK(esp_sleep_enable_ext1_wakeup(1ULL << ext1_wakeup_gpio, ESP_EXT1_WAKEUP_ANY_HIGH));
+
+ /* To simplify test environment, we'll use a ULP program to set GPIO high */
+ ulp_insn_t ulp_code[] = {
+ I_DELAY(65535), /* about 8ms, given 8MHz ULP clock */
+ I_WR_REG_BIT(RTC_CNTL_HOLD_FORCE_REG, RTC_CNTL_PDAC1_HOLD_FORCE_S, 0),
+ I_WR_REG_BIT(RTC_GPIO_OUT_REG, ext_rtc_io + RTC_GPIO_OUT_DATA_S, 1),
+ I_DELAY(1000),
+ I_WR_REG_BIT(RTC_GPIO_OUT_REG, ext_rtc_io + RTC_GPIO_OUT_DATA_S, 0),
+ I_WR_REG_BIT(RTC_CNTL_HOLD_FORCE_REG, RTC_CNTL_PDAC1_HOLD_FORCE_S, 1),
+ I_END(),
+ I_HALT()
+ };
+ TEST_ESP_OK(ulp_set_wakeup_period(0, 1000 /* us */));
+ size_t size = sizeof(ulp_code)/sizeof(ulp_insn_t);
+ TEST_ESP_OK(ulp_process_macros_and_load(0, ulp_code, &size));
+
+ light_sleep_enable();
+
+ for (int i = 0; i < 10; ++i) {
+ /* Set GPIO low */
+ REG_CLR_BIT(rtc_gpio_desc[ext1_wakeup_gpio].reg, rtc_gpio_desc[ext1_wakeup_gpio].hold_force);
+ rtc_gpio_set_level(ext1_wakeup_gpio, 0);
+ REG_SET_BIT(rtc_gpio_desc[ext1_wakeup_gpio].reg, rtc_gpio_desc[ext1_wakeup_gpio].hold_force);
+
+ /* Wait for the next tick */
+ vTaskDelay(1);
+
+ /* Start ULP program */
+ ulp_run(0);
+
+ const int delay_ms = 200;
+ const int delay_ticks = delay_ms / portTICK_PERIOD_MS;
+
+ int64_t start_rtc = esp_clk_rtc_time();
+ int64_t start_hs = esp_timer_get_time();
+ uint32_t start_tick = xTaskGetTickCount();
+ /* Will enter sleep here */
+ vTaskDelay(delay_ticks);
+ int64_t end_rtc = esp_clk_rtc_time();
+ int64_t end_hs = esp_timer_get_time();
+ uint32_t end_tick = xTaskGetTickCount();
+
+ printf("%lld %lld %u\n", end_rtc - start_rtc, end_hs - start_hs, end_tick - start_tick);
+
+ TEST_ASSERT_INT32_WITHIN(3, delay_ticks, end_tick - start_tick);
+ TEST_ASSERT_INT32_WITHIN(2 * portTICK_PERIOD_MS * 1000, delay_ms * 1000, end_hs - start_hs);
+ TEST_ASSERT_INT32_WITHIN(2 * portTICK_PERIOD_MS * 1000, delay_ms * 1000, end_rtc - start_rtc);
+ }
+ REG_CLR_BIT(rtc_gpio_desc[ext1_wakeup_gpio].reg, rtc_gpio_desc[ext1_wakeup_gpio].hold_force);
+ rtc_gpio_deinit(ext1_wakeup_gpio);
+
+ light_sleep_disable();
+}
+
+
+typedef struct {
+ int delay_us;
+ int result;
+ SemaphoreHandle_t done;
+} delay_test_arg_t;
+
+static void test_delay_task(void* p)
+{
+ delay_test_arg_t* arg = (delay_test_arg_t*) p;
+ vTaskDelay(1);
+
+ uint64_t start = esp_clk_rtc_time();
+ vTaskDelay(arg->delay_us / portTICK_PERIOD_MS / 1000);
+ uint64_t stop = esp_clk_rtc_time();
+
+ arg->result = (int) (stop - start);
+ xSemaphoreGive(arg->done);
+ vTaskDelete(NULL);
+}
+
+TEST_CASE("vTaskDelay duration is correct with light sleep enabled", "[pm]")
+{
+ light_sleep_enable();
+
+ delay_test_arg_t args = {
+ .done = xSemaphoreCreateBinary()
+ };
+
+ const int delays[] = { 10, 20, 50, 100, 150, 200, 250 };
+ const int delays_count = sizeof(delays) / sizeof(delays[0]);
+
+ for (int i = 0; i < delays_count; ++i) {
+ int delay_ms = delays[i];
+ args.delay_us = delay_ms * 1000;
+
+ xTaskCreatePinnedToCore(test_delay_task, "", 2048, (void*) &args, 3, NULL, 0);
+ TEST_ASSERT( xSemaphoreTake(args.done, delay_ms * 10 / portTICK_PERIOD_MS) );
+ printf("CPU0: %d %d\n", args.delay_us, args.result);
+ TEST_ASSERT_INT32_WITHIN(1000 * portTICK_PERIOD_MS * 2, args.delay_us, args.result);
+
+#if portNUM_PROCESSORS == 2
+ xTaskCreatePinnedToCore(test_delay_task, "", 2048, (void*) &args, 3, NULL, 1);
+ TEST_ASSERT( xSemaphoreTake(args.done, delay_ms * 10 / portTICK_PERIOD_MS) );
+ printf("CPU1: %d %d\n", args.delay_us, args.result);
+ TEST_ASSERT_INT32_WITHIN(1000 * portTICK_PERIOD_MS * 2, args.delay_us, args.result);
+#endif
+ }
+ vSemaphoreDelete(args.done);
+
+ light_sleep_disable();
+}
+
+/* This test is similar to the one in test_esp_timer.c, but since we can't use
+ * ref_clock, this test uses RTC clock for timing. Also enables automatic
+ * light sleep.
+ */
+TEST_CASE("esp_timer produces correct delays with light sleep", "[pm]")
+{
+ // no, we can't make this a const size_t (ยง6.7.5.2)
+#define NUM_INTERVALS 16
+
+ typedef struct {
+ esp_timer_handle_t timer;
+ size_t cur_interval;
+ int intervals[NUM_INTERVALS];
+ int64_t t_start;
+ SemaphoreHandle_t done;
+ } test_args_t;
+
+ void timer_func(void* arg)
+ {
+ test_args_t* p_args = (test_args_t*) arg;
+ int64_t t_end = esp_clk_rtc_time();
+ int32_t ms_diff = (t_end - p_args->t_start) / 1000;
+ printf("timer #%d %dms\n", p_args->cur_interval, ms_diff);
+ p_args->intervals[p_args->cur_interval++] = ms_diff;
+ // Deliberately make timer handler run longer.
+ // We check that this doesn't affect the result.
+ ets_delay_us(10*1000);
+ if (p_args->cur_interval == NUM_INTERVALS) {
+ printf("done\n");
+ TEST_ESP_OK(esp_timer_stop(p_args->timer));
+ xSemaphoreGive(p_args->done);
+ }
+ }
+
+ light_sleep_enable();
+
+ const int delay_ms = 100;
+ test_args_t args = {0};
+ esp_timer_handle_t timer1;
+ esp_timer_create_args_t create_args = {
+ .callback = &timer_func,
+ .arg = &args,
+ .name = "timer1",
+ };
+ TEST_ESP_OK(esp_timer_create(&create_args, &timer1));
+
+ args.timer = timer1;
+ args.t_start = esp_clk_rtc_time();
+ args.done = xSemaphoreCreateBinary();
+ TEST_ESP_OK(esp_timer_start_periodic(timer1, delay_ms * 1000));
+
+ TEST_ASSERT(xSemaphoreTake(args.done, delay_ms * NUM_INTERVALS * 2));
+
+ TEST_ASSERT_EQUAL_UINT32(NUM_INTERVALS, args.cur_interval);
+ for (size_t i = 0; i < NUM_INTERVALS; ++i) {
+ TEST_ASSERT_INT32_WITHIN(portTICK_PERIOD_MS, (i + 1) * delay_ms, args.intervals[i]);
+ }
+
+ TEST_ESP_OK( esp_timer_dump(stdout) );
+
+ TEST_ESP_OK( esp_timer_delete(timer1) );
+ vSemaphoreDelete(args.done);
+
+ light_sleep_disable();
+
+#undef NUM_INTERVALS
+}
+
+#endif // CONFIG_FREERTOS_USE_TICKLESS_IDLE
+
#endif // CONFIG_PM_ENABLE
#if ( configUSE_TICKLESS_IDLE != 0 )
+ static BaseType_t xHaveReadyTasks()
+ {
+ for (int i = tskIDLE_PRIORITY + 1; i < configMAX_PRIORITIES; ++i)
+ {
+ if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ i ] ) ) > 0 )
+ {
+ return pdTRUE;
+ }
+ else
+ {
+ mtCOVERAGE_TEST_MARKER();
+ }
+ }
+ return pdFALSE;
+ }
+
+
static TickType_t prvGetExpectedIdleTime( void )
{
TickType_t xReturn;
{
xReturn = 0;
}
- else if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ tskIDLE_PRIORITY ] ) ) > 1 )
+#if portNUM_PROCESSORS > 1
+ /* This function is called from Idle task; in single core case this
+ * means that no higher priority tasks are ready to run, and we can
+ * enter sleep. In SMP case, there might be ready tasks waiting for
+ * the other CPU, so need to check all ready lists.
+ */
+ else if( xHaveReadyTasks() )
+ {
+ xReturn = 0;
+ }
+#endif // portNUM_PROCESSORS > 1
+ else if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ tskIDLE_PRIORITY ] ) ) > portNUM_PROCESSORS )
{
/* There are other idle priority tasks in the ready state. If
time slicing is used then the very next tick interrupt must be
#endif /* configUSE_IDLE_HOOK */
{
/* Call the esp-idf hook system */
- extern void esp_vApplicationIdleHook( void );
esp_vApplicationIdleHook();
}
#if ( configUSE_TICKLESS_IDLE != 0 )
{
TickType_t xExpectedIdleTime;
+ BaseType_t xEnteredSleep = pdFALSE;
/* It is not desirable to suspend then resume the scheduler on
each iteration of the idle task. Therefore, a preliminary
if( xExpectedIdleTime >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP )
{
-// vTaskSuspendAll();
taskENTER_CRITICAL(&xTaskQueueMutex);
{
/* Now the scheduler is suspended, the expected idle
if( xExpectedIdleTime >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP )
{
traceLOW_POWER_IDLE_BEGIN();
- portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime );
+ xEnteredSleep = portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime );
traceLOW_POWER_IDLE_END();
}
else
}
}
taskEXIT_CRITICAL(&xTaskQueueMutex);
-// ( void ) xTaskResumeAll();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
+ /* It might be possible to enter tickless idle again, so skip
+ * the fallback sleep hook if tickless idle was successful
+ */
+ if ( !xEnteredSleep )
+ {
+ esp_vApplicationWaitiHook();
+ }
}
+ #else
+ esp_vApplicationWaitiHook();
#endif /* configUSE_TICKLESS_IDLE */
}
}
projects / esp-idf / commitdiff