main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_join.h"
#include "nx_ether_driver_c6.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_c6link.h"
#include "ra8_c6link_wifi.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_c6link.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_net_provision.h"
#include "ra8_secure.h"
#include "ra8_time.h"
#include "tx_api.h"

static uint32_t s_cpuclk_hz;
static uint32_t s_pclka_hz;
static ra8_err_t s_init_err = k_ra8_err_not_initialized;
static TX_THREAD s_worker;
static CHAR s_worker_name[] = "c6_wifi_join";
static UCHAR s_worker_stack[k_c6_join_worker_stack];
static uint8_t s_arena[k_c6_join_arena_bytes];
static ra8_c6link_t s_link;
static volatile uint32_t s_events;
static volatile uint8_t s_connected;
static volatile uint8_t s_disconnected;
static volatile uint16_t s_reason;
static const ra8_net_provision_uart_t s_provision_uart = {
  .write   = ra8_board_uart_console_write,
  .read    = ra8_board_uart_console_read,
  .wait_ms = ra8_delay_ms,
};

static void c6_join_panic_halt(void)
{
  while (true) {
    __asm volatile("wfi");
  }
}

static void c6_join_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    c6_join_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &s_cpuclk_hz) != k_ra8_ok) {
    c6_join_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_pclka_hz) != k_ra8_ok) {
    c6_join_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    c6_join_panic_halt();
  }
  if (ra8_time_init(s_cpuclk_hz) != k_ra8_ok) {
    c6_join_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_c6_join_uart_baud) != k_ra8_ok) {
    c6_join_panic_halt();
  }
}

static void c6_join_on_event(void* ctx, const ra8_c6link_event_t* ev)
{
  (void)ctx;
  if (ev == nullptr) {
    return;
  }
  s_events++;
  if (ev->kind == k_ra8_c6link_event_sta_connected) {
    s_connected = 1U;
  } else if (ev->kind == k_ra8_c6link_event_sta_disconnected) {
    s_disconnected = 1U;
    s_reason       = ev->reason;
  } else {
    /* boot / bare wifi events: counted above, nothing else to latch. */
  }
}

static void c6_join_report_fault(const char* what, ra8_err_t err)
{
  ra8_c6link_fault_t fault = {};
  (void)ra8_c6link_last_fault(&s_link, &fault);
  c6_join_puts("c6_join: FAIL ");
  c6_join_puts(what);
  c6_join_puts(" err=");
  c6_join_puts(ra8_err_to_str(err));
  c6_join_puts("\r\n");
}

static ra8_err_t c6_join_open_link(void)
{
  ra8_c6link_cfg_t cfg  = {};
  const ra8_err_t  seam = ra8_esp_hosted_c6link_bind(&cfg.transport);
  if (seam != k_ra8_ok) {
    return seam;
  }
  cfg.arena       = s_arena;
  cfg.arena_bytes = (uint32_t)sizeof(s_arena);
  cfg.event_cb    = c6_join_on_event;
  cfg.rx_cb       = nx_ether_driver_c6_rx;
  cfg.cb_ctx      = nullptr;
  return ra8_c6link_open(&s_link, &cfg);
}

static bool c6_join_phase_ready(ra8_c6link_fw_version_t* out)
{
  const ra8_err_t opened = c6_join_open_link();
  c6_join_puts("c6_join: link_open=");
  c6_join_puts(ra8_err_to_str(opened));
  c6_join_puts("\r\n");
  if (opened != k_ra8_ok) {
    return false;
  }
  const ra8_err_t ready =
    ra8_c6link_await_ready(&s_link, (uint16_t)k_ra8_c6link_announce_transfers, out);
  if (ready != k_ra8_ok) {
    c6_join_report_fault("await_ready", ready);
    return false;
  }
  c6_join_puts("c6_join: coprocessor fw=");
  c6_join_put_u32(out->major);
  c6_join_puts(".");
  c6_join_put_u32(out->minor);
  c6_join_puts(".");
  c6_join_put_u32(out->patch);
  c6_join_puts(" chip_id=");
  c6_join_put_hex(out->chip_id, (uint8_t)k_c6_join_hex_byte);
  c6_join_puts("\r\n");
  return true;
}

static bool c6_join_wait_connected(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_c6_join_assoc_tries; i++) {
    ra8_c6link_stats_t stats = {};
    (void)ra8_c6link_poll(&s_link, (uint16_t)k_ra8_c6link_announce_transfers, &stats);
    if (s_connected != 0U) {
      return true;
    }
    if (s_disconnected != 0U) {
      return false;
    }
    tx_thread_sleep((ULONG)k_c6_join_assoc_gap_ms);
  }
  return false;
}

