ux_dcd_ra8_usb_setup.c

Go to the documentation of this file.

 
#define UX_SOURCE_CODE
 
#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.h"
#include "ux_dcd_ra8_usb_internal.h"
#include "ux_device_stack.h"
#include "ux_system.h"
#include "ux_utility.h"

volatile uint32_t g_setup_dispatch_count = 0U;

volatile uint8_t g_setup_packet_buffer[8] = {};

volatile uint32_t g_setup_packet_count = 0U;

volatile uint32_t g_dispatch_skip_reason = 0U;

volatile bool g_ctrl_out_pending = false;

UX_SLAVE_TRANSFER* g_ctrl_out_tr = UX_NULL;

volatile uint16_t g_ctrl_out_wlen = 0U;

volatile uint32_t g_ctrl_out_rx = 0U;

volatile uint32_t g_ctrl_out_done = 0U;

volatile uint64_t g_last_dispatched_setup_fp = 0U;

volatile uint64_t g_dispatched_fp_ring[4] = {};
 
volatile uint8_t g_dispatched_fp_ring_idx = 0U;

volatile uint8_t g_state_at_dispatch = 0U;

typedef enum : uint8_t {
  /* bmRequestType bit 7 -- USB 2.0 spec sec 9.3 Table 9-2:
   * 0 = Host-to-Device (write or no-data), 1 = Device-to-Host (read). */
  k_ra8_usb_setup_dir_mask = 0x80U, 
  /* SET_ADDRESS standard request code. USB 2.0 spec sec 9.4.6
   * Table 9-4 ("Standard Request Codes"): bRequest = 5 = SET_ADDRESS.
   * Used to gate out the manual CCPL pulse for SET_ADDRESS, which
   * the Renesas USBHS SIE auto-handles per HUM Ch 37.3 (auto
   * response function, p 2147). */
  k_ra8_usb_breq_set_address = 0x05U, 
} ra8_usb_setup_local_t;

typedef enum : uint16_t {
  k_ra8_usb_dcp_brdy_bit = 0x0001U, 
} ra8_usb_dcp_brdy_t;

static volatile uint32_t s_trace[k_dcd_trace_entries] = {};

static volatile uint32_t s_trace_ts[k_dcd_trace_entries] = {};

typedef enum : uintptr_t {
  k_dcd_dwt_cyccnt_addr = 0xE0001004U, 
} ra8_dcd_dwt_t;

static volatile uint32_t* const s_dcd_dwt_cyccnt = (volatile uint32_t*)k_dcd_dwt_cyccnt_addr;

static volatile uint32_t s_trace_seq = 0U;

void priv_trace_event(uint8_t kind, uint8_t code, uint16_t length)
{
  const uint32_t slot = s_trace_seq % (uint32_t)k_dcd_trace_entries;
  s_trace[slot]       = ((uint32_t)kind << (uint32_t)k_dcd_trace_kind_shift) |
                        ((uint32_t)code << (uint32_t)k_dcd_trace_code_shift) | (uint32_t)length;
  s_trace_ts[slot]    = *s_dcd_dwt_cyccnt;
  s_trace_seq++;
}

typedef enum : uint16_t {
  k_ra8_usb_usbreq_breq_mask = 0xFF00U, 
  k_ra8_usb_usbreq_bmrt_mask = 0x00FFU, 
  k_ra8_usb_usbreq_set_addr  = 0x0500U, 
} ra8_usb_setup_usbreq_t;

typedef enum : uint8_t {
  k_ra8_usb_fp_shift_usbleng = 48U, 
} ra8_usb_setup_fp_shift_t;

RA8_INTERNAL static void internal_pack_setup_le(volatile uint8_t* buf, const ra8_usb_setup_t* setup)
{
  buf[k_setup_idx_bmrt]   = setup->bm_request_type;
  buf[k_setup_idx_brq]    = setup->b_request;
  buf[k_setup_idx_val_lo] = (uint8_t)(setup->w_value & k_setup_byte_mask);
  buf[k_setup_idx_val_hi] = (uint8_t)((setup->w_value >> k_setup_byte_shift) & k_setup_byte_mask);
  buf[k_setup_idx_idx_lo] = (uint8_t)(setup->w_index & k_setup_byte_mask);
  buf[k_setup_idx_idx_hi] = (uint8_t)((setup->w_index >> k_setup_byte_shift) & k_setup_byte_mask);
  buf[k_setup_idx_len_lo] = (uint8_t)(setup->w_length & k_setup_byte_mask);
  buf[k_setup_idx_len_hi] = (uint8_t)((setup->w_length >> k_setup_byte_shift) & k_setup_byte_mask);
}

