ns_usb.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ns_usb_internal.h"
#include "ra8_usb.h"
#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"
 
/* =============================================================================
 * Bench milestone counters (NS .bss; J-Link reads these)
 * =============================================================================
 *
 * ``g_tz_nsc_cgc_usb_match`` is defined in ns_main.c (the HIL gate symbol). The
 * USB worker advances it once per polled-dispatch iteration, so a continuing
 * advance proves the NS-resident USBX worker is alive and dispatching.
 */

extern volatile uint32_t g_tz_nsc_cgc_usb_match;

typedef enum : uint32_t {
  k_tz_usb_state_stack_up   = 1U, 
  k_tz_usb_state_cdc_ready  = 2U, 
  k_tz_usb_state_dcd_ready  = 3U, 
  k_tz_usb_state_attached   = 4U, 
  k_tz_usb_state_dispatched = 5U, 
} tz_usb_state_t;

volatile uint32_t g_tz_usb_state;

volatile uint32_t g_tz_usb_configured;

volatile uint32_t g_tz_usb_dispatch_count;

volatile uint32_t g_tz_usb_intsts_or;
 
/* =============================================================================
 * Non-Secure ra8_delay_ms (ThreadX-backed; replaces ra8_time.c in the NS link)
 * =============================================================================
 */

void ra8_delay_ms(uint32_t ms)
{
  (void)tx_thread_sleep(ms == 0U ? 1UL : (ULONG)ms);
}

uint32_t ra8_time_ms(void)
{
  return (uint32_t)tx_time_get();
}
 
/* =============================================================================
 * Worker thread + USBX pool storage (NS .bss)
 * =============================================================================
 */

typedef enum : uint32_t {
  k_ns_usb_thread_stack  = 8192U,  
  k_ns_usb_pool_bytes    = 16384U, 
  k_ns_usb_thread_prio   = 8U,     
  k_ns_usb_echo_out_pipe = 2U,     
  k_ns_usb_echo_in_pipe  = 1U,     
} ns_usb_cfg_t;

static TX_THREAD s_ns_usb_thread;

static UCHAR s_ns_usb_stack[k_ns_usb_thread_stack];

static UCHAR s_ns_usbx_pool[k_ns_usb_pool_bytes];

static CHAR s_ns_usb_thread_name[] = "ns_usb_worker";

static UX_SLAVE_CLASS_CDC_ACM* s_ns_cdc_acm = UX_NULL;
 
/* =============================================================================
 * USB descriptors (DEVICE + CONFIG + IAD + CDC interfaces + endpoints)
 * =============================================================================
 *
 * Verbatim from the validated threadx_usbx_cdc_demo: VID/PID 1209:000a (pid.codes
 * test range), one CDC-ACM communications interface + one CDC data interface,
 * EP3 IN (interrupt) for notifications, EP2 OUT / EP1 IN (bulk, 64-byte MPS).
 * Layout per CDC 1.20 sec 5 + USB 2.0 sec 9.6; bcdUSB 0x0200 (macOS rejects IAD
 * composite devices that advertise USB 1.1).
 */
static UCHAR s_ns_device_framework_fs[] = {
  /* Device descriptor (18 bytes). idVendor 0x1209, idProduct 0x000A. */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0xEFU,
  0x02U,
  0x01U,
  0x40U,
  0x09U,
  0x12U,
  0x0AU,
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (wTotalLength 0x4B = 75). */
  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_ns_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!". */
  0x09U,
  0x04U,
  0x02U,
  0x12U,
  'E',
  'K',
  '-',
  'R',
  'A',
  '8',
  'D',
  '2',
  ' ',
  'C',
  'D',
  'C',
  ' ',
  'E',
  'c',
  'h',
  'o',
  '!',
  /* idx 3: serial "00000001". */
  0x09U,
  0x04U,
  0x03U,
  0x08U,
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '1',
};

typedef enum : uint8_t {
  k_ns_usb_langid_lo = 0x09U, 
  k_ns_usb_langid_hi = 0x04U, 
} ns_usb_langid_t;
 
static UCHAR s_ns_language_id_framework[] = {k_ns_usb_langid_lo, k_ns_usb_langid_hi};
 
/* =============================================================================
 * CDC-ACM activate / deactivate callbacks
 * =============================================================================
 */

