fix(eppp): Final fixes to SDIO transport

Author: david-cermak

components/eppp_link/eppp_sdio.c

@@ -13,6 +13,7 @@
 #include "eppp_link.h"
 #include "eppp_transport.h"
 #include "eppp_transport_sdio.h"
+#include "eppp_sdio.h"
 
 #define TAG "eppp_sdio"
 
@@ -65,6 +66,9 @@ eppp_transport_handle_t eppp_sdio_init(struct eppp_config_sdio_s *config)
     __attribute__((unused)) esp_err_t ret = ESP_OK;
     struct eppp_sdio *h = calloc(1, sizeof(struct eppp_sdio));
     ESP_RETURN_ON_FALSE(h, NULL, TAG, "Failed to allocate eppp_handle");
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+    h->parent.channel_tx = eppp_sdio_transmit_channel;
+#endif
     h->parent.base.post_attach = post_attach;
     h->is_host = config->is_host;
     esp_err_t (*init_fn)(struct eppp_config_sdio_s * eppp_config) = h->is_host ? eppp_sdio_host_init : eppp_sdio_slave_init;

components/eppp_link/eppp_sdio.h

@@ -25,3 +25,5 @@ struct header {
     uint8_t channel;
     uint16_t size;
 } __attribute__((packed));
+
+esp_err_t eppp_sdio_transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len);

components/eppp_link/eppp_sdio_host.c

@@ -15,6 +15,7 @@
 #include "sdmmc_cmd.h"
 #include "esp_check.h"
 #include "eppp_link.h"
+#include "eppp_transport.h"
 
 #if CONFIG_EPPP_LINK_DEVICE_SDIO_HOST
 
@@ -31,7 +32,7 @@ static sdmmc_card_t *s_card = NULL;
 static DRAM_DMA_ALIGNED_ATTR uint8_t send_buffer[SDIO_PACKET_SIZE];
 static DMA_ATTR uint8_t rcv_buffer[SDIO_PACKET_SIZE];
 
-esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len)
+static esp_err_t eppp_sdio_host_tx_generic(int channel, void *buffer, size_t len)
 {
     if (s_essl == NULL || s_essl_mutex == NULL) {
         // silently skip the Tx if the SDIO not fully initialized
@@ -41,7 +42,7 @@ esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len)
 
     struct header *head = (void *)send_buffer;
     head->magic = PPP_SOF;
-    head->channel = 0;
+    head->channel = channel;
     head->size = len;
     memcpy(send_buffer + sizeof(struct header), buffer, len);
     size_t send_len = SDIO_ALIGN(len + sizeof(struct header));
@@ -61,6 +62,19 @@ esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len)
     return ret;
 }
 
+esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len)
+{
+    return eppp_sdio_host_tx_generic(0, buffer, len);
+}
+
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+esp_err_t eppp_sdio_transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len)
+{
+    return eppp_sdio_host_tx_generic(channel, buffer, len);
+}
+#endif
+
+
 static esp_err_t request_slave_reset(void)
 {
     esp_err_t ret = ESP_OK;
@@ -162,7 +176,7 @@ esp_err_t eppp_sdio_host_rx(esp_netif_t *netif)
                     ESP_LOGE(TAG, "invalid magic %x", head->magic);
                     break;
                 }
-                if (head->channel >= NR_OF_CHANNELS) {
+                if (head->channel > NR_OF_CHANNELS) {
                     ESP_LOGE(TAG, "invalid channel %x", head->channel);
                     break;
                 }
@@ -171,7 +185,16 @@ esp_err_t eppp_sdio_host_rx(esp_netif_t *netif)
                     break;
                 }
                 ESP_LOG_BUFFER_HEXDUMP(TAG, rcv_buffer, size_read, ESP_LOG_VERBOSE);
