main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
#include "ra8_usb.h"
#include "usb_host_keyboard_steps.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_hid.h"
#include "ux_device_stack.h"
 
/* Strong SysTick override: route the tick into BOTH the ra8_time millisecond
 * counter (for ra8_delay_ms and the polled host stack's timeouts) AND
 * ThreadX's timer; the 1 ms pulse also recovers the DCD's storm-guard mask. */
 
extern void _tx_timer_interrupt(void);

static volatile bool s_tx_kernel_up = false;
 
void SysTick_Handler(void);
void SysTick_Handler(void)
{
  ra8_time_on_tick();
  if (s_tx_kernel_up) {
    _tx_timer_interrupt();
    ux_dcd_ra8_usb_irq_reenable();
  }
}
#endif
 
/* -------------------------------------------------------------------------- */
/* Pinout (FSP-aligned, EK-RA8D2 v1 User's Manual) */
/* -------------------------------------------------------------------------- */

static const ra8_port_pin_t k_hid_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_hid_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_hid_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_hid_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_hid_pin_hs_vbus = (ra8_port_pin_t)k_ra8_board_usbhs_pin_vbus;

static const ra8_port_pin_t k_hid_pin_hs_pwr = (ra8_port_pin_t)k_ra8_board_usbhs_pin_pwr;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

static char s_typed[k_hid_nkeys + 1U] = {};

typedef enum : uint32_t {
  k_hid_phase_boot   = 0U, 
  k_hid_phase_init   = 1U, 
  k_hid_phase_enum   = 2U, 
  k_hid_phase_verify = 3U, 
  k_hid_phase_pass   = 4U, 
} hid_phase_t;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX host worker + shared activation semaphore */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_host_thread;

static UCHAR s_host_stack[k_hid_host_stack];

TX_SEMAPHORE s_usb_host_keyboard_hid_active_sem;
 
/* -------------------------------------------------------------------------- */
/* 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_hid_no_mismatch;
static volatile uint32_t s_dbg_pass_count;
static volatile uint32_t s_dbg_last_seq;
 
/* -------------------------------------------------------------------------- */
/* Keycode decode (host side) */
/* -------------------------------------------------------------------------- */

static char hid_keycode_to_ascii(uint8_t kc)
{
  if ((kc >= (uint8_t)k_hid_kc_a) && (kc <= (uint8_t)k_hid_kc_z)) {
    return (char)('A' + (int)(kc - (uint8_t)k_hid_kc_a));
  }
  if ((kc >= (uint8_t)k_hid_kc_1) && (kc < (uint8_t)k_hid_kc_0)) {
    return (char)('1' + (int)(kc - (uint8_t)k_hid_kc_1));
  }
  if (kc == (uint8_t)k_hid_kc_0) {
    return '0';
  }
  return '?';
}
 
