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_log.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
#include "ra8_usb.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"
#include "ux_system.h"
 
/* SysTick handler lives in libs/ra8_core/src/ra8_time.c -- the project's
 * shared weak SysTick_Handler dispatches into ThreadX (via a weak
 * extern to `_tx_timer_interrupt`) AND re-arms the USB storm-guard
 * NVIC line (via a weak extern to `ux_dcd_ra8_usb_irq_reenable`), so
 * no per-app override is needed. Closes Issue #8. */
#endif
 
/* -------------------------------------------------------------------------- */
/* Pinout (FSP-aligned, EK-RA8D2 v1 User's Manual) */
/* -------------------------------------------------------------------------- */

static const ra8_port_pin_t k_demo_pin_vbus   = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;
static const ra8_port_pin_t k_demo_pin_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;
static const ra8_port_pin_t k_demo_pin_dp     = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;
static const ra8_port_pin_t k_demo_pin_dm     = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_demo_thread_stack    = 8192U,  
  k_demo_usbx_pool_bytes = 32768U, 
  k_demo_echo_buf_bytes  = 64U,    
  k_demo_idle_ticks      = 1U,     
} demo_config_t;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_demo_thread;

static UCHAR s_demo_stack[k_demo_thread_stack];

static UCHAR s_usbx_pool[k_demo_usbx_pool_bytes];

static UX_SLAVE_CLASS_CDC_ACM* s_cdc_acm = UX_NULL;

typedef struct {
  volatile uint32_t loop_iter;       
  volatile uint32_t loop_cdc_null;   
  volatile uint32_t loop_pre_read;   
  volatile uint32_t loop_post_read;  
  volatile uint32_t loop_read_ok;    
  volatile uint32_t loop_read_zero;  
  volatile uint32_t loop_pre_write;  
  volatile uint32_t loop_post_write; 
} demo_diag_t;

volatile demo_diag_t s_demo_diag = {};

static TX_SEMAPHORE s_cdc_active_sem;
 
/* -------------------------------------------------------------------------- */
/* USB descriptors (DEVICE + CONFIG + IAD + CDC interfaces + endpoints) */
/* -------------------------------------------------------------------------- */
 
/* VID/PID matches the prior bare-metal app (pid.codes test range). The
 * configuration is one CDC ACM communications interface + one CDC data
 * interface, with EP3 IN (interrupt) for notifications and EP2 OUT /
 * EP1 IN (bulk, 64-byte MPS) for the data pipes. Layout per CDC 1.20
 * sec 5 + USB 2.0 sec 9.6.
 */
static UCHAR s_device_framework_fs[] = {
  /* Device descriptor (USB 2.0 sec 9.6.1) -- 18 bytes.
     bcdUSB = 0x0200 (USB 2.0); macOS rejects IAD-based composite
     devices that advertise USB 1.1 (IAD ECN was added in USB 2.0). */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0xEFU, /* class      = MISC   */
  0x02U, /* subclass   = common */
  0x01U, /* protocol   = IAD    */
  0x40U,
  0x09U,
  0x12U,
  0x0AU,
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (75 bytes total: 9 cfg + 8 IAD + 9 CCI +
     5 hdr + 5 call-mgmt + 4 ACM + 5 union + 7 EP3 + 9 DCI + 7 EP2 +
     7 EP1 = 75 = 0x4B).  Host reads wTotalLength then requests that
     many bytes; truncating to 0x43 silently dropped EP1 IN, which
     caused USBX to dereference a NULL endpoint after SET_CONFIG and
     escalate to lockup (PC=0xEFFFFFFE). */
  0x09U,
  0x02U,
  0x4BU,
  0x00U,
  0x02U,
  0x01U,
  0x00U,
  0x80U, /* bmAttributes = bus-powered (bit 7 reserved-1).  Was 0xC0
            (self-powered) which conflicted with bMaxPower=100mA. */
  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 (CDC 1.20). */
  0x05U,
  0x24U,
  0x00U,
  0x20U,
  0x01U,
  /* Call-management functional descriptor.
     bmCapabilities = 0x01 (device handles call management itself);
     bDataInterface=0x01 only makes sense if D0 is set. */
  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: "EK-RA8D2 CDC Echo!" (18 ASCII bytes). */
  0x09U,
  0x04U,
  0x02U,
  0x12U,
  'E',
  'K',
  '-',
  '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',
  '0',
  '1',
};
 
