main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ra8p1.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_device.h"
#include "ra8_err.h"
#include "ra8_npu.h"
#include "ra8_npu_fake_cmd.h"
#include "ra8_npu_regs.h"
 
/*
 * Compile-time proof that the RA8P1 toolchain selection reached this TU: the NPU
 * driver only exists when RA8_HAS_NPU is defined (RA8_DEVICE_RA8P1). Building this
 * app with the RA8D2 toolchain fails loudly here instead of silently dropping
 * the NPU.
 */
#ifndef RA8_HAS_NPU
#error "npu_smoke must be built with cmake/toolchain-ra8p1.cmake (RA8_DEVICE_RA8P1)."
#endif

typedef enum : uint32_t {
  k_npu_smoke_baud        = 115200U,                 
  k_npu_smoke_arena_bytes = 64U,                     
  k_npu_smoke_cmd_words   = k_ra8_npu_fake_word_num, 
  k_npu_smoke_hex_digits  = 8U,                      
  k_npu_smoke_hex_shift   = 4U,                      
  k_npu_smoke_hex_mask    = 0x0FU,                   
} npu_smoke_size_t;

typedef enum : uint8_t {
  k_npu_smoke_region_weights = 0U, 
  k_npu_smoke_region_input   = 1U, 
  k_npu_smoke_region_output  = 2U, 
  k_npu_smoke_region_count   = 3U, 
} npu_smoke_region_t;

typedef enum : uint8_t {
  k_npu_smoke_addk      = 0x11U, 
  k_npu_smoke_seed_mul  = 7U,    
  k_npu_smoke_seed_add  = 3U,    
  k_npu_smoke_byte_mask = 0xFFU, 
} npu_smoke_seed_t;

typedef enum : uint32_t {
  k_npu_smoke_fnv_offset = 0x811C9DC5U, 
  k_npu_smoke_fnv_prime  = 0x01000193U, 
} npu_smoke_fnv_t;

static uint32_t s_npu_cmd_stream[k_npu_smoke_cmd_words];

static uint8_t s_npu_weights[k_npu_smoke_arena_bytes];

static uint8_t s_npu_input[k_npu_smoke_arena_bytes];

static uint8_t s_npu_output[k_npu_smoke_arena_bytes];

volatile uint32_t g_npu_smoke_id = 0U;

volatile uint32_t g_npu_smoke_status = 0U;

volatile uint32_t g_npu_smoke_check = 0U;

volatile uint32_t g_npu_smoke_pass = 0U;

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

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

RA8_INTERNAL static void internal_npu_smoke_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_npu_smoke_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_npu_smoke_baud) != k_ra8_ok) {
    internal_npu_smoke_panic_halt();
  }
}

RA8_INTERNAL static void internal_npu_smoke_build_stream(void)
{
  s_npu_cmd_stream[k_ra8_npu_fake_word_op] =
    (uint32_t)k_ra8_npu_fake_magic | (uint32_t)k_ra8_npu_fake_op_addk;
  s_npu_cmd_stream[k_ra8_npu_fake_word_src]   = (uint32_t)k_npu_smoke_region_input;
  s_npu_cmd_stream[k_ra8_npu_fake_word_dst]   = (uint32_t)k_npu_smoke_region_output;
  s_npu_cmd_stream[k_ra8_npu_fake_word_count] = (uint32_t)k_npu_smoke_arena_bytes;
  s_npu_cmd_stream[k_ra8_npu_fake_word_const] = (uint32_t)k_npu_smoke_addk;
}

RA8_INTERNAL static void internal_npu_smoke_seed_arenas(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_npu_smoke_arena_bytes; i++) {
    s_npu_input[i] =
      (uint8_t)(((i * (uint32_t)k_npu_smoke_seed_mul) + (uint32_t)k_npu_smoke_seed_add) &
                (uint32_t)k_npu_smoke_byte_mask);
    s_npu_output[i] = 0U;
  }
}

RA8_INTERNAL static ra8_err_t internal_npu_smoke_run_job(void)
{
  ra8_npu_job_t job                           = {};
  job.cmd_stream                              = s_npu_cmd_stream;
  job.cmd_stream_bytes                        = (uint32_t)sizeof(s_npu_cmd_stream);
  job.region_count                            = (uint8_t)k_npu_smoke_region_count;
  job.region_base[k_npu_smoke_region_weights] = (uint64_t)(uintptr_t)s_npu_weights;
  job.region_base[k_npu_smoke_region_input]   = (uint64_t)(uintptr_t)s_npu_input;
  job.region_base[k_npu_smoke_region_output]  = (uint64_t)(uintptr_t)s_npu_output;
 
  const ra8_err_t sub = ra8_npu_submit(&job);
  if (sub != k_ra8_ok) {
    return sub;
  }
  const ra8_err_t run = ra8_npu_run();
  if (run != k_ra8_ok) {
    return run;
  }
  return ra8_npu_wait();
}

