diff --git a/components/esp_hw_support/CMakeLists.txt b/components/esp_hw_support/CMakeLists.txt
index 2df8c2553f..58db4cac43 100644
--- a/components/esp_hw_support/CMakeLists.txt
+++ b/components/esp_hw_support/CMakeLists.txt
@@ -71,6 +71,7 @@ if(NOT non_os_build)
             )
         if(CONFIG_SOC_PAU_SUPPORTED AND CONFIG_SOC_PM_SUPPORT_TOP_PD)
             list(APPEND srcs "sleep_system_peripheral.c")
+            list(APPEND srcs "port/${target}/peripheral_domain_pd.c")
         endif()
     endif()
 
@@ -239,6 +240,10 @@ if(CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND OR CONFIG_PM_SLP_DISABLE_GPIO)
     target_link_libraries(${COMPONENT_LIB} INTERFACE "-u esp_sleep_gpio_include")
 endif()
 
+if(CONFIG_SOC_PAU_SUPPORTED AND CONFIG_SOC_PM_SUPPORT_TOP_PD)
+    target_link_libraries(${COMPONENT_LIB} INTERFACE "-u sleep_system_peripheral_dummy")
+endif()
+
 if(NOT non_os_build)
     if(CONFIG_SPIRAM)
         idf_component_optional_requires(PRIVATE esp_psram)
diff --git a/components/esp_hw_support/include/esp_private/sleep_retention.h b/components/esp_hw_support/include/esp_private/sleep_retention.h
index 0b211ff885..3b5671eb82 100644
--- a/components/esp_hw_support/include/esp_private/sleep_retention.h
+++ b/components/esp_hw_support/include/esp_private/sleep_retention.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
  */
@@ -30,6 +30,17 @@ typedef struct {
 #define RETENTION_MODULE_BITMAP_INIT(module) { .bitmap[(SLEEP_RETENTION_MODULE_ ## module) >> 5] = BIT((SLEEP_RETENTION_MODULE_ ## module) % 32) }
     uint32_t bitmap[SLEEP_RETENTION_MODULE_BITMAP_SZ];
 } sleep_retention_module_bitmap_t;
+
+/**
+ * @brief Set a bit in the retention module bitmap
+ *
+ * @param bitmap_ptr Pointer to the bitmap structure
+ * @param module     Module number (e.g., SLEEP_RETENTION_MODULE_SYS_PERIPH)
+ */
+#define RETENTION_MODULE_BITMAP_SET(bitmap_ptr, module) \
+    do { \
+        (bitmap_ptr)->bitmap[(module) >> 5] |= BIT((module) % 32); \
+    } while (0)
 typedef regdma_entry_buf_t                  sleep_retention_entries_t;
 typedef regdma_entries_config_t             sleep_retention_entries_config_t;
 
