ux_dcd_ra8_usb.c

Go to the documentation of this file.

 
#define UX_SOURCE_CODE
 
#include "ux_dcd_ra8_usb.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_check.h"
#include "ra8_elc_regs.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_usb_regs.h"
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb_internal.h"
#include "ux_device_stack.h"
#include "ux_system.h"
#include "ux_utility.h"

typedef enum : uint8_t {
  /* Priority 8 (NVIC 0x80) leaves SysTick (NVIC 0x40) and PendSV able to
   * preempt the USB ISR. With same priority, SysTick cannot interrupt the
   * USB ISR and the 8 kHz SOFR + per-pipe NRDY events starve thread mode,
   * preventing tx_thread_sleep from ever waking. HUM Ch 13 NVIC priorities. */
  k_ra8_usb_dcd_isr_prio = 8U, 
} ra8_usb_dcd_isr_prio_t;
 
/* Tag used by ra8_log_*. Must be a static lifetime string. */
static const char* const s_tag = "ux_dcd_ra8_usb";

volatile uint16_t g_syscfg_after_dcd_init = 0U;

volatile uint16_t g_lpsts_after_dcd_init = 0U;

ra8_usb_dcd_t g_dcd = {
  .state = k_ux_dcd_ra8_usb_state_uninit,
  .speed = k_ra8_usb_speed_fs,
  .owner = nullptr,
  .pipes = {},
};
 
volatile uint32_t g_dcd_auto_echo_enable = 0U;
 
uint8_t g_dcd_auto_echo_out_pipe = 0U;
 
uint8_t g_dcd_auto_echo_in_pipe = 0U;

void ux_dcd_ra8_usb_auto_echo_enable(uint8_t out_pipe, uint8_t in_pipe)
{
  g_dcd_auto_echo_out_pipe = out_pipe;
  g_dcd_auto_echo_in_pipe  = in_pipe;
  g_dcd_auto_echo_enable   = 1U;
}

typedef enum : uintptr_t {
  k_nvic_iser_base = 0xE000E100U, 
  k_nvic_icer_base = 0xE000E180U, 
  k_nvic_ispr_base = 0xE000E200U, 
} ra8_nvic_reg_t;

typedef enum : uint32_t {
  k_nvic_irqs_per_reg = 32U, 
  k_nvic_reg_stride   = 4U,  
} ra8_nvic_layout_t;

static uint16_t s_usb_irq_slot = 0U;

volatile uint32_t g_isr_spurious_run = 0U;

RA8_INTERNAL static void internal_usbfs_irq_set_enabled(bool enabled)
{
  const uint32_t  word = (uint32_t)s_usb_irq_slot / (uint32_t)k_nvic_irqs_per_reg;
  const uint32_t  bit  = 1UL << ((uint32_t)s_usb_irq_slot % (uint32_t)k_nvic_irqs_per_reg);
  const uintptr_t base = enabled ? (uintptr_t)k_nvic_iser_base : (uintptr_t)k_nvic_icer_base;
  *(volatile uint32_t*)(base + ((uintptr_t)word * (uintptr_t)k_nvic_reg_stride)) = bit;
}

void priv_usbfs_irq_mask(void)
{
  internal_usbfs_irq_set_enabled(false);
}

void ux_dcd_ra8_usb_irq_reenable(void)
{
  g_isr_spurious_run = 0U;
  internal_usbfs_irq_set_enabled(true);
  /* Watchdog kick for stalled transfers: a stashed pipe transfer with
   * no pending controller event generates no IRQ, so the walk -- and
   * with it the IN-pipe strand recovery -- never runs. Pend the line
   * once per SysTick while any transfer is stashed; the ISR walk is
   * idempotent for pipes with nothing to do. */
  bool stashed = false;
  for (uint8_t i = 1U; i < (uint8_t)k_ux_dcd_ra8_usb_max_pipes; i++) {
    if (g_dcd.pipes[i].xfer != UX_NULL) {
      stashed = true;
    }
  }
  if (stashed) {
    const uint32_t  word = (uint32_t)s_usb_irq_slot / (uint32_t)k_nvic_irqs_per_reg;
    const uint32_t  bit  = 1UL << ((uint32_t)s_usb_irq_slot % (uint32_t)k_nvic_irqs_per_reg);
    const uintptr_t addr =
      (uintptr_t)k_nvic_ispr_base + ((uintptr_t)word * (uintptr_t)k_nvic_reg_stride);
    *(volatile uint32_t*)addr = bit;
  }
}

