board_usb_host.c

Go to the documentation of this file.

 
#include "board_usb_host.h"
 
#include <stdio.h>
#include <string.h>
 
#include "board_usb.h"
#include "emu_host_io_internal.h"
#include "ra8_usb_regs.h"
 
/* =============================================================================
 * Window geometry + model sizing.
 * =============================================================================
 */

typedef enum : uint64_t {
  k_usbhs_base      = 0x40351000UL, 
  k_usbhs_span      = 0x104UL,      
  k_usbhs_reg_words = 0x104UL / 2U, 
  k_usbhs_stage_cap = 512UL,        
  k_usbhs_mps_fall  = 64UL,         
} usbhs_geom_t;

typedef enum : uint16_t {
  k_usbhs_dvst_rhst_fs = 0x0002U, 
  k_usbhs_dvst_usbrst  = 0x0040U, 
} usbhs_dvst_t;

typedef enum : uint16_t {
  k_usbhs_dcpctr_sureq    = 0x4000U, 
  k_usbhs_dcpctr_sureqclr = 0x0800U, 
  k_usbhs_dcpctr_ccpl     = 0x0004U, 
  k_usbhs_ctr_sqset       = 0x0080U, 
  k_usbhs_ctr_sqclr       = 0x0100U, 
  k_usbhs_ctr_pulse_mask  = 0x4980U, 
} usbhs_pulse_t;

typedef enum : uint16_t {
  k_usbhs_int1_sack = 0x0010U, 
  k_usbhs_int1_sign = 0x0020U, 
} usbhs_int1_t;

typedef enum : uint16_t {
  k_usbhs_setup_dir_in = 0x0080U, 
  k_usbhs_dcp_bit      = 0x0001U, 
  k_usbhs_lnst_j_state = 0x0001U, 
  k_usbhs_byte_mask    = 0x00FFU, 
} usbhs_bits_t;

typedef enum : uint32_t {
  k_usbhs_byte_bits = 8U, 
} usbhs_misc_t;

typedef enum : uint16_t {
  k_usbhs_dcpmaxp_mxps  = 0x007FU, 
  k_usbhs_pipemaxp_mxps = 0x07FFU, 
  k_usbhs_rhst_mask     = 0x0007U, 
} usbhs_field_t;
 
/* =============================================================================
 * Model state.
 * =============================================================================
 */

typedef struct {
  uint16_t reg[k_usbhs_reg_words];         
  uint16_t pipecfg[k_ra8_usb_pipe_count];  
  uint16_t pipebuf[k_ra8_usb_pipe_count];  
  uint16_t pipemaxp[k_ra8_usb_pipe_count]; 
  uint16_t pipeperi[k_ra8_usb_pipe_count]; 
  uint8_t  stage[k_usbhs_stage_cap];       
  uint16_t stage_len;                      
  uint16_t rhst;                           
  bool     engaged;                        
  bool     allowed;                        
  bool     last_setup_in;                  
  bool     sie_status_done;                
  bool     ccpl_armed;                     
  bool     status_zlp;                     
  uint32_t setups;                         
  uint32_t bulk_out;                       
  uint32_t bulk_in;                        
} usbhs_state_t;

static usbhs_state_t s_hs;

static bool s_hs_trace;
 
/* =============================================================================
 * Small helpers.
 * =============================================================================
 */

RA8_INTERNAL static uint32_t internal_usbhs_word(uint64_t off)
{
  return (uint32_t)((off & ~(uint64_t)1U) / 2U);
}

RA8_INTERNAL static uint8_t internal_usbhs_cur_pipe(void)
{
  const uint16_t sel = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_cfifosel)];
  return (uint8_t)(sel & (uint16_t)k_ra8_fifosel_curpipe);
}

RA8_INTERNAL static bool internal_usbhs_cfifo_isel(void)
{
  const uint16_t sel = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_cfifosel)];
  return (sel & (uint16_t)k_ra8_fifosel_isel) != 0U;
}

RA8_INTERNAL static uint8_t internal_usbhs_pipe_ep(uint8_t pipe)
{
  const uint8_t ep =
    (uint8_t)(s_hs.pipecfg[pipe % k_ra8_usb_pipe_count] & (uint16_t)k_ra8_pipecfg_epnum_mask);
  return (ep != 0U) ? ep : pipe; /* unconfigured: fall back to pipe == EP. */
}

RA8_INTERNAL static bool internal_usbhs_pipe_is_tx(uint8_t pipe)
{
  return (s_hs.pipecfg[pipe % k_ra8_usb_pipe_count] & (uint16_t)k_ra8_pipecfg_dir_in) != 0U;
}

