main.c

Go to the documentation of this file.

 
#include <stdint.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_mstp.h"
#include "ra8_sdramc.h"
#include "ra8_sdramc_regs.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_sdram_demo_baud        = 115200U, 
  k_sdram_demo_period_ms   = 1000U,   
  k_sdram_demo_block_bytes = 65536U,  
  k_sdram_demo_block_words = 16384U,  
  k_sdram_demo_us_per_ms   = 1000U,   
} sdram_demo_const_t;

typedef enum : uint8_t {
  k_sdram_demo_ascii_zero   = '0',   
  k_sdram_demo_ascii_a      = 'a',   
  k_sdram_demo_dec_base     = 10U,   
  k_sdram_demo_uint_dec_max = 10U,   
  k_sdram_demo_print_buf    = 64U,   
  k_sdram_demo_fail_buf     = 96U,   
  k_sdram_demo_hex_digits   = 8U,    
  k_sdram_demo_nyb_bits     = 4U,    
  k_sdram_demo_nyb_mask     = 0x0FU, 
} sdram_demo_byte_t;

typedef struct {
  uint32_t count;     
  uint32_t first_idx; 
  uint32_t expected;  
  uint32_t got;       
} sdram_demo_diag_t;

typedef enum : uint32_t {
  k_sdram_demo_pattern_seed = 0xC0FFEE00UL, 
} sdram_demo_seed_t;

static const uint8_t k_sdram_demo_pass_msg[] = "sdram: bench OK\r\n";

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

static void sdram_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_sdram_demo_baud) != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_sdramc_init() != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    sdram_demo_panic_halt();
  }
}

static uint32_t sdram_demo_mbps(uint32_t bytes, uint32_t ms)
{
  const uint32_t ms_clamped = (ms == 0U) ? 1U : ms;
  return bytes / (ms_clamped * (uint32_t)k_sdram_demo_us_per_ms);
}

static uint32_t sdram_demo_write_pass(uint32_t base)
{
  volatile uint32_t* mem      = (volatile uint32_t*)k_ra8_sdram_base_addr;
  const uint32_t     start_ms = ra8_time_ms();
  for (uint32_t i = 0U; i < (uint32_t)k_sdram_demo_block_words; i++) {
    mem[i] = base + i;
  }
  return ra8_time_ms() - start_ms;
}

static bool sdram_demo_read_check(uint32_t base, uint32_t* elapsed, sdram_demo_diag_t* diag)
{
  const volatile uint32_t* mem      = (const volatile uint32_t*)k_ra8_sdram_base_addr;
  const uint32_t           start_ms = ra8_time_ms();
  diag->count                       = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_sdram_demo_block_words; i++) {
    const uint32_t got = mem[i];
    if (got != base + i) {
      if (diag->count == 0U) {
        diag->first_idx = i;
        diag->expected  = base + i;
        diag->got       = got;
      }
      diag->count++;
    }
  }
  *elapsed = ra8_time_ms() - start_ms;
  return diag->count == 0U;
}

static uint8_t sdram_demo_uint_to_hex(uint8_t* buf, uint32_t v)
{
  for (uint8_t i = 0U; i < (uint8_t)k_sdram_demo_hex_digits; i++) {
    const uint8_t shift =
      (uint8_t)(((uint8_t)k_sdram_demo_hex_digits - 1U - i) * (uint8_t)k_sdram_demo_nyb_bits);
    const uint8_t nyb = (uint8_t)((v >> shift) & (uint32_t)k_sdram_demo_nyb_mask);
    buf[i]            = (nyb < (uint8_t)k_sdram_demo_dec_base)
                          ? (uint8_t)((uint8_t)k_sdram_demo_ascii_zero + nyb)
                          : (uint8_t)((uint8_t)k_sdram_demo_ascii_a +
                                      (uint8_t)(nyb - (uint8_t)k_sdram_demo_dec_base));
  }
  return (uint8_t)k_sdram_demo_hex_digits;
}

static uint8_t sdram_demo_uint_to_dec(uint8_t* buf, uint32_t v)
{
  uint8_t  tmp[k_sdram_demo_uint_dec_max];
  uint8_t  n = 0U;
  uint32_t r = v;
  if (r == 0U) {
    buf[0] = (uint8_t)k_sdram_demo_ascii_zero;
    return 1U;
  }
  while ((r > 0U) && (n < (uint8_t)k_sdram_demo_uint_dec_max)) {
    tmp[n] =
      (uint8_t)((uint8_t)k_sdram_demo_ascii_zero + (uint8_t)(r % (uint32_t)k_sdram_demo_dec_base));
    r = r / (uint32_t)k_sdram_demo_dec_base;
    n++;
  }
  for (uint8_t i = 0U; i < n; i++) {
    buf[i] = tmp[(uint8_t)(n - 1U - i)];
  }
  return n;
}

