main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_gpio_constants.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
#include "ra8_usb.h"
#include "ra8_usb_hmsc.h"
#include "usb_selftest_common.h"
#include "usb_selftest_console.h"
#include "usb_selftest_device.h"
#include "usb_selftest_host.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_storage.h"
#include "ux_device_stack.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 (for tx_thread_sleep and USBX class-thread scheduling).
 * The 1 ms pulse also recovers the DCD's storm-guard NVIC 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_selftest_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_selftest_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_selftest_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_selftest_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_selftest_pin_hs_vbus = (ra8_port_pin_t)k_ra8_board_usbhs_pin_vbus;

static const ra8_port_pin_t k_selftest_pin_hs_pwr = (ra8_port_pin_t)k_ra8_board_usbhs_pin_pwr;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker thread storage (device + host TCBs and stacks) */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;

static UCHAR s_device_stack[k_selftest_thread_stack];

static TX_THREAD s_host_thread;

static UCHAR s_host_stack[k_selftest_host_stack];

static VOID selftest_host_worker(ULONG arg)
{
  (void)arg;
 
  tx_thread_sleep(k_selftest_boot_wait_ticks);
  for (;;) {
    const ra8_err_t err = selftest_host_pass();
    if (err == k_ra8_ok) {
      break;
    }
    tx_thread_sleep(k_selftest_retry_ticks);
  }
  while (1) {
    tx_thread_sleep(k_selftest_idle_ticks);
  }
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_device_thread_name[] = "selftest_device";
  static CHAR s_host_thread_name[]   = "selftest_host";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true; /* ThreadX timer state is initialized past here. */
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         selftest_device_worker,
                         0UL,
                         s_device_stack,
                         k_selftest_thread_stack,
                         (UINT)k_selftest_dev_priority,
                         (UINT)k_selftest_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  (void)tx_thread_create(&s_host_thread,
                         s_host_thread_name,
                         selftest_host_worker,
                         0UL,
                         s_host_stack,
                         k_selftest_host_stack,
                         (UINT)k_selftest_host_priority,
                         (UINT)k_selftest_host_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup helpers */
/* -------------------------------------------------------------------------- */

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

static void selftest_route_usb_or_halt(void)
{
  /* FS port: device role. */
  if (ra8_pfs_route_peripheral(k_selftest_pin_fs_vbus, k_ra8_psel_usb_fs, "selftest.fs_vbus") !=
      k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_gpio_output_init(k_selftest_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_selftest_pin_fs_dp, k_ra8_psel_usb_fs, "selftest.fs_dp") !=
      k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_selftest_pin_fs_dm, k_ra8_psel_usb_fs, "selftest.fs_dm") !=
      k_ra8_ok) {
    selftest_panic_halt();
  }
  /* HS port: host role. */
  if (ra8_board_io_expander_set_usbhs_host_mode() != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_gpio_output_init(k_selftest_pin_hs_pwr, k_ra8_level_high) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_selftest_pin_hs_vbus, k_ra8_psel_usb_hs, "selftest.hs_vbus") !=
      k_ra8_ok) {
    selftest_panic_halt();
  }
}

static void selftest_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_cgc_usbhs_pll_enable() != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_selftest_baud) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    selftest_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    selftest_panic_halt();
  }
  selftest_route_usb_or_halt();
}

void main(void)
{
  selftest_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  /* tx_kernel_enter is __noreturn -- it never comes back. */
  tx_kernel_enter();
#endif
 
  selftest_panic_halt();
}