RA8_INTERNAL static uint16_t internal_usbhs_pipe_mps(uint8_t pipe)
{
  const uint16_t mps =
    (uint16_t)(s_hs.pipemaxp[pipe % k_ra8_usb_pipe_count] & (uint16_t)k_usbhs_pipemaxp_mxps);
  return (mps != 0U) ? mps : (uint16_t)k_usbhs_mps_fall;
}

RA8_INTERNAL static uint16_t internal_usbhs_dcp_mps(void)
{
  const uint16_t mps = (uint16_t)(s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_dcpmaxp)] &
                                  (uint16_t)k_usbhs_dcpmaxp_mxps);
  return (mps != 0U) ? mps : (uint16_t)k_usbhs_mps_fall;
}
 
/* =============================================================================
 * Bus transactions (loop-cable forwarding).
 * =============================================================================
 */

RA8_INTERNAL static void internal_usbhs_do_setup(uc_engine* uc)
{
  s_hs.last_setup_in   = false;
  s_hs.sie_status_done = false;
  s_hs.ccpl_armed      = false;
  s_hs.status_zlp      = false;
  const uint32_t w1    = internal_usbhs_word((uint64_t)k_ra8_usb_off_intsts1);
  if (!board_usb_loop_attached()) {
    s_hs.reg[w1] = (uint16_t)(s_hs.reg[w1] | (uint16_t)k_usbhs_int1_sign);
    return;
  }
  const uint16_t req   = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_usbreq)];
  const uint16_t val   = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_usbval)];
  const uint16_t indx  = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_usbindx)];
  const uint16_t leng  = s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_usbleng)];
  s_hs.last_setup_in   = ((req & (uint16_t)k_usbhs_setup_dir_in) != 0U);
  s_hs.sie_status_done = board_usb_loop_setup(uc, req, val, indx, leng);
  s_hs.reg[w1]         = (uint16_t)(s_hs.reg[w1] | (uint16_t)k_usbhs_int1_sack);
  s_hs.setups++;
  if (s_hs_trace) {
    (void)priv_emu_io_errf("  USBHS host    : SETUP req=0x%04X wVal=0x%04X wLen=%u%s\n",
                           (unsigned)req,
                           (unsigned)val,
                           (unsigned)leng,
                           s_hs.sie_status_done ? " (SIE status)" : "");
  }
}

RA8_INTERNAL static void internal_usbhs_do_ccpl(uc_engine* uc)
{
  const uint32_t wb = internal_usbhs_word((uint64_t)k_ra8_usb_off_bempsts);
  if (s_hs.last_setup_in) {
    board_usb_loop_status_out_zlp(uc);
    s_hs.reg[wb] = (uint16_t)(s_hs.reg[wb] | (uint16_t)k_usbhs_dcp_bit);
    return;
  }
  if (s_hs.sie_status_done) {
    s_hs.status_zlp = true; /* SET_ADDRESS: the SIE completed the transfer. */
    return;
  }
  s_hs.ccpl_armed = true; /* status ZLP follows the device firmware's CCPL. */
}

RA8_INTERNAL static uint16_t internal_usbhs_brdysts_value(uc_engine* uc)
{
  if (s_hs.ccpl_armed && board_usb_loop_take_ccpl(uc)) {
    s_hs.ccpl_armed = false;
    s_hs.status_zlp = true;
  }
  uint16_t v = 0U;
  if (s_hs.status_zlp || (board_usb_loop_ctrl_in_avail() > 0U)) {
    v |= (uint16_t)k_usbhs_dcp_bit;
  }
  for (uint8_t pipe = 1U; pipe < (uint8_t)k_ra8_usb_pipe_count; pipe++) {
    if (s_hs.pipecfg[pipe] == 0U) {
      continue;
    }
    if (internal_usbhs_pipe_is_tx(pipe)) {
      continue;
    }
    if (board_usb_loop_bulk_in_avail(internal_usbhs_pipe_ep(pipe)) > 0U) {
      v = (uint16_t)(v | (uint16_t)(1U << pipe));
    }
  }
  return v;
}

RA8_INTERNAL static uint16_t internal_usbhs_cfifoctr_value(void)
{
  const uint8_t pipe  = internal_usbhs_cur_pipe();
  uint16_t      avail = 0U;
  uint16_t      mps   = (uint16_t)k_usbhs_mps_fall;
  if (pipe == 0U) {
    if (!internal_usbhs_cfifo_isel()) {
      avail = board_usb_loop_ctrl_in_avail();
      mps   = internal_usbhs_dcp_mps();
    }
  } else if (!internal_usbhs_pipe_is_tx(pipe)) {
    avail = board_usb_loop_bulk_in_avail(internal_usbhs_pipe_ep(pipe));
    mps   = internal_usbhs_pipe_mps(pipe);
  } else {
    avail = 0U;
  }
  const uint16_t dtln = (avail < mps) ? avail : mps;
  return (uint16_t)((uint16_t)k_ra8_fifoctr_frdy | (dtln & (uint16_t)k_ra8_fifoctr_dtln));
}