-                esp_netif_receive(netif, rcv_buffer + sizeof(struct header), head->size, NULL);
+                if (head->channel == 0) {
+                    esp_netif_receive(netif, rcv_buffer + sizeof(struct header), head->size, NULL);
+                } else {
+#if defined(CONFIG_EPPP_LINK_CHANNELS_SUPPORT)
+                    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+                    if (h->channel_rx) {
+                        h->channel_rx(netif, head->channel, rcv_buffer + sizeof(struct header), head->size);
+                    }
+#endif
+                }
                 break;
             } else {
                 ESP_LOGE(TAG, "rx packet error: %08X", ret);

components/eppp_link/eppp_sdio_slave.c

@@ -10,9 +10,9 @@
 #include "esp_netif.h"
 #include "driver/sdio_slave.h"
 #include "eppp_link.h"
+#include "eppp_transport.h"
 #include "eppp_sdio.h"
 #include "esp_check.h"
-
 #if CONFIG_EPPP_LINK_DEVICE_SDIO_SLAVE
 #define BUFFER_NUM 4
 #define BUFFER_SIZE SDIO_PAYLOAD
@@ -21,23 +21,18 @@ static DMA_ATTR uint8_t sdio_slave_rx_buffer[BUFFER_NUM][BUFFER_SIZE];
 static DMA_ATTR uint8_t sdio_slave_tx_buffer[SDIO_PAYLOAD];
 static int s_slave_request = 0;
 
-esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len)
+static esp_err_t eppp_sdio_host_tx_generic(int channel, void *buffer, size_t len)
 {
     if (s_slave_request != REQ_INIT) {
         // silently skip the Tx if the SDIO not fully initialized
         return ESP_OK;
     }
     struct header *head = (void *)sdio_slave_tx_buffer;
     head->magic = PPP_SOF;
-    head->channel = 0;
+    head->channel = channel;
     head->size = len;
     memcpy(sdio_slave_tx_buffer + sizeof(struct header), buffer, len);
     size_t send_len = SDIO_ALIGN(len + sizeof(struct header));
-//    if (send_len > len) {
-//        // pad with SOF's if the size is not 4 bytes aligned
-//        memset(&sdio_slave_tx_buffer[len], PPP_SOF, send_len - len);
-//    }
-
     ESP_LOG_BUFFER_HEXDUMP(TAG, sdio_slave_tx_buffer, send_len, ESP_LOG_VERBOSE);
     esp_err_t ret = sdio_slave_transmit(sdio_slave_tx_buffer, send_len);
     if (ret != ESP_OK) {
@@ -48,6 +43,18 @@ esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len)
     return ESP_OK;
 }
 
+esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len)
+{
+    return eppp_sdio_host_tx_generic(0, buffer, len);
+}
+
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+esp_err_t eppp_sdio_transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len)
+{
+    return eppp_sdio_host_tx_generic(channel, buffer, len);
+}
+#endif
+
 static esp_err_t slave_reset(void)
 {
     esp_err_t ret = ESP_OK;
@@ -91,16 +98,24 @@ esp_err_t eppp_sdio_slave_rx(esp_netif_t *netif)
             ESP_LOGE(TAG, "invalid magic %x", head->magic);
             return ESP_FAIL;
         }
