From 78b272c0927ea23f81bd6841bd482f9f8c7333aa Mon Sep 17 00:00:00 2001 From: Li Shuai Date: Wed, 18 Sep 2024 16:44:22 +0800 Subject: [PATCH] feat(esp_hw_support): extend sleep retention module bitmap bit width --- .../include/esp_private/esp_regdma.h | 42 ++-- .../include/esp_private/sleep_retention.h | 78 ++++++- components/esp_hw_support/port/regdma_link.c | 68 +++--- components/esp_hw_support/sleep_retention.c | 198 ++++++++++++------ components/soc/include/soc/regdma.h | 2 +- 5 files changed, 270 insertions(+), 118 deletions(-) diff --git a/components/esp_hw_support/include/esp_private/esp_regdma.h b/components/esp_hw_support/include/esp_private/esp_regdma.h index 1a082408fd..c0b1e45382 100644 --- a/components/esp_hw_support/include/esp_private/esp_regdma.h +++ b/components/esp_hw_support/include/esp_private/esp_regdma.h @@ -35,7 +35,7 @@ extern "C" { * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_continuous(void *backup, void *buff, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_continuous(void *backup, void *buff, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA addr_map type linked list node without retention buffer and the retention buffer is passed in by the caller @@ -52,7 +52,7 @@ void *regdma_link_new_continuous(void *backup, void *buff, int len, void *restor * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA write type linked list node without retention buffer and the retention buffer is passed in by the caller @@ -66,7 +66,7 @@ void *regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], int * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA write type linked list node without retention buffer and the retention buffer is passed in by the caller @@ -80,7 +80,7 @@ void *regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void *n * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA continuouos branch list node without retention buffer and the retention buffer is passed in by the caller @@ -95,7 +95,7 @@ void *regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *ne * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_continuous(void *backup, void *buff, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_continuous(void *backup, void *buff, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA addr_map branch list node without retention buffer and the retention buffer is passed in by the caller @@ -112,7 +112,7 @@ void *regdma_link_new_branch_continuous(void *backup, void *buff, int len, void * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA write branch list node without retention buffer and the retention buffer is passed in by the caller @@ -126,7 +126,7 @@ void *regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap[ * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a REGDMA wait branch list node without retention buffer and the retention buffer is passed in by the caller @@ -140,7 +140,7 @@ void *regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA continuous type linked list node with retention buffer @@ -154,7 +154,7 @@ void *regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, r * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_continuous_default(void *backup, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_continuous_default(void *backup, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA addr_map type linked list node with retention buffer @@ -170,7 +170,7 @@ void *regdma_link_new_continuous_default(void *backup, int len, void *restore, v * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA write type linked list node with retention buffer @@ -184,7 +184,7 @@ void *regdma_link_new_addr_map_default(void *backup, uint32_t bitmap[4], int len * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_write_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_write_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA wait type linked list node with retention buffer @@ -198,7 +198,7 @@ void *regdma_link_new_write_default(void *backup, uint32_t value, uint32_t mask, * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_wait_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_wait_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA continuous branch list node with retention buffer @@ -212,7 +212,7 @@ void *regdma_link_new_wait_default(void *backup, uint32_t value, uint32_t mask, * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_continuous_default(void *backup, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_continuous_default(void *backup, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA addr_map branch list node with retention buffer @@ -228,7 +228,7 @@ void *regdma_link_new_branch_continuous_default(void *backup, int len, void *res * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA write branch list node with retention buffer @@ -242,7 +242,7 @@ void *regdma_link_new_branch_addr_map_default(void *backup, uint32_t bitmap[4], * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_write_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_write_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create a default REGDMA wait branch list node with retention buffer @@ -256,7 +256,7 @@ void *regdma_link_new_branch_write_default(void *backup, uint32_t value, uint32_ * @param module The module identifier of the current linked list node * @return Created REGDMA linked list node pointer */ -void *regdma_link_new_branch_wait_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module); +void *regdma_link_new_branch_wait_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module); /** * @brief Create and initialize a REGDMA linked list node through configuration parameters @@ -267,7 +267,7 @@ void *regdma_link_new_branch_wait_default(void *backup, uint32_t value, uint32_t * @param args next pointer, Since REGDMA supports 4 entries, it supports up to 4 variable parameter next pointers, and more will be ignored * @return Initialized REGDMA linked list head node pointer */ -void *regdma_link_init(const regdma_link_config_t *config, bool branch, uint32_t module, int nentry, ...); +void *regdma_link_init(const regdma_link_config_t *config, bool branch, int module, int nentry, ...); /** * @brief Get REGDMA linked list node mode through configuration parameters @@ -361,7 +361,7 @@ uint32_t regdma_link_get_owner_bitmap(void *link, void *tail, int entry); * @param module Module bitmap Identification * @return The found head node pointer or NULL */ -void *regdma_find_module_link_head(void *link, void *tail, int entry, uint32_t module); +void *regdma_find_module_link_head(void *link, void *tail, int entry, int module); /** * @brief Find the tail node of the specified module in the REGDMA linked list indicated by the @@ -372,7 +372,7 @@ void *regdma_find_module_link_head(void *link, void *tail, int entry, uint32_t m * @param module Module bitmap Identification * @return The found tail node pointer or NULL */ -void *regdma_find_module_link_tail(void *link, void *tail, int entry, uint32_t module); +void *regdma_find_module_link_tail(void *link, void *tail, int entry, int module); /** * @brief Find the tail node of the previous module of the specified module in the REGDMA linked list @@ -383,7 +383,7 @@ void *regdma_find_module_link_tail(void *link, void *tail, int entry, uint32_t m * @param module Module bitmap Identification * @return The found tail node pointer or NULL */ -void *regdma_find_prev_module_link_tail(void *link, void *tail, int entry, uint32_t module); +void *regdma_find_prev_module_link_tail(void *link, void *tail, int entry, int module); /** * @brief Find the head node of the next module of the specified module in the REGDMA linked list @@ -394,7 +394,7 @@ void *regdma_find_prev_module_link_tail(void *link, void *tail, int entry, uint3 * @param module Module bitmap Identification * @return The found head node pointer or NULL */ -void *regdma_find_next_module_link_head(void *link, void *tail, int entry, uint32_t module); +void *regdma_find_next_module_link_head(void *link, void *tail, int entry, int module); #define regdma_link_init_safe(pcfg, branch, module, ...) regdma_link_init((pcfg), (branch), (module), ESP_VA_NARG(__VA_ARGS__), ##__VA_ARGS__) 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 5b4e95e338..6603c5f0d7 100644 --- a/components/esp_hw_support/include/esp_private/sleep_retention.h +++ b/components/esp_hw_support/include/esp_private/sleep_retention.h @@ -17,6 +17,8 @@ extern "C" { #include "esp_regdma.h" #include "soc/retention_periph_defs.h" +#define SLEEP_RETENTION_MODULE_BITMAP_SZ ((SLEEP_RETENTION_MODULE_MAX >> 5) + 1) + /** * @file sleep_retention.h * @@ -24,7 +26,10 @@ extern "C" { * includes sleep retention list creation, destruction and debugging interfaces. */ typedef periph_retention_module_t sleep_retention_module_t; -typedef periph_retention_module_bitmap_t sleep_retention_module_bitmap_t; +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; typedef regdma_entry_buf_t sleep_retention_entries_t; typedef regdma_entries_config_t sleep_retention_entries_config_t; @@ -171,7 +176,7 @@ esp_err_t sleep_retention_power_lock_release(void); * * @return the bitmap for all modules that require sleep retention */ -uint32_t sleep_retention_get_inited_modules(void); +sleep_retention_module_bitmap_t sleep_retention_get_inited_modules(void); /** * @brief Get all created modules that require sleep retention @@ -184,7 +189,74 @@ uint32_t sleep_retention_get_inited_modules(void); * @return the bitmap for all modules that have successfully created a sleep * retention context */ -uint32_t sleep_retention_get_created_modules(void); +sleep_retention_module_bitmap_t sleep_retention_get_created_modules(void); + +/** + * @brief Get the initialization state of module + * + * @param module module number + * + * @return false if the module is not initialized or the module number is + * invalid, otherwise return true + */ +bool sleep_retention_is_module_inited(sleep_retention_module_t module); + +/** + * @brief Get the creation state of module + * + * @param module module number + * + * @return false if the module is not created or the module number is + * invalid, otherwise return true + */ +bool sleep_retention_is_module_created(sleep_retention_module_t module); + +/** + * @brief Calculates the bitwise logical and of the module bitmap and return results + * + * This is an unprotected interface. It can only be called by the sleep procedure. + * + * @param op0 module bitmap operator 0 + * @param op1 module bitmap operator 1 + * + * @return the bitwise logical and result of module bitmap + */ +sleep_retention_module_bitmap_t sleep_retention_module_bitmap_and(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1); + +/** + * @brief Calculates the bitwise logical or of the module bitmap and return results + * + * This is an unprotected interface. It can only be called by the sleep procedure. + * + * @param op0 module bitmap operator 0 + * @param op1 module bitmap operator 1 + * + * @return the bitwise logical or result of module bitmap + */ +sleep_retention_module_bitmap_t sleep_retention_module_bitmap_or(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1); + +/** + * @brief Calculates the bitwise logical not of the module bitmap and return results + * + * This is an unprotected interface. It can only be called by the sleep procedure. + * + * @param op0 module bitmap operator + * + * @return the bitwise logical not result of module bitmap + */ +sleep_retention_module_bitmap_t sleep_retention_module_bitmap_not(sleep_retention_module_bitmap_t op); + +/** + * @brief Compares the module bitmap values are equal and return results + * + * This is an unprotected interface. It can only be called by the sleep procedure. + * + * @param op0 module bitmap operator 0 + * @param op1 module bitmap operator 1 + * + * @return If the module bitmap values are equal then return true, otherwise return false + */ +bool sleep_retention_module_bitmap_eq(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1); /** * @brief Software trigger REGDMA to do extra linked list retention diff --git a/components/esp_hw_support/port/regdma_link.c b/components/esp_hw_support/port/regdma_link.c index 69db06f5e0..c459e01069 100644 --- a/components/esp_hw_support/port/regdma_link.c +++ b/components/esp_hw_support/port/regdma_link.c @@ -22,7 +22,7 @@ #define REGDMA_LINK_ADDR_ALIGN (4) #define REGDMA_LINK_MEM_TYPE_CAPS (MALLOC_CAP_DMA | MALLOC_CAP_DEFAULT) -void * regdma_link_new_continuous(void *backup, void *buff, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_continuous(void *backup, void *buff, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_continuous_t *link = (regdma_link_continuous_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, @@ -38,7 +38,7 @@ void * regdma_link_new_continuous(void *backup, void *buff, int len, void *resto return NULL; } -void * regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_addr_map_t *link = (regdma_link_addr_map_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, @@ -54,7 +54,7 @@ void * regdma_link_new_addr_map(void *backup, void *buff, uint32_t bitmap[4], in return NULL; } -void * regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_write_wait_t *link = (regdma_link_write_wait_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, sizeof(regdma_link_write_wait_t), REGDMA_LINK_MEM_TYPE_CAPS); @@ -66,7 +66,7 @@ void * regdma_link_new_write(void *backup, uint32_t value, uint32_t mask, void * return NULL; } -void * regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_write_wait_t *link = (regdma_link_write_wait_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, sizeof(regdma_link_write_wait_t), REGDMA_LINK_MEM_TYPE_CAPS); @@ -78,7 +78,7 @@ void * regdma_link_new_wait(void *backup, uint32_t value, uint32_t mask, void *n return NULL; } -void * regdma_link_new_branch_continuous(void *backup, void *buff, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_continuous(void *backup, void *buff, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_branch_continuous_t *link = (regdma_link_branch_continuous_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, @@ -94,7 +94,7 @@ void * regdma_link_new_branch_continuous(void *backup, void *buff, int len, void return NULL; } -void * regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_branch_addr_map_t *link = (regdma_link_branch_addr_map_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, @@ -110,7 +110,7 @@ void * regdma_link_new_branch_addr_map(void *backup, void *buff, uint32_t bitmap return NULL; } -void * regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_branch_write_wait_t *link = (regdma_link_branch_write_wait_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, sizeof(regdma_link_branch_write_wait_t), REGDMA_LINK_MEM_TYPE_CAPS); @@ -122,7 +122,7 @@ void * regdma_link_new_branch_write(void *backup, uint32_t value, uint32_t mask, return NULL; } -void * regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { regdma_link_branch_write_wait_t *link = (regdma_link_branch_write_wait_t *)heap_caps_aligned_alloc( REGDMA_LINK_ADDR_ALIGN, sizeof(regdma_link_branch_write_wait_t), REGDMA_LINK_MEM_TYPE_CAPS); @@ -134,48 +134,48 @@ void * regdma_link_new_branch_wait(void *backup, uint32_t value, uint32_t mask, return NULL; } -void * regdma_link_new_continuous_default(void *backup, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_continuous_default(void *backup, int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_continuous(backup, NULL, len, restore, next, skip_b, skip_r, id, module); } -void * regdma_link_new_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, void *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_addr_map(backup, NULL, bitmap, len, restore, next, skip_b, skip_r, id, module); } -void * regdma_link_new_write_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_write_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_write(backup, value, mask, next, skip_b, skip_r, id, module); } -void * regdma_link_new_wait_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_wait_default(void *backup, uint32_t value, uint32_t mask, void *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_wait(backup, value, mask, next, skip_b, skip_r, id, module); } -void * regdma_link_new_branch_continuous_default(void *backup, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_continuous_default(void *backup, int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_branch_continuous(backup, NULL, len, restore, next, skip_b, skip_r, id, module); } -void * regdma_link_new_branch_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_addr_map_default(void *backup, uint32_t bitmap[4], int len, void *restore, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_branch_addr_map(backup, NULL, bitmap, len, restore, next, skip_b, skip_r, id, module); } -void * regdma_link_new_branch_write_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_write_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_branch_write(backup, value, mask, next, skip_b, skip_r, id, module); } -void * regdma_link_new_branch_wait_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, uint32_t module) +void * regdma_link_new_branch_wait_default(void *backup, uint32_t value, uint32_t mask, regdma_entry_buf_t *next, bool skip_b, bool skip_r, int id, int module) { return regdma_link_new_branch_wait(backup, value, mask, next, skip_b, skip_r, id, module); } -static void * regdma_link_init_continuous_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_continuous_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -188,7 +188,7 @@ static void * regdma_link_init_continuous_wrapper(const regdma_link_config_t *co config->head.skip_r, config->id, module); } -static void * regdma_link_init_addr_map_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_addr_map_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -201,7 +201,7 @@ static void * regdma_link_init_addr_map_wrapper(const regdma_link_config_t *conf config->head.skip_r, config->id, module); } -static void * regdma_link_init_write_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_write_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -214,7 +214,7 @@ static void * regdma_link_init_write_wrapper(const regdma_link_config_t *config, config->id, module); } -static void * regdma_link_init_wait_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_wait_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -227,7 +227,7 @@ static void * regdma_link_init_wait_wrapper(const regdma_link_config_t *config, config->id, module); } -static void * regdma_link_init_branch_continuous_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_branch_continuous_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -240,7 +240,7 @@ static void * regdma_link_init_branch_continuous_wrapper(const regdma_link_confi config->head.skip_b, config->head.skip_r, config->id, module); } -static void * regdma_link_init_branch_addr_map_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_branch_addr_map_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -253,7 +253,7 @@ static void * regdma_link_init_branch_addr_map_wrapper(const regdma_link_config_ &next, config->head.skip_b, config->head.skip_r, config->id, module); } -static void * regdma_link_init_branch_write_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_branch_write_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -266,7 +266,7 @@ static void * regdma_link_init_branch_write_wrapper(const regdma_link_config_t * config->head.skip_r, config->id, module); } -static void * regdma_link_init_branch_wait_wrapper(const regdma_link_config_t *config, uint32_t module, int n, va_list args) +static void * regdma_link_init_branch_wait_wrapper(const regdma_link_config_t *config, int module, int n, va_list args) { regdma_entry_buf_t next; @@ -279,7 +279,7 @@ static void * regdma_link_init_branch_wait_wrapper(const regdma_link_config_t *c config->head.skip_r, config->id, module); } -static void * regdma_link_init_wrapper(const regdma_link_config_t *config, bool branch, uint32_t module, int nentry, va_list args) +static void * regdma_link_init_wrapper(const regdma_link_config_t *config, bool branch, int module, int nentry, va_list args) { typedef void * (*init_fn_t)(const void *, uint32_t, int, va_list); @@ -302,7 +302,7 @@ static void * regdma_link_init_wrapper(const regdma_link_config_t *config, bool return (*pfn)(config, module, nentry, args); } -void * regdma_link_init(const regdma_link_config_t *config, bool branch, uint32_t module, int nentry, ...) +void * regdma_link_init(const regdma_link_config_t *config, bool branch, int module, int nentry, ...) { assert(config != NULL); @@ -643,7 +643,7 @@ uint32_t regdma_link_get_owner_bitmap(void *link, void *tail, int entry) return owner; } -void * regdma_find_module_link_head(void *link, void *tail, int entry, uint32_t module) +void * regdma_find_module_link_head(void *link, void *tail, int entry, int module) { assert(entry < REGDMA_LINK_ENTRY_NUM); @@ -651,7 +651,7 @@ void * regdma_find_module_link_head(void *link, void *tail, int entry, uint32_t void *next = link; if (link) { do { - if (regdma_link_get_stats(next)->module & module) { + if (regdma_link_get_stats(next)->module == module) { find_link = next; break; } @@ -663,7 +663,7 @@ void * regdma_find_module_link_head(void *link, void *tail, int entry, uint32_t return find_link; } -void * regdma_find_module_link_tail(void *link, void *tail, int entry, uint32_t module) +void * regdma_find_module_link_tail(void *link, void *tail, int entry, int module) { assert(entry < REGDMA_LINK_ENTRY_NUM); @@ -673,13 +673,13 @@ void * regdma_find_module_link_tail(void *link, void *tail, int entry, uint32_t do { if (next != tail) { void *temp = regdma_link_get_next(next, entry); - if ((regdma_link_get_stats(next)->module & module) && - !(regdma_link_get_stats(temp)->module & module)) { + if ((regdma_link_get_stats(next)->module == module) && + !(regdma_link_get_stats(temp)->module == module)) { find_tail = next; break; } } else { - if (regdma_link_get_stats(next)->module & module) { + if (regdma_link_get_stats(next)->module == module) { find_tail = next; break; } @@ -689,7 +689,7 @@ void * regdma_find_module_link_tail(void *link, void *tail, int entry, uint32_t return find_tail; } -void * regdma_find_next_module_link_head(void *link, void *tail, int entry, uint32_t module) +void * regdma_find_next_module_link_head(void *link, void *tail, int entry, int module) { assert(entry < REGDMA_LINK_ENTRY_NUM); void *find_tail = regdma_find_module_link_tail(link, tail, entry, module); @@ -699,7 +699,7 @@ void * regdma_find_next_module_link_head(void *link, void *tail, int entry, uint return NULL; } -void * regdma_find_prev_module_link_tail(void *link, void *tail, int entry, uint32_t module) +void * regdma_find_prev_module_link_tail(void *link, void *tail, int entry, int module) { assert(entry < REGDMA_LINK_ENTRY_NUM); void *find_head = regdma_find_module_link_head(link, tail, entry, module); diff --git a/components/esp_hw_support/sleep_retention.c b/components/esp_hw_support/sleep_retention.c index 7e01204a6e..d7b63cb63f 100644 --- a/components/esp_hw_support/sleep_retention.c +++ b/components/esp_hw_support/sleep_retention.c @@ -43,8 +43,8 @@ struct sleep_retention_module_object { static inline void sleep_retention_module_object_ctor(struct sleep_retention_module_object * const self, sleep_retention_module_callbacks_t *cbs) { self->cbs = *cbs; - self->dependents = 0; - self->references = 0; + self->dependents = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }; + self->references = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }; self->attributes = 0; } @@ -60,7 +60,7 @@ static inline void set_dependencies(struct sleep_retention_module_object * const static inline void clr_dependencies(struct sleep_retention_module_object * const self) { - self->dependents = 0; + self->dependents = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }; } static inline sleep_retention_module_bitmap_t get_dependencies(struct sleep_retention_module_object * const self) @@ -70,12 +70,12 @@ static inline sleep_retention_module_bitmap_t get_dependencies(struct sleep_rete static inline void set_reference(struct sleep_retention_module_object * const self, sleep_retention_module_t module) { - self->references |= BIT(module); + self->references.bitmap[module >> 5] |= BIT(module % 32); } static inline void clr_reference(struct sleep_retention_module_object * const self, sleep_retention_module_t module) { - self->references &= ~BIT(module); + self->references.bitmap[module >> 5] &= ~BIT(module % 32); } static inline sleep_retention_module_bitmap_t get_references(struct sleep_retention_module_object * const self) @@ -85,7 +85,12 @@ static inline sleep_retention_module_bitmap_t get_references(struct sleep_retent static inline bool references_exist(struct sleep_retention_module_object * const self) { - return (get_references(self) != 0); + uint32_t references = 0; + sleep_retention_module_bitmap_t map = get_references(self); + for (int i = 0; i < SLEEP_RETENTION_MODULE_BITMAP_SZ; i++) { + references |= map.bitmap[i]; + } + return (references != 0); } static inline void set_attributes(struct sleep_retention_module_object * const self, sleep_retention_module_attribute_t attributes) @@ -110,12 +115,14 @@ static inline bool module_is_passive(struct sleep_retention_module_object * cons static inline bool module_is_inited(sleep_retention_module_t module) { - return (sleep_retention_get_inited_modules() & BIT(module)) ? true : false; + 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) { - return (sleep_retention_get_created_modules() & BIT(module)) ? true : false; + sleep_retention_module_bitmap_t created_modules = sleep_retention_get_created_modules(); + return (created_modules.bitmap[module >> 5] & BIT(module % 32)) ? true : false; } /** @@ -189,16 +196,18 @@ typedef struct { } lists[SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES]; _lock_t lock; regdma_link_priority_t highpri; - uint32_t inited_modules; - uint32_t created_modules; + sleep_retention_module_bitmap_t inited_modules; + sleep_retention_module_bitmap_t created_modules; - struct sleep_retention_module_object instance[32]; + struct sleep_retention_module_object instance[SLEEP_RETENTION_MODULE_MAX + 1]; #define EXTRA_LINK_NUM (REGDMA_LINK_ENTRY_NUM - 1) } sleep_retention_t; static DRAM_ATTR __attribute__((unused)) sleep_retention_t s_retention = { - .highpri = (uint8_t)-1, .inited_modules = 0, .created_modules = 0 + .highpri = (uint8_t)-1, + .inited_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } }, + .created_modules = (sleep_retention_module_bitmap_t){ .bitmap = { 0 } } }; #define SLEEP_RETENTION_ENTRY_BITMAP_MASK (BIT(REGDMA_LINK_ENTRY_NUM) - 1) @@ -207,11 +216,6 @@ static DRAM_ATTR __attribute__((unused)) sleep_retention_t s_retention = { 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 inline sleep_retention_module_bitmap_t module_num2map(sleep_retention_module_t module) -{ - return (module == SLEEP_RETENTION_MODULE_INVALID) ? 0 : BIT(module); -} - static inline bool sleep_retention_entries_require_branch(uint32_t owner, uint32_t runtime_bitmap) { bool use_new_entry = SLEEP_RETENTION_ENTRY_BITMAP(owner & ~runtime_bitmap) ? true : false; @@ -273,9 +277,8 @@ static void * sleep_retention_entries_try_create(const regdma_link_config_t *con _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_num2map(module)) == ESP_OK) { /* branch node can't as tail node */ - link = regdma_link_init_safe( - config, true, module_num2map(module), + s_retention.lists[priority].entries_bitmap, priority, module) == ESP_OK) { /* branch node can't as tail node */ + 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, @@ -286,7 +289,7 @@ static void * sleep_retention_entries_try_create(const regdma_link_config_t *con ); } } else { - link = regdma_link_init_safe(config, false, module_num2map(module), s_retention.lists[priority].entries[__builtin_ffs(owner) - 1]); + link = regdma_link_init_safe(config, false, module, s_retention.lists[priority].entries[__builtin_ffs(owner) - 1]); } _lock_release_recursive(&s_retention.lock); return link; @@ -296,8 +299,7 @@ static void * sleep_retention_entries_try_create_bonding(const regdma_link_confi { assert(owner > 0 && owner < BIT(REGDMA_LINK_ENTRY_NUM)); _lock_acquire_recursive(&s_retention.lock); - void *link = regdma_link_init_safe( - config, true, module_num2map(module), + 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, @@ -323,12 +325,10 @@ static void sleep_retention_entries_stats(void) void sleep_retention_dump_modules(FILE *out) { - uint32_t inited_modules = sleep_retention_get_inited_modules(); - uint32_t created_modules = sleep_retention_get_created_modules(); for (int i = SLEEP_RETENTION_MODULE_MIN; i <= SLEEP_RETENTION_MODULE_MAX; i++) { - bool inited = (inited_modules & BIT(i)) != 0; - bool created = (created_modules & BIT(i)) != 0; - bool is_top = (TOP_DOMAIN_PERIPHERALS_BM & BIT(i)) != 0; + bool inited = sleep_retention_is_module_inited(i); + bool created = sleep_retention_is_module_created(i); + bool is_top = is_top_domain_module(i); const char* status = !inited? "-": created? "CREATED": @@ -387,13 +387,13 @@ static bool sleep_retention_entries_get_destroy_context(regdma_link_priority_t p _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_num2map(module)); + 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_num2map(module)); + s_retention.lists[priority].entries[entry], s_retention.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_num2map(module)); + s_retention.lists[priority].entries[entry], s_retention.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_num2map(module)); + s_retention.lists[priority].entries[entry], s_retention.lists[priority].entries_tail, entry, module); if ((*destroy_entries)[entry] && destroy_tails[entry]) { exist = true; } @@ -459,7 +459,11 @@ static void sleep_retention_entries_check_and_distroy_final_default(void) { _lock_acquire_recursive(&s_retention.lock); assert(s_retention.highpri == SLEEP_RETENTION_REGDMA_LINK_LOWEST_PRIORITY); - assert(s_retention.created_modules == 0); + uint32_t created_modules = 0; + for (int i = 0; i < SLEEP_RETENTION_MODULE_BITMAP_SZ; i++) { + 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); _lock_release_recursive(&s_retention.lock); } @@ -485,7 +489,7 @@ static void sleep_retention_entries_all_destroy_wrapper(sleep_retention_module_t priority++; } } while (priority < SLEEP_RETENTION_REGDMA_LINK_NR_PRIORITIES); - s_retention.created_modules &= ~module_num2map(module); + s_retention.created_modules.bitmap[module >> 5] &= ~BIT(module % 32); _lock_release_recursive(&s_retention.lock); } @@ -504,7 +508,11 @@ 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); - if (s_retention.created_modules == 0) { + 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(); pmu_sleep_disable_regdma_backup(); memset((void *)s_retention.lists, 0, sizeof(s_retention.lists)); @@ -610,7 +618,7 @@ static esp_err_t sleep_retention_entries_create_wrapper(const sleep_retention_en if(err) goto error; err = sleep_retention_entries_create_bonding(priority, module); if(err) goto error; - s_retention.created_modules |= module_num2map(module); + s_retention.created_modules.bitmap[module >> 5] |= BIT(module % 32); sleep_retention_entries_join(); error: @@ -651,16 +659,72 @@ void sleep_retention_entries_get(sleep_retention_entries_t *entries) _lock_release_recursive(&s_retention.lock); } -uint32_t IRAM_ATTR sleep_retention_get_inited_modules(void) +sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_get_inited_modules(void) { return s_retention.inited_modules; } -uint32_t IRAM_ATTR sleep_retention_get_created_modules(void) +sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_get_created_modules(void) { return s_retention.created_modules; } +bool sleep_retention_is_module_inited(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 inited = module_is_inited(module); + _lock_release_recursive(&s_retention.lock); + return inited; +} + +bool sleep_retention_is_module_created(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 created = module_is_created(module); + _lock_release_recursive(&s_retention.lock); + return created; +} + +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; + for (int i = 0; i < ARRAY_SIZE(and.bitmap); i++) { + and.bitmap[i] = op0.bitmap[i] & op1.bitmap[i]; + } + return and; +} +sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_module_bitmap_or(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1) +{ + sleep_retention_module_bitmap_t or; + for (int i = 0; i < ARRAY_SIZE(or.bitmap); i++) { + or.bitmap[i] = op0.bitmap[i] | op1.bitmap[i]; + } + return or; +} +sleep_retention_module_bitmap_t IRAM_ATTR sleep_retention_module_bitmap_not(sleep_retention_module_bitmap_t op) +{ + sleep_retention_module_bitmap_t not; + for (int i = 0; i < ARRAY_SIZE(not.bitmap); i++) { + not.bitmap[i] = ~op.bitmap[i]; + } + return not; +} +bool IRAM_ATTR sleep_retention_module_bitmap_eq(sleep_retention_module_bitmap_t op0, sleep_retention_module_bitmap_t op1) +{ + for (int i = 0; i < ARRAY_SIZE(op0.bitmap); i++) { + if (op0.bitmap[i] != op1.bitmap[i]) { + return false; + } + } + return true; +} + 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) { @@ -688,7 +752,7 @@ esp_err_t sleep_retention_module_init(sleep_retention_module_t module, sleep_ret sleep_retention_module_object_ctor(&s_retention.instance[module], ¶m->cbs); set_dependencies(&s_retention.instance[module], param->depends); set_attributes(&s_retention.instance[module], param->attribute); - s_retention.inited_modules |= module_num2map(module); + s_retention.inited_modules.bitmap[module >> 5] |= BIT(module % 32); } _lock_release_recursive(&s_retention.lock); return err; @@ -709,8 +773,12 @@ esp_err_t sleep_retention_module_deinit(sleep_retention_module_t module) clr_attributes(&s_retention.instance[module]); clr_dependencies(&s_retention.instance[module]); sleep_retention_module_object_dtor(&s_retention.instance[module]); - s_retention.inited_modules &= ~module_num2map(module); - do_lock_release = (sleep_retention_get_inited_modules() == 0); + 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++) { + inited_modules |= s_retention.inited_modules.bitmap[i]; + } + do_lock_release = (inited_modules == 0); } _lock_release_recursive(&s_retention.lock); @@ -731,10 +799,13 @@ static esp_err_t sleep_retention_passive_module_allocate(sleep_retention_module_ 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) && depends; depends >>= 1, i++) { - if (depends & BIT(0)) { - set_reference(&s_retention.instance[i], module); - err = sleep_retention_passive_module_allocate(i); + 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); + } } } if (err == ESP_OK) { @@ -759,11 +830,14 @@ esp_err_t sleep_retention_module_allocate(sleep_retention_module_t module) if (!module_is_passive(&s_retention.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) && depends; depends >>= 1, i++) { - if (depends & BIT(0)) { - set_reference(&s_retention.instance[i], module); - if (module_is_passive(&s_retention.instance[i])) { /* the callee ensures this module is inited */ - err = sleep_retention_passive_module_allocate(i); + 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); + } } } } @@ -796,10 +870,13 @@ static esp_err_t sleep_retention_passive_module_free(sleep_retention_module_t mo sleep_retention_entries_destroy(module); sleep_retention_module_bitmap_t depends = get_dependencies(&s_retention.instance[module]); - for (int i = 0; (err == ESP_OK) && depends; depends >>= 1, i++) { - if (depends & BIT(0)) { - clr_reference(&s_retention.instance[i], module); - err = sleep_retention_passive_module_free(i); + 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); + } } } } @@ -821,11 +898,14 @@ esp_err_t sleep_retention_module_free(sleep_retention_module_t 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) && depends; depends >>= 1, i++) { - if (depends & BIT(0)) { - clr_reference(&s_retention.instance[i], module); - if (module_is_passive(&s_retention.instance[i])) { - err = sleep_retention_passive_module_free(i); + 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); + } } } } diff --git a/components/soc/include/soc/regdma.h b/components/soc/include/soc/regdma.h index 80b7cf301f..3a89917367 100644 --- a/components/soc/include/soc/regdma.h +++ b/components/soc/include/soc/regdma.h @@ -179,7 +179,7 @@ typedef struct regdma_link_stats { reserve: 16-REGDMA_LINK_ENTRY_NUM, #endif id: 16; /* REGDMA linked list node unique identifier */ - volatile uint32_t module; /* a bitmap used to identify the module to which the current node belongs */ + volatile int module; /* a number used to identify the module to which the current node belongs */ } regdma_link_stats_t; typedef struct regdma_link_continuous {