alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

timer_group: use the LL

Browse Source
This commit is contained in:
Michael (XIAO Xufeng) 2019-07-24 23:18:19 +08:00
parent feea477023
commit 264ffbeb14
22 changed files with 217 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
components/app_trace/gcov/gcov_rtio.c
View File

@ -21,6 +21,7 @@
#include "soc/timer_periph.h" #include "soc/timer_periph.h"
#include "esp_app_trace.h" #include "esp_app_trace.h"
#include "esp_private/dbg_stubs.h" #include "esp_private/dbg_stubs.h"
#include "hal/timer_ll.h"
#if CONFIG_ESP32_GCOV_ENABLE #if CONFIG_ESP32_GCOV_ENABLE
@ -124,13 +125,13 @@ void esp_gcov_dump(void)
#endif #endif
while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_TRAX)) { while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_TRAX)) {
// to avoid complains that task watchdog got triggered for other tasks // to avoid complains that task watchdog got triggered for other tasks
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_feed=1; timer_ll_wdt_feed(&TIMERG0);
TIMERG0.wdt_wprotect=0; timer_ll_wdt_set_protect(&TIMERG0, true);
// to avoid reboot on INT_WDT // to avoid reboot on INT_WDT
TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_feed=1; timer_ll_wdt_feed(&TIMERG1);
TIMERG1.wdt_wprotect=0; timer_ll_wdt_set_protect(&TIMERG1, true);
} }
esp_dbg_stub_gcov_dump_do(); esp_dbg_stub_gcov_dump_do();

72
components/app_trace/test/test_trace.c
View File

