ra8_wifi.c

Go to the documentation of this file.

 
#include "ra8_wifi.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_wifi_backend.h"

#define RA8_WIFI_TAG "WIFI"

RA8_INTERNAL static ra8_err_t internal_check_backend_lifecycle(const ra8_wifi_backend_t* b)
{
  RA8_CHECK_NULL_PTR(b, RA8_WIFI_TAG, "backend");
  RA8_CHECK_NULL_PTR(b->open, RA8_WIFI_TAG, "backend.open");
  RA8_CHECK_NULL_PTR(b->close, RA8_WIFI_TAG, "backend.close");
  RA8_CHECK_NULL_PTR(b->radio_up, RA8_WIFI_TAG, "backend.radio_up");
  RA8_CHECK_NULL_PTR(b->radio_down, RA8_WIFI_TAG, "backend.radio_down");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_check_backend_session(const ra8_wifi_backend_t* b)
{
  RA8_CHECK_NULL_PTR(b, RA8_WIFI_TAG, "backend");
  RA8_CHECK_NULL_PTR(b->join, RA8_WIFI_TAG, "backend.join");
  RA8_CHECK_NULL_PTR(b->leave, RA8_WIFI_TAG, "backend.leave");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_check_backend_query(const ra8_wifi_backend_t* b)
{
  RA8_CHECK_NULL_PTR(b, RA8_WIFI_TAG, "backend");
  RA8_CHECK_NULL_PTR(b->service, RA8_WIFI_TAG, "backend.service");
  RA8_CHECK_NULL_PTR(b->get_mac, RA8_WIFI_TAG, "backend.get_mac");
  RA8_CHECK_NULL_PTR(b->get_ap, RA8_WIFI_TAG, "backend.get_ap");
  RA8_CHECK_NULL_PTR(b->idle, RA8_WIFI_TAG, "backend.idle");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_check_backend(const ra8_wifi_backend_t* b)
{
  const ra8_err_t lifecycle = internal_check_backend_lifecycle(b);
  if (lifecycle != k_ra8_ok) {
    return lifecycle;
  }
  const ra8_err_t session = internal_check_backend_session(b);
  if (session != k_ra8_ok) {
    return session;
  }
  return internal_check_backend_query(b);
}
 
ra8_err_t ra8_wifi_init(ra8_wifi_t* wifi, const ra8_wifi_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(cfg, RA8_WIFI_TAG, "cfg");
  RA8_CHECK_NULL_PTR(cfg->ip_bind, RA8_WIFI_TAG, "cfg.ip_bind");
 
  const ra8_err_t table = internal_check_backend(cfg->backend);
  if (table != k_ra8_ok) {
    return table;
  }
  if (wifi->open) {
    return k_ra8_err_invalid_state;
  }
 
  const ra8_err_t opened = cfg->backend->open(cfg->backend_ctx);
  if (opened != k_ra8_ok) {
    return opened;
  }
 
  *wifi             = (ra8_wifi_t){};
  wifi->backend     = cfg->backend;
  wifi->backend_ctx = cfg->backend_ctx;
  wifi->ip_bind     = cfg->ip_bind;
  wifi->ip_ctx      = cfg->ip_ctx;
  wifi->state       = k_ra8_wifi_state_down;
  wifi->open        = true;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_deinit(ra8_wifi_t* wifi)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t closed = wifi->backend->close(wifi->backend_ctx);
  wifi->open             = false;
  wifi->radio_on         = false;
  wifi->state            = k_ra8_wifi_state_down;
  return closed;
}

RA8_INTERNAL static ra8_err_t internal_ensure_radio_up(ra8_wifi_t* wifi)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  if (wifi->radio_on) {
    return k_ra8_ok;
  }
  const ra8_err_t up = wifi->backend->radio_up(wifi->backend_ctx);
  if (up != k_ra8_ok) {
    return up;
  }
  wifi->radio_on = true;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_BOUNDED_LOOP(k_ra8_wifi_join_polls)
static ra8_err_t internal_await_association(ra8_wifi_t* wifi)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  ra8_err_t last_fault = k_ra8_ok;
  bool      answered   = false;
 
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_wifi_join_polls; i++) {
    ra8_wifi_link_t link     = k_ra8_wifi_link_down;
    const ra8_err_t serviced = wifi->backend->service(wifi->backend_ctx, &link);
    if (serviced != k_ra8_ok) {
      last_fault = serviced;
    } else {
      answered = true;
      if (link == k_ra8_wifi_link_up) {
        wifi->state = k_ra8_wifi_state_associated;
        return k_ra8_ok;
      }
    }
    wifi->backend->idle(wifi->backend_ctx, (uint16_t)k_ra8_wifi_poll_gap_ms);
  }
 
  /* Nothing answered across the whole budget: the radio is absent, not slow, so
   * name the fault it kept reporting rather than calling it a plain timeout. */
  if (!answered) {
    return last_fault;
  }
  return k_ra8_err_timeout;
}
 
ra8_err_t ra8_wifi_connect(ra8_wifi_t* wifi, const char* ssid, const char* psk)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(ssid, RA8_WIFI_TAG, "ssid");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t powered = internal_ensure_radio_up(wifi);
  if (powered != k_ra8_ok) {
    return powered;
  }
 
  const ra8_err_t got_mac = wifi->backend->get_mac(wifi->backend_ctx, &wifi->mac);
  if (got_mac != k_ra8_ok) {
    return got_mac;
  }
  wifi->mac_valid = true;
 
  wifi->state           = k_ra8_wifi_state_associating;
  const ra8_err_t asked = wifi->backend->join(wifi->backend_ctx, ssid, psk);
  if (asked != k_ra8_ok) {
    return asked;
  }
  return internal_await_association(wifi);
}
 
