252 lines
7.3 KiB
C
252 lines
7.3 KiB
C
/*
|
|
* Kneron NPU driver for KDP520
|
|
*
|
|
* Copyright (C) 2018 Kneron, Inc. All rights reserved.
|
|
*
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "io.h"
|
|
#include "kmdw_memory.h"
|
|
#include "ipc.h"
|
|
#include "scu_ipc.h"
|
|
#include "kdrv_ncpu.h"
|
|
#include "kmdw_console.h"
|
|
#include "base.h"
|
|
#include "power_manager.h"
|
|
#include "kdrv_cmsis_core.h"
|
|
|
|
#define IRQ_QUEUE_SIZE (5*2)
|
|
|
|
#define NCPU_IRQ 51
|
|
|
|
#define INPROC_ARRAY_MAX_SIZE 1000 /* 1000 uint32*/
|
|
#define IMAGE_PREPROCESS_BUF_SIZE 0x200000
|
|
|
|
ipc_handler_t ipc_handler_cb;
|
|
|
|
struct scpu_to_ncpu_s *s_out_comm;
|
|
struct ncpu_to_scpu_s *s_in_comm;
|
|
|
|
#define CMD_FLAGS(i) (s_out_comm->cmd_flags[i])
|
|
#define CMD_FLAGS_IS_ACTIVE(i) (s_out_comm->cmd_flags[i] == IMAGE_STATE_ACTIVE)
|
|
#define CMD_FLAGS_IS_INACTIVE(i) (s_out_comm->cmd_flags[i] == IMAGE_STATE_INACTIVE)
|
|
#define CMD_STATUS(i) (s_in_comm->cmd_status[i])
|
|
#define CMD_STATUS_IS_NPU_BUSY(i) (s_in_comm->cmd_status[i] == IMAGE_STATE_NPU_BUSY)
|
|
#define CMD_STATUS_IS_NPU_DONE(i) (s_in_comm->cmd_status[i] == IMAGE_STATE_NPU_DONE)
|
|
#define CMD_STATUS_IS_PROC_DONE(i) (s_in_comm->cmd_status[i] == IMAGE_STATE_POST_PROCESSING_DONE)
|
|
|
|
void kdrv_ncpu_trigger_int(int to_trigger)
|
|
{
|
|
CMD_FLAGS(to_trigger) = IMAGE_STATE_ACTIVE;
|
|
|
|
check_status:
|
|
// check if npu is busy
|
|
if (CMD_STATUS_IS_NPU_BUSY(to_trigger)) {
|
|
err_msg("kdrv_ncpu: npu busy: [%d] %d/%d ?\n", to_trigger,
|
|
CMD_FLAGS(to_trigger), CMD_STATUS(to_trigger));
|
|
|
|
osDelay(5);
|
|
goto check_status;
|
|
}
|
|
|
|
s_out_comm->cmd = CMD_RUN_NPU + to_trigger;
|
|
|
|
scu_ipc_trigger_to_ncpu_int();
|
|
}
|
|
|
|
static void NCPU_IRQHandler(void)
|
|
{
|
|
int en_q, de_q, irq, ipc_idx;
|
|
|
|
// kp inference debug code
|
|
if(s_in_comm->kp_dbg_status == 0xAA)
|
|
{
|
|
scu_ipc_clear_from_ncpu_int();
|
|
NVIC_ClearPendingIRQ((IRQn_Type)NCPU_IRQ);
|
|
|
|
ipc_handler_cb(0x999, 0x0);
|
|
return;
|
|
}
|
|
|
|
handler_entry:
|
|
en_q = s_in_comm->irq_enqueued;
|
|
de_q = s_in_comm->irq_dequeued;
|
|
while (de_q != en_q) {
|
|
irq = s_in_comm->irq_queue[de_q];
|
|
if (irq < IRQ_BASE) {
|
|
err_msg("SCPU IRQ queue[%d] %d ?\n", de_q, irq);
|
|
s_in_comm->irq_queue[de_q] = -1;
|
|
de_q++;
|
|
break;
|
|
}
|
|
|
|
irq -= IRQ_BASE;
|
|
ipc_idx = irq / IRQ_PER_IMG;
|
|
irq %= IRQ_PER_IMG;
|
|
|
|
if (ipc_idx >= IPC_IMAGE_ACTIVE_MAX) {
|
|
err_msg("SCPU IRQ queue[%d] ipc_idx %d? irq %d\n", de_q, ipc_idx, irq);
|
|
s_in_comm->irq_queue[de_q] = -2;
|
|
de_q++;
|
|
break;
|
|
}
|
|
|
|
if (CMD_FLAGS_IS_ACTIVE(ipc_idx)) {
|
|
if (irq == IRQ_POST_PROC_DONE) {
|
|
CMD_FLAGS(ipc_idx) = IMAGE_STATE_RECEIVING;
|
|
ipc_handler_cb(ipc_idx, CMD_FLAGS(ipc_idx));
|
|
CMD_FLAGS(ipc_idx) = IMAGE_STATE_INACTIVE;
|
|
} else if (irq == IRQ_NPU_DONE) {
|
|
ipc_handler_cb(ipc_idx, CMD_FLAGS(ipc_idx));
|
|
} else {
|
|
err_msg("SCPU IRQ queue[%d] ipc_idx %d irq %d?\n", de_q, ipc_idx, irq);
|
|
s_in_comm->irq_queue[de_q] = -3;
|
|
de_q++;
|
|
break;
|
|
}
|
|
|
|
s_in_comm->irq_queue[de_q] = 0;
|
|
de_q++;
|
|
de_q %= IRQ_QUEUE_SIZE;
|
|
} else {
|
|
err_msg("SCPU: wrong status: %d: [0] %d/%d, [1] %d/%d\n",
|
|
s_in_comm->status,
|
|
CMD_FLAGS(0), CMD_STATUS(0),
|
|
CMD_FLAGS(1), CMD_STATUS(1));
|
|
err_msg("SCPU IRQ queue[%d] ipc_idx %d? irq %d\n", de_q, ipc_idx, irq);
|
|
|
|
s_in_comm->irq_queue[de_q] = -4;
|
|
de_q++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
s_in_comm->irq_dequeued = de_q % IRQ_QUEUE_SIZE;
|
|
|
|
scu_ipc_clear_from_ncpu_int();
|
|
NVIC_ClearPendingIRQ((IRQn_Type)NCPU_IRQ);
|
|
|
|
// Re-check for new IRQ
|
|
if (en_q != s_in_comm->irq_enqueued)
|
|
goto handler_entry;
|
|
|
|
if (s_in_comm->status == STATUS_ERR) {
|
|
power_manager_reset();
|
|
}
|
|
}
|
|
|
|
/* ############################
|
|
* ## Public Functions ##
|
|
* ############################ */
|
|
|
|
int kdrv_ncpu_get_avail_com(void)
|
|
{
|
|
if (CMD_FLAGS_IS_INACTIVE(0))
|
|
return 0;
|
|
else if (CMD_FLAGS_IS_INACTIVE(1))
|
|
return 1;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
int kdrv_ncpu_set_image_active(uint32_t n_index)
|
|
{
|
|
int rc;
|
|
|
|
rc = kdrv_ncpu_get_avail_com();
|
|
if (rc != -1) {
|
|
s_out_comm->active_img_index[rc] = n_index;
|
|
} else {
|
|
dbg_msg("[NO AVAIL] set_image_active: [0] %d/%d, [1] %d/%d\n",
|
|
CMD_FLAGS(0), CMD_STATUS(0),
|
|
CMD_FLAGS(1), CMD_STATUS(1));
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
void kdrv_ncpu_set_model_active(int ipc_idx, uint32_t n_index)
|
|
{
|
|
s_out_comm->model_slot_index[ipc_idx] = n_index;
|
|
}
|
|
|
|
void kdrv_ncpu_set_model(struct kdp_model_s *model_info_addr, uint32_t info_idx, int32_t slot_idx)
|
|
{
|
|
if (slot_idx >= MULTI_MODEL_MAX) {
|
|
dbg_msg("[ERR] too many active model is set\n");
|
|
return;
|
|
}
|
|
|
|
struct kdp_model_s * info = model_info_addr + info_idx;
|
|
s_out_comm->models[slot_idx] = *(info);
|
|
s_out_comm->models_type[slot_idx] = info->model_type;
|
|
|
|
dbg_msg("[%s] idx [%u], slot [%d]\n"
|
|
"in addr [0x%x], len [%u], out addr [0x%x], len [%u]\n",
|
|
__func__, info_idx, slot_idx,
|
|
info->input_mem_addr, info->input_mem_len, info->output_mem_addr, info->output_mem_len);
|
|
|
|
dbg_msg("buf addr [0x%x], len [%u], cmd addr [0x%x], len [%u]\n"
|
|
"weight addr [0x%x], len [%u], setup addr [0x%x], len [%u]\n",
|
|
info->buf_addr, info->buf_len, info->cmd_mem_addr, info->cmd_mem_len,
|
|
info->weight_mem_addr, info->weight_mem_len, info->setup_mem_addr, info->setup_mem_len);
|
|
|
|
if (slot_idx + 1 > s_out_comm->num_models) {
|
|
s_out_comm->num_models = slot_idx + 1;
|
|
}
|
|
}
|
|
|
|
void kdrv_ncpu_initialize(ipc_handler_t ipc_handler)
|
|
{
|
|
s_out_comm = (struct scpu_to_ncpu_s *)IPC_MEM_ADDR;
|
|
s_in_comm = (struct ncpu_to_scpu_s *)IPC_MEM_ADDR2;
|
|
|
|
memset(s_out_comm, 0, sizeof(struct scpu_to_ncpu_s));
|
|
memset(s_in_comm, 0, sizeof(struct ncpu_to_scpu_s));
|
|
|
|
s_out_comm->id = SCPU2NCPU_ID;
|
|
s_out_comm->input_count = 0;
|
|
s_out_comm->kp_dbg_checkpoinots = 0x0; // kp inference debug code
|
|
|
|
kmdw_console_set_log_level_scpu(LOG_INFO);
|
|
kmdw_console_set_log_level_ncpu(LOG_ERROR);
|
|
|
|
NVIC_SetVector((IRQn_Type)NCPU_IRQ, (uint32_t)NCPU_IRQHandler);
|
|
NVIC_EnableIRQ((IRQn_Type)NCPU_IRQ);
|
|
|
|
uint32_t mem_len2 = IMAGE_PREPROCESS_BUF_SIZE;
|
|
uint8_t *mem_addr2 = (uint8_t*)kmdw_ddr_reserve(sizeof(uint8_t)*mem_len2);
|
|
kdrv_ncpu_get_output()->input_mem_addr2 = (uint32_t)mem_addr2;
|
|
kdrv_ncpu_get_output()->input_mem_len2 = mem_len2;
|
|
|
|
//allocate the space for inproc array
|
|
uint8_t *mem_addr3 = (uint8_t*)kmdw_ddr_reserve(sizeof(uint32_t)*INPROC_ARRAY_MAX_SIZE);
|
|
kdrv_ncpu_get_output()->inproc_mem_addr = (uint32_t)mem_addr3;
|
|
|
|
ipc_handler_cb = ipc_handler;
|
|
|
|
scu_ipc_enable_to_ncpu_int();
|
|
}
|
|
|
|
struct ncpu_to_scpu_s* kdrv_ncpu_get_input(void)
|
|
{
|
|
return s_in_comm;
|
|
}
|
|
|
|
struct scpu_to_ncpu_s* kdrv_ncpu_get_output(void)
|
|
{
|
|
return s_out_comm;
|
|
}
|
|
|
|
void kdrv_ncpu_set_scpu_debug_lvl(uint32_t lvl)
|
|
{
|
|
s_out_comm->debug_flags = (s_out_comm->debug_flags & ~0x000F0000) | (((lvl) << 16) & 0x000F0000);
|
|
}
|
|
|
|
void kdrv_ncpu_set_ncpu_debug_lvl(uint32_t lvl)
|
|
{
|
|
s_out_comm->debug_flags = (s_out_comm->debug_flags & ~0x0000000F) | ((lvl)&0x0000000F);
|
|
}
|
|
|