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 e10199af0b8..00387b19dae 100644
--- a/components/esp_hw_support/include/esp_private/sleep_retention.h
+++ b/components/esp_hw_support/include/esp_private/sleep_retention.h
@@ -56,7 +56,8 @@ typedef struct {
 } sleep_retention_module_callbacks_t;
 
 typedef enum {
-    SLEEP_RETENTION_MODULE_ATTR_PASSIVE = 0x1
+    SLEEP_RETENTION_MODULE_ATTR_PASSIVE = 0x1,
+    SLEEP_RETENTION_MODULE_ATTR_ATTACH = 0x2
 } sleep_retention_module_attribute_t;
 
 /**
@@ -202,6 +203,19 @@ sleep_retention_module_bitmap_t sleep_retention_get_inited_modules(void);
  */
 sleep_retention_module_bitmap_t sleep_retention_get_created_modules(void);
 
+/**
+ * @brief Get all retainted modules that require sleep retention
+ *
+ * This is an unprotected interface for getting a bitmap of all modules that
+ * require sleep retention.
+ *
+ * It can only be called by the sleep procedure.
+ *
+ * @return the bitmap for all modules that have successfully created a sleep
+ * retention context
+ */
+sleep_retention_module_bitmap_t sleep_retention_get_retained_modules(void);
+
 /**
  * @brief Get the initialization state of module
  *
@@ -222,6 +236,8 @@ bool sleep_retention_is_module_inited(sleep_retention_module_t module);
  */
 bool sleep_retention_is_module_created(sleep_retention_module_t module);
 
+bool sleep_retention_is_module_attached(sleep_retention_module_t module);
+
 /**
  * @brief Calculates the bitwise logical and of the module bitmap and return results
  *
diff --git a/components/esp_hw_support/sleep_retention.c b/components/esp_hw_support/sleep_retention.c
index eb4232a3e8b..3bcfc7c4094 100644
--- a/components/esp_hw_support/sleep_retention.c
+++ b/components/esp_hw_support/sleep_retention.c
@@ -108,26 +108,38 @@ static inline sleep_retention_module_attribute_t get_attributes(struct sleep_ret
     return self->attributes;
 }
 
+static inline bool module_runtime_attach(struct sleep_retention_module_object * const self)
+{
+    if (self) {
+        return (get_attributes(self) & SLEEP_RETENTION_MODULE_ATTR_ATTACH) ? true : false;
+    }
+    return false; /* for SLEEP_RETENTION_MODULE_INVALID */
+}
+
 static inline bool module_is_passive(struct sleep_retention_module_object * const self)
 {
     return (get_attributes(self) & SLEEP_RETENTION_MODULE_ATTR_PASSIVE) ? true : false;
 }
 
-static inline bool module_is_inited(sleep_retention_module_t module)
-{
-    sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
-    return (inited_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false;
-}
-
-static inline bool module_is_created(sleep_retention_module_t module)
-{
-    sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
-    return (created_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false;
-}
-
 /**
  * Internal structure which holds all requested sleep retention parameters
  */
+struct module_sleep_retention_context {
+#define SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES       (8u)
+#define SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY    (0)
+#define SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY     (SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES - 1)
+#define SLEEP_RETENTION_MODULE_INVALID                  ((sleep_retention_module_t)(-1)) /* the final node does not belong to any module */
+    struct {
+        sleep_retention_entries_t entries;
+        uint32_t entries_bitmap: REGDMA_LINK_ENTRY_NUM;
+        uint32_t runtime_bitmap: REGDMA_LINK_ENTRY_NUM;
+#if REGDMA_LINK_ENTRY_NUM < 16
+        uint32_t reserved: 32-(2*REGDMA_LINK_ENTRY_NUM);
+#endif
+        void *entries_tail;
+    } lists[SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES];
+};
+
 typedef struct {
     /* The hardware retention module (REGDMA and PMU) uses 4 linked lists to
      * record the hardware context information that needs to be backed up and
@@ -181,23 +193,15 @@ typedef struct {
      *    restore the register context, which ensures only one backup or restore
      *    when multiple modules (BLE and 15.4) exists.
      */
-#define SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES       (8u)
-#define SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY    (0)
-#define SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY     (SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES - 1)
-#define SLEEP_RETENTION_MODULE_INVALID                  ((sleep_retention_module_t)(-1)) /* the final node does not belong to any module */
-    struct {
-        sleep_retention_entries_t entries;
-        uint32_t entries_bitmap: REGDMA_LINK_ENTRY_NUM;
-        uint32_t runtime_bitmap: REGDMA_LINK_ENTRY_NUM;
-#if REGDMA_LINK_ENTRY_NUM < 16
-        uint32_t reserved: 32-(2*REGDMA_LINK_ENTRY_NUM);
-#endif
-        void *entries_tail;
-    } lists[SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES];
+    union {
+        struct module_sleep_retention_context retention;
+        struct module_sleep_retention_context context[2];
+    };
     _lock_t lock;
     regdma_link_priority_t highpri;
     sleep_retention_module_bitmap_t inited_modules;
     sleep_retention_module_bitmap_t created_modules;
+    sleep_retention_module_bitmap_t retention_modules;
 
     struct sleep_retention_module_object instance[SLEEP_RETENTION_MODULE_MAX + 1];
 
@@ -207,122 +211,158 @@ typedef struct {
 static DRAM_ATTR __attribute__((unused)) sleep_retention_t s_retention = {
     .highpri = (uint8_t)-1,
     .inited_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } },
-    .created_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }
+    .created_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } },
+    .retention_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }
 };
 
 #define SLEEP_RETENTION_ENTRY_BITMAP_MASK       (BIT(REGDMA_LINK_ENTRY_NUM) - 1)
 #define SLEEP_RETENTION_ENTRY_BITMAP(bitmap)    ((bitmap) & SLEEP_RETENTION_ENTRY_BITMAP_MASK)
 
-static esp_err_t sleep_retention_entries_create_impl(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module);
-static void sleep_retention_entries_join(void);
+static esp_err_t entries_create(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module);
+static void retention_entries_join(void);
 
