fix(esp_system): fix ext 32k io revoking breaks sleep io holding

esp-wzh · espressif-bot · commit 4bb6a0195987 · 2025-10-10T19:44:07.000+08:00
diff --git a/components/esp_system/port/soc/esp32/clk.c b/components/esp_system/port/soc/esp32/clk.c
@@ -61,7 +61,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
      */
     int retry_32k_xtal = RTC_XTAL_CAL_RETRY;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -85,13 +87,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {
             rtc_clk_8m_enable(true, true);
         }
         rtc_clk_slow_src_set(rtc_slow_clk_src);
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {
             rtc_clk_32k_enable(false);
             rtc_clk_32k_disable_external();
         }
diff --git a/components/esp_system/port/soc/esp32c2/clk.c b/components/esp_system/port/soc/esp32c2/clk.c
@@ -154,7 +154,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
      */
     int retry_ext_clk = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* external clock needs to be connected to PIN0 before it can
              * be used. Here we use rtc_clk_cal function to count
@@ -174,13 +176,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
                     }
                     ESP_EARLY_LOGW(TAG, "external clock connected to pin0 not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {
             rtc_clk_8m_enable(true, true);
         }
         rtc_clk_slow_src_set(rtc_slow_clk_src);
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW))) {
             rtc_clk_32k_disable_external();
         }
         if (SLOW_CLK_CAL_CYCLES > 0) {
diff --git a/components/esp_system/port/soc/esp32c3/clk.c b/components/esp_system/port/soc/esp32c3/clk.c
@@ -146,7 +146,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -170,13 +172,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {
             rtc_clk_8m_enable(true, true);
         }
         rtc_clk_slow_src_set(rtc_slow_clk_src);
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {
             rtc_clk_32k_enable(false);
             rtc_clk_32k_disable_external();
         }
diff --git a/components/esp_system/port/soc/esp32c5/clk.c b/components/esp_system/port/soc/esp32c5/clk.c
@@ -167,7 +167,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -194,13 +196,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_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.
-        if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32c6/clk.c b/components/esp_system/port/soc/esp32c6/clk.c
@@ -146,7 +146,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -173,6 +175,7 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) {
@@ -181,7 +184,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
         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.
-        if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32c61/clk.c b/components/esp_system/port/soc/esp32c61/clk.c
@@ -117,7 +117,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -144,13 +146,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_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.
-        if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32h2/clk.c b/components/esp_system/port/soc/esp32h2/clk.c
@@ -150,7 +150,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -177,6 +179,7 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) {
@@ -185,7 +188,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
         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.
-        if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32h21/clk.c b/components/esp_system/port/soc/esp32h21/clk.c
@@ -120,7 +120,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -147,13 +149,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW_D4;
+                    revoke_32k_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 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)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32h4/clk.c b/components/esp_system/port/soc/esp32h4/clk.c
@@ -117,7 +117,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K || rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -144,13 +146,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW_D4;
+                    revoke_32k_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 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)) {
+        if (revoke_32k_enable || \
+                (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) || (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \
+                 ((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();
         }
diff --git a/components/esp_system/port/soc/esp32p4/clk.c b/components/esp_system/port/soc/esp32p4/clk.c
@@ -162,7 +162,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
      */
     int retry_32k_xtal = 3;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -186,6 +188,7 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) {
@@ -195,7 +198,8 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t 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.
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K)) {
             rtc_clk_32k_enable(false);
         }
         if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_RC32K) {
diff --git a/components/esp_system/port/soc/esp32s2/clk.c b/components/esp_system/port/soc/esp32s2/clk.c
@@ -149,7 +149,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
      */
     int retry_32k_xtal = RTC_XTAL_CAL_RETRY;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -173,13 +175,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 90 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {
             rtc_clk_8m_enable(true, true);
         }
         rtc_clk_slow_src_set(rtc_slow_clk_src);
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {
             rtc_clk_32k_enable(false);
             rtc_clk_32k_disable_external();
         }
diff --git a/components/esp_system/port/soc/esp32s3/clk.c b/components/esp_system/port/soc/esp32s3/clk.c
@@ -148,7 +148,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
      */
     int retry_32k_xtal = RTC_XTAL_CAL_RETRY;
 
+    soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();
     do {
+        bool revoke_32k_enable = false;
         if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
             /* 32k XTAL oscillator needs to be enabled and running before it can
              * be used. Hardware doesn't have a direct way of checking if the
@@ -172,13 +174,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)
                     }
                     ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 150 kHz oscillator");
                     rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;
+                    revoke_32k_enable = true;
                 }
             }
         } else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {
             rtc_clk_8m_enable(true, true);
         }
         rtc_clk_slow_src_set(rtc_slow_clk_src);
-        if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {
+        if (revoke_32k_enable || \
+                ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {
             rtc_clk_32k_enable(false);
             rtc_clk_32k_disable_external();
         }

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`61`	`61`	`*/`
`62`	`62`	`int retry_32k_xtal = RTC_XTAL_CAL_RETRY;`
`63`	`63`
	`64`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`64`	`65`	`do {`
	`66`	`+ bool revoke_32k_enable = false;`
`65`	`67`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
`66`	`68`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`67`	`69`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -85,13 +87,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`85`	`87`	`}`
`86`	`88`	`ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 150 kHz oscillator");`
`87`	`89`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`90`	`+ revoke_32k_enable = true;`
`88`	`91`	`}`
`89`	`92`	`}`
`90`	`93`	`} else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {`
`91`	`94`	`rtc_clk_8m_enable(true, true);`
`92`	`95`	`}`
`93`	`96`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`94`		`- if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
	`97`	`+ if (revoke_32k_enable \|\| \`
	`98`	`+ ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {`
`95`	`99`	`rtc_clk_32k_enable(false);`
`96`	`100`	`rtc_clk_32k_disable_external();`
`97`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`154`	`154`	`*/`
`155`	`155`	`int retry_ext_clk = 3;`
`156`	`156`
	`157`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`157`	`158`	`do {`
	`159`	`+ bool revoke_32k_enable = false;`
`158`	`160`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {`
`159`	`161`	`/* external clock needs to be connected to PIN0 before it can`
`160`	`162`	`* be used. Here we use rtc_clk_cal function to count`
`@@ -174,13 +176,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`174`	`176`	`}`
`175`	`177`	`ESP_EARLY_LOGW(TAG, "external clock connected to pin0 not found, switching to internal 150 kHz oscillator");`
`176`	`178`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`179`	`+ revoke_32k_enable = true;`
`177`	`180`	`}`
`178`	`181`	`}`
`179`	`182`	`} else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {`
`180`	`183`	`rtc_clk_8m_enable(true, true);`
`181`	`184`	`}`
`182`	`185`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`183`		`- if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {`
	`186`	`+ if (revoke_32k_enable \|\| \`
	`187`	`+ ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW))) {`
`184`	`188`	`rtc_clk_32k_disable_external();`
`185`	`189`	`}`
`186`	`190`	`if (SLOW_CLK_CAL_CYCLES > 0) {`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,9 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`146`	`146`	`*/`
`147`	`147`	`int retry_32k_xtal = 3;`
`148`	`148`
	`149`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`149`	`150`	`do {`
	`151`	`+ bool revoke_32k_enable = false;`
`150`	`152`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
`151`	`153`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`152`	`154`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -170,13 +172,15 @@ static void select_rtc_slow_clk(slow_clk_sel_t slow_clk)`
`170`	`172`	`}`
`171`	`173`	`ESP_EARLY_LOGW(TAG, "32 kHz XTAL not found, switching to internal 150 kHz oscillator");`
`172`	`174`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`175`	`+ revoke_32k_enable = true;`
`173`	`176`	`}`
`174`	`177`	`}`
`175`	`178`	`} else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC_FAST_D256) {`
`176`	`179`	`rtc_clk_8m_enable(true, true);`
`177`	`180`	`}`
`178`	`181`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`179`		`- if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
	`182`	`+ if (revoke_32k_enable \|\| \`
	`183`	`+ ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K))) {`
`180`	`184`	`rtc_clk_32k_enable(false);`
`181`	`185`	`rtc_clk_32k_disable_external();`
`182`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`167`	`167`	`*/`
`168`	`168`	`int retry_32k_xtal = 3;`
`169`	`169`
	`170`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`170`	`171`	`do {`
	`172`	`+ bool revoke_32k_enable = false;`
`171`	`173`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K \|\| rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {`
`172`	`174`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`173`	`175`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -194,13 +196,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`194`	`196`	`}`
`195`	`197`	`ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");`
`196`	`198`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`199`	`+ revoke_32k_enable = true;`
`197`	`200`	`}`
`198`	`201`	`}`
`199`	`202`	`}`
`200`	`203`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`201`	`204`	`// Disable unused clock sources after clock source switching is complete.`
`202`	`205`	`// Regardless of the clock source selection, the internal 136K clock source will always keep on.`
`203`		`- if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {`
	`206`	`+ if (revoke_32k_enable \|\| \`
	`207`	`+ (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) \|\| (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \`
	`208`	`+ ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)))) {`
`204`	`209`	`rtc_clk_32k_enable(false);`
`205`	`210`	`rtc_clk_32k_disable_external();`
`206`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`117`	`117`	`*/`
`118`	`118`	`int retry_32k_xtal = 3;`
`119`	`119`
	`120`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`120`	`121`	`do {`
	`122`	`+ bool revoke_32k_enable = false;`
`121`	`123`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K \|\| rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {`
`122`	`124`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`123`	`125`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -144,13 +146,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`144`	`146`	`}`
`145`	`147`	`ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");`
`146`	`148`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`149`	`+ revoke_32k_enable = true;`
`147`	`150`	`}`
`148`	`151`	`}`
`149`	`152`	`}`
`150`	`153`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`151`	`154`	`// Disable unused clock sources after clock source switching is complete.`
`152`	`155`	`// Regardless of the clock source selection, the internal 136K clock source will always keep on.`
`153`		`- if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {`
	`156`	`+ if (revoke_32k_enable \|\| \`
	`157`	`+ (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) \|\| (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \`
	`158`	`+ ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)))) {`
`154`	`159`	`rtc_clk_32k_enable(false);`
`155`	`160`	`rtc_clk_32k_disable_external();`
`156`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`120`	`120`	`*/`
`121`	`121`	`int retry_32k_xtal = 3;`
`122`	`122`
	`123`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`123`	`124`	`do {`
	`125`	`+ bool revoke_32k_enable = false;`
`124`	`126`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K \|\| rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW) {`
`125`	`127`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`126`	`128`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -147,13 +149,16 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`147`	`149`	`}`
`148`	`150`	`ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");`
`149`	`151`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW_D4;`
	`152`	`+ revoke_32k_enable = true;`
`150`	`153`	`}`
`151`	`154`	`}`
`152`	`155`	`}`
`153`	`156`	`rtc_clk_slow_src_set(rtc_slow_clk_src);`
`154`	`157`	`// Disable unused clock sources after clock source switching is complete.`
`155`	`158`	`// Regardless of the clock source selection, the internal 600k clock source will always keep on.`
`156`		`- if ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) {`
	`159`	`+ if (revoke_32k_enable \|\| \`
	`160`	`+ (((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) \|\| (old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)) && \`
	`161`	`+ ((rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) && (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_OSC_SLOW)))) {`
`157`	`162`	`rtc_clk_32k_enable(false);`
`158`	`163`	`rtc_clk_32k_disable_external();`
`159`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,9 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`162`	`162`	`*/`
`163`	`163`	`int retry_32k_xtal = 3;`
`164`	`164`
	`165`	`+ soc_rtc_slow_clk_src_t old_rtc_slow_clk_src = rtc_clk_slow_src_get();`
`165`	`166`	`do {`
	`167`	`+ bool revoke_32k_enable = false;`
`166`	`168`	`if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
`167`	`169`	`/* 32k XTAL oscillator needs to be enabled and running before it can`
`168`	`170`	`* be used. Hardware doesn't have a direct way of checking if the`
`@@ -186,6 +188,7 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`186`	`188`	`}`
`187`	`189`	`ESP_EARLY_LOGW(TAG, "32 kHz clock not found, switching to internal 150 kHz oscillator");`
`188`	`190`	`rtc_slow_clk_src = SOC_RTC_SLOW_CLK_SRC_RC_SLOW;`
	`191`	`+ revoke_32k_enable = true;`
`189`	`192`	`}`
`190`	`193`	`}`
`191`	`194`	`} else if (rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_RC32K) {`
`@@ -195,7 +198,8 @@ static void select_rtc_slow_clk(soc_rtc_slow_clk_src_t rtc_slow_clk_src)`
`195`	`198`
`196`	`199`	`// Disable unused clock sources after clock source switching is complete.`
`197`	`200`	`// Regardless of the clock source selection, the internal 136K clock source will always keep on.`
`198`		`- if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K) {`
	`201`	`+ if (revoke_32k_enable \|\| \`
	`202`	`+ ((old_rtc_slow_clk_src == SOC_RTC_SLOW_CLK_SRC_XTAL32K) && rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_XTAL32K)) {`
`199`	`203`	`rtc_clk_32k_enable(false);`
`200`	`204`	`}`
`201`	`205`	`if (rtc_slow_clk_src != SOC_RTC_SLOW_CLK_SRC_RC32K) {`