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_dfu.h"
#include "ra8_dfu_device.h"
#include "ra8_dfu_host.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_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;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_dfu_thread_stack    = 4096U,   
  k_dfu_host_stack      = 8192U,   
  k_dfu_usbx_pool_bytes = 32768U,  
  k_dfu_idle_ticks      = 50U,     
  k_dfu_boot_wait_ticks = 500U,    
  k_dfu_retry_ticks     = 3000U,   
  k_dfu_baud            = 115200U, 
  k_dfu_print_cap       = 160U,    
  k_dfu_dev_priority    = 8U,      
  k_dfu_host_priority   = 24U,     
  k_dfu_commit_tries    = 200U,    
} dfu_config_t;

typedef enum : uint8_t {
  k_dfu_hex_chars_u32   = 8U,  
  k_dfu_nibble_bits     = 4U,  
  k_dfu_hex_digit_split = 10U, 
} dfu_hex_t;

typedef enum : uint32_t {
  k_dfu_nibble_mask = 0xFU, 
} dfu_mask_t;

typedef enum : uint32_t {
  k_dfu_phase_boot     = 0U, 
  k_dfu_phase_init     = 1U, 
  k_dfu_phase_enum     = 2U, 
  k_dfu_phase_download = 3U, 
  k_dfu_phase_upload   = 4U, 
  k_dfu_phase_pass     = 5U, 
} dfu_phase_t;
 
#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 const UCHAR s_boot_payload[64] = {
  0x00U, 0x00U, 0x07U, 0x22U, 0x11U, 0x00U, 0x02U, 0x02U, 0xAFU, 0xF3U, 0x00U, 0x80U, 0xAFU,
  0xF3U, 0x00U, 0x80U, 0x46U, 0xF2U, 0x0DU, 0x00U, 0xC6U, 0xF2U, 0x0DU, 0x00U, 0x40U, 0xF2U,
  0x00U, 0x01U, 0xC2U, 0xF2U, 0x04U, 0x21U, 0x08U, 0x60U, 0xFEU, 0xE7U, 0xFFU, 0xFFU, 0xFFU,
  0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
  0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
};
 
/* -------------------------------------------------------------------------- */
/* J-Link probes */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_phase;
static volatile uint32_t s_dbg_pid;
static volatile uint32_t s_dbg_pass_count;
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_device_worker(ULONG arg)
{
  (void)arg;
 
  /* Config A device half: the FS controller runs the DFU device class wired
   * to real MRAM (libs/ra8_dfu). DFU_DNLOAD programs the inactive Slot B. */
  ra8_dfu_device_set_target(k_ra8_dfu_slot_a);
  const ra8_err_t e = ra8_dfu_device_start(k_ra8_usb_speed_fs,
                                           s_usbx_pool,
                                           (uint32_t)sizeof(s_usbx_pool),
                                           s_device_framework,
                                           (uint32_t)sizeof(s_device_framework),
                                           s_string_framework,
                                           (uint32_t)sizeof(s_string_framework),
                                           s_language_id_framework,
                                           (uint32_t)sizeof(s_language_id_framework));
  if (e != k_ra8_ok) {
    s_dbg_host_err = (uint32_t)e;
    return;
  }
  s_dbg_dev_step = 4U;
  /* Each DFU_DNLOAD block is programmed synchronously inside the DFU write
   * callback; this worker only finalizes the image header once the host
   * signals end-of-download (the self-test uses DFU_ABORT, so that path is
   * the bootloader's, not this twin's). */
  while (1) {
    (void)ra8_dfu_device_worker_step();
    tx_thread_sleep(k_dfu_idle_ticks);
  }
}
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

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

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

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

[[nodiscard]] static ra8_err_t dfu_print(const char* text)
{
  return dfu_sci_write((const uint8_t*)text, dfu_str_len(text));
}

[[nodiscard]] static ra8_err_t dfu_print_hex(uint32_t value, uint8_t digits)
{
  uint8_t out[k_dfu_hex_chars_u32] = {};
  uint8_t width                    = digits;
  if (width > (uint8_t)k_dfu_hex_chars_u32) {
    width = (uint8_t)k_dfu_hex_chars_u32;
  }
  for (uint8_t i = 0U; i < width; i++) {
    const uint8_t shift = (uint8_t)((width - 1U - i) * k_dfu_nibble_bits);
    out[i]              = dfu_nibble_to_hex((value >> shift) & k_dfu_nibble_mask);
  }
  return dfu_sci_write(out, (uint32_t)width);
}

