Only 1 outstanding sleep poll, remove async_ctx

Completely null out the async_context used by the CYW43 driver to ensure
it will crash immediately instead of just doing nothing should there be
some driver code which uses it.  Replace the connect routines to use
our custom methods directly.

Limit the outstanding sleep poll messages in the LWIP queue to 1.  This
avoids the case where, due to some long running operation, the sleep alarm
ends up being called multiple times before actually processing the callback
(which would flood the LWIP work queue and crash the machine).

Author: earlephilhower

cores/rp2040/lwip_wrap.cpp

@@ -887,6 +887,14 @@ extern "C" {
     void __wrap_cyw43_schedule_internal_poll_dispatch(void (*func)()) {
         __real_cyw43_schedule_internal_poll_dispatch(func);
     }
+    extern int __real_cyw43_arch_wifi_connect_bssid_timeout_ms(const char *ssid, const uint8_t *bssid, const char *pw, uint32_t auth, uint32_t timeout_ms);
+    int __wrap_cyw43_arch_wifi_connect_bssid_timeout_ms(const char *ssid, const uint8_t *bssid, const char *pw, uint32_t auth, uint32_t timeout_ms) {
+        return __real_cyw43_arch_wifi_connect_bssid_timeout_ms(ssid, bssid, pw, auth, timeout_ms);
+    }
+    extern int __real_cyw43_arch_wifi_connect_timeout_ms(const char *ssid, const char *pw, uint32_t auth, uint32_t timeout_ms);
+    extern "C" int __wrap_cyw43_arch_wifi_connect_timeout_ms(const char *ssid, const char *pw, uint32_t auth, uint32_t timeout_ms) {
+        return __real_cyw43_arch_wifi_connect_timeout_ms(ssid, pw, auth, timeout_ms);
+    }
 
 #endif
 

cores/rp2040/sdkoverride/cyw43_arch_freertos.c

@@ -50,14 +50,17 @@ async_context_t *cyw43_arch_init_default_async_context(void) {
 }
 
 int cyw43_arch_init(void) {
-    async_context_t *context = cyw43_arch_async_context();
-    if (!context) {
-        context = cyw43_arch_init_default_async_context();
-        if (!context) {
-            return PICO_ERROR_GENERIC;
-        }
-        cyw43_arch_set_async_context(context);
-    }
+//    async_context_t *context = cyw43_arch_async_context();
+//    if (!context) {
+//        context = cyw43_arch_init_default_async_context();
+//        if (!context) {
+//            return PICO_ERROR_GENERIC;
+//        }
+//        cyw43_arch_set_async_context(context);
+//    }
+    async_context_t *context = NULL;
+    cyw43_arch_set_async_context(context);
+
     bool ok = cyw43_driver_init(context);
 #if CYW43_LWIP
     ok &= lwip_freertos_init(context);

lib/core_wrap.txt

@@ -90,4 +90,5 @@
 -Wl,--wrap=cyw43_delay_us
 -Wl,--wrap=cyw43_post_poll_hook
 -Wl,--wrap=cyw43_schedule_internal_poll_dispatch
-
+-Wl,--wrap=cyw43_arch_wifi_connect_bssid_timeout_ms
+-Wl,--wrap=cyw43_arch_wifi_connect_timeout_ms

libraries/lwIP_CYW43/src/cyw43_driver_freertos.cpp

@@ -39,6 +39,7 @@ extern "C" {
 
 static SemaphoreHandle_t _cyw43_arch_mutex;
 static SemaphoreHandle_t _cyw43_irq_called_binary;
+static SemaphoreHandle_t _cyw43_sleep_poll_binary;
 
 static void cb_cyw43_do_poll(void *context);
 static __callback_req _irqBuffer;
@@ -86,12 +87,17 @@ extern "C" void __wrap_cyw43_schedule_internal_poll_dispatch(__unused void (*fun
     lwip_callback(cb_cyw43_do_poll, nullptr);
 }
 
+
+
 static int64_t cb_cyw43_sleep_timeout_reached(alarm_id_t id, void *ptr) {
     (void) id;
     (void) ptr;
     static __callback_req _sleepIRQBuffer;
     // This will be in IRQ context, so do a lwip callback.  Only one at a time can be outstanding so this single struct is good enough
-    lwip_callback(cb_cyw43_do_poll, nullptr, &_sleepIRQBuffer);
+    BaseType_t pxHigherPriorityTaskWoken;
+    if (xSemaphoreTakeFromISR(_cyw43_sleep_poll_binary, &pxHigherPriorityTaskWoken)) {
+        lwip_callback(cb_cyw43_do_poll, nullptr, &_sleepIRQBuffer);
+    }
     return 0; // Don't reschedule
 }
 
@@ -100,6 +106,7 @@ static void cb_cyw43_do_poll(void *context) { //, __unused async_when_pending_wo
 #ifndef NDEBUG
     assert(get_core_num() == 0);
 #endif
+    cyw43_thread_enter();
     if (cyw43_poll) {
         if (cyw43_sleep > 0) {
             cyw43_sleep--;
@@ -111,12 +118,17 @@ static void cb_cyw43_do_poll(void *context) { //, __unused async_when_pending_wo
             // Nothing to do.  We have 1-shot alarms
         }
     }
+    cyw43_thread_exit();
+    xSemaphoreGive(_cyw43_irq_called_binary);
+    xSemaphoreGive(_cyw43_sleep_poll_binary);
 }
 
 extern "C" bool __wrap_cyw43_driver_init(async_context_t *context) {
     assert(get_core_num() == 0);
     _cyw43_arch_mutex = xSemaphoreCreateRecursiveMutex();
     _cyw43_irq_called_binary = xSemaphoreCreateBinary();
+    _cyw43_sleep_poll_binary = xSemaphoreCreateBinary();
+    xSemaphoreGive(_cyw43_sleep_poll_binary);
     cyw43_init(&cyw43_state);
     cyw43_irq_init(nullptr);
     return true;
@@ -144,6 +156,7 @@ extern "C" void __wrap_cyw43_thread_lock_check() {
 #endif
 
 extern "C" void __wrap_cyw43_await_background_or_timeout_us(uint32_t timeout_us) {
+//    cyw43_set_irq_enabled(true);
     if (__get_current_exception() > 0) {
         vTaskDelay((timeout_us / 1000) / portTICK_PERIOD_MS);
         return;
@@ -165,4 +178,48 @@ extern "C" void __wrap_cyw43_delay_us(uint32_t us) {
     delayMicroseconds(us);
 }
 
+
+
+static int this_cyw43_arch_wifi_connect_bssid_until(const char *ssid, const uint8_t *bssid, const char *pw, uint32_t auth, uint32_t timeout_ms) {
+    uint32_t start = millis();
+    int err = cyw43_arch_wifi_connect_bssid_async(ssid, bssid, pw, auth);
+    if (err) return err;
+    int status = CYW43_LINK_UP + 1;
+    while(status >= 0 && status != CYW43_LINK_UP) {
+        int new_status = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);
+        // If there was no network, keep trying
+        if (new_status == CYW43_LINK_NONET) {
+            new_status = CYW43_LINK_JOIN;
+            err = cyw43_arch_wifi_connect_bssid_async(ssid, bssid, pw, auth);
+            if (err) return err;
+        }
+        if (new_status != status) {
+            status = new_status;
+        }
+        uint32_t delta = millis() - start;
+        if (delta > timeout_ms) {
+            return PICO_ERROR_TIMEOUT;
+        }
+        // Do polling
+        //cyw43_arch_poll();
+        __wrap_cyw43_await_background_or_timeout_us((timeout_ms - delta) * 1000); //cyw43_arch_wait_for_work_until(until);
+    }
+    // Turn status into a pico_error_codes, CYW43_LINK_NONET shouldn't happen as we fail with PICO_ERROR_TIMEOUT instead
+    assert(status == CYW43_LINK_UP || status == CYW43_LINK_BADAUTH || status == CYW43_LINK_FAIL);
+    if (status == CYW43_LINK_UP) {
+        return PICO_OK; // success
+    } else if (status == CYW43_LINK_BADAUTH) {
+        return PICO_ERROR_BADAUTH;
+    } else {
+        return PICO_ERROR_CONNECT_FAILED;
+    }
+}
+extern "C" int __wrap_cyw43_arch_wifi_connect_bssid_timeout_ms(const char *ssid, const uint8_t *bssid, const char *pw, uint32_t auth, uint32_t timeout_ms) {
+    return this_cyw43_arch_wifi_connect_bssid_until(ssid, bssid, pw, auth, timeout_ms); //make_timeout_time_ms(timeout_ms));
+}
+
+extern "C" int __wrap_cyw43_arch_wifi_connect_timeout_ms(const char *ssid, const char *pw, uint32_t auth, uint32_t timeout_ms) {
+    return __wrap_cyw43_arch_wifi_connect_bssid_timeout_ms(ssid, nullptr, pw, auth, timeout_ms);
+}
+
 #endif