@ -145,56 +145,16 @@ static void esp_apptrace_test_timer_isr(void *arg)
} }
tim_arg->data.wr_cnt++; tim_arg->data.wr_cnt++;
if (tim_arg->group == 0) { timer_group_intr_clr_in_isr(tim_arg->group, tim_arg->id);
if (tim_arg->id == 0) { timer_group_enable_alarm_in_isr(tim_arg->group, tim_arg->id);
TIMERG0.int_clr_timers.t0 = 1;
TIMERG0.hw_timer[0].update = 1;
TIMERG0.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
TIMERG0.hw_timer[1].update = 1;
TIMERG0.hw_timer[1].config.alarm_en = 1;
}
}
if (tim_arg->group == 1) {
if (tim_arg->id == 0) {
TIMERG1.int_clr_timers.t0 = 1;
TIMERG1.hw_timer[0].update = 1;
TIMERG1.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG1.int_clr_timers.t1 = 1;
TIMERG1.hw_timer[1].update = 1;
TIMERG1.hw_timer[1].config.alarm_en = 1;
}
}
} }
static void esp_apptrace_test_timer_isr_crash(void *arg) static void esp_apptrace_test_timer_isr_crash(void *arg)
{ {
esp_apptrace_test_timer_arg_t *tim_arg = (esp_apptrace_test_timer_arg_t *)arg; esp_apptrace_test_timer_arg_t *tim_arg = (esp_apptrace_test_timer_arg_t *)arg;
if (tim_arg->group == 0) { timer_group_intr_clr_in_isr(tim_arg->group, tim_arg->id);
if (tim_arg->id == 0) { timer_group_enable_alarm_in_isr(tim_arg->group, tim_arg->id);
TIMERG0.int_clr_timers.t0 = 1;
TIMERG0.hw_timer[0].update = 1;
TIMERG0.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
TIMERG0.hw_timer[1].update = 1;
TIMERG0.hw_timer[1].config.alarm_en = 1;
}
}
if (tim_arg->group == 1) {
if (tim_arg->id == 0) {
TIMERG1.int_clr_timers.t0 = 1;
TIMERG1.hw_timer[0].update = 1;
TIMERG1.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG1.int_clr_timers.t1 = 1;
TIMERG1.hw_timer[1].update = 1;
TIMERG1.hw_timer[1].config.alarm_en = 1;
}
}
if (tim_arg->data.wr_cnt < ESP_APPTRACE_TEST_BLOCKS_BEFORE_CRASH) { if (tim_arg->data.wr_cnt < ESP_APPTRACE_TEST_BLOCKS_BEFORE_CRASH) {
uint32_t *ts = (uint32_t *)(tim_arg->data.buf + sizeof(uint32_t)); uint32_t *ts = (uint32_t *)(tim_arg->data.buf + sizeof(uint32_t));
*ts = (uint32_t)esp_apptrace_test_ts_get();//xthal_get_ccount();//xTaskGetTickCount(); *ts = (uint32_t)esp_apptrace_test_ts_get();//xthal_get_ccount();//xTaskGetTickCount();
@ -850,28 +810,8 @@ static void esp_sysview_test_timer_isr(void *arg)
//ESP_APPTRACE_TEST_LOGI("tim-%d: IRQ %d/%d\n", tim_arg->id, tim_arg->group, tim_arg->timer); //ESP_APPTRACE_TEST_LOGI("tim-%d: IRQ %d/%d\n", tim_arg->id, tim_arg->group, tim_arg->timer);
if (tim_arg->group == 0) { timer_group_intr_clr_in_isr(tim_arg->group, tim_arg->id);
if (tim_arg->timer == 0) { timer_group_enable_alarm_in_isr(tim_arg->group, tim_arg->id);
TIMERG0.int_clr_timers.t0 = 1;
TIMERG0.hw_timer[0].update = 1;
TIMERG0.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
TIMERG0.hw_timer[1].update = 1;
TIMERG0.hw_timer[1].config.alarm_en = 1;
}
}
if (tim_arg->group == 1) {
if (tim_arg->timer == 0) {
TIMERG1.int_clr_timers.t0 = 1;
TIMERG1.hw_timer[0].update = 1;
TIMERG1.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG1.int_clr_timers.t1 = 1;
TIMERG1.hw_timer[1].update = 1;
TIMERG1.hw_timer[1].config.alarm_en = 1;
}
}
} }
static void esp_sysviewtrace_test_task(void *p) static void esp_sysviewtrace_test_task(void *p)

5
components/bootloader_support/src/bootloader_init.c
View File

@ -53,6 +53,7 @@
#include "bootloader_flash_config.h" #include "bootloader_flash_config.h"
#include "flash_qio_mode.h" #include "flash_qio_mode.h"
#include "hal/timer_ll.h"
extern int _bss_start; extern int _bss_start;
extern int _bss_end; extern int _bss_end;
@ -158,8 +159,8 @@ static esp_err_t bootloader_main(void)
/* disable watch dog here */ /* disable watch dog here */
rtc_wdt_disable(); rtc_wdt_disable();
#endif #endif
REG_SET_FIELD(TIMG_WDTWPROTECT_REG(0), TIMG_WDT_WKEY, TIMG_WDT_WKEY_VALUE); timer_ll_wdt_set_protect(&TIMERG0, false);
REG_CLR_BIT( TIMG_WDTCONFIG0_REG(0), TIMG_WDT_FLASHBOOT_MOD_EN ); timer_ll_wdt_flashboot_en(&TIMERG0, false);
#ifndef CONFIG_SPI_FLASH_ROM_DRIVER_PATCH #ifndef CONFIG_SPI_FLASH_ROM_DRIVER_PATCH
const uint32_t spiconfig = ets_efuse_get_spiconfig(); const uint32_t spiconfig = ets_efuse_get_spiconfig();

112
components/driver/test/test_timer.c
View File

@ -11,68 +11,44 @@
#define TIMER_DELTA 0.001 #define TIMER_DELTA 0.001
static bool alarm_flag; static bool alarm_flag;
// group0 interruption typedef struct {
static void test_timer_group0_isr(void *para) timer_group_t timer_group;
{ timer_idx_t timer_idx;
int timer_idx = (int) para; } timer_info_t;
uint64_t timer_val;
double time;
uint64_t alarm_value;
alarm_flag = true;
if (TIMERG0.hw_timer[timer_idx].config.autoreload == 1) {
if (timer_idx == 0) {
TIMERG0.int_clr_timers.t0 = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
}
ets_printf("This is TG0 timer[%d] reload-timer alarm!\n", timer_idx);
timer_get_counter_value(TIMER_GROUP_0, timer_idx, &timer_val);
timer_get_counter_time_sec(TIMER_GROUP_0, timer_idx, &time);
ets_printf("time: %.8f S\n", time);
} else {
if (timer_idx == 0) {
TIMERG0.int_clr_timers.t0 = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
}
ets_printf("This is TG0 timer[%d] count-up-timer alarm!\n", timer_idx);
timer_get_counter_value(TIMER_GROUP_0, timer_idx, &timer_val);
timer_get_counter_time_sec(TIMER_GROUP_0, timer_idx, &time);
timer_get_alarm_value(TIMER_GROUP_0, timer_idx, &alarm_value);
ets_printf("time: %.8f S\n", time);
double alarm_time = (double) alarm_value / TIMER_SCALE;
ets_printf("alarm_time: %.8f S\n", alarm_time);
}
}
// group1 interruption #define TIMER_INFO_INIT(TG, TID) {.timer_group = (TG), .timer_idx = (TID),}
static void test_timer_group1_isr(void *para)
static timer_info_t timer_info[4] = {
TIMER_INFO_INIT(TIMER_GROUP_0, TIMER_0),
TIMER_INFO_INIT(TIMER_GROUP_0, TIMER_1),
TIMER_INFO_INIT(TIMER_GROUP_1, TIMER_0),
TIMER_INFO_INIT(TIMER_GROUP_1, TIMER_1),
};
#define GET_TIMER_INFO(TG, TID) (&timer_info[(TG)*2+(TID)])
// timer group interruption
static void test_timer_group_isr(void *para)
{ {
int timer_idx = (int) para; timer_info_t* info = (timer_info_t*) para;
const timer_group_t timer_group = info->timer_group;
const timer_idx_t timer_idx = info->timer_idx;
uint64_t timer_val; uint64_t timer_val;
double time; double time;
uint64_t alarm_value; uint64_t alarm_value;
alarm_flag = true; alarm_flag = true;
if (TIMERG1.hw_timer[timer_idx].config.autoreload == 1) { if (timer_group_get_auto_reload_in_isr(timer_group, timer_idx)) {
if (timer_idx == 0) { timer_group_intr_clr_in_isr(timer_group, timer_idx);
TIMERG1.int_clr_timers.t0 = 1; ets_printf("This is TG%d timer[%d] reload-timer alarm!\n", timer_group, timer_idx);
} else { timer_get_counter_value(timer_group, timer_idx, &timer_val);
TIMERG1.int_clr_timers.t1 = 1; timer_get_counter_time_sec(timer_group, timer_idx, &time);
}
ets_printf("This is TG1 timer[%d] reload-timer alarm!\n", timer_idx);
timer_get_counter_value(TIMER_GROUP_1, timer_idx, &timer_val);
timer_get_counter_time_sec(TIMER_GROUP_1, timer_idx, &time);
ets_printf("time: %.8f S\n", time); ets_printf("time: %.8f S\n", time);
} else { } else {
if (timer_idx == 0) { timer_group_intr_clr_in_isr(timer_group, timer_idx);
TIMERG1.int_clr_timers.t0 = 1; ets_printf("This is TG%d timer[%d] count-up-timer alarm!\n", timer_group, timer_idx);
} else { timer_get_counter_value(timer_group, timer_idx, &timer_val);
TIMERG1.int_clr_timers.t1 = 1; timer_get_counter_time_sec(timer_group, timer_idx, &time);
} timer_get_alarm_value(timer_group, timer_idx, &alarm_value);
ets_printf("This is TG1 timer[%d] count-up-timer alarm!\n", timer_idx);
timer_get_counter_value(TIMER_GROUP_1, timer_idx, &timer_val);
timer_get_counter_time_sec(TIMER_GROUP_1, timer_idx, &time);
timer_get_alarm_value(TIMER_GROUP_1, timer_idx, &alarm_value);
ets_printf("time: %.8f S\n", time); ets_printf("time: %.8f S\n", time);
double alarm_time = (double) alarm_value / TIMER_SCALE; double alarm_time = (double) alarm_value / TIMER_SCALE;
ets_printf("alarm_time: %.8f S\n", alarm_time); ets_printf("alarm_time: %.8f S\n", alarm_time);
@ -86,13 +62,7 @@ static void tg_timer_init(int timer_group, int timer_idx, double alarm_time)
timer_set_counter_value(timer_group, timer_idx, 0x0); timer_set_counter_value(timer_group, timer_idx, 0x0);
timer_set_alarm_value(timer_group, timer_idx, alarm_time * TIMER_SCALE); timer_set_alarm_value(timer_group, timer_idx, alarm_time * TIMER_SCALE);
timer_enable_intr(timer_group, timer_idx); timer_enable_intr(timer_group, timer_idx);
if (timer_group == 0) { timer_isr_register(timer_group, timer_idx, test_timer_group_isr, GET_TIMER_INFO(timer_group, timer_idx), ESP_INTR_FLAG_LOWMED, NULL);
timer_isr_register(timer_group, timer_idx, test_timer_group0_isr,
(void *) timer_idx, ESP_INTR_FLAG_LOWMED, NULL);
} else {
timer_isr_register(timer_group, timer_idx, test_timer_group1_isr,
(void *) timer_idx, ESP_INTR_FLAG_LOWMED, NULL);
}
timer_start(timer_group, timer_idx); timer_start(timer_group, timer_idx);
} }
@ -747,8 +717,8 @@ TEST_CASE("Timer enable timer interrupt", "[hw_timer]")
// enable timer_intr0 // enable timer_intr0
timer_set_counter_value(TIMER_GROUP_0, TIMER_0, set_timer_val); timer_set_counter_value(TIMER_GROUP_0, TIMER_0, set_timer_val);
timer_set_alarm_value(TIMER_GROUP_0, TIMER_0, 1.2 * TIMER_SCALE); timer_set_alarm_value(TIMER_GROUP_0, TIMER_0, 1.2 * TIMER_SCALE);
timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group0_isr, timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group_isr,
(void *) TIMER_0, ESP_INTR_FLAG_LOWMED, NULL); GET_TIMER_INFO(TIMER_GROUP_0, TIMER_0), ESP_INTR_FLAG_LOWMED, NULL);
timer_start(TIMER_GROUP_0, TIMER_0); timer_start(TIMER_GROUP_0, TIMER_0);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(2000 / portTICK_PERIOD_MS);
TEST_ASSERT(alarm_flag == true) TEST_ASSERT(alarm_flag == true)
@ -765,8 +735,8 @@ TEST_CASE("Timer enable timer interrupt", "[hw_timer]")
// enable timer_intr1 // enable timer_intr1
timer_set_counter_value(TIMER_GROUP_1, TIMER_1, set_timer_val); timer_set_counter_value(TIMER_GROUP_1, TIMER_1, set_timer_val);
timer_set_alarm_value(TIMER_GROUP_1, TIMER_1, 1.2 * TIMER_SCALE); timer_set_alarm_value(TIMER_GROUP_1, TIMER_1, 1.2 * TIMER_SCALE);
timer_isr_register(TIMER_GROUP_1, TIMER_1, test_timer_group1_isr, timer_isr_register(TIMER_GROUP_1, TIMER_1, test_timer_group_isr,
(void *) TIMER_1, ESP_INTR_FLAG_LOWMED, NULL); GET_TIMER_INFO(TIMER_GROUP_1, TIMER_1), ESP_INTR_FLAG_LOWMED, NULL);
timer_start(TIMER_GROUP_1, TIMER_1); timer_start(TIMER_GROUP_1, TIMER_1);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(2000 / portTICK_PERIOD_MS);
TEST_ASSERT(alarm_flag == true) TEST_ASSERT(alarm_flag == true)
@ -813,23 +783,21 @@ TEST_CASE("Timer enable timer group interrupt", "[hw_timer][ignore]")
all_timer_set_alarm_value(1.2); all_timer_set_alarm_value(1.2);
// enable timer group // enable timer group
timer_group_intr_enable(TIMER_GROUP_0, TIMG_T0_INT_ENA_M); timer_group_intr_enable(TIMER_GROUP_0, TIMER_INTR_T0);
timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group0_isr, timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group_isr, GET_TIMER_INFO(TIMER_GROUP_0, TIMER_0), ESP_INTR_FLAG_LOWMED, NULL);
(void *) TIMER_0, ESP_INTR_FLAG_LOWMED, NULL);
timer_start(TIMER_GROUP_0, TIMER_0); timer_start(TIMER_GROUP_0, TIMER_0);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(2000 / portTICK_PERIOD_MS);
TEST_ASSERT(alarm_flag == true); TEST_ASSERT(alarm_flag == true);
//test enable auto_reload //test enable auto_reload
alarm_flag = false; alarm_flag = false;
timer_group_intr_disable(TIMER_GROUP_0, TIMG_T0_INT_ENA_M); timer_group_intr_disable(TIMER_GROUP_0, TIMER_INTR_T0);
timer_start(TIMER_GROUP_0, TIMER_0); timer_start(TIMER_GROUP_0, TIMER_0);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(2000 / portTICK_PERIOD_MS);
TEST_ASSERT(alarm_flag == false); TEST_ASSERT(alarm_flag == false);
timer_group_intr_enable(TIMER_GROUP_0, TIMG_T0_INT_ENA_M); timer_group_intr_enable(TIMER_GROUP_0, TIMER_INTR_T0);
timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group0_isr, timer_isr_register(TIMER_GROUP_0, TIMER_0, test_timer_group_isr, GET_TIMER_INFO(TIMER_GROUP_0, TIMER_0), ESP_INTR_FLAG_LOWMED, NULL);
(void *) TIMER_0, ESP_INTR_FLAG_LOWMED, NULL);
timer_start(TIMER_GROUP_0, TIMER_0); timer_start(TIMER_GROUP_0, TIMER_0);
vTaskDelay(2000 / portTICK_PERIOD_MS); vTaskDelay(2000 / portTICK_PERIOD_MS);
TEST_ASSERT(alarm_flag == true); TEST_ASSERT(alarm_flag == true);

