ux_dcd_ra8_usb_ep.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"

RA8_INTERNAL static void internal_endpoint_arm_out_pid(uint8_t pipe, uint8_t ep_addr)
{
  if ((ep_addr & (uint8_t)k_ra8_usb_ep_addr_dir_in_bit) != 0U) {
    return; /* IN pipe -- queue_in / internal_submit_pipe own the PID */
  }
  /* Fresh OUT-pipe config: drop any orphan packet held from a prior
   * configuration so it cannot be misdelivered to a new transfer. */
  g_orphan_len        = 0U;
  bool auto_echo_pipe = false;
  if (g_dcd_auto_echo_enable != 0U) {
    if (pipe == g_dcd_auto_echo_out_pipe) {
      auto_echo_pipe = true;
    }
  }
  /* HUM Ch 36.2.27 "PIPEnCTR : PIPE n Control Register" p 2005 */
  if (auto_echo_pipe) {
    (void)ra8_usb_rearm_out_pipe(g_dcd.speed, pipe);
  } else {
    (void)ra8_usb_park_out_pipe(g_dcd.speed, pipe);
  }
}

RA8_INTERNAL static unsigned int internal_endpoint_create(struct UX_SLAVE_ENDPOINT_STRUCT* ep)
{
  g_diag.ep_create_calls++;
  if (ep == nullptr) {
    return UX_ERROR;
  }
  const uint8_t ep_addr = (uint8_t)ep->ux_slave_endpoint_descriptor.bEndpointAddress;
  const uint8_t pipe    = priv_ep_to_pipe(ep_addr);
  if (pipe == 0U || pipe >= (uint8_t)k_ux_dcd_ra8_usb_max_pipes) {
    /* DCP is configured by ra8_usb_device_init; class layer should
     * not call CREATE_ENDPOINT for EP0. */
    return UX_SUCCESS;
  }
 
  ra8_usb_ep_dir_t  dir = ((ep_addr & (uint8_t)k_ra8_usb_ep_addr_dir_in_bit) != 0U)
                            ? k_ra8_usb_ep_dir_in
                            : k_ra8_usb_ep_dir_out;
  ra8_usb_ep_type_t type;
  switch ((uint8_t)ep->ux_slave_endpoint_descriptor.bmAttributes & 0x03U) {
    case 0x02U:
      type = k_ra8_usb_ep_type_bulk;
      break;
    case 0x03U:
      type = k_ra8_usb_ep_type_intr;
      break;
    case 0x01U:
      type = k_ra8_usb_ep_type_iso;
      break;
    default:
      return UX_ERROR;
  }
 
  if (ra8_usb_configure_endpoint(g_dcd.speed,
                                 pipe,
                                 (uint8_t)(ep_addr & (uint8_t)k_ra8_usb_ep_addr_num_mask),
                                 dir,
                                 type,
                                 (uint16_t)ep->ux_slave_endpoint_descriptor.wMaxPacketSize) !=
      k_ra8_ok) {
    g_diag.ep_create_fail++;
    return UX_ERROR;
  }
  g_dcd.pipes[pipe].ep_addr = ep_addr;
  g_dcd.pipes[pipe].dir_in =
    (uint8_t)((ep_addr & (uint8_t)k_ra8_usb_ep_addr_dir_in_bit) != 0U ? 1U : 0U);
  g_dcd.pipes[pipe].max_pkt = (uint16_t)ep->ux_slave_endpoint_descriptor.wMaxPacketSize;
  internal_endpoint_arm_out_pid(pipe, ep_addr);
  return UX_SUCCESS;
}

RA8_INTERNAL static unsigned int internal_endpoint_stall(struct UX_SLAVE_ENDPOINT_STRUCT* ep)
{
  if (ep == nullptr) {
    return UX_ERROR;
  }
  const uint8_t pipe = priv_ep_to_pipe((uint8_t)ep->ux_slave_endpoint_descriptor.bEndpointAddress);
  if (pipe >= (uint8_t)k_ux_dcd_ra8_usb_max_pipes) {
    return UX_ERROR;
  }
  return (ra8_usb_stall_endpoint(g_dcd.speed, pipe) == k_ra8_ok) ? UX_SUCCESS : UX_ERROR;
}
 