static uint32_t sdram_demo_format_line(uint8_t* out, uint32_t w_mbps, uint32_t r_mbps)
{
  uint32_t      off      = 0U;
  const uint8_t prefix[] = "sdram: w=";
  const uint8_t mid[]    = " MB/s r=";
  const uint8_t suffix[] = " MB/s\r\n";
  for (uint32_t i = 0U; i < sizeof(prefix) - 1U; i++) {
    out[off++] = prefix[i];
  }
  off += sdram_demo_uint_to_dec(&out[off], w_mbps);
  for (uint32_t i = 0U; i < sizeof(mid) - 1U; i++) {
    out[off++] = mid[i];
  }
  off += sdram_demo_uint_to_dec(&out[off], r_mbps);
  for (uint32_t i = 0U; i < sizeof(suffix) - 1U; i++) {
    out[off++] = suffix[i];
  }
  return off;
}

static uint32_t sdram_demo_format_fail(uint8_t* out, const sdram_demo_diag_t* diag)
{
  uint32_t      off       = 0U;
  const uint8_t prefix[]  = "sdram: FAIL idx=";
  const uint8_t exp_tag[] = " exp=";
  const uint8_t got_tag[] = " got=";
  const uint8_t n_tag[]   = " n=";
  const uint8_t suffix[]  = "\r\n";
  for (uint32_t i = 0U; i < sizeof(prefix) - 1U; i++) {
    out[off++] = prefix[i];
  }
  off += sdram_demo_uint_to_dec(&out[off], diag->first_idx);
  for (uint32_t i = 0U; i < sizeof(exp_tag) - 1U; i++) {
    out[off++] = exp_tag[i];
  }
  off += sdram_demo_uint_to_hex(&out[off], diag->expected);
  for (uint32_t i = 0U; i < sizeof(got_tag) - 1U; i++) {
    out[off++] = got_tag[i];
  }
  off += sdram_demo_uint_to_hex(&out[off], diag->got);
  for (uint32_t i = 0U; i < sizeof(n_tag) - 1U; i++) {
    out[off++] = n_tag[i];
  }
  off += sdram_demo_uint_to_dec(&out[off], diag->count);
  for (uint32_t i = 0U; i < sizeof(suffix) - 1U; i++) {
    out[off++] = suffix[i];
  }
  return off;
}

void main(void)
{
  sdram_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  uint32_t base = (uint32_t)k_sdram_demo_pattern_seed;
  while (1) {
    const uint32_t    w_ms   = sdram_demo_write_pass(base);
    uint32_t          r_ms   = 0U;
    sdram_demo_diag_t diag   = {};
    const bool        match  = sdram_demo_read_check(base, &r_ms, &diag);
    const uint32_t    w_mbps = sdram_demo_mbps((uint32_t)k_sdram_demo_block_bytes, w_ms);
    const uint32_t    r_mbps = sdram_demo_mbps((uint32_t)k_sdram_demo_block_bytes, r_ms);
 
    uint8_t        out[k_sdram_demo_print_buf] = {};
    const uint32_t off                         = sdram_demo_format_line(out, w_mbps, r_mbps);
    if (!match) {
      (void)ra8_board_led_on(k_ra8_board_led2);
      /* Emit a FAIL diagnostic so the HIL negative regex catches a
       * read-back mismatch and a log reader sees the corruption
       * signature (first index, expected vs got, total count). */
      uint8_t        fail[k_sdram_demo_fail_buf] = {};
      const uint32_t fail_off                    = sdram_demo_format_fail(fail, &diag);
      (void)ra8_board_uart_console_write(fail, (size_t)fail_off);
    }
    if (ra8_board_uart_console_write(out, (size_t)off) != k_ra8_ok) {
      break;
    }
    /* Success-only verdict for the HIL scrape: a clean read-back pass. */
    if (match) {
      (void)ra8_board_uart_console_write(k_sdram_demo_pass_msg,
                                         (size_t)(sizeof(k_sdram_demo_pass_msg) - 1U));
    }
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    base += 1U;
    ra8_delay_ms(k_sdram_demo_period_ms);
  }
 
  sdram_demo_panic_halt();
}