main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_time.h"
#include "ra8_xspi.h"

typedef enum : uint32_t {
  k_journal_period_ms     = 1000U, 
  k_journal_record_bytes  = 16U,   
  k_journal_record_addr   = 0x0U,  
  k_journal_xspi_instance = 0U,    
  k_journal_counter_bytes = 4U,    
  k_journal_byte_mask     = 0xFFU, 
  k_journal_byte_shift    = 8U,    
} flash_journal_const_t;

volatile uint32_t g_fj_match = 0U;

volatile uint32_t g_fj_mismatch = 0U;

typedef enum : uint32_t {
  k_fj_step_init             = 0U, 
  k_fj_step_erase_ok         = 1U, 
  k_fj_step_program_ok       = 2U, 
  k_fj_step_read_ok          = 3U, 
  k_fj_step_compare_ok       = 4U, 
  k_fj_step_erase_failed     = 5U, 
  k_fj_step_program_failed   = 6U, 
  k_fj_step_read_failed      = 7U, 
  k_fj_step_compare_mismatch = 8U, 
} fj_step_t;

volatile uint32_t g_fj_last_step = k_fj_step_init;

volatile uint32_t g_fj_last_counter = 0U;

volatile uint32_t g_fj_last_echoed = 0U;

volatile uint32_t g_fj_jedec_id = 0U;

typedef enum : uint32_t {
  k_fj_err_none = 0xFFFFFFFFU, 
} fj_err_sentinel_t;
 
volatile uint32_t g_fj_expander_err = k_fj_err_none;

static void flash_journal_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void flash_journal_pack(uint32_t counter, uint8_t* rec)
{
  for (uint8_t i = 0U; i < (uint8_t)k_journal_counter_bytes; i++) {
    rec[i] =
      (uint8_t)((counter >> ((uint32_t)k_journal_byte_shift * i)) & (uint32_t)k_journal_byte_mask);
  }
  for (uint8_t i = (uint8_t)k_journal_counter_bytes; i < (uint8_t)k_journal_record_bytes; i++) {
    rec[i] = i;
  }
}

static uint32_t flash_journal_unpack(const uint8_t* rec)
{
  uint32_t v = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_journal_counter_bytes; i++) {
    v |= ((uint32_t)rec[i]) << ((uint32_t)k_journal_byte_shift * i);
  }
  return v;
}

[[nodiscard]] static ra8_err_t flash_journal_round_trip(uint32_t counter, uint32_t* echoed)
{
  uint8_t rec[k_journal_record_bytes];
  uint8_t back[k_journal_record_bytes];
  g_fj_last_counter = counter;
  flash_journal_pack(counter, rec);
  if (ra8_xspi_flash_erase_sector((uint8_t)k_journal_xspi_instance,
                                  (uint32_t)k_journal_record_addr) != k_ra8_ok) {
    g_fj_last_step = k_fj_step_erase_failed;
    return k_ra8_err_hw_error;
  }
  g_fj_last_step = k_fj_step_erase_ok;
  if (ra8_xspi_flash_program((uint8_t)k_journal_xspi_instance,
                             (uint32_t)k_journal_record_addr,
                             rec,
                             (uint32_t)k_journal_record_bytes) != k_ra8_ok) {
    g_fj_last_step = k_fj_step_program_failed;
    return k_ra8_err_hw_error;
  }
  g_fj_last_step = k_fj_step_program_ok;
  if (ra8_xspi_flash_read((uint8_t)k_journal_xspi_instance,
                          (uint32_t)k_journal_record_addr,
                          back,
                          (uint32_t)k_journal_record_bytes) != k_ra8_ok) {
    g_fj_last_step = k_fj_step_read_failed;
    return k_ra8_err_hw_error;
  }
  g_fj_last_step   = k_fj_step_read_ok;
  *echoed          = flash_journal_unpack(back);
  g_fj_last_echoed = *echoed;
  return k_ra8_ok;
}

static void flash_journal_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  /* Best-effort U15 I/O-expander courtesy write. The on-board Octo-SPI
   * flash (U3, ISSI IS25LX512M; UM section 6.3 p 35) is connected through
   * the SW4-3 analog mux, which is hardware-only. A firmware sweep of the
   * full U15 output space (issue #44; see docs/HARDWARE_BRINGUP.md) proved
   * the expander's GPIOs do NOT gate the OSPI bus, so this call cannot
   * affect flash reachability -- it is kept only as a no-op courtesy and
   * its return code is stamped to g_fj_expander_err for the memprobe. If
   * the JEDEC read below returns 0x00FFFFFF the bus is sitting at the board
   * pull-ups (flash not passed through SW4-3), which is a physical check. */
  const ra8_err_t exp_err = ra8_board_io_expander_set_octospi_active();
  g_fj_expander_err       = (uint32_t)exp_err;
  /* OCTA pins come out of reset as GPIO; ra8_board_xspi_pins_init
   * routes them to PSEL=0x1C and pulses RESET_L on P106 so the
   * IS25LX512M lands in standard-SPI mode with deterministic state.
   * HUM Ch 20.6 "Multiplexed Pin Function Selector" p 871. */
  if (ra8_board_xspi_pins_init() != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  if (ra8_xspi_init((uint8_t)k_journal_xspi_instance, k_ra8_xspi_lio_1s1s1s) != k_ra8_ok) {
    flash_journal_panic_halt();
  }
  uint32_t jedec_id = 0U;
  (void)ra8_xspi_flash_read_id((uint8_t)k_journal_xspi_instance, &jedec_id);
  g_fj_jedec_id = jedec_id;
}
 
void main(void)
{
  flash_journal_setup_or_halt();
  ra8_isr_globals_enable();
 
  uint32_t counter = 0U;
  while (1) {
    uint32_t        echoed = 0U;
    const ra8_err_t err    = flash_journal_round_trip(counter, &echoed);
    if (err == k_ra8_ok && echoed == counter) {
      (void)ra8_board_led_toggle(k_ra8_board_led1);
      g_fj_match += 1U;
      g_fj_last_step = k_fj_step_compare_ok;
    } else {
      (void)ra8_board_led_toggle(k_ra8_board_led2);
      g_fj_mismatch += 1U;
      if (err == k_ra8_ok) {
        g_fj_last_step = k_fj_step_compare_mismatch;
      }
    }
    counter++;
    ra8_delay_ms(k_journal_period_ms);
  }
  flash_journal_panic_halt();
}