From 6d293c858246573530c29a2c5a750822abe4a2d4 Mon Sep 17 00:00:00 2001 From: Song Ruo Jing Date: Tue, 4 Mar 2025 16:53:52 +0800 Subject: [PATCH] feat(clk): Add basic clock support for esp32h21 --- Kconfig | 1 - .../src/bootloader_flash_config_esp32h21.c | 7 +- .../src/bootloader_clock_init.c | 2 +- .../src/esp32h21/bootloader_esp32h21.c | 1 - components/esp_hw_support/esp_clk.c | 8 +- .../include/esp_private/esp_clk_tree_common.h | 27 +- components/esp_hw_support/linker.lf | 2 + .../esp_hw_support/port/esp32/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32/rtc_clk.c | 6 +- .../port/esp32c2/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32c2/rtc_clk.c | 17 +- .../port/esp32c3/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32c3/rtc_clk.c | 6 +- .../port/esp32c5/esp_clk_tree.c | 13 + .../esp_hw_support/port/esp32c5/rtc_clk.c | 15 +- .../port/esp32c5/rtc_clk_init.c | 2 - .../port/esp32c6/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32c6/rtc_clk.c | 17 +- .../port/esp32c6/rtc_clk_init.c | 1 - .../port/esp32c61/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32c61/rtc_clk.c | 15 +- .../port/esp32c61/rtc_clk_init.c | 2 - .../port/esp32h2/esp_clk_tree.c | 18 +- .../port/esp32h2/include/soc/rtc.h | 2 +- .../esp_hw_support/port/esp32h2/rtc_clk.c | 17 +- .../port/esp32h2/rtc_clk_init.c | 1 - .../port/esp32h21/CMakeLists.txt | 5 +- .../esp_hw_support/port/esp32h21/Kconfig.rtc | 10 +- .../port/esp32h21/esp_clk_tree.c | 81 +++++- .../port/esp32h21/include/soc/rtc.h | 162 +++--------- .../esp_hw_support/port/esp32h21/pmu_init.c | 11 +- .../esp_hw_support/port/esp32h21/pmu_param.c | 1 - .../esp_hw_support/port/esp32h21/pmu_sleep.c | 18 +- .../port/esp32h21/private_include/pmu_param.h | 50 ++-- .../esp_hw_support/port/esp32h21/rtc_clk.c | 159 +++++------ .../port/esp32h21/rtc_clk_init.c | 24 +- .../esp_hw_support/port/esp32h21/rtc_time.c | 98 ++----- .../port/esp32h4/esp_clk_tree.c | 16 ++ .../esp_hw_support/port/esp32h4/rtc_clk.c | 17 +- .../port/esp32p4/esp_clk_tree.c | 16 ++ .../esp_hw_support/port/esp32p4/rtc_clk.c | 6 +- .../port/esp32p4/rtc_clk_init.c | 1 - .../port/esp32s2/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32s2/rtc_clk.c | 6 +- .../port/esp32s3/esp_clk_tree.c | 18 +- .../esp_hw_support/port/esp32s3/rtc_clk.c | 6 +- .../test_apps/rtc_clk/CMakeLists.txt | 4 + .../test_apps/rtc_clk/README.md | 4 +- .../test_apps/rtc_clk/main/test_rtc_clk.c | 12 +- .../esp32h21/include/esp32h21/rom/rtc.h | 31 +-- .../esp_rom/patches/esp_rom_regi2c_esp32h21.c | 3 + components/esp_system/fpga_overrides_clk.c | 10 +- components/esp_system/port/cpu_start.c | 3 +- .../esp_system/port/soc/esp32h21/Kconfig.cpu | 8 +- components/esp_system/port/soc/esp32h21/clk.c | 27 +- components/esp_system/startup_funcs.c | 2 +- components/hal/esp32c5/clk_tree_hal.c | 1 - components/hal/esp32c61/clk_tree_hal.c | 1 - components/hal/esp32h21/clk_tree_hal.c | 34 +-- .../hal/esp32h21/include/hal/clk_tree_ll.h | 249 +++--------------- components/hal/esp32h21/include/hal/uart_ll.h | 2 + .../soc/esp32/include/soc/clk_tree_defs.h | 10 +- .../soc/esp32c2/include/soc/clk_tree_defs.h | 12 +- .../soc/esp32c2/register/soc/io_mux_reg.h | 2 - .../soc/esp32c3/include/soc/clk_tree_defs.h | 9 +- .../soc/esp32c5/include/soc/clk_tree_defs.h | 10 + .../soc/esp32c5/register/soc/io_mux_reg.h | 2 - .../soc/esp32c6/include/soc/clk_tree_defs.h | 12 +- .../soc/esp32c6/register/soc/io_mux_reg.h | 2 - .../soc/esp32c61/include/soc/clk_tree_defs.h | 12 +- .../soc/esp32c61/register/soc/io_mux_reg.h | 2 - .../soc/esp32h2/include/soc/clk_tree_defs.h | 12 +- components/soc/esp32h2/include/soc/soc.h | 2 +- .../soc/esp32h2/register/soc/io_mux_reg.h | 2 - .../esp32h21/include/soc/Kconfig.soc_caps.in | 22 +- .../soc/esp32h21/include/soc/clk_tree_defs.h | 85 +++--- components/soc/esp32h21/include/soc/soc.h | 2 +- .../soc/esp32h21/include/soc/soc_caps.h | 14 +- .../soc/esp32h21/register/soc/io_mux_reg.h | 3 - .../soc/esp32h21/register/soc/pcr_reg.h | 17 +- .../soc/esp32h21/register/soc/pcr_struct.h | 10 +- .../soc/esp32h4/include/soc/clk_tree_defs.h | 10 + .../soc/esp32h4/register/soc/io_mux_reg.h | 1 - .../soc/esp32p4/include/soc/clk_tree_defs.h | 12 + .../soc/esp32p4/register/soc/io_mux_reg.h | 2 - .../soc/esp32s2/include/soc/clk_tree_defs.h | 10 +- .../soc/esp32s3/include/soc/clk_tree_defs.h | 9 +- docs/docs_not_updated/esp32h21.txt | 1 - .../en/api-reference/peripherals/clk_tree.rst | 10 +- .../api-reference/peripherals/clk_tree.rst | 10 +- 90 files changed, 833 insertions(+), 858 deletions(-) diff --git a/Kconfig b/Kconfig index 5e8f3ec82a..329d7d8e99 100644 --- a/Kconfig +++ b/Kconfig @@ -141,7 +141,6 @@ mainmenu "Espressif IoT Development Framework Configuration" default "y" if IDF_TARGET="esp32h21" select FREERTOS_UNICORE select IDF_TARGET_ARCH_RISCV - select IDF_ENV_FPGA select IDF_ENV_BRINGUP config IDF_TARGET_ESP32H4 diff --git a/components/bootloader_support/bootloader_flash/src/bootloader_flash_config_esp32h21.c b/components/bootloader_support/bootloader_flash/src/bootloader_flash_config_esp32h21.c index a1f142b050..4cffe27fd5 100644 --- a/components/bootloader_support/bootloader_flash/src/bootloader_flash_config_esp32h21.c +++ b/components/bootloader_support/bootloader_flash/src/bootloader_flash_config_esp32h21.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -18,6 +18,7 @@ #include "hal/cache_hal.h" #include "hal/cache_ll.h" #include "hal/mspi_ll.h" +#include "hal/clk_tree_ll.h" #include "soc/pcr_reg.h" static const char *TAG = "boot.esp32h21"; @@ -80,7 +81,9 @@ void IRAM_ATTR bootloader_configure_spi_pins(int drv) static void IRAM_ATTR bootloader_flash_clock_init(void) { - // At this moment, BBPLL should be enabled, safe to switch MSPI clock source to PLL_F64M (default clock src) to raise speed + // To raise the MSPI clock to 64MHz, needs to enable the 64MHz clock source, which is XTAL_X2_CLK + // (FPGA image fixed MSPI0/1 clock to 64MHz) + clk_ll_xtal_x2_enable(); _mspi_timing_ll_set_flash_clk_src(0, FLASH_CLK_SRC_PLL_F64M); } diff --git a/components/bootloader_support/src/bootloader_clock_init.c b/components/bootloader_support/src/bootloader_clock_init.c index 1799fbbff9..cb26082f60 100644 --- a/components/bootloader_support/src/bootloader_clock_init.c +++ b/components/bootloader_support/src/bootloader_clock_init.c @@ -18,7 +18,7 @@ #include "soc/pmu_reg.h" #endif -#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32C5 +#if CONFIG_IDF_TARGET_ESP32 #include "hal/clk_tree_ll.h" #endif #include "esp_rom_sys.h" diff --git a/components/bootloader_support/src/esp32h21/bootloader_esp32h21.c b/components/bootloader_support/src/esp32h21/bootloader_esp32h21.c index 096dcb1903..005c624277 100644 --- a/components/bootloader_support/src/esp32h21/bootloader_esp32h21.c +++ b/components/bootloader_support/src/esp32h21/bootloader_esp32h21.c @@ -90,7 +90,6 @@ static inline void bootloader_hardware_init(void) SET_PERI_REG_MASK(PMU_RF_PWC_REG, PMU_XPD_FORCE_RFPLL); _regi2c_ctrl_ll_master_enable_clock(true); // keep ana i2c mst clock always enabled in bootloader - regi2c_ctrl_ll_master_force_enable_clock(true); // TODO: IDF-11548 Remove this? regi2c_ctrl_ll_master_configure_clock(); } diff --git a/components/esp_hw_support/esp_clk.c b/components/esp_hw_support/esp_clk.c index ec85b60f00..805a184f1a 100644 --- a/components/esp_hw_support/esp_clk.c +++ b/components/esp_hw_support/esp_clk.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -85,10 +85,10 @@ int IRAM_ATTR esp_clk_cpu_freq(void) int IRAM_ATTR esp_clk_apb_freq(void) { // TODO: IDF-5173 Require cleanup, implementation should be unified -#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32P4 || CONFIG_IDF_TARGET_ESP32C5 || CONFIG_IDF_TARGET_ESP32C61 - return rtc_clk_apb_freq_get(); -#else +#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C2 return MIN(s_get_cpu_freq_mhz() * MHZ, APB_CLK_FREQ); +#else // for all later targets + return rtc_clk_apb_freq_get(); #endif } diff --git a/components/esp_hw_support/include/esp_private/esp_clk_tree_common.h b/components/esp_hw_support/include/esp_private/esp_clk_tree_common.h index 5755cd8232..7e75bc1367 100644 --- a/components/esp_hw_support/include/esp_private/esp_clk_tree_common.h +++ b/components/esp_hw_support/include/esp_private/esp_clk_tree_common.h @@ -90,12 +90,33 @@ uint32_t esp_clk_tree_lp_fast_get_freq_hz(esp_clk_tree_src_freq_precision_t prec */ esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable); -#if SOC_CLOCK_TREE_MANAGEMENT_SUPPORTED /** - * @brief Set the clock source not in use on the clock tree to the gated state. + * @brief Initialize clock circuit power and clock gating + * + * Set the clock source not in uses on the clock tree to the gated state, + * and initialize reference counters for clock circuit power and clock gating. */ void esp_clk_tree_initialize(void); -#endif + +/** + * @brief Enable / Disable the power of the clock circuit + * + * @param[in] clk_circuit Clock circuits, in soc_root_clk_circuit_t + * @param[in] enable Enable / Disable the power of the clock circuit + * + * @return + * - ESP_OK Success + */ +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable); + +/** + * @brief Get the power status of the clock circuit + * + * @param[in] clk_circuit Clock circuits, in soc_root_clk_circuit_t + * + * @return True if the clock circuit power is on, false otherwise + */ +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit); #ifdef __cplusplus } diff --git a/components/esp_hw_support/linker.lf b/components/esp_hw_support/linker.lf index 1ee15d6e2f..4f72c89fef 100644 --- a/components/esp_hw_support/linker.lf +++ b/components/esp_hw_support/linker.lf @@ -17,6 +17,8 @@ entries: rtc_clk (noflash) rtc_time (noflash_text) esp_clk_tree: esp_clk_tree_enable_src (noflash) + esp_clk_tree: esp_clk_tree_enable_power (noflash) + esp_clk_tree: esp_clk_tree_is_power_on (noflash) if IDF_TARGET_ESP32 = y: rtc_clk:rtc_clk_cpu_freq_to_pll_mhz (noflash) rtc_clk:rtc_clk_cpu_freq_to_xtal (noflash) diff --git a/components/esp_hw_support/port/esp32/esp_clk_tree.c b/components/esp_hw_support/port/esp32/esp_clk_tree.c index e748df5d4c..1e6670f950 100644 --- a/components/esp_hw_support/port/esp32/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -70,6 +70,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32/rtc_clk.c b/components/esp_hw_support/port/esp32/rtc_clk.c index df155ba849..767d50f0e2 100644 --- a/components/esp_hw_support/port/esp32/rtc_clk.c +++ b/components/esp_hw_support/port/esp32/rtc_clk.c @@ -34,7 +34,7 @@ #define XTAL_32K_BOOTSTRAP_TIME_US 7 -static void rtc_clk_cpu_freq_to_8m(void); +static void rtc_clk_cpu_freq_to_rc_fast(void); static void rtc_clk_cpu_freq_to_pll_mhz(int cpu_freq_mhz); // Current PLL frequency, in MHZ (320 or 480). Zero if PLL is not enabled. @@ -387,7 +387,7 @@ void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_DIG_DBIAS_WAK, dbias); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { esp_rom_set_cpu_ticks_per_us(8); REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_DIG_DBIAS_WAK, DIG_DBIAS_XTAL); @@ -542,7 +542,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t* config) rtc_clk_bbpll_configure(rtc_clk_xtal_freq_get(), config->source_freq_mhz); rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } } diff --git a/components/esp_hw_support/port/esp32c2/esp_clk_tree.c b/components/esp_hw_support/port/esp32c2/esp_clk_tree.c index 50291204d3..dda7b7bbb0 100644 --- a/components/esp_hw_support/port/esp32c2/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32c2/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -64,6 +64,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32c2/rtc_clk.c b/components/esp_hw_support/port/esp32c2/rtc_clk.c index 044f3a4ed5..2f1948dc11 100644 --- a/components/esp_hw_support/port/esp32c2/rtc_clk.c +++ b/components/esp_hw_support/port/esp32c2/rtc_clk.c @@ -15,7 +15,7 @@ #include "soc/rtc.h" #include "esp_private/esp_sleep_internal.h" #include "esp_private/rtc_clk.h" -#include "soc/io_mux_reg.h" +#include "hal/gpio_ll.h" #include "soc/soc.h" #include "esp_hw_log.h" #include "esp_rom_sys.h" @@ -28,19 +28,18 @@ static const char *TAG = "rtc_clk"; static int s_cur_pll_freq; void rtc_clk_cpu_freq_to_xtal(int freq, int div); -static void rtc_clk_cpu_freq_to_8m(void); +static void rtc_clk_cpu_freq_to_rc_fast(void); void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_0 - PIN_INPUT_ENABLE(IO_MUX_GPIO0_REG); - REG_SET_BIT(RTC_CNTL_PAD_HOLD_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(RTC_CNTL_PAD_HOLD_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); } void rtc_clk_32k_disable_external(void) { - PIN_INPUT_DISABLE(IO_MUX_GPIO0_REG); - REG_CLR_BIT(RTC_CNTL_PAD_HOLD_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(RTC_CNTL_PAD_HOLD_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); } void rtc_clk_8m_enable(bool clk_8m_en, bool d256_en) @@ -220,7 +219,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) } rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if (old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL) { rtc_clk_bbpll_disable(); } @@ -317,7 +316,7 @@ void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) rtc_clk_apb_freq_update(cpu_freq * MHZ); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { esp_rom_set_cpu_ticks_per_us(20); clk_ll_cpu_set_divider(1); diff --git a/components/esp_hw_support/port/esp32c3/esp_clk_tree.c b/components/esp_hw_support/port/esp32c3/esp_clk_tree.c index a3eaae3200..cf885a4234 100644 --- a/components/esp_hw_support/port/esp32c3/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32c3/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -64,6 +64,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32c3/rtc_clk.c b/components/esp_hw_support/port/esp32c3/rtc_clk.c index 4328ab28d5..d7fd3600c1 100644 --- a/components/esp_hw_support/port/esp32c3/rtc_clk.c +++ b/components/esp_hw_support/port/esp32c3/rtc_clk.c @@ -26,7 +26,7 @@ static const char *TAG = "rtc_clk"; static int s_cur_pll_freq; static void rtc_clk_cpu_freq_to_xtal(int freq, int div); -static void rtc_clk_cpu_freq_to_8m(void); +static void rtc_clk_cpu_freq_to_rc_fast(void); static uint32_t s_bbpll_digi_consumers_ref_count = 0; // Currently, it only tracks whether the 48MHz PHY clock is in-use by USB Serial/JTAG @@ -248,7 +248,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) } rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL) && !s_bbpll_digi_consumers_ref_count) { // We don't turn off the bbpll if some consumers depend on bbpll rtc_clk_bbpll_disable(); @@ -346,7 +346,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) rtc_clk_apb_freq_update(cpu_freq * MHZ); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { esp_rom_set_cpu_ticks_per_us(20); clk_ll_cpu_set_divider(1); diff --git a/components/esp_hw_support/port/esp32c5/esp_clk_tree.c b/components/esp_hw_support/port/esp32c5/esp_clk_tree.c index a84919e032..0064b870d9 100644 --- a/components/esp_hw_support/port/esp32c5/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32c5/esp_clk_tree.c @@ -14,6 +14,7 @@ #include "hal/clk_tree_ll.h" #include "hal/clk_gate_ll.h" #include "esp_private/esp_clk_tree_common.h" +#include "esp_rom_sys.h" static const char *TAG = "esp_clk_tree"; @@ -106,6 +107,18 @@ void esp_clk_tree_initialize(void) esp_clk_tree_initialized = true; } +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { if (!esp_clk_tree_initialized || (clk_src < SOC_MOD_CLK_PLL_F12M) || (clk_src > SOC_MOD_CLK_PLL_F240M)) { diff --git a/components/esp_hw_support/port/esp32c5/rtc_clk.c b/components/esp_hw_support/port/esp32c5/rtc_clk.c index 55d5e2e62c..e5ab6c0f41 100644 --- a/components/esp_hw_support/port/esp32c5/rtc_clk.c +++ b/components/esp_hw_support/port/esp32c5/rtc_clk.c @@ -52,16 +52,15 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_0 - gpio_ll_input_enable(&GPIO, EXT_OSC_SLOW_GPIO_NUM); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - gpio_ll_input_disable(&GPIO, EXT_OSC_SLOW_GPIO_NUM); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } @@ -172,7 +171,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { clk_ll_cpu_set_divider(1); clk_ll_ahb_set_divider(1); @@ -329,7 +328,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_pll_160_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } if (old_cpu_clk_src != config->source) { rtc_clk_update_pll_state_on_cpu_switching_end(old_cpu_clk_src, config->source); @@ -381,7 +380,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == CLK_LL_PLL_480M_FREQ_MHZ) { rtc_clk_cpu_freq_to_pll_240_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); diff --git a/components/esp_hw_support/port/esp32c5/rtc_clk_init.c b/components/esp_hw_support/port/esp32c5/rtc_clk_init.c index 18cb9a2830..383a52ec58 100644 --- a/components/esp_hw_support/port/esp32c5/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32c5/rtc_clk_init.c @@ -10,7 +10,6 @@ #include #include "esp32c5/rom/ets_sys.h" #include "esp32c5/rom/rtc.h" -#include "esp32c5/rom/uart.h" #include "soc/rtc.h" #include "soc/soc_caps.h" #include "esp_cpu.h" @@ -19,7 +18,6 @@ #include "soc/regi2c_dig_reg.h" #include "esp_hw_log.h" #include "sdkconfig.h" -#include "esp_rom_uart.h" #include "esp_private/esp_pmu.h" #include "hal/clk_tree_ll.h" #if SOC_MODEM_CLOCK_SUPPORTED diff --git a/components/esp_hw_support/port/esp32c6/esp_clk_tree.c b/components/esp_hw_support/port/esp32c6/esp_clk_tree.c index 21d98303df..576720d656 100644 --- a/components/esp_hw_support/port/esp32c6/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32c6/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -64,6 +64,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32c6/rtc_clk.c b/components/esp_hw_support/port/esp32c6/rtc_clk.c index 20027f936d..ac5b2ba835 100644 --- a/components/esp_hw_support/port/esp32c6/rtc_clk.c +++ b/components/esp_hw_support/port/esp32c6/rtc_clk.c @@ -17,7 +17,7 @@ #include "esp_rom_sys.h" #include "hal/clk_tree_ll.h" #include "hal/regi2c_ctrl_ll.h" -#include "soc/io_mux_reg.h" +#include "hal/gpio_ll.h" #include "soc/lp_aon_reg.h" #include "esp_private/sleep_event.h" #include "esp_private/regi2c_ctrl.h" @@ -50,16 +50,15 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_0 - PIN_INPUT_ENABLE(IO_MUX_GPIO0_REG); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - PIN_INPUT_DISABLE(IO_MUX_GPIO0_REG); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } @@ -179,7 +178,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { clk_ll_ahb_set_ls_divider(1); clk_ll_cpu_set_ls_divider(1); @@ -267,7 +266,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL) && !s_bbpll_digi_consumers_ref_count) { // We don't turn off the bbpll if some consumers depend on bbpll rtc_clk_bbpll_disable(); @@ -319,7 +318,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == config->source_freq_mhz) { rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); diff --git a/components/esp_hw_support/port/esp32c6/rtc_clk_init.c b/components/esp_hw_support/port/esp32c6/rtc_clk_init.c index 9ab938f02a..296f617394 100644 --- a/components/esp_hw_support/port/esp32c6/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32c6/rtc_clk_init.c @@ -10,7 +10,6 @@ #include #include "esp32c6/rom/ets_sys.h" #include "esp32c6/rom/rtc.h" -#include "esp32c6/rom/uart.h" #include "soc/rtc.h" #include "esp_cpu.h" #include "regi2c_ctrl.h" diff --git a/components/esp_hw_support/port/esp32c61/esp_clk_tree.c b/components/esp_hw_support/port/esp32c61/esp_clk_tree.c index 7915de98ec..eff66bd087 100644 --- a/components/esp_hw_support/port/esp32c61/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32c61/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -64,6 +64,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32c61/rtc_clk.c b/components/esp_hw_support/port/esp32c61/rtc_clk.c index 400a6f2cde..c896655364 100644 --- a/components/esp_hw_support/port/esp32c61/rtc_clk.c +++ b/components/esp_hw_support/port/esp32c61/rtc_clk.c @@ -50,16 +50,15 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_0 - gpio_ll_input_enable(&GPIO, EXT_OSC_SLOW_GPIO_NUM); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - gpio_ll_input_disable(&GPIO, EXT_OSC_SLOW_GPIO_NUM); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } @@ -170,7 +169,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { clk_ll_cpu_set_divider(1); clk_ll_ahb_set_divider(1); @@ -262,7 +261,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_pll_160_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_bbpll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL_F160M) && !s_bbpll_digi_consumers_ref_count) { // We don't turn off the bbpll if some consumers depend on bbpll rtc_clk_bbpll_disable(); @@ -308,7 +307,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == CLK_LL_PLL_480M_FREQ_MHZ) { rtc_clk_cpu_freq_to_pll_160_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); diff --git a/components/esp_hw_support/port/esp32c61/rtc_clk_init.c b/components/esp_hw_support/port/esp32c61/rtc_clk_init.c index 965fabc705..196a0afac8 100644 --- a/components/esp_hw_support/port/esp32c61/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32c61/rtc_clk_init.c @@ -10,7 +10,6 @@ #include #include "esp32c61/rom/ets_sys.h" #include "esp32c61/rom/rtc.h" -#include "esp32c61/rom/uart.h" #include "soc/rtc.h" #include "esp_cpu.h" #include "regi2c_ctrl.h" @@ -18,7 +17,6 @@ #include "soc/regi2c_dig_reg.h" #include "esp_hw_log.h" #include "sdkconfig.h" -#include "esp_rom_uart.h" #include "esp_private/esp_pmu.h" #include "hal/clk_tree_ll.h" #include "hal/pmu_ll.h" diff --git a/components/esp_hw_support/port/esp32h2/esp_clk_tree.c b/components/esp_hw_support/port/esp32h2/esp_clk_tree.c index b221582a10..e9125ac1d4 100644 --- a/components/esp_hw_support/port/esp32h2/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32h2/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -61,6 +61,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32h2/include/soc/rtc.h b/components/esp_hw_support/port/esp32h2/include/soc/rtc.h index e1332deb0e..d3811d23d3 100644 --- a/components/esp_hw_support/port/esp32h2/include/soc/rtc.h +++ b/components/esp_hw_support/port/esp32h2/include/soc/rtc.h @@ -158,7 +158,7 @@ typedef struct { * Default initializer for rtc_clk_config_t */ #define RTC_CLK_CONFIG_DEFAULT() { \ - .xtal_freq = SOC_XTAL_FREQ_32M, \ + .xtal_freq = CONFIG_XTAL_FREQ, \ .cpu_freq_mhz = 96, \ .fast_clk_src = SOC_RTC_FAST_CLK_SRC_RC_FAST, \ .slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW, \ diff --git a/components/esp_hw_support/port/esp32h2/rtc_clk.c b/components/esp_hw_support/port/esp32h2/rtc_clk.c index a089b29a8b..aa7b185e85 100644 --- a/components/esp_hw_support/port/esp32h2/rtc_clk.c +++ b/components/esp_hw_support/port/esp32h2/rtc_clk.c @@ -17,7 +17,7 @@ #include "esp_rom_sys.h" #include "hal/clk_tree_ll.h" #include "hal/regi2c_ctrl_ll.h" -#include "soc/io_mux_reg.h" +#include "hal/gpio_ll.h" #include "soc/lp_aon_reg.h" #include "esp_private/sleep_event.h" #include "esp_private/regi2c_ctrl.h" @@ -50,16 +50,15 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_13 - PIN_INPUT_ENABLE(IO_MUX_GPIO13_REG); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - PIN_INPUT_DISABLE(IO_MUX_GPIO13_REG); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } @@ -197,7 +196,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { // let f_cpu = f_ahb clk_ll_cpu_set_divider(1); @@ -311,7 +310,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL || old_cpu_clk_src == SOC_CPU_CLK_SRC_FLASH_PLL) && !s_bbpll_digi_consumers_ref_count) { rtc_clk_bbpll_disable(); @@ -374,7 +373,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == config->source_freq_mhz) { rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else if (config->source == SOC_CPU_CLK_SRC_FLASH_PLL && s_cur_pll_freq == clk_ll_bbpll_get_freq_mhz()) { // On ESP32H2, FLASH_PLL (64MHz) is directly derived from the BBPLL (96MHz) diff --git a/components/esp_hw_support/port/esp32h2/rtc_clk_init.c b/components/esp_hw_support/port/esp32h2/rtc_clk_init.c index fcac148c6a..f3496e6c6d 100644 --- a/components/esp_hw_support/port/esp32h2/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32h2/rtc_clk_init.c @@ -10,7 +10,6 @@ #include #include "esp32h2/rom/ets_sys.h" #include "esp32h2/rom/rtc.h" -#include "esp32h2/rom/uart.h" #include "soc/rtc.h" #include "esp_cpu.h" #include "regi2c_ctrl.h" diff --git a/components/esp_hw_support/port/esp32h21/CMakeLists.txt b/components/esp_hw_support/port/esp32h21/CMakeLists.txt index dd0517199b..9f9db291e3 100644 --- a/components/esp_hw_support/port/esp32h21/CMakeLists.txt +++ b/components/esp_hw_support/port/esp32h21/CMakeLists.txt @@ -1,10 +1,11 @@ set(srcs "rtc_clk.c" "rtc_time.c" "chip_info.c" + "rtc_clk_init.c" ) + if(CONFIG_SOC_PMU_SUPPORTED) - list(APPEND srcs "rtc_clk_init.c" - "pmu_param.c" + list(APPEND srcs "pmu_param.c" "pmu_init.c" "pmu_sleep.c" ) diff --git a/components/esp_hw_support/port/esp32h21/Kconfig.rtc b/components/esp_hw_support/port/esp32h21/Kconfig.rtc index b02d6e6cc0..5214d9afa0 100644 --- a/components/esp_hw_support/port/esp32h21/Kconfig.rtc +++ b/components/esp_hw_support/port/esp32h21/Kconfig.rtc @@ -5,22 +5,20 @@ choice RTC_CLK_SRC Choose which clock is used as RTC clock source. config RTC_CLK_SRC_INT_RC - bool "Internal 136 kHz RC oscillator" + bool "Internal 600 kHz RC oscillator" config RTC_CLK_SRC_EXT_CRYS bool "External 32 kHz crystal" select ESP_SYSTEM_RTC_EXT_XTAL config RTC_CLK_SRC_EXT_OSC bool "External 32 kHz oscillator at 32K_XP pin" select ESP_SYSTEM_RTC_EXT_OSC - config RTC_CLK_SRC_INT_RC32K - bool "Internal 32 kHz RC oscillator" endchoice config RTC_CLK_CAL_CYCLES int "Number of cycles for RTC_SLOW_CLK calibration" - default 3000 if RTC_CLK_SRC_EXT_CRYS || RTC_CLK_SRC_EXT_OSC || RTC_CLK_SRC_INT_RC32K + default 3000 if RTC_CLK_SRC_EXT_CRYS || RTC_CLK_SRC_EXT_OSC default 1024 if RTC_CLK_SRC_INT_RC - range 0 8190 if RTC_CLK_SRC_EXT_CRYS || RTC_CLK_SRC_EXT_OSC || RTC_CLK_SRC_INT_RC32K + range 0 8190 if RTC_CLK_SRC_EXT_CRYS || RTC_CLK_SRC_EXT_OSC range 0 32766 if RTC_CLK_SRC_INT_RC help When the startup code initializes RTC_SLOW_CLK, it can perform @@ -33,7 +31,7 @@ config RTC_CLK_CAL_CYCLES When this option is set to 0, clock calibration will not be performed at startup, and approximate clock frequencies will be assumed: - - 136000 Hz if internal RC oscillator is used as clock source. For this use value 1024. + - 600000 Hz if internal RC oscillator is used as clock source. For this use value 1024. - 32768 Hz if the 32k crystal oscillator is used. For this use value 3000 or more. In case more value will help improve the definition of the launch of the crystal. If the crystal could not start, it will be switched to internal RC. diff --git a/components/esp_hw_support/port/esp32h21/esp_clk_tree.c b/components/esp_hw_support/port/esp32h21/esp_clk_tree.c index f2b4c71017..71ad12c5e8 100644 --- a/components/esp_hw_support/port/esp32h21/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32h21/esp_clk_tree.c @@ -13,8 +13,6 @@ #include "hal/clk_tree_ll.h" #include "esp_private/esp_clk_tree_common.h" -//TODO: [ESP32H21] IDF-11521 - static const char *TAG = "esp_clk_tree"; esp_err_t esp_clk_tree_src_get_freq_hz(soc_module_clk_t clk_src, esp_clk_tree_src_freq_precision_t precision, @@ -24,24 +22,35 @@ uint32_t *freq_value) ESP_RETURN_ON_FALSE(precision < ESP_CLK_TREE_SRC_FREQ_PRECISION_INVALID, ESP_ERR_INVALID_ARG, TAG, "unknown precision"); ESP_RETURN_ON_FALSE(freq_value, ESP_ERR_INVALID_ARG, TAG, "null pointer"); -#if !SOC_CLK_TREE_SUPPORTED - // Have only XTAL 32M before clock tree supported - assert(clk_src == SOC_MOD_CLK_XTAL); -#endif uint32_t clk_src_freq = 0; switch (clk_src) { + case SOC_MOD_CLK_CPU: + clk_src_freq = clk_hal_cpu_get_freq_hz(); + break; case SOC_MOD_CLK_XTAL: - clk_src_freq = SOC_XTAL_FREQ_32M * MHZ; + clk_src_freq = clk_hal_xtal_get_freq_mhz() * MHZ; break; case SOC_MOD_CLK_PLL_F48M: clk_src_freq = CLK_LL_PLL_48M_FREQ_MHZ * MHZ; break; - case SOC_MOD_CLK_PLL_F64M: + case SOC_MOD_CLK_XTAL_X2_F64M: clk_src_freq = CLK_LL_PLL_64M_FREQ_MHZ * MHZ; break; case SOC_MOD_CLK_PLL_F96M: clk_src_freq = CLK_LL_PLL_96M_FREQ_MHZ * MHZ; break; + case SOC_MOD_CLK_RTC_SLOW: + clk_src_freq = esp_clk_tree_lp_slow_get_freq_hz(precision); + break; + case SOC_MOD_CLK_RTC_FAST: + clk_src_freq = esp_clk_tree_lp_fast_get_freq_hz(precision); + break; + case SOC_MOD_CLK_RC_FAST: + clk_src_freq = esp_clk_tree_rc_fast_get_freq_hz(precision); + break; + case SOC_MOD_CLK_XTAL32K: + clk_src_freq = esp_clk_tree_xtal32k_get_freq_hz(precision); + break; default: break; } @@ -51,8 +60,60 @@ uint32_t *freq_value) return ESP_OK; } +static int16_t s_xtal_x2_ref_cnt = 0; + +void esp_clk_tree_initialize(void) +{ + // In bootloader, flash clock source will always be switched to use XTAL_X2 clock + s_xtal_x2_ref_cnt++; + if (clk_ll_cpu_get_src() == SOC_CPU_CLK_SRC_XTAL_X2) { + s_xtal_x2_ref_cnt++; + } +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + switch (clk_circuit) { + case SOC_ROOT_CIRCUIT_CLK_XTAL_X2: + return s_xtal_x2_ref_cnt > 0; + default: + break; + } + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + switch (clk_circuit) { + case SOC_ROOT_CIRCUIT_CLK_XTAL_X2: + if (enable) { + s_xtal_x2_ref_cnt++; + } else { + s_xtal_x2_ref_cnt--; + } + + if (s_xtal_x2_ref_cnt == 1) { + clk_ll_xtal_x2_enable(); + } else if (s_xtal_x2_ref_cnt == 0) { + clk_ll_xtal_x2_disable(); + } + + assert(s_xtal_x2_ref_cnt >= 0); + break; + default: + break; + } + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { - (void)clk_src; (void)enable; - return ESP_OK; + switch (clk_src) { + case SOC_MOD_CLK_XTAL_X2_F64M: + // later, here should handle ref count for PLL_F64M clock gating, then also handle XTAL_X2 circuit enable/disable + esp_clk_tree_enable_power(SOC_ROOT_CIRCUIT_CLK_XTAL_X2, enable); + default: + break; + } + return ESP_OK; // TODO: PM-354 } diff --git a/components/esp_hw_support/port/esp32h21/include/soc/rtc.h b/components/esp_hw_support/port/esp32h21/include/soc/rtc.h index a4a34476a4..55c42f60e0 100644 --- a/components/esp_hw_support/port/esp32h21/include/soc/rtc.h +++ b/components/esp_hw_support/port/esp32h21/include/soc/rtc.h @@ -50,10 +50,6 @@ extern "C" { #define MHZ (1000000) -#define RTC_SLOW_CLK_150K_CAL_TIMEOUT_THRES(cycles) (cycles << 10) -#define RTC_SLOW_CLK_32K_CAL_TIMEOUT_THRES(cycles) (cycles << 12) -#define RTC_FAST_CLK_8M_CAL_TIMEOUT_THRES(cycles) (TIMG_RTC_CALI_TIMEOUT_THRES_V) // Just use the max timeout thres value - #define OTHER_BLOCKS_POWERUP 1 #define OTHER_BLOCKS_WAIT 1 @@ -64,16 +60,14 @@ extern "C" { #define SOC_DELAY_RTC_SLOW_CLK_SWITCH 300 #define SOC_DELAY_RC_FAST_ENABLE 50 #define SOC_DELAY_RC_FAST_DIGI_SWITCH 5 -#define SOC_DELAY_RC32K_ENABLE 300 -#define SOC_DELAY_LP_PLL_SWITCH 3 -#define SOC_DELAY_LP_PLL_ENABLE 50 #define RTC_CNTL_PLL_BUF_WAIT_DEFAULT 20 #define RTC_CNTL_XTL_BUF_WAIT_DEFAULT 100 +// TODO: IDF-11548 check all following values! + #define RTC_CNTL_CK8M_DFREQ_DEFAULT 860 #define RTC_CNTL_SCK_DCAP_DEFAULT 85 -#define RTC_CNTL_RC32K_DFREQ_DEFAULT 700 /* Various delays to be programmed into power control state machines */ #define RTC_CNTL_XTL_BUF_WAIT_SLP_US (250) @@ -84,29 +78,29 @@ extern "C" { #define RTC_CNTL_OTHER_BLOCKS_WAIT_CYCLES (1) #define RTC_CNTL_MIN_SLP_VAL_MIN (2) -/* -set sleep_init default param -*/ -#define RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_DEFAULT 5 -#define RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_NODROP 0 -#define RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT 15 -#define RTC_CNTL_DBG_ATTEN_MONITOR_DEFAULT 0 -#define RTC_CNTL_BIASSLP_MONITOR_DEFAULT 0 -#define RTC_CNTL_BIASSLP_SLEEP_ON 0 -#define RTC_CNTL_BIASSLP_SLEEP_DEFAULT 1 -#define RTC_CNTL_PD_CUR_MONITOR_DEFAULT 0 -#define RTC_CNTL_PD_CUR_SLEEP_ON 0 -#define RTC_CNTL_PD_CUR_SLEEP_DEFAULT 1 -#define RTC_CNTL_DG_VDD_DRV_B_SLP_DEFAULT 254 +// /* +// set sleep_init default param +// */ +// #define RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_DEFAULT 5 +// #define RTC_CNTL_DBG_ATTEN_LIGHTSLEEP_NODROP 0 +// #define RTC_CNTL_DBG_ATTEN_DEEPSLEEP_DEFAULT 15 +// #define RTC_CNTL_DBG_ATTEN_MONITOR_DEFAULT 0 +// #define RTC_CNTL_BIASSLP_MONITOR_DEFAULT 0 +// #define RTC_CNTL_BIASSLP_SLEEP_ON 0 +// #define RTC_CNTL_BIASSLP_SLEEP_DEFAULT 1 +// #define RTC_CNTL_PD_CUR_MONITOR_DEFAULT 0 +// #define RTC_CNTL_PD_CUR_SLEEP_ON 0 +// #define RTC_CNTL_PD_CUR_SLEEP_DEFAULT 1 +// #define RTC_CNTL_DG_VDD_DRV_B_SLP_DEFAULT 254 -/* -The follow value is used to get a reasonable rtc voltage dbias value according to digital dbias & some other value -storing in efuse (based on ATE 5k ECO3 chips) -*/ -#define K_RTC_MID_MUL10000 215 -#define K_DIG_MID_MUL10000 213 -#define V_RTC_MID_MUL10000 10800 -#define V_DIG_MID_MUL10000 10860 +// /* +// The follow value is used to get a reasonable rtc voltage dbias value according to digital dbias & some other value +// storing in efuse +// */ +// #define K_RTC_MID_MUL10000 215 +// #define K_DIG_MID_MUL10000 213 +// #define V_RTC_MID_MUL10000 10800 +// #define V_DIG_MID_MUL10000 10860 /** * @brief CPU clock configuration structure @@ -132,11 +126,10 @@ typedef struct rtc_cpu_freq_config_s { */ typedef enum { RTC_CAL_RTC_MUX = -1, //!< Currently selected RTC_SLOW_CLK - RTC_CAL_RC_SLOW = SOC_RTC_SLOW_CLK_SRC_RC_SLOW, //!< Internal 150kHz RC oscillator - RTC_CAL_RC32K = SOC_RTC_SLOW_CLK_SRC_RC32K, //!< Internal 32kHz RC oscillator, as one type of 32k clock + RTC_CAL_RC_SLOW = SOC_RTC_SLOW_CLK_SRC_RC_SLOW, //!< Internal 600kHz RC oscillator RTC_CAL_32K_XTAL = SOC_RTC_SLOW_CLK_SRC_XTAL32K, //!< External 32kHz XTAL, as one type of 32k clock RTC_CAL_32K_OSC_SLOW = SOC_RTC_SLOW_CLK_SRC_OSC_SLOW, //!< External slow clock signal input by lp_pad_gpiox, as one type of 32k clock - RTC_CAL_RC_FAST //!< Internal 8MHz RC oscillator + RTC_CAL_RC_FAST //!< Internal 20MHz RC oscillator } rtc_cal_sel_t; /** @@ -148,29 +141,27 @@ typedef struct { soc_rtc_fast_clk_src_t fast_clk_src : 2; //!< RTC_FAST_CLK clock source to choose soc_rtc_slow_clk_src_t slow_clk_src : 3; //!< RTC_SLOW_CLK clock source to choose uint32_t clk_rtc_clk_div : 8; - uint32_t clk_8m_clk_div : 3; //!< RC_FAST clock divider (division is by clk_8m_div+1, i.e. 0 means ~8MHz frequency) + uint32_t clk_8m_clk_div : 3; //!< RC_FAST clock divider (division is by clk_8m_div+1, i.e. 0 means ~20MHz frequency) uint32_t slow_clk_dcap : 8; //!< RC_SLOW clock adjustment parameter (higher value leads to lower frequency) uint32_t clk_8m_dfreq : 10; //!< RC_FAST clock adjustment parameter (higher value leads to higher frequency) - uint32_t rc32k_dfreq : 10; //!< Internal RC32K clock adjustment parameter (higher value leads to higher frequency) } rtc_clk_config_t; /** * Default initializer for rtc_clk_config_t */ #define RTC_CLK_CONFIG_DEFAULT() { \ - .xtal_freq = SOC_XTAL_FREQ_32M, \ - .cpu_freq_mhz = 96, \ + .xtal_freq = CONFIG_XTAL_FREQ, \ + .cpu_freq_mhz = 64, \ .fast_clk_src = SOC_RTC_FAST_CLK_SRC_RC_FAST, \ .slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW, \ .clk_rtc_clk_div = 0, \ .clk_8m_clk_div = 0, \ .slow_clk_dcap = RTC_CNTL_SCK_DCAP_DEFAULT, \ .clk_8m_dfreq = RTC_CNTL_CK8M_DFREQ_DEFAULT, \ - .rc32k_dfreq = RTC_CNTL_RC32K_DFREQ_DEFAULT, \ } /** - * Initialize clocks and set CPU frequency + * @brief Initialize clocks and set CPU frequency * * @param cfg clock configuration as rtc_clk_config_t */ @@ -179,23 +170,10 @@ void rtc_clk_init(rtc_clk_config_t cfg); /** * @brief Get main XTAL frequency * - * This is the value stored in RTC register RTC_XTAL_FREQ_REG by the bootloader. As passed to - * rtc_clk_init function - * * @return XTAL frequency, one of soc_xtal_freq_t */ soc_xtal_freq_t rtc_clk_xtal_freq_get(void); -/** - * @brief Update XTAL frequency - * - * Updates the XTAL value stored in RTC_XTAL_FREQ_REG. Usually this value is ignored - * after startup. - * - * @param xtal_freq New frequency value - */ -void rtc_clk_xtal_freq_update(soc_xtal_freq_t xtal_freq); - /** * @brief Enable or disable 32 kHz XTAL oscillator * @param en true to enable, false to disable @@ -230,12 +208,6 @@ bool rtc_clk_32k_enabled(void); */ void rtc_clk_32k_bootstrap(uint32_t cycle); -/** - * @brief Enable or disable 32 kHz internal rc oscillator - * @param en true to enable, false to disable - */ -void rtc_clk_rc32k_enable(bool enable); - /** * @brief Enable or disable 8 MHz internal oscillator * @@ -249,20 +221,6 @@ void rtc_clk_8m_enable(bool clk_8m_en); */ bool rtc_clk_8m_enabled(void); -/** - * @brief Enable or disable LP_PLL_CLK - * Note that to be able to use LP_PLL clock, besides turn on the power for LP_PLL, also needs to turn on the power for - * the LP_PLL clock source (either XTAL32K or RC32K). - * @param enable true to enable, false to disable - */ -void rtc_clk_lp_pll_enable(bool enable); - -/** - * @brief Select clock source for LP_PLL_CLK - * @param clk_src clock source (one of soc_lp_pll_clk_src_t values) - */ -void rtc_clk_lp_pll_src_set(soc_lp_pll_clk_src_t clk_src); - /** * @brief Select source for RTC_SLOW_CLK * @param clk_src clock source (one of soc_rtc_slow_clk_src_t values) @@ -278,9 +236,8 @@ soc_rtc_slow_clk_src_t rtc_clk_slow_src_get(void); /** * @brief Get the approximate frequency of RTC_SLOW_CLK, in Hz * - * - if SOC_RTC_SLOW_CLK_SRC_RC_SLOW is selected, returns 136000 + * - if SOC_RTC_SLOW_CLK_SRC_RC_SLOW is selected, returns 600000 * - if SOC_RTC_SLOW_CLK_SRC_XTAL32K is selected, returns 32768 - * - if SOC_RTC_SLOW_CLK_SRC_RC32K is selected, returns 32768 * - if SOC_RTC_SLOW_CLK_SRC_OSC_SLOW is selected, returns 32768 * * rtc_clk_cal function can be used to get more precise value by comparing @@ -359,14 +316,15 @@ void rtc_clk_cpu_freq_get_config(rtc_cpu_freq_config_t *out_config); * rtc_clk_cpu_freq_set_config when a switch to XTAL is needed. * Assumes that XTAL frequency has been determined — don't call in startup code. * - * @note On ESP32H21, this function will check whether BBPLL can be disabled. If there is no consumer, then BBPLL will be - * turned off. The behaviour is the same as using rtc_clk_cpu_freq_set_config to switch cpu clock source to XTAL. + * @note This function always disables BBPLL after switching the CPU clock source to XTAL for power saving purpose. + * If this is unwanted, please use rtc_clk_cpu_freq_set_config. It helps to check whether USB Serial JTAG is in use, + * if so, then BBPLL will not be turned off. */ void rtc_clk_cpu_freq_set_xtal(void); /** - * @brief Get the current stored APB frequency. - * @return The APB frequency value as last set via rtc_clk_apb_freq_update(), in Hz. + * @brief Get the current APB frequency. + * @return The calculated APB frequency value, in Hz. */ uint32_t rtc_clk_apb_freq_get(void); @@ -378,6 +336,11 @@ uint32_t rtc_clk_apb_freq_get(void); * 32k XTAL is being calibrated, but the oscillator has not started up (due to * incorrect loading capacitance, board design issue, or lack of 32 XTAL on board). * + * @note When 32k CLK is being calibrated, this function will check the accuracy + * of the clock. Since the xtal 32k or ext osc 32k is generally very stable, if + * the check fails, then consider this an invalid 32k clock and return 0. This + * check can filter some jamming signal. + * * @param cal_clk clock to be measured * @param slow_clk_cycles number of slow clock cycles to average * @return average slow clock period in microseconds, Q13.19 fixed point format, @@ -452,49 +415,6 @@ uint32_t rtc_clk_freq_cal(uint32_t cal_val); */ uint32_t rtc_clk_freq_to_period(uint32_t freq_hz); -// -------------------------- CLOCK TREE DEFS ALIAS ---------------------------- -// **WARNING**: The following are only for backwards compatibility. -// Please use the declarations in soc/clk_tree_defs.h instead. -/** - * @brief CPU clock source - */ -typedef soc_cpu_clk_src_t rtc_cpu_freq_src_t; -#define RTC_CPU_FREQ_SRC_XTAL SOC_CPU_CLK_SRC_XTAL //!< XTAL -#define RTC_CPU_FREQ_SRC_PLL SOC_CPU_CLK_SRC_PLL //!< PLL (96M) -#define RTC_CPU_FREQ_SRC_8M SOC_CPU_CLK_SRC_RC_FAST //!< Internal 8M RTC oscillator - -/** - * @brief RTC SLOW_CLK frequency values - */ -typedef soc_rtc_slow_clk_src_t rtc_slow_freq_t; -#define RTC_SLOW_FREQ_RTC SOC_RTC_SLOW_CLK_SRC_RC_SLOW //!< Internal 150 kHz RC oscillator -#define RTC_SLOW_FREQ_32K_XTAL SOC_RTC_SLOW_CLK_SRC_XTAL32K //!< External 32 kHz XTAL - -/** - * @brief RTC FAST_CLK frequency values - */ -typedef soc_rtc_fast_clk_src_t rtc_fast_freq_t; -#define RTC_FAST_FREQ_XTALD4 SOC_RTC_FAST_CLK_SRC_XTAL_DIV //!< Main XTAL, divided by 2 -#define RTC_FAST_FREQ_8M SOC_RTC_FAST_CLK_SRC_RC_FAST //!< Internal 8 MHz RC oscillator - -/** - * @brief Possible main XTAL frequency values. - */ -typedef soc_xtal_freq_t rtc_xtal_freq_t; -#define RTC_XTAL_FREQ_32M SOC_XTAL_FREQ_32M //!< 32 MHz XTAL - -/* Alias of frequency related macros */ -#define RTC_FAST_CLK_FREQ_APPROX SOC_CLK_RC_FAST_FREQ_APPROX -#define RTC_FAST_CLK_FREQ_8M SOC_CLK_RC_FAST_FREQ_APPROX -#define RTC_SLOW_CLK_FREQ_150K SOC_CLK_RC_SLOW_FREQ_APPROX -#define RTC_SLOW_CLK_FREQ_32K SOC_CLK_XTAL32K_FREQ_APPROX - -/* Alias of deprecated function names */ -#define rtc_clk_slow_freq_set(slow_freq) rtc_clk_slow_src_set(slow_freq) -#define rtc_clk_slow_freq_get() rtc_clk_slow_src_get() -#define rtc_clk_fast_freq_set(fast_freq) rtc_clk_fast_src_set(fast_freq) -#define rtc_clk_fast_freq_get() rtc_clk_fast_src_get() - #ifdef __cplusplus } #endif diff --git a/components/esp_hw_support/port/esp32h21/pmu_init.c b/components/esp_hw_support/port/esp32h21/pmu_init.c index 5e0a07c105..9d8300a0a3 100644 --- a/components/esp_hw_support/port/esp32h21/pmu_init.c +++ b/components/esp_hw_support/port/esp32h21/pmu_init.c @@ -3,7 +3,6 @@ * * SPDX-License-Identifier: Apache-2.0 */ - #include #include #include @@ -15,8 +14,9 @@ #include "pmu_param.h" #include "esp_private/esp_pmu.h" #include "soc/regi2c_pmu.h" -#include "soc/regi2c_bias.h" #include "regi2c_ctrl.h" +#include "esp_private/ocode_init.h" +#include "esp_rom_sys.h" static __attribute__((unused)) const char *TAG = "pmu_init"; @@ -248,4 +248,11 @@ void pmu_init() pmu_lp_system_init_default(PMU_instance()); pmu_power_domain_force_default(PMU_instance()); + +#if !CONFIG_IDF_ENV_FPGA + // TODO: IDF-11548 + // if (esp_rom_get_reset_reason(0) == RESET_REASON_CHIP_POWER_ON) { + // esp_ocode_calib_init(); + // } +#endif } diff --git a/components/esp_hw_support/port/esp32h21/pmu_param.c b/components/esp_hw_support/port/esp32h21/pmu_param.c index 991564a25d..1f709df7fa 100644 --- a/components/esp_hw_support/port/esp32h21/pmu_param.c +++ b/components/esp_hw_support/port/esp32h21/pmu_param.c @@ -3,7 +3,6 @@ * * SPDX-License-Identifier: Apache-2.0 */ - #include #include #include diff --git a/components/esp_hw_support/port/esp32h21/pmu_sleep.c b/components/esp_hw_support/port/esp32h21/pmu_sleep.c index 06987dfe67..af1a662878 100644 --- a/components/esp_hw_support/port/esp32h21/pmu_sleep.c +++ b/components/esp_hw_support/port/esp32h21/pmu_sleep.c @@ -132,6 +132,7 @@ static inline pmu_sleep_param_config_t * pmu_sleep_param_config_default( const pmu_sleep_config_t* pmu_sleep_config_default( pmu_sleep_config_t *config, uint32_t sleep_flags, + uint32_t clk_flags, uint32_t adjustment, soc_rtc_slow_clk_src_t slowclk_src, uint32_t slowclk_period, @@ -146,11 +147,14 @@ const pmu_sleep_config_t* pmu_sleep_config_default( config->param = *pmu_sleep_param_config_default(¶m_default, &power_default, sleep_flags, adjustment, slowclk_period, fastclk_period); if (dslp) { + pmu_sleep_digital_config_t digital_default = PMU_SLEEP_DIGITAL_DSLP_CONFIG_DEFAULT(sleep_flags, clk_flags); + config->digital = digital_default; + pmu_sleep_analog_config_t analog_default = PMU_SLEEP_ANALOG_DSLP_CONFIG_DEFAULT(sleep_flags); analog_default.lp_sys[LP(SLEEP)].analog.dbias = get_slp_lp_dbias(); config->analog = analog_default; } else { - pmu_sleep_digital_config_t digital_default = PMU_SLEEP_DIGITAL_LSLP_CONFIG_DEFAULT(sleep_flags); + pmu_sleep_digital_config_t digital_default = PMU_SLEEP_DIGITAL_LSLP_CONFIG_DEFAULT(sleep_flags, clk_flags); config->digital = digital_default; pmu_sleep_analog_config_t analog_default = PMU_SLEEP_ANALOG_LSLP_CONFIG_DEFAULT(sleep_flags); @@ -188,9 +192,13 @@ static void pmu_sleep_power_init(pmu_context_t *ctx, const pmu_sleep_power_confi pmu_ll_lp_set_xtal_xpd (ctx->hal->dev, LP(SLEEP), power->lp_sys[LP(SLEEP)].xtal.xpd_xtal); } -static void pmu_sleep_digital_init(pmu_context_t *ctx, const pmu_sleep_digital_config_t *dig) +static void pmu_sleep_digital_init(pmu_context_t *ctx, const pmu_sleep_digital_config_t *dig, bool dslp) { - pmu_ll_hp_set_dig_pad_slp_sel (ctx->hal->dev, HP(SLEEP), dig->syscntl.dig_pad_slp_sel); + pmu_ll_hp_set_icg_sysclk_enable(ctx->hal->dev, HP(SLEEP), (dig->icg_func != 0)); + pmu_ll_hp_set_icg_func(ctx->hal->dev, HP(SLEEP), dig->icg_func); + if (!dslp) { + pmu_ll_hp_set_dig_pad_slp_sel (ctx->hal->dev, HP(SLEEP), dig->syscntl.dig_pad_slp_sel); + } } static void pmu_sleep_analog_init(pmu_context_t *ctx, const pmu_sleep_analog_config_t *analog, bool dslp) @@ -234,9 +242,7 @@ void pmu_sleep_init(const pmu_sleep_config_t *config, bool dslp) { assert(PMU_instance()); pmu_sleep_power_init(PMU_instance(), &config->power, dslp); - if (!dslp) { - pmu_sleep_digital_init(PMU_instance(), &config->digital); - } + pmu_sleep_digital_init(PMU_instance(), &config->digital, dslp); pmu_sleep_analog_init(PMU_instance(), &config->analog, dslp); pmu_sleep_param_init(PMU_instance(), &config->param, dslp); } diff --git a/components/esp_hw_support/port/esp32h21/private_include/pmu_param.h b/components/esp_hw_support/port/esp32h21/private_include/pmu_param.h index f0fd3e7704..502b0e6edb 100644 --- a/components/esp_hw_support/port/esp32h21/private_include/pmu_param.h +++ b/components/esp_hw_support/port/esp32h21/private_include/pmu_param.h @@ -16,8 +16,8 @@ extern "C" { #endif -#define HP_CALI_DBIAS_DEFAULT 17 -#define LP_CALI_DBIAS_DEFAULT 18 +#define HP_CALI_DBIAS_DEFAULT 0 +#define LP_CALI_DBIAS_DEFAULT 0 // FOR XTAL FORCE PU IN SLEEP #define PMU_PD_CUR_SLEEP_ON 0 @@ -285,13 +285,13 @@ typedef struct { } lp_sys[PMU_MODE_LP_MAX]; } pmu_sleep_power_config_t; -#define PMU_SLEEP_POWER_CONFIG_DEFAULT(pd_flags) { \ +#define PMU_SLEEP_POWER_CONFIG_DEFAULT(sleep_flags) { \ .hp_sys = { \ .dig_power = { \ .vdd_flash_mode = 3, \ - .wifi_pd_en = ((pd_flags) & PMU_SLEEP_PD_MODEM) ? 1 : 0, \ - .cpu_pd_en = ((pd_flags) & PMU_SLEEP_PD_CPU) ? 1 : 0, \ - .top_pd_en = ((pd_flags) & PMU_SLEEP_PD_TOP) ? 1 : 0, \ + .wifi_pd_en = ((sleep_flags) & PMU_SLEEP_PD_MODEM) ? 1 : 0,\ + .cpu_pd_en = ((sleep_flags) & PMU_SLEEP_PD_CPU) ? 1 : 0,\ + .top_pd_en = ((sleep_flags) & PMU_SLEEP_PD_TOP) ? 1 : 0,\ .mem_pd_en = 0, \ .mem_dslp = 0 \ }, \ @@ -304,7 +304,7 @@ typedef struct { }, \ .xtal = { \ .xpd_xtalx2 = 0, \ - .xpd_xtal = ((pd_flags) & PMU_SLEEP_PD_XTAL) ? 0 : 1, \ + .xpd_xtal = ((sleep_flags) & PMU_SLEEP_PD_XTAL) ? 0 : 1, \ } \ }, \ .lp_sys[PMU_MODE_LP_ACTIVE] = { \ @@ -317,8 +317,8 @@ typedef struct { }, \ .clk_power = { \ .xpd_lppll = 0, \ - .xpd_xtal32k = ((pd_flags) & PMU_SLEEP_PD_XTAL32K) ? 0 : 1, \ - .xpd_rc32k = ((pd_flags) & PMU_SLEEP_PD_RC32K) ? 0 : 1, \ + .xpd_xtal32k = ((sleep_flags) & PMU_SLEEP_PD_XTAL32K) ? 0 : 1, \ + .xpd_rc32k = ((sleep_flags) & PMU_SLEEP_PD_RC32K) ? 0 : 1, \ .xpd_fosc = 1 \ } \ }, \ @@ -327,18 +327,18 @@ typedef struct { .vdd_io_mode = 11, \ .bod_source_sel = 0, \ .vddbat_mode = 1, \ - .peri_pd_en = ((pd_flags) & PMU_SLEEP_PD_LP_PERIPH) ? 1 : 0,\ + .peri_pd_en = ((sleep_flags) & PMU_SLEEP_PD_LP_PERIPH) ? 1 : 0,\ .mem_dslp = 1 \ }, \ .clk_power = { \ .xpd_lppll = 0, \ - .xpd_xtal32k = ((pd_flags) & PMU_SLEEP_PD_XTAL32K) ? 0 : 1, \ - .xpd_rc32k = ((pd_flags) & PMU_SLEEP_PD_RC32K) ? 0 : 1, \ - .xpd_fosc = ((pd_flags) & PMU_SLEEP_PD_RC_FAST) ? 0 : 1 \ + .xpd_xtal32k = ((sleep_flags) & PMU_SLEEP_PD_XTAL32K) ? 0 : 1, \ + .xpd_rc32k = ((sleep_flags) & PMU_SLEEP_PD_RC32K) ? 0 : 1, \ + .xpd_fosc = ((sleep_flags) & PMU_SLEEP_PD_RC_FAST) ? 0 : 1 \ }, \ .xtal = { \ .xpd_xtalx2 = 0, \ - .xpd_xtal = ((pd_flags) & PMU_SLEEP_PD_XTAL) ? 0 : 1, \ + .xpd_xtal = ((sleep_flags) & PMU_SLEEP_PD_XTAL) ? 0 : 1, \ } \ } \ } @@ -346,14 +346,24 @@ typedef struct { typedef struct { pmu_hp_sys_cntl_reg_t syscntl; + uint32_t icg_func; } pmu_sleep_digital_config_t; -#define PMU_SLEEP_DIGITAL_LSLP_CONFIG_DEFAULT(pd_flags) { \ +#define PMU_SLEEP_DIGITAL_LSLP_CONFIG_DEFAULT(sleep_flags, clk_flags) { \ .syscntl = { \ - .dig_pad_slp_sel = ((pd_flags) & PMU_SLEEP_PD_TOP) ? 0 : 1, \ - } \ + .dig_pad_slp_sel = ((sleep_flags) & PMU_SLEEP_PD_TOP) ? 0 : 1, \ + }, \ + .icg_func = clk_flags \ } +#define PMU_SLEEP_DIGITAL_DSLP_CONFIG_DEFAULT(sleep_flags, clk_flags) { \ + .syscntl = { \ + .dig_pad_slp_sel = 1, \ + }, \ + .icg_func = 0 \ +} + + typedef struct { struct { pmu_hp_analog_t analog; @@ -363,7 +373,7 @@ typedef struct { } lp_sys[PMU_MODE_LP_MAX]; } pmu_sleep_analog_config_t; -#define PMU_SLEEP_ANALOG_LSLP_CONFIG_DEFAULT(pd_flags) { \ +#define PMU_SLEEP_ANALOG_LSLP_CONFIG_DEFAULT(sleep_flags) { \ .hp_sys = { \ .analog = { \ .dcdc_ccm_enb = 1, \ @@ -417,7 +427,7 @@ typedef struct { } \ } -#define PMU_SLEEP_ANALOG_DSLP_CONFIG_DEFAULT(pd_flags) { \ +#define PMU_SLEEP_ANALOG_DSLP_CONFIG_DEFAULT(sleep_flags) { \ .hp_sys = { \ .analog = { \ .dcdc_ccm_enb = 0, \ @@ -477,7 +487,7 @@ typedef struct { pmu_hp_lp_param_t hp_lp; } pmu_sleep_param_config_t; -#define PMU_SLEEP_PARAM_CONFIG_DEFAULT(pd_flags) { \ +#define PMU_SLEEP_PARAM_CONFIG_DEFAULT(sleep_flags) { \ .hp_sys = { \ .min_slp_slow_clk_cycle = PMU_HP_SLEEP_MIN_SLOW_CLK_CYCLES, \ .analog_wait_target_cycle = PMU_HP_ANALOG_WAIT_TARGET_CYCLES, \ diff --git a/components/esp_hw_support/port/esp32h21/rtc_clk.c b/components/esp_hw_support/port/esp32h21/rtc_clk.c index 9e15e2d7af..10f0ca990e 100644 --- a/components/esp_hw_support/port/esp32h21/rtc_clk.c +++ b/components/esp_hw_support/port/esp32h21/rtc_clk.c @@ -10,17 +10,18 @@ #include #include #include "sdkconfig.h" -#include "rom/rtc.h" +#include "esp32h21/rom/rtc.h" #include "soc/rtc.h" #include "esp_private/rtc_clk.h" #include "esp_hw_log.h" #include "esp_rom_sys.h" #include "hal/clk_tree_ll.h" #include "hal/regi2c_ctrl_ll.h" -#include "soc/io_mux_reg.h" +#include "hal/gpio_ll.h" #include "soc/lp_aon_reg.h" #include "esp_private/sleep_event.h" #include "esp_private/regi2c_ctrl.h" +#include "esp_private/esp_clk_tree_common.h" static const char *TAG = "rtc_clk"; @@ -50,22 +51,21 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_13 - PIN_INPUT_ENABLE(IO_MUX_GPIO13_REG); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - PIN_INPUT_DISABLE(IO_MUX_GPIO13_REG); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } void rtc_clk_32k_bootstrap(uint32_t cycle) { - /* No special bootstrapping needed for ESP32-H2, 'cycle' argument is to keep the signature + /* No special bootstrapping needed for ESP32-H21, 'cycle' argument is to keep the signature * same as for the ESP32. Just enable the XTAL here. */ (void)cycle; @@ -77,16 +77,6 @@ bool rtc_clk_32k_enabled(void) return clk_ll_xtal32k_is_enabled(); } -void rtc_clk_rc32k_enable(bool enable) -{ - if (enable) { - clk_ll_rc32k_enable(); - esp_rom_delay_us(SOC_DELAY_RC32K_ENABLE); - } else { - clk_ll_rc32k_disable(); - } -} - void rtc_clk_8m_enable(bool clk_8m_en) { if (clk_8m_en) { @@ -102,22 +92,6 @@ bool rtc_clk_8m_enabled(void) return clk_ll_rc_fast_is_enabled(); } -void rtc_clk_lp_pll_enable(bool enable) -{ - if (enable) { - clk_ll_lp_pll_enable(); - esp_rom_delay_us(SOC_DELAY_LP_PLL_ENABLE); - } else { - clk_ll_lp_pll_disable(); - } -} - -void rtc_clk_lp_pll_src_set(soc_lp_pll_clk_src_t clk_src) -{ - clk_ll_lp_pll_set_src(clk_src); - esp_rom_delay_us(SOC_DELAY_LP_PLL_SWITCH); -} - void rtc_clk_slow_src_set(soc_rtc_slow_clk_src_t clk_src) { clk_ll_rtc_slow_set_src(clk_src); @@ -134,7 +108,6 @@ uint32_t rtc_clk_slow_freq_get_hz(void) switch (rtc_clk_slow_src_get()) { case SOC_RTC_SLOW_CLK_SRC_RC_SLOW: return SOC_CLK_RC_SLOW_FREQ_APPROX; case SOC_RTC_SLOW_CLK_SRC_XTAL32K: return SOC_CLK_XTAL32K_FREQ_APPROX; - case SOC_RTC_SLOW_CLK_SRC_RC32K: return SOC_CLK_RC32K_FREQ_APPROX; case SOC_RTC_SLOW_CLK_SRC_OSC_SLOW: return SOC_CLK_OSC_SLOW_FREQ_APPROX; default: return 0; } @@ -174,7 +147,7 @@ static void rtc_clk_bbpll_configure(soc_xtal_freq_t xtal_freq, int pll_freq) clk_ll_bbpll_set_config(pll_freq, xtal_freq); /* WAIT CALIBRATION DONE */ while(!regi2c_ctrl_ll_bbpll_calibration_is_done()); - esp_rom_delay_us(10); + esp_rom_delay_us(10); // wait for true stop /* BBPLL CALIBRATION STOP */ regi2c_ctrl_ll_bbpll_calibration_stop(); ANALOG_CLOCK_DISABLE(); @@ -197,14 +170,14 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { // let f_cpu = f_ahb clk_ll_cpu_set_divider(1); clk_ll_ahb_set_divider(1); clk_ll_cpu_set_src(SOC_CPU_CLK_SRC_RC_FAST); clk_ll_bus_update(); - esp_rom_set_cpu_ticks_per_us(8); + esp_rom_set_cpu_ticks_per_us(20); } /** @@ -227,18 +200,18 @@ static void rtc_clk_cpu_freq_to_pll_mhz(int cpu_freq_mhz) } /** - * Switch to FLASH_PLL as cpu clock source. - * On ESP32H2, FLASH_PLL frequency is 64MHz. - * PLL must already be enabled. + * Switch to XTAL_X2 as cpu clock source. + * On ESP32H21, XTAL_X2 frequency is 64MHz. + * XTAL_X2 circuit must already been enabled. */ -static void rtc_clk_cpu_freq_to_flash_pll(uint32_t cpu_freq_mhz, uint32_t cpu_divider) +static void rtc_clk_cpu_freq_to_xtal_x2(uint32_t cpu_freq_mhz, uint32_t cpu_divider) { // f_hp_root = 64MHz clk_ll_cpu_set_divider(cpu_divider); // Constraint: f_ahb <= 32MHz; f_cpu = N * f_ahb (N = 1, 2, 3...) uint32_t ahb_divider = (cpu_divider == 1) ? 2 : cpu_divider; clk_ll_ahb_set_divider(ahb_divider); - clk_ll_cpu_set_src(SOC_CPU_CLK_SRC_FLASH_PLL); + clk_ll_cpu_set_src(SOC_CPU_CLK_SRC_XTAL_X2); clk_ll_bus_update(); esp_rom_set_cpu_ticks_per_us(cpu_freq_mhz); } @@ -268,7 +241,7 @@ bool rtc_clk_cpu_freq_mhz_to_config(uint32_t freq_mhz, rtc_cpu_freq_config_t *ou divider = 1; } else if (freq_mhz == 64) { real_freq_mhz = freq_mhz; - source = SOC_CPU_CLK_SRC_FLASH_PLL; + source = SOC_CPU_CLK_SRC_XTAL_X2; source_freq_mhz = CLK_LL_PLL_64M_FREQ_MHZ; divider = 1; } else if (freq_mhz == 48) { @@ -293,39 +266,55 @@ __attribute__((weak)) void rtc_clk_set_cpu_switch_to_pll(int event_id) { } +static void rtc_clk_cpu_src_clk_enable(soc_cpu_clk_src_t new_src, uint32_t new_src_freq_mhz) +{ + if (new_src == SOC_CPU_CLK_SRC_PLL) { + rtc_clk_bbpll_enable(); + rtc_clk_bbpll_configure(rtc_clk_xtal_freq_get(), new_src_freq_mhz); + } else if (new_src == SOC_CPU_CLK_SRC_XTAL_X2) { +#if BOOTLOADER_BUILD + clk_ll_xtal_x2_enable(); +#else + esp_clk_tree_enable_power(SOC_ROOT_CIRCUIT_CLK_XTAL_X2, true); +#endif + } +} + +static void rtc_clk_cpu_src_clk_disable(soc_cpu_clk_src_t old_src) +{ + if ((old_src == SOC_CPU_CLK_SRC_PLL) && !s_bbpll_digi_consumers_ref_count) { + rtc_clk_bbpll_disable(); + } else if (old_src == SOC_CPU_CLK_SRC_XTAL_X2) { +#if BOOTLOADER_BUILD + clk_ll_xtal_x2_disable(); +#else + esp_clk_tree_enable_power(SOC_ROOT_CIRCUIT_CLK_XTAL_X2, false); +#endif + } +} + void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) { soc_cpu_clk_src_t old_cpu_clk_src = clk_ll_cpu_get_src(); + + if (old_cpu_clk_src != config->source) { + rtc_clk_cpu_src_clk_enable(config->source, config->source_freq_mhz); + } + if (config->source == SOC_CPU_CLK_SRC_XTAL) { rtc_clk_cpu_freq_to_xtal(config->freq_mhz, config->div); - if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL || old_cpu_clk_src == SOC_CPU_CLK_SRC_FLASH_PLL) && - !s_bbpll_digi_consumers_ref_count) { - rtc_clk_bbpll_disable(); - } } else if (config->source == SOC_CPU_CLK_SRC_PLL) { - if (old_cpu_clk_src != SOC_CPU_CLK_SRC_PLL && old_cpu_clk_src != SOC_CPU_CLK_SRC_FLASH_PLL) { - rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_START); - rtc_clk_bbpll_enable(); - rtc_clk_bbpll_configure(rtc_clk_xtal_freq_get(), config->source_freq_mhz); - } + rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_START); rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); - if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL || old_cpu_clk_src == SOC_CPU_CLK_SRC_FLASH_PLL) && - !s_bbpll_digi_consumers_ref_count) { - rtc_clk_bbpll_disable(); - } - } else if (config->source == SOC_CPU_CLK_SRC_FLASH_PLL) { - if (old_cpu_clk_src != SOC_CPU_CLK_SRC_PLL && old_cpu_clk_src != SOC_CPU_CLK_SRC_FLASH_PLL) { - // On ESP32H2, FLASH_PLL (64MHz) is directly derived from the BBPLL (96MHz) - // Therefore, enabling and configuration are applied to BBPLL. - rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_FLASH_BBPLL_EN_START); - rtc_clk_bbpll_enable(); - rtc_clk_bbpll_configure(rtc_clk_xtal_freq_get(), CLK_LL_PLL_96M_FREQ_MHZ); - } - rtc_clk_cpu_freq_to_flash_pll(config->freq_mhz, config->div); - rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_FLASH_BBPLL_EN_STOP); + rtc_clk_cpu_freq_to_rc_fast(); + } else if (config->source == SOC_CPU_CLK_SRC_XTAL_X2) { + rtc_clk_cpu_freq_to_xtal_x2(config->freq_mhz, config->div); + } + + if (old_cpu_clk_src != config->source) { + rtc_clk_cpu_src_clk_disable(old_cpu_clk_src); } } @@ -347,11 +336,11 @@ void rtc_clk_cpu_freq_get_config(rtc_cpu_freq_config_t *out_config) break; } case SOC_CPU_CLK_SRC_RC_FAST: - source_freq_mhz = 8; + source_freq_mhz = 20; freq_mhz = source_freq_mhz / div; break; - case SOC_CPU_CLK_SRC_FLASH_PLL: - source_freq_mhz = clk_ll_flash_pll_get_freq_mhz(); + case SOC_CPU_CLK_SRC_XTAL_X2: + source_freq_mhz = clk_ll_xtal_x2_get_freq_mhz(); freq_mhz = source_freq_mhz / div; break; default: @@ -374,12 +363,10 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == config->source_freq_mhz) { rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); - } else if (config->source == SOC_CPU_CLK_SRC_FLASH_PLL && - s_cur_pll_freq == clk_ll_bbpll_get_freq_mhz()) { - // On ESP32H2, FLASH_PLL (64MHz) is directly derived from the BBPLL (96MHz) - // Therefore, as long as bbpll was not disabled, no need to re-enable and re-configure parameters for the source clock - rtc_clk_cpu_freq_to_flash_pll(config->freq_mhz, config->div); + rtc_clk_cpu_freq_to_rc_fast(); + } else if (config->source == SOC_CPU_CLK_SRC_XTAL_X2 + && esp_clk_tree_is_power_on(SOC_ROOT_CIRCUIT_CLK_XTAL_X2)) { + rtc_clk_cpu_freq_to_xtal_x2(config->freq_mhz, config->div); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); @@ -407,19 +394,11 @@ void rtc_clk_cpu_freq_set_xtal_for_sleep(void) soc_xtal_freq_t rtc_clk_xtal_freq_get(void) { - uint32_t xtal_freq_mhz = clk_ll_xtal_load_freq_mhz(); - if (xtal_freq_mhz == 0) { - ESP_HW_LOGW(TAG, "invalid RTC_XTAL_FREQ_REG value, assume 32MHz"); - return SOC_XTAL_FREQ_32M; - } + uint32_t xtal_freq_mhz = clk_ll_xtal_get_freq_mhz(); + assert(xtal_freq_mhz == SOC_XTAL_FREQ_32M); return (soc_xtal_freq_t)xtal_freq_mhz; } -void rtc_clk_xtal_freq_update(soc_xtal_freq_t xtal_freq) -{ - clk_ll_xtal_store_freq_mhz(xtal_freq); -} - static uint32_t rtc_clk_ahb_freq_get(void) { soc_cpu_clk_src_t source = clk_ll_cpu_get_src(); @@ -433,10 +412,10 @@ static uint32_t rtc_clk_ahb_freq_get(void) soc_root_freq_mhz = clk_ll_bbpll_get_freq_mhz(); break; case SOC_CPU_CLK_SRC_RC_FAST: - soc_root_freq_mhz = 8; + soc_root_freq_mhz = 20; break; - case SOC_CPU_CLK_SRC_FLASH_PLL: - soc_root_freq_mhz = clk_ll_flash_pll_get_freq_mhz(); + case SOC_CPU_CLK_SRC_XTAL_X2: + soc_root_freq_mhz = clk_ll_xtal_x2_get_freq_mhz(); break; default: // Unknown SOC_ROOT clock source diff --git a/components/esp_hw_support/port/esp32h21/rtc_clk_init.c b/components/esp_hw_support/port/esp32h21/rtc_clk_init.c index 488e764b79..c10a4af66c 100644 --- a/components/esp_hw_support/port/esp32h21/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32h21/rtc_clk_init.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -9,8 +9,7 @@ #include #include #include "rom/ets_sys.h" -#include "rom/rtc.h" -#include "rom/uart.h" +#include "esp32h21/rom/rtc.h" #include "soc/rtc.h" #include "esp_cpu.h" #include "regi2c_ctrl.h" @@ -18,7 +17,6 @@ #include "soc/regi2c_pmu.h" #include "esp_hw_log.h" #include "sdkconfig.h" -#include "esp_rom_uart.h" #include "hal/clk_tree_ll.h" #include "soc/pmu_reg.h" #include "pmu_param.h" @@ -29,32 +27,26 @@ void rtc_clk_init(rtc_clk_config_t cfg) { rtc_cpu_freq_config_t old_config, new_config; - /* Set tuning parameters for RC_FAST, RC_SLOW, and RC32K clocks. + /* Set tuning parameters for RC_FAST and RC_SLOW clocks. * Note: this doesn't attempt to set the clocks to precise frequencies. * Instead, we calibrate these clocks against XTAL frequency later, when necessary. * - SCK_DCAP value controls tuning of RC_SLOW clock. * The higher the value of DCAP is, the lower is the frequency. * - CK8M_DFREQ value controls tuning of RC_FAST clock. * CLK_8M_DFREQ constant gives the best temperature characteristics. - * - RC32K_DFREQ value controls tuning of RC32K clock. */ REG_SET_FIELD(LP_CLKRST_FOSC_CNTL_REG, LP_CLKRST_FOSC_DFREQ, cfg.clk_8m_dfreq); - REGI2C_WRITE_MASK(I2C_PMU, I2C_PMU_OC_SCK_DCAP, cfg.slow_clk_dcap); - REG_SET_FIELD(LP_CLKRST_RC32K_CNTL_REG, LP_CLKRST_RC32K_DFREQ, cfg.rc32k_dfreq); - - REGI2C_WRITE_MASK(I2C_PMU, I2C_PMU_EN_I2C_RTC_DREG, 0); - REGI2C_WRITE_MASK(I2C_PMU, I2C_PMU_EN_I2C_DIG_DREG, 0); + REGI2C_WRITE_MASK(I2C_PMU, I2C_PMU_OC_SCK_DCAP, cfg.slow_clk_dcap); // TODO: IDF-11548 uint32_t hp_cali_dbias = get_act_hp_dbias(); uint32_t lp_cali_dbias = get_act_lp_dbias(); - SET_PERI_REG_BITS(PMU_HP_MODEM_HP_REGULATOR0_REG, PMU_HP_MODEM_HP_REGULATOR_DBIAS, hp_cali_dbias, PMU_HP_MODEM_HP_REGULATOR_DBIAS_S); SET_PERI_REG_BITS(PMU_HP_ACTIVE_HP_REGULATOR0_REG, PMU_HP_ACTIVE_HP_REGULATOR_DBIAS, hp_cali_dbias, PMU_HP_ACTIVE_HP_REGULATOR_DBIAS_S); SET_PERI_REG_BITS(PMU_HP_SLEEP_LP_REGULATOR0_REG, PMU_HP_SLEEP_LP_REGULATOR_DBIAS, lp_cali_dbias, PMU_HP_SLEEP_LP_REGULATOR_DBIAS_S); - soc_xtal_freq_t xtal_freq = cfg.xtal_freq; - esp_rom_output_tx_wait_idle(0); - rtc_clk_xtal_freq_update(xtal_freq); + // XTAL freq can be directly informed from register field PCR_CLK_XTAL_FREQ + + // No need to wait UART0 TX idle since its default clock source is XTAL, should not be affected by system clock configuration /* Set CPU frequency */ rtc_clk_cpu_freq_get_config(&old_config); @@ -77,8 +69,6 @@ void rtc_clk_init(rtc_clk_config_t cfg) rtc_clk_32k_enable(true); } else if (cfg.slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) { rtc_clk_32k_enable_external(); - } else if (cfg.slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) { - rtc_clk_rc32k_enable(true); } rtc_clk_8m_enable(need_rc_fast_en); rtc_clk_fast_src_set(cfg.fast_clk_src); diff --git a/components/esp_hw_support/port/esp32h21/rtc_time.c b/components/esp_hw_support/port/esp32h21/rtc_time.c index e2b9588d30..0c588a894f 100644 --- a/components/esp_hw_support/port/esp32h21/rtc_time.c +++ b/components/esp_hw_support/port/esp32h21/rtc_time.c @@ -5,7 +5,7 @@ */ #include -#include "rom/ets_sys.h" +#include "esp32h21/rom/ets_sys.h" #include "soc/rtc.h" #include "hal/lp_timer_hal.h" #include "hal/clk_tree_ll.h" @@ -14,8 +14,6 @@ #include "soc/pcr_reg.h" #include "esp_rom_sys.h" #include "assert.h" -#include "hal/efuse_hal.h" -#include "soc/chip_revision.h" #include "esp_private/periph_ctrl.h" __attribute__((unused)) static const char *TAG = "rtc_time"; @@ -23,42 +21,21 @@ __attribute__((unused)) static const char *TAG = "rtc_time"; /* Calibration of RTC_SLOW_CLK is performed using a special feature of TIMG0. * This feature counts the number of XTAL clock cycles within a given number of * RTC_SLOW_CLK cycles. - * - * Slow clock calibration feature has two modes of operation: one-off and cycling. - * In cycling mode (which is enabled by default on SoC reset), counting of XTAL - * cycles within RTC_SLOW_CLK cycle is done continuously. Cycling mode is enabled - * using TIMG_RTC_CALI_START_CYCLING bit. In one-off mode counting is performed - * once, and TIMG_RTC_CALI_RDY bit is set when counting is done. One-off mode is - * enabled using TIMG_RTC_CALI_START bit. */ +#define RTC_SLOW_CLK_600K_CAL_TIMEOUT_THRES(cycles) (cycles << 10) +#define RTC_SLOW_CLK_32K_CAL_TIMEOUT_THRES(cycles) (cycles << 12) +#define RTC_FAST_CLK_20M_CAL_TIMEOUT_THRES(cycles) (TIMG_RTC_CALI_TIMEOUT_THRES_V) // Just use the max timeout thres value + /* On ESP32H21, TIMG_RTC_CALI_CLK_SEL can config to 0, 1, 2, 3 * 0 or 3: calibrate RC_SLOW clock * 1: calibrate RC_FAST clock - * 2: calibrate 32K clock, which 32k depends on reg_32k_sel: 0: Internal 32 kHz RC oscillator, 1: External 32 kHz XTAL, 2: External 32kHz clock input by gpio13 + * 2: calibrate 32K clock, which 32k depends on reg_32k_sel: 1: External 32 kHz XTAL, 2: External 32kHz clock input by gpio11 */ #define TIMG_RTC_CALI_CLK_SEL_RC_SLOW 0 #define TIMG_RTC_CALI_CLK_SEL_RC_FAST 1 #define TIMG_RTC_CALI_CLK_SEL_32K 2 -/** - * @brief Clock calibration function used by rtc_clk_cal - * - * Calibration of RTC_SLOW_CLK is performed using a special feature of TIMG0. - * This feature counts the number of XTAL clock cycles within a given number of - * RTC_SLOW_CLK cycles. - * - * Slow clock calibration feature has two modes of operation: one-off and cycling. - * In cycling mode (which is enabled by default on SoC reset), counting of XTAL - * cycles within RTC_SLOW_CLK cycle is done continuously. Cycling mode is enabled - * using TIMG_RTC_CALI_START_CYCLING bit. In one-off mode counting is performed - * once, and TIMG_RTC_CALI_RDY bit is set when counting is done. One-off mode is - * enabled using TIMG_RTC_CALI_START bit. - * - * @param cal_clk which clock to calibrate - * @param slowclk_cycles number of slow clock cycles to count - * @return number of XTAL clock cycles within the given number of slow clock cycles - */ static uint32_t rtc_clk_cal_internal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cycles) { assert(slowclk_cycles < TIMG_RTC_CALI_MAX_V); @@ -99,17 +76,6 @@ static uint32_t rtc_clk_cal_internal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cyc } } - bool rc32k_enabled = clk_ll_rc32k_is_enabled(); - bool dig_rc32k_enabled = clk_ll_rc32k_digi_is_enabled(); - if (cal_clk == RTC_CAL_RC32K) { - if (!rc32k_enabled) { - rtc_clk_rc32k_enable(true); - } - if (!dig_rc32k_enabled) { - clk_ll_rc32k_digi_enable(); - } - } - /* There may be another calibration process already running during we call this function, * so we should wait the last process is done. */ @@ -138,13 +104,10 @@ static uint32_t rtc_clk_cal_internal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cyc REG_SET_FIELD(TIMG_RTCCALICFG2_REG(0), TIMG_RTC_CALI_TIMEOUT_THRES, RTC_SLOW_CLK_32K_CAL_TIMEOUT_THRES(slowclk_cycles)); expected_freq = SOC_CLK_XTAL32K_FREQ_APPROX; } else if (cali_clk_sel == TIMG_RTC_CALI_CLK_SEL_RC_FAST) { - REG_SET_FIELD(TIMG_RTCCALICFG2_REG(0), TIMG_RTC_CALI_TIMEOUT_THRES, RTC_FAST_CLK_8M_CAL_TIMEOUT_THRES(slowclk_cycles)); - expected_freq = SOC_CLK_RC_FAST_FREQ_APPROX; - if (ESP_CHIP_REV_ABOVE(efuse_hal_chip_revision(), 2)) { - expected_freq = expected_freq >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; - } + REG_SET_FIELD(TIMG_RTCCALICFG2_REG(0), TIMG_RTC_CALI_TIMEOUT_THRES, RTC_FAST_CLK_20M_CAL_TIMEOUT_THRES(slowclk_cycles)); + expected_freq = SOC_CLK_RC_FAST_FREQ_APPROX >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; } else { - REG_SET_FIELD(TIMG_RTCCALICFG2_REG(0), TIMG_RTC_CALI_TIMEOUT_THRES, RTC_SLOW_CLK_150K_CAL_TIMEOUT_THRES(slowclk_cycles)); + REG_SET_FIELD(TIMG_RTCCALICFG2_REG(0), TIMG_RTC_CALI_TIMEOUT_THRES, RTC_SLOW_CLK_600K_CAL_TIMEOUT_THRES(slowclk_cycles)); expected_freq = SOC_CLK_RC_SLOW_FREQ_APPROX; } uint32_t us_time_estimate = (uint32_t) (((uint64_t) slowclk_cycles) * MHZ / expected_freq); @@ -159,16 +122,10 @@ static uint32_t rtc_clk_cal_internal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cyc if (GET_PERI_REG_MASK(TIMG_RTCCALICFG_REG(0), TIMG_RTC_CALI_RDY)) { cal_val = REG_GET_FIELD(TIMG_RTCCALICFG1_REG(0), TIMG_RTC_CALI_VALUE); - /*The Fosc CLK of calibration circuit is divided by 32 for ECO2. - So we need to multiply the frequency of the Fosc for ECO2 and above chips by 32 times. - And ensure that this modification will not affect ECO0 and ECO1. - And the 32-divider belongs to REF_TICK module, so we need to enable its clock during - calibration. */ - if (ESP_CHIP_REV_ABOVE(efuse_hal_chip_revision(), 2)) { - if (cal_clk == RTC_CAL_RC_FAST) { - cal_val = cal_val >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; - CLEAR_PERI_REG_MASK(PCR_CTRL_TICK_CONF_REG, PCR_TICK_ENABLE); - } + /* The Fosc CLK of calibration circuit is divided by a factor, k. + So we need to multiply the frequency of the FOSC by k times. */ + if (cal_clk == RTC_CAL_RC_FAST) { + cal_val = cal_val >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; } break; } @@ -193,15 +150,6 @@ static uint32_t rtc_clk_cal_internal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cyc } } - if (cal_clk == RTC_CAL_RC32K) { - if (!dig_rc32k_enabled) { - clk_ll_rc32k_digi_disable(); - } - if (!rc32k_enabled) { - rtc_clk_rc32k_enable(false); - } - } - // Always set back the calibration 32kHz clock selection if (old_32k_cal_clk_sel != SOC_RTC_SLOW_CLK_SRC_INVALID) { clk_ll_32k_calibration_set_target(old_32k_cal_clk_sel); @@ -219,19 +167,15 @@ static bool rtc_clk_cal_32k_valid(uint32_t xtal_freq, uint32_t slowclk_cycles, u uint32_t rtc_clk_cal(rtc_cal_sel_t cal_clk, uint32_t slowclk_cycles) { - assert(slowclk_cycles); - soc_xtal_freq_t xtal_freq = rtc_clk_xtal_freq_get(); - - /*The Fosc CLK of calibration circuit is divided by 32 for ECO2. - So we need to divide the calibrate cycles of the FOSC for ECO1 and above chips by 32 to - avoid excessive calibration time.*/ - if (ESP_CHIP_REV_ABOVE(efuse_hal_chip_revision(), 2)) { - if (cal_clk == RTC_CAL_RC_FAST) { - slowclk_cycles = slowclk_cycles >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; - SET_PERI_REG_MASK(PCR_CTRL_TICK_CONF_REG, PCR_TICK_ENABLE); - } + /* The Fosc CLK of calibration circuit is divided by a factor, k. + So we need to divide the calibrate cycles of the FOSC by k to + avoid excessive calibration time. */ + if (cal_clk == RTC_CAL_RC_FAST) { + slowclk_cycles = slowclk_cycles >> CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS; } + assert(slowclk_cycles); + soc_xtal_freq_t xtal_freq = rtc_clk_xtal_freq_get(); uint64_t xtal_cycles = rtc_clk_cal_internal(cal_clk, slowclk_cycles); if (cal_clk == RTC_CAL_32K_XTAL && !rtc_clk_cal_32k_valid((uint32_t)xtal_freq, slowclk_cycles, xtal_cycles)) { @@ -262,7 +206,7 @@ uint64_t rtc_time_get(void) { ESP_EARLY_LOGW(TAG, "rtc_timer has not been implemented yet"); return 0; - //TODO: [ESP32H21] IDF-11548 + // TODO: [ESP32H21] IDF-11512 // return lp_timer_hal_get_cycle_count(); } diff --git a/components/esp_hw_support/port/esp32h4/esp_clk_tree.c b/components/esp_hw_support/port/esp32h4/esp_clk_tree.c index efdd789e28..7c8cb8b577 100644 --- a/components/esp_hw_support/port/esp32h4/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32h4/esp_clk_tree.c @@ -47,6 +47,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32h4/rtc_clk.c b/components/esp_hw_support/port/esp32h4/rtc_clk.c index dc76bf8376..9da7371ae4 100644 --- a/components/esp_hw_support/port/esp32h4/rtc_clk.c +++ b/components/esp_hw_support/port/esp32h4/rtc_clk.c @@ -18,7 +18,7 @@ #include "hal/clk_tree_ll.h" #include "hal/gpio_ll.h" #include "hal/regi2c_ctrl_ll.h" -#include "soc/io_mux_reg.h" +#include "hal/gpio_ll.h" #include "soc/lp_aon_reg.h" #include "esp_private/sleep_event.h" @@ -50,16 +50,15 @@ void rtc_clk_32k_enable(bool enable) void rtc_clk_32k_enable_external(void) { - // EXT_OSC_SLOW_GPIO_NUM == GPIO_NUM_0 - gpio_ll_input_enable(&GPIO, GPIO_NUM_0); - REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_enable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_SET_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_enable(CLK_LL_XTAL32K_ENABLE_MODE_EXTERNAL); } void rtc_clk_32k_disable_external(void) { - gpio_ll_input_disable(&GPIO, GPIO_NUM_0); - REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(EXT_OSC_SLOW_GPIO_NUM)); + gpio_ll_input_disable(&GPIO, SOC_EXT_OSC_SLOW_GPIO_NUM); + REG_CLR_BIT(LP_AON_GPIO_HOLD0_REG, BIT(SOC_EXT_OSC_SLOW_GPIO_NUM)); clk_ll_xtal32k_disable(); } @@ -176,7 +175,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { clk_ll_ahb_set_ls_divider(1); clk_ll_cpu_set_ls_divider(1); @@ -264,7 +263,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); rtc_clk_set_cpu_switch_to_bbpll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL) && !s_bbpll_digi_consumers_ref_count) { // We don't turn off the bbpll if some consumers depend on bbpll rtc_clk_bbpll_disable(); @@ -316,7 +315,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_pll_freq == config->source_freq_mhz) { rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); diff --git a/components/esp_hw_support/port/esp32p4/esp_clk_tree.c b/components/esp_hw_support/port/esp32p4/esp_clk_tree.c index 102ea66476..e9eeb558c4 100644 --- a/components/esp_hw_support/port/esp32p4/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32p4/esp_clk_tree.c @@ -89,6 +89,22 @@ esp_err_t esp_clk_tree_src_get_freq_hz(soc_module_clk_t clk_src, esp_clk_tree_sr return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { if(!enable) { diff --git a/components/esp_hw_support/port/esp32p4/rtc_clk.c b/components/esp_hw_support/port/esp32p4/rtc_clk.c index 6a3f9adc97..86931160b9 100644 --- a/components/esp_hw_support/port/esp32p4/rtc_clk.c +++ b/components/esp_hw_support/port/esp32p4/rtc_clk.c @@ -190,7 +190,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div, bool to_default) esp_rom_set_cpu_ticks_per_us(cpu_freq); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { // let f_cpu = f_mem = f_sys = f_apb clk_ll_cpu_set_divider(1, 0, 0); @@ -359,7 +359,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) rtc_clk_cpu_freq_to_cpll_mhz(config->freq_mhz, (hal_utils_clk_div_t *)&config->div); rtc_clk_set_cpu_switch_to_pll(SLEEP_EVENT_HW_PLL_EN_STOP); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if (old_cpu_clk_src == SOC_CPU_CLK_SRC_CPLL) { rtc_clk_cpll_disable(); } @@ -418,7 +418,7 @@ void rtc_clk_cpu_freq_set_config_fast(const rtc_cpu_freq_config_t *config) s_cur_cpll_freq == config->source_freq_mhz) { rtc_clk_cpu_freq_to_cpll_mhz(config->freq_mhz, (hal_utils_clk_div_t *)&config->div); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } else { /* fallback */ rtc_clk_cpu_freq_set_config(config); diff --git a/components/esp_hw_support/port/esp32p4/rtc_clk_init.c b/components/esp_hw_support/port/esp32p4/rtc_clk_init.c index 2003e50066..5d054b8573 100644 --- a/components/esp_hw_support/port/esp32p4/rtc_clk_init.c +++ b/components/esp_hw_support/port/esp32p4/rtc_clk_init.c @@ -10,7 +10,6 @@ #include #include "esp32p4/rom/ets_sys.h" #include "esp32p4/rom/rtc.h" -#include "esp32p4/rom/uart.h" #include "soc/rtc.h" #include "esp_cpu.h" #include "regi2c_ctrl.h" diff --git a/components/esp_hw_support/port/esp32s2/esp_clk_tree.c b/components/esp_hw_support/port/esp32s2/esp_clk_tree.c index ff9e20571d..3ceca58f91 100644 --- a/components/esp_hw_support/port/esp32s2/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32s2/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -68,6 +68,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32s2/rtc_clk.c b/components/esp_hw_support/port/esp32s2/rtc_clk.c index 47f2e47c80..e79ee6272b 100644 --- a/components/esp_hw_support/port/esp32s2/rtc_clk.c +++ b/components/esp_hw_support/port/esp32s2/rtc_clk.c @@ -33,7 +33,7 @@ static const char *TAG = "rtc_clk"; static uint32_t s_cur_pll_freq = CLK_LL_PLL_480M_FREQ_MHZ; static void rtc_clk_cpu_freq_to_xtal(int freq, int div); -static void rtc_clk_cpu_freq_to_8m(void); +static void rtc_clk_cpu_freq_to_rc_fast(void); void rtc_clk_32k_enable(bool enable) { @@ -376,7 +376,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t* config) rtc_clk_bbpll_configure((soc_xtal_freq_t)CLK_LL_XTAL_FREQ_MHZ, config->source_freq_mhz); rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); } } @@ -488,7 +488,7 @@ static void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) } } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { assert(0 && "LDO dbias need to modified"); esp_rom_set_cpu_ticks_per_us(8); diff --git a/components/esp_hw_support/port/esp32s3/esp_clk_tree.c b/components/esp_hw_support/port/esp32s3/esp_clk_tree.c index d71373714b..566d39c6ce 100644 --- a/components/esp_hw_support/port/esp32s3/esp_clk_tree.c +++ b/components/esp_hw_support/port/esp32s3/esp_clk_tree.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -68,6 +68,22 @@ uint32_t *freq_value) return ESP_OK; } +void esp_clk_tree_initialize(void) +{ +} + +bool esp_clk_tree_is_power_on(soc_root_clk_circuit_t clk_circuit) +{ + (void)clk_circuit; + return false; +} + +esp_err_t esp_clk_tree_enable_power(soc_root_clk_circuit_t clk_circuit, bool enable) +{ + (void)clk_circuit; (void)enable; + return ESP_OK; // TODO: PM-354 +} + esp_err_t esp_clk_tree_enable_src(soc_module_clk_t clk_src, bool enable) { (void)clk_src; (void)enable; diff --git a/components/esp_hw_support/port/esp32s3/rtc_clk.c b/components/esp_hw_support/port/esp32s3/rtc_clk.c index ba9986d3cc..bfe7b665b6 100644 --- a/components/esp_hw_support/port/esp32s3/rtc_clk.c +++ b/components/esp_hw_support/port/esp32s3/rtc_clk.c @@ -34,7 +34,7 @@ static uint32_t s_cur_pll_freq; static uint32_t s_apb_freq; void rtc_clk_cpu_freq_to_xtal(int freq, int div); -static void rtc_clk_cpu_freq_to_8m(void); +static void rtc_clk_cpu_freq_to_rc_fast(void); extern uint32_t g_dig_dbias_pvt_240m; extern uint32_t g_rtc_dbias_pvt_240m; @@ -308,7 +308,7 @@ void rtc_clk_cpu_freq_set_config(const rtc_cpu_freq_config_t *config) } rtc_clk_cpu_freq_to_pll_mhz(config->freq_mhz); } else if (config->source == SOC_CPU_CLK_SRC_RC_FAST) { - rtc_clk_cpu_freq_to_8m(); + rtc_clk_cpu_freq_to_rc_fast(); if ((old_cpu_clk_src == SOC_CPU_CLK_SRC_PLL) && !s_bbpll_digi_consumers_ref_count) { // We don't turn off the bbpll if some consumers depend on bbpll rtc_clk_bbpll_disable(); @@ -421,7 +421,7 @@ void rtc_clk_cpu_freq_to_xtal(int cpu_freq, int div) REG_SET_FIELD(RTC_CNTL_DATE_REG, RTC_CNTL_SLAVE_PD, DEFAULT_LDO_SLAVE); } -static void rtc_clk_cpu_freq_to_8m(void) +static void rtc_clk_cpu_freq_to_rc_fast(void) { assert(0 && "LDO dbias need to modified"); esp_rom_set_cpu_ticks_per_us(20); diff --git a/components/esp_hw_support/test_apps/rtc_clk/CMakeLists.txt b/components/esp_hw_support/test_apps/rtc_clk/CMakeLists.txt index d259ce59bb..5a2c96430b 100644 --- a/components/esp_hw_support/test_apps/rtc_clk/CMakeLists.txt +++ b/components/esp_hw_support/test_apps/rtc_clk/CMakeLists.txt @@ -7,4 +7,8 @@ set(EXTRA_COMPONENT_DIRS "$ENV{IDF_PATH}/tools/unit-test-app/components") list(PREPEND SDKCONFIG_DEFAULTS "$ENV{IDF_PATH}/tools/test_apps/configs/sdkconfig.debug_helpers" "sdkconfig.defaults") include($ENV{IDF_PATH}/tools/cmake/project.cmake) + +# "Trim" the build. Include the minimal set of components, main, and anything it depends on. +set(COMPONENTS main) + project(rtc_clk) diff --git a/components/esp_hw_support/test_apps/rtc_clk/README.md b/components/esp_hw_support/test_apps/rtc_clk/README.md index 7b96141437..15bfc62bf3 100644 --- a/components/esp_hw_support/test_apps/rtc_clk/README.md +++ b/components/esp_hw_support/test_apps/rtc_clk/README.md @@ -1,2 +1,2 @@ -| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C5 | ESP32-C6 | ESP32-C61 | ESP32-H2 | ESP32-P4 | ESP32-S2 | ESP32-S3 | -| ----------------- | ----- | -------- | -------- | -------- | -------- | --------- | -------- | -------- | -------- | -------- | +| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C5 | ESP32-C6 | ESP32-C61 | ESP32-H2 | ESP32-H21 | ESP32-P4 | ESP32-S2 | ESP32-S3 | +| ----------------- | ----- | -------- | -------- | -------- | -------- | --------- | -------- | --------- | -------- | -------- | -------- | diff --git a/components/esp_hw_support/test_apps/rtc_clk/main/test_rtc_clk.c b/components/esp_hw_support/test_apps/rtc_clk/main/test_rtc_clk.c index 62d7512776..923bc74c58 100644 --- a/components/esp_hw_support/test_apps/rtc_clk/main/test_rtc_clk.c +++ b/components/esp_hw_support/test_apps/rtc_clk/main/test_rtc_clk.c @@ -244,8 +244,9 @@ static void start_freq(soc_rtc_slow_clk_src_t required_src, uint32_t start_delay } else { printf("PASS. Time measurement..."); } - uint64_t clk_rtc_time; uint32_t fail_measure = 0; +#if SOC_LP_TIMER_SUPPORTED + uint64_t clk_rtc_time; for (int j = 0; j < 3; ++j) { clk_rtc_time = esp_clk_rtc_time(); esp_rom_delay_us(1000000); @@ -257,6 +258,7 @@ static void start_freq(soc_rtc_slow_clk_src_t required_src, uint32_t start_delay break; } } +#endif if(fail_measure == 0) { printf("PASS"); } @@ -285,10 +287,10 @@ TEST_CASE("Test starting external RTC quartz", "[rtc_clk][test_env=xtal32k]") bootstrap_cycles, CONFIG_RTC_CLK_CAL_CYCLES); #endif // CONFIG_RTC_CLK_SRC_EXT_CRYS - if (CONFIG_RTC_CLK_CAL_CYCLES < 1500){ + if (CONFIG_RTC_CLK_CAL_CYCLES < 1500) { printf("Recommended increase Number of cycles for RTC_SLOW_CLK calibration to 3000!\n"); } - while(i < COUNT_TEST){ + while (i < COUNT_TEST) { start_time = xTaskGetTickCount() * (1000 / configTICK_RATE_HZ); i++; printf("attempt #%d/%d...", i, COUNT_TEST); @@ -296,7 +298,7 @@ TEST_CASE("Test starting external RTC quartz", "[rtc_clk][test_env=xtal32k]") rtc_clk_select_rtc_slow_clk(); end_time = xTaskGetTickCount() * (1000 / configTICK_RATE_HZ); printf(" [time=%"PRIu32"] ", end_time - start_time); - if((end_time - start_time) > TIMEOUT_TEST_MS){ + if ((end_time - start_time) > TIMEOUT_TEST_MS) { printf("FAIL\n"); fail = 1; } else { @@ -332,6 +334,7 @@ TEST_CASE("Test starting 'External 32kHz XTAL' on the board without it.", "[rtc_ #endif // !defined(CONFIG_IDF_CI_BUILD) || !CONFIG_SPIRAM_BANKSWITCH_ENABLE #endif // SOC_CLK_XTAL32K_SUPPORTED +#if SOC_LP_TIMER_SUPPORTED TEST_CASE("Test rtc clk calibration compensation", "[rtc_clk]") { int64_t t1 = esp_rtc_get_time_us(); @@ -358,6 +361,7 @@ TEST_CASE("Test rtc clk calibration compensation", "[rtc_clk]") TEST_ASSERT_GREATER_THAN(t1, t2); } +#endif #if SOC_DEEP_SLEEP_SUPPORTED static RTC_NOINIT_ATTR int64_t start = 0; diff --git a/components/esp_rom/esp32h21/include/esp32h21/rom/rtc.h b/components/esp_rom/esp32h21/include/esp32h21/rom/rtc.h index ad09743b85..2a73cec5ed 100644 --- a/components/esp_rom/esp32h21/include/esp32h21/rom/rtc.h +++ b/components/esp_rom/esp32h21/include/esp32h21/rom/rtc.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -14,8 +14,6 @@ #include "soc/reset_reasons.h" #include "esp_assert.h" -//TODO: [ESP32H21] IDF-11548 - #ifdef __cplusplus extern "C" { #endif @@ -34,30 +32,29 @@ extern "C" { * Please do not use reserved or used rtc memory or registers. * * * ************************************************************************************* - * RTC Memory & Store Register usage + * LP Memory & Store Register usage ************************************************************************************* * rtc memory addr type size usage - * 0x50000000 Fast 0x4000 deep sleep entry code + * 0x50000000 Fast 0x1000 deep sleep entry code * ************************************************************************************* * RTC store registers usage - * RTC_CNTL_STORE0_REG Reserved - * RTC_CNTL_STORE1_REG RTC_SLOW_CLK calibration value - * RTC_CNTL_STORE2_REG Boot time, low word - * RTC_CNTL_STORE3_REG Boot time, high word - * RTC_CNTL_STORE4_REG External XTAL frequency - * RTC_CNTL_STORE5_REG FAST_RTC_MEMORY_LENGTH - * RTC_CNTL_STORE6_REG FAST_RTC_MEMORY_ENTRY - * RTC_CNTL_STORE7_REG FAST_RTC_MEMORY_CRC + * LP_AON_STORE0_REG Reserved + * LP_AON_STORE1_REG RTC_SLOW_CLK calibration value + * LP_AON_STORE2_REG Boot time, low word + * LP_AON_STORE3_REG Boot time, high word + * LP_AON_STORE4_REG Status of whether to disable LOG from ROM at bit[0] + * LP_AON_STORE5_REG FAST_RTC_MEMORY_LENGTH + * LP_AON_STORE6_REG FAST_RTC_MEMORY_ENTRY + * LP_AON_STORE7_REG FAST_RTC_MEMORY_CRC + * LP_AON_STORE8_REG Store light sleep wake stub addr + * LP_AON_STORE9_REG Store the sleep mode at bit[0] (0:light sleep 1:deep sleep) ************************************************************************************* */ -//TODO: [ESP32H21] IDF-1154, need to check from esp_rom #define RTC_SLOW_CLK_CAL_REG LP_AON_STORE1_REG #define RTC_BOOT_TIME_LOW_REG LP_AON_STORE2_REG #define RTC_BOOT_TIME_HIGH_REG LP_AON_STORE3_REG -#define RTC_XTAL_FREQ_REG LP_AON_STORE4_REG -#define RTC_APB_FREQ_REG LP_AON_STORE5_REG #define RTC_ENTRY_ADDR_REG LP_AON_STORE6_REG #define RTC_RESET_CAUSE_REG LP_AON_STORE6_REG #define RTC_MEMORY_CRC_REG LP_AON_STORE7_REG @@ -209,7 +206,7 @@ void esp_rom_set_rtc_wake_addr(esp_rom_wake_func_t entry_addr, size_t length); static inline void rtc_suppress_rom_log(void) { /* To disable logging in the ROM, only the least significant bit of the register is used, - * but since this register is also used to store the frequency of the main crystal (RTC_XTAL_FREQ_REG), + * but this register was also used to store the frequency of the main crystal (RTC_XTAL_FREQ_REG) on old targets, * you need to write to this register in the same format. * Namely, the upper 16 bits and lower should be the same. */ diff --git a/components/esp_rom/patches/esp_rom_regi2c_esp32h21.c b/components/esp_rom/patches/esp_rom_regi2c_esp32h21.c index dc64ed1e16..008385b959 100644 --- a/components/esp_rom/patches/esp_rom_regi2c_esp32h21.c +++ b/components/esp_rom/patches/esp_rom_regi2c_esp32h21.c @@ -7,6 +7,7 @@ #include "esp_attr.h" #include "soc/i2c_ana_mst_reg.h" #include "hal/regi2c_ctrl_ll.h" +#include "sdkconfig.h" /* SLAVE */ #define REGI2C_BBPLL 0x66 // regi2c_bbpll.h @@ -29,7 +30,9 @@ void esp_rom_regi2c_write_mask(uint8_t block, uint8_t host_id, uint8_t reg_add, static IRAM_ATTR uint8_t regi2c_enable_block(uint8_t block) { uint32_t i2c_sel = 0; +#if !CONFIG_IDF_ENV_FPGA // on FPGA, unable to manipulate modem registers, skip the check assert(regi2c_ctrl_ll_master_is_clock_enabled()); +#endif /* Before config I2C register, enable corresponding slave. */ switch (block) { diff --git a/components/esp_system/fpga_overrides_clk.c b/components/esp_system/fpga_overrides_clk.c index 732a5ba732..4ed9d9be3b 100644 --- a/components/esp_system/fpga_overrides_clk.c +++ b/components/esp_system/fpga_overrides_clk.c @@ -5,6 +5,7 @@ */ #include "sdkconfig.h" #include "soc/soc.h" +#include "soc/soc_caps.h" #include "esp_private/periph_ctrl.h" #ifndef CONFIG_IDF_TARGET_ESP32 #include "soc/system_reg.h" @@ -12,7 +13,7 @@ #include "soc/rtc.h" #include "rom/rtc.h" -#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32C61 +#if SOC_PMU_SUPPORTED #include "esp_private/esp_pmu.h" #endif @@ -31,10 +32,11 @@ void bootloader_clock_configure(void) { s_warn(); esp_rom_output_tx_wait_idle(0); + uint32_t xtal_freq_mhz __attribute__((unused)); #if CONFIG_IDF_TARGET_ESP32H21 || CONFIG_IDF_TARGET_ESP32H4 - uint32_t xtal_freq_mhz = 32; + xtal_freq_mhz = 32; #else - uint32_t xtal_freq_mhz = 40; + xtal_freq_mhz = 40; #endif #ifdef CONFIG_IDF_TARGET_ESP32S2 uint32_t apb_freq_hz = 20000000; @@ -45,7 +47,9 @@ void bootloader_clock_configure(void) #ifdef RTC_APB_FREQ_REG REG_WRITE(RTC_APB_FREQ_REG, (apb_freq_hz >> 12) | ((apb_freq_hz >> 12) << 16)); #endif +#ifdef RTC_XTAL_FREQ_REG REG_WRITE(RTC_XTAL_FREQ_REG, (xtal_freq_mhz) | ((xtal_freq_mhz) << 16)); +#endif } void esp_rtc_init(void) diff --git a/components/esp_system/port/cpu_start.c b/components/esp_system/port/cpu_start.c index 9df6b9d8ee..33438d3b36 100644 --- a/components/esp_system/port/cpu_start.c +++ b/components/esp_system/port/cpu_start.c @@ -100,6 +100,7 @@ #include "soc/periph_defs.h" #include "esp_cpu.h" #include "esp_private/esp_clk.h" +#include "esp_private/esp_clk_tree_common.h" #if CONFIG_ESP32_TRAX || CONFIG_ESP32S2_TRAX || CONFIG_ESP32S3_TRAX #include "esp_private/trax.h" @@ -708,9 +709,7 @@ void IRAM_ATTR call_start_cpu0(void) trax_start_trace(TRAX_DOWNCOUNT_WORDS); #endif // CONFIG_ESP32_TRAX || CONFIG_ESP32S2_TRAX || CONFIG_ESP32S3_TRAX -#if SOC_CLOCK_TREE_MANAGEMENT_SUPPORTED esp_clk_tree_initialize(); -#endif esp_clk_init(); esp_perip_clk_init(); diff --git a/components/esp_system/port/soc/esp32h21/Kconfig.cpu b/components/esp_system/port/soc/esp32h21/Kconfig.cpu index 82a9af1112..e9fabeb5bd 100644 --- a/components/esp_system/port/soc/esp32h21/Kconfig.cpu +++ b/components/esp_system/port/soc/esp32h21/Kconfig.cpu @@ -1,16 +1,13 @@ choice ESP_DEFAULT_CPU_FREQ_MHZ prompt "CPU frequency" - default ESP_DEFAULT_CPU_FREQ_MHZ_32 if IDF_ENV_FPGA + default ESP_DEFAULT_CPU_FREQ_MHZ_32 if IDF_ENV_FPGA || ESP_BRINGUP_BYPASS_CPU_CLK_SETTING default ESP_DEFAULT_CPU_FREQ_MHZ_96 help CPU frequency to be set on application startup. - config ESP_DEFAULT_CPU_FREQ_MHZ_16 - bool "16 MHz" - depends on IDF_ENV_FPGA config ESP_DEFAULT_CPU_FREQ_MHZ_32 bool "32 MHz" - depends on IDF_ENV_FPGA + depends on IDF_ENV_FPGA || ESP_BRINGUP_BYPASS_CPU_CLK_SETTING config ESP_DEFAULT_CPU_FREQ_MHZ_48 bool "48 MHz" depends on !IDF_ENV_FPGA @@ -23,7 +20,6 @@ endchoice config ESP_DEFAULT_CPU_FREQ_MHZ int - default 16 if ESP_DEFAULT_CPU_FREQ_MHZ_16 default 32 if ESP_DEFAULT_CPU_FREQ_MHZ_32 default 48 if ESP_DEFAULT_CPU_FREQ_MHZ_48 default 64 if ESP_DEFAULT_CPU_FREQ_MHZ_64 diff --git a/components/esp_system/port/soc/esp32h21/clk.c b/components/esp_system/port/soc/esp32h21/clk.c index dfe54c947e..c377305ef1 100644 --- a/components/esp_system/port/soc/esp32h21/clk.c +++ b/components/esp_system/port/soc/esp32h21/clk.c @@ -16,13 +16,8 @@ #include "esp32h21/rom/ets_sys.h" #include "esp32h21/rom/uart.h" #include "soc/soc.h" -#include "soc/pcr_reg.h" #include "soc/rtc.h" #include "soc/rtc_periph.h" -#include "soc/i2s_reg.h" -#include "soc/lpperi_reg.h" -#include "soc/lp_clkrst_reg.h" -#include "soc/pcr_reg.h" #include "hal/wdt_hal.h" #include "esp_private/esp_modem_clock.h" #include "esp_private/periph_ctrl.h" @@ -32,8 +27,6 @@ #include "esp_rom_sys.h" #include "esp_sleep.h" -// TODO: [ESP32H21] IDF-11900, IDF-11907 - /* Number of cycles to wait from the 32k XTAL oscillator to consider it running. * Larger values increase startup delay. Smaller values may cause false positive * detection (i.e. oscillator runs for a few cycles and then stops). @@ -48,8 +41,7 @@ static const char *TAG = "clk"; void esp_rtc_init(void) { -// TODO: [ESP32H21] IDF-11906 -#if !CONFIG_IDF_ENV_FPGA +#if SOC_PMU_SUPPORTED && !CONFIG_IDF_ENV_FPGA pmu_init(); #endif } @@ -65,12 +57,12 @@ __attribute__((weak)) void esp_clk_init(void) #ifdef CONFIG_BOOTLOADER_WDT_ENABLE // WDT uses a SLOW_CLK clock source. After a function select_rtc_slow_clk a frequency of this source can changed. - // If the frequency changes from 150kHz to 32kHz, then the timeout set for the WDT will increase 4.6 times. + // If the frequency changes from 600kHz to 32kHz, then the timeout set for the WDT will increase 18.75 times. // Therefore, for the time of frequency change, set a new lower timeout value (2 sec). // This prevents excessive delay before resetting in case the supply voltage is drawdown. - // (If frequency is changed from 150kHz to 32kHz then WDT timeout will increased to 2 sec * 150/32 = 9.375 sec). + // (If frequency is changed from 600kHz to 32kHz then WDT timeout will increased to 2 sec * 600/32 = 37.5 sec). - wdt_hal_context_t rtc_wdt_ctx = {.inst = WDT_RWDT, .rwdt_dev = &LP_WDT}; + wdt_hal_context_t rtc_wdt_ctx = RWDT_HAL_CONTEXT_DEFAULT(); uint32_t stage_timeout_ticks = (uint32_t)(2000ULL * rtc_clk_slow_freq_get_hz() / 1000ULL); wdt_hal_write_protect_disable(&rtc_wdt_ctx); @@ -85,8 +77,6 @@ __attribute__((weak)) void esp_clk_init(void) select_rtc_slow_clk(SOC_RTC_SLOW_CLK_SRC_XTAL32K); #elif defined(CONFIG_RTC_CLK_SRC_EXT_OSC) select_rtc_slow_clk(SOC_RTC_SLOW_CLK_SRC_OSC_SLOW); -#elif defined(CONFIG_RTC_CLK_SRC_INT_RC32K) - select_rtc_slow_clk(SOC_RTC_SLOW_CLK_SRC_RC32K); #else select_rtc_slow_clk(SOC_RTC_SLOW_CLK_SRC_RC_SLOW); #endif @@ -155,23 +145,18 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src) if (retry_32k_xtal-- > 0) { continue; } - ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator"); + ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 600 kHz oscillator"); rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW; } } - } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) { - rtc_clk_rc32k_enable(true); } rtc_clk_slow_src_set(rtc_slow_clk_src); // Disable unused clock sources after clock source switching is complete. - // Regardless of the clock source selection, the internal 136K clock source will always keep on. + // Regardless of the clock source selection, the internal 600k clock source will always keep on. if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) { rtc_clk_32k_enable(false); rtc_clk_32k_disable_external(); } - if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_RC32K) { - rtc_clk_rc32k_enable(false); - } if (SLOW_CLK_CAL_CYCLES > 0) { /* TODO: 32k XTAL oscillator has some frequency drift at startup. diff --git a/components/esp_system/startup_funcs.c b/components/esp_system/startup_funcs.c index 204108f128..c586c29335 100644 --- a/components/esp_system/startup_funcs.c +++ b/components/esp_system/startup_funcs.c @@ -74,7 +74,7 @@ ESP_SYSTEM_INIT_FN(init_show_cpu_freq, CORE, BIT(0), 10) * It is protected from all REE accesses through memory protection mechanisms, * as it is a critical module for device functioning. */ -#if !CONFIG_SECURE_ENABLE_TEE +#if SOC_BOD_SUPPORTED && !CONFIG_SECURE_ENABLE_TEE ESP_SYSTEM_INIT_FN(init_brownout, CORE, BIT(0), 104) { // [refactor-todo] leads to call chain rtc_is_register (driver) -> esp_intr_alloc (esp32/esp32s2) -> diff --git a/components/hal/esp32c5/clk_tree_hal.c b/components/hal/esp32c5/clk_tree_hal.c index d7d648db89..2497a39b1b 100644 --- a/components/hal/esp32c5/clk_tree_hal.c +++ b/components/hal/esp32c5/clk_tree_hal.c @@ -9,7 +9,6 @@ #include "hal/clk_tree_hal.h" #include "hal/clk_tree_ll.h" #include "hal/gpio_ll.h" -#include "hal/log.h" uint32_t clk_hal_soc_root_get_freq_mhz(soc_cpu_clk_src_t cpu_clk_src) { diff --git a/components/hal/esp32c61/clk_tree_hal.c b/components/hal/esp32c61/clk_tree_hal.c index 9c8792081f..d5a79868d0 100644 --- a/components/hal/esp32c61/clk_tree_hal.c +++ b/components/hal/esp32c61/clk_tree_hal.c @@ -7,7 +7,6 @@ #include "hal/clk_tree_hal.h" #include "hal/clk_tree_ll.h" #include "hal/assert.h" -#include "hal/log.h" uint32_t clk_hal_soc_root_get_freq_mhz(soc_cpu_clk_src_t cpu_clk_src) { diff --git a/components/hal/esp32h21/clk_tree_hal.c b/components/hal/esp32h21/clk_tree_hal.c index 232a32405f..bcdb5932ec 100644 --- a/components/hal/esp32h21/clk_tree_hal.c +++ b/components/hal/esp32h21/clk_tree_hal.c @@ -1,19 +1,12 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ -#include "soc/clkout_channel.h" -#include "hal/assert.h" #include "hal/clk_tree_hal.h" #include "hal/clk_tree_ll.h" -#include "hal/gpio_ll.h" -#include "hal/log.h" - -//TODO: [ESP32H21] IDF-11521 - -static const char *CLK_HAL_TAG = "clk_hal"; +#include "hal/assert.h" uint32_t clk_hal_soc_root_get_freq_mhz(soc_cpu_clk_src_t cpu_clk_src) { @@ -24,8 +17,8 @@ uint32_t clk_hal_soc_root_get_freq_mhz(soc_cpu_clk_src_t cpu_clk_src) return clk_ll_bbpll_get_freq_mhz(); case SOC_CPU_CLK_SRC_RC_FAST: return SOC_CLK_RC_FAST_FREQ_APPROX / MHZ; - case SOC_CPU_CLK_SRC_FLASH_PLL: - return clk_ll_flash_pll_get_freq_mhz(); + case SOC_CPU_CLK_SRC_XTAL_X2: + return clk_ll_xtal_x2_get_freq_mhz(); default: // Unknown CPU_CLK mux input HAL_ASSERT(false); @@ -59,8 +52,6 @@ uint32_t clk_hal_lp_slow_get_freq_hz(void) return SOC_CLK_XTAL32K_FREQ_APPROX; case SOC_RTC_SLOW_CLK_SRC_OSC_SLOW: return SOC_CLK_OSC_SLOW_FREQ_APPROX; - case SOC_RTC_SLOW_CLK_SRC_RC32K: - return SOC_CLK_RC32K_FREQ_APPROX; default: // Unknown RTC_SLOW_CLK mux input HAL_ASSERT(false); @@ -70,20 +61,7 @@ uint32_t clk_hal_lp_slow_get_freq_hz(void) uint32_t clk_hal_xtal_get_freq_mhz(void) { - uint32_t freq = clk_ll_xtal_load_freq_mhz(); - if (freq == 0) { - HAL_LOGW(CLK_HAL_TAG, "invalid RTC_XTAL_FREQ_REG value, assume 32MHz"); - return (uint32_t)SOC_XTAL_FREQ_32M; - } + uint32_t freq = clk_ll_xtal_get_freq_mhz(); + HAL_ASSERT(freq == SOC_XTAL_FREQ_32M); return freq; } - -void clk_hal_clock_output_setup(soc_clkout_sig_id_t clk_sig, clock_out_channel_t channel_id) -{ - abort(); // TODO: IDF-11582 -} - -void clk_hal_clock_output_teardown(clock_out_channel_t channel_id) -{ - abort(); // TODO: IDF-11582 -} diff --git a/components/hal/esp32h21/include/hal/clk_tree_ll.h b/components/hal/esp32h21/include/hal/clk_tree_ll.h index ea9949a196..78fbcce8de 100644 --- a/components/hal/esp32h21/include/hal/clk_tree_ll.h +++ b/components/hal/esp32h21/include/hal/clk_tree_ll.h @@ -14,21 +14,17 @@ #include "soc/pmu_reg.h" #include "hal/regi2c_ctrl.h" #include "soc/regi2c_bbpll.h" -#include "soc/regi2c_pmu.h" #include "hal/assert.h" #include "hal/log.h" -#include "rom/rtc.h" +#include "esp32h21/rom/rtc.h" #include "hal/misc.h" -//TODO: [ESP32H21] IDF-11521, inherit from h2 - #ifdef __cplusplus extern "C" { #endif #define MHZ (1000000) -#define CLK_LL_PLL_8M_FREQ_MHZ (8) #define CLK_LL_PLL_48M_FREQ_MHZ (48) #define CLK_LL_PLL_64M_FREQ_MHZ (64) #define CLK_LL_PLL_96M_FREQ_MHZ (96) @@ -40,13 +36,8 @@ extern "C" { .dbuf = 1, \ } -/* -Set the frequency division factor of ref_tick -The FOSC of rtc calibration uses the 32 frequency division clock for ECO2, -So the frequency division factor of ref_tick must be greater than or equal to 32 -*/ -#define CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS 5 -#define REG_FOSC_TICK_NUM 255 +// Fix default division factor for the RC_FAST clock for calibration to be 32 +#define CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS 5 /** * @brief XTAL32K_CLK enable modes @@ -72,8 +63,7 @@ typedef struct { */ static inline __attribute__((always_inline)) void clk_ll_bbpll_enable(void) { - SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_XPD_BB_I2C | - PMU_TIE_HIGH_XPD_BBPLL | PMU_TIE_HIGH_XPD_BBPLL_I2C); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_XPD_BB_I2C | PMU_TIE_HIGH_XPD_BBPLL | PMU_TIE_HIGH_XPD_BBPLL_I2C); SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_GLOBAL_BBPLL_ICG); } @@ -82,26 +72,31 @@ static inline __attribute__((always_inline)) void clk_ll_bbpll_enable(void) */ static inline __attribute__((always_inline)) void clk_ll_bbpll_disable(void) { - SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_GLOBAL_BBPLL_ICG) ; - SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_XPD_BBPLL | PMU_TIE_LOW_XPD_BBPLL_I2C); + CLEAR_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_XPD_BB_I2C | PMU_TIE_HIGH_XPD_BBPLL | PMU_TIE_HIGH_XPD_BBPLL_I2C); + CLEAR_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_GLOBAL_BBPLL_ICG); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_XPD_BBPLL_I2C | PMU_TIE_LOW_XPD_BBPLL | PMU_TIE_LOW_XPD_BBPLL_I2C); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_GLOBAL_BBPLL_ICG); } /** - * @brief Enable the internal oscillator output for LP_PLL_CLK + * @brief Power up XTAL_X2 circuit */ -static inline __attribute__((always_inline)) void clk_ll_lp_pll_enable(void) +static inline __attribute__((always_inline)) void clk_ll_xtal_x2_enable(void) { - // Enable lp_pll xpd status - SET_PERI_REG_MASK(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_LPPLL); + CLEAR_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_XPD_XTALX2); + CLEAR_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_GLOBAL_XTALX2_ICG); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_XTALX2); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_GLOBAL_XTALX2_ICG); } /** - * @brief Disable the internal oscillator output for LP_PLL_CLK + * @brief Power down XTAL_X2 circuit */ -static inline __attribute__((always_inline)) void clk_ll_lp_pll_disable(void) +static inline __attribute__((always_inline)) void clk_ll_xtal_x2_disable(void) { - // Disable lp_pll xpd status - CLEAR_PERI_REG_MASK(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_LPPLL); + CLEAR_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_HIGH_XTALX2 | PMU_TIE_HIGH_GLOBAL_XTALX2_ICG); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_XPD_XTALX2); + SET_PERI_REG_MASK(PMU_IMM_HP_CK_POWER_REG, PMU_TIE_LOW_GLOBAL_XTALX2_ICG); } /** @@ -144,34 +139,6 @@ static inline __attribute__((always_inline)) bool clk_ll_xtal32k_is_enabled(void return REG_GET_FIELD(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_XTAL32K) == 1; } -/** - * @brief Enable the internal oscillator output for RC32K_CLK - */ -static inline __attribute__((always_inline)) void clk_ll_rc32k_enable(void) -{ - // Enable rc32k xpd status - SET_PERI_REG_MASK(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_RC32K); -} - -/** - * @brief Disable the internal oscillator output for RC32K_CLK - */ -static inline __attribute__((always_inline)) void clk_ll_rc32k_disable(void) -{ - // Disable rc32k xpd status - CLEAR_PERI_REG_MASK(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_RC32K); -} - -/** - * @brief Get the state of the internal oscillator for RC32K_CLK - * - * @return True if the oscillator is enabled - */ -static inline __attribute__((always_inline)) bool clk_ll_rc32k_is_enabled(void) -{ - return REG_GET_FIELD(PMU_HP_SLEEP_LP_CK_POWER_REG, PMU_HP_SLEEP_XPD_RC32K) == 1; -} - /** * @brief Enable the internal oscillator output for RC_FAST_CLK */ @@ -250,32 +217,6 @@ static inline __attribute__((always_inline)) bool clk_ll_xtal32k_digi_is_enabled return LP_CLKRST.clk_to_hp.clkrst_icg_hp_xtal32k; } -/** - * @brief Enable the digital RC32K_CLK, which is used to support peripherals. - */ -static inline __attribute__((always_inline)) void clk_ll_rc32k_digi_enable(void) -{ - LP_CLKRST.clk_to_hp.clkrst_icg_hp_osc32k = 1; -} - -/** - * @brief Disable the digital RC32K_CLK, which is used to support peripherals. - */ -static inline __attribute__((always_inline)) void clk_ll_rc32k_digi_disable(void) -{ - LP_CLKRST.clk_to_hp.clkrst_icg_hp_osc32k = 0; -} - -/** - * @brief Get the state of the digital RC32K_CLK - * - * @return True if the digital RC32K_CLK is enabled - */ -static inline __attribute__((always_inline)) bool clk_ll_rc32k_digi_is_enabled(void) -{ - return LP_CLKRST.clk_to_hp.clkrst_icg_hp_osc32k; -} - /** * @brief Get XTAL_CLK frequency * @@ -324,8 +265,8 @@ static inline __attribute__((always_inline)) void clk_ll_bbpll_set_config(uint32 uint8_t oc_dhref_sel; uint8_t oc_dlref_sel; - oc_ref_div = 0; - oc_div = 1; + oc_ref_div = 8; + oc_div = 24; oc_dhref_sel = 3; oc_dlref_sel = 1; @@ -336,14 +277,13 @@ static inline __attribute__((always_inline)) void clk_ll_bbpll_set_config(uint32 } /** - * @brief Get FLASH_PLL_CLK frequency + * @brief Get XTAL_X2_CLK frequency * - * @return FLASH_PLL clock frequency, in MHz + * @return XTAL_X2 clock frequency, in MHz */ -static inline __attribute__((always_inline)) uint32_t clk_ll_flash_pll_get_freq_mhz(void) +static inline __attribute__((always_inline)) uint32_t clk_ll_xtal_x2_get_freq_mhz(void) { - // The target has a fixed 64MHz flash PLL, which is directly derived from BBPLL - return CLK_LL_PLL_64M_FREQ_MHZ; + return SOC_XTAL_FREQ_32M * 2; } /** @@ -372,7 +312,7 @@ static inline __attribute__((always_inline)) void clk_ll_cpu_set_src(soc_cpu_clk case SOC_CPU_CLK_SRC_RC_FAST: PCR.sysclk_conf.soc_clk_sel = 2; break; - case SOC_CPU_CLK_SRC_FLASH_PLL: + case SOC_CPU_CLK_SRC_XTAL_X2: PCR.sysclk_conf.soc_clk_sel = 3; break; default: @@ -397,7 +337,7 @@ static inline __attribute__((always_inline)) soc_cpu_clk_src_t clk_ll_cpu_get_sr case 2: return SOC_CPU_CLK_SRC_RC_FAST; case 3: - return SOC_CPU_CLK_SRC_FLASH_PLL; + return SOC_CPU_CLK_SRC_XTAL_X2; default: // Invalid SOC_CLK_SEL value return SOC_CPU_CLK_SRC_INVALID; @@ -472,14 +412,11 @@ static inline __attribute__((always_inline)) uint32_t clk_ll_apb_get_divider(voi /** * @brief Select the calibration 32kHz clock source for timergroup0 * - * @param in_sel One of the 32kHz clock sources (RC32K_CLK, XTAL32K_CLK, OSC_SLOW_CLK) + * @param in_sel One of the 32kHz clock sources (XTAL32K_CLK, OSC_SLOW_CLK) */ static inline __attribute__((always_inline)) void clk_ll_32k_calibration_set_target(soc_rtc_slow_clk_src_t in_sel) { switch (in_sel) { - case SOC_RTC_SLOW_CLK_SRC_RC32K: - PCR.ctrl_32k_conf.clk_32k_sel = 0; - break; case SOC_RTC_SLOW_CLK_SRC_XTAL32K: PCR.ctrl_32k_conf.clk_32k_sel = 1; break; @@ -501,8 +438,6 @@ static inline __attribute__((always_inline)) soc_rtc_slow_clk_src_t clk_ll_32k_c { uint32_t clk_sel = PCR.ctrl_32k_conf.clk_32k_sel; switch (clk_sel) { - case 0: - return SOC_RTC_SLOW_CLK_SRC_RC32K; case 1: return SOC_RTC_SLOW_CLK_SRC_XTAL32K; case 2: @@ -526,9 +461,6 @@ static inline __attribute__((always_inline)) void clk_ll_rtc_slow_set_src(soc_rt case SOC_RTC_SLOW_CLK_SRC_XTAL32K: LP_CLKRST.lp_clk_conf.clkrst_slow_clk_sel = 1; break; - case SOC_RTC_SLOW_CLK_SRC_RC32K: - LP_CLKRST.lp_clk_conf.clkrst_slow_clk_sel = 2; - break; case SOC_RTC_SLOW_CLK_SRC_OSC_SLOW: LP_CLKRST.lp_clk_conf.clkrst_slow_clk_sel = 3; break; @@ -551,8 +483,6 @@ static inline __attribute__((always_inline)) soc_rtc_slow_clk_src_t clk_ll_rtc_s return SOC_RTC_SLOW_CLK_SRC_RC_SLOW; case 1: return SOC_RTC_SLOW_CLK_SRC_XTAL32K; - case 2: - return SOC_RTC_SLOW_CLK_SRC_RC32K; case 3: return SOC_RTC_SLOW_CLK_SRC_OSC_SLOW; default: @@ -560,57 +490,6 @@ static inline __attribute__((always_inline)) soc_rtc_slow_clk_src_t clk_ll_rtc_s } } -/** - * @brief Select the clock source for LP_PLL_CLK - * - * @param in_sel One of the clock sources in soc_lp_pll_clk_src_t - */ -static inline __attribute__((always_inline)) void clk_ll_lp_pll_set_src(soc_lp_pll_clk_src_t in_sel) -{ - uint32_t field_value; - switch (in_sel) { - case SOC_LP_PLL_CLK_SRC_RC32K: - field_value = 0; - break; - case SOC_LP_PLL_CLK_SRC_XTAL32K: - field_value = 1; - break; - default: - // Unsupported LP_PLL_CLK mux input sel - abort(); - } - REGI2C_WRITE_MASK(I2C_PMU, I2C_PMU_SEL_PLL8M_REF, field_value); -} - -/** - * @brief Get the clock source for LP_PLL_CLK - * - * @return Currently selected clock source (one of soc_lp_pll_clk_src_t values) - */ -static inline __attribute__((always_inline)) soc_lp_pll_clk_src_t clk_ll_lp_pll_get_src(void) -{ - uint32_t clk_sel = REGI2C_READ_MASK(I2C_PMU, I2C_PMU_SEL_PLL8M_REF); - switch (clk_sel) { - case 0: - return SOC_LP_PLL_CLK_SRC_RC32K; - case 1: - return SOC_LP_PLL_CLK_SRC_XTAL32K; - default: - return SOC_LP_PLL_CLK_SRC_INVALID; - } -} - -/** - * @brief Get LP_PLL_CLK frequency - * - * @return LP_PLL clock frequency, in MHz - */ -static inline __attribute__((always_inline)) uint32_t clk_ll_lp_pll_get_freq_mhz(void) -{ - // The target has a fixed 8MHz LP_PLL - return CLK_LL_PLL_8M_FREQ_MHZ; -} - /** * @brief Select the clock source for RTC_FAST_CLK * @@ -625,9 +504,6 @@ static inline __attribute__((always_inline)) void clk_ll_rtc_fast_set_src(soc_rt case SOC_RTC_FAST_CLK_SRC_XTAL_D2: LP_CLKRST.lp_clk_conf.clkrst_fast_clk_sel = 1; break; - case SOC_RTC_FAST_CLK_SRC_LP_PLL: - LP_CLKRST.lp_clk_conf.clkrst_fast_clk_sel = 2; - break; default: // Unsupported RTC_FAST_CLK mux input sel abort(); @@ -647,8 +523,6 @@ static inline __attribute__((always_inline)) soc_rtc_fast_clk_src_t clk_ll_rtc_f return SOC_RTC_FAST_CLK_SRC_RC_FAST; case 1: return SOC_RTC_FAST_CLK_SRC_XTAL_D2; - case 2: - return SOC_RTC_FAST_CLK_SRC_LP_PLL; default: return SOC_RTC_FAST_CLK_SRC_INVALID; } @@ -676,6 +550,14 @@ static inline __attribute__((always_inline)) uint32_t clk_ll_rc_fast_get_divider return 1; } +/** + * @brief Set the frequency division factor of RC_FAST clock + */ +static inline void clk_ll_rc_fast_tick_conf(void) +{ + HAL_FORCE_MODIFY_U32_REG_FIELD(PCR.ctrl_tick_conf, fosc_tick_num, (1 << CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS) - 1); // divider = 1 << CLK_LL_RC_FAST_CALIB_TICK_DIV_BITS +} + /** * @brief Set RC_SLOW_CLK divider * @@ -688,47 +570,6 @@ static inline __attribute__((always_inline)) void clk_ll_rc_slow_set_divider(uin } /************************** LP STORAGE REGISTER STORE/LOAD **************************/ -/** - * @brief Store XTAL_CLK frequency in RTC storage register - * - * Value of RTC_XTAL_FREQ_REG is stored as two copies in lower and upper 16-bit - * halves. These are the routines to work with that representation. - * - * @param xtal_freq_mhz XTAL frequency, in MHz. The frequency must necessarily be even, - * otherwise there will be a conflict with the low bit, which is used to disable logs - * in the ROM code. - */ -static inline __attribute__((always_inline)) void clk_ll_xtal_store_freq_mhz(uint32_t xtal_freq_mhz) -{ - // Read the status of whether disabling logging from ROM code - uint32_t reg = READ_PERI_REG(RTC_XTAL_FREQ_REG) & RTC_DISABLE_ROM_LOG; - // If so, need to write back this setting - if (reg == RTC_DISABLE_ROM_LOG) { - xtal_freq_mhz |= 1; - } - WRITE_PERI_REG(RTC_XTAL_FREQ_REG, (xtal_freq_mhz & UINT16_MAX) | ((xtal_freq_mhz & UINT16_MAX) << 16)); -} - -/** - * @brief Load XTAL_CLK frequency from RTC storage register - * - * Value of RTC_XTAL_FREQ_REG is stored as two copies in lower and upper 16-bit - * halves. These are the routines to work with that representation. - * - * @return XTAL frequency, in MHz. Returns 0 if value in reg is invalid. - */ -static inline __attribute__((always_inline)) uint32_t clk_ll_xtal_load_freq_mhz(void) -{ - // Read from RTC storage register - uint32_t xtal_freq_reg = READ_PERI_REG(RTC_XTAL_FREQ_REG); - if ((xtal_freq_reg & 0xFFFF) == ((xtal_freq_reg >> 16) & 0xFFFF) && - xtal_freq_reg != 0 && xtal_freq_reg != UINT32_MAX) { - return xtal_freq_reg & ~RTC_DISABLE_ROM_LOG & UINT16_MAX; - } - // If the format in reg is invalid - return 0; -} - /** * @brief Store RTC_SLOW_CLK calibration value in RTC storage register * @@ -754,24 +595,6 @@ static inline __attribute__((always_inline)) uint32_t clk_ll_rtc_slow_load_cal(v return REG_READ(RTC_SLOW_CLK_CAL_REG); } -/* -Set the frequency division factor of ref_tick -*/ -static inline void clk_ll_rc_fast_tick_conf(void) -{ - HAL_FORCE_MODIFY_U32_REG_FIELD(PCR.ctrl_tick_conf, fosc_tick_num, REG_FOSC_TICK_NUM); // enable a division of 32 to the fosc clock -} - -/* - * Enable/Disable the clock gate for clock output signal source -*/ -static inline void clk_ll_enable_clkout_source(soc_clkout_sig_id_t clk_src, bool en) -{ - if (clk_src == CLKOUT_SIG_XTAL) { - PCR.ctrl_clk_out_en.clk_xtal_oen = en; - } -} - #ifdef __cplusplus } #endif diff --git a/components/hal/esp32h21/include/hal/uart_ll.h b/components/hal/esp32h21/include/hal/uart_ll.h index 24df5176b7..67513010a2 100644 --- a/components/hal/esp32h21/include/hal/uart_ll.h +++ b/components/hal/esp32h21/include/hal/uart_ll.h @@ -28,6 +28,8 @@ extern "C" { #define UART_LL_FIFO_DEF_LEN (SOC_UART_FIFO_LEN) // Get UART hardware instance with giving uart num #define UART_LL_GET_HW(num) (((num) == UART_NUM_0) ? (&UART0) : (&UART1)) +// Get UART sleep clock with giving uart num +#define UART_LL_SLEEP_CLOCK(num) (((num) == UART_NUM_0) ? (ESP_SLEEP_CLOCK_UART0) : (ESP_SLEEP_CLOCK_UART1)) #define UART_LL_PULSE_TICK_CNT_MAX UART_LOWPULSE_MIN_CNT_V diff --git a/components/soc/esp32/include/soc/clk_tree_defs.h b/components/soc/esp32/include/soc/clk_tree_defs.h index ffdf27170b..48668299f1 100644 --- a/components/soc/esp32/include/soc/clk_tree_defs.h +++ b/components/soc/esp32/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -57,6 +57,14 @@ typedef enum { SOC_ROOT_CLK_EXT_XTAL32K, /*!< External 32kHz crystal/clock signal */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the BBPLL generator circuit */ + SOC_ROOT_CIRCUIT_CLK_APLL, /*!< APLL_CLK is the output of the APLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c2/include/soc/clk_tree_defs.h b/components/soc/esp32c2/include/soc/clk_tree_defs.h index 21fbf24382..2fda76d4b9 100644 --- a/components/soc/esp32c2/include/soc/clk_tree_defs.h +++ b/components/soc/esp32c2/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -34,6 +34,9 @@ extern "C" { * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 0 + /* With the default value of CK8M_DFREQ = 100, RC_FAST clock frequency is 17.5 MHz +/- 7% */ #define SOC_CLK_RC_FAST_FREQ_APPROX 17500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ #define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ @@ -54,6 +57,13 @@ typedef enum { SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin0, only support 32.768 KHz currently */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the BBPLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c2/register/soc/io_mux_reg.h b/components/soc/esp32c2/register/soc/io_mux_reg.h index 7a59d046f7..14e32a985f 100644 --- a/components/soc/esp32c2/register/soc/io_mux_reg.h +++ b/components/soc/esp32c2/register/soc/io_mux_reg.h @@ -129,8 +129,6 @@ #define SPI_D_GPIO_NUM 16 #define SPI_Q_GPIO_NUM 17 -#define EXT_OSC_SLOW_GPIO_NUM 0 - #define MAX_RTC_GPIO_NUM 5 #define MAX_PAD_GPIO_NUM 20 #define MAX_GPIO_NUM 24 diff --git a/components/soc/esp32c3/include/soc/clk_tree_defs.h b/components/soc/esp32c3/include/soc/clk_tree_defs.h index a36eceeac5..287ffe305a 100644 --- a/components/soc/esp32c3/include/soc/clk_tree_defs.h +++ b/components/soc/esp32c3/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -55,6 +55,13 @@ typedef enum { SOC_ROOT_CLK_EXT_XTAL32K, /*!< External 32kHz crystal/clock signal */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the BBPLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c5/include/soc/clk_tree_defs.h b/components/soc/esp32c5/include/soc/clk_tree_defs.h index 43226a472d..0376bf748c 100644 --- a/components/soc/esp32c5/include/soc/clk_tree_defs.h +++ b/components/soc/esp32c5/include/soc/clk_tree_defs.h @@ -41,6 +41,9 @@ extern "C" { * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 0 + /* With the default value of FOSC_DFREQ = 100, RC_FAST clock frequency is 17.5 MHz +/- 7% */ #define SOC_CLK_RC_FAST_FREQ_APPROX 17500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ #define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ @@ -62,6 +65,13 @@ typedef enum { SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin0 */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the PLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c5/register/soc/io_mux_reg.h b/components/soc/esp32c5/register/soc/io_mux_reg.h index 0576291a35..18365a6a87 100644 --- a/components/soc/esp32c5/register/soc/io_mux_reg.h +++ b/components/soc/esp32c5/register/soc/io_mux_reg.h @@ -141,8 +141,6 @@ extern "C" { #define USB_INT_PHY0_DM_GPIO_NUM 13 #define USB_INT_PHY0_DP_GPIO_NUM 14 -#define EXT_OSC_SLOW_GPIO_NUM 0 - #define MAX_RTC_GPIO_NUM 6 #define MAX_PAD_GPIO_NUM 28 #define MAX_GPIO_NUM 32 diff --git a/components/soc/esp32c6/include/soc/clk_tree_defs.h b/components/soc/esp32c6/include/soc/clk_tree_defs.h index a63e2fbc09..c785df80d4 100644 --- a/components/soc/esp32c6/include/soc/clk_tree_defs.h +++ b/components/soc/esp32c6/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -43,6 +43,9 @@ extern "C" { * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 0 + /* With the default value of FOSC_DFREQ = 100, RC_FAST clock frequency is 17.5 MHz +/- 7% */ #define SOC_CLK_RC_FAST_FREQ_APPROX 17500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ #define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ @@ -66,6 +69,13 @@ typedef enum { SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin0 */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the PLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c6/register/soc/io_mux_reg.h b/components/soc/esp32c6/register/soc/io_mux_reg.h index 0adf0203ef..8769a66dae 100644 --- a/components/soc/esp32c6/register/soc/io_mux_reg.h +++ b/components/soc/esp32c6/register/soc/io_mux_reg.h @@ -146,8 +146,6 @@ #define USB_INT_PHY0_DM_GPIO_NUM 12 #define USB_INT_PHY0_DP_GPIO_NUM 13 -#define EXT_OSC_SLOW_GPIO_NUM 0 - #define MAX_RTC_GPIO_NUM 7 #define MAX_PAD_GPIO_NUM 30 #define MAX_GPIO_NUM 34 diff --git a/components/soc/esp32c61/include/soc/clk_tree_defs.h b/components/soc/esp32c61/include/soc/clk_tree_defs.h index 18c9209da4..b61dc05f43 100644 --- a/components/soc/esp32c61/include/soc/clk_tree_defs.h +++ b/components/soc/esp32c61/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -39,6 +39,9 @@ extern "C" { * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 0 + /* With the default value of FOSC_DFREQ = 100, RC_FAST clock frequency is 17.5 MHz +/- 7% */ #define SOC_CLK_RC_FAST_FREQ_APPROX 17500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ #define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ @@ -60,6 +63,13 @@ typedef enum { SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin0 */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the PLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32c61/register/soc/io_mux_reg.h b/components/soc/esp32c61/register/soc/io_mux_reg.h index fcea82ecb7..67953452ee 100644 --- a/components/soc/esp32c61/register/soc/io_mux_reg.h +++ b/components/soc/esp32c61/register/soc/io_mux_reg.h @@ -109,8 +109,6 @@ extern "C" { #define USB_INT_PHY0_DM_GPIO_NUM 12 #define USB_INT_PHY0_DP_GPIO_NUM 13 -#define EXT_OSC_SLOW_GPIO_NUM 0 - #define MAX_RTC_GPIO_NUM 6 #define MAX_PAD_GPIO_NUM 29 #define MAX_GPIO_NUM 33 diff --git a/components/soc/esp32h2/include/soc/clk_tree_defs.h b/components/soc/esp32h2/include/soc/clk_tree_defs.h index b81776c7c5..749573cf5a 100644 --- a/components/soc/esp32h2/include/soc/clk_tree_defs.h +++ b/components/soc/esp32h2/include/soc/clk_tree_defs.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -43,6 +43,9 @@ extern "C" { * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 13 + /* With the default value of CK8M_DFREQ = 860, RC_FAST clock frequency is 8.5 MHz +/- 7% */ #define SOC_CLK_RC_FAST_FREQ_APPROX 8500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ #define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ @@ -66,6 +69,13 @@ typedef enum { SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin13 */ } soc_root_clk_t; +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the PLL generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose diff --git a/components/soc/esp32h2/include/soc/soc.h b/components/soc/esp32h2/include/soc/soc.h index b35b9cc15f..35441cfe23 100644 --- a/components/soc/esp32h2/include/soc/soc.h +++ b/components/soc/esp32h2/include/soc/soc.h @@ -161,7 +161,7 @@ #define SOC_IRAM_HIGH 0x40850000 #define SOC_DRAM_LOW 0x40800000 #define SOC_DRAM_HIGH 0x40850000 -#define SOC_RTC_IRAM_LOW 0x50000000 // ESP32-H2 only has 16k LP memory +#define SOC_RTC_IRAM_LOW 0x50000000 // ESP32-H2 only has 4k LP memory #define SOC_RTC_IRAM_HIGH 0x50001000 #define SOC_RTC_DRAM_LOW 0x50000000 #define SOC_RTC_DRAM_HIGH 0x50001000 diff --git a/components/soc/esp32h2/register/soc/io_mux_reg.h b/components/soc/esp32h2/register/soc/io_mux_reg.h index c19f3de9e0..a765ae92db 100644 --- a/components/soc/esp32h2/register/soc/io_mux_reg.h +++ b/components/soc/esp32h2/register/soc/io_mux_reg.h @@ -158,8 +158,6 @@ #define USB_INT_PHY0_DM_GPIO_NUM 26 #define USB_INT_PHY0_DP_GPIO_NUM 27 -#define EXT_OSC_SLOW_GPIO_NUM 13 - #define MAX_RTC_GPIO_NUM 14 // GPIO7~14 are the pads with LP function #define MAX_PAD_GPIO_NUM 27 #define MAX_GPIO_NUM 31 diff --git a/components/soc/esp32h21/include/soc/Kconfig.soc_caps.in b/components/soc/esp32h21/include/soc/Kconfig.soc_caps.in index 4aac6c2869..2eb7f5658b 100644 --- a/components/soc/esp32h21/include/soc/Kconfig.soc_caps.in +++ b/components/soc/esp32h21/include/soc/Kconfig.soc_caps.in @@ -87,6 +87,14 @@ config SOC_SECURE_BOOT_SUPPORTED bool default y +config SOC_PMU_SUPPORTED + bool + default y + +config SOC_CLK_TREE_SUPPORTED + bool + default y + config SOC_WDT_SUPPORTED bool default y @@ -891,6 +899,14 @@ config SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY bool default y +config SOC_PM_SUPPORT_PMU_CLK_ICG + bool + default y + +config SOC_CLK_RC_FAST_SUPPORT_CALIBRATION + bool + default y + config SOC_CLK_XTAL32K_SUPPORTED bool default y @@ -899,11 +915,7 @@ config SOC_CLK_OSC_SLOW_SUPPORTED bool default y -config SOC_CLK_RC32K_SUPPORTED - bool - default y - -config SOC_CLK_LP_FAST_SUPPORT_LP_PLL +config SOC_CLK_LP_FAST_SUPPORT_XTAL_D2 bool default y diff --git a/components/soc/esp32h21/include/soc/clk_tree_defs.h b/components/soc/esp32h21/include/soc/clk_tree_defs.h index b0c55a60e7..4876e38b26 100644 --- a/components/soc/esp32h21/include/soc/clk_tree_defs.h +++ b/components/soc/esp32h21/include/soc/clk_tree_defs.h @@ -11,45 +11,66 @@ extern "C" { /* ************************* ESP32H21 Root Clock Source **************************** - * 1) Internal 8MHz RC Oscillator: RC_FAST (usually referred as FOSC in TRM and reg. description) + * 1) Internal 20MHz RC Oscillator: RC_FAST (usually referred as FOSC in TRM and reg. description) * - * This RC oscillator generates a ~8.5MHz clock signal output as the RC_FAST_CLK. + * This RC oscillator generates a ~20MHz clock signal output as the RC_FAST_CLK. * * The exact frequency of RC_FAST_CLK can be computed in runtime through calibration. * * 2) External 32MHz Crystal Clock: XTAL * - * 3) Internal 136kHz RC Oscillator: RC_SLOW (usually referred as SOSC in TRM or reg. description) + * 3) Internal 600kHz RC Oscillator: RC_SLOW (usually referred as SOSC in TRM or reg. description) * - * This RC oscillator generates a ~136kHz clock signal output as the RC_SLOW_CLK. The exact frequency of this clock + * This RC oscillator generates a ~600kHz clock signal output as the RC_SLOW_CLK. The exact frequency of this clock * can be computed in runtime through calibration. * - * 4) Internal 32kHz RC Oscillator: RC32K - * - * The exact frequency of this clock can be computed in runtime through calibration. - * - * 5) External 32kHz Crystal Clock (optional): XTAL32K + * 4) External 32kHz Crystal Clock (optional): XTAL32K * * The clock source for this XTAL32K_CLK should be a 32kHz crystal connecting to the XTAL_32K_P and XTAL_32K_N * pins. * * XTAL32K_CLK can also be calibrated to get its exact frequency. * - * 6) External Slow Clock (optional): OSC_SLOW + * 5) External Slow Clock (optional): OSC_SLOW * - * A slow clock signal generated by an external circuit can be connected to GPIO13 to be the clock source for the + * A slow clock signal generated by an external circuit can be connected to GPIO11 to be the clock source for the * RTC_SLOW_CLK. * * OSC_SLOW_CLK can also be calibrated to get its exact frequency. */ -/* With the default value of CK8M_DFREQ = 860, RC_FAST clock frequency is 8.5 MHz +/- 7% */ -#define SOC_CLK_RC_FAST_FREQ_APPROX 8500000 /*!< Approximate RC_FAST_CLK frequency in Hz */ -#define SOC_CLK_RC_SLOW_FREQ_APPROX 136000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ -#define SOC_CLK_RC32K_FREQ_APPROX 32768 /*!< Approximate RC32K_CLK frequency in Hz */ +/* The pin number to connect the external slow clock (OSC_SLOW_CLK), XTAL_32K_P */ +#define SOC_EXT_OSC_SLOW_GPIO_NUM 11 + +/* With the default value of CK8M_DFREQ = 860, RC_FAST clock frequency is 20 MHz +/- 7% */ +#define SOC_CLK_RC_FAST_FREQ_APPROX 20000000 /*!< Approximate RC_FAST_CLK frequency in Hz */ +#define SOC_CLK_RC_SLOW_FREQ_APPROX 600000 /*!< Approximate RC_SLOW_CLK frequency in Hz */ #define SOC_CLK_XTAL32K_FREQ_APPROX 32768 /*!< Approximate XTAL32K_CLK frequency in Hz */ #define SOC_CLK_OSC_SLOW_FREQ_APPROX 32768 /*!< Approximate OSC_SLOW_CLK (external slow clock) frequency in Hz */ +// Naming convention: SOC_ROOT_CLK_{loc}_{type}_[attr] +// {loc}: EXT, INT +// {type}: XTAL, RC +// [attr] - optional: [frequency], FAST, SLOW +/** + * @brief Root clock + */ +typedef enum { + SOC_ROOT_CLK_INT_RC_FAST, /*!< Internal 20MHz RC oscillator */ + SOC_ROOT_CLK_INT_RC_SLOW, /*!< Internal 600kHz RC oscillator */ + SOC_ROOT_CLK_EXT_XTAL, /*!< External 32MHz crystal */ + SOC_ROOT_CLK_EXT_XTAL32K, /*!< External 32kHz crystal/clock signal */ + SOC_ROOT_CLK_EXT_OSC_SLOW, /*!< External slow clock signal at pin11 */ +} soc_root_clk_t; + +/** + * @brief ROOT clock circuit, which requires explicitly enabling the targeting circuit to use + */ +typedef enum { + SOC_ROOT_CIRCUIT_CLK_BBPLL, /*!< BBPLL_CLK is the output of the PLL generator circuit */ + SOC_ROOT_CIRCUIT_CLK_XTAL_X2, /*!< XTAL_X2_CLK is the output of the XTAL_X2 generator circuit */ +} soc_root_clk_circuit_t; + /** * @brief CPU_CLK mux inputs, which are the supported clock sources for the CPU_CLK * @note Enum values are matched with the register field values on purpose @@ -58,7 +79,7 @@ typedef enum { SOC_CPU_CLK_SRC_XTAL = 0, /*!< Select XTAL_CLK as CPU_CLK source */ SOC_CPU_CLK_SRC_PLL = 1, /*!< Select PLL_CLK as CPU_CLK source (PLL_CLK is one of the outputs of 32MHz crystal oscillator frequency multiplier, 96MHz) */ SOC_CPU_CLK_SRC_RC_FAST = 2, /*!< Select RC_FAST_CLK as CPU_CLK source */ - SOC_CPU_CLK_SRC_FLASH_PLL = 3, /*!< Select FLASH_PLL_CLK as CPU_CLK source (FLASH_PLL_CLK is the other output of 32MHz crystal oscillator frequency multiplier, 64MHz) */ + SOC_CPU_CLK_SRC_XTAL_X2 = 3, /*!< Select XTAL_X2_CLK as CPU_CLK source (XTAL_X2_CLK is the other output of 32MHz crystal oscillator frequency multiplier, 64MHz) */ SOC_CPU_CLK_SRC_INVALID, /*!< Invalid CPU_CLK source */ } soc_cpu_clk_src_t; @@ -69,7 +90,6 @@ typedef enum { typedef enum { SOC_RTC_SLOW_CLK_SRC_RC_SLOW = 0, /*!< Select RC_SLOW_CLK as RTC_SLOW_CLK source */ SOC_RTC_SLOW_CLK_SRC_XTAL32K = 1, /*!< Select XTAL32K_CLK as RTC_SLOW_CLK source */ - SOC_RTC_SLOW_CLK_SRC_RC32K = 2, /*!< Select RC32K_CLK as RTC_SLOW_CLK source */ SOC_RTC_SLOW_CLK_SRC_OSC_SLOW = 3, /*!< Select OSC_SLOW_CLK (external slow clock) as RTC_SLOW_CLK source */ SOC_RTC_SLOW_CLK_SRC_INVALID, /*!< Invalid RTC_SLOW_CLK source */ } soc_rtc_slow_clk_src_t; @@ -81,24 +101,11 @@ typedef enum { typedef enum { SOC_RTC_FAST_CLK_SRC_RC_FAST = 0, /*!< Select RC_FAST_CLK as RTC_FAST_CLK source */ SOC_RTC_FAST_CLK_SRC_XTAL_D2 = 1, /*!< Select XTAL_D2_CLK (may referred as XTAL_CLK_DIV_2) as RTC_FAST_CLK source */ - SOC_RTC_FAST_CLK_SRC_XTAL_DIV = SOC_RTC_FAST_CLK_SRC_XTAL_D2, /*!< Alias name for `SOC_RTC_FAST_CLK_SRC_XTAL_D2` */ - SOC_RTC_FAST_CLK_SRC_LP_PLL = 2, /*!< Select LP_PLL_CLK as RTC_FAST_CLK source (LP_PLL_CLK is a 8MHz clock sourced from RC32K or XTAL32K)*/ SOC_RTC_FAST_CLK_SRC_INVALID, /*!< Invalid RTC_FAST_CLK source */ SOC_RTC_FAST_CLK_SRC_DEFAULT = SOC_RTC_FAST_CLK_SRC_XTAL_D2, /*!< XTAL_D2_CLK is the default clock source for RTC_FAST_CLK */ - } soc_rtc_fast_clk_src_t; -/** - * @brief LP_PLL_CLK mux inputs, which are the supported clock sources for the LP_PLL_CLK - * @note Enum values are matched with the register field values on purpose - */ -typedef enum { - SOC_LP_PLL_CLK_SRC_RC32K = 0, /*!< Select RC32K_CLK as LP_PLL_CLK source */ - SOC_LP_PLL_CLK_SRC_XTAL32K = 1, /*!< Select XTAL32K_CLK as LP_PLL_CLK source */ - SOC_LP_PLL_CLK_SRC_INVALID, /*!< Invalid LP_PLL_CLK source */ -} soc_lp_pll_clk_src_t; - /** * @brief Possible main XTAL frequency options on the target * @note Enum values equal to the frequency value in MHz @@ -125,10 +132,10 @@ typedef enum { SOC_MOD_CLK_RTC_SLOW, /*!< RTC_SLOW_CLK can be sourced from RC_SLOW, XTAL32K, OSC_SLOW, or RC32K by configuring soc_rtc_slow_clk_src_t */ // For digital domain: peripherals, BLE SOC_MOD_CLK_PLL_F48M, /*!< PLL_F48M_CLK is derived from PLL (clock gating + fixed divider of 2), it has a fixed frequency of 48MHz */ - SOC_MOD_CLK_PLL_F64M, /*!< PLL_F64M_CLK is derived from FLASH_PLL (clock gating), it has a fixed frequency of 64MHz */ + SOC_MOD_CLK_XTAL_X2_F64M, /*!< PLL_F64M_CLK is derived from XTAL_X2 (clock gating), it has a fixed frequency of 64MHz */ SOC_MOD_CLK_PLL_F96M, /*!< PLL_F96M_CLK is derived from PLL (clock gating), it has a fixed frequency of 96MHz */ SOC_MOD_CLK_XTAL32K, /*!< XTAL32K_CLK comes from the external 32kHz crystal, passing a clock gating to the peripherals */ - SOC_MOD_CLK_RC_FAST, /*!< RC_FAST_CLK comes from the internal 8MHz rc oscillator, passing a clock gating to the peripherals */ + SOC_MOD_CLK_RC_FAST, /*!< RC_FAST_CLK comes from the internal 20MHz rc oscillator, passing a clock gating to the peripherals */ SOC_MOD_CLK_XTAL, /*!< XTAL_CLK comes from the external 32MHz crystal */ SOC_MOD_CLK_INVALID, /*!< Indication of the end of the available module clock sources */ } soc_module_clk_t; @@ -292,17 +299,17 @@ typedef enum { /** * @brief Array initializer for all supported clock sources of FLASH MSPI controller */ -#define SOC_FLASH_CLKS {SOC_MOD_CLK_XTAL, SOC_MOD_CLK_RC_FAST, SOC_MOD_CLK_PLL_F64M, SOC_MOD_CLK_PLL_F48M} +#define SOC_FLASH_CLKS {SOC_MOD_CLK_XTAL, SOC_MOD_CLK_RC_FAST, SOC_MOD_CLK_XTAL_X2_F64M, SOC_MOD_CLK_PLL_F48M} /** * @brief FLASH MSPI controller clock source */ typedef enum { - FLASH_CLK_SRC_XTAL = SOC_MOD_CLK_XTAL, /*!< Select XTAL as the source clock */ - FLASH_CLK_SRC_RC_FAST = SOC_MOD_CLK_RC_FAST, /*!< Select RC_FAST as the source clock */ - FLASH_CLK_SRC_PLL_F64M = SOC_MOD_CLK_PLL_F64M, /*!< Select PLL_F64M as the source clock */ - FLASH_CLK_SRC_PLL_F48M = SOC_MOD_CLK_PLL_F48M, /*!< Select PLL_F48M as the source clock */ - FLASH_CLK_SRC_DEFAULT = SOC_MOD_CLK_PLL_F64M, /*!< Select PLL_F64M as the default clock choice */ - FLASH_CLK_SRC_ROM_DEFAULT = SOC_MOD_CLK_XTAL, /*!< Select XTAL as ROM default clock source */ + FLASH_CLK_SRC_XTAL = SOC_MOD_CLK_XTAL, /*!< Select XTAL as the source clock */ + FLASH_CLK_SRC_RC_FAST = SOC_MOD_CLK_RC_FAST, /*!< Select RC_FAST as the source clock */ + FLASH_CLK_SRC_PLL_F64M = SOC_MOD_CLK_XTAL_X2_F64M, /*!< Select PLL_F64M as the source clock */ + FLASH_CLK_SRC_PLL_F48M = SOC_MOD_CLK_PLL_F48M, /*!< Select PLL_F48M as the source clock */ + FLASH_CLK_SRC_DEFAULT = SOC_MOD_CLK_XTAL_X2_F64M, /*!< Select PLL_F64M as the default clock choice */ + FLASH_CLK_SRC_ROM_DEFAULT = SOC_MOD_CLK_XTAL, /*!< Select XTAL as ROM default clock source */ } soc_periph_flash_clk_src_t; #ifdef __cplusplus diff --git a/components/soc/esp32h21/include/soc/soc.h b/components/soc/esp32h21/include/soc/soc.h index 14bc1952ef..76e914f339 100644 --- a/components/soc/esp32h21/include/soc/soc.h +++ b/components/soc/esp32h21/include/soc/soc.h @@ -159,7 +159,7 @@ #define SOC_IRAM_HIGH 0x40850000 #define SOC_DRAM_LOW 0x40800000 #define SOC_DRAM_HIGH 0x40850000 -#define SOC_RTC_IRAM_LOW 0x50000000 // ESP32-H21 only has 16k LP memory +#define SOC_RTC_IRAM_LOW 0x50000000 // ESP32-H21 only has 4k LP memory #define SOC_RTC_IRAM_HIGH 0x50001000 #define SOC_RTC_DRAM_LOW 0x50000000 #define SOC_RTC_DRAM_HIGH 0x50001000 diff --git a/components/soc/esp32h21/include/soc/soc_caps.h b/components/soc/esp32h21/include/soc/soc_caps.h index 26945c5cc4..f24a27ff26 100644 --- a/components/soc/esp32h21/include/soc/soc_caps.h +++ b/components/soc/esp32h21/include/soc/soc_caps.h @@ -54,11 +54,11 @@ #define SOC_SECURE_BOOT_SUPPORTED 1 // #define SOC_BOD_SUPPORTED 1 //TODO: [ESP32H21] IDF-11530 // #define SOC_APM_SUPPORTED 1 //TODO: [ESP32H21] IDF-11494 -// #define SOC_PMU_SUPPORTED 1 +#define SOC_PMU_SUPPORTED 1 // #define SOC_LP_TIMER_SUPPORTED 1 // #define SOC_LP_AON_SUPPORTED 1 // #define SOC_LP_PERIPHERALS_SUPPORTED 1 -// #define SOC_CLK_TREE_SUPPORTED 1 //TODO: [ESP32H21] IDF-11521 +#define SOC_CLK_TREE_SUPPORTED 1 // #define SOC_ASSIST_DEBUG_SUPPORTED 1 //TODO: [ESP32H21] IDF-11544 #define SOC_WDT_SUPPORTED 1 #define SOC_SPI_FLASH_SUPPORTED 1 //TODO: [ESP32H21] IDF-11526 @@ -230,7 +230,7 @@ // #define SOC_GPIO_CLOCKOUT_CHANNEL_NUM (3) /*-------------------------- RTCIO CAPS --------------------------------------*/ -/* No dedicated LP_IOMUX subsystem on ESP32-H2. LP functions are still supported +/* No dedicated LP_IOMUX subsystem on ESP32-H21. LP functions are still supported * for hold, wake & 32kHz crystal functions - via LP_AON registers */ #define SOC_RTCIO_PIN_COUNT (7U) #define SOC_RTCIO_HOLD_SUPPORTED (1) @@ -541,14 +541,16 @@ #define SOC_PM_MODEM_RETENTION_BY_REGDMA (1) #define SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY (1) /*!