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_err.h"
#include "ra8_eth.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_eop_uart_baud = 115200U, 
  k_eop_channel   = 1U,      
  k_eop_hex_chars = 8U,      
  k_eop_hex_shift = 4U,      
  k_eop_hex_mask  = 0xFU,    
  k_eop_dec_base  = 10U,     
  k_eop_dec_max   = 10U,     
} eop_consts_t;

typedef enum : uint32_t {
  k_eop_pad_bytes = RA8_ETH_PROBE_PAD_BYTES, 
} eop_pad_t;
 
static_assert((k_eop_pad_bytes % 16U) == 0U, "pad must be a multiple of 16");
static_assert(k_eop_pad_bytes >= 16U, "pad must be non-empty");

[[gnu::section(".bss")]] static volatile uint8_t s_eop_bss_pad[k_eop_pad_bytes];

typedef enum : uint8_t {
  k_eop_mac_0 = 0x02U, 
  k_eop_mac_1 = 0x00U, 
  k_eop_mac_2 = 0x00U, 
  k_eop_mac_3 = 0x00U, 
  k_eop_mac_4 = 0x00U, 
  k_eop_mac_5 = 0x01U, 
} eop_mac_t;
 
static const uint8_t k_eop_msg_boot[]     = "eth-open-probe: boot\r\n";
static const uint8_t k_eop_msg_clock[]    = "eth-open-probe: cpuclk0=";
static const uint8_t k_eop_msg_pad[]      = " bss_pad=";
static const uint8_t k_eop_msg_padlen[]   = " pad_bytes=";
static const uint8_t k_eop_msg_board[]    = "eth-open-probe: board_eth rc=";
static const uint8_t k_eop_msg_opening[]  = "eth-open-probe: calling ra8_eth_open ch=1\r\n";
static const uint8_t k_eop_msg_open_rc[]  = "eth-open-probe: eth_open rc=";
static const uint8_t k_eop_msg_pass[]     = "eth-open-probe: PASS\r\n";
static const uint8_t k_eop_msg_fail[]     = "eth-open-probe: FAIL\r\n";
static const uint8_t k_eop_msg_hw_fail[]  = "eth-open-probe: hw_init_failed\r\n";
static const uint8_t k_eop_msg_newline[]  = "\r\n";
static const uint8_t k_eop_hex_digits[]   = "0123456789ABCDEF";
static const uint8_t k_eop_msg_hex_lead[] = "0x";

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

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

static void eop_print_hex(uint32_t value)
{
  eop_print(k_eop_msg_hex_lead, (uint32_t)sizeof(k_eop_msg_hex_lead) - 1U);
  for (uint32_t i = 0U; i < (uint32_t)k_eop_hex_chars; i++) {
    const uint32_t shift = ((uint32_t)k_eop_hex_chars - 1U - i) * (uint32_t)k_eop_hex_shift;
    const uint32_t digit = (value >> shift) & (uint32_t)k_eop_hex_mask;
    eop_print(&k_eop_hex_digits[digit], 1U);
  }
}

static void eop_print_uint(uint32_t value)
{
  uint8_t  buf[k_eop_dec_max];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = (uint8_t)'0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_eop_dec_max)) {
    buf[n] = (uint8_t)((uint32_t)'0' + (value % (uint32_t)k_eop_dec_base));
    n++;
    value /= (uint32_t)k_eop_dec_base;
  }
  for (uint32_t i = 0U; i < n; i++) {
    eop_print(&buf[n - 1U - i], 1U);
  }
}

static uint32_t eop_bss_pad_anchor(void)
{
  enum : uint8_t {
    k_eop_pad_probe_idx  = 0U,    
    k_eop_pad_probe_byte = 0xA5U, 
  };
  s_eop_bss_pad[k_eop_pad_probe_idx] = (uint8_t)k_eop_pad_probe_byte;
  return (uint32_t)(uintptr_t)&s_eop_bss_pad[k_eop_pad_probe_idx];
}

[[noreturn]] static void eop_panic_halt(void)
{
  eop_print(k_eop_msg_hw_fail, (uint32_t)sizeof(k_eop_msg_hw_fail) - 1U);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void eop_setup_or_halt(uint32_t* out_cpuclk_hz)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    eop_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    eop_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    eop_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    eop_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_eop_uart_baud) != k_ra8_ok) {
    eop_panic_halt();
  }
  *out_cpuclk_hz = cpuclk0_hz;
}

[[nodiscard]] static ra8_err_t eop_run_once(void)
{
  const ra8_err_t board_rc = ra8_board_ethernet_init();
  eop_print(k_eop_msg_board, (uint32_t)sizeof(k_eop_msg_board) - 1U);
  eop_print_uint((uint32_t)board_rc);
  eop_print(k_eop_msg_newline, (uint32_t)sizeof(k_eop_msg_newline) - 1U);
  if (board_rc != k_ra8_ok) {
    return board_rc;
  }
 
  const ra8_eth_cfg_t cfg = {
    .mac_address        = {(uint8_t)k_eop_mac_0,
                           (uint8_t)k_eop_mac_1,
                           (uint8_t)k_eop_mac_2,
                           (uint8_t)k_eop_mac_3,
                           (uint8_t)k_eop_mac_4,
                           (uint8_t)k_eop_mac_5},
    .channel            = (uint8_t)k_eop_channel,
    .num_tx_descriptors = 0U,
    .num_rx_descriptors = 0U,
    .buffer_size        = 0U,
  };
 
  eop_print(k_eop_msg_opening, (uint32_t)sizeof(k_eop_msg_opening) - 1U);
  const ra8_err_t open_rc = ra8_eth_open(&cfg);
  eop_print(k_eop_msg_open_rc, (uint32_t)sizeof(k_eop_msg_open_rc) - 1U);
  eop_print_uint((uint32_t)open_rc);
  eop_print(k_eop_msg_newline, (uint32_t)sizeof(k_eop_msg_newline) - 1U);
  return open_rc;
}
 
void main(void)
{
  uint32_t cpuclk0_hz = 0U;
  eop_setup_or_halt(&cpuclk0_hz);
  ra8_isr_globals_enable();
 
  /* Route the shared fault decoder's ra8_log dump onto the bench
   * console before anything that can fault runs. */
  ra8_log_set_byte_sink(eop_log_sink, nullptr);
 
  eop_print(k_eop_msg_boot, (uint32_t)sizeof(k_eop_msg_boot) - 1U);
  eop_print(k_eop_msg_clock, (uint32_t)sizeof(k_eop_msg_clock) - 1U);
  eop_print_hex(cpuclk0_hz);
  eop_print(k_eop_msg_pad, (uint32_t)sizeof(k_eop_msg_pad) - 1U);
  eop_print_hex(eop_bss_pad_anchor());
  eop_print(k_eop_msg_padlen, (uint32_t)sizeof(k_eop_msg_padlen) - 1U);
  eop_print_hex((uint32_t)k_eop_pad_bytes);
  eop_print(k_eop_msg_newline, (uint32_t)sizeof(k_eop_msg_newline) - 1U);
 
  if (eop_run_once() != k_ra8_ok) {
    eop_print(k_eop_msg_fail, (uint32_t)sizeof(k_eop_msg_fail) - 1U);
  } else {
    eop_print(k_eop_msg_pass, (uint32_t)sizeof(k_eop_msg_pass) - 1U);
  }
 
  while (1) {
    __asm__ volatile("wfi");
  }
}