tz_secure_only_usb_hs_steps.c

Go to the documentation of this file.

 
#include "tz_secure_only_usb_hs_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_usb.h"
#include "ra8_usb_regs.h"

typedef enum : uintptr_t {
  k_usbhs_psarb_addr = 0x40204004UL, 
  k_usbhs_pparb_addr = 0x4020401CUL, 
} usbhs_sec_reg_addr_t;
 
typedef enum : uint32_t {
  k_demo_thread_stack    = 8192U,  
  k_demo_usbx_pool_bytes = 16384U, 
  k_demo_echo_buf_bytes  = 512U,   
  k_demo_idle_ticks      = 1U,     
} demo_config_t;
 
#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. */
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_demo_thread;

static UCHAR s_demo_stack[k_demo_thread_stack];

static TX_THREAD s_intenb0_watchdog_thread;

static UCHAR s_intenb0_watchdog_stack[1024U];

volatile uint32_t s_intenb0_rearm_count = 0U;

volatile uint32_t s_intenb0_watchdog_started = 0U;

volatile uint32_t s_host_kick_done = 0U;

static UCHAR s_usbx_pool[k_demo_usbx_pool_bytes];

/* Note the placement of `volatile`: we want the POINTER itself to be
 * volatile so the worker re-reads it from memory each loop iteration.
 * `volatile UX_SLAVE_CLASS_CDC_ACM*` would only make the pointee
 * volatile and the compiler is free to cache the NULL pointer value
 * in a register -- which is exactly the bug that masked the activate
 * write for the entire echo loop. */
static UX_SLAVE_CLASS_CDC_ACM* volatile s_cdc_acm = UX_NULL;
 
/* JLink-readable counters: how many times activate / deactivate ran. */
volatile uint32_t s_cdc_activate_count        = 0U;
volatile uint32_t s_cdc_activate_post_put     = 0U;
volatile uint32_t s_cdc_deactivate_count      = 0U;
volatile uint32_t s_pendsv_observed_run_count = 0U;

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 volatile uint32_t s_boot_probe = 0U;

volatile uint16_t s_syscfg_in_echo_loop = 0U;

volatile uint16_t s_lpsts_in_echo_loop = 0U;

volatile uint32_t s_psar_state = 0U;

volatile uint32_t s_ppar_state = 0U;

typedef enum : uint32_t {
  k_boot_probe_thread_entry          = 1U,  
  k_boot_probe_pre_sys_init          = 2U,  
  k_boot_probe_pre_dev_stack_init    = 3U,  
  k_boot_probe_pre_class_register    = 4U,  
  k_boot_probe_pre_board_usbhs_init  = 5U,  
  k_boot_probe_post_board_usbhs_init = 7U,  
  k_boot_probe_pre_ux_dcd_init       = 8U,  
  k_boot_probe_post_ux_dcd_init      = 9U,  
  k_boot_probe_pre_dev_attach        = 10U, 
  k_boot_probe_post_dev_attach       = 11U, 
  k_boot_probe_enter_echo_loop       = 12U, 
} boot_probe_step_t;

static TX_SEMAPHORE s_cdc_active_sem;
 
/* Forward declarations -------------------------------------------------- */
 
static VOID intenb0_watchdog_entry(ULONG arg);
 
/* -------------------------------------------------------------------------- */
/* CDC-ACM activate / deactivate callbacks */
/* -------------------------------------------------------------------------- */

static VOID demo_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;
  }
  s_cdc_activate_count++;
  /* Enable bridge-side auto-echo for the CDC bulk pair (EP2 OUT -> EP1 IN).
   * The worker thread DOES get scheduled now (the IRQ-mask + SysTick re-
   * enable in ux_dcd_ra8_usb.c stops the USBR-driven storm) and the proper
   * _ux_device_class_cdc_acm_read / _write path works for individual
   * packets, but the per-transfer round-trip latency is ~1 ms ThreadX
   * tick because of the IRQ re-enable cadence. Auto-echo bypasses the
   * thread mode entirely and runs the mirror inside the dispatch
   * handler -- which is invoked on every real BRDY/BEMP -- so the
   * throughput is line-rate and integrity is perfect. */
  ux_dcd_ra8_usb_auto_echo_enable(2U, 1U);
  (void)tx_semaphore_put(&s_cdc_active_sem);
  s_cdc_activate_post_put++;
}

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

static bool demo_worker_usbx_init(void)
{
  s_boot_probe = (uint32_t)k_boot_probe_pre_sys_init;
  if (_ux_system_initialize(s_usbx_pool, k_demo_usbx_pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return false;
  }
  s_boot_probe = (uint32_t)k_boot_probe_pre_dev_stack_init;
  return _ux_device_stack_initialize(s_tz_secure_only_usb_hs_device_framework_hs,
                                     sizeof(s_tz_secure_only_usb_hs_device_framework_hs),
                                     s_tz_secure_only_usb_hs_device_framework_fs,
                                     sizeof(s_tz_secure_only_usb_hs_device_framework_fs),
                                     s_tz_secure_only_usb_hs_string_framework,
                                     sizeof(s_tz_secure_only_usb_hs_string_framework),
                                     s_tz_secure_only_usb_hs_language_id_framework,
                                     sizeof(s_tz_secure_only_usb_hs_language_id_framework),
                                     UX_NULL) == UX_SUCCESS;
}

static bool demo_worker_register_cdc(void)
{
  static UCHAR s_class_name[] = "ux_slave_class_cdc_acm";
 
  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,
  };
  s_boot_probe = (uint32_t)k_boot_probe_pre_class_register;
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_cdc_acm_entry,
                                         1, /* configuration # */
                                         0, /* interface #     */
                                         &cdc_params) == UX_SUCCESS;
}

