feat(eppp): API to add channels

Author: david-cermak

components/eppp_link/eppp_link.c

@@ -361,3 +361,13 @@ void eppp_close(esp_netif_t *netif)
     eppp_deinit(netif);
     remove_handlers();
 }
+
+esp_err_t eppp_add_channels(esp_netif_t *netif, int nr, eppp_channel_fn_t *tx, const eppp_channel_fn_t rx)
+{
+    ESP_RETURN_ON_FALSE(netif != NULL && nr > 0 && nr < NR_OF_CHANNELS && tx != NULL && rx != NULL, ESP_ERR_INVALID_ARG, TAG, "Invalid arguments");
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    ESP_RETURN_ON_FALSE(h != NULL && h->channel_tx != NULL, ESP_ERR_INVALID_STATE, TAG, "Transport not initialized");
+    *tx = h->channel_tx;
+    h->channel_rx = rx;
+    return ESP_OK;
+}

components/eppp_link/eppp_sdio.h

@@ -11,7 +11,6 @@
 #define SDIO_PACKET_SIZE SDIO_ALIGN(MAX_SDIO_PAYLOAD + 4)
 #define PPP_SOF 0x7E
 
-#define NR_OF_CHANNELS 2
 
 // Interrupts and registers
 #define SLAVE_INTR      0

components/eppp_link/eppp_spi.c

@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdint.h>
 #include <inttypes.h>
+#include "sdkconfig.h"
 #include "esp_log.h"
 #include "esp_netif.h"
 #include "esp_check.h"
@@ -24,18 +25,21 @@
 
 #define MAX_PAYLOAD 1500
 #define MIN_TRIGGER_US 20
-#define SPI_HEADER_MAGIC 0x1234
+#define PPP_SOF 0x7E
+#define SPI_HEADER_MAGIC PPP_SOF
 #define SPI_ALIGN(size) (((size) + 3U) & ~(3U))
 #define TRANSFER_SIZE SPI_ALIGN((MAX_PAYLOAD + 6))
 #define NEXT_TRANSACTION_SIZE(a,b) (((a)>(b))?(a):(b)) /* next transaction: whichever is bigger */
 
 struct packet {
     size_t len;
     uint8_t *data;
+    int channel;
 };
 
 struct header {
-    uint16_t magic;
+    uint8_t magic;
+    uint8_t channel;
     uint16_t size;
     uint16_t next_size;
     uint16_t check;
@@ -65,12 +69,10 @@ struct eppp_spi {
     esp_timer_handle_t timer;
 };
 
-static esp_err_t transmit(void *h, void *buffer, size_t len)
+static esp_err_t transmit_generic(struct eppp_spi *handle, int channel, void *buffer, size_t len)
 {
-    struct eppp_handle *common = h;
-    struct eppp_spi *handle = __containerof(common, struct eppp_spi, parent);;
-#if CONFIG_EPPP_LINK_DEVICE_SPI
-    struct packet buf = { };
+
+    struct packet buf = { .channel = channel };
     uint8_t *current_buffer = buffer;
     size_t remaining = len;
     do {    // TODO(IDF-9194): Refactor this loop to allocate only once and perform
@@ -100,14 +102,24 @@ static esp_err_t transmit(void *h, void *buffer, size_t len)
         }
         gpio_set_level(handle->gpio_intr, 0);
     }
-
-#elif CONFIG_EPPP_LINK_DEVICE_UART
-    ESP_LOG_BUFFER_HEXDUMP("ppp_uart_send", buffer, len, ESP_LOG_WARN);
-    uart_write_bytes(handle->uart_port, buffer, len);
-#endif // DEVICE UART or SPI
     return ESP_OK;
 }
 
