main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_wifi.h"
#include "esp_hosted_host_fw_ver.h"
#include "esp_hosted_transport.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_time.h"
#include "transport_drv.h"
#include "tx_api.h"

typedef enum : uint32_t {
  k_c6_wifi_expect_chip = (uint32_t)ESP_PRIV_FIRMWARE_CHIP_ESP32C6,
  k_c6_wifi_drain_polls = 8U,
} c6_wifi_expect_t;

static uint32_t s_c6_wifi_cpuclk_hz;

static uint32_t s_c6_wifi_pclka_hz;

static ra8_err_t s_c6_wifi_init_err = k_ra8_err_not_initialized;

static TX_THREAD s_c6_wifi_worker;

static CHAR s_c6_wifi_worker_name[] = "c6_wifi_link";

static UCHAR s_c6_wifi_worker_stack[k_c6_wifi_worker_stack];

static uint8_t s_c6_wifi_arena[k_c6_wifi_arena_bytes];

static ra8_c6link_t s_c6_wifi_link;

static uint32_t s_c6_wifi_events;

static void c6_wifi_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void c6_wifi_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &s_c6_wifi_cpuclk_hz) != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_c6_wifi_pclka_hz) != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
  if (ra8_time_init(s_c6_wifi_cpuclk_hz) != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_c6_wifi_uart_baud) != k_ra8_ok) {
    c6_wifi_panic_halt();
  }
}

static void c6_wifi_on_event(void* ctx, const ra8_c6link_event_t* ev)
{
  (void)ctx;
  s_c6_wifi_events++;
  c6_wifi_puts("c6_wifi: event kind=");
  c6_wifi_put_u32((uint32_t)ev->kind);
  c6_wifi_puts(" wifi_event_id=");
  c6_wifi_put_i32(ev->wifi_event_id);
  c6_wifi_puts(" reason=");
  c6_wifi_put_u32((uint32_t)ev->reason);
  c6_wifi_puts(" ssid=");
  c6_wifi_put_text(ev->ssid, (size_t)ev->ssid_len);
  c6_wifi_puts("\r\n");
}

static void c6_wifi_report_fault(const char* what, ra8_err_t err)
{
  ra8_c6link_fault_t fault = {};
  (void)ra8_c6link_last_fault(&s_c6_wifi_link, &fault);
  c6_wifi_puts("c6_wifi: ");
  c6_wifi_puts(what);
  c6_wifi_puts(" failed err=");
  c6_wifi_puts(ra8_err_to_str(err));
  c6_wifi_puts(" rpc_id=");
  c6_wifi_put_u32(fault.rpc_id);
  c6_wifi_puts(" coprocessor_resp=");
  c6_wifi_put_i32(fault.resp);
  c6_wifi_puts("\r\n");
}

static bool c6_wifi_phase_identity(const ra8_c6link_fw_version_t* fw_in)
{
  if (fw_in == nullptr) {
    c6_wifi_puts("c6_wifi: identity record missing\r\n");
    return false;
  }
  const ra8_c6link_fw_version_t fw = *fw_in;
 
  c6_wifi_puts("c6_wifi: coprocessor fw=");
  c6_wifi_put_u32(fw.major);
  c6_wifi_puts(".");
  c6_wifi_put_u32(fw.minor);
  c6_wifi_puts(".");
  c6_wifi_put_u32(fw.patch);
  c6_wifi_puts(" chip_id=0x");
  c6_wifi_put_hex(fw.chip_id, (uint8_t)k_c6_wifi_hex_byte);
  c6_wifi_puts(" idf_target=");
  c6_wifi_put_text(fw.target, (size_t)fw.target_len);
  c6_wifi_puts(" expected=");
  c6_wifi_put_u32((uint32_t)ESP_HOSTED_VERSION_MAJOR_1);
  c6_wifi_puts(".");
  c6_wifi_put_u32((uint32_t)ESP_HOSTED_VERSION_MINOR_1);
  c6_wifi_puts(".");
  c6_wifi_put_u32((uint32_t)ESP_HOSTED_VERSION_PATCH_1);
  c6_wifi_puts("\r\n");
 
  const bool matched = (fw.major == (uint32_t)ESP_HOSTED_VERSION_MAJOR_1) &&
                       (fw.minor == (uint32_t)ESP_HOSTED_VERSION_MINOR_1) &&
                       (fw.patch == (uint32_t)ESP_HOSTED_VERSION_PATCH_1) &&
                       (fw.chip_id == (uint32_t)k_c6_wifi_expect_chip);
  if (!matched) {
    c6_wifi_puts("c6_wifi: coprocessor identity is not the one this host was built against\r\n");
  }
  return matched;
}

static bool c6_wifi_phase_station(void)
{
  const ra8_err_t started = ra8_c6link_wifi_start(&s_c6_wifi_link);
  if (started != k_ra8_ok) {
    c6_wifi_report_fault("wifi_start", started);
    return false;
  }
  c6_wifi_puts("c6_wifi: station started (WifiInit + SetWifiMode + WifiStart accepted)\r\n");
 
  ra8_c6link_stats_t drain = {};
  (void)ra8_c6link_poll(&s_c6_wifi_link, (uint16_t)k_c6_wifi_drain_polls, &drain);
  c6_wifi_print_stats("drain", &drain);
 
  ra8_c6link_mac_t mac    = {};
  const ra8_err_t  readen = ra8_c6link_wifi_mac(&s_c6_wifi_link, &mac);
  if (readen != k_ra8_ok) {
    c6_wifi_report_fault("wifi_mac", readen);
    (void)ra8_c6link_wifi_stop(&s_c6_wifi_link);
    return false;
  }
  c6_wifi_puts("c6_wifi: station mac=");
  c6_wifi_put_mac(&mac);
  c6_wifi_puts("\r\n");
 
  const ra8_err_t stopped = ra8_c6link_wifi_stop(&s_c6_wifi_link);
  if (stopped != k_ra8_ok) {
    c6_wifi_report_fault("wifi_stop", stopped);
    return false;
  }
  c6_wifi_puts("c6_wifi: station stopped (WifiStop + WifiDeinit accepted)\r\n");
  return true;
}

