fix(eppp): Support for channels

Author: david-cermak

components/eppp_link/Kconfig

@@ -93,4 +93,21 @@ menu "eppp_link"
         default "06:00:00:00:00:02"
         depends on EPPP_LINK_DEVICE_ETH
 
+    config EPPP_LINK_CHANNELS_SUPPORT
+        bool "Enable channel support (multiple logical channels)"
+        default n
+        depends on !EPPP_LINK_DEVICE_ETH
+        help
+            Enable support for multiple logical channels in the EPPP link layer.
+            When enabled, you can configure the number of channels used for communication.
+
+    config EPPP_LINK_NR_OF_CHANNELS
+        int "Number of logical channels"
+        depends on EPPP_LINK_CHANNELS_SUPPORT && !EPPP_LINK_DEVICE_ETH
+        range 1 8
+        default 2
+        help
+            Set the number of logical channels for EPPP link communication.
+            Each channel can be used for independent data streams.
+
 endmenu

components/eppp_link/README.md

@@ -36,6 +36,14 @@ brings in the WiFi connectivity from the "SLAVE" microcontroller.
 
 Use PPP netif for UART; Keep the default (TUN) for others
 
+### Channel support (multiple logical channels)
+
+* `CONFIG_EPPP_LINK_CHANNELS_SUPPORT` -- Enable support for multiple logical channels (default: disabled)
+* `CONFIG_EPPP_LINK_NR_OF_CHANNELS` -- Number of logical channels (default: 2, range: 1-8, only visible if channel support is enabled)
+
+When channel support is enabled, the EPPP link can multiplex multiple logical data streams over the same transport. The number of channels is configurable. Channel support is not available for Ethernet transport.
+
+To use channels in your application, use the `eppp_add_channels()` API and provide your own channel transmit/receive callbacks. These APIs and related types are only available when channel support is enabled in Kconfig.
 
 ## API
 
@@ -54,6 +62,9 @@ Use PPP netif for UART; Keep the default (TUN) for others
 * `eppp_netif_start()` -- Starts the network, could be called after startup or whenever a connection is lost
 * `eppp_netif_stop()` --  Stops the network
 * `eppp_perform()` -- Perform one iteration of the PPP task (need to be called regularly in task-less configuration)
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+* `eppp_add_channels()` -- Register channel transmit/receive callbacks (only available if channel support is enabled)
+#endif
 
 ## Throughput
 

components/eppp_link/eppp_link.c

@@ -362,6 +362,7 @@ void eppp_close(esp_netif_t *netif)
     remove_handlers();
 }
 
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 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");
@@ -371,3 +372,4 @@ esp_err_t eppp_add_channels(esp_netif_t *netif, int nr, eppp_channel_fn_t *tx, c
     h->channel_rx = rx;
     return ESP_OK;
 }
+#endif

components/eppp_link/eppp_spi.c

@@ -112,13 +112,15 @@ static esp_err_t transmit(void *h, void *buffer, size_t len)
     return transmit_generic(spi_handle, 0, buffer, len);
 }
 
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 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);
 }
+#endif
 
 static void IRAM_ATTR timer_callback(void *arg)
 {
@@ -394,11 +396,11 @@ esp_err_t eppp_perform(esp_netif_t *netif)
         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 defined(CONFIG_EPPP_LINK_CHANNELS_SUPPORT)
             if (h->parent.channel_rx) {
                 h->parent.channel_rx(netif, head->channel, in_buf + sizeof(struct header), head->size);
             }
+#endif
         }
     }
     h->transaction_size = NEXT_TRANSACTION_SIZE(next_tx_size, head->next_size);
@@ -435,7 +437,9 @@ 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");
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     h->parent.channel_tx = transmit_channel;
+#endif
     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

@@ -5,16 +5,21 @@
  */
 #pragma once
 #include "esp_netif_types.h"
+#include "sdkconfig.h"
 
-#define NR_OF_CHANNELS 2
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
+#define NR_OF_CHANNELS CONFIG_EPPP_LINK_NR_OF_CHANNELS
+#else
+#define NR_OF_CHANNELS 1
+#endif
 
 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
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     eppp_channel_fn_t channel_tx;
     eppp_channel_fn_t channel_rx;
 #endif

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

@@ -87,15 +87,19 @@ static void mqtt_app_start(void)
     esp_mqtt_client_start(client);
 }
 #endif // MQTT
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 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;
 }
+#endif
 
 void app_main(void)
 {
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     static eppp_channel_fn_t transmit = NULL;
+#endif
     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());
@@ -161,11 +165,13 @@ void app_main(void)
     // start console REPL
     ESP_ERROR_CHECK(console_cmd_start());
 
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
     eppp_add_channels(eppp_netif, 1, &transmit, recv);
     while (1)  {
         transmit(eppp_netif, 1, "Hi three", 3);
         vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
+#endif
 #if CONFIG_EXAMPLE_MQTT
     mqtt_app_start();
 #endif

components/eppp_link/include/eppp_link.h

@@ -198,6 +198,8 @@ void eppp_netif_deinit(esp_netif_t *netif);
 
 esp_err_t eppp_perform(esp_netif_t *netif);
 
+#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
 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);
+#endif

components/eppp_link/plan.md

@@ -0,0 +1,28 @@
+# Plan: Make Number of Channels Configurable in eppp_link
+
+## 1. Update Kconfig ✅ (completed)
+- Add a new boolean configuration option (e.g., `CONFIG_EPPP_LINK_CHANNELS_SUPPORT`) to enable channel support in the `components/eppp_link/Kconfig` file.
+- Add a new integer configuration option (e.g., `CONFIG_EPPP_LINK_NR_OF_CHANNELS`) that is only visible when the boolean option is enabled.
+- Set reasonable defaults (e.g., boolean disabled by default, integer default of 2) and provide help text for both options.
+- Ensure both options are properly documented in the menu with appropriate dependencies.
+- **Note:** Channel support options are not available when Ethernet transport is selected (`!EPPP_LINK_DEVICE_ETH`).
+
+## 2. Update Code to Use Config Value ✅ (completed)
+- Replace all hardcoded uses of `#define NR_OF_CHANNELS 2` in `eppp_transport.h` with a macro that uses the Kconfig value (e.g., `#define NR_OF_CHANNELS CONFIG_EPPP_LINK_NR_OF_CHANNELS`).
+- Update all `.c` files that reference `NR_OF_CHANNELS` to ensure they use the new configurable value.
+- Add `#include "sdkconfig.h"` where needed to access the Kconfig value.
+- Use `#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT` for all channel-related code:
+    - The typedef for `eppp_channel_fn_t` and the `eppp_add_channels` API in `eppp_link.h` are now conditionally compiled.
+    - The `channel_tx` and `channel_rx` members in the handle struct are also conditionally compiled.
+- Ensure that all channel-related APIs and struct members are only available when channel support is enabled in Kconfig.
+
+## 3. Update Documentation
+- Update `components/eppp_link/README.md` to document the new configuration option and its effect.
+- Mention the new option in the "Configuration" section, with usage notes.
+
+## 4. Update Example Projects
+- Optionally, update example `sdkconfig.defaults` files in `examples/host` and `examples/slave` to show how to set the number of channels.
+- Add a note in example READMEs if relevant.
+
+## 5. Test and Validate
+- Build and run the examples with different values for the number of channels to ensure the configuration is respected and works as intended.