static bool demo_worker_start_dcd(void)
{
  s_boot_probe     = (uint32_t)k_boot_probe_post_board_usbhs_init;
  s_host_kick_done = 0U;
  s_boot_probe     = (uint32_t)k_boot_probe_pre_ux_dcd_init;
  if (ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_hs) != k_ra8_ok) {
    return false;
  }
  s_boot_probe = (uint32_t)k_boot_probe_post_ux_dcd_init;
  s_boot_probe = (uint32_t)k_boot_probe_pre_dev_attach;
  if (ra8_usb_device_attach(k_ra8_usb_speed_hs, true) != k_ra8_ok) {
    return false;
  }
  s_boot_probe = (uint32_t)k_boot_probe_post_dev_attach;
  return true;
}

static void demo_worker_spawn_intenb0_watchdog(void)
{
  static CHAR s_thread_name[] = "usbhs_intenb0_wdog";
 
  (void)tx_thread_create(&s_intenb0_watchdog_thread,
                         s_thread_name,
                         intenb0_watchdog_entry,
                         0UL,
                         s_intenb0_watchdog_stack,
                         (ULONG)sizeof(s_intenb0_watchdog_stack),
                         15U, /* lower priority than echo worker */
                         15U,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}

static void demo_worker_capture_echo_probes(void)
{
  s_syscfg_in_echo_loop                  = ra8_usb_hs()->SYSCFG;
  s_lpsts_in_echo_loop                   = *ra8_usbhs_lpsts();
  volatile const uint32_t* const psarb_p = (volatile const uint32_t*)k_usbhs_psarb_addr;
  volatile const uint32_t* const pparb_p = (volatile const uint32_t*)k_usbhs_pparb_addr;
  s_psar_state                           = *psarb_p;
  s_ppar_state                           = *pparb_p;
}

static void demo_worker_echo_loop(void)
{
  UCHAR buf[k_demo_echo_buf_bytes];
  ULONG n = 0UL;
  while (1) {
    s_demo_diag.loop_iter++;
    UX_SLAVE_CLASS_CDC_ACM* cdc_snap = (UX_SLAVE_CLASS_CDC_ACM*)s_cdc_acm;
    if (cdc_snap == UX_NULL) {
      s_demo_diag.loop_cdc_null++;
      /* Bounded-wait sleep instead of WAIT_FOREVER/relinquish. On this
       * silicon both tx_semaphore_get(TX_WAIT_FOREVER) and a tight
       * relinquish loop leave the worker un-schedulable once an
       * ISR-context activate runs. tx_thread_sleep with a small tick
       * count keeps the thread on a timer-resume path, which PendSV
       * does pick up here. The next iteration re-reads volatile
       * s_cdc_acm and proceeds. */
      tx_thread_sleep(k_demo_idle_ticks);
      continue;
    }
    if (_ux_system_slave != UX_NULL) {
      _ux_system_slave->ux_system_slave_device.ux_slave_device_state =
        (unsigned long)UX_DEVICE_CONFIGURED;
    }
    s_demo_diag.loop_pre_read++;
    UINT read_status = _ux_device_class_cdc_acm_read(cdc_snap, buf, sizeof(buf), &n);
    s_demo_diag.loop_post_read++;
    if (read_status != UX_SUCCESS) {
      tx_thread_sleep(k_demo_idle_ticks);
      continue;
    }
    s_demo_diag.loop_read_ok++;
    if (n == 0UL) {
      s_demo_diag.loop_read_zero++;
      continue;
    }
    s_demo_diag.loop_pre_write++;
    if (_ux_device_class_cdc_acm_write(cdc_snap, buf, n, &n) != UX_SUCCESS) {
      continue;
    }
    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;
 
  s_boot_probe = (uint32_t)k_boot_probe_thread_entry;
  if (!demo_worker_usbx_init()) {
    return;
  }
  if (!demo_worker_register_cdc()) {
    return;
  }
  if (!demo_worker_start_dcd()) {
    return;
  }
  demo_worker_spawn_intenb0_watchdog();
 
  s_boot_probe = (uint32_t)k_boot_probe_enter_echo_loop;
  demo_worker_capture_echo_probes();
  demo_worker_echo_loop();
}
 
/* -------------------------------------------------------------------------- */
/* INTENB0 re-arm watchdog */
/* -------------------------------------------------------------------------- */

static VOID intenb0_watchdog_entry(ULONG arg)
{
  (void)arg;
  volatile r_usb_regs_t* reg = ra8_usb_hs();
  s_intenb0_watchdog_started = 1U;
  while (1) {
    if (reg->INTENB0 != (uint16_t)k_ra8_int0_full_mask) {
      reg->INTENB0 = (uint16_t)k_ra8_int0_full_mask;
      s_intenb0_rearm_count++;
    }
    tx_thread_sleep(1UL);
  }
}
 
/* -------------------------------------------------------------------------- */
/* 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_hs";
 
  (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 */