diff --git a/components/esp_netif/CMakeLists.txt b/components/esp_netif/CMakeLists.txt index 663a41648a..6eb4d85911 100644 --- a/components/esp_netif/CMakeLists.txt +++ b/components/esp_netif/CMakeLists.txt @@ -19,11 +19,6 @@ set(srcs set(include_dirs "include") set(priv_include_dirs "lwip" "private_include") -if(CONFIG_LWIP_SLIP_SUPPORT) -list(APPEND srcs - "lwip/esp_netif_lwip_slip.c") -endif() - if(CONFIG_PPP_SUPPORT) list(APPEND srcs "lwip/esp_netif_lwip_ppp.c") diff --git a/components/esp_netif/esp_netif_defaults.c b/components/esp_netif/esp_netif_defaults.c index 950772a720..a49c69d85b 100644 --- a/components/esp_netif/esp_netif_defaults.c +++ b/components/esp_netif/esp_netif_defaults.c @@ -32,5 +32,3 @@ const esp_netif_inherent_config_t _g_esp_netif_inherent_ap_config = ESP_NETIF_IN const esp_netif_inherent_config_t _g_esp_netif_inherent_eth_config = ESP_NETIF_INHERENT_DEFAULT_ETH(); const esp_netif_inherent_config_t _g_esp_netif_inherent_ppp_config = ESP_NETIF_INHERENT_DEFAULT_PPP(); - -const esp_netif_inherent_config_t _g_esp_netif_inherent_slip_config = ESP_NETIF_INHERENT_DEFAULT_SLIP(); diff --git a/components/esp_netif/include/esp_netif_defaults.h b/components/esp_netif/include/esp_netif_defaults.h index fdf7f32a76..90fbca16dd 100644 --- a/components/esp_netif/include/esp_netif_defaults.h +++ b/components/esp_netif/include/esp_netif_defaults.h @@ -72,18 +72,7 @@ extern "C" { }; -#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \ - { \ - .flags = ESP_NETIF_FLAG_IS_SLIP, \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \ - .get_ip_event = 0, \ - .lost_ip_event = 0, \ - .if_key = "SLP_DEF", \ - .if_desc = "slip", \ - .route_prio = 16, \ - .bridge_info = NULL \ -}; + #define ESP_NETIF_INHERENT_DEFAULT_BR() \ { \ @@ -140,17 +129,6 @@ extern "C" { .stack = ESP_NETIF_NETSTACK_DEFAULT_PPP, \ } -/** -* @brief Default configuration reference of SLIP client -*/ -#define ESP_NETIF_DEFAULT_SLIP() \ - { \ - .base = ESP_NETIF_BASE_DEFAULT_SLIP, \ - .driver = NULL, \ - .stack = ESP_NETIF_NETSTACK_DEFAULT_SLIP, \ - } - - /** * @brief Default base config (esp-netif inherent) of WIFI STA */ @@ -173,11 +151,6 @@ extern "C" { */ #define ESP_NETIF_BASE_DEFAULT_PPP &_g_esp_netif_inherent_ppp_config -/** - * @brief Default base config (esp-netif inherent) of slip interface - */ -#define ESP_NETIF_BASE_DEFAULT_SLIP &_g_esp_netif_inherent_slip_config - #define ESP_NETIF_NETSTACK_DEFAULT_ETH _g_esp_netif_netstack_default_eth #define ESP_NETIF_NETSTACK_DEFAULT_BR _g_esp_netif_netstack_default_br @@ -186,7 +159,6 @@ extern "C" { #define ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP _g_esp_netif_netstack_default_wifi_ap #endif #define ESP_NETIF_NETSTACK_DEFAULT_PPP _g_esp_netif_netstack_default_ppp -#define ESP_NETIF_NETSTACK_DEFAULT_SLIP _g_esp_netif_netstack_default_slip // // Include default network stacks configs @@ -201,7 +173,6 @@ extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_sta extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_ap; #endif extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_ppp; -extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip; // // Include default common configs inherent to esp-netif @@ -214,7 +185,6 @@ extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ap_config; #endif extern const esp_netif_inherent_config_t _g_esp_netif_inherent_eth_config; extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ppp_config; -extern const esp_netif_inherent_config_t _g_esp_netif_inherent_slip_config; #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT extern const esp_netif_ip_info_t _g_esp_netif_soft_ap_ip; diff --git a/components/esp_netif/include/esp_netif_slip.h b/components/esp_netif/include/esp_netif_slip.h deleted file mode 100644 index 5cad14ea28..0000000000 --- a/components/esp_netif/include/esp_netif_slip.h +++ /dev/null @@ -1,82 +0,0 @@ -// 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_NETIF_SLIP_H_ -#define _ESP_NETIF_SLIP_H_ - -#include "esp_netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** @brief Configuration structure for SLIP network interface - * - */ -typedef struct esp_netif_slip_config { - esp_ip6_addr_t ip6_addr; /* Local IP6 address */ - -} esp_netif_slip_config_t; - - -/** @brief Sets common parameters for the supplied esp-netif. - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] config Pointer to SLIP netif configuration structure - * - * @return ESP_OK on success, ESP_ERR_ESP_NETIF_INVALID_PARAMS if netif null or not SLIP - */ -esp_err_t esp_netif_slip_set_params(esp_netif_t *netif, const esp_netif_slip_config_t *config); - -#if CONFIG_LWIP_IPV6 -/** @brief Sets IPV6 address for the supplied esp-netif. - * - * @param[in] netif handle to slip esp-netif instance - * @param[in] ipv6 IPv6 address of the SLIP interface - * - * @return ESP_OK on success, ESP_ERR_ESP_NETIF_INVALID_PARAMS if netif null or not SLIP - */ -esp_err_t esp_netif_slip_set_ipv6(esp_netif_t *netif, const esp_ip6_addr_t *ipv6); -#endif - -/** - * @brief Data path API to write raw packet ous the SLIP interface - * - * This API is typically used when implementing user defined methods - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] buffer pointer to the outgoing data - * @param[in] len length of the data - * - * @return - * - ESP_OK on success - */ -void esp_netif_lwip_slip_raw_output(esp_netif_t *netif, void *buffer, size_t len); - -/** - * @brief Fetch IP6 address attached to the SLIP interface - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] address index (unused) - * - * @return - * - pointer to the internal ip6 address object - */ -const esp_ip6_addr_t *esp_slip_get_ip6(esp_netif_t *slip_netif); - -#ifdef __cplusplus -} -#endif -#endif //_ESP_NETIF_SLIP_H_ diff --git a/components/esp_netif/include/esp_netif_types.h b/components/esp_netif/include/esp_netif_types.h index 3268f4732b..de7f7579fc 100644 --- a/components/esp_netif/include/esp_netif_types.h +++ b/components/esp_netif/include/esp_netif_types.h @@ -159,8 +159,7 @@ typedef enum esp_netif_flags { ESP_NETIF_FLAG_GARP = 1 << 3, ESP_NETIF_FLAG_EVENT_IP_MODIFIED = 1 << 4, ESP_NETIF_FLAG_IS_PPP = 1 << 5, - ESP_NETIF_FLAG_IS_SLIP = 1 << 6, - ESP_NETIF_FLAG_IS_BRIDGE = 1 << 7, + ESP_NETIF_FLAG_IS_BRIDGE = 1 << 6, } esp_netif_flags_t; typedef enum esp_netif_ip_event_type { diff --git a/components/esp_netif/include/lwip/esp_netif_net_stack.h b/components/esp_netif/include/lwip/esp_netif_net_stack.h index e908b96a60..52790d72ac 100644 --- a/components/esp_netif/include/lwip/esp_netif_net_stack.h +++ b/components/esp_netif/include/lwip/esp_netif_net_stack.h @@ -9,7 +9,6 @@ #include "esp_netif.h" #include "lwip/netif.h" #include "esp_netif_ppp.h" -#include "esp_netif_slip.h" #if defined(CONFIG_ESP_NETIF_TCPIP_LWIP) @@ -26,12 +25,6 @@ struct esp_netif_netstack_lwip_ppp_config { esp_netif_ppp_config_t ppp_events; }; -struct esp_netif_netstack_lwip_slip_config { - init_fn_t init_fn; - input_fn_t input_fn; - esp_netif_slip_config_t slip_config; -}; - // LWIP netif specific network stack configuration struct esp_netif_netstack_config { union { diff --git a/components/esp_netif/loopback/esp_netif_loopback.c b/components/esp_netif/loopback/esp_netif_loopback.c index 8418e9d28b..c328a37e5e 100644 --- a/components/esp_netif/loopback/esp_netif_loopback.c +++ b/components/esp_netif/loopback/esp_netif_loopback.c @@ -6,7 +6,6 @@ #include -#include "esp_netif_lwip_internal.h" #include "esp_netif.h" #include "esp_netif_private.h" diff --git a/components/esp_netif/lwip/esp_netif_lwip.c b/components/esp_netif/lwip/esp_netif_lwip.c index 049fd55e69..22f770869e 100644 --- a/components/esp_netif/lwip/esp_netif_lwip.c +++ b/components/esp_netif/lwip/esp_netif_lwip.c @@ -41,7 +41,6 @@ #endif // CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT #include "esp_netif_lwip_ppp.h" -#include "esp_netif_lwip_slip.h" #include "dhcpserver/dhcpserver.h" #include "dhcpserver/dhcpserver_options.h" #include "netif/dhcp_state.h" @@ -64,7 +63,7 @@ /** * @brief macros to check netif related data to evaluate interface type */ -#if CONFIG_PPP_SUPPORT || CONFIG_LWIP_SLIP_SUPPORT +#if CONFIG_PPP_SUPPORT #define _IS_NETIF_ANY_POINT2POINT_TYPE(netif) (netif->related_data && netif->related_data->is_point2point) #else #define _IS_NETIF_ANY_POINT2POINT_TYPE(netif) false @@ -255,7 +254,7 @@ static esp_netif_t* esp_netif_is_active(esp_netif_t *arg) */ static void esp_netif_set_default_netif_internal(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT esp_netif_ppp_set_default_netif(esp_netif->netif_handle); #endif @@ -450,7 +449,7 @@ esp_netif_t* esp_netif_get_handle_from_netif_impl(void *dev) void* esp_netif_get_netif_impl(esp_netif_t *esp_netif) { // get impl ptr only for vanilla lwip impl (ppp_pcb not supported) - if (esp_netif && !_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (esp_netif && !ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { return esp_netif->lwip_netif; } return NULL; @@ -577,23 +576,6 @@ static esp_err_t esp_netif_init_configuration(esp_netif_t *esp_netif, const esp_ esp_netif->netif_handle = esp_netif->related_data; #else LOG_NETIF_DISABLED_AND_DO("PPP", return ESP_ERR_NOT_SUPPORTED); -#endif - } else if (cfg->base->flags & ESP_NETIF_FLAG_IS_SLIP) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif->related_data = esp_netif_new_slip(esp_netif, esp_netif_stack_config); - if (esp_netif->related_data == NULL) { - return ESP_ERR_ESP_NETIF_INIT_FAILED; - } - if (esp_netif_stack_config->lwip.init_fn) { - esp_netif->lwip_init_fn = esp_netif_stack_config->lwip.init_fn; - } - if (esp_netif_stack_config->lwip.input_fn) { - esp_netif->lwip_input_fn = esp_netif_stack_config->lwip.input_fn; - } - // Make the netif handle (used for tcpip input function) the esp_netif itself - esp_netif->netif_handle = esp_netif; -#else - LOG_NETIF_DISABLED_AND_DO("SLIP", return ESP_ERR_NOT_SUPPORTED); #endif } else { if (esp_netif_stack_config-> lwip.init_fn) { @@ -786,13 +768,9 @@ static esp_err_t esp_netif_lwip_add(esp_netif_t *esp_netif) static void esp_netif_destroy_related(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT esp_netif_destroy_ppp(esp_netif->related_data); -#endif - } else if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif_destroy_slip(esp_netif->related_data); #endif } } @@ -945,11 +923,7 @@ static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg) #endif } struct netif *p_netif = esp_netif->lwip_netif; - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif_start_slip(esp_netif); -#endif - } + if (esp_netif->flags&ESP_NETIF_FLAG_AUTOUP) { ESP_LOGD(TAG, "%s Setting the lwip netif%p UP", __func__, p_netif); netif_set_up(p_netif); @@ -1011,7 +985,7 @@ static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg) esp_err_t esp_netif_start(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT // No need to start PPP interface in lwip thread esp_err_t ret = esp_netif_start_ppp(esp_netif); @@ -1066,7 +1040,7 @@ static esp_err_t esp_netif_stop_api(esp_netif_api_msg_t *msg) esp_err_t esp_netif_stop(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT // No need to stop PPP interface in lwip thread esp_err_t ret = esp_netif_stop_ppp(esp_netif->related_data); @@ -1074,15 +1048,6 @@ esp_err_t esp_netif_stop(esp_netif_t *esp_netif) esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED); } return ret; -#endif - } else if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - // No need to stop SLIP interface in lwip thread - esp_err_t ret = esp_netif_stop_slip(esp_netif); - if (ret == ESP_OK) { - esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED); - } - return ret; #endif } return esp_netif_lwip_ipc_call(esp_netif_stop_api, esp_netif, NULL); diff --git a/components/esp_netif/lwip/esp_netif_lwip_internal.h b/components/esp_netif/lwip/esp_netif_lwip_internal.h index 0737f79c3c..332a4f822d 100644 --- a/components/esp_netif/lwip/esp_netif_lwip_internal.h +++ b/components/esp_netif/lwip/esp_netif_lwip_internal.h @@ -8,7 +8,6 @@ #include "esp_netif.h" #include "esp_netif_ppp.h" -#include "esp_netif_slip.h" #include "lwip/netif.h" #include "dhcpserver/dhcpserver.h" @@ -39,10 +38,10 @@ typedef struct esp_netif_ip_lost_timer_s { /** * @brief Check the netif if of a specific P2P type */ -#if CONFIG_PPP_SUPPORT || CONFIG_LWIP_SLIP_SUPPORT -#define _IS_NETIF_POINT2POINT_TYPE(netif, type) (netif->related_data && netif->related_data->is_point2point && netif->related_data->netif_type == type) +#if CONFIG_PPP_SUPPORT +#define ESP_NETIF_IS_POINT2POINT_TYPE(netif, type) (netif->related_data && netif->related_data->is_point2point && netif->related_data->netif_type == type) #else -#define _IS_NETIF_POINT2POINT_TYPE(netif, type) false +#define ESP_NETIF_IS_POINT2POINT_TYPE(netif, type) false #endif /** @@ -51,12 +50,11 @@ typedef struct esp_netif_ip_lost_timer_s { enum netif_types { COMMON_LWIP_NETIF, PPP_LWIP_NETIF, - SLIP_LWIP_NETIF }; /** * @brief Related data to esp-netif (additional data for some special types of netif - * (typically for point-point network types, such as PPP or SLIP) + * (typically for point-point network types, such as PPP) */ typedef struct netif_related_data { bool is_point2point; diff --git a/components/esp_netif/lwip/esp_netif_lwip_ppp.c b/components/esp_netif/lwip/esp_netif_lwip_ppp.c index 2c6c1c1248..67175df4d9 100644 --- a/components/esp_netif/lwip/esp_netif_lwip_ppp.c +++ b/components/esp_netif/lwip/esp_netif_lwip_ppp.c @@ -203,7 +203,7 @@ static uint32_t pppos_low_level_output(ppp_pcb *pcb, uint8_t *data, uint32_t len esp_err_t esp_netif_ppp_set_auth(esp_netif_t *netif, esp_netif_auth_type_t authtype, const char *user, const char *passwd) { - if (!_IS_NETIF_POINT2POINT_TYPE(netif, PPP_LWIP_NETIF)) { + if (!ESP_NETIF_IS_POINT2POINT_TYPE(netif, PPP_LWIP_NETIF)) { return ESP_ERR_ESP_NETIF_INVALID_PARAMS; } #if PPP_AUTH_SUPPORT diff --git a/components/esp_netif/lwip/esp_netif_lwip_slip.c b/components/esp_netif/lwip/esp_netif_lwip_slip.c deleted file mode 100644 index 6d59370f4e..0000000000 --- a/components/esp_netif/lwip/esp_netif_lwip_slip.c +++ /dev/null @@ -1,307 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - - - -#include "esp_netif.h" -#include "esp_log.h" -#include "esp_netif_slip.h" -#include "esp_netif_lwip_internal.h" -#include "esp_netif_net_stack.h" -#include "lwip/esp_netif_net_stack.h" - -#ifdef CONFIG_ESP_NETIF_TCPIP_LWIP - -#include "lwip/dns.h" -#include "lwip/opt.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "netif/slipif.h" -#include "lwip/sio.h" - -#include - -static const char *TAG = "esp-netif_lwip-slip"; - -/** - * @brief LWIP SLIP context object extends esp-netif related data - */ -typedef struct lwip_slip_ctx { - //! Generic esp-netif related data - netif_related_data_t base; - - //! SLIP interface IP6 address - esp_ip6_addr_t addr; - -} lwip_slip_ctx_t; - -/** - * @brief Create a new lwip slip interface - */ -netif_related_data_t * esp_netif_new_slip(esp_netif_t *esp_netif, const esp_netif_netstack_config_t *esp_netif_stack_config) -{ - ESP_LOGD(TAG, "%s", __func__); - - // Fetch netif and create context - struct netif *netif_impl = esp_netif->lwip_netif; - - lwip_slip_ctx_t *slip_ctx = calloc(1, sizeof(lwip_slip_ctx_t)); - if (slip_ctx == NULL) { - ESP_LOGE(TAG, "%s: cannot allocate lwip_slip_ctx_t", __func__); - return NULL; - } - // Setup the generic esp-netif fields - slip_ctx->base.is_point2point = true; - slip_ctx->base.netif_type = SLIP_LWIP_NETIF; - - ESP_LOGD(TAG, "%s: Initialising SLIP (esp_netif %p, lwip_netif %p)", __func__, esp_netif, netif_impl); - - ESP_LOGI(TAG, "%s: Created SLIP interface (netif %p, slip_ctx: %p)", __func__, esp_netif, slip_ctx); - - return (netif_related_data_t *)slip_ctx; -} - -/** - * @brief Stops the SLIP interface - */ -esp_err_t esp_netif_stop_slip(esp_netif_t *esp_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)esp_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGI(TAG, "%s: Stopped SLIP connection: %p", __func__, slip_ctx); - - // Stop interface - netif_set_link_down(esp_netif->lwip_netif); - - return ESP_OK; -} - -/** - * @brief Starts the SLIP interface - */ -esp_err_t esp_netif_start_slip(esp_netif_t *esp_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)esp_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGI(TAG, "%s: Starting SLIP interface: %p", __func__, slip_ctx); - - // Set the netif up - netif_set_up(esp_netif->lwip_netif); - netif_set_link_up(esp_netif->lwip_netif); -#if CONFIG_LWIP_IPV6 - int8_t addr_index = 0; - - netif_ip6_addr_set(esp_netif->lwip_netif, addr_index, (ip6_addr_t *)&slip_ctx->addr); - netif_ip6_addr_set_state(esp_netif->lwip_netif, addr_index, IP6_ADDR_VALID); -#endif - return ESP_OK; -} - - -/** - * @brief Sets paramaters for the supplied netif - */ -esp_err_t esp_netif_slip_set_params(esp_netif_t *netif, const esp_netif_slip_config_t *slip_config) -{ - - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGD(TAG, "%s (slip_ctx: %p)", __func__, slip_ctx); - - if (netif_is_link_up(netif->lwip_netif)) { - ESP_LOGE(TAG, "Cannot set parameters while SLIP interface is running"); - return ESP_ERR_INVALID_STATE; - } - - memcpy(&slip_ctx->addr, &slip_config->ip6_addr, sizeof(esp_ip6_addr_t)); - - - return ESP_OK; -} - -#if CONFIG_LWIP_IPV6 -esp_err_t esp_netif_slip_set_ipv6(esp_netif_t *netif, const esp_ip6_addr_t *ipv6) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGV(TAG, "%s (slip_ctx: %p)", __func__, slip_ctx); - - if (netif_is_link_up(netif->lwip_netif)) { - ESP_LOGE(TAG, "Cannot set parameters while SLIP interface is running"); - return ESP_ERR_INVALID_STATE; - } - memcpy(&slip_ctx->addr, ipv6, sizeof(ip6_addr_t)); - int8_t addr_index = 0; - - netif_ip6_addr_set(netif->lwip_netif, addr_index, (ip6_addr_t *)&slip_ctx->addr); - netif_ip6_addr_set_state(netif->lwip_netif, addr_index, IP6_ADDR_VALID); - - return ESP_OK; -} -#endif - -/** - * @brief Write incoming serial data to the SLIP interface - */ -void esp_netif_lwip_slip_input(void *h, void *buffer, unsigned int len, void *eb) -{ - esp_netif_t *netif = h; - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - - // Update slip netif with data - const int max_batch = 255; - int sent = 0; - while(sent < len) { - int batch = (len - sent) > max_batch ? max_batch : (len - sent); - slipif_received_bytes(netif->lwip_netif, buffer+sent, batch); - sent += batch; - } - - // Process incoming bytes - for (int i = 0; i < len; i++) { - slipif_process_rxqueue(netif->lwip_netif); - } -} - -/** - * @brief Write raw data out the SLIP interface - */ -void esp_netif_lwip_slip_raw_output(esp_netif_t *slip_netif, void *buffer, size_t len) -{ - struct netif *lwip_netif = slip_netif->lwip_netif; - - ESP_LOGD(TAG, "%s", __func__); - - struct pbuf p = { - .next = NULL, - .payload = buffer, - .tot_len = len, - .len = len, - }; - - // Call slip if output function to feed data out slip interface -#if CONFIG_LWIP_IPV6 - lwip_netif->output_ip6(lwip_netif, &p, NULL); -#else - lwip_netif->output(lwip_netif, &p, NULL); -#endif -} - -/** - * @brief Destroys the SLIP context object - */ -void esp_netif_destroy_slip(netif_related_data_t *slip) -{ - ESP_LOGD(TAG, "%s", __func__); - - // Free base object - free(slip); -} - -const esp_ip6_addr_t *esp_slip_get_ip6(esp_netif_t *slip_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)slip_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - return &slip_ctx->addr; -} - -/** @brief Get esp-netif object corresponding to registration index - */ -static esp_netif_t * get_netif_with_esp_index(int index) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (counter == index) { - return netif; - } - counter++; - } - return NULL; -} - -/** @brief Return list registration index of the supplied netif ptr - */ -static int get_esp_netif_index(esp_netif_t * esp_netif) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (esp_netif == netif) { - return counter; - } - counter++; - } - return -1; -} - -err_t esp_slipif_init(struct netif *netif) -{ - esp_netif_t *esp_netif = netif->state; - int esp_index = get_esp_netif_index(esp_netif); - if (esp_index < 0) { - return ERR_IF; - } - - // Store netif index in net interface for SIO open command to abstract the dev - netif->state = (void *)esp_index; - - return slipif_init(netif); -} - -static const struct esp_netif_netstack_config s_netif_config_slip = { - .lwip = { - .init_fn = esp_slipif_init, - .input_fn = esp_netif_lwip_slip_input, - } -}; - -const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip = &s_netif_config_slip; - - -/*** - * @brief Open a serial device for communication - */ -sio_fd_t sio_open(uint8_t devnum) -{ - ESP_LOGD(TAG, "Opening device: %d\r\n", devnum); - - esp_netif_t *esp_netif = get_netif_with_esp_index(devnum); - if (!esp_netif) { - ESP_LOGE(TAG, "didn't find esp-netif with index=%d\n", devnum); - return NULL; - } - - // Return SIO handle - return esp_netif; -} - -/*** - * @brief Send a single character to the serial device (blocking) - */ -void sio_send(uint8_t c, sio_fd_t fd) -{ - esp_netif_t *esp_netif = fd; - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEX_LEVEL(TAG, &c, 1, ESP_LOG_DEBUG); - - esp_err_t ret = esp_netif_transmit(esp_netif, &c, 1); - if (ret != ESP_OK) { - // Handle errors - ESP_LOGD(TAG, "%s: uart_write_bytes error %i", __func__, ret); - } -} - -#endif /* CONFIG_ESP_NETIF_TCPIP_LWIP */ diff --git a/components/esp_netif/lwip/esp_netif_lwip_slip.h b/components/esp_netif/lwip/esp_netif_lwip_slip.h deleted file mode 100644 index e8f9ae3264..0000000000 --- a/components/esp_netif/lwip/esp_netif_lwip_slip.h +++ /dev/null @@ -1,58 +0,0 @@ -// 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_NETIF_LWIP_SLIP_H_ -#define _ESP_NETIF_LWIP_SLIP_H_ - -/** - * @brief Creates new SLIP related structure - * - * @param[in] esp_netif pointer esp-netif instance - * @param[in] stack_config TCP/IP stack configuration structure - * - * @return - * - pointer to slip-netif object on success - * - NULL otherwise - */ -netif_related_data_t * esp_netif_new_slip(esp_netif_t *esp_netif, const esp_netif_netstack_config_t *esp_netif_stack_config); - -/** - * @brief Destroys the slip netif object - * - * @param[in] slip pointer to internal slip context instance - */ -void esp_netif_destroy_slip(netif_related_data_t *slip); - -/** - * @brief Stop the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * - * @return - * - ESP_OK on success - */ -esp_err_t esp_netif_stop_slip(esp_netif_t *esp_netif); - -/** - * @brief Start the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * - * @return - * - ESP_OK on success - */ -esp_err_t esp_netif_start_slip(esp_netif_t *esp_netif); - - -#endif // _ESP_NETIF_LWIP_SLIP_H_ diff --git a/examples/protocols/slip/slip_udp/README.md b/examples/protocols/slip/slip_udp/README.md index e83944da84..f8c50d9c35 100644 --- a/examples/protocols/slip/slip_udp/README.md +++ b/examples/protocols/slip/slip_udp/README.md @@ -9,6 +9,8 @@ This provides SLIP support for connection to Contiki gateway devices, allowing the ESP platform board to be used to bridge between low-power networks and IP (Wifi / Ethernet). +This example also demonstrates creating custom network interfaces, including UART drivers and lwIP netif layers, and attaching them to the standard `esp_netif` component, so the generic system interfaces can still use the common approach of listing all interfaces, updating states, posting events and handling routing priorities. Please refer to the implementation of [slip_modem](components/slip_modem) component for more details. + ## How to use example ### Hardware Required @@ -49,8 +51,8 @@ nc -u 10.0.0.2 5678 | ESP32 | Gateway | | ------ | -------------- | -| GPIO4 | RX | -| GPIO36 | TX | +| GPIO25 | RX | +| GPIO26 | TX | | GND | GND | | 3v3 | VCC | diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt b/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt index 838d5a975a..6837386287 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt +++ b/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt @@ -1,7 +1,7 @@ # SLIP Modem Component idf_component_register( - SRCS "library/slip_modem.c" + SRCS "library/slip_modem.c" "library/slip_modem_netif.c" INCLUDE_DIRS "include" REQUIRES esp_netif driver ) diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h b/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h index 2cbd4be519..53b8eba5bb 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h +++ b/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h @@ -1,16 +1,8 @@ -// Copyright 2020 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. +/* + * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ #pragma once @@ -18,15 +10,30 @@ #include #include "esp_netif.h" -#include "esp_netif_slip.h" - #include "driver/uart.h" +/** @brief Configuration of SLIP network interface + * + */ +#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \ + { \ + ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \ + ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \ + .get_ip_event = 0, \ + .lost_ip_event = 0, \ + .if_key = "SLP_DEF", \ + .if_desc = "slip", \ + .route_prio = 16, \ + .bridge_info = NULL \ +}; + +extern esp_netif_netstack_config_t *netstack_default_slip; + // Forward declare modem object -typedef struct esp_slip_modem esp_slip_modem_t; +typedef struct slip_modem slip_modem_t; // Filter callbacks for handling application specific slip messages -typedef bool slip_rx_filter_cb_t(void *ctx, uint8_t *data, uint32_t len); +typedef bool slip_rx_filter_cb_t(slip_modem_t *slip, uint8_t *data, uint32_t len); /** @brief Configuration structure for SLIP modem interface @@ -43,9 +50,10 @@ typedef struct { uint32_t rx_buffer_len; /* Length of buffer for RX messages */ slip_rx_filter_cb_t *rx_filter; /* Filter for parsing out non-SLIP messages from incoming SLIP stream */ - void *rx_filter_ctx; /* Context to be passed to SLIP filter function */ + esp_ip6_addr_t *ipv6_addr; + +} slip_modem_config_t; -} esp_slip_modem_config_t; /** @brief Create a slip modem @@ -56,7 +64,7 @@ typedef struct { * @returns * - slip modem driver glue object */ -void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *modem_config); +slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config); /** @brief Destroy a slip modem * @@ -65,4 +73,24 @@ void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *mo * @return * - ESP_OK on success */ -esp_err_t esp_slip_modem_destroy(esp_slip_modem_t *slip_modem); +esp_err_t slip_modem_destroy(slip_modem_t *slip); + +/** + * @brief Getter for the internally configured IPv6 address + * + * @param[in] slip modem object + * + * @returns + * - ipv6 address + */ +const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip); + +/** + * @brief Data path API that forward the supplied data to the attached network interface + * + * @param[in] slip modem object + * @param[in] buffer pointer to the outgoing data + * @param[in] len length of the data + * + */ +void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c index 816ffdded9..907270a611 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c @@ -4,17 +4,18 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include "slip_modem.h" #include "esp_netif.h" -#include "esp_netif_slip.h" +#include "slip_modem_netif.h" #include "esp_event.h" #include "esp_log.h" #define SLIP_RX_TASK_PRIORITY 10 #define SLIP_RX_TASK_STACK_SIZE (4 * 1024) -static const char *TAG = "esp-slip_modem"; +static const char *TAG = "slip-modem"; // UART container object @@ -40,7 +41,7 @@ typedef struct { // Modem object, implements glue logic for slip_driver and esp_netif -struct esp_slip_modem { +struct slip_modem { // ESP base netif driver esp_netif_driver_base_t base; @@ -53,50 +54,54 @@ struct esp_slip_modem { // Filter callbacks for application-specific slip message handling slip_rx_filter_cb_t *rx_filter; - void *rx_filter_ctx; // Running flag bool running; + + // esp_netif related: SLIP interface IP6 address + esp_ip6_addr_t addr; + }; // Forward function declaration -static void esp_slip_modem_uart_rx_task(void *arg); -static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args); +static void slip_modem_uart_rx_task(void *arg); +static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args); -// Create a new slip netif -void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *modem_config) +// Create a new slip modem +slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config) { ESP_LOGI(TAG, "%s: Creating slip modem (netif: %p)", __func__, slip_netif); ESP_LOGD(TAG, "%s (netif: %p)", __func__, slip_netif); - esp_slip_modem_t *slip_modem = calloc(1, sizeof(esp_slip_modem_t)); + slip_modem_t *slip_modem = calloc(1, sizeof(slip_modem_t)); if (!slip_modem) { ESP_LOGE(TAG, "create netif glue failed"); return NULL; } // Attach driver and post_attach callbacks - slip_modem->base.post_attach = esp_slip_modem_post_attach; + slip_modem->base.post_attach = slip_modem_post_attach; + slip_modem->base.netif = slip_netif; // Attach config slip_modem->buffer_len = modem_config->rx_buffer_len; slip_modem->rx_filter = modem_config->rx_filter; - slip_modem->rx_filter_ctx = modem_config->rx_filter_ctx; slip_modem->uart.uart_dev = modem_config->uart_dev; slip_modem->uart.uart_baud = modem_config->uart_baud; slip_modem->uart.uart_rx_pin = modem_config->uart_rx_pin; slip_modem->uart.uart_tx_pin = modem_config->uart_tx_pin; + memcpy(&slip_modem->addr, modem_config->ipv6_addr, sizeof(esp_ip6_addr_t)); - // Return new modem, with a cast to the first item - return &slip_modem->base; + // Return the new modem + return slip_modem; } // Internal handler called on driver start -static esp_err_t esp_slip_driver_start(esp_slip_modem_t *slip_modem) +static esp_err_t esp_slip_driver_start(slip_modem_t *slip_modem) { ESP_LOGD(TAG, "%s: Starting SLIP modem (modem %p)", __func__, slip_modem); @@ -129,38 +134,39 @@ static esp_err_t esp_slip_driver_start(esp_slip_modem_t *slip_modem) // Start slip RX task slip_modem->running = true; - xTaskCreate(esp_slip_modem_uart_rx_task, "slip_modem_uart_rx_task", SLIP_RX_TASK_STACK_SIZE, slip_modem, SLIP_RX_TASK_PRIORITY, &slip_modem->uart.uart_rx_task); + xTaskCreate(slip_modem_uart_rx_task, "slip_modem_uart_rx_task", SLIP_RX_TASK_STACK_SIZE, slip_modem, SLIP_RX_TASK_PRIORITY, &slip_modem->uart.uart_rx_task); // Finally, initialise slip network interface esp_netif_action_start(slip_modem->base.netif, 0, 0, 0); - + ESP_ERROR_CHECK(slip_modem_netif_start(slip_modem->base.netif, &slip_modem->addr)); return ESP_OK; } -esp_err_t esp_slip_modem_destroy(esp_slip_modem_t *slip_modem) +esp_err_t slip_modem_destroy(slip_modem_t *slip) { // Stop slip driver - esp_netif_action_stop(slip_modem->base.netif, 0, 0, 0); + esp_netif_action_stop(slip->base.netif, 0, 0, 0); + ESP_ERROR_CHECK(slip_modem_netif_stop(slip->base.netif)); // Stop uart rx task - vTaskDelete(slip_modem->uart.uart_rx_task); + vTaskDelete(slip->uart.uart_rx_task); // Delete driver - uart_driver_delete(slip_modem->uart.uart_dev); + uart_driver_delete(slip->uart.uart_dev); // Free slip interface - free(slip_modem); + free(slip); return ESP_OK; } // Modem transmit for glue logic -static esp_err_t esp_slip_modem_transmit(void *slip_driver, void *buffer, size_t len) +static esp_err_t slip_modem_transmit(void *slip_driver, void *buffer, size_t len) { ESP_LOGD(TAG, "%s", __func__); ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) slip_driver; + slip_modem_t *slip_modem = (slip_modem_t *) slip_driver; int32_t res = uart_write_bytes(slip_modem->uart.uart_dev, (char *)buffer, len); if (res < 0) { @@ -172,15 +178,15 @@ static esp_err_t esp_slip_modem_transmit(void *slip_driver, void *buffer, size_t } // Post-attach handler for netif -static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args) +static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args) { - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) args; + slip_modem_t *slip_modem = (slip_modem_t *) args; ESP_LOGD(TAG, "%s (netif: %p args: %p)", __func__, esp_netif, args); const esp_netif_driver_ifconfig_t driver_ifconfig = { .driver_free_rx_buffer = NULL, - .transmit = esp_slip_modem_transmit, + .transmit = slip_modem_transmit, .handle = slip_modem, }; @@ -192,9 +198,9 @@ static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args) return ESP_OK; } -static void esp_slip_modem_uart_rx_task(void *arg) +static void slip_modem_uart_rx_task(void *arg) { - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) arg; + slip_modem_t *slip_modem = (slip_modem_t *) arg; ESP_LOGD(TAG, "Start SLIP modem RX task (slip_modem %p filter: %p)", slip_modem, slip_modem->rx_filter); ESP_LOGD(TAG, "Uart: %d, buffer: %p (%d bytes)", slip_modem->uart.uart_dev, slip_modem->buffer, slip_modem->buffer_len); @@ -213,11 +219,12 @@ static void esp_slip_modem_uart_rx_task(void *arg) slip_modem->buffer[len] = '\0'; // Filter if provided - if ((slip_modem->rx_filter != NULL) && slip_modem->rx_filter(slip_modem->rx_filter_ctx, slip_modem->buffer, len)) { + if ((slip_modem->rx_filter != NULL) && slip_modem->rx_filter(slip_modem, slip_modem->buffer, len)) { continue; } // Pass received bytes in to slip interface + ESP_LOGI(TAG, "esp_netif %p", slip_modem->base.netif); esp_netif_receive(slip_modem->base.netif, slip_modem->buffer, len, NULL); } @@ -225,3 +232,16 @@ static void esp_slip_modem_uart_rx_task(void *arg) vTaskDelay(1 * portTICK_PERIOD_MS); } } + +/** + * @brief Gets the internally configured ipv6 address + */ +const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip) +{ + return &slip->addr; +} + +void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len) +{ + slip_modem_netif_raw_output(slip->base.netif, buffer, len); +} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c new file mode 100644 index 0000000000..ee90bb6e0f --- /dev/null +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c @@ -0,0 +1,192 @@ +/* + * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "esp_netif.h" +#include "esp_log.h" +#include "esp_netif_net_stack.h" +#include "lwip/esp_netif_net_stack.h" +#include "lwip/dns.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" +#include "netif/slipif.h" +#include "lwip/sio.h" + +static const char *TAG = "slip-modem-netif"; + +/** + * @brief Stops the SLIP interface + */ +esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif) +{ + struct netif *netif = esp_netif_get_netif_impl(esp_netif); + + ESP_LOGI(TAG, "%s: Stopped SLIP connection: lwip netif:%p", __func__, netif); + + // Stop interface + netif_set_link_down(netif); + + return ESP_OK; +} + +/** + * @brief Starts the SLIP interface + */ +esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr) +{ + struct netif *netif = esp_netif_get_netif_impl(esp_netif); + + ESP_LOGI(TAG, "%s: Starting SLIP interface: lwip netif:%p", __func__, netif); + + // Set the netif up + netif_set_up(netif); + netif_set_link_up(netif); +#if CONFIG_LWIP_IPV6 + int8_t addr_index = 0; + + netif_ip6_addr_set(netif, addr_index, (ip6_addr_t *)addr); + netif_ip6_addr_set_state(netif, addr_index, IP6_ADDR_VALID); +#endif + return ESP_OK; +} + +/** + * @brief Write incoming serial data to the SLIP interface + */ +void esp_netif_lwip_slip_input(void *h, void *buffer, unsigned int len, void *eb) +{ + struct netif *netif = h; + + ESP_LOGD(TAG, "%s", __func__); + ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); + + // Update slip netif with data + const int max_batch = 255; + int sent = 0; + while(sent < len) { + int batch = (len - sent) > max_batch ? max_batch : (len - sent); + slipif_received_bytes(netif, buffer+sent, batch); + sent += batch; + } + + // Process incoming bytes + for (int i = 0; i < len; i++) { + slipif_process_rxqueue(netif); + } +} + +/** + * @brief Write raw data out the SLIP interface + */ +void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len) +{ + struct netif *lwip_netif = esp_netif_get_netif_impl(netif); + + ESP_LOGD(TAG, "%s", __func__); + + struct pbuf p = { + .next = NULL, + .payload = buffer, + .tot_len = len, + .len = len, + }; + + // Call slip if output function to feed data out slip interface +#if CONFIG_LWIP_IPV6 + lwip_netif->output_ip6(lwip_netif, &p, NULL); +#else + lwip_netif->output(lwip_netif, &p, NULL); +#endif +} + + +/** @brief Get esp-netif object corresponding to registration index + */ +static esp_netif_t * get_netif_with_esp_index(int index) +{ + esp_netif_t *netif = NULL; + int counter = 0; + while ((netif = esp_netif_next(netif)) != NULL) { + if (counter == index) { + return netif; + } + counter++; + } + return NULL; +} + +/** @brief Return list registration index of the supplied netif ptr + */ +static int get_esp_netif_index(esp_netif_t * esp_netif) +{ + esp_netif_t *netif = NULL; + int counter = 0; + while ((netif = esp_netif_next(netif)) != NULL) { + if (esp_netif == netif) { + return counter; + } + counter++; + } + return -1; +} + +err_t esp_slipif_init(struct netif *netif) +{ + esp_netif_t *esp_netif = netif->state; + int esp_index = get_esp_netif_index(esp_netif); + if (esp_index < 0) { + return ERR_IF; + } + + // Store netif index in net interface for SIO open command to abstract the dev + netif->state = (void *)esp_index; + + return slipif_init(netif); +} + +const struct esp_netif_netstack_config s_netif_config_slip = { + .lwip = { + .init_fn = esp_slipif_init, + .input_fn = esp_netif_lwip_slip_input, + } +}; + +const esp_netif_netstack_config_t *netstack_default_slip = &s_netif_config_slip; + + +/*** + * @brief Open a serial device for communication + */ +sio_fd_t sio_open(uint8_t devnum) +{ + ESP_LOGD(TAG, "Opening device: %d\r\n", devnum); + + esp_netif_t *esp_netif = get_netif_with_esp_index(devnum); + if (!esp_netif) { + ESP_LOGE(TAG, "didn't find esp-netif with index=%d\n", devnum); + return NULL; + } + + // Return SIO handle + return esp_netif; +} + +/*** + * @brief Send a single character to the serial device (blocking) + */ +void sio_send(uint8_t c, sio_fd_t fd) +{ + esp_netif_t *esp_netif = fd; + + ESP_LOGD(TAG, "%s", __func__); + ESP_LOG_BUFFER_HEX_LEVEL(TAG, &c, 1, ESP_LOG_DEBUG); + + esp_err_t ret = esp_netif_transmit(esp_netif, &c, 1); + if (ret != ESP_OK) { + // Handle errors + ESP_LOGD(TAG, "%s: uart_write_bytes error %i", __func__, ret); + } +} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h new file mode 100644 index 0000000000..339ee675bf --- /dev/null +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h @@ -0,0 +1,42 @@ +/* + * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +/** + * @brief Stop the esp slip netif + * + * @param[in] esp_netif handle to slip esp-netif instance + * + * @return + * - ESP_OK on success + */ +esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif); + +/** + * @brief Start the esp slip netif + * + * @param[in] esp_netif handle to slip esp-netif instance + * @param[in] addr IPv6 address associated with this SLIP interface + * + * @return + * - ESP_OK on success + */ +esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr); + +/** + * @brief Data path API to write raw packet ous the SLIP interface + * + * This API is typically used when implementing user defined methods + * + * @param[in] esp_netif handle to slip esp-netif instance + * @param[in] buffer pointer to the outgoing data + * @param[in] len length of the data + * + * @return + * - ESP_OK on success + */ +void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild b/examples/protocols/slip/slip_udp/main/Kconfig.projbuild index e23abfa081..047ba12e2f 100644 --- a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild +++ b/examples/protocols/slip/slip_udp/main/Kconfig.projbuild @@ -3,14 +3,14 @@ menu "Example Configuration" menu "UART Configuration" config EXAMPLE_UART_TX_PIN int "TXD Pin Number" - default 4 + default 25 range 0 36 help Pin number of UART TX. config EXAMPLE_UART_RX_PIN int "RXD Pin Number" - default 36 + default 26 range 0 36 help Pin number of UART RX. diff --git a/examples/protocols/slip/slip_udp/main/slip_client_main.c b/examples/protocols/slip/slip_udp/main/slip_client_main.c index 8bb131f986..72a364a4f6 100644 --- a/examples/protocols/slip/slip_udp/main/slip_client_main.c +++ b/examples/protocols/slip/slip_udp/main/slip_client_main.c @@ -7,20 +7,18 @@ CONDITIONS OF ANY KIND, either express or implied. */ #include +#include + #include "freertos/FreeRTOS.h" #include "freertos/task.h" - #include "esp_system.h" #include "esp_log.h" #include "esp_event.h" #include "esp_netif.h" -#include "esp_netif_slip.h" - -#include "lwip/sockets.h" #include "slip_modem.h" -static const char *TAG = "SLIP_EXAMPLE"; +static const char *TAG = "slip-example"; #define STACK_SIZE (10 * 1024) #define PRIORITY 10 @@ -118,13 +116,10 @@ esp_err_t udp_rx_tx_init(void) } // Write a prefix to the contiki slip device -static void slip_set_prefix(esp_netif_t *slip_netif) +static void slip_set_prefix(slip_modem_t *slip) { uint8_t buff[10] = {0}; - - // Fetch the slip interface IP - const esp_ip6_addr_t *addr = esp_slip_get_ip6(slip_netif); - + const esp_ip6_addr_t *addr = slip_modem_get_ipv6_address(slip); ESP_LOGI(TAG, "%s: prefix set (%08x:%08x)", __func__, lwip_ntohl(addr->addr[0]), lwip_ntohl(addr->addr[1])); @@ -138,21 +133,18 @@ static void slip_set_prefix(esp_netif_t *slip_netif) } // Write raw data out the slip interface - esp_netif_lwip_slip_raw_output(slip_netif, buff, 2 + 8); + slip_modem_raw_output(slip, buff, 2 + 8); } // slip_rx_filter filters incoming commands from the slip interface // this implementation is designed for use with contiki slip devices -bool slip_rx_filter(void *ctx, uint8_t *data, uint32_t len) +static bool slip_rx_filter(slip_modem_t *slip, uint8_t *data, uint32_t len) { - - esp_netif_t *slip_netif = (esp_netif_t *)ctx; - if (data[1] == '?') { switch (data[2]) { case 'P': ESP_LOGI(TAG, "Prefix request"); - slip_set_prefix(slip_netif); + slip_set_prefix(slip); return true; @@ -191,24 +183,21 @@ esp_netif_t *slip_if_init(void) #endif esp_netif_config_t cfg = { .base = &base_cfg, .driver = NULL, - .stack = ESP_NETIF_NETSTACK_DEFAULT_SLIP }; + .stack = netstack_default_slip }; esp_netif_t *slip_netif = esp_netif_new(&cfg); - esp_netif_slip_config_t slip_config; - - IP6_ADDR(&slip_config.ip6_addr, + esp_ip6_addr_t local_addr; /* Local IP6 address */ + IP6_ADDR(&local_addr, lwip_htonl(0xfd0000), lwip_htonl(0x00000000), lwip_htonl(0x00000000), lwip_htonl(0x00000001) ); - esp_netif_slip_set_params(slip_netif, &slip_config); - ESP_LOGI(TAG, "Initialising SLIP modem"); - esp_slip_modem_config_t modem_cfg = { + slip_modem_config_t modem_cfg = { .uart_dev = UART_NUM_1, .uart_tx_pin = CONFIG_EXAMPLE_UART_TX_PIN, @@ -216,12 +205,12 @@ esp_netif_t *slip_if_init(void) .uart_baud = CONFIG_EXAMPLE_UART_BAUD, .rx_buffer_len = 1024, - .rx_filter = slip_rx_filter, - .rx_filter_ctx = slip_netif, + .ipv6_addr = &local_addr }; - void *slip_modem = esp_slip_modem_create(slip_netif, &modem_cfg); + void *slip_modem = slip_modem_create(slip_netif, &modem_cfg); + assert(slip_modem); ESP_ERROR_CHECK(esp_netif_attach(slip_netif, slip_modem)); ESP_LOGI(TAG, "SLIP init complete"); diff --git a/tools/ci/check_copyright_ignore.txt b/tools/ci/check_copyright_ignore.txt index 1af9e0034d..e053a03b7f 100644 --- a/tools/ci/check_copyright_ignore.txt +++ b/tools/ci/check_copyright_ignore.txt @@ -460,8 +460,6 @@ components/esp_local_ctrl/src/esp_local_ctrl_handler.c components/esp_local_ctrl/src/esp_local_ctrl_priv.h components/esp_local_ctrl/src/esp_local_ctrl_transport_ble.c components/esp_netif/include/esp_netif_ppp.h -components/esp_netif/include/esp_netif_slip.h -components/esp_netif/lwip/esp_netif_lwip_slip.h components/esp_netif/private_include/esp_netif_private.h components/esp_netif/test/test_esp_netif.c components/esp_netif/test_apps/component_ut_test.py @@ -1821,7 +1819,6 @@ examples/protocols/mqtt/ws/main/app_main.c examples/protocols/mqtt/ws/mqtt_ws_example_test.py examples/protocols/mqtt/wss/main/app_main.c examples/protocols/mqtt/wss/mqtt_wss_example_test.py -examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h examples/protocols/slip/slip_udp/main/slip_client_main.c examples/protocols/sntp/example_test.py examples/protocols/sntp/main/sntp_example_main.c