Unbreak FreeRTOS, clean up unused async_ctx method

When in FreeRTOS, we don't use an async_context to drive our Ethernet
NICs.  Ifdef around any unused code/variables.

Author: earlephilhower

libraries/lwIP_Ethernet/src/LwipEthernet.cpp

@@ -31,20 +31,8 @@
 #include <pico/async_context_freertos.h>
 #include "FreeRTOS.h"
 #include "task.h"
-//static async_context_freertos_t lwip_ethernet_async_context;
-//static StackType_t lwip_ethernet_async_context_freertos_task_stack[CYW43_TASK_STACK_SIZE];
-
-//static async_context_t *lwip_ethernet_init_default_async_context(void) {
-//    async_context_freertos_config_t config = async_context_freertos_default_config();
-//#if configSUPPORT_STATIC_ALLOCATION && !CYW43_NO_DEFAULT_TASK_STACK
-//    config.task_stack = lwip_ethernet_async_context_freertos_task_stack;
-//#endif
-//    if (async_context_freertos_init(&lwip_ethernet_async_context, &config)) {
-//        return &lwip_ethernet_async_context.core;
-//    }
-//    return NULL;
-//}
-
+#include "semphr.h"
+static SemaphoreHandle_t _lwip_ethernet_mutex;
 #else
 #include <pico/async_context_threadsafe_background.h>
 static async_context_threadsafe_background_t lwip_ethernet_async_context;
@@ -56,6 +44,10 @@ static async_context_t *lwip_ethernet_init_default_async_context(void) {
     }
     return NULL;
 }
+// Async context that pumps the ethernet controllers
+static async_when_pending_worker_t always_pending_update_timeout_worker;
+static async_at_time_worker_t ethernet_timeout_worker;
+static async_context_t *_context = nullptr;
 
 #endif
 
@@ -64,36 +56,37 @@ static async_context_t *lwip_ethernet_init_default_async_context(void) {
 
 bool __ethernetContextInitted = false;
 
-// Async context that pumps the ethernet controllers
-static async_when_pending_worker_t always_pending_update_timeout_worker;
-static async_at_time_worker_t ethernet_timeout_worker;
-static async_context_t *_context = nullptr;
 
 // Theoretically support multiple interfaces
 static std::map<int, std::function<void(void)>> _handlePacketList;
 
 void ethernet_arch_lwip_begin() {
+    __startEthernetContext();
 #ifdef __FREERTOS
-    panic("oops");
+    xSemaphoreTake(_lwip_ethernet_mutex, portMAX_DELAY);
+#else
+#if defined(PICO_CYW43_SUPPORTED)
+    if (rp2040.isPicoW()) {
+        cyw43_arch_lwip_begin();
+        return;
+    }
+#endif
+    async_context_acquire_lock_blocking(_context);
 #endif
-    #if defined(PICO_CYW43_SUPPORTED)
-        if (rp2040.isPicoW()) {
-            cyw43_arch_lwip_begin();
-            return;
-        }
-    #endif
-        __startEthernetContext();
-        async_context_acquire_lock_blocking(_context);
 }
 
 void ethernet_arch_lwip_end() {
-    #if defined(PICO_CYW43_SUPPORTED)
-        if (rp2040.isPicoW()) {
-            cyw43_arch_lwip_end();
-            return;
-        }
-    #endif
-        async_context_release_lock(_context);
+#ifdef __FREERTOS
+    xSemaphoreGive(_lwip_ethernet_mutex);
+#else
+#if defined(PICO_CYW43_SUPPORTED)
+    if (rp2040.isPicoW()) {
+        cyw43_arch_lwip_end();
+        return;
+    }
+#endif
+    async_context_release_lock(_context);
+#endif
 }
 
 int __addEthernetPacketHandler(std::function<void(void)> _packetHandler) {
@@ -207,24 +200,6 @@ int hostByName(const char* aHostname, IPAddress& aResult, int timeout_ms) {
 
 uint32_t __ethernet_timeout_reached_calls = 0;
 static uint32_t _pollingPeriod = 20;
-// This will only be called under the protection of the async context mutex, so no re-entrancy checks needed
-static void ethernet_timeout_reached(__unused async_context_t *context, __unused async_at_time_worker_t *worker) {
-    assert(worker == &ethernet_timeout_worker);
-    __ethernet_timeout_reached_calls++;
-    ethernet_arch_lwip_gpio_mask(); // Ensure non-polled devices won't interrupt us
-    for (auto handlePacket : _handlePacketList) {
-        handlePacket.second();
-        sys_check_timeouts();
-    }
-    ethernet_arch_lwip_gpio_unmask();
-}
-
-static void update_next_timeout(async_context_t *context, async_when_pending_worker_t *worker) {
-    assert(worker == &always_pending_update_timeout_worker);
-    worker->work_pending = true;
-    async_context_add_at_time_worker_in_ms(context, &ethernet_timeout_worker, _pollingPeriod);
-}
-
 
 // We have a background pump which calls sys_check_timeouts on a periodic basis
 // and polls all Ethernet interfaces
@@ -255,24 +230,44 @@ static void ethernetTask(void *param) {
         lwip_callback(stage2, nullptr);
     }
 }
+#else
+// This will only be called under the protection of the async context mutex, so no re-entrancy checks needed
+static void ethernet_timeout_reached(__unused async_context_t *context, __unused async_at_time_worker_t *worker) {
+    assert(worker == &ethernet_timeout_worker);
+    __ethernet_timeout_reached_calls++;
+    ethernet_arch_lwip_gpio_mask(); // Ensure non-polled devices won't interrupt us
+    for (auto handlePacket : _handlePacketList) {
+        handlePacket.second();
+        sys_check_timeouts();
+    }
+    ethernet_arch_lwip_gpio_unmask();
+}
+
+static void update_next_timeout(async_context_t *context, async_when_pending_worker_t *worker) {
+    assert(worker == &always_pending_update_timeout_worker);
+    worker->work_pending = true;
+    async_context_add_at_time_worker_in_ms(context, &ethernet_timeout_worker, _pollingPeriod);
+}
 #endif
 
+
 void __startEthernetContext() {
     if (__ethernetContextInitted) {
         return;
     }
 #ifdef __FREERTOS
+    _lwip_ethernet_mutex = xSemaphoreCreateMutex();
     xTaskCreate(ethernetTask, "EthPoll", 256, nullptr, 1, &_ethernetTask);
 #else
-    #if defined(PICO_CYW43_SUPPORTED)
+#if defined(PICO_CYW43_SUPPORTED)
     if (rp2040.isPicoW()) {
         _context = cyw43_arch_async_context();
     } else {
         _context = lwip_ethernet_init_default_async_context();
     }
-    #else
+#else
     _context = lwip_ethernet_init_default_async_context();
-    #endif
+#endif
     ethernet_timeout_worker.do_work = ethernet_timeout_reached;
     always_pending_update_timeout_worker.work_pending = true;
     always_pending_update_timeout_worker.do_work = update_next_timeout;