RA8_INTERNAL static bool internal_npu_smoke_verify(uint32_t* out_check)
{
  uint32_t check = (uint32_t)k_npu_smoke_fnv_offset;
  bool     ok    = true;
  for (uint32_t i = 0U; i < (uint32_t)k_npu_smoke_arena_bytes; i++) {
    const uint8_t expected =
      (uint8_t)((s_npu_input[i] + (uint32_t)k_npu_smoke_addk) & (uint32_t)k_npu_smoke_byte_mask);
    if (s_npu_output[i] != expected) {
      ok = false;
    }
    check = (check ^ (uint32_t)s_npu_output[i]) * (uint32_t)k_npu_smoke_fnv_prime;
  }
  *out_check = check;
  return ok;
}
 
RA8_INTERNAL static void internal_npu_smoke_write(const uint8_t* data, size_t len)
{
  (void)ra8_board_uart_console_write(data, len);
}
 
RA8_INTERNAL static void internal_npu_smoke_write_hex32(uint32_t value)
{
  static const uint8_t k_hex[]                        = "0123456789ABCDEF";
  uint8_t              digits[k_npu_smoke_hex_digits] = {};
  for (uint8_t i = 0U; i < (uint8_t)k_npu_smoke_hex_digits; ++i) {
    const uint8_t shift =
      (uint8_t)(((uint8_t)k_npu_smoke_hex_digits - 1U - i) * (uint8_t)k_npu_smoke_hex_shift);
    digits[i] = k_hex[(value >> shift) & (uint32_t)k_npu_smoke_hex_mask];
  }
  internal_npu_smoke_write(digits, (size_t)k_npu_smoke_hex_digits);
}
 
RA8_INTERNAL static void internal_npu_smoke_write_status(bool ok)
{
  const uint8_t* text = ok ? (const uint8_t*)"OK" : (const uint8_t*)"FAIL";
  const size_t   len  = ok ? 2U : 4U;
  internal_npu_smoke_write(text, len);
}
 
RA8_INTERNAL static void internal_npu_smoke_write_verdict(bool pass)
{
  const uint8_t* text = pass ? (const uint8_t*)"PASS" : (const uint8_t*)"FAIL";
  internal_npu_smoke_write(text, 4U);
}

RA8_INTERNAL static void
internal_npu_smoke_emit(uint32_t id, bool run_ok, uint32_t check, bool pass)
{
  internal_npu_smoke_write((const uint8_t*)"npu: id=0x", sizeof("npu: id=0x") - 1U);
  internal_npu_smoke_write_hex32(id);
  internal_npu_smoke_write((const uint8_t*)" run=", sizeof(" run=") - 1U);
  internal_npu_smoke_write_status(run_ok);
  internal_npu_smoke_write((const uint8_t*)" out=0x", sizeof(" out=0x") - 1U);
  internal_npu_smoke_write_hex32(check);
  internal_npu_smoke_write((const uint8_t*)" verdict=", sizeof(" verdict=") - 1U);
  internal_npu_smoke_write_verdict(pass);
  internal_npu_smoke_write((const uint8_t*)"\r\n", sizeof("\r\n") - 1U);
  (void)ra8_board_uart_console_flush();
}

void main(void)
{
  internal_npu_smoke_setup_or_halt();
 
  bool     run_ok = false;
  uint32_t id     = 0U;
  uint32_t check  = 0U;
  bool     pass   = false;
 
  if (ra8_npu_init() == k_ra8_ok) {
    (void)ra8_npu_read_id(&id);
    g_npu_smoke_id = id;
 
    internal_npu_smoke_build_stream();
    internal_npu_smoke_seed_arenas();
    run_ok = (internal_npu_smoke_run_job() == k_ra8_ok);
 
    ra8_npu_status_t st = {};
    if (ra8_npu_read_status(&st) == k_ra8_ok) {
      g_npu_smoke_status = st.raw;
    }
    const bool matched = internal_npu_smoke_verify(&check);
    g_npu_smoke_check  = check;
    pass               = run_ok && matched && (id != 0U);
  }
 
  g_npu_smoke_pass = pass ? 1U : 0U;
  internal_npu_smoke_emit(id, run_ok, check, pass);
 
  internal_npu_smoke_park();
}