ux_dcd_ra8_usb_dvst_default.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_busreset_rearm_count = 0U;

volatile uint16_t g_dcpctr_after_rearm = 0U;

volatile uint16_t g_intenb0_after_rearm = 0U;

volatile uint16_t g_cfifosel_after_rearm = 0U;

volatile uint16_t g_dcpctr_pre_rearm = 0U;

volatile uint32_t g_setup_token_observed = 0U;

static volatile uint16_t s_prev_dcpctr_sqmon = 0U;

volatile uint32_t g_dispatch_attempts = 0U;

volatile uint16_t g_intsts0_at_sqmon_edge = 0U;

volatile uint16_t g_intsts0_observed_or_recent = 0U;

volatile uint16_t g_dcpctr_bit_map_observed = 0U;

volatile uint16_t g_usbreq_first_nonzero = 0U;

volatile uint32_t g_unconditional_dispatch_count = 0U;

volatile uint16_t g_last_dispatched_usbreq = 0U;

typedef enum : uint32_t {
  k_ra8_usb_dcd_default_poll_iters = 200000U, 
} ra8_usb_dcd_default_poll_t;

typedef enum : uint16_t {
  k_ra8_dcpctr_mask_sqmon = (uint16_t)(1U << 6U), 
} ra8_usb_dcpctr_bits_t;

RA8_INTERNAL static void internal_dvst_capture_setup_mirror(uint16_t usbreq_live,
                                                            uint16_t usbval_live,
                                                            uint16_t usbindx_live,
                                                            uint16_t usbleng_live)
{
  const bool any_nonzero = ((usbreq_live | usbval_live | usbindx_live | usbleng_live) != 0U);
  if (!any_nonzero) {
    return;
  }
  g_setup_packet_buffer[k_setup_idx_bmrt] = (uint8_t)(usbreq_live & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_brq] =
    (uint8_t)((usbreq_live >> k_setup_byte_shift) & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_val_lo] = (uint8_t)(usbval_live & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_val_hi] =
    (uint8_t)((usbval_live >> k_setup_byte_shift) & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_idx_lo] = (uint8_t)(usbindx_live & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_idx_hi] =
    (uint8_t)((usbindx_live >> k_setup_byte_shift) & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_len_lo] = (uint8_t)(usbleng_live & k_setup_byte_mask);
  g_setup_packet_buffer[k_setup_idx_len_hi] =
    (uint8_t)((usbleng_live >> k_setup_byte_shift) & k_setup_byte_mask);
  g_setup_packet_count++;
  if (g_usbreq_first_nonzero == 0U) {
    g_usbreq_first_nonzero = usbreq_live;
  }
}

RA8_INTERNAL static void internal_dvst_dispatch_if_new(volatile r_usb_regs_t* reg,
                                                       uint16_t               usbreq_live,
                                                       uint16_t               usbval_live,
                                                       uint16_t               usbindx_live,
                                                       uint16_t               usbleng_live)
{
  if (usbreq_live == g_last_dispatched_usbreq) {
    /* USBREQ unchanged since last dispatch: do not re-fire. */
    g_dispatch_skip_reason |= (uint32_t)k_ra8_usb_skip_usbreq_unchanged;
    return;
  }
  ra8_usb_setup_t setup = {};
  setup.bm_request_type = (uint8_t)(usbreq_live & k_setup_byte_mask);
  setup.b_request       = (uint8_t)((usbreq_live >> k_setup_byte_shift) & k_setup_byte_mask);
  setup.w_value         = usbval_live;
  setup.w_index         = usbindx_live;
  setup.w_length        = usbleng_live;
 
  g_setup_token_observed++;
  g_setup_dispatch_count++;
  g_unconditional_dispatch_count++;
  (void)priv_dispatch_setup(&setup);
  g_last_dispatched_usbreq = usbreq_live;
 
  /* Post-dispatch W0C-ack of INTSTS0.VALID (HUM Ch 37.2.18 p 2081). */
  reg->INTSTS0 = (uint16_t)(reg->INTSTS0 & (uint16_t)~(uint16_t)k_ra8_intsts0_mask_valid);
  /* Pulse DCPCTR write (HUM Ch 37.2.32 p 2093). Benign W0C confirm. */
  reg->DCPCTR = (uint16_t)(reg->DCPCTR & (uint16_t)~(uint16_t)k_ra8_dcpctr_mask_sqmon);
}

void priv_dvst_default_state(ra8_usb_speed_t speed)
{
  /* HUM Ch 37.2.32 DCPCTR p 2093: capture DCPCTR BEFORE the rearm.
   * DCPCTR.SQMON resets to 1 = DATA1-expected, so "SQMON==1" is NOT
   * a SETUP-arrival signal -- VALID is the race-immune signal. */
  volatile r_usb_regs_t* const reg = (speed == k_ra8_usb_speed_hs) ? ra8_usb_hs() : ra8_usb_fs();
  if (reg != nullptr) {
    const uint16_t dcpctr_pre = reg->DCPCTR;
    g_dcpctr_pre_rearm        = dcpctr_pre;
    g_dcpctr_bit_map_observed = (uint16_t)(g_dcpctr_bit_map_observed | dcpctr_pre);
 
    /* SQMON probe retained for older bisect notes. */
    const uint16_t now_sqmon = (uint16_t)(dcpctr_pre & (uint16_t)k_ra8_dcpctr_mask_sqmon);
 
    g_dispatch_attempts++;
    const uint16_t intsts0_pre   = reg->INTSTS0;
    g_intsts0_at_sqmon_edge      = intsts0_pre;
    g_intsts0_observed_or_recent = intsts0_pre;
 
    /* Drain persistent SETUP mirrors every Default-state tick. */
    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;
 
    internal_dvst_capture_setup_mirror(usbreq_live, usbval_live, usbindx_live, usbleng_live);
    internal_dvst_dispatch_if_new(reg, usbreq_live, usbval_live, usbindx_live, usbleng_live);
    s_prev_dcpctr_sqmon = now_sqmon;
  }
  (void)ra8_usb_device_busreset_rearm(speed);
  g_busreset_rearm_count++;
  if (reg != nullptr) {
    g_dcpctr_after_rearm   = reg->DCPCTR;
    g_intenb0_after_rearm  = reg->INTENB0;
    g_cfifosel_after_rearm = reg->CFIFOSEL;
  }
}