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"
 
#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"
 
/* SysTick handler lives in libs/ra8_core/src/ra8_time.c -- the project's
 * shared weak SysTick_Handler dispatches into ThreadX (via a weak
 * extern to `_tx_timer_interrupt`) AND re-arms the USB storm-guard
 * NVIC line (via a weak extern to `ux_dcd_ra8_usb_irq_reenable`), so
 * no per-app override is needed. Closes Issue #8. */
#endif
 
/* -------------------------------------------------------------------------- */
/* Pinout (FSP-aligned, EK-RA8D2 v1 User's Manual) */
/* -------------------------------------------------------------------------- */

static const ra8_port_pin_t k_demo_pin_vbus   = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;
static const ra8_port_pin_t k_demo_pin_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;
static const ra8_port_pin_t k_demo_pin_dp     = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;
static const ra8_port_pin_t k_demo_pin_dm     = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_demo_thread_stack        = 4096U,  
  k_demo_usbx_pool_bytes     = 32768U, 
  k_demo_jiggle_period_ticks = 100U,   
} demo_config_t;

typedef enum : uint8_t {
  k_demo_hid_report_bytes = 3U, 
  k_demo_hid_idx_buttons  = 0U, 
  k_demo_hid_idx_dx       = 1U, 
  k_demo_hid_idx_dy       = 2U, 
} demo_hid_report_t;

typedef enum : int8_t {
  k_demo_jiggle_step = 4,  
  k_demo_jiggle_zero = 0,  
  k_demo_jiggle_neg  = -4, 
} demo_jiggle_t;

typedef enum : uint8_t {
  k_demo_phase_right = 0U, 
  k_demo_phase_down  = 1U, 
  k_demo_phase_left  = 2U, 
  k_demo_phase_up    = 3U, 
  k_demo_phase_count = 4U, 
} demo_phase_t;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_demo_thread;

static UCHAR s_demo_stack[k_demo_thread_stack];

static UCHAR s_usbx_pool[k_demo_usbx_pool_bytes];

static UX_SLAVE_CLASS_HID* s_hid_class = UX_NULL;

volatile uint32_t g_usb_hid_match = 0U;

volatile uint32_t g_usb_hid_mismatch = 0U;
 
/* -------------------------------------------------------------------------- */
/* HID Report Descriptor (3-button + X/Y boot mouse) */
/* -------------------------------------------------------------------------- */

static UCHAR s_report_descriptor[] = {
  0x05U, 0x01U, /* Usage Page (Generic Desktop) */
  0x09U, 0x02U, /* Usage (Mouse)                */
  0xA1U, 0x01U, /* Collection (Application)     */
  0x09U, 0x01U, /* Usage (Pointer)              */
  0xA1U, 0x00U, /* Collection (Physical)        */
  0x05U, 0x09U, /* Usage Page (Buttons)         */
  0x19U, 0x01U, /* Usage Min (1)                */
  0x29U, 0x03U, /* Usage Max (3)                */
  0x15U, 0x00U, /* Logical Min (0)              */
  0x25U, 0x01U, /* Logical Max (1)              */
  0x95U, 0x03U, /* Report Count (3)             */
  0x75U, 0x01U, /* Report Size  (1)             */
  0x81U, 0x02U, /* Input (Data,Var,Abs)         */
  0x95U, 0x01U, /* Report Count (1)             */
  0x75U, 0x05U, /* Report Size  (5)             */
  0x81U, 0x03U, /* Input (Cnst,Var,Abs) padding */
  0x05U, 0x01U, /* Usage Page (Generic Desktop) */
  0x09U, 0x30U, /* Usage (X)                    */
  0x09U, 0x31U, /* Usage (Y)                    */
  0x15U, 0x81U, /* Logical Min (-127)           */
  0x25U, 0x7FU, /* Logical Max ( 127)           */
  0x75U, 0x08U, /* Report Size  (8)             */
  0x95U, 0x02U, /* Report Count (2)             */
  0x81U, 0x06U, /* Input (Data,Var,Rel)         */
  0xC0U,        /* End Collection (Physical)    */
  0xC0U,        /* End Collection (Application) */
};
 
/* -------------------------------------------------------------------------- */
/* USB descriptors (DEVICE + CONFIG + INTERFACE + HID + EP IN) */
/* -------------------------------------------------------------------------- */
 
/* VID/PID matches the prior bare-metal app (pid.codes test range). The
 * configuration is one HID interface, one interrupt-IN endpoint, no
 * OUT endpoint -- the boot mouse class profile.
 *
 * Total config-blob length:
 *   9 (config) + 9 (interface) + 9 (HID class) + 7 (EP IN) = 34 bytes.
 *
 * Layout per USB 2.0 sec 9.6 and HID 1.11 sec 6.2.1.
 */
