ra8-firmware/examples_2ek__ra8d2_2hil__needs__revalidation_2pagecache_2src_2main_8c_source.html

#include <stddef.h>

#include <stdint.h>


#include "literata_latin1.h"

#include "ra8_attributes.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_port_utils.h"

#include "ra8_sci_spi.h"

#include "ra8_sdmmc_spi.h"

#include "ra8_spi.h"

#include "ra8_time.h"

#include "reflow.h"

#include "reflow_cache.h"


typedef enum : uint32_t {

  k_pc_uart_baud = 115200U,

  k_pc_spi_chan  = 0U,

  k_pc_font_cap =

    98304U,

  k_pc_blob_cap    = 16384U,

  k_pc_view_w      = 600U,

  k_pc_view_h      = 800U,

  k_pc_font_px     = 18U,

  k_pc_font_px_alt = 24U,

  k_pc_ink_argb    = 0xFF101010U,

  k_pc_link_argb   = 0xFF2A52BEU,

  k_pc_crc_init    = 0xFFFFFFFFU,

  k_pc_crc_poly    = 0xEDB88320U,

  k_pc_crc_bits    = 8U,

} pc_consts_t;


static const ra8_port_pin_t s_pc_pin_sck = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck;


static const ra8_port_pin_t s_pc_pin_cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo;


static const ra8_port_pin_t s_pc_pin_copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi;


static const ra8_port_pin_t s_pc_pin_cs = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs;


static const char s_pc_font_path[] = "FONT.OTF";


static const char s_pc_cache_path[] = "PCACHE.BIN";


static const char s_pc_body[] = "<html><body><h1>Cache</h1>"

                                "<p>Pagination cache round-trip on silicon.</p>"

                                "<p>Second paragraph for the break engine.</p></body></html>";


typedef enum : uint32_t {

  k_pc_err_none     = 0U,

  k_pc_err_init     = 1U,

  k_pc_err_card     = 2U,

  k_pc_err_mount    = 3U,

  k_pc_err_font     = 4U,

  k_pc_err_layout   = 5U,

  k_pc_err_ser      = 6U,

  k_pc_err_persist  = 7U,

  k_pc_err_readback = 8U,

  k_pc_err_load     = 9U,

  k_pc_err_crc      = 10U,

  k_pc_err_invalid  = 11U,

} pc_err_t;


typedef enum : uint32_t {

  k_pc_frame_ms = 100U,

} pc_pace_t;


/* ---- J-Link / ra8_emulator readable diagnostics (memprobe gate) ------------- */


volatile uint32_t g_pc_err = (uint32_t)k_pc_err_none;

volatile uint32_t g_pc_hit = 0U;

volatile uint32_t g_pc_crc_match = 0U;

volatile uint32_t g_pc_invalidate = 0U;

volatile uint32_t g_pc_pages = 0U;

volatile uint32_t g_pc_live_crc = 0U;

volatile uint32_t g_pc_cache_crc = 0U;

volatile uint32_t g_pc_heartbeat = 0U;


/* ---- Static storage (large pools off the stack) -------------------------- */


static uint8_t s_font_buf[k_pc_font_cap];

static reflow_t s_engine;

static uint8_t s_live_blob[k_pc_blob_cap];

static uint8_t s_read_blob[k_pc_blob_cap];

static uint8_t s_reser_blob[k_pc_blob_cap];

static ra8_fs_backend_t s_backend;


static const uint8_t s_msg_boot[] = "pagecache-hil: boot\r\n";


static const uint8_t s_msg_pass[] = "pagecache-hil: hit=";


static const uint8_t s_msg_ok[] = " crc_match=1 invalidate=1 PASS\r\n";


RA8_INTERNAL static void internal_pc_print(const uint8_t* msg, uint32_t len)

{

  (void)ra8_board_uart_console_write(msg, (size_t)len);

}


[[noreturn]] RA8_INTERNAL static void internal_pc_fail(uint32_t err)

{

  g_pc_err = err;

  while (1) {

    __asm__ volatile("wfi");

  }

}


RA8_INTERNAL static uint32_t internal_pc_crc32(const uint8_t* data, size_t len)

{

  uint32_t crc = (uint32_t)k_pc_crc_init;

  for (size_t i = 0U; i < len; i++) {

    crc ^= (uint32_t)data[i];

    for (uint32_t bit = 0U; bit < (uint32_t)k_pc_crc_bits; bit++) {

      const uint32_t mask = (uint32_t)(-(int32_t)(crc & 1U));

      crc                 = (crc >> 1U) ^ ((uint32_t)k_pc_crc_poly & mask);

    }

  }

  return ~crc;

}


RA8_INTERNAL static bool internal_pc_blob_equal(const uint8_t* a, const uint8_t* b, size_t len)

