main.c

Go to the documentation of this file.

 
#include <stdint.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_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci.h"
#include "ra8_time.h"
#include "ra8_usb.h"
#ifdef RA8_ENABLE_ROOT_OF_TRUST
#include "mbedtls/memory_buffer_alloc.h"
#include "ra8_psa_crypto.h"
#endif
 
#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_blc_pin_fs_vbus = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbus;

static const ra8_port_pin_t k_blc_pin_fs_vbusen = (ra8_port_pin_t)k_ra8_board_usbfs_pin_vbusen;

static const ra8_port_pin_t k_blc_pin_fs_dp = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dp;

static const ra8_port_pin_t k_blc_pin_fs_dm = (ra8_port_pin_t)k_ra8_board_usbfs_pin_dm;

static const ra8_port_pin_t k_blc_pin_sci_tx = (ra8_port_pin_t)k_ra8_board_uart_console_pin_txd;

static const ra8_port_pin_t k_blc_pin_sci_rx = (ra8_port_pin_t)k_ra8_board_uart_console_pin_rxd;
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_blc_thread_stack    = 4096U,   
  k_blc_usbx_pool_bytes = 32768U,  
  k_blc_idle_ticks      = 50U,     
  k_blc_baud            = 115200U, 
  k_blc_sci_channel     = 8U,      
  k_blc_print_cap       = 160U,    
  k_blc_dev_priority    = 8U,      
} blc_config_t;

typedef enum : uint8_t {
  k_blc_hex_chars_u32   = 8U,  
  k_blc_nibble_bits     = 4U,  
  k_blc_hex_digit_split = 10U, 
} blc_hex_t;

typedef enum : uint32_t {
  k_blc_nibble_mask = 0xFU, 
} blc_mask_t;

typedef enum : uintptr_t {
  k_blc_scb_aircr_addr = 0xE000ED0CU, 
} blc_scb_t;

typedef enum : uint32_t {
  k_blc_aircr_sysreset = 0x05FA0004U, 
} blc_reset_t;

[[gnu::section(".noinit")]] static volatile uint32_t g_dfu_trigger;
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* ThreadX worker + USBX pool storage */
/* -------------------------------------------------------------------------- */

static TX_THREAD s_device_thread;
static UCHAR s_device_stack[k_blc_thread_stack];
static UCHAR s_usbx_pool[k_blc_usbx_pool_bytes];

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. */
  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',
};

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};
 
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* J-Link probes */
/* -------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_blc_dbg_unset = 0xFFFFFFFFU, 
} blc_dbg_t;

static volatile uint32_t s_dbg_action = k_blc_dbg_unset;
static volatile uint32_t s_dbg_target = k_blc_dbg_unset;
static volatile uint32_t s_dbg_dev_step;
static volatile uint32_t s_dbg_dev_err;

volatile uint32_t g_blc_dfu_tick = 0U;
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

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

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

[[nodiscard]] static ra8_err_t blc_print(const char* text)
{
  return ra8_sci_write_polling((uint8_t)k_blc_sci_channel, (const uint8_t*)text, blc_str_len(text));
}

[[nodiscard]] static ra8_err_t blc_print_hex(uint32_t value)
{
  uint8_t out[k_blc_hex_chars_u32] = {};
  for (uint8_t i = 0U; i < (uint8_t)k_blc_hex_chars_u32; i++) {
    const uint8_t shift = (uint8_t)(((uint8_t)k_blc_hex_chars_u32 - 1U - i) * k_blc_nibble_bits);
    out[i]              = blc_nibble_to_hex((value >> shift) & k_blc_nibble_mask);
  }
  return ra8_sci_write_polling((uint8_t)k_blc_sci_channel, out, (uint32_t)k_blc_hex_chars_u32);
}
 
/* -------------------------------------------------------------------------- */
/* Boot decision + slot hand-off */
/* -------------------------------------------------------------------------- */

