ra8_usb_cdc.c

Go to the documentation of this file.

 
#include "ra8_usb_cdc.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_cdc_internal.h"
 
static const char* s_tag = "USBCDC";

typedef enum : uint8_t {
  k_ra8_cdc_bm_class_recip_iface = 0x21U, 
  k_ra8_cdc_bm_class_recip_in    = 0xA1U, 
  k_ra8_cdc_default_data_bits    = 8U,    
  k_ra8_cdc_default_stop_bits    = 0U,    
  k_ra8_cdc_default_parity_none  = 0U,    
  k_ra8_cdc_line_coding_len      = 7U,    
} ra8_usb_cdc_setup_field_t;

typedef enum : uint16_t {
  k_ra8_cdc_data_stage_polls = 1000U, 
} ra8_usb_cdc_data_stage_t;

typedef enum : uint32_t {
  k_ra8_cdc_default_baud = 9600U, 
} ra8_usb_cdc_default_baud_t;

typedef enum : uint8_t {
  k_ra8_cdc_shift_byte0 = 0U,  
  k_ra8_cdc_shift_byte1 = 8U,  
  k_ra8_cdc_shift_byte2 = 16U, 
  k_ra8_cdc_shift_byte3 = 24U, 
} ra8_usb_cdc_byte_shift_t;

typedef enum : uint8_t {
  k_ra8_cdc_idx_baud_b0     = 0U, 
  k_ra8_cdc_idx_baud_b1     = 1U, 
  k_ra8_cdc_idx_baud_b2     = 2U, 
  k_ra8_cdc_idx_baud_b3     = 3U, 
  k_ra8_cdc_idx_char_format = 4U, 
  k_ra8_cdc_idx_parity_type = 5U, 
  k_ra8_cdc_idx_data_bits   = 6U, 
} ra8_usb_cdc_byte_idx_t;

typedef struct {
  bool                      initialized; 
  ra8_usb_speed_t           speed;       
  ra8_usb_cdc_line_coding_t coding;      
  bool                      dtr;         
  bool                      rts;         
} ra8_usb_cdc_state_t;
 
static ra8_usb_cdc_state_t s_state = {};
 
/* =============================================================================
 * Internal helpers
 * =============================================================================
 */

RA8_INTERNAL
static void internal_default_coding(ra8_usb_cdc_line_coding_t* coding)
{
  coding->dte_rate    = k_ra8_cdc_default_baud;
  coding->char_format = k_ra8_cdc_default_stop_bits;
  coding->parity_type = k_ra8_cdc_default_parity_none;
  coding->data_bits   = k_ra8_cdc_default_data_bits;
}

RA8_INTERNAL
static ra8_err_t internal_configure_pipes(ra8_usb_speed_t speed)
{
  const uint16_t bulk_mp =
    (speed == k_ra8_usb_speed_hs) ? k_ra8_cdc_bulk_max_packet_hs : k_ra8_cdc_bulk_max_packet_fs;
 
  ra8_err_t err = ra8_usb_configure_endpoint(speed,
                                             k_ra8_cdc_pipe_bulk_in,
                                             k_ra8_cdc_ep_bulk_in_addr,
                                             k_ra8_usb_ep_dir_in,
                                             k_ra8_usb_ep_type_bulk,
                                             bulk_mp);
  RA8_RETURN_ON_ERROR(err, /* GCOVR_EXCL_BR_LINE -- valid speed + static valid bulk-IN tuple */
                      s_tag,
                      "cdc: bulk-in cfg");
 
  err = ra8_usb_configure_endpoint(speed,
                                   k_ra8_cdc_pipe_bulk_out,
                                   k_ra8_cdc_ep_bulk_out_addr,
                                   k_ra8_usb_ep_dir_out,
                                   k_ra8_usb_ep_type_bulk,
                                   bulk_mp);
  RA8_RETURN_ON_ERROR(err, /* GCOVR_EXCL_BR_LINE -- valid speed + static valid bulk-OUT tuple */
                      s_tag,
                      "cdc: bulk-out cfg");
 
  err = ra8_usb_configure_endpoint(speed,
                                   k_ra8_cdc_pipe_intr_in,
                                   k_ra8_cdc_ep_intr_in_addr,
                                   k_ra8_usb_ep_dir_in,
                                   k_ra8_usb_ep_type_intr,
                                   k_ra8_cdc_intr_max_packet);
  return err;
}

RA8_INTERNAL
static void internal_apply_line_coding(const uint8_t* data, uint16_t len)
{
  if ((data == nullptr) || (len < k_ra8_cdc_line_coding_len)) {
    return;
  }
  uint32_t baud = (uint32_t)data[k_ra8_cdc_idx_baud_b0];
  baud |= (uint32_t)((uint32_t)data[k_ra8_cdc_idx_baud_b1] << k_ra8_cdc_shift_byte1);
  baud |= (uint32_t)((uint32_t)data[k_ra8_cdc_idx_baud_b2] << k_ra8_cdc_shift_byte2);
  baud |= (uint32_t)((uint32_t)data[k_ra8_cdc_idx_baud_b3] << k_ra8_cdc_shift_byte3);
  s_state.coding.dte_rate    = baud;
  s_state.coding.char_format = data[k_ra8_cdc_idx_char_format];
  s_state.coding.parity_type = data[k_ra8_cdc_idx_parity_type];
  s_state.coding.data_bits   = data[k_ra8_cdc_idx_data_bits];
}
 
RA8_TEST_HELPER
void ra8_usb_cdc_test_apply_line_coding(const uint8_t* data, uint16_t len)
{
  internal_apply_line_coding(data, len);
}
 
/* =============================================================================
 * Lifecycle
 * =============================================================================
 */
 
