ux_dcd_ra8_usb_dvst.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_dvst_irq_count = 0U;

typedef enum : uint16_t {
  k_ra8_usb_u16_unset = 0xFFFFU, 
} ra8_usb_dcd_sentinel_t;

volatile uint16_t g_dvstctr0_at_first_dvst = (uint16_t)k_ra8_usb_u16_unset;

typedef enum : uint8_t {
  k_ra8_usb_dcd_rhst_hist_n = 16U, 
} ra8_usb_dcd_rhst_hist_t;

volatile uint8_t g_rhst_history[(uint32_t)k_ra8_usb_dcd_rhst_hist_n] = {};

volatile uint32_t g_rhst_history_count = 0U;

volatile uint16_t g_dvstctr0_history[(uint32_t)k_ra8_usb_dcd_rhst_hist_n] = {};

volatile uint32_t g_dvstctr0_history_count = 0U;

volatile uint16_t g_intsts1_history[(uint32_t)k_ra8_usb_dcd_rhst_hist_n] = {};

volatile uint8_t g_dvst_state_history[(uint32_t)k_ra8_usb_dcd_rhst_hist_n] = {};

volatile uint32_t g_dvst_state_history_count = 0U;

typedef enum : uint8_t {
  k_ra8_usb_rhst_fs = 2U, 
  k_ra8_usb_rhst_hs = 3U, 
} ra8_usb_dcd_rhst_t;

RA8_INTERNAL static unsigned long internal_dvst_map_dvsq_to_ux_state(uint16_t dvsq)
{
  if ((dvsq & (uint16_t)k_ra8_dvsq_suspend) != 0U) {
    return (unsigned long)UX_DEVICE_SUSPENDED;
  }
  switch (dvsq & (uint16_t)k_ra8_intsts0_mask_dvsq) {
    case (uint16_t)k_ra8_dvsq_default: /* Default -- bus reset complete */
      return (unsigned long)UX_DEVICE_ATTACHED;
    case (uint16_t)k_ra8_dvsq_address: /* Address state */
      return (unsigned long)UX_DEVICE_ADDRESSED;
    case (uint16_t)k_ra8_dvsq_configured: /* Configured state */
      return (unsigned long)UX_DEVICE_CONFIGURED;
    case (uint16_t)k_ra8_dvsq_powered: /* Powered -- pre-bus-reset */
    default:
      return (unsigned long)UX_DEVICE_ATTACHED;
  }
}

RA8_INTERNAL static void internal_dvst_record_history(uint16_t dvsq)
{
  const uint8_t dvst_slot =
    (uint8_t)(g_dvst_state_history_count % (uint32_t)k_ra8_usb_dcd_rhst_hist_n);
  uint8_t entry_state = (uint8_t)k_dcd_trace_nibble;
  if (_ux_system_slave != UX_NULL) {
    entry_state = (uint8_t)(_ux_system_slave->ux_system_slave_device.ux_slave_device_state &
                            (unsigned long)k_dcd_trace_nibble);
  }
  const uint8_t packed            = (uint8_t)((uint8_t)((dvsq >> (uint8_t)k_ra8_int0_dvsq_shift)
                                                        << (uint8_t)k_dcd_trace_nib_shift) |
                                              entry_state);
  g_dvst_state_history[dvst_slot] = packed;
  g_dvst_state_history_count++;
  priv_trace_event((uint8_t)k_dcd_trace_kind_dvst, packed, 0U);
}

RA8_INTERNAL static bool
internal_dvst_policy_apply(UX_SLAVE_DEVICE* device, uint16_t dvsq, unsigned long new_state)
{
  bool apply = false;
  if (new_state == (unsigned long)UX_DEVICE_SUSPENDED) {
    apply = false;
  } else if (new_state > device->ux_slave_device_state) {
    apply = true; /* upgrade */
  } else if (dvsq == (uint16_t)k_ra8_dvsq_default) {
    (void)_ux_device_stack_disconnect(); /* deactivates iff configured */
    apply = true;
  }
  return apply;
}

RA8_INTERNAL static void internal_handle_dvst(ra8_usb_speed_t speed, uint16_t intsts0)
{
  /* DVSQ field bits 6:4 on BOTH controllers (suspend = bit 6). USBHS
   * additionally reports VBUS status in bit 7, which must be stripped
   * -- keeping it made every event decode as "suspended" and the
   * mirror went inert (bus resets were ignored, see below). */
  const uint16_t dvsq = (uint16_t)(intsts0 & (uint16_t)k_ra8_intsts0_mask_dvsq);
 
  internal_dvst_record_history(dvsq);
 
  /* On Default-state entry (DVSQ == 0x10), re-arm DCP per FSP
   * usb_pstd_busreset reference flow. Without rearm the IP silently
   * drops the host's first SETUP token after bus reset. */
  if (dvsq == (uint16_t)k_ra8_dvsq_default) {
    priv_dvst_default_state(speed);
  }
  /* Suspended sub-states must not be treated as bus transitions. */
 
  if (_ux_system_slave == UX_NULL) {
    return;
  }
  UX_SLAVE_DEVICE*    device    = &_ux_system_slave->ux_system_slave_device;
  const unsigned long new_state = internal_dvst_map_dvsq_to_ux_state(dvsq);
  if ((dvsq & (uint16_t)k_ra8_dvsq_suspend) == 0U) {
    /* Any non-suspend bus-state transition invalidates the SETUP
     * de-dup fingerprint. */
    g_last_dispatched_setup_fp = 0U;
  }
  /* Upgrade-only mirror; disconnect + apply on true bus reset only --
   * rationale in internal_dvst_policy_apply's header. */
  if (internal_dvst_policy_apply(device, dvsq, new_state)) {
    device->ux_slave_device_state = new_state;
    if (_ux_system_slave->ux_system_slave_change_function != UX_NULL) {
      (void)_ux_system_slave->ux_system_slave_change_function(new_state);
    }
  }
}

RA8_INTERNAL static void internal_dvst_track_speed(uint8_t rhst)
{
  if (_ux_system_slave == UX_NULL) {
    return;
  }
  if (rhst == (uint8_t)k_ra8_usb_rhst_fs) {
    _ux_system_slave->ux_system_slave_speed = UX_FULL_SPEED_DEVICE;
    _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;
  } else if (rhst == (uint8_t)k_ra8_usb_rhst_hs) {
    _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 {
    /* Transient RHST (LS / in-reset / undefined): leave the mirror. */
  }
}

void priv_irq_dvst_prelude(ra8_usb_speed_t speed, uint16_t intsts0)
{
  g_dvst_irq_count++;
  volatile r_usb_regs_t* reg      = (speed == k_ra8_usb_speed_hs) ? ra8_usb_hs() : ra8_usb_fs();
  const uint16_t         dvstctr0 = reg->DVSTCTR0;
  if (g_dvstctr0_at_first_dvst == (uint16_t)k_ra8_usb_u16_unset) {
    g_dvstctr0_at_first_dvst = dvstctr0;
  }
  /* RHST occupies DVSTCTR0[2:0]. HUM Ch 36.2.5 p 1971. */
  const uint8_t rhst_mask   = (uint8_t)k_ra8_usb_dvsq_field_mask;
  const uint8_t rhst        = (uint8_t)(dvstctr0 & rhst_mask);
  const uint8_t hist_slot   = (uint8_t)(g_rhst_history_count % (uint32_t)k_ra8_usb_dcd_rhst_hist_n);
  g_rhst_history[hist_slot] = rhst;
  g_rhst_history_count++;
  internal_dvst_track_speed(rhst);
  internal_handle_dvst(speed, intsts0);
}