static UCHAR s_device_framework_fs[] = {
  /* Device descriptor (USB 2.0 sec 9.6.1) -- 18 bytes. */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0x00U,
  0x00U,
  0x00U,
  0x40U,
  0x09U,
  0x12U,
  0x01U,
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (USB 2.0 sec 9.6.3) -- 9 bytes.
   * bmAttributes = 0x80 (bus-powered). 0xC0 (self-powered)
   * conflicted with bMaxPower=100mA (50 * 2). */
  0x09U,
  0x02U,
  0x22U,
  0x00U,
  0x01U,
  0x01U,
  0x00U,
  0x80U,
  0x32U,
  /* Interface descriptor -- HID, boot subclass, mouse protocol. */
  0x09U,
  0x04U,
  0x00U,
  0x00U,
  0x01U,
  0x03U,
  0x01U,
  0x02U,
  0x00U,
  /* HID class descriptor (HID 1.11 sec 6.2.1) -- 9 bytes.
   * Report-descriptor length is sizeof(s_report_descriptor) = 52,
   * little-endian (0x34, 0x00). */
  0x09U,
  0x21U,
  0x11U,
  0x01U,
  0x00U,
  0x01U,
  0x22U,
  0x34U,
  0x00U,
  /* Endpoint descriptor: EP1 IN, interrupt, 8-byte MPS, 10 ms poll. */
  0x07U,
  0x05U,
  0x81U,
  0x03U,
  0x08U,
  0x00U,
  0x0AU,
};
 
/* String descriptors -- vendor / product / serial. Each entry:
 *   2 bytes lang-id, 1 byte string index, 1 byte string length,
 *   then ASCII bytes. */
static UCHAR s_string_framework[] = {
  /* idx 1: "Brighton Sikarskie" (18 chars). */
  0x09U,
  0x04U,
  0x01U,
  0x12U,
  'B',
  'r',
  'i',
  'g',
  'h',
  't',
  'o',
  'n',
  ' ',
  'S',
  'i',
  'k',
  'a',
  'r',
  's',
  'k',
  'i',
  'e',
  /* idx 2: "EK-RA8D2 HID Mouse" (18 chars). */
  0x09U,
  0x04U,
  0x02U,
  0x12U,
  'E',
  'K',
  '-',
  'R',
  'A',
  '8',
  'D',
  '2',
  ' ',
  'H',
  'I',
  'D',
  ' ',
  'M',
  'o',
  'u',
  's',
  'e',
  /* idx 3: "00000001" (8 chars). */
  0x09U,
  0x04U,
  0x03U,
  0x08U,
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '1',
};
 
/* USBX LANGID descriptor 0x0409 (English-US), little-endian byte pair. */
typedef enum : uint8_t {
  k_usb_langid_en_us_lo = 0x09U, 
  k_usb_langid_en_us_hi = 0x04U, 
} usb_langid_byte_t;
 
static UCHAR s_language_id_framework[] = {k_usb_langid_en_us_lo, k_usb_langid_en_us_hi};
 
/* -------------------------------------------------------------------------- */
/* HID activate / deactivate callbacks */
/* -------------------------------------------------------------------------- */

static VOID demo_hid_activate(VOID* hid_instance)
{
  s_hid_class = (UX_SLAVE_CLASS_HID*)hid_instance;
}

static VOID demo_hid_deactivate(VOID* hid_instance)
{
  (void)hid_instance;
  s_hid_class = UX_NULL;
}

static UINT demo_hid_get_callback(UX_SLAVE_CLASS_HID* hid, UX_SLAVE_CLASS_HID_EVENT* hid_event)
{
  (void)hid;
  hid_event->ux_device_class_hid_event_length      = (ULONG)k_demo_hid_report_bytes;
  hid_event->ux_device_class_hid_event_report_id   = 0UL;
  hid_event->ux_device_class_hid_event_report_type = (ULONG)UX_DEVICE_CLASS_HID_REPORT_TYPE_INPUT;
  hid_event->ux_device_class_hid_event_buffer[k_demo_hid_idx_buttons] = 0U;
  hid_event->ux_device_class_hid_event_buffer[k_demo_hid_idx_dx]      = 0U;
  hid_event->ux_device_class_hid_event_buffer[k_demo_hid_idx_dy]      = 0U;
  return UX_SUCCESS;
}
 
/* -------------------------------------------------------------------------- */
/* Worker thread: bring USBX up + jiggle loop */
/* -------------------------------------------------------------------------- */

static void demo_build_jiggle(demo_phase_t phase, UCHAR* report)
{
  int8_t dx = k_demo_jiggle_zero;
  int8_t dy = k_demo_jiggle_zero;
  switch (phase) {
    case k_demo_phase_right:
      dx = k_demo_jiggle_step;
      break;
    case k_demo_phase_down:
      dy = k_demo_jiggle_step;
      break;
    case k_demo_phase_left:
      dx = k_demo_jiggle_neg;
      break;
    case k_demo_phase_up:
      dy = k_demo_jiggle_neg;
      break;
    case k_demo_phase_count:
    default:
      break;
  }
  report[k_demo_hid_idx_buttons] = 0U;
  report[k_demo_hid_idx_dx]      = (UCHAR)dx;
  report[k_demo_hid_idx_dy]      = (UCHAR)dy;
}