static bool c6_join_phase_associate(ra8_c6link_mac_t*            mac_out,
                                    const ra8_net_credentials_t* credentials)
{
  const ra8_err_t started = ra8_c6link_wifi_start(&s_link);
  if (started != k_ra8_ok) {
    c6_join_report_fault("wifi_start", started);
    return false;
  }
  const ra8_err_t got_mac = ra8_c6link_wifi_mac(&s_link, mac_out);
  if (got_mac != k_ra8_ok) {
    c6_join_report_fault("wifi_mac", got_mac);
    return false;
  }
  c6_join_puts("c6_join: station mac=");
  c6_join_put_mac(mac_out);
  c6_join_puts("\r\n");
 
  ra8_c6link_sta_cfg_t sta = {};
  const ra8_err_t      set = ra8_c6link_sta_cfg_set(&sta, credentials->ssid, credentials->psk);
  if (set != k_ra8_ok) {
    ra8_secure_memzero(&sta, sizeof(sta));
    c6_join_report_fault("sta_cfg_set", set);
    return false;
  }
  const ra8_err_t joined = ra8_c6link_wifi_join(&s_link, &sta);
  ra8_secure_memzero(&sta, sizeof(sta));
  if (joined != k_ra8_ok) {
    c6_join_report_fault("wifi_join", joined);
    return false;
  }
  if (!c6_join_wait_connected()) {
    c6_join_puts("c6_join: FAIL association did not complete (reason=");
    c6_join_put_u32((uint32_t)s_reason);
    c6_join_puts(")\r\n");
    return false;
  }
  c6_join_puts("c6_join: associated\r\n");
  return true;
}

static bool c6_join_phase_ip(const ra8_c6link_mac_t* mac)
{
  c6_join_lease_t lease = {};
  const ra8_err_t up    = c6_join_net_up(&s_link, mac, &lease);
  if (up != k_ra8_ok) {
    c6_join_puts("c6_join: FAIL dhcp did not bind err=");
    c6_join_puts(ra8_err_to_str(up));
    c6_join_puts("\r\n");
    return false;
  }
  c6_join_puts("c6_join: dhcp bound ip=");
  c6_join_put_ip(lease.ip);
  c6_join_puts(" mask=");
  c6_join_put_ip(lease.mask);
  c6_join_puts(" gw=");
  c6_join_put_ip(lease.gateway);
  c6_join_puts(" server=");
  c6_join_put_ip(lease.dhcp_server);
  c6_join_puts("\r\n");
  c6_join_puts("c6_join: reachability gateway ping=");
  c6_join_puts(lease.ping_ok ? "ok" : "no-reply");
  c6_join_puts("\r\n");
  return (lease.ip != 0U);
}

static void c6_join_heartbeat(bool passed)
{
  while (true) {
    c6_join_puts(passed ? "c6_join: alive PASS\r\n" : "c6_join: alive FAIL\r\n");
    tx_thread_sleep((ULONG)k_c6_join_heartbeat_ms);
  }
}

static void c6_join_worker_entry(ULONG thread_input)
{
  (void)thread_input;
 
  c6_join_puts("c6_join: port_init=");
  c6_join_puts(ra8_err_to_str(s_init_err));
  c6_join_puts("\r\n");
  if (s_init_err != k_ra8_ok) {
    c6_join_puts("c6_join: FAIL port init failed -- no transaction attempted\r\n");
    c6_join_heartbeat(false);
    return;
  }
 
  ra8_delay_ms((uint32_t)k_c6_join_boot_wait_ms);
 
  ra8_net_credentials_t credentials = {};
  const ra8_err_t provisioned = ra8_net_provision_receive(&s_provision_uart,
                                                          (uint32_t)k_ra8_net_provision_timeout_ms,
                                                          &credentials);
  if (provisioned != k_ra8_ok) {
    c6_join_puts("c6_join: FAIL runtime provisioning err=");
    c6_join_puts(ra8_err_to_str(provisioned));
    c6_join_puts("\r\n");
    ra8_net_provision_clear(&credentials);
    c6_join_heartbeat(false);
    return;
  }
 
  ra8_c6link_fw_version_t fw  = {};
  ra8_c6link_mac_t        mac = {};
  bool                    ok  = c6_join_phase_ready(&fw);
  ok                          = ok && c6_join_phase_associate(&mac, &credentials);
  ra8_net_provision_clear(&credentials);
  ok = ok && c6_join_phase_ip(&mac);
 
  c6_join_puts("c6_join: events_seen=");
  c6_join_put_u32((uint32_t)s_events);
  c6_join_puts("\r\n");
  if (ok) {
    c6_join_puts("c6_join: PASS ra8_c6link joined the bench Wi-Fi and DHCP leased an "
                 "address\r\n");
  } else {
    c6_join_puts("c6_join: FAIL Wi-Fi join to a DHCP lease did not complete\r\n");
  }
  c6_join_heartbeat(ok);
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  const ra8_esp_hosted_port_cfg_t cfg = {
    .pclk_hz      = s_pclka_hz,
    .sck_hz       = (uint32_t)k_c6_join_sck_hz,
    .edge_poll_ms = (uint16_t)k_c6_join_edge_poll_ms,
    .sci_channel  = (uint8_t)k_ra8_board_pmod1_sci_channel,
  };
  s_init_err = ra8_esp_hosted_port_init(&cfg);
 
  if (tx_thread_create(&s_worker,
                       s_worker_name,
                       c6_join_worker_entry,
                       0U,
                       s_worker_stack,
                       (ULONG)sizeof(s_worker_stack),
                       (UINT)k_c6_join_worker_prio,
                       (UINT)k_c6_join_worker_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    c6_join_puts("c6_join: worker thread creation failed\r\n");
  }
}

void main(void)
{
  c6_join_setup_or_halt();
  ra8_isr_globals_enable();
 
  c6_join_print_banner(s_cpuclk_hz, s_pclka_hz);
  c6_join_puts("c6_join: entering ThreadX; port init runs from tx_application_define\r\n");
 
  tx_kernel_enter();
 
  c6_join_panic_halt();
}