+static esp_err_t transmit(void *h, void *buffer, size_t len)
+{
+    struct eppp_handle *handle = h;
+    struct eppp_spi *spi_handle = __containerof(handle, struct eppp_spi, parent);;
+    return transmit_generic(spi_handle, 0, buffer, len);
+}
+
+static esp_err_t transmit_channel(esp_netif_t *netif, int channel, void *buffer, size_t len)
+{
+//    printf("transmit_channel %d %p %zu\n", channel, buffer, len);
+    struct eppp_handle *handle = esp_netif_get_io_driver(netif);
+    struct eppp_spi *spi_handle = __containerof(handle, struct eppp_spi, parent);;
+    return transmit_generic(spi_handle, channel, buffer, len);
+}
+
 static void IRAM_ATTR timer_callback(void *arg)
 {
     struct eppp_spi *h = arg;
@@ -339,6 +351,7 @@ esp_err_t eppp_perform(esp_netif_t *netif)
     if (h->outbound.len <= h->transaction_size && allow_test_tx == false) {
         // sending outbound
         head->size = h->outbound.len;
+        head->channel = h->outbound.channel;
         if (h->outbound.len > 0) {
             memcpy(out_buf + sizeof(struct header), h->outbound.data, h->outbound.len);
             free(h->outbound.data);
@@ -355,6 +368,7 @@ esp_err_t eppp_perform(esp_netif_t *netif)
     } else {
         // outbound is bigger, need to transmit in another transaction (keep this empty)
         head->size = 0;
+        head->channel = 0;
     }
     next_tx_size = head->next_size = h->outbound.len;
     head->magic = SPI_HEADER_MAGIC;
@@ -367,17 +381,25 @@ esp_err_t eppp_perform(esp_netif_t *netif)
     }
     head = (void *)in_buf;
     uint16_t check = esp_rom_crc16_le(0, in_buf, sizeof(struct header) - sizeof(uint16_t));
-    if (check != head->check || head->magic != SPI_HEADER_MAGIC) {
+    if (check != head->check || head->magic != SPI_HEADER_MAGIC || head->channel >= NR_OF_CHANNELS) {
         h->transaction_size = 0; // need to start with HEADER only transaction
         if (allow_test_tx) {
             return ESP_OK;
         }
-        ESP_LOGE(TAG, "Wrong checksum or magic");
+        ESP_LOGE(TAG, "Wrong checksum, magic, or channel: %x %x %x", check, head->magic, head->channel);
         return ESP_FAIL;
     }
     if (head->size > 0) {
         ESP_LOG_BUFFER_HEXDUMP(TAG, in_buf + sizeof(struct header), head->size, ESP_LOG_VERBOSE);
-        esp_netif_receive(netif, in_buf + sizeof(struct header), head->size, NULL);
+        if (head->channel == 0) {
+            esp_netif_receive(netif, in_buf + sizeof(struct header), head->size, NULL);
+        } else {
+//            printf("channel receive %d\n", head->channel);
+//            printf("channel_rx  %p\n", h->parent.channel_rx);
+            if (h->parent.channel_rx) {
+                h->parent.channel_rx(netif, head->channel, in_buf + sizeof(struct header), head->size);
+            }
+        }
     }
     h->transaction_size = NEXT_TRANSACTION_SIZE(next_tx_size, head->next_size);
     return ESP_OK;
@@ -413,6 +435,7 @@ eppp_transport_handle_t eppp_spi_init(struct eppp_config_spi_s *config)
     __attribute__((unused)) esp_err_t ret = ESP_OK;
     struct eppp_spi *h = calloc(1, sizeof(struct eppp_spi));
     ESP_RETURN_ON_FALSE(h, NULL, TAG, "Failed to allocate eppp_handle");
+    h->parent.channel_tx = transmit_channel;
     h->is_master = config->is_master;
     h->parent.base.post_attach = post_attach;
     h->out_queue = xQueueCreate(CONFIG_EPPP_LINK_PACKET_QUEUE_SIZE, sizeof(struct packet));

components/eppp_link/eppp_transport.h

@@ -6,12 +6,18 @@
 #pragma once
 #include "esp_netif_types.h"
 
+#define NR_OF_CHANNELS 2
+
 struct eppp_handle {
     esp_netif_driver_base_t base;
     eppp_type_t role;
     bool stop;
     bool exited;
     bool netif_stop;
+#if NR_OF_CHANNELS > 0
+    eppp_channel_fn_t channel_tx;
+    eppp_channel_fn_t channel_rx;
+#endif
 };
 
 esp_err_t eppp_check_connection(esp_netif_t *netif);

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

@@ -87,10 +87,15 @@ static void mqtt_app_start(void)
     esp_mqtt_client_start(client);
 }
 #endif // MQTT
-
+static esp_err_t recv(esp_netif_t *netif, int nr, void *buffer, size_t len)
+{
+    printf("recv %d %p %zu\n", nr, buffer, len);
+    return ESP_OK;
+}
 
 void app_main(void)
 {
+    static eppp_channel_fn_t transmit = NULL;
     ESP_LOGI(TAG, "[APP] Startup..");
     ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
     ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
@@ -156,6 +161,11 @@ void app_main(void)
     // start console REPL
     ESP_ERROR_CHECK(console_cmd_start());
 
+    eppp_add_channels(eppp_netif, 1, &transmit, recv);
+    while (1)  {
+        transmit(eppp_netif, 1, "Hi three", 3);
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
 #if CONFIG_EXAMPLE_MQTT
     mqtt_app_start();
 #endif

components/eppp_link/examples/slave/main/eppp_slave.c

@@ -114,8 +114,18 @@ void init_network_interface(void)
 
 #endif // SoC WiFi capable chip
 
+static esp_err_t recv(esp_netif_t *netif, int nr, void *buffer, size_t len)
+{
+    char data[32];
+    if (len < sizeof(data)) {
+        memcpy(data, buffer, len);
+        printf("Received #[%d] %s\n", nr, data);
+    }
+    return ESP_OK;
+}
 void app_main(void)
 {
+    static eppp_channel_fn_t transmit = NULL;
     //Initialize NVS
     esp_err_t ret = nvs_flash_init();
     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
@@ -153,6 +163,14 @@ void app_main(void)
         ESP_LOGE(TAG, "Failed to setup connection");
         return ;
     }
-    vTaskDelay(10000 / portTICK_PERIOD_MS);
     ESP_ERROR_CHECK(esp_netif_napt_enable(eppp_netif));
+    ret = eppp_add_channels(eppp_netif, 1, &transmit, recv);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to add channels");
+        return ;
+    }
+    while (1)  {
+        transmit(eppp_netif, 1, "SLAve three", 3);
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
 }

components/eppp_link/include/eppp_link.h

@@ -197,3 +197,7 @@ esp_err_t eppp_netif_start(esp_netif_t *netif);
 void eppp_netif_deinit(esp_netif_t *netif);
 
 esp_err_t eppp_perform(esp_netif_t *netif);
+
+typedef esp_err_t (*eppp_channel_fn_t)(esp_netif_t *netif, int nr, void *buffer, size_t len);
+
+esp_err_t eppp_add_channels(esp_netif_t *netif, int nr, eppp_channel_fn_t *tx, const eppp_channel_fn_t rx);