ra8_usb_pal.c

Go to the documentation of this file.

 
#include "ra8_usb_pal.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_usb.h"
#include "ra8_usb_pal_internal.h"

bool priv_usb_pal_should_dispatch_event(const void* event_fn, uint16_t mask, uint16_t none_value)
{
  return (event_fn != nullptr) && (mask != none_value);
}

bool priv_usb_pal_ep_out_of_range(uint8_t ep_addr, uint8_t ep_max)
{
  return (ep_addr == 0U) || (ep_addr > ep_max);
}
 
static const char* s_tag = "USBPAL";
 
/* =============================================================================
 * Ring sizing
 * =============================================================================
 */
 
typedef enum : uint16_t {
  k_ra8_usb_pal_ep_table_len = 11U,   
  k_ra8_usb_pal_ring_slots   = 4U,    
  k_ra8_usb_pal_pkt_max      = 1024U, 
} ra8_usb_pal_ring_dim_t;
 
/* =============================================================================
 * Per-EP + per-PAL state
 * =============================================================================
 */

typedef struct {
  uint16_t len;                         
  uint8_t  data[k_ra8_usb_pal_pkt_max]; 
} ra8_usb_pal_packet_t;

typedef struct {
  bool                  opened;                         
  ra8_usb_pal_ep_dir_t  dir;                            
  ra8_usb_pal_ep_type_t type;                           
  uint16_t              max_packet;                     
  uint16_t              head;                           
  uint16_t              tail;                           
  uint16_t              count;                          
  ra8_usb_pal_packet_t  ring[k_ra8_usb_pal_ring_slots]; 
} ra8_usb_pal_ep_slot_t;

typedef struct {
  ra8_usb_speed_t        speed;                           
  ra8_usb_pal_state_t    state;                           
  ra8_usb_pal_event_fn_t event_fn;                        
  void*                  event_ctx;                       
  bool                   initialized;                     
  ra8_usb_pal_ep_slot_t  eps[k_ra8_usb_pal_ep_table_len]; 
} ra8_usb_pal_state_inner_t;
 
static ra8_usb_pal_state_inner_t s_state = {};
 
/* =============================================================================
 * Internal helpers
 * =============================================================================
 */

RA8_INTERNAL
static void internal_copy_bytes(uint8_t* dst, const uint8_t* src, uint16_t len)
{
  for (uint16_t i = 0U; i < len; ++i) {
    dst[i] = src[i];
  }
}

RA8_INTERNAL
static void internal_reset_eps(void)
{
  for (uint16_t i = 0U; i < k_ra8_usb_pal_ep_table_len; ++i) {
    ra8_usb_pal_ep_slot_t* slot = &s_state.eps[i];
    slot->opened                = false;
    slot->dir                   = k_ra8_usb_pal_ep_dir_out;
    slot->type                  = k_ra8_usb_pal_ep_type_control;
    slot->max_packet            = 0U;
    slot->head                  = 0U;
    slot->tail                  = 0U;
    slot->count                 = 0U;
    for (uint16_t j = 0U; j < k_ra8_usb_pal_ring_slots; ++j) {
      slot->ring[j].len = 0U;
    }
  }
}

RA8_INTERNAL
static uint16_t internal_translate(uint16_t usb_mask)
{
  if (usb_mask != 0U) {
    return k_ra8_usb_pal_event_error;
  }
  return k_ra8_usb_pal_event_none;
}

RA8_INTERNAL
static void internal_usb_event(void* ctx, ra8_usb_speed_t speed, uint16_t status_mask)
{
  (void)ctx;
  if (!s_state.initialized) {
    return;
  }
  if (speed != s_state.speed) {
    return;
  }
  const uint16_t pal_mask = internal_translate(status_mask);
  if (priv_usb_pal_should_dispatch_event((const void*)s_state.event_fn,
                                         pal_mask,
                                         (uint16_t)k_ra8_usb_pal_event_none)) {
    s_state.event_fn(s_state.event_ctx, speed, pal_mask);
  }
}
 
/* =============================================================================
 * Public API
 * =============================================================================
 */

ra8_err_t ra8_usb_pal_init(ra8_usb_speed_t speed)
{
  if ((speed != k_ra8_usb_speed_fs) && (speed != k_ra8_usb_speed_hs)) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t usb_err = ra8_usb_device_init(speed);
  if (usb_err != k_ra8_ok) {
    ra8_log_error_val(s_tag, "ra8_usb_device_init failed", (uint32_t)usb_err);
    return k_ra8_err_hw_init_failed;
  }
 
  s_state.speed       = speed;
  s_state.state       = k_ra8_usb_pal_state_detached;
  s_state.event_fn    = nullptr;
  s_state.event_ctx   = nullptr;
  s_state.initialized = true;
  internal_reset_eps();
 
  ra8_usb_attach_handler(speed, internal_usb_event, nullptr);
 
  ra8_log_info(s_tag, "PAL ready");
  return k_ra8_ok;
}

ra8_err_t ra8_usb_pal_deinit(void)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  (void)ra8_usb_device_attach(s_state.speed, false);
  ra8_usb_attach_handler(s_state.speed, nullptr, nullptr);
  const ra8_err_t err = ra8_usb_device_deinit(s_state.speed);
  s_state.initialized = false;
  s_state.event_fn    = nullptr;
  s_state.event_ctx   = nullptr;
  s_state.state       = k_ra8_usb_pal_state_detached;
  internal_reset_eps();
  return err;
}