{

  for (size_t i = 0U; i < len; i++) {

    if (a[i] != b[i]) {

      return false;

    }

  }

  return true;

}


/* ---- SPI -> ra8_sdmmc_spi transport adapter (mirror of epub_open) ------ */


// cppcheck-suppress constParameterCallback -- The set_clock vtable fixes void* ctx.


RA8_INTERNAL static ra8_err_t internal_pc_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_pc_spi_chan, hz, pclka_hz);

}


RA8_INTERNAL static ra8_err_t internal_pc_spi_cs(void* ctx, bool asserted)

{

  (void)ctx;

  return ra8_gpio_write(s_pc_pin_cs, asserted ? k_ra8_level_low : k_ra8_level_high);

}


RA8_INTERNAL static ra8_err_t


internal_pc_spi_xfer(void* ctx, const uint8_t* tx, uint8_t* rx, uint32_t len)

{

  (void)ctx;

  return ra8_sci_spi_xfer((uint8_t)k_pc_spi_chan, tx, rx, len);

}


[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_pc_spi_pins_init(void)

{

  ra8_err_t err = ra8_pfs_route_peripheral(s_pc_pin_sck, k_ra8_psel_sci_async, "pc.sck");

  if (err != k_ra8_ok) {

    return err;

  }

  err = ra8_pfs_route_peripheral(s_pc_pin_cipo, k_ra8_psel_sci_async, "pc.cipo");

  if (err != k_ra8_ok) {

    return err;

  }

  err = ra8_pfs_route_peripheral(s_pc_pin_copi, k_ra8_psel_sci_async, "pc.copi");

  if (err != k_ra8_ok) {

    return err;

  }

  return ra8_gpio_output_init(s_pc_pin_cs, k_ra8_level_high);

}


RA8_INTERNAL static void internal_pc_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)) {

    internal_pc_fail((uint32_t)k_pc_err_init);

  }

  if (ra8_board_uart_console_init((uint32_t)k_pc_uart_baud) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_init);

  }

  if (internal_pc_spi_pins_init() != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_init);

  }

  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_pc_spi_chan, &spi_cfg) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_init);

  }

  *out_pclka_hz = pclka_hz;

}


RA8_INTERNAL static void internal_pc_init_card_or_halt(uint32_t* pclka_hz)

{

  const ra8_sdmmc_spi_transport_t transport = {.set_clock = internal_pc_spi_set_clock,

                                               .cs        = internal_pc_spi_cs,

                                               .xfer      = internal_pc_spi_xfer,

                                               .ctx       = pclka_hz};

  if (ra8_sdmmc_spi_init(&transport) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_card);

  }

}


RA8_INTERNAL static ra8_fs_mount_t* internal_pc_mount_or_halt(void)

{

  if (ra8_sdmmc_spi_bind_fs_backend(&s_backend) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_mount);

  }

  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                = "RAPCACHE";

    if ((ra8_fs_format(&s_backend, &opts) != k_ra8_ok) ||

        (ra8_fs_mount(&s_backend, &mount) != k_ra8_ok)) {

      internal_pc_fail((uint32_t)k_pc_err_mount);

    }

  }

  return mount;

}


RA8_INTERNAL static void internal_pc_font_or_halt(ra8_fs_mount_t* mount, uint32_t* out_len)

{

  ra8_fs_file_t* file = nullptr;

  if (ra8_fs_open(mount, s_pc_font_path, k_ra8_fs_mode_read, &file) != k_ra8_ok) {

    if (ra8_fs_write_file(mount,

                          s_pc_font_path,

                          g_ra8_font_literata_latin1,

                          (uint32_t)g_ra8_font_literata_latin1_len) != k_ra8_ok) {

      internal_pc_fail((uint32_t)k_pc_err_font);

    }

    if (ra8_fs_open(mount, s_pc_font_path, k_ra8_fs_mode_read, &file) != k_ra8_ok) {

      internal_pc_fail((uint32_t)k_pc_err_font);

    }

  }

  uint32_t got = 0U;

  if ((ra8_fs_read(file, s_font_buf, (uint32_t)k_pc_font_cap, &got) != k_ra8_ok) || (got == 0U)) {

    (void)ra8_fs_close(file);

    internal_pc_fail((uint32_t)k_pc_err_font);

  }

  (void)ra8_fs_close(file);

  *out_len = got;

}


RA8_INTERNAL static uint32_t


internal_pc_read_cache(ra8_fs_mount_t* mount, uint8_t* buf, uint32_t cap)