static ra8_dfu_action_t blc_decide(ra8_dfu_slot_t* out_target)
{
  if (out_target == nullptr) {
    return k_ra8_dfu_action_dfu; /* safe fallback: never jump on a bad caller */
  }
  const bool trig = (g_dfu_trigger == (uint32_t)k_ra8_dfu_trigger_magic);
  g_dfu_trigger   = 0U; /* one-shot: consume the request */
 
  const bool a_valid = ra8_dfu_slot_valid(k_ra8_dfu_slot_a);
  const bool b_valid = ra8_dfu_slot_valid(k_ra8_dfu_slot_b);
  uint32_t   a_seq   = 0U;
  uint32_t   b_seq   = 0U;
  /* A failed read leaves seq at 0 (treated as oldest) -- a safe default that
   * never wins the higher-seq tiebreak, so the discarded return is intentional. */
  (void)ra8_dfu_slot_seq(k_ra8_dfu_slot_a, &a_seq);
  (void)ra8_dfu_slot_seq(k_ra8_dfu_slot_b, &b_seq);
 
  const ra8_dfu_slot_t active = ra8_dfu_select_slot(a_valid, a_seq, b_valid, b_seq);
  *out_target = (active == k_ra8_dfu_slot_none) ? k_ra8_dfu_slot_a : ra8_dfu_other_slot(active);
 
  return ra8_dfu_boot_decide(trig, a_valid, a_seq, b_valid, b_seq);
}

static void blc_boot_slot(ra8_dfu_slot_t slot)
{
  ra8_dfu_img_hdr_t hdr = {};
  if (ra8_dfu_read_header(slot, &hdr) != k_ra8_ok) {
    return; /* unreadable header -> let main fall through to DFU */
  }
  ra8_dfu_launch(ra8_dfu_slot_base(slot), hdr.img_len, hdr.entry);
  /* Returns only if ra8_dfu_run_target_valid rejected the image -> main -> DFU. */
}
 
#ifndef RA8_OFF_TARGET

[[noreturn]] static void blc_system_reset(void)
{
  __asm__ volatile("dsb 0xF" ::: "memory");
  /* HUM Ch 6.1 Table 6.1 p 244 "Software reset (AIRCR.SYSRESETREQ)"; the
   * Cortex-M85 AIRCR itself is defined in ARMv8-M ARM B3.2.6 at 0xE000ED0C. */
  *(volatile uint32_t*)(uintptr_t)k_blc_scb_aircr_addr = (uint32_t)k_blc_aircr_sysreset;
  __asm__ volatile("dsb 0xF" ::: "memory");
  /* NASA Rule 2 exemption: spin until the reset lands (a few cycles); the
   * function is [[noreturn]] and never iterates unboundedly in practice. */
  while (1) {
    __asm__ volatile("wfi");
  }
}

static VOID blc_device_worker(ULONG arg)
{
  (void)arg;
 
  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_dev_err = (uint32_t)e;
    (void)blc_print("dfu-bootloader: FAIL device bring-up\r\n");
    return;
  }
  s_dbg_dev_step = 4U;
  (void)blc_print("dfu-bootloader: DFU device up on USB-FS, awaiting DFU_DNLOAD...\r\n");
 
  /* NASA Rule 2 exemption: deliberate RTOS service loop. It exits only via
   * blc_system_reset() once an image commits (that call does not return). */
  while (1) {
    (void)ra8_dfu_device_worker_step();
    g_blc_dfu_tick += 1U; /* HIL liveness: proves the DFU service loop iterates */
    if (ra8_dfu_device_committed() && (ra8_dfu_device_last_error() == k_ra8_ok)) {
      (void)blc_print("dfu-bootloader: image committed -- resetting into new slot\r\n");
      blc_system_reset();
    }
    tx_thread_sleep((ULONG)k_blc_idle_ticks);
  }
}

