static void ddl_encoder_eos_done(struct ddl_context *ddl_context) { struct ddl_client_context *ddl; u32 channel_inst_id; vidc_1080p_get_returned_channel_inst_id(&channel_inst_id); vidc_1080p_clear_returned_channel_inst_id(); ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context, ddl_context->response_cmd_ch_id); if (!ddl || (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE))) { DDL_MSG_ERROR("STATE-CRITICAL-EOSFRMDONE"); ddl_client_fatal_cb(ddl); } else { struct ddl_encoder_data *encoder = &(ddl->codec_data.encoder); vidc_1080p_get_encode_frame_info(&encoder->enc_frame_info); ddl_handle_enc_frame_done(ddl); DDL_MSG_LOW("encoder_eos_done"); ddl->cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME; DDL_MSG_LOW("eos_done"); ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE, VCD_S_SUCCESS, NULL, 0, (u32 *)ddl, ddl->client_data); ddl_release_command_channel(ddl_context, ddl->command_channel); } }
static u32 ddl_dpb_buffers_set_done_callback( struct ddl_context *ddl_context) { struct ddl_client_context *ddl; u32 channel_inst_id, ret_status = true; DDL_MSG_MED("ddl_dpb_buffers_set_done_callback"); vidc_1080p_get_returned_channel_inst_id(&channel_inst_id); vidc_1080p_clear_returned_channel_inst_id(); ddl = ddl_get_current_ddl_client_for_command(ddl_context, DDL_CMD_DECODE_SET_DPB); if (ddl) { ddl->cmd_state = DDL_CMD_INVALID; if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPBDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-DPBDONE"); ddl_client_fatal_cb(ddl); } else { DDL_MSG_LOW("INTR_DPBDONE"); DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(ddl->client_state)); if (vidc_msg_timing) { ddl_calc_core_proc_time(__func__, DEC_OP_TIME); ddl_reset_core_time_variables(DEC_OP_TIME); } ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME; ddl_vidc_decode_frame_run(ddl); ret_status = false; } } return ret_status; }
static void ddl_channel_end_callback(struct ddl_context *ddl_context) { struct ddl_client_context *ddl; DDL_MSG_MED("ddl_channel_end_callback"); ddl = ddl_get_current_ddl_client_for_command(ddl_context, DDL_CMD_CHANNEL_END); if (ddl) { ddl->cmd_state = DDL_CMD_INVALID; if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHEND)) { DDL_MSG_LOW("STATE-CRITICAL-CHEND"); } else { DDL_MSG_LOW("CH_END_DONE"); ddl_release_client_internal_buffers(ddl); ddl_context->ddl_callback(VCD_EVT_RESP_STOP, VCD_S_SUCCESS, NULL, 0, (u32 *)ddl, ddl->client_data); DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_OPEN", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_OPEN; } ddl_release_command_channel(ddl_context, ddl->command_channel); } }
static u32 ddl_encoder_seq_done_callback(struct ddl_context_type *p_ddl_context, struct ddl_client_context_type *p_ddl) { struct ddl_encoder_data_type *p_encoder; DDL_MSG_MED("ddl_encoder_seq_done_callback"); if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-INITCODEC"); ddl_client_fatal_cb(p_ddl); return TRUE; } p_ddl->e_cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(p_ddl->e_client_state)); p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_FRAME; DDL_MSG_LOW("INIT_CODEC_DONE"); p_encoder = &p_ddl->codec_data.encoder; vidc_1080p_get_encoder_sequence_header_size( &p_encoder->n_seq_header_length); p_ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *) p_ddl, p_ddl->p_client_data); ddl_release_command_channel(p_ddl_context, p_ddl->n_command_channel); return TRUE; }
static u32 ddl_encoder_seq_done_callback(struct ddl_context *ddl_context, struct ddl_client_context *ddl) { struct ddl_encoder_data *encoder; DDL_MSG_MED("ddl_encoder_seq_done_callback"); if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-INITCODEC"); ddl_client_fatal_cb(ddl); return true; } if (vidc_msg_timing) ddl_calc_core_proc_time(__func__, ENC_OP_TIME); ddl->cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME; DDL_MSG_LOW("INIT_CODEC_DONE"); encoder = &ddl->codec_data.encoder; vidc_1080p_get_encoder_sequence_header_size( &encoder->seq_header_length); if ((encoder->codec.codec == VCD_CODEC_H264) && (encoder->profile.profile == VCD_PROFILE_H264_BASELINE)) if ((encoder->seq_header.align_virtual_addr) && (encoder->seq_header_length > 6)) encoder->seq_header.align_virtual_addr[6] = 0xC0; ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *) ddl, ddl->client_data); ddl_release_command_channel(ddl_context, ddl->command_channel); return true; }
static void ddl_input_failed_cb(struct ddl_client_context_type *p_ddl, u32 vcd_event, u32 vcd_status) { struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context; u32 n_payload_size = sizeof(struct ddl_frame_data_type_tag); p_ddl->e_cmd_state = DDL_CMD_INVALID; if (p_ddl->b_decoding) ddl_vidc_decode_dynamic_property(p_ddl, FALSE); else ddl_vidc_encode_dynamic_property(p_ddl, FALSE); if (p_ddl->e_client_state == DDL_CLIENT_WAIT_FOR_INITCODECDONE) { n_payload_size = 0; DDL_MSG_LOW("ddl_state_transition: %s ~~> " "DDL_CLIENT_WAIT_FOR_INITCODEC", ddl_get_state_string(p_ddl->e_client_state)); p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_INITCODEC; } else { DDL_MSG_LOW("ddl_state_transition: %s ~~> " "DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(p_ddl->e_client_state)); p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_FRAME; } p_ddl_context->ddl_callback(vcd_event, vcd_status, &p_ddl->input_frame, n_payload_size, (u32 *)p_ddl, p_ddl->p_client_data); }
void ddl_set_core_start_time(const char *func_name, u32 index) { u32 act_time; struct timeval ddl_tv; struct time_data *time_data = &proc_time[index]; do_gettimeofday(&ddl_tv); act_time = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000); if (!time_data->ddl_t1) { time_data->ddl_t1 = act_time; DDL_MSG_LOW("\n%s(): Start Time (%u)", func_name, act_time); } else if (vidc_msg_timing) { DDL_MSG_LOW("\n%s(): Timer already started! St(%u) Act(%u)", func_name, time_data->ddl_t1, act_time); } }
u32 ddl_fw_init(struct ddl_buf_addr *dram_base) { u8 *dest_addr; dest_addr = DDL_GET_ALIGNED_VITUAL(*dram_base); DDL_MSG_LOW("FW Addr / FW Size : %x/%d", (u32)vidc_video_codec_fw, vidc_video_codec_fw_size); if (res_trk_check_for_sec_session() && res_trk_is_cp_enabled()) { if (res_trk_enable_footswitch()) { pr_err("Failed to enable footswitch"); return false; } if (res_trk_enable_iommu_clocks()) { res_trk_disable_footswitch(); pr_err("Failed to enable iommu clocks\n"); return false; } dram_base->pil_cookie = pil_get("vidc"); if (res_trk_disable_iommu_clocks()) pr_err("Failed to disable iommu clocks\n"); if (IS_ERR_OR_NULL(dram_base->pil_cookie)) { res_trk_disable_footswitch(); pr_err("pil_get failed\n"); return false; } } else { if (vidc_video_codec_fw_size > dram_base->buffer_size || !vidc_video_codec_fw) return false; memcpy(dest_addr, vidc_video_codec_fw, vidc_video_codec_fw_size); } return true; }
u32 ddl_open(u32 **ddl_handle, u32 decoding) { struct ddl_context *ddl_context; struct ddl_client_context *ddl; void *ptr; u32 status; DDL_MSG_HIGH("ddl_open"); if (!ddl_handle) { DDL_MSG_ERROR("ddl_open:Bad_handle"); return VCD_ERR_BAD_HANDLE; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_open:Not_inited"); return VCD_ERR_ILLEGAL_OP; } status = ddl_client_transact(DDL_GET_CLIENT, &ddl); if (status) { DDL_MSG_ERROR("ddl_open:Client_trasac_failed"); return status; } ptr = ddl_pmem_alloc(&ddl->shared_mem[0], DDL_FW_AUX_HOST_CMD_SPACE_SIZE, sizeof(u32)); if (!ptr) status = VCD_ERR_ALLOC_FAIL; if (!status && ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) { ptr = ddl_pmem_alloc(&ddl->shared_mem[1], DDL_FW_AUX_HOST_CMD_SPACE_SIZE, sizeof(u32)); if (!ptr) { ddl_pmem_free(&ddl->shared_mem[0]); status = VCD_ERR_ALLOC_FAIL; } } if (!status) { memset(ddl->shared_mem[0].align_virtual_addr, 0, DDL_FW_AUX_HOST_CMD_SPACE_SIZE); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) { memset(ddl->shared_mem[1].align_virtual_addr, 0, DDL_FW_AUX_HOST_CMD_SPACE_SIZE); } DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_OPEN", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_OPEN; ddl->codec_data.hdr.decoding = decoding; ddl->decoding = decoding; ddl_set_default_meta_data_hdr(ddl); ddl_set_initial_default_values(ddl); *ddl_handle = (u32 *) ddl; } else { ddl_pmem_free(&ddl->shared_mem[0]); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) ddl_pmem_free(&ddl->shared_mem[1]); ddl_client_transact(DDL_FREE_CLIENT, &ddl); } return status; }
static u32 ddl_eos_frame_done_callback( struct ddl_client_context *ddl) { struct ddl_context *ddl_context = ddl->ddl_context; struct ddl_decoder_data *decoder = &ddl->codec_data.decoder; struct ddl_mask *dpb_mask = &decoder->dpb_mask; u32 ret_status = true, rsl_chg; enum vidc_1080p_display_status disp_status; if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) { DDL_MSG_ERROR("STATE-CRITICAL-EOSFRMRUN"); ddl_client_fatal_cb(ddl); } else { DDL_MSG_LOW("EOS_FRM_RUN_DONE"); ddl->cmd_state = DDL_CMD_INVALID; get_dec_status(&ddl->codec_data.decoder.dec_disp_info, ddl->codec_data.decoder.output_order, &disp_status, &rsl_chg); ddl_vidc_decode_dynamic_property(ddl, false); if (disp_status == VIDC_1080P_DISPLAY_STATUS_DPB_EMPTY) { ddl_decoder_eos_done_callback(ddl); } else { struct vidc_1080p_dec_frame_start_param dec_param; ret_status = false; if (disp_status == VIDC_1080P_DISPLAY_STATUS_DISPLAY_ONLY) { if (ddl_decoder_output_done_callback( ddl, false)) ret_status = true; } else if (disp_status != VIDC_1080P_DISPLAY_STATUS_NOOP) DDL_MSG_ERROR("EOS-STATE-CRITICAL-" "WRONG-DISP-STATUS"); if (!ret_status) { ddl_decoder_dpb_transact(decoder, NULL, DDL_DPB_OP_SET_MASK); ddl->cmd_state = DDL_CMD_EOS; memset(&dec_param, 0, sizeof(dec_param)); dec_param.cmd_seq_num = ++ddl_context->cmd_seq_num; dec_param.inst_id = ddl->instance_id; dec_param.shared_mem_addr_offset = DDL_ADDR_OFFSET( ddl_context->dram_base_a, ddl->shared_mem[ddl->command_channel]); dec_param.release_dpb_bit_mask = dpb_mask->hw_mask; dec_param.decode = VIDC_1080P_DEC_TYPE_LAST_FRAME_DATA; ddl_context->vidc_decode_frame_start[ddl->\ command_channel](&dec_param); } } } return ret_status; }
static void ddl_sys_init_done_callback(struct ddl_context *ddl_context, u32 fw_size) { u32 vcd_status = VCD_S_SUCCESS; u8 *fw_ver; DDL_MSG_MED("ddl_sys_init_done_callback"); if (!DDLCOMMAND_STATE_IS(ddl_context, DDL_CMD_DMA_INIT)) { DDL_MSG_ERROR("UNKNOWN_SYS_INIT_DONE"); } else { ddl_context->cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("SYS_INIT_DONE"); vidc_1080p_get_fw_version(&ddl_context->fw_version); fw_ver = (u8 *)&ddl_context->fw_version; DDL_MSG_ERROR("fw_version %x:%x:20%x", fw_ver[1]&0xFF, fw_ver[0]&0xFF, fw_ver[2]&0xFF); if (ddl_context->fw_memory_size >= fw_size) { ddl_context->device_state = DDL_DEVICE_INITED; vcd_status = VCD_S_SUCCESS; } else vcd_status = VCD_ERR_FAIL; ddl_context->ddl_callback(VCD_EVT_RESP_DEVICE_INIT, vcd_status, NULL, 0, NULL, ddl_context->client_data); DDL_IDLE(ddl_context); } }
u32 ddl_reset_hw(u32 mode) { struct ddl_context *ddl_context; struct ddl_client_context *ddl; u32 i; DDL_MSG_HIGH("ddl_reset_hw"); DDL_MSG_LOW("ddl_reset_hw:called"); ddl_context = ddl_get_context(); ddl_context->cmd_state = DDL_CMD_INVALID; DDL_BUSY(ddl_context); if (ddl_context->core_virtual_base_addr) { vidc_1080p_do_sw_reset(VIDC_1080P_RESET_IN_SEQ_FIRST_STAGE); msleep(DDL_SW_RESET_SLEEP); vidc_1080p_do_sw_reset(VIDC_1080P_RESET_IN_SEQ_SECOND_STAGE); msleep(DDL_SW_RESET_SLEEP); ddl_context->core_virtual_base_addr = NULL; } ddl_context->device_state = DDL_DEVICE_NOTINIT; for (i = 0; i < VCD_MAX_NO_CLIENT; i++) { ddl = ddl_context->ddl_clients[i]; ddl_context->ddl_clients[i] = NULL; if (ddl) { ddl_release_client_internal_buffers(ddl); ddl_client_transact(DDL_FREE_CLIENT, &ddl); } } ddl_release_context_buffers(ddl_context); memset(ddl_context, 0, sizeof(struct ddl_context)); return true; }
u32 ddl_device_release(void *client_data) { struct ddl_context *ddl_context; DDL_MSG_HIGH("ddl_device_release"); ddl_context = ddl_get_context(); if (!DDL_IS_IDLE(ddl_context)) { DDL_MSG_ERROR("ddl_dev_rel:Ddl_busy"); return VCD_ERR_BUSY; } if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dev_rel:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (!ddl_client_transact(DDL_ACTIVE_CLIENT, NULL)) { DDL_MSG_ERROR("ddl_dev_rel:Client_present_err"); return VCD_ERR_CLIENT_PRESENT; } DDL_BUSY(ddl_context); ddl_context->device_state = DDL_DEVICE_NOTINIT; ddl_context->client_data = client_data; ddl_context->cmd_state = DDL_CMD_INVALID; ddl_vidc_core_term(ddl_context); DDL_MSG_LOW("FW_ENDDONE"); ddl_context->core_virtual_base_addr = NULL; ddl_release_context_buffers(ddl_context); ddl_context->video_ion_client = NULL; DDL_IDLE(ddl_context); return VCD_S_SUCCESS; }
static void ddl_print_buffer_port(struct ddl_context *ddl_context, struct ddl_buf_addr *buf, u32 idx, u8 *str) { DDL_MSG_LOW("\n"); ddl_print_buffer(ddl_context, buf, idx, str); ddl_print_port(ddl_context, buf); }
static void ddl_print_buffer(struct ddl_context *ddl_context, struct ddl_buf_addr *buf, u32 idx, u8 *str) { struct ddl_buf_addr *base_ram; s32 offset; size_t sz, KB = 0; base_ram = &ddl_context->dram_base_a; offset = (s32) DDL_ADDR_OFFSET(*base_ram, *buf); sz = buf->buffer_size; if (sz > 0) { if (!(sz % 1024)) { sz /= 1024; KB++; if (!(sz % 1024)) { sz /= 1024; KB++; } } } DDL_MSG_LOW("\n%12s [%2d]: 0x%08x [0x%04x], 0x%08x(%d%s), %s", str, idx, (u32) buf->align_physical_addr, (offset > 0) ? offset : 0, buf->buffer_size, sz, ((2 == KB) ? "MB" : (1 == KB) ? "KB" : ""), (((u32) buf->virtual_base_addr) ? "Alloc" : "")); }
u32 ddl_close(u32 **ddl_handle) { struct ddl_context *ddl_context; struct ddl_client_context **pp_ddl = (struct ddl_client_context **)ddl_handle; DDL_MSG_HIGH("ddl_close"); if (!pp_ddl || !*pp_ddl) { DDL_MSG_ERROR("ddl_close:Bad_handle"); return VCD_ERR_BAD_HANDLE; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_close:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (!DDLCLIENT_STATE_IS(*pp_ddl, DDL_CLIENT_OPEN)) { DDL_MSG_ERROR("ddl_close:Not_in_open_state"); return VCD_ERR_ILLEGAL_OP; } ddl_pmem_free(&(*pp_ddl)->shared_mem[0]); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) ddl_pmem_free(&(*pp_ddl)->shared_mem[1]); DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_INVALID", ddl_get_state_string((*pp_ddl)->client_state)); (*pp_ddl)->client_state = DDL_CLIENT_INVALID; ddl_codec_type_transact(*pp_ddl, true, (enum vcd_codec)0); ddl_client_transact(DDL_FREE_CLIENT, pp_ddl); return VCD_S_SUCCESS; }
static u32 ddl_channel_set_callback(struct ddl_context *ddl_context, u32 instance_id) { struct ddl_client_context *ddl; u32 ret = false; DDL_MSG_MED("ddl_channel_open_callback"); ddl = ddl_get_current_ddl_client_for_command(ddl_context, DDL_CMD_CHANNEL_SET); if (ddl) { ddl->cmd_state = DDL_CMD_INVALID; if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_CHDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-CHSET"); ddl_release_command_channel(ddl_context, ddl->command_channel); } else { DDL_MSG_LOW("CH_SET_DONE"); DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_WAIT_FOR_INITCODEC", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_WAIT_FOR_INITCODEC; ddl->instance_id = instance_id; if (ddl->decoding) { if (vidc_msg_timing) ddl_calc_core_proc_time(__func__, DEC_OP_TIME); if (ddl->codec_data.decoder.header_in_start) ddl_vidc_decode_init_codec(ddl); else { ddl_context->ddl_callback( VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *)ddl, ddl->client_data); ddl_release_command_channel( ddl_context, ddl->command_channel); ret = true; } } else ddl_vidc_encode_init_codec(ddl); } } return ret; }
static void ddl_print_port(struct ddl_context *ddl_context, struct ddl_buf_addr *buf) { struct ddl_buf_addr *a = &ddl_context->dram_base_a; struct ddl_buf_addr *b = &ddl_context->dram_base_b; if (!buf->align_physical_addr || !buf->buffer_size) return; if (buf->align_physical_addr >= a->align_physical_addr && buf->align_physical_addr + buf->buffer_size <= a->align_physical_addr + a->buffer_size) DDL_MSG_LOW(" -A [0x%x]-", DDL_ADDR_OFFSET(*a, *buf)); else if (buf->align_physical_addr >= b->align_physical_addr && buf->align_physical_addr + buf->buffer_size <= b->align_physical_addr + b->buffer_size) DDL_MSG_LOW(" -B [0x%x]-", DDL_ADDR_OFFSET(*b, *buf)); else DDL_MSG_LOW(" -?-"); }
static u32 ddl_channel_set_callback(struct ddl_context_type *p_ddl_context, u32 n_instance_id) { struct ddl_client_context_type *p_ddl; u32 b_ret = FALSE; DDL_MSG_MED("ddl_channel_open_callback"); p_ddl = ddl_get_current_ddl_client_for_command(p_ddl_context, DDL_CMD_CHANNEL_SET); if (p_ddl) { p_ddl->e_cmd_state = DDL_CMD_INVALID; if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_CHDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-CHSET"); ddl_release_command_channel(p_ddl_context, p_ddl->n_command_channel); } else { DDL_MSG_LOW("CH_SET_DONE"); DDL_MSG_LOW("ddl_state_transition: %s ~~>\ DDL_CLIENT_WAIT_FOR_INITCODEC", ddl_get_state_string(p_ddl->e_client_state)); p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_INITCODEC; p_ddl->n_channel_id = n_instance_id; if (p_ddl->b_decoding) { if (p_ddl->codec_data.decoder.b_header_in_start) ddl_vidc_decode_init_codec(p_ddl); else { p_ddl_context->ddl_callback( VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *)p_ddl, p_ddl->p_client_data); ddl_release_command_channel( p_ddl_context, p_ddl->n_command_channel); b_ret = TRUE; } } else ddl_vidc_encode_init_codec(p_ddl); } } return b_ret; }
void ddl_update_core_start_time(const char *func_name, u32 index) { u32 act_time; struct timeval ddl_tv; struct time_data *time_data = &proc_time[index]; do_gettimeofday(&ddl_tv); act_time = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000); time_data->ddl_t1 = act_time; DDL_MSG_LOW("\n%s(): Start time updated Act(%u)", func_name, act_time); }
static void ddl_fw_status_done_callback(struct ddl_context_type *p_ddl_context) { DDL_MSG_MED("ddl_fw_status_done_callback"); if (!DDLCOMMAND_STATE_IS(p_ddl_context, DDL_CMD_DMA_INIT)) { DDL_MSG_ERROR("UNKWN_DMADONE"); } else { DDL_MSG_LOW("FW_STATUS_DONE"); vidc_1080p_set_host2risc_cmd(VIDC_1080P_HOST2RISC_CMD_SYS_INIT, p_ddl_context->n_fw_ctxt_memory_size, 0, 0, 0); } }
static void ddl_encoder_eos_done(struct ddl_context *ddl_context) { struct ddl_client_context *ddl; u32 channel_inst_id; DDL_MSG_LOW("encoder_eos_done"); vidc_1080p_get_returned_channel_inst_id(&channel_inst_id); vidc_1080p_clear_returned_channel_inst_id(); ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context, ddl_context->response_cmd_ch_id); if (ddl) { if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_EOS_DONE)) { DDL_MSG_LOW("ENC_EOS_DONE"); ddl->cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_WAIT_FOR_FRAME", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_WAIT_FOR_FRAME; DDL_MSG_LOW("EOS_DONE"); ddl->output_frame.frm_trans_end = true; ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE, VCD_S_SUCCESS, &(ddl->output_frame), sizeof(struct ddl_frame_data_tag), (u32 *)ddl, ddl->client_data); } else { DDL_MSG_LOW("STATE-CRITICAL-EOSDONE"); } ddl_release_command_channel(ddl_context, ddl->command_channel); } else { DDL_MSG_LOW("Invalid Client DDL context"); } }
void *ddl_pmem_alloc(struct ddl_buf_addr *addr, size_t sz, u32 alignment) { u32 alloc_size, offset = 0; DBG_PMEM("\n%s() IN: Requested alloc size(%u)", __func__, (u32)sz); alloc_size = (sz + alignment); addr->physical_base_addr = (u8 *) pmem_kalloc(alloc_size, PMEM_MEMTYPE_SMI | PMEM_ALIGNMENT_4K); if (!addr->physical_base_addr) { DDL_MSG_ERROR("%s() : pmem alloc failed (%d)\n", __func__, alloc_size); return NULL; } DDL_MSG_LOW("%s() : pmem alloc physical base addr/sz 0x%x / %d\n",\ __func__, (u32)addr->physical_base_addr, alloc_size); addr->virtual_base_addr = (u8 *)ioremap((unsigned long) addr->physical_base_addr, alloc_size); if (!addr->virtual_base_addr) { DDL_MSG_ERROR("%s() : ioremap failed, virtual(%x)\n", __func__, (u32)addr->virtual_base_addr); return NULL; } DDL_MSG_LOW("%s() : pmem alloc virtual base addr/sz 0x%x / %d\n",\ __func__, (u32)addr->virtual_base_addr, alloc_size); addr->align_physical_addr = (u8 *) DDL_ALIGN((u32) addr->physical_base_addr, alignment); offset = (u32)(addr->align_physical_addr - addr->physical_base_addr); addr->align_virtual_addr = addr->virtual_base_addr + offset; addr->buffer_size = sz; DDL_MSG_LOW("\n%s() : alig_phy_addr(%p) alig_vir_addr(%p)", __func__, addr->align_physical_addr, addr->align_virtual_addr); DBG_PMEM("\n%s() OUT: phy_addr(%p) vir_addr(%p) size(%u)", __func__, addr->physical_base_addr, addr->virtual_base_addr, addr->buffer_size); return addr->virtual_base_addr; }
u32 ddl_fw_init(struct ddl_buf_addr *dram_base) { u8 *dest_addr; dest_addr = DDL_GET_ALIGNED_VITUAL(*dram_base); if (vidc_video_codec_fw_size > dram_base->buffer_size || !vidc_video_codec_fw) return false; DDL_MSG_LOW("FW Addr / FW Size : %x/%d", (u32)vidc_video_codec_fw, vidc_video_codec_fw_size); memcpy(dest_addr, vidc_video_codec_fw, vidc_video_codec_fw_size); return true; }
static void ddl_edfu_callback(struct ddl_context *ddl_context) { struct ddl_client_context *ddl; u32 channel_inst_id; DDL_MSG_MED("ddl_edfu_callback"); vidc_1080p_get_returned_channel_inst_id(&channel_inst_id); vidc_1080p_clear_returned_channel_inst_id(); ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context, ddl_context->response_cmd_ch_id); if (ddl) { if (ddl->cmd_state != DDL_CMD_ENCODE_FRAME) DDL_MSG_LOW("UNKWN_EDFU"); } }
static void get_dec_op_done_crop(u32 output_order, struct vidc_1080p_dec_disp_info *dec_disp_info, struct vcd_frame_rect *crop_data, struct vcd_property_frame_size *op_frame_sz, struct vcd_property_frame_size *frame_sz, struct ddl_buf_addr *shared_mem) { u32 crop_exists = (output_order == VCD_DEC_ORDER_DECODE) ? dec_disp_info->dec_crop_exists : dec_disp_info->disp_crop_exists; crop_data->left = 0; crop_data->top = 0; crop_data->right = dec_disp_info->img_size_x; crop_data->bottom = dec_disp_info->img_size_y; op_frame_sz->width = dec_disp_info->img_size_x; op_frame_sz->height = dec_disp_info->img_size_y; ddl_calculate_stride(op_frame_sz, false); op_frame_sz->stride = DDL_ALIGN(op_frame_sz->width, DDL_TILE_ALIGN_WIDTH); op_frame_sz->scan_lines = DDL_ALIGN(op_frame_sz->height, DDL_TILE_ALIGN_HEIGHT); DDL_MSG_LOW("%s img_size_x = %u img_size_y = %u\n", __func__, dec_disp_info->img_size_x, dec_disp_info->img_size_y); if (crop_exists) { if (output_order == VCD_DEC_ORDER_DECODE) vidc_sm_get_dec_order_crop_info(shared_mem, &dec_disp_info->crop_left_offset, &dec_disp_info->crop_right_offset, &dec_disp_info->crop_top_offset, &dec_disp_info->crop_bottom_offset); else vidc_sm_get_crop_info(shared_mem, &dec_disp_info->crop_left_offset, &dec_disp_info->crop_right_offset, &dec_disp_info->crop_top_offset, &dec_disp_info->crop_bottom_offset); crop_data->left = dec_disp_info->crop_left_offset; crop_data->top = dec_disp_info->crop_top_offset; crop_data->right -= dec_disp_info->crop_right_offset; crop_data->bottom -= dec_disp_info->crop_bottom_offset; op_frame_sz->width = crop_data->right - crop_data->left; op_frame_sz->height = crop_data->bottom - crop_data->top; } }
void ddl_client_fatal_cb(struct ddl_client_context_type *p_ddl) { struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context; if (p_ddl->e_cmd_state == DDL_CMD_DECODE_FRAME) ddl_vidc_decode_dynamic_property(p_ddl, FALSE); else if (p_ddl->e_cmd_state == DDL_CMD_ENCODE_FRAME) ddl_vidc_encode_dynamic_property(p_ddl, FALSE); p_ddl->e_cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_FAVIDC_ERROR", ddl_get_state_string(p_ddl->e_client_state)); p_ddl->e_client_state = DDL_CLIENT_FAVIDC_ERROR; p_ddl_context->ddl_callback(VCD_EVT_IND_HWERRFATAL, VCD_ERR_CLIENT_FATAL, NULL, 0, (u32 *)p_ddl, p_ddl->p_client_data); ddl_release_command_channel(p_ddl_context, p_ddl->n_command_channel); }
u32 ddl_process_core_response(void) { struct ddl_context *ddl_context; struct ddl_hw_interface *ddl_hw_response; u32 status = false; ddl_context = ddl_get_context(); if (!ddl_context->core_virtual_base_addr) { DDL_MSG_LOW("SPURIOUS_INTERRUPT"); return status; } ddl_hw_response = &ddl_context->ddl_hw_response; status = ddl_process_intr_status(ddl_context, ddl_hw_response->cmd); if (ddl_context->interrupt_clr) (*ddl_context->interrupt_clr)(); return status; }
static u32 ddl_process_intr_status(struct ddl_context *ddl_context, u32 intr_status) { u32 return_status = true; switch (intr_status) { case VIDC_1080P_RISC2HOST_CMD_OPEN_CH_RET: return_status = ddl_channel_set_callback(ddl_context, ddl_context->response_cmd_ch_id); break; case VIDC_1080P_RISC2HOST_CMD_CLOSE_CH_RET: ddl_channel_end_callback(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_SEQ_DONE_RET: return_status = ddl_sequence_done_callback(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_FRAME_DONE_RET: return_status = ddl_frame_run_callback(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_SYS_INIT_RET: ddl_sys_init_done_callback(ddl_context, ddl_context->response_cmd_ch_id); break; case VIDC_1080P_RISC2HOST_CMD_FW_STATUS_RET: ddl_fw_status_done_callback(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_EDFU_INT_RET: ddl_edfu_callback(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_ENC_COMPLETE_RET: ddl_encoder_eos_done(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_ERROR_RET: DDL_MSG_ERROR("CMD_ERROR_INTR"); return_status = ddl_handle_core_errors(ddl_context); break; case VIDC_1080P_RISC2HOST_CMD_INIT_BUFFERS_RET: return_status = ddl_dpb_buffers_set_done_callback(ddl_context); break; default: DDL_MSG_LOW("UNKWN_INTR"); break; } return return_status; }
static void ddl_decoder_eos_done_callback( struct ddl_client_context_type *p_ddl) { struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context; if (!p_ddl->b_decoding) { DDL_MSG_ERROR("STATE-CRITICAL-EOSDONE"); ddl_client_fatal_cb(p_ddl); } else { p_ddl->e_client_state = DDL_CLIENT_WAIT_FOR_FRAME; DDL_MSG_LOW("EOS_DONE"); p_ddl_context->ddl_callback(VCD_EVT_RESP_EOS_DONE, VCD_S_SUCCESS, NULL, 0, (u32 *)p_ddl, p_ddl->p_client_data); ddl_release_command_channel(p_ddl_context, p_ddl->n_command_channel); } }