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_selftest_dfu_steps.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_dfu.h"
#include "ux_device_stack.h"
 
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_dfu_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_dfu_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_dfu_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_dfu_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_dfu_pin_hs_vbus = (ra8_port_pin_t)k_ra8_board_usbhs_pin_vbus;

static const ra8_port_pin_t k_dfu_pin_hs_pwr = (ra8_port_pin_t)k_ra8_board_usbhs_pin_pwr;
 
/* The J-Link OB CDC console (SCI8, PD_02 TXD / PD_03 RXD) bring-up -- pin
 * routing, baud, and SCI init -- is owned by ra8_board_uart_console_init(). */
 
/* Compile-time tunables, image geometry, text-formatter sizing, the host
 * progress-phase markers, and the Chapter-9 + DFU request constants all live in
 * "usb_selftest_dfu_steps.h" (shared with the host-ladder sibling). */
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX workers + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;
static UCHAR s_device_stack[k_dfu_thread_stack];
static TX_THREAD s_host_thread;
static UCHAR s_host_stack[k_dfu_host_stack];
static UCHAR s_usbx_pool[k_dfu_usbx_pool_bytes];

static UCHAR s_dfu_image[k_dfu_image_bytes];

static volatile uint32_t s_dfu_image_len;
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (device side) */
/* -------------------------------------------------------------------------- */
 
/* The host-ladder probes (s_dbg_phase / s_dbg_pid / s_dbg_blocks_ok /
 * s_dbg_mismatch / s_dbg_pass_count) live in the host-ladder sibling, the only
 * translation unit that reads or writes them. */

static volatile uint32_t s_dbg_dev_writes;
static volatile uint32_t s_dbg_dev_step;
static volatile uint32_t s_dbg_host_err;
 
/* -------------------------------------------------------------------------- */
/* USB descriptors (DFU mode: single DFU interface, EP0 only) */
/* -------------------------------------------------------------------------- */
 
/* DFU-mode framework: device (PID 0x0019) + one config with a single DFU
 * interface (class 0xFE / subclass 0x01 / protocol 0x02 = DFU mode, so USBX
 * enumerates straight into dfuIDLE) + the DFU functional descriptor
 * (CAN_DNLOAD | CAN_UPLOAD | MANIFESTATION_TOLERANT, wTransferSize 64). No data
 * endpoints -- DFU runs over EP0. Layout per DFU 1.1 + USB 2.0 sec 9.6. */
static UCHAR s_device_framework[] = {
  /* Device descriptor (18 bytes). idVendor 0x1209, idProduct 0x0019. */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0x00U,
  0x00U,
  0x00U,
  0x40U,
  0x09U,
  0x12U,
  0x19U,
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (wTotalLength 0x1B = 27). */
  0x09U,
  0x02U,
  0x1BU,
  0x00U,
  0x01U,
  0x01U,
  0x00U,
  0x80U,
  0x32U,
  /* DFU interface (class 0xFE, subclass 0x01, protocol 0x02 = DFU mode). */
  0x09U,
  0x04U,
  0x00U,
  0x00U,
  0x00U,
  0xFEU,
  0x01U,
  0x02U,
  0x00U,
  /* DFU functional descriptor. bmAttributes 0x07, wTransferSize 64,
     bcdDFUVersion 0x0110. */
  0x09U,
  0x21U,
  0x07U,
  0xFFU,
  0x00U,
  0x40U,
  0x00U,
  0x10U,
  0x01U,
};

static UCHAR s_string_framework[] = {
  /* idx 1: "Brighton Sikarskie". */
  0x09U,
  0x04U,
  0x01U,
  0x12U,
  'B',
  'r',
  'i',
  'g',
  'h',
  't',
  'o',
  'n',
  ' ',
  'S',
  'i',
  'k',
  'a',
  'r',
  's',
  'k',
  'i',
  'e',
  /* idx 2: "RA8D2 DFU". */
  0x09U,
  0x04U,
  0x02U,
  0x09U,
  'R',
  'A',
  '8',
  'D',
  '2',
  ' ',
  'D',
  'F',
  'U',
  /* idx 3: serial "00000019". */
  0x09U,
  0x04U,
  0x03U,
  0x08U,
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '1',
  '9',
};
 
/* 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};
 
/* -------------------------------------------------------------------------- */
/* Device side: USBX DFU class callbacks */
/* -------------------------------------------------------------------------- */

static VOID dfu_activate(VOID* dfu)
{
  (void)dfu;
}

static VOID dfu_deactivate(VOID* dfu)
{
  (void)dfu;
}