RA8_INTERNAL static uint64_t internal_usbhs_cfifo_read(uc_engine* uc, unsigned size)
{
  uint8_t        bytes[sizeof(uint32_t)] = {};
  const uint16_t cap  = (size < sizeof(bytes)) ? (uint16_t)size : (uint16_t)sizeof(bytes);
  const uint8_t  pipe = internal_usbhs_cur_pipe();
  uint16_t       got  = 0U;
  if (pipe == 0U) {
    got = board_usb_loop_ctrl_in_read(bytes, cap);
  } else if (!internal_usbhs_pipe_is_tx(pipe)) {
    got = board_usb_loop_bulk_in_read(uc, internal_usbhs_pipe_ep(pipe), bytes, cap);
    if (got > 0U) {
      s_hs.bulk_in++;
    }
  } else {
    got = 0U;
  }
  (void)got; /* short reads leave the upper packed bytes zero (don't-care). */
  uint64_t v = 0U;
  for (uint32_t i = 0U; i < (uint32_t)cap; i++) {
    v |= ((uint64_t)bytes[i]) << (i * (uint32_t)k_usbhs_byte_bits);
  }
  return v;
}

RA8_INTERNAL static void internal_usbhs_cfifo_write(uint64_t value, unsigned size)
{
  for (uint32_t i = 0U; (i < size) && (s_hs.stage_len < (uint16_t)k_usbhs_stage_cap); i++) {
    s_hs.stage[s_hs.stage_len] =
      (uint8_t)((value >> (i * (uint32_t)k_usbhs_byte_bits)) & (uint64_t)k_usbhs_byte_mask);
    s_hs.stage_len++;
  }
}

RA8_INTERNAL static void internal_usbhs_cfifoctr_write(uc_engine* uc, uint16_t value)
{
  const uint8_t pipe = internal_usbhs_cur_pipe();
  if ((value & (uint16_t)k_ra8_fifoctr_bclr) != 0U) {
    if (pipe == 0U) {
      if (internal_usbhs_cfifo_isel()) {
        s_hs.stage_len = 0U;
      } else {
        board_usb_loop_ctrl_in_flush();
        s_hs.status_zlp = false;
      }
    } else if (internal_usbhs_pipe_is_tx(pipe)) {
      s_hs.stage_len = 0U;
    } else {
      board_usb_loop_bulk_in_flush(internal_usbhs_pipe_ep(pipe));
    }
  }
  if ((value & (uint16_t)k_ra8_fifoctr_bval) != 0U) {
    const uint32_t wb = internal_usbhs_word((uint64_t)k_ra8_usb_off_bempsts);
    if ((pipe == 0U) && internal_usbhs_cfifo_isel() && (s_hs.stage_len > 0U)) {
      board_usb_loop_ctrl_out(uc, s_hs.stage, s_hs.stage_len);
      s_hs.reg[wb]   = (uint16_t)(s_hs.reg[wb] | (uint16_t)k_usbhs_dcp_bit);
      s_hs.stage_len = 0U;
    } else if ((pipe != 0U) && (s_hs.stage_len > 0U)) {
      board_usb_loop_bulk_out(uc, internal_usbhs_pipe_ep(pipe), s_hs.stage, s_hs.stage_len);
      s_hs.reg[wb]   = (uint16_t)(s_hs.reg[wb] | (uint16_t)(1U << pipe));
      s_hs.stage_len = 0U;
      s_hs.bulk_out++;
    }
  }
}

RA8_INTERNAL static void internal_usbhs_dvstctr_write(uc_engine* uc, uint16_t value)
{
  const uint32_t w   = internal_usbhs_word((uint64_t)k_ra8_usb_off_dvstctr0);
  const uint16_t old = s_hs.reg[w];
  s_hs.reg[w]        = (uint16_t)(value & (uint16_t)~(uint16_t)k_usbhs_rhst_mask);
  const bool was_rst = (old & (uint16_t)k_usbhs_dvst_usbrst) != 0U;
  const bool is_rst  = (value & (uint16_t)k_usbhs_dvst_usbrst) != 0U;
  if (was_rst && !is_rst) {
    if (board_usb_loop_attached()) {
      s_hs.rhst = (uint16_t)k_usbhs_dvst_rhst_fs;
      board_usb_loop_bus_reset(uc);
    } else {
      s_hs.rhst = 0U;
    }
  }
}

