main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_etha.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_eth_loopback_baud        = 115200U, 
  k_eth_loopback_burst_count = 4U,      
} eth_loopback_const_t;

typedef enum : uint16_t {
  k_eth_loopback_ring_tx     = 4U,    
  k_eth_loopback_ring_rx     = 4U,    
  k_eth_loopback_buffer_size = 1536U, 
} eth_loopback_ring_t;

static const uint8_t s_eth_loopback_log_msg[]  = "etha: loopback ok\r\n";
static const uint8_t s_eth_loopback_boot_msg[] = "etha: boot\r\n";

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

RA8_INTERNAL static void internal_eth_loopback_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_eth_loopback_baud) != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t
internal_eth_loopback_run_once(ra8_etha_port_stats_t* out)
{
  const ra8_etha_config_t cfg = {
    .initial_mode = k_ra8_etha_opc_config,
    .eaeie0_mask  = 0U,
    .eaeie1_mask  = 0U,
    .eaeie2_mask  = 0U,
  };
  ra8_err_t err = ra8_etha_init(k_ra8_etha_port_0, &cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_etha_descriptor_ring_init(k_ra8_etha_port_0,
                                      (uint16_t)k_eth_loopback_ring_tx,
                                      (uint16_t)k_eth_loopback_ring_rx,
                                      (uint16_t)k_eth_loopback_buffer_size);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_etha_set_mode(k_ra8_etha_port_0, k_ra8_etha_opc_operation);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_eth_loopback_burst_count; i++) {
    err = ra8_etha_account_traffic(k_ra8_etha_port_0, 1U, 0U, 1U, 0U, 0U);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return ra8_etha_get_stats(k_ra8_etha_port_0, out);
}
 
void main(void)
{
  internal_eth_loopback_setup_or_halt();
  ra8_isr_globals_enable();
 
  /* Boot banner -- emit before the loopback runs so the HIL host can
   * confirm the firmware booted even when the ETHA loopback fails for
   * board-specific reasons (PHY not negotiated, missing pull-ups, etc.). */
  (void)ra8_board_uart_console_write(s_eth_loopback_boot_msg,
                                     (size_t)(sizeof(s_eth_loopback_boot_msg) - 1U));
 
  ra8_etha_port_stats_t stats = {};
  if (internal_eth_loopback_run_once(&stats) != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  if (ra8_board_uart_console_write(s_eth_loopback_log_msg,
                                   (size_t)(sizeof(s_eth_loopback_log_msg) - 1U)) != k_ra8_ok) {
    internal_eth_loopback_panic_halt();
  }
  (void)ra8_etha_deinit(k_ra8_etha_port_0);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}