Merge branch 'fix/drop_pm_code_if_not_need' into 'master'

fix(drivers): only call esp_pm APIs when CONFIG_PM_ENABLE is enabled

Closes IDFGH-15263

See merge request espressif/esp-idf!39045

Author: suda-morris

components/driver/twai/twai.c

@@ -100,8 +100,10 @@ typedef struct twai_obj_t {
     SemaphoreHandle_t alert_semphr;
     uint32_t alerts_enabled;
     uint32_t alerts_triggered;
+#ifdef CONFIG_PM_ENABLE
     //Power Management Lock
     esp_pm_lock_handle_t pm_lock;
+#endif
     portMUX_TYPE spinlock;
 } twai_obj_t;
 

components/esp_adc/adc_continuous.c

@@ -264,9 +264,11 @@ esp_err_t adc_continuous_start(adc_continuous_handle_t handle)
         adc_ll_reset_register();
     }
 
+#if CONFIG_PM_ENABLE
     if (handle->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_acquire(handle->pm_lock), ADC_TAG, "acquire pm_lock failed");
     }
+#endif
 
     handle->fsm = ADC_FSM_STARTED;
     sar_periph_ctrl_adc_continuous_power_acquire();
@@ -369,10 +371,12 @@ esp_err_t adc_continuous_stop(adc_continuous_handle_t handle)
     }
     sar_periph_ctrl_adc_continuous_power_release();
 
+#if CONFIG_PM_ENABLE
     //release power manager lock
     if (handle->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_release(handle->pm_lock), ADC_TAG, "release pm_lock failed");
     }
+#endif
 
     ANALOG_CLOCK_DISABLE();
 
@@ -422,9 +426,11 @@ esp_err_t adc_continuous_deinit(adc_continuous_handle_t handle)
         free(handle->ringbuf_struct);
     }
 
+#if CONFIG_PM_ENABLE
     if (handle->pm_lock) {
         esp_pm_lock_delete(handle->pm_lock);
     }
+#endif
 
     free(handle->rx_dma_buf);
     free(handle->hal.rx_desc);

components/esp_adc/adc_continuous_internal.h