58
components/esp32/int_wdt.c
View File

@ -30,10 +30,11 @@
#include "driver/timer.h" #include "driver/timer.h"
#include "driver/periph_ctrl.h" #include "driver/periph_ctrl.h"
#include "esp_int_wdt.h" #include "esp_int_wdt.h"
#include "hal/timer_ll.h"
#if CONFIG_ESP_INT_WDT #if CONFIG_ESP_INT_WDT
#define TG1_WDT_TICK_US 500
#define WDT_INT_NUM 24 #define WDT_INT_NUM 24
@ -48,11 +49,15 @@ static void IRAM_ATTR tick_hook(void) {
} else { } else {
//Only feed wdt if app cpu also ticked. //Only feed wdt if app cpu also ticked.
if (int_wdt_app_cpu_ticked) { if (int_wdt_app_cpu_ticked) {
TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_config2=CONFIG_ESP_INT_WDT_TIMEOUT_MS*2; //Set timeout before interrupt //Set timeout before interrupt
TIMERG1.wdt_config3=CONFIG_ESP_INT_WDT_TIMEOUT_MS*4; //Set timeout before reset timer_ll_wdt_set_timeout(&TIMERG1, 0,
TIMERG1.wdt_feed=1; CONFIG_ESP_INT_WDT_TIMEOUT_MS*1000/TG1_WDT_TICK_US);
TIMERG1.wdt_wprotect=0; //Set timeout before reset
timer_ll_wdt_set_timeout(&TIMERG1, 1,
2*CONFIG_ESP_INT_WDT_TIMEOUT_MS*1000/TG1_WDT_TICK_US);
timer_ll_wdt_feed(&TIMERG1);
timer_ll_wdt_set_protect(&TIMERG1, true);
int_wdt_app_cpu_ticked=false; int_wdt_app_cpu_ticked=false;
} }
} }
@ -60,33 +65,36 @@ static void IRAM_ATTR tick_hook(void) {
#else #else
static void IRAM_ATTR tick_hook(void) { static void IRAM_ATTR tick_hook(void) {
if (xPortGetCoreID()!=0) return; if (xPortGetCoreID()!=0) return;
TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_config2=CONFIG_ESP_INT_WDT_TIMEOUT_MS*2; //Set timeout before interrupt //Set timeout before interrupt
TIMERG1.wdt_config3=CONFIG_ESP_INT_WDT_TIMEOUT_MS*4; //Set timeout before reset timer_ll_wdt_set_timeout(&TIMERG1, 0, CONFIG_ESP_INT_WDT_TIMEOUT_MS*1000/TG1_WDT_TICK_US);
TIMERG1.wdt_feed=1; //Set timeout before reset
TIMERG1.wdt_wprotect=0; timer_ll_wdt_set_timeout(&TIMERG1, 1, 2*CONFIG_ESP_INT_WDT_TIMEOUT_MS*1000/TG1_WDT_TICK_US);
timer_ll_wdt_feed(&TIMERG1);
timer_ll_wdt_set_protect(&TIMERG1, true);
} }
#endif #endif
void esp_int_wdt_init(void) { void esp_int_wdt_init(void) {
periph_module_enable(PERIPH_TIMG1_MODULE); periph_module_enable(PERIPH_TIMG1_MODULE);
TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE;
TIMERG1.wdt_config0.sys_reset_length=7; //3.2uS
TIMERG1.wdt_config0.cpu_reset_length=7; //3.2uS
TIMERG1.wdt_config0.level_int_en=1;
TIMERG1.wdt_config0.stg0=TIMG_WDT_STG_SEL_INT; //1st stage timeout: interrupt
TIMERG1.wdt_config0.stg1=TIMG_WDT_STG_SEL_RESET_SYSTEM; //2nd stage timeout: reset system
TIMERG1.wdt_config1.clk_prescale=80*500; //Prescaler: wdt counts in ticks of 0.5mS
//The timer configs initially are set to 5 seconds, to make sure the CPU can start up. The tick hook sets //The timer configs initially are set to 5 seconds, to make sure the CPU can start up. The tick hook sets
//it to their actual value. //it to their actual value.
TIMERG1.wdt_config2=10000; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_config3=10000; timer_ll_wdt_init(&TIMERG1);
TIMERG1.wdt_config0.en=1; timer_ll_wdt_set_tick(&TIMERG1, TG1_WDT_TICK_US); //Prescaler: wdt counts in ticks of TG1_WDT_TICK_US
TIMERG1.wdt_feed=1; //1st stage timeout: interrupt
TIMERG1.wdt_wprotect=0; timer_ll_wdt_set_timeout_behavior(&TIMERG1, 0, TIMER_WDT_INT);
TIMERG1.int_clr_timers.wdt=1; timer_ll_wdt_set_timeout(&TIMERG1, 0, 5*1000*1000/TG1_WDT_TICK_US);
timer_group_intr_enable(TIMER_GROUP_1, TIMG_WDT_INT_ENA_M); //2nd stage timeout: reset system
timer_ll_wdt_set_timeout_behavior(&TIMERG1, 1, TIMER_WDT_RESET_SYSTEM);
timer_ll_wdt_set_timeout(&TIMERG1, 1, 5*1000*1000/TG1_WDT_TICK_US);
timer_ll_wdt_set_enable(&TIMERG1, true);
timer_ll_wdt_feed(&TIMERG1);
timer_ll_wdt_set_protect(&TIMERG1, true);
timer_ll_intr_status_clear(&TIMERG1, TIMER_INTR_WDT);
timer_group_intr_enable(TIMER_GROUP_1, TIMER_INTR_WDT);
} }
void esp_int_wdt_cpu_init(void) void esp_int_wdt_cpu_init(void)

43
components/esp32/panic.c
View File

@ -44,6 +44,8 @@
#include "esp_private/system_internal.h" #include "esp_private/system_internal.h"
#include "sdkconfig.h" #include "sdkconfig.h"
#include "esp_ota_ops.h" #include "esp_ota_ops.h"
#include "driver/timer.h"
#include "hal/timer_ll.h"
#if CONFIG_SYSVIEW_ENABLE #if CONFIG_SYSVIEW_ENABLE
#include "SEGGER_RTT.h" #include "SEGGER_RTT.h"
#endif #endif
@ -311,7 +313,7 @@ void panicHandler(XtExcFrame *frame)
disableAllWdts(); disableAllWdts();
if (frame->exccause == PANIC_RSN_INTWDT_CPU0 || if (frame->exccause == PANIC_RSN_INTWDT_CPU0 ||
frame->exccause == PANIC_RSN_INTWDT_CPU1) { frame->exccause == PANIC_RSN_INTWDT_CPU1) {
TIMERG1.int_clr_timers.wdt = 1; timer_group_clr_intr_sta_in_isr(TIMER_GROUP_1, TIMER_INTR_WDT);
} }
#if CONFIG_ESP32_APPTRACE_ENABLE #if CONFIG_ESP32_APPTRACE_ENABLE
#if CONFIG_SYSVIEW_ENABLE #if CONFIG_SYSVIEW_ENABLE
@ -401,19 +403,21 @@ static void illegal_instruction_helper(XtExcFrame *frame)
*/ */
static void reconfigureAllWdts(void) static void reconfigureAllWdts(void)
{ {
TIMERG0.wdt_wprotect = TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_feed = 1; timer_ll_wdt_feed(&TIMERG0);
TIMERG0.wdt_config0.sys_reset_length = 7; //3.2uS timer_ll_wdt_init(&TIMERG0);
TIMERG0.wdt_config0.cpu_reset_length = 7; //3.2uS timer_ll_wdt_set_tick(&TIMERG0, TG0_WDT_TICK_US); //Prescaler: wdt counts in ticks of TG0_WDT_TICK_US
TIMERG0.wdt_config0.stg0 = TIMG_WDT_STG_SEL_RESET_SYSTEM; //1st stage timeout: reset system //1st stage timeout: reset system
TIMERG0.wdt_config1.clk_prescale = 80 * 500; //Prescaler: wdt counts in ticks of 0.5mS timer_ll_wdt_set_timeout_behavior(&TIMERG0, 0, TIMER_WDT_RESET_SYSTEM);
TIMERG0.wdt_config2 = 2000; //1 second before reset //1 second before reset
TIMERG0.wdt_config0.en = 1; timer_ll_wdt_set_timeout(&TIMERG0, 0, 1000*1000/TG0_WDT_TICK_US);
TIMERG0.wdt_wprotect = 0; timer_ll_wdt_set_enable(&TIMERG0, true);
timer_ll_wdt_set_protect(&TIMERG0, true);
//Disable wdt 1 //Disable wdt 1
TIMERG1.wdt_wprotect = TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_config0.en = 0; timer_ll_wdt_set_enable(&TIMERG1, false);
TIMERG1.wdt_wprotect = 0; timer_ll_wdt_set_protect(&TIMERG1, true);
} }
/* /*
@ -421,12 +425,13 @@ static void reconfigureAllWdts(void)
*/ */
static inline void disableAllWdts(void) static inline void disableAllWdts(void)
{ {
TIMERG0.wdt_wprotect = TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_config0.en = 0; timer_ll_wdt_set_enable(&TIMERG0, false);
TIMERG0.wdt_wprotect = 0; timer_ll_wdt_set_protect(&TIMERG0, true);
TIMERG1.wdt_wprotect = TIMG_WDT_WKEY_VALUE;
TIMERG1.wdt_config0.en = 0; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_wprotect = 0; timer_ll_wdt_set_enable(&TIMERG1, false);
timer_ll_wdt_set_protect(&TIMERG1, true);
} }
static void esp_panic_dig_reset(void) __attribute__((noreturn)); static void esp_panic_dig_reset(void) __attribute__((noreturn));

22
components/esp32/system_api.c
View File

@ -38,6 +38,7 @@
#include "esp_private/system_internal.h" #include "esp_private/system_internal.h"
#include "esp_efuse.h" #include "esp_efuse.h"
#include "esp_efuse_table.h" #include "esp_efuse_table.h"
#include "hal/timer_ll.h"
static const char* TAG = "system_api"; static const char* TAG = "system_api";
@ -204,7 +205,7 @@ esp_err_t esp_read_mac(uint8_t* mac, esp_mac_type_t type)
ESP_LOGW(TAG, "incorrect mac type"); ESP_LOGW(TAG, "incorrect mac type");
break; break;
} }
return ESP_OK; return ESP_OK;
} }
@ -281,12 +282,13 @@ void IRAM_ATTR esp_restart_noos(void)
esp_dport_access_int_abort(); esp_dport_access_int_abort();
// Disable TG0/TG1 watchdogs // Disable TG0/TG1 watchdogs
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_config0.en = 0; timer_ll_wdt_set_enable(&TIMERG0, false);
TIMERG0.wdt_wprotect=0; timer_ll_wdt_set_protect(&TIMERG0, true);
TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE;
TIMERG1.wdt_config0.en = 0; timer_ll_wdt_set_protect(&TIMERG1, false);
TIMERG1.wdt_wprotect=0; timer_ll_wdt_set_enable(&TIMERG1, false);
timer_ll_wdt_set_protect(&TIMERG1, true);
// Flush any data left in UART FIFOs // Flush any data left in UART FIFOs
uart_tx_wait_idle(0); uart_tx_wait_idle(0);
@ -307,10 +309,10 @@ void IRAM_ATTR esp_restart_noos(void)
WRITE_PERI_REG(GPIO_FUNC5_IN_SEL_CFG_REG, 0x30); WRITE_PERI_REG(GPIO_FUNC5_IN_SEL_CFG_REG, 0x30);
// Reset wifi/bluetooth/ethernet/sdio (bb/mac) // Reset wifi/bluetooth/ethernet/sdio (bb/mac)
DPORT_SET_PERI_REG_MASK(DPORT_CORE_RST_EN_REG, DPORT_SET_PERI_REG_MASK(DPORT_CORE_RST_EN_REG,
DPORT_BB_RST | DPORT_FE_RST | DPORT_MAC_RST | DPORT_BB_RST | DPORT_FE_RST | DPORT_MAC_RST |
DPORT_BT_RST | DPORT_BTMAC_RST | DPORT_SDIO_RST | DPORT_BT_RST | DPORT_BTMAC_RST | DPORT_SDIO_RST |
DPORT_SDIO_HOST_RST | DPORT_EMAC_RST | DPORT_MACPWR_RST | DPORT_SDIO_HOST_RST | DPORT_EMAC_RST | DPORT_MACPWR_RST |
DPORT_RW_BTMAC_RST | DPORT_RW_BTLP_RST); DPORT_RW_BTMAC_RST | DPORT_RW_BTLP_RST);
DPORT_REG_WRITE(DPORT_CORE_RST_EN_REG, 0); DPORT_REG_WRITE(DPORT_CORE_RST_EN_REG, 0);
@ -370,7 +372,7 @@ static void get_chip_info_esp32(esp_chip_info_t* out_info)
{ {
uint32_t reg = REG_READ(EFUSE_BLK0_RDATA3_REG); uint32_t reg = REG_READ(EFUSE_BLK0_RDATA3_REG);
memset(out_info, 0, sizeof(*out_info)); memset(out_info, 0, sizeof(*out_info));
out_info->model = CHIP_ESP32; out_info->model = CHIP_ESP32;
if ((reg & EFUSE_RD_CHIP_VER_REV1_M) != 0) { if ((reg & EFUSE_RD_CHIP_VER_REV1_M) != 0) {
out_info->revision = 1; out_info->revision = 1;

65
components/esp32/task_wdt.c
View File

@ -34,6 +34,8 @@
#include "driver/periph_ctrl.h" #include "driver/periph_ctrl.h"
#include "esp_task_wdt.h" #include "esp_task_wdt.h"
#include "esp_private/system_internal.h" #include "esp_private/system_internal.h"
#include "hal/timer_ll.h"
static const char *TAG = "task_wdt"; static const char *TAG = "task_wdt";
@ -107,9 +109,9 @@ static twdt_task_t *find_task_in_twdt_list(TaskHandle_t handle, bool *all_reset)
static void reset_hw_timer(void) static void reset_hw_timer(void)
{ {
//All tasks have reset; time to reset the hardware timer. //All tasks have reset; time to reset the hardware timer.
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_feed=1; timer_ll_wdt_feed(&TIMERG0);
TIMERG0.wdt_wprotect=0; timer_ll_wdt_set_protect(&TIMERG0, true);
//Clear all has_reset flags in list //Clear all has_reset flags in list
for (twdt_task_t *task = twdt_config->list; task != NULL; task = task->next){ for (twdt_task_t *task = twdt_config->list; task != NULL; task = task->next){
task->has_reset=false; task->has_reset=false;
@ -137,11 +139,11 @@ static void task_wdt_isr(void *arg)
twdt_task_t *twdttask; twdt_task_t *twdttask;
const char *cpu; const char *cpu;
//Reset hardware timer so that 2nd stage timeout is not reached (will trigger system reset) //Reset hardware timer so that 2nd stage timeout is not reached (will trigger system reset)
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; timer_ll_wdt_set_protect(&TIMERG0, false);
TIMERG0.wdt_feed=1; timer_ll_wdt_feed(&TIMERG0);
TIMERG0.wdt_wprotect=0; timer_ll_wdt_set_protect(&TIMERG0, true);
//Acknowledge interrupt //Acknowledge interrupt
TIMERG0.int_clr_timers.wdt=1; timer_group_clr_intr_sta_in_isr(TIMER_GROUP_0, TIMER_INTR_WDT);
//We are taking a spinlock while doing I/O (ESP_EARLY_LOGE) here. Normally, that is a pretty //We are taking a spinlock while doing I/O (ESP_EARLY_LOGE) here. Normally, that is a pretty
//bad thing, possibly (temporarily) hanging up the 2nd core and stopping FreeRTOS. In this case, //bad thing, possibly (temporarily) hanging up the 2nd core and stopping FreeRTOS. In this case,
//something bad already happened and reporting this is considered more important //something bad already happened and reporting this is considered more important
@ -198,32 +200,33 @@ esp_err_t esp_task_wdt_init(uint32_t timeout, bool panic)
//Configure hardware timer //Configure hardware timer
periph_module_enable(PERIPH_TIMG0_MODULE); periph_module_enable(PERIPH_TIMG0_MODULE);
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; //Disable write protection timer_ll_wdt_set_protect(&TIMERG0, false); //Disable write protection
TIMERG0.wdt_config0.sys_reset_length=7; //3.2uS timer_ll_wdt_init(&TIMERG0);
TIMERG0.wdt_config0.cpu_reset_length=7; //3.2uS timer_ll_wdt_set_tick(&TIMERG0, TG0_WDT_TICK_US); //Prescaler: wdt counts in ticks of TG0_WDT_TICK_US
TIMERG0.wdt_config0.level_int_en=1; //1st stage timeout: interrupt
TIMERG0.wdt_config0.stg0=TIMG_WDT_STG_SEL_INT; //1st stage timeout: interrupt timer_ll_wdt_set_timeout_behavior(&TIMERG0, 0, TIMER_WDT_INT);
TIMERG0.wdt_config0.stg1=TIMG_WDT_STG_SEL_RESET_SYSTEM; //2nd stage timeout: reset system timer_ll_wdt_set_timeout(&TIMERG0, 0, twdt_config->timeout*1000*1000/TG0_WDT_TICK_US);
TIMERG0.wdt_config1.clk_prescale=80*500; //Prescaler: wdt counts in ticks of 0.5mS //2nd stage timeout: reset system
TIMERG0.wdt_config2=twdt_config->timeout*2000; //Set timeout before interrupt timer_ll_wdt_set_timeout_behavior(&TIMERG0, 1, TIMER_WDT_RESET_SYSTEM);
TIMERG0.wdt_config3=twdt_config->timeout*4000; //Set timeout before reset timer_ll_wdt_set_timeout(&TIMERG0, 1, 2*twdt_config->timeout*1000*1000/TG0_WDT_TICK_US);
TIMERG0.wdt_config0.en=1; timer_ll_wdt_set_enable(&TIMERG0, true);
TIMERG0.wdt_feed=1; timer_ll_wdt_feed(&TIMERG0);
TIMERG0.wdt_wprotect=0; //Enable write protection timer_ll_wdt_set_protect(&TIMERG0, true); //Enable write protection
} else { //twdt_config previously initialized
}else{ //twdt_config previously initialized
//Reconfigure task wdt //Reconfigure task wdt
twdt_config->panic = panic; twdt_config->panic = panic;
twdt_config->timeout = timeout; twdt_config->timeout = timeout;
//Reconfigure hardware timer //Reconfigure hardware timer
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; //Disable write protection timer_ll_wdt_set_protect(&TIMERG0, false); //Disable write protection
TIMERG0.wdt_config0.en=0; //Disable timer timer_ll_wdt_set_enable(&TIMERG0, false); //Disable timer
TIMERG0.wdt_config2=twdt_config->timeout*2000; //Set timeout before interrupt //Set timeout before interrupt
TIMERG0.wdt_config3=twdt_config->timeout*4000; //Set timeout before reset timer_ll_wdt_set_timeout(&TIMERG0, 0, twdt_config->timeout*1000*1000/TG0_WDT_TICK_US);
TIMERG0.wdt_config0.en=1; //Renable timer //Set timeout before reset
TIMERG0.wdt_feed=1; //Reset timer timer_ll_wdt_set_timeout(&TIMERG0, 1, 2*twdt_config->timeout*1000*1000/TG0_WDT_TICK_US);
TIMERG0.wdt_wprotect=0; //Enable write protection timer_ll_wdt_set_enable(&TIMERG0, true); //Renable timer
timer_ll_wdt_feed(&TIMERG0); //Reset timer
timer_ll_wdt_set_protect(&TIMERG0, true); //Enable write protection
} }
portEXIT_CRITICAL(&twdt_spinlock); portEXIT_CRITICAL(&twdt_spinlock);
return ESP_OK; return ESP_OK;
@ -238,9 +241,9 @@ esp_err_t esp_task_wdt_deinit(void)
ASSERT_EXIT_CRIT_RETURN((twdt_config->list == NULL), ESP_ERR_INVALID_STATE); ASSERT_EXIT_CRIT_RETURN((twdt_config->list == NULL), ESP_ERR_INVALID_STATE);
//Disable hardware timer //Disable hardware timer
TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; //Disable write protection timer_ll_wdt_set_protect(&TIMERG0, false); //Disable write protection
TIMERG0.wdt_config0.en=0; //Disable timer timer_ll_wdt_set_enable(&TIMERG0, false); //Disable timer
TIMERG0.wdt_wprotect=0; //Enable write protection timer_ll_wdt_set_protect(&TIMERG0, true); //Enable write protection
ESP_ERROR_CHECK(esp_intr_free(twdt_config->intr_handle)); //Unregister interrupt ESP_ERROR_CHECK(esp_intr_free(twdt_config->intr_handle)); //Unregister interrupt
free(twdt_config); //Free twdt_config free(twdt_config); //Free twdt_config

22
components/esp32/test/test_intr_alloc.c
View File

@ -55,24 +55,20 @@ static void timer_isr(void *arg)
int timer_idx = (int)arg; int timer_idx = (int)arg;
count[timer_idx]++; count[timer_idx]++;
if (timer_idx==0) { if (timer_idx==0) {
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[0].update=1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[0].config.alarm_en = 1;
} }
if (timer_idx==1) { if (timer_idx==1) {
TIMERG0.int_clr_timers.t1 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_1);
TIMERG0.hw_timer[1].update=1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, TIMER_1);
TIMERG0.hw_timer[1].config.alarm_en = 1;
} }
if (timer_idx==2) { if (timer_idx==2) {
TIMERG1.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_1, TIMER_0);
TIMERG1.hw_timer[0].update=1; timer_group_enable_alarm_in_isr(TIMER_GROUP_1, TIMER_0);
TIMERG1.hw_timer[0].config.alarm_en = 1;
} }
if (timer_idx==3) { if (timer_idx==3) {
TIMERG1.int_clr_timers.t1 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_1, TIMER_1);
TIMERG1.hw_timer[1].update=1; timer_group_enable_alarm_in_isr(TIMER_GROUP_1, TIMER_1);
TIMERG1.hw_timer[1].config.alarm_en = 1;
} }
// ets_printf("int %d\n", timer_idx); // ets_printf("int %d\n", timer_idx);
} }
@ -280,7 +276,7 @@ TEST_CASE("allocate 2 handlers for a same source and remove the later one","[esp
r=esp_intr_alloc(ETS_SPI2_INTR_SOURCE, ESP_INTR_FLAG_SHARED, int_handler2, &ctx, &handle2); r=esp_intr_alloc(ETS_SPI2_INTR_SOURCE, ESP_INTR_FLAG_SHARED, int_handler2, &ctx, &handle2);
TEST_ESP_OK(r); TEST_ESP_OK(r);
SPI2.slave.trans_inten = 1; SPI2.slave.trans_inten = 1;
printf("trigger first time.\n"); printf("trigger first time.\n");
SPI2.slave.trans_done = 1; SPI2.slave.trans_done = 1;

5
components/esp32/test/test_reset_reason.c
View File

@ -280,11 +280,12 @@ static void timer_group_test_first_stage(void)
//Start timer //Start timer
timer_start(TIMER_GROUP_0, TIMER_0); timer_start(TIMER_GROUP_0, TIMER_0);
//Waiting for timer_group to generate an interrupt //Waiting for timer_group to generate an interrupt
while( !TIMERG0.int_raw.t0 && loop_cnt++ < 100) { while( !(timer_group_intr_get_in_isr(TIMER_GROUP_0) & TIMER_INTR_T0) &&
loop_cnt++ < 100) {
vTaskDelay(200); vTaskDelay(200);
} }
//TIMERG0.int_raw.t0 == 1 means an interruption has occurred //TIMERG0.int_raw.t0 == 1 means an interruption has occurred
TEST_ASSERT_EQUAL(1, TIMERG0.int_raw.t0); TEST_ASSERT(timer_group_intr_get_in_isr(TIMER_GROUP_0) & TIMER_INTR_T0);
esp_restart(); esp_restart();
} }

