main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_io.h"
#include "ra8_log.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci.h"
#include "ra8_time.h"
#include "ra8_xspi.h"

typedef enum : uint32_t {
  k_swap_uart_chan   = 8U,      
  k_swap_uart_baud   = 115200U, 
  k_swap_pin_shift   = 8U,      
  k_swap_ram_blocks  = 256U,    
  k_swap_xspi_inst   = 0U,      
  k_swap_xspi_base   = 0U,      
  k_swap_xspi_blocks = 512U,    
  k_swap_payload     = 96U,     
  k_swap_log_cap     = 512U,    
  k_swap_backends    = 2U,      
} swap_const_t;

typedef enum : uint32_t {
  k_swap_pat_mul = 7U,    
  k_swap_pat_add = 3U,    
  k_swap_pat_xor = 0x5AU, 
} swap_pattern_t;

typedef struct {
  ra8_io_blockdev_t* bd;    
  const char*        name;  
  const char*        label; 
  const char*        file;  
} swap_backend_t;

static const ra8_port_pin_t s_swap_txd =
  (ra8_port_pin_t)(((uint16_t)k_ra8_port_13 << (uint16_t)k_swap_pin_shift) | (uint16_t)k_ra8_pin_2);
static const ra8_port_pin_t s_swap_rxd =
  (ra8_port_pin_t)(((uint16_t)k_ra8_port_13 << (uint16_t)k_swap_pin_shift) | (uint16_t)k_ra8_pin_3);

static uint8_t s_ram_disk[(size_t)k_swap_ram_blocks * (size_t)k_ra8_io_block_size_bytes];
static ra8_io_blockdev_t           s_ram_bd;
static ra8_io_blockdev_ram_state_t s_ram_state;
static ra8_io_blockdev_t            s_xspi_bd;
static ra8_io_blockdev_xspi_state_t s_xspi_state;
static ra8_fs_backend_t s_be;

static ra8_io_stream_t            s_uart;
static ra8_io_stream_uart_state_t s_uart_state;
static ra8_io_stream_t           s_ram_log;
static ra8_io_stream_ram_state_t s_ram_log_state;
static uint8_t                   s_ram_log_buf[k_swap_log_cap];

static uint8_t s_payload[k_swap_payload];
static uint8_t s_readback[k_swap_payload];

static const char* const s_tag = "ra8_io_swap_demo";

RA8_INTERNAL static void internal_swap_uart_print(const char* msg)
{
  (void)ra8_io_stream_puts(&s_uart, msg);
}

RA8_INTERNAL static void internal_swap_fill(uint32_t len)
{
  for (uint32_t i = 0U; i < len; ++i) {
    s_payload[i] = (uint8_t)(((i * (uint32_t)k_swap_pat_mul) + (uint32_t)k_swap_pat_add) ^
                             (uint32_t)k_swap_pat_xor);
  }
}

RA8_INTERNAL static ra8_err_t internal_swap_vfs_write(const char* path, uint32_t len)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path");
  RA8_CHECK_RANGE_TAG(len, 0U, (uint32_t)k_swap_payload, k_ra8_err_invalid_size, s_tag);
 
  ra8_fs_file_t* wf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_write, &wf), s_tag, "open w");
  const ra8_err_t werr = ra8_fs_write(wf, s_payload, len);
  RA8_RETURN_ON_ERROR(ra8_fs_close(wf), s_tag, "close w");
  return werr;
}

