Support esp32s3 create thread on psram

Author: maidang-xing

tuya_open_sdk/main/main.c

@@ -4,6 +4,21 @@
 
 #include "nvs_flash.h"
 
+#if CONFIG_IDF_TARGET_ESP32S3
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+extern void tkl_flash_agent_init(void);
+extern void tkl_flash_agent_process(void);
+
+static void flash_agent_task(void *arg)
+{
+    while (1) {
+        tkl_flash_agent_process();
+    }
+}
+#endif
+
 extern void tuya_app_main(void);
 void app_main(void)
 {
@@ -15,5 +30,10 @@ void app_main(void)
     }
     ESP_ERROR_CHECK(ret);
 
+#if CONFIG_IDF_TARGET_ESP32S3
+    tkl_flash_agent_init();
+    xTaskCreate(flash_agent_task, "flash_agent", 2048, NULL, configMAX_PRIORITIES - 1, NULL);
+#endif
+
     tuya_app_main();
 }

tuya_open_sdk/tuyaos_adapter/src/drivers/tkl_flash.c

@@ -41,6 +41,82 @@ typedef struct {
     char *uuid;
     char *authkey;
 } tuya_iot_license_t;
+
+#if CONFIG_IDF_TARGET_ESP32S3
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+
+typedef enum {
+    FLASH_OP_READ = 0,
+    FLASH_OP_WRITE,
+    FLASH_OP_ERASE,
+} FLASH_OP_TYPE_E;
+
+typedef struct {
+    FLASH_OP_TYPE_E op;
+    uint32_t addr;
+    union {
+        const uint8_t *src;
+        uint8_t *dst;
+    };
+    uint32_t size;
+    TaskHandle_t caller;
+    OPERATE_RET result;
+} FLASH_REQ_T;
+
+static QueueHandle_t s_flash_queue = NULL;
+
+static OPERATE_RET __flash_dispatch(FLASH_REQ_T *req)
+{
+    req->caller = xTaskGetCurrentTaskHandle();
+    FLASH_REQ_T *preq = req;
+    xQueueSend(s_flash_queue, &preq, portMAX_DELAY);
+    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+    return req->result;
+}
+
+void tkl_flash_agent_init(void)
+{
+    s_flash_queue = xQueueCreate(8, sizeof(FLASH_REQ_T *));
+}
+
+void tkl_flash_agent_process(void)
+{
+    FLASH_REQ_T *req = NULL;
+
+    if (xQueueReceive(s_flash_queue, &req, portMAX_DELAY) != pdTRUE || req == NULL) {
+        return;
+    }
+
+    const esp_partition_t *partition = GET_TUYA_DATA_PARTITION();
+    if (partition == NULL) {
+        req->result = OPRT_COM_ERROR;
+        xTaskNotifyGive(req->caller);
+        return;
+    }
+
+    switch (req->op) {
+        case FLASH_OP_READ:
+            req->result = (esp_partition_read(partition, req->addr, req->dst, req->size) == ESP_OK)
+                          ? OPRT_OK : OPRT_COM_ERROR;
+            break;
+        case FLASH_OP_WRITE:
+            req->result = (esp_partition_write(partition, req->addr, req->src, req->size) == ESP_OK)
+                          ? OPRT_OK : OPRT_COM_ERROR;
+            break;
+        case FLASH_OP_ERASE:
+            req->result = (esp_partition_erase_range(partition, req->addr, req->size) == ESP_OK)
+                          ? OPRT_OK : OPRT_COM_ERROR;
+            break;
+        default:
+            req->result = OPRT_INVALID_PARM;
+            break;
+    }
+
+    xTaskNotifyGive(req->caller);
+}
+#endif
 // --- END: user defines and implements ---
 
 /**
@@ -57,13 +133,18 @@ typedef struct {
 OPERATE_RET tkl_flash_read(uint32_t addr, uint8_t *dst, uint32_t size)
 {
     // --- BEGIN: user implements ---
-    const esp_partition_t *partition;
-
     if (NULL == dst) {
         return OPRT_INVALID_PARM;
     }
 
-    partition = GET_TUYA_DATA_PARTITION();
+#if CONFIG_IDF_TARGET_ESP32S3
+    if (s_flash_queue != NULL) {
+        FLASH_REQ_T req = { .op = FLASH_OP_READ, .addr = addr, .dst = dst, .size = size };
+        return __flash_dispatch(&req);
+    }
+#endif
+
+    const esp_partition_t *partition = GET_TUYA_DATA_PARTITION();
     if (NULL == partition) {
         return OPRT_COM_ERROR;
     }
@@ -90,13 +171,18 @@ OPERATE_RET tkl_flash_read(uint32_t addr, uint8_t *dst, uint32_t size)
 OPERATE_RET tkl_flash_write(uint32_t addr, const uint8_t *src, uint32_t size)
 {
     // --- BEGIN: user implements ---
-    const esp_partition_t *partition;
-
     if (NULL == src) {
         return OPRT_INVALID_PARM;
     }
-    
-    partition = GET_TUYA_DATA_PARTITION();
+
+#if CONFIG_IDF_TARGET_ESP32S3
+    if (s_flash_queue != NULL) {
+        FLASH_REQ_T req = { .op = FLASH_OP_WRITE, .addr = addr, .src = src, .size = size };
+        return __flash_dispatch(&req);
+    }
+#endif
+
+    const esp_partition_t *partition = GET_TUYA_DATA_PARTITION();
     if (NULL == partition) {
         return OPRT_COM_ERROR;
     }
@@ -122,9 +208,14 @@ OPERATE_RET tkl_flash_write(uint32_t addr, const uint8_t *src, uint32_t size)
 OPERATE_RET tkl_flash_erase(uint32_t addr, uint32_t size)
 {
     // --- BEGIN: user implements ---
-    const esp_partition_t *partition;
+#if CONFIG_IDF_TARGET_ESP32S3
+    if (s_flash_queue != NULL) {
+        FLASH_REQ_T req = { .op = FLASH_OP_ERASE, .addr = addr, .size = size };
+        return __flash_dispatch(&req);
+    }
+#endif
 
-    partition = GET_TUYA_DATA_PARTITION();
+    const esp_partition_t *partition = GET_TUYA_DATA_PARTITION();
     if (NULL == partition) {
         return OPRT_COM_ERROR;
     }
@@ -133,7 +224,6 @@ OPERATE_RET tkl_flash_erase(uint32_t addr, uint32_t size)
         return OPRT_COM_ERROR;
     }
 
-
     return OPRT_OK;
     // --- END: user implements ---
 }

tuya_open_sdk/tuyaos_adapter/src/system/tkl_thread.c

@@ -29,12 +29,7 @@ typedef struct {
 
 typedef struct {
     TaskHandle_t task;
-} THREAD_HANDLE_T;
-
-typedef struct {
-    THREAD_FUNC_T entry;
-    void *arg;
-} THREAD_ENTRY_CTX_T;
+} RAM_THREAD_HANDLE_T;
 
 #define PSRAM_THREAD_MAGIC 0x5053524DU
 
@@ -71,27 +66,9 @@ static TaskHandle_t __tkl_thread_get_task_handle(const TKL_THREAD_HANDLE thread)
         return psram_handle->task;
     }
 
-    return ((THREAD_HANDLE_T *)thread)->task;
+    return ((RAM_THREAD_HANDLE_T *)thread)->task;
 }
 
-static void __tkl_thread_entry(void *arg)
-{
-    THREAD_ENTRY_CTX_T *ctx = (THREAD_ENTRY_CTX_T *)arg;
-    THREAD_FUNC_T entry = NULL;
-    void *entry_arg = NULL;
-
-    if (ctx != NULL) {
-        entry = ctx->entry;
-        entry_arg = ctx->arg;
-        free(ctx);
-    }
-
-    if (entry != NULL) {
-        entry(entry_arg);
-    }
-
-    vTaskDelete(NULL);
-}
 // --- END: user defines and implements ---
 
 /**
@@ -116,31 +93,20 @@ OPERATE_RET tkl_thread_create(TKL_THREAD_HANDLE* thread,
                               void* const arg)
 {
     // --- BEGIN: user implements ---
-    THREAD_HANDLE_T *handle = NULL;
-    THREAD_ENTRY_CTX_T *entry_ctx = NULL;
+    RAM_THREAD_HANDLE_T *handle = NULL;
 
     if ((thread == NULL) || (func == NULL)) {
         return OPRT_INVALID_PARM;
     }
 
-    handle = (THREAD_HANDLE_T *)malloc(sizeof(THREAD_HANDLE_T));
+    handle = (RAM_THREAD_HANDLE_T *)malloc(sizeof(RAM_THREAD_HANDLE_T));
     if (handle == NULL) {
         return OPRT_MALLOC_FAILED;
     }
 
-    entry_ctx = (THREAD_ENTRY_CTX_T *)malloc(sizeof(THREAD_ENTRY_CTX_T));
-    if (entry_ctx == NULL) {
-        free(handle);
-        return OPRT_MALLOC_FAILED;
-    }
-
-    entry_ctx->entry = func;
-    entry_ctx->arg = arg;
-
     stack_size = __tkl_thread_adjust_stack_size(stack_size);
 
-    if (xTaskCreate(__tkl_thread_entry, name, stack_size / sizeof(portSTACK_TYPE), (void *const)entry_ctx, priority, &handle->task) != pdPASS) {
-        free(entry_ctx);
+    if (xTaskCreate(func, name, stack_size / sizeof(portSTACK_TYPE), arg, priority, &handle->task) != pdPASS) {
         free(handle);
         return OPRT_OS_ADAPTER_THRD_CREAT_FAILED;
     }
@@ -163,7 +129,7 @@ OPERATE_RET tkl_thread_release(const TKL_THREAD_HANDLE thread)
 {
     // --- BEGIN: user implements ---
     PSRAM_THREAD_HANDLE_T *psram_handle = __tkl_thread_get_psram_handle(thread);
-    THREAD_HANDLE_T *handle = (THREAD_HANDLE_T *)thread;
+    RAM_THREAD_HANDLE_T *handle = (RAM_THREAD_HANDLE_T *)thread;
 
     if (psram_handle != NULL) {
         vTaskDelete(psram_handle->task);
@@ -226,13 +192,13 @@ OPERATE_RET tkl_thread_get_watermark(const TKL_THREAD_HANDLE thread, uint32_t* w
 OPERATE_RET tkl_thread_get_id(TKL_THREAD_HANDLE *thread)
 {
     // --- BEGIN: user implements ---
-    THREAD_HANDLE_T *handle = NULL;
+    RAM_THREAD_HANDLE_T *handle = NULL;
 
     if (thread == NULL) {
         return OPRT_INVALID_PARM;
     }
 
-    handle = (THREAD_HANDLE_T *)malloc(sizeof(THREAD_HANDLE_T));
+    handle = (RAM_THREAD_HANDLE_T *)malloc(sizeof(RAM_THREAD_HANDLE_T));
     if (handle == NULL) {
         return OPRT_MALLOC_FAILED;
     }
@@ -400,7 +366,6 @@ OPERATE_RET tkl_thread_create_in_psram(TKL_THREAD_HANDLE* thread,
     uint32_t adjusted_stack_size = __tkl_thread_adjust_stack_size(stack_size);
     uint32_t stack_depth = adjusted_stack_size / sizeof(StackType_t);
     PSRAM_THREAD_HANDLE_T *handle = NULL;
-    THREAD_ENTRY_CTX_T *entry_ctx = NULL;
 
     if (stack_depth == 0) {
         return OPRT_INVALID_PARM;
@@ -411,48 +376,27 @@ OPERATE_RET tkl_thread_create_in_psram(TKL_THREAD_HANDLE* thread,
         return OPRT_MALLOC_FAILED;
     }
 
-    entry_ctx = (THREAD_ENTRY_CTX_T *)malloc(sizeof(THREAD_ENTRY_CTX_T));
-    if (entry_ctx == NULL) {
-        free(handle);
-        return OPRT_MALLOC_FAILED;
-    }
-
-    entry_ctx->entry = func;
-    entry_ctx->arg = arg;
-
     handle->stack_buffer = (StackType_t *)heap_caps_malloc(stack_depth * sizeof(StackType_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
     if (handle->stack_buffer == NULL) {
-        free(entry_ctx);
         free(handle);
         return OPRT_MALLOC_FAILED;
     }
 
     handle->task_buffer = (StaticTask_t *)malloc(sizeof(StaticTask_t));
     if (handle->task_buffer == NULL) {
         free(handle->stack_buffer);
-        free(entry_ctx);
         free(handle);
         return OPRT_MALLOC_FAILED;
     }
 
-    handle->task = xTaskCreateStatic(__tkl_thread_entry, name, stack_depth, (void *const)entry_ctx, priority, handle->stack_buffer,
+    handle->task = xTaskCreateStatic(func, name, stack_depth, arg, priority, handle->stack_buffer,
                                      handle->task_buffer);
     if (handle->task == NULL) {
         free(handle->task_buffer);
         free(handle->stack_buffer);
-        free(entry_ctx);
         free(handle);
         return OPRT_OS_ADAPTER_THRD_CREAT_FAILED;
     }
-    printf("create in psram success\n");
-    printf("handle->task: %p\n", handle->task);
-    printf("handle->stack_buffer: %p\n", handle->stack_buffer);
-    printf("handle->task_buffer: %p\n", handle->task_buffer);
-    printf("entry_ctx: %p\n", entry_ctx);
-    printf("handle: %p\n", handle);
-    printf("name: %s\n", name);
-    printf("stack_size: %lu\n", stack_size);
-    printf("priority: %lu\n", priority);
 
     handle->magic = PSRAM_THREAD_MAGIC;
     *thread = (TKL_THREAD_HANDLE)handle;