{

  ra8_fs_file_t* file = nullptr;

  if (ra8_fs_open(mount, s_pc_cache_path, k_ra8_fs_mode_read, &file) != k_ra8_ok) {

    return 0U;

  }

  uint32_t got = 0U;

  if (ra8_fs_read(file, buf, cap, &got) != k_ra8_ok) {

    got = 0U;

  }

  (void)ra8_fs_close(file);

  return got;

}


RA8_INTERNAL static bool internal_pc_engine_init(uint16_t font_px, uint32_t font_len)

{

  return reflow_init((uint16_t)k_pc_view_w,

                     (uint16_t)k_pc_view_h,

                     s_font_buf,

                     (size_t)font_len,

                     font_px,

                     (uint32_t)k_pc_ink_argb,

                     (uint32_t)k_pc_link_argb,

                     &s_engine) == k_ra8_ok;

}


RA8_INTERNAL static void internal_pc_live_layout_or_halt(uint32_t font_len, size_t* out_n)

{

  if (!internal_pc_engine_init((uint16_t)k_pc_font_px, font_len)) {

    internal_pc_fail((uint32_t)k_pc_err_layout);

  }

  uint32_t pages = 0U;

  if (reflow_layout_chapter(&s_engine,

                            (const uint8_t*)s_pc_body,

                            (size_t)(sizeof(s_pc_body) - 1U),

                            &pages) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_layout);

  }

  g_pc_pages = pages;

  size_t n   = 0U;

  if (reflow_cache_serialize(&s_engine,

                             (const uint8_t*)s_pc_body,

                             (size_t)(sizeof(s_pc_body) - 1U),

                             s_live_blob,

                             (size_t)k_pc_blob_cap,

                             &n) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_ser);

  }

  g_pc_live_crc = internal_pc_crc32(s_live_blob, n);

  *out_n        = n;

}


RA8_INTERNAL static void internal_pc_persist_and_verify_or_halt(ra8_fs_mount_t* mount, size_t n)

{

  if (ra8_fs_write_file(mount, s_pc_cache_path, s_live_blob, (uint32_t)n) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_persist);

  }

  const uint32_t got = internal_pc_read_cache(mount, s_read_blob, (uint32_t)k_pc_blob_cap);

  if (got != (uint32_t)n) {

    internal_pc_fail((uint32_t)k_pc_err_persist);

  }

  if (!internal_pc_blob_equal(s_live_blob, s_read_blob, n)) {

    internal_pc_fail((uint32_t)k_pc_err_readback);

  }

}


RA8_INTERNAL static void internal_pc_reload_check_or_halt(uint32_t font_len, size_t n)

{

  if (!internal_pc_engine_init((uint16_t)k_pc_font_px, font_len)) {

    internal_pc_fail((uint32_t)k_pc_err_layout);

  }

  if (reflow_cache_load(&s_engine,

                        (const uint8_t*)s_pc_body,

                        (size_t)(sizeof(s_pc_body) - 1U),

                        s_read_blob,

                        n) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_load);

  }

  size_t n2 = 0U;

  if (reflow_cache_serialize(&s_engine,

                             (const uint8_t*)s_pc_body,

                             (size_t)(sizeof(s_pc_body) - 1U),

                             s_reser_blob,

                             (size_t)k_pc_blob_cap,

                             &n2) != k_ra8_ok) {

    internal_pc_fail((uint32_t)k_pc_err_ser);

  }

  g_pc_cache_crc = internal_pc_crc32(s_reser_blob, n2);

  if ((n2 != n) || (g_pc_cache_crc != g_pc_live_crc)) {

    internal_pc_fail((uint32_t)k_pc_err_crc);

  }

  g_pc_crc_match = 1U;

}


RA8_INTERNAL static void internal_pc_invalidate_check_or_halt(uint32_t font_len, size_t n)

{

  if (!internal_pc_engine_init((uint16_t)k_pc_font_px_alt, font_len)) {

    internal_pc_fail((uint32_t)k_pc_err_layout);

  }

  if (reflow_cache_load(&s_engine,

                        (const uint8_t*)s_pc_body,

                        (size_t)(sizeof(s_pc_body) - 1U),

                        s_read_blob,

                        n) != k_ra8_err_invalid_state) {

    internal_pc_fail((uint32_t)k_pc_err_invalid);

  }

  g_pc_invalidate = 1U;

}


void main(void)

