ra8_exception.c

Go to the documentation of this file.

 
#include "ra8_exception.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_error_handler.h"
#include "ra8_log.h"
#include "ra8_scb.h"
 
#ifdef RA8_OFF_TARGET
/* Host-side test builds get the legacy halt-via-fatal-error path so
 * tests can override `ra8_fatal_error` to longjmp out. */
#define RA8_EXCEPTION_HALT(tag, msg, exc) ra8_fatal_error((tag), (msg), (exc))
#else
#define RA8_EXCEPTION_HALT(tag, msg, exc)                                                          \
  do {                                                                                             \
    (void)(tag);                                                                                   \
    (void)(msg);                                                                                   \
    (void)(exc);                                                                                   \
    internal_exception_halt_loop();                                                                \
  } while (0)
#endif

typedef enum : uint32_t {
  k_ra8_exc_num_nmi = 2U, 
} ra8_exc_num_t;

void ra8_exception_capture_diagnostics(ra8_exception_diagnostics_t* out)
{
  if (out == nullptr) {
    return;
  }
  ra8_scb_fault_status_t fs = {};
  if (ra8_scb_read_fault_status(&fs) == k_ra8_ok) {
    out->cfsr  = fs.cfsr;
    out->hfsr  = fs.hfsr;
    out->dfsr  = fs.dfsr;
    out->mmfar = fs.mmfar;
    out->bfar  = fs.bfar;
    out->afsr  = fs.afsr;
    out->sfsr  = fs.sfsr;
    out->sfar  = fs.sfar;
  }
}

volatile ra8_exception_last_t g_ra8_exception_last;

static volatile uint32_t s_ra8_exception_nmi_stage;

static ra8_exception_persist_fn s_ra8_exception_persist;

void ra8_exception_set_persist_hook(ra8_exception_persist_fn hook)
{
  s_ra8_exception_persist = hook;
}
 
#ifndef RA8_OFF_TARGET
[[noreturn, gnu::noinline]] RA8_INTERNAL static void internal_exception_halt_loop(void)
{
  __asm__ volatile("cpsid i" ::: "memory");
  while (1) {
    __asm__ volatile("wfi");
  }
}
#endif

RA8_INTERNAL static void internal_log_fault_dump(const ra8_exception_frame_t*       frame,
                                                 uint32_t                           exc_number,
                                                 const ra8_exception_diagnostics_t* diag,
                                                 uint32_t                           nmisr)
{
  ra8_log_error_val("EXC", "exception", exc_number);
 
  if (frame != nullptr) {
    ra8_log_error_val("EXC", "pc  ", frame->pc);
    ra8_log_error_val("EXC", "lr  ", frame->lr);
    ra8_log_error_val("EXC", "xpsr", frame->xpsr);
    ra8_log_error_val("EXC", "r0  ", frame->r0);
    ra8_log_error_val("EXC", "r1  ", frame->r1);
    ra8_log_error_val("EXC", "r2  ", frame->r2);
    ra8_log_error_val("EXC", "r3  ", frame->r3);
    ra8_log_error_val("EXC", "r12 ", frame->r12);
  }
 
  ra8_log_error_val("EXC", "cfsr ", diag->cfsr);
  ra8_log_error_val("EXC", "hfsr ", diag->hfsr);
  ra8_log_error_val("EXC", "bfar ", diag->bfar);
  ra8_log_error_val("EXC", "mmfar", diag->mmfar);
  ra8_log_error_val("EXC", "sfsr ", diag->sfsr);
  ra8_log_error_val("EXC", "sfar ", diag->sfar);
  if (exc_number == (uint32_t)k_ra8_exc_num_nmi) {
    ra8_log_error_val("EXC", "nmisr", nmisr);
  }
}

void ra8_exception_report(const ra8_exception_frame_t* frame, uint32_t exc_number)
{
  /* Step 1: capture EVERYTHING into fixed SRAM FIRST -- before any
   * function call that might itself fault. This guarantees that even
   * if the log backend, ITM, or anything else takes a secondary fault,
   * a debugger can still recover the original fault context from
   * g_ra8_exception_last. */
  g_ra8_exception_last.magic      = 0U;
  g_ra8_exception_last.exc_number = exc_number;
  g_ra8_exception_last.frame_ptr  = (uintptr_t)frame;
  if (frame != nullptr) {
    g_ra8_exception_last.frame.r0   = frame->r0;
    g_ra8_exception_last.frame.r1   = frame->r1;
    g_ra8_exception_last.frame.r2   = frame->r2;
    g_ra8_exception_last.frame.r3   = frame->r3;
    g_ra8_exception_last.frame.r12  = frame->r12;
    g_ra8_exception_last.frame.lr   = frame->lr;
    g_ra8_exception_last.frame.pc   = frame->pc;
    g_ra8_exception_last.frame.xpsr = frame->xpsr;
  }
  ra8_exception_diagnostics_t diag = {};
  ra8_exception_capture_diagnostics(&diag);
  g_ra8_exception_last.diag = diag;
  /* Fold in the ICU cause staged by ra8_exception_report_nmi(), then
   * clear the stage so a later non-NMI record cannot inherit it. */
  g_ra8_exception_last.nmisr = s_ra8_exception_nmi_stage;
  s_ra8_exception_nmi_stage  = 0U;
  g_ra8_exception_last.magic = (uint32_t)k_ra8_exc_magic_valid;
 
  /* Step 1b: persist the completed snapshot across the coming reset (if a
   * sink is armed). Runs before any code that might take a secondary fault
   * so a field unit's post-mortem + reset-loop count survive to the next
   * boot. A plain SRAM copy -- fault-context safe. See ra8_crashlog.c. */
  if (s_ra8_exception_persist != nullptr) {
    s_ra8_exception_persist(&g_ra8_exception_last);
  }
 
  /* Step 2: best-effort logging, strictly after the snapshot. */
  internal_log_fault_dump(frame, exc_number, &diag, g_ra8_exception_last.nmisr);
 
  /* Step 3: halt at a named symbol. On target we do NOT call
   * ra8_fatal_error from a fault context -- that path issues
   * `bkpt #0`, which on a board without an attached debugger re-enters
   * HardFault and can escalate to LOCKUP at PC=0xEFFFFFFE. The
   * dedicated halt loop parks PC at a symbol the debugger can name.
   * On host (fake) builds we still go through the overridable
   * fatal hook so unit tests can longjmp out. */
  RA8_EXCEPTION_HALT("EXC", "fault", exc_number);
}

void ra8_exception_report_nmi(const ra8_exception_frame_t* frame, uint32_t nmisr)
{
  /* Plain SRAM store first (cannot fault), so even a secondary fault
   * inside the common path leaves the cause recoverable: the stage is
   * copied into g_ra8_exception_last.nmisr before magic is set. */
  s_ra8_exception_nmi_stage = nmisr;
  ra8_exception_report(frame, (uint32_t)k_ra8_exc_num_nmi);
}