main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.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_blob.h"
#include "ra8_npu_fake_cmd.h"
#include "ra8_npu_loader.h"
#include "ra8_npu_model_addk_fake.h"
#include "ra8_npu_regs.h"
 
#ifndef RA8_HAS_NPU
#error "npu_vela must be built with cmake/toolchain-ra8p1.cmake (RA8_DEVICE_RA8P1)."
#endif

typedef enum : uint32_t {
  k_npu_vela_baud       = 115200U, 
  k_npu_vela_arena      = 128U,    
  k_npu_vela_word_bytes = 4U,      
  k_npu_vela_byte_mask  = 0xFFU,   
  k_npu_vela_hex_digits = 8U,      
  k_npu_vela_hex_shift  = 4U,      
  k_npu_vela_hex_mask   = 0x0FU,   
} npu_vela_size_t;

typedef enum : uint32_t {
  k_npu_vela_fnv_offset = 0x811C9DC5U, 
  k_npu_vela_fnv_prime  = 0x01000193U, 
} npu_vela_fnv_t;

static uint8_t s_npu_vela_arena[k_npu_vela_arena];

volatile uint32_t g_npu_vela_id = 0U;

volatile uint32_t g_npu_vela_check = 0U;

volatile uint32_t g_npu_vela_pass = 0U;

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

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

RA8_INTERNAL static void internal_npu_vela_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_npu_vela_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_npu_vela_baud) != k_ra8_ok) {
    internal_npu_vela_panic_halt();
  }
}

RA8_INTERNAL static uint32_t internal_npu_vela_cmd_word(const ra8_npu_job_t*    job,
                                                        ra8_npu_fake_word_idx_t widx)
{
  return ra8_npu_blob_read_word((const uint8_t*)job->cmd_stream,
                                (uint32_t)widx * (uint32_t)k_npu_vela_word_bytes);
}

RA8_INTERNAL static bool internal_npu_vela_verify(const ra8_npu_job_t* job, uint32_t* out_check)
{
  const uint8_t* input  = (const uint8_t*)(uintptr_t)job->region_base[k_ra8_npu_region_1];
  const uint8_t* output = (const uint8_t*)(uintptr_t)job->region_base[k_ra8_npu_region_2];
  const uint32_t konst  = internal_npu_vela_cmd_word(job, k_ra8_npu_fake_word_const);
  const uint32_t count  = internal_npu_vela_cmd_word(job, k_ra8_npu_fake_word_count);
  uint32_t       check  = (uint32_t)k_npu_vela_fnv_offset;
  bool           ok     = true;
  for (uint32_t i = 0U; i < count; i++) {
    const uint8_t expected = (uint8_t)((input[i] + konst) & (uint32_t)k_npu_vela_byte_mask);
    if (output[i] != expected) {
      ok = false;
    }
    check = (check ^ (uint32_t)output[i]) * (uint32_t)k_npu_vela_fnv_prime;
  }
  *out_check = check;
  return ok;
}

RA8_INTERNAL static ra8_err_t internal_npu_vela_run_job(ra8_npu_job_t* out_job)
{
  const ra8_npu_arena_t arena = {.base = s_npu_vela_arena, .bytes = (uint32_t)k_npu_vela_arena};
  const ra8_err_t       ld =
    ra8_npu_load(ra8_npu_model_addk_fake_blob(), ra8_npu_model_addk_fake_bytes(), &arena, out_job);
  if (ld != k_ra8_ok) {
    return ld;
  }
  const ra8_err_t sub = ra8_npu_submit(out_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 void internal_npu_vela_write(const uint8_t* data, size_t len)
{
  (void)ra8_board_uart_console_write(data, len);
}
 
RA8_INTERNAL static void internal_npu_vela_write_hex32(uint32_t value)
{
  static const uint8_t k_hex[]                       = "0123456789ABCDEF";
  uint8_t              digits[k_npu_vela_hex_digits] = {};
  for (uint8_t i = 0U; i < (uint8_t)k_npu_vela_hex_digits; ++i) {
    const uint8_t shift =
      (uint8_t)(((uint8_t)k_npu_vela_hex_digits - 1U - i) * (uint8_t)k_npu_vela_hex_shift);
    digits[i] = k_hex[(value >> shift) & (uint32_t)k_npu_vela_hex_mask];
  }
  internal_npu_vela_write(digits, (size_t)k_npu_vela_hex_digits);
}
 
RA8_INTERNAL static void internal_npu_vela_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_vela_write(text, len);
}
 
RA8_INTERNAL static void internal_npu_vela_write_verdict(bool pass)
{
  const uint8_t* text = pass ? (const uint8_t*)"PASS" : (const uint8_t*)"FAIL";
  internal_npu_vela_write(text, 4U);
}

RA8_INTERNAL static void
internal_npu_vela_emit(uint32_t id, bool load_ok, bool run_ok, uint32_t check, bool pass)
{
  internal_npu_vela_write((const uint8_t*)"npu-vela: id=0x", sizeof("npu-vela: id=0x") - 1U);
  internal_npu_vela_write_hex32(id);
  internal_npu_vela_write((const uint8_t*)" load=", sizeof(" load=") - 1U);
  internal_npu_vela_write_status(load_ok);
  internal_npu_vela_write((const uint8_t*)" run=", sizeof(" run=") - 1U);
  internal_npu_vela_write_status(run_ok);
  internal_npu_vela_write((const uint8_t*)" out=0x", sizeof(" out=0x") - 1U);
  internal_npu_vela_write_hex32(check);
  internal_npu_vela_write((const uint8_t*)" verdict=", sizeof(" verdict=") - 1U);
  internal_npu_vela_write_verdict(pass);
  internal_npu_vela_write((const uint8_t*)"\r\n", sizeof("\r\n") - 1U);
  (void)ra8_board_uart_console_flush();
}

void main(void)
{
  internal_npu_vela_setup_or_halt();
 
  bool     load_ok = false;
  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_vela_id = id;
 
    ra8_npu_job_t   job = {};
    const ra8_err_t rc  = internal_npu_vela_run_job(&job);
    load_ok             = (job.cmd_stream != nullptr); /* load leaves it null on failure */
    run_ok              = (rc == k_ra8_ok);
 
    /* Gate verify on load_ok as well: a successful run implies the load
     * populated cmd_stream, but stating it explicitly lets the static analyzer
     * see that internal_npu_vela_verify() never dereferences a null cmd_stream. */
    const bool matched = run_ok && load_ok && internal_npu_vela_verify(&job, &check);
    g_npu_vela_check   = check;
    pass               = load_ok && run_ok && matched && (id != 0U);
  }
 
  g_npu_vela_pass = pass ? 1U : 0U;
  internal_npu_vela_emit(id, load_ok, run_ok, check, pass);
 
  internal_npu_vela_park();
}