-static inline bool sleep_retention_entries_require_branch(uint32_t owner, uint32_t runtime_bitmap)
+static struct sleep_retention_module_object * instance(sleep_retention_module_t module)
+{
+    return (module == SLEEP_RETENTION_MODULE_INVALID) ? NULL : &s_retention.instance[module];
+}
+
+static inline bool module_is_inited(sleep_retention_module_t module)
+{
+    sleep_retention_module_bitmap_t inited_modules = sleep_retention_get_inited_modules();
+    return (inited_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false;
+}
+
+static inline bool module_is_created(sleep_retention_module_t module)
+{
+    sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules();
+    return (created_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false;
+}
+
+static inline bool module_is_retained(sleep_retention_module_t module)
+{
+    if (module_runtime_attach(instance(module))) {
+        sleep_retention_module_bitmap_t retained_modules = sleep_retention_get_retained_modules();
+        return (retained_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false;
+    } else {
+        return false;
+    }
+}
+
+static inline bool entries_require_branch(uint32_t owner, uint32_t runtime_bitmap)
 {
     bool use_new_entry      = SLEEP_RETENTION_ENTRY_BITMAP(owner & ~runtime_bitmap) ? true : false;
     bool intersection_exist = SLEEP_RETENTION_ENTRY_BITMAP(owner &  runtime_bitmap) ? true : false;
     return use_new_entry && intersection_exist;
 }
 
-static esp_err_t sleep_retention_entries_check_and_create_default(uint32_t owner, uint32_t runtime_bitmap, uint32_t entries_bitmap, regdma_link_priority_t priority, sleep_retention_module_t module)
+static esp_err_t check_and_create_default(uint32_t owner, uint32_t runtime_bitmap, uint32_t entries_bitmap, regdma_link_priority_t priority, sleep_retention_module_t module)
 {
-    assert(sleep_retention_entries_require_branch(owner, runtime_bitmap));
+    assert(entries_require_branch(owner, runtime_bitmap));
 
     static sleep_retention_entries_config_t dummy = { REGDMA_LINK_WAIT_INIT(0xffff, 0, 0, 0, 1, 1), 0 };
     dummy.owner = SLEEP_RETENTION_ENTRY_BITMAP(owner & ~entries_bitmap);
     if (dummy.owner) {
-        return sleep_retention_entries_create_impl(&dummy, 1, priority, module);
+        return entries_create(&dummy, 1, priority, module);
     }
     return ESP_OK;
 }
 
-static esp_err_t sleep_retention_entries_check_and_create_final_default(void)
+static esp_err_t check_and_create_final_default(void)
 {
     static const sleep_retention_entries_config_t final_dummy = { REGDMA_LINK_WAIT_INIT(0xffff, 0, 0, 0, 1, 1), SLEEP_RETENTION_ENTRY_BITMAP_MASK };
 
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
-    if (s_retention.lists[SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY].entries_bitmap == 0) {
-        err = sleep_retention_entries_create_impl(&final_dummy, 1, SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY, SLEEP_RETENTION_MODULE_INVALID);
+    if (s_retention.retention.lists[SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY].entries_bitmap == 0) {
+        err = entries_create(&final_dummy, 1, SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY, SLEEP_RETENTION_MODULE_INVALID);
     }
     _lock_release_recursive(&s_retention.lock);
     return err;
 }
 
-static void sleep_retention_entries_update(uint32_t owner, void *new_link, regdma_link_priority_t priority)
+static void entries_stats(struct module_sleep_retention_context *ctx)
 {
     _lock_acquire_recursive(&s_retention.lock);
-    sleep_retention_entries_t retention_entries = {
-        (owner & BIT(0)) ? new_link : s_retention.lists[priority].entries[0],
-        (owner & BIT(1)) ? new_link : s_retention.lists[priority].entries[1],
-        (owner & BIT(2)) ? new_link : s_retention.lists[priority].entries[2],
-        (owner & BIT(3)) ? new_link : s_retention.lists[priority].entries[3]
-#if (REGDMA_LINK_ENTRY_NUM == 5)
-        , (owner & BIT(4)) ? new_link : s_retention.lists[priority].entries[4]
-#endif
-    };
-    if (s_retention.lists[priority].entries_bitmap == 0) {
-        s_retention.lists[priority].entries_tail = new_link;
+    for (regdma_link_priority_t priority = 0; priority < SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES; priority++) {
+        for (int entry = 0; entry < ARRAY_SIZE(ctx->lists[s_retention.highpri].entries); entry++) {
+            regdma_link_stats(ctx->lists[priority].entries[entry], entry);
+        }
     }
-    memcpy(s_retention.lists[priority].entries, retention_entries, sizeof(sleep_retention_entries_t));
-    s_retention.lists[priority].runtime_bitmap  = owner;
-    s_retention.lists[priority].entries_bitmap |= owner;
     _lock_release_recursive(&s_retention.lock);
 }
 
-static void * sleep_retention_entries_try_create(const regdma_link_config_t *config, uint32_t owner, regdma_link_priority_t priority, sleep_retention_module_t module)
+static void entries_context_update(struct module_sleep_retention_context *ctx, uint32_t owner, void *new_link, regdma_link_priority_t priority)
+{
+    _lock_acquire_recursive(&s_retention.lock);
+    sleep_retention_entries_t entries = {
+        (owner & BIT(0)) ? new_link : ctx->lists[priority].entries[0],
+        (owner & BIT(1)) ? new_link : ctx->lists[priority].entries[1],
+        (owner & BIT(2)) ? new_link : ctx->lists[priority].entries[2],
+        (owner & BIT(3)) ? new_link : ctx->lists[priority].entries[3]
+#if (REGDMA_LINK_ENTRY_NUM == 5)
+      , (owner & BIT(4)) ? new_link : ctx->lists[priority].entries[4]
+#endif
+    };
+    if (ctx->lists[priority].entries_bitmap == 0) {
+        ctx->lists[priority].entries_tail = new_link;
+    }
+    memcpy(ctx->lists[priority].entries, entries, sizeof(sleep_retention_entries_t));
+    ctx->lists[priority].runtime_bitmap  = owner;
+    ctx->lists[priority].entries_bitmap |= owner;
+    entries_stats(ctx);
+    _lock_release_recursive(&s_retention.lock);
+}
+
+static void * entries_try_create(const regdma_link_config_t *config, uint32_t owner, regdma_link_priority_t priority, sleep_retention_module_t module)
 {
     void *link = NULL;
     assert(owner > 0 && owner < BIT(REGDMA_LINK_ENTRY_NUM));
 
     _lock_acquire_recursive(&s_retention.lock);
-    if (sleep_retention_entries_require_branch(owner, s_retention.lists[priority].runtime_bitmap)) {
-        if (sleep_retention_entries_check_and_create_default(owner, s_retention.lists[priority].runtime_bitmap,
-            s_retention.lists[priority].entries_bitmap, priority, module) == ESP_OK) { /* branch node can't as tail node */
+    int index = module_runtime_attach(instance(module)) ? 1 : 0;
+    struct module_sleep_retention_context *ctx = &s_retention.context[index];
+    uint32_t bm_runtime = ctx->lists[priority].runtime_bitmap;
+    uint32_t bm_entries = ctx->lists[priority].entries_bitmap;
+    if (entries_require_branch(owner, bm_runtime)) {
+        /* branch node can't as tail node */
+        esp_err_t err = check_and_create_default(owner, bm_runtime, bm_entries, priority, module);
+        if (err == ESP_OK) {
             link = regdma_link_init_safe(config, true, module,
-                        (owner & BIT(0)) ? s_retention.lists[priority].entries[0] : NULL,
-                        (owner & BIT(1)) ? s_retention.lists[priority].entries[1] : NULL,
-                        (owner & BIT(2)) ? s_retention.lists[priority].entries[2] : NULL,
-                        (owner & BIT(3)) ? s_retention.lists[priority].entries[3] : NULL
+                        (owner & BIT(0)) ? ctx->lists[priority].entries[0] : NULL,
+                        (owner & BIT(1)) ? ctx->lists[priority].entries[1] : NULL,
+                        (owner & BIT(2)) ? ctx->lists[priority].entries[2] : NULL,
+                        (owner & BIT(3)) ? ctx->lists[priority].entries[3] : NULL
 #if (REGDMA_LINK_ENTRY_NUM == 5)
-                        , (owner & BIT(4)) ? s_retention.lists[priority].entries[4] : NULL
+                      , (owner & BIT(4)) ? ctx->lists[priority].entries[4] : NULL
 #endif
                     );
         }
     } else {
-        link = regdma_link_init_safe(config, false, module, s_retention.lists[priority].entries[__builtin_ffs(owner) - 1]);
+        link = regdma_link_init_safe(config, false, module, ctx->lists[priority].entries[__builtin_ffs(owner) - 1]);
     }
     _lock_release_recursive(&s_retention.lock);
     return link;
 }
 
-static void * sleep_retention_entries_try_create_bonding(const regdma_link_config_t *config, uint32_t owner, regdma_link_priority_t priority, sleep_retention_module_t module)
+static void * entries_try_create_bonding(const regdma_link_config_t *config, uint32_t owner, regdma_link_priority_t priority, sleep_retention_module_t module)
 {
     assert(owner > 0 && owner < BIT(REGDMA_LINK_ENTRY_NUM));
     _lock_acquire_recursive(&s_retention.lock);
+    int index = module_runtime_attach(instance(module)) ? 1 : 0;
+    struct module_sleep_retention_context *ctx = &s_retention.context[index];
     void *link = regdma_link_init_safe(config, true, module,
-                (owner & BIT(0)) ? s_retention.lists[priority].entries[0] : NULL,
-                (owner & BIT(1)) ? s_retention.lists[priority].entries[1] : NULL,
-                (owner & BIT(2)) ? s_retention.lists[priority].entries[2] : NULL,
-                (owner & BIT(3)) ? s_retention.lists[priority].entries[3] : NULL
+                (owner & BIT(0)) ? ctx->lists[priority].entries[0] : NULL,
+                (owner & BIT(1)) ? ctx->lists[priority].entries[1] : NULL,
+                (owner & BIT(2)) ? ctx->lists[priority].entries[2] : NULL,
+                (owner & BIT(3)) ? ctx->lists[priority].entries[3] : NULL
 #if (REGDMA_LINK_ENTRY_NUM == 5)
-                , (owner & BIT(4)) ? s_retention.lists[priority].entries[4] : NULL
+              , (owner & BIT(4)) ? ctx->lists[priority].entries[4] : NULL
 #endif
             );
     _lock_release_recursive(&s_retention.lock);
     return link;
 }
 
-static void sleep_retention_entries_stats(void)
-{
-    _lock_acquire_recursive(&s_retention.lock);
-    if (s_retention.highpri >= SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY && s_retention.highpri <= SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY) {
-        for (int entry = 0; entry < ARRAY_SIZE(s_retention.lists[s_retention.highpri].entries); entry++) {
-            regdma_link_stats(s_retention.lists[s_retention.highpri].entries[entry], entry);
-        }
-    }
-    _lock_release_recursive(&s_retention.lock);
-}
-
 void sleep_retention_dump_modules(FILE *out)
 {
     for (int i = SLEEP_RETENTION_MODULE_MIN; i <= SLEEP_RETENTION_MODULE_MAX; i++) {
@@ -342,9 +382,9 @@ void sleep_retention_dump_entries(FILE *out)
 {
     _lock_acquire_recursive(&s_retention.lock);
     if (s_retention.highpri >= SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY && s_retention.highpri <= SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY) {
-        for (int entry = 0; entry < ARRAY_SIZE(s_retention.lists[s_retention.highpri].entries); entry++) {
+        for (int entry = 0; entry < ARRAY_SIZE(s_retention.retention.lists[s_retention.highpri].entries); entry++) {
             fprintf(out, "\nsleep retention entries[%d] context:\n", entry);
-            regdma_link_dump(out, s_retention.lists[s_retention.highpri].entries[entry], entry);
+            regdma_link_dump(out, s_retention.retention.lists[s_retention.highpri].entries[entry], entry);
         }
     }
     fflush(out);
@@ -357,15 +397,15 @@ void * sleep_retention_find_link_by_id(int id)
     _lock_acquire_recursive(&s_retention.lock);
     if (s_retention.highpri >= SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY &&
         s_retention.highpri <= SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY) {
-        for (int entry = 0; (link == NULL && entry < ARRAY_SIZE(s_retention.lists[s_retention.highpri].entries)); entry++) {
-            link = regdma_find_link_by_id(s_retention.lists[s_retention.highpri].entries[entry], entry, id);
+        for (int entry = 0; (link == NULL && entry < ARRAY_SIZE(s_retention.retention.lists[s_retention.highpri].entries)); entry++) {
+            link = regdma_find_link_by_id(s_retention.retention.lists[s_retention.highpri].entries[entry], entry, id);
         }
     }
     _lock_release_recursive(&s_retention.lock);
     return link;
 }
 
-static uint32_t sleep_retention_entries_owner_bitmap(sleep_retention_entries_t *entries, sleep_retention_entries_t *tails)
+static uint32_t entries_owner_bitmap(sleep_retention_entries_t *entries, sleep_retention_entries_t *tails)
 {
     uint32_t owner = 0;
     _lock_acquire_recursive(&s_retention.lock);
@@ -376,61 +416,78 @@ static uint32_t sleep_retention_entries_owner_bitmap(sleep_retention_entries_t *
     return owner;
 }
 
-static bool sleep_retention_entries_get_destroy_context(regdma_link_priority_t priority, sleep_retention_module_t module, sleep_retention_entries_t *destroy_entries, void **destroy_tail, sleep_retention_entries_t *next_entries, void **prev_tail)
+static bool module_entries_get(struct module_sleep_retention_context *ctx, regdma_link_priority_t priority, sleep_retention_module_t module, sleep_retention_entries_t *entries, void **tail, sleep_retention_entries_t *next_entries, void **prev_tail)
 {
     bool exist = false;
-    sleep_retention_entries_t destroy_tails, prev_tails;
+    sleep_retention_entries_t tails, prev_tails;
 
-    memset(&destroy_tails, 0, sizeof(sleep_retention_entries_t));
+    memset(&tails, 0, sizeof(sleep_retention_entries_t));
     memset(&prev_tails, 0, sizeof(sleep_retention_entries_t));
 
     _lock_acquire_recursive(&s_retention.lock);
-    for (int entry = 0; entry < ARRAY_SIZE(s_retention.lists[priority].entries); entry++) {
-        (*destroy_entries)[entry] = regdma_find_module_link_head(
-                s_retention.lists[priority].entries[entry], s_retention.lists[priority].entries_tail, entry, module);
-        destroy_tails     [entry] = regdma_find_module_link_tail(
-                s_retention.lists[priority].entries[entry], s_retention.lists[priority].entries_tail, entry, module);
+    for (int entry = 0; entry < ARRAY_SIZE(ctx->lists[priority].entries); entry++) {
+        (*entries)[entry] = regdma_find_module_link_head(
+                ctx->lists[priority].entries[entry],
+                ctx->lists[priority].entries_tail,
+                entry, module);
+        tails     [entry] = regdma_find_module_link_tail(
+                ctx->lists[priority].entries[entry],
+                ctx->lists[priority].entries_tail,
+                entry, module);
         (*next_entries)   [entry] = regdma_find_next_module_link_head(
-                s_retention.lists[priority].entries[entry], s_retention.lists[priority].entries_tail, entry, module);
+                ctx->lists[priority].entries[entry],
+                ctx->lists[priority].entries_tail,
+                entry, module);
         prev_tails        [entry] = regdma_find_prev_module_link_tail(
-                s_retention.lists[priority].entries[entry], s_retention.lists[priority].entries_tail, entry, module);
-        if ((*destroy_entries)[entry] && destroy_tails[entry]) {
+                ctx->lists[priority].entries[entry],
+                ctx->lists[priority].entries_tail,
+                entry, module);
+        if ((*entries)[entry] && tails[entry]) {
             exist = true;
         }
-        assert(destroy_tails[entry] == destroy_tails[0]);
+        assert(tails[entry] == tails[0]);
         assert(prev_tails[entry] == prev_tails[0]);
     }
-    *destroy_tail = destroy_tails[0];
+    *tail = tails[0];
     *prev_tail = prev_tails[0];
     _lock_release_recursive(&s_retention.lock);
     return exist;
 }
 
-static void sleep_retention_entries_context_update(regdma_link_priority_t priority)
+static void entries_context_refresh(struct module_sleep_retention_context *ctx, regdma_link_priority_t priority)
 {
     _lock_acquire_recursive(&s_retention.lock);
     sleep_retention_entries_t tails = {
-        s_retention.lists[priority].entries_tail, s_retention.lists[priority].entries_tail,
-        s_retention.lists[priority].entries_tail, s_retention.lists[priority].entries_tail
+        ctx->lists[priority].entries_tail, ctx->lists[priority].entries_tail,
+        ctx->lists[priority].entries_tail, ctx->lists[priority].entries_tail
+#if (REGDMA_LINK_ENTRY_NUM == 5)
+      , ctx->lists[priority].entries_tail
+#endif
     };
-    s_retention.lists[priority].entries_bitmap = sleep_retention_entries_owner_bitmap(&s_retention.lists[priority].entries, &tails);
-    s_retention.lists[priority].runtime_bitmap = sleep_retention_entries_owner_bitmap(&s_retention.lists[priority].entries, &s_retention.lists[priority].entries);
+    ctx->lists[priority].entries_bitmap = entries_owner_bitmap(&ctx->lists[priority].entries, &tails);
+    ctx->lists[priority].runtime_bitmap = entries_owner_bitmap(&ctx->lists[priority].entries, &ctx->lists[priority].entries);
     _lock_release_recursive(&s_retention.lock);
 }
 
-static bool sleep_retention_entries_dettach(regdma_link_priority_t priority, sleep_retention_entries_t *destroy_entries, void *destroy_tail, sleep_retention_entries_t *next_entries, void *prev_tail)
+static bool entries_detach(struct module_sleep_retention_context *ctx, regdma_link_priority_t priority,
+        sleep_retention_entries_t *entries, void *tail, sleep_retention_entries_t *next_entries, void *prev_tail)
 {
     _lock_acquire_recursive(&s_retention.lock);
-    bool is_head = (memcmp(destroy_entries, &s_retention.lists[priority].entries, sizeof(sleep_retention_entries_t)) == 0);
-    bool is_tail = (destroy_tail == s_retention.lists[priority].entries_tail);
+    bool is_head = (memcmp(entries, ctx->lists[priority].entries, sizeof(sleep_retention_entries_t)) == 0);
+    bool is_tail = (tail == ctx->lists[priority].entries_tail);
 
     if (is_head && is_tail) {
-        memset(s_retention.lists[priority].entries, 0, sizeof(sleep_retention_entries_t));
-        s_retention.lists[priority].entries_tail = NULL;
+        memset(ctx->lists[priority].entries, 0, sizeof(sleep_retention_entries_t));
+        ctx->lists[priority].entries_tail = NULL;
     } else if (is_head) {
-        memcpy(&s_retention.lists[priority].entries, next_entries, sizeof(sleep_retention_entries_t));
+        memcpy(ctx->lists[priority].entries, next_entries, sizeof(sleep_retention_entries_t));
     } else if (is_tail) {
-        s_retention.lists[priority].entries_tail = prev_tail;
+        ctx->lists[priority].entries_tail = prev_tail;
+#if (REGDMA_LINK_ENTRY_NUM == 5)
+        regdma_link_update_next_safe(prev_tail, NULL, NULL, NULL, NULL, NULL);
+#else
+        regdma_link_update_next_safe(prev_tail, NULL, NULL, NULL, NULL);
+#endif
     } else {
 #if (REGDMA_LINK_ENTRY_NUM == 5)
         regdma_link_update_next_safe(prev_tail, (*next_entries)[0], (*next_entries)[1], (*next_entries)[2], (*next_entries)[3], (*next_entries)[4]);
@@ -438,24 +495,24 @@ static bool sleep_retention_entries_dettach(regdma_link_priority_t priority, sle
         regdma_link_update_next_safe(prev_tail, (*next_entries)[0], (*next_entries)[1], (*next_entries)[2], (*next_entries)[3]);
 #endif
     }
-    sleep_retention_entries_context_update(priority);
+    entries_context_refresh(ctx, priority);
 #if (REGDMA_LINK_ENTRY_NUM == 5)
-    regdma_link_update_next_safe(destroy_tail, NULL, NULL, NULL, NULL, NULL);
+    regdma_link_update_next_safe(tail, NULL, NULL, NULL, NULL, NULL);
 #else
-    regdma_link_update_next_safe(destroy_tail, NULL, NULL, NULL, NULL);
+    regdma_link_update_next_safe(tail, NULL, NULL, NULL, NULL);
 #endif
     _lock_release_recursive(&s_retention.lock);
     return (is_head || is_tail);
 }
 
-static void sleep_retention_entries_destroy_wrapper(sleep_retention_entries_t *destroy_entries)
+static void module_entries_destroy(sleep_retention_entries_t *entries)
 {
-    for (int entry = 0; entry < ARRAY_SIZE(*destroy_entries); entry++) {
-        regdma_link_destroy((*destroy_entries)[entry], entry);
+    for (int entry = 0; entry < ARRAY_SIZE(*entries); entry++) {
+        regdma_link_destroy((*entries)[entry], entry);
     }
 }
 
-static void sleep_retention_entries_check_and_distroy_final_default(void)
+static void check_and_destroy_final_default(void)
 {
     _lock_acquire_recursive(&s_retention.lock);
     assert(s_retention.highpri == SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY);
@@ -464,27 +521,31 @@ static void sleep_retention_entries_check_and_distroy_final_default(void)
         created_modules |= s_retention.created_modules.bitmap[i];
     }
     assert(created_modules == 0);
-    sleep_retention_entries_destroy_wrapper(&s_retention.lists[SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY].entries);
+    module_entries_destroy(&s_retention.retention.lists[SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY].entries);
     _lock_release_recursive(&s_retention.lock);
 }
 
-static void sleep_retention_entries_all_destroy_wrapper(sleep_retention_module_t module)
+static void entries_do_destroy(sleep_retention_module_t module)
 {
-    void *destroy_tail = NULL, *prev_tail = NULL;
-    sleep_retention_entries_t destroy_entries, next_entries;
+    void *tail = NULL, *prev_tail = NULL;
+    sleep_retention_entries_t entries, next_entries;
 
-    memset(&destroy_entries, 0, sizeof(sleep_retention_entries_t));
+    memset(&entries, 0, sizeof(sleep_retention_entries_t));
     memset(&next_entries, 0, sizeof(sleep_retention_entries_t));
 
     _lock_acquire_recursive(&s_retention.lock);
+    int index = module_runtime_attach(instance(module)) ? 1 : 0;
+    struct module_sleep_retention_context *ctx = &s_retention.context[index];
     regdma_link_priority_t priority = 0;
     do {
-        bool exist = sleep_retention_entries_get_destroy_context(priority, module, &destroy_entries, &destroy_tail, &next_entries, &prev_tail);
-        if (s_retention.lists[priority].entries_bitmap && exist) {
-            if (sleep_retention_entries_dettach(priority, &destroy_entries, destroy_tail, &next_entries, prev_tail)) {
-                sleep_retention_entries_join();
+        bool exist = module_entries_get(ctx, priority, module, &entries, &tail, &next_entries, &prev_tail);
+        if (exist) {
+            if (entries_detach(ctx, priority, &entries, tail, &next_entries, prev_tail)) {
+                if (!module_runtime_attach(instance(module))) {
+                    retention_entries_join();
+                }
             }
-            sleep_retention_entries_destroy_wrapper(&destroy_entries);
+            module_entries_destroy(&entries);
         } else {
             priority++;
         }
@@ -493,13 +554,16 @@ static void sleep_retention_entries_all_destroy_wrapper(sleep_retention_module_t
     _lock_release_recursive(&s_retention.lock);
 }
 
-static void sleep_retention_entries_do_destroy(sleep_retention_module_t module)
+static void entries_destroy(sleep_retention_module_t module)
 {
     assert(SLEEP_RETENTION_MODULE_MIN <= module && module <= SLEEP_RETENTION_MODULE_MAX);
     _lock_acquire_recursive(&s_retention.lock);
-    sleep_retention_entries_join();
-    sleep_retention_entries_stats();
-    sleep_retention_entries_all_destroy_wrapper(module);
+    if (!module_runtime_attach(instance(module))) {
+        retention_entries_join();
+    }
+    int index = module_runtime_attach(instance(module)) ? 1 : 0;
+    entries_stats(&s_retention.context[index]);
+    entries_do_destroy(module);
     _lock_release_recursive(&s_retention.lock);
 }
 
@@ -507,23 +571,23 @@ static void sleep_retention_entries_destroy(sleep_retention_module_t module)
 {
     assert(SLEEP_RETENTION_MODULE_MIN <= module && module <= SLEEP_RETENTION_MODULE_MAX);
     _lock_acquire_recursive(&s_retention.lock);
-    sleep_retention_entries_do_destroy(module);
+    entries_destroy(module);
     uint32_t created_modules = 0;
     for (int i = 0; i < SLEEP_RETENTION_MODULE_BITMAP_SZ; i++) {
         created_modules |= s_retention.created_modules.bitmap[i];
     }
     if (created_modules == 0) {
-        sleep_retention_entries_check_and_distroy_final_default();
+        check_and_destroy_final_default();
 #if SOC_LIGHT_SLEEP_SUPPORTED
         pmu_sleep_disable_regdma_backup();
 #endif
-        memset((void *)s_retention.lists, 0, sizeof(s_retention.lists));
+        memset((void *)s_retention.context, 0, sizeof(struct module_sleep_retention_context) * 2);
         s_retention.highpri = (uint8_t)-1;
     }
     _lock_release_recursive(&s_retention.lock);
 }
 
-static esp_err_t sleep_retention_entries_create_impl(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module)
+static esp_err_t entries_create(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module)
 {
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
@@ -531,7 +595,7 @@ static esp_err_t sleep_retention_entries_create_impl(const sleep_retention_entri
 #if SOC_PM_RETENTION_HAS_CLOCK_BUG
         if ((retent[i].owner > BIT(EXTRA_LINK_NUM)) && (retent[i].config.id != 0xffff)) {
             _lock_release_recursive(&s_retention.lock);
-            sleep_retention_entries_do_destroy(module);
+            entries_destroy(module);
             return ESP_ERR_NOT_SUPPORTED;
         }
 #endif
@@ -552,77 +616,83 @@ static esp_err_t sleep_retention_entries_create_impl(const sleep_retention_entri
                 [0] = { .config = REGDMA_LINK_WRITE_INIT(0xfffe, PMU_DATE_REG, ~value, mask, skip_b, skip_r), .owner = retent[i].owner },
                 [1] = { .config = REGDMA_LINK_WAIT_INIT (0xfffe, PMU_DATE_REG, ~value, mask, skip_b, skip_r), .owner = retent[i].owner }
             };
-            err = sleep_retention_entries_create_impl(wait_bug_workaround, ARRAY_SIZE(wait_bug_workaround), priority, module);
+            err = entries_create(wait_bug_workaround, ARRAY_SIZE(wait_bug_workaround), priority, module);
         }
 #endif
         if (err == ESP_OK) {
-            void *link = sleep_retention_entries_try_create(&retent[i].config, retent[i].owner, priority, module);
+            void *link = entries_try_create(&retent[i].config, retent[i].owner, priority, module);
             if (link == NULL) {
                 _lock_release_recursive(&s_retention.lock);
-                sleep_retention_entries_do_destroy(module);
+                entries_destroy(module);
                 return ESP_ERR_NO_MEM;
             }
-            sleep_retention_entries_update(retent[i].owner, link, priority);
+
+            int index = module_runtime_attach(instance(module)) ? 1 : 0;
+            struct module_sleep_retention_context *ctx = &s_retention.context[index];
+            entries_context_update(ctx, retent[i].owner, link, priority);
         }
     }
     _lock_release_recursive(&s_retention.lock);
     return err;
 }
 
-static esp_err_t sleep_retention_entries_create_bonding(regdma_link_priority_t priority, sleep_retention_module_t module)
+static esp_err_t entries_create_bonding(regdma_link_priority_t priority, sleep_retention_module_t module)
 {
     static const sleep_retention_entries_config_t bonding_dummy = { REGDMA_LINK_WAIT_INIT(0xffff, 0, 0, 0, 1, 1), SLEEP_RETENTION_ENTRY_BITMAP_MASK };
 
     _lock_acquire_recursive(&s_retention.lock);
-    void *link = sleep_retention_entries_try_create_bonding(&bonding_dummy.config, bonding_dummy.owner, priority, module);
+    void *link = entries_try_create_bonding(&bonding_dummy.config, bonding_dummy.owner, priority, module);
     if (link == NULL) {
         _lock_release_recursive(&s_retention.lock);
-        sleep_retention_entries_do_destroy(module);
+        entries_destroy(module);
         return ESP_ERR_NO_MEM;
     }
-    sleep_retention_entries_update(bonding_dummy.owner, link, priority);
+    int index = module_runtime_attach(instance(module)) ? 1 : 0;
+    struct module_sleep_retention_context *ctx = &s_retention.context[index];
+    entries_context_update(ctx, bonding_dummy.owner, link, priority);
     _lock_release_recursive(&s_retention.lock);
     return ESP_OK;
 }
 
-static void sleep_retention_entries_join(void)
+static void retention_entries_join(void)
 {
     void *entries_tail = NULL;
     _lock_acquire_recursive(&s_retention.lock);
     s_retention.highpri = SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY;
     for (regdma_link_priority_t priority = 0; priority < SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES; priority++) {
-        if (s_retention.lists[priority].entries_bitmap == 0) continue;
+        if (s_retention.retention.lists[priority].entries_bitmap == 0) continue;
         if (priority < s_retention.highpri) { s_retention.highpri = priority; }
         if (entries_tail) {
             regdma_link_update_next_safe(
                     entries_tail,
-                    s_retention.lists[priority].entries[0],
-                    s_retention.lists[priority].entries[1],
-                    s_retention.lists[priority].entries[2],
-                    s_retention.lists[priority].entries[3]
+                    s_retention.retention.lists[priority].entries[0],
+                    s_retention.retention.lists[priority].entries[1],
+                    s_retention.retention.lists[priority].entries[2],
+                    s_retention.retention.lists[priority].entries[3]
 #if (REGDMA_LINK_ENTRY_NUM == 5)
-                    , s_retention.lists[priority].entries[4]
+                  , s_retention.retention.lists[priority].entries[4]
 #endif
                 );
         }
-        entries_tail = s_retention.lists[priority].entries_tail;
+        entries_tail = s_retention.retention.lists[priority].entries_tail;
     }
-    pau_regdma_set_entry_link_addr(&(s_retention.lists[s_retention.highpri].entries));
+    pau_regdma_set_entry_link_addr(&(s_retention.retention.lists[s_retention.highpri].entries));
     _lock_release_recursive(&s_retention.lock);
 }
 
-static esp_err_t sleep_retention_entries_create_wrapper(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module)
+static esp_err_t entries_create_wrapper(const sleep_retention_entries_config_t retent[], int num, regdma_link_priority_t priority, sleep_retention_module_t module)
 {
     _lock_acquire_recursive(&s_retention.lock);
-    esp_err_t err = sleep_retention_entries_create_bonding(priority, module);
+    esp_err_t err = entries_create_bonding(priority, module);
     if(err) goto error;
-    err = sleep_retention_entries_create_impl(retent, num, priority, module);
+    err = entries_create(retent, num, priority, module);
     if(err) goto error;
-    err = sleep_retention_entries_create_bonding(priority, module);
+    err = entries_create_bonding(priority, module);
     if(err) goto error;
     s_retention.created_modules.bitmap[module >> 5] |= BIT(module % 32);
-    sleep_retention_entries_join();
-
+    if (!module_runtime_attach(instance(module))) {
+        retention_entries_join();
+    }
 error:
     _lock_release_recursive(&s_retention.lock);
     return err;
@@ -639,9 +709,9 @@ esp_err_t sleep_retention_entries_create(const sleep_retention_entries_config_t
     if (module < SLEEP_RETENTION_MODULE_MIN || module > SLEEP_RETENTION_MODULE_MAX) {
         return ESP_ERR_INVALID_ARG;
     }
-    esp_err_t err = sleep_retention_entries_check_and_create_final_default();
+    esp_err_t err = check_and_create_final_default();
     if (err)  goto error;
-    err = sleep_retention_entries_create_wrapper(retent, num, priority, module);
+    err = entries_create_wrapper(retent, num, priority, module);
     if (err)  goto error;
 #if SOC_LIGHT_SLEEP_SUPPORTED
     pmu_sleep_enable_regdma_backup();
@@ -660,7 +730,7 @@ void sleep_retention_entries_get(sleep_retention_entries_t *entries)
     _lock_acquire_recursive(&s_retention.lock);
     if (s_retention.highpri >= SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY &&
         s_retention.highpri <= SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY) {
-        memcpy(entries, &s_retention.lists[s_retention.highpri].entries, sizeof(sleep_retention_entries_t));
+        memcpy(entries, &s_retention.retention.lists[s_retention.highpri].entries, sizeof(sleep_retention_entries_t));
     }
     _lock_release_recursive(&s_retention.lock);
 }
@@ -675,6 +745,11 @@ sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_get_created_modules(vo
     return s_retention.created_modules;
 }
 
+sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_get_retained_modules(void)
+{
+    return s_retention.retention_modules;
+}
+
 bool sleep_retention_is_module_inited(sleep_retention_module_t module)
 {
     if (module < SLEEP_RETENTION_MODULE_MIN || module > SLEEP_RETENTION_MODULE_MAX) {
@@ -697,6 +772,17 @@ bool sleep_retention_is_module_created(sleep_retention_module_t module)
     return created;
 }
 
+bool sleep_retention_is_module_attached(sleep_retention_module_t module)
+{
+    if (module < SLEEP_RETENTION_MODULE_MIN || module > SLEEP_RETENTION_MODULE_MAX) {
+        return false;
+    }
+    _lock_acquire_recursive(&s_retention.lock);
+    bool attached = module_is_retained(module);
+    _lock_release_recursive(&s_retention.lock);
+    return attached;
+}
+
 sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_module_bitmap_and(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1)
 {
     sleep_retention_module_bitmap_t and;
@@ -731,6 +817,41 @@ bool IRAM_ATTR sleep_retention_module_bitmap_eq(sleep_retention_module_bitmap_t
     return true;
 }
 
+
+static void module_action(sleep_retention_module_t module, sleep_retention_module_t dep_module, int action)
+{
+    switch (action)
+    {
+    case 0: break;  /* Nothing to do */
+    case 1: set_reference(instance(dep_module), module); break; /* allocate */
+    case 2: clr_reference(instance(dep_module), module); break; /* free */
+    default:  break;
+    }
+}
+
+static esp_err_t module_action_wrapper(sleep_retention_module_t module, int arg, esp_err_t (*rec)(sleep_retention_module_t))
+{
+    esp_err_t err = ESP_OK;
+
+    sleep_retention_module_bitmap_t depends = get_dependencies(instance(module));
+    for (int i = 0; ((err == ESP_OK) && (i < SLEEP_RETENTION_MODULE_BITMAP_SZ)); i++) {
+        uint32_t bitmap = depends.bitmap[i];
+        for (int j = 0; (err == ESP_OK) && bitmap; bitmap >>= 1, j++) {
+            if (bitmap & BIT(0)) {
+                sleep_retention_module_t dep_module = (sleep_retention_module_t)((i << 5) + j);
+
+                #define action(x)   ((x) & 0xf)
+                module_action(module, dep_module, action(arg));
+
+                if ((arg & BIT(31)) || module_is_passive(instance(dep_module))) {
+                    err = (*rec)(dep_module);
+                }
+            }
+        }
+    }
+    return err;
+}
+
 esp_err_t sleep_retention_module_init(sleep_retention_module_t module, sleep_retention_module_init_param_t *param)
 {
     if (module < SLEEP_RETENTION_MODULE_MIN || module > SLEEP_RETENTION_MODULE_MAX) {
@@ -755,9 +876,9 @@ esp_err_t sleep_retention_module_init(sleep_retention_module_t module, sleep_ret
     if (module_is_created(module) || module_is_inited(module)) {
         err = ESP_ERR_INVALID_STATE;
     } else {
-        sleep_retention_module_object_ctor(&s_retention.instance[module], &param->cbs);
-        set_dependencies(&s_retention.instance[module], param->depends);
-        set_attributes(&s_retention.instance[module], param->attribute);
+        sleep_retention_module_object_ctor(instance(module), &param->cbs);
+        set_dependencies(instance(module), param->depends);
+        set_attributes(instance(module), param->attribute);
         s_retention.inited_modules.bitmap[module >> 5] |= BIT(module % 32);
     }
     _lock_release_recursive(&s_retention.lock);
@@ -776,9 +897,9 @@ esp_err_t sleep_retention_module_deinit(sleep_retention_module_t module)
     if (module_is_created(module) || !module_is_inited(module)) {
         err = ESP_ERR_INVALID_STATE;
     } else {
-        clr_attributes(&s_retention.instance[module]);
-        clr_dependencies(&s_retention.instance[module]);
-        sleep_retention_module_object_dtor(&s_retention.instance[module]);
+        clr_attributes(instance(module));
+        clr_dependencies(instance(module));
+        sleep_retention_module_object_dtor(instance(module));
         s_retention.inited_modules.bitmap[module >> 5] &= ~BIT(module % 32);
         uint32_t inited_modules = 0;
         for (int i = 0; i < SLEEP_RETENTION_MODULE_BITMAP_SZ; i++) {
@@ -795,29 +916,20 @@ esp_err_t sleep_retention_module_deinit(sleep_retention_module_t module)
     return err;
 }
 
-static esp_err_t sleep_retention_passive_module_allocate(sleep_retention_module_t module)
+static esp_err_t passive_module_allocate(sleep_retention_module_t module)
 {
     assert(module >= SLEEP_RETENTION_MODULE_MIN && module <= SLEEP_RETENTION_MODULE_MAX);
 
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
-    assert(module_is_passive(&s_retention.instance[module]) && "Illegal dependency");
+    assert(module_is_passive(instance(module)) && "Illegal dependency");
     assert(module_is_inited(module) && "All passive module must be inited first!");
     if (!module_is_created(module)) {
-        sleep_retention_module_bitmap_t depends = get_dependencies(&s_retention.instance[module]);
-        for (int i = 0; ((err == ESP_OK) && (i < SLEEP_RETENTION_MODULE_BITMAP_SZ)); i++) {
-            uint32_t bitmap = depends.bitmap[i];
-            for (int j = 0; (err == ESP_OK) && bitmap; bitmap >>= 1, j++) {
-                if (bitmap & BIT(0)) {
-                    set_reference(&s_retention.instance[(i << 5) + j], module);
-                    err = sleep_retention_passive_module_allocate((i << 5) + j);
-                }
-            }
-        }
+        err = module_action_wrapper(module, (BIT(31) | action(1)), passive_module_allocate);
         if (err == ESP_OK) {
-            sleep_retention_callback_t fn = s_retention.instance[module].cbs.create.handle;
+            sleep_retention_callback_t fn = instance(module)->cbs.create.handle;
             if (fn) {
-                err = (*fn)(s_retention.instance[module].cbs.create.arg);
+                err = (*fn)(instance(module)->cbs.create.arg);
             }
         }
     }
@@ -833,24 +945,13 @@ esp_err_t sleep_retention_module_allocate(sleep_retention_module_t module)
 
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
-    if (!module_is_passive(&s_retention.instance[module])) {
+    if (!module_is_passive(instance(module))) {
         if (module_is_inited(module) && !module_is_created(module)) {
-            sleep_retention_module_bitmap_t depends = get_dependencies(&s_retention.instance[module]);
-            for (int i = 0; ((err == ESP_OK) && (i < SLEEP_RETENTION_MODULE_BITMAP_SZ)); i++) {
-                uint32_t bitmap = depends.bitmap[i];
-                for (int j = 0; (err == ESP_OK) && bitmap; bitmap >>= 1, j++) {
-                    if (bitmap & BIT(0)) {
-                        set_reference(&s_retention.instance[(i << 5) + j], module);
-                        if (module_is_passive(&s_retention.instance[(i << 5) + j])) { /* the callee ensures this module is inited */
-                            err = sleep_retention_passive_module_allocate((i << 5) + j);
-                        }
-                    }
-                }
-            }
+            err = module_action_wrapper(module, action(1), passive_module_allocate);
             if (err == ESP_OK) {
-                sleep_retention_callback_t fn = s_retention.instance[module].cbs.create.handle;
+                sleep_retention_callback_t fn = instance(module)->cbs.create.handle;
                 if (fn) {
-                    err = (*fn)(s_retention.instance[module].cbs.create.arg);
+                    err = (*fn)(instance(module)->cbs.create.arg);
                 }
             }
         } else {
@@ -863,27 +964,21 @@ esp_err_t sleep_retention_module_allocate(sleep_retention_module_t module)
     return err;
 }
 
-static esp_err_t sleep_retention_passive_module_free(sleep_retention_module_t module)
+static esp_err_t passive_module_free(sleep_retention_module_t module)
 {
     assert(module >= SLEEP_RETENTION_MODULE_MIN && module <= SLEEP_RETENTION_MODULE_MAX);
 
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
-    assert(module_is_passive(&s_retention.instance[module]) && "Illegal dependency");
+    assert(module_is_passive(instance(module)) && "Illegal dependency");
     assert(module_is_inited(module) && "All passive module must be inited first!");
     if (module_is_created(module)) {
-        if (!references_exist(&s_retention.instance[module])) {
-            sleep_retention_entries_destroy(module);
-
-            sleep_retention_module_bitmap_t depends = get_dependencies(&s_retention.instance[module]);
-            for (int i = 0; ((err == ESP_OK) && (i < SLEEP_RETENTION_MODULE_BITMAP_SZ)); i++) {
-                uint32_t bitmap = depends.bitmap[i];
-                for (int j = 0; (err == ESP_OK) && bitmap; bitmap >>= 1, j++) {
-                    if (bitmap & BIT(0)) {
-                        clr_reference(&s_retention.instance[(i << 5) + j], module);
-                        err = sleep_retention_passive_module_free((i << 5) + j);
-                    }
-                }
+        if (!references_exist(instance(module))) {
+            if (!module_is_retained(module)) {
+                sleep_retention_entries_destroy(module);
+                err = module_action_wrapper(module, (BIT(31) | action(2)), passive_module_free);
+            } else {
+                err = ESP_ERR_INVALID_STATE;
             }
         }
     }
@@ -899,22 +994,10 @@ esp_err_t sleep_retention_module_free(sleep_retention_module_t module)
 
     esp_err_t err = ESP_OK;
     _lock_acquire_recursive(&s_retention.lock);
-    if (!module_is_passive(&s_retention.instance[module])) {
-        if (module_is_inited(module) && module_is_created(module)) {
+    if (!module_is_passive(instance(module))) {
+        if (module_is_inited(module) && module_is_created(module) && !module_is_retained(module)) {
             sleep_retention_entries_destroy(module);
-
-            sleep_retention_module_bitmap_t depends = get_dependencies(&s_retention.instance[module]);
-            for (int i = 0; ((err == ESP_OK) && (i < SLEEP_RETENTION_MODULE_BITMAP_SZ)); i++) {
-                uint32_t bitmap = depends.bitmap[i];
-                for (int j = 0; (err == ESP_OK) && bitmap; bitmap >>= 1, j++) {
-                    if (bitmap & BIT(0)) {
-                        clr_reference(&s_retention.instance[(i << 5) + j], module);
-                        if (module_is_passive(&s_retention.instance[(i << 5) + j])) {
-                            err = sleep_retention_passive_module_free((i << 5) + j);
-                        }
-                    }
-                }
-            }
+            err = module_action_wrapper(module, action(2), passive_module_free);
         } else {
             err = ESP_ERR_INVALID_STATE;
         }
@@ -971,7 +1054,7 @@ void IRAM_ATTR sleep_retention_do_extra_retention(bool backup_or_restore)
     bool origin_bypass_en = pau_regdma_enable_aon_link_entry(false);
 #endif
     // Set extra linked list head pointer to hardware
-    pau_regdma_set_extra_link_addr(s_retention.lists[s_retention.highpri].entries[EXTRA_LINK_NUM]);
+    pau_regdma_set_extra_link_addr(s_retention.retention.lists[s_retention.highpri].entries[EXTRA_LINK_NUM]);
 #if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE
     /* Data of retention link may be temporarily stored in L1 DCache, which is not accessible by
        REGDMA, write it back to L2MEM before starting REGDMA. */
@@ -994,7 +1077,7 @@ void IRAM_ATTR sleep_retention_do_system_retention(bool backup_or_restore)
     if (s_retention.highpri >= SLEEP_RETENTION_REGDMA_LINK_HIGHEST_PRIORITY &&
         s_retention.highpri <= SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY) {
         // Set extra linked list head pointer to hardware
-        pau_regdma_set_system_link_addr(s_retention.lists[s_retention.highpri].entries[SYSTEM_LINK_NUM]);
+        pau_regdma_set_system_link_addr(s_retention.retention.lists[s_retention.highpri].entries[SYSTEM_LINK_NUM]);
         // When PD TOP, we need to prevent the PMU from triggering the REGDMA backup, because REGDMA will power off
         pmu_sleep_disable_regdma_backup();
         if (backup_or_restore) {