ra8_usb_dcd_diag_t g_diag = {};

typedef enum : uint8_t {
  k_ra8_usb_dcd_controller_id = 99U, 
} ra8_usb_dcd_ctrl_id_t;
 
/* -------------------------------------------------------------------------- */
/* Lifecycle */
/* -------------------------------------------------------------------------- */
 
#ifndef RA8_USB_POLLED_ONLY
RA8_INTERNAL static void internal_usbfs_storm_guard_init(ra8_usb_speed_t speed)
{
  uint16_t slot = 0U;
  if (ra8_isr_lookup_slot(priv_pick_event(speed), &slot) == k_ra8_ok) {
    s_usb_irq_slot = slot;
  }
}
#endif

RA8_INTERNAL static ra8_err_t internal_init_bind_owner(ra8_usb_speed_t speed)
{
  if (_ux_system_slave == UX_NULL) {
    return k_ra8_err_invalid_state;
  }
  UX_SLAVE_DCD* owner                 = &_ux_system_slave->ux_system_slave_dcd;
  owner->ux_slave_dcd_status          = UX_DCD_STATUS_OPERATIONAL;
  owner->ux_slave_dcd_controller_type = (UINT)k_ra8_usb_dcd_controller_id; /* RA-USB private id. */
  owner->ux_slave_dcd_function        = _ux_dcd_ra8_usb_function;
  owner->ux_slave_dcd_controller_hardware = (void*)&g_dcd;
 
  g_dcd.speed = speed;
  g_dcd.owner = owner;
  g_dcd.state = k_ux_dcd_ra8_usb_state_ready;
 
  for (uint8_t i = 0U; i < (uint8_t)k_ux_dcd_ra8_usb_max_pipes; i++) {
    g_dcd.pipes[i].xfer = nullptr;
  }
 
#ifndef RA8_USB_POLLED_ONLY
  /* Wire the controller's ELC event onto an NVIC line. ra8_isr_init is
   * idempotent. HUM Ch 13 NVIC + Ch 14 ICU IELSR. */
  RA8_RETURN_ON_ERROR(ra8_isr_init(), s_tag, "ra8_isr_init");
  RA8_RETURN_ON_ERROR(ra8_isr_register(priv_pick_event(speed),
                                       priv_pick_isr(speed),
                                       nullptr,
                                       (uint8_t)k_ra8_usb_dcd_isr_prio,
                                       nullptr),
                      s_tag,
                      "ra8_isr_register");
  internal_usbfs_storm_guard_init(speed);
#else
  /* RA8_USB_POLLED_ONLY (TrustZone NS image, #96): the worker drives the
   * controller by calling ra8_usb_dispatch() in a tight loop instead of taking
   * the USB NVIC line. The ICU IELSR + NVIC are Secure-attributed and would
   * fault from Non-secure state, so skip ra8_isr_register entirely. Bus events,
   * chapter-9 SETUP handling, and bulk auto-echo all run inside the polled
   * dispatch -> priv_event_cb -> ux_dcd_ra8_usb_irq path. */
  (void)speed;
#endif
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_init_parse_framework(UX_SLAVE_DEVICE* device)
{
  if (_ux_system_slave->ux_system_slave_speed == UX_HIGH_SPEED_DEVICE) {
    _ux_system_slave->ux_system_slave_device_framework =
      _ux_system_slave->ux_system_slave_device_framework_high_speed;
    _ux_system_slave->ux_system_slave_device_framework_length =
      _ux_system_slave->ux_system_slave_device_framework_length_high_speed;
  } else {
    _ux_system_slave->ux_system_slave_device_framework =
      _ux_system_slave->ux_system_slave_device_framework_full_speed;
    _ux_system_slave->ux_system_slave_device_framework_length =
      _ux_system_slave->ux_system_slave_device_framework_length_full_speed;
  }
 
  if (_ux_system_slave->ux_system_slave_device_framework != UX_NULL) {
    _ux_utility_descriptor_parse(_ux_system_slave->ux_system_slave_device_framework,
                                 _ux_system_device_descriptor_structure,
                                 UX_DEVICE_DESCRIPTOR_ENTRIES,
                                 (UCHAR*)&device->ux_slave_device_descriptor);
  }
}

RA8_INTERNAL static void internal_init_setup_ep0(UX_SLAVE_DEVICE* device, UX_SLAVE_DCD* owner)
{
  UX_SLAVE_TRANSFER* tr =
    &device->ux_slave_device_control_endpoint.ux_slave_endpoint_transfer_request;
  tr->ux_slave_transfer_request_timeout              = UX_MS_TO_TICK(UX_CONTROL_TRANSFER_TIMEOUT);
  tr->ux_slave_transfer_request_current_data_pointer = tr->ux_slave_transfer_request_data_pointer;
  tr->ux_slave_transfer_request_endpoint             = &device->ux_slave_device_control_endpoint;
  device->ux_slave_device_control_endpoint.ux_slave_endpoint_descriptor.wMaxPacketSize =
    device->ux_slave_device_descriptor.bMaxPacketSize0;
  tr->ux_slave_transfer_request_requested_length =
    device->ux_slave_device_descriptor.bMaxPacketSize0;
  tr->ux_slave_transfer_request_transfer_length =
    device->ux_slave_device_descriptor.bMaxPacketSize0;
 
  /* Hand EP0 to ourselves so any future TRANSFER_REQUEST has the
   * pipe table populated. */
  (void)_ux_dcd_ra8_usb_function(owner,
                                 UX_DCD_CREATE_ENDPOINT,
                                 (void*)&device->ux_slave_device_control_endpoint);
 
  device->ux_slave_device_control_endpoint.ux_slave_endpoint_state = UX_ENDPOINT_RESET;
  tr->ux_slave_transfer_request_phase                              = UX_TRANSFER_PHASE_DATA_IN;
 
  /* Stamp ATTACHED so the chapter-9 dispatcher accepts the host's
   * first SETUP (gate is state in {ATTACHED, ADDRESSED, CONFIGURED}). */
  device->ux_slave_device_state = (unsigned long)UX_DEVICE_ATTACHED;
}

ra8_err_t ux_dcd_ra8_usb_initialize(ra8_usb_speed_t speed)
{
  if ((uint8_t)speed > (uint8_t)k_ra8_usb_speed_hs) {
    return k_ra8_err_invalid_arg;
  }
  RA8_RETURN_ON_ERROR(ra8_usb_device_init(speed), s_tag, "ra8_usb_device_init");
  ra8_usb_attach_handler(speed, priv_event_cb, nullptr);
 
  RA8_RETURN_ON_ERROR(internal_init_bind_owner(speed), s_tag, "bind_owner");
 
  /* Tell USBX system the speed. HS-controller reports HS (512-byte bulk
   * MPS); FS-controller reports FS. */
  _ux_system_slave->ux_system_slave_speed =
    (speed == k_ra8_usb_speed_hs) ? UX_HIGH_SPEED_DEVICE : UX_FULL_SPEED_DEVICE;
 
  UX_SLAVE_DEVICE* device = &_ux_system_slave->ux_system_slave_device;
  internal_init_parse_framework(device);
  internal_init_setup_ep0(device, g_dcd.owner);
 
  /* Bisect probes: SYSCFG/LPSTS state at end of DCD init, BEFORE the
   * application calls ra8_usb_device_attach(true). HUM Ch 37.2.1 SYSCFG
   * p 2060, HUM Ch 37.2.43 LPSTS p 2111. */
  if (speed == k_ra8_usb_speed_hs) {
    g_syscfg_after_dcd_init = ra8_usb_hs()->SYSCFG;
    g_lpsts_after_dcd_init  = *ra8_usbhs_lpsts();
  }
 
  ra8_log_info(s_tag, "DCD bridge installed");
  return k_ra8_ok;
}

ra8_err_t ux_dcd_ra8_usb_uninitialize(void)
{
  if (g_dcd.state == k_ux_dcd_ra8_usb_state_uninit) {
    return k_ra8_err_invalid_state;
  }
  /* Matching pair to the disabled ra8_isr_register in the init path. */
  ra8_usb_attach_handler(g_dcd.speed, nullptr, nullptr);
  (void)ra8_usb_device_deinit(g_dcd.speed);
  if (g_dcd.owner != nullptr) {
    g_dcd.owner->ux_slave_dcd_status   = UX_DCD_STATUS_HALTED;
    g_dcd.owner->ux_slave_dcd_function = nullptr;
  }
  g_dcd.state = k_ux_dcd_ra8_usb_state_uninit;
  g_dcd.owner = nullptr;
  return k_ra8_ok;
}

ra8_usb_dcd_state_t ux_dcd_ra8_usb_state(void)
{
  return g_dcd.state;
}