main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "cache_coherency_shared.h"
#include "ra8_board_ek_ra8d2_peripherals.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_dual_core.h"
#include "ra8_err.h"
#include "ra8_log.h"

extern uint32_t g_ra8_ls_cpu1_mram_start;
extern uint32_t g_ra8_ls_cpu1_stack_top;

typedef enum : uint32_t {
  k_cache_coherency_hil_baud = 115200U, 
} cache_coherency_hil_const_t;

volatile uint32_t g_cache_coherency_match = 0U;

volatile uint32_t g_cache_coherency_mismatch = 0U;

static const uint8_t s_cache_coherency_pass_banner[] = "cache_coherency_hil: 8 rounds PASS\r\n";

RA8_INTERNAL static bool internal_console_init(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    return false;
  }
  if (ra8_board_uart_console_init((uint32_t)k_cache_coherency_hil_baud) != k_ra8_ok) {
    return false;
  }
  return true;
}

RA8_INTERNAL static void internal_emit_pass(void)
{
  (void)ra8_board_uart_console_write(s_cache_coherency_pass_banner,
                                     (size_t)(sizeof(s_cache_coherency_pass_banner) - 1U));
  (void)ra8_board_uart_console_flush();
  ra8_log_info("M85", "cache_coherency_hil: 8 rounds PASS");
}

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

RA8_INTERNAL static bool internal_wait_for_pong(const volatile cache_coherency_shared_t* shared,
                                                uint32_t                                 target)
{
  if (shared == nullptr) {
    return false;
  }
  for (uint32_t i = 0U; i < (uint32_t)k_cache_coherency_poll_budget; ++i) {
    if (shared->pong_seq == target) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static void
internal_round(volatile cache_coherency_shared_t* shared, uint32_t round, uint32_t* next_seq)
{
  if ((shared == nullptr) || (next_seq == nullptr)) {
    return;
  }
  const uint32_t expect = (uint32_t)k_cache_coherency_pong_base + round;
 
  shared->ping_payload = (uint32_t)k_cache_coherency_ping_base + round;
  __asm volatile("dsb" ::: "memory");
  shared->ping_seq = *next_seq;
 
  bool ok = internal_wait_for_pong(shared, *next_seq);
  if (ok) {
    ok = (shared->pong_payload == expect);
  }
  if (ok) {
    g_cache_coherency_match += 1U;
  } else {
    g_cache_coherency_mismatch += 1U;
  }
  *next_seq += 1U;
}

void main(void)
{
  ra8_log_init();
  ra8_log_info("M85", "cache_coherency_hil: D-cache ON, non-cacheable shared SRAM");
 
  volatile cache_coherency_shared_t* shared = internal_shared();
  /* CPU0 owns initialisation of the shared block. Zero it before
   * releasing CPU1 so CPU1 starts from a known clean state. */
  shared->ping_seq     = 0U;
  shared->pong_seq     = 0U;
  shared->ping_payload = 0U;
  shared->pong_payload = 0U;
  __asm volatile("dsb" ::: "memory");
 
  /* Best-effort VCOM console (banner) + LED1 (self-test heartbeat). */
  const bool console_up = internal_console_init();
  if (!console_up) {
    ra8_log_info("M85", "VCOM console init failed -- banner over ITM only");
  }
  const bool led_up = (ra8_board_led_init(k_ra8_board_led1) == k_ra8_ok);
 
  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");
    internal_park_forever();
  }
 
  uint32_t next_seq    = 1U;
  uint32_t round       = 0U;
  bool     banner_sent = false;
 
  while (1) {
    /* Self-test heartbeat: one IOPORT write per round keeps ra8_emulator's
     * MMIO-keyed idle detector awake through the pure-SRAM hand-off so the
     * banner surfaces under RA8_EMU_IDLE_STOP=1 (and the LED visibly
     * blinks on the bench). Dropped once the self-test has passed, so the
     * steady phase below is pure SRAM and IDLE_STOP can stop the fake. */
    if (led_up && (round < (uint32_t)k_cache_coherency_rounds)) {
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    }
 
    internal_round(shared, round, &next_seq);
 
    if (!banner_sent && (g_cache_coherency_match >= (uint32_t)k_cache_coherency_rounds)) {
      internal_emit_pass();
      banner_sent = true;
    }
    round += 1U;
  }
}