-        if (head->channel >= NR_OF_CHANNELS) {
+        if (head->channel > NR_OF_CHANNELS) {
             ESP_LOGE(TAG, "invalid channel %x", head->channel);
             return ESP_FAIL;
         }
         if (head->size > SDIO_PAYLOAD || head->size > length) {
             ESP_LOGE(TAG, "invalid size %x", head->size);
             return ESP_FAIL;
         }
-
-        esp_netif_receive(netif, ptr + sizeof(struct header), head->size, NULL);
+        if (head->channel == 0) {
+            esp_netif_receive(netif, ptr + sizeof(struct header), head->size, NULL);
+        } else {
+#if defined(CONFIG_EPPP_LINK_CHANNELS_SUPPORT)
+            struct eppp_handle *h = esp_netif_get_io_driver(netif);
+            if (h->channel_rx) {
+                h->channel_rx(netif, head->channel, ptr + sizeof(struct header), head->size);
+            }
+#endif
+        }
         if (sdio_slave_recv_load_buf(handle) != ESP_OK) {
             ESP_LOGE(TAG, "Failed to recycle packet buffer");
             return ESP_FAIL;

components/eppp_link/examples/host/main/CMakeLists.txt

@@ -1,3 +1,6 @@
+if(CONFIG_EXAMPLE_WIFI_OVER_EPPP_CHANNEL)
+    set(wifi_over_channels channel_wifi_station.c)
+endif()
 idf_component_register(SRCS app_main.c register_iperf.c
-                    channel_wifi_station.c
-                    INCLUDE_DIRS ".")
+                            ${wifi_over_channels}
+                       INCLUDE_DIRS ".")

components/eppp_link/examples/host/main/Kconfig.projbuild

@@ -50,4 +50,14 @@ menu "Example Configuration"
         help
             Baudrate used by the PPP over UART
 
+    config EXAMPLE_WIFI_OVER_EPPP_CHANNEL
+        bool "Use WiFi over EPPP channel"
+        default n
+        depends on EPPP_LINK_CHANNELS_SUPPORT && ESP_WIFI_REMOTE_ENABLED
+        help
+            Enable this option to use WiFi over EPPP channel.
+            If this option is enabled, the example will only start the Wi-Fi driver,
+            but the Wi-Fi netif will reside on client's end and will channel
+            the Rx and Tx data via EPPP channels.
+
 endmenu

components/eppp_link/examples/host/main/app_main.c

@@ -17,13 +17,6 @@
 #include "esp_check.h"
 #include "mqtt_client.h"
 #include "console_ping.h"
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-#if __has_include("esp_wifi_remote.h")
-#include "esp_wifi_remote.h"
-#define HAVE_WIFI_REMOTE
-#endif
-#endif
-
 
 void register_iperf(void);
 
@@ -96,119 +89,6 @@ static void mqtt_app_start(void)
 }
 #endif // MQTT
 
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-#define HELLO_DONE BIT0
-#define WIFI_MAC BIT1
-#define CONNECT BIT2
-
-typedef enum {
-    UNKNOWN,
-    HELLO,
-    START,
-    ERROR,
-} state_t;
-static state_t s_state = UNKNOWN;
-static esp_netif_t *s_wifi_netif = NULL;
-static EventGroupHandle_t s_events;
-static eppp_channel_fn_t s_transmit = {NULL};
-static esp_err_t recv(esp_netif_t *netif, int nr, void *buffer, size_t len)
-{
-    if (nr == 1) {
-        printf("Received channel=%d len=%d %.*s\n", nr, (int)len, (int)len, (char *)buffer);
-        if (s_state == HELLO) {
-            const char hello[] = "Hello client";
-            const char mac[] = "MAC: ";
-            size_t mac_len = 5 /* MAC: */ + 6 * 2 /* 6 bytes per char */ + 5 /* : */ + 1 /* \0 */;
-            if (len == sizeof(hello) && memcmp(buffer, hello, len) == 0) {
-                xEventGroupSetBits(s_events, HELLO_DONE);
-            } else if (len == mac_len && memcmp(buffer, mac, 5) == 0) {
-                uint8_t mac_addr[6];
-                sscanf((char *)buffer + 5, "%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8,
-                       &mac_addr[0], &mac_addr[1], &mac_addr[2], &mac_addr[3], &mac_addr[4], &mac_addr[5]);
-                printf("Parsed MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
-                esp_netif_set_mac(s_wifi_netif, mac_addr);
-                xEventGroupSetBits(s_events, WIFI_MAC);
-            }
-        } else if (s_state == START) {
-            const char connected[] = "Connected";
-            if (len == sizeof(connected) && memcmp(buffer, connected, len) == 0) {
-                xEventGroupSetBits(s_events, CONNECT);
-            }
-        }
-    } else if (nr == 2) {
-        printf("Received WIFI channel=%d len=%d\n", nr, (int)len);
-//         ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_INFO);
-        return esp_wifi_remote_channel_rx(NULL, buffer, NULL, len);
-    }
-    return ESP_OK;
-}
-
-static void task_transmit(void *arg)
-{
-    int counter = 0;
-    esp_netif_t *eppp_netif = (esp_netif_t *)arg;
-    while (1) {
-        EventBits_t bits = xEventGroupWaitBits(s_events,
-                                               HELLO_DONE | WIFI_MAC | CONNECT,
-                                               pdTRUE,
-                                               pdFALSE,
-                                               pdMS_TO_TICKS(1000));
-        // if (bits & HELLO_SERVER) {
-        //     const char hello[] = "Hello server";
-        //     s_transmit(eppp_netif, 1, hello, sizeof(hello));
-        // } else
-        if (bits & HELLO_DONE) {
-            ESP_LOGI(TAG, "Hello done");
-            const char command[] = "Get MAC";
-            s_transmit(eppp_netif, 1, (void*)command, sizeof(command));
-            // s_state = CONNECTED;
-        } else if (bits & WIFI_MAC) {
-            s_state = START;
-            ESP_LOGI(TAG, "Starting WIFI");
-            esp_netif_action_start(s_wifi_netif, 0, 0, 0);
-        } else if (bits & CONNECT) {
-            ESP_LOGI(TAG, "WIFI connected");
-            esp_netif_action_connected(s_wifi_netif, 0, 0, 0);
-        } else if (s_state != START) {
-            const char hello[] = "Hello server";
-            s_transmit(eppp_netif, 1, (void*)hello, sizeof(hello));
-            s_state = HELLO;
-        }
-    }
-
-    while (1)  {
-
-        char data[32];
-        sprintf(data, "Message from host #%d", counter++);
-        s_transmit(eppp_netif, 1, data, strlen(data));
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-    }
-}
-
-esp_netif_t* esp_wifi_remote_create_default_sta(void);
-
-// move to netif2
-ESP_EVENT_DEFINE_BASE(WIFI_REMOTE_EVENT);
-
-static esp_err_t wifi_remote_tx(void *h, void *buffer, size_t len)
-{
-    esp_netif_t *eppp_netif = (esp_netif_t *)h;
-    // ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_INFO);
-    return s_transmit(eppp_netif, 2, buffer, len);
-}
-
-static void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
-{
-    ESP_LOGI(TAG, "IP event_handler: event_base=%s event_id=%d", event_base, event_id);
-    if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
-        ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
-        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
-        xEventGroupSetBits(s_events, CONNECT);
-    }
-}
-
-#endif // CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-
 void station_over_eppp_channel(void *arg);
 
 void app_main(void)
