ra8_npu_loader.c

Go to the documentation of this file.

 
#include "ra8_device.h"
 
#ifdef RA8_HAS_NPU
 
#include <stdint.h>
 
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_npu.h"
#include "ra8_npu_blob.h"
#include "ra8_npu_loader.h"

static const char* s_tag = "NPU-LOAD";

typedef enum : uint32_t {
  k_ra8_npu_loader_align_mask =
    (uint32_t)k_ra8_npu_blob_arena_align - 1U, 
} ra8_npu_loader_const_t;

static bool internal_npu_span_ok(uint32_t offset, uint32_t size, uint32_t limit)
{
  if (size > limit) {
    return false;
  }
  if (offset > (limit - size)) {
    return false;
  }
  return true;
}

static ra8_err_t internal_npu_check_header(const uint8_t* p,
                                           uint32_t       blob_bytes,
                                           uint32_t*      out_total,
                                           uint32_t*      out_rcount,
                                           uint32_t*      out_coff,
                                           uint32_t*      out_cbytes)
{
  if (blob_bytes < (uint32_t)k_ra8_npu_blob_header_bytes) {
    ra8_log_error(s_tag, "load: buffer smaller than header");
    return k_ra8_err_invalid_size;
  }
  if (ra8_npu_blob_read_word(p,
                             (uint32_t)k_ra8_npu_blob_word_magic *
                               (uint32_t)k_ra8_npu_blob_word_bytes) !=
      (uint32_t)k_ra8_npu_blob_magic) {
    ra8_log_error(s_tag, "load: bad magic");
    return k_ra8_err_invalid_arg;
  }
  if (ra8_npu_blob_read_word(p,
                             (uint32_t)k_ra8_npu_blob_word_version *
                               (uint32_t)k_ra8_npu_blob_word_bytes) !=
      (uint32_t)k_ra8_npu_blob_version) {
    ra8_log_error(s_tag, "load: unsupported version");
    return k_ra8_err_invalid_arg;
  }
  const uint32_t total = ra8_npu_blob_read_word(p,
                                                (uint32_t)k_ra8_npu_blob_word_total_bytes *
                                                  (uint32_t)k_ra8_npu_blob_word_bytes);
  if (!internal_npu_span_ok(0U, total, blob_bytes)) {
    ra8_log_error(s_tag, "load: total_bytes exceeds buffer");
    return k_ra8_err_out_of_range;
  }
  const uint32_t rcount = ra8_npu_blob_read_word(p,
                                                 (uint32_t)k_ra8_npu_blob_word_region_count *
                                                   (uint32_t)k_ra8_npu_blob_word_bytes);
  if (rcount > (uint32_t)k_ra8_npu_region_count) {
    ra8_log_error(s_tag, "load: too many regions");
    return k_ra8_err_invalid_arg;
  }
  const uint32_t coff   = ra8_npu_blob_read_word(p,
                                                 (uint32_t)k_ra8_npu_blob_word_cmd_offset *
                                                   (uint32_t)k_ra8_npu_blob_word_bytes);
  const uint32_t cbytes = ra8_npu_blob_read_word(p,
                                                 (uint32_t)k_ra8_npu_blob_word_cmd_bytes *
                                                   (uint32_t)k_ra8_npu_blob_word_bytes);
  if (cbytes == 0U) {
    ra8_log_error(s_tag, "load: empty command stream");
    return k_ra8_err_invalid_size;
  }
  if (!internal_npu_span_ok(coff, cbytes, total)) {
    ra8_log_error(s_tag, "load: command stream outside blob");
    return k_ra8_err_out_of_range;
  }
  *out_total  = total;
  *out_rcount = rcount;
  *out_coff   = coff;
  *out_cbytes = cbytes;
  return k_ra8_ok;
}