diff --git a/components/esp_hw_support/port/esp32c5/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32c5/peripheral_domain_pd.c
new file mode 100644
index 0000000000..0f96516745
--- /dev/null
+++ b/components/esp_hw_support/port/esp32c5/peripheral_domain_pd.c
@@ -0,0 +1,86 @@
+/*
+ * SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+
+    // ESP32C5 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+
+    // ESP32C5 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    /* ESP32C5 does not support Timer1 */
+
+    // ESP32C5 supports ADC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    /* ESP32C5 supports UART sleep retention */
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    /* ESP32C5 only supports UART0 and UART1 */
+
+    /* ESP32C5 supports RMT0 */
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // ESP32C5 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    /* ESP32C5 supports GDMA_CH2 */
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32C5 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32C5 only supports I2S0*/
+
+    // ESP32C5 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    /* ESP32C5 only supports I2C0*/
+
+    // ESP32C5 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32C5 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32C5 does not support TWAI sleep retention yet: IDF-13001
+
+    // ESP32C5 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32C5 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+
+    // ESP32C5 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32C5 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+    /* ESP32C5 only supports MCPWM0 */
+
+    // ESP32C5 supports SDM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32c6/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32c6/peripheral_domain_pd.c
new file mode 100644
index 0000000000..9d3742a961
--- /dev/null
+++ b/components/esp_hw_support/port/esp32c6/peripheral_domain_pd.c
@@ -0,0 +1,86 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32C6 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+
+    // ESP32C6 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    /* ESP32C6 only supports Timer0 */
+
+    // ESP32C6 supports ADC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    // ESP32C6 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    /* ESP32C6 only supports UART0 and UART1 */
+
+    // ESP32C6 supports RMT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // ESP32C6 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32C6 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32C6 only supports I2S0 */
+
+    // ESP32C6 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    /* ESP32C6 only supports I2C0 */
+
+    // ESP32C6 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32C6 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32C6 supports TWAI sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI1);
+    /* ESP32C6 only supports TWAI0 and TWAI1 */
+
+    // ESP32C6 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32C6 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+
+    // ESP32C6 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32C6 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+
+    // ESP32C6 supports SDM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32c61/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32c61/peripheral_domain_pd.c
new file mode 100644
index 0000000000..715d747c7f
--- /dev/null
+++ b/components/esp_hw_support/port/esp32c61/peripheral_domain_pd.c
@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32C61 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+    // ESP32C61 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    /* ESP32C61 only supports Timer0 */
+
+    // ESP32C61 does not support ADC sleep retention
+    // TODO: IDF-10376
+
+    // ESP32C61 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART2);
+    /* ESP32C61 only supports UART0, UART1 and UART2 */
+
+    // ESP32C61 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    /* ESP32C61 only supports GDMA_CH0 and GDMA_CH1 */
+
+    // ESP32C61 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32C61 only supports I2S0 */
+
+    // ESP32C61 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    /* ESP32C61 only supports I2C0 */
+
+    // ESP32C61 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32C61 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32C61 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+
+    // ESP32C61 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32h2/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32h2/peripheral_domain_pd.c
new file mode 100644
index 0000000000..e0c8050bd4
--- /dev/null
+++ b/components/esp_hw_support/port/esp32h2/peripheral_domain_pd.c
@@ -0,0 +1,87 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32H2 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+
+    // ESP32H2 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    /* ESP32H2 only supports Timer0 */
+
+    // ESP32H2 supports ADC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    // ESP32H2 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    /* ESP32H2 only supports UART0 and UART1 */
+
+    // ESP32H2 supports RMT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // ESP32H2 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32H2 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32H2 only supports I2S0 */
+
+    // ESP32H2 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C1);
+    /* ESP32H2 only supports I2C0 and I2C1 */
+
+    // ESP32H2 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32H2 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32H2 supports TWAI sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI0);
+    /* ESP32H2 only supports TWAI0 */
+
+    // ESP32H2 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32H2 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+
+    // ESP32H2 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32H2 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+    /* ESP32H2 only supports MCPWM0 */
+
+    // ESP32H2 supports SDM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32h21/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32h21/peripheral_domain_pd.c
new file mode 100644
index 0000000000..f113c661e7
--- /dev/null
+++ b/components/esp_hw_support/port/esp32h21/peripheral_domain_pd.c
@@ -0,0 +1,87 @@
+/*
+ * SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32H21 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+
+    // ESP32H21 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    /* ESP32H21 only supports Timer0 */
+
+    // ESP32H21 supports ADC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    // ESP32H21 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    /* ESP32H21 only supports UART0 and UART1 */
+
+    // ESP32H21 supports RMT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // ESP32H21 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32H21 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32H21 only supports I2S0 */
+
+    // ESP32H21 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C1);
+
+    // ESP32H21 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32H21 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32H21 supports TWAI sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI0);
+    /* ESP32H21 only supports TWAI0 */
+
+    // ESP32H21 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32H21 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+
+    // ESP32H21 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32H21 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+    /* ESP32H21 only supports MCPWM0 */
+
+    // ESP32H21 does not support SDM sleep retention yet
+    // TODO: [ESP32H21] IDF-11573, IDF-14159 - Enable SDM support when available
+    // RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32h4/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32h4/peripheral_domain_pd.c
new file mode 100644
index 0000000000..06dbbfb8d7
--- /dev/null
+++ b/components/esp_hw_support/port/esp32h4/peripheral_domain_pd.c
@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32H4 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+    // ESP32H4 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    // ESP32H4 only supports Timer0
+
+    // ESP32H4 supports ADC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    // ESP32H4 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    // ESP32H4 only supports UART0 and UART1
+
+    // ESP32H4 supports RMT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // ESP32H4 supports GDMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32H4 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    /* ESP32H4 only supports I2S0 */
+
+    // ESP32H4 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C1);
+    /* ESP32H4 only supports I2C0 and I2C1 */
+
+    // ESP32H4 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32H4 supports temperature sensor sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TEMP_SENSOR);
+
+    // ESP32H4 supports TWAI sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI0);
+    /* ESP32H4 only supports TWAI0 */
+
+    // ESP32H4 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32H4 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+    // ESP32H4 supports GPSPI3 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI3);
+
+    // ESP32H4 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32H4 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM1);
+
+    // ESP32H4 supports SDM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/port/esp32p4/peripheral_domain_pd.c b/components/esp_hw_support/port/esp32p4/peripheral_domain_pd.c
new file mode 100644
index 0000000000..1ff1a78509
--- /dev/null
+++ b/components/esp_hw_support/port/esp32p4/peripheral_domain_pd.c
@@ -0,0 +1,105 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+
+#include "sdkconfig.h"
+#include "soc/system_periph_retention.h"
+#include "esp_private/sleep_retention.h"
+
+bool peripheral_domain_pd_allowed(void)
+{
+#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
+    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+
+    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SYS_PERIPH);
+    // ESP32P4 supports WDT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_WDT);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_WDT);
+
+    // ESP32P4 supports Timer sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG0_TIMER1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TG1_TIMER1);
+
+    // TODO: IDF-11369
+    // RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ADC);
+
+    // ESP32P4 supports UART sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART2);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART3);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_UART4);
+
+    // ESP32P4 supports RMT sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_RMT0);
+
+    // TODO: IDF-11371
+    // RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH0);
+    // RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH1);
+    // RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GDMA_CH2);
+
+    // ESP32P4 supports AHB_DMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AHB_DMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AHB_DMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AHB_DMA_CH2);
+
+    // ESP32P4 supports AXI_DMA sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AXI_DMA_CH0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AXI_DMA_CH1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_AXI_DMA_CH2);
+
+    // ESP32P4 supports PAU and I2S sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2S2);
+
+    // ESP32P4 supports I2C sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_I2C1);
+
+    // ESP32P4 supports ETM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_ETM0);
+
+    // ESP32P4 does not support temperature sensor sleep retention since it is in LP domain
+
+    // ESP32P4 supports TWAI sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI1);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_TWAI2);
+
+    // ESP32P4 supports PARLIO sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_PARLIO0);
+
+    // ESP32P4 supports GPSPI2 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI2);
+    // ESP32P4 supports GPSPI3 sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_GPSPI3);
+
+    // ESP32P4 supports LEDC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_LEDC);
+
+    // ESP32P4 supports MCPWM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM0);
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_MCPWM1);
+
+    // ESP32P4 supports SDM sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_SDM0);
+
+    // ESP32P4 supports EMAC sleep retention
+    RETENTION_MODULE_BITMAP_SET(&mask, SLEEP_RETENTION_MODULE_EMAC);
+
+    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
+    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
+    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
+#else
+    return false;
+#endif
+}
diff --git a/components/esp_hw_support/sleep_system_peripheral.c b/components/esp_hw_support/sleep_system_peripheral.c
index 155bbadba3..73babdba3b 100644
--- a/components/esp_hw_support/sleep_system_peripheral.c
+++ b/components/esp_hw_support/sleep_system_peripheral.c
@@ -1,25 +1,14 @@
 /*
- * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <stddef.h>
-#include <string.h>
-
 #include "sdkconfig.h"
-#include "soc/soc_caps.h"
 #include "soc/system_periph_retention.h"
 #include "hal/uart_periph.h"
-#include "hal/timer_ll.h"
-#if SOC_HAS(I2S)
-#include "hal/i2s_ll.h"
-#endif
-
-#include "esp_sleep.h"
 #include "esp_log.h"
 #include "esp_check.h"
-#include "hal/gdma_periph.h"
 #include "esp_private/startup_internal.h"
 #include "esp_private/sleep_retention.h"
 
@@ -177,141 +166,6 @@ error:
     return err;
 }
 
-bool peripheral_domain_pd_allowed(void)
-{
-#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
-    const sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
-    const sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
-
-    sleep_retention_module_bitmap_t mask = RETENTION_MODULE_BITMAP_INIT(NULL);
-    mask.bitmap[SLEEP_RETENTION_MODULE_SYS_PERIPH >> 5] |= BIT(SLEEP_RETENTION_MODULE_SYS_PERIPH % 32);
-#if SOC_MWDT_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG0_WDT >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG0_WDT % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG1_WDT >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG1_WDT % 32);
-#endif
-#if SOC_TIMER_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG0_TIMER0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG0_TIMER0 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG1_TIMER0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG1_TIMER0 % 32);
-#if TIMG_LL_GET(GPTIMERS_PER_INST) > 1
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG0_TIMER1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG0_TIMER1 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_TG1_TIMER1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TG1_TIMER1 % 32);
-#endif
-#endif
-
-#if SOC_ADC_SUPPORTED && !CONFIG_IDF_TARGET_ESP32P4 && !CONFIG_IDF_TARGET_ESP32C61 // TODO: IDF-11369
-    mask.bitmap[SLEEP_RETENTION_MODULE_ADC >> 5] |= BIT(SLEEP_RETENTION_MODULE_ADC % 32);
-#endif
-
-#if SOC_UART_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_UART0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_UART0 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_UART1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_UART1 % 32);
-# if (SOC_UART_HP_NUM > 2)
-    mask.bitmap[SLEEP_RETENTION_MODULE_UART2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_UART2 % 32);
-# endif
-# if (SOC_UART_HP_NUM > 3)
-    mask.bitmap[SLEEP_RETENTION_MODULE_UART3 >> 5] |= BIT(SLEEP_RETENTION_MODULE_UART3 % 32);
-# endif
-# if (SOC_UART_HP_NUM > 4)
-    mask.bitmap[SLEEP_RETENTION_MODULE_UART4 >> 5] |= BIT(SLEEP_RETENTION_MODULE_UART4 % 32);
-# endif
-#endif /* SOC_UART_SUPPORT_SLEEP_RETENTION */
-
-#if SOC_RMT_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_RMT0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_RMT0 % 32);
-#endif
-
-#if SOC_GDMA_SUPPORT_SLEEP_RETENTION
-# if SOC_GDMA_SUPPORTED && !CONFIG_IDF_TARGET_ESP32P4 // TODO: IDF-11371
-    mask.bitmap[SLEEP_RETENTION_MODULE_GDMA_CH0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_GDMA_CH0 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_GDMA_CH1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_GDMA_CH1 % 32);
-#  if (GDMA_LL_GET(PAIRS_PER_INST) > 2)
-    mask.bitmap[SLEEP_RETENTION_MODULE_GDMA_CH2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_GDMA_CH2 % 32);
-#  endif
-# endif /* SOC_GDMA_SUPPORTED */
-# if SOC_HAS(AHB_GDMA) && CONFIG_IDF_TARGET_ESP32P4 // TODO: IDF-11372
-    mask.bitmap[SLEEP_RETENTION_MODULE_AHB_DMA_CH0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AHB_DMA_CH0 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_AHB_DMA_CH1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AHB_DMA_CH1 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_AHB_DMA_CH2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AHB_DMA_CH2 % 32);
-# endif /* SOC_HAS(AHB_GDMA) */
-# if SOC_HAS(AXI_GDMA)
-    mask.bitmap[SLEEP_RETENTION_MODULE_AXI_DMA_CH0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AXI_DMA_CH0 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_AXI_DMA_CH1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AXI_DMA_CH1 % 32);
-    mask.bitmap[SLEEP_RETENTION_MODULE_AXI_DMA_CH2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_AXI_DMA_CH2 % 32);
-# endif /* SOC_HAS(AXI_GDMA) */
-#endif /* SOC_GDMA_SUPPORT_SLEEP_RETENTION */
-
-#if SOC_HAS(PAU)
-    mask.bitmap[SLEEP_RETENTION_MODULE_I2S0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_I2S0 % 32);
-#ifdef I2S_LL_GET
-# if (I2S_LL_GET(INST_NUM) > 1)
-    mask.bitmap[SLEEP_RETENTION_MODULE_I2S1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_I2S1 % 32);
-# endif
-# if (I2S_LL_GET(INST_NUM) > 2)
-    mask.bitmap[SLEEP_RETENTION_MODULE_I2S2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_I2S2 % 32);
-# endif
-#endif  /* I2S_LL_GET */
-#endif /* SOC_HAS(PAU) */
-
-#if SOC_I2C_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_I2C0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_I2C0 % 32);
-# if (SOC_HP_I2C_NUM > 1)
-    mask.bitmap[SLEEP_RETENTION_MODULE_I2C1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_I2C1 % 32);
-# endif
-#endif /* SOC_I2C_SUPPORT_SLEEP_RETENTION */
-
-#if SOC_ETM_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_ETM0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_ETM0 % 32);
-#endif
-
-#if SOC_TEMP_SENSOR_SUPPORTED && !CONFIG_IDF_TARGET_ESP32P4
-    mask.bitmap[SLEEP_RETENTION_MODULE_TEMP_SENSOR >> 5] |= BIT(SLEEP_RETENTION_MODULE_TEMP_SENSOR % 32);
-#endif
-
-#if SOC_TWAI_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_TWAI0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TWAI0 % 32);
-# if (SOC_TWAI_CONTROLLER_NUM > 1)
-    mask.bitmap[SLEEP_RETENTION_MODULE_TWAI1 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TWAI1 % 32);
-# endif
-# if (SOC_TWAI_CONTROLLER_NUM > 2)
-    mask.bitmap[SLEEP_RETENTION_MODULE_TWAI2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_TWAI2 % 32);
-# endif
-#endif /* SOC_TWAI_SUPPORT_SLEEP_RETENTION */
-
-#if SOC_PARLIO_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_PARLIO0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_PARLIO0 % 32);
-#endif
-
-#if SOC_GPSPI_SUPPORTED
-    mask.bitmap[SLEEP_RETENTION_MODULE_GPSPI2 >> 5] |= BIT(SLEEP_RETENTION_MODULE_GPSPI2 % 32);
-# if CONFIG_IDF_TARGET_ESP32P4
-    mask.bitmap[SLEEP_RETENTION_MODULE_GPSPI3 >> 5] |= BIT(SLEEP_RETENTION_MODULE_GPSPI3 % 32);
-# endif
-#endif
-
-#if SOC_LEDC_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_LEDC >> 5] |= BIT(SLEEP_RETENTION_MODULE_LEDC % 32);
-#endif
-
-#if SOC_MCPWM_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_MCPWM0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_MCPWM0 % 32);
-#endif
-
-#if SOC_SDM_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_SDM0 >> 5] |= BIT(SLEEP_RETENTION_MODULE_SDM0 % 32);
-#endif
-
-#if SOC_EMAC_SUPPORT_SLEEP_RETENTION
-    mask.bitmap[SLEEP_RETENTION_MODULE_EMAC >> 5] |= BIT(SLEEP_RETENTION_MODULE_EMAC % 32);
-#endif
-
-    const sleep_retention_module_bitmap_t peripheral_domain_inited_modules = sleep_retention_module_bitmap_and(inited_modules, mask);
-    const sleep_retention_module_bitmap_t peripheral_domain_created_modules = sleep_retention_module_bitmap_and(created_modules, mask);
-    return sleep_retention_module_bitmap_eq(peripheral_domain_inited_modules, peripheral_domain_created_modules);
-#else
-    return false;
-#endif
-}
-
 #if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP
 ESP_SYSTEM_INIT_FN(sleep_sys_periph_startup_init, SECONDARY, BIT(0), 107)
 {
@@ -329,3 +183,12 @@ ESP_SYSTEM_INIT_FN(sleep_sys_periph_startup_init, SECONDARY, BIT(0), 107)
     return ESP_OK;
 }
 #endif
+
+/**
+ * @brief Dummy function used to force linking this file.
+ * This works via -u sleep_system_peripheral_dummy flag in CMakeLists.txt
+ */
+void sleep_system_peripheral_dummy(void)
+{
+    return;
+}
diff --git a/components/esp_pm/linker.lf b/components/esp_pm/linker.lf
index 07237e3d96..a95de76a25 100644
--- a/components/esp_pm/linker.lf
+++ b/components/esp_pm/linker.lf
@@ -28,7 +28,7 @@ entries:
                 sleep_gpio:esp_sleep_gpio_pupd_config_workaround_unapply (noflash)
             if SOC_PM_SUPPORT_TOP_PD = y:
                 sleep_clock:clock_domain_pd_allowed (noflash)
-                sleep_system_peripheral:peripheral_domain_pd_allowed (noflash)
+                peripheral_domain_pd:peripheral_domain_pd_allowed (noflash)
             if SOC_PM_CPU_RETENTION_BY_RTCCNTL = y && (PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP = y || SOC_PM_SUPPORT_TAGMEM_PD = y):
                 sleep_cpu:sleep_enable_cpu_retention (noflash)
             if PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP = y || (ESP32P4_SELECTS_REV_LESS_V3 = y && PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP = y):