@@ -278,15 +158,8 @@ void app_main(void)
     // start console REPL
     ESP_ERROR_CHECK(console_cmd_start());
 
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+#ifdef CONFIG_EXAMPLE_WIFI_OVER_EPPP_CHANNEL
     station_over_eppp_channel(eppp_netif);
-//    ESP_RETURN_ON_FALSE(s_events = xEventGroupCreate(),, TAG, "Failed to create event group");
-//    ESP_RETURN_ON_FALSE(eppp_add_channels(eppp_netif, &s_transmit, recv, NULL) == ESP_OK,, TAG, "Failed to add channels");
-//    ESP_RETURN_ON_FALSE(s_transmit,, TAG, "Channel tx function is not set");
-//    xTaskCreate(task_transmit, "task_transmit", 2048, eppp_netif, 5, NULL);
-//    s_wifi_netif = esp_wifi_remote_create_default_sta();
-//    esp_wifi_remote_channel_set(WIFI_IF_STA, eppp_netif, wifi_remote_tx);
-//    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, event_handler, NULL);
 #endif
 #if CONFIG_EXAMPLE_MQTT
     mqtt_app_start();

components/eppp_link/examples/host/main/channel_wifi_station.c

@@ -13,12 +13,7 @@
 #include "eppp_link.h"
 #include "esp_log.h"
 #include "esp_check.h"
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-#if __has_include("esp_wifi_remote.h")
 #include "esp_wifi_remote.h"
-#define HAVE_WIFI_REMOTE
-#endif
-#endif
 
 #define CHAT_CHANNEL 1
 #define WIFI_CHANNEL 2
@@ -34,7 +29,6 @@ typedef struct context {
     eppp_channel_fn_t transmit;
     EventGroupHandle_t flags;
     state_t state;
-//    esp_netif_t *wifi;
     esp_netif_t *eppp;
 } context_t;
 

components/eppp_link/examples/host/main/idf_component.yml

@@ -5,6 +5,3 @@ dependencies:
     override_path: ../../..
   console_cmd_ping:
     version: '*'
-  espressif/esp_wifi_remote:
-    version: '*'
-    override_path: /home/david/repos/esp-wifi-remote/components/esp_wifi_remote

components/eppp_link/examples/slave/main/CMakeLists.txt

@@ -1,2 +1,6 @@
-idf_component_register(SRCS "eppp_slave.c" "channel_wifi_station.c"
-                    INCLUDE_DIRS ".")
+if(CONFIG_EXAMPLE_WIFI_OVER_EPPP_CHANNEL)
+    set(wifi_over_channels channel_wifi_station.c)
+endif()
+idf_component_register(SRCS eppp_slave.c
+                            ${wifi_over_channels}
+                       INCLUDE_DIRS ".")