ra8_err_t ra8_usb_cdc_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.dtr   = false;
  s_state.rts   = false;
  internal_default_coding(&s_state.coding);
 
  const ra8_err_t pipes_err = internal_configure_pipes(speed);
  if (pipes_err != k_ra8_ok) {
    (void)ra8_usb_device_deinit(speed);
    return pipes_err;
  }
  s_state.initialized = true;
  ra8_log_info(s_tag, "CDC ready");
  return k_ra8_ok;
}
 
ra8_err_t ra8_usb_cdc_deinit(void)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  (void)ra8_usb_device_attach(s_state.speed, false);
  const ra8_err_t err = ra8_usb_device_deinit(s_state.speed);
  s_state.initialized = false;
  s_state.dtr         = false;
  s_state.rts         = false;
  return err;
}
 
ra8_err_t ra8_usb_cdc_attach(bool attached)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  return ra8_usb_device_attach(s_state.speed, attached);
}
 
/* =============================================================================
 * Bulk byte pipe
 * =============================================================================
 */
 
ra8_err_t ra8_usb_cdc_send(const uint8_t* data, uint16_t len)
{
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if ((data == nullptr) && (len != 0U)) {
    return k_ra8_err_invalid_arg;
  }
  return ra8_usb_queue_in(s_state.speed, k_ra8_cdc_pipe_bulk_in, data, len);
}
 
ra8_err_t ra8_usb_cdc_recv(uint8_t* out_buf, uint16_t* inout_len)
{
  RA8_CHECK_NULL_PTR(out_buf, s_tag, "cdc_recv: out_buf");
  RA8_CHECK_NULL_PTR(inout_len, s_tag, "cdc_recv: inout_len");
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if (*inout_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  /* rearm = true: re-arm PID=BUF so the bulk-OUT pipe keeps ACKing
   * host data between cdc_recv calls (the legacy queue_out behaviour). */
  return ra8_usb_queue_out(s_state.speed, k_ra8_cdc_pipe_bulk_out, out_buf, inout_len, true);
}
 
/* =============================================================================
 * SETUP request handler
 * =============================================================================
 */
 
RA8_INTERNAL
RA8_BOUNDED_LOOP(k_ra8_cdc_data_stage_polls)
static ra8_err_t internal_pull_data_stage(uint8_t* buf, uint16_t cap, uint16_t* out_len)
{
  RA8_CHECK_NULL_PTR(buf, s_tag, "pull_data_stage: buf");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "pull_data_stage: out_len");
  if (cap == 0U) {
    return k_ra8_err_invalid_arg;
  }
  *out_len              = 0U;
  const ra8_err_t armed = ra8_usb_dcp_out_arm(s_state.speed);
  if (armed != k_ra8_ok) {
    return armed;
  }
  ra8_err_t rc = k_ra8_err_no_data;
  for (uint16_t i = 0U; i < k_ra8_cdc_data_stage_polls; ++i) {
    rc = ra8_usb_dcp_out_read(s_state.speed, buf, cap, out_len);
    if (rc != k_ra8_err_no_data) {
      return rc;
    }
  }
  return rc;
}

RA8_INTERNAL
static ra8_err_t internal_dispatch_class_setup(const ra8_usb_setup_t* setup)
{
  switch (setup->b_request) {
    case k_ra8_cdc_req_set_line_coding: {
      uint8_t         buf[k_ra8_cdc_line_coding_len + 1U] = {};
      uint16_t        plen                                = 0U;
      const ra8_err_t pull = internal_pull_data_stage(buf, (uint16_t)sizeof(buf), &plen);
      if (pull == k_ra8_ok) {
        internal_apply_line_coding(buf, plen);
      }
      /* The status stage is ACKed either way: a host that abandoned the data
       * stage still gets a well-formed control-write completion, and the cached
       * coding simply keeps its previous value. */
      return ra8_usb_control_response(s_state.speed, true);
    }
    case k_ra8_cdc_req_get_line_coding: {
      return ra8_usb_control_response(s_state.speed, true);
    }
    case k_ra8_cdc_req_set_control_line_state: {
      const uint16_t mask = setup->w_value;
      s_state.dtr         = ((mask & k_ra8_cdc_line_state_dtr) != 0U);
      s_state.rts         = ((mask & k_ra8_cdc_line_state_rts) != 0U);
      return ra8_usb_control_response(s_state.speed, true);
    }
    default: {
      return k_ra8_err_not_supported;
    }
  }
}
 
ra8_err_t ra8_usb_cdc_handle_setup(const ra8_usb_setup_t* setup)
{
  RA8_CHECK_NULL_PTR(setup, s_tag, "handle_setup: setup");
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  if ((setup->bm_request_type != k_ra8_cdc_bm_class_recip_iface) &&
      (setup->bm_request_type != k_ra8_cdc_bm_class_recip_in)) {
    return k_ra8_err_not_supported;
  }
  return internal_dispatch_class_setup(setup);
}
 
ra8_err_t ra8_usb_cdc_get_line_coding(ra8_usb_cdc_line_coding_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "get_line_coding: out");
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  *out = s_state.coding;
  return k_ra8_ok;
}
 
ra8_err_t ra8_usb_cdc_get_line_state(bool* out_dtr, bool* out_rts)
{
  RA8_CHECK_NULL_PTR(out_dtr, s_tag, "get_line_state: out_dtr");
  RA8_CHECK_NULL_PTR(out_rts, s_tag, "get_line_state: out_rts");
  if (!s_state.initialized) {
    return k_ra8_err_invalid_state;
  }
  *out_dtr = s_state.dtr;
  *out_rts = s_state.rts;
  return k_ra8_ok;
}