static ra8_err_t internal_npu_verify_checksum(const uint8_t* p, uint32_t total)
{
  uint32_t digest = (uint32_t)k_ra8_npu_blob_fnv_offset;
  for (uint32_t i = (uint32_t)k_ra8_npu_blob_header_bytes; i < total; i++) {
    digest = (digest ^ (uint32_t)p[i]) * (uint32_t)k_ra8_npu_blob_fnv_prime;
  }
  const uint32_t stored = ra8_npu_blob_read_word(p,
                                                 (uint32_t)k_ra8_npu_blob_word_checksum *
                                                   (uint32_t)k_ra8_npu_blob_word_bytes);
  if (digest != stored) {
    ra8_log_error(s_tag, "load: checksum mismatch");
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

static ra8_err_t internal_npu_place_region(const uint8_t*         p,
                                           uint32_t               total,
                                           uint32_t               desc_off,
                                           const ra8_npu_arena_t* arena,
                                           uint32_t*              arena_used,
                                           uint64_t*              out_base)
{
  const uint32_t flags = ra8_npu_blob_read_word(
    p,
    desc_off + ((uint32_t)k_ra8_npu_blob_rdesc_flags * (uint32_t)k_ra8_npu_blob_word_bytes));
  const uint32_t size = ra8_npu_blob_read_word(
    p,
    desc_off + ((uint32_t)k_ra8_npu_blob_rdesc_size * (uint32_t)k_ra8_npu_blob_word_bytes));
  if ((flags & (uint32_t)k_ra8_npu_blob_rflag_baked) != 0U) {
    const uint32_t data_off =
      ra8_npu_blob_read_word(p,
                             desc_off + ((uint32_t)k_ra8_npu_blob_rdesc_data_offset *
                                         (uint32_t)k_ra8_npu_blob_word_bytes));
    if (!internal_npu_span_ok(data_off, size, total)) {
      ra8_log_error(s_tag, "load: baked region outside blob");
      return k_ra8_err_out_of_range;
    }
    *out_base = (uint64_t)(uintptr_t)(p + data_off);
    return k_ra8_ok;
  }
  const uint32_t aligned =
    (*arena_used + (uint32_t)k_ra8_npu_loader_align_mask) & ~(uint32_t)k_ra8_npu_loader_align_mask;
  if (aligned > arena->bytes) {
    ra8_log_error(s_tag, "load: runtime arena exhausted");
    return k_ra8_err_no_mem;
  }
  if (size > (arena->bytes - aligned)) {
    ra8_log_error(s_tag, "load: runtime region does not fit");
    return k_ra8_err_no_mem;
  }
  *out_base   = (uint64_t)(uintptr_t)(arena->base + aligned);
  *arena_used = aligned + size;
  return k_ra8_ok;
}

static ra8_err_t internal_npu_place_all_regions(const uint8_t*         p,
                                                uint32_t               total,
                                                uint32_t               rcount,
                                                const ra8_npu_arena_t* arena,
                                                ra8_npu_job_t*         job)
{
  uint32_t used = 0U;
  for (uint32_t r = 0U; r < rcount; r++) {
    const uint32_t desc_off =
      (uint32_t)k_ra8_npu_blob_header_bytes + (r * (uint32_t)k_ra8_npu_blob_region_desc_bytes);
    const ra8_err_t rgn =
      internal_npu_place_region(p, total, desc_off, arena, &used, &job->region_base[r]);
    RA8_RETURN_ON_ERROR(rgn, s_tag, "load: region");
  }
  return k_ra8_ok;
}

static ra8_err_t internal_npu_build_job(const uint8_t*         p,
                                        uint32_t               blob_bytes,
                                        const ra8_npu_arena_t* arena,
                                        ra8_npu_job_t*         out_job)
{
  uint32_t total  = 0U;
  uint32_t rcount = 0U;
  uint32_t coff   = 0U;
  uint32_t cbytes = 0U;
  /* Each callee logs its own specific failure, so a plain early return here
   * propagates the code without a redundant second log line. */
  const ra8_err_t hdr = internal_npu_check_header(p, blob_bytes, &total, &rcount, &coff, &cbytes);
  if (hdr != k_ra8_ok) {
    return hdr;
  }
  if (!internal_npu_span_ok((uint32_t)k_ra8_npu_blob_header_bytes,
                            rcount * (uint32_t)k_ra8_npu_blob_region_desc_bytes,
                            total)) {
    ra8_log_error(s_tag, "load: region table outside blob");
    return k_ra8_err_out_of_range;
  }
  const ra8_err_t sum = internal_npu_verify_checksum(p, total);
  if (sum != k_ra8_ok) {
    return sum;
  }
  ra8_npu_job_t   job = {};
  const ra8_err_t rgn = internal_npu_place_all_regions(p, total, rcount, arena, &job);
  if (rgn != k_ra8_ok) {
    return rgn;
  }
  job.cmd_stream       = p + coff;
  job.cmd_stream_bytes = cbytes;
  job.region_count     = (uint8_t)rcount;
  *out_job             = job;
  return k_ra8_ok;
}
 
ra8_err_t ra8_npu_load(const void*            blob,
                       uint32_t               blob_bytes,
                       const ra8_npu_arena_t* arena,
                       ra8_npu_job_t*         out_job)
{
  RA8_CHECK_NULL_PTR(blob, s_tag, "blob must not be nullptr");
  RA8_CHECK_NULL_PTR(arena, s_tag, "arena must not be nullptr");
  RA8_CHECK_NULL_PTR(out_job, s_tag, "out_job must not be nullptr");
  return internal_npu_build_job((const uint8_t*)blob, blob_bytes, arena, out_job);
}
 
#else
/* RA8D2 (no NPU): this translation unit is intentionally empty. */
typedef int ra8_npu_loader_not_on_this_device_t;
#endif /* RA8_HAS_NPU */