usb_selftest_cdc_steps.c

Go to the documentation of this file.

 
#include "usb_selftest_cdc_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_time.h"
#include "ra8_usb.h"
 
#ifndef RA8_OFF_TARGET

typedef enum : uint8_t {
  k_cdc_hex_chars_u16   = 4U,  
  k_cdc_hex_chars_u32   = 8U,  
  k_cdc_dec_chars_u32   = 10U, 
  k_cdc_nibble_bits     = 4U,  
  k_cdc_hex_digit_split = 10U, 
} cdc_hex_t;

typedef enum : uint32_t {
  k_cdc_nibble_mask = 0xFU, 
  k_cdc_dec_radix   = 10U,  
} cdc_mask_t;

typedef enum : uint32_t {
  k_cdc_phase_boot   = 0U, 
  k_cdc_phase_init   = 1U, 
  k_cdc_phase_enum   = 2U, 
  k_cdc_phase_verify = 3U, 
  k_cdc_phase_pass   = 4U, 
} cdc_phase_t;
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (host side) */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_phase;
static volatile uint32_t s_dbg_rounds_ok;
static volatile uint32_t s_dbg_pid;
static volatile uint32_t s_dbg_mismatch = (uint32_t)k_cdc_no_mismatch;
static volatile uint32_t s_dbg_pass_count;
 
/* -------------------------------------------------------------------------- */
/* Shared per-round echo pattern */
/* -------------------------------------------------------------------------- */

static void cdc_pattern_fill(uint32_t round, uint8_t* out, uint32_t len)
{
  for (uint32_t i = 0U; i < len; i++) {
    const uint32_t v = (round * (uint32_t)k_cdc_pat_round_mul) + (i * (uint32_t)k_cdc_pat_idx_mul) +
                       (uint32_t)k_cdc_pat_bias;
    out[i]           = (uint8_t)(v & (uint32_t)k_cdc_byte_mask);
  }
}
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

static uint8_t cdc_nibble_to_hex(uint32_t nibble)
{
  if (nibble < k_cdc_hex_digit_split) {
    return (uint8_t)((uint8_t)'0' + (uint8_t)nibble);
  }
  return (uint8_t)((uint8_t)'A' + (uint8_t)nibble - (uint8_t)k_cdc_hex_digit_split);
}

static uint32_t cdc_str_len(const char* text)
{
  uint32_t len = 0U;
  while (len < (uint32_t)k_cdc_print_cap) {
    if (text[len] == '\0') {
      break;
    }
    len++;
  }
  return len;
}

[[nodiscard]] static ra8_err_t cdc_sci_write(const uint8_t* data, uint32_t len)
{
  return ra8_board_uart_console_write(data, (size_t)len);
}

[[nodiscard]] static ra8_err_t cdc_print(const char* text)
{
  return cdc_sci_write((const uint8_t*)text, cdc_str_len(text));
}

[[nodiscard]] static ra8_err_t cdc_print_dec(uint32_t value)
{
  uint8_t  scratch[k_cdc_dec_chars_u32] = {};
  uint8_t  out[k_cdc_dec_chars_u32]     = {};
  uint8_t  count                        = 0U;
  uint32_t v                            = value;
  if (v == 0U) {
    out[0] = (uint8_t)'0';
    return cdc_sci_write(out, 1U);
  }
  while (v != 0U) {
    if (count >= (uint8_t)k_cdc_dec_chars_u32) {
      break;
    }
    scratch[count] = (uint8_t)((uint8_t)'0' + (uint8_t)(v % k_cdc_dec_radix));
    v              = v / k_cdc_dec_radix;
    count++;
  }
  for (uint8_t i = 0U; i < count; i++) {
    out[i] = scratch[count - 1U - i];
  }
  return cdc_sci_write(out, (uint32_t)count);
}

[[nodiscard]] static ra8_err_t cdc_print_hex(uint32_t value, uint8_t digits)
{
  uint8_t out[k_cdc_hex_chars_u32] = {};
  uint8_t width                    = digits;
  if (width > (uint8_t)k_cdc_hex_chars_u32) {
    width = (uint8_t)k_cdc_hex_chars_u32;
  }
  for (uint8_t i = 0U; i < width; i++) {
    const uint8_t shift = (uint8_t)((width - 1U - i) * k_cdc_nibble_bits);
    out[i]              = cdc_nibble_to_hex((value >> shift) & k_cdc_nibble_mask);
  }
  return cdc_sci_write(out, (uint32_t)width);
}

[[nodiscard]] static ra8_err_t cdc_print_fail(const char* what, ra8_err_t err)
{
  ra8_err_t e = cdc_print("ra8d2 cdc: FAIL ");
  if (e != k_ra8_ok) {
    return e;
  }
  e = cdc_print(what);
  if (e != k_ra8_ok) {
    return e;
  }
  e = cdc_print(" err=0x");
  if (e != k_ra8_ok) {
    return e;
  }
  e = cdc_print_hex((uint32_t)err, (uint8_t)k_cdc_hex_chars_u32);
  if (e != k_ra8_ok) {
    return e;
  }
  return cdc_print("\r\n");
}
 
