cpu1_main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "book.h"
#include "compile_on_m33.h"
#include "epub.h"
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_ipc.h"
#include "ra8_rabook_pipeline.h"
#include "rabook_compile.h"

extern uint32_t g_ra8_ls_cpu1_stack_top;
extern uint32_t g_ra8_ls_cpu1_data_start;
extern uint32_t g_ra8_ls_cpu1_data_end;
extern uint32_t g_ra8_ls_cpu1_data_load;
extern uint32_t g_ra8_ls_cpu1_bss_start;
extern uint32_t g_ra8_ls_cpu1_bss_end;
 
[[noreturn]] void cpu1_reset_handler(void);

typedef enum : uint32_t {
  k_arena_chapters = 8U,          
  k_arena_nodes    = 256U,        
  k_arena_attrs    = 64U,         
  k_arena_styles   = 4U,          
  k_arena_images   = 8U,          
  k_arena_string   = 8U * 1024U,  
  k_arena_imgpool  = 64U * 1024U, 
  k_arena_xhtml    = 16U * 1024U, 
  k_arena_imgraw   = 16U * 1024U, 
  k_arena_css      = 16U * 1024U, 
} m33_arena_cap_t;
 
/* The full compile working set lives in external SDRAM (.sdram_bss, NOLOAD):
 * epub_book_t alone is ~65 KiB and the builder/scratch arenas push well past
 * the 64 KiB SRAM_CPU1. The M85 brings up the SDRAM controller before releasing
 * the M33. NOLOAD needs no startup zeroing -- the builder appends into its
 * arenas before reading, the EPUB scratch is filled before each read, and
 * s_book is memset in compile_fixture before epub_open. The finalized blob
 * goes to the shared SRAM2 output buffer (com33_blob), not here. */
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static epub_book_t    s_book;
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static book_chapter_t s_chapters[k_arena_chapters];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static book_node_t    s_nodes[k_arena_nodes];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static book_attr_t    s_attrs[k_arena_attrs];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static book_stylesheet_t s_styles[k_arena_styles];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static book_image_t      s_images[k_arena_images];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static char    s_string_pool[k_arena_string];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static uint8_t s_image_pool[k_arena_imgpool];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static uint8_t s_xhtml[k_arena_xhtml];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static ra8_rabook_xml_workspace_t s_xml_workspace;
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static uint8_t s_image_raw[k_arena_imgraw];
[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static char    s_css[k_arena_css];

static bool bind_compile(ra8_rabook_buffers_t* buf, ra8_rabook_pipeline_scratch_t* scr)
{
  if (buf == nullptr) {
    return false;
  }
  if (scr == nullptr) {
    return false;
  }
  uint8_t* out = com33_blob();
  if (out == nullptr) {
    return false;
  }
  *buf = (ra8_rabook_buffers_t){
    .chapters       = s_chapters,
    .nodes          = s_nodes,
    .attrs          = s_attrs,
    .stylesheets    = s_styles,
    .images         = s_images,
    .string_pool    = s_string_pool,
    .image_pool     = s_image_pool,
    .out            = out,
    .chapter_cap    = (uint32_t)k_arena_chapters,
    .node_cap       = (uint32_t)k_arena_nodes,
    .attr_cap       = (uint32_t)k_arena_attrs,
    .stylesheet_cap = (uint32_t)k_arena_styles,
    .image_cap      = (uint32_t)k_arena_images,
    .string_cap     = (uint32_t)k_arena_string,
    .image_pool_cap = (uint32_t)k_arena_imgpool,
    .out_cap        = (uint32_t)k_com33_blob_cap,
  };
  *scr = (ra8_rabook_pipeline_scratch_t){
    .xhtml         = s_xhtml,
    .xhtml_cap     = sizeof(s_xhtml),
    .image_raw     = s_image_raw,
    .image_cap     = sizeof(s_image_raw),
    .img_arena     = nullptr,
    .gray          = nullptr,
    .gray_cap      = 0U,
    .css           = s_css,
    .css_cap       = sizeof(s_css),
    .xml_workspace = &s_xml_workspace,
  };
  return true;
}

static bool compile_fixture(const void** out_blob, uint32_t* out_len)
{
  if (out_blob == nullptr) {
    return false;
  }
  if (out_len == nullptr) {
    return false;
  }
  /* The M85 staged the source .epub into shared SRAM and posted its base/len in
   * the request; the M33 compiles whatever was staged (not a baked-in fixture),
   * so the same image serves any book the M85 dispatches. */
  const volatile com33_mailbox_t* mb = com33_mailbox();
  memset(&s_book, 0, sizeof(s_book));
  const epub_mem_media_t media = {
    .data = (const uint8_t*)(uintptr_t)mb->epub_base,
    .size = (size_t)mb->epub_len,
  };
  if (epub_open(&media, "rabook.epub", &s_book) != k_ra8_ok) {
    return false;
  }
 
  ra8_rabook_buffers_t          buf = {};
  ra8_rabook_pipeline_scratch_t scr = {};
  if (!bind_compile(&buf, &scr)) {
    (void)epub_close(&s_book);
    return false;
  }
 
  const ra8_err_t rc = rabook_compile_from_epub_to_buffer(&s_book, &buf, &scr, out_blob, out_len);
  (void)epub_close(&s_book);
  return rc == k_ra8_ok;
}

static void publish_result(volatile com33_mailbox_t* mb, const void* blob, uint32_t len, bool ok)
{
  if (mb == nullptr) {
    return;
  }
  bool good = ok;
  if (blob == nullptr) {
    good = false;
  }
  if (len == 0U) {
    good = false;
  }
  if (good) {
    const book_header_t* hdr = book_header(blob);
    mb->blob_base            = (uint32_t)(uintptr_t)blob;
    mb->blob_len             = len;
    mb->blob_crc             = hdr->crc32_val;
    mb->chapter_count        = hdr->chapter_count;
    __asm volatile("dsb" ::: "memory");
    mb->status = (uint32_t)k_com33_status_ok;
  } else {
    mb->status = (uint32_t)k_com33_status_build_fail;
  }
  __asm volatile("dsb" ::: "memory");
  mb->done = 1U;
}

[[noreturn]] static void cpu1_park(void)
{
  while (1) {
    __asm volatile("nop");
  }
}

typedef enum : uint8_t {
  k_cpu1_ipc_wake_channel = 0U, 
} cpu1_ipc_t;

static void notify_m85(void)
{
  (void)ra8_ipc_send_event((uint8_t)k_cpu1_ipc_wake_channel, k_ra8_ipc_irq_event_0);
}

[[noreturn]] static void cpu1_run_compile(void)
{
  volatile com33_mailbox_t* mb = com33_mailbox();
  mb->m33_sig                  = (uint32_t)k_com33_m33_sig;
  __asm volatile("dsb" ::: "memory");
 
  /* The M85 stages the .epub + buffers and posts req_magic BEFORE releasing this
   * core, so the job is ready on the first read; the dmb orders that read after
   * observing the boot handshake. A missing request is reported, not compiled. */
  __asm volatile("dmb" ::: "memory");
  if (mb->req_magic != (uint32_t)k_com33_req_magic) {
    mb->status = (uint32_t)k_com33_status_no_request;
    __asm volatile("dsb" ::: "memory");
    mb->done = 1U;
    __asm volatile("dsb" ::: "memory");
    notify_m85();
    cpu1_park();
  }
 
  const void* blob = nullptr;
  uint32_t    len  = 0U;
  const bool  ok   = compile_fixture(&blob, &len);
 
  publish_result(mb, blob, len, ok);
  notify_m85();
  cpu1_park();
}

[[noreturn]] void cpu1_reset_handler(void)
{
  uint32_t* dst = &g_ra8_ls_cpu1_data_start;
  uint32_t* src = &g_ra8_ls_cpu1_data_load;
  RA8_LOOP_BOUND_RUNTIME(g_ra8_ls_cpu1_data_end);
  while (dst < &g_ra8_ls_cpu1_data_end) {
    *dst = *src;
    dst++;
    src++;
  }
 
  uint32_t* bss = &g_ra8_ls_cpu1_bss_start;
  RA8_LOOP_BOUND_RUNTIME(g_ra8_ls_cpu1_bss_end);
  while (bss < &g_ra8_ls_cpu1_bss_end) {
    *bss = 0U;
    bss++;
  }
 
  cpu1_run_compile();
}

[[noreturn]] static void cpu1_fault_handler(void)
{
  volatile com33_mailbox_t* mb = com33_mailbox();
  mb->status                   = (uint32_t)k_com33_status_fault;
  __asm volatile("dsb" ::: "memory");
  mb->done = 1U;
  __asm volatile("dsb" ::: "memory");
  notify_m85();
  while (1) {
    __asm volatile("nop");
  }
}

#ifndef RA8_OFF_TARGET
/* The vector table is only meaningful in the cross-compiled M33 image. The host
 * unit-test build compile-checks this TU but never links it as an executable, so
 * dropping the table there costs no coverage. */
[[gnu::used, gnu::section(".cpu1_vectors")]] const uintptr_t g_cpu1_vector_table[] = {
  (uintptr_t)&g_ra8_ls_cpu1_stack_top,
  (uintptr_t)&cpu1_reset_handler,
  (uintptr_t)&cpu1_fault_handler,
  (uintptr_t)&cpu1_fault_handler,
  (uintptr_t)&cpu1_fault_handler,
  (uintptr_t)&cpu1_fault_handler,
  (uintptr_t)&cpu1_fault_handler,
  (uintptr_t)&cpu1_fault_handler,
};
#endif