main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "epub.h"
#include "epub_fixture.h"
#include "epub_fs.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci_spi.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_spi.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_eoh_uart_baud   = 115200U,     
  k_eoh_spi_chan    = 0U,          
  k_eoh_expect_chap = 2U,          
  k_eoh_expect_crc  = 0xCF23AEEEU, 
  k_eoh_chap_cap    = 4096U,       
  k_eoh_crc_init    = 0xFFFFFFFFU, 
  k_eoh_crc_poly    = 0xEDB88320U, 
  k_eoh_crc_bits    = 8U,          
  k_eoh_hex_nibbles = 8U,          
  k_eoh_nibble_bits = 4U,          
  k_eoh_nibble_mask = 0x0FU,       
  k_eoh_dec_ten     = 10U,         
} eoh_consts_t;

static const ra8_port_pin_t k_eoh_pin_sck  = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck;
static const ra8_port_pin_t k_eoh_pin_cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo;
static const ra8_port_pin_t k_eoh_pin_copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi;
static const ra8_port_pin_t k_eoh_pin_cs   = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs;

static const char k_eoh_book_path[] = "BOOK.EPB";

typedef enum : uint32_t {
  k_eoh_err_none  = 0U, 
  k_eoh_err_init  = 1U, 
  k_eoh_err_card  = 2U, 
  k_eoh_err_mount = 3U, 
  k_eoh_err_prov  = 4U, 
  k_eoh_err_open  = 5U, 
  k_eoh_err_chap  = 6U, 
  k_eoh_err_load  = 7U, 
  k_eoh_err_crc   = 8U, 
  k_eoh_err_meta  = 9U, 
} eoh_err_t;

typedef enum : uint32_t {
  k_eoh_frame_ms = 100U, 
} eoh_pace_t;

volatile uint32_t g_eoh_err = (uint32_t)k_eoh_err_none;
volatile uint32_t g_eoh_chapters = 0U;
volatile uint32_t g_eoh_crc = 0U;
volatile uint32_t g_eoh_heartbeat = 0U;

static epub_book_t s_book;
static epub_stream_fs_ctx_t s_epub_io;
static uint8_t s_chapter[k_eoh_chap_cap];
static ra8_fs_backend_t s_backend;
 
static const uint8_t k_msg_boot[]   = "epub-open-hil: boot\r\n";
static const uint8_t k_msg_cardok[] = "epub-open-hil: card ready\r\n";
static const uint8_t k_msg_finit[]  = "epub-hil: FAIL init\r\n";
static const uint8_t k_msg_fcard[]  = "epub-hil: FAIL card\r\n";
static const uint8_t k_msg_fmount[] = "epub-hil: FAIL mount\r\n";
static const uint8_t k_msg_fprov[]  = "epub-hil: FAIL provision\r\n";
static const uint8_t k_msg_fopen[]  = "epub-hil: FAIL open\r\n";
static const uint8_t k_msg_fchap[]  = "epub-hil: FAIL chapters\r\n";
static const uint8_t k_msg_fload[]  = "epub-hil: FAIL load\r\n";
static const uint8_t k_msg_fcrc[]   = "epub-hil: FAIL crc\r\n";
static const uint8_t k_msg_fmeta[]  = "epub-hil: FAIL meta\r\n";
static const uint8_t k_msg_pre[]    = "epub-hil: chapters=";
static const uint8_t k_msg_crc[]    = " ch0_crc=";
static const uint8_t k_msg_ok[]     = " PASS\r\n";

static void eoh_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

static void eoh_fail(uint32_t err, const uint8_t* msg, uint32_t len)
{
  g_eoh_err = err;
  eoh_print(msg, len);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static uint32_t eoh_crc32(const uint8_t* data, size_t len)
{
  uint32_t crc = (uint32_t)k_eoh_crc_init;
  for (size_t i = 0U; i < len; i++) {
    crc ^= (uint32_t)data[i];
    for (uint32_t bit = 0U; bit < (uint32_t)k_eoh_crc_bits; bit++) {
      const uint32_t mask = (uint32_t)(-(int32_t)(crc & 1U));
      crc                 = (crc >> 1U) ^ ((uint32_t)k_eoh_crc_poly & mask);
    }
  }
  return ~crc;
}

static void eoh_print_hex(uint32_t value)
{
  uint8_t buf[k_eoh_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_eoh_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_eoh_hex_nibbles - 1U - i) * (uint32_t)k_eoh_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_eoh_nibble_mask;
    buf[i] =
      (uint8_t)((nib < (uint32_t)k_eoh_dec_ten) ? ('0' + nib) : ('A' + (nib - k_eoh_dec_ten)));
  }
  eoh_print(buf, (uint32_t)k_eoh_hex_nibbles);
}

