ns_usb_host.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ns_usb_internal.h"
#include "ra8_usb.h"
#include "tx_api.h"
 
/* =============================================================================
 * Host-side bench milestone counters (NS .bss; J-Link reads these)
 * =============================================================================
 */

volatile uint32_t g_tz_usb_host_phase;

volatile uint32_t g_tz_usb_host_pid;

volatile uint32_t g_tz_usb_host_rounds_ok;

volatile uint32_t g_tz_usb_host_err;
 
/* =============================================================================
 * HS host: polled CDC enumerate + bulk echo over the self-loop
 * =============================================================================
 */

TX_THREAD s_ns_host_thread;

UCHAR s_ns_host_stack[k_ns_host_stack_bytes];

CHAR s_ns_host_thread_name[] = "ns_usb_host";

typedef enum : uint16_t {
  k_ns_bm_std_dev_in   = 0x80U, 
  k_ns_bm_std_dev_out  = 0x00U, 
  k_ns_breq_get_desc   = 0x06U, 
  k_ns_breq_set_addr   = 0x05U, 
  k_ns_breq_set_config = 0x09U, 
  k_ns_desc_device     = 0x01U, 
  k_ns_dev_desc_len    = 18U,   
  k_ns_off_dev_pid     = 10U,   
  k_ns_byte_bits       = 8U,    
  k_ns_config_value    = 1U,    
} ns_host_req_t;

typedef enum : uint32_t {
  k_ns_vbus_settle_ms = 200U,      
  k_ns_attach_to_ms   = 2000U,     
  k_ns_debounce_ms    = 500U,      
  k_ns_reset_hold_ms  = 50U,       
  k_ns_recovery_ms    = 20U,       
  k_ns_addr_settle_ms = 5U,        
  k_ns_enum_tries     = 8U,        
  k_ns_attach_spin    = 50000000U, 
  k_ns_dev_addr       = 1U,        
  k_ns_mps            = 64U,       
  k_ns_payload        = 60U,       
  k_ns_echo_buf       = 64U,       
  k_ns_ep_in_num      = 1U,        
  k_ns_ep_out_num     = 2U,        
  k_ns_host_pipe_in   = 1U,        
  k_ns_host_pipe_out  = 2U,        
  k_ns_pat_round_mul  = 97U,       
  k_ns_pat_idx_mul    = 7U,        
  k_ns_pat_bias       = 0x5AU,     
  k_ns_byte_mask      = 0xFFU,     
  k_ns_boot_wait_tk   = 500U,      
  k_ns_retry_tk       = 1000U,     
} ns_host_tune_t;

static void ns_host_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_ns_pat_round_mul) + (i * (uint32_t)k_ns_pat_idx_mul) +
                       (uint32_t)k_ns_pat_bias;
    out[i]           = (uint8_t)(v & (uint32_t)k_ns_byte_mask);
  }
}

[[nodiscard]] static ra8_err_t ns_host_get_dev_desc(uint8_t* desc)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_ns_bm_std_dev_in,
    .b_request       = (uint8_t)k_ns_breq_get_desc,
    .w_value         = (uint16_t)((uint16_t)k_ns_desc_device << (uint16_t)k_ns_byte_bits),
    .w_index         = 0U,
    .w_length        = (uint16_t)k_ns_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_ns_dev_desc_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  return (rx == (uint16_t)k_ns_dev_desc_len) ? k_ra8_ok : k_ra8_err_hw_error;
}

