Update the implementation of some APIs

Author: Jerry-ESP

config/esp32/components/chip/idf_component.yml

@@ -26,7 +26,7 @@ dependencies:
             - if: "target != esp32h2"
 
     espressif/esp_rcp_update:
-        version: "1.2.0"
+        version: "~1.3.0"
         rules:
             - if: "idf_version >=5.0"
 

examples/thread-br-app/esp32/README.md

@@ -11,12 +11,13 @@ guides to get started.
 
 ---
 
--   [OpenThread Border Router Board](#openthread-border-router-board)
--   [OpenThread RCP](#openthread-rcp)
--   [OpenThread CLI](#openthread-cli)
--   [Setup Thread Network](#setup-thread-network)
--   [Commissioning Thread End Devices](#commissioning-thread-end-devices)
--   [Generate OTA Firmware For BR](#generate-ota-firmware-for-br)
+- [Matter ESP32 Thread Border Router Example](#matter-esp32-thread-border-router-example)
+    - [OpenThread Border Router Board](#openthread-border-router-board)
+    - [OpenThread RCP](#openthread-rcp)
+    - [OpenThread CLI](#openthread-cli)
+    - [Setup Thread Network](#setup-thread-network)
+    - [Commissioning Thread End Devices](#commissioning-thread-end-devices)
+    - [Generate OTA Firmware For BR](#generate-ota-firmware-for-br)
 
 ---
 
@@ -96,12 +97,10 @@ the Thread network.
 
 ### Generate OTA Firmware For BR
 
-Can use this python
-[script](https://github.com/espressif/esp-thread-br/blob/main/components/esp_rcp_update/create_ota_image.py)
-to merge thread border router firmware and the RCP firmware
+After enable the option `CONFIG_CREATE_OTA_IMAGE_WITH_RCP_FW` in menuconfig, will generate
+OTA image with rcp firmware in build process, named `ota_with_rcp_image` in build folder.
 
+Then can add a Matter OTA header for the ota_with_rcp_image file.
 ```
-python create_ota_image.py --rcp-build-dir /path/to/rcp_image/dir --br-firmware /path/to/br_image --target-file ota_target_file.bin
-```
-
-Then can use the generated bin file to create a Matter OTA file normally.
+./ota_image_tool.py create -v 65521 -p 32768 --version 1 --version-str "v1.0" -da sha256 build/ota_with_rcp_image ota_with_rcp_image.ota
+```

examples/thread-br-app/esp32/partitions.csv

@@ -3,6 +3,6 @@
 nvs,      data, nvs,     ,        0xC000,
 otadata,  data, ota,     ,        0x2000,
 phy_init, data, phy,     ,        0x1000,
-ota_0,    app,  ota_0,   ,        1700k,
+ota_0,    app,  ota_0,   ,        1600k,
 ota_1,    app,  ota_1,   ,        1600k,
 rcp_fw,   data, spiffs,  ,        640k,

examples/thread-br-app/esp32/sdkconfig.defaults

@@ -29,9 +29,9 @@ CONFIG_BT_NIMBLE_ENABLE_CONN_REATTEMPT=n
 
 # Increase some stack size
 CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=7200
-CONFIG_ESP_MAIN_TASK_STACK_SIZE=10240
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=5120
 CONFIG_ESP_TIMER_TASK_STACK_SIZE=5120
-CONFIG_CHIP_TASK_STACK_SIZE=10240
+CONFIG_CHIP_TASK_STACK_SIZE=9216
 
 # USB console for Thread border board
 CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y
@@ -88,7 +88,7 @@ CONFIG_BT_NIMBLE_ROLE_OBSERVER=n
 
 CONFIG_EVENT_LOGGING_CRIT_BUFFER_SIZE=1024
 
-#CONFIG_LOG_DEFAULT_LEVEL_ERROR=y
+CONFIG_LOG_DEFAULT_LEVEL_ERROR=y
 
 CONFIG_COMPILER_OPTIMIZATION_SIZE=y
 CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y

src/platform/ESP32/OTAImageProcessorImpl.cpp

@@ -36,24 +36,13 @@
 #include <esp_delta_ota.h>
 #endif // CONFIG_ENABLE_DELTA_OTA
 
-#if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-#include "esp_br_firmware.h"
-#include "esp_check.h"
-#include "esp_rcp_update.h"
-#endif
-
 #define TAG "OTAImageProcessor"
 
 #ifdef CONFIG_ENABLE_DELTA_OTA
 #define PATCH_HEADER_SIZE 64
 #define DIGEST_SIZE 32
 #endif // CONFIG_ENABLE_DELTA_OTA
 
-#if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-#define MAX_WRITE_RETRY_COUNT 5
-#define OTA_MAX_WRITE_SIZE 16
-#endif // defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-
 using namespace chip::System;
 using namespace ::chip::DeviceLayer::Internal;
 
@@ -292,178 +281,33 @@ esp_err_t OTAImageProcessorImpl::DeltaOTAWriteCallback(const uint8_t * buf, size
 #endif // CONFIG_ENABLE_DELTA_OTA
 
 #if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-typedef enum rcpImageState
+esp_err_t OTAImageProcessorImpl::ProcessRcpImage(intptr_t context, const uint8_t * buffer, uint32_t bufLen)
 {
-    BR_OTA_INIT = 0,
-    RCP_DOWNLOAD,
-    BR_FW_DOWNLOAD,
-} RcpImageState_t;
+    esp_err_t err = ESP_OK;
+    auto * imageProcessor = reinterpret_cast<OTAImageProcessorImpl *>(context);
 
-static int WriteFileForLength(FILE * fp, const void * buf, size_t size)
-{
-    int retryCount       = 0;
-    int offset           = 0;
-    const uint8_t * data = (const uint8_t *) buf;
-    while (offset < size)
+    if (!imageProcessor->mRcpDone)
     {
-        int ret = fwrite(data + offset, 1, ((size - offset) < OTA_MAX_WRITE_SIZE ? (size - offset) : OTA_MAX_WRITE_SIZE), fp);
-        if (ret < 0)
-        {
-            return ret;
-        }
-        if (ret == 0)
-        {
-            retryCount++;
-        }
-        else
-        {
-            offset += ret;
-            retryCount = 0;
-        }
-
-        if (retryCount > MAX_WRITE_RETRY_COUNT)
-        {
-            return -1;
-        }
-    }
-    return size;
-}
-
-esp_err_t OTAImageProcessorImpl::ProcessRcpImage(esp_ota_handle_t handle, const uint8_t * buffer, uint32_t bufLengthen)
-{
-    static char rcpTargetPath[RCP_FILENAME_MAX_SIZE];
-    static RcpImageState_t state       = BR_OTA_INIT;
-    static const char * rcpFirmwareDir = esp_rcp_get_firmware_dir();
-    static int8_t rcpUpdateSeq         = esp_rcp_get_next_update_seq();
-    static uint32_t headerSize         = 0;
-    static uint32_t totalRevSize       = 0;
-    static uint32_t brFirmwareOffset   = 0;
-    static uint32_t brFirmwareSize     = 0;
-    static FILE * fp                   = NULL;
-
-    switch (state)
-    {
-    case BR_OTA_INIT: {
-        sprintf(rcpTargetPath, "%s_%d/" ESP_BR_RCP_IMAGE_FILENAME, rcpFirmwareDir, rcpUpdateSeq);
-        ESP_LOGI(TAG, "Downloading RCP target file %s", rcpTargetPath);
-
-        fp = fopen(rcpTargetPath, "w");
-        if (!fp)
-        {
-            ESP_LOGE(TAG, "Fail to open %s, will delete it", rcpTargetPath);
-            remove(rcpTargetPath);
-            return ESP_FAIL;
-        }
-
-        esp_br_subfile_info_t subFileInfo[7];
-        if (sizeof(subFileInfo) > bufLengthen)
-        {
-            ESP_LOGE(TAG, "Packet len is less than the RCP header len");
-            if (fp != NULL)
-            {
-                fclose(fp);
-            }
-            return ESP_FAIL;
-        }
-
-        memcpy((char *) subFileInfo, buffer, sizeof(subFileInfo));
-        for (int i = 0; i < 7; i++)
-        {
-            ESP_LOGD(TAG, "subFileInfo[%d].tag:0x%lx--offset:0x%lx---size:0x%lx\n", i, subFileInfo[i].tag, subFileInfo[i].offset,
-                     subFileInfo[i].size);
-            if (subFileInfo[i].tag == FILETAG_IMAGE_HEADER)
-            {
-                headerSize = subFileInfo[i].size;
-                ESP_LOGI(TAG, "RCP image header-----headerSize:%ld\n", headerSize);
-            }
-            else if (subFileInfo[i].tag == FILETAG_BR_FIRMWARE)
-            {
-                brFirmwareOffset = subFileInfo[i].offset;
-                brFirmwareSize   = subFileInfo[i].size;
-                ESP_LOGI(TAG, "Border Router image--offset:%ld--size:%ld\n", brFirmwareOffset, brFirmwareSize);
-            }
-        }
-
-        if ((headerSize != sizeof(subFileInfo)) || (brFirmwareOffset == 0) || (brFirmwareSize == 0))
-        {
-            ESP_LOGE(TAG, "RCP header error");
-            fclose(fp);
-            return ESP_FAIL;
-        }
+        size_t rcpOtaReceivedLen = 0;
+        err = esp_rcp_ota_receive(imageProcessor->mRcpOtaHandle, buffer, bufLen, &rcpOtaReceivedLen);
 
-        if (WriteFileForLength(fp, buffer, bufLengthen) != bufLengthen)
+        if (esp_rcp_ota_get_state(imageProcessor->mRcpOtaHandle) == ESP_RCP_OTA_STATE_FINISHED)
         {
-            ESP_LOGE(TAG, "Failed to write data");
-            fclose(fp);
-            return ESP_FAIL;
+            imageProcessor->mBrFirmwareSize = esp_rcp_ota_get_subfile_size(imageProcessor->mRcpOtaHandle, FILETAG_HOST_FIRMWARE);
+            err = esp_ota_write(imageProcessor->mOTAUpdateHandle, buffer + rcpOtaReceivedLen, bufLen - rcpOtaReceivedLen);
+            imageProcessor->mRcpDone = true;
         }
-
-        state        = RCP_DOWNLOAD;
-        totalRevSize = bufLengthen;
-        break;
-    }
-    case RCP_DOWNLOAD: {
-        if (totalRevSize + bufLengthen >= brFirmwareOffset)
-        {
-            uint32_t len = brFirmwareOffset - totalRevSize;
-            if (WriteFileForLength(fp, buffer, len) == len)
-            {
-                ESP_LOGI(TAG, "RCP receive done, total size %ld bytes", brFirmwareOffset);
-                state = BR_FW_DOWNLOAD;
-                fclose(fp);
-                if (esp_rcp_submit_new_image() != ESP_OK)
-                {
-                    ESP_LOGI(TAG, "Failed to submit RCP image");
-                    state = BR_OTA_INIT;
-                    return ESP_FAIL;
-                }
-            }
-            else
-            {
-                ESP_LOGE(TAG, "Failed to write data");
-                fclose(fp);
-                state = BR_OTA_INIT;
-                return ESP_FAIL;
-            }
-
-            if (esp_ota_write(handle, buffer + len, bufLengthen - len) != ESP_OK)
-            {
-                ESP_LOGE(TAG, "OTA write failed");
-                state = BR_OTA_INIT;
-                return ESP_FAIL;
-            }
-
-            totalRevSize = bufLengthen - len;
-        }
-        else
-        {
-            if (WriteFileForLength(fp, buffer, bufLengthen) != bufLengthen)
-            {
-                ESP_LOGE(TAG, "Failed to write data");
-                fclose(fp);
-                state = BR_OTA_INIT;
-                return ESP_FAIL;
-            }
-            totalRevSize += bufLengthen;
-        }
-        break;
-    }
-    case BR_FW_DOWNLOAD: {
-        if (esp_ota_write(handle, buffer, bufLengthen) != ESP_OK)
-        {
-            ESP_LOGE(TAG, "OTA write failed");
-            state = BR_OTA_INIT;
-            return ESP_FAIL;
-            ESP_LOGI(TAG, "Thread BR image receive done");
-        }
-        break;
     }
-    default: {
-        return ESP_FAIL;
+    else if (imageProcessor->mBrFirmwareSize > 0)
+    {
+        err = esp_ota_write(imageProcessor->mOTAUpdateHandle, buffer, bufLen);
     }
+    else
+    {
+        err = ESP_FAIL;
     }
 
-    return ESP_OK;
+    return err;
 }
 #endif
 
@@ -524,6 +368,16 @@ void OTAImageProcessorImpl::HandlePrepareDownload(intptr_t context)
     }
 #endif // CONFIG_ENABLE_ENCRYPTED_OTA
 
+#if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
+    imageProcessor->mRcpOtaHandle = 0;
+    imageProcessor->mBrFirmwareSize = 0;
+    imageProcessor->mRcpDone = false;
+    if (esp_rcp_ota_begin(&imageProcessor->mRcpOtaHandle) != ESP_OK)
+    {
+        return;
+    }
+#endif
+
     imageProcessor->mHeaderParser.Init();
     imageProcessor->mDownloader->OnPreparedForDownload(CHIP_NO_ERROR);
     PostOTAStateChangeEvent(DeviceLayer::kOtaDownloadInProgress);
@@ -567,6 +421,12 @@ void OTAImageProcessorImpl::HandleFinalize(intptr_t context)
 
     err = esp_ota_end(imageProcessor->mOTAUpdateHandle);
     DeltaOTACleanUp(reinterpret_cast<intptr_t>(imageProcessor));
+#elif defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
+    esp_err_t err = esp_rcp_ota_end(imageProcessor->mRcpOtaHandle);
+    err |= esp_ota_end(imageProcessor->mOTAUpdateHandle);
+    imageProcessor->mRcpOtaHandle = 0;
+    imageProcessor->mBrFirmwareSize = 0;
+    imageProcessor->mRcpDone = false;
 #else
     esp_err_t err = esp_ota_end(imageProcessor->mOTAUpdateHandle);
 #endif // CONFIG_ENABLE_DELTA_OTA
@@ -608,6 +468,16 @@ void OTAImageProcessorImpl::HandleAbort(intptr_t context)
     DeltaOTACleanUp(reinterpret_cast<intptr_t>(imageProcessor));
 #endif // CONFIG_ENABLE_DELTA_OTA
 
+#if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
+    if (esp_rcp_ota_abort(imageProcessor->mRcpOtaHandle) != ESP_OK)
+    {
+        ESP_LOGE(TAG, "ESP RCP OTA abort failed");
+    }
+    imageProcessor->mRcpOtaHandle = 0;
+    imageProcessor->mBrFirmwareSize = 0;
+    imageProcessor->mRcpDone = false;
+#endif
+
     if (esp_ota_abort(imageProcessor->mOTAUpdateHandle) != ESP_OK)
     {
         ESP_LOGE(TAG, "ESP OTA abort failed");
@@ -671,7 +541,7 @@ void OTAImageProcessorImpl::HandleProcessBlock(intptr_t context)
     // Apply the patch and writes that data to the passive partition.
     err = esp_delta_ota_feed_patch(imageProcessor->mDeltaOTAUpdateHandle, blockToWrite.data() + index, blockToWrite.size() - index);
 #elif defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-    err           = imageProcessor->ProcessRcpImage(imageProcessor->mOTAUpdateHandle, blockToWrite.data(), blockToWrite.size());
+    err           = imageProcessor->ProcessRcpImage(context, blockToWrite.data(), blockToWrite.size());
 #else
     err = esp_ota_write(imageProcessor->mOTAUpdateHandle, blockToWrite.data(), blockToWrite.size());
 #endif // CONFIG_ENABLE_DELTA_OTA

src/platform/ESP32/OTAImageProcessorImpl.h

@@ -33,6 +33,12 @@
 #define IMG_HEADER_LEN sizeof(esp_image_header_t)
 #endif // CONFIG_ENABLE_DELTA_OTA
 
+#if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
+#include "esp_check.h"
+#include "esp_rcp_update.h"
+#include "esp_rcp_ota.h"
+#endif
+
 namespace chip {
 
 class OTAImageProcessorImpl : public OTAImageProcessorInterface
@@ -101,7 +107,10 @@ class OTAImageProcessorImpl : public OTAImageProcessorInterface
 #endif // CONFIG_ENABLE_ENCRYPTED_OTA
 
 #if defined(CONFIG_AUTO_UPDATE_RCP) && defined(CONFIG_OPENTHREAD_BORDER_ROUTER)
-    esp_err_t ProcessRcpImage(esp_ota_handle_t handle, const uint8_t * buffer, uint32_t bufLengthen);
+    esp_rcp_ota_handle_t mRcpOtaHandle;
+    bool mRcpDone;
+    uint32_t mBrFirmwareSize;
+    esp_err_t ProcessRcpImage(intptr_t context, const uint8_t * buffer, uint32_t bufLen);
 #endif
 };
 

src/platform/ESP32/OpenthreadLauncher.cpp

@@ -156,7 +156,9 @@ static void update_rcp(void)
 {
     // Deinit uart to transfer UART to the serial loader
     esp_openthread_rcp_deinit();
-    if (esp_rcp_update() == ESP_OK)
+
+    esp_err_t err = esp_rcp_update();
+    if (err == ESP_OK)
     {
         esp_rcp_mark_image_verified(true);
     }