static ra8_err_t c6_wifi_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_c6_wifi_arena;
  cfg.arena_bytes = (uint32_t)sizeof(s_c6_wifi_arena);
  cfg.event_cb    = c6_wifi_on_event;
  cfg.cb_ctx      = nullptr;
  return ra8_c6link_open(&s_c6_wifi_link, &cfg);
}

static void c6_wifi_heartbeat(bool passed)
{
  uint32_t beat = 0U;
  while (1) {
    c6_wifi_puts("c6_wifi: heartbeat n=");
    c6_wifi_put_u32(beat);
    c6_wifi_puts(passed ? " verdict=PASS\r\n" : " verdict=FAIL\r\n");
    beat++;
    tx_thread_sleep((ULONG)k_c6_wifi_heartbeat_ms);
  }
}

static bool c6_wifi_phase_ready(ra8_c6link_fw_version_t* out)
{
  if (out == nullptr) {
    c6_wifi_puts("c6_wifi: FAIL no identity record to fill\r\n");
    return false;
  }
 
  const ra8_err_t opened = c6_wifi_open_link();
  c6_wifi_puts("c6_wifi: link_open=");
  c6_wifi_puts(ra8_err_to_str(opened));
  c6_wifi_puts("\r\n");
  if (opened != k_ra8_ok) {
    c6_wifi_puts("c6_wifi: FAIL could not open the link\r\n");
    return false;
  }
 
  const ra8_err_t ready =
    ra8_c6link_await_ready(&s_c6_wifi_link, (uint16_t)k_ra8_c6link_announce_transfers, out);
  c6_wifi_puts("c6_wifi: await_ready=");
  c6_wifi_puts(ra8_err_to_str(ready));
  c6_wifi_puts("\r\n");
  if (ready != k_ra8_ok) {
    c6_wifi_report_fault("await_ready", ready);
    c6_wifi_puts("c6_wifi: FAIL the coprocessor did not answer the readiness probe\r\n");
    return false;
  }
  return true;
}

static void c6_wifi_worker_entry(ULONG thread_input)
{
  (void)thread_input;
 
  c6_wifi_puts("c6_wifi: port_init=");
  c6_wifi_puts(ra8_err_to_str(s_c6_wifi_init_err));
  c6_wifi_puts("\r\n");
  if (s_c6_wifi_init_err != k_ra8_ok) {
    c6_wifi_puts("c6_wifi: FAIL port init failed -- no transaction attempted\r\n");
    c6_wifi_heartbeat(false);
    return;
  }
 
  ra8_delay_ms((uint32_t)k_c6_wifi_boot_wait_ms);
 
  ra8_c6link_fw_version_t fw = {};
  if (!c6_wifi_phase_ready(&fw)) {
    c6_wifi_heartbeat(false);
    return;
  }
 
  const bool identity = c6_wifi_phase_identity(&fw);
  const bool station  = identity && c6_wifi_phase_station();
 
  c6_wifi_puts("c6_wifi: events_seen=");
  c6_wifi_put_u32(s_c6_wifi_events);
  c6_wifi_puts("\r\n");
  if (station) {
    c6_wifi_puts("c6_wifi: PASS ra8_c6link drove the coprocessor station up and read its "
                 "address\r\n");
  } else {
    c6_wifi_puts("c6_wifi: FAIL station bring-up through ra8_c6link did not complete\r\n");
  }
  ra8_esp_hosted_mem_dump("c6_wifi_link");
  c6_wifi_heartbeat(station);
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  const ra8_esp_hosted_port_cfg_t cfg = {
    .pclk_hz      = s_c6_wifi_pclka_hz,
    .sck_hz       = (uint32_t)k_c6_wifi_sck_hz,
    .edge_poll_ms = (uint16_t)k_c6_wifi_edge_poll_ms,
    .sci_channel  = (uint8_t)k_ra8_board_pmod1_sci_channel,
  };
  s_c6_wifi_init_err = ra8_esp_hosted_port_init(&cfg);
 
  if (tx_thread_create(&s_c6_wifi_worker,
                       s_c6_wifi_worker_name,
                       c6_wifi_worker_entry,
                       0U,
                       s_c6_wifi_worker_stack,
                       (ULONG)sizeof(s_c6_wifi_worker_stack),
                       (UINT)k_c6_wifi_worker_prio,
                       (UINT)k_c6_wifi_worker_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    c6_wifi_puts("c6_wifi: worker thread creation failed\r\n");
  }
}

void main(void)
{
  c6_wifi_setup_or_halt();
  ra8_isr_globals_enable();
 
  c6_wifi_print_banner(s_c6_wifi_cpuclk_hz, s_c6_wifi_pclka_hz);
  c6_wifi_puts("c6_wifi: entering ThreadX; port init runs from tx_application_define\r\n");
 
  tx_kernel_enter();
 
  c6_wifi_panic_halt();
}