[[nodiscard]] static ra8_err_t ns_host_enum_hunt(uint8_t* desc)
{
  ra8_delay_ms((uint32_t)k_ns_vbus_settle_ms);
  const uint32_t t0 = ra8_time_ms();
  for (uint32_t spin = 0U; spin < (uint32_t)k_ns_attach_spin; spin++) {
    if (ra8_usb_host_line_state(k_ra8_usb_speed_hs) != 0U) {
      break;
    }
    if ((ra8_time_ms() - t0) > (uint32_t)k_ns_attach_to_ms) {
      break;
    }
  }
  ra8_delay_ms((uint32_t)k_ns_debounce_ms);
  ra8_err_t err = k_ra8_err_hw_timeout;
  for (uint8_t attempt = 0U; attempt < (uint8_t)k_ns_enum_tries; attempt++) {
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, true);
    ra8_delay_ms((uint32_t)k_ns_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((uint32_t)k_ns_recovery_ms);
    (void)ra8_usb_host_set_target(k_ra8_usb_speed_hs, 0U);
    err = ns_host_get_dev_desc(desc);
    if (err == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return err;
}

[[nodiscard]] static ra8_err_t ns_host_set_address(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_ns_bm_std_dev_out,
    .b_request       = (uint8_t)k_ns_breq_set_addr,
    .w_value         = (uint16_t)k_ns_dev_addr,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  const 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((uint32_t)k_ns_addr_settle_ms);
  return ra8_usb_host_set_target(k_ra8_usb_speed_hs, (uint8_t)k_ns_dev_addr);
}

[[nodiscard]] static ra8_err_t ns_host_set_config(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_ns_bm_std_dev_out,
    .b_request       = (uint8_t)k_ns_breq_set_config,
    .w_value         = (uint16_t)k_ns_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 ns_host_open_pipes(void)
{
  const ra8_err_t err = ra8_usb_host_pipe_setup(k_ra8_usb_speed_hs,
                                                (uint8_t)k_ns_host_pipe_out,
                                                (uint8_t)k_ns_dev_addr,
                                                (uint8_t)k_ns_ep_out_num,
                                                false,
                                                (uint16_t)k_ns_mps);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_usb_host_pipe_setup(k_ra8_usb_speed_hs,
                                 (uint8_t)k_ns_host_pipe_in,
                                 (uint8_t)k_ns_dev_addr,
                                 (uint8_t)k_ns_ep_in_num,
                                 true,
                                 (uint16_t)k_ns_mps);
}

[[nodiscard]] static ra8_err_t ns_host_enumerate(uint32_t* out_pid)
{
  uint8_t   desc[k_ns_dev_desc_len] = {};
  ra8_err_t err                     = ns_host_enum_hunt(desc);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_pid = (uint32_t)desc[k_ns_off_dev_pid] |
             ((uint32_t)desc[(uint32_t)k_ns_off_dev_pid + 1U] << (uint32_t)k_ns_byte_bits);
  err      = ns_host_set_address();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ns_host_set_config();
  if (err != k_ra8_ok) {
    return err;
  }
  return ns_host_open_pipes();
}

[[nodiscard]] static ra8_err_t ns_host_echo_round(uint32_t round)
{
  static uint8_t s_tx[k_ns_payload]  = {};
  static uint8_t s_rx[k_ns_echo_buf] = {};
  ns_host_pattern_fill(round, s_tx, (uint32_t)k_ns_payload);
  ra8_err_t err = ra8_usb_host_bulk_out(k_ra8_usb_speed_hs,
                                        (uint8_t)k_ns_host_pipe_out,
                                        s_tx,
                                        (uint16_t)k_ns_payload);
  if (err != k_ra8_ok) {
    return err;
  }
  uint16_t rx = 0U;
  err         = ra8_usb_host_bulk_in(k_ra8_usb_speed_hs,
                                     (uint8_t)k_ns_host_pipe_in,
                                     s_rx,
                                     (uint16_t)k_ns_echo_buf,
                                     &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rx != (uint16_t)k_ns_payload) {
    return k_ra8_err_invalid_size;
  }
  if (memcmp(s_rx, s_tx, (size_t)k_ns_payload) != 0) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}
 
VOID ns_host_worker(ULONG arg)
{
  (void)arg;
  (void)tx_thread_sleep((ULONG)k_ns_boot_wait_tk);
 
  uint32_t pid = 0U;
  while (1) {
    g_tz_usb_host_phase = 1U;
    ra8_err_t err       = ra8_usb_host_init(k_ra8_usb_speed_hs);
    if (err != k_ra8_ok) {
      g_tz_usb_host_err = (uint32_t)err;
      (void)tx_thread_sleep((ULONG)k_ns_retry_tk);
      continue;
    }
    g_tz_usb_host_phase = 2U;
    err                 = ns_host_enumerate(&pid);
    if (err != k_ra8_ok) {
      g_tz_usb_host_err = (uint32_t)err;
      (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
      (void)tx_thread_sleep((ULONG)k_ns_retry_tk);
      continue;
    }
    g_tz_usb_host_pid   = pid;
    g_tz_usb_host_phase = 3U;
    break;
  }
 
  /* Enumerated. Run bulk echo rounds forever; rounds_ok advancing is the
   * end-to-end self-loop proof (host bulk-OUT -> device auto-echo -> host
   * bulk-IN, byte-checked). */
  g_tz_usb_host_phase = 4U;
  uint32_t round      = 0U;
  while (1) {
    const ra8_err_t err = ns_host_echo_round(round);
    if (err == k_ra8_ok) {
      g_tz_usb_host_rounds_ok += 1U;
    } else if (g_tz_usb_host_err == 0U) {
      g_tz_usb_host_err = (uint32_t)err;
    }
    round += 1U;
  }
}