2
components/esp_common/include/esp_private/system_internal.h
View File

@ -20,6 +20,8 @@ extern "C" {
#include "esp_system.h" #include "esp_system.h"
#define TG0_WDT_TICK_US 500
/** /**
* @brief Internal function to restart PRO and APP CPUs. * @brief Internal function to restart PRO and APP CPUs.
* *

16
components/esp_event/test/test_event.c
View File

@ -30,14 +30,14 @@ static const char* TAG = "test_event";
#define TEST_CONFIG_WAIT_MULTIPLIER 5 #define TEST_CONFIG_WAIT_MULTIPLIER 5
// The initial logging "initializing test" is to ensure mutex allocation is not counted against memory not being freed // The initial logging "initializing test" is to ensure mutex allocation is not counted against memory not being freed
// during teardown. // during teardown.
#define TEST_SETUP() \ #define TEST_SETUP() \
ESP_LOGI(TAG, "initializing test"); \ ESP_LOGI(TAG, "initializing test"); \
size_t free_mem_before = heap_caps_get_free_size(MALLOC_CAP_DEFAULT); \ size_t free_mem_before = heap_caps_get_free_size(MALLOC_CAP_DEFAULT); \
test_setup(); \ test_setup(); \
s_test_core_id = xPortGetCoreID(); \ s_test_core_id = xPortGetCoreID(); \
s_test_priority = uxTaskPriorityGet(NULL); s_test_priority = uxTaskPriorityGet(NULL);
#define TEST_TEARDOWN() \ #define TEST_TEARDOWN() \
test_teardown(); \ test_teardown(); \
@ -294,15 +294,11 @@ void IRAM_ATTR test_event_on_timer_alarm(void* para)
{ {
/* Retrieve the interrupt status and the counter value /* Retrieve the interrupt status and the counter value
from the timer that reported the interrupt */ from the timer that reported the interrupt */
TIMERG0.hw_timer[TIMER_0].update = 1;
uint64_t timer_counter_value = uint64_t timer_counter_value =
((uint64_t) TIMERG0.hw_timer[TIMER_0].cnt_high) << 32 timer_group_get_counter_value_in_isr(TIMER_GROUP_0, TIMER_0);
| TIMERG0.hw_timer[TIMER_0].cnt_low; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.int_clr_timers.t0 = 1;
timer_counter_value += (uint64_t) (TIMER_INTERVAL0_SEC * TIMER_SCALE); timer_counter_value += (uint64_t) (TIMER_INTERVAL0_SEC * TIMER_SCALE);
TIMERG0.hw_timer[TIMER_0].alarm_high = (uint32_t) (timer_counter_value >> 32); timer_group_set_alarm_value_in_isr(TIMER_GROUP_0, TIMER_0, timer_counter_value);
TIMERG0.hw_timer[TIMER_0].alarm_low = (uint32_t) timer_counter_value;
int data = (int) para; int data = (int) para;
// Posting events with data more than 4 bytes should fail. // Posting events with data more than 4 bytes should fail.

4
components/esp_ringbuf/test/test_ringbuf.c
View File

@ -356,8 +356,8 @@ static int iterations;
static void ringbuffer_isr(void *arg) static void ringbuffer_isr(void *arg)
{ {
//Clear timer interrupt //Clear timer interrupt
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[xPortGetCoreID()].config.alarm_en = 1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, xPortGetCoreID());
//Test sending to buffer from ISR from ISR //Test sending to buffer from ISR from ISR
if (buf_type < NO_OF_RB_TYPES) { if (buf_type < NO_OF_RB_TYPES) {

18
components/freemodbus/port/porttimer.c
View File

@ -64,19 +64,15 @@
static const USHORT usTimerIndex = CONFIG_FMB_TIMER_INDEX; // Modbus Timer index used by stack static const USHORT usTimerIndex = CONFIG_FMB_TIMER_INDEX; // Modbus Timer index used by stack
static const USHORT usTimerGroupIndex = CONFIG_FMB_TIMER_GROUP; // Modbus Timer group index used by stack static const USHORT usTimerGroupIndex = CONFIG_FMB_TIMER_GROUP; // Modbus Timer group index used by stack
static timg_dev_t *MB_TG[2] = {&TIMERG0, &TIMERG1};
/* ----------------------- Start implementation -----------------------------*/ /* ----------------------- Start implementation -----------------------------*/
static void IRAM_ATTR vTimerGroupIsr(void *param) static void IRAM_ATTR vTimerGroupIsr(void *param)
{ {
// Retrieve the interrupt status and the counter value assert((int)param == usTimerIndex);
// from the timer that reported the interrupt // Retrieve the counter value from the timer that reported the interrupt
uint32_t intr_status = MB_TG[usTimerGroupIndex]->int_st_timers.val; timer_group_intr_clr_in_isr(usTimerGroupIndex, usTimerIndex);
if (intr_status & BIT(usTimerIndex)) { (void)pxMBPortCBTimerExpired(); // Timer callback function
MB_TG[usTimerGroupIndex]->int_clr_timers.val |= BIT(usTimerIndex); // Enable alarm
(void)pxMBPortCBTimerExpired(); // Timer callback function timer_group_enable_alarm_in_isr(usTimerGroupIndex, usTimerIndex);
MB_TG[usTimerGroupIndex]->hw_timer[usTimerIndex].config.alarm_en = TIMER_ALARM_EN;
}
} }
#endif #endif
@ -113,7 +109,7 @@ BOOL xMBPortTimersInit(USHORT usTim1Timerout50us)
"failure to set alarm failure, timer_set_alarm_value() returned (0x%x).", "failure to set alarm failure, timer_set_alarm_value() returned (0x%x).",
(uint32_t)xErr); (uint32_t)xErr);
// Register ISR for timer // Register ISR for timer
xErr = timer_isr_register(usTimerGroupIndex, usTimerIndex, vTimerGroupIsr, NULL, ESP_INTR_FLAG_IRAM, NULL); xErr = timer_isr_register(usTimerGroupIndex, usTimerIndex, vTimerGroupIsr, (void*)(uint32_t)usTimerIndex, ESP_INTR_FLAG_IRAM, NULL);
MB_PORT_CHECK((xErr == ESP_OK), FALSE, MB_PORT_CHECK((xErr == ESP_OK), FALSE,
"timer set value failure, timer_isr_register() returned (0x%x).", "timer set value failure, timer_isr_register() returned (0x%x).",
(uint32_t)xErr); (uint32_t)xErr);

20
components/freemodbus/port/porttimer_m.c
View File

@ -61,22 +61,16 @@ static USHORT usT35TimeOut50us;
static const USHORT usTimerIndex = MB_TIMER_INDEX; // Initialize Modbus Timer index used by stack, static const USHORT usTimerIndex = MB_TIMER_INDEX; // Initialize Modbus Timer index used by stack,
static const USHORT usTimerGroupIndex = MB_TIMER_GROUP; // Timer group index used by stack static const USHORT usTimerGroupIndex = MB_TIMER_GROUP; // Timer group index used by stack
static timg_dev_t *MB_TG[2] = { &TIMERG0, &TIMERG1 };
/* ----------------------- static functions ---------------------------------*/ /* ----------------------- static functions ---------------------------------*/
static void IRAM_ATTR vTimerGroupIsr(void *param) static void IRAM_ATTR vTimerGroupIsr(void *param)
{ {
// Retrieve the interrupt status and the counter value assert((int)param == usTimerIndex);
// from the timer that reported the interrupt // Retrieve the the counter value from the timer that reported the interrupt
uint32_t intr_status = MB_TG[usTimerGroupIndex]->int_st_timers.val; timer_group_intr_clr_in_isr(usTimerGroupIndex, usTimerIndex);
if (intr_status & BIT(usTimerIndex)) { (void)pxMBMasterPortCBTimerExpired(); // Timer expired callback function
MB_TG[usTimerGroupIndex]->int_clr_timers.val |= BIT(usTimerIndex); // Enable alarm
MB_TG[usTimerGroupIndex]->hw_timer[usTimerIndex].update = 1; timer_group_enable_alarm_in_isr(usTimerGroupIndex, usTimerIndex);
(void)pxMBMasterPortCBTimerExpired(); // Timer expired callback function
// Enable alarm
MB_TG[usTimerGroupIndex]->hw_timer[usTimerIndex].config.alarm_en = TIMER_ALARM_EN;
}
} }
/* ----------------------- Start implementation -----------------------------*/ /* ----------------------- Start implementation -----------------------------*/
@ -115,7 +109,7 @@ BOOL xMBMasterPortTimersInit(USHORT usTimeOut50us)
(uint32_t)xErr); (uint32_t)xErr);
// Register ISR for timer // Register ISR for timer
xErr = timer_isr_register(usTimerGroupIndex, usTimerIndex, xErr = timer_isr_register(usTimerGroupIndex, usTimerIndex,
vTimerGroupIsr, NULL, ESP_INTR_FLAG_IRAM, NULL); vTimerGroupIsr, (void*)(uint32_t)usTimerIndex, ESP_INTR_FLAG_IRAM, NULL);
MB_PORT_CHECK((xErr == ESP_OK), FALSE, MB_PORT_CHECK((xErr == ESP_OK), FALSE,
"timer set value failure, timer_isr_register() returned (0x%x).", "timer set value failure, timer_isr_register() returned (0x%x).",
(uint32_t)xErr); (uint32_t)xErr);