static void eoh_print_uint(uint32_t value)
{
  uint8_t  buf[k_eoh_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_eoh_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_eoh_dec_ten));
    n++;
    value /= (uint32_t)k_eoh_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    eoh_print(&buf[n - 1U - i], 1U);
  }
}
 
/* ---- SPI -> ra8_sdmmc_spi transport adapter (mirror of fs_format_mount) ---- */
 
/* cppcheck-suppress constParameterCallback -- bound to ra8_sdmmc_spi_transport_t::set_clock, `ra8_err_t (*)(void*, uint32_t)`; constifying ctx would break the binding. */
static ra8_err_t eoh_spi_set_clock(void* ctx, uint32_t hz)
{
  const uint32_t pclka_hz = *(const uint32_t*)ctx;
  return ra8_sci_spi_set_clock((uint8_t)k_eoh_spi_chan, hz, pclka_hz);
}

static ra8_err_t eoh_spi_cs(void* ctx, bool asserted)
{
  (void)ctx;
  return ra8_gpio_write(k_eoh_pin_cs, asserted ? k_ra8_level_low : k_ra8_level_high);
}

static ra8_err_t eoh_spi_xfer(void* ctx, const uint8_t* tx, uint8_t* rx, uint32_t len)
{
  (void)ctx;
  return ra8_sci_spi_xfer((uint8_t)k_eoh_spi_chan, tx, rx, len);
}

[[nodiscard]] static ra8_err_t eoh_spi_pins_init(void)
{
  ra8_err_t err = ra8_pfs_route_peripheral(k_eoh_pin_sck, k_ra8_psel_sci_async, "eoh.sck");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_eoh_pin_cipo, k_ra8_psel_sci_async, "eoh.cipo");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_eoh_pin_copi, k_ra8_psel_sci_async, "eoh.copi");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_output_init(k_eoh_pin_cs, k_ra8_level_high);
}

static void eoh_setup_or_halt(uint32_t* out_pclka_hz)
{
  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_board_uart_console_init((uint32_t)k_eoh_uart_baud) != k_ra8_ok)) {
    eoh_fail((uint32_t)k_eoh_err_init, k_msg_finit, (uint32_t)sizeof(k_msg_finit) - 1U);
  }
  if (eoh_spi_pins_init() != k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_init, k_msg_finit, (uint32_t)sizeof(k_msg_finit) - 1U);
  }
  const ra8_sci_spi_cfg_t spi_cfg = {.baud_hz   = (uint32_t)k_ra8_sdmmc_spi_clock_init_hz,
                                     .pclk_hz   = pclka_hz,
                                     .mode      = k_ra8_spi_mode_0,
                                     .lsb_first = false};
  if (ra8_sci_spi_init((uint8_t)k_eoh_spi_chan, &spi_cfg) != k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_init, k_msg_finit, (uint32_t)sizeof(k_msg_finit) - 1U);
  }
  *out_pclka_hz = pclka_hz;
}

static void eoh_init_card_or_halt(uint32_t* pclka_hz)
{
  const ra8_sdmmc_spi_transport_t transport = {.set_clock = eoh_spi_set_clock,
                                               .cs        = eoh_spi_cs,
                                               .xfer      = eoh_spi_xfer,
                                               .ctx       = pclka_hz};
  if (ra8_sdmmc_spi_init(&transport) != k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_card, k_msg_fcard, (uint32_t)sizeof(k_msg_fcard) - 1U);
  }
  eoh_print(k_msg_cardok, (uint32_t)sizeof(k_msg_cardok) - 1U);
}

