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_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 "usb_selftest_cdc_steps.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_cdc_acm.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; 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_cdc_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_cdc_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_cdc_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_cdc_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_cdc_pin_hs_vbus = (ra8_port_pin_t)k_ra8_board_usbhs_pin_vbus;

static const ra8_port_pin_t k_cdc_pin_hs_pwr = (ra8_port_pin_t)k_ra8_board_usbhs_pin_pwr;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */
 
/* The shared sizing/geometry enums (::cdc_config_t, ::cdc_geom_t) live in the
 * companion `usb_selftest_cdc_steps.h`; the host-only formatter, mask, and
 * phase enums live in `usb_selftest_cdc_steps.c`. Only the device-side step
 * enum is private to this unit. */

typedef enum : uint32_t {
  k_cdc_dev_step_stack  = 1U, 
  k_cdc_dev_step_class  = 2U, 
  k_cdc_dev_step_dcd    = 3U, 
  k_cdc_dev_step_attach = 4U, 
  k_cdc_dev_step_echo   = 5U, 
} cdc_dev_step_t;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX workers + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;

static UCHAR s_device_stack[k_cdc_thread_stack];

static TX_THREAD s_host_thread;

static UCHAR s_host_stack[k_cdc_host_stack];

static UCHAR s_usbx_pool[k_cdc_usbx_pool_bytes];

static UX_SLAVE_CLASS_CDC_ACM* s_cdc_acm = UX_NULL;

static TX_SEMAPHORE s_cdc_active_sem;
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (device side) */
/* -------------------------------------------------------------------------- */
 
/* The host-side ladder probes (``s_dbg_phase``, ``s_dbg_rounds_ok``,
 * ``s_dbg_pid``, ``s_dbg_mismatch``, ``s_dbg_pass_count``) live in the
 * companion `usb_selftest_cdc_steps.c` alongside their only writers. */

static volatile uint32_t s_dbg_dev_echo_calls;
static volatile uint32_t s_dbg_dev_last_len;
static volatile uint32_t s_dbg_dev_step;
static volatile uint32_t s_dbg_dev_err;
 
/* -------------------------------------------------------------------------- */
/* USB descriptors (CDC-ACM: comm + data interface via an IAD) */
/* -------------------------------------------------------------------------- */
 
/* CDC-ACM config: one communications interface + one data interface joined
 * by an Interface Association Descriptor, EP3 IN (interrupt notify), EP2 OUT
 * / EP1 IN (bulk data, 64-byte MPS). Layout per CDC 1.20 sec 5 + USB 2.0 sec
 * 9.6 -- byte-identical to the proven usb_cdc_echo device, retagged PID
 * 0x0017 for the CDC self-test identity. The host only drives the bulk data
 * pipes (EP2 OUT / EP1 IN); the interrupt-IN notify endpoint is unused. */
static UCHAR s_device_framework_fs[] = {
  /* Device descriptor (USB 2.0 sec 9.6.1) -- 18 bytes. bcdUSB 0x0200 and
     class MISC/common/IAD so IAD-based composites enumerate cleanly. */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0xEFU, /* class      = MISC   */
  0x02U, /* subclass   = common */
  0x01U, /* protocol   = IAD    */
  0x40U,
  0x09U,
  0x12U,
  0x17U, /* PID = 0x0017 (pid.codes test). */
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (75 bytes total = 0x4B). */
  0x09U,
  0x02U,
  0x4BU,
  0x00U,
  0x02U,
  0x01U,
  0x00U,
  0x80U,
  0x32U,
  /* Interface association (CDC). */
  0x08U,
  0x0BU,
  0x00U,
  0x02U,
  0x02U,
  0x02U,
  0x01U,
  0x00U,
  /* Communications interface (CDC ACM). */
  0x09U,
  0x04U,
  0x00U,
  0x00U,
  0x01U,
  0x02U,
  0x02U,
  0x01U,
  0x00U,
  /* CDC header functional descriptor. bcdCDC = 0x0120. */
  0x05U,
  0x24U,
  0x00U,
  0x20U,
  0x01U,
  /* Call-management functional descriptor. */
  0x05U,
  0x24U,
  0x01U,
  0x01U,
  0x01U,
  /* ACM functional descriptor. */
  0x04U,
  0x24U,
  0x02U,
  0x02U,
  /* Union functional descriptor. */
  0x05U,
  0x24U,
  0x06U,
  0x00U,
  0x01U,
  /* Interrupt-IN endpoint (EP3 IN, 8-byte MPS, 255 ms poll). */
  0x07U,
  0x05U,
  0x83U,
  0x03U,
  0x08U,
  0x00U,
  0xFFU,
  /* Data-class interface. */
  0x09U,
  0x04U,
  0x01U,
  0x00U,
  0x02U,
  0x0AU,
  0x00U,
  0x00U,
  0x00U,
  /* Bulk-OUT endpoint (EP2 OUT, 64-byte MPS). */
  0x07U,
  0x05U,
  0x02U,
  0x02U,
  0x40U,
  0x00U,
  0x00U,
  /* Bulk-IN endpoint (EP1 IN, 64-byte MPS). */
  0x07U,
  0x05U,
  0x81U,
  0x02U,
  0x40U,
  0x00U,
  0x00U,
};