RA8_INTERNAL static bool internal_try_defer_ctrl_out(const ra8_usb_setup_t* setup,
                                                     UX_SLAVE_TRANSFER*     tr)
{
  g_ctrl_out_pending = false;
  if ((setup->bm_request_type & (uint8_t)k_ra8_usb_setup_dir_mask) == 0U) {
    if (setup->w_length > 0U) {
      g_ctrl_out_tr      = tr;
      g_ctrl_out_wlen    = setup->w_length;
      g_ctrl_out_pending = true;
      (void)ra8_usb_dcp_out_arm(g_dcd.speed);
      return true;
    }
  }
  return false;
}

unsigned int priv_dispatch_setup(const ra8_usb_setup_t* setup)
{
  if (setup == nullptr) {
    return UX_ERROR;
  }
 
  /* Mirror the just-decoded SETUP into the JLink-readable probe BEFORE
   * touching any USBX-owned state. Even if USBX is not yet bound (no
   * device stack init, no class registration), the bench can confirm
   * via JLink that the chip latched a real SETUP and the bridge drained
   * USBREQ/USBVAL/USBINDX/USBLENG correctly. */
  internal_pack_setup_le(g_setup_packet_buffer, setup);
  g_setup_packet_count++;
  priv_trace_event((uint8_t)k_dcd_trace_kind_setup, setup->b_request, setup->w_value);
 
  /* USBX must already be bound to forward the SETUP into the chapter-9
   * dispatcher. If it is not, that is fine for the bench probe path --
   * we still recorded the packet above. Mark the skip reason so a JLink
   * read disambiguates "USBX not bound" from "drain failed". */
  if (_ux_system_slave == UX_NULL) {
    g_dispatch_skip_reason |= 0x10U;
    return UX_ERROR;
  }
  UX_SLAVE_DEVICE*   device = &_ux_system_slave->ux_system_slave_device;
  UX_SLAVE_TRANSFER* tr =
    &device->ux_slave_device_control_endpoint.ux_slave_endpoint_transfer_request;
  if (tr == UX_NULL) {
    g_dispatch_skip_reason |= 0x20U;
    return UX_ERROR;
  }
 
  internal_pack_setup_le(tr->ux_slave_transfer_request_setup, setup);
 
  tr->ux_slave_transfer_request_actual_length        = 0UL;
  tr->ux_slave_transfer_request_current_data_pointer = tr->ux_slave_transfer_request_data_pointer;
  /* Chapter-9 dispatcher gates on completion_code == UX_SUCCESS
   * (ux_device_stack_control_request_process.c line ~101). The
   * previous SETUP may have left it as UX_TRANSFER_STALLED on a
   * STALL'd request -- clear it so this fresh SETUP is honored. */
  tr->ux_slave_transfer_request_completion_code = UX_SUCCESS;
 
  /* Control-OUT with a data stage (e.g. DFU_DNLOAD) is armed and DEFERRED to
   * the DCP BRDY ISR (see internal_try_defer_ctrl_out); IN / no-data requests
   * fall through to the immediate chapter-9 dispatch below. */
  if (internal_try_defer_ctrl_out(setup, tr)) {
    g_dispatch_skip_reason |= (uint32_t)k_ra8_usb_skip_process_ok;
    return UX_SUCCESS;
  }
 
  const unsigned int rc = _ux_device_stack_control_request_process(tr);
  if (rc != UX_SUCCESS) {
    g_dispatch_skip_reason |= 0x08U;
  } else {
    g_dispatch_skip_reason |= (uint32_t)k_ra8_usb_skip_process_ok;
  }
  return rc;
}