ra8_err_t ra8_wifi_disconnect(ra8_wifi_t* wifi)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t left    = wifi->backend->leave(wifi->backend_ctx);
  const ra8_err_t stopped = wifi->backend->radio_down(wifi->backend_ctx);
  wifi->radio_on          = false;
  wifi->state             = k_ra8_wifi_state_down;
  wifi->lease             = (ra8_wifi_lease_t){};
  return (left != k_ra8_ok) ? left : stopped;
}
 
ra8_err_t ra8_wifi_wait_ip(ra8_wifi_t* wifi, ra8_wifi_lease_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  *out = (ra8_wifi_lease_t){};
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
  if (wifi->state < k_ra8_wifi_state_associated) {
    return k_ra8_err_invalid_state;
  }
 
  ra8_wifi_lease_t lease = {};
  const ra8_err_t  bound = wifi->ip_bind(wifi->ip_ctx, &wifi->mac, &lease);
  if (bound != k_ra8_ok) {
    wifi->lease = (ra8_wifi_lease_t){};
    return bound;
  }
  lease.bound = (lease.ip != 0U);
  if (!lease.bound) {
    wifi->lease = (ra8_wifi_lease_t){};
    return k_ra8_err_timeout;
  }
 
  wifi->lease = lease;
  wifi->state = k_ra8_wifi_state_ip_bound;
  *out        = lease;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_get_ip(const ra8_wifi_t* wifi, ra8_wifi_lease_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
  *out = wifi->lease;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_status(const ra8_wifi_t* wifi, ra8_wifi_status_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
 
  *out            = (ra8_wifi_status_t){};
  out->state      = wifi->state;
  out->associated = (wifi->state >= k_ra8_wifi_state_associated);
  out->ip_bound   = (wifi->state == k_ra8_wifi_state_ip_bound);
  out->rssi       = wifi->rssi;
  out->ip         = wifi->lease;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_poll(ra8_wifi_t* wifi, ra8_wifi_link_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  *out = k_ra8_wifi_link_down;
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
  if (wifi->state == k_ra8_wifi_state_ip_bound) {
    return k_ra8_err_invalid_state;
  }
 
  ra8_wifi_link_t link     = k_ra8_wifi_link_down;
  const ra8_err_t serviced = wifi->backend->service(wifi->backend_ctx, &link);
  if (serviced != k_ra8_ok) {
    return serviced;
  }
 
  wifi->state = (link == k_ra8_wifi_link_up) ? k_ra8_wifi_state_associated : k_ra8_wifi_state_down;
  *out        = link;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_get_mac(ra8_wifi_t* wifi, ra8_wifi_mac_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t got = wifi->backend->get_mac(wifi->backend_ctx, out);
  if (got != k_ra8_ok) {
    /* A station's own address does not change while it is associated, so a
     * cached one is the right answer when the radio cannot be re-asked. It
     * routinely cannot: once the AP starts forwarding broadcast traffic this
     * query competes with it for the link, and handing the caller
     * 00:00:00:00:00:00 instead is how the bench first printed a null MAC into
     * a run that had in fact associated. */
    if (wifi->mac_valid) {
      *out = wifi->mac;
      return k_ra8_ok;
    }
    *out = (ra8_wifi_mac_t){};
    return got;
  }
  wifi->mac       = *out;
  wifi->mac_valid = true;
  return k_ra8_ok;
}
 
ra8_err_t ra8_wifi_get_ap(ra8_wifi_t* wifi, ra8_wifi_ap_t* out)
{
  RA8_CHECK_NULL_PTR(wifi, RA8_WIFI_TAG, "wifi");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_TAG, "out");
  if (!wifi->open) {
    return k_ra8_err_not_initialized;
  }
  if (wifi->state < k_ra8_wifi_state_associated) {
    return k_ra8_err_invalid_state;
  }
 
  const ra8_err_t got = wifi->backend->get_ap(wifi->backend_ctx, out);
  if (got != k_ra8_ok) {
    *out = (ra8_wifi_ap_t){};
    return got;
  }
  wifi->rssi = out->rssi;
  return k_ra8_ok;
}