main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_fwver.h"
#include "esp_hosted_interface.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"
#include "tx_api.h"

typedef enum : uint16_t {
  k_c6_fwver_caps_transfers = 8U, 
} c6_fwver_pump_budget_t;

static uint32_t s_c6_fwver_cpuclk_hz;

static uint32_t s_c6_fwver_pclka_hz;

static ra8_err_t s_c6_fwver_init_err = k_ra8_err_not_initialized;

static TX_THREAD s_c6_fwver_worker;

static CHAR s_c6_fwver_worker_name[] = "c6_fw_version";

static UCHAR s_c6_fwver_worker_stack[k_c6_fwver_worker_stack];

static uint8_t s_c6_fwver_txbuf[k_c6_fwver_tx_max];

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

static void c6_fwver_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &s_c6_fwver_cpuclk_hz) != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_c6_fwver_pclka_hz) != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
  if (ra8_time_init(s_c6_fwver_cpuclk_hz) != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_c6_fwver_uart_baud) != k_ra8_ok) {
    c6_fwver_panic_halt();
  }
}

static void c6_fwver_phase_caps(void)
{
  uint16_t        len = 0U;
  const ra8_err_t err =
    c6_fwver_priv_host_caps(s_c6_fwver_txbuf, (uint16_t)k_c6_fwver_tx_max, &len);
  c6_fwver_puts("c6_fwver: host caps build=");
  c6_fwver_puts(ra8_err_to_str(err));
  c6_fwver_puts(" bytes=");
  c6_fwver_put_u32((uint32_t)len);
  c6_fwver_puts("\r\n");
  if (err != k_ra8_ok) {
    return;
  }
 
  c6_fwver_pump_stats_t stats = {};
  const ra8_err_t       ran   = c6_fwver_link_pump((uint8_t)ESP_PRIV_IF,
                                                   0U,
                                                   s_c6_fwver_txbuf,
                                                   len,
                                                   (uint16_t)k_c6_fwver_caps_transfers,
                                                   c6_fwver_dispatch,
                                                   &stats);
  c6_fwver_print_pump("caps", &stats);
  if (ran != k_ra8_ok) {
    c6_fwver_puts("c6_fwver: caps pump=");
    c6_fwver_puts(ra8_err_to_str(ran));
    c6_fwver_puts("\r\n");
  }
}

static void c6_fwver_phase_request(void)
{
  uint16_t        len = 0U;
  const ra8_err_t err = c6_fwver_rpc_request(s_c6_fwver_txbuf, (uint16_t)k_c6_fwver_tx_max, &len);
  c6_fwver_puts("c6_fwver: request build=");
  c6_fwver_puts(ra8_err_to_str(err));
  c6_fwver_puts(" bytes=");
  c6_fwver_put_u32((uint32_t)len);
  c6_fwver_puts("\r\n");
  if (err != k_ra8_ok) {
    return;
  }
 
  c6_fwver_pump_stats_t stats = {};
  const ra8_err_t       ran   = c6_fwver_link_pump((uint8_t)ESP_SERIAL_IF,
                                                   0U,
                                                   s_c6_fwver_txbuf,
                                                   len,
                                                   (uint16_t)k_c6_fwver_max_transfers,
                                                   c6_fwver_dispatch,
                                                   &stats);
  c6_fwver_print_pump("rpc", &stats);
  if (ran != k_ra8_ok) {
    c6_fwver_puts("c6_fwver: rpc pump=");
    c6_fwver_puts(ra8_err_to_str(ran));
    c6_fwver_puts("\r\n");
  }
}

static void c6_fwver_heartbeat(bool passed)
{
  uint32_t beat = 0U;
  while (1) {
    c6_fwver_puts("c6_fwver: heartbeat n=");
    c6_fwver_put_u32(beat);
    c6_fwver_puts(passed ? " verdict=PASS\r\n" : " verdict=FAIL\r\n");
    beat++;
    tx_thread_sleep((ULONG)k_c6_fwver_heartbeat_ms);
  }
}

static void c6_fwver_worker_entry(ULONG thread_input)
{
  (void)thread_input;
 
  c6_fwver_puts("c6_fwver: port_init=");
  c6_fwver_puts(ra8_err_to_str(s_c6_fwver_init_err));
  c6_fwver_puts("\r\n");
 
  if (s_c6_fwver_init_err != k_ra8_ok) {
    c6_fwver_puts("c6_fwver: FAIL port init failed -- no transaction attempted\r\n");
    c6_fwver_heartbeat(false);
    return;
  }
 
  ra8_delay_ms((uint32_t)k_c6_fwver_boot_wait_ms);
  c6_fwver_phase_caps();
  c6_fwver_phase_request();
  const bool passed = c6_fwver_rpc_report();
  ra8_esp_hosted_mem_dump("c6_fw_version");
  c6_fwver_heartbeat(passed);
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  const ra8_esp_hosted_port_cfg_t cfg = {
    .pclk_hz      = s_c6_fwver_pclka_hz,
    .sck_hz       = (uint32_t)k_c6_fwver_sck_hz,
    .edge_poll_ms = (uint16_t)k_c6_fwver_edge_poll_ms,
    .sci_channel  = (uint8_t)k_ra8_board_pmod1_sci_channel,
  };
  s_c6_fwver_init_err = ra8_esp_hosted_port_init(&cfg);
 
  if (tx_thread_create(&s_c6_fwver_worker,
                       s_c6_fwver_worker_name,
                       c6_fwver_worker_entry,
                       0U,
                       s_c6_fwver_worker_stack,
                       (ULONG)sizeof(s_c6_fwver_worker_stack),
                       (UINT)k_c6_fwver_worker_prio,
                       (UINT)k_c6_fwver_worker_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    c6_fwver_puts("c6_fwver: worker thread creation failed\r\n");
  }
}

void main(void)
{
  c6_fwver_setup_or_halt();
  ra8_isr_globals_enable();
 
  c6_fwver_print_banner(s_c6_fwver_cpuclk_hz, s_c6_fwver_pclka_hz);
  c6_fwver_puts("c6_fwver: entering ThreadX; port init runs from tx_application_define\r\n");
 
  tx_kernel_enter();
 
  c6_fwver_panic_halt();
}