main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "epub.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_rabook_pipeline.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_time.h"
#include "ra8_vmem.h"
#include "rabook_compile.h"
#include "rabook_import.h"
#include "rabook_import_compiler.h"
 
/* =============================================================================
 * Tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_imp_uart_baud        = 115200U, 
  k_imp_spi_channel      = 0U,      
  k_imp_format_version   = 1U,      
  k_imp_importer_version = 1U,      
  k_imp_scratch_cap      = 4096U,   
  k_imp_path_cap         = 16U,     
  k_imp_dec_base         = 10U,     
  k_imp_str_max          = 256U,    
} imp_config_t;

typedef enum : uint32_t {
  k_imp_cache_frame_bytes = 4096U,              
  k_imp_cache_frames      = 64U,                
  k_imp_cache_buckets     = 128U,               
  k_imp_chapter_cap       = 32U,                
  k_imp_node_cap          = 2048U,              
  k_imp_attr_cap          = 512U,               
  k_imp_style_cap         = 16U,                
  k_imp_image_cap         = 32U,                
  k_imp_string_cap        = 64U * 1024U,        
  k_imp_imgpool_cap       = 1024U * 1024U,      
  k_imp_out_cap           = 512U * 1024U,       
  k_imp_xhtml_cap         = 64U * 1024U,        
  k_imp_css_cap           = 16U * 1024U,        
  k_imp_imgraw_cap        = 2U * 1024U * 1024U, 
  k_imp_arena_cap         = 4U * 1024U * 1024U, 
  k_imp_gray_cap          = 2U * 1024U * 1024U, 
  k_imp_readback_cap      = 512U * 1024U,       
} imp_buf_cap_t;
 
/* =============================================================================
 * Pinout (Pmod2 SPI for SD card)
 * =============================================================================
 */

static const ra8_port_pin_t k_imp_pin_sck  = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck;
static const ra8_port_pin_t k_imp_pin_cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo;
static const ra8_port_pin_t k_imp_pin_copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi;
static const ra8_port_pin_t k_imp_pin_cs   = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs;

static const char k_imp_epub_path[] = "BOOK.EPB";
 
/* =============================================================================
 * SDRAM working storage (no heap; NASA Rule 3). All NOLOAD .sdram_data.
 * =============================================================================
 */

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_scratch[k_imp_scratch_cap];

[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static uint8_t s_imp_cache_frames[k_imp_cache_frames * k_imp_cache_frame_bytes];

static ra8_vmem_frame_t s_imp_cache_meta[k_imp_cache_frames];

static ra8_vmem_key_t s_imp_cache_keys[k_imp_cache_frames];

static int32_t s_imp_cache_buckets[k_imp_cache_buckets];

static ra8_vmem_t s_imp_cache;

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static epub_book_t s_imp_epub;

[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static book_chapter_t s_imp_chapters[k_imp_chapter_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static book_node_t  s_imp_nodes[k_imp_node_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static book_attr_t  s_imp_attrs[k_imp_attr_cap];
[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static book_stylesheet_t                         s_imp_styles[k_imp_style_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static book_image_t s_imp_images[k_imp_image_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static char    s_imp_strpool[k_imp_string_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_imgpool[k_imp_imgpool_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_out[k_imp_out_cap];

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_xhtml[k_imp_xhtml_cap];
[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static ra8_rabook_xml_workspace_t           s_imp_xml_workspace;
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_image_raw[k_imp_imgraw_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_img_scratch[k_imp_arena_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_gray[k_imp_gray_cap];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static char    s_imp_css[k_imp_css_cap];

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_imp_readback[k_imp_readback_cap];
 
/* =============================================================================
 * Static message strings (ASCII-only per project policy)
 * =============================================================================
 */
 
static const uint8_t k_msg_boot[]    = "import_reader: boot\r\n";
static const uint8_t k_msg_card_ok[] = "import_reader: card ready\r\n";
static const uint8_t k_msg_mounted[] = "import_reader: volume mounted\r\n";
static const uint8_t k_msg_miss[]    = "import_reader: first open MISS -> compiled, cache=";
static const uint8_t k_msg_hit[]     = "import_reader: second open HIT (no recompile), cache=";
static const uint8_t k_msg_cbytes[]  = "import_reader: cache bytes=";
static const uint8_t k_msg_title[]   = "import_reader: title=";
static const uint8_t k_msg_chaps[]   = " chapters=";
static const uint8_t k_msg_ch[]      = "import_reader: ch";
static const uint8_t k_msg_textlen[] = " textlen=";
static const uint8_t k_msg_eol[]     = "\r\n";
static const uint8_t k_msg_pass[]    = "import_reader: miss->compile->cache->hit->read PASS\r\n";
static const uint8_t k_msg_fail[]    = "import_reader: FAIL ";
 
/* =============================================================================
 * Console output helpers
 * =============================================================================
 */

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

#define IMP_PUTS(lit) imp_print((lit), (uint32_t)sizeof(lit) - 1U)

static void imp_print_cstr(const char* str)
{
  uint32_t n = 0U;
  while ((n < (uint32_t)k_imp_str_max) && (str[n] != '\0')) {
    n++;
  }
  imp_print((const uint8_t*)str, n);
}

static void imp_print_uint(uint32_t value)
{
  uint8_t  buf[k_imp_dec_base];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_imp_dec_base)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_imp_dec_base));
    n++;
    value /= (uint32_t)k_imp_dec_base;
  }
  for (uint32_t i = 0U; i < n; i++) {
    imp_print(&buf[n - 1U - i], 1U);
  }
}

static void imp_panic(const char* stage)
{
  IMP_PUTS(k_msg_fail);
  imp_print_cstr(stage);
  imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
  (void)ra8_board_uart_console_flush();
  __asm__ volatile("bkpt #0");
  while (true) {
    __asm__ volatile("wfi");
  }
}
 
/* =============================================================================
 * Hardware bring-up
 * =============================================================================
 */

static void imp_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) {
    imp_panic("clocks");
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    imp_panic("clocks");
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) {
    imp_panic("clocks");
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    imp_panic("time");
  }
  if (ra8_board_uart_console_init((uint32_t)k_imp_uart_baud) != k_ra8_ok) {
    imp_panic("console");
  }
  *out_pclka_hz = pclka_hz;
}

static void imp_init_card_or_halt(uint32_t pclka_hz)
{
  const ra8_sdmmc_spi_sci_pins_t pins = {
    .sck  = k_imp_pin_sck,
    .cipo = k_imp_pin_cipo,
    .copi = k_imp_pin_copi,
    .cs   = k_imp_pin_cs,
  };
  ra8_sdmmc_spi_transport_t transport = {};
  if (ra8_sdmmc_spi_transport_sci((uint8_t)k_imp_spi_channel, pclka_hz, &pins, &transport) !=
      k_ra8_ok) {
    imp_panic("sd transport");
  }
  if (ra8_sdmmc_spi_init(&transport) != k_ra8_ok) {
    imp_panic("sd init");
  }
  IMP_PUTS(k_msg_card_ok);
}

static void imp_mount_or_halt(ra8_fs_mount_t** out_mount)
{
  ra8_fs_backend_t backend = {};
  if (ra8_sdmmc_spi_bind_fs_backend(&backend) != k_ra8_ok) {
    imp_panic("sd backend");
  }
  if (ra8_fs_mount(&backend, out_mount) != k_ra8_ok) {
    imp_panic("mount");
  }
  IMP_PUTS(k_msg_mounted);
}
 
/* =============================================================================
 * Importer wiring (production compile adapter behind the DIP seam)
 * =============================================================================
 */

static ra8_rabook_buffers_t          s_imp_bufs;
static ra8_rabook_pipeline_scratch_t s_imp_scr;
static ra8_img_arena_t               s_imp_arena;
static rabook_import_compiler_ctx_t  s_imp_cookie;

static void imp_build_cookie(void)
{
  s_imp_bufs = (ra8_rabook_buffers_t){
    .chapters       = s_imp_chapters,
    .chapter_cap    = (uint32_t)k_imp_chapter_cap,
    .nodes          = s_imp_nodes,
    .node_cap       = (uint32_t)k_imp_node_cap,
    .attrs          = s_imp_attrs,
    .attr_cap       = (uint32_t)k_imp_attr_cap,
    .stylesheets    = s_imp_styles,
    .stylesheet_cap = (uint32_t)k_imp_style_cap,
    .images         = s_imp_images,
    .image_cap      = (uint32_t)k_imp_image_cap,
    .string_pool    = s_imp_strpool,
    .string_cap     = (uint32_t)k_imp_string_cap,
    .image_pool     = s_imp_imgpool,
    .image_pool_cap = (uint32_t)k_imp_imgpool_cap,
    .out            = s_imp_out,
    .out_cap        = (uint32_t)k_imp_out_cap,
  };
  s_imp_arena = (ra8_img_arena_t){s_imp_img_scratch, sizeof(s_imp_img_scratch), 0U, 0U};
  s_imp_scr   = (ra8_rabook_pipeline_scratch_t){
    .xhtml         = s_imp_xhtml,
    .xhtml_cap     = sizeof(s_imp_xhtml),
    .image_raw     = s_imp_image_raw,
    .image_cap     = sizeof(s_imp_image_raw),
    .img_arena     = &s_imp_arena,
    .gray          = s_imp_gray,
    .gray_cap      = (uint32_t)k_imp_gray_cap,
    .css           = s_imp_css,
    .css_cap       = sizeof(s_imp_css),
    .xml_workspace = &s_imp_xml_workspace,
  };
  s_imp_cookie = (rabook_import_compiler_ctx_t){
    .epub               = &s_imp_epub,
    .cache              = &s_imp_cache,
    .cache_frames       = s_imp_cache_frames,
    .cache_frame_bytes  = (uint32_t)k_imp_cache_frame_bytes,
    .cache_frame_count  = (uint32_t)k_imp_cache_frames,
    .cache_meta         = s_imp_cache_meta,
    .cache_keys         = s_imp_cache_keys,
    .cache_buckets      = s_imp_cache_buckets,
    .cache_bucket_count = (uint32_t)k_imp_cache_buckets,
    .bufs               = &s_imp_bufs,
    .scr                = &s_imp_scr,
  };
}

static rabook_import_cfg_t imp_make_cfg(ra8_fs_mount_t* mount)
{
  rabook_import_cfg_t cfg = {};
  cfg.mount               = mount;
  cfg.compile             = rabook_import_compile_adapter;
  cfg.compile_ctx         = &s_imp_cookie;
  cfg.scratch             = s_imp_scratch;
  cfg.scratch_cap         = (uint32_t)k_imp_scratch_cap;
  cfg.format_version      = (uint32_t)k_imp_format_version;
  cfg.importer_version    = (uint32_t)k_imp_importer_version;
  return cfg;
}
 
/* =============================================================================
 * Cache read-back + book walk
 * =============================================================================
 */

[[nodiscard]] static ra8_err_t
imp_read_cache(ra8_fs_mount_t* mount, const char* path, uint32_t* out_len)
{
  ra8_fs_file_t* file = nullptr;
  ra8_err_t      err  = ra8_fs_open(mount, path, k_ra8_fs_mode_read, &file);
  if (err != k_ra8_ok) {
    return err;
  }
  uint64_t size = 0U;
  err           = ra8_fs_size(file, &size);
  if (err != k_ra8_ok) {
    (void)ra8_fs_close(file);
    return err;
  }
  if (size > (uint64_t)sizeof(s_imp_readback)) {
    (void)ra8_fs_close(file);
    return k_ra8_err_no_mem;
  }
  uint32_t got = 0U;
  err          = ra8_fs_read(file, s_imp_readback, (uint32_t)sizeof(s_imp_readback), &got);
  (void)ra8_fs_close(file);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = got;
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t imp_walk_book(uint32_t len)
{
  const void* base = (const void*)s_imp_readback;
  ra8_err_t   err  = book_validate(base, (size_t)len);
  if (err != k_ra8_ok) {
    return err;
  }
  const book_header_t* hdr = book_header(base);
  IMP_PUTS(k_msg_title);
  imp_print_cstr(book_string(base, hdr->title_off));
  IMP_PUTS(k_msg_chaps);
  imp_print_uint(hdr->chapter_count);
  imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
 
  for (uint32_t ci = 0U; ci < hdr->chapter_count; ci++) {
    size_t    tlen = 0U;
    ra8_err_t cerr = book_chapter_text(base, ci, (char*)s_imp_xhtml, sizeof(s_imp_xhtml), &tlen);
    if (cerr != k_ra8_ok) {
      return cerr;
    }
    IMP_PUTS(k_msg_ch);
    imp_print_uint(ci);
    IMP_PUTS(k_msg_textlen);
    imp_print_uint((uint32_t)tlen);
    imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * End-to-end flow
 * =============================================================================
 */

static void imp_run(ra8_fs_mount_t* mount)
{
  rabook_import_cfg_t     cfg                   = imp_make_cfg(mount);
  rabook_import_outcome_t out                   = k_rabook_import_hit;
  char                    path1[k_imp_path_cap] = {};
  char                    path2[k_imp_path_cap] = {};
 
  /* First open: cache miss -> compile + write-through. */
  if (rabook_import_open(&cfg, k_imp_epub_path, path1, (uint32_t)sizeof(path1), &out) != k_ra8_ok) {
    imp_panic("import compile");
  }
  if (out != k_rabook_import_compiled) {
    imp_panic("expected miss");
  }
  IMP_PUTS(k_msg_miss);
  imp_print_cstr(path1);
  imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
 
  /* The .rabook now exists on the card. */
  uint32_t cache_len = 0U;
  if (imp_read_cache(mount, path1, &cache_len) != k_ra8_ok) {
    imp_panic("cache read");
  }
  IMP_PUTS(k_msg_cbytes);
  imp_print_uint(cache_len);
  imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
 
  /* Second open: fresh cache -> hit, the compiler seam is NOT invoked. */
  if (rabook_import_open(&cfg, k_imp_epub_path, path2, (uint32_t)sizeof(path2), &out) != k_ra8_ok) {
    imp_panic("import reopen");
  }
  if (out != k_rabook_import_hit) {
    imp_panic("expected hit");
  }
  IMP_PUTS(k_msg_hit);
  imp_print_cstr(path2);
  imp_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
 
  /* Read the cached book back and walk it. */
  if (imp_read_cache(mount, path2, &cache_len) != k_ra8_ok) {
    imp_panic("cache reread");
  }
  if (imp_walk_book(cache_len) != k_ra8_ok) {
    imp_panic("book walk");
  }
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  uint32_t pclka_hz = 0U;
  imp_setup_or_halt(&pclka_hz);
  ra8_isr_globals_enable();
  ra8_log_init();
  IMP_PUTS(k_msg_boot);
 
  imp_init_card_or_halt(pclka_hz);
 
  ra8_fs_mount_t* mount = nullptr;
  imp_mount_or_halt(&mount);
 
  imp_build_cookie();
  imp_run(mount);
 
  IMP_PUTS(k_msg_pass);
  (void)ra8_board_uart_console_flush();
 
  while (true) {
    __asm__ volatile("wfi");
  }
}