static VOID ns_cdc_activate(VOID* cdc_instance)
{
  s_ns_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;
  }
  /* Mirror CDC bulk OUT (pipe 2) back on IN (pipe 1) inside the bridge
   * bottom-half, which the polled ra8_usb_dispatch reaches. */
  ux_dcd_ra8_usb_auto_echo_enable((uint8_t)k_ns_usb_echo_out_pipe, (uint8_t)k_ns_usb_echo_in_pipe);
  g_tz_usb_configured += 1U;
}

static VOID ns_cdc_deactivate(VOID* cdc_instance)
{
  (void)cdc_instance;
  s_ns_cdc_acm = UX_NULL;
}
 
/* =============================================================================
 * USBX bring-up helpers
 * =============================================================================
 */

static UINT ns_usbx_stack_up(void)
{
  if (_ux_system_initialize(s_ns_usbx_pool, (ULONG)k_ns_usb_pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return UX_ERROR;
  }
  return _ux_device_stack_initialize((UCHAR*)UX_NULL,
                                     0,
                                     s_ns_device_framework_fs,
                                     sizeof(s_ns_device_framework_fs),
                                     s_ns_string_framework,
                                     sizeof(s_ns_string_framework),
                                     s_ns_language_id_framework,
                                     sizeof(s_ns_language_id_framework),
                                     UX_NULL);
}

static UINT ns_cdc_class_register(void)
{
  UX_SLAVE_CLASS_CDC_ACM_PARAMETER cdc_params = {
    .ux_slave_class_cdc_acm_instance_activate   = ns_cdc_activate,
    .ux_slave_class_cdc_acm_instance_deactivate = ns_cdc_deactivate,
    .ux_slave_class_cdc_acm_parameter_change    = UX_NULL,
  };
  /* (UCHAR*)(uintptr_t): USBX takes a non-const class name; the uintptr_t hop
   * launders the string-literal const without tripping -Wcast-qual. */
  return _ux_device_stack_class_register((UCHAR*)(uintptr_t)"ux_slave_class_cdc_acm",
                                         _ux_device_class_cdc_acm_entry,
                                         1,
                                         0,
                                         &cdc_params);
}
 
/* =============================================================================
 * USBX worker thread
 * =============================================================================
 */

static VOID ns_usb_worker(ULONG arg)
{
  (void)arg;
 
  if (ns_usbx_stack_up() != UX_SUCCESS) {
    return;
  }
  g_tz_usb_state = (uint32_t)k_tz_usb_state_stack_up;
 
  if (ns_cdc_class_register() != UX_SUCCESS) {
    return;
  }
  g_tz_usb_state = (uint32_t)k_tz_usb_state_cdc_ready;
 
  if (ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs) != k_ra8_ok) {
    return;
  }
  g_tz_usb_state = (uint32_t)k_tz_usb_state_dcd_ready;
 
  if (ra8_usb_device_attach(k_ra8_usb_speed_fs, true) != k_ra8_ok) {
    return;
  }
  g_tz_usb_state = (uint32_t)k_tz_usb_state_attached;
 
  /* Polled controller service: drives bus reset, chapter-9 SETUP, and the
   * bulk auto-echo (all inside ra8_usb_dispatch -> internal_event_cb ->
   * ux_dcd_ra8_usb_irq). Time-sliced against ::ns_host_worker at the same
   * priority, so this yields each tick and the host's transfers land inside the
   * dispatch service window. */
  g_tz_usb_state = (uint32_t)k_tz_usb_state_dispatched;
  while (1) {
    ra8_usb_dispatch(k_ra8_usb_speed_fs);
    g_tz_usb_intsts_or |= (uint32_t)ra8_usb_intsts0_snapshot(k_ra8_usb_speed_fs);
    g_tz_usb_dispatch_count += 1U;
    g_tz_nsc_cgc_usb_match += 1U;
  }
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
  (void)tx_thread_create(&s_ns_usb_thread,
                         s_ns_usb_thread_name,
                         ns_usb_worker,
                         0UL,
                         s_ns_usb_stack,
                         (ULONG)k_ns_usb_thread_stack,
                         (UINT)k_ns_usb_thread_prio,
                         (UINT)k_ns_usb_thread_prio,
                         (ULONG)k_ns_time_slice,
                         TX_AUTO_START);
  (void)tx_thread_create(&s_ns_host_thread,
                         s_ns_host_thread_name,
                         ns_host_worker,
                         0UL,
                         s_ns_host_stack,
                         (ULONG)k_ns_host_stack_bytes,
                         (UINT)k_ns_usb_thread_prio,
                         (UINT)k_ns_usb_thread_prio,
                         (ULONG)k_ns_time_slice,
                         TX_AUTO_START);
}