RA8_INTERNAL static void internal_usbhs_dcpctr_write(uc_engine* uc, uint16_t value)
{
  const uint32_t w   = internal_usbhs_word((uint64_t)k_ra8_usb_off_dcpctr);
  const uint16_t old = s_hs.reg[w];
  if (((value & (uint16_t)k_usbhs_dcpctr_sureq) != 0U) &&
      ((old & (uint16_t)k_usbhs_dcpctr_sureq) == 0U)) {
    internal_usbhs_do_setup(uc);
  }
  if (((value & (uint16_t)k_usbhs_dcpctr_ccpl) != 0U) &&
      ((old & (uint16_t)k_usbhs_dcpctr_ccpl) == 0U)) {
    internal_usbhs_do_ccpl(uc);
  }
  s_hs.reg[w] = (uint16_t)(value & (uint16_t)~(uint16_t)((uint16_t)k_usbhs_ctr_pulse_mask |
                                                         (uint16_t)k_usbhs_dcpctr_sureqclr));
}
 
/* =============================================================================
 * Engaged read / write dispatch.
 * =============================================================================
 */

RA8_INTERNAL static uint64_t internal_usbhs_reg_read(uc_engine* uc, uint64_t off, unsigned size)
{
  const uint8_t sel = (uint8_t)(s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_pipesel)] &
                                (uint16_t)k_ra8_fifosel_curpipe);
  switch ((uint16_t)off) {
    case (uint16_t)k_ra8_usb_off_syssts0:
      return (board_usb_loop_attached()) ? (uint64_t)k_usbhs_lnst_j_state : 0U;
    case (uint16_t)k_ra8_usbhs_off_pllsta:
      return (uint16_t)k_ra8_pllsta_plllock;
    case (uint16_t)k_ra8_usb_off_dvstctr0:
      return (uint16_t)(s_hs.reg[internal_usbhs_word(off)] | s_hs.rhst);
    case (uint16_t)k_ra8_usb_off_cfifo:
      return internal_usbhs_cfifo_read(uc, size); /* full width: 32-bit MBW drains. */
    case (uint16_t)k_ra8_usb_off_cfifoctr:
      return internal_usbhs_cfifoctr_value();
    case (uint16_t)k_ra8_usb_off_brdysts:
      return internal_usbhs_brdysts_value(uc);
    case (uint16_t)k_ra8_usb_off_nrdysts:
      return 0U;
    case (uint16_t)k_ra8_usb_off_pipecfg:
      return s_hs.pipecfg[sel % k_ra8_usb_pipe_count];
    case (uint16_t)k_ra8_usb_off_pipebuf:
      return s_hs.pipebuf[sel % k_ra8_usb_pipe_count];
    case (uint16_t)k_ra8_usb_off_pipemaxp:
      return s_hs.pipemaxp[sel % k_ra8_usb_pipe_count];
    case (uint16_t)k_ra8_usb_off_pipeperi:
      return s_hs.pipeperi[sel % k_ra8_usb_pipe_count];
    default:
      return s_hs.reg[internal_usbhs_word(off)];
  }
}

