Fork fix: the SDIO wedge is FIXED (esp-hosted-mcu #167)

Root cause (verified against our exact IDF tree, not the community guess):
the "258" in "sdio_write_task: Failed to send data: 258" is NOT a timeout
(that is 263). 258 = 0x102 = ESP_ERR_INVALID_ARG. On the ESP32-P4, block-
mode CMD53 writes require the SOURCE buffer to be 64-byte (cache-line)
aligned; the IDF sdmmc driver rejects a misaligned source with INVALID_ARG
BEFORE any bus activity. esp_hosts write loop then declares "Unrecoverable
host sdio state" and reboots the whole P4. The audio TX payload is not
64-aligned, so streaming mic audio wedged on the very FIRST frame (which is
exactly what we saw: listening -> instant Failed to send -> reboot).

This also explains why buffer/queue/clock/retry tuning all did nothing: the
write never reached the bus. And why our symptom was instant, not after
~100 writes (the community block-mode-desync theory) — it is the first
misaligned buffer, every time.

Fix: vendored esp_hosted 2.12.11 as an editable local component (overrides
the registry copy) and bounce a misaligned TX payload through one aligned
DMA scratch buffer in hosted_sdio_write_block (port_esp_hosted_host_sdio.c).
TX is serialized by the bus lock so a single static bounce buffer is safe;
freed in hosted_sdio_deinit. Host-only change — no C6 reflash.

VERIFIED ON HARDWARE (autonomous self-test): 40s of continuous mic-audio
upstream streaming — the traffic that previously wedged on the first frame
— ran clean, zero timeouts, zero reboots. A guarded SDIO_TX_SELFTEST harness
is kept (compiled out) for future SDIO stress testing.

Credit: root cause + patch designed via multi-agent investigation; the
precise 258=INVALID_ARG decode (correcting the upstream community timeout
assumption) came from checking our actual esp_err.h.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

firmware/components/esp_hosted/host/api/include/esp_hosted_api_types.h

@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
+*
+* SPDX-License-Identifier: Apache-2.0
+*/
+
+/** prevent recursive inclusion **/
+#ifndef __ESP_HOSTED_API_TYPES_H__
+#define __ESP_HOSTED_API_TYPES_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	uint32_t major1;
+	uint32_t minor1;
+	uint32_t patch1;
+	int32_t revision;
+	int32_t prerelease;
+	int32_t build;
+} esp_hosted_coprocessor_fwver_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

firmware/components/esp_hosted/host/api/include/esp_hosted_cp_ext_coex.h

@@ -0,0 +1,105 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file esp_hosted_cp_ext_coex.h
+ * @brief External Coexistence API for ESP-Hosted Co-Processor
+ *
+ * Platform-agnostic APIs to configure external coexistence GPIO pins on
+ * the ESP-Hosted co-processor from the host MCU. Also compatible with non-ESP
+ * hosts (e.g. STM32, nRF) that do not use ESP-IDF.
+ */
+
+#ifndef __ESP_HOSTED_CP_EXT_COEX_H__
+#define __ESP_HOSTED_CP_EXT_COEX_H__
+
+#include <stdbool.h>
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ESP_HOSTED_EXT_COEX_WIRE_1 0
+#define ESP_HOSTED_EXT_COEX_WIRE_2 1
+#define ESP_HOSTED_EXT_COEX_WIRE_3 2
+#define ESP_HOSTED_EXT_COEX_WIRE_4 3
+
+typedef enum {
+	ESP_HOSTED_EXT_COEX_LEADER_ROLE = 0,
+	ESP_HOSTED_EXT_COEX_FOLLOWER_ROLE = 2,
+	ESP_HOSTED_EXT_COEX_UNKNOWN_ROLE,
+} esp_hosted_ext_coex_work_mode_t;
+
+typedef struct {
+	int32_t request;
+	int32_t priority;
+	int32_t grant;
+	int32_t tx_line;
+} esp_hosted_ext_coex_gpio_set_t;
+
+#if defined(CONFIG_ESP_HOSTED_CP_EXT_COEX) && CONFIG_ESP_HOSTED_CP_EXT_COEX
+
+/**
+ * @brief Host-side API to set the work mode for external coexistence
+ *        on the co-processor connected to the host.
+ *
+ * @param work_mode  Work mode to be set
+ *
+ * @return ESP_OK on success, otherwise an error code
+ */
+esp_err_t esp_hosted_cp_ext_coex_set_work_mode(esp_hosted_ext_coex_work_mode_t work_mode);
+
+/**
+ * @brief Host-side API to configure GPIO pins for external coexistence
+ *        on the co-processor connected to the host.
+ *
+ * @param wire_type  Wire type for which the GPIO pins are configured
+ * @param gpio_pins  GPIO pin configuration to be set
+ *
+ * @return ESP_OK on success, otherwise an error code
+ */
+esp_err_t esp_hosted_cp_ext_coex_set_gpio_pin(uint32_t wire_type,
+		const esp_hosted_ext_coex_gpio_set_t *gpio_pins);
+
+#if defined(CONFIG_ESP_HOSTED_CP_EXT_COEX_ADVANCE) && CONFIG_ESP_HOSTED_CP_EXT_COEX_ADVANCE
+/**
+ * @brief Host-side API to set the grant delay for external coexistence
+ *        on the co-processor connected to the host.
+ *
+ * @param delay_us  Grant delay to be set
+ *
+ * @return ESP_OK on success, otherwise an error code
+ */
+esp_err_t esp_hosted_cp_ext_coex_set_grant_delay(uint8_t delay_us);
+
+/**
+ * @brief Host-side API to set the validate high for external coexistence
+ *        on the co-processor connected to the host.
+ *
+ * @param is_high_valid  Validate high to be set
+ *
+ * @return ESP_OK on success, otherwise an error code
+ */
+esp_err_t esp_hosted_cp_ext_coex_set_validate_high(bool is_high_valid);
+
+#endif
+
+/**
+ * @brief Host-side API to disable external coexistence
+ *        on the co-processor connected to the host.
+ *
+ * @return ESP_OK on success, otherwise an error code
+ */
+esp_err_t esp_hosted_cp_ext_coex_disable(void);
+
+#endif /* CONFIG_ESP_HOSTED_CP_EXT_COEX */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ESP_HOSTED_CP_EXT_COEX_H__ */

firmware/components/esp_hosted/host/api/include/esp_hosted_cp_gpio.h

@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __ESP_HOSTED_CP_GPIO_H__
+#define __ESP_HOSTED_CP_GPIO_H__
+
+
+#include "esp_err.h"
+
+typedef struct
+{
+	uint64_t pin_bit_mask;   /*!< GPIO pin: set with bit mask, each bit maps to a GPIO */
+	uint32_t mode;           /*!< GPIO mode: set input/output mode                     */
+	uint32_t pull_up_en;     /*!< GPIO pull-up                                         */
+	uint32_t pull_down_en;   /*!< GPIO pull-down                                       */
+	uint32_t intr_type;      /*!< GPIO interrupt type                                  */
+} esp_hosted_cp_gpio_config_t;
+
+#define H_BIT0  (1ULL << 0)
+#define H_BIT1  (1ULL << 1)
+#define H_BIT2  (1ULL << 2)
+
+#define H_CP_GPIO_MODE_DEF_DISABLE         (0)
+#define H_CP_GPIO_MODE_DEF_INPUT           (H_BIT0)    ///< bit mask for input
+#define H_CP_GPIO_MODE_DEF_OUTPUT          (H_BIT1)    ///< bit mask for output
+#define H_CP_GPIO_MODE_DEF_OD              (H_BIT2)    ///< bit mask for OD mode
+
+enum {
+	H_CP_GPIO_MODE_DISABLE = H_CP_GPIO_MODE_DEF_DISABLE,                                                                   /*!< GPIO mode : disable input and output             */
+	H_CP_GPIO_MODE_INPUT = H_CP_GPIO_MODE_DEF_INPUT,                                                                       /*!< GPIO mode : input only                           */
+	H_CP_GPIO_MODE_OUTPUT = H_CP_GPIO_MODE_DEF_OUTPUT,                                                                     /*!< GPIO mode : output only mode                     */
+	H_CP_GPIO_MODE_OUTPUT_OD = ((H_CP_GPIO_MODE_DEF_OUTPUT) | (H_CP_GPIO_MODE_DEF_OD)),                                    /*!< GPIO mode : output only with open-drain mode     */
+	H_CP_GPIO_MODE_INPUT_OUTPUT_OD = ((H_CP_GPIO_MODE_DEF_INPUT) | (H_CP_GPIO_MODE_DEF_OUTPUT) | (H_CP_GPIO_MODE_DEF_OD)), /*!< GPIO mode : output and input with open-drain mode*/
+	H_CP_GPIO_MODE_INPUT_OUTPUT = ((H_CP_GPIO_MODE_DEF_INPUT) | (H_CP_GPIO_MODE_DEF_OUTPUT)),                              /*!< GPIO mode : output and input mode                */
+};
+
+#define H_CP_GPIO_PULL_UP                  (1)
+#define H_CP_GPIO_PULL_DOWN                (0)
+
+esp_err_t esp_hosted_cp_gpio_config(const esp_hosted_cp_gpio_config_t *pGPIOConfig);
+esp_err_t esp_hosted_cp_gpio_reset_pin(uint32_t gpio_num);
+esp_err_t esp_hosted_cp_gpio_set_level(uint32_t gpio_num, uint32_t level);
+esp_err_t esp_hosted_cp_gpio_get_level(uint32_t gpio_num, int *level);
+esp_err_t esp_hosted_cp_gpio_set_direction(uint32_t gpio_num, uint32_t mode);
+esp_err_t esp_hosted_cp_gpio_input_enable(uint32_t gpio_num);
+esp_err_t esp_hosted_cp_gpio_set_pull_mode(uint32_t gpio_num, uint32_t pull_mode);
+
+#endif /*__ESP_HOSTED_CP_GPIO_H__*/

firmware/components/esp_hosted/host/api/include/esp_hosted_openthread.h