/* 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 demo_cdc_activate(VOID* cdc_instance)
{
  s_cdc_acm = (UX_SLAVE_CLASS_CDC_ACM*)cdc_instance;
  /* USBX writes ux_slave_device_state = CONFIGURED in
   * _ux_device_stack_configuration_set just before invoking this
   * activate callback. Pin it here so any concurrent IRQ/poll-driven
   * write in the dispatch worker observes the chapter-9 result and
   * does not demote it back to ATTACHED, which would break the
   * subsequent cdc_acm_read state gate. */
  if (_ux_system_slave != UX_NULL) {
    _ux_system_slave->ux_system_slave_device.ux_slave_device_state =
      (unsigned long)UX_DEVICE_CONFIGURED;
  }
  /* Wake the demo loop -- it blocks on s_cdc_active_sem instead of
   * polling s_cdc_acm with tx_thread_sleep, which never returned on
   * this hardware. */
  (void)tx_semaphore_put(&s_cdc_active_sem);
  /* CDC bulk endpoints: EP2 OUT -> pipe 2, EP1 IN -> pipe 1. Enable
   * the bridge's ISR-side auto-echo, which mirrors OUT data back on
   * the IN pipe directly inside the ISR -- ~10x faster than the
   * worker-thread _read/_write loop. demo_worker's _read/_write call
   * is suppressed under the matching s_dcd_auto_echo_enable check so
   * the two paths cannot race on the bulk-OUT pipe. */
  ux_dcd_ra8_usb_auto_echo_enable(2U, 1U);
}

static VOID demo_cdc_deactivate(VOID* cdc_instance)
{
  (void)cdc_instance;
  s_cdc_acm = UX_NULL;
}
 
/* -------------------------------------------------------------------------- */
/* Worker thread: bring USBX up + echo loop */
/* -------------------------------------------------------------------------- */

