ra8_wifi_c6link.c

Go to the documentation of this file.

 
#include "ra8_wifi_c6link.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_wifi.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_secure.h"
#include "ra8_wifi.h"
#include "ra8_wifi_backend.h"

#define RA8_WIFI_C6_TAG "WIFI-C6"
 
static_assert((uint32_t)k_ra8_wifi_mac_bytes == (uint32_t)k_ra8_c6link_mac_bytes,
              "the facade and link MAC widths must agree for a straight copy");
static_assert((uint32_t)k_ra8_wifi_ssid_max == (uint32_t)k_ra8_c6link_ssid_max,
              "the facade and link SSID capacities must agree for a straight copy");

RA8_INTERNAL static void internal_c6link_on_event(void* ctx, const ra8_c6link_event_t* ev)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  if (ev->kind == k_ra8_c6link_event_sta_connected) {
    self->connected = true;
  } else if (ev->kind == k_ra8_c6link_event_sta_disconnected) {
    self->disconnected = true;
    self->reason       = ev->reason;
  } else {
    /* boot / bare Wi-Fi events: nothing to latch here. */
  }
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_open(void* ctx)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(self->link, RA8_WIFI_C6_TAG, "ctx.link");
 
  ra8_c6link_cfg_t cfg = {};
  cfg.transport        = self->transport;
  cfg.arena            = self->arena;
  cfg.arena_bytes      = self->arena_bytes;
  cfg.event_cb         = internal_c6link_on_event;
  cfg.rx_cb            = self->rx_cb;
  cfg.cb_ctx           = self;
 
  const ra8_err_t opened = ra8_c6link_open(self->link, &cfg);
  if (opened != k_ra8_ok) {
    return opened;
  }
 
  ra8_c6link_fw_version_t fw = {};
  return ra8_c6link_await_ready(self->link, (uint16_t)k_ra8_c6link_announce_transfers, &fw);
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_close(void* ctx)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(self->link, RA8_WIFI_C6_TAG, "ctx.link");
  return ra8_c6link_close(self->link);
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_radio_up(void* ctx)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(self->link, RA8_WIFI_C6_TAG, "ctx.link");
  return ra8_c6link_wifi_start(self->link);
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_radio_down(void* ctx)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(self->link, RA8_WIFI_C6_TAG, "ctx.link");
  return ra8_c6link_wifi_stop(self->link);
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_join(void* ctx, const char* ssid, const char* psk)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(ssid, RA8_WIFI_C6_TAG, "ssid");
 
  self->connected    = false;
  self->disconnected = false;
  self->reason       = 0U;
 
  ra8_c6link_sta_cfg_t sta = {};
  const ra8_err_t      set = ra8_c6link_sta_cfg_set(&sta, ssid, psk);
  if (set != k_ra8_ok) {
    ra8_secure_memzero(&sta, sizeof(sta));
    return set;
  }
  const ra8_err_t joined = ra8_c6link_wifi_join(self->link, &sta);
  ra8_secure_memzero(&sta, sizeof(sta));
  return joined;
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_leave(void* ctx)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(self->link, RA8_WIFI_C6_TAG, "ctx.link");
  return ra8_c6link_wifi_leave(self->link);
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_service(void* ctx, ra8_wifi_link_t* out_link)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(out_link, RA8_WIFI_C6_TAG, "out_link");
 
  ra8_c6link_stats_t stats = {};
  const ra8_err_t    err =
    ra8_c6link_poll(self->link, (uint16_t)k_ra8_c6link_announce_transfers, &stats);
  if (err != k_ra8_ok) {
    return err;
  }
 
  /* Down unless a connect was seen, and a later disconnect wins outright. Two
   * single-condition tests applied in that order, so the precedence lives in
   * the sequence rather than in a compound decision that would then owe MC/DC
   * vectors. */
  *out_link = k_ra8_wifi_link_down;
  if (self->connected) {
    *out_link = k_ra8_wifi_link_up;
  }
  if (self->disconnected) {
    *out_link = k_ra8_wifi_link_down;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_get_mac(void* ctx, ra8_wifi_mac_t* out)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_C6_TAG, "out");
 
  ra8_c6link_mac_t mac = {};
  const ra8_err_t  err = ra8_c6link_wifi_mac(self->link, &mac);
  if (err != k_ra8_ok) {
    return err;
  }
  (void)memcpy(out->octet, mac.octet, (size_t)k_ra8_wifi_mac_bytes);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_c6link_op_get_ap(void* ctx, ra8_wifi_ap_t* out)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "ctx");
  RA8_CHECK_NULL_PTR(out, RA8_WIFI_C6_TAG, "out");
 
  ra8_c6link_ap_info_t ap  = {};
  const ra8_err_t      err = ra8_c6link_wifi_ap_info(self->link, &ap);
  if (err != k_ra8_ok) {
    return err;
  }
  *out = (ra8_wifi_ap_t){};
  (void)memcpy(out->bssid.octet, ap.bssid.octet, (size_t)k_ra8_wifi_mac_bytes);
  (void)memcpy(out->ssid, ap.ssid, sizeof(out->ssid));
  out->ssid_len = ap.ssid_len;
  out->channel  = ap.channel;
  out->rssi     = ap.rssi;
  out->authmode = ap.authmode;
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_c6link_op_idle(void* ctx, uint16_t ms)
{
  ra8_wifi_c6link_t* self = (ra8_wifi_c6link_t*)ctx;
  if (self == nullptr) {
    return;
  }
  if (self->transport.delay_ms == nullptr) {
    return;
  }
  self->transport.delay_ms(self->transport.ctx, ms);
}

const ra8_wifi_backend_t k_ra8_wifi_backend_c6link = {
  .open       = internal_c6link_op_open,
  .close      = internal_c6link_op_close,
  .radio_up   = internal_c6link_op_radio_up,
  .radio_down = internal_c6link_op_radio_down,
  .join       = internal_c6link_op_join,
  .leave      = internal_c6link_op_leave,
  .service    = internal_c6link_op_service,
  .get_mac    = internal_c6link_op_get_mac,
  .get_ap     = internal_c6link_op_get_ap,
  .idle       = internal_c6link_op_idle,
};
 
ra8_err_t ra8_wifi_c6link_setup(ra8_wifi_c6link_t*           self,
                                const ra8_wifi_c6link_cfg_t* cfg,
                                ra8_wifi_cfg_t*              out_wcfg)
{
  RA8_CHECK_NULL_PTR(self, RA8_WIFI_C6_TAG, "self");
  RA8_CHECK_NULL_PTR(cfg, RA8_WIFI_C6_TAG, "cfg");
  RA8_CHECK_NULL_PTR(out_wcfg, RA8_WIFI_C6_TAG, "out_wcfg");
  RA8_CHECK_NULL_PTR(cfg->link, RA8_WIFI_C6_TAG, "cfg.link");
  if (cfg->arena_bytes < (uint32_t)k_ra8_c6link_arena_min) {
    return k_ra8_err_invalid_size;
  }
 
  *self             = (ra8_wifi_c6link_t){};
  self->link        = cfg->link;
  self->transport   = cfg->transport;
  self->arena       = cfg->arena;
  self->arena_bytes = cfg->arena_bytes;
  self->rx_cb       = cfg->rx_cb;
 
  out_wcfg->backend     = &k_ra8_wifi_backend_c6link;
  out_wcfg->backend_ctx = self;
  return k_ra8_ok;
}