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"
 
/*
 * The host unit-test build (RA8_OFF_TARGET) does not link the
 * ThreadX vendor tree, so `tx_api.h` (and the ThreadX-port header
 * `ra8_threadx.h`) are pulled in only on the cross-compile target.
 */
#ifndef RA8_OFF_TARGET
#include "ra8_threadx.h"
#include "tx_api.h"
#endif
 
/* ---------------------------------------------------------------------------
 * Tunables (typed enums per the project's no-magic-number rule).
 * --------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_retune_thread_stack_bytes = 1024U, 
} retune_stack_t;

typedef enum : uint8_t {
  k_retune_thread_priority = 4U, 
} retune_priority_t;

typedef enum : uint16_t {
  k_retune_loop_ticks = 250U, 
} retune_period_t;

typedef enum : uintptr_t {
  k_retune_syst_rvr_addr = 0xE000E014UL, 
} retune_syst_addr_t;
 
/* ---------------------------------------------------------------------------
 * HIL / EIL observables. Global (non-static) + volatile so the symbols stay
 * linker-visible for J-Link / ra8_emulator --dump-sym and survive optimization.
 * --------------------------------------------------------------------------- */

volatile uint32_t g_threadx_retune_tick = 0U;

volatile uint32_t g_threadx_retune_reload = 0U;

volatile uint32_t g_threadx_retune_bad = 0U;
 
#ifndef RA8_OFF_TARGET
/* ---------------------------------------------------------------------------
 * Static thread + stack storage (cross build only -- TX_THREAD is a vendor
 * type unavailable on the host clang-tidy pass).
 * --------------------------------------------------------------------------- */

[[gnu::aligned(8)]] static uint8_t s_retune_stack[k_retune_thread_stack_bytes];

static TX_THREAD s_retune_thread;
 
/* SysTick handler lives in libs/ra8_core/src/ra8_time.c -- the shared weak
 * SysTick_Handler dispatches to ThreadX via a weak extern to
 * `_tx_timer_interrupt`, so no per-app override is needed (issue #8). */

RA8_INTERNAL static uint32_t internal_retune_read_syst_rvr(void)
{
  volatile const uint32_t* rvr = (volatile const uint32_t*)k_retune_syst_rvr_addr;
  return *rvr;
}
 
/* ---------------------------------------------------------------------------
 * Thread body.
 * --------------------------------------------------------------------------- */

RA8_INTERNAL static void internal_retune_thread_entry(ULONG thread_input)
{
  (void)thread_input;
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    g_threadx_retune_tick += 1U;
    (void)tx_thread_sleep((ULONG)k_retune_loop_ticks);
  }
}
 
/* ---------------------------------------------------------------------------
 * tx_application_define -- ThreadX calls this once, after
 * _tx_initialize_low_level but before the first scheduling decision.
 * --------------------------------------------------------------------------- */

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_thread_name[] = "retune";
 
  (void)first_unused_memory;
 
  /* Reprogram SysTick.LOAD from the live CPUCLK0 (issue #287). */
  const ra8_err_t retune_err = ra8_threadx_systick_retune();
 
  /* Independently recompute the expected reload from the live clock and
   * compare against what retune actually left in SYST_RVR. Any deviation
   * means the kernel tick would drift, so flag it for the probe. */
  uint32_t        cpuclk_hz = 0U;
  uint32_t        expected  = 0U;
  const ra8_err_t clk_err   = ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk_hz);
  const ra8_err_t rel_err =
    ra8_threadx_systick_reload_for(cpuclk_hz, (uint32_t)k_ra8_threadx_tick_hz, &expected);
  const uint32_t live_rvr = internal_retune_read_syst_rvr();
 
  g_threadx_retune_reload = expected;
  if ((retune_err != k_ra8_ok) || (clk_err != k_ra8_ok) || (rel_err != k_ra8_ok) ||
      (live_rvr != expected)) {
    g_threadx_retune_bad = 1U;
  }
 
  const UINT err = tx_thread_create(&s_retune_thread,
                                    s_thread_name,
                                    internal_retune_thread_entry,
                                    0U,
                                    s_retune_stack,
                                    (ULONG)k_retune_thread_stack_bytes,
                                    (UINT)k_retune_thread_priority,
                                    (UINT)k_retune_thread_priority,
                                    TX_NO_TIME_SLICE,
                                    TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
}
#endif /* !RA8_OFF_TARGET */
 
/* ---------------------------------------------------------------------------
 * main() -- raise the clock, bring up the LED, then drop into ThreadX.
 * --------------------------------------------------------------------------- */

void main(void)
{
  /* Raise CPUCLK0 to the PLL1 target so the retune has a real
   * high-frequency clock to program SysTick against. */
  if (ra8_cgc_init() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
#ifndef RA8_OFF_TARGET
  ra8_isr_globals_enable();
  tx_kernel_enter();
#endif
 
  while (1) {
    __asm__ volatile("wfi");
  }
}