@@ -0,0 +1,61 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __ESP_HOSTED_OPENTHREAD_H__
+#define __ESP_HOSTED_OPENTHREAD_H__
+
+typedef enum {
+	HOSTED_OPENTHREAD_TRANSPORT_UART,
+	HOSTED_OPENTHREAD_TRANSPORT_MAX,
+} esp_hosted_openthread_radio_transport_t;
+
+typedef enum {
+	HOSTED_OPENTHREAD_QUERY_CONFIGURED,
+	HOSTED_OPENTHREAD_QUERY_INITED,
+	HOSTED_OPENTHREAD_QUERY_ENABLED,
+	HOSTED_OPENTHREAD_QUERY_READY,
+} esp_hosted_openthread_query_t;
+
+typedef struct {
+	int port;
+	int baud_rate;
+	int data_bits;
+	int parity;
+	int stop_bits;
+	int flow_ctrl;
+	int rx_flow_ctrl_thresh;
+	int source_clk;
+	int rx_pin;
+	int tx_pin;
+} esp_hosted_openthread_uart_config_t;
+
+typedef struct {
+	esp_hosted_openthread_radio_transport_t type;
+	union {
+		esp_hosted_openthread_uart_config_t radio_uart_config;
+	};
+} esp_hosted_openthread_radio_config_t;
+
+/**
+  * @brief  Gets the current Hosted OpenThread Radio Config
+  *
+  * Caller responsible for filling OT implementation dependent radio configuration
+  * from the returned info
+  *
+  * @param config ESP-Hosted Radio Config
+  *
+  * @return 0 on success
+  */
+int esp_hosted_openthread_get_radio_config(esp_hosted_openthread_radio_config_t *config);
+
+int esp_hosted_openthread_rcp_init(void);
+int esp_hosted_openthread_rcp_deinit(void);
+int esp_hosted_openthread_rcp_start(void);
+int esp_hosted_openthread_rcp_stop(void);
+
+// query the RCP on its state: configured, inited, enabled or ready
+int esp_hosted_openthread_rcp_query(esp_hosted_openthread_query_t query);
+#endif

firmware/components/esp_hosted/host/api/include/esp_hosted_ota.h

@@ -0,0 +1,82 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+*
+* SPDX-License-Identifier: Apache-2.0
+*/
+
+/* APIs to do OTA updates of the co-processor
+ *
+ * Note: This API is platform dependent
+ *
+ * Add additional APIs as required based on how the OTA binary is to
+ * be fetched.
+ *
+ * Source for the API should be in host/port/<platform>/...
+ *
+ * Procedure used by APIs to do OTA update:
+ * 1. Fetch and prepare OTA binary
+ * 2. Call rpc_ota_begin() to start OTA
+ * 3. Repeatedly call rpc_ota_write() with a continuous chunk of OTA data
+ * 4. Call rpc_ota_end()
+ *
+ * @deprecated This API is deprecated. Use the new OTA examples in examples/host_slave_ota/
+ *             and examples/host_self_ota/ which provide more flexible OTA implementations.
+ *             These examples demonstrate how to use the low-level esp_hosted_ota_begin(),
+ *             esp_hosted_ota_write(), and esp_hosted_ota_end() APIs directly.
+ */
+
+#ifndef __ESP_HOSTED_OTA_H__
+#define __ESP_HOSTED_OTA_H__
+
+#include "esp_err.h"
+
+enum {
+    ESP_HOSTED_SLAVE_OTA_ACTIVATED,
+    ESP_HOSTED_SLAVE_OTA_COMPLETED,
+    ESP_HOSTED_SLAVE_OTA_NOT_REQUIRED,
+    ESP_HOSTED_SLAVE_OTA_NOT_STARTED,
+    ESP_HOSTED_SLAVE_OTA_IN_PROGRESS,
+    ESP_HOSTED_SLAVE_OTA_FAILED,
+};
+
+/**
+ * @brief Fetch OTA image from a web server (image_url)
+ * @deprecated Use the examples in examples/host_slave_ota/ for new implementations
+ * @param image_url URL of the OTA image
+ * @return esp_err_t ESP_OK on success, error code on failure
+ */
+esp_err_t esp_hosted_slave_ota(const char* image_url) __attribute__((deprecated("Use examples/host_slave_ota/ for new OTA implementations")));
+
+/* --------- OTA APIs --------- */
+/**
+ * @brief Begin OTA update on the remote coprocessor device
+ *
+ * @return esp_err_t ESP_OK on success, error code on failure
+ */
+esp_err_t esp_hosted_slave_ota_begin(void);
+
+/**
+ * @brief Write OTA data chunk to the remote coprocessor device
+ *
+ * @param ota_data Pointer to OTA data chunk
+ * @param ota_data_len Length of OTA data chunk
+ * @return esp_err_t ESP_OK on success, error code on failure
+ */
+esp_err_t esp_hosted_slave_ota_write(uint8_t* ota_data, uint32_t ota_data_len);
+
+/**
+ * @brief End OTA update on the remote coprocessor device
+ *
+ * @return esp_err_t ESP_OK on success, error code on failure
+ */
+esp_err_t esp_hosted_slave_ota_end(void);
+
+/**
+ * @brief Activate OTA update on the remote coprocessor device. This would also reboot the remote coprocessor.
+ *
+ * @return esp_err_t ESP_OK on success, error code on failure
+ */
+esp_err_t esp_hosted_slave_ota_activate(void);
+
+
+#endif /*__ESP_HOSTED_OTA_H__*/

firmware/components/esp_hosted/host/api/include/esp_hosted_power_save.h

@@ -0,0 +1,82 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ESP_HOSTED_POWER_SAVE_API_H
+#define ESP_HOSTED_POWER_SAVE_API_H
+
+typedef enum {
+    HOSTED_WAKEUP_UNDEFINED = 0,
+    HOSTED_WAKEUP_NORMAL_REBOOT,
+    HOSTED_WAKEUP_DEEP_SLEEP,
+} esp_hosted_wakeup_reason_t;
+
+typedef enum {
+    HOSTED_POWER_SAVE_TYPE_NONE = 0,
+    HOSTED_POWER_SAVE_TYPE_LIGHT_SLEEP,
+    HOSTED_POWER_SAVE_TYPE_DEEP_SLEEP,
+} esp_hosted_power_save_type_t;
+
+/*
+ * @brief Initializes the power save driver.
+ *        This function is typically called automatically during esp_hosted_init().
+ */
+int esp_hosted_power_save_init(void);
+
+/*
+ * @brief Deinitializes the power save driver.
+ *        This function is typically called automatically during esp_hosted_deinit().
+ */
+int esp_hosted_power_save_deinit(void);
+
+/**
+ * @brief Checks if the host power save feature is enabled in Kconfig.
+ *
+ * @return int Returns 1 if the feature is enabled, 0 otherwise.
+ */
+int esp_hosted_power_save_enabled(void);
+
+/**
+ * @brief Determines if the host rebooted due to deep sleep.
+ *
+ * @return int Returns 1 if the host rebooted due to deep sleep, 0 otherwise.
+ */
+int esp_hosted_woke_from_power_save(void);
+
+/**
+ * @brief Checks if the host is currently in power saving mode.
+ *
+ * @return int Returns 1 if the host is in power saving mode, 0 otherwise.
+ */
+int esp_hosted_power_saving(void);
+
+/**
+ * @brief Initiates the host power save mode (deep sleep).
+ * @note This function does not return. The host will enter deep sleep
+ *       and reboot upon wake-up.
+ *
+ * @param power_save_type The type of power save mode to enter.
+ *                        Currently, only HOSTED_POWER_SAVE_TYPE_DEEP_SLEEP is supported.
+ * @return int Returns 0 on success, or a nonzero value on failure (e.g., if the feature is disabled).
+ */
+int esp_hosted_power_save_start(esp_hosted_power_save_type_t power_save_type);
+
+/**
+ * @brief Starts a timer that will place the host into deep sleep upon expiration.
+ *
+ * @param time_ms The duration in milliseconds after which the host will enter deep sleep.
+ * @return int Returns 0 on success or a nonzero value on failure.
+ */
+int esp_hosted_power_save_timer_start(uint32_t time_ms);
+
+/**
+ * @brief Stops the host power save timer.
+ *
+ * @return int Returns 0 on success or a nonzero value on failure.
+ */
+int esp_hosted_power_save_timer_stop(void);
+
+
+#endif

firmware/components/esp_hosted/host/api/include/esp_hosted_transport_config.h

