diff --git a/components/esp_netif/include/esp_netif_types.h b/components/esp_netif/include/esp_netif_types.h index 908f15133..8f4d43c5c 100644 --- a/components/esp_netif/include/esp_netif_types.h +++ b/components/esp_netif/include/esp_netif_types.h @@ -176,7 +176,6 @@ struct esp_netif_driver_ifconfig { void (*driver_free_rx_buffer)(void *h, void* buffer); }; -//typedef struct esp_netif_net_stack_ifconfig esp_netif_net_stack_ifconfig_t; typedef struct esp_netif_driver_ifconfig esp_netif_driver_ifconfig_t; /** @@ -194,4 +193,9 @@ struct esp_netif_config { const esp_netif_netstack_config_t *stack; }; +/** + * @brief ESP-NETIF Receive function type + */ +typedef esp_err_t (*esp_netif_receive_t)(esp_netif_t *esp_netif, void *buffer, size_t len, void *eb); + #endif // _ESP_NETIF_TYPES_H_ \ No newline at end of file diff --git a/components/esp_wifi/CMakeLists.txt b/components/esp_wifi/CMakeLists.txt index ec7432648..7338c480c 100644 --- a/components/esp_wifi/CMakeLists.txt +++ b/components/esp_wifi/CMakeLists.txt @@ -16,6 +16,7 @@ idf_component_register(SRCS "src/coexist.c" "src/smartconfig_ack.c" "src/wifi_init.c" "src/wifi_default.c" + "src/wifi_netif.c" INCLUDE_DIRS "include" "${idf_target}/include" PRIV_REQUIRES wpa_supplicant nvs_flash esp_netif LDFRAGMENTS "${ldfragments}") diff --git a/components/esp_wifi/include/esp_wifi_default.h b/components/esp_wifi/include/esp_wifi_default.h index 3dfc5a4b5..a6fb03014 100644 --- a/components/esp_wifi/include/esp_wifi_default.h +++ b/components/esp_wifi/include/esp_wifi_default.h @@ -16,26 +16,42 @@ #define _ESP_WIFI_DEFAULT_H /** - * @brief Sets default wifi event handlers for STA interface + * @brief Attaches wifi station interface to supplied netif * - * @param esp_netif instance of corresponding if object + * @param esp_netif instance to attach the wifi station to * * @return - * - ESP_OK on success, error returned from esp_event_handler_register if failed + * - ESP_OK on success + * - ESP_FAIL if attach failed */ -esp_err_t esp_wifi_set_default_wifi_sta_handlers(void *esp_netif); +esp_err_t esp_netif_attach_wifi_station(esp_netif_t *esp_netif); + +/** + * @brief Attaches wifi soft AP interface to supplied netif + * + * @param esp_netif instance to attach the wifi AP to + * + * @return + * - ESP_OK on success + * - ESP_FAIL if attach failed + */ +esp_err_t esp_netif_attach_wifi_ap(esp_netif_t *esp_netif); /** * @brief Sets default wifi event handlers for STA interface * - * @param esp_netif instance of corresponding if object + * @return + * - ESP_OK on success, error returned from esp_event_handler_register if failed + */ +esp_err_t esp_wifi_set_default_wifi_sta_handlers(void); + +/** + * @brief Sets default wifi event handlers for STA interface * * @return * - ESP_OK on success, error returned from esp_event_handler_register if failed */ -esp_err_t esp_wifi_set_default_wifi_driver_and_handlers(wifi_interface_t wifi_if, void *esp_netif); - -esp_err_t esp_wifi_set_default_wifi_ap_handlers(void *esp_netif); +esp_err_t esp_wifi_set_default_wifi_ap_handlers(void); /** * @brief Clears default wifi event handlers for supplied network interface diff --git a/components/esp_wifi/include/esp_wifi_netif.h b/components/esp_wifi/include/esp_wifi_netif.h new file mode 100644 index 000000000..777ab5b07 --- /dev/null +++ b/components/esp_wifi/include/esp_wifi_netif.h @@ -0,0 +1,84 @@ +// Copyright 2019 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _ESP_WIFI_NETIF_H +#define _ESP_WIFI_NETIF_H + +/** + * @brief Number of WiFi interfaces used by wifi-netif abstraction + */ +#define MAX_WIFI_IFS (2) + +/** + * @brief Forward declaration of WiFi interface handle + */ +typedef struct wifi_netif_driver* wifi_netif_driver_t; + +/** + * @brief Creates wifi driver instance to be used with esp-netif + * + * @param wifi_if wifi interface type (station, softAP) + * + * @return + * - pointer to wifi interface handle on success + * - NULL otherwise + */ +wifi_netif_driver_t esp_wifi_create_if_driver(wifi_interface_t wifi_if); + +/** + * @brief Destroys wifi driver instance + * + * @param h pointer to wifi interface handle + * + */ +void esp_wifi_destroy_if_driver(wifi_netif_driver_t h); + +/** + * @brief Return mac of specified wifi driver instance + * + * @param[in] ifx pointer to wifi interface handle + * @param[out] mac output mac address + * + * @return ESP_OK on success + * + */ +esp_err_t esp_wifi_get_if_mac(wifi_netif_driver_t ifx, uint8_t mac[6]); + +/** + * @brief Return true if the supplied interface instance is ready after start. + * Typically used when registering on receive callback, which ought to be + * installed as soon as AP started, but once STA gets connected. + * + * @param[in] ifx pointer to wifi interface handle + * + * @return + * - true if ready after intertace started (typically Access Point type) + * - false if ready once intertace connected (typically for Station type) + */ +bool esp_wifi_is_if_ready_when_stared(wifi_netif_driver_t ifx); + +/** + * @brief Register interface receive callback function with argument + * + * @param[in] ifx pointer to wifi interface handle + * @param[in] fn funtion to be registered (typically esp_netif_receive) + * @param[in] arg argument to be supplied to registered function (typically esp_netif ptr) + * + * @return ESP_OK on success + * + */ +esp_err_t esp_wifi_register_if_rxcb(wifi_netif_driver_t ifx, esp_netif_receive_t fn, void * arg); + + +#endif //_ESP_WIFI_NETIF_H \ No newline at end of file diff --git a/components/esp_wifi/src/wifi_default.c b/components/esp_wifi/src/wifi_default.c index 251f12d64..ab45ecdd5 100644 --- a/components/esp_wifi/src/wifi_default.c +++ b/components/esp_wifi/src/wifi_default.c @@ -15,66 +15,44 @@ #include "esp_netif.h" #include "esp_log.h" #include "esp_private/wifi.h" +#include "esp_wifi_netif.h" // // Purpose of this module is to provide basic wifi initialization setup for -// station and AP and their conversion to esp-netif objects -// Also this module holds esp-netif handles for AP and STA +// default station and AP and to register default handles for these interfaces // - -typedef struct wifi_netif_driver { - esp_netif_driver_base_t base; - wifi_interface_t wifi_if; -}* wifi_netif_driver_t; - static const char* TAG = "wifi_init_default"; -#define MAX_WIFI_IFS (2) - static esp_netif_t *s_wifi_netifs[MAX_WIFI_IFS] = { NULL }; static bool wifi_default_handlers_set = false; -static esp_err_t wifi_sta_receive(void *buffer, uint16_t len, void *eb) -{ - return esp_netif_receive(s_wifi_netifs[WIFI_IF_STA], buffer, len, eb); -} +static esp_err_t disconnect_and_destroy(esp_netif_t* esp_netif); -static esp_err_t wifi_ap_receive(void *buffer, uint16_t len, void *eb) -{ - return esp_netif_receive(s_wifi_netifs[WIFI_IF_AP], buffer, len, eb); -} +// +// Default event handlers +// -void wifi_free(void *h, void* buffer) +/** + * @brief Wifi start action when station or AP get started + */ +static void wifi_start(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data) { - esp_wifi_internal_free_rx_buffer(buffer); -} - -esp_err_t wifi_transmit(void *h, void *buffer, size_t len) -{ - wifi_netif_driver_t driver = h; - return esp_wifi_internal_tx(driver->wifi_if, buffer, len); -} - -void wifi_start(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data) -{ - ESP_LOGD(TAG, "%s esp-netif:%p event-id%d", __func__, esp_netif, event_id); - uint8_t mac[6]; esp_err_t ret; - wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif); - wifi_interface_t wifi_interface = driver->wifi_if; + ESP_LOGD(TAG, "%s esp-netif:%p event-id%d", __func__, esp_netif, event_id); - if ((ret = esp_wifi_get_mac(wifi_interface, mac)) != ESP_OK) { + wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif); + + if ((ret = esp_wifi_get_if_mac(driver, mac)) != ESP_OK) { ESP_LOGE(TAG, "esp_wifi_get_mac failed with %d", ret); return; } ESP_LOGD(TAG, "WIFI mac address: %x %x %x %x %x %x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); - if (wifi_interface == ESP_IF_WIFI_AP) { - // By default register wifi rxcb on start for AP only, station gets it registered on connect event - if ((ret = esp_wifi_internal_reg_rxcb(wifi_interface, wifi_ap_receive)) != ESP_OK) { - ESP_LOGE(TAG, "esp_wifi_internal_reg_rxcb for if=%d failed with %d", wifi_interface, ret); + if (esp_wifi_is_if_ready_when_stared(driver)) { + if ((ret = esp_wifi_register_if_rxcb(driver, esp_netif_receive, esp_netif)) != ESP_OK) { + ESP_LOGE(TAG, "esp_wifi_register_if_rxcb for if=%p failed with %d", driver, ret); return; } } @@ -83,6 +61,9 @@ void wifi_start(void *esp_netif, esp_event_base_t base, int32_t event_id, void * esp_netif_action_start(esp_netif, base, event_id, data); } +/** + * @brief Wifi default handlers for specific events for station and APs + */ static void wifi_default_action_sta_start(void *arg, esp_event_base_t base, int32_t event_id, void *data) { @@ -102,10 +83,15 @@ static void wifi_default_action_sta_connected(void *arg, esp_event_base_t base, { if (s_wifi_netifs[WIFI_IF_STA] != NULL) { esp_err_t ret; - // By default register wifi rxcb once the STA gets connected - if ((ret = esp_wifi_internal_reg_rxcb(ESP_IF_WIFI_STA, wifi_sta_receive)) != ESP_OK) { - ESP_LOGE(TAG, "esp_wifi_internal_reg_rxcb for if=%d failed with %d", ESP_IF_WIFI_STA, ret); - return; + esp_netif_t *esp_netif = s_wifi_netifs[WIFI_IF_STA]; + wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif); + + if (!esp_wifi_is_if_ready_when_stared(driver)) { + // if interface not ready when started, rxcb to be registered on connection + if ((ret = esp_wifi_register_if_rxcb(driver, esp_netif_receive, esp_netif)) != ESP_OK) { + ESP_LOGE(TAG, "esp_wifi_register_if_rxcb for if=%p failed with %d", driver, ret); + return; + } } esp_netif_action_connected(s_wifi_netifs[WIFI_IF_STA], base, event_id, data); @@ -145,7 +131,10 @@ static void wifi_default_action_sta_got_ip(void *arg, esp_event_base_t base, int } } -esp_err_t esp_wifi_clear_default_wifi_handlers(void) +/** + * @brief Clear default handlers + */ +esp_err_t _esp_wifi_clear_default_wifi_handlers(void) { esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_START, wifi_default_action_sta_start); esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_STOP, wifi_default_action_sta_stop); @@ -159,42 +148,9 @@ esp_err_t esp_wifi_clear_default_wifi_handlers(void) return ESP_OK; } -static esp_err_t wifi_driver_start(esp_netif_t * esp_netif, void * args) -{ - wifi_netif_driver_t driver = args; - driver->base.netif = esp_netif; - esp_netif_driver_ifconfig_t driver_ifconfig = { - .handle = driver, - .transmit = wifi_transmit, - .driver_free_rx_buffer = wifi_free - }; - - return esp_netif_set_driver_config(esp_netif, &driver_ifconfig); -} - -static esp_err_t disconnect_and_destroy(esp_netif_t* esp_netif) -{ - wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif); - driver->base.netif = NULL; - esp_netif_driver_ifconfig_t driver_ifconfig = { }; - esp_err_t ret = esp_netif_set_driver_config(esp_netif, &driver_ifconfig); - free(driver); - return ret; -} - -static esp_err_t create_and_attach(wifi_interface_t wifi_if, esp_netif_t* esp_netif) -{ - wifi_netif_driver_t driver = calloc(1, sizeof(struct wifi_netif_driver)); - if (driver == NULL) { - ESP_LOGE(TAG, "No memory to create a wifi driver"); - return ESP_ERR_NO_MEM; - } - driver->wifi_if = wifi_if; - driver->base.post_attach = wifi_driver_start; - esp_netif_attach(esp_netif, driver); - return ESP_OK; -} - +/** + * @brief Set default handlers + */ esp_err_t _esp_wifi_set_default_wifi_handlers(void) { if (wifi_default_handlers_set) { @@ -244,19 +200,29 @@ esp_err_t _esp_wifi_set_default_wifi_handlers(void) return ESP_OK; fail: - esp_wifi_clear_default_wifi_handlers(); + _esp_wifi_clear_default_wifi_handlers(); return err; } -esp_err_t esp_wifi_set_default_wifi_driver_and_handlers(wifi_interface_t wifi_if, void *esp_netif) +/** + * @brief Set default handlers for station (official API) + */ +esp_err_t esp_wifi_set_default_wifi_sta_handlers(void) { - assert(esp_netif); - assert(wifi_if < MAX_WIFI_IFS); - s_wifi_netifs[wifi_if] = esp_netif; - ESP_ERROR_CHECK(create_and_attach(wifi_if, esp_netif)); return _esp_wifi_set_default_wifi_handlers(); } +/** + * @brief Set default handlers for AP (official API) + */ +esp_err_t esp_wifi_set_default_wifi_ap_handlers(void) +{ + return _esp_wifi_set_default_wifi_handlers(); +} + +/** + * @brief Clear default handlers and destroy appropriate objects (official API) + */ esp_err_t esp_wifi_clear_default_wifi_driver_and_handlers(void *esp_netif) { int i; @@ -273,25 +239,83 @@ esp_err_t esp_wifi_clear_default_wifi_driver_and_handlers(void *esp_netif) if (i == MAX_WIFI_IFS) { // if all wifi default netifs are null ESP_LOGD(TAG, "Clearing wifi default handlers"); - esp_wifi_clear_default_wifi_handlers(); + _esp_wifi_clear_default_wifi_handlers(); } return disconnect_and_destroy(esp_netif); } + +// +// Object manipulation +// + +/** + * @brief Create and destroy objects + */ +static esp_err_t disconnect_and_destroy(esp_netif_t* esp_netif) +{ + wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif); + esp_netif_driver_ifconfig_t driver_ifconfig = { }; + esp_err_t ret = esp_netif_set_driver_config(esp_netif, &driver_ifconfig); + esp_wifi_destroy_if_driver(driver); + return ret; +} + +static esp_err_t create_and_attach(wifi_interface_t wifi_if, esp_netif_t* esp_netif) +{ + wifi_netif_driver_t driver = esp_wifi_create_if_driver(wifi_if); + if (driver == NULL) { + ESP_LOGE(TAG, "Failed to create wifi interface handle"); + return ESP_FAIL; + } + return esp_netif_attach(esp_netif, driver); +} + +esp_err_t esp_netif_attach_wifi_station(esp_netif_t *esp_netif) +{ + if (esp_netif == NULL) { + return ESP_ERR_INVALID_ARG; + } + s_wifi_netifs[WIFI_IF_STA] = esp_netif; + return create_and_attach(WIFI_IF_STA, esp_netif); +} + +esp_err_t esp_netif_attach_wifi_ap(esp_netif_t *esp_netif) +{ + if (esp_netif == NULL) { + return ESP_ERR_INVALID_ARG; + } + s_wifi_netifs[WIFI_IF_AP] = esp_netif; + return create_and_attach(WIFI_IF_AP, esp_netif); +} + + +// +// Default WiFi creation from user code +// + +/** + * @brief User init default AP (official API) + */ esp_netif_t* esp_netif_create_default_wifi_ap(void) { esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_AP(); esp_netif_t *netif = esp_netif_new(&cfg); assert(netif); - esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_AP, netif); + esp_netif_attach_wifi_ap(netif); + esp_wifi_set_default_wifi_ap_handlers(); return netif; } +/** + * @brief User init default station (official API) + */ esp_netif_t* esp_netif_create_default_wifi_sta(void) { esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_STA(); esp_netif_t *netif = esp_netif_new(&cfg); assert(netif); - esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_STA, netif); + esp_netif_attach_wifi_station(netif); + esp_wifi_set_default_wifi_sta_handlers(); return netif; } \ No newline at end of file diff --git a/components/esp_wifi/src/wifi_netif.c b/components/esp_wifi/src/wifi_netif.c new file mode 100644 index 000000000..884b2e33b --- /dev/null +++ b/components/esp_wifi/src/wifi_netif.c @@ -0,0 +1,146 @@ +// Copyright 2018 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#include "esp_wifi.h" +#include "esp_netif.h" +#include "esp_log.h" +#include "esp_private/wifi.h" +#include "esp_wifi_netif.h" + +// +// Purpose of this module is provide object oriented abstraction to wifi interfaces +// in order to integrate wifi as esp-netif driver +// + +/** + * @brief WiFi netif driver structure + */ +typedef struct wifi_netif_driver { + esp_netif_driver_base_t base; + wifi_interface_t wifi_if; +}* wifi_netif_driver_t; + +static const char* TAG = "wifi_netif"; + +/** + * @brief Local storage for netif handles and callbacks for specific wifi interfaces + */ +static esp_netif_receive_t s_wifi_rxcbs[MAX_WIFI_IFS] = { NULL }; +static esp_netif_t *s_wifi_netifs[MAX_WIFI_IFS] = { NULL }; + +/** + * @brief WiFi netif driver IO functions, a thin glue layer + * to the original wifi interface API + */ +static esp_err_t wifi_sta_receive(void *buffer, uint16_t len, void *eb) +{ + return s_wifi_rxcbs[WIFI_IF_STA](s_wifi_netifs[WIFI_IF_STA], buffer, len, eb); +} + +static esp_err_t wifi_ap_receive(void *buffer, uint16_t len, void *eb) +{ + return s_wifi_rxcbs[WIFI_IF_AP](s_wifi_netifs[WIFI_IF_AP], buffer, len, eb); +} + +static void wifi_free(void *h, void* buffer) +{ + esp_wifi_internal_free_rx_buffer(buffer); +} + +static esp_err_t wifi_transmit(void *h, void *buffer, size_t len) +{ + wifi_netif_driver_t driver = h; + return esp_wifi_internal_tx(driver->wifi_if, buffer, len); +} + +static esp_err_t wifi_driver_start(esp_netif_t * esp_netif, void * args) +{ + wifi_netif_driver_t driver = args; + driver->base.netif = esp_netif; + esp_netif_driver_ifconfig_t driver_ifconfig = { + .handle = driver, + .transmit = wifi_transmit, + .driver_free_rx_buffer = wifi_free + }; + + return esp_netif_set_driver_config(esp_netif, &driver_ifconfig); +} + +void esp_wifi_destroy_if_driver(wifi_netif_driver_t h) +{ + free(h); +} + +wifi_netif_driver_t esp_wifi_create_if_driver(wifi_interface_t wifi_if) +{ + wifi_netif_driver_t driver = calloc(1, sizeof(struct wifi_netif_driver)); + if (driver == NULL) { + ESP_LOGE(TAG, "No memory to create a wifi interface handle"); + return NULL; + } + driver->wifi_if = wifi_if; + driver->base.post_attach = wifi_driver_start; + return driver; +} + +esp_err_t esp_wifi_get_if_mac(wifi_netif_driver_t ifx, uint8_t mac[6]) +{ + wifi_interface_t wifi_interface = ifx->wifi_if; + + return esp_wifi_get_mac(wifi_interface, mac); +} + +bool esp_wifi_is_if_ready_when_stared(wifi_netif_driver_t ifx) +{ + // WiFi rxcb to be register wifi rxcb on start for AP only, station gets it registered on connect event + return (ifx->wifi_if == WIFI_IF_AP); +} + +esp_err_t esp_wifi_register_if_rxcb(wifi_netif_driver_t ifx, esp_netif_receive_t fn, void * arg) +{ + if (ifx->base.netif != arg) { + ESP_LOGE(TAG, "Invalid argument: supplied netif=%p does not equal to interface netif=%p", arg, ifx->base.netif); + return ESP_ERR_INVALID_ARG; + } + wifi_interface_t wifi_interface = ifx->wifi_if; + s_wifi_rxcbs[wifi_interface] = fn; + wifi_rxcb_t rxcb = NULL; + esp_err_t ret; + + switch (wifi_interface) + { + case WIFI_IF_STA: + rxcb = wifi_sta_receive; + break; + + case WIFI_IF_AP: + rxcb = wifi_ap_receive; + break; + + default: + break; + } + + if (rxcb == NULL) { + ESP_LOGE(TAG, "Unknown wifi interface id if=%d", wifi_interface); + return ESP_ERR_NOT_SUPPORTED; + } + + if ((ret = esp_wifi_internal_reg_rxcb(wifi_interface, rxcb)) != ESP_OK) { + ESP_LOGE(TAG, "esp_wifi_internal_reg_rxcb for if=%d failed with %d", wifi_interface, ret); + return ESP_ERR_INVALID_STATE; + } + + s_wifi_netifs[wifi_interface] = ifx->base.netif; + return ESP_OK; +} diff --git a/components/tcpip_adapter/tcpip_adapter_compat.c b/components/tcpip_adapter/tcpip_adapter_compat.c index 5efc1574d..3cc87a266 100644 --- a/components/tcpip_adapter/tcpip_adapter_compat.c +++ b/components/tcpip_adapter/tcpip_adapter_compat.c @@ -26,8 +26,7 @@ extern void _esp_wifi_set_default_ap_netif(esp_netif_t* esp_netif); extern void _esp_wifi_set_default_sta_netif(esp_netif_t* esp_netif); extern esp_err_t _esp_wifi_set_default_wifi_handlers(void); -extern esp_err_t esp_eth_set_default_handlers(void *esp_netif); -extern esp_err_t esp_wifi_clear_default_wifi_handlers(void); +extern esp_err_t _esp_wifi_clear_default_wifi_handlers(void); // // Purpose of this module is to provide backward compatible version of esp-netif @@ -45,15 +44,14 @@ static const char* s_netif_keyif[TCPIP_ADAPTER_IF_MAX] = { static bool s_tcpip_adapter_compat = false; -void wifi_start(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data); - static void wifi_create_and_start_ap(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data) { if (s_esp_netifs[TCPIP_ADAPTER_IF_AP] == NULL) { esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_AP(); esp_netif_t *ap_netif = esp_netif_new(&cfg); - esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_AP, ap_netif); + esp_netif_attach_wifi_ap(ap_netif); + esp_wifi_set_default_wifi_sta_handlers(); s_esp_netifs[TCPIP_ADAPTER_IF_AP] = ap_netif; } } @@ -64,7 +62,8 @@ static void wifi_create_and_start_sta(void *esp_netif, esp_event_base_t base, in esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_STA(); esp_netif_t *sta_netif = esp_netif_new(&cfg); - esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_STA, sta_netif); + esp_netif_attach_wifi_station(sta_netif); + esp_wifi_set_default_wifi_sta_handlers(); s_esp_netifs[TCPIP_ADAPTER_IF_STA] = sta_netif; } } @@ -168,7 +167,7 @@ esp_err_t tcpip_adapter_set_default_wifi_handlers(void) esp_err_t tcpip_adapter_clear_default_wifi_handlers(void) { - return esp_wifi_clear_default_wifi_handlers(); + return _esp_wifi_clear_default_wifi_handlers(); } tcpip_adapter_if_t tcpip_adapter_if_from_esp_netif(esp_netif_t *esp_netif) diff --git a/examples/common_components/protocol_examples_common/connect.c b/examples/common_components/protocol_examples_common/connect.c index f9b974fba..b161e9a6e 100644 --- a/examples/common_components/protocol_examples_common/connect.c +++ b/examples/common_components/protocol_examples_common/connect.c @@ -137,7 +137,8 @@ static void start(void) assert(netif); - esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_STA, netif); + esp_netif_attach_wifi_station(netif); + esp_wifi_set_default_wifi_sta_handlers(); s_example_esp_netif = netif; diff --git a/examples/mesh/internal_communication/main/mesh_main.c b/examples/mesh/internal_communication/main/mesh_main.c index 2e564551b..2c29d51e4 100644 --- a/examples/mesh/internal_communication/main/mesh_main.c +++ b/examples/mesh/internal_communication/main/mesh_main.c @@ -8,7 +8,6 @@ */ #include #include "esp_wifi.h" -#include "esp_wifi_default.h" #include "esp_system.h" #include "esp_event.h" #include "esp_log.h" @@ -388,8 +387,8 @@ static esp_err_t create_wifi_netifs(void) }; esp_netif_t *netif_ap = esp_netif_new(&cfg_ap); assert(netif_ap); - ESP_ERROR_CHECK(esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_AP, netif_ap)); - + ESP_ERROR_CHECK(esp_netif_attach_wifi_ap(netif_ap)); + ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers()); memcpy(&netif_cfg, ESP_NETIF_BASE_DEFAULT_WIFI_STA, sizeof(netif_cfg)); netif_cfg.flags &= ~ESP_NETIF_DHCPC; @@ -400,7 +399,8 @@ static esp_err_t create_wifi_netifs(void) netif_sta = esp_netif_new(&cfg_sta); assert(netif_sta); - ESP_ERROR_CHECK(esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_STA, netif_sta)); + ESP_ERROR_CHECK(esp_netif_attach_wifi_station(netif_sta)); + ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers()); return ESP_OK; } diff --git a/examples/mesh/manual_networking/main/mesh_main.c b/examples/mesh/manual_networking/main/mesh_main.c index c4c481b09..bb203b67e 100644 --- a/examples/mesh/manual_networking/main/mesh_main.c +++ b/examples/mesh/manual_networking/main/mesh_main.c @@ -8,7 +8,6 @@ */ #include #include "esp_wifi.h" -#include "esp_wifi_default.h" #include "esp_system.h" #include "esp_event.h" #include "esp_log.h" @@ -312,8 +311,8 @@ static esp_err_t create_wifi_netifs(void) }; esp_netif_t *netif_ap = esp_netif_new(&cfg_ap); assert(netif_ap); - ESP_ERROR_CHECK(esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_AP, netif_ap)); - + ESP_ERROR_CHECK(esp_netif_attach_wifi_ap(netif_ap)); + ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers()); memcpy(&netif_cfg, ESP_NETIF_BASE_DEFAULT_WIFI_STA, sizeof(netif_cfg)); netif_cfg.flags &= ~ESP_NETIF_DHCPC; @@ -324,7 +323,8 @@ static esp_err_t create_wifi_netifs(void) netif_sta = esp_netif_new(&cfg_sta); assert(netif_sta); - ESP_ERROR_CHECK(esp_wifi_set_default_wifi_driver_and_handlers(ESP_IF_WIFI_STA, netif_sta)); + ESP_ERROR_CHECK(esp_netif_attach_wifi_station(netif_sta)); + ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers()); return ESP_OK; }