From ec898b771eb9c0c2991348198a8c86b5b69b4b46 Mon Sep 17 00:00:00 2001 From: morris Date: Fri, 2 Apr 2021 12:41:21 +0800 Subject: [PATCH] systimer: strip hal driver --- .../esp_timer/src/esp_timer_impl_systimer.c | 47 +++-- components/freertos/port/riscv/port.c | 29 +-- components/hal/CMakeLists.txt | 12 +- components/hal/component.mk | 2 +- .../hal/esp32c3/include/hal/systimer_ll.h | 135 +++++++------ components/hal/esp32c3/systimer_hal.c | 128 ------------ .../hal/esp32s2/include/hal/systimer_ll.h | 138 ++++++++----- components/hal/esp32s2/systimer_hal.c | 148 -------------- .../hal/esp32s3/include/hal/systimer_ll.h | 138 +++++++------ components/hal/esp32s3/systimer_hal.c | 123 ------------ components/hal/include/hal/systimer_hal.h | 125 ++++++------ components/hal/systimer_hal.c | 188 ++++++++++++++++++ 12 files changed, 541 insertions(+), 672 deletions(-) delete mode 100644 components/hal/esp32c3/systimer_hal.c delete mode 100644 components/hal/esp32s2/systimer_hal.c delete mode 100644 components/hal/esp32s3/systimer_hal.c create mode 100644 components/hal/systimer_hal.c diff --git a/components/esp_timer/src/esp_timer_impl_systimer.c b/components/esp_timer/src/esp_timer_impl_systimer.c index f67ea1a0a6..19c963110b 100644 --- a/components/esp_timer/src/esp_timer_impl_systimer.c +++ b/components/esp_timer/src/esp_timer_impl_systimer.c @@ -19,7 +19,10 @@ #include "esp_attr.h" #include "esp_intr_alloc.h" #include "esp_log.h" +#include "esp_compiler.h" #include "soc/periph_defs.h" +#include "soc/soc_caps.h" +#include "soc/rtc.h" #include "freertos/FreeRTOS.h" #include "hal/systimer_ll.h" #include "hal/systimer_types.h" @@ -46,6 +49,9 @@ static intr_handle_t s_timer_interrupt_handle; */ static intr_handler_t s_alarm_handler = NULL; +/* Systimer HAL layer object */ +static systimer_hal_context_t systimer_hal; + /* Spinlock used to protect access to the hardware registers. */ portMUX_TYPE s_time_update_lock = portMUX_INITIALIZER_UNLOCKED; @@ -61,15 +67,15 @@ void esp_timer_impl_unlock(void) uint64_t IRAM_ATTR esp_timer_impl_get_counter_reg(void) { - return systimer_hal_get_counter_value(SYSTIMER_COUNTER_0); + return systimer_hal_get_counter_value(&systimer_hal, SYSTIMER_LL_COUNTER_CLOCK); } int64_t IRAM_ATTR esp_timer_impl_get_time(void) { - if (s_alarm_handler == NULL) { + if (unlikely(s_alarm_handler == NULL)) { return 0; } - return systimer_hal_get_time(SYSTIMER_COUNTER_0); + return systimer_hal_get_time(&systimer_hal, SYSTIMER_LL_COUNTER_CLOCK); } int64_t esp_timer_get_time(void) __attribute__((alias("esp_timer_impl_get_time"))); @@ -81,7 +87,7 @@ void IRAM_ATTR esp_timer_impl_set_alarm_id(uint64_t timestamp, unsigned alarm_id timestamp_id[alarm_id] = timestamp; timestamp = MIN(timestamp_id[0], timestamp_id[1]); if (timestamp != UINT64_MAX) { - systimer_hal_set_alarm_target(SYSTIMER_ALARM_2, timestamp); + systimer_hal_set_alarm_target(&systimer_hal, SYSTIMER_LL_ALARM_CLOCK, timestamp); } portEXIT_CRITICAL_SAFE(&s_time_update_lock); } @@ -94,20 +100,22 @@ void IRAM_ATTR esp_timer_impl_set_alarm(uint64_t timestamp) static void IRAM_ATTR timer_alarm_isr(void *arg) { // clear the interrupt - systimer_ll_clear_alarm_int(SYSTIMER_ALARM_2); + systimer_ll_clear_alarm_int(systimer_hal.dev, SYSTIMER_LL_ALARM_CLOCK); /* Call the upper layer handler */ (*s_alarm_handler)(arg); } void IRAM_ATTR esp_timer_impl_update_apb_freq(uint32_t apb_ticks_per_us) { - systimer_hal_on_apb_freq_update(apb_ticks_per_us); +#if !SOC_SYSTIMER_FIXED_TICKS_US + systimer_hal_on_apb_freq_update(&systimer_hal, apb_ticks_per_us); +#endif } void esp_timer_impl_advance(int64_t time_us) { portENTER_CRITICAL_SAFE(&s_time_update_lock); - systimer_hal_counter_value_advance(SYSTIMER_COUNTER_0, time_us); + systimer_hal_counter_value_advance(&systimer_hal, SYSTIMER_LL_COUNTER_CLOCK, time_us); portEXIT_CRITICAL_SAFE(&s_time_update_lock); } @@ -129,16 +137,21 @@ esp_err_t esp_timer_impl_init(intr_handler_t alarm_handler) goto err_intr_alloc; } - systimer_hal_init(); - systimer_hal_enable_counter(SYSTIMER_COUNTER_0); - systimer_hal_select_alarm_mode(SYSTIMER_ALARM_2, SYSTIMER_ALARM_MODE_ONESHOT); - systimer_hal_connect_alarm_counter(SYSTIMER_ALARM_2, SYSTIMER_COUNTER_0); + systimer_hal_init(&systimer_hal); +#if !SOC_SYSTIMER_FIXED_TICKS_US + assert(rtc_clk_xtal_freq_get() == 40 && "update the step for xtal to support other XTAL:APB frequency ratios"); + systimer_hal_set_steps_per_tick(&systimer_hal, 0, 2); // for xtal + systimer_hal_set_steps_per_tick(&systimer_hal, 1, 1); // for pll +#endif + systimer_hal_enable_counter(&systimer_hal, SYSTIMER_LL_COUNTER_CLOCK); + systimer_hal_select_alarm_mode(&systimer_hal, SYSTIMER_LL_ALARM_CLOCK, SYSTIMER_ALARM_MODE_ONESHOT); + systimer_hal_connect_alarm_counter(&systimer_hal, SYSTIMER_LL_ALARM_CLOCK, SYSTIMER_LL_COUNTER_CLOCK); /* TODO: if SYSTIMER is used for anything else, access to SYSTIMER_INT_ENA_REG has to be * protected by a shared spinlock. Since this code runs as part of early startup, this * is practically not an issue. */ - systimer_hal_enable_alarm_int(SYSTIMER_ALARM_2); + systimer_hal_enable_alarm_int(&systimer_hal, SYSTIMER_LL_ALARM_CLOCK); err = esp_intr_enable(s_timer_interrupt_handle); if (err != ESP_OK) { @@ -148,9 +161,9 @@ esp_err_t esp_timer_impl_init(intr_handler_t alarm_handler) return ESP_OK; err_intr_en: - systimer_ll_disable_alarm(SYSTIMER_ALARM_2); + systimer_ll_enable_alarm(systimer_hal.dev, SYSTIMER_LL_ALARM_CLOCK, false); /* TODO: may need a spinlock, see the note related to SYSTIMER_INT_ENA_REG in systimer_hal_init */ - systimer_ll_disable_alarm_int(SYSTIMER_ALARM_2); + systimer_ll_enable_alarm_int(systimer_hal.dev, SYSTIMER_LL_ALARM_CLOCK, false); esp_intr_free(s_timer_interrupt_handle); err_intr_alloc: s_alarm_handler = NULL; @@ -160,9 +173,9 @@ err_intr_alloc: void esp_timer_impl_deinit(void) { esp_intr_disable(s_timer_interrupt_handle); - systimer_ll_disable_alarm(SYSTIMER_ALARM_2); + systimer_ll_enable_alarm(systimer_hal.dev, SYSTIMER_LL_ALARM_CLOCK, false); /* TODO: may need a spinlock, see the note related to SYSTIMER_INT_ENA_REG in systimer_hal_init */ - systimer_ll_disable_alarm_int(SYSTIMER_ALARM_2); + systimer_ll_enable_alarm_int(systimer_hal.dev, SYSTIMER_LL_ALARM_CLOCK, false); esp_intr_free(s_timer_interrupt_handle); s_timer_interrupt_handle = NULL; s_alarm_handler = NULL; @@ -176,7 +189,7 @@ uint64_t IRAM_ATTR esp_timer_impl_get_min_period_us(void) uint64_t esp_timer_impl_get_alarm_reg(void) { portENTER_CRITICAL_SAFE(&s_time_update_lock); - uint64_t val = systimer_hal_get_alarm_value(SYSTIMER_ALARM_2); + uint64_t val = systimer_hal_get_alarm_value(&systimer_hal, SYSTIMER_LL_ALARM_CLOCK); portEXIT_CRITICAL_SAFE(&s_time_update_lock); return val; } diff --git a/components/freertos/port/riscv/port.c b/components/freertos/port/riscv/port.c index 0ea7ce0d33..1af1eb8a82 100644 --- a/components/freertos/port/riscv/port.c +++ b/components/freertos/port/riscv/port.c @@ -147,17 +147,19 @@ void vPortExitCritical(void) */ void vPortSetupTimer(void) { + /* Systimer HAL layer object */ + static systimer_hal_context_t systimer_hal; /* set system timer interrupt vector */ - ESP_ERROR_CHECK(esp_intr_alloc(ETS_SYSTIMER_TARGET0_EDGE_INTR_SOURCE, ESP_INTR_FLAG_IRAM, vPortSysTickHandler, NULL, NULL)); + ESP_ERROR_CHECK(esp_intr_alloc(ETS_SYSTIMER_TARGET0_EDGE_INTR_SOURCE, ESP_INTR_FLAG_IRAM, vPortSysTickHandler, &systimer_hal, NULL)); /* configure the timer */ - systimer_hal_init(); - systimer_hal_connect_alarm_counter(SYSTIMER_ALARM_0, SYSTIMER_COUNTER_1); - systimer_hal_enable_counter(SYSTIMER_COUNTER_1); - systimer_hal_counter_can_stall_by_cpu(SYSTIMER_COUNTER_1, 0, true); - systimer_hal_set_alarm_period(SYSTIMER_ALARM_0, 1000000UL / CONFIG_FREERTOS_HZ); - systimer_hal_select_alarm_mode(SYSTIMER_ALARM_0, SYSTIMER_ALARM_MODE_PERIOD); - systimer_hal_enable_alarm_int(SYSTIMER_ALARM_0); + systimer_hal_init(&systimer_hal); + systimer_hal_connect_alarm_counter(&systimer_hal, SYSTIMER_LL_ALARM_OS_TICK_CORE0, SYSTIMER_LL_COUNTER_OS_TICK); + systimer_hal_enable_counter(&systimer_hal, SYSTIMER_LL_COUNTER_OS_TICK); + systimer_hal_counter_can_stall_by_cpu(&systimer_hal, SYSTIMER_LL_COUNTER_OS_TICK, 0, true); + systimer_hal_set_alarm_period(&systimer_hal, SYSTIMER_LL_ALARM_OS_TICK_CORE0, 1000000UL / CONFIG_FREERTOS_HZ); + systimer_hal_select_alarm_mode(&systimer_hal, SYSTIMER_LL_ALARM_OS_TICK_CORE0, SYSTIMER_ALARM_MODE_PERIOD); + systimer_hal_enable_alarm_int(&systimer_hal, SYSTIMER_LL_ALARM_OS_TICK_CORE0); } void prvTaskExitError(void) @@ -227,7 +229,7 @@ StackType_t *pxPortInitialiseStack(StackType_t *pxTopOfStack, TaskFunction_t pxC extern char _thread_local_start, _thread_local_end, _flash_rodata_start; /* Byte pointer, so that subsequent calculations don't depend on sizeof(StackType_t). */ - uint8_t* sp = (uint8_t*) pxTopOfStack; + uint8_t *sp = (uint8_t *) pxTopOfStack; /* Set up TLS area. * The following diagram illustrates the layout of link-time and run-time @@ -293,9 +295,9 @@ StackType_t *pxPortInitialiseStack(StackType_t *pxTopOfStack, TaskFunction_t pxC IRAM_ATTR void vPortSysTickHandler(void *arg) { - (void)arg; + systimer_hal_context_t *systimer_hal = (systimer_hal_context_t *)arg; - systimer_ll_clear_alarm_int(SYSTIMER_ALARM_0); + systimer_ll_clear_alarm_int(systimer_hal->dev, SYSTIMER_LL_ALARM_OS_TICK_CORE0); #ifdef CONFIG_PM_TRACE ESP_PM_TRACE_ENTER(TICK, xPortGetCoreID()); @@ -380,8 +382,9 @@ void vPortSetStackWatchpoint(void *pxStackStart) esp_cpu_set_watchpoint(STACK_WATCH_POINT_NUMBER, (char *)addr, STACK_WATCH_AREA_SIZE, ESP_WATCHPOINT_STORE); } -uint32_t xPortGetTickRateHz(void) { - return (uint32_t)configTICK_RATE_HZ; +uint32_t xPortGetTickRateHz(void) +{ + return (uint32_t)configTICK_RATE_HZ; } BaseType_t xPortInIsrContext(void) diff --git a/components/hal/CMakeLists.txt b/components/hal/CMakeLists.txt index e709ee1397..e9948d81bb 100644 --- a/components/hal/CMakeLists.txt +++ b/components/hal/CMakeLists.txt @@ -56,11 +56,11 @@ if(NOT BOOTLOADER_BUILD) "pcnt_hal.c" "spi_flash_hal_gpspi.c" "spi_slave_hd_hal.c" + "systimer_hal.c" "touch_sensor_hal.c" "esp32s2/adc_hal.c" "esp32s2/brownout_hal.c" "esp32s2/cp_dma_hal.c" - "esp32s2/systimer_hal.c" "esp32s2/touch_sensor_hal.c" "esp32s2/dac_hal.c" "esp32s2/interrupt_descriptor_table.c" @@ -75,10 +75,10 @@ if(NOT BOOTLOADER_BUILD) "pcnt_hal.c" "spi_flash_hal_gpspi.c" "spi_slave_hd_hal.c" + "systimer_hal.c" "touch_sensor_hal.c" "esp32s3/brownout_hal.c" "esp32s3/interrupt_descriptor_table.c" - "esp32s3/systimer_hal.c" "esp32s3/touch_sensor_hal.c") endif() @@ -86,12 +86,12 @@ if(NOT BOOTLOADER_BUILD) list(APPEND srcs "ds_hal.c" "gdma_hal.c" - "esp32c3/adc_hal.c" - "esp32c3/brownout_hal.c" - "esp32c3/systimer_hal.c" - "esp32c3/hmac_hal.c" "spi_flash_hal_gpspi.c" "spi_slave_hd_hal.c" + "systimer_hal.c" + "esp32c3/adc_hal.c" + "esp32c3/brownout_hal.c" + "esp32c3/hmac_hal.c" "esp32c3/rtc_cntl_hal.c") endif() endif() diff --git a/components/hal/component.mk b/components/hal/component.mk index da3d6456b9..7dbf48b048 100644 --- a/components/hal/component.mk +++ b/components/hal/component.mk @@ -2,7 +2,7 @@ COMPONENT_SRCDIRS := . esp32 COMPONENT_ADD_INCLUDEDIRS := esp32/include include COMPONENT_ADD_LDFRAGMENTS += linker.lf -COMPONENT_OBJEXCLUDE += ./spi_slave_hd_hal.o ./spi_flash_hal_gpspi.o ./spi_slave_hd_hal.o ./ds_hal.o ./gdma_hal.o ./lcd_hal.o +COMPONENT_OBJEXCLUDE += ./spi_slave_hd_hal.o ./spi_flash_hal_gpspi.o ./spi_slave_hd_hal.o ./ds_hal.o ./gdma_hal.o ./lcd_hal.o ./systimer_hal.o ifndef CONFIG_ETH_USE_ESP32_EMAC COMPONENT_OBJEXCLUDE += esp32/emac_hal.o diff --git a/components/hal/esp32c3/include/hal/systimer_ll.h b/components/hal/esp32c3/include/hal/systimer_ll.h index f0dab94c5f..e7d50778ab 100644 --- a/components/hal/esp32c3/include/hal/systimer_ll.h +++ b/components/hal/esp32c3/include/hal/systimer_ll.h @@ -13,139 +13,148 @@ // limitations under the License. #pragma once +#include +#include +#include +#include "soc/systimer_struct.h" + +#define SYSTIMER_LL_COUNTER_CLOCK (0) // Counter used for "wallclock" time +#define SYSTIMER_LL_COUNTER_OS_TICK (1) // Counter used for OS tick +#define SYSTIMER_LL_ALARM_OS_TICK_CORE0 (0) // Alarm used for OS tick of CPU core 0 +#define SYSTIMER_LL_ALARM_CLOCK (2) // Alarm used for "wallclock" time + #ifdef __cplusplus extern "C" { #endif -#include -#include -#include "soc/soc.h" -#include "soc/systimer_reg.h" - // All these functions get invoked either from ISR or HAL that linked to IRAM. // Always inline these functions even no gcc optimization is applied. -/*******************counter*************************/ +/******************* Clock *************************/ -__attribute__((always_inline)) static inline void systimer_ll_enable_clock(void) +__attribute__((always_inline)) static inline void systimer_ll_enable_clock(systimer_dev_t *dev, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, SYS_TIMER_CLK_EN); + dev->conf.clk_en = en; } -__attribute__((always_inline)) static inline void systimer_ll_enable_counter(uint32_t counter_id) -{ - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (30 - counter_id)); -} +/******************* Counter *************************/ -__attribute__((always_inline)) static inline void systimer_ll_counter_can_stall_by_cpu(uint32_t counter_id, uint32_t cpu_id, bool can) +__attribute__((always_inline)) static inline void systimer_ll_enable_counter(systimer_dev_t *dev, uint32_t counter_id, bool en) { - if (can) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << ((28 - counter_id * 2) - cpu_id)); + if (en) { + dev->conf.val |= 1 << (30 - counter_id); } else { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << ((28 - counter_id * 2) - cpu_id)); + dev->conf.val &= ~(1 << (30 - counter_id)); } } -__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_counter_can_stall_by_cpu(systimer_dev_t *dev, uint32_t counter_id, uint32_t cpu_id, bool can) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_UNIT0_OP_REG + 4 * counter_id, 1 << 30); + if (can) { + dev->conf.val |= 1 << ((28 - counter_id * 2) - cpu_id); + } else { + dev->conf.val &= ~(1 << ((28 - counter_id * 2) - cpu_id)); + } } -__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(systimer_dev_t *dev, uint32_t counter_id) { - return REG_GET_BIT(SYS_TIMER_SYSTIMER_UNIT0_OP_REG + 4 * counter_id, 1 << 29); + dev->unit_op[counter_id].timer_unit_update = 1; } -__attribute__((always_inline)) static inline void systimer_ll_set_counter_value(uint32_t counter_id, uint64_t value) +__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(systimer_dev_t *dev, uint32_t counter_id) { - REG_WRITE(SYS_TIMER_SYSTIMER_UNIT0_LOAD_LO_REG + 8 * counter_id, value & 0xFFFFFFFF); - REG_WRITE(SYS_TIMER_SYSTIMER_UNIT0_LOAD_HI_REG, (value >> 32) & 0xFFFFF); + return dev->unit_op[counter_id].timer_unit_value_valid; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_set_counter_value(systimer_dev_t *dev, uint32_t counter_id, uint64_t value) { - return REG_READ(SYS_TIMER_SYSTIMER_UNIT0_VALUE_LO_REG + 8 * counter_id); + dev->unit_load_val[counter_id].hi.timer_unit_load_hi = value >> 32; + dev->unit_load_val[counter_id].lo.timer_unit_load_lo = value & 0xFFFFFFFF; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(uint32_t counter_id) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(systimer_dev_t *dev, uint32_t counter_id) { - return REG_READ(SYS_TIMER_SYSTIMER_UNIT0_VALUE_HI_REG + 8 * counter_id); + return dev->unit_val[counter_id].lo.timer_unit_value_lo; } -__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(uint32_t counter_id) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(systimer_dev_t *dev, uint32_t counter_id) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_UNIT0_LOAD_REG + 4 * counter_id, SYS_TIMER_TIMER_UNIT0_LOAD); + return dev->unit_val[counter_id].hi.timer_unit_value_hi; } -/*******************alarm*************************/ - -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_target(uint32_t alarm_id, uint64_t value) +__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(systimer_dev_t *dev, uint32_t counter_id) { - REG_WRITE(SYS_TIMER_SYSTIMER_TARGET0_LO_REG + alarm_id * 8, value & 0xFFFFFFFF); - REG_WRITE(SYS_TIMER_SYSTIMER_TARGET0_HI_REG + alarm_id * 8, (value >> 32) & 0xFFFFF); + dev->unit_load[counter_id].val = 0x01; } -__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_target(uint32_t alarm_id) +/******************* Alarm *************************/ + +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_target(systimer_dev_t *dev, uint32_t alarm_id, uint64_t value) { - return ((uint64_t) REG_READ(SYS_TIMER_SYSTIMER_TARGET0_HI_REG + alarm_id * 8) << 32) \ - | REG_READ(SYS_TIMER_SYSTIMER_TARGET0_LO_REG + alarm_id * 8); + dev->target_val[alarm_id].hi.timer_target_hi = value >> 32; + dev->target_val[alarm_id].lo.timer_target_lo = value & 0xFFFFFFFF; } -__attribute__((always_inline)) static inline void systimer_ll_connect_alarm_counter(uint32_t alarm_id, uint32_t counter_id) +__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_target(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_FIELD(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + 4 * alarm_id, SYS_TIMER_TARGET0_TIMER_UNIT_SEL, counter_id); + return ((uint64_t)(dev->target_val[alarm_id].hi.timer_target_hi) << 32) | dev->target_val[alarm_id].lo.timer_target_lo; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_connect_alarm_counter(systimer_dev_t *dev, uint32_t alarm_id, uint32_t counter_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD_MODE); + dev->target_conf[alarm_id].target_timer_unit_sel = counter_id; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD_MODE); + dev->target_conf[alarm_id].target_period_mode = 0; } -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(uint32_t alarm_id, uint32_t period) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_FIELD(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD, period); + dev->target_conf[alarm_id].target_period_mode = 1; } -__attribute__((always_inline)) static inline void systimer_ll_apply_alarm_value(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(systimer_dev_t *dev, uint32_t alarm_id, uint32_t period) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_COMP0_LOAD_REG + alarm_id * 4, SYS_TIMER_TIMER_COMP0_LOAD); + assert(period < (1 << 26)); + dev->target_conf[alarm_id].target_period = period; } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_apply_alarm_value(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (24 - alarm_id)); + dev->comp_load[alarm_id].val = 0x01; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (24 - alarm_id)); + if (en) { + dev->conf.val |= 1 << (24 - alarm_id); + } else { + dev->conf.val &= ~(1 << (24 - alarm_id)); + } } -/*******************interrupt*************************/ +/******************* Interrupt *************************/ -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_INT_ENA_REG, 1 << alarm_id); + if (en) { + dev->int_ena.val |= 1 << alarm_id; + } else { + dev->int_ena.val &= ~(1 << alarm_id); + } } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_INT_ENA_REG, 1 << alarm_id); + return dev->int_st.val & (1 << alarm_id); } -__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(systimer_dev_t *dev, uint32_t alarm_id) { - return REG_GET_BIT(SYS_TIMER_SYSTIMER_INT_RAW_REG, 1 << alarm_id); -} - -__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(uint32_t alarm_id) -{ - REG_SET_BIT(SYS_TIMER_SYSTIMER_INT_CLR_REG, 1 << alarm_id); + dev->int_clr.val |= 1 << alarm_id; } #ifdef __cplusplus diff --git a/components/hal/esp32c3/systimer_hal.c b/components/hal/esp32c3/systimer_hal.c deleted file mode 100644 index c01ff909ac..0000000000 --- a/components/hal/esp32c3/systimer_hal.c +++ /dev/null @@ -1,128 +0,0 @@ -// Copyright 2020 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include -#include "hal/systimer_hal.h" -#include "hal/systimer_ll.h" -#include "hal/systimer_types.h" -#include "soc/systimer_caps.h" -#include "hal/clk_gate_ll.h" - -#define SYSTIMER_TICKS_PER_US (16) // Systimer clock source is fixed to 16MHz - -uint64_t systimer_hal_get_counter_value(systimer_counter_id_t counter_id) -{ - uint32_t lo, lo_start, hi; - /* Set the "update" bit and wait for acknowledgment */ - systimer_ll_counter_snapshot(counter_id); - while (!systimer_ll_is_counter_value_valid(counter_id)); - /* Read LO, HI, then LO again, check that LO returns the same value. - * This accounts for the case when an interrupt may happen between reading - * HI and LO values, and this function may get called from the ISR. - * In this case, the repeated read will return consistent values. - */ - lo_start = systimer_ll_get_counter_value_low(counter_id); - do { - lo = lo_start; - hi = systimer_ll_get_counter_value_high(counter_id); - lo_start = systimer_ll_get_counter_value_low(counter_id); - } while (lo_start != lo); - - systimer_counter_value_t result = { - .lo = lo, - .hi = hi - }; - - return result.val; -} - -uint64_t systimer_hal_get_time(systimer_counter_id_t counter_id) -{ - return systimer_hal_get_counter_value(counter_id) / SYSTIMER_TICKS_PER_US; -} - -void systimer_hal_set_alarm_target(systimer_alarm_id_t alarm_id, uint64_t target) -{ - systimer_counter_value_t alarm = { .val = target * SYSTIMER_TICKS_PER_US}; - systimer_ll_disable_alarm(alarm_id); - systimer_ll_set_alarm_target(alarm_id, alarm.val); - systimer_ll_apply_alarm_value(alarm_id); - systimer_ll_enable_alarm(alarm_id); -} - -void systimer_hal_set_alarm_period(systimer_alarm_id_t alarm_id, uint32_t period) -{ - systimer_ll_disable_alarm(alarm_id); - systimer_ll_set_alarm_period(alarm_id, period * SYSTIMER_TICKS_PER_US); - systimer_ll_apply_alarm_value(alarm_id); - systimer_ll_enable_alarm(alarm_id); -} - -uint64_t systimer_hal_get_alarm_value(systimer_alarm_id_t alarm_id) -{ - return systimer_ll_get_alarm_target(alarm_id); -} - -void systimer_hal_enable_alarm_int(systimer_alarm_id_t alarm_id) -{ - systimer_ll_enable_alarm_int(alarm_id); -} - -void systimer_hal_on_apb_freq_update(uint32_t apb_ticks_per_us) -{ - /* Nothing to do here, SYSTIMER clock is independent of APB clock */ - (void)apb_ticks_per_us; -} - -void systimer_hal_counter_value_advance(systimer_counter_id_t counter_id, int64_t time_us) -{ - systimer_counter_value_t new_count = { .val = systimer_hal_get_counter_value(counter_id) + time_us * SYSTIMER_TICKS_PER_US }; - systimer_ll_set_counter_value(counter_id, new_count.val); - systimer_ll_apply_counter_value(counter_id); -} - -void systimer_hal_enable_counter(systimer_counter_id_t counter_id) -{ - systimer_ll_enable_counter(counter_id); -} - -void systimer_hal_init(void) -{ - periph_ll_enable_clk_clear_rst(PERIPH_SYSTIMER_MODULE); - systimer_ll_enable_clock(); -} - -void systimer_hal_select_alarm_mode(systimer_alarm_id_t alarm_id, systimer_alarm_mode_t mode) -{ - switch (mode) { - case SYSTIMER_ALARM_MODE_ONESHOT: - systimer_ll_enable_alarm_oneshot(alarm_id); - break; - case SYSTIMER_ALARM_MODE_PERIOD: - systimer_ll_enable_alarm_period(alarm_id); - break; - default: - break; - } -} - -void systimer_hal_connect_alarm_counter(systimer_alarm_id_t alarm_id, systimer_counter_id_t counter_id) -{ - systimer_ll_connect_alarm_counter(alarm_id, counter_id); -} - -void systimer_hal_counter_can_stall_by_cpu(uint32_t counter_id, uint32_t cpu_id, bool can) -{ - systimer_ll_counter_can_stall_by_cpu(counter_id, cpu_id, can); -} diff --git a/components/hal/esp32s2/include/hal/systimer_ll.h b/components/hal/esp32s2/include/hal/systimer_ll.h index 752ad2dd24..388f00580f 100644 --- a/components/hal/esp32s2/include/hal/systimer_ll.h +++ b/components/hal/esp32s2/include/hal/systimer_ll.h @@ -1,4 +1,4 @@ -// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// Copyright 2020-2021 Espressif Systems (Shanghai) PTE LTD // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,124 +13,156 @@ // limitations under the License. #pragma once +#include +#include +#include +#include "soc/systimer_struct.h" + +#define SYSTIMER_LL_COUNTER_CLOCK (0) // Counter used for "wallclock" time +#define SYSTIMER_LL_ALARM_CLOCK (2) // Alarm used for "wallclock" time + #ifdef __cplusplus extern "C" { #endif -#include -#include -#include "soc/soc.h" -#include "soc/systimer_reg.h" - // All these functions get invoked either from ISR or HAL that linked to IRAM. // Always inline these functions even no gcc optimization is applied. -/*******************counter*************************/ +/******************* Clock *************************/ -__attribute__((always_inline)) static inline void systimer_ll_enable_clock(void) +__attribute__((always_inline)) static inline void systimer_ll_enable_clock(systimer_dev_t *dev, bool en) { - REG_SET_BIT(SYSTIMER_CONF_REG, SYSTIMER_CLK_EN); + dev->conf.clk_en = en; } -__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(void) +/******************* Counter *************************/ + +__attribute__((always_inline)) static inline void systimer_ll_enable_counter(systimer_dev_t *dev, uint32_t counter_id, bool en) { - REG_SET_BIT(SYSTIMER_LOAD_REG, SYSTIMER_TIMER_LOAD); + // ESP32-S2 only has one counter in systimer group + (void)dev; + (void)counter_id; } -__attribute__((always_inline)) static inline void systimer_ll_load_counter_value(uint64_t value) +__attribute__((always_inline)) static inline void systimer_ll_counter_can_stall_by_cpu(systimer_dev_t *dev, uint32_t counter_id, uint32_t cpu_id, bool can) { - REG_WRITE(SYSTIMER_LOAD_LO_REG, value & 0xFFFFFFFF); - REG_WRITE(SYSTIMER_LOAD_HI_REG, (value & 0xFFFFFFFF00000000) >> 32); + (void)dev; + (void)counter_id; + (void)cpu_id; + (void)can; } -__attribute__((always_inline)) static inline void systimer_ll_set_step_for_pll(uint32_t step) +__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(systimer_dev_t *dev, uint32_t counter_id) { - REG_SET_FIELD(SYSTIMER_STEP_REG, SYSTIMER_TIMER_PLL_STEP, step); + (void)counter_id; + dev->update.timer_update = 1; } -__attribute__((always_inline)) static inline void systimer_ll_set_step_for_xtal(uint32_t step) +__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(systimer_dev_t *dev, uint32_t counter_id) { - REG_SET_FIELD(SYSTIMER_STEP_REG, SYSTIMER_TIMER_XTAL_STEP, step); + (void)counter_id; + return dev->update.timer_value_valid; } -__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(void) +__attribute__((always_inline)) static inline void systimer_ll_set_counter_value(systimer_dev_t *dev, uint32_t counter_id, uint64_t value) { - REG_WRITE(SYSTIMER_UPDATE_REG, SYSTIMER_TIMER_UPDATE); + (void)counter_id; + dev->load_hi.timer_load_hi = value >> 32; + dev->load_lo.timer_load_lo = value; } -__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(void) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(systimer_dev_t *dev, uint32_t counter_id) { - return REG_GET_BIT(SYSTIMER_UPDATE_REG, SYSTIMER_TIMER_VALUE_VALID); + return dev->value_lo.timer_value_lo; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(void) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(systimer_dev_t *dev, uint32_t counter_id) { - return REG_READ(SYSTIMER_VALUE_LO_REG); + return dev->value_hi.timer_value_hi; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(void) +__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(systimer_dev_t *dev, uint32_t counter_id) { - return REG_READ(SYSTIMER_VALUE_HI_REG); + dev->load.timer_load = 1; } -/*******************alarm*************************/ - -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_value(uint32_t alarm_id, uint64_t value) +__attribute__((always_inline)) static inline void systimer_ll_set_step_for_pll(systimer_dev_t *dev, uint32_t step) { - REG_WRITE(SYSTIMER_TARGET0_LO_REG + alarm_id * 8, value & 0xFFFFFFFF); - REG_WRITE(SYSTIMER_TARGET0_HI_REG + alarm_id * 8, (value & 0xFFFFFFFF00000000) >> 32); + dev->step.timer_pll_step = step; } -__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_value(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_set_step_for_xtal(systimer_dev_t *dev, uint32_t step) { - return (uint64_t)REG_READ(SYSTIMER_TARGET0_HI_REG + alarm_id * 8) << 32 | REG_READ(SYSTIMER_TARGET0_LO_REG + alarm_id * 8); + dev->step.timer_xtal_step = step; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(uint32_t alarm_id) +/******************* Alarm *************************/ + +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_target(systimer_dev_t *dev, uint32_t alarm_id, uint64_t value) { - REG_SET_BIT(SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, BIT(31)); + dev->target_val[alarm_id].hi.timer_target_hi = value >> 32; + dev->target_val[alarm_id].lo.timer_target_lo = value; } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm(uint32_t alarm_id) +__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_target(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, BIT(31)); + return ((uint64_t)(dev->target_val[alarm_id].hi.timer_target_hi) << 32) | dev->target_val[alarm_id].lo.timer_target_lo; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_connect_alarm_counter(systimer_dev_t *dev, uint32_t alarm_id, uint32_t counter_id) { - REG_CLR_BIT(SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, BIT(30)); + // On esp32-s2, counter int the systimer is fixed connectred to other three alarm comparators + (void)dev; + (void)alarm_id; + (void)counter_id; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_BIT(SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, BIT(30)); + dev->target_conf[alarm_id].target_period_mode = 0; } -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(uint32_t alarm_id, uint32_t period) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_FIELD(SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYSTIMER_TARGET0_PERIOD, period); + dev->target_conf[alarm_id].target_period_mode = 1; } -/*******************interrupt*************************/ - -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(systimer_dev_t *dev, uint32_t alarm_id, uint32_t period) { - REG_SET_BIT(SYSTIMER_INT_ENA_REG, 1 << alarm_id); + assert(period < (1 << 30)); + dev->target_conf[alarm_id].target_period = period; } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_apply_alarm_value(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYSTIMER_INT_ENA_REG, 1 << alarm_id); + (void)dev; + (void)alarm_id; } -__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - return REG_GET_BIT(SYSTIMER_INT_RAW_REG, 1 << alarm_id); + dev->target_conf[alarm_id].target_work_en = en; } -__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(uint32_t alarm_id) +/******************* Interrupt *************************/ + +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - REG_SET_BIT(SYSTIMER_INT_CLR_REG, 1 << alarm_id); + if (en) { + dev->int_ena.val |= 1 << alarm_id; + } else { + dev->int_ena.val &= ~(1 << alarm_id); + } +} + +__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(systimer_dev_t *dev, uint32_t alarm_id) +{ + return dev->int_raw.val & (1 << alarm_id); +} + +__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(systimer_dev_t *dev, uint32_t alarm_id) +{ + dev->int_clr.val |= 1 << alarm_id; } #ifdef __cplusplus diff --git a/components/hal/esp32s2/systimer_hal.c b/components/hal/esp32s2/systimer_hal.c deleted file mode 100644 index 9124c32814..0000000000 --- a/components/hal/esp32s2/systimer_hal.c +++ /dev/null @@ -1,148 +0,0 @@ -// Copyright 2020 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include -#include -#include "soc/soc_caps.h" -#include "hal/systimer_hal.h" -#include "hal/systimer_ll.h" -#include "hal/systimer_types.h" -#include "soc/rtc.h" - -#define SYSTIMER_TICKS_PER_US (80) // Number of timer ticks per microsecond - -uint64_t systimer_hal_get_counter_value(systimer_counter_id_t counter_id) -{ - uint32_t lo, lo_start, hi; - /* Set the "update" bit and wait for acknowledgment */ - systimer_ll_counter_snapshot(); - while (!systimer_ll_is_counter_value_valid()); - /* Read LO, HI, then LO again, check that LO returns the same value. - * This accounts for the case when an interrupt may happen between reading - * HI and LO values, and this function may get called from the ISR. - * In this case, the repeated read will return consistent values. - */ - lo_start = systimer_ll_get_counter_value_low(); - do { - lo = lo_start; - hi = systimer_ll_get_counter_value_high(); - lo_start = systimer_ll_get_counter_value_low(); - } while (lo_start != lo); - - systimer_counter_value_t result = { - .lo = lo, - .hi = hi - }; - - return result.val; -} - -uint64_t systimer_hal_get_time(systimer_counter_id_t counter_id) -{ - return systimer_hal_get_counter_value(counter_id) / SYSTIMER_TICKS_PER_US; -} - -void systimer_hal_set_alarm_target(systimer_alarm_id_t alarm_id, uint64_t timestamp) -{ - int64_t offset = SYSTIMER_TICKS_PER_US * 2; - uint64_t now_time = systimer_hal_get_counter_value(SYSTIMER_COUNTER_0); - systimer_counter_value_t alarm = { .val = MAX(timestamp * SYSTIMER_TICKS_PER_US, now_time + offset) }; - do { - systimer_ll_disable_alarm(alarm_id); - systimer_ll_set_alarm_value(alarm_id, alarm.val); - systimer_ll_enable_alarm(alarm_id); - now_time = systimer_hal_get_counter_value(SYSTIMER_COUNTER_0); - int64_t delta = (int64_t)alarm.val - (int64_t)now_time; - if (delta <= 0 && !systimer_ll_is_alarm_int_fired(alarm_id)) { - // new alarm is less than the counter and the interrupt flag is not set - offset += -1 * delta + SYSTIMER_TICKS_PER_US * 2; - alarm.val = now_time + offset; - } else { - // finish if either (alarm > counter) or the interrupt flag is already set. - break; - } - } while (1); -} - -uint64_t systimer_hal_get_alarm_value(systimer_alarm_id_t alarm_id) -{ - return systimer_ll_get_alarm_value(alarm_id); -} - -void systimer_hal_enable_alarm_int(systimer_alarm_id_t alarm_id) -{ - systimer_ll_enable_alarm_int(alarm_id); -} - -void systimer_hal_on_apb_freq_update(uint32_t apb_ticks_per_us) -{ - /* If this function was called when switching APB clock to PLL, don't need - * do anything: the SYSTIMER_TIMER_PLL_STEP is already correct. - * If this was called when switching APB clock to XTAL, need to adjust - * XTAL_STEP value accordingly. - */ - if (apb_ticks_per_us != SYSTIMER_TICKS_PER_US) { - assert((SYSTIMER_TICKS_PER_US % apb_ticks_per_us) == 0 && "TICK_PER_US should be divisible by APB frequency (in MHz)"); - systimer_ll_set_step_for_xtal(SYSTIMER_TICKS_PER_US / apb_ticks_per_us); - } -} - -void systimer_hal_counter_value_advance(systimer_counter_id_t counter_id, int64_t time_us) -{ - systimer_counter_value_t new_count = { .val = systimer_hal_get_counter_value(counter_id) + time_us * SYSTIMER_TICKS_PER_US }; - systimer_ll_load_counter_value(new_count.val); - systimer_ll_apply_counter_value(); -} - -void systimer_hal_enable_counter(systimer_counter_id_t counter_id) -{ - (void)counter_id; -} - -void systimer_hal_init(void) -{ - assert(rtc_clk_xtal_freq_get() == 40 && "update the step for xtal to support other XTAL:APB frequency ratios"); - systimer_ll_enable_clock(); - /* Configure the counter: - * - increment by 1 when running from PLL (80 ticks per microsecond), - * - increment by 2 when running from XTAL (40 ticks per microsecond). - * Note that if the APB frequency is derived from XTAL with divider != 1, - * XTAL_STEP needs to be adjusted accordingly. For example, if - * the APB frequency is XTAL/4 = 10 MHz, then XTAL_STEP should be set to 8. - * This is handled in systimer_hal_on_apb_freq_update function. - */ - systimer_ll_set_step_for_pll(1); - systimer_ll_set_step_for_xtal(2); -} - -void systimer_hal_select_alarm_mode(systimer_alarm_id_t alarm_id, systimer_alarm_mode_t mode) -{ - switch (mode) { - case SYSTIMER_ALARM_MODE_ONESHOT: - systimer_ll_enable_alarm_oneshot(alarm_id); - break; - case SYSTIMER_ALARM_MODE_PERIOD: - systimer_ll_enable_alarm_period(alarm_id); - break; - default: - break; - } -} - -void systimer_hal_connect_alarm_counter(systimer_alarm_id_t alarm_id, systimer_counter_id_t counter_id) -{ - // esp32s2 only has one counter, so there's no need to connect alarm unit to counter - (void)alarm_id; - (void)counter_id; -} diff --git a/components/hal/esp32s3/include/hal/systimer_ll.h b/components/hal/esp32s3/include/hal/systimer_ll.h index a277771bb3..ba07f4658b 100644 --- a/components/hal/esp32s3/include/hal/systimer_ll.h +++ b/components/hal/esp32s3/include/hal/systimer_ll.h @@ -1,4 +1,4 @@ -// Copyright 2020 Espressif Systems (Shanghai) PTE LTD +// Copyright 2021 Espressif Systems (Shanghai) PTE LTD // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,139 +13,149 @@ // limitations under the License. #pragma once +#include +#include +#include +#include "soc/systimer_struct.h" + +#define SYSTIMER_LL_COUNTER_CLOCK (0) // Counter used for "wallclock" time +#define SYSTIMER_LL_COUNTER_OS_TICK (1) // Counter used for OS tick +#define SYSTIMER_LL_ALARM_OS_TICK_CORE0 (0) // Alarm used for OS tick of CPU core 0 +#define SYSTIMER_LL_ALARM_OS_TICK_CORE1 (1) // Alarm used for OS tick of CPU core 1 +#define SYSTIMER_LL_ALARM_CLOCK (2) // Alarm used for "wallclock" time + #ifdef __cplusplus extern "C" { #endif -#include -#include -#include "soc/soc.h" -#include "soc/sys_timer_reg.h" - // All these functions get invoked either from ISR or HAL that linked to IRAM. // Always inline these functions even no gcc optimization is applied. -/*******************counter*************************/ +/******************* Clock *************************/ -__attribute__((always_inline)) static inline void systimer_ll_enable_clock(void) +__attribute__((always_inline)) static inline void systimer_ll_enable_clock(systimer_dev_t *dev, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, SYS_TIMER_CLK_EN); + dev->conf.clk_en = en; } -__attribute__((always_inline)) static inline void systimer_ll_enable_counter(uint32_t counter_id) -{ - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (30 - counter_id)); -} +/******************* Counter *************************/ -__attribute__((always_inline)) static inline void systimer_ll_counter_can_stall_by_cpu(uint32_t counter_id, uint32_t cpu_id, bool can) +__attribute__((always_inline)) static inline void systimer_ll_enable_counter(systimer_dev_t *dev, uint32_t counter_id, bool en) { - if (can) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << ((28 - counter_id * 2) - cpu_id)); + if (en) { + dev->conf.val |= 1 << (30 - counter_id); } else { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << ((28 - counter_id * 2) - cpu_id)); + dev->conf.val &= ~(1 << (30 - counter_id)); } } -__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_counter_can_stall_by_cpu(systimer_dev_t *dev, uint32_t counter_id, uint32_t cpu_id, bool can) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_UNIT0_OP_REG + 4 * counter_id, 1 << 30); + if (can) { + dev->conf.val |= 1 << ((28 - counter_id * 2) - cpu_id); + } else { + dev->conf.val &= ~(1 << ((28 - counter_id * 2) - cpu_id)); + } } -__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_counter_snapshot(systimer_dev_t *dev, uint32_t counter_id) { - return REG_GET_BIT(SYS_TIMER_SYSTIMER_UNIT0_OP_REG + 4 * counter_id, 1 << 29); + dev->unit_op[counter_id].timer_unit_update = 1; } -__attribute__((always_inline)) static inline void systimer_ll_set_counter_value(uint32_t counter_id, uint64_t value) +__attribute__((always_inline)) static inline bool systimer_ll_is_counter_value_valid(systimer_dev_t *dev, uint32_t counter_id) { - REG_WRITE(SYS_TIMER_SYSTIMER_UNIT0_LOAD_LO_REG + 8 * counter_id, value & 0xFFFFFFFF); - REG_WRITE(SYS_TIMER_SYSTIMER_UNIT0_LOAD_HI_REG, (value >> 32) & 0xFFFFF); + return dev->unit_op[counter_id].timer_unit_value_valid; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(uint32_t counter_id) +__attribute__((always_inline)) static inline void systimer_ll_set_counter_value(systimer_dev_t *dev, uint32_t counter_id, uint64_t value) { - return REG_READ(SYS_TIMER_SYSTIMER_UNIT0_VALUE_LO_REG + 8 * counter_id); + dev->unit_load_val[counter_id].hi.timer_unit_load_hi = value >> 32; + dev->unit_load_val[counter_id].lo.timer_unit_load_lo = value & 0xFFFFFFFF; } -__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(uint32_t counter_id) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_low(systimer_dev_t *dev, uint32_t counter_id) { - return REG_READ(SYS_TIMER_SYSTIMER_UNIT0_VALUE_HI_REG + 8 * counter_id); + return dev->unit_val[counter_id].lo.timer_unit_value_lo; } -__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(uint32_t counter_id) +__attribute__((always_inline)) static inline uint32_t systimer_ll_get_counter_value_high(systimer_dev_t *dev, uint32_t counter_id) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_UNIT0_LOAD_REG + 4 * counter_id, SYS_TIMER_TIMER_UNIT0_LOAD); + return dev->unit_val[counter_id].hi.timer_unit_value_hi; } -/*******************alarm*************************/ - -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_target(uint32_t alarm_id, uint64_t value) +__attribute__((always_inline)) static inline void systimer_ll_apply_counter_value(systimer_dev_t *dev, uint32_t counter_id) { - REG_WRITE(SYS_TIMER_SYSTIMER_TARGET0_LO_REG + alarm_id * 8, value & 0xFFFFFFFF); - REG_WRITE(SYS_TIMER_SYSTIMER_TARGET0_HI_REG + alarm_id * 8, (value >> 32) & 0xFFFFF); + dev->unit_load[counter_id].val = 0x01; } -__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_target(uint32_t alarm_id) +/******************* Alarm *************************/ + +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_target(systimer_dev_t *dev, uint32_t alarm_id, uint64_t value) { - return ((uint64_t) REG_READ(SYS_TIMER_SYSTIMER_TARGET0_HI_REG + alarm_id * 8) << 32) \ - | REG_READ(SYS_TIMER_SYSTIMER_TARGET0_LO_REG + alarm_id * 8); + dev->target_val[alarm_id].hi.timer_target_hi = value >> 32; + dev->target_val[alarm_id].lo.timer_target_lo = value & 0xFFFFFFFF; } -__attribute__((always_inline)) static inline void systimer_ll_connect_alarm_counter(uint32_t alarm_id, uint32_t counter_id) +__attribute__((always_inline)) static inline uint64_t systimer_ll_get_alarm_target(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_FIELD(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + 4 * alarm_id, SYS_TIMER_TARGET0_TIMER_UNIT_SEL, counter_id); + return ((uint64_t)(dev->target_val[alarm_id].hi.timer_target_hi) << 32) | dev->target_val[alarm_id].lo.timer_target_lo; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_connect_alarm_counter(systimer_dev_t *dev, uint32_t alarm_id, uint32_t counter_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD_MODE); + dev->target_conf[alarm_id].target_timer_unit_sel = counter_id; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_oneshot(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD_MODE); + dev->target_conf[alarm_id].target_period_mode = 0; } -__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(uint32_t alarm_id, uint32_t period) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_period(systimer_dev_t *dev, uint32_t alarm_id) { - REG_SET_FIELD(SYS_TIMER_SYSTIMER_TARGET0_CONF_REG + alarm_id * 4, SYS_TIMER_TARGET0_PERIOD, period); + dev->target_conf[alarm_id].target_period_mode = 1; } -__attribute__((always_inline)) static inline void systimer_ll_apply_alarm_value(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_set_alarm_period(systimer_dev_t *dev, uint32_t alarm_id, uint32_t period) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_COMP0_LOAD_REG + alarm_id * 4, SYS_TIMER_TIMER_COMP0_LOAD); + assert(period < (1 << 26)); + dev->target_conf[alarm_id].target_period = period; } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_apply_alarm_value(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (24 - alarm_id)); + dev->comp_load[alarm_id].val = 0x01; } -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_CONF_REG, 1 << (24 - alarm_id)); + if (en) { + dev->conf.val |= 1 << (24 - alarm_id); + } else { + dev->conf.val &= ~(1 << (24 - alarm_id)); + } } -/*******************interrupt*************************/ +/******************* Interrupt *************************/ -__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_enable_alarm_int(systimer_dev_t *dev, uint32_t alarm_id, bool en) { - REG_SET_BIT(SYS_TIMER_SYSTIMER_INT_ENA_REG, 1 << alarm_id); + if (en) { + dev->int_ena.val |= 1 << alarm_id; + } else { + dev->int_ena.val &= ~(1 << alarm_id); + } } -__attribute__((always_inline)) static inline void systimer_ll_disable_alarm_int(uint32_t alarm_id) +__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(systimer_dev_t *dev, uint32_t alarm_id) { - REG_CLR_BIT(SYS_TIMER_SYSTIMER_INT_ENA_REG, 1 << alarm_id); + return dev->int_st.val & (1 << alarm_id); } -__attribute__((always_inline)) static inline bool systimer_ll_is_alarm_int_fired(uint32_t alarm_id) +__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(systimer_dev_t *dev, uint32_t alarm_id) { - return REG_GET_BIT(SYS_TIMER_SYSTIMER_INT_RAW_REG, 1 << alarm_id); -} - -__attribute__((always_inline)) static inline void systimer_ll_clear_alarm_int(uint32_t alarm_id) -{ - REG_SET_BIT(SYS_TIMER_SYSTIMER_INT_CLR_REG, 1 << alarm_id); + dev->int_clr.val |= 1 << alarm_id; } #ifdef __cplusplus diff --git a/components/hal/esp32s3/systimer_hal.c b/components/hal/esp32s3/systimer_hal.c deleted file mode 100644 index 1ac1696052..0000000000 --- a/components/hal/esp32s3/systimer_hal.c +++ /dev/null @@ -1,123 +0,0 @@ -// Copyright 2020 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include -#include "soc/soc_caps.h" -#include "hal/systimer_hal.h" -#include "hal/systimer_ll.h" -#include "hal/systimer_types.h" -#include "hal/clk_gate_ll.h" - -#define SYSTIMER_TICKS_PER_US (16) // Systimer clock source is fixed to 16MHz - -uint64_t systimer_hal_get_counter_value(systimer_counter_id_t counter_id) -{ - uint32_t lo, lo_start, hi; - /* Set the "update" bit and wait for acknowledgment */ - systimer_ll_counter_snapshot(counter_id); - while (!systimer_ll_is_counter_value_valid(counter_id)); - /* Read LO, HI, then LO again, check that LO returns the same value. - * This accounts for the case when an interrupt may happen between reading - * HI and LO values, and this function may get called from the ISR. - * In this case, the repeated read will return consistent values. - */ - lo_start = systimer_ll_get_counter_value_low(counter_id); - do { - lo = lo_start; - hi = systimer_ll_get_counter_value_high(counter_id); - lo_start = systimer_ll_get_counter_value_low(counter_id); - } while (lo_start != lo); - - systimer_counter_value_t result = { - .lo = lo, - .hi = hi - }; - - return result.val; -} - -uint64_t systimer_hal_get_time(systimer_counter_id_t counter_id) -{ - return systimer_hal_get_counter_value(counter_id) / SYSTIMER_TICKS_PER_US; -} - -void systimer_hal_set_alarm_target(systimer_alarm_id_t alarm_id, uint64_t target) -{ - systimer_counter_value_t alarm = { .val = target * SYSTIMER_TICKS_PER_US}; - systimer_ll_disable_alarm(alarm_id); - systimer_ll_set_alarm_target(alarm_id, alarm.val); - systimer_ll_apply_alarm_value(alarm_id); - systimer_ll_enable_alarm(alarm_id); -} - -void systimer_hal_set_alarm_period(systimer_alarm_id_t alarm_id, uint32_t period) -{ - systimer_ll_disable_alarm(alarm_id); - systimer_ll_set_alarm_period(alarm_id, period * SYSTIMER_TICKS_PER_US); - systimer_ll_apply_alarm_value(alarm_id); - systimer_ll_enable_alarm(alarm_id); -} - -uint64_t systimer_hal_get_alarm_value(systimer_alarm_id_t alarm_id) -{ - return systimer_ll_get_alarm_target(alarm_id); -} - -void systimer_hal_enable_alarm_int(systimer_alarm_id_t alarm_id) -{ - systimer_ll_enable_alarm_int(alarm_id); -} - -void systimer_hal_on_apb_freq_update(uint32_t apb_ticks_per_us) -{ - /* Nothing to do here, SYSTIMER clock is independent of APB clock */ - (void)apb_ticks_per_us; -} - -void systimer_hal_counter_value_advance(systimer_counter_id_t counter_id, int64_t time_us) -{ - systimer_counter_value_t new_count = { .val = systimer_hal_get_counter_value(counter_id) + time_us * SYSTIMER_TICKS_PER_US }; - systimer_ll_set_counter_value(counter_id, new_count.val); - systimer_ll_apply_counter_value(counter_id); -} - -void systimer_hal_enable_counter(systimer_counter_id_t counter_id) -{ - systimer_ll_enable_counter(counter_id); -} - -void systimer_hal_init(void) -{ - periph_ll_enable_clk_clear_rst(PERIPH_SYSTIMER_MODULE); - systimer_ll_enable_clock(); -} - -void systimer_hal_select_alarm_mode(systimer_alarm_id_t alarm_id, systimer_alarm_mode_t mode) -{ - switch (mode) { - case SYSTIMER_ALARM_MODE_ONESHOT: - systimer_ll_enable_alarm_oneshot(alarm_id); - break; - case SYSTIMER_ALARM_MODE_PERIOD: - systimer_ll_enable_alarm_period(alarm_id); - break; - default: - break; - } -} - -void systimer_hal_connect_alarm_counter(systimer_alarm_id_t alarm_id, systimer_counter_id_t counter_id) -{ - systimer_ll_connect_alarm_counter(alarm_id, counter_id); -} diff --git a/components/hal/include/hal/systimer_hal.h b/components/hal/include/hal/systimer_hal.h index 1f4eb5c488..9ac3262fa8 100644 --- a/components/hal/include/hal/systimer_hal.h +++ b/components/hal/include/hal/systimer_hal.h @@ -14,78 +14,91 @@ #pragma once +#include +#include +#include "soc/soc_caps.h" +#include "soc/systimer_struct.h" +#include "hal/systimer_types.h" + #ifdef __cplusplus extern "C" { #endif -#include -#include -#include "hal/systimer_types.h" - -/** - * @brief enable systimer counter - */ -void systimer_hal_enable_counter(systimer_counter_id_t counter_id); - -/** - * @brief get current counter value - */ -uint64_t systimer_hal_get_counter_value(systimer_counter_id_t counter_id); - -/** - * @brief get current time (in microseconds) - */ -uint64_t systimer_hal_get_time(systimer_counter_id_t counter_id); - -/* - * @brief set alarm target value (used in one-shot mode) - */ -void systimer_hal_set_alarm_target(systimer_alarm_id_t alarm_id, uint64_t target); - -/** - * @brief set alarm period value (used in period mode) - */ -void systimer_hal_set_alarm_period(systimer_alarm_id_t alarm_id, uint32_t period); - -/** - * @brief get alarm time - */ -uint64_t systimer_hal_get_alarm_value(systimer_alarm_id_t alarm_id); - -/** - * @brief enable alarm interrupt - */ -void systimer_hal_enable_alarm_int(systimer_alarm_id_t alarm_id); - -/** - * @brief select alarm mode - */ -void systimer_hal_select_alarm_mode(systimer_alarm_id_t alarm_id, systimer_alarm_mode_t mode); - -/** - * @brief update systimer step when apb clock gets changed - */ -void systimer_hal_on_apb_freq_update(uint32_t apb_ticks_per_us); - -/** - * @brief move systimer counter value forward or backward - */ -void systimer_hal_counter_value_advance(systimer_counter_id_t counter_id, int64_t time_us); +typedef struct { + systimer_dev_t *dev; +} systimer_hal_context_t; /** * @brief initialize systimer in HAL layer */ -void systimer_hal_init(void); +void systimer_hal_init(systimer_hal_context_t *hal); + +/** + * @brief enable systimer counter + */ +void systimer_hal_enable_counter(systimer_hal_context_t *hal, uint32_t counter_id); + +/** + * @brief get current counter value + */ +uint64_t systimer_hal_get_counter_value(systimer_hal_context_t *hal, uint32_t counter_id); + +/** + * @brief get current time (in microseconds) + */ +uint64_t systimer_hal_get_time(systimer_hal_context_t *hal, uint32_t counter_id); + +/* + * @brief set alarm target value (used in one-shot mode) + */ +void systimer_hal_set_alarm_target(systimer_hal_context_t *hal, uint32_t alarm_id, uint64_t target); + +/** + * @brief set alarm period value (used in period mode) + */ +void systimer_hal_set_alarm_period(systimer_hal_context_t *hal, uint32_t alarm_id, uint32_t period); + +/** + * @brief get alarm time + */ +uint64_t systimer_hal_get_alarm_value(systimer_hal_context_t *hal, uint32_t alarm_id); + +/** + * @brief enable alarm interrupt + */ +void systimer_hal_enable_alarm_int(systimer_hal_context_t *hal, uint32_t alarm_id); + +/** + * @brief select alarm mode + */ +void systimer_hal_select_alarm_mode(systimer_hal_context_t *hal, uint32_t alarm_id, systimer_alarm_mode_t mode); + +/** + * @brief update systimer step when apb clock gets changed + */ +void systimer_hal_on_apb_freq_update(systimer_hal_context_t *hal, uint32_t apb_ticks_per_us); + +/** + * @brief move systimer counter value forward or backward + */ +void systimer_hal_counter_value_advance(systimer_hal_context_t *hal, uint32_t counter_id, int64_t time_us); /** * @brief connect alarm unit to selected counter */ -void systimer_hal_connect_alarm_counter(systimer_alarm_id_t alarm_id, systimer_counter_id_t counter_id); +void systimer_hal_connect_alarm_counter(systimer_hal_context_t *hal, uint32_t alarm_id, uint32_t counter_id); /** * @brief set if a counter should be stalled when CPU is halted by the debugger */ -void systimer_hal_counter_can_stall_by_cpu(uint32_t counter_id, uint32_t cpu_id, bool can); +void systimer_hal_counter_can_stall_by_cpu(systimer_hal_context_t *hal, uint32_t counter_id, uint32_t cpu_id, bool can); + +#if !SOC_SYSTIMER_FIXED_TICKS_US +/** + * @brief set increase steps for systimer counter on different clock source + */ +void systimer_hal_set_steps_per_tick(systimer_hal_context_t *hal, int clock_source, uint32_t steps); +#endif #ifdef __cplusplus } diff --git a/components/hal/systimer_hal.c b/components/hal/systimer_hal.c new file mode 100644 index 0000000000..2521060308 --- /dev/null +++ b/components/hal/systimer_hal.c @@ -0,0 +1,188 @@ +// Copyright 2021 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include "soc/soc_caps.h" +#include "hal/systimer_hal.h" +#include "hal/systimer_ll.h" +#include "hal/systimer_types.h" +#include "hal/clk_gate_ll.h" + +// Number of timer ticks per microsecond +#if SOC_SYSTIMER_FIXED_TICKS_US +#define SYSTIMER_TICKS_PER_US (SOC_SYSTIMER_FIXED_TICKS_US) +#else +#define SYSTIMER_TICKS_PER_US (80) +#endif + +void systimer_hal_init(systimer_hal_context_t *hal) +{ + hal->dev = &SYSTIMER; + periph_ll_enable_clk_clear_rst(PERIPH_SYSTIMER_MODULE); + systimer_ll_enable_clock(hal->dev, true); +} + +uint64_t systimer_hal_get_counter_value(systimer_hal_context_t *hal, uint32_t counter_id) +{ + uint32_t lo, lo_start, hi; + /* Set the "update" bit and wait for acknowledgment */ + systimer_ll_counter_snapshot(hal->dev, counter_id); + while (!systimer_ll_is_counter_value_valid(hal->dev, counter_id)); + /* Read LO, HI, then LO again, check that LO returns the same value. + * This accounts for the case when an interrupt may happen between reading + * HI and LO values, and this function may get called from the ISR. + * In this case, the repeated read will return consistent values. + */ + lo_start = systimer_ll_get_counter_value_low(hal->dev, counter_id); + do { + lo = lo_start; + hi = systimer_ll_get_counter_value_high(hal->dev, counter_id); + lo_start = systimer_ll_get_counter_value_low(hal->dev, counter_id); + } while (lo_start != lo); + + systimer_counter_value_t result = { + .lo = lo, + .hi = hi + }; + + return result.val; +} + +uint64_t systimer_hal_get_time(systimer_hal_context_t *hal, uint32_t counter_id) +{ + return systimer_hal_get_counter_value(hal, counter_id) / SYSTIMER_TICKS_PER_US; +} + +#if SOC_SYSTIMER_ALARM_MISS_COMPENSATE +void systimer_hal_set_alarm_target(systimer_hal_context_t *hal, uint32_t alarm_id, uint64_t target) +{ + systimer_counter_value_t alarm = { .val = target * SYSTIMER_TICKS_PER_US}; + systimer_ll_enable_alarm(hal->dev, alarm_id, false); + systimer_ll_set_alarm_target(hal->dev, alarm_id, alarm.val); + systimer_ll_apply_alarm_value(hal->dev, alarm_id); + systimer_ll_enable_alarm(hal->dev, alarm_id, true); +} +#else +void systimer_hal_set_alarm_target(systimer_hal_context_t *hal, uint32_t alarm_id, uint64_t timestamp) +{ + int64_t offset = SYSTIMER_TICKS_PER_US * 2; + uint64_t now_time = systimer_hal_get_counter_value(hal, 0); + systimer_counter_value_t alarm = { .val = MAX(timestamp * SYSTIMER_TICKS_PER_US, now_time + offset) }; + do { + systimer_ll_enable_alarm(hal->dev, alarm_id, false); + systimer_ll_set_alarm_target(hal->dev, alarm_id, alarm.val); + systimer_ll_enable_alarm(hal->dev, alarm_id, true); + now_time = systimer_hal_get_counter_value(hal, 0); + int64_t delta = (int64_t)alarm.val - (int64_t)now_time; + if (delta <= 0 && !systimer_ll_is_alarm_int_fired(hal->dev, alarm_id)) { + // new alarm is less than the counter and the interrupt flag is not set + offset += -1 * delta + SYSTIMER_TICKS_PER_US * 2; + alarm.val = now_time + offset; + } else { + // finish if either (alarm > counter) or the interrupt flag is already set. + break; + } + } while (1); +} +#endif + +void systimer_hal_set_alarm_period(systimer_hal_context_t *hal, uint32_t alarm_id, uint32_t period) +{ + systimer_ll_enable_alarm(hal->dev, alarm_id, false); + systimer_ll_set_alarm_period(hal->dev, alarm_id, period * SYSTIMER_TICKS_PER_US); + systimer_ll_apply_alarm_value(hal->dev, alarm_id); + systimer_ll_enable_alarm(hal->dev, alarm_id, true); +} + +uint64_t systimer_hal_get_alarm_value(systimer_hal_context_t *hal, uint32_t alarm_id) +{ + return systimer_ll_get_alarm_target(hal->dev, alarm_id); +} + +void systimer_hal_enable_alarm_int(systimer_hal_context_t *hal, uint32_t alarm_id) +{ + systimer_ll_enable_alarm_int(hal->dev, alarm_id, true); +} + +void systimer_hal_counter_value_advance(systimer_hal_context_t *hal, uint32_t counter_id, int64_t time_us) +{ + systimer_counter_value_t new_count = { .val = systimer_hal_get_counter_value(hal, counter_id) + time_us * SYSTIMER_TICKS_PER_US }; + systimer_ll_set_counter_value(hal->dev, counter_id, new_count.val); + systimer_ll_apply_counter_value(hal->dev, counter_id); +} + +void systimer_hal_enable_counter(systimer_hal_context_t *hal, uint32_t counter_id) +{ + systimer_ll_enable_counter(hal->dev, counter_id, true); +} + +void systimer_hal_select_alarm_mode(systimer_hal_context_t *hal, uint32_t alarm_id, systimer_alarm_mode_t mode) +{ + switch (mode) { + case SYSTIMER_ALARM_MODE_ONESHOT: + systimer_ll_enable_alarm_oneshot(hal->dev, alarm_id); + break; + case SYSTIMER_ALARM_MODE_PERIOD: + systimer_ll_enable_alarm_period(hal->dev, alarm_id); + break; + default: + break; + } +} + +void systimer_hal_connect_alarm_counter(systimer_hal_context_t *hal, uint32_t alarm_id, uint32_t counter_id) +{ + systimer_ll_connect_alarm_counter(hal->dev, alarm_id, counter_id); +} + +void systimer_hal_counter_can_stall_by_cpu(systimer_hal_context_t *hal, uint32_t counter_id, uint32_t cpu_id, bool can) +{ + systimer_ll_counter_can_stall_by_cpu(hal->dev, counter_id, cpu_id, can); +} + +#if !SOC_SYSTIMER_FIXED_TICKS_US +void systimer_hal_set_steps_per_tick(systimer_hal_context_t *hal, int clock_source, uint32_t steps) +{ + /* Configure the counter: + * - increment by 1 when running from PLL (80 ticks per microsecond), + * - increment by 2 when running from XTAL (40 ticks per microsecond). + * Note that if the APB frequency is derived from XTAL with divider != 1, + * XTAL_STEP needs to be adjusted accordingly. For example, if + * the APB frequency is XTAL/4 = 10 MHz, then XTAL_STEP should be set to 8. + * This is handled in systimer_hal_on_apb_freq_update function. + */ + switch (clock_source) { + case 0: + systimer_ll_set_step_for_xtal(hal->dev, steps); + break; + case 1: + systimer_ll_set_step_for_pll(hal->dev, steps); + default: + break; + } +} + +void systimer_hal_on_apb_freq_update(systimer_hal_context_t *hal, uint32_t apb_ticks_per_us) +{ + /* If this function was called when switching APB clock to PLL, don't need + * do anything: the SYSTIMER_TIMER_PLL_STEP is already correct. + * If this was called when switching APB clock to XTAL, need to adjust + * XTAL_STEP value accordingly. + */ + if (apb_ticks_per_us != SYSTIMER_TICKS_PER_US) { + assert((SYSTIMER_TICKS_PER_US % apb_ticks_per_us) == 0 && "TICK_PER_US should be divisible by APB frequency (in MHz)"); + systimer_ll_set_step_for_xtal(hal->dev, SYSTIMER_TICKS_PER_US / apb_ticks_per_us); + } +} +#endif