static UINT
dfu_write(VOID* dfu, ULONG block_number, const UCHAR* data, ULONG length, ULONG* media_status)
{
  (void)dfu;
  const ULONG off = block_number * (ULONG)k_dfu_xfer_size;
  if ((length > 0UL) && (off + length <= (ULONG)sizeof(s_dfu_image))) {
    (void)memcpy(&s_dfu_image[off], data, (size_t)length);
    if ((uint32_t)(off + length) > s_dfu_image_len) {
      s_dfu_image_len = (uint32_t)(off + length);
    }
    s_dbg_dev_writes++;
  }
  *media_status = (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_OK;
  return UX_SUCCESS;
}

static UINT dfu_read(VOID* dfu, ULONG block_number, UCHAR* data, ULONG length, ULONG* actual_length)
{
  (void)dfu;
  const ULONG off = block_number * (ULONG)k_dfu_xfer_size;
  if (off >= (ULONG)s_dfu_image_len) {
    *actual_length = 0UL;
    return UX_SUCCESS;
  }
  ULONG remain = (ULONG)s_dfu_image_len - off;
  if (remain > length) {
    remain = length;
  }
  (void)memcpy(data, &s_dfu_image[off], (size_t)remain);
  *actual_length = remain;
  return UX_SUCCESS;
}

static UINT dfu_get_status(VOID* dfu, ULONG* media_status)
{
  (void)dfu;
  *media_status = (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_OK;
  return UX_SUCCESS;
}

static UINT dfu_notify(VOID* dfu, ULONG notification)
{
  (void)dfu;
  (void)notification;
  return UX_SUCCESS;
}

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

typedef UINT (
  *dfu_write_cb_t)(VOID* dfu, ULONG block_number, UCHAR* data, ULONG length, ULONG* media_status);

static UINT dfu_class_register(void)
{
  UX_SLAVE_CLASS_DFU_PARAMETER dfu_params = {
    .ux_slave_class_dfu_parameter_will_detach = 0UL,
    .ux_slave_class_dfu_parameter_capabilities =
      (ULONG)(UX_SLAVE_CLASS_DFU_CAPABILITY_CAN_DOWNLOAD |
              UX_SLAVE_CLASS_DFU_CAPABILITY_CAN_UPLOAD),
    .ux_slave_class_dfu_parameter_instance_activate   = dfu_activate,
    .ux_slave_class_dfu_parameter_instance_deactivate = dfu_deactivate,
    .ux_slave_class_dfu_parameter_read                = dfu_read,
    .ux_slave_class_dfu_parameter_write               = (dfu_write_cb_t)dfu_write,
    .ux_slave_class_dfu_parameter_get_status          = dfu_get_status,
    .ux_slave_class_dfu_parameter_notify              = dfu_notify,
    .ux_slave_class_dfu_parameter_framework           = s_device_framework,
    .ux_slave_class_dfu_parameter_framework_length    = (ULONG)sizeof(s_device_framework),
  };
  static UCHAR s_class_name[] = "ux_slave_class_dfu";
 
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_dfu_entry,
                                         1,
                                         0,
                                         &dfu_params);
}

static VOID dfu_device_worker(ULONG arg)
{
  (void)arg;
 
  UINT ux = dfu_usbx_stack_up();
  if (ux != UX_SUCCESS) {
    s_dbg_host_err = (uint32_t)ux;
    return;
  }
  s_dbg_dev_step = 1U;
  ux             = dfu_class_register();
  if (ux != UX_SUCCESS) {
    s_dbg_host_err = (uint32_t)ux;
    return;
  }
  s_dbg_dev_step = 2U;
  ra8_err_t e    = ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs);
  if (e != k_ra8_ok) {
    s_dbg_host_err = (uint32_t)e;
    return;
  }
  s_dbg_dev_step = 3U;
  e              = ra8_usb_device_attach(k_ra8_usb_speed_fs, true);
  if (e != k_ra8_ok) {
    s_dbg_host_err = (uint32_t)e;
    return;
  }
  s_dbg_dev_step = 4U;
  while (1) {
    tx_thread_sleep(k_dfu_idle_ticks);
  }
}

static VOID dfu_host_worker(ULONG arg)
{
  (void)arg;
 
  tx_thread_sleep(k_dfu_boot_wait_ticks);
  for (;;) {
    const ra8_err_t err = dfu_host_pass();
    if (err == k_ra8_ok) {
      break;
    }
    s_dbg_host_err = (uint32_t)err;
    tx_thread_sleep(k_dfu_retry_ticks);
  }
  while (1) {
    tx_thread_sleep(k_dfu_idle_ticks);
  }
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_device_thread_name[] = "dfu_device";
  static CHAR s_host_thread_name[]   = "dfu_host";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         dfu_device_worker,
                         0UL,
                         s_device_stack,
                         k_dfu_thread_stack,
                         (UINT)k_dfu_dev_priority,
                         (UINT)k_dfu_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  (void)tx_thread_create(&s_host_thread,
                         s_host_thread_name,
                         dfu_host_worker,
                         0UL,
                         s_host_stack,
                         k_dfu_host_stack,
                         (UINT)k_dfu_host_priority,
                         (UINT)k_dfu_host_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

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

static void dfu_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_dfu_pin_fs_vbus, k_ra8_psel_usb_fs, "dfu.fs_vbus") != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_gpio_output_init(k_dfu_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_dfu_pin_fs_dp, k_ra8_psel_usb_fs, "dfu.fs_dp") != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_dfu_pin_fs_dm, k_ra8_psel_usb_fs, "dfu.fs_dm") != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_board_io_expander_set_usbhs_host_mode() != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_gpio_output_init(k_dfu_pin_hs_pwr, k_ra8_level_high) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_dfu_pin_hs_vbus, k_ra8_psel_usb_hs, "dfu.hs_vbus") != k_ra8_ok) {
    dfu_panic_halt();
  }
}

static void dfu_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_cgc_usbhs_pll_enable() != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_dfu_baud) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    dfu_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    dfu_panic_halt();
  }
  dfu_route_usb_or_halt();
}

void main(void)
{
  dfu_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  dfu_panic_halt();
}