/* -------------------------------------------------------------------------- */
/* USBX entry-point: the ux_slave_dcd_function trampoline */
/* -------------------------------------------------------------------------- */

RA8_INTERNAL static unsigned int internal_endpoint_destroy(struct UX_SLAVE_ENDPOINT_STRUCT* ep)
{
  if (ep == nullptr) {
    return UX_ERROR;
  }
  const uint8_t pipe = priv_ep_to_pipe((uint8_t)ep->ux_slave_endpoint_descriptor.bEndpointAddress);
  if (pipe < (uint8_t)k_ux_dcd_ra8_usb_max_pipes) {
    g_dcd.pipes[pipe].xfer = nullptr;
  }
  return UX_SUCCESS;
}

RA8_INTERNAL static void internal_count_change_state(unsigned long state)
{
  if (state == (unsigned long)UX_DEVICE_ATTACHED) {
    g_diag.chg_state_attached++;
  }
  if (state == (unsigned long)UX_DEVICE_CONFIGURED) {
    g_diag.chg_state_configured++;
  }
}
 
unsigned int
_ux_dcd_ra8_usb_function(struct UX_SLAVE_DCD_STRUCT* dcd, unsigned int function, void* parameter)
{
  (void)dcd;
  if (g_dcd.state == k_ux_dcd_ra8_usb_state_uninit) {
    return UX_CONTROLLER_UNKNOWN;
  }
 
  switch (function) {
    case UX_DCD_TRANSFER_REQUEST:
      return priv_transfer_request((UX_SLAVE_TRANSFER*)parameter);
 
    case UX_DCD_TRANSFER_ABORT:
      /* Best effort: NAK the pipe by re-running endpoint configure. */
      return UX_SUCCESS;
 
    case UX_DCD_CREATE_ENDPOINT:
      return internal_endpoint_create((UX_SLAVE_ENDPOINT*)parameter);
 
    case UX_DCD_DESTROY_ENDPOINT:
      return internal_endpoint_destroy((UX_SLAVE_ENDPOINT*)parameter);
 
    case UX_DCD_RESET_ENDPOINT:
      /* ra8_usb has no per-pipe reset that's exposed -- the class
       * layer's expected sequence is destroy + create. We accept
       * this as a no-op. */
      return UX_SUCCESS;
 
    case UX_DCD_STALL_ENDPOINT:
      return internal_endpoint_stall((UX_SLAVE_ENDPOINT*)parameter);
 
    case UX_DCD_SET_DEVICE_ADDRESS:
      /* No-op: the SIE auto-responds to SET_ADDRESS (HUM Ch 37.3 p 2147)
       * -- writing USBADDR from firmware fights the auto-latch and
       * stalls enumeration. */
      return UX_SUCCESS;
 
    case UX_DCD_GET_FRAME_NUMBER:
      if (parameter != nullptr) {
        *(unsigned long*)parameter = 0UL; /* ra8_usb does not surface FRMNUM. */
      }
      return UX_SUCCESS;
 
    case UX_DCD_CHANGE_STATE:
      internal_count_change_state((unsigned long)parameter);
      g_dcd.state = ((unsigned long)parameter != 0UL) ? k_ux_dcd_ra8_usb_state_active
                                                      : k_ux_dcd_ra8_usb_state_ready;
      return UX_SUCCESS;
 
    case UX_DCD_ENDPOINT_STATUS:
      return UX_SUCCESS;
 
    case UX_DCD_ISR_PENDING:
      return UX_SUCCESS;
 
    default:
      return UX_FUNCTION_NOT_SUPPORTED;
  }
}