@@ -89,7 +89,9 @@ struct adc_continuous_ctx_t {
     adc_hal_digi_ctrlr_cfg_t        hal_digi_ctrlr_cfg;         //Hal digital controller configuration
     adc_continuous_evt_cbs_t        cbs;                        //Callbacks
     void                            *user_data;                 //User context
+#if CONFIG_PM_ENABLE
     esp_pm_lock_handle_t            pm_lock;                    //For power management
+#endif
     struct {
         uint32_t flush_pool: 1;     //Flush the internal pool when the pool is full. With this flag, the `on_pool_ovf` event will not happen.
     } flags;

components/esp_driver_ana_cmpr/ana_cmpr.c

@@ -27,7 +27,9 @@ struct ana_cmpr_t {
     uint32_t                    intr_mask;          /*!< Interrupt mask */
     int                         intr_priority;      /*!< Interrupt priority */
     uint32_t                    src_clk_freq_hz;    /*!< Source clock frequency of the Analog Comparator unit */
+#if CONFIG_PM_ENABLE
     esp_pm_lock_handle_t        pm_lock;            /*!< The Power Management lock that used to avoid unexpected power down of the clock domain */
+#endif
 };
 
 /* Helper macros */
@@ -80,9 +82,11 @@ static esp_err_t s_ana_cmpr_init_gpio(ana_cmpr_handle_t cmpr, bool is_external_r
 
 static void ana_cmpr_destroy_unit(ana_cmpr_handle_t cmpr)
 {
+#if CONFIG_PM_ENABLE
     if (cmpr->pm_lock) {
         esp_pm_lock_delete(cmpr->pm_lock);
     }
+#endif
     if (cmpr->intr_handle) {
         esp_intr_free(cmpr->intr_handle);
     }
@@ -274,9 +278,11 @@ esp_err_t ana_cmpr_enable(ana_cmpr_handle_t cmpr)
     ANA_CMPR_NULL_POINTER_CHECK(cmpr);
     ana_cmpr_fsm_t expected_fsm = ANA_CMPR_FSM_INIT;
     if (atomic_compare_exchange_strong(&cmpr->fsm, &expected_fsm, ANA_CMPR_FSM_WAIT)) {
+#if CONFIG_PM_ENABLE
         if (cmpr->pm_lock) {
             esp_pm_lock_acquire(cmpr->pm_lock);
         }
+#endif
 
         // the underlying register may be accessed by different threads at the same time, so use spin lock to protect it
         portENTER_CRITICAL(&s_spinlock);
@@ -305,9 +311,11 @@ esp_err_t ana_cmpr_disable(ana_cmpr_handle_t cmpr)
         analog_cmpr_ll_enable(cmpr->dev, false);
         portEXIT_CRITICAL(&s_spinlock);
 
+#if CONFIG_PM_ENABLE
         if (cmpr->pm_lock) {
             esp_pm_lock_release(cmpr->pm_lock);
         }
+#endif
 
         // switch the state machine to init state
         atomic_store(&cmpr->fsm, ANA_CMPR_FSM_INIT);

components/esp_driver_gpio/src/gpio_flex_glitch_filter.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -28,8 +28,8 @@ struct gpio_flex_glitch_filter_t {
     gpio_glitch_filter_t base;
     gpio_flex_glitch_filter_group_t *group;
     uint32_t filter_id;
-    esp_pm_lock_handle_t pm_lock;
 #if CONFIG_PM_ENABLE
+    esp_pm_lock_handle_t pm_lock;
     char pm_lock_name[GLITCH_FILTER_PM_LOCK_NAME_LEN_MAX]; // pm lock name
 #endif
 };
@@ -72,9 +72,11 @@ static esp_err_t gpio_filter_destroy(gpio_flex_glitch_filter_t *filter)
         portEXIT_CRITICAL(&group->spinlock);
     }
 
+#if CONFIG_PM_ENABLE
     if (filter->pm_lock) {
         esp_pm_lock_delete(filter->pm_lock);
     }
+#endif
 
     free(filter);
     return ESP_OK;
@@ -92,10 +94,12 @@ static esp_err_t gpio_flex_glitch_filter_enable(gpio_glitch_filter_t *filter)
     ESP_RETURN_ON_FALSE(filter->fsm == GLITCH_FILTER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "filter not in init state");
     gpio_flex_glitch_filter_t *flex_filter = __containerof(filter, gpio_flex_glitch_filter_t, base);
 
+#if CONFIG_PM_ENABLE
     // acquire pm lock
     if (flex_filter->pm_lock) {
         esp_pm_lock_acquire(flex_filter->pm_lock);
     }
+#endif
 
     int filter_id = flex_filter->filter_id;
     gpio_ll_glitch_filter_enable(s_gpio_glitch_filter_group.hw, filter_id, true);
@@ -111,10 +115,12 @@ static esp_err_t gpio_flex_glitch_filter_disable(gpio_glitch_filter_t *filter)
     int filter_id = flex_filter->filter_id;
     gpio_ll_glitch_filter_enable(s_gpio_glitch_filter_group.hw, filter_id, false);
 
+#if CONFIG_PM_ENABLE
     // release pm lock
     if (flex_filter->pm_lock) {
         esp_pm_lock_release(flex_filter->pm_lock);
     }
+#endif
 
     filter->fsm = GLITCH_FILTER_FSM_INIT;
     return ESP_OK;

components/esp_driver_gpio/src/gpio_pin_glitch_filter.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,17 +20,19 @@ static const char *TAG = "gpio-filter";
  */
 typedef struct gpio_pin_glitch_filter_t {
     gpio_glitch_filter_t base;
-    esp_pm_lock_handle_t pm_lock;
 #if CONFIG_PM_ENABLE
+    esp_pm_lock_handle_t pm_lock;
     char pm_lock_name[GLITCH_FILTER_PM_LOCK_NAME_LEN_MAX]; // pm lock name
 #endif
 } gpio_pin_glitch_filter_t;
 
 static esp_err_t gpio_filter_destroy(gpio_pin_glitch_filter_t *filter)
 {
+#if CONFIG_PM_ENABLE
     if (filter->pm_lock) {
         esp_pm_lock_delete(filter->pm_lock);
     }
+#endif
 
     free(filter);
     return ESP_OK;
@@ -46,12 +48,14 @@ static esp_err_t gpio_pin_glitch_filter_del(gpio_glitch_filter_t *filter)
 static esp_err_t gpio_pin_glitch_filter_enable(gpio_glitch_filter_t *filter)
 {
     ESP_RETURN_ON_FALSE(filter->fsm == GLITCH_FILTER_FSM_INIT, ESP_ERR_INVALID_STATE, TAG, "filter not in init state");
-    gpio_pin_glitch_filter_t *pin_filter = __containerof(filter, gpio_pin_glitch_filter_t, base);
+    [[maybe_unused]] gpio_pin_glitch_filter_t *pin_filter = __containerof(filter, gpio_pin_glitch_filter_t, base);
 
+#if CONFIG_PM_ENABLE
     // acquire pm lock
     if (pin_filter->pm_lock) {
         esp_pm_lock_acquire(pin_filter->pm_lock);
     }
+#endif
 
     gpio_ll_pin_filter_enable(NULL, filter->gpio_num);
     filter->fsm = GLITCH_FILTER_FSM_ENABLE;
@@ -61,14 +65,16 @@ static esp_err_t gpio_pin_glitch_filter_enable(gpio_glitch_filter_t *filter)
 static esp_err_t gpio_pin_glitch_filter_disable(gpio_glitch_filter_t *filter)
 {
     ESP_RETURN_ON_FALSE(filter->fsm == GLITCH_FILTER_FSM_ENABLE, ESP_ERR_INVALID_STATE, TAG, "filter not in enable state");
-    gpio_pin_glitch_filter_t *pin_filter = __containerof(filter, gpio_pin_glitch_filter_t, base);
+    [[maybe_unused]] gpio_pin_glitch_filter_t *pin_filter = __containerof(filter, gpio_pin_glitch_filter_t, base);
 
     gpio_ll_pin_filter_disable(NULL, filter->gpio_num);
 
+#if CONFIG_PM_ENABLE
     // release pm lock
     if (pin_filter->pm_lock) {
         esp_pm_lock_release(pin_filter->pm_lock);
     }
+#endif
 
     filter->fsm = GLITCH_FILTER_FSM_INIT;
     return ESP_OK;

components/esp_driver_gptimer/src/gptimer.c

@@ -108,9 +108,11 @@ static void gptimer_unregister_from_group(gptimer_t *timer)
 
 static esp_err_t gptimer_destroy(gptimer_t *timer)
 {
+#if CONFIG_PM_ENABLE
     if (timer->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_delete(timer->pm_lock), TAG, "delete pm_lock failed");
     }
+#endif
     if (timer->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(timer->intr), TAG, "delete interrupt service failed");
     }
@@ -347,10 +349,12 @@ esp_err_t gptimer_enable(gptimer_handle_t timer)
     ESP_RETURN_ON_FALSE(atomic_compare_exchange_strong(&timer->fsm, &expected_fsm, GPTIMER_FSM_ENABLE),
                         ESP_ERR_INVALID_STATE, TAG, "timer not in init state");
 
+#if CONFIG_PM_ENABLE
     // acquire power manager lock
     if (timer->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_acquire(timer->pm_lock), TAG, "acquire pm_lock failed");
     }
+#endif
 
     // enable interrupt service
     if (timer->intr) {
@@ -373,10 +377,12 @@ esp_err_t gptimer_disable(gptimer_handle_t timer)
         ESP_RETURN_ON_ERROR(esp_intr_disable(timer->intr), TAG, "disable interrupt service failed");
     }
 
+#if CONFIG_PM_ENABLE
     // release power manager lock
     if (timer->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_release(timer->pm_lock), TAG, "release pm_lock failed");
     }
+#endif
 
     return ESP_OK;
 }

components/esp_driver_gptimer/src/gptimer_common.c

@@ -134,8 +134,7 @@ esp_err_t gptimer_select_periph_clock(gptimer_t *timer, gptimer_clock_source_t s
 #endif // CONFIG_IDF_TARGET_ESP32C2
 
     if (need_pm_lock) {
-        sprintf(timer->pm_lock_name, "gptimer_%d_%d", group_id, timer_id); // e.g. gptimer_0_0
-        ESP_RETURN_ON_ERROR(esp_pm_lock_create(pm_lock_type, 0, timer->pm_lock_name, &timer->pm_lock),
+        ESP_RETURN_ON_ERROR(esp_pm_lock_create(pm_lock_type, 0, timer_group_periph_signals.groups[group_id].module_name[timer_id], &timer->pm_lock),
                             TAG, "create pm lock failed");
     }
 #endif // CONFIG_PM_ENABLE
@@ -165,12 +164,14 @@ esp_err_t gptimer_get_intr_handle(gptimer_handle_t timer, intr_handle_t *ret_int
     return ESP_OK;
 }
 
+#if CONFIG_PM_ENABLE
 esp_err_t gptimer_get_pm_lock(gptimer_handle_t timer, esp_pm_lock_handle_t *ret_pm_lock)
 {
     ESP_RETURN_ON_FALSE(timer && ret_pm_lock, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
     *ret_pm_lock = timer->pm_lock;
     return ESP_OK;
 }
+#endif // CONFIG_PM_ENABLE
 
 int gptimer_get_group_id(gptimer_handle_t timer, int *group_id)
 {

components/esp_driver_gptimer/src/gptimer_priv.h

@@ -51,8 +51,6 @@ extern "C" {
 
 #define GPTIMER_ALLOW_INTR_PRIORITY_MASK ESP_INTR_FLAG_LOWMED
 
-#define GPTIMER_PM_LOCK_NAME_LEN_MAX 16
-
 #define GPTIMER_USE_RETENTION_LINK  (SOC_TIMER_SUPPORT_SLEEP_RETENTION && CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP)
 
 #if SOC_PERIPH_CLK_CTRL_SHARED
@@ -95,9 +93,8 @@ struct gptimer_t {
     gptimer_alarm_cb_t on_alarm;
     void *user_ctx;
     gptimer_clock_source_t clk_src;
-    esp_pm_lock_handle_t pm_lock; // power management lock
 #if CONFIG_PM_ENABLE
-    char pm_lock_name[GPTIMER_PM_LOCK_NAME_LEN_MAX]; // pm lock name
+    esp_pm_lock_handle_t pm_lock; // power management lock
 #endif
     struct {
         uint32_t intr_shared: 1;

components/esp_driver_i2c/i2c_common.c

@@ -211,9 +211,11 @@ esp_err_t i2c_release_bus_handle(i2c_bus_handle_t i2c_bus)
             if (i2c_bus->intr_handle) {
                 ESP_RETURN_ON_ERROR(esp_intr_free(i2c_bus->intr_handle), TAG, "delete interrupt service failed");
             }
+#if CONFIG_PM_ENABLE
             if (i2c_bus->pm_lock) {
                 ESP_RETURN_ON_ERROR(esp_pm_lock_delete(i2c_bus->pm_lock), TAG, "delete pm_lock failed");
             }
+#endif
             // Disable I2C module
             if (!i2c_bus->is_lp_i2c) {
                 I2C_RCC_ATOMIC() {
@@ -306,8 +308,7 @@ esp_err_t i2c_select_periph_clock(i2c_bus_handle_t handle, soc_module_clk_t clk_
     }
 
     if (need_pm_lock) {
-        sprintf(handle->pm_lock_name, "I2C_%d", handle->port_num); // e.g. PORT_0
-        ret  = esp_pm_lock_create(pm_lock_type, 0, handle->pm_lock_name, &handle->pm_lock);
+        ret  = esp_pm_lock_create(pm_lock_type, 0, i2c_periph_signal[handle->port_num].module_name, &handle->pm_lock);
         ESP_RETURN_ON_ERROR(ret, TAG, "create pm lock failed");
     }
 #endif // CONFIG_PM_ENABLE