RA8_INTERNAL static ra8_err_t internal_swap_vfs_read_verify(const char* path, uint32_t len)
{
  RA8_CHECK_NULL_PTR(path, s_tag, "path");
  RA8_CHECK_RANGE_TAG(len, 0U, (uint32_t)k_swap_payload, k_ra8_err_invalid_size, s_tag);
 
  ra8_fs_file_t* rf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_read, &rf), s_tag, "open r");
  (void)memset(s_readback, 0, sizeof(s_readback));
  uint32_t        got  = 0U;
  const ra8_err_t rerr = ra8_fs_read(rf, s_readback, len, &got);
  RA8_RETURN_ON_ERROR(ra8_fs_close(rf), s_tag, "close r");
  RA8_RETURN_ON_ERROR(rerr, s_tag, "read");
  if ((got != len) || (memcmp(s_payload, s_readback, (size_t)len) != 0)) {
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_swap_run_one(const swap_backend_t* b, uint32_t len, ra8_io_stream_t* log)
{
  RA8_CHECK_NULL_PTR(b, s_tag, "backend");
  RA8_CHECK_NULL_PTR(log, s_tag, "log");
 
  (void)ra8_io_stream_puts(log, "swap[");
  (void)ra8_io_stream_puts(log, b->name);
  (void)ra8_io_stream_puts(log, "]: mount ");
  (void)ra8_io_stream_puts(log, b->label);
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_as_fs_backend(b->bd, &s_be), s_tag, "fs bridge");
  ra8_fs_format_opts_t opts = {};
  opts.type                 = k_ra8_fs_type_fat12;
  opts.label                = b->label;
  RA8_RETURN_ON_ERROR(ra8_fs_format(&s_be, &opts), s_tag, "format");
  ra8_fs_mount_t* mnt = nullptr;
  RA8_RETURN_ON_ERROR(ra8_fs_mount(&s_be, &mnt), s_tag, "mount");
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mount(b->name, mnt), s_tag, "vfs mount");
 
  internal_swap_fill(len);
  RA8_RETURN_ON_ERROR(internal_swap_vfs_write(b->file, len), s_tag, "write");
  RA8_RETURN_ON_ERROR(internal_swap_vfs_read_verify(b->file, len), s_tag, "verify");
 
  RA8_RETURN_ON_ERROR(ra8_io_vfs_unmount(b->name), s_tag, "vfs unmount");
  RA8_RETURN_ON_ERROR(ra8_fs_unmount(mnt), s_tag, "unmount");
  (void)ra8_io_stream_puts(log, " -> ");
  (void)ra8_io_stream_put_u32(log, len);
  (void)ra8_io_stream_puts(log, " bytes ok\r\n");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_swap_replay_capture(uint32_t* out_used)
{
  RA8_CHECK_NULL_PTR(out_used, s_tag, "out_used");
  RA8_VALIDATE_INIT(s_ram_log_state.buf != nullptr, s_tag, "ram log");
 
  uint32_t used = 0U;
  RA8_RETURN_ON_ERROR(ra8_io_stream_ram_used(&s_ram_log_state, &used), s_tag, "used");
  internal_swap_uart_print("ra8_io_swap_demo: --- ram-captured stdio ---\r\n");
  RA8_RETURN_ON_ERROR(ra8_io_stream_write(&s_uart, s_ram_log_buf, used, nullptr), s_tag, "replay");
  internal_swap_uart_print("ra8_io_swap_demo: --- end capture ---\r\n");
  *out_used = used;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_swap_run_all(const char** out_failed)
{
  RA8_CHECK_NULL_PTR(out_failed, s_tag, "out_failed");
  *out_failed = nullptr;
 
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_ram_init(&s_ram_bd,
                                               &s_ram_state,
                                               s_ram_disk,
                                               (uint32_t)k_swap_ram_blocks,
                                               false),
                      s_tag,
                      "ram bind");
  RA8_RETURN_ON_ERROR(ra8_xspi_init((uint8_t)k_swap_xspi_inst, k_ra8_xspi_lio_1s1s1s),
                      s_tag,
                      "xspi init");
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_xspi_init(&s_xspi_bd,
                                                &s_xspi_state,
                                                (uint8_t)k_swap_xspi_inst,
                                                (uint32_t)k_swap_xspi_base,
                                                (uint32_t)k_swap_xspi_blocks,
                                                false),
                      s_tag,
                      "xspi bind");
 
  const swap_backend_t table[k_swap_backends] = {
    {.bd = &s_ram_bd, .name = "ram", .label = "RAIORAM", .file = "ram:/DATA.BIN"},
    {.bd = &s_xspi_bd, .name = "xs", .label = "RAIOXS", .file = "xs:/DATA.BIN"},
  };
 
  for (uint32_t i = 0U; i < (uint32_t)k_swap_backends; ++i) {
    const ra8_err_t e = internal_swap_run_one(&table[i], (uint32_t)k_swap_payload, &s_ram_log);
    if (e != k_ra8_ok) {
      *out_failed = table[i].name;
      return e;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) ||
      (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) ||
      (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) ||
      (ra8_time_init(cpuclk0_hz) != k_ra8_ok) ||
      (ra8_pfs_route_peripheral(s_swap_txd, k_ra8_psel_sci_async, "swap.txd") != k_ra8_ok) ||
      (ra8_pfs_route_peripheral(s_swap_rxd, k_ra8_psel_sci_async, "swap.rxd") != k_ra8_ok)) {
    while (true) {
    }
  }
  const ra8_sci_cfg_t sci_cfg = {.baud      = (uint32_t)k_swap_uart_baud,
                                 .data_bits = k_ra8_sci_data_8,
                                 .parity    = k_ra8_sci_parity_none,
                                 .stop_bits = k_ra8_sci_stop_1,
                                 .pclk_hz   = pclka_hz};
  if (ra8_sci_init((uint8_t)k_swap_uart_chan, &sci_cfg) != k_ra8_ok) {
    while (true) {
    }
  }
}

void main(void)
{
  ra8_log_init();
  internal_demo_setup_or_halt();
  (void)ra8_io_stream_uart_init(&s_uart, &s_uart_state, (uint8_t)k_swap_uart_chan);
  (void)ra8_io_log_attach(&s_uart); /* route ra8_log errors onto the UART too */
  internal_swap_uart_print("ra8_io_swap_demo: boot\r\n");
 
  /* Retarget the engine's stdio into the in-RAM capture sink. */
  (void)
    ra8_io_stream_ram_init(&s_ram_log, &s_ram_log_state, s_ram_log_buf, (uint32_t)k_swap_log_cap);
 
  const char*     failed = nullptr;
  const ra8_err_t swap_e = internal_swap_run_all(&failed);
 
  uint32_t        captured = 0U;
  const ra8_err_t rep_e    = internal_swap_replay_capture(&captured);
 
  if (swap_e == k_ra8_ok) {
    internal_swap_uart_print("ra8_io_swap_demo: two-backend swap (ram + xs) PASS\r\n");
  } else if (failed != nullptr) {
    internal_swap_uart_print("ra8_io_swap_demo: backend ");
    internal_swap_uart_print(failed);
    internal_swap_uart_print(" FAIL\r\n");
  } else {
    internal_swap_uart_print("ra8_io_swap_demo: swap FAIL\r\n");
  }
 
  if ((rep_e == k_ra8_ok) && (captured > 0U)) {
    internal_swap_uart_print("ra8_io_swap_demo: ram-stream capture ");
    (void)ra8_io_stream_put_u32(&s_uart, captured);
    internal_swap_uart_print(" bytes PASS\r\n");
  } else {
    internal_swap_uart_print("ra8_io_swap_demo: ram-stream capture FAIL\r\n");
  }
 
  (void)ra8_sci_flush((uint8_t)k_swap_uart_chan);
  while (true) {
  }
}