ra8_ethosu_shim.c

Go to the documentation of this file.

 
#include "ra8_device.h"
 
#ifdef RA8_HAS_NPU
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_ethosu_shim.h"
#include "ra8_log.h"
#include "ra8_npu.h"
#include "ra8_npu_regs.h"

static const char* s_tag = "ETHOSU";

typedef enum : int32_t {
  k_ra8_ethosu_ret_ok  = 0,  
  k_ra8_ethosu_ret_err = -1, 
} ra8_ethosu_ret_t;

struct ethosu_driver {
  bool reserved; 
};

static struct ethosu_driver s_ethosu_driver = {};

static bool s_ethosu_driver_ready = false;
 
struct ethosu_driver* ethosu_reserve_driver(void)
{
  if (!s_ethosu_driver_ready) {
    const ra8_err_t err = ra8_npu_init();
    if (ra8_err_is_error(err)) {
      ra8_log_error(s_tag, "reserve: npu_init failed");
      return nullptr;
    }
    s_ethosu_driver_ready = true;
  }
  s_ethosu_driver.reserved = true; 
  return &s_ethosu_driver;         
}

RA8_INTERNAL
static bool internal_invoke_args_ok(const struct ethosu_driver* drv,
                                    const void*                 custom_data_ptr,
                                    int                         custom_data_size,
                                    const uint64_t*             base_addr,
                                    int                         num_base_addr)
{
  if (drv == nullptr) {
    ra8_log_error(s_tag, "invoke: null driver");
    return false;
  }
  if (custom_data_ptr == nullptr) {
    ra8_log_error(s_tag, "invoke: null command stream");
    return false;
  }
  if (custom_data_size <= 0) {
    ra8_log_error(s_tag, "invoke: empty command stream");
    return false;
  }
  if (num_base_addr < 0) {
    ra8_log_error(s_tag, "invoke: negative region count");
    return false;
  }
  /* Bound the region count to ra8_npu's fixed region_base[] capacity BEFORE the
   * copy loop, so an oversized count can never overflow the job descriptor. */
  if ((uint32_t)num_base_addr > (uint32_t)k_ra8_npu_region_count) {
    ra8_log_error(s_tag, "invoke: too many regions");
    return false;
  }
  if ((num_base_addr > 0) && (base_addr == nullptr)) {
    ra8_log_error(s_tag, "invoke: null base_addr array");
    return false;
  }
  return true;
}
 
int ethosu_invoke_v3(struct ethosu_driver* drv,
                     const void*           custom_data_ptr,
                     int                   custom_data_size,
                     const uint64_t*       base_addr,
                     const size_t*         base_addr_size,
                     int                   num_base_addr,
                     void*                 user_arg)
{
  /* base_addr_size (per-region byte sizes) and user_arg (Arm callback cookie)
   * are part of the ABI but have no analogue in the ra8_npu job model. */
  (void)base_addr_size;
  (void)user_arg;
 
  if (!internal_invoke_args_ok(drv, custom_data_ptr, custom_data_size, base_addr, num_base_addr)) {
    return (int)k_ra8_ethosu_ret_err;
  }
 
  ra8_npu_job_t job    = {};
  job.cmd_stream       = custom_data_ptr;
  job.cmd_stream_bytes = (uint32_t)custom_data_size;
  job.region_count     = (uint8_t)num_base_addr;
  for (uint8_t i = 0U; i < job.region_count; i++) {
    job.region_base[i] = base_addr[i];
  }
 
  const ra8_err_t serr = ra8_npu_submit(&job);
  if (ra8_err_is_error(serr)) {
    ra8_log_error(s_tag, "invoke: submit");
    return (int)k_ra8_ethosu_ret_err;
  }
  const ra8_err_t rerr = ra8_npu_run();
  if (ra8_err_is_error(rerr)) {
    ra8_log_error(s_tag, "invoke: run");
    return (int)k_ra8_ethosu_ret_err;
  }
  const ra8_err_t werr = ra8_npu_wait();
  if (ra8_err_is_error(werr)) {
    ra8_log_error(s_tag, "invoke: wait");
    return (int)k_ra8_ethosu_ret_err;
  }
  return (int)k_ra8_ethosu_ret_ok;
}
 
void ethosu_release_driver(struct ethosu_driver* drv)
{
  if (drv == nullptr) {
    ra8_log_error(s_tag, "release: null driver");
    return;
  }
  /* Single persistent NPU: the block stays initialised so a later
   * ethosu_reserve_driver() re-hands the same context. Only clear the
   * caller-visible reserved flag. */
  drv->reserved = false;
}
 
#else
/* RA8D2 (no NPU): this translation unit is intentionally empty. */
typedef int ra8_ethosu_shim_not_on_this_device_t;
#endif /* RA8_HAS_NPU */