main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ereader_m33.h"
#include "ra8_attributes.h"
#include "ra8_boot_entry.h"
#include "ra8_dual_core.h"
#include "ra8_err.h"
#include "ra8_ipc.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_lpm.h"

extern uint32_t g_ra8_ls_cpu1_mram_start;
extern uint32_t g_ra8_ls_cpu1_stack_top;

typedef enum : uint32_t {
  k_m85_sig_poll_budget  = 10000000UL,  
  k_m85_done_poll_budget = 200000000UL, 
} m85_poll_t;

typedef enum : uint32_t {
  k_banner_cap = 96U, 
} m85_banner_t;

typedef enum : uint8_t {
  k_hex_nibbles = 8U,    
  k_nibble_bits = 4U,    
  k_nibble_mask = 0x0FU, 
} m85_hex_t;

typedef enum : uint8_t {
  k_dec_digits_max = 10U, 
  k_dec_radix      = 10U, 
} m85_dec_t;

typedef enum : uint32_t {
  k_heavy_work_iters = 256U, 
} m85_work_t;

static void banner_append(char* dst, uint32_t* off, uint32_t cap, const char* src)
{
  if (dst == nullptr) {
    return;
  }
  if (off == nullptr) {
    return;
  }
  if (src == nullptr) {
    return;
  }
  RA8_LOOP_BOUND(k_banner_cap);
  for (uint32_t i = 0U; i < cap; i++) {
    const char c = src[i];
    if (c == '\0') {
      break;
    }
    if (*off >= (cap - 1U)) {
      break;
    }
    dst[*off] = c;
    *off += 1U;
  }
  dst[*off] = '\0';
}

static void banner_append_hex(char* dst, uint32_t* off, uint32_t cap, uint32_t value)
{
  if (dst == nullptr) {
    return;
  }
  if (off == nullptr) {
    return;
  }
  static const char digits[] = "0123456789ABCDEF";
  RA8_LOOP_BOUND(k_hex_nibbles);
  for (uint32_t i = 0U; i < (uint32_t)k_hex_nibbles; i++) {
    if (*off >= (cap - 1U)) {
      break;
    }
    const uint32_t shift  = ((uint32_t)k_hex_nibbles - 1U - i) * (uint32_t)k_nibble_bits;
    const uint32_t nibble = (value >> shift) & (uint32_t)k_nibble_mask;
    dst[*off]             = digits[nibble];
    *off += 1U;
  }
}

static void banner_append_u32(char* dst, uint32_t* off, uint32_t cap, uint32_t value)
{
  if (dst == nullptr) {
    return;
  }
  if (off == nullptr) {
    return;
  }
  char     tmp[k_dec_digits_max];
  uint32_t count = 0U;
  uint32_t v     = value;
  RA8_LOOP_BOUND(k_dec_digits_max);
  for (uint32_t i = 0U; i < (uint32_t)k_dec_digits_max; i++) {
    tmp[count] = (char)('0' + (char)(v % (uint32_t)k_dec_radix));
    count += 1U;
    v /= (uint32_t)k_dec_radix;
    if (v == 0U) {
      break;
    }
  }
  RA8_LOOP_BOUND(k_dec_digits_max);
  for (uint32_t i = 0U; i < count; i++) {
    if (*off >= (cap - 1U)) {
      break;
    }
    dst[*off] = tmp[count - 1U - i];
    *off += 1U;
  }
}

static void prep_mailbox(volatile erm33_mailbox_t* mb)
{
  mb->magic       = 0U;
  mb->m33_sig     = 0U;
  mb->status      = (uint32_t)k_erm33_status_running;
  mb->fb_base     = 0U;
  mb->fb_width    = 0U;
  mb->fb_height   = 0U;
  mb->fb_stride   = 0U;
  mb->fb_format   = 0U;
  mb->fb_crc      = 0U;
  mb->glyph_count = 0U;
  mb->done        = 0U;
  mb->turn_req    = 0U;
  mb->turn_ack    = 0U;
  mb->turn_done   = 0U;
  __asm volatile("dsb" ::: "memory");
  mb->magic = (uint32_t)k_erm33_magic;
  __asm volatile("dsb" ::: "memory");
}

static bool wait_for_m33_sig(const volatile erm33_mailbox_t* mb)
{
  RA8_LOOP_BOUND(k_m85_sig_poll_budget);
  for (uint32_t i = 0U; i < (uint32_t)k_m85_sig_poll_budget; i++) {
    if (mb->m33_sig == (uint32_t)k_erm33_m33_sig) {
      return true;
    }
  }
  return false;
}

static bool wait_for_done(const volatile erm33_mailbox_t* mb)
{
  RA8_LOOP_BOUND(k_m85_done_poll_budget);
  for (uint32_t i = 0U; i < (uint32_t)k_m85_done_poll_budget; i++) {
    if (mb->done == 1U) {
      return true;
    }
  }
  return false;
}