[[nodiscard]] static ra8_err_t dfu_print_fail(const char* what, ra8_err_t err)
{
  ra8_err_t e = dfu_print("ra8d2 dfu: FAIL ");
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print(what);
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print(" err=0x");
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print_hex((uint32_t)err, (uint8_t)k_dfu_hex_chars_u32);
  if (e != k_ra8_ok) {
    return e;
  }
  return dfu_print("\r\n");
}
 
/* -------------------------------------------------------------------------- */
/* Host side: enumerate, then DFU download + upload-verify */
/* -------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_dfu_bm_std_dev_in     = 0x80U, 
  k_dfu_bm_std_dev_out    = 0x00U, 
  k_dfu_bm_class_if_out   = 0x21U, 
  k_dfu_bm_class_if_in    = 0xA1U, 
  k_dfu_breq_get_desc     = 0x06U, 
  k_dfu_breq_set_addr     = 0x05U, 
  k_dfu_breq_set_config   = 0x09U, 
  k_dfu_breq_dnload       = 0x01U, 
  k_dfu_breq_upload       = 0x02U, 
  k_dfu_breq_getstatus    = 0x03U, 
  k_dfu_breq_abort        = 0x06U, 
  k_dfu_desc_device       = 0x01U, 
  k_dfu_dev_desc_len      = 18U,   
  k_dfu_off_dev_pid       = 10U,   
  k_dfu_byte_bits         = 8U,    
  k_dfu_getstatus_len     = 6U,    
  k_dfu_off_status_state  = 4U,    
  k_dfu_state_dnload_idle = 5U,    
  k_dfu_state_idle        = 2U,    
} dfu_req_t;

typedef enum : uint32_t {
  k_dfu_vbus_settle_ms = 200U,      
  k_dfu_attach_to_ms   = 2000U,     
  k_dfu_debounce_ms    = 500U,      
  k_dfu_reset_hold_ms  = 50U,       
  k_dfu_recovery_ms    = 20U,       
  k_dfu_addr_settle_ms = 5U,        
  k_dfu_status_poll_ms = 2U,        
  k_dfu_status_tries   = 50U,       
  k_dfu_enum_tries     = 8U,        
  k_dfu_attach_spin    = 50000000U, 
} dfu_enum_tune_t;

[[nodiscard]] static ra8_err_t dfu_host_pass(void)
{
  s_dbg_phase = (uint32_t)k_dfu_phase_init;
  ra8_err_t err =
    dfu_print("ra8d2 dfu-boot: host up, DFU-flashing a bootable Slot-A payload...\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
 
  /* Real DFU flash flow: DFU_DNLOAD the bootable Slot-A image, then a
   * zero-length DFU_DNLOAD (manifest) so the DEVICE commits the slot header --
   * exactly what dfu-util drives, but over the self-loop so no external host is
   * needed. The device half runs on this same chip (Slot A target). */
  s_dbg_phase               = (uint32_t)k_dfu_phase_download;
  ra8_dfu_host_result_t res = {};
  err                       = ra8_dfu_host_program(k_ra8_usb_speed_hs,
                                                   s_boot_payload,
                                                   (uint32_t)sizeof(s_boot_payload),
                                                   &res);
  s_dbg_pid                 = res.pid;
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("dfu program", err);
    return err;
  }
 
  /* Wait for the device worker to commit the header, then confirm Slot A is
   * bootable (CRC over the just-programmed body matches) from this side. */
  bool committed = false;
  for (uint32_t i = 0U; i < (uint32_t)k_dfu_commit_tries; i++) {
    if (ra8_dfu_device_committed()) {
      committed = true;
      break;
    }
    tx_thread_sleep(k_dfu_idle_ticks);
  }
  if (!committed) {
    (void)dfu_print_fail("commit timeout", k_ra8_err_hw_timeout);
    return k_ra8_err_hw_timeout;
  }
  const ra8_err_t cerr = ra8_dfu_device_last_error();
  if (cerr != k_ra8_ok) {
    (void)dfu_print_fail("device commit", cerr);
    return cerr;
  }
  if (!ra8_dfu_slot_valid(k_ra8_dfu_slot_a)) {
    (void)dfu_print_fail("Slot A not bootable after commit", k_ra8_err_crc_mismatch);
    return k_ra8_err_crc_mismatch;
  }
 
  s_dbg_phase = (uint32_t)k_dfu_phase_pass;
  s_dbg_pass_count++;
  err = dfu_print(
    "ra8d2 dfu-boot: Slot A DFU-committed + bootable -- USB SELFTEST DFU-BOOT COMMIT PASS\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}

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();
}