enum ia_css_err ia_css_bufq_enqueue_buffer(
int thread_index,
int queue_id,
uint32_t item)
{
enum ia_css_err return_err = IA_CSS_SUCCESS;
ia_css_queue_t *q;
int error;
IA_CSS_ENTER_PRIVATE("queue_id=%d", queue_id);
if ((thread_index >= SH_CSS_MAX_SP_THREADS) || (thread_index < 0) ||
(queue_id == SH_CSS_INVALID_QUEUE_ID))
return IA_CSS_ERR_INVALID_ARGUMENTS;
/* Get the queue for communication */
q = bufq_get_qhandle(sh_css_host2sp_buffer_queue,
queue_id,
thread_index);
if (q != NULL) {
error = ia_css_queue_enqueue(q, item);
return_err = ia_css_convert_errno(error);
} else {
IA_CSS_ERROR("queue is not initialized");
return_err = IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
}
enum ia_css_err ia_css_bufq_dequeue_isys_event(
uint8_t item[BUFQ_EVENT_SIZE])
{
#if !defined(HAS_NO_INPUT_SYSTEM)
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
/* No ENTER/LEAVE in this function since this is polled
* by some test apps. Enablign logging here floods the log
* files which may cause timeouts. */
if (item == NULL)
return IA_CSS_ERR_INVALID_ARGUMENTS;
q = bufq_get_qhandle(sh_css_sp2host_isys_event_queue, -1, -1);
if (q == NULL) {
IA_CSS_ERROR("queue is not initialized");
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
error = ia_css_eventq_recv(q, item);
return_err = ia_css_convert_errno(error);
return return_err;
#else
(void)item;
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
#endif
}
enum ia_css_err ia_css_bufq_dequeue_buffer(
int queue_id,
uint32_t *item)
{
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
IA_CSS_ENTER_PRIVATE("queue_id=%d", queue_id);
if ((item == NULL) ||
(queue_id <= SH_CSS_INVALID_QUEUE_ID) ||
(queue_id >= SH_CSS_MAX_NUM_QUEUES)
)
return IA_CSS_ERR_INVALID_ARGUMENTS;
q = bufq_get_qhandle(sh_css_sp2host_buffer_queue,
queue_id,
-1);
if (q != NULL) {
error = ia_css_queue_dequeue(q, item);
return_err = ia_css_convert_errno(error);
} else {
IA_CSS_ERROR("queue is not initialized");
return_err = IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
}
bool ia_css_refcount_decrement(int32_t id, hrt_vaddress ptr)
{
struct ia_css_refcount_entry *entry;
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
"ia_css_refcount_decrement(%x) 0x%x\n", id, ptr);
if (ptr == mmgr_NULL)
return false;
entry = refcount_find_entry(ptr, false);
if (entry) {
if (entry->id != id) {
ia_css_debug_dtrace(IA_CSS_DEBUG_ERROR,
"ia_css_refcount_decrement(): Ref count IDS do not match!\n");
return false;
}
if (entry->count > 0) {
entry->count -= 1;
if (entry->count == 0) {
/* ia_css_debug_dtrace(IA_CSS_DBEUG_TRACE,
"ia_css_refcount_decrement: freeing\n");*/
mmgr_free(ptr);
entry->data = mmgr_NULL;
entry->id = 0;
}
return true;
}
}
/* SHOULD NOT HAPPEN: ptr not managed by refcount, or not
valid anymore */
if (entry)
IA_CSS_ERROR("id %x, ptr 0x%x entry %p entry->id %x entry->count %d\n",
id, ptr, entry, entry->id, entry->count);
else
IA_CSS_ERROR("entry NULL for ptr 0x%x\n", ptr);
/* assert(false); */
return false;
}
void ia_css_pipeline_map(unsigned int pipe_num, bool map)
{
assert(pipe_num < IA_CSS_PIPELINE_NUM_MAX);
IA_CSS_ENTER_PRIVATE("pipe_num = %d, map = %d", pipe_num, map);
if (pipe_num >= IA_CSS_PIPELINE_NUM_MAX) {
IA_CSS_ERROR("Invalid pipe number");
IA_CSS_LEAVE_PRIVATE("void");
return;
}
if (map)
pipeline_map_num_to_sp_thread(pipe_num);
else
pipeline_unmap_num_to_sp_thread(pipe_num);
IA_CSS_LEAVE_PRIVATE("void");
}
bool ia_css_pipeline_is_mapped(unsigned int key)
{
bool ret = false;
IA_CSS_ENTER_PRIVATE("key = %d", key);
if ((key >= IA_CSS_PIPELINE_NUM_MAX) || (key >= IA_CSS_PIPE_ID_NUM)) {
IA_CSS_ERROR("Invalid key!!");
IA_CSS_LEAVE_PRIVATE("return = %d", false);
return false;
}
ret = (bool)(pipeline_num_to_sp_thread_map[key] != (unsigned)PIPELINE_NUM_UNMAPPED);
IA_CSS_LEAVE_PRIVATE("return = %d", ret);
return ret;
}
/** @brief destroy a pipeline
*
* @param[in] pipeline
* @return None
*
*/
void ia_css_pipeline_destroy(struct ia_css_pipeline *pipeline)
{
assert(pipeline != NULL);
IA_CSS_ENTER_PRIVATE("pipeline = %p", pipeline);
if (pipeline == NULL) {
IA_CSS_ERROR("NULL input parameter");
IA_CSS_LEAVE_PRIVATE("void");
return;
}
IA_CSS_LOG("pipe_num = %d", pipeline->pipe_num);
/* Free the pipeline number */
ia_css_pipeline_clean(pipeline);
IA_CSS_LEAVE_PRIVATE("void");
}
enum ia_css_err ia_css_bufq_enqueue_unlock_raw_buff_msg(
uint32_t exp_id)
{
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
IA_CSS_ENTER_PRIVATE("exposure ID=%d", exp_id);
q = bufq_get_qhandle(sh_css_host2sp_unlock_buff_msg_queue, -1, -1);
if (NULL == q) {
IA_CSS_ERROR("queue is not initialized");
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
error = ia_css_queue_enqueue(q, exp_id);
return_err = ia_css_convert_errno(error);
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
}
enum ia_css_err ia_css_bufq_enqueue_tag_cmd(
uint32_t item)
{
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
IA_CSS_ENTER_PRIVATE("item=%d", item);
q = bufq_get_qhandle(sh_css_host2sp_tag_cmd_queue, -1, -1);
if (NULL == q) {
IA_CSS_ERROR("queue is not initialized");
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
error = ia_css_queue_enqueue(q, item);
return_err = ia_css_convert_errno(error);
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
}
enum ia_css_err ia_css_bufq_enqueue_isys_event(uint8_t evt_id)
{
#if !defined(HAS_NO_INPUT_SYSTEM)
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
IA_CSS_ENTER_PRIVATE("event_id=%d", evt_id);
q = bufq_get_qhandle(sh_css_host2sp_isys_event_queue, -1, -1);
if (q == NULL) {
IA_CSS_ERROR("queue is not initialized");
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
error = ia_css_eventq_send(q, evt_id, 0, 0, 0);
return_err = ia_css_convert_errno(error);
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
#else
(void)evt_id;
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
#endif
}
void ia_css_pipeline_clean(struct ia_css_pipeline *pipeline)
{
struct ia_css_pipeline_stage *s;
assert(pipeline != NULL);
IA_CSS_ENTER_PRIVATE("pipeline = %p", pipeline);
if (pipeline == NULL) {
IA_CSS_ERROR("NULL input parameter");
IA_CSS_LEAVE_PRIVATE("void");
return;
}
s = pipeline->stages;
while (s) {
struct ia_css_pipeline_stage *next = s->next;
pipeline_stage_destroy(s);
s = next;
}
pipeline_init_defaults(pipeline, pipeline->pipe_id, pipeline->pipe_num, pipeline->dvs_frame_delay);
IA_CSS_LEAVE_PRIVATE("void");
}
struct ia_css_shading_table *
ia_css_shading_table_alloc(
unsigned int width,
unsigned int height)
{
unsigned int i;
struct ia_css_shading_table *me;
IA_CSS_ENTER("");
me = sh_css_malloc(sizeof(*me));
if (me == NULL) {
IA_CSS_ERROR("out of memory");
return me;
}
me->width = width;
me->height = height;
me->sensor_width = 0;
me->sensor_height = 0;
me->fraction_bits = 0;
for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) {
me->data[i] =
sh_css_malloc(width * height * sizeof(*me->data[0]));
if (me->data[i] == NULL) {
unsigned int j;
for (j = 0; j < i; j++)
sh_css_free(me->data[j]);
sh_css_free(me);
return NULL;
}
}
IA_CSS_LEAVE("");
return me;
}
enum ia_css_err ia_css_bufq_enqueue_psys_event(
uint8_t evt_id,
uint8_t evt_payload_0,
uint8_t evt_payload_1,
uint8_t evt_payload_2)
{
enum ia_css_err return_err;
int error = 0;
ia_css_queue_t *q;
IA_CSS_ENTER_PRIVATE("evt_id=%d", evt_id);
q = bufq_get_qhandle(sh_css_host2sp_psys_event_queue, -1, -1);
if (NULL == q) {
IA_CSS_ERROR("queue is not initialized");
return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
}
error = ia_css_eventq_send(q,
evt_id, evt_payload_0, evt_payload_1, evt_payload_2);
return_err = ia_css_convert_errno(error);
IA_CSS_LEAVE_ERR_PRIVATE(return_err);
return return_err;
}
enum ia_css_err
sh_css_load_firmware(const char *fw_data,
unsigned int fw_size)
{
unsigned i;
struct ia_css_fw_info *binaries;
struct sh_css_fw_bi_file_h *file_header;
bool valid_firmware = false;
firmware_header = (struct firmware_header *)fw_data;
file_header = (struct sh_css_fw_bi_file_h *)&firmware_header->file_header;
binaries = (struct ia_css_fw_info *)&firmware_header->binary_header;
strncpy(FW_rel_ver_name, file_header->version, min(sizeof(FW_rel_ver_name), sizeof(file_header->version)) - 1);
valid_firmware = sh_css_check_firmware_version(fw_data);
if (!valid_firmware) {
#if (!defined HRT_CSIM && !defined HRT_RTL)
IA_CSS_ERROR("CSS code version (%s) and firmware version (%s) mismatch!",
file_header->version, release_version);
return IA_CSS_ERR_VERSION_MISMATCH;
#endif
} else {
IA_CSS_LOG("successfully load firmware version %s", release_version);
}
/* some sanity checks */
if (!fw_data || fw_size < sizeof(struct sh_css_fw_bi_file_h))
return IA_CSS_ERR_INTERNAL_ERROR;
if (file_header->h_size != sizeof(struct sh_css_fw_bi_file_h))
return IA_CSS_ERR_INTERNAL_ERROR;
sh_css_num_binaries = file_header->binary_nr;
/* Only allocate memory for ISP blob info */
if (sh_css_num_binaries > NUM_OF_SPS) {
sh_css_blob_info = sh_css_malloc(
(sh_css_num_binaries - NUM_OF_SPS) *
sizeof(*sh_css_blob_info));
if (sh_css_blob_info == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
} else {
sh_css_blob_info = NULL;
}
fw_minibuffer = sh_css_malloc(sh_css_num_binaries * sizeof(struct fw_param));
if (fw_minibuffer == NULL)
return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
memset(fw_minibuffer, 0, sh_css_num_binaries * sizeof(struct fw_param));
for (i = 0; i < sh_css_num_binaries; i++) {
struct ia_css_fw_info *bi = &binaries[i];
/* note: the var below is made static as it is quite large;
if it is not static it ends up on the stack which could
cause issues for drivers
*/
static struct ia_css_blob_descr bd;
enum ia_css_err err;
err = sh_css_load_blob_info(fw_data, bi, &bd, i);
if (err != IA_CSS_SUCCESS)
return IA_CSS_ERR_INTERNAL_ERROR;
if (bi->blob.offset + bi->blob.size > fw_size)
return IA_CSS_ERR_INTERNAL_ERROR;
if (bi->type == ia_css_sp_firmware) {
if (i != SP_FIRMWARE)
return IA_CSS_ERR_INTERNAL_ERROR;
err = setup_sp(bi, fw_data, &sh_css_sp_fw, i);
if (err != IA_CSS_SUCCESS)
return err;
#if defined(HAS_SEC_SP)
} else if (bi->type == ia_css_sp1_firmware) {
if (i != SP1_FIRMWARE)
return IA_CSS_ERR_INTERNAL_ERROR;
err = setup_sp(bi, fw_data, &sh_css_sp1_fw, i);
if (err != IA_CSS_SUCCESS)
return err;
#endif /* HAS_SEC_SP */
} else {
/* All subsequent binaries (i>NUM_OF_SPS) are ISP firmware */
if (i < NUM_OF_SPS)
return IA_CSS_ERR_INTERNAL_ERROR;
if (bi->type != ia_css_isp_firmware)
return IA_CSS_ERR_INTERNAL_ERROR;
if (sh_css_blob_info == NULL) /* cannot happen but KW does not see this */
return IA_CSS_ERR_INTERNAL_ERROR;
sh_css_blob_info[i-NUM_OF_SPS] = bd;
}
}
return IA_CSS_SUCCESS;
}
