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_eth_coma.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_mstp_regs.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_ehb_baud = 115200U, 
} ehb_const_t;

typedef enum : uint8_t {
  k_ehb_radix       = 10U, 
  k_ehb_dec_u32_max = 10U, 
} ehb_fmt_t;
 
/* Console line fragments (short so each write is one shift-register fill). */
static const uint8_t k_ehb_msg_boot[]    = "eth-hal: boot\r\n";
static const uint8_t k_ehb_msg_eswclk[]  = "eth-hal: eswclk_init rc=";
static const uint8_t k_ehb_msg_mstp[]    = "eth-hal: mstp_eswm rc=";
static const uint8_t k_ehb_msg_coma[]    = "eth-hal: coma_bringup rc=";
static const uint8_t k_ehb_msg_rgmii[]   = "eth-hal: rgmii_select rc=";
static const uint8_t k_ehb_msg_pass[]    = "eth-hal: bringup PASS\r\n";
static const uint8_t k_ehb_msg_fail[]    = "eth-hal: bringup FAIL\r\n";
static const uint8_t k_ehb_msg_hw_fail[] = "eth-hal: hw_init_failed\r\n";
static const uint8_t k_ehb_msg_crlf[]    = "\r\n";

static void ehb_write(const uint8_t* data, uint32_t len)
{
  (void)ra8_board_uart_console_write(data, (size_t)len);
}

static void ehb_write_u32_line(uint32_t val)
{
  uint8_t  buf[k_ehb_dec_u32_max];
  uint32_t n = 0U;
  if (val == 0U) {
    buf[n] = (uint8_t)'0';
    n++;
  }
  while ((val > 0U) && (n < (uint32_t)k_ehb_dec_u32_max)) {
    buf[n] = (uint8_t)((uint32_t)'0' + (val % (uint32_t)k_ehb_radix));
    n++;
    val /= (uint32_t)k_ehb_radix;
  }
  for (uint32_t i = 0U; i < n; i++) {
    ehb_write(&buf[n - 1U - i], 1U);
  }
  ehb_write(k_ehb_msg_crlf, (uint32_t)sizeof(k_ehb_msg_crlf) - 1U);
}

[[noreturn]] static void ehb_panic_halt(void)
{
  ehb_write(k_ehb_msg_hw_fail, (uint32_t)sizeof(k_ehb_msg_hw_fail) - 1U);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void ehb_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    ehb_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    ehb_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    ehb_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ehb_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_ehb_baud) != k_ra8_ok) {
    ehb_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t ehb_run_once(void)
{
  ra8_err_t rc = ra8_cgc_eswclk_init();
  ehb_write(k_ehb_msg_eswclk, (uint32_t)sizeof(k_ehb_msg_eswclk) - 1U);
  ehb_write_u32_line((uint32_t)rc);
  if (rc != k_ra8_ok) {
    return rc;
  }
 
  rc = ra8_mstp_enable(k_ra8_mstp_eswm);
  ehb_write(k_ehb_msg_mstp, (uint32_t)sizeof(k_ehb_msg_mstp) - 1U);
  ehb_write_u32_line((uint32_t)rc);
  if (rc != k_ra8_ok) {
    return rc;
  }
 
  rc = ra8_eth_coma_bringup();
  ehb_write(k_ehb_msg_coma, (uint32_t)sizeof(k_ehb_msg_coma) - 1U);
  ehb_write_u32_line((uint32_t)rc);
  if (rc != k_ra8_ok) {
    return rc;
  }
 
  rc = ra8_eth_rgmii_select(k_ra8_eth_mii_port_1);
  ehb_write(k_ehb_msg_rgmii, (uint32_t)sizeof(k_ehb_msg_rgmii) - 1U);
  ehb_write_u32_line((uint32_t)rc);
  return rc;
}
 
void main(void)
{
  ehb_setup_or_halt();
  ra8_isr_globals_enable();
 
  ehb_write(k_ehb_msg_boot, (uint32_t)sizeof(k_ehb_msg_boot) - 1U);
 
  if (ehb_run_once() != k_ra8_ok) {
    ehb_write(k_ehb_msg_fail, (uint32_t)sizeof(k_ehb_msg_fail) - 1U);
  } else {
    ehb_write(k_ehb_msg_pass, (uint32_t)sizeof(k_ehb_msg_pass) - 1U);
  }
 
  while (1) {
    __asm__ volatile("wfi");
  }
}