/* -------------------------------------------------------------------------- */
/* Host side: self-contained polled enumerate + HID interrupt-IN read */
/* -------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_hid_bm_std_dev_in   = 0x80U, 
  k_hid_bm_std_dev_out  = 0x00U, 
  k_hid_breq_get_desc   = 0x06U, 
  k_hid_breq_set_addr   = 0x05U, 
  k_hid_breq_set_config = 0x09U, 
  k_hid_desc_device     = 0x01U, 
  k_hid_dev_desc_len    = 18U,   
  k_hid_off_dev_pid     = 10U,   
  k_hid_byte_bits       = 8U,    
  k_hid_config_value    = 1U,    
} hid_usb_req_t;

typedef enum : uint32_t {
  k_hid_vbus_settle_ms = 200U,      
  k_hid_attach_to_ms   = 2000U,     
  k_hid_debounce_ms    = 500U,      
  k_hid_reset_hold_ms  = 50U,       
  k_hid_recovery_ms    = 20U,       
  k_hid_addr_settle_ms = 5U,        
  k_hid_enum_tries     = 8U,        
  k_hid_attach_spin    = 50000000U, 
} hid_enum_tune_t;

[[nodiscard]] static ra8_err_t hid_ctrl_get_dev_desc(uint8_t* desc)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_hid_bm_std_dev_in,
    .b_request       = (uint8_t)k_hid_breq_get_desc,
    .w_value         = (uint16_t)((uint16_t)k_hid_desc_device << (uint16_t)k_hid_byte_bits),
    .w_index         = 0U,
    .w_length        = (uint16_t)k_hid_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_hid_dev_desc_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rx != (uint16_t)k_hid_dev_desc_len) {
    return k_ra8_err_hw_error;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t hid_enum_hunt(uint8_t* desc)
{
  ra8_delay_ms(k_hid_vbus_settle_ms);
  const uint32_t t0 = ra8_time_ms();
  for (uint32_t spin = 0U; spin < (uint32_t)k_hid_attach_spin; spin++) {
    if (ra8_usb_host_line_state(k_ra8_usb_speed_hs) != 0U) {
      break;
    }
    if ((ra8_time_ms() - t0) > (uint32_t)k_hid_attach_to_ms) {
      break;
    }
  }
  ra8_delay_ms(k_hid_debounce_ms);
  ra8_err_t err = k_ra8_err_hw_timeout;
  for (uint8_t attempt = 0U; attempt < (uint8_t)k_hid_enum_tries; attempt++) {
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, true);
    ra8_delay_ms(k_hid_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_hid_recovery_ms);
    (void)ra8_usb_host_set_target(k_ra8_usb_speed_hs, 0U);
    err = hid_ctrl_get_dev_desc(desc);
    if (err == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return err;
}

[[nodiscard]] static ra8_err_t hid_enum_set_address(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_hid_bm_std_dev_out,
    .b_request       = (uint8_t)k_hid_breq_set_addr,
    .w_value         = (uint16_t)k_hid_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_hid_addr_settle_ms);
  return ra8_usb_host_set_target(k_ra8_usb_speed_hs, (uint8_t)k_hid_dev_addr);
}

[[nodiscard]] static ra8_err_t hid_enum_set_config(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_hid_bm_std_dev_out,
    .b_request       = (uint8_t)k_hid_breq_set_config,
    .w_value         = (uint16_t)k_hid_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 hid_open_pipes(void)
{
  return ra8_usb_host_pipe_setup(k_ra8_usb_speed_hs,
                                 (uint8_t)k_hid_pipe_in,
                                 (uint8_t)k_hid_dev_addr,
                                 (uint8_t)k_hid_ep_in_num,
                                 true,
                                 (uint16_t)k_hid_mps);
}

[[nodiscard]] static ra8_err_t hid_enumerate(uint32_t* out_pid)
{
  uint8_t   desc[k_hid_dev_desc_len] = {};
  ra8_err_t err                      = hid_enum_hunt(desc);
  if (err != k_ra8_ok) {
    (void)hid_print_fail("enumerate", err);
    return err;
  }
  *out_pid = (uint32_t)desc[k_hid_off_dev_pid] |
             ((uint32_t)desc[(uint32_t)k_hid_off_dev_pid + 1U] << (uint32_t)k_hid_byte_bits);
  err      = hid_enum_set_address();
  if (err != k_ra8_ok) {
    (void)hid_print_fail("set_address", err);
    return err;
  }
  err = hid_enum_set_config();
  if (err != k_ra8_ok) {
    (void)hid_print_fail("set_config", err);
    return err;
  }
  err = hid_open_pipes();
  if (err != k_ra8_ok) {
    (void)hid_print_fail("open_pipes", err);
  }
  return err;
}

[[nodiscard]] static ra8_err_t hid_print_enum(uint32_t pid)
{
  ra8_err_t err = hid_print("ra8d2 hid: enumerated pid=0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = hid_print_hex(pid, (uint8_t)k_hid_hex_chars_u16);
  if (err != k_ra8_ok) {
    return err;
  }
  return hid_print("\r\n");
}

[[nodiscard]] static ra8_err_t hid_print_pass(void)
{
  ra8_err_t err = hid_print("ra8d2 hid: host decoded keys \"");
  if (err == k_ra8_ok) {
    err = hid_print(s_typed);
  }
  if (err == k_ra8_ok) {
    err = hid_print("\" over ");
  }
  if (err == k_ra8_ok) {
    err = hid_print_dec((uint32_t)k_hid_rounds);
  }
  if (err == k_ra8_ok) {
    err = hid_print(" reports -- USB HOST KEYBOARD PASS\r\n");
  }
  return err;
}

[[nodiscard]] static ra8_err_t hid_read_round(uint32_t round)
{
  static uint8_t s_expect[k_hid_read_buf] = {};
  static uint8_t s_rx[k_hid_read_buf]     = {};
  hid_fill_report_body(s_expect, (uint32_t)k_hid_report_len);
  uint16_t        rx  = 0U;
  const ra8_err_t err = ra8_usb_host_bulk_in(k_ra8_usb_speed_hs,
                                             (uint8_t)k_hid_pipe_in,
                                             s_rx,
                                             (uint16_t)k_hid_read_buf,
                                             &rx);
  if (err != k_ra8_ok) {
    (void)hid_print_fail("report read", err);
    return err;
  }
  if (rx != (uint16_t)k_hid_report_len) {
    s_dbg_mismatch = round;
    (void)hid_print_fail("report length", k_ra8_err_invalid_size);
    return k_ra8_err_invalid_size;
  }
  const size_t body = (size_t)((uint32_t)k_hid_report_len - (uint32_t)k_hid_body_idx);
  if (memcmp(&s_rx[k_hid_body_idx], &s_expect[k_hid_body_idx], body) != 0) {
    s_dbg_mismatch = round;
    (void)hid_print_fail("report pattern mismatch", k_ra8_err_invalid_state);
    return k_ra8_err_invalid_state;
  }
  s_dbg_last_seq = (uint32_t)s_rx[k_hid_seq_idx];
  /* Decode the boot-keyboard keycodes (bytes 2..) back to ASCII for the verdict.
   * The report is constant, so doing it each round is idempotent. */
  for (uint32_t i = 0U; i < (uint32_t)k_hid_nkeys; i++) {
    s_typed[i] = hid_keycode_to_ascii(s_rx[(uint32_t)k_hid_key0_idx + i]);
  }
  s_typed[(uint32_t)k_hid_nkeys] = '\0';
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t hid_host_pass(void)
{
  s_dbg_phase   = (uint32_t)k_hid_phase_init;
  ra8_err_t err = hid_print("ra8d2 hid: 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)hid_print_fail("host init", err);
    return err;
  }
 
  s_dbg_phase  = (uint32_t)k_hid_phase_enum;
  uint32_t pid = 0U;
  err          = hid_enumerate(&pid);
  if (err != k_ra8_ok) {
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
  s_dbg_pid = pid;
  err       = hid_print_enum(pid);
  if (err != k_ra8_ok) {
    return err;
  }
 
  s_dbg_phase     = (uint32_t)k_hid_phase_verify;
  s_dbg_rounds_ok = 0U;
  for (uint32_t r = 0U; r < (uint32_t)k_hid_rounds; r++) {
    err = hid_read_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_hid_phase_pass;
  s_dbg_pass_count++;
  err = hid_print_pass();
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}

static VOID hid_host_worker(ULONG arg)
{
  (void)arg;
 
  tx_thread_sleep(k_hid_boot_wait_ticks);
  for (;;) {
    const ra8_err_t err = hid_host_pass();
    if (err == k_ra8_ok) {
      break;
    }
    tx_thread_sleep(k_hid_retry_ticks);
  }
  while (1) {
    tx_thread_sleep(k_hid_idle_ticks);
  }
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_semaphore_name[]   = "hid_active";
  static CHAR s_host_thread_name[] = "hid_host";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_semaphore_create(&s_usb_host_keyboard_hid_active_sem, s_semaphore_name, 0U);
  usb_host_keyboard_device_thread_create();
  (void)tx_thread_create(&s_host_thread,
                         s_host_thread_name,
                         hid_host_worker,
                         0UL,
                         s_host_stack,
                         k_hid_host_stack,
                         (UINT)k_hid_host_priority,
                         (UINT)k_hid_host_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

static void hid_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void hid_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_hid_pin_fs_vbus, k_ra8_psel_usb_fs, "hid.fs_vbus") != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_gpio_output_init(k_hid_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_hid_pin_fs_dp, k_ra8_psel_usb_fs, "hid.fs_dp") != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_hid_pin_fs_dm, k_ra8_psel_usb_fs, "hid.fs_dm") != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_board_io_expander_set_usbhs_host_mode() != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_gpio_output_init(k_hid_pin_hs_pwr, k_ra8_level_high) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_hid_pin_hs_vbus, k_ra8_psel_usb_hs, "hid.hs_vbus") != k_ra8_ok) {
    hid_panic_halt();
  }
}

static void hid_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_cgc_usbhs_pll_enable() != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_hid_baud) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    hid_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    hid_panic_halt();
  }
  hid_route_usb_or_halt();
}

void main(void)
{
  hid_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  hid_panic_halt();
}