4
components/freertos/test/test_freertos_eventgroups.c
View File

@ -138,8 +138,8 @@ static bool test_clear_bits;
static void IRAM_ATTR event_group_isr(void *arg) static void IRAM_ATTR event_group_isr(void *arg)
{ {
portBASE_TYPE task_woken = pdFALSE; portBASE_TYPE task_woken = pdFALSE;
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[xPortGetCoreID()].config.alarm_en = 1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, xPortGetCoreID());
if(test_set_bits){ if(test_set_bits){
xEventGroupSetBitsFromISR(eg, BITS, &task_woken); xEventGroupSetBitsFromISR(eg, BITS, &task_woken);

12
components/freertos/test/test_freertos_task_notify.c
View File

@ -97,16 +97,10 @@ static void receiver_task (void* arg){
static void IRAM_ATTR sender_ISR (void *arg) static void IRAM_ATTR sender_ISR (void *arg)
{ {
int curcore = xPortGetCoreID(); int curcore = xPortGetCoreID();
if(curcore == 0){ //Clear timer interrupt timer_group_intr_clr_in_isr(TIMER_GROUP_0, curcore);
//Clear intr and pause via direct reg access as IRAM ISR cannot access timer APIs timer_group_set_counter_enable_in_isr(TIMER_GROUP_0, curcore, TIMER_PAUSE);
TIMERG0.int_clr_timers.t0 = 1;
TIMERG0.hw_timer[0].config.enable = 0;
}else{
TIMERG0.int_clr_timers.t1 = 1;
TIMERG0.hw_timer[1].config.enable = 0;
}
//Re-enable alarm //Re-enable alarm
TIMERG0.hw_timer[curcore].config.alarm_en = 1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, curcore);
if(isr_give){ //Test vTaskNotifyGiveFromISR() on same core if(isr_give){ //Test vTaskNotifyGiveFromISR() on same core
notifs_sent++; notifs_sent++;

5
components/freertos/test/test_suspend_scheduler.c
View File

@ -20,9 +20,8 @@ static volatile unsigned isr_count;
mutex semaphore to wake up another counter task */ mutex semaphore to wake up another counter task */
static void timer_group0_isr(void *vp_arg) static void timer_group0_isr(void *vp_arg)
{ {
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[TIMER_0].update = 1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[TIMER_0].config.alarm_en = 1;
portBASE_TYPE higher_awoken = pdFALSE; portBASE_TYPE higher_awoken = pdFALSE;
isr_count++; isr_count++;
xSemaphoreGiveFromISR(isr_semaphore, &higher_awoken); xSemaphoreGiveFromISR(isr_semaphore, &higher_awoken);

2
components/freertos/test/test_task_suspend_resume.c
View File

@ -118,7 +118,7 @@ volatile bool timer_isr_fired;
void IRAM_ATTR timer_group0_isr(void *vp_arg) void IRAM_ATTR timer_group0_isr(void *vp_arg)
{ {
// Clear interrupt // Clear interrupt
TIMERG0.int_clr_timers.val = TIMERG0.int_st_timers.val; timer_group_clr_intr_sta_in_isr(TIMER_GROUP_0, TIMER_0|TIMER_1);
timer_isr_fired = true; timer_isr_fired = true;
TaskHandle_t handle = vp_arg; TaskHandle_t handle = vp_arg;

4
components/spi_flash/test/test_spi_flash.c
View File

@ -108,8 +108,8 @@ typedef struct {
static void IRAM_ATTR timer_isr(void* varg) { static void IRAM_ATTR timer_isr(void* varg) {
block_task_arg_t* arg = (block_task_arg_t*) varg; block_task_arg_t* arg = (block_task_arg_t*) varg;
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
TIMERG0.hw_timer[0].config.alarm_en = 1; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, TIMER_0);
ets_delay_us(arg->delay_time_us); ets_delay_us(arg->delay_time_us);
arg->repeat_count++; arg->repeat_count++;
} }

24
examples/peripherals/timer_group/main/timer_group_example_main.c
View File

@ -60,11 +60,8 @@ void IRAM_ATTR timer_group0_isr(void *para)
/* Retrieve the interrupt status and the counter value /* Retrieve the interrupt status and the counter value
from the timer that reported the interrupt */ from the timer that reported the interrupt */
uint32_t intr_status = TIMERG0.int_st_timers.val; timer_intr_t timer_intr = timer_group_intr_get_in_isr(TIMER_GROUP_0);
TIMERG0.hw_timer[timer_idx].update = 1; uint64_t timer_counter_value = timer_group_get_counter_value_in_isr(TIMER_GROUP_0, timer_idx);
uint64_t timer_counter_value =
((uint64_t) TIMERG0.hw_timer[timer_idx].cnt_high) << 32
| TIMERG0.hw_timer[timer_idx].cnt_low;
/* Prepare basic event data /* Prepare basic event data
that will be then sent back to the main program task */ that will be then sent back to the main program task */
@ -75,22 +72,21 @@ void IRAM_ATTR timer_group0_isr(void *para)
/* Clear the interrupt /* Clear the interrupt
and update the alarm time for the timer with without reload */ and update the alarm time for the timer with without reload */
if ((intr_status & BIT(timer_idx)) && timer_idx == TIMER_0) { if (timer_intr & TIMER_INTR_T0) {
evt.type = TEST_WITHOUT_RELOAD; evt.type = TEST_WITHOUT_RELOAD;
TIMERG0.int_clr_timers.t0 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_0);
timer_counter_value += (uint64_t) (TIMER_INTERVAL0_SEC * TIMER_SCALE); timer_counter_value += (uint64_t) (TIMER_INTERVAL0_SEC * TIMER_SCALE);
TIMERG0.hw_timer[timer_idx].alarm_high = (uint32_t) (timer_counter_value >> 32); timer_group_set_alarm_value_in_isr(TIMER_GROUP_0, timer_idx, timer_counter_value);
TIMERG0.hw_timer[timer_idx].alarm_low = (uint32_t) timer_counter_value; } else if (timer_intr & TIMER_INTR_T1) {
} else if ((intr_status & BIT(timer_idx)) && timer_idx == TIMER_1) {
evt.type = TEST_WITH_RELOAD; evt.type = TEST_WITH_RELOAD;
TIMERG0.int_clr_timers.t1 = 1; timer_group_intr_clr_in_isr(TIMER_GROUP_0, TIMER_1);
} else { } else {
evt.type = -1; // not supported even type evt.type = -1; // not supported even type
} }
/* After the alarm has been triggered /* After the alarm has been triggered
we need enable it again, so it is triggered the next time */ we need enable it again, so it is triggered the next time */
TIMERG0.hw_timer[timer_idx].config.alarm_en = TIMER_ALARM_EN; timer_group_enable_alarm_in_isr(TIMER_GROUP_0, timer_idx);
/* Now just send the event data back to the main program task */ /* Now just send the event data back to the main program task */
xQueueSendFromISR(timer_queue, &evt, NULL); xQueueSendFromISR(timer_queue, &evt, NULL);
@ -103,7 +99,7 @@ void IRAM_ATTR timer_group0_isr(void *para)
* auto_reload - should the timer auto reload on alarm? * auto_reload - should the timer auto reload on alarm?
* timer_interval_sec - the interval of alarm to set * timer_interval_sec - the interval of alarm to set
*/ */
static void example_tg0_timer_init(int timer_idx, static void example_tg0_timer_init(int timer_idx,
bool auto_reload, double timer_interval_sec) bool auto_reload, double timer_interval_sec)
{ {
/* Select and initialize basic parameters of the timer */ /* Select and initialize basic parameters of the timer */
@ -123,7 +119,7 @@ static void example_tg0_timer_init(int timer_idx,
/* Configure the alarm value and the interrupt on alarm. */ /* Configure the alarm value and the interrupt on alarm. */
timer_set_alarm_value(TIMER_GROUP_0, timer_idx, timer_interval_sec * TIMER_SCALE); timer_set_alarm_value(TIMER_GROUP_0, timer_idx, timer_interval_sec * TIMER_SCALE);
timer_enable_intr(TIMER_GROUP_0, timer_idx); timer_enable_intr(TIMER_GROUP_0, timer_idx);
timer_isr_register(TIMER_GROUP_0, timer_idx, timer_group0_isr, timer_isr_register(TIMER_GROUP_0, timer_idx, timer_group0_isr,
(void *) timer_idx, ESP_INTR_FLAG_IRAM, NULL); (void *) timer_idx, ESP_INTR_FLAG_IRAM, NULL);
timer_start(TIMER_GROUP_0, timer_idx); timer_start(TIMER_GROUP_0, timer_idx);

29
examples/system/sysview_tracing/main/sysview_tracing.c
View File

@ -107,32 +107,6 @@ static void example_timer_init(int timer_group, int timer_idx, uint32_t period)
timer_enable_intr(timer_group, timer_idx); timer_enable_intr(timer_group, timer_idx);
} }
static void example_timer_rearm(int timer_group, int timer_idx)
{
if (timer_group == 0) {
if (timer_idx == 0) {
TIMERG0.int_clr_timers.t0 = 1;
TIMERG0.hw_timer[0].update = 1;
TIMERG0.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG0.int_clr_timers.t1 = 1;
TIMERG0.hw_timer[1].update = 1;
TIMERG0.hw_timer[1].config.alarm_en = 1;
}
}
if (timer_group == 1) {
if (timer_idx == 0) {
TIMERG1.int_clr_timers.t0 = 1;
TIMERG1.hw_timer[0].update = 1;
TIMERG1.hw_timer[0].config.alarm_en = 1;
} else {
TIMERG1.int_clr_timers.t1 = 1;
TIMERG1.hw_timer[1].update = 1;
TIMERG1.hw_timer[1].config.alarm_en = 1;
}
}
}
static void example_timer_isr(void *arg) static void example_timer_isr(void *arg)
{ {
example_event_data_t *tim_arg = (example_event_data_t *)arg; example_event_data_t *tim_arg = (example_event_data_t *)arg;
@ -152,7 +126,8 @@ static void example_timer_isr(void *arg)
} }
} }
// re-start timer // re-start timer
example_timer_rearm(tim_arg->group, tim_arg->timer); timer_group_intr_clr_in_isr(tim_arg->group, tim_arg->timer);
timer_group_enable_alarm_in_isr(tim_arg->group, tim_arg->timer);
} }
static void example_task(void *p) static void example_task(void *p)