@@ -0,0 +1,171 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __ESP_HOSTED_TRANSPORT_CONFIG_H__
+#define __ESP_HOSTED_TRANSPORT_CONFIG_H__
+
+#include <stdbool.h>
+
+#include "esp_err.h"
+
+typedef enum {
+	ESP_TRANSPORT_OK = ESP_OK,
+	ESP_TRANSPORT_ERR_INVALID_ARG = ESP_ERR_INVALID_ARG,
+	ESP_TRANSPORT_ERR_ALREADY_SET = ESP_ERR_NOT_ALLOWED,
+	ESP_TRANSPORT_ERR_INVALID_STATE = ESP_ERR_INVALID_STATE,
+} esp_hosted_transport_err_t;
+
+/* GPIO pin configuration structure */
+typedef struct {
+	void *port;
+	int pin;
+} gpio_pin_t;
+
+/* New Configuration Structures */
+struct esp_hosted_sdio_config {
+	uint32_t clock_freq_khz;
+	uint8_t bus_width;
+	uint8_t slot;
+	gpio_pin_t pin_clk;
+	gpio_pin_t pin_cmd;
+	gpio_pin_t pin_d0;
+	gpio_pin_t pin_d1;
+	gpio_pin_t pin_d2;
+	gpio_pin_t pin_d3;
+	gpio_pin_t pin_reset;
+	uint8_t rx_mode;
+	bool block_mode;
+	bool iomux_enable;
+	uint16_t tx_queue_size;
+	uint16_t rx_queue_size;
+};
+
+struct esp_hosted_spi_hd_config {
+	/* Number of lines used */
+	uint8_t num_data_lines;
+
+	/* SPI HD pins */
+	gpio_pin_t pin_cs;
+	gpio_pin_t pin_clk;
+	gpio_pin_t pin_data_ready;
+	gpio_pin_t pin_d0;
+	gpio_pin_t pin_d1;
+	gpio_pin_t pin_d2;
+	gpio_pin_t pin_d3;
+	gpio_pin_t pin_reset;
+
+	/* SPI HD configuration */
+	uint32_t clk_mhz;
+	uint8_t mode;
+	uint16_t tx_queue_size;
+	uint16_t rx_queue_size;
+	bool checksum_enable;
+	uint8_t num_command_bits;
+	uint8_t num_address_bits;
+	uint8_t num_dummy_bits;
+};
+
+struct esp_hosted_spi_config {
+	/* SPI Full Duplex pins */
+	gpio_pin_t pin_mosi;
+	gpio_pin_t pin_miso;
+	gpio_pin_t pin_sclk;
+	gpio_pin_t pin_cs;
+	gpio_pin_t pin_handshake;
+	gpio_pin_t pin_data_ready;
+	gpio_pin_t pin_reset;
+
+	/* SPI Full Duplex configuration */
+	uint16_t tx_queue_size;
+	uint16_t rx_queue_size;
+	uint8_t mode;
+	uint32_t clk_mhz;
+};
+
+struct esp_hosted_uart_config {
+	/* UART bus number */
+	uint8_t port;
+
+	/* UART pins */
+	gpio_pin_t pin_tx;
+	gpio_pin_t pin_rx;
+	gpio_pin_t pin_reset;
+
+	/* UART configuration */
+	uint8_t num_data_bits;
+	uint8_t parity;
+	uint8_t stop_bits;
+	uint8_t flow_ctrl;
+	uint8_t clk_src;
+	bool checksum_enable;
+	uint32_t baud_rate;
+	uint16_t tx_queue_size;
+	uint16_t rx_queue_size;
+};
+
+struct esp_hosted_transport_config {
+	uint8_t transport_in_use;
+	union {
+		struct esp_hosted_sdio_config sdio;
+		struct esp_hosted_spi_hd_config spi_hd;
+		struct esp_hosted_spi_config spi;
+		struct esp_hosted_uart_config uart;
+	} u;
+};
+
+/* Default configuration functions - implemented by port layer */
+struct esp_hosted_sdio_config esp_hosted_get_default_sdio_config(void);
+struct esp_hosted_sdio_config esp_hosted_get_default_sdio_iomux_config(void);
+struct esp_hosted_spi_hd_config esp_hosted_get_default_spi_hd_config(void);
+struct esp_hosted_spi_config esp_hosted_get_default_spi_config(void);
+struct esp_hosted_uart_config esp_hosted_get_default_uart_config(void);
+
+/* Convenience macros for backward compatibility and ease of use */
+#define INIT_DEFAULT_HOST_SDIO_CONFIG() esp_hosted_get_default_sdio_config()
+#define INIT_DEFAULT_HOST_SDIO_IOMUX_CONFIG() esp_hosted_get_default_sdio_iomux_config()
+#define INIT_DEFAULT_HOST_SPI_HD_CONFIG() esp_hosted_get_default_spi_hd_config()
+#define INIT_DEFAULT_HOST_SPI_CONFIG() esp_hosted_get_default_spi_config()
+#define INIT_DEFAULT_HOST_UART_CONFIG() esp_hosted_get_default_uart_config()
+
+/***
+ * Generic Transport APIs
+ ***/
+esp_err_t esp_hosted_set_default_config(void);
+bool esp_hosted_is_config_valid(void);
+
+/* Configuration get/set functions */
+esp_hosted_transport_err_t esp_hosted_transport_set_default_config(void);
+esp_hosted_transport_err_t esp_hosted_transport_get_config(struct esp_hosted_transport_config **config);
+esp_hosted_transport_err_t esp_hosted_transport_get_reset_config(gpio_pin_t *pin_config);
+
+bool esp_hosted_transport_is_config_valid(void);
+
+/***
+ * Transport dependent APIs.
+ * Can only be used with the configured host transport
+ ***/
+/* SDIO functions */
+esp_hosted_transport_err_t esp_hosted_sdio_get_config(struct esp_hosted_sdio_config **config);
+esp_hosted_transport_err_t esp_hosted_sdio_set_config(struct esp_hosted_sdio_config *config) __attribute__((warn_unused_result));
+
+esp_hosted_transport_err_t esp_hosted_sdio_iomux_set_config(struct esp_hosted_sdio_config *config) __attribute__((warn_unused_result));
+
+/* SPI Half Duplex functions */
+esp_hosted_transport_err_t esp_hosted_spi_hd_get_config(struct esp_hosted_spi_hd_config **config);
+esp_hosted_transport_err_t esp_hosted_spi_hd_set_config(struct esp_hosted_spi_hd_config *config) __attribute__((warn_unused_result));
+
+esp_hosted_transport_err_t esp_hosted_spi_hd_2lines_get_config(struct esp_hosted_spi_hd_config **config);
+esp_hosted_transport_err_t esp_hosted_spi_hd_2lines_set_config(struct esp_hosted_spi_hd_config *config) __attribute__((warn_unused_result));
+
+/* SPI Full Duplex functions */
+esp_hosted_transport_err_t esp_hosted_spi_get_config(struct esp_hosted_spi_config **config);
+esp_hosted_transport_err_t esp_hosted_spi_set_config(struct esp_hosted_spi_config *config) __attribute__((warn_unused_result));
+
+/* UART functions */
+esp_hosted_transport_err_t esp_hosted_uart_get_config(struct esp_hosted_uart_config **config);
+esp_hosted_transport_err_t esp_hosted_uart_set_config(struct esp_hosted_uart_config *config) __attribute__((warn_unused_result));
+
+#endif /* __ESP_HOSTED_TRANSPORT_CONFIG_H__ */

firmware/components/esp_hosted/host/api/include/esp_hosted_wifi_remote_glue.h

@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+*
+* SPDX-License-Identifier: Apache-2.0
+*/
+
+#ifndef __ESP_HOSTED_WIFI_REMOTE_GLUE_H__
+#define __ESP_HOSTED_WIFI_REMOTE_GLUE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_hosted_interface.h"
+#include "esp_wifi_remote.h"
+#include "esp_wifi.h"
+
+struct esp_remote_channel_config {
+    esp_hosted_if_type_t if_type;
+    bool secure;
+};
+
+typedef struct esp_remote_channel_config * esp_remote_channel_config_t;
+
+/* Transport/Channel related data structures and macros */
+#define ESP_HOSTED_CHANNEL_CONFIG_DEFAULT()  { \
+	.secure = true,                            \
+}
+
+/* Function pointer types for channel callbacks */
+typedef esp_err_t (*esp_remote_channel_rx_fn_t)(void *h, void *buffer,
+		void *buff_to_free, size_t len);
+typedef esp_err_t (*esp_remote_channel_tx_fn_t)(void *h, void *buffer, size_t len);
+
+/* Transport/Channel Management API Functions - use managed component typedef */
+esp_remote_channel_t esp_hosted_add_channel(esp_remote_channel_config_t config,
+		esp_remote_channel_tx_fn_t *tx, const esp_remote_channel_rx_fn_t rx);
+esp_err_t esp_hosted_remove_channel(esp_remote_channel_t channel);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ESP_HOSTED_WIFI_REMOTE_GLUE_H__ */

firmware/components/esp_hosted/host/api/priv/esp_hosted_api_priv.h

