main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_crashlog.h"
#include "ra8_err.h"
#include "ra8_exception.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_mstp.h"

typedef enum : uint32_t {
  k_fc_uart_baud    = 115200U, 
  k_fc_hex_nib_mask = 0xFU,    
} fc_consts_t;

typedef enum : uint8_t {
  k_fc_hex_nib_bits = 4U, 
  k_fc_hex_digits   = 8U, 
} fc_hex_t;

typedef enum : uint32_t {
  k_fc_synth_exc  = 6U,          
  k_fc_synth_pc   = 0x02001234U, 
  k_fc_synth_lr   = 0x02001200U, 
  k_fc_synth_cfsr = 0x02000000U, 
} fc_synth_t;
 
static const uint8_t k_msg_boot[]     = "crashlog: boot\r\n";
static const uint8_t k_msg_fail[]     = "crashlog: FAIL init\r\n";
static const uint8_t k_msg_none[]     = "crashlog: no prior record (cold/first boot)\r\n";
static const uint8_t k_msg_prior[]    = "crashlog: prior record exc=";
static const uint8_t k_msg_pc[]       = " pc=";
static const uint8_t k_msg_loops[]    = " boot_loops=";
static const uint8_t k_msg_safemode[] = "crashlog: SAFE-MODE requested -- reset loop, idling\r\n";
static const uint8_t k_msg_recorded[] = "crashlog: recorded+readback exc=";
static const uint8_t k_msg_crlf[]     = "\r\n";

static void fc_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

static void fc_print_uint(uint32_t value)
{
  enum : uint32_t {
    k_fc_dec_base   = 10U, 
    k_fc_dec_digits = 10U, 
  };
  uint8_t  buf[k_fc_dec_digits];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_fc_dec_digits)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_fc_dec_base));
    n++;
    value /= (uint32_t)k_fc_dec_base;
  }
  for (uint32_t i = 0U; i < n; i++) {
    fc_print(&buf[n - 1U - i], 1U);
  }
}

static void fc_print_hex32(uint32_t value)
{
  static const uint8_t k_hex[]  = "0123456789ABCDEF";
  const uint8_t        prefix[] = {'0', 'x'};
  fc_print(prefix, (uint32_t)sizeof(prefix));
  for (uint32_t i = 0U; i < (uint32_t)k_fc_hex_digits; i++) {
    const uint32_t shift = (uint32_t)((k_fc_hex_digits - 1U - i) * (uint32_t)k_fc_hex_nib_bits);
    const uint32_t nib   = (value >> shift) & (uint32_t)k_fc_hex_nib_mask;
    fc_print(&k_hex[nib], 1U);
  }
}

static void fc_log_sink(void* ctx, uint8_t byte)
{
  (void)ctx;
  (void)ra8_board_uart_console_write(&byte, 1U);
}

[[noreturn]] static void fc_panic_halt(const uint8_t* msg, uint32_t len)
{
  fc_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void fc_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    fc_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    fc_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_fc_uart_baud) != k_ra8_ok) {
    fc_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void fc_print_record(const ra8_crashlog_record_t* rec)
{
  if (rec == nullptr) {
    return;
  }
  fc_print(k_msg_prior, (uint32_t)sizeof(k_msg_prior) - 1U);
  fc_print_uint(rec->fault.exc_number);
  fc_print(k_msg_pc, (uint32_t)sizeof(k_msg_pc) - 1U);
  fc_print_hex32(rec->fault.frame.pc);
  fc_print(k_msg_loops, (uint32_t)sizeof(k_msg_loops) - 1U);
  fc_print_uint(rec->boot_loops);
  fc_print(k_msg_crlf, (uint32_t)sizeof(k_msg_crlf) - 1U);
}

static void fc_make_synth(ra8_exception_last_t* out)
{
  if (out == nullptr) {
    return;
  }
  *out            = (ra8_exception_last_t){};
  out->magic      = (uint32_t)k_ra8_exc_magic_valid;
  out->exc_number = (uint32_t)k_fc_synth_exc;
  out->frame.pc   = (uint32_t)k_fc_synth_pc;
  out->frame.lr   = (uint32_t)k_fc_synth_lr;
  out->diag.cfsr  = (uint32_t)k_fc_synth_cfsr;
}
 
void main(void)
{
  fc_setup_or_halt();
  ra8_isr_globals_enable();
  ra8_log_set_byte_sink(fc_log_sink, nullptr);
  fc_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  /* Arm the persist hook so any subsequent real fault is captured, then
   * read whatever a prior (warm-reset) boot left behind. */
  ra8_crashlog_install();
 
  ra8_crashlog_record_t rec = {};
  if (ra8_crashlog_peek(&rec)) {
    fc_print_record(&rec);
    if (ra8_crashlog_safe_mode_requested()) {
      fc_print(k_msg_safemode, (uint32_t)sizeof(k_msg_safemode) - 1U);
      ra8_crashlog_claim(); /* clean claim: reset the loop guard */
      while (1) {
        __asm__ volatile("wfi");
      }
    }
  } else {
    fc_print(k_msg_none, (uint32_t)sizeof(k_msg_none) - 1U);
  }
 
  /* In-process write+decode proof (the only leg ra8_emulator can show): push
   * a synthesised decoded snapshot through the installed write path, then
   * read it back. Left in place so a bench warm reset shows survival. */
  ra8_exception_last_t synth = {};
  fc_make_synth(&synth);
  ra8_crashlog_record_fault(&synth);
 
  if (ra8_crashlog_peek(&rec)) {
    fc_print(k_msg_recorded, (uint32_t)sizeof(k_msg_recorded) - 1U);
    fc_print_uint(rec.fault.exc_number);
    fc_print(k_msg_pc, (uint32_t)sizeof(k_msg_pc) - 1U);
    fc_print_hex32(rec.fault.frame.pc);
    fc_print(k_msg_loops, (uint32_t)sizeof(k_msg_loops) - 1U);
    fc_print_uint(rec.boot_loops);
    fc_print(k_msg_crlf, (uint32_t)sizeof(k_msg_crlf) - 1U);
  } else {
    fc_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
 
  while (1) {
    __asm__ volatile("wfi");
  }
}