alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Merge branch 'bugfix/remove_task_for_ot_tasklet' into 'master'

Browse Source 
fix(openthread): remove the empty task for openthread tasklets

Closes TZ-902

See merge request espressif/esp-idf!31176
This commit is contained in:
Shu Chen 2024-06-05 09:47:51 +08:00
commit d051410609
8 changed files with 65 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.codespellrc
View File

@ -1,4 +1,4 @@
[codespell]
skip = build,*.yuv,components/fatfs/src/*,alice.txt,*.rgb,components/wpa_supplicant/*,components/esp_wifi/*
ignore-words-list = ser,dout,rsource,fram,inout,shs,ans,aci,unstall,unstalling,hart,wheight,wel
ignore-words-list = ser,dout,rsource,fram,inout,shs,ans,aci,unstall,unstalling,hart,wheight,wel,ot
write-changes = true

14
components/openthread/src/esp_openthread.cpp
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -129,7 +129,7 @@ esp_err_t esp_openthread_auto_start(otOperationalDatasetTlvs *datasetTlvs)
memcpy(dataset.mMeshLocalPrefix.m8, prefix.mPrefix.mFields.m8, sizeof(dataset.mMeshLocalPrefix.m8));
dataset.mComponents.mIsMeshLocalPrefixPresent = true;
} else {
ESP_LOGE("Falied to parse mesh local prefix", CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX);
ESP_LOGE("Failed to parse mesh local prefix", CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX);
}
// Network Key
@ -213,13 +213,3 @@ esp_err_t esp_openthread_deinit(void)
otInstanceFinalize(esp_openthread_get_instance());
return esp_openthread_platform_deinit();
}
static void stub_task(void *context)
{
// this is a empty function used for ot-task signal pending
}
void otTaskletsSignalPending(otInstance *aInstance)
{
esp_openthread_task_queue_post(stub_task, NULL);
}

5
components/openthread/src/esp_openthread_platform.cpp
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -34,7 +34,7 @@ static esp_openthread_platform_workflow_t *s_workflow_list = NULL;
esp_err_t esp_openthread_platform_workflow_register(esp_openthread_update_func update_func,
esp_openthread_process_func process_func, const char *name)
{
uint8_t name_len = strnlen(name, WORKFLOW_MAX_NAMELEN);
uint8_t name_len = strnlen(name, WORKFLOW_MAX_NAMELEN - 1);
esp_openthread_platform_workflow_t *current_workflow = s_workflow_list;
esp_openthread_platform_workflow_t *before_workflow = NULL;
esp_openthread_platform_workflow_t *add_workflow =
@ -42,6 +42,7 @@ esp_err_t esp_openthread_platform_workflow_register(esp_openthread_update_func u
ESP_RETURN_ON_FALSE(add_workflow != NULL, ESP_ERR_NO_MEM, OT_PLAT_LOG_TAG,
"Failed to alloc memory for esp_openthread_workflow");
strncpy(add_workflow->name, name, name_len);
add_workflow->name[name_len] = '\0';
add_workflow->update_func = update_func;
add_workflow->process_func = process_func;
add_workflow->next = NULL;

11
components/openthread/src/esp_openthread_task_queue.c
View File

@ -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
*/
@ -15,6 +15,7 @@
#include "freertos/FreeRTOS.h"
#include "freertos/portmacro.h"
#include "freertos/queue.h"
#include "openthread/tasklet.h"
static QueueHandle_t s_task_queue = NULL;
static int s_task_queue_event_fd = -1;
@ -37,6 +38,14 @@ esp_err_t esp_openthread_task_queue_init(const esp_openthread_platform_config_t
&esp_openthread_task_queue_process, task_queue_workflow);
}
void otTaskletsSignalPending(otInstance *aInstance)
{
uint64_t val = 1;
ssize_t ret;
ret = write(s_task_queue_event_fd, &val, sizeof(val));
assert(ret == sizeof(val));
}
esp_err_t IRAM_ATTR esp_openthread_task_queue_post(esp_openthread_task_t task, void *arg)
{
task_storage_t task_storage = {

90
components/openthread/src/port/esp_openthread_udp.c
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -20,6 +20,7 @@
#include "esp_openthread_task_queue.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "lwip/err.h"
#include "lwip/ip6.h"
#include "lwip/ip6_addr.h"
#include "lwip/ip_addr.h"
@ -40,24 +41,19 @@ typedef struct {
} udp_recv_task_t;
typedef struct {
TaskHandle_t source_task;
otUdpSocket *socket;
struct udp_pcb *pcb_ret;
} udp_new_task_t;
typedef struct {
TaskHandle_t source_task;
struct udp_pcb *pcb;
ip_addr_t addr;
uint16_t port;
err_t ret;
} udp_bind_connect_task_t;
typedef struct {
TaskHandle_t source_task;
struct udp_pcb *pcb;
uint8_t netif_index;
esp_err_t err;
} udp_bind_netif_task_t;
typedef struct {
@ -78,13 +74,6 @@ typedef struct {
ip6_addr_t addr;
} udp_multicast_join_leave_task_t;
static void wait_for_task_notification(void)
{
esp_openthread_task_switching_lock_release();
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
}
static ip_addr_t map_openthread_addr_to_lwip_addr(const otIp6Address *address)
{
ip_addr_t addr;
@ -185,23 +174,25 @@ static void handle_udp_recv(void *ctx, struct udp_pcb *pcb, struct pbuf *p, cons
}
}
static void udp_new_task(void *ctx)
static esp_err_t udp_new_task(void *ctx)
{
udp_new_task_t *task = (udp_new_task_t *)ctx;
task->pcb_ret = udp_new();
ESP_RETURN_ON_FALSE(task->pcb_ret != NULL, ESP_ERR_NO_MEM, OT_PLAT_LOG_TAG, "Failed to create a new UDP pcb");
udp_recv(task->pcb_ret, handle_udp_recv, task->socket);
xTaskNotifyGive(task->source_task);
return ESP_OK;
}
otError otPlatUdpSocket(otUdpSocket *udp_socket)
{
otError error = OT_ERROR_NONE;
esp_err_t err = ESP_OK;
udp_new_task_t task = { .source_task = xTaskGetCurrentTaskHandle(), .socket = udp_socket };
tcpip_callback(udp_new_task, &task);
wait_for_task_notification();
VerifyOrExit(task.pcb_ret != NULL, error = OT_ERROR_FAILED);
udp_new_task_t task = {.socket = udp_socket };
esp_openthread_task_switching_lock_release();
err = esp_netif_tcpip_exec(udp_new_task, &task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
VerifyOrExit(err == ESP_OK, error = OT_ERROR_FAILED);
udp_socket->mHandle = task.pcb_ret;
exit:
@ -220,24 +211,25 @@ otError otPlatUdpClose(otUdpSocket *udp_socket)
struct udp_pcb *pcb = (struct udp_pcb *)udp_socket->mHandle;
if (pcb) {
esp_openthread_task_switching_lock_release();
tcpip_callback(udp_close_task, pcb);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
}
return OT_ERROR_NONE;
}
static void udp_bind_task(void *ctx)
static esp_err_t udp_bind_task(void *ctx)
{
udp_bind_connect_task_t *task = (udp_bind_connect_task_t *)ctx;
task->ret = udp_bind(task->pcb, &task->addr, task->port);
xTaskNotifyGive(task->source_task);
err_t ret = udp_bind(task->pcb, &task->addr, task->port);
return (ret == ERR_OK) ? ESP_OK : ESP_FAIL;
}
otError otPlatUdpBind(otUdpSocket *udp_socket)
{
esp_err_t err = ESP_OK;
udp_bind_connect_task_t task = {
.source_task = xTaskGetCurrentTaskHandle(),
.pcb = (struct udp_pcb *)udp_socket->mHandle,
.port = udp_socket->mSockName.mPort,
};
@ -247,17 +239,18 @@ otError otPlatUdpBind(otUdpSocket *udp_socket)
task.addr.type = IPADDR_TYPE_ANY;
#endif
memcpy(ip_2_ip6(&task.addr)->addr, udp_socket->mSockName.mAddress.mFields.m8, sizeof(ip_2_ip6(&task.addr)->addr));
tcpip_callback(udp_bind_task, &task);
wait_for_task_notification();
esp_openthread_task_switching_lock_release();
err = esp_netif_tcpip_exec(udp_bind_task, &task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
return task.ret == ERR_OK ? OT_ERROR_NONE : OT_ERROR_FAILED;
return err == ESP_OK ? OT_ERROR_NONE : OT_ERROR_FAILED;
}
static void udp_bind_netif_task(void *ctx)
static esp_err_t udp_bind_netif_task(void *ctx)
{
udp_bind_netif_task_t *task = (udp_bind_netif_task_t *)ctx;
udp_bind_netif(task->pcb, netif_get_by_index(task->netif_index));
xTaskNotifyGive(task->source_task);
return ESP_OK;
}
static uint8_t get_netif_index(otNetifIdentifier netif_identifier)
@ -276,34 +269,30 @@ static uint8_t get_netif_index(otNetifIdentifier netif_identifier)
otError otPlatUdpBindToNetif(otUdpSocket *udp_socket, otNetifIdentifier netif_identifier)
{
otError err = OT_ERROR_NONE;
esp_err_t err = ESP_OK;
udp_bind_netif_task_t task = {
.source_task = xTaskGetCurrentTaskHandle(),
.pcb = (struct udp_pcb *)udp_socket->mHandle,
.netif_index = get_netif_index(netif_identifier),
.err = ESP_OK,
};
tcpip_callback(udp_bind_netif_task, &task);
wait_for_task_notification();
if (task.err != ESP_OK) {
err = OT_ERROR_FAILED;
}
return err;
esp_openthread_task_switching_lock_release();
err = esp_netif_tcpip_exec(udp_bind_netif_task, &task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
return err == ESP_OK ? OT_ERROR_NONE : OT_ERROR_FAILED;
}
static void udp_connect_task(void *ctx)
static esp_err_t udp_connect_task(void *ctx)
{
udp_bind_connect_task_t *task = (udp_bind_connect_task_t *)ctx;
task->ret = udp_connect(task->pcb, &task->addr, task->port);
xTaskNotifyGive(task->source_task);
err_t ret = udp_connect(task->pcb, &task->addr, task->port);
return (ret == ERR_OK) ? ESP_OK : ESP_FAIL;
}
otError otPlatUdpConnect(otUdpSocket *udp_socket)
{
esp_err_t err = ESP_OK;
udp_bind_connect_task_t task = {
.source_task = xTaskGetCurrentTaskHandle(),
.pcb = (struct udp_pcb *)udp_socket->mHandle,
.port = udp_socket->mPeerName.mPort,
};
@ -312,10 +301,11 @@ otError otPlatUdpConnect(otUdpSocket *udp_socket)
if (ip_addr_isany_val(task.addr) && task.port == 0) {
return OT_ERROR_NONE;
}
tcpip_callback(udp_connect_task, &task);
wait_for_task_notification();
esp_openthread_task_switching_lock_release();
err = esp_netif_tcpip_exec(udp_connect_task, &task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
return task.ret == ERR_OK ? OT_ERROR_NONE : OT_ERROR_FAILED;
return err == ESP_OK ? OT_ERROR_NONE : OT_ERROR_FAILED;
}
static bool is_link_local(const otIp6Address *address)
@ -419,7 +409,9 @@ otError otPlatUdpSend(otUdpSocket *udp_socket, otMessage *message, const otMessa
// If the destination address is a openthread mesh local address, set the netif OT.
task->netif_index = get_netif_index(OT_NETIF_THREAD);
}
esp_openthread_task_switching_lock_release();
tcpip_callback(udp_send_task, task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
exit:
return error;
@ -458,7 +450,9 @@ otError otPlatUdpJoinMulticastGroup(otUdpSocket *socket, otNetifIdentifier netif
task->netif_index = get_netif_index(netif_id);
task->addr.zone = task->netif_index;
memcpy(task->addr.addr, addr->mFields.m8, sizeof(task->addr.addr));
esp_openthread_task_switching_lock_release();
tcpip_callback(udp_multicast_join_leave_task, task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
exit:
return error;
@ -475,7 +469,9 @@ otError otPlatUdpLeaveMulticastGroup(otUdpSocket *socket, otNetifIdentifier neti
task->netif_index = get_netif_index(netif_id);
task->addr.zone = task->netif_index;
memcpy(task->addr.addr, addr->mFields.m8, sizeof(task->addr.addr));
esp_openthread_task_switching_lock_release();
tcpip_callback(udp_multicast_join_leave_task, task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
exit:
return error;

4
components/openthread/src/port/esp_spi_spinel_interface.cpp
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -266,8 +266,8 @@ otError SpiSpinelInterface::WaitForFrame(uint64_t timeout_us)
otError SpiSpinelInterface::HardwareReset(void)
{
if (mRcpFailureHandler) {
mRcpFailureHandler();
ConductSPITransaction(true, 0, 0); // clear
mRcpFailureHandler();
}
return OT_ERROR_NONE;
}

4
components/openthread/src/port/esp_uart_spinel_interface.cpp
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -295,8 +295,8 @@ esp_err_t UartSpinelInterface::TryRecoverUart(void)
otError UartSpinelInterface::HardwareReset(void)
{
if (mRcpFailureHandler) {
mRcpFailureHandler();
TryRecoverUart();
mRcpFailureHandler();
}
return OT_ERROR_NONE;
}

4
components/openthread/src/spinel/esp_radio_spinel_uart_interface.cpp
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -276,8 +276,8 @@ esp_err_t UartSpinelInterface::TryRecoverUart(void)
otError UartSpinelInterface::HardwareReset(void)
{
if (mRcpFailureHandler) {
mRcpFailureHandler();
TryRecoverUart();
mRcpFailureHandler();
}
return OT_ERROR_NONE;
}