@@ -0,0 +1,156 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* prevent recursive inclusion */
+#ifndef __ESP_HOSTED_API_PRIV_H__
+#define __ESP_HOSTED_API_PRIV_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes */
+#include "stdbool.h"
+#include "esp_wifi.h"
+#include "esp_wifi_remote.h"
+#include "esp_hosted_api_types.h"
+#include "port_esp_hosted_host_wifi_config.h"
+
+
+#if H_WIFI_ENTERPRISE_SUPPORT
+#include "esp_eap_client.h"
+#endif
+
+#if H_DPP_SUPPORT
+#include "esp_dpp.h"
+#endif
+
+/* Remote WiFi API Functions - Port/Implementation Specific */
+esp_err_t esp_wifi_remote_init(const wifi_init_config_t *arg);
+esp_err_t esp_wifi_remote_deinit(void);
+esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode);
+esp_err_t esp_wifi_remote_get_mode(wifi_mode_t* mode);
+esp_err_t esp_wifi_remote_start(void);
+esp_err_t esp_wifi_remote_stop(void);
+esp_err_t esp_wifi_remote_connect(void);
+esp_err_t esp_wifi_remote_disconnect(void);
+esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf);
+esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf);
+esp_err_t esp_wifi_remote_get_mac(wifi_interface_t mode, uint8_t mac[6]);
+esp_err_t esp_wifi_remote_set_mac(wifi_interface_t mode, const uint8_t mac[6]);
+
+esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, bool block);
+esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config);
+esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config);
+esp_err_t esp_wifi_remote_scan_stop(void);
+esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number);
+esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record);
+esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records);
+esp_err_t esp_wifi_remote_clear_ap_list(void);
+esp_err_t esp_wifi_remote_restore(void);
+esp_err_t esp_wifi_remote_clear_fast_connect(void);
+esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid);
+esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info);
+esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type);
+esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type);
+esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage);
+esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw);
+esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw);
+esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second);
+esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second);
+esp_err_t esp_wifi_remote_set_country_code(const char *country, bool ieee80211d_enabled);
+esp_err_t esp_wifi_remote_get_country_code(char *country);
+esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country);
+esp_err_t esp_wifi_remote_get_country(wifi_country_t *country);
+esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta);
+esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid);
+esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi);
+esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap);
+esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap);
+esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power);
+esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power);
+esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode);
+esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid);
+esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec);
+esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec);
+esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx);
+
+#if H_WIFI_HE_SUPPORT
+esp_err_t esp_wifi_remote_sta_twt_config(wifi_twt_config_t *config);
+#if H_WIFI_HE_GREATER_THAN_ESP_IDF_5_3
+esp_err_t esp_wifi_remote_sta_itwt_setup(wifi_itwt_setup_config_t *setup_config);
+#else
+esp_err_t esp_wifi_remote_sta_itwt_setup(wifi_twt_setup_config_t *setup_config);
+#endif
+esp_err_t esp_wifi_remote_sta_itwt_teardown(int flow_id);
+esp_err_t esp_wifi_remote_sta_itwt_suspend(int flow_id, int suspend_time_ms);
+esp_err_t esp_wifi_remote_sta_itwt_get_flow_id_status(int *flow_id_bitmap);
+esp_err_t esp_wifi_remote_sta_itwt_send_probe_req(int timeout_ms);
+esp_err_t esp_wifi_remote_sta_itwt_set_target_wake_time_offset(int timeout_us);
+#endif
+
+#if H_WIFI_DUALBAND_SUPPORT
+/* Dual-band WiFi API (Depends upon co-processor used) */
+esp_err_t esp_wifi_remote_set_band(wifi_band_t band);
+esp_err_t esp_wifi_remote_get_band(wifi_band_t *band);
+esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode);
+esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode);
+esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols);
+esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols);
+esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw);
+esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw);
+#endif
+
+#if H_WIFI_ENTERPRISE_SUPPORT
+esp_err_t esp_wifi_remote_sta_enterprise_enable(void);
+esp_err_t esp_wifi_remote_sta_enterprise_disable(void);
+esp_err_t esp_eap_client_remote_set_identity(const unsigned char *identity, int len);
+esp_err_t esp_eap_client_remote_clear_identity(void);
+esp_err_t esp_eap_client_remote_set_username(const unsigned char *username, int len);
+esp_err_t esp_eap_client_remote_clear_username(void);
+esp_err_t esp_eap_client_remote_set_password(const unsigned char *password, int len);
+esp_err_t esp_eap_client_remote_clear_password(void);
+esp_err_t esp_eap_client_remote_set_new_password(const unsigned char *new_password, int len);
+esp_err_t esp_eap_client_remote_clear_new_password(void);
+esp_err_t esp_eap_client_remote_set_ca_cert(const unsigned char *ca_cert, int ca_cert_len);
+esp_err_t esp_eap_client_remote_clear_ca_cert(void);
+esp_err_t esp_eap_client_remote_clear_certificate_and_key(void);
+esp_err_t esp_eap_client_remote_set_disable_time_check(bool disable);
+esp_err_t esp_eap_client_remote_get_disable_time_check(bool *disable);
+esp_err_t esp_eap_client_remote_set_ttls_phase2_method(esp_eap_ttls_phase2_types type);
+esp_err_t esp_eap_client_remote_set_suiteb_192bit_certification(bool enable);
+esp_err_t esp_eap_client_remote_set_pac_file(const unsigned char *pac_file, int pac_file_len);
+esp_err_t esp_eap_client_remote_set_fast_params(esp_eap_fast_config config);
+esp_err_t esp_eap_client_remote_use_default_cert_bundle(bool use_default_bundle);
+esp_err_t esp_wifi_remote_set_okc_support(bool enable);
+esp_err_t esp_eap_client_remote_set_domain_name(const char *domain_name);
+esp_err_t esp_eap_client_remote_set_certificate_and_key(const unsigned char *client_cert, int client_cert_len,
+                                                 const unsigned char *private_key, int private_key_len,
+                                                 const unsigned char *private_key_password, int private_key_passwd_len);
+#if H_GOT_SET_EAP_METHODS_API
+esp_err_t esp_eap_client_remote_set_eap_methods(esp_eap_method_t methods);
+#endif
+#endif
+
+#if H_DPP_SUPPORT
+#if H_SUPP_DPP_SUPPORT
+esp_err_t esp_supp_remote_dpp_init(esp_supp_dpp_event_cb_t evt_cb);
+#else
+esp_err_t esp_supp_remote_dpp_init(void);
+#endif
+esp_err_t esp_supp_remote_dpp_deinit(void);
+esp_err_t esp_supp_remote_dpp_bootstrap_gen(const char *chan_list,
+		esp_supp_dpp_bootstrap_t type,
+		const char *key, const char *info);
+esp_err_t esp_supp_remote_dpp_start_listen(void);
+esp_err_t esp_supp_remote_dpp_stop_listen(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ESP_HOSTED_API_PRIV_H__ */

firmware/components/esp_hosted/host/api/src/esp_hosted_api.c

@@ -0,0 +1,988 @@
+/*
+ * SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Includes **/
+#include "esp_hosted_transport_config.h"
+#include "esp_hosted_api_priv.h"
+#include "esp_hosted_wifi_remote_glue.h"
+#include "port_esp_hosted_host_wifi_config.h"
+#include "port_esp_hosted_host_openthread.h"
+#include "port_esp_hosted_host_os.h"
+#include "esp_hosted_misc.h"
+#include "esp_check.h"
+#include "transport_drv.h"
+#include "rpc_wrap.h"
+#include "esp_log.h"
+#include "esp_hosted_event.h"
+
+#if H_DPP_SUPPORT
+#include "esp_dpp.h"
+#endif
+
+#if H_HOST_OT_ENABLE
+#include "esp_hosted_openthread.h"
+#endif
+
+/** Macros **/
+static const char *TAG="H_API";
+
+static uint8_t esp_hosted_init_done;
+static uint8_t esp_hosted_transport_up;
+
+
+#define check_transport_up()                                                    \
+    do {                                                                        \
+        if (!(esp_hosted_transport_up)) {                                       \
+            ESP_LOGE(TAG, "ESP-Hosted link not yet up");                        \
+            return ESP_FAIL;                                                    \
+        }                                                                       \
+    } while (0)
+
+
+
+/** Exported variables **/
+struct esp_remote_channel {
+	transport_channel_t *t_chan;
+};
+
+//static semaphore_handle_t transport_up_sem;
+
+/** Inline functions **/
+
+/** Exported Functions **/
+static void transport_active_cb(void)
+{
+	ESP_LOGI(TAG, "Transport active");
+	esp_hosted_transport_up = 1;
+	g_h.funcs->_h_event_post(ESP_HOSTED_EVENT,
+			ESP_HOSTED_EVENT_TRANSPORT_UP,
+			NULL, 0, HOSTED_BLOCK_MAX);
+}
+
+#if 0
+static void create_esp_hosted_transport_up_sem(void)
+{
+	if (!transport_up_sem) {
+		transport_up_sem = g_h.funcs->_h_create_semaphore(1);
+		assert(transport_up_sem);
+		/* clear semaphore */
+		g_h.funcs->_h_get_semaphore(transport_up_sem, 0);
+	}
+}
+
+esp_err_t esp_hosted_setup(void)
+{
+	create_esp_hosted_transport_up_sem();
+	g_h.funcs->_h_get_semaphore(transport_up_sem, HOSTED_BLOCK_MAX);
+	g_h.funcs->_h_post_semaphore(transport_up_sem);
+	return ESP_OK;
+}
+#endif
+
+static esp_remote_channel_t sta_ch = NULL;
+static esp_remote_channel_t ap_ch = NULL;
+
+static esp_err_t add_esp_wifi_remote_channels(void)
+{
+	ESP_LOGI(TAG, "** %s **", __func__);
+	esp_remote_channel_tx_fn_t tx_cb;
+
+	/* Add an RPC channel with default config (i.e. secure=true) */
+	struct esp_remote_channel_config config = ESP_HOSTED_CHANNEL_CONFIG_DEFAULT();
+	config.if_type = ESP_SERIAL_IF;
+	/*TODO: add rpc channel from here
+	ch = esp_hosted_add_channel(&config, &tx_cb, esp_wifi_remote_rpc_channel_rx);
+	esp_wifi_remote_rpc_channel_set(ch, tx_cb); */
+
+	/* Add two other channels for the two WiFi interfaces (STA, softAP) in plain text */
+	config.secure = false;
+	config.if_type = ESP_STA_IF;
+	sta_ch = esp_hosted_add_channel(&config, &tx_cb, esp_wifi_remote_channel_rx);
+	esp_wifi_remote_channel_set(WIFI_IF_STA, sta_ch, tx_cb);
+
+
+	config.secure = false;
+	config.if_type = ESP_AP_IF;
+	ap_ch = esp_hosted_add_channel(&config, &tx_cb, esp_wifi_remote_channel_rx);
+	esp_wifi_remote_channel_set(WIFI_IF_AP, ap_ch, tx_cb);
+
+	return ESP_OK;
+}
+
+static esp_err_t remove_esp_wifi_remote_channels(void)
+{
+	if (sta_ch) {
+		esp_hosted_remove_channel(sta_ch);
+		sta_ch = NULL;
+	}
+	if (ap_ch) {
+		esp_hosted_remove_channel(ap_ch);
+		ap_ch = NULL;
+	}
+	return ESP_OK;
+}
+
+static void set_host_modules_log_level(void)
+{
+	esp_log_level_set("rpc_core", ESP_LOG_WARN);
+	esp_log_level_set("rpc_rsp", ESP_LOG_WARN);
+	esp_log_level_set("rpc_evt", ESP_LOG_WARN);
+}
+int esp_hosted_init(void)
+{
+	if (esp_hosted_init_done)
+		return ESP_OK;
+
+	set_host_modules_log_level();
+
+	//create_esp_hosted_transport_up_sem();
+	ESP_LOGI(TAG, "ESP-Hosted starting. Hosted_Tasks: prio:%u, stack: %u RPC_task_stack: %u",
+			DFLT_TASK_PRIO, DFLT_TASK_STACK_SIZE, RPC_TASK_STACK_SIZE);
+	if (esp_hosted_is_config_valid()) {
+		ESP_LOGW(TAG, "ESP-Hosted config valid; reuse existing config");
+	} else {
+		ESP_ERROR_CHECK(esp_hosted_set_default_config());
+	}
+	ESP_ERROR_CHECK(add_esp_wifi_remote_channels());
+	ESP_ERROR_CHECK(setup_transport(transport_active_cb));
+	ESP_ERROR_CHECK(rpc_init());
+	rpc_register_event_callbacks();
+
+	esp_hosted_init_done = 1;
+	return ESP_OK;
+}
+
+int esp_hosted_deinit(void)
+{
+	ESP_LOGI(TAG, "ESP-Hosted deinit\n");
+	rpc_unregister_event_callbacks();
+	ESP_ERROR_CHECK(rpc_deinit());
+	ESP_ERROR_CHECK(remove_esp_wifi_remote_channels());
+	ESP_ERROR_CHECK(teardown_transport());
+	esp_hosted_init_done = 0;
+	esp_hosted_transport_up = 0;
+	g_h.funcs->_h_event_post(ESP_HOSTED_EVENT,
+			ESP_HOSTED_EVENT_TRANSPORT_DOWN,
+			NULL, 0, HOSTED_BLOCK_MAX);
+	return ESP_OK;
+}
+
+static inline esp_err_t esp_hosted_reconfigure(void)
+{
+	if (!esp_hosted_is_config_valid()) {
+		ESP_LOGE(TAG, "Transport not initialized, call esp_hosted_init() first");
+		return ESP_FAIL;
+	}
+
+	ESP_ERROR_CHECK_WITHOUT_ABORT(transport_drv_reconfigure());
+	return ESP_OK;
+}
+
+int esp_hosted_connect_to_slave(void)
+{
+	ESP_LOGI(TAG, "ESP-Hosted Try to communicate with ESP-Hosted slave\n");
+	return esp_hosted_reconfigure();
+}
+
+esp_remote_channel_t esp_hosted_add_channel(esp_remote_channel_config_t config,
+		esp_remote_channel_tx_fn_t *tx, const esp_remote_channel_rx_fn_t rx)
+{
+	transport_channel_t *t_chan = NULL;
+	esp_remote_channel_t eh_chan = NULL;
+
+	eh_chan = g_h.funcs->_h_calloc(sizeof(struct esp_remote_channel), 1);
+	assert(eh_chan);
+
+	t_chan = transport_drv_add_channel(eh_chan, config->if_type, config->secure, tx, rx);
+	if (t_chan) {
+		*tx = t_chan->tx;
+		eh_chan->t_chan = t_chan;
+		return eh_chan;
+	} else {
+		HOSTED_FREE(eh_chan);
+	}
+
+	return NULL;
+}
+
+esp_err_t esp_hosted_remove_channel(esp_remote_channel_t eh_chan)
+{
+	if (eh_chan && eh_chan->t_chan) {
+		transport_drv_remove_channel(eh_chan->t_chan);
+		HOSTED_FREE(eh_chan);
+		return ESP_OK;
+	}
+
+	return ESP_FAIL;
+}
+
+esp_err_t esp_wifi_remote_init(const wifi_init_config_t *arg)
+{
+	ESP_ERROR_CHECK_WITHOUT_ABORT(esp_hosted_reconfigure());
+	check_transport_up();
+	return rpc_wifi_init(arg);
+}
+
+esp_err_t esp_wifi_remote_deinit(void)
+{
+	check_transport_up();
+	return rpc_wifi_deinit();
+}
+
+esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode)
+{
+	check_transport_up();
+	return rpc_wifi_set_mode(mode);
+}
+
+esp_err_t esp_wifi_remote_get_mode(wifi_mode_t* mode)
+{
+	check_transport_up();
+	return rpc_wifi_get_mode(mode);
+}
+
+esp_err_t esp_wifi_remote_start(void)
+{
+	check_transport_up();
+	return rpc_wifi_start();
+}
+
+esp_err_t esp_wifi_remote_stop(void)
+{
+	check_transport_up();
+	return rpc_wifi_stop();
+}
+
+esp_err_t esp_wifi_remote_connect(void)
+{
+	ESP_LOGI(TAG, "%s",__func__);
+	check_transport_up();
+	return rpc_wifi_connect();
+}
+
+esp_err_t esp_wifi_remote_disconnect(void)
+{
+	check_transport_up();
+	return rpc_wifi_disconnect();
+}
+
+esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf)
+{
+	check_transport_up();
+	return rpc_wifi_set_config(interface, conf);
+}
+
+esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf)
+{
+	check_transport_up();
+	return rpc_wifi_get_config(interface, conf);
+}
+
+esp_err_t esp_wifi_remote_get_mac(wifi_interface_t mode, uint8_t mac[6])
+{
+	check_transport_up();
+	return rpc_wifi_get_mac(mode, mac);
+}
+
+esp_err_t esp_wifi_remote_set_mac(wifi_interface_t mode, const uint8_t mac[6])
+{
+	check_transport_up();
+	return rpc_wifi_set_mac(mode, mac);
+}
+
+esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, bool block)
+{
+	check_transport_up();
+	return rpc_wifi_scan_start(config, block);
+}
+
+esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config)
+{
+	check_transport_up();
+	return rpc_wifi_set_scan_parameters(config);
+}
+
+esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config)
+{
+	check_transport_up();
+	return rpc_wifi_get_scan_parameters(config);
+}
+
+esp_err_t esp_wifi_remote_scan_stop(void)
+{
+	check_transport_up();
+	return rpc_wifi_scan_stop();
+}
+
+esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number)
+{
+	check_transport_up();
+	return rpc_wifi_scan_get_ap_num(number);
+}
+
+esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record)
+{
+	check_transport_up();
+	return rpc_wifi_scan_get_ap_record(ap_record);
+}
+
+esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records)
+{
+	check_transport_up();
+	return rpc_wifi_scan_get_ap_records(number, ap_records);
+}
+
+esp_err_t esp_wifi_remote_clear_ap_list(void)
+{
+	check_transport_up();
+	return rpc_wifi_clear_ap_list();
+}
+
+esp_err_t esp_wifi_remote_restore(void)
+{
+	check_transport_up();
+	return rpc_wifi_restore();
+}
+
+esp_err_t esp_wifi_remote_clear_fast_connect(void)
+{
+	check_transport_up();
+	return rpc_wifi_clear_fast_connect();
+}
+
+esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid)
+{
+	check_transport_up();
+	return rpc_wifi_deauth_sta(aid);
+}
+
+esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info)
+{
+	check_transport_up();
+	return rpc_wifi_sta_get_ap_info(ap_info);
+}
+
+esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type)
+{
+	check_transport_up();
+	return rpc_wifi_set_ps(type);
+}
+
+esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type)
+{
+	check_transport_up();
+	return rpc_wifi_get_ps(type);
+}
+
+esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage)
+{
+	check_transport_up();
+	return rpc_wifi_set_storage(storage);
+}
+
+esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw)
+{
+	check_transport_up();
+	return rpc_wifi_set_bandwidth(ifx, bw);
+}
+
+esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw)
+{
+	check_transport_up();
+	return rpc_wifi_get_bandwidth(ifx, bw);
+}
+
+esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second)
+{
+	check_transport_up();
+	return rpc_wifi_set_channel(primary, second);
+}
+
+esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second)
+{
+	check_transport_up();
+	return rpc_wifi_get_channel(primary, second);
+}
+
+esp_err_t esp_wifi_remote_set_country_code(const char *country, bool ieee80211d_enabled)
+{
+	check_transport_up();
+	return rpc_wifi_set_country_code(country, ieee80211d_enabled);
+}
+
+esp_err_t esp_wifi_remote_get_country_code(char *country)
+{
+	check_transport_up();
+	return rpc_wifi_get_country_code(country);
+}
+
+esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country)
+{
+	check_transport_up();
+	return rpc_wifi_set_country(country);
+}
+
+esp_err_t esp_wifi_remote_get_country(wifi_country_t *country)
+{
+	check_transport_up();
+	return rpc_wifi_get_country(country);
+}
+
+esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta)
+{
+	check_transport_up();
+	return rpc_wifi_ap_get_sta_list(sta);
+}
+
+esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid)
+{
+	check_transport_up();
+	return rpc_wifi_ap_get_sta_aid(mac, aid);
+}
+
+esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi)
+{
+	check_transport_up();
+	return rpc_wifi_sta_get_rssi(rssi);
+}
+
+esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap)
+{
+	check_transport_up();
+	return rpc_wifi_set_protocol(ifx, protocol_bitmap);
+}
+
+esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap)
+{
+	check_transport_up();
+	return rpc_wifi_get_protocol(ifx, protocol_bitmap);
+}
+
+esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power)
+{
+	check_transport_up();
+	return rpc_wifi_set_max_tx_power(power);
+}
+
+esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power)
+{
+	check_transport_up();
+	return rpc_wifi_get_max_tx_power(power);
+}
+
+esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
+{
+	check_transport_up();
+	return rpc_wifi_sta_get_negotiated_phymode(phymode);
+}
+
+esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid)
+{
+	check_transport_up();
+	return rpc_wifi_sta_get_aid(aid);
+}
+
+esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec)
+{
+	check_transport_up();
+	return rpc_wifi_set_inactive_time(ifx, sec);
+}
+
+esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec)
+{
+	check_transport_up();
+	return rpc_wifi_get_inactive_time(ifx, sec);
+}
+
+esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx)
+{
+	check_transport_up();
+	return rpc_wifi_disable_pmf_config(ifx);
+}
+
+#if H_WIFI_HE_SUPPORT
+esp_err_t esp_wifi_remote_sta_twt_config(wifi_twt_config_t *config)
+{
+	check_transport_up();
+	return rpc_wifi_sta_twt_config(config);
+}
+
+#if H_WIFI_HE_GREATER_THAN_ESP_IDF_5_3
+esp_err_t esp_wifi_remote_sta_itwt_setup(wifi_itwt_setup_config_t *setup_config)
+#else
+esp_err_t esp_wifi_remote_sta_itwt_setup(wifi_twt_setup_config_t *setup_config)
+#endif
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_setup(setup_config);
+}
+
+esp_err_t esp_wifi_remote_sta_itwt_teardown(int flow_id)
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_teardown(flow_id);
+}
+
+esp_err_t esp_wifi_remote_sta_itwt_suspend(int flow_id, int suspend_time_ms)
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_suspend(flow_id, suspend_time_ms);
+}
+
+esp_err_t esp_wifi_remote_sta_itwt_get_flow_id_status(int *flow_id_bitmap)
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_get_flow_id_status(flow_id_bitmap);
+}
+
+esp_err_t esp_wifi_remote_sta_itwt_send_probe_req(int timeout_ms)
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_send_probe_req(timeout_ms);
+}
+
+esp_err_t esp_wifi_remote_sta_itwt_set_target_wake_time_offset(int offset_us)
+{
+	check_transport_up();
+	return rpc_wifi_sta_itwt_set_target_wake_time_offset(offset_us);
+}
+#endif
+
+#if H_WIFI_DUALBAND_SUPPORT
+/* Dual-band WiFi API - always available at high level, but returns ESP_ERR_NOT_SUPPORTED when co-processor do not support */
+esp_err_t esp_wifi_remote_set_band(wifi_band_t band)
+{
+	check_transport_up();
+	return rpc_wifi_set_band(band);
+}
+
+esp_err_t esp_wifi_remote_get_band(wifi_band_t *band)
+{
+	check_transport_up();
+	return rpc_wifi_get_band(band);
+}
+
+esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode)
+{
+	check_transport_up();
+	return rpc_wifi_set_band_mode(band_mode);
+}
+
+esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode)
+{
+	check_transport_up();
+	return rpc_wifi_get_band_mode(band_mode);
+}
+
+esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols)
+{
+	check_transport_up();
+	return rpc_wifi_set_protocols(ifx, protocols);
+}
+
+esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols)
+{
+	check_transport_up();
+	return rpc_wifi_get_protocols(ifx, protocols);
+}
+
+esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw)
+{
+	check_transport_up();
+	return rpc_wifi_set_bandwidths(ifx, bw);
+}
+
+esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw)
+{
+	check_transport_up();
+	return rpc_wifi_get_bandwidths(ifx, bw);
+}
+#endif
+
+#if H_DPP_SUPPORT
+#if H_SUPP_DPP_SUPPORT
+esp_err_t esp_supp_remote_dpp_init(esp_supp_dpp_event_cb_t evt_cb)
+{
+	check_transport_up();
+	return rpc_supp_dpp_init(evt_cb);
+}
+#else
+esp_err_t esp_supp_remote_dpp_init(void)
+{
+	check_transport_up();
+	return rpc_supp_dpp_init();
+}
+#endif
+
+esp_err_t esp_supp_remote_dpp_deinit(void)
+{
+	check_transport_up();
+	return rpc_supp_dpp_deinit();
+}
+
+esp_err_t esp_supp_remote_dpp_bootstrap_gen(const char *chan_list,
+		esp_supp_dpp_bootstrap_t type,
+		const char *key, const char *info)
+{
+	check_transport_up();
+	return rpc_supp_dpp_bootstrap_gen(chan_list, type, key, info);
+}
+
+esp_err_t esp_supp_remote_dpp_start_listen(void)
+{
+	check_transport_up();
+	return rpc_supp_dpp_start_listen();
+}
+
+esp_err_t esp_supp_remote_dpp_stop_listen(void)
+{
+	check_transport_up();
+	return rpc_supp_dpp_stop_listen();
+}
+#endif
+
+esp_err_t esp_hosted_get_coprocessor_fwversion(esp_hosted_coprocessor_fwver_t *ver_info)
+{
+	check_transport_up();
+	return rpc_get_coprocessor_fwversion(ver_info);
+}
+
+esp_err_t esp_hosted_get_cp_info(uint32_t *cp_chip_id, char *cp_target_name,
+		size_t cp_target_name_len)
+{
+	check_transport_up();
+	return rpc_get_cp_info(cp_chip_id, cp_target_name, cp_target_name_len);
+}
+
+#if H_WIFI_ENTERPRISE_SUPPORT
+esp_err_t esp_wifi_remote_sta_enterprise_enable(void)
+{
+	check_transport_up();
+	return rpc_wifi_sta_enterprise_enable();
+}
+
+esp_err_t esp_wifi_remote_sta_enterprise_disable(void)
+{
+	check_transport_up();
+	return rpc_wifi_sta_enterprise_disable();
+}
+
+esp_err_t esp_eap_client_remote_set_identity(const unsigned char *identity, int len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_identity(identity, len);
+}
+
+esp_err_t esp_eap_client_remote_clear_identity(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_identity();
+}
+
+esp_err_t esp_eap_client_remote_set_username(const unsigned char *username, int len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_username(username, len);
+}
+
+esp_err_t esp_eap_client_remote_clear_username(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_username();
+}
+
+esp_err_t esp_eap_client_remote_set_password(const unsigned char *password, int len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_password(password, len);
+}
+
+esp_err_t esp_eap_client_remote_clear_password(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_password();
+}
+
+esp_err_t esp_eap_client_remote_set_new_password(const unsigned char *new_password, int len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_new_password(new_password, len);
+}
+
+esp_err_t esp_eap_client_remote_clear_new_password(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_new_password();
+}
+
+esp_err_t esp_eap_client_remote_set_ca_cert(const unsigned char *ca_cert, int ca_cert_len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_ca_cert(ca_cert, ca_cert_len);
+}
+
+esp_err_t esp_eap_client_remote_clear_ca_cert(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_ca_cert();
+}
+
+esp_err_t esp_eap_client_remote_set_certificate_and_key(const unsigned char *client_cert,
+							int client_cert_len,
+							const unsigned char *private_key,
+							int private_key_len,
+							const unsigned char *private_key_password,
+							int private_key_passwd_len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_certificate_and_key(client_cert, client_cert_len, private_key,
+						      private_key_len, private_key_password, private_key_passwd_len);
+}
+
+esp_err_t esp_eap_client_remote_clear_certificate_and_key(void)
+{
+	check_transport_up();
+	return rpc_eap_client_clear_certificate_and_key();
+}
+
+esp_err_t esp_eap_client_remote_set_disable_time_check(bool disable)
+{
+	check_transport_up();
+	return rpc_eap_client_set_disable_time_check(disable);
+}
+
+esp_err_t esp_eap_client_remote_get_disable_time_check(bool *disable)
+{
+	check_transport_up();
+	return rpc_eap_client_get_disable_time_check(disable);
+}
+
+esp_err_t esp_eap_client_remote_set_ttls_phase2_method(esp_eap_ttls_phase2_types type)
+{
+	check_transport_up();
+	return rpc_eap_client_set_ttls_phase2_method(type);
+}
+
+esp_err_t esp_eap_client_remote_set_suiteb_192bit_certification(bool enable)
+{
+	check_transport_up();
+	return rpc_eap_client_set_suiteb_192bit_certification(enable);
+}
+
+esp_err_t esp_eap_client_remote_set_pac_file(const unsigned char *pac_file, int pac_file_len)
+{
+	check_transport_up();
+	return rpc_eap_client_set_pac_file(pac_file, pac_file_len);
+}
+
+esp_err_t esp_eap_client_remote_set_fast_params(esp_eap_fast_config config)
+{
+	check_transport_up();
+	return rpc_eap_client_set_fast_params(config);
+}
+
+esp_err_t esp_eap_client_remote_use_default_cert_bundle(bool use_default_bundle)
+{
+	check_transport_up();
+	return rpc_eap_client_use_default_cert_bundle(use_default_bundle);
+}
+
+esp_err_t esp_wifi_remote_set_okc_support(bool enable)
+{
+	check_transport_up();
+	return rpc_wifi_set_okc_support(enable);
+}
+
+esp_err_t esp_eap_client_remote_set_domain_name(const char *domain_name)
+{
+	check_transport_up();
+	return rpc_eap_client_set_domain_name(domain_name);
+}
+
+#if H_GOT_SET_EAP_METHODS_API
+esp_err_t esp_eap_client_remote_set_eap_methods(esp_eap_method_t methods)
+{
+	check_transport_up();
+	return rpc_eap_client_set_eap_methods(methods);
+}
+#endif
+#endif
+
+esp_err_t esp_hosted_bt_controller_init(void)
+{
+	check_transport_up();
+	return rpc_bt_controller_init();
+}
+
+esp_err_t esp_hosted_bt_controller_deinit(bool mem_release)
+{
+	check_transport_up();
+	return rpc_bt_controller_deinit(mem_release);
+}
+
+esp_err_t esp_hosted_bt_controller_enable(void)
+{
+	check_transport_up();
+	return rpc_bt_controller_enable();
+}
+
+esp_err_t esp_hosted_bt_controller_disable(void)
+{
+	check_transport_up();
+	return rpc_bt_controller_disable();
+}
+
+static bool check_mac_len(size_t mac_len, esp_mac_type_t type)
+{
+	if (((type == ESP_MAC_IEEE802154) && (mac_len == 8)) ||
+			((type == ESP_MAC_EFUSE_EXT) && (mac_len == 2)) ||
+			(mac_len == 6)) {
+		return true;
+	}
+	return false;
+}
+
+esp_err_t esp_hosted_iface_mac_addr_set(uint8_t *mac, size_t mac_len, esp_mac_type_t type)
+{
+	// check that incoming mac_len is correct for the provided type
+	if (!check_mac_len(mac_len, type)) {
+		ESP_LOGE(TAG, "Invalid mac length for provided MAC type");
+		return ESP_ERR_INVALID_ARG;
+	}
+
+	check_transport_up();
+	return rpc_iface_mac_addr_set_get(true, mac, mac_len, type);
+}
+
+esp_err_t esp_hosted_iface_mac_addr_get(uint8_t *mac, size_t mac_len, esp_mac_type_t type)
+{
+	// check that incoming mac_len is correct for the provided type
+	if (!check_mac_len(mac_len, type)) {
+		ESP_LOGE(TAG, "Invalid mac length for provided MAC type");
+		return ESP_ERR_INVALID_ARG;
+	}
+
+	check_transport_up();
+	return rpc_iface_mac_addr_set_get(false, mac, mac_len, type);
+}
+
+size_t esp_hosted_iface_mac_addr_len_get(esp_mac_type_t type)
+{
+	// NOTE: this API returns size_t, not esp_err_t
+	// to match size_t esp_mac_addr_len_get(esp_mac_type_t type)
+	size_t len;
+
+	check_transport_up();
+	if (ESP_OK != rpc_iface_mac_addr_len_get(&len, type)) {
+		return 0;
+	} else {
+		return len;
+	}
+}
+
+esp_err_t esp_hosted_get_coprocessor_app_desc(esp_hosted_app_desc_t *app_desc)
+{
+	check_transport_up();
+	return rpc_iface_get_coprocessor_app_desc(app_desc);
+}
+
+esp_err_t esp_hosted_configure_heartbeat(bool enable, int duration_sec)
+{
+	check_transport_up();
+	return rpc_iface_configure_heartbeat(enable, duration_sec);
+}
+
+#if H_MEM_MONITOR
+esp_err_t esp_hosted_set_mem_monitor(esp_hosted_config_mem_monitor_t *config, esp_hosted_curr_mem_info_t *curr_mem_info)
+{
+	check_transport_up();
+	if (!config || !curr_mem_info) {
+		ESP_LOGE(TAG, "%s: got NULL pointer(s)", __func__);
+		return ESP_ERR_INVALID_ARG;
+	}
+	return rpc_iface_set_mem_monitor(config, curr_mem_info);
+}
+#endif
+
+#if H_HOST_OT_ENABLE
+esp_err_t esp_hosted_openthread_rcp_init(void)
+{
+	check_transport_up();
+	return rpc_iface_openthread_rcp_init();
+}
+
+esp_err_t esp_hosted_openthread_rcp_deinit(void)
+{
+	check_transport_up();
+	return rpc_iface_openthread_rcp_deinit();
+}
+
+esp_err_t esp_hosted_openthread_rcp_start(void)
+{
+	check_transport_up();
+	return rpc_iface_openthread_rcp_start();
+}
+
+esp_err_t esp_hosted_openthread_rcp_stop(void)
+{
+	check_transport_up();
+	return rpc_iface_openthread_rcp_stop();
+}
+
+esp_err_t esp_hosted_openthread_rcp_query(esp_hosted_openthread_query_t query)
+{
+	check_transport_up();
+	return rpc_iface_openthread_rcp_query(query);
+}
+#endif
+
+/* esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record)
+esp_err_t esp_wifi_remote_set_csi(_Bool en)
+esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx)
+esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config)
+esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie)
+esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx)
+
+esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid)
+esp_err_t esp_wifi_remote_set_ant_gpio(const wifi_ant_gpio_config_t *config)
+esp_err_t esp_wifi_remote_get_ant_gpio(wifi_ant_gpio_config_t *config)
+esp_err_t esp_wifi_remote_set_ant(const wifi_ant_config_t *config)
+esp_err_t esp_wifi_remote_get_ant(wifi_ant_config_t *config)
+int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface)
+esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec)
+esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec)
+esp_err_t esp_wifi_remote_statis_dump(uint32_t modules)
+esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi)
+esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg)
+esp_err_t esp_wifi_remote_ftm_end_session(void)
+esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm)
+esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries)
+esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable)
+esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval)
+esp_err_t esp_wifi_remote_force_wakeup_acquire(void)
+esp_err_t esp_wifi_remote_force_wakeup_release(void)
+esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask)
+esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask)
+esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq)
+esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb)
+esp_err_t esp_wifi_remote_set_promiscuous(_Bool en)
+esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en)
+esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter)
+esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter)
+esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter)
+esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter)
+
+esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate)
+esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
+esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled) */
+
+#ifdef __cplusplus
+}
+#endif