static UCHAR s_string_framework[] = {
  /* idx 1: "Brighton Sikarskie". */
  0x09U,
  0x04U,
  0x01U,
  0x12U,
  'B',
  'r',
  'i',
  'g',
  'h',
  't',
  'o',
  'n',
  ' ',
  'S',
  'i',
  'k',
  'a',
  'r',
  's',
  'k',
  'i',
  'e',
  /* idx 2: "RA8D2 CDC ECHO". */
  0x09U,
  0x04U,
  0x02U,
  0x0EU,
  'R',
  'A',
  '8',
  'D',
  '2',
  ' ',
  'C',
  'D',
  'C',
  ' ',
  'E',
  'C',
  'H',
  'O',
  /* idx 3: serial. */
  0x09U,
  0x04U,
  0x03U,
  0x08U,
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '1',
  '3',
};
 
/* USBX LANGID descriptor 0x0409 (English-US), little-endian byte pair. */
typedef enum : uint8_t {
  k_usb_langid_en_us_lo = 0x09U, 
  k_usb_langid_en_us_hi = 0x04U, 
} usb_langid_byte_t;

static UCHAR s_language_id_framework[] = {k_usb_langid_en_us_lo, k_usb_langid_en_us_hi};
 
/* -------------------------------------------------------------------------- */
/* CDC-ACM activate / deactivate callbacks */
/* -------------------------------------------------------------------------- */

static VOID cdc_activate(VOID* cdc_instance)
{
  s_cdc_acm = (UX_SLAVE_CLASS_CDC_ACM*)cdc_instance;
  if (_ux_system_slave != UX_NULL) {
    _ux_system_slave->ux_system_slave_device.ux_slave_device_state =
      (unsigned long)UX_DEVICE_CONFIGURED;
  }
  (void)tx_semaphore_put(&s_cdc_active_sem);
}

static VOID cdc_deactivate(VOID* cdc_instance)
{
  (void)cdc_instance;
  s_cdc_acm = UX_NULL;
}
 
/* -------------------------------------------------------------------------- */
/* Device side: USBX CDC-ACM echo */
/* -------------------------------------------------------------------------- */

static UINT cdc_usbx_stack_up(void)
{
  if (_ux_system_initialize(s_usbx_pool, k_cdc_usbx_pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return UX_ERROR;
  }
  return _ux_device_stack_initialize((UCHAR*)UX_NULL,
                                     0,
                                     s_device_framework_fs,
                                     sizeof(s_device_framework_fs),
                                     s_string_framework,
                                     sizeof(s_string_framework),
                                     s_language_id_framework,
                                     sizeof(s_language_id_framework),
                                     UX_NULL);
}

static UINT cdc_class_register(void)
{
  UX_SLAVE_CLASS_CDC_ACM_PARAMETER cdc_params = {
    .ux_slave_class_cdc_acm_instance_activate   = cdc_activate,
    .ux_slave_class_cdc_acm_instance_deactivate = cdc_deactivate,
    .ux_slave_class_cdc_acm_parameter_change    = UX_NULL,
  };
  static UCHAR s_class_name[] = "ux_slave_class_cdc_acm";
 
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_cdc_acm_entry,
                                         1,
                                         0,
                                         &cdc_params);
}

