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_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
#include "ra8_time_constants.h"

typedef enum : uint32_t {
  k_clock_check_half_period_ms = 500U, 
} clock_check_period_t;

volatile uint32_t g_clock_check_match = 0U;

volatile uint32_t g_clock_check_mismatch = 0U;

typedef struct {
  ra8_clock_id_t id;          
  uint32_t       expected_hz; 
} clock_check_expected_t;
 
/* Forward declarations -- definitions appear after main() so the
 * audit_init_order linter sees the canonical CGC -> TIME -> peripheral
 * sequence in source order. */
[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_clock_check_pins_init(void);
[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_clock_check_pins_toggle_all(void);
[[nodiscard]] RA8_INTERNAL static bool      internal_clock_check_verify_all(void);

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

void main(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_clock_check_panic_halt();
  }
 
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_clock_check_panic_halt();
  }
 
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_clock_check_panic_halt();
  }
 
  if (internal_clock_check_pins_init() != k_ra8_ok) {
    internal_clock_check_panic_halt();
  }
 
  ra8_isr_globals_enable();
 
  while (1) {
    if (internal_clock_check_pins_toggle_all() != k_ra8_ok) {
      g_clock_check_mismatch += 1U;
      break;
    }
    if (internal_clock_check_verify_all()) {
      g_clock_check_match += 1U;
    } else {
      g_clock_check_mismatch += 1U;
    }
    ra8_delay_ms(k_clock_check_half_period_ms);
  }
 
  internal_clock_check_panic_halt();
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_clock_check_pins_init(void)
{
  ra8_err_t err = ra8_board_led_init(k_ra8_board_led1);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_led_init(k_ra8_board_led2);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_board_led_init(k_ra8_board_led3);
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_clock_check_pins_toggle_all(void)
{
  ra8_err_t err = ra8_board_led_toggle(k_ra8_board_led1);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_led_toggle(k_ra8_board_led2);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_board_led_toggle(k_ra8_board_led3);
}

[[nodiscard]] RA8_INTERNAL static bool internal_clock_check_verify_all(void)
{
  const clock_check_expected_t kExpected[] = {
    {k_ra8_clock_id_cpuclk0, (uint32_t)k_ra8_cpuclk0_hz},
    {k_ra8_clock_id_cpuclk1, (uint32_t)k_ra8_cpuclk1_hz},
    {k_ra8_clock_id_iclk, (uint32_t)k_ra8_iclk_hz},
    {k_ra8_clock_id_pclka, (uint32_t)k_ra8_pclka_hz},
    {k_ra8_clock_id_pclkb, (uint32_t)k_ra8_pclkb_hz},
    {k_ra8_clock_id_pclkc, (uint32_t)k_ra8_pclkc_hz},
    {k_ra8_clock_id_pclkd, (uint32_t)k_ra8_pclkd_hz},
    {k_ra8_clock_id_pclke, (uint32_t)k_ra8_pclke_hz},
    {k_ra8_clock_id_fclk, (uint32_t)k_ra8_fclk_hz},
    {k_ra8_clock_id_mriclk, (uint32_t)k_ra8_mriclk_hz},
  };
  const uint32_t kExpectedCount = (uint32_t)(sizeof(kExpected) / sizeof(kExpected[0]));
  for (uint32_t i = 0U; i < kExpectedCount; ++i) {
    uint32_t hz = 0U;
    if (ra8_cgc_get_clock_hz(kExpected[i].id, &hz) != k_ra8_ok) {
      return false;
    }
    if (hz != kExpected[i].expected_hz) {
      return false;
    }
  }
  return true;
}