static bool verify_page(const volatile erm33_mailbox_t* mb)
{
  if (mb->status != (uint32_t)k_erm33_status_ok) {
    return false;
  }
  if ((mb->fb_base < (uint32_t)k_erm33_sdram_base) ||
      (mb->fb_base >= (uint32_t)k_erm33_sdram_end)) {
    return false;
  }
  if ((mb->fb_width != (uint32_t)k_erm33_fb_width) ||
      (mb->fb_height != (uint32_t)k_erm33_fb_height)) {
    return false;
  }
  if (mb->fb_stride != (uint32_t)k_erm33_fb_stride) {
    return false;
  }
  if (mb->fb_format != (uint32_t)k_erm33_fb_format_rgb565) {
    return false;
  }
  if ((mb->glyph_count == 0U) || (mb->fb_crc == 0U)) {
    return false;
  }
  return true;
}

static void emit_verdict(uint32_t crc, bool pass)
{
  char     buf[k_banner_cap];
  uint32_t off = 0U;
  banner_append(buf, &off, (uint32_t)k_banner_cap, "ereader_m33: rgb565 256x64 sdram crc=");
  banner_append_hex(buf, &off, (uint32_t)k_banner_cap, crc);
  banner_append(buf, &off, (uint32_t)k_banner_cap, pass ? " PASS" : " FAIL");
  ra8_log_info("M85", buf);
}

typedef enum : uint8_t {
  k_ipc_wake_channel = 0U, 
} m85_ipc_t;

static volatile bool s_m33_woke;

static void ipc_wake_handler(void* ctx, uint8_t channel, ra8_ipc_irq_event_id_t event_id)
{
  (void)ctx;
  (void)channel;
  (void)event_id;
  s_m33_woke = true;
}

static void ipc0_receive_isr(void* ctx)
{
  (void)ctx;
  ra8_ipc_dispatch((uint8_t)k_ipc_wake_channel);
}

static bool arm_ipc_wake(void)
{
  if (ra8_isr_init() != k_ra8_ok) {
    return false;
  }
  const ra8_ipc_config_t cfg = {
    .channel      = (uint8_t)k_ipc_wake_channel,
    .reset_fifo   = true,
    .clear_status = true,
    .event_mask   = (uint32_t)k_ra8_ipc_event_irq0,
  };
  if (ra8_ipc_init(&cfg) != k_ra8_ok) {
    return false;
  }
  if (ra8_ipc_attach_event_handler((uint8_t)k_ipc_wake_channel,
                                   k_ra8_ipc_irq_event_0,
                                   ipc_wake_handler,
                                   nullptr) != k_ra8_ok) {
    return false;
  }
  if (ra8_isr_register((ra8_elc_event_t)k_ra8_ipc_elc_event_irq0,
                       ipc0_receive_isr,
                       nullptr,
                       (uint8_t)k_ra8_isr_prio_default,
                       nullptr) != k_ra8_ok) {
    return false;
  }
  ra8_isr_globals_enable();
  return true;
}

static void m85_lpm_configure(void)
{
  if (ra8_lpm_prcr_unlock() != k_ra8_ok) {
    return;
  }
  const ra8_lpm_config_t cfg = {
    .opa_bus_keep = true,
  };
  (void)ra8_lpm_init(&cfg);
  (void)ra8_lpm_prcr_relock();
}

static void m85_gate_hoco(bool stop)
{
  if (ra8_lpm_prcr_unlock() != k_ra8_ok) {
    return;
  }
  (void)ra8_lpm_set_clock_stop(k_ra8_lpm_clock_hoco, stop);
  (void)ra8_lpm_prcr_relock();
}

static bool m85_wait_turn(const volatile erm33_mailbox_t* mb, uint32_t turn)
{
  RA8_LOOP_BOUND(k_m85_done_poll_budget);
  for (uint32_t i = 0U; i < (uint32_t)k_m85_done_poll_budget; i++) {
    if (mb->turn_req >= turn) {
      return true;
    }
    __asm volatile("wfi" ::: "memory");
  }
  return false;
}

static uint32_t m85_heavy_work(uint32_t turn)
{
  uint32_t acc = turn;
  RA8_LOOP_BOUND(k_heavy_work_iters);
  for (uint32_t i = 0U; i < (uint32_t)k_heavy_work_iters; i++) {
    acc += i;
  }
  return acc;
}

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

