Added WiFi kernel drivers and refactored Wifi service (#557)

+ other improvements
2026-07-09 21:03:38 +02:00
parent dbb96a891c
commit 1c2806bddf
104 changed files with 2347 additions and 1428 deletions
@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// Mock WiFi driver for the simulator: fakes a radio with a fixed list of
+// access points instead of talking to real hardware. Behaviour is modeled
+// after Tactility/Source/service/wifi/WifiMock.cpp (the old HAL's equivalent
+// mock) - actions succeed instantly, there's no real scan or connect delay.
+
+#include <tactility/concurrent/mutex.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/wifi.h>
+#include <tactility/log.h>
+
+#include <algorithm>
+#include <cstring>
+#include <new>
+
+#define TAG "mock_wifi"
+
+namespace {
+
+constexpr size_t WIFI_MAX_CALLBACKS = 4;
+
+struct MockApRecord {
+    const char* ssid;
+    int8_t rssi;
+    WifiAuthenticationType authentication_type;
+};
+
+// Same fixture data as the old WifiMock.cpp, so simulator UI testing sees
+// familiar results.
+constexpr MockApRecord MOCK_SCAN_RESULTS[] = {
+    { "Home Wifi", -30, WIFI_AUTHENTICATION_TYPE_WPA2_PSK },
+    { "No place like 127.0.0.1", -67, WIFI_AUTHENTICATION_TYPE_WPA2_PSK },
+    { "Pretty fly for a Wi-Fi", -70, WIFI_AUTHENTICATION_TYPE_WPA2_PSK },
+    { "An AP with a really, really long name", -80, WIFI_AUTHENTICATION_TYPE_WPA2_PSK },
+    { "Bad Reception", -90, WIFI_AUTHENTICATION_TYPE_OPEN },
+};
+constexpr size_t MOCK_SCAN_RESULT_COUNT = sizeof(MOCK_SCAN_RESULTS) / sizeof(MOCK_SCAN_RESULTS[0]);
+constexpr int8_t MOCK_CONNECTED_RSSI = -30;
+constexpr const char* MOCK_IPV4_ADDRESS = "192.168.1.2";
+
+struct WifiCallbackEntry {
+    WifiEventCallback fn = nullptr;
+    void* ctx = nullptr;
+};
+
+struct PosixWifiCtx {
+    Device* device = nullptr;
+
+    Mutex mutex {};
+    WifiRadioState radioState = WIFI_RADIO_STATE_OFF;
+    WifiStationState stationState = WIFI_STATION_STATE_DISCONNECTED;
+    bool scanning = false;
+    char targetSsid[33] = {};
+
+    Mutex callbackMutex {};
+    WifiCallbackEntry callbacks[WIFI_MAX_CALLBACKS] = {};
+    size_t callbackCount = 0;
+};
+
+#define GET_CTX(device) (static_cast<PosixWifiCtx*>(device_get_driver_data(device)))
+
+void fireEvent(PosixWifiCtx* ctx, WifiEvent event) {
+    WifiCallbackEntry local[WIFI_MAX_CALLBACKS];
+    size_t count;
+    mutex_lock(&ctx->callbackMutex);
+    count = ctx->callbackCount;
+    memcpy(local, ctx->callbacks, count * sizeof(WifiCallbackEntry));
+    mutex_unlock(&ctx->callbackMutex);
+
+    for (size_t i = 0; i < count; i++) {
+        local[i].fn(ctx->device, local[i].ctx, event);
+    }
+}
+
+// ---- WifiApi ----
+
+error_t apiGetRadioState(Device* device, WifiRadioState* state) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || state == nullptr) return ERROR_INVALID_ARGUMENT;
+    mutex_lock(&ctx->mutex);
+    *state = ctx->radioState;
+    mutex_unlock(&ctx->mutex);
+    return ERROR_NONE;
+}
+
+error_t apiGetStationState(Device* device, WifiStationState* state) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || state == nullptr) return ERROR_INVALID_ARGUMENT;
+    mutex_lock(&ctx->mutex);
+    *state = ctx->stationState;
+    mutex_unlock(&ctx->mutex);
+    return ERROR_NONE;
+}
+
+error_t apiGetAccessPointState(Device* device, WifiAccessPointState* state) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || state == nullptr) return ERROR_INVALID_ARGUMENT;
+    // Access point mode isn't implemented by this mock.
+    *state = WIFI_ACCESS_POINT_STATE_STOPPED;
+    return ERROR_NONE;
+}
+
+bool apiIsScanning(Device* device) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr) return false;
+    mutex_lock(&ctx->mutex);
+    bool scanning = ctx->scanning;
+    mutex_unlock(&ctx->mutex);
+    return scanning;
+}
+
+error_t apiScan(Device* device) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr) return ERROR_INVALID_STATE;
+
+    mutex_lock(&ctx->mutex);
+    if (ctx->radioState != WIFI_RADIO_STATE_ON || ctx->scanning) {
+        mutex_unlock(&ctx->mutex);
+        return ERROR_INVALID_STATE;
+    }
+    ctx->scanning = true;
+    mutex_unlock(&ctx->mutex);
+
+    WifiEvent started_event = {};
+    started_event.type = WIFI_EVENT_TYPE_SCAN_STARTED;
+    fireEvent(ctx, started_event);
+
+    // No real radio, so the "scan" completes instantly.
+    mutex_lock(&ctx->mutex);
+    ctx->scanning = false;
+    mutex_unlock(&ctx->mutex);
+
+    WifiEvent finished_event = {};
+    finished_event.type = WIFI_EVENT_TYPE_SCAN_FINISHED;
+    fireEvent(ctx, finished_event);
+
+    return ERROR_NONE;
+}
+
+error_t apiGetScanResults(Device* device, WifiApRecord* results, size_t* num_results) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || results == nullptr || num_results == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    size_t count = std::min(*num_results, MOCK_SCAN_RESULT_COUNT);
+    for (size_t i = 0; i < count; i++) {
+        const MockApRecord& src = MOCK_SCAN_RESULTS[i];
+        WifiApRecord& dst = results[i];
+        memset(dst.ssid, 0, sizeof(dst.ssid));
+        strncpy(dst.ssid, src.ssid, sizeof(dst.ssid) - 1);
+        dst.rssi = src.rssi;
+        dst.channel = 1;
+        dst.authentication_type = src.authentication_type;
+    }
+    *num_results = count;
+    return ERROR_NONE;
+}
+
+error_t apiStationGetIpv4Address(Device* device, char* ipv4) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || ipv4 == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    mutex_lock(&ctx->mutex);
+    bool connected = ctx->stationState == WIFI_STATION_STATE_CONNECTED;
+    mutex_unlock(&ctx->mutex);
+
+    strncpy(ipv4, connected ? MOCK_IPV4_ADDRESS : "0.0.0.0", 16);
+    return ERROR_NONE;
+}
+
+error_t apiStationGetTargetSsid(Device* device, char* ssid) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || ssid == nullptr) return ERROR_INVALID_ARGUMENT;
+    mutex_lock(&ctx->mutex);
+    strncpy(ssid, ctx->targetSsid, sizeof(ctx->targetSsid));
+    mutex_unlock(&ctx->mutex);
+    return ERROR_NONE;
+}
+
+error_t apiStationConnect(Device* device, const char* ssid, const char* password, int32_t channel) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || ssid == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    mutex_lock(&ctx->mutex);
+    if (ctx->radioState != WIFI_RADIO_STATE_ON) {
+        mutex_unlock(&ctx->mutex);
+        return ERROR_INVALID_STATE;
+    }
+    strncpy(ctx->targetSsid, ssid, sizeof(ctx->targetSsid) - 1);
+    ctx->targetSsid[sizeof(ctx->targetSsid) - 1] = '\0';
+    ctx->stationState = WIFI_STATION_STATE_CONNECTION_PENDING;
+    mutex_unlock(&ctx->mutex);
+
+    WifiEvent pending_event = {};
+    pending_event.type = WIFI_EVENT_TYPE_STATION_STATE_CHANGED;
+    pending_event.station_state = WIFI_STATION_STATE_CONNECTION_PENDING;
+    fireEvent(ctx, pending_event);
+
+    // No real radio to negotiate with, so the mock always succeeds instantly.
+    mutex_lock(&ctx->mutex);
+    ctx->stationState = WIFI_STATION_STATE_CONNECTED;
+    mutex_unlock(&ctx->mutex);
+
+    WifiEvent connected_event = {};
+    connected_event.type = WIFI_EVENT_TYPE_STATION_STATE_CHANGED;
+    connected_event.station_state = WIFI_STATION_STATE_CONNECTED;
+    fireEvent(ctx, connected_event);
+
+    WifiEvent result_event = {};
+    result_event.type = WIFI_EVENT_TYPE_STATION_CONNECTION_RESULT;
+    result_event.connection_error = WIFI_STATION_CONNECTION_ERROR_NONE;
+    fireEvent(ctx, result_event);
+
+    return ERROR_NONE;
+}
+
+error_t apiStationDisconnect(Device* device) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr) return ERROR_INVALID_STATE;
+
+    mutex_lock(&ctx->mutex);
+    bool was_connected = ctx->stationState != WIFI_STATION_STATE_DISCONNECTED;
+    ctx->stationState = WIFI_STATION_STATE_DISCONNECTED;
+    mutex_unlock(&ctx->mutex);
+
+    if (was_connected) {
+        WifiEvent event = {};
+        event.type = WIFI_EVENT_TYPE_STATION_STATE_CHANGED;
+        event.station_state = WIFI_STATION_STATE_DISCONNECTED;
+        fireEvent(ctx, event);
+    }
+
+    return ERROR_NONE;
+}
+
+error_t apiStationGetRssi(Device* device, int32_t* rssi) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || rssi == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    mutex_lock(&ctx->mutex);
+    bool connected = ctx->stationState == WIFI_STATION_STATE_CONNECTED;
+    mutex_unlock(&ctx->mutex);
+
+    if (!connected) return ERROR_INVALID_STATE;
+    *rssi = MOCK_CONNECTED_RSSI;
+    return ERROR_NONE;
+}
+
+error_t apiAddEventCallback(Device* device, void* callback_context, WifiEventCallback callback) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || callback == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    mutex_lock(&ctx->callbackMutex);
+    if (ctx->callbackCount >= WIFI_MAX_CALLBACKS) {
+        mutex_unlock(&ctx->callbackMutex);
+        return ERROR_OUT_OF_MEMORY;
+    }
+    ctx->callbacks[ctx->callbackCount] = { .fn = callback, .ctx = callback_context };
+    ctx->callbackCount++;
+    mutex_unlock(&ctx->callbackMutex);
+    return ERROR_NONE;
+}
+
+error_t apiRemoveEventCallback(Device* device, WifiEventCallback callback) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr || callback == nullptr) return ERROR_INVALID_ARGUMENT;
+
+    mutex_lock(&ctx->callbackMutex);
+    for (size_t i = 0; i < ctx->callbackCount; i++) {
+        if (ctx->callbacks[i].fn == callback) {
+            for (size_t j = i; j + 1 < ctx->callbackCount; j++) {
+                ctx->callbacks[j] = ctx->callbacks[j + 1];
+            }
+            ctx->callbackCount--;
+            mutex_unlock(&ctx->callbackMutex);
+            return ERROR_NONE;
+        }
+    }
+    mutex_unlock(&ctx->callbackMutex);
+    return ERROR_NOT_FOUND;
+}
+
+const WifiApi posix_wifi_api = {
+    .get_radio_state = apiGetRadioState,
+    .get_station_state = apiGetStationState,
+    .get_access_point_state = apiGetAccessPointState,
+    .is_scanning = apiIsScanning,
+    .scan = apiScan,
+    .get_scan_results = apiGetScanResults,
+    .station_get_ipv4_address = apiStationGetIpv4Address,
+    .station_get_target_ssid = apiStationGetTargetSsid,
+    .station_connect = apiStationConnect,
+    .station_disconnect = apiStationDisconnect,
+    .station_get_rssi = apiStationGetRssi,
+    .add_event_callback = apiAddEventCallback,
+    .remove_event_callback = apiRemoveEventCallback
+};
+
+// ---- Driver lifecycle ----
+// Unlike the real esp32 driver, there's no hardware to bring up: the radio
+// simply reports itself as ON as soon as the device is started.
+
+error_t startDevice(Device* device) {
+    auto* ctx = new(std::nothrow) PosixWifiCtx();
+    if (ctx == nullptr) return ERROR_OUT_OF_MEMORY;
+
+    ctx->device = device;
+    mutex_construct(&ctx->mutex);
+    mutex_construct(&ctx->callbackMutex);
+    ctx->radioState = WIFI_RADIO_STATE_ON;
+
+    device_set_driver_data(device, ctx);
+
+    LOG_I(TAG, "WiFi radio on (mock)");
+    return ERROR_NONE;
+}
+
+error_t stopDevice(Device* device) {
+    auto* ctx = GET_CTX(device);
+    if (ctx == nullptr) return ERROR_NONE;
+
+    device_set_driver_data(device, nullptr);
+    mutex_destruct(&ctx->callbackMutex);
+    mutex_destruct(&ctx->mutex);
+    delete ctx;
+
+    LOG_I(TAG, "WiFi radio off (mock)");
+    return ERROR_NONE;
+}
+
+} // namespace
+
+extern "C" {
+
+extern Module platform_posix_module;
+
+Driver posix_wifi_driver = {
+    .name = "mock_wifi",
+    .compatible = (const char*[]) { "posix,mock-wifi", nullptr },
+    .start_device = startDevice,
+    .stop_device = stopDevice,
+    .api = (const void*)&posix_wifi_api,
+    .device_type = &WIFI_TYPE,
+    .owner = &platform_posix_module,
+    .internal = nullptr
+};
+
+} // extern "C"
@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
+#include <tactility/check.h>
+#include <tactility/driver.h>
 #include <tactility/module.h>

 extern "C" {

+extern Driver posix_wifi_driver;
+
 static error_t start() {
-    /* NO-OP for now */
+    check(driver_construct_add(&posix_wifi_driver) == ERROR_NONE);
    return ERROR_NONE;
 }

 static error_t stop() {
-    /* NO-OP for now */
+    check(driver_remove_destruct(&posix_wifi_driver) == ERROR_NONE);
    return ERROR_NONE;
 }