ra8_err_t ra8_usb_pal_attach(bool attached)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  /* `ra8_usb_device_attach` rejects only an invalid controller selector;
   * successful initialization stored a validated selector in `s_state`. */
  (void)ra8_usb_device_attach(s_state.speed, attached);
  if (attached) {
    s_state.state = k_ra8_usb_pal_state_attached;
  } else {
    s_state.state = k_ra8_usb_pal_state_detached;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_usb_pal_get_state(ra8_usb_pal_state_t* out_state)
{
  RA8_CHECK_NULL_PTR(out_state, s_tag, "get_state: out_state");
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  *out_state = s_state.state;
  return k_ra8_ok;
}

ra8_err_t ra8_usb_pal_ep_open(uint8_t               ep_addr,
                              ra8_usb_pal_ep_dir_t  dir,
                              ra8_usb_pal_ep_type_t type,
                              uint16_t              max_packet)
{
  /* USB descriptor bEndpointAddress encodes direction in bit 7
   * (0x80 = IN). Strip it so callers can pass either the descriptor
   * form (e.g. 0x83) or the bare endpoint number (e.g. 3). */
  ep_addr = (uint8_t)(ep_addr & (uint8_t)k_ra8_usb_pal_ep_addr_mask);
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if (priv_usb_pal_ep_out_of_range(ep_addr, (uint8_t)k_ra8_usb_pal_ep_max)) {
    return k_ra8_err_invalid_arg;
  }
  if ((dir != k_ra8_usb_pal_ep_dir_out) && (dir != k_ra8_usb_pal_ep_dir_in)) {
    return k_ra8_err_invalid_arg;
  }
  if ((type > k_ra8_usb_pal_ep_type_intr) || (max_packet == 0U) ||
      (max_packet > k_ra8_usb_pal_xfer_max)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_usb_pal_ep_slot_t* slot = &s_state.eps[ep_addr];
  slot->opened                = true;
  slot->dir                   = dir;
  slot->type                  = type;
  slot->max_packet            = max_packet;
  slot->head                  = 0U;
  slot->tail                  = 0U;
  slot->count                 = 0U;
  for (uint16_t j = 0U; j < k_ra8_usb_pal_ring_slots; ++j) {
    slot->ring[j].len = 0U;
  }
  return k_ra8_ok;
}

ra8_err_t ra8_usb_pal_ep_send(uint8_t ep_addr, const uint8_t* data, uint16_t len)
{
  /* Accept descriptor-shaped (0x80 | ep) and bare-number ep_addr. */
  ep_addr = (uint8_t)(ep_addr & (uint8_t)k_ra8_usb_pal_ep_addr_mask);
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if (priv_usb_pal_ep_out_of_range(ep_addr, (uint8_t)k_ra8_usb_pal_ep_max)) {
    return k_ra8_err_invalid_arg;
  }
  if ((len > k_ra8_usb_pal_xfer_max) || ((data == nullptr) && (len != 0U))) {
    return (data == nullptr) ? k_ra8_err_null_ptr : k_ra8_err_invalid_arg;
  }
  ra8_usb_pal_ep_slot_t* slot = &s_state.eps[ep_addr];
  if (!slot->opened) {
    return k_ra8_err_invalid_state;
  }
  if (len > slot->max_packet) {
    return k_ra8_err_invalid_arg;
  }
  if (slot->count >= k_ra8_usb_pal_ring_slots) {
    return k_ra8_err_no_mem;
  }
  ra8_usb_pal_packet_t* pkt = &slot->ring[slot->tail];
  if (len > 0U) {
    internal_copy_bytes(pkt->data, data, len);
  }
  pkt->len   = len;
  slot->tail = (uint16_t)((slot->tail + 1U) % k_ra8_usb_pal_ring_slots);
  ++slot->count;
  if (s_state.event_fn != nullptr) {
    s_state.event_fn(s_state.event_ctx, s_state.speed, k_ra8_usb_pal_event_ep_in);
  }
  return k_ra8_ok;
}

ra8_err_t ra8_usb_pal_ep_recv(uint8_t ep_addr, uint8_t* out_buf, uint16_t* inout_len)
{
  RA8_CHECK_NULL_PTR(out_buf, s_tag, "ep_recv: out_buf");
  RA8_CHECK_NULL_PTR(inout_len, s_tag, "ep_recv: inout_len");
  /* Accept descriptor-shaped (0x80 | ep) and bare-number ep_addr. */
  ep_addr = (uint8_t)(ep_addr & (uint8_t)k_ra8_usb_pal_ep_addr_mask);
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if (priv_usb_pal_ep_out_of_range(ep_addr, (uint8_t)k_ra8_usb_pal_ep_max)) {
    return k_ra8_err_invalid_arg;
  }
  if (*inout_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  ra8_usb_pal_ep_slot_t* slot = &s_state.eps[ep_addr];
  if (!slot->opened) {
    return k_ra8_err_invalid_state;
  }
  if (slot->count == 0U) {
    return k_ra8_err_no_data;
  }
  ra8_usb_pal_packet_t* pkt = &slot->ring[slot->head];
  const uint16_t        n   = (pkt->len < *inout_len) ? pkt->len : *inout_len;
  if (n > 0U) {
    internal_copy_bytes(out_buf, pkt->data, n);
  }
  *inout_len = n;
  pkt->len   = 0U;
  slot->head = (uint16_t)((slot->head + 1U) % k_ra8_usb_pal_ring_slots);
  --slot->count;
  return k_ra8_ok;
}

ra8_err_t ra8_usb_pal_set_event_handler(ra8_usb_pal_event_fn_t fn, void* ctx)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  s_state.event_fn  = fn;
  s_state.event_ctx = ctx;
  return k_ra8_ok;
}