static void cdc_echo_iter(UCHAR* buf, ULONG cap)
{
  if (_ux_system_slave != UX_NULL) {
    _ux_system_slave->ux_system_slave_device.ux_slave_device_state =
      (unsigned long)UX_DEVICE_CONFIGURED;
  }
  ULONG n = 0UL;
  if (_ux_device_class_cdc_acm_read(s_cdc_acm, buf, cap, &n) != UX_SUCCESS) {
    tx_thread_sleep(1U);
    return;
  }
  if (n == 0UL) {
    return;
  }
  if (_ux_device_class_cdc_acm_write(s_cdc_acm, buf, n, &n) != UX_SUCCESS) {
    return;
  }
  s_dbg_dev_echo_calls++;
  s_dbg_dev_last_len = (uint32_t)n;
  (void)ra8_board_led_toggle(k_ra8_board_led1);
}

static VOID cdc_device_worker(ULONG arg)
{
  (void)arg;
 
  UINT ux = cdc_usbx_stack_up();
  if (ux != UX_SUCCESS) {
    s_dbg_dev_err = (uint32_t)ux;
    return;
  }
  s_dbg_dev_step = (uint32_t)k_cdc_dev_step_stack;
  ux             = cdc_class_register();
  if (ux != UX_SUCCESS) {
    s_dbg_dev_err = (uint32_t)ux;
    return;
  }
  s_dbg_dev_step = (uint32_t)k_cdc_dev_step_class;
  ra8_err_t e    = ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs);
  if (e != k_ra8_ok) {
    s_dbg_dev_err = (uint32_t)e;
    return;
  }
  s_dbg_dev_step = (uint32_t)k_cdc_dev_step_dcd;
  e              = ra8_usb_device_attach(k_ra8_usb_speed_fs, true);
  if (e != k_ra8_ok) {
    s_dbg_dev_err = (uint32_t)e;
    return;
  }
  s_dbg_dev_step = (uint32_t)k_cdc_dev_step_attach;
 
  static UCHAR s_echo_buf[k_cdc_echo_buf];
  while (1) {
    if (s_cdc_acm == UX_NULL) {
      (void)tx_semaphore_get(&s_cdc_active_sem, TX_WAIT_FOREVER);
      continue;
    }
    s_dbg_dev_step = (uint32_t)k_cdc_dev_step_echo;
    cdc_echo_iter(s_echo_buf, (ULONG)k_cdc_echo_buf);
  }
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_semaphore_name[]     = "cdc_active";
  static CHAR s_device_thread_name[] = "cdc_device";
  static CHAR s_host_thread_name[]   = "cdc_host";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_semaphore_create(&s_cdc_active_sem, s_semaphore_name, 0U);
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         cdc_device_worker,
                         0UL,
                         s_device_stack,
                         k_cdc_thread_stack,
                         (UINT)k_cdc_dev_priority,
                         (UINT)k_cdc_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  (void)tx_thread_create(&s_host_thread,
                         s_host_thread_name,
                         cdc_host_worker,
                         0UL,
                         s_host_stack,
                         k_cdc_host_stack,
                         (UINT)k_cdc_host_priority,
                         (UINT)k_cdc_host_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

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

static void cdc_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_cdc_pin_fs_vbus, k_ra8_psel_usb_fs, "cdc.fs_vbus") != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_gpio_output_init(k_cdc_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_cdc_pin_fs_dp, k_ra8_psel_usb_fs, "cdc.fs_dp") != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_cdc_pin_fs_dm, k_ra8_psel_usb_fs, "cdc.fs_dm") != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_board_io_expander_set_usbhs_host_mode() != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_gpio_output_init(k_cdc_pin_hs_pwr, k_ra8_level_high) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_cdc_pin_hs_vbus, k_ra8_psel_usb_hs, "cdc.hs_vbus") != k_ra8_ok) {
    cdc_panic_halt();
  }
}

static void cdc_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_cgc_usbhs_pll_enable() != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_cdc_baud) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    cdc_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    cdc_panic_halt();
  }
  cdc_route_usb_or_halt();
}

void main(void)
{
  cdc_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  cdc_panic_halt();
}