firmware/components/esp_hosted/host/api/src/esp_hosted_ota_api.c

@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "esp_hosted.h"
+#include "esp_log.h"
+#include "rpc_wrap.h"
+#include "esp_hosted_os_abstraction.h"
+
+static const char* TAG = "esp_hosted_ota";
+
+esp_err_t esp_hosted_slave_ota_begin(void)
+{
+    ESP_LOGD(TAG, "Starting OTA on slave device");
+    return rpc_ota_begin();
+}
+
+esp_err_t esp_hosted_slave_ota_write(uint8_t* ota_data, uint32_t ota_data_len)
+{
+    esp_err_t ret = ESP_OK;
+
+    if (!ota_data || ota_data_len == 0) {
+        ESP_LOGE(TAG, "Invalid OTA data parameters");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    ESP_LOGV(TAG, "Writing %ld bytes of OTA data", ota_data_len);
+    ret = rpc_ota_write(ota_data, ota_data_len);
+    g_h.funcs->_h_msleep(10);
+    return ret;
+}
+
+esp_err_t esp_hosted_slave_ota_end(void)
+{
+    ESP_LOGD(TAG, "Ending OTA on slave device");
+    return rpc_ota_end();
+}
+
+esp_err_t esp_hosted_slave_ota_activate(void)
+{
+    ESP_LOGD(TAG, "Activating OTA on slave device");
+    return rpc_ota_activate();
+}

firmware/components/esp_hosted/host/api/src/esp_hosted_transport_config.c

@@ -0,0 +1,261 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
+*
+* SPDX-License-Identifier: Apache-2.0
+*/
+
+#include <string.h>
+#include "esp_log.h"
+
+#include "port_esp_hosted_host_config.h"
+#include "esp_hosted_transport_config.h"
+
+static const char *TAG = "esp_hosted_transport_config";
+
+/* Static configurations */
+static struct esp_hosted_transport_config s_transport_config = { 0 };
+
+/* Flags to track if configs were set */
+static bool esp_hosted_transport_config_set;
+
+bool esp_hosted_transport_is_config_valid(void) {
+  return esp_hosted_transport_config_set;
+}
+
+esp_err_t esp_hosted_set_default_config(void) {
+  return esp_hosted_transport_set_default_config();
+}
+
+bool esp_hosted_is_config_valid(void) {
+  return esp_hosted_transport_is_config_valid();
+}
+
+esp_hosted_transport_err_t esp_hosted_transport_set_default_config(void)
+{
+	memset(&s_transport_config, 0, sizeof(s_transport_config));
+
+#if H_TRANSPORT_IN_USE == H_TRANSPORT_SDIO
+	ESP_ERROR_CHECK(esp_hosted_sdio_set_config(NULL));
+#elif H_TRANSPORT_IN_USE == H_TRANSPORT_SPI_HD
+	ESP_ERROR_CHECK(esp_hosted_spi_hd_set_config(NULL));
+#elif H_TRANSPORT_IN_USE == H_TRANSPORT_SPI
+	ESP_ERROR_CHECK(esp_hosted_spi_set_config(NULL));
+#elif H_TRANSPORT_IN_USE == H_TRANSPORT_UART
+	ESP_ERROR_CHECK(esp_hosted_uart_set_config(NULL));
+#else
+	return ESP_TRANSPORT_ERR_INVALID_STATE;
+#endif
+
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_transport_get_config(struct esp_hosted_transport_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_transport_get_reset_config(gpio_pin_t *pin_config)
+{
+	if (!pin_config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+
+	switch(s_transport_config.transport_in_use) {
+	case H_TRANSPORT_SDIO:
+		pin_config->port = s_transport_config.u.sdio.pin_reset.port;
+		pin_config->pin  = s_transport_config.u.sdio.pin_reset.pin;
+		break;
+	case H_TRANSPORT_SPI_HD:
+		pin_config->port = s_transport_config.u.spi_hd.pin_reset.port;
+		pin_config->pin  = s_transport_config.u.spi_hd.pin_reset.pin;
+		break;
+	case H_TRANSPORT_SPI:
+		pin_config->port = s_transport_config.u.spi.pin_reset.port;
+		pin_config->pin  = s_transport_config.u.spi.pin_reset.pin;
+		break;
+	case H_TRANSPORT_UART:
+		pin_config->port = s_transport_config.u.uart.pin_reset.port;
+		pin_config->pin  = s_transport_config.u.uart.pin_reset.pin;
+		break;
+	case H_TRANSPORT_NONE: // drop through to default case
+	default:
+		// transport config not yet initialised. Use default Reset pin config
+		pin_config->port = H_GPIO_PORT_RESET;
+		pin_config->pin  = H_GPIO_PIN_RESET;
+		break;
+	}
+
+	return ESP_TRANSPORT_OK;
+}
+
+#if H_TRANSPORT_IN_USE == H_TRANSPORT_SDIO
+/* SDIO functions */
+esp_hosted_transport_err_t esp_hosted_sdio_get_config(struct esp_hosted_sdio_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config.u.sdio;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_sdio_set_config(struct esp_hosted_sdio_config *config)
+{
+	struct esp_hosted_sdio_config new_config = config ? *config : INIT_DEFAULT_HOST_SDIO_CONFIG();
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.sdio, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.sdio = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_SDIO;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_sdio_iomux_set_config(struct esp_hosted_sdio_config *config)
+{
+	struct esp_hosted_sdio_config new_config = config ? *config : INIT_DEFAULT_HOST_SDIO_IOMUX_CONFIG();
+	new_config.iomux_enable = true;
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.sdio, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.sdio = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_SDIO;
+	return ESP_TRANSPORT_OK;
+}
+#endif
+
+#if H_TRANSPORT_IN_USE == H_TRANSPORT_SPI_HD
+/* SPI Half Duplex functions */
+esp_hosted_transport_err_t esp_hosted_spi_hd_get_config(struct esp_hosted_spi_hd_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config.u.spi_hd;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_spi_hd_set_config(struct esp_hosted_spi_hd_config *config)
+{
+	struct esp_hosted_spi_hd_config new_config = config ? *config : INIT_DEFAULT_HOST_SPI_HD_CONFIG();
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.spi_hd, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.spi_hd = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_SPI_HD;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_spi_hd_2lines_get_config(struct esp_hosted_spi_hd_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config.u.spi_hd;
+	s_transport_config.u.spi_hd.num_data_lines = 2;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_spi_hd_2lines_set_config(struct esp_hosted_spi_hd_config *config)
+{
+	struct esp_hosted_spi_hd_config new_config = config ? *config : INIT_DEFAULT_HOST_SPI_HD_CONFIG();
+	new_config.num_data_lines = 2;
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.spi_hd, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.spi_hd = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_SPI_HD;
+	return ESP_TRANSPORT_OK;
+}
+#endif
+
+#if H_TRANSPORT_IN_USE == H_TRANSPORT_SPI
+/* SPI Full Duplex functions */
+esp_hosted_transport_err_t esp_hosted_spi_get_config(struct esp_hosted_spi_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config.u.spi;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_spi_set_config(struct esp_hosted_spi_config *config)
+{
+	struct esp_hosted_spi_config new_config = config ? *config : INIT_DEFAULT_HOST_SPI_CONFIG();
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.spi, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.spi = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_SPI;
+	return ESP_TRANSPORT_OK;
+}
+#endif
+
+#if H_TRANSPORT_IN_USE == H_TRANSPORT_UART
+/* UART functions */
+esp_hosted_transport_err_t esp_hosted_uart_get_config(struct esp_hosted_uart_config **config)
+{
+	if (!config) {
+		return ESP_TRANSPORT_ERR_INVALID_ARG;
+	}
+	*config = &s_transport_config.u.uart;
+	return ESP_TRANSPORT_OK;
+}
+
+esp_hosted_transport_err_t esp_hosted_uart_set_config(struct esp_hosted_uart_config *config)
+{
+	struct esp_hosted_uart_config new_config = config ? *config : INIT_DEFAULT_HOST_UART_CONFIG();
+
+	if (esp_hosted_transport_config_set) {
+		if (memcmp(&s_transport_config.u.uart, &new_config, sizeof(new_config)) == 0) {
+			return ESP_TRANSPORT_OK;
+		}
+		ESP_LOGE(TAG, "Transport already initialized (through constructor?), reconfiguring not allowed");
+		return ESP_TRANSPORT_ERR_ALREADY_SET;
+	}
+
+	s_transport_config.u.uart = new_config;
+	esp_hosted_transport_config_set = true;
+	s_transport_config.transport_in_use = H_TRANSPORT_UART;
+	return ESP_TRANSPORT_OK;
+}
+#endif

firmware/components/esp_hosted/host/api/src/esp_wifi_weak.c

@@ -0,0 +1,505 @@
+/*
+ * SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Weak version of esp_wifi API.
+ *
+ * Used when WiFi-Remote does not provide required esp_wifi calls
+ */
+
+#include "esp_hosted_api_priv.h"
+#include "port_esp_hosted_host_config.h"
+#include "port_esp_hosted_host_wifi_config.h"
+
+#if H_DPP_SUPPORT
+#include "esp_dpp.h"
+#endif
+
+H_WEAK_REF esp_err_t esp_wifi_init(const wifi_init_config_t *config)
+{
+	return esp_wifi_remote_init(config);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_deinit(void)
+{
+	return esp_wifi_remote_deinit();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_mode(wifi_mode_t mode)
+{
+	return esp_wifi_remote_set_mode(mode);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_mode(wifi_mode_t *mode)
+{
+	return esp_wifi_remote_get_mode(mode);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_start(void)
+{
+	return esp_wifi_remote_start();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_stop(void)
+{
+	return esp_wifi_remote_stop();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_restore(void)
+{
+	return esp_wifi_remote_restore();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_connect(void)
+{
+	return esp_wifi_remote_connect();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_disconnect(void)
+{
+	return esp_wifi_remote_disconnect();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_clear_fast_connect(void)
+{
+	return esp_wifi_remote_clear_fast_connect();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_deauth_sta(uint16_t aid)
+{
+	return esp_wifi_remote_deauth_sta(aid);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_scan_start(const wifi_scan_config_t *config, bool block)
+{
+	return esp_wifi_remote_scan_start(config, block);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_scan_parameters(const wifi_scan_default_params_t *config)
+{
+	return esp_wifi_remote_set_scan_parameters(config);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_scan_parameters(wifi_scan_default_params_t *config)
+{
+	return esp_wifi_remote_get_scan_parameters(config);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_scan_stop(void)
+{
+	return esp_wifi_remote_scan_stop();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_scan_get_ap_num(uint16_t *number)
+{
+	return esp_wifi_remote_scan_get_ap_num(number);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_scan_get_ap_record(wifi_ap_record_t *ap_record)
+{
+	return esp_wifi_remote_scan_get_ap_record(ap_record);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records)
+{
+	return esp_wifi_remote_scan_get_ap_records(number, ap_records);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_clear_ap_list(void)
+{
+	return esp_wifi_remote_clear_ap_list();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_get_ap_info(wifi_ap_record_t *ap_info)
+{
+	return esp_wifi_remote_sta_get_ap_info(ap_info);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_ps(wifi_ps_type_t type)
+{
+	return esp_wifi_remote_set_ps(type);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_ps(wifi_ps_type_t *type)
+{
+	return esp_wifi_remote_get_ps(type);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap)
+{
+	return esp_wifi_remote_set_protocol(ifx, protocol_bitmap);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap)
+{
+	return esp_wifi_remote_get_protocol(ifx, protocol_bitmap);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw)
+{
+	return esp_wifi_remote_set_bandwidth(ifx, bw);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw)
+{
+	return esp_wifi_remote_get_bandwidth(ifx, bw);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_channel(uint8_t primary, wifi_second_chan_t second)
+{
+	return esp_wifi_remote_set_channel(primary, second);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_channel(uint8_t *primary, wifi_second_chan_t *second)
+{
+	return esp_wifi_remote_get_channel(primary, second);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_country(const wifi_country_t *country)
+{
+	return esp_wifi_remote_set_country(country);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_country(wifi_country_t *country)
+{
+	return esp_wifi_remote_get_country(country);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_mac(wifi_interface_t ifx, const uint8_t mac[6])
+{
+	return esp_wifi_remote_set_mac(ifx, mac);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_mac(wifi_interface_t ifx, uint8_t mac[6])
+{
+	return esp_wifi_remote_get_mac(ifx, mac);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_config(wifi_interface_t interface, wifi_config_t *conf)
+{
+	return esp_wifi_remote_set_config(interface, conf);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_config(wifi_interface_t interface, wifi_config_t *conf)
+{
+	return esp_wifi_remote_get_config(interface, conf);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_ap_get_sta_list(wifi_sta_list_t *sta)
+{
+	return esp_wifi_remote_ap_get_sta_list(sta);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid)
+{
+	return esp_wifi_remote_ap_get_sta_aid(mac, aid);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_storage(wifi_storage_t storage)
+{
+	return esp_wifi_remote_set_storage(storage);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_max_tx_power(int8_t power)
+{
+	return esp_wifi_remote_set_max_tx_power(power);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_max_tx_power(int8_t *power)
+{
+	return esp_wifi_remote_get_max_tx_power(power);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_country_code(const char *country, bool ieee80211d_enabled)
+{
+	return esp_wifi_remote_set_country_code(country, ieee80211d_enabled);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_country_code(char *country)
+{
+	return esp_wifi_remote_get_country_code(country);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
+{
+	return esp_wifi_remote_sta_get_negotiated_phymode(phymode);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_get_aid(uint16_t *aid)
+{
+	return esp_wifi_remote_sta_get_aid(aid);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_get_rssi(int *rssi)
+{
+	return esp_wifi_remote_sta_get_rssi(rssi);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_inactive_time(wifi_interface_t ifx, uint16_t sec)
+{
+	return esp_wifi_remote_set_inactive_time(ifx, sec);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_inactive_time(wifi_interface_t ifx, uint16_t *sec)
+{
+	return esp_wifi_remote_get_inactive_time(ifx, sec);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_disable_pmf_config(wifi_interface_t ifx)
+{
+	return esp_wifi_remote_disable_pmf_config(ifx);
+}
+
+#if H_WIFI_HE_SUPPORT
+H_WEAK_REF esp_err_t esp_wifi_sta_twt_config(wifi_twt_config_t *config)
+{
+	return esp_wifi_remote_sta_twt_config(config);
+}
+
+#if H_WIFI_HE_GREATER_THAN_ESP_IDF_5_3
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_setup(wifi_itwt_setup_config_t *setup_config)
+#else
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_setup(wifi_twt_setup_config_t *setup_config)
+#endif
+{
+	return esp_wifi_remote_sta_itwt_setup(setup_config);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_teardown(int flow_id)
+{
+	return esp_wifi_remote_sta_itwt_teardown(flow_id);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_suspend(int flow_id, int suspend_time_ms)
+{
+	return esp_wifi_remote_sta_itwt_suspend(flow_id, suspend_time_ms);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_get_flow_id_status(int *flow_id_bitmap)
+{
+	return esp_wifi_remote_sta_itwt_get_flow_id_status(flow_id_bitmap);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_send_probe_req(int timeout_ms)
+{
+	return esp_wifi_remote_sta_itwt_send_probe_req(timeout_ms);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_itwt_set_target_wake_time_offset(int offset_us)
+{
+	return esp_wifi_remote_sta_itwt_set_target_wake_time_offset(offset_us);
+}
+
+#endif
+
+#if H_WIFI_DUALBAND_SUPPORT
+H_WEAK_REF esp_err_t esp_wifi_set_band(wifi_band_t band)
+{
+	return esp_wifi_remote_set_band(band);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_band(wifi_band_t *band)
+{
+	return esp_wifi_remote_get_band(band);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_band_mode(wifi_band_mode_t band_mode)
+{
+	return esp_wifi_remote_set_band_mode(band_mode);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_band_mode(wifi_band_mode_t *band_mode)
+{
+	return esp_wifi_remote_get_band_mode(band_mode);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols)
+{
+	return esp_wifi_remote_set_protocols(ifx, protocols);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols)
+{
+	return esp_wifi_remote_get_protocols(ifx, protocols);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw)
+{
+	return esp_wifi_remote_set_bandwidths(ifx, bw);
+}
+
+H_WEAK_REF esp_err_t esp_wifi_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw)
+{
+	return esp_wifi_remote_get_bandwidths(ifx, bw);
+}
+#endif
+
+#if H_WIFI_ENTERPRISE_SUPPORT
+H_WEAK_REF esp_err_t esp_wifi_sta_enterprise_enable(void)
+{
+	return esp_wifi_remote_sta_enterprise_enable();
+}
+
+H_WEAK_REF esp_err_t esp_wifi_sta_enterprise_disable(void)
+{
+	return esp_wifi_remote_sta_enterprise_disable();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_identity(const unsigned char *identity, int len)
+{
+	return esp_eap_client_remote_set_identity(identity, len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_identity(void)
+{
+	esp_eap_client_remote_clear_identity();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_username(const unsigned char *username, int len)
+{
+	return esp_eap_client_remote_set_username(username, len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_username(void)
+{
+	esp_eap_client_remote_clear_username();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_password(const unsigned char *password, int len)
+{
+	return esp_eap_client_remote_set_password(password, len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_password(void)
+{
+	esp_eap_client_remote_clear_password();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_new_password(const unsigned char *new_password, int len)
+{
+	return esp_eap_client_remote_set_new_password(new_password, len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_new_password(void)
+{
+	esp_eap_client_remote_clear_new_password();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_ca_cert(const unsigned char *ca_cert, int ca_cert_len)
+{
+	return esp_eap_client_remote_set_ca_cert(ca_cert, ca_cert_len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_ca_cert(void)
+{
+	esp_eap_client_remote_clear_ca_cert();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_certificate_and_key(const unsigned char *client_cert, int client_cert_len,
+									   const unsigned char *private_key, int private_key_len,
+									   const unsigned char *private_key_password, int private_key_passwd_len)
+{
+	return esp_eap_client_remote_set_certificate_and_key(client_cert, client_cert_len,
+										   private_key, private_key_len,
+										   private_key_password, private_key_passwd_len);
+}
+
+H_WEAK_REF void esp_eap_client_clear_certificate_and_key(void)
+{
+	esp_eap_client_remote_clear_certificate_and_key();
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_disable_time_check(bool disable)
+{
+	return esp_eap_client_remote_set_disable_time_check(disable);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_get_disable_time_check(bool *disable)
+{
+	return esp_eap_client_remote_get_disable_time_check(disable);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_ttls_phase2_method(esp_eap_ttls_phase2_types type)
+{
+	return esp_eap_client_remote_set_ttls_phase2_method(type);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_suiteb_192bit_certification(bool enable)
+{
+	return esp_eap_client_remote_set_suiteb_192bit_certification(enable);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_pac_file(const unsigned char *pac_file, int pac_file_len)
+{
+	return esp_eap_client_remote_set_pac_file(pac_file, pac_file_len);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_fast_params(esp_eap_fast_config config)
+{
+	return esp_eap_client_remote_set_fast_params(config);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_use_default_cert_bundle(bool use_default_bundle)
+{
+	return esp_eap_client_remote_use_default_cert_bundle(use_default_bundle);
+}
+
+H_WEAK_REF void esp_wifi_set_okc_support(bool enable)
+{
+	esp_wifi_remote_set_okc_support(enable);
+}
+
+H_WEAK_REF esp_err_t esp_eap_client_set_domain_name(const char *domain_name)
+{
+	return esp_eap_client_remote_set_domain_name(domain_name);
+}
+
+#if H_GOT_SET_EAP_METHODS_API
+H_WEAK_REF esp_err_t esp_eap_client_set_eap_methods(esp_eap_method_t methods)
+{
+	return esp_eap_client_remote_set_eap_methods(methods);
+}
+#endif
+#endif
+
+#if H_DPP_SUPPORT
+/**
+ * Weak version of esp_dpp API
+ */
+#if H_SUPP_DPP_SUPPORT
+H_WEAK_REF esp_err_t esp_supp_dpp_init(esp_supp_dpp_event_cb_t evt_cb)
+{
+	return esp_supp_remote_dpp_init(evt_cb);
+}
+#else
+H_WEAK_REF esp_err_t esp_supp_dpp_init(void)
+{
+	return esp_supp_remote_dpp_init();
+}
+#endif
+
+H_WEAK_REF esp_err_t esp_supp_dpp_deinit(void)
+{
+	return esp_supp_remote_dpp_deinit();
+}
+
+H_WEAK_REF esp_err_t esp_supp_dpp_bootstrap_gen(const char *chan_list,
+		esp_supp_dpp_bootstrap_t type,
+		const char *key, const char *info)
+{
+	return esp_supp_remote_dpp_bootstrap_gen(chan_list, type, key, info);
+}
+
+H_WEAK_REF esp_err_t esp_supp_dpp_start_listen(void)
+{
+	return esp_supp_remote_dpp_start_listen();
+}
+
+H_WEAK_REF esp_err_t esp_supp_dpp_stop_listen(void)
+{
+	return esp_supp_remote_dpp_stop_listen();
+}
+#endif