ns_main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_err.h"
#include "ra8_nsc.h"
#include "tx_api.h"
 
/* Linker symbols for BSS, Stack, and Run memory */
extern uint32_t g_ra8_ls_ns_bss_start;
extern uint32_t g_ra8_ls_ns_bss_end;
extern uint32_t g_ra8_ls_ns_stack_top;
extern uint32_t g_ra8_ls_ns_run_start;

typedef enum : uintptr_t {
  k_ns_scb_vtor_addr = 0xE000ED08U, 
} ns_scb_addr_t;

typedef enum : uint32_t {
  k_ns_ui_thread_stack_size   = 2048U, 
  k_ns_work_thread_stack_size = 2048U, 
} ns_thread_stack_t;
 
static TX_THREAD s_ui_thread;
static TX_THREAD s_work_thread;
 
static uint8_t s_ui_thread_stack[k_ns_ui_thread_stack_size];
static uint8_t s_work_thread_stack[k_ns_work_thread_stack_size];

typedef enum : uint32_t {
  k_ns_ui_heartbeat_iters   = 50U, 
  k_ns_work_heartbeat_iters = 10U, 
} ns_log_cadence_t;
 
/* External declarations for thread tick hooks */
extern void              PendSV_Handler(void);
extern void              _tx_timer_interrupt(void);
extern volatile uint32_t g_ra8_threadx_systick_ready;

static void ns_systick_handler(void)
{
  if (g_ra8_threadx_systick_ready != 0U) {
    _tx_timer_interrupt();
  }
}

[[noreturn]] static void ns_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

typedef enum : uint16_t {
  k_ns_ui_sleep_ticks   = 20U,  
  k_ns_work_sleep_ticks = 100U, 
} ns_thread_cadence_t;

static void ui_thread_entry(ULONG thread_input)
{
  (void)thread_input;
  (void)ra8_nsc_log_emit("UI", "UI thread started -- Simulating screen/event loop");
 
  uint32_t count = 0U;
  for (;;) {
    count++;
    if ((count % (uint32_t)k_ns_ui_heartbeat_iters) == 0U) {
      (void)ra8_nsc_log_emit("UI", "UI Loop: Refreshing screen layout...");
    }
    tx_thread_sleep((ULONG)k_ns_ui_sleep_ticks);
  }
}

static void work_thread_entry(ULONG thread_input)
{
  (void)thread_input;
  (void)ra8_nsc_log_emit("WORK", "Worker thread started -- Processing background tasks");
 
  uint32_t count = 0U;
  for (;;) {
    count++;
    if ((count % (uint32_t)k_ns_work_heartbeat_iters) == 0U) {
      (void)ra8_nsc_log_emit("WORK", "Worker Loop: Reading battery & sensor state via NSC veneers");
    }
    tx_thread_sleep((ULONG)k_ns_work_sleep_ticks);
  }
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  /* Create the UI thread. (CHAR*)(uintptr_t): the vendored ThreadX API takes
   * a non-const CHAR* for the thread name; the uintptr_t hop launders the
   * string-literal const without tripping -Wcast-qual. */
  (void)tx_thread_create(&s_ui_thread,
                         (CHAR*)(uintptr_t)"UI Thread",
                         ui_thread_entry,
                         0UL,
                         s_ui_thread_stack,
                         k_ns_ui_thread_stack_size,
                         10U, /* Priority             */
                         10U, /* Preemption threshold */
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
 
  /* Create the Worker thread */
  (void)tx_thread_create(&s_work_thread,
                         (CHAR*)(uintptr_t)"Worker Thread",
                         work_thread_entry,
                         0UL,
                         s_work_thread_stack,
                         k_ns_work_thread_stack_size,
                         15U, /* Priority             */
                         15U, /* Preemption threshold */
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}

[[noreturn]] void ns_reset_handler(void);
 
[[noreturn]] void ns_reset_handler(void)
{
  /* Zero the NS BSS section */
  const uintptr_t bss_start = (uintptr_t)&g_ra8_ls_ns_bss_start;
  const uintptr_t bss_end   = (uintptr_t)&g_ra8_ls_ns_bss_end;
  for (uintptr_t addr = bss_start; addr < bss_end; addr += sizeof(uint32_t)) {
    *(volatile uint32_t*)addr = 0U;
  }
 
  /* Set the NS VTOR so exceptions vector correctly to NS handlers */
  *(volatile uint32_t*)k_ns_scb_vtor_addr = (uint32_t)(uintptr_t)&g_ra8_ls_ns_run_start;
 
  /* Call Secure-side substrate initialization via NSC veneer gateway */
  if (ra8_nsc_periph_init() != k_ra8_ok) {
    ns_panic_halt();
  }
 
  /* Announce that Non-Secure is online! */
  (void)ra8_nsc_log_emit("BOOT", "tz_threadx_demo: Non-Secure world online!");
 
  /* Enter ThreadX RTOS kernel (never returns) */
  tx_kernel_enter();
 
  ns_panic_halt();
}
 
/* =============================================================================
 * Non-Secure Vector Table
 * =============================================================================
 */
typedef void (*ns_exc_handler_t)(void);
 
[[noreturn]] static void ns_nmi_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}
 
[[gnu::section(".ns_vectors"), gnu::used]] const ns_exc_handler_t g_ra8_ns_vector_table[16] = {
  (ns_exc_handler_t)&g_ra8_ls_ns_stack_top, /* 0 Initial MSP_NS */
  ns_reset_handler,                         /* 1 Reset          */
  ns_nmi_halt,                              /* 2 NMI            */
  ns_nmi_halt,                              /* 3 HardFault      */
  ns_nmi_halt,                              /* 4 MemManage      */
  ns_nmi_halt,                              /* 5 BusFault       */
  ns_nmi_halt,                              /* 6 UsageFault     */
  ns_nmi_halt,                              /* 7 SecureFault    */
  0,                                        /* 8 Reserved       */
  0,                                        /* 9 Reserved       */
  0,                                        /* 10 Reserved      */
  ns_nmi_halt,                              /* 11 SVCall        */
  ns_nmi_halt,                              /* 12 DebugMonitor  */
  0,                                        /* 13 Reserved      */
  PendSV_Handler,                           /* 14 PendSV        */
  ns_systick_handler,                       /* 15 SysTick       */
};