VOID tx_application_define(VOID* first_unused_memory)
{
  static CHAR s_device_thread_name[] = "dfu_device";
 
  (void)first_unused_memory;
  s_tx_kernel_up = true;
  (void)tx_thread_create(&s_device_thread,
                         s_device_thread_name,
                         blc_device_worker,
                         0UL,
                         s_device_stack,
                         (ULONG)k_blc_thread_stack,
                         (UINT)k_blc_dev_priority,
                         (UINT)k_blc_dev_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */
 
/* -------------------------------------------------------------------------- */
/* Startup */
/* -------------------------------------------------------------------------- */

[[noreturn]] static void blc_panic_halt(void)
{
  /* NASA Rule 2 exemption: terminal panic spin -- intentionally never exits. */
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void blc_route_usb_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_blc_pin_fs_vbus, k_ra8_psel_usb_fs, "blc.fs_vbus") != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_gpio_output_init(k_blc_pin_fs_vbusen, k_ra8_level_low) != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_blc_pin_fs_dp, k_ra8_psel_usb_fs, "blc.fs_dp") != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_blc_pin_fs_dm, k_ra8_psel_usb_fs, "blc.fs_dm") != k_ra8_ok) {
    blc_panic_halt();
  }
}
 
#ifdef RA8_ENABLE_ROOT_OF_TRUST
typedef enum : uint32_t {
  k_blc_psa_heap_bytes = 0x10000U, 
} blc_rot_const_t;

static uint8_t s_blc_psa_heap[k_blc_psa_heap_bytes];
#endif

static void blc_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_cgc_usbfs_clock_enable() != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_blc_pin_sci_tx, k_ra8_psel_sci_async, "blc.txd8") != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_blc_pin_sci_rx, k_ra8_psel_sci_async, "blc.rxd8") != k_ra8_ok) {
    blc_panic_halt();
  }
  const ra8_sci_cfg_t sci_cfg = {
    .baud      = k_blc_baud,
    .data_bits = k_ra8_sci_data_8,
    .parity    = k_ra8_sci_parity_none,
    .stop_bits = k_ra8_sci_stop_1,
    .pclk_hz   = pclka_hz,
  };
  if (ra8_sci_init((uint8_t)k_blc_sci_channel, &sci_cfg) != k_ra8_ok) {
    blc_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    blc_panic_halt();
  }
#ifdef RA8_ENABLE_ROOT_OF_TRUST
  /* Bring up the tf-psa-crypto backend for the root-of-trust launch gate: a
   * static buffer-alloc arena (no malloc) then psa_crypto_init. A failure here
   * means the bootloader cannot authenticate any slot, so halt rather than boot
   * an unverified image. */
  mbedtls_memory_buffer_alloc_init(s_blc_psa_heap, sizeof(s_blc_psa_heap));
  if (ra8_psa_crypto_init() != k_ra8_ok) {
    blc_panic_halt();
  }
#endif
  blc_route_usb_or_halt();
}

void main(void)
{
  blc_setup_or_halt();
  ra8_isr_globals_enable();
 
  (void)blc_print("\r\nra8d2 dfu-bootloader (immutable, 128K @ 0x02000000)\r\n");
 
  ra8_dfu_slot_t         target = k_ra8_dfu_slot_a;
  const ra8_dfu_action_t action = blc_decide(&target);
  s_dbg_action                  = (uint32_t)action;
  s_dbg_target                  = (uint32_t)target;
 
  if (action == k_ra8_dfu_action_jump_a) {
    (void)blc_print("dfu-bootloader: Slot A -> copy-to-run @0x");
    (void)blc_print_hex((uint32_t)k_ra8_dfu_run_base);
    (void)blc_print("\r\n");
    blc_boot_slot(k_ra8_dfu_slot_a); /* returns only if the run target is invalid */
  }
  if (action == k_ra8_dfu_action_jump_b) {
    (void)blc_print("dfu-bootloader: Slot B -> copy-to-run @0x");
    (void)blc_print_hex((uint32_t)k_ra8_dfu_run_base);
    (void)blc_print("\r\n");
    blc_boot_slot(k_ra8_dfu_slot_b); /* returns only if the run target is invalid */
  }
 
  /* k_ra8_dfu_action_dfu (or a slot whose run target failed validation): no
   * bootable slot -- accept a DFU update into the inactive slot over USB-FS. */
  (void)blc_print("dfu-bootloader: no bootable slot -- entering DFU\r\n");
#ifndef RA8_OFF_TARGET
  ra8_dfu_device_set_target(target);
  tx_kernel_enter();
#endif
 
  blc_panic_halt();
}