static ra8_fs_mount_t* eoh_mount_or_halt(void)
{
  if (ra8_sdmmc_spi_bind_fs_backend(&s_backend) != k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_mount, k_msg_fmount, (uint32_t)sizeof(k_msg_fmount) - 1U);
  }
  ra8_fs_mount_t* mount = nullptr;
  if (ra8_fs_mount(&s_backend, &mount) != k_ra8_ok) {
    ra8_fs_format_opts_t opts = {};
    opts.type                 = k_ra8_fs_type_fat32;
    opts.label                = "RAEPUB";
    if ((ra8_fs_format(&s_backend, &opts) != k_ra8_ok) ||
        (ra8_fs_mount(&s_backend, &mount) != k_ra8_ok)) {
      eoh_fail((uint32_t)k_eoh_err_mount, k_msg_fmount, (uint32_t)sizeof(k_msg_fmount) - 1U);
    }
  }
  return mount;
}

static void eoh_provision_or_halt(ra8_fs_mount_t* mount)
{
  ra8_fs_file_t* file = nullptr;
  if (ra8_fs_open(mount, k_eoh_book_path, k_ra8_fs_mode_read, &file) == k_ra8_ok) {
    (void)ra8_fs_close(file); /* already present -- nothing to provision. */
    return;
  }
  if (ra8_fs_write_file(mount, k_eoh_book_path, k_epub_fixture, (uint32_t)k_epub_fixture_len) !=
      k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_prov, k_msg_fprov, (uint32_t)sizeof(k_msg_fprov) - 1U);
  }
}

static uint16_t eoh_parse_or_halt(ra8_fs_mount_t* mount, uint32_t* out_crc)
{
  if (epub_open_streamed_fs(mount, k_eoh_book_path, &s_epub_io, &s_book) != k_ra8_ok) {
    eoh_fail((uint32_t)k_eoh_err_open, k_msg_fopen, (uint32_t)sizeof(k_msg_fopen) - 1U);
  }
  uint16_t chapters = 0U;
  if ((epub_get_chapter_count(&s_book, &chapters) != k_ra8_ok) ||
      (chapters != (uint16_t)k_eoh_expect_chap)) {
    eoh_fail((uint32_t)k_eoh_err_chap, k_msg_fchap, (uint32_t)sizeof(k_msg_fchap) - 1U);
  }
  size_t got = 0U;
  if ((epub_load_chapter(&s_book, 0U, s_chapter, (size_t)k_eoh_chap_cap, &got) != k_ra8_ok) ||
      (got == 0U)) {
    eoh_fail((uint32_t)k_eoh_err_load, k_msg_fload, (uint32_t)sizeof(k_msg_fload) - 1U);
  }
  const uint32_t crc = eoh_crc32(s_chapter, got);
  if (crc != (uint32_t)k_eoh_expect_crc) {
    eoh_fail((uint32_t)k_eoh_err_crc, k_msg_fcrc, (uint32_t)sizeof(k_msg_fcrc) - 1U);
  }
  epub_metadata_t meta = {};
  if ((epub_get_metadata(&s_book, &meta) != k_ra8_ok) || (meta.title == nullptr) ||
      (meta.title[0] == '\0')) {
    eoh_fail((uint32_t)k_eoh_err_meta, k_msg_fmeta, (uint32_t)sizeof(k_msg_fmeta) - 1U);
  }
  *out_crc = crc;
  return chapters;
}

void main(void)
{
  uint32_t pclka_hz = 0U;
  eoh_setup_or_halt(&pclka_hz);
  ra8_isr_globals_enable();
  ra8_log_init();
  eoh_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  eoh_init_card_or_halt(&pclka_hz);
  ra8_fs_mount_t* const mount = eoh_mount_or_halt();
  eoh_provision_or_halt(mount);
 
  uint32_t       ch0_crc  = 0U;
  const uint16_t chapters = eoh_parse_or_halt(mount, &ch0_crc);
 
  /* Latch the results for the J-Link / `--dump-sym` memprobe gate. */
  g_eoh_chapters = (uint32_t)chapters;
  g_eoh_crc      = ch0_crc;
 
  eoh_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  eoh_print_uint((uint32_t)chapters);
  eoh_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  eoh_print_hex(ch0_crc);
  eoh_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  /* Idle with a heartbeat that advances ONLY here -- the failure path parks in
   * WFI without bumping it -- so a memprobe gate proves the full SD -> ra8_fs ->
   * epub open/parse pipeline ran and the chapter-0 CRC matched. */
  while (1) {
    ra8_delay_ms(k_eoh_frame_ms);
    g_eoh_heartbeat++;
  }
}