main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci_spi.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_spi.h"
#include "ra8_time.h"
#include "usb_selftest_microsd_steps.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_dcd_ra8_usb.h"
 
/* Strong SysTick override: route the tick into BOTH the ra8_time millisecond
 * counter (for ra8_delay_ms and the polled host stack's timeouts) AND
 * ThreadX's timer; the 1 ms pulse also recovers the DCD's storm-guard mask. */
 
extern void _tx_timer_interrupt(void);

static volatile bool s_tx_kernel_up = false;
 
void SysTick_Handler(void);
void SysTick_Handler(void)
{
  ra8_time_on_tick();
  if (s_tx_kernel_up) {
    _tx_timer_interrupt();
    ux_dcd_ra8_usb_irq_reenable();
  }
}
#endif
 
/* -------------------------------------------------------------------------- */
/* Pinout (FSP-aligned, EK-RA8D2 v1 User's Manual) */
/* -------------------------------------------------------------------------- */

static const ra8_port_pin_t k_microsd_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_microsd_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_microsd_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_microsd_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_microsd_pin_hs_vbus = (ra8_port_pin_t)k_ra8_board_usbhs_pin_vbus;

static const ra8_port_pin_t k_microsd_pin_hs_pwr = (ra8_port_pin_t)k_ra8_board_usbhs_pin_pwr;

static const ra8_port_pin_t k_microsd_pin_sd_sck = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck;
static const ra8_port_pin_t k_microsd_pin_sd_cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo;
static const ra8_port_pin_t k_microsd_pin_sd_copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi;
static const ra8_port_pin_t k_microsd_pin_sd_cs = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */
 
/*
 * The shared compile-time tunables, hex/mask formatter sizing, LUN geometry,
 * host/device progress phases, SCSI sense triples, and USB LANGID bytes all
 * live as typed enums in "usb_selftest_microsd_steps.h" so main.c and both
 * helper siblings observe one definition.
 */
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX workers + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;

static UCHAR s_device_stack[k_microsd_thread_stack];

static TX_THREAD s_host_thread;

static UCHAR s_host_stack[k_microsd_host_stack];
 
/* The USBX pool, SCSI INQUIRY strings, USB descriptor frameworks, and the
 * device/host-owned J-Link progress probes live in
 * "usb_selftest_microsd_steps.c"; only the SD bring-up probes and the two
 * cross-TU snapshot symbols are owned here. */
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (SD bring-up owned) */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_sd_err = (uint32_t)k_microsd_no_mismatch;
static volatile uint32_t s_dbg_sd_blocks;

volatile uint32_t s_usb_selftest_microsd_dbg_bootsig;

static uint32_t s_pclka_hz = 0U;

UCHAR s_usb_selftest_microsd_sd_snapshot[k_microsd_snap_bytes];
 
/* -------------------------------------------------------------------------- */
/* microSD over SCI0 Simple-SPI -- READ-ONLY backing snapshot */
/* -------------------------------------------------------------------------- */
 
/* cppcheck-suppress-begin [constParameterCallback] -- these three hooks
 * are bound to the ra8_sdmmc_spi_transport_t vtable, whose signatures take
 * a non-const void* ctx; const-qualifying would break the type. */

static ra8_err_t microsd_spi_set_clock(void* ctx, uint32_t hz)
{
  const uint32_t pclka = *(const uint32_t*)ctx;
  return ra8_sci_spi_set_clock((uint8_t)k_microsd_sd_spi_channel, hz, pclka);
}

static ra8_err_t microsd_spi_cs(void* ctx, bool asserted)
{
  (void)ctx;
  return ra8_gpio_write(k_microsd_pin_sd_cs, asserted ? k_ra8_level_low : k_ra8_level_high);
}

static ra8_err_t microsd_spi_xfer(void* ctx, const uint8_t* tx, uint8_t* rx, uint32_t len)
{
  (void)ctx;
  return ra8_sci_spi_xfer((uint8_t)k_microsd_sd_spi_channel, tx, rx, len);
}
/* cppcheck-suppress-end [constParameterCallback] */

