From aff23f32e4715fa4123b540fbed81884af231ab8 Mon Sep 17 00:00:00 2001 From: Xu Si Yu Date: Tue, 29 Oct 2024 11:56:16 +0800 Subject: [PATCH 1/3] feat(openthread): update openthread submodule and border router lib --- .../include/esp_openthread_border_router.h | 10 +++++ .../openthread/include/esp_openthread_types.h | 2 + .../openthread/include/esp_radio_spinel.h | 11 ++++++ .../include/esp_radio_spinel_platform.h | 28 ++++++++++++++ components/openthread/lib | 2 +- components/openthread/openthread | 2 +- .../openthread-core-esp32x-ftd-config.h | 10 +++++ .../openthread-core-esp32x-spinel-config.h | 21 +++++++++- components/openthread/sbom_openthread.yml | 2 +- .../src/esp_openthread_netif_glue.c | 15 ++++++++ .../src/port/esp_openthread_radio_spinel.cpp | 27 +++++++++++-- .../src/spinel/esp_radio_spinel.cpp | 38 ++++++++++++++++++- examples/openthread/ot_ci_function.py | 3 +- 13 files changed, 159 insertions(+), 12 deletions(-) create mode 100644 components/openthread/include/esp_radio_spinel_platform.h diff --git a/components/openthread/include/esp_openthread_border_router.h b/components/openthread/include/esp_openthread_border_router.h index de4b8ee6048..8960fc861d5 100644 --- a/components/openthread/include/esp_openthread_border_router.h +++ b/components/openthread/include/esp_openthread_border_router.h @@ -66,6 +66,16 @@ esp_netif_t *esp_openthread_get_backbone_netif(void); */ void esp_openthread_register_rcp_failure_handler(esp_openthread_rcp_failure_handler handler); +/** + * @brief Registers the callback for spinel compatibility error. + * + * @note This function must be called before esp_openthread_init. + * + * @param[in] callback The callback. + * + */ +void esp_openthread_set_compatibility_error_callback(esp_openthread_compatibility_error_callback callback); + /** * @brief Deinitializes the connection to RCP. * diff --git a/components/openthread/include/esp_openthread_types.h b/components/openthread/include/esp_openthread_types.h index debc464066d..ce1d258a3dc 100644 --- a/components/openthread/include/esp_openthread_types.h +++ b/components/openthread/include/esp_openthread_types.h @@ -200,6 +200,8 @@ typedef struct { typedef void (*esp_openthread_rcp_failure_handler)(void); +typedef void (*esp_openthread_compatibility_error_callback)(void); + #ifdef __cplusplus } #endif diff --git a/components/openthread/include/esp_radio_spinel.h b/components/openthread/include/esp_radio_spinel.h index 24c5f1a6299..710d61d6465 100644 --- a/components/openthread/include/esp_radio_spinel.h +++ b/components/openthread/include/esp_radio_spinel.h @@ -46,6 +46,7 @@ typedef struct { typedef void (*esp_radio_spinel_rcp_failure_handler)(void); /* The handler for rcp failure.*/ typedef esp_err_t (*esp_radio_spinel_uart_init_handler)(const esp_radio_spinel_uart_config_t *uart_config_t, int *uart_fd); /* The handler for UART initialization.*/ typedef esp_err_t (*esp_radio_spinel_uart_deinit_handler)(const esp_radio_spinel_uart_config_t *uart_config_t, int *uart_fd); /* The handler for UART deinitialization.*/ +typedef void (*esp_radio_spinel_compatibility_error_callback)(void); typedef struct { @@ -391,6 +392,16 @@ esp_err_t esp_radio_spinel_rcp_deinit(esp_radio_spinel_idx_t idx); */ esp_err_t esp_radio_spinel_rcp_version_get(char *running_rcp_version, esp_radio_spinel_idx_t idx); +/** + * @brief Registers the callback for spinel compatibility error. + * + * @note This function must be called before esp_radio_spinel_init. + * + * @param[in] callback The callback. + * + */ +void esp_radio_spinel_set_compatibility_error_callback(esp_radio_spinel_compatibility_error_callback callback); + #ifdef __cplusplus } #endif diff --git a/components/openthread/include/esp_radio_spinel_platform.h b/components/openthread/include/esp_radio_spinel_platform.h new file mode 100644 index 00000000000..d6ce8717161 --- /dev/null +++ b/components/openthread/include/esp_radio_spinel_platform.h @@ -0,0 +1,28 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include "sdkconfig.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Get frame counter. + * + * @param[in] idx The index of 802.15.4 related protocol stack. + * + * @return + * - The frame counter + * + */ +uint32_t esp_radio_spinel_extern_get_frame_counter(esp_radio_spinel_idx_t idx); + +#ifdef __cplusplus +} +#endif diff --git a/components/openthread/lib b/components/openthread/lib index 203c78501e9..55f18e4cc6a 160000 --- a/components/openthread/lib +++ b/components/openthread/lib @@ -1 +1 @@ -Subproject commit 203c78501e9a6ea9ca3a929e6f9b6b9691ef16ee +Subproject commit 55f18e4cc6a249974247fd408aad79b1049d4b31 diff --git a/components/openthread/openthread b/components/openthread/openthread index f32c18bc084..005c5cefc22 160000 --- a/components/openthread/openthread +++ b/components/openthread/openthread @@ -1 +1 @@ -Subproject commit f32c18bc0840f400182456e58ae3900fc2fb4af7 +Subproject commit 005c5cefc22aaf0396e4327ee7f2e0ad32a7733b diff --git a/components/openthread/private_include/openthread-core-esp32x-ftd-config.h b/components/openthread/private_include/openthread-core-esp32x-ftd-config.h index ec948015059..42ea9d9546c 100644 --- a/components/openthread/private_include/openthread-core-esp32x-ftd-config.h +++ b/components/openthread/private_include/openthread-core-esp32x-ftd-config.h @@ -261,6 +261,16 @@ #define OPENTHREAD_POSIX_CONFIG_RCP_TIME_SYNC_INTERVAL (60 * 1000 * 1000) #endif +/** + * @def OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE + * + * Enables compatibility error callback in Spinel + */ +#ifndef OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE +#define OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE 1 +#endif + + #endif /** diff --git a/components/openthread/private_include/openthread-core-esp32x-spinel-config.h b/components/openthread/private_include/openthread-core-esp32x-spinel-config.h index 3c9def78404..0b257baebae 100644 --- a/components/openthread/private_include/openthread-core-esp32x-spinel-config.h +++ b/components/openthread/private_include/openthread-core-esp32x-spinel-config.h @@ -41,7 +41,6 @@ * */ #ifndef OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT -// TZ-567: Set OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT to 3 after adding rcp failure notification mechanism #define OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT 3 #endif @@ -77,3 +76,23 @@ #ifndef OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_DIRECT #define OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_DIRECT CONFIG_OPENTHREAD_MAC_MAX_CSMA_BACKOFFS_DIRECT #endif + + +/** + * @def OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE + * + * Enables compatibility error callback in Spinel + */ +#ifndef OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE +#define OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE 1 +#endif + +/** + * @def OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES + * + * Defines size of the local source match table used by RadioSpinel + * when OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT is used. + */ +#ifndef OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES +#define OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES 12 +#endif diff --git a/components/openthread/sbom_openthread.yml b/components/openthread/sbom_openthread.yml index 7738bbe0a2e..b227b42db85 100644 --- a/components/openthread/sbom_openthread.yml +++ b/components/openthread/sbom_openthread.yml @@ -5,4 +5,4 @@ supplier: 'Organization: Espressif Systems (Shanghai) CO LTD' originator: 'Organization: Google LLC' description: OpenThread released by Google is an open-source implementation of the Thread networking url: https://github.com/espressif/openthread -hash: f32c18bc0840f400182456e58ae3900fc2fb4af7 +hash: 005c5cefc22aaf0396e4327ee7f2e0ad32a7733b diff --git a/components/openthread/src/esp_openthread_netif_glue.c b/components/openthread/src/esp_openthread_netif_glue.c index e7184698682..dd623aa5f78 100644 --- a/components/openthread/src/esp_openthread_netif_glue.c +++ b/components/openthread/src/esp_openthread_netif_glue.c @@ -16,6 +16,7 @@ #include "esp_log.h" #include "esp_netif.h" #include "esp_openthread.h" +#include "esp_openthread_border_router.h" #include "esp_openthread_common_macro.h" #include "esp_openthread_lock.h" #include "esp_openthread_netif_glue_priv.h" @@ -33,6 +34,7 @@ #include "openthread/ip6.h" #include "openthread/link.h" #include "openthread/message.h" +#include "openthread/platform/infra_if.h" #include "openthread/thread.h" typedef struct { @@ -381,3 +383,16 @@ esp_netif_t *esp_openthread_get_netif(void) { return s_openthread_netif; } + +otError otPlatGetInfraIfLinkLayerAddress(otInstance *aInstance, uint32_t aIfIndex, otPlatInfraIfLinkLayerAddress *aInfraIfLinkLayerAddress) +{ + esp_netif_t *backbone_netif = esp_openthread_get_backbone_netif(); + if (esp_netif_get_netif_impl_index(backbone_netif) != aIfIndex) { + ESP_LOGE(OT_PLAT_LOG_TAG, "Failed to get LL address, error: Invalid If index"); + return OT_ERROR_FAILED; + } else { + esp_netif_get_mac(backbone_netif, aInfraIfLinkLayerAddress->mAddress); + aInfraIfLinkLayerAddress->mLength = 6; + return OT_ERROR_NONE; + } +} diff --git a/components/openthread/src/port/esp_openthread_radio_spinel.cpp b/components/openthread/src/port/esp_openthread_radio_spinel.cpp index b851c5608b5..67cb2bb66ae 100644 --- a/components/openthread/src/port/esp_openthread_radio_spinel.cpp +++ b/components/openthread/src/port/esp_openthread_radio_spinel.cpp @@ -54,6 +54,8 @@ static const char *radiospinel_workflow = "radio_spinel"; static const esp_openthread_radio_config_t *s_esp_openthread_radio_config = NULL; +static esp_openthread_compatibility_error_callback s_compatibility_error_callback = NULL; + static void esp_openthread_radio_config_set(const esp_openthread_radio_config_t *config) { s_esp_openthread_radio_config = config; @@ -64,6 +66,22 @@ static const esp_openthread_radio_config_t *esp_openthread_radio_config_get(void return s_esp_openthread_radio_config; } +static void ot_spinel_compatibility_error_callback(void *context) +{ + OT_UNUSED_VARIABLE(context); + if (s_compatibility_error_callback) { + s_compatibility_error_callback(); + } else { + ESP_LOGE(OT_PLAT_LOG_TAG, "None callback to handle compatibility error of openthread spinel"); + assert(false); + } +} + +void esp_openthread_set_compatibility_error_callback(esp_openthread_compatibility_error_callback callback) +{ + s_compatibility_error_callback = callback; +} + esp_err_t esp_openthread_radio_init(const esp_openthread_platform_config_t *config) { spinel_iid_t iidList[ot::Spinel::kSpinelHeaderMaxNumIid]; @@ -89,7 +107,8 @@ esp_err_t esp_openthread_radio_init(const esp_openthread_platform_config_t *conf "Spinel interface init failed"); #endif s_spinel_driver.Init(s_spinel_interface.GetSpinelInterface(), true, iidList, ot::Spinel::kSpinelHeaderMaxNumIid); - s_radio.Init(/*skip_rcp_compatibility_check=*/false, /*reset_radio=*/true, &s_spinel_driver, s_radio_caps); + s_radio.SetCompatibilityErrorCallback(ot_spinel_compatibility_error_callback, esp_openthread_get_instance()); + s_radio.Init(/*skip_rcp_compatibility_check=*/false, /*reset_radio=*/true, &s_spinel_driver, s_radio_caps, /*RCP_time_sync=*/true); #if CONFIG_OPENTHREAD_RADIO_SPINEL_SPI // CONFIG_OPENTHREAD_RADIO_SPINEL_SPI ESP_RETURN_ON_ERROR(s_spinel_interface.GetSpinelInterface().AfterRadioInit(), OT_PLAT_LOG_TAG, "Spinel interface init failed"); #endif @@ -336,15 +355,15 @@ void otPlatRadioSetMacFrameCounter(otInstance *aInstance, uint32_t aMacFrameCoun } #if CONFIG_OPENTHREAD_DIAG -otError otPlatDiagProcess(otInstance *instance, int argc, char *argv[], char *output, size_t output_max_len) +otError otPlatDiagProcess(otInstance *aInstance, uint8_t aArgsLength, char *aArgs[]) { // deliver the platform specific diags commands to radio only ncp. char cmd[OPENTHREAD_CONFIG_DIAG_CMD_LINE_BUFFER_SIZE] = {'\0'}; char *cur = cmd; char *end = cmd + sizeof(cmd); - for (int index = 0; index < argc; index++) { - cur += snprintf(cur, static_cast(end - cur), "%s ", argv[index]); + for (int index = 0; index < aArgsLength; index++) { + cur += snprintf(cur, static_cast(end - cur), "%s ", aArgs[index]); } return s_radio.PlatDiagProcess(cmd); diff --git a/components/openthread/src/spinel/esp_radio_spinel.cpp b/components/openthread/src/spinel/esp_radio_spinel.cpp index fbf794046df..79ae1efbe77 100644 --- a/components/openthread/src/spinel/esp_radio_spinel.cpp +++ b/components/openthread/src/spinel/esp_radio_spinel.cpp @@ -10,9 +10,11 @@ #include "platform/exit_code.h" #include "radio_spinel.hpp" #include "esp_radio_spinel.h" +#include "esp_radio_spinel_platform.h" #include "esp_radio_spinel_adapter.hpp" #include "esp_radio_spinel_uart_interface.hpp" #include "spinel_driver.hpp" +#include "openthread/link.h" #define SPINEL_VENDOR_PROPERTY_BIT_PENDINGMODE BIT(0) #define SPINEL_VENDOR_PROPERTY_BIT_COORDINATOR BIT(1) @@ -39,6 +41,8 @@ static otRadioCaps s_radio_caps = (OT_RADIO_CAPS_ENERGY_SCAN | OT_RADIO_CAPS_ACK_TIMEOUT | OT_RADIO_CAPS_SLEEP_TO_TX); +static esp_radio_spinel_compatibility_error_callback s_radio_spinel_compatibility_error_callback = NULL; + static esp_radio_spinel_idx_t get_index_from_instance(otInstance *instance) { // TZ-563: Implement the function to get the esp radio spinel idx from otInstance for multipan rcp @@ -67,6 +71,22 @@ static void esp_radio_spinel_restore_vendor_properities(void *context) } } +static void radio_spinel_compatibility_error_callback(void *context) +{ + OT_UNUSED_VARIABLE(context); + if (s_radio_spinel_compatibility_error_callback) { + s_radio_spinel_compatibility_error_callback(); + } else { + ESP_LOGE(ESP_SPINEL_LOG_TAG, "None callback to handle compatibility error of openthread spinel"); + assert(false); + } +} + +void esp_openthread_set_compatibility_error_callback(esp_radio_spinel_compatibility_error_callback callback) +{ + s_radio_spinel_compatibility_error_callback = callback; +} + void ReceiveDone(otInstance *aInstance, otRadioFrame *aFrame, otError aError) { esp_radio_spinel_idx_t idx = get_index_from_instance(aInstance); @@ -242,12 +262,13 @@ esp_err_t esp_radio_spinel_uart_interface_enable(const esp_radio_spinel_uart_con void esp_radio_spinel_init(esp_radio_spinel_idx_t idx) { spinel_iid_t iidList[ot::Spinel::kSpinelHeaderMaxNumIid]; + otInstance *instance = get_instance_from_index(idx); // Multipan is not currently supported iidList[0] = 0; s_spinel_driver[idx].Init(s_spinel_interface[idx].GetSpinelInterface(), true, iidList, ot::Spinel::kSpinelHeaderMaxNumIid); - s_radio[idx].Init(/*skip_rcp_compatibility_check=*/false, /*reset_radio=*/true, &s_spinel_driver[idx], s_radio_caps); - otInstance *instance = get_instance_from_index(idx); + s_radio[idx].SetCompatibilityErrorCallback(radio_spinel_compatibility_error_callback, instance); + s_radio[idx].Init(/*skip_rcp_compatibility_check=*/false, /*reset_radio=*/true, &s_spinel_driver[idx], s_radio_caps, false); s_radio[idx].SetVendorRestorePropertiesCallback(esp_radio_spinel_restore_vendor_properities, instance); } @@ -405,6 +426,19 @@ esp_err_t esp_radio_spinel_set_rcp_ready(esp_radio_spinel_idx_t idx) return ESP_OK; } +// TZ-1261 +uint32_t otLinkGetFrameCounter(otInstance *aInstance) +{ + esp_radio_spinel_idx_t idx = get_index_from_instance(aInstance); + return esp_radio_spinel_extern_get_frame_counter(idx); +} + +__attribute__((weak)) uint32_t esp_radio_spinel_extern_get_frame_counter(esp_radio_spinel_idx_t idx) +{ + ESP_LOGW(ESP_SPINEL_LOG_TAG, "None function to get frame counter"); + return 0; +} + namespace ot { namespace Spinel { diff --git a/examples/openthread/ot_ci_function.py b/examples/openthread/ot_ci_function.py index 3561f4ad1d9..4793b7cb7d9 100644 --- a/examples/openthread/ot_ci_function.py +++ b/examples/openthread/ot_ci_function.py @@ -2,7 +2,6 @@ # SPDX-License-Identifier: Unlicense OR CC0-1.0 # !/usr/bin/env python3 # this file defines some functions for testing cli and br under pytest framework - import re import socket import struct @@ -145,7 +144,7 @@ def changeDeviceRole(dut:IdfDut, role:str) -> None: def getDataset(dut:IdfDut) -> str: clean_buffer(dut) execute_command(dut, 'dataset active -x') - dut_data = dut.expect(r'\n(\w{212})\r', timeout=5)[1].decode() + dut_data = dut.expect(r'\n(\w+)\r', timeout=5)[1].decode() return str(dut_data) From bb24084db4809fb26f6af1e4a48ebb48bb292741 Mon Sep 17 00:00:00 2001 From: Simon Dean Date: Sat, 5 Oct 2024 21:15:58 +0100 Subject: [PATCH 2/3] enable openthread coap client for mtd --- .../openthread-core-esp32x-mtd-config.h | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/components/openthread/private_include/openthread-core-esp32x-mtd-config.h b/components/openthread/private_include/openthread-core-esp32x-mtd-config.h index f21c9ce01ea..dd247037d74 100644 --- a/components/openthread/private_include/openthread-core-esp32x-mtd-config.h +++ b/components/openthread/private_include/openthread-core-esp32x-mtd-config.h @@ -73,6 +73,24 @@ */ #define OPENTHREAD_CONFIG_NUM_MESSAGE_BUFFERS CONFIG_OPENTHREAD_NUM_MESSAGE_BUFFERS +/** + * @def OPENTHREAD_CONFIG_COAP_API_ENABLE + * + * Define to 1 to enable the CoAP API. + * + */ +#define OPENTHREAD_CONFIG_COAP_API_ENABLE 1 + +/** + * @def OPENTHREAD_CONFIG_PLATFORM_NETIF_ENABLE + * + * Define to 1 to enable platform NETIF support. + * + */ +#ifndef OPENTHREAD_CONFIG_PLATFORM_NETIF_ENABLE +#define OPENTHREAD_CONFIG_PLATFORM_NETIF_ENABLE 1 +#endif + /** * @def OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE * From 98bd2ef93c24efecf6e30524fa9a5d9ce8b99ae8 Mon Sep 17 00:00:00 2001 From: zwx Date: Mon, 9 Sep 2024 20:38:29 +0800 Subject: [PATCH 3/3] feat(openthread): support alloc nat64 session from psram --- components/openthread/Kconfig | 18 +++++++++++----- .../private_include/esp_openthread_common.hpp | 21 +++++++++++++++++++ .../private_include/esp_openthread_platform.h | 13 ++++++++++-- .../src/esp_openthread_platform.cpp | 10 +++++++++ 4 files changed, 55 insertions(+), 7 deletions(-) create mode 100644 components/openthread/private_include/esp_openthread_common.hpp diff --git a/components/openthread/Kconfig b/components/openthread/Kconfig index d344f596152..a739f701635 100644 --- a/components/openthread/Kconfig +++ b/components/openthread/Kconfig @@ -278,12 +278,20 @@ menu "OpenThread" help Select this option to enable border router features in OpenThread. - config OPENTHREAD_PLATFORM_MSGPOOL_MANAGEMENT - bool 'Allocate message pool buffer from PSRAM' + menu "Thread Memory Allocation Config" depends on OPENTHREAD_ENABLED && (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) - default n - help - If enabled, the message pool is managed by platform defined logic. + config OPENTHREAD_MEM_ALLOC_EXTERNAL + bool 'Allocate memory from PSRAM' + default y + help + Select this option to allocate buffer from PSRAM for Thread + + config OPENTHREAD_PLATFORM_MSGPOOL_MANAGEMENT + bool 'Allocate message pool buffer from PSRAM' + default n + help + If enabled, the message pool is managed by platform defined logic. + endmenu config OPENTHREAD_NUM_MESSAGE_BUFFERS int "The number of openthread message buffers" diff --git a/components/openthread/private_include/esp_openthread_common.hpp b/components/openthread/private_include/esp_openthread_common.hpp new file mode 100644 index 00000000000..c4dbf749ee8 --- /dev/null +++ b/components/openthread/private_include/esp_openthread_common.hpp @@ -0,0 +1,21 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include "esp_heap_caps.h" +#include +#include "common/new.hpp" + +template +inline T *New(uint32_t alloc_caps, Args &&...args) +{ + void *p = heap_caps_calloc(1, sizeof(T), alloc_caps); + if (p != nullptr) { + return new (p) T(std::forward(args)...); + } + return nullptr; +} diff --git a/components/openthread/private_include/esp_openthread_platform.h b/components/openthread/private_include/esp_openthread_platform.h index 6919e914be2..3999322a8d1 100644 --- a/components/openthread/private_include/esp_openthread_platform.h +++ b/components/openthread/private_include/esp_openthread_platform.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -84,7 +84,7 @@ void esp_openthread_platform_workflow_unregister(const char *name); * @brief Initializes the platform-specific support for the OpenThread stack. * * @note This function is not called by and will not call the OpenThread library. - * The user needs to call otInstanceInitSingle to intialize the OpenThread + * The user needs to call otInstanceInitSingle to initialize the OpenThread * stack after calling this function. * * @param[in] init_config The initialization configuration. @@ -146,6 +146,15 @@ esp_err_t esp_openthread_platform_process(otInstance *instance, const esp_openth * */ void esp_openthread_set_storage_name(const char *name); + +/** + * @brief Gets the caps of memory allocation. + * + * @return + * - The caps of the memory. + */ +uint32_t esp_openthread_get_alloc_caps(void); + #ifdef __cplusplus } // end of extern "C" #endif diff --git a/components/openthread/src/esp_openthread_platform.cpp b/components/openthread/src/esp_openthread_platform.cpp index 8beb8143dc4..51bfd779042 100644 --- a/components/openthread/src/esp_openthread_platform.cpp +++ b/components/openthread/src/esp_openthread_platform.cpp @@ -204,3 +204,13 @@ esp_err_t esp_openthread_platform_process(otInstance *instance, const esp_openth } return ESP_OK; } + +uint32_t esp_openthread_get_alloc_caps(void) +{ + return +#if CONFIG_OPENTHREAD_PLATFORM_MALLOC_CAP_SPIRAM + (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); +#else + (MALLOC_CAP_DEFAULT | MALLOC_CAP_8BIT); +#endif +}