static UINT demo_usbx_stack_up(void)
{
  if (_ux_system_initialize(s_usbx_pool, k_demo_usbx_pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return UX_ERROR;
  }
  return _ux_device_stack_initialize((UCHAR*)UX_NULL,
                                     0,
                                     s_device_framework_fs,
                                     sizeof(s_device_framework_fs),
                                     s_string_framework,
                                     sizeof(s_string_framework),
                                     s_language_id_framework,
                                     sizeof(s_language_id_framework),
                                     UX_NULL);
}

static UINT demo_hid_class_register(void)
{
  UX_SLAVE_CLASS_HID_PARAMETER hid_params = {
    .ux_slave_class_hid_instance_activate         = demo_hid_activate,
    .ux_slave_class_hid_instance_deactivate       = demo_hid_deactivate,
    .ux_device_class_hid_parameter_report_address = s_report_descriptor,
    .ux_device_class_hid_parameter_report_id      = 0UL,
    .ux_device_class_hid_parameter_report_length  = (ULONG)sizeof(s_report_descriptor),
    .ux_device_class_hid_parameter_callback       = UX_NULL,
    .ux_device_class_hid_parameter_get_callback   = demo_hid_get_callback,
  };
  static UCHAR s_class_name[] = "ux_slave_class_hid";
 
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_hid_entry,
                                         1,
                                         0,
                                         &hid_params);
}

static void demo_jiggle_send(demo_phase_t* phase)
{
  UX_SLAVE_CLASS_HID_EVENT hid_event;
  (void)memset(&hid_event, 0, sizeof(hid_event));
  hid_event.ux_device_class_hid_event_length      = (ULONG)k_demo_hid_report_bytes;
  hid_event.ux_device_class_hid_event_report_id   = 0UL;
  hid_event.ux_device_class_hid_event_report_type = (ULONG)UX_DEVICE_CLASS_HID_REPORT_TYPE_INPUT;
  demo_build_jiggle(*phase, hid_event.ux_device_class_hid_event_buffer);
 
  if (_ux_device_class_hid_event_set(s_hid_class, &hid_event) == UX_SUCCESS) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    *phase = (demo_phase_t)(((uint8_t)(*phase + 1U)) % k_demo_phase_count);
    g_usb_hid_match += 1U;
  } else {
    g_usb_hid_mismatch += 1U;
  }
}
 
static VOID demo_worker(ULONG arg)
{
  (void)arg;
 
  if (demo_usbx_stack_up() != UX_SUCCESS) {
    return;
  }
  if (demo_hid_class_register() != UX_SUCCESS) {
    return;
  }
  if (ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs) != k_ra8_ok) {
    return;
  }
  if (ra8_usb_device_attach(k_ra8_usb_speed_fs, true) != k_ra8_ok) {
    return;
  }
 
  /* Jiggle loop. INTSTS0 is drained by the bridge's own polled-dispatch
   * worker (spawned inside ux_dcd_ra8_usb_initialize BEFORE the
   * ra8_usb_device_attach(true) above raised DPRPU), so this thread
   * only needs to push HID reports once per period. */
  demo_phase_t phase = k_demo_phase_right;
  while (1) {
    if (s_hid_class == UX_NULL) {
      tx_thread_sleep(k_demo_jiggle_period_ticks);
      continue;
    }
    demo_jiggle_send(&phase);
    tx_thread_sleep(k_demo_jiggle_period_ticks);
  }
}
 
/* -------------------------------------------------------------------------- */
/* ThreadX kernel entry: spawn the worker */
/* -------------------------------------------------------------------------- */

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_thread_name[] = "usb_hid_device";
 
  (void)first_unused_memory;
  (void)tx_thread_create(&s_demo_thread,
                         s_thread_name,
                         demo_worker,
                         0UL,
                         s_demo_stack,
                         k_demo_thread_stack,
                         8U, /* priority          */
                         8U, /* preempt threshold */
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup helpers */
/* -------------------------------------------------------------------------- */

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

[[nodiscard]] static ra8_err_t demo_pins_init(void)
{
  ra8_err_t err = ra8_pfs_route_peripheral(k_demo_pin_vbus, k_ra8_psel_usb_fs, "usb_hid.vbus");
  if (err != k_ra8_ok) {
    return err;
  }
  /* VBUSEN as GPIO output LOW for USB device mode. Peripheral routing
   * forces VBUSEN HIGH (host mode) which blocks device enumeration. */
  err = ra8_gpio_output_init(k_demo_pin_vbusen, k_ra8_level_low);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(k_demo_pin_dp, k_ra8_psel_usb_fs, "usb_hid.dp");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_pfs_route_peripheral(k_demo_pin_dm, k_ra8_psel_usb_fs, "usb_hid.dm");
}

void main(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  /* Bring up PLL2 -> USBCKCR / USBCKDIVCR so USBFS sees a spec-compliant
   * 48 MHz reference (PLL2P 240 MHz / 5). Without this the SIE never
   * leaves Powered after host bus-reset. */
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (demo_pins_init() != k_ra8_ok) {
    demo_panic_halt();
  }
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  /* tx_kernel_enter is __noreturn -- it never comes back. */
  tx_kernel_enter();
#endif
 
  demo_panic_halt();
}