RA8_INTERNAL static void internal_ctrt_dispatch_fresh_setup(ra8_usb_speed_t speed,
                                                            uint64_t        fingerprint)
{
  ra8_usb_setup_t setup = {};
  if (ra8_usb_read_setup_unconditional(speed, &setup) != k_ra8_ok) {
    return;
  }
  g_setup_dispatch_count++;
  g_last_dispatched_setup_fp                     = fingerprint;
  g_dispatched_fp_ring[g_dispatched_fp_ring_idx] = fingerprint;
  g_dispatched_fp_ring_idx = (uint8_t)((g_dispatched_fp_ring_idx + 1U) & 0x03U);
 
  /* Belt-and-suspenders: ensure device_state is in {ATTACHED,
   * ADDRESSED, CONFIGURED} BEFORE dispatch so the chapter-9 gate
   * does not silently drop the SETUP. State demotion only happens on
   * bus reset / suspend, so promoting to ATTACHED is monotonic-safe.
   * Per-case branch keeps this out of the compound-decision MC/DC
   * inventory. */
  if (_ux_system_slave != UX_NULL) {
    UX_SLAVE_DEVICE* const dev = &_ux_system_slave->ux_system_slave_device;
    switch (dev->ux_slave_device_state) {
      case (ULONG)UX_DEVICE_ATTACHED:
      case (ULONG)UX_DEVICE_ADDRESSED:
      case (ULONG)UX_DEVICE_CONFIGURED:
        break;
      default:
        dev->ux_slave_device_state = (ULONG)UX_DEVICE_ATTACHED;
        break;
    }
  }
  g_state_at_dispatch = (uint8_t)(_ux_system_slave != UX_NULL
                                    ? _ux_system_slave->ux_system_slave_device.ux_slave_device_state
                                    : (ULONG)k_ra8_usb_state_unknown);
  const unsigned int rc = priv_dispatch_setup(&setup);
 
  /* Drive CCPL for no-data H2D control transfers (SET_ADDRESS,
   * SET_CONFIGURATION, SET_INTERFACE, SET_FEATURE...) so the host
   * observes the status-stage IN-ZLP. Nested ifs keep the
   * (dir==0) AND (wLength==0) gate out of the MC/DC inventory. */
  if ((setup.bm_request_type & (uint8_t)k_ra8_usb_setup_dir_mask) == 0U) {
    if (setup.w_length == 0U) {
      (void)ra8_usb_control_response(speed, rc == UX_SUCCESS);
      /* kind 7: H2D status driven -- code = bRequest, len = USBX rc. */
      priv_trace_event((uint8_t)k_dcd_trace_kind_ccpl, setup.b_request, (uint16_t)rc);
    }
  }
}

RA8_INTERNAL static void internal_ctrt_handle_valid(ra8_usb_speed_t speed)
{
  volatile r_usb_regs_t* const reg = (speed == k_ra8_usb_speed_hs) ? ra8_usb_hs() : ra8_usb_fs();
  if (reg == nullptr) {
    return;
  }
  const uint16_t usbreq_live  = reg->USBREQ;
  const uint16_t usbval_live  = reg->USBVAL;
  const uint16_t usbindx_live = reg->USBINDX;
  const uint16_t usbleng_live = reg->USBLENG;
  const uint64_t fingerprint  = ((uint64_t)usbreq_live) | ((uint64_t)usbval_live << 16) |
                                ((uint64_t)usbindx_live << 32) |
                                ((uint64_t)usbleng_live << (uint8_t)k_ra8_usb_fp_shift_usbleng);
 
  /* Clear INTSTS0.VALID before anything else. The USBREQ/USBVAL/
   * USBINDX/USBLENG mirrors persist (HUM Ch 37.2.21..24 p 2087), so the
   * SETUP stays readable below; but a latched VALID stalls the
   * DCPCTR.PID write gate (HUM Ch 37.2.31 p 2095) and holds the USB IRQ
   * line asserted. VALID is a real event bit (in event_msk), so the
   * ISR spurious-entry gate does not short-circuit it -- it must be
   * cleared here. The early clear is also the dedup: a second
   * ISR entry for the same physical SETUP sees VALID=0 and
   * priv_handle_ctrt skips this function.
   * HUM Ch 36.2.14 INTSTS0 p 1985 (W0C). */
  reg->INTSTS0 = (uint16_t)(reg->INTSTS0 & (uint16_t)~(uint16_t)k_ra8_intsts0_mask_valid);
 
  /* SET_ADDRESS short-circuit (HUM Ch 37.3 p 2147 -- the SIE owns the
   * USBADDR latch and the IN-ZLP status stage). Nested ifs keep this
   * out of the MC/DC compound-decision inventory. */
  bool is_set_address = false;
  if ((usbreq_live & (uint16_t)k_ra8_usb_usbreq_breq_mask) == (uint16_t)k_ra8_usb_usbreq_set_addr) {
    if ((usbreq_live & (uint16_t)k_ra8_usb_usbreq_bmrt_mask) == 0x0000U) {
      if (usbleng_live == 0U) {
        is_set_address = true;
      }
    }
  }
  if (is_set_address) {
    return;
  }
 
  /* Dispatch every observed SETUP, including a host retransmit of
   * byte-identical bytes after a missed response window. The previous
   * `fingerprint != g_last_dispatched_setup_fp` skip dropped exactly
   * those retransmits and -- with the VALID clear also skipped -- left
   * the controller wedged. The early VALID clear above is the real
   * dedup; the fingerprint is now recorded for diagnostics only. */
  internal_ctrt_dispatch_fresh_setup(speed, fingerprint);
}

