cpu1_main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "book.h"
#include "ereader_m33.h"
#include "ra8_attributes.h"
#include "ra8_gfx.h"
#include "ra8_ipc.h"
#include "rabook_fixture.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);
 
/* The published format tag must equal the real ra8_gfx RGB565 enumerator. */
static_assert((uint32_t)k_erm33_fb_format_rgb565 == (uint32_t)k_ra8_gfx_format_rgb565,
              "published fb_format must equal ra8_gfx RGB565");
/* The geometry the mailbox advertises must match the baked plane size. */
static_assert((uint32_t)k_erm33_fb_bytes ==
                ((uint32_t)k_erm33_fb_width * (uint32_t)k_erm33_fb_height *
                 (uint32_t)k_erm33_fb_bpp),
              "framebuffer byte size must equal width*height*bpp");

[[gnu::section(".sdram_bss"), gnu::aligned(8)]] static uint8_t s_framebuffer[k_erm33_fb_bytes];

typedef enum : uint32_t {
  k_walk_iter_max = 4096U, 
  k_max_run_len   = 1024U, 
} m33_walk_bound_t;

typedef enum : uint16_t {
  k_walk_stack_depth = 64U,   
  k_max_chapters     = 32U,   
  k_max_nodes        = 4096U, 
  k_magic_len        = 7U,    
} m33_walk_size_t;

typedef enum : uint32_t {
  k_erm33_glyph_h = 16U,       
  k_erm33_paper   = 0xFFFFFFU, 
  k_erm33_ink     = 0x000000U, 
} m33_render_t;

typedef enum : uint32_t {
  k_crc32_init = 0xFFFFFFFFU, 
  k_crc32_poly = 0xEDB88320U, 
} m33_crc_t;

typedef enum : uint8_t {
  k_crc32_bits = 8U, 
} m33_crc_bits_t;

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

typedef enum : uint32_t {
  k_m33_ack_budget = 50000000UL, 
} m33_cycle_bound_t;

static void append_run(char* out, uint32_t* plen, uint32_t cap, const char* txt)
{
  if (out == nullptr) {
    return;
  }
  if (plen == nullptr) {
    return;
  }
  if (txt == nullptr) {
    return;
  }
  RA8_LOOP_BOUND(k_max_run_len);
  for (uint32_t i = 0U; i < (uint32_t)k_max_run_len; i++) {
    const char c = txt[i];
    if (c == '\0') {
      break;
    }
    if (*plen >= cap) {
      break;
    }
    out[*plen] = c;
    *plen += 1U;
  }
}

typedef struct {
  uint32_t items[k_walk_stack_depth]; 
  uint32_t sp;                        
} m33_walk_stack_t;

static void walk_push(m33_walk_stack_t* st, uint32_t node)
{
  if (st == nullptr) {
    return;
  }
  if (node == (uint32_t)k_book_nil) {
    return;
  }
  if (st->sp < (uint32_t)k_walk_stack_depth) {
    st->items[st->sp] = node;
    st->sp += 1U;
  }
}

static uint32_t
collect_chapter_text(const void* base, uint32_t root, uint32_t node_count, char* out, uint32_t cap)
{
  if (base == nullptr) {
    return 0U;
  }
  if (out == nullptr) {
    return 0U;
  }
  if (root == (uint32_t)k_book_nil) {
    return 0U;
  }
  const book_node_t* nodes = book_nodes(base);
  m33_walk_stack_t   st    = {};
  uint32_t           len   = 0U;
  if (root != (uint32_t)k_book_nil) {
    walk_push(&st, nodes[root].first_child);
  }
  RA8_LOOP_BOUND(k_walk_iter_max);
  for (uint32_t it = 0U; it < (uint32_t)k_walk_iter_max; it++) {
    if ((st.sp == 0U) || (len >= cap)) {
      break;
    }
    const uint32_t n = st.items[--st.sp];
    if (n >= node_count) {
      continue;
    }
    const book_node_t* node = &nodes[n];
    walk_push(&st, node->next_sibling);
    if (node->kind == (uint8_t)k_book_node_text) {
      append_run(out, &len, cap, book_node_text(base, node));
    } else {
      walk_push(&st, node->first_child);
    }
  }
  return len;
}