/* -------------------------------------------------------------------------- */
/* Host side: self-contained polled CDC enumerate + bulk echo */
/* -------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_cdc_bm_std_dev_in   = 0x80U, 
  k_cdc_bm_std_dev_out  = 0x00U, 
  k_cdc_breq_get_desc   = 0x06U, 
  k_cdc_breq_set_addr   = 0x05U, 
  k_cdc_breq_set_config = 0x09U, 
  k_cdc_desc_device     = 0x01U, 
  k_cdc_dev_desc_len    = 18U,   
  k_cdc_off_dev_pid     = 10U,   
  k_cdc_byte_bits       = 8U,    
  k_cdc_config_value    = 1U,    
} cdc_usb_req_t;

typedef enum : uint32_t {
  k_cdc_vbus_settle_ms = 200U,      
  k_cdc_attach_to_ms   = 2000U,     
  k_cdc_debounce_ms    = 500U,      
  k_cdc_reset_hold_ms  = 50U,       
  k_cdc_recovery_ms    = 20U,       
  k_cdc_addr_settle_ms = 5U,        
  k_cdc_enum_tries     = 8U,        
  k_cdc_attach_spin    = 50000000U, 
} cdc_enum_tune_t;

[[nodiscard]] static ra8_err_t cdc_ctrl_get_dev_desc(uint8_t* desc)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_cdc_bm_std_dev_in,
    .b_request       = (uint8_t)k_cdc_breq_get_desc,
    .w_value         = (uint16_t)((uint16_t)k_cdc_desc_device << (uint16_t)k_cdc_byte_bits),
    .w_index         = 0U,
    .w_length        = (uint16_t)k_cdc_dev_desc_len,
  };
  uint16_t        rx = 0U;
  const ra8_err_t err =
    ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, desc, (uint16_t)k_cdc_dev_desc_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rx != (uint16_t)k_cdc_dev_desc_len) {
    return k_ra8_err_hw_error;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t cdc_enum_hunt(uint8_t* desc)
{
  ra8_delay_ms(k_cdc_vbus_settle_ms);
  const uint32_t t0 = ra8_time_ms();
  for (uint32_t spin = 0U; spin < (uint32_t)k_cdc_attach_spin; spin++) {
    if (ra8_usb_host_line_state(k_ra8_usb_speed_hs) != 0U) {
      break;
    }
    if ((ra8_time_ms() - t0) > (uint32_t)k_cdc_attach_to_ms) {
      break;
    }
  }
  ra8_delay_ms(k_cdc_debounce_ms);
  ra8_err_t err = k_ra8_err_hw_timeout;
  for (uint8_t attempt = 0U; attempt < (uint8_t)k_cdc_enum_tries; attempt++) {
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, true);
    ra8_delay_ms(k_cdc_reset_hold_ms);
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, false);
    (void)ra8_usb_host_set_uact(k_ra8_usb_speed_hs, true);
    ra8_delay_ms(k_cdc_recovery_ms);
    (void)ra8_usb_host_set_target(k_ra8_usb_speed_hs, 0U);
    err = cdc_ctrl_get_dev_desc(desc);
    if (err == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return err;
}

[[nodiscard]] static ra8_err_t cdc_enum_set_address(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_cdc_bm_std_dev_out,
    .b_request       = (uint8_t)k_cdc_breq_set_addr,
    .w_value         = (uint16_t)k_cdc_dev_addr,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  ra8_err_t err = ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, nullptr, 0U, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms(k_cdc_addr_settle_ms);
  return ra8_usb_host_set_target(k_ra8_usb_speed_hs, (uint8_t)k_cdc_dev_addr);
}

[[nodiscard]] static ra8_err_t cdc_enum_set_config(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_cdc_bm_std_dev_out,
    .b_request       = (uint8_t)k_cdc_breq_set_config,
    .w_value         = (uint16_t)k_cdc_config_value,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  return ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, nullptr, 0U, nullptr);
}

[[nodiscard]] static ra8_err_t cdc_open_pipes(void)
{
  ra8_err_t err = ra8_usb_host_pipe_setup(k_ra8_usb_speed_hs,
                                          (uint8_t)k_cdc_pipe_out,
                                          (uint8_t)k_cdc_dev_addr,
                                          (uint8_t)k_cdc_ep_out_num,
                                          false,
                                          (uint16_t)k_cdc_mps);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_usb_host_pipe_setup(k_ra8_usb_speed_hs,
                                 (uint8_t)k_cdc_pipe_in,
                                 (uint8_t)k_cdc_dev_addr,
                                 (uint8_t)k_cdc_ep_in_num,
                                 true,
                                 (uint16_t)k_cdc_mps);
}

[[nodiscard]] static ra8_err_t cdc_enumerate(uint32_t* out_pid)
{
  uint8_t   desc[k_cdc_dev_desc_len] = {};
  ra8_err_t err                      = cdc_enum_hunt(desc);
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("enumerate", err);
    return err;
  }
  *out_pid = (uint32_t)desc[k_cdc_off_dev_pid] |
             ((uint32_t)desc[(uint32_t)k_cdc_off_dev_pid + 1U] << (uint32_t)k_cdc_byte_bits);
  err      = cdc_enum_set_address();
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("set_address", err);
    return err;
  }
  err = cdc_enum_set_config();
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("set_config", err);
    return err;
  }
  err = cdc_open_pipes();
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("open_pipes", err);
  }
  return err;
}

[[nodiscard]] static ra8_err_t cdc_print_enum(uint32_t pid)
{
  ra8_err_t err = cdc_print("ra8d2 cdc: enumerated pid=0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = cdc_print_hex(pid, (uint8_t)k_cdc_hex_chars_u16);
  if (err != k_ra8_ok) {
    return err;
  }
  return cdc_print("\r\n");
}

[[nodiscard]] static ra8_err_t cdc_print_pass(void)
{
  ra8_err_t err = cdc_print("ra8d2 cdc: ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = cdc_print_dec((uint32_t)k_cdc_rounds);
  if (err != k_ra8_ok) {
    return err;
  }
  return cdc_print(" rounds echoed -- USB SELFTEST CDC-ECHO PASS\r\n");
}

[[nodiscard]] static ra8_err_t cdc_echo_round(uint32_t round)
{
  static uint8_t s_tx[k_cdc_payload]  = {};
  static uint8_t s_rx[k_cdc_echo_buf] = {};
  cdc_pattern_fill(round, s_tx, (uint32_t)k_cdc_payload);
  ra8_err_t err = ra8_usb_host_bulk_out(k_ra8_usb_speed_hs,
                                        (uint8_t)k_cdc_pipe_out,
                                        s_tx,
                                        (uint16_t)k_cdc_payload);
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("bulk_out", err);
    return err;
  }
  uint16_t rx = 0U;
  err         = ra8_usb_host_bulk_in(k_ra8_usb_speed_hs,
                                     (uint8_t)k_cdc_pipe_in,
                                     s_rx,
                                     (uint16_t)k_cdc_echo_buf,
                                     &rx);
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("bulk_in", err);
    return err;
  }
  if (rx != (uint16_t)k_cdc_payload) {
    s_dbg_mismatch = round;
    (void)cdc_print_fail("echo length", k_ra8_err_invalid_size);
    return k_ra8_err_invalid_size;
  }
  if (memcmp(s_rx, s_tx, (size_t)k_cdc_payload) != 0) {
    s_dbg_mismatch = round;
    (void)cdc_print_fail("echo data mismatch", k_ra8_err_invalid_state);
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t cdc_host_pass(void)
{
  s_dbg_phase   = (uint32_t)k_cdc_phase_init;
  ra8_err_t err = cdc_print("ra8d2 cdc: host up on USB-HS, probing the loop...\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_usb_host_init(k_ra8_usb_speed_hs);
  if (err != k_ra8_ok) {
    (void)cdc_print_fail("host init", err);
    return err;
  }
 
  s_dbg_phase  = (uint32_t)k_cdc_phase_enum;
  uint32_t pid = 0U;
  err          = cdc_enumerate(&pid);
  if (err != k_ra8_ok) {
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
  s_dbg_pid = pid;
  err       = cdc_print_enum(pid);
  if (err != k_ra8_ok) {
    return err;
  }
 
  s_dbg_phase     = (uint32_t)k_cdc_phase_verify;
  s_dbg_rounds_ok = 0U;
  for (uint32_t r = 0U; r < (uint32_t)k_cdc_rounds; r++) {
    err = cdc_echo_round(r);
    if (err != k_ra8_ok) {
      (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
      return err;
    }
    s_dbg_rounds_ok++;
  }
 
  s_dbg_phase = (uint32_t)k_cdc_phase_pass;
  s_dbg_pass_count++;
  err = cdc_print_pass();
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}
 
VOID cdc_host_worker(ULONG arg)
{
  (void)arg;
 
  tx_thread_sleep(k_cdc_boot_wait_ticks);
  for (;;) {
    const ra8_err_t err = cdc_host_pass();
    if (err == k_ra8_ok) {
      break;
    }
    tx_thread_sleep(k_cdc_retry_ticks);
  }
  while (1) {
    tx_thread_sleep(k_cdc_idle_ticks);
  }
}
 
#endif /* !RA8_OFF_TARGET */