static bool run_handoff_cycle(volatile erm33_mailbox_t* mb)
{
  if (mb == nullptr) {
    return false;
  }
  RA8_LOOP_BOUND(k_erm33_max_turns);
  for (uint32_t turn = 1U; turn <= (uint32_t)k_erm33_max_turns; turn++) {
    m85_gate_hoco(true);
    const bool woke = m85_wait_turn(mb, turn);
    m85_gate_hoco(false);
    if (!woke) {
      ra8_log_info_val("M85", "page-turn wake timed out at turn", turn);
      return false;
    }
    [[maybe_unused]] const uint32_t work = m85_heavy_work(turn);
    mb->turn_ack                         = turn;
    __asm volatile("dsb" ::: "memory");
    ra8_log_info_val("M85", "woke from low-power for page turn", turn);
    ra8_log_info_val("M85", "M85 heavy next-page work result", work);
  }
  return true;
}

static void emit_cycle_verdict(const volatile erm33_mailbox_t* mb, bool pass)
{
  if (mb == nullptr) {
    return;
  }
  char     buf[k_banner_cap];
  uint32_t off = 0U;
  banner_append(buf, &off, (uint32_t)k_banner_cap, "ereader_m33: handoff turns=");
  banner_append_u32(buf, &off, (uint32_t)k_banner_cap, mb->turn_done);
  banner_append(buf, &off, (uint32_t)k_banner_cap, " crc=");
  banner_append_hex(buf, &off, (uint32_t)k_banner_cap, mb->fb_crc);
  banner_append(buf, &off, (uint32_t)k_banner_cap, pass ? " PARKED" : " FAIL");
  ra8_log_info("M85", buf);
}

static void run_mode_switch(volatile erm33_mailbox_t* mb)
{
  if (mb == nullptr) {
    return;
  }
  ra8_log_info("M85", "entering #150 mode-switch cycle; M33 holds the page + polls touch");
  const bool cycled  = run_handoff_cycle(mb);
  bool       done_ok = false;
  if (cycled) {
    done_ok = m85_wait_turn_done(mb, (uint32_t)k_erm33_max_turns);
  }
  bool verdict = false;
  if (done_ok) {
    if (mb->fb_crc != 0U) {
      verdict = true;
    }
  }
  emit_cycle_verdict(mb, verdict);
}

[[noreturn]] static void park_low_power(void)
{
  ra8_log_info("M85", "M85 parked in low-power WFI; M33 holds the page");
  m85_gate_hoco(true);
  while (1) {
    __asm volatile("wfi");
  }
}

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

void main(void)
{
  ra8_log_init();
  ra8_log_info("M85", "==== RA8D2 ereader_m33 demo (#150 M85-park / M33-hold) ====");
  ra8_log_info("M85", "Cortex-M85 primary core online");
  ra8_log_info("M85", "M33 renders a held page into external SDRAM (0x68000000)");
 
  volatile erm33_mailbox_t* mb = erm33_mailbox();
  prep_mailbox(mb);
 
  /* Arm the IPC0 receive IRQ + configure the LPM block BEFORE releasing the M33,
   * so the page-turn wake path and the Sleep-mode posture are ready the moment
   * the M33 starts running. A wake-arm failure is non-fatal: m85_wait_turn still
   * bounds-polls the mailbox (its WFI then just sleeps to the next interrupt). */
  if (arm_ipc_wake()) {
    ra8_log_info("M85", "IPC0 receive IRQ armed -- M85 can WFI-wake on a page turn");
  } else {
    ra8_log_info("M85", "IPC wake arm failed -- page-turn WFI falls back to bounded poll");
  }
  m85_lpm_configure();
 
  ra8_log_info("M85", "releasing Cortex-M33 secondary core ...");
  const ra8_err_t err = ra8_cpu1_release(&g_ra8_ls_cpu1_mram_start, &g_ra8_ls_cpu1_stack_top);
  ra8_log_info_val("M85", "ra8_cpu1_release rc (0 = ok)", (uint32_t)err);
  if (err != k_ra8_ok) {
    ra8_log_info("M85", "release FAILED -- halting");
    park_forever();
  }
 
  if (wait_for_m33_sig(mb)) {
    ra8_log_info("M85", "M33 reader is alive");
  } else {
    ra8_log_info("M85", "M33 signature not seen -- did it boot?");
  }
 
  ra8_log_info("M85", "M85 idle; waiting for the M33 to render the held page ...");
  if (!wait_for_done(mb)) {
    ra8_log_info("M85", "M33 done flag not seen -- timed out");
    park_forever();
  }
  __asm volatile("dsb" ::: "memory");
 
  ra8_log_info_val("M85", "M33 published fb_base", mb->fb_base);
  ra8_log_info_val("M85", "M33 held-page glyphs", mb->glyph_count);
  ra8_log_info_val("M85", "M33 held-page pixels CRC32 (decimal)", mb->fb_crc);
  emit_verdict(mb->fb_crc, verify_page(mb));
 
  /* #150 mode-switch: hand the live core to the slow M33, park, and wake on each
   * scripted page turn to do the heavy next-page work, then park for good. */
  run_mode_switch(mb);
  park_low_power();
}