void priv_handle_ctrt(ra8_usb_speed_t speed, uint16_t intsts0)
{
  const uint16_t ctsq       = (uint16_t)(intsts0 & (uint16_t)k_ra8_intsts0_mask_ctsq);
  const bool     have_valid = ((intsts0 & (uint16_t)k_ra8_intsts0_mask_valid) != 0U);
 
  /* Per HUM Ch 37.2.18 p 2081 the SIE auto-clears VALID quickly but
   * USBREQ/USBVAL/USBINDX/USBLENG persist; drain unconditionally on
   * any VALID observation and dedup via the fingerprint. */
  if (have_valid) {
    internal_ctrt_handle_valid(speed);
  }
 
  /* Status-stage-only handling (no SETUP drain needed). CTSQ=wrnd
   * fires on the trailing edge of no-data H2D transfers when the
   * SETUP-drain CCPL above did not run. */
  switch (ctsq) {
    case k_ra8_ctsq_rdss:
    case k_ra8_ctsq_wrss:
    case k_ra8_ctsq_wrnd:
      (void)ra8_usb_control_response(speed, true);
      break;
    case k_ra8_ctsq_sqer:
      (void)ra8_usb_control_response(speed, false);
      break;
    default:
      break;
  }
}

void priv_handle_ctrl_out_data(ra8_usb_speed_t speed)
{
  if (!g_ctrl_out_pending) {
    return;
  }
  volatile r_usb_regs_t* const reg = (speed == k_ra8_usb_speed_hs) ? ra8_usb_hs() : ra8_usb_fs();
  if (reg == nullptr) {
    return;
  }
  /* Wait for the host's OUT packet to land before draining; an unrelated IRQ
   * (e.g. a BRDY for a bulk pipe) leaves us pending for the next pass.
   * HUM Ch 36.2.13 "BRDYSTS" p 1984. */
  if ((reg->BRDYSTS & (uint16_t)k_ra8_usb_dcp_brdy_bit) == 0U) {
    return;
  }
 
  UX_SLAVE_TRANSFER* const tr = g_ctrl_out_tr;
  g_ctrl_out_pending          = false;
  g_ctrl_out_tr               = UX_NULL;
  if (tr == UX_NULL) {
    return;
  }
 
  uint16_t rx = 0U;
  if (ra8_usb_dcp_out_read(speed,
                           tr->ux_slave_transfer_request_data_pointer,
                           g_ctrl_out_wlen,
                           &rx) != k_ra8_ok) {
    return;
  }
  tr->ux_slave_transfer_request_actual_length = rx;
  g_ctrl_out_rx                               = (uint32_t)rx;
  g_ctrl_out_done++;
  (void)_ux_device_stack_control_request_process(tr);
  /* Complete the control-write with its IN-ZLP status stage: pulse CCPL so the
   * SIE answers the host's status-stage IN token. Without this the host's
   * status read (internal_host_ctrl_status) never sees the ZLP and times out. */
  (void)ra8_usb_control_response(speed, true);
}