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_sdmmc_spi.h"
#include "ra8_time.h"
#include "usb_msc_sdcard_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 SD driver'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_sdmsc_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_sdmsc_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_sdmsc_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_sdmsc_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;
 
/* -------------------------------------------------------------------------- */
/* J-Link probes + the cross-TU capacity latch */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_sd_err;

volatile uint32_t s_usb_msc_sdcard_blocks;
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

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

[[nodiscard]] static ra8_err_t sdmsc_print_card_banner(uint32_t blocks)
{
  ra8_err_t err = sdmsc_print("usb_msc_sdcard: card ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = sdmsc_print_dec(blocks);
  if (err != k_ra8_ok) {
    return err;
  }
  err = sdmsc_print(" blocks (");
  if (err != k_ra8_ok) {
    return err;
  }
  err = sdmsc_print_dec(blocks / (uint32_t)k_sdmsc_blocks_per_mib);
  if (err != k_ra8_ok) {
    return err;
  }
  return sdmsc_print(" MiB)\r\n");
}

[[nodiscard]] static ra8_err_t sdmsc_card_up(uint32_t pclka_hz)
{
  const ra8_sdmmc_spi_sci_pins_t pins = {
    .sck  = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck,
    .cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo,
    .copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi,
    .cs   = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs,
  };
  ra8_sdmmc_spi_transport_t transport = {};
 
  ra8_err_t err =
    ra8_sdmmc_spi_transport_sci((uint8_t)k_sdmsc_sd_spi_channel, pclka_hz, &pins, &transport);
  if (err != k_ra8_ok) {
    s_dbg_sd_err = (uint32_t)err;
    (void)sdmsc_print_fail("sd transport", err);
    return err;
  }
  err = ra8_sdmmc_spi_init(&transport);
  if (err != k_ra8_ok) {
    s_dbg_sd_err = (uint32_t)err;
    (void)sdmsc_print_fail("sd init (card seated?)", err);
    return err;
  }
  uint32_t blocks = 0U;
  err             = ra8_sdmmc_spi_get_capacity(&blocks);
  if (err != k_ra8_ok) {
    s_dbg_sd_err = (uint32_t)err;
    (void)sdmsc_print_fail("sd capacity", err);
    return err;
  }
  s_usb_msc_sdcard_blocks = blocks;
  s_dbg_sd_err            = 0U;
  return sdmsc_print_card_banner(blocks);
}

static void sdmsc_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_sdmsc_pin_fs_vbus, k_ra8_psel_usb_fs, "sdmsc.fs_vbus") !=
      k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_gpio_output_init(k_sdmsc_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_sdmsc_pin_fs_dp, k_ra8_psel_usb_fs, "sdmsc.fs_dp") != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_sdmsc_pin_fs_dm, k_ra8_psel_usb_fs, "sdmsc.fs_dm") != k_ra8_ok) {
    sdmsc_panic_halt();
  }
}

static void sdmsc_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_sdmsc_baud) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    sdmsc_panic_halt();
  }
  /* Enumerate the card and latch its capacity before the kernel starts.
   * On failure s_dbg_sd_err records it, the FAIL banner is on the wire,
   * and the worker refuses to attach -- the board does not hang. */
  (void)sdmsc_card_up(pclka_hz);
  sdmsc_route_usb_or_halt();
}
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker storage + kernel entry */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;

static UCHAR s_device_stack[k_sdmsc_thread_stack];

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_device_thread_name[] = "sdmsc_device";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         sdmsc_device_worker,
                         0UL,
                         s_device_stack,
                         k_sdmsc_thread_stack,
                         (UINT)k_sdmsc_dev_priority,
                         (UINT)k_sdmsc_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */

void main(void)
{
  sdmsc_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  sdmsc_panic_halt();
}