{

  uint32_t pclka_hz = 0U;

  internal_pc_setup_or_halt(&pclka_hz);

  ra8_isr_globals_enable();

  ra8_log_init();

  internal_pc_print(s_msg_boot, (uint32_t)sizeof(s_msg_boot) - 1U);


  internal_pc_init_card_or_halt(&pclka_hz);

  ra8_fs_mount_t* const mount = internal_pc_mount_or_halt();


  /* Reset-survival: a prior boot's persisted cache file is the hit signal. */

  g_pc_hit = (internal_pc_read_cache(mount, s_read_blob, (uint32_t)k_pc_blob_cap) != 0U) ? 1U : 0U;


  uint32_t font_len = 0U;

  internal_pc_font_or_halt(mount, &font_len);


  size_t n = 0U;

  internal_pc_live_layout_or_halt(font_len, &n);

  internal_pc_persist_and_verify_or_halt(mount, n);

  internal_pc_reload_check_or_halt(font_len, n);

  internal_pc_invalidate_check_or_halt(font_len, n);


  internal_pc_print(s_msg_pass, (uint32_t)sizeof(s_msg_pass) - 1U);

  internal_pc_print((const uint8_t*)(g_pc_hit != 0U ? "1" : "0"), 1U);

  internal_pc_print(s_msg_ok, (uint32_t)sizeof(s_msg_ok) - 1U);


  /* Idle with a heartbeat that advances ONLY here -- every failure path parks

   * in WFI without bumping it -- so a memprobe gate proves the full SD -> ra8_fs

   * -> reflow_cache round-trip + invalidation ran clean. */

  while (1) {

    ra8_delay_ms(k_pc_frame_ms);

    g_pc_heartbeat++;

  }

}


main
void main(void)
Secure fallback main entry point.
Definition main.c:37

s_backend
static ra8_fs_backend_t s_backend
SD backend; file-scope so the mount handle may reference it.
Definition main.c:138

internal_pc_spi_pins_init
static ra8_err_t internal_pc_spi_pins_init(void)
Route Pmod2 SPI signals and initialize chip select high.
Definition main.c:415

pc_err_t
pc_err_t
Failure-stage codes stamped to g_pc_err for SWD / --dump-sym.
Definition main.c:155

k_pc_err_none
@ k_pc_err_none
No failure (success path).
Definition main.c:156

k_pc_err_crc
@ k_pc_err_crc
Reloaded layout CRC != live CRC.
Definition main.c:166

k_pc_err_persist
@ k_pc_err_persist
Write / read-back the blob on SD.
Definition main.c:163

k_pc_err_init
@ k_pc_err_init
CGC / time / console / SPI bring-up.
Definition main.c:157

k_pc_err_ser
@ k_pc_err_ser
reflow_cache_serialize.
Definition main.c:162

k_pc_err_font
@ k_pc_err_font
Provision / read FONT.OTF.
Definition main.c:160

k_pc_err_load
@ k_pc_err_load
reflow_cache_load (expected hit).
Definition main.c:165

k_pc_err_layout
@ k_pc_err_layout
reflow_init / layout_chapter.
Definition main.c:161

k_pc_err_mount
@ k_pc_err_mount
Mount (and format-if-blank).
Definition main.c:159

k_pc_err_readback
@ k_pc_err_readback
Read-back blob != written blob.
Definition main.c:164

k_pc_err_card
@ k_pc_err_card
SD card SPI init.
Definition main.c:158

k_pc_err_invalid
@ k_pc_err_invalid
Alt-size load did not invalidate.
Definition main.c:167

s_engine
static reflow_t s_engine
Reflow engine (glyph / page / token / text pools live inside).
Definition main.c:199

internal_pc_mount_or_halt
static ra8_fs_mount_t * internal_pc_mount_or_halt(void)
Bind and mount the SD filesystem, formatting blank media if needed.
Definition main.c:506

s_pc_pin_copi
static const ra8_port_pin_t s_pc_pin_copi
Pmod2 controller-output/peripheral-input pin.
Definition main.c:110

s_pc_cache_path
static const char s_pc_cache_path[]
Root-directory 8.3 name for the serialized pagination cache.
Definition main.c:137

g_pc_crc_match
volatile uint32_t g_pc_crc_match
1 if the reloaded-cache blob CRC equals the live-layout blob CRC.
Definition main.c:182

g_pc_invalidate
volatile uint32_t g_pc_invalidate
1 if loading the blob at the alt font size returned invalid_state.
Definition main.c:184

s_font_buf
static uint8_t s_font_buf[k_pc_font_cap]
Font blob read off the card.
Definition main.c:197

s_msg_boot
static const uint8_t s_msg_boot[]
Console marker emitted after core and peripheral setup.
Definition main.c:216

s_live_blob
static uint8_t s_live_blob[k_pc_blob_cap]
Serialised cache blob from the live layout.
Definition main.c:201

internal_pc_spi_cs
static ra8_err_t internal_pc_spi_cs(void *ctx, bool asserted)
Drive the SD-card active-low chip-select GPIO.
Definition main.c:370

s_msg_ok
static const uint8_t s_msg_ok[]
Final cache-CRC and invalidation success suffix.
Definition main.c:234

g_pc_live_crc
volatile uint32_t g_pc_live_crc
CRC-32 of the live-layout serialised blob.
Definition main.c:188