RA8_INTERNAL static void
internal_usbhs_reg_write(uc_engine* uc, uint64_t off, unsigned size, uint64_t value64)
{
  const uint16_t value = (uint16_t)value64;
  const uint8_t  sel   = (uint8_t)(s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_pipesel)] &
                                   (uint16_t)k_ra8_fifosel_curpipe);
  /* The CFIFO port spans +0x14..+0x17: 32-bit head words at +0x14, the
   * CFIFOH (+0x16) / CFIFOHH (+0x17) residual aliases for the 2- / 1-byte
   * tails. All append to the same OUT staging. */
  if ((off >= (uint64_t)k_ra8_usb_off_cfifo) && (off < (uint64_t)(k_ra8_usb_off_cfifo + 4U))) {
    internal_usbhs_cfifo_write(value64, size); /* full width: 32-bit MBW fills. */
    return;
  }
  switch ((uint16_t)off) {
    case (uint16_t)k_ra8_usb_off_cfifoctr:
      internal_usbhs_cfifoctr_write(uc, value);
      return;
    case (uint16_t)k_ra8_usb_off_dcpctr:
      internal_usbhs_dcpctr_write(uc, value);
      return;
    case (uint16_t)k_ra8_usb_off_dvstctr0:
      internal_usbhs_dvstctr_write(uc, value);
      return;
    case (uint16_t)k_ra8_usb_off_intsts1:
    case (uint16_t)k_ra8_usb_off_bempsts:
      /* W0C: a written 0 clears, a written 1 preserves. */
      s_hs.reg[internal_usbhs_word(off)] &= value;
      return;
    case (uint16_t)k_ra8_usb_off_brdysts:
      /* Live bits are composed; only the sticky status-ZLP flag is W0C. */
      if ((value & (uint16_t)k_usbhs_dcp_bit) == 0U) {
        s_hs.status_zlp = false;
      }
      return;
    case (uint16_t)k_ra8_usb_off_nrdysts:
      return; /* never latched -- nothing to clear. */
    case (uint16_t)k_ra8_usb_off_pipecfg:
      s_hs.pipecfg[sel % k_ra8_usb_pipe_count] = value;
      return;
    case (uint16_t)k_ra8_usb_off_pipebuf:
      s_hs.pipebuf[sel % k_ra8_usb_pipe_count] = value;
      return;
    case (uint16_t)k_ra8_usb_off_pipemaxp:
      s_hs.pipemaxp[sel % k_ra8_usb_pipe_count] = value;
      return;
    case (uint16_t)k_ra8_usb_off_pipeperi:
      s_hs.pipeperi[sel % k_ra8_usb_pipe_count] = value;
      return;
    default:
      break;
  }
  if ((off >= (uint64_t)k_ra8_usb_off_pipectr) &&
      (off < (uint64_t)(k_ra8_usb_off_pipectr +
                        ((uint64_t)k_ra8_usb_pipectr_count * sizeof(uint16_t))))) {
    /* PIPECTR: PID persists; the SQSET / SQCLR pulses never store. */
    s_hs.reg[internal_usbhs_word(off)] =
      (uint16_t)(value & (uint16_t)~(uint16_t)k_usbhs_ctr_pulse_mask);
    return;
  }
  s_hs.reg[internal_usbhs_word(off)] = value;
}
 
/* =============================================================================
 * Public lifecycle + MMIO entry points.
 * =============================================================================
 */
 
void board_usb_host_init(bool trace)
{
  s_hs       = (usbhs_state_t){};
  s_hs_trace = trace;
}
 
void board_usb_host_set_allowed(bool allowed)
{
  s_hs.allowed = allowed;
}
 
uint64_t board_usb_host_read(uc_engine* uc, uint64_t addr, unsigned size, bool* handled)
{
  if (!s_hs.engaged || (addr < (uint64_t)k_usbhs_base) ||
      (addr >= ((uint64_t)k_usbhs_base + (uint64_t)k_usbhs_span))) {
    *handled = false;
    return 0U;
  }
  *handled = true;
  return internal_usbhs_reg_read(uc, addr - (uint64_t)k_usbhs_base, size);
}
 
void board_usb_host_write(uc_engine* uc,
                          uint64_t   addr,
                          unsigned   size,
                          uint64_t   value,
                          bool*      handled)
{
  if ((addr < (uint64_t)k_usbhs_base) ||
      (addr >= ((uint64_t)k_usbhs_base + (uint64_t)k_usbhs_span))) {
    *handled = false;
    return;
  }
  const uint64_t off = addr - (uint64_t)k_usbhs_base;
  if (!s_hs.engaged) {
    /* Dormant: watch only the SYSCFG host-role select. The write still
     * reports unhandled so the sparse fallback records it and every app that
     * never engages keeps its exact current behaviour. */
    *handled = false;
    if (s_hs.allowed && (off == (uint64_t)k_ra8_usb_off_syscfg) &&
        (((uint16_t)value & (uint16_t)(1U << k_ra8_syscfg_bit_dcfm)) != 0U)) {
      s_hs.engaged                                                  = true;
      s_hs.reg[internal_usbhs_word((uint64_t)k_ra8_usb_off_syscfg)] = (uint16_t)value;
      board_usb_loop_latch();
      (void)priv_emu_io_errf(
        "  USBHS host    : host mode engaged (SYSCFG.DCFM) -- self-loop to USBFS\n");
      *handled = true;
    }
    return;
  }
  *handled = true;
  internal_usbhs_reg_write(uc, off, size, value);
}
 
void board_usb_host_report(void)
{
  if (!s_hs.engaged) {
    return;
  }
  (void)priv_emu_io_errf(
    "  USBHS host    : %u SETUP(s), %u bulk-OUT commit(s), %u bulk-IN drain(s)\n",
    s_hs.setups,
    s_hs.bulk_out,
    s_hs.bulk_in);
}