static UINT demo_usbx_stack_up(void)
{
  if (_ux_system_initialize(s_usbx_pool, k_demo_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 demo_cdc_class_register(void)
{
  UX_SLAVE_CLASS_CDC_ACM_PARAMETER cdc_params = {
    .ux_slave_class_cdc_acm_instance_activate   = demo_cdc_activate,
    .ux_slave_class_cdc_acm_instance_deactivate = demo_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 demo_pin_configured_state(void)
{
  if (_ux_system_slave != UX_NULL) {
    _ux_system_slave->ux_system_slave_device.ux_slave_device_state =
      (unsigned long)UX_DEVICE_CONFIGURED;
  }
}

static void demo_echo_iter(UCHAR* buf, ULONG cap)
{
  demo_pin_configured_state();
  ULONG n = 0UL;
  s_demo_diag.loop_pre_read++;
  UINT read_status = _ux_device_class_cdc_acm_read(s_cdc_acm, buf, cap, &n);
  s_demo_diag.loop_post_read++;
  if (read_status != UX_SUCCESS) {
    tx_thread_sleep(k_demo_idle_ticks);
    return;
  }
  s_demo_diag.loop_read_ok++;
  if (n == 0UL) {
    s_demo_diag.loop_read_zero++;
    return;
  }
  s_demo_diag.loop_pre_write++;
  if (_ux_device_class_cdc_acm_write(s_cdc_acm, buf, n, &n) != UX_SUCCESS) {
    return;
  }
  s_demo_diag.loop_post_write++;
  for (ULONG i = 0UL; i < n; i++) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
  }
}

static VOID demo_worker(ULONG arg)
{
  (void)arg;
 
  if (demo_usbx_stack_up() != UX_SUCCESS) {
    return;
  }
  if (demo_cdc_class_register() != UX_SUCCESS) {
    return;
  }
  if (ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs) != k_ra8_ok) {
    return;
  }
  if (ra8_usb_device_attach(k_ra8_usb_speed_fs, true) != k_ra8_ok) {
    return;
  }
 
  UCHAR buf[k_demo_echo_buf_bytes];
  (void)buf;            /* Auto-echo owns the data path; buf reserved for future fallback. */
  (void)demo_echo_iter; /* Kept for the optional non-auto-echo fallback path.              */
  while (1) {
    s_demo_diag.loop_iter++;
    if (s_cdc_acm == UX_NULL) {
      s_demo_diag.loop_cdc_null++;
      /* Block until demo_cdc_activate posts the semaphore. Avoids
       * tx_thread_sleep, which we observed never returning on this
       * silicon under polled-dispatch worker load. */
      (void)tx_semaphore_get(&s_cdc_active_sem, TX_WAIT_FOREVER);
      continue;
    }
    /* Auto-echo handles bulk OUT -> IN mirroring inside the ISR.
     * Invoking demo_echo_iter here would race with auto-echo on the
     * IN pipe and deliver out-of-order data for MPS-aligned packets. */
    tx_thread_sleep(k_demo_idle_ticks);
  }
}
 
/* -------------------------------------------------------------------------- */
/* ThreadX kernel entry: spawn the worker */
/* -------------------------------------------------------------------------- */

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_semaphore_name[] = "cdc_active";
  static CHAR s_thread_name[]    = "usb_cdc_echo";
 
  (void)first_unused_memory;
  (void)tx_semaphore_create(&s_cdc_active_sem, s_semaphore_name, 0U);
  (void)tx_thread_create(&s_demo_thread,
                         s_thread_name,
                         demo_worker,
                         0UL,
                         s_demo_stack,
                         k_demo_thread_stack,
                         8U, /* priority          */
                         8U, /* preempt threshold */
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup helpers */
/* -------------------------------------------------------------------------- */

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

[[nodiscard]] static ra8_err_t demo_pins_init(void)
{
  ra8_err_t err = ra8_pfs_route_peripheral(k_demo_pin_vbus, k_ra8_psel_usb_fs, "usb_cdc.vbus");
  if (err != k_ra8_ok) {
    return err;
  }
  /* P500 is the EK-RA8D2 USB-FS role-select GPIO per the v1 User's
   * Manual section "USB Full Speed" (J11 connector): drive LOW for
   * device mode, HIGH for host mode. Routing P500 to the USBFS
   * peripheral function lets the USB module drive it as VBUSEN
   * (host-mode VBUS supply enable, default HIGH) which keeps the chip
   * in HOST mode and prevents enumeration. For this device-mode demo
   * we instead claim P500 as a GPIO output and drive it LOW so the
   * board's role-select circuitry presents a USB device to the host. */
  err = ra8_gpio_output_init(k_demo_pin_vbusen, k_ra8_level_low);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_demo_pin_dp, k_ra8_psel_usb_fs, "usb_cdc.dp");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_pfs_route_peripheral(k_demo_pin_dm, k_ra8_psel_usb_fs, "usb_cdc.dm");
}

void main(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    demo_panic_halt();
  }
 
  /* Bring up PLL2 -> USBCKCR / USBCKDIVCR so USBFS sees a spec-compliant
   * 48 MHz reference (PLL2P 240 MHz / 5). Must run BEFORE any caller
   * releases MSTPB11 (USBFS) -- the SREQ -> SRDY handshake silently
   * hangs otherwise (HUM Ch 9 "Clock selection switching procedure"
   * step 1). Without this the SIE never sees a 48 MHz clock and the
   * host never enumerates the device. The init-order audit
   * (scripts/checks/audit_init_order.py) requires CGC bring-up to
   * land BEFORE peripheral inits like ra8_log_init, so the RTT
   * heart-beat moves down to right after the time/board bring-up. */
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (demo_pins_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  ra8_log_init();
  ra8_log_info("USBCDC", "usb_cdc_echo boot, CGC PLL2 enable OK");
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  /* tx_kernel_enter is __noreturn -- it never comes back. */
  tx_kernel_enter();
#endif
 
  demo_panic_halt();
}