static bool render_page(uint8_t* fb, const char* text, uint32_t len)
{
  if (fb == nullptr) {
    return false;
  }
  if (text == nullptr) {
    return false;
  }
  if (ra8_gfx_init(fb,
                   (uint16_t)k_erm33_fb_width,
                   (uint16_t)k_erm33_fb_height,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    return false;
  }
  if (ra8_gfx_clear((uint32_t)k_erm33_paper) != k_ra8_ok) {
    return false;
  }
  RA8_LOOP_BOUND(k_erm33_fb_rows);
  for (uint32_t row = 0U; row < (uint32_t)k_erm33_fb_rows; row++) {
    char     line[(uint32_t)k_erm33_fb_cols + 1U];
    uint32_t cols = 0U;
    RA8_LOOP_BOUND(k_erm33_fb_cols);
    for (uint32_t col = 0U; col < (uint32_t)k_erm33_fb_cols; col++) {
      const uint32_t idx = (row * (uint32_t)k_erm33_fb_cols) + col;
      if (idx >= len) {
        break;
      }
      line[cols] = text[idx];
      cols += 1U;
    }
    line[cols] = '\0';
    if (cols == 0U) {
      continue;
    }
    const int32_t y = (int32_t)(row * (uint32_t)k_erm33_glyph_h);
    if (ra8_gfx_text_out(0,
                         y,
                         line,
                         &ra8_gfx_font_8x16,
                         (uint32_t)k_erm33_ink,
                         (uint32_t)k_erm33_paper) != k_ra8_ok) {
      return false;
    }
  }
  return true;
}

static uint32_t fb_crc32(const uint8_t* fb, uint32_t len)
{
  if (fb == nullptr) {
    return 0U;
  }
  if (len == 0U) {
    return 0U;
  }
  uint32_t crc = (uint32_t)k_crc32_init;
  RA8_LOOP_BOUND(k_erm33_fb_bytes);
  for (uint32_t i = 0U; i < len; i++) {
    if (i >= (uint32_t)k_erm33_fb_bytes) {
      break;
    }
    crc ^= (uint32_t)fb[i];
    RA8_LOOP_BOUND(k_crc32_bits);
    for (uint8_t b = 0U; b < (uint8_t)k_crc32_bits; b++) {
      const uint32_t mask = (uint32_t)(0U - (crc & 1U));
      crc                 = (crc >> 1U) ^ ((uint32_t)k_crc32_poly & mask);
    }
  }
  return crc ^ (uint32_t)k_crc32_init;
}

static void publish_page(volatile erm33_mailbox_t* mb, uint32_t crc, uint32_t glyphs)
{
  if (mb == nullptr) {
    return;
  }
  mb->fb_base     = (uint32_t)(uintptr_t)s_framebuffer;
  mb->fb_width    = (uint32_t)k_erm33_fb_width;
  mb->fb_height   = (uint32_t)k_erm33_fb_height;
  mb->fb_stride   = (uint32_t)k_erm33_fb_stride;
  mb->fb_format   = (uint32_t)k_erm33_fb_format_rgb565;
  mb->glyph_count = glyphs;
  mb->fb_crc      = crc;
  __asm volatile("dsb" ::: "memory");
}

static bool book_is_valid(const void* base, uint32_t size)
{
  if (base == nullptr) {
    return false;
  }
  if (size < (uint32_t)k_book_sizeof_header) {
    return false;
  }
  const book_header_t* hdr      = book_header(base);
  static const char    expect[] = {'R', 'A', 'B', 'O', 'O', 'K', '1'};
  RA8_LOOP_BOUND(k_magic_len);
  for (uint32_t i = 0U; i < (uint32_t)k_magic_len; i++) {
    if (hdr->magic[i] != expect[i]) {
      return false;
    }
  }
  if (hdr->format_version != (uint32_t)k_book_format_version) {
    return false;
  }
  if (hdr->total_size != size) {
    return false;
  }
  if ((hdr->chapter_count == 0U) || (hdr->chapter_count > (uint32_t)k_max_chapters)) {
    return false;
  }
  if ((hdr->node_count == 0U) || (hdr->node_count > (uint32_t)k_max_nodes)) {
    return false;
  }
  return true;
}

static bool render_held_page(const void* base, uint32_t* out_crc, uint32_t* out_glyphs)
{
  if (base == nullptr) {
    return false;
  }
  if (out_crc == nullptr) {
    return false;
  }
  if (out_glyphs == nullptr) {
    return false;
  }
  const book_header_t*  hdr      = book_header(base);
  const book_chapter_t* chapters = book_chapters(base);
  char                  page_text[k_erm33_page_chars];
  const uint32_t        glyphs = collect_chapter_text(base,
                                                      chapters[0].root_node,
                                                      hdr->node_count,
                                                      page_text,
                                                      (uint32_t)k_erm33_page_chars);
  if (!render_page(s_framebuffer, page_text, glyphs)) {
    return false;
  }
  __asm volatile("dsb" ::: "memory");
  *out_crc    = fb_crc32(s_framebuffer, (uint32_t)k_erm33_fb_bytes);
  *out_glyphs = glyphs;
  return true;
}

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

static void simulate_touch_dwell(void)
{
  volatile uint32_t spin = 0U;
  RA8_LOOP_BOUND(k_erm33_touch_dwell);
  for (uint32_t i = 0U; i < (uint32_t)k_erm33_touch_dwell; i++) {
    spin = spin + 1U;
  }
  (void)spin;
}

static bool wait_for_ack(volatile const erm33_mailbox_t* mb, uint32_t turn)
{
  if (mb == nullptr) {
    return false;
  }
  RA8_LOOP_BOUND(k_m33_ack_budget);
  for (uint32_t i = 0U; i < (uint32_t)k_m33_ack_budget; i++) {
    if (mb->turn_ack >= turn) {
      return true;
    }
  }
  return false;
}

static void run_page_turns(volatile erm33_mailbox_t* mb, const void* base)
{
  if (mb == nullptr) {
    return;
  }
  if (base == nullptr) {
    return;
  }
  RA8_LOOP_BOUND(k_erm33_max_turns);
  for (uint32_t turn = 1U; turn <= (uint32_t)k_erm33_max_turns; turn++) {
    simulate_touch_dwell();
    mb->turn_req = turn;
    __asm volatile("dsb" ::: "memory");
    notify_m85();
    if (!wait_for_ack(mb, turn)) {
      return;
    }
    uint32_t crc    = 0U;
    uint32_t glyphs = 0U;
    if (render_held_page(base, &crc, &glyphs)) {
      publish_page(mb, crc, glyphs);
    }
    mb->turn_done = turn;
    __asm volatile("dsb" ::: "memory");
  }
}

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

[[noreturn]] static void cpu1_fail(volatile erm33_mailbox_t* mb, uint32_t status)
{
  if (mb != nullptr) {
    mb->status = status;
    __asm volatile("dsb" ::: "memory");
    mb->done = 1U;
    __asm volatile("dsb" ::: "memory");
  }
  cpu1_park();
}

[[noreturn]] static void cpu1_run_reader(void)
{
  volatile erm33_mailbox_t* mb = erm33_mailbox();
  mb->m33_sig                  = (uint32_t)k_erm33_m33_sig;
  __asm volatile("dsb" ::: "memory");
 
  const void* base = (const void*)k_rabook_fixture;
  if (!book_is_valid(base, (uint32_t)k_rabook_fixture_len)) {
    cpu1_fail(mb, (uint32_t)k_erm33_status_bad_book);
  }
 
  uint32_t crc    = 0U;
  uint32_t glyphs = 0U;
  if (!render_held_page(base, &crc, &glyphs)) {
    cpu1_fail(mb, (uint32_t)k_erm33_status_render_fail);
  }
  publish_page(mb, crc, glyphs);
 
  mb->status = (uint32_t)k_erm33_status_ok;
  __asm volatile("dsb" ::: "memory");
  mb->done = 1U;
  __asm volatile("dsb" ::: "memory");
 
  /* #150 mode-switch: the M33 is now the live core. Hold the page, poll the
   * simulated touch, and on each page turn wake the parked M85, wait for its
   * heavy-work ack, then re-render + republish the (identical) held page. */
  run_page_turns(mb, base);
  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;
  while (dst < &g_ra8_ls_cpu1_data_end) {
    *dst = *src;
    dst++;
    src++;
  }
 
  uint32_t* bss = &g_ra8_ls_cpu1_bss_start;
  while (bss < &g_ra8_ls_cpu1_bss_end) {
    *bss = 0U;
    bss++;
  }
 
  cpu1_run_reader();
}

[[noreturn]] static void cpu1_fault_handler(void)
{
  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