internal_pc_read_cache
static uint32_t internal_pc_read_cache(ra8_fs_mount_t *mount, uint8_t *buf, uint32_t cap)
Read the persisted cache file into a bounded caller buffer.
Definition main.c:578

g_pc_heartbeat
volatile uint32_t g_pc_heartbeat
Idle heartbeat; advances ONLY after every assertion passes.
Definition main.c:192

s_pc_pin_sck
static const ra8_port_pin_t s_pc_pin_sck
Pmod2 SCI clock pin used by the SD-card transport.
Definition main.c:92

pc_consts_t
pc_consts_t
Console / SPI / reflow knobs (no magic numbers).
Definition main.c:68

k_pc_blob_cap
@ k_pc_blob_cap
Cache-blob buffer capacity, bytes.
Definition main.c:73

k_pc_font_cap
@ k_pc_font_cap
Font read buffer (OTF is ~57 KiB; trimmed from 128 KiB when the fs sector arena grew ....
Definition main.c:71

k_pc_uart_baud
@ k_pc_uart_baud
Console baud.
Definition main.c:69

k_pc_link_argb
@ k_pc_link_argb
Anchor text colour.
Definition main.c:79

k_pc_spi_chan
@ k_pc_spi_chan
Pmod2 / J25 SCI0 Simple-SPI.
Definition main.c:70

k_pc_view_w
@ k_pc_view_w
Reflow viewport width, px.
Definition main.c:74

k_pc_ink_argb
@ k_pc_ink_argb
Body text colour.
Definition main.c:78

k_pc_crc_poly
@ k_pc_crc_poly
CRC-32 reflected polynomial.
Definition main.c:81

k_pc_font_px
@ k_pc_font_px
Body font size, px (round-trip key).
Definition main.c:76

k_pc_font_px_alt
@ k_pc_font_px_alt
Alt font size to force invalidation.
Definition main.c:77

k_pc_crc_init
@ k_pc_crc_init
CRC-32 initial value.
Definition main.c:80

k_pc_view_h
@ k_pc_view_h
Reflow viewport height, px.
Definition main.c:75

k_pc_crc_bits
@ k_pc_crc_bits
Bits folded per byte.
Definition main.c:82

pc_pace_t
pc_pace_t
Idle-loop pacing for the success heartbeat.
Definition main.c:171

k_pc_frame_ms
@ k_pc_frame_ms
Heartbeat period in milliseconds.
Definition main.c:172

internal_pc_fail
static void internal_pc_fail(uint32_t err)
Stamp the failure stage and park the CPU without a heartbeat.
Definition main.c:266

internal_pc_spi_xfer
static ra8_err_t internal_pc_spi_xfer(void *ctx, const uint8_t *tx, uint8_t *rx, uint32_t len)
Exchange an SD-card byte span through SCI SPI.
Definition main.c:395

internal_pc_blob_equal
static bool internal_pc_blob_equal(const uint8_t *a, const uint8_t *b, size_t len)
Compare two equal-length cache-blob spans.
Definition main.c:319

internal_pc_print
static void internal_pc_print(const uint8_t *msg, uint32_t len)
Emit a byte run on the board console.
Definition main.c:249

internal_pc_crc32
static uint32_t internal_pc_crc32(const uint8_t *data, size_t len)
Calculate reflected CRC-32 over a byte span.
Definition main.c:289

internal_pc_engine_init
static bool internal_pc_engine_init(uint16_t font_px, uint32_t font_len)
Initialise the engine at font_px over the SD font.
Definition main.c:608

s_msg_pass
static const uint8_t s_msg_pass[]
Prefix for the final reset-survival hit diagnostic.
Definition main.c:225

s_read_blob
static uint8_t s_read_blob[k_pc_blob_cap]
Blob read back off SD (compared to s_live_blob).
Definition main.c:203

internal_pc_spi_set_clock
static ra8_err_t internal_pc_spi_set_clock(void *ctx, uint32_t hz)
Apply an SD-card SPI clock through the SCI transport.
Definition main.c:348

s_reser_blob
static uint8_t s_reser_blob[k_pc_blob_cap]
Blob re-serialised from the reloaded engine (CRC vs live).
Definition main.c:205

internal_pc_reload_check_or_halt
static void internal_pc_reload_check_or_halt(uint32_t font_len, size_t n)
Load the read-back blob into a fresh same-size engine and CRC it.
Definition main.c:699

s_pc_font_path
static const char s_pc_font_path[]
Root-directory 8.3 name for the persisted font.
Definition main.c:128

internal_pc_font_or_halt
static void internal_pc_font_or_halt(ra8_fs_mount_t *mount, uint32_t *out_len)
Provision FONT.OTF if absent, then read it into s_font_buf.
Definition main.c:537

internal_pc_setup_or_halt
static void internal_pc_setup_or_halt(uint32_t *out_pclka_hz)
Bring up clocks, timekeeping, console, and the SD SPI controller.
Definition main.c:444

internal_pc_init_card_or_halt
static void internal_pc_init_card_or_halt(uint32_t *pclka_hz)
Initialize the SD card over the configured SPI transport.
Definition main.c:482

s_pc_pin_cipo
static const ra8_port_pin_t s_pc_pin_cipo
Pmod2 controller-input/peripheral-output pin.
Definition main.c:101

s_pc_body
static const char s_pc_body[]
Fixed HTML chapter used by the live and cached layout passes.
Definition main.c:147

internal_pc_invalidate_check_or_halt
static void internal_pc_invalidate_check_or_halt(uint32_t font_len, size_t n)
Verify that a font-size change invalidates the persisted cache.
Definition main.c:740

g_pc_err
volatile uint32_t g_pc_err
First failing stage (pc_err_t), 0 on success.
Definition main.c:178

s_pc_pin_cs
static const ra8_port_pin_t s_pc_pin_cs
GPIO-driven active-low SD-card chip-select pin.
Definition main.c:119

internal_pc_live_layout_or_halt
static void internal_pc_live_layout_or_halt(uint32_t font_len, size_t *out_n)
Lay out the chapter live and serialise it into s_live_blob.
Definition main.c:633

internal_pc_persist_and_verify_or_halt
static void internal_pc_persist_and_verify_or_halt(ra8_fs_mount_t *mount, size_t n)
Persist the live cache blob and verify an exact read-back.
Definition main.c:672

g_pc_cache_crc
volatile uint32_t g_pc_cache_crc
CRC-32 of the reloaded-then-reserialised blob.
Definition main.c:190

g_pc_hit
volatile uint32_t g_pc_hit
1 if the cache file existed at boot (reset-survival hit).
Definition main.c:180

g_pc_pages
volatile uint32_t g_pc_pages
Page count produced by the live layout.
Definition main.c:186

literata_latin1.h
Declaration of the Latin-1 Literata font baked into internal flash.

g_ra8_font_literata_latin1_len
const unsigned int g_ra8_font_literata_latin1_len
Length of g_ra8_font_literata_latin1 in bytes.

g_ra8_font_literata_latin1
const unsigned char g_ra8_font_literata_latin1[]
Baked Latin-1 subset of Literata Regular (TrueType/glyf), in flash.

ra8_attributes.h
Annotation-attribute framework macros for ra8-firmware.

RA8_INTERNAL
#define RA8_INTERNAL
Marker that a function is intended to be static (file-local).
Definition ra8_attributes.h:190

ra8_board_ek_ra8d2.h
Board-support layer for the Renesas EK-RA8D2 v1 evaluation kit.

k_ra8_board_pmod2_spi_cipo
@ k_ra8_board_pmod2_spi_cipo
Pmod2.3 CIPO (CIPO0_B), P602.
Definition ra8_board_ek_ra8d2_connectors.h:681

k_ra8_board_pmod2_spi_cs
@ k_ra8_board_pmod2_spi_cs
Pmod2.1 CS (SS0_B), P604.
Definition ra8_board_ek_ra8d2_connectors.h:676

k_ra8_board_pmod2_spi_copi
@ k_ra8_board_pmod2_spi_copi
Pmod2.2 COPI (COPI0_B), P603.
Definition ra8_board_ek_ra8d2_connectors.h:678

k_ra8_board_pmod2_spi_sck
@ k_ra8_board_pmod2_spi_sck
Pmod2.4 SCK (SCK0_B), P601.
Definition ra8_board_ek_ra8d2_connectors.h:684

ra8_board_uart_console_write
ra8_err_t ra8_board_uart_console_write(const uint8_t *data, size_t len)
Polled blocking write to the J-Link OB VCOM console.
Definition ra8_board_ek_ra8d2_comms.c:294

ra8_board_uart_console_init
ra8_err_t ra8_board_uart_console_init(uint32_t baud)
Configure SCI8 + PD02/PD03 as the debug-console UART.
Definition ra8_board_ek_ra8d2_comms.c:240

ra8_boot_entry.h
Boot entry points shared between a vector table and its startup code.

ra8_cgc.h
High-level Clock Generation Circuit driver.

ra8_cgc_get_clock_hz
ra8_err_t ra8_cgc_get_clock_hz(ra8_clock_id_t id, uint32_t *out_hz)
Query the current frequency of a clock-tree domain.
Definition ra8_cgc.c:132

k_ra8_clock_id_cpuclk0
@ k_ra8_clock_id_cpuclk0
Cortex-M85 CPUCLK0.
Definition ra8_cgc.h:70

k_ra8_clock_id_pclka
@ k_ra8_clock_id_pclka
PCLKA.
Definition ra8_cgc.h:73

ra8_cgc_init
ra8_err_t ra8_cgc_init(void)
Configure the clock tree to a safe default.
Definition ra8_cgc.c:727

ra8_err.h
Error Code Definitions for ra8-firmware.

k_ra8_err_invalid_state
@ k_ra8_err_invalid_state
Module in wrong state for requested operation.
Definition ra8_err.h:161

k_ra8_ok
@ k_ra8_ok
Success – operation completed with all postconditions satisfied.
Definition ra8_err.h:119

ra8_err_t
ra8_err_codes_t ra8_err_t
Canonical error-return type used by every ra8-firmware API.
Definition ra8_err.h:546

ra8_fs.h
Minimal FAT12/FAT16/FAT32 filesystem adapter (read + write).

ra8_fs_format
ra8_err_t ra8_fs_format(const ra8_fs_backend_t *backend, const ra8_fs_format_opts_t *opts)
Format a block device as a fresh, empty FAT12/FAT16/FAT32/exFAT volume.
Definition ra8_fs_fat_mount.c:744

ra8_fs_mount
ra8_err_t ra8_fs_mount(const ra8_fs_backend_t *backend, ra8_fs_mount_t **out_handle)
Mount a FAT volume from a block-device backend, auto-selecting the first partition.
Definition ra8_fs_fat_mount.c:762

ra8_fs_read
ra8_err_t ra8_fs_read(ra8_fs_file_t *file, uint8_t *buf, uint32_t max_len, uint32_t *got_len)
Read up to max_len bytes; advance the cluster chain on cluster crossings.
Definition ra8_fs_fat_fileio.c:758

ra8_fs_open
ra8_err_t ra8_fs_open(ra8_fs_mount_t *handle, const char *path, ra8_fs_mode_t mode, ra8_fs_file_t **out_file)
Open or create a file by path, 8.3 or long.
Definition ra8_fs_fat_file.c:569

ra8_fs_close
ra8_err_t ra8_fs_close(ra8_fs_file_t *file)
Close an open file, stamping its final modification time.
Definition ra8_fs_fat_file.c:578

ra8_fs_write_file
ra8_err_t ra8_fs_write_file(ra8_fs_mount_t *handle, const char *path, const uint8_t *data, uint32_t len)
Create a whole file in one call (provisioning helper).
Definition ra8_fs_fat_fileio.c:777

k_ra8_fs_type_fat32
@ k_ra8_fs_type_fat32
count_of_clusters >= 65525.
Definition ra8_fs_types.h:119

k_ra8_fs_mode_read
@ k_ra8_fs_mode_read
Read-only, must exist.
Definition ra8_fs_types.h:92

k_ra8_psel_sci_async
@ k_ra8_psel_sci_async
00100b: SCI async serial (UART).
Definition ra8_gpio_constants.h:56

ra8_isr.h
NVIC + ICU IELSR allocator.

ra8_isr_globals_enable
void ra8_isr_globals_enable(void)
Globally enable maskable interrupts (PRIMASK = 0).
Definition ra8_isr.c:439

ra8_log.h
Lightweight Logging Interface for ra8-firmware.

ra8_log_init
void ra8_log_init(void)
Initialise the logging backend.
Definition ra8_log.c:379

ra8_port_pin_t
ra8_port_pin_t
Packed (port << 8) | pin pin identifier.
Definition ra8_port_constants.h:147

k_ra8_level_high
@ k_ra8_level_high
Drive or read 1.
Definition ra8_port_constants.h:196

k_ra8_level_low
@ k_ra8_level_low
Drive or read 0.
Definition ra8_port_constants.h:195

ra8_port_utils.h
High-level GPIO helpers on top of the PORT + PFS register layer.

ra8_gpio_output_init
ra8_err_t ra8_gpio_output_init(ra8_port_pin_t pin, ra8_level_t init_level)
Configure a pin as a digital output and drive it to an initial level.
Definition gpio.c:88

ra8_gpio_write
ra8_err_t ra8_gpio_write(ra8_port_pin_t pin, ra8_level_t level)
Drive a previously-configured output to the given level.
Definition gpio.c:154

ra8_pfs_route_peripheral
ra8_err_t ra8_pfs_route_peripheral(ra8_port_pin_t pin, ra8_psel_t psel, const char *owner)
Route a pin to a non-IRQ peripheral function via PFS.PSEL.
Definition gpio.c:238

ra8_sci_spi.h
SCI Simple-SPI controller-mode driver (polling, full-duplex).

ra8_sci_spi_set_clock
ra8_err_t ra8_sci_spi_set_clock(uint8_t channel, uint32_t baud_hz, uint32_t pclk_hz)
Re-program the bit-rate without otherwise reconfiguring.
Definition ra8_sci_spi.c:230

ra8_sci_spi_xfer
ra8_err_t ra8_sci_spi_xfer(uint8_t channel, const uint8_t *tx, uint8_t *rx, uint32_t len)
Full-duplex multi-byte transfer.
Definition ra8_sci_spi.c:281

ra8_sci_spi_init
ra8_err_t ra8_sci_spi_init(uint8_t channel, const ra8_sci_spi_cfg_t *cfg)
Bring an SCI channel up as a Simple-SPI controller.
Definition ra8_sci_spi.c:185

ra8_sdmmc_spi.h
SD card driver in SPI-mode (PMOD-attached cards).

k_ra8_sdmmc_spi_clock_init_hz
@ k_ra8_sdmmc_spi_clock_init_hz
Mandatory init clock floor.
Definition ra8_sdmmc_spi.h:90

ra8_sdmmc_spi_init
ra8_err_t ra8_sdmmc_spi_init(const ra8_sdmmc_spi_transport_t *transport)
Run the SD SPI-mode identification sequence on a card.
Definition ra8_sdmmc_spi_io.c:266

ra8_sdmmc_spi_bind_fs_backend
ra8_err_t ra8_sdmmc_spi_bind_fs_backend(ra8_fs_backend_t *out_backend)
Populate an ra8_fs_backend_t that mounts onto this SD driver.
Definition ra8_sdmmc_spi_io.c:767

ra8_spi.h
SPI_B controller driver (RA8D2 Type-B SPI peripheral).

k_ra8_spi_mode_0
@ k_ra8_spi_mode_0
CPOL=0, CPHA=0.
Definition ra8_spi.h:62

ra8_time.h
SysTick-based tick counter, delay and timestamp helpers.

ra8_time_init
ra8_err_t ra8_time_init(uint32_t cpu_hz)
Initialise SysTick for a 1 kHz tick interrupt.
Definition ra8_time.c:59

ra8_delay_ms
void ra8_delay_ms(uint32_t ms)
Busy-wait for at least ms milliseconds.
Definition ra8_time.c:129

reflow.h
HTML / CSS reflow + paginate engine for the ra8d2 ereader.

reflow_layout_chapter
ra8_err_t reflow_layout_chapter(reflow_t *engine, const uint8_t *xhtml_buf, size_t xhtml_len, uint32_t *out_total_pages)
Parse + lay out one chapter of XHTML.
Definition reflow_layout_driver.c:233

reflow_init
ra8_err_t reflow_init(uint16_t viewport_w, uint16_t viewport_h, const uint8_t *font_data, size_t font_len, uint16_t font_px, uint32_t body_color, uint32_t link_color, reflow_t *out_engine)
Initialise a reflow engine for a given viewport / font.
Definition reflow_layout_driver.c:149

reflow_cache.h
Import-time pagination cache for reflow (#79).

reflow_cache_serialize
ra8_err_t reflow_cache_serialize(const reflow_t *engine, const uint8_t *content, size_t content_len, uint8_t *out_buf, size_t out_cap, size_t *out_len)
Serialise the laid-out pages of engine into a keyed byte blob.
Definition reflow_cache.c:679

reflow_cache_load
ra8_err_t reflow_cache_load(reflow_t *engine, const uint8_t *content, size_t content_len, const uint8_t *buf, size_t len)
Validate a cache blob and, if it matches, restore the layout.
Definition reflow_cache.c:716

ra8_fs_backend_t
Block-device interface that ra8_fs runs on top of.
Definition ra8_fs_types.h:149

ra8_fs_file_t
Open-file state.
Definition ra8_fs_types.h:304

ra8_fs_format_opts_t
Tunables for ra8_fs_format() (the on-disk geometry of a fresh volume).
Definition ra8_fs_types.h:224

ra8_fs_format_opts_t::type
ra8_fs_type_t type
FAT variant to lay down (12/16/32).
Definition ra8_fs_types.h:225

ra8_fs_format_opts_t::label
const char * label
0..11 char volume label, or NULL.
Definition ra8_fs_types.h:226

ra8_fs_mount_t
Cached parse of one mounted FAT volume.
Definition ra8_fs_types.h:244

ra8_sci_spi_cfg_t
Configuration descriptor for ra8_sci_spi_init.
Definition ra8_sci_spi.h:49

ra8_sdmmc_spi_transport_t
Driver-to-bus binding (Dependency Inversion seam).
Definition ra8_sdmmc_spi.h:165

reflow_t
Reflow / pagination engine state.
Definition reflow_types.h:448