[[nodiscard]] static ra8_err_t microsd_sd_spi_open(void)
{
  ra8_err_t err =
    ra8_pfs_route_peripheral(k_microsd_pin_sd_sck, k_ra8_psel_sci_async, "microsd.sck");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_microsd_pin_sd_cipo, k_ra8_psel_sci_async, "microsd.cipo");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_microsd_pin_sd_copi, k_ra8_psel_sci_async, "microsd.copi");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_gpio_output_init(k_microsd_pin_sd_cs, k_ra8_level_high);
  if (err != k_ra8_ok) {
    return err;
  }
  const ra8_sci_spi_cfg_t spi_cfg = {
    .baud_hz   = (uint32_t)k_ra8_sdmmc_spi_clock_init_hz,
    .pclk_hz   = s_pclka_hz,
    .mode      = k_ra8_spi_mode_0,
    .lsb_first = false,
  };
  return ra8_sci_spi_init((uint8_t)k_microsd_sd_spi_channel, &spi_cfg);
}

[[nodiscard]] static ra8_err_t microsd_sd_snapshot(void)
{
  ra8_err_t err = microsd_sd_spi_open();
  if (err != k_ra8_ok) {
    s_dbg_sd_err = (uint32_t)err;
    return err;
  }
  const ra8_sdmmc_spi_transport_t transport = {
    .set_clock = microsd_spi_set_clock,
    .cs        = microsd_spi_cs,
    .xfer      = microsd_spi_xfer,
    .ctx       = &s_pclka_hz,
  };
  err = ra8_sdmmc_spi_init(&transport);
  if (err != k_ra8_ok) {
    s_dbg_sd_err = (uint32_t)err;
    return err;
  }
  uint32_t blocks = 0U;
  (void)ra8_sdmmc_spi_get_capacity(&blocks);
  s_dbg_sd_blocks = blocks;
  for (uint32_t lba = 0U; lba < (uint32_t)k_microsd_sectors; lba++) {
    err = ra8_sdmmc_spi_read_block(
      lba,
      &s_usb_selftest_microsd_sd_snapshot[lba * (uint32_t)k_microsd_block_size]);
    if (err != k_ra8_ok) {
      s_dbg_sd_err = (uint32_t)err;
      return err;
    }
  }
  const bool sig =
    (s_usb_selftest_microsd_sd_snapshot[k_microsd_bootsig_off] == (UCHAR)k_microsd_bootsig_lo) &&
    (s_usb_selftest_microsd_sd_snapshot[k_microsd_bootsig_off + 1U] == (UCHAR)k_microsd_bootsig_hi);
  s_usb_selftest_microsd_dbg_bootsig = sig ? 1U : 0U;
  s_dbg_sd_err                       = 0U;
  return k_ra8_ok;
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_device_thread_name[] = "microsd_device";
  static CHAR s_host_thread_name[]   = "microsd_host";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         microsd_device_worker,
                         0UL,
                         s_device_stack,
                         k_microsd_thread_stack,
                         (UINT)k_microsd_dev_priority,
                         (UINT)k_microsd_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  (void)tx_thread_create(&s_host_thread,
                         s_host_thread_name,
                         microsd_host_worker,
                         0UL,
                         s_host_stack,
                         k_microsd_host_stack,
                         (UINT)k_microsd_host_priority,
                         (UINT)k_microsd_host_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

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

static void microsd_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_microsd_pin_fs_vbus, k_ra8_psel_usb_fs, "microsd.fs_vbus") !=
      k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_gpio_output_init(k_microsd_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_microsd_pin_fs_dp, k_ra8_psel_usb_fs, "microsd.fs_dp") !=
      k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_microsd_pin_fs_dm, k_ra8_psel_usb_fs, "microsd.fs_dm") !=
      k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_board_io_expander_set_usbhs_host_mode() != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_gpio_output_init(k_microsd_pin_hs_pwr, k_ra8_level_high) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_microsd_pin_hs_vbus, k_ra8_psel_usb_hs, "microsd.hs_vbus") !=
      k_ra8_ok) {
    microsd_panic_halt();
  }
}

static void microsd_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_cgc_usbhs_pll_enable() != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) {
    microsd_panic_halt();
  }
  s_pclka_hz = pclka_hz;
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_microsd_baud) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    microsd_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    microsd_panic_halt();
  }
  /* Snapshot SD LBA 0..63 into RAM (read-only) before the kernel starts.
   * On failure s_dbg_sd_err records it and the host verifier reports the
   * missing boot signature -- the board does not hang. */
  (void)microsd_sd_snapshot();
  microsd_route_usb_or_halt();
}

void main(void)
{
  microsd_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  microsd_panic_halt();
}