自学教程：C++ DDL_MSG_ERROR函数代码示例

static int res_trk_pmem_alloc	(struct ddl_buf_addr *addr, size_t sz, u32 alignment){	u32 alloc_size;	struct ddl_context *ddl_context;	int rc = 0;	DBG_PMEM("/n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);	if (!addr) {		DDL_MSG_ERROR("/n%s() Invalid Parameters", __func__);		rc = -EINVAL;		goto bail_out;	}	ddl_context = ddl_get_context();	res_trk_set_mem_type(addr->mem_type);	alloc_size = (sz + alignment);	if (res_trk_get_enable_ion()) {		if (!res_trk_is_cp_enabled() ||			 !res_trk_check_for_sec_session()) {			if (!ddl_context->video_ion_client)				ddl_context->video_ion_client =					res_trk_get_ion_client();			if (!ddl_context->video_ion_client) {				DDL_MSG_ERROR(				"%s() :DDL ION Client Invalid handle/n",						__func__);				rc = -ENOMEM;				goto bail_out;			}			alloc_size = (alloc_size+4095) & ~4095;			addr->alloc_handle = ion_alloc(					ddl_context->video_ion_client,					 alloc_size, SZ_4K,					res_trk_get_mem_type());			if (IS_ERR_OR_NULL(addr->alloc_handle)) {				DDL_MSG_ERROR("%s() :DDL ION alloc failed/n",						__func__);				rc = -ENOMEM;				goto bail_out;			}		} else {			addr->alloc_handle = NULL;			addr->alloced_phys_addr = PIL_FW_BASE_ADDR;			addr->buffer_size = sz;		}	} else {		addr->alloced_phys_addr = (phys_addr_t)			allocate_contiguous_memory_nomap(alloc_size,					res_trk_get_mem_type(), SZ_4K);		if (!addr->alloced_phys_addr) {			DDL_MSG_ERROR("%s() : acm alloc failed (%d)/n",					__func__, alloc_size);			rc = -ENOMEM;			goto bail_out;		}		addr->buffer_size = sz;		return rc;	}bail_out:	return rc;}

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);	}}

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;}

void *ddl_pmem_alloc(struct ddl_buf_addr *addr, size_t sz, u32 alignment){	u32 alloc_size, offset = 0, flags = 0;	u32 index = 0;	struct ddl_context *ddl_context;	struct msm_mapped_buffer *mapped_buffer = NULL;	DBG_PMEM("/n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);	if (!addr) {		DDL_MSG_ERROR("/n%s() Invalid Parameters", __func__);		goto bail_out;	}	ddl_context = ddl_get_context();	alloc_size = (sz + alignment);	addr->alloced_phys_addr = (phys_addr_t)	allocate_contiguous_memory_nomap(alloc_size,		res_trk_get_mem_type(), SZ_4K);	if (!addr->alloced_phys_addr) {		DDL_MSG_ERROR("%s() : acm alloc failed (%d)/n", __func__,			alloc_size);		goto bail_out;	}	flags = MSM_SUBSYSTEM_MAP_IOVA | MSM_SUBSYSTEM_MAP_KADDR;	if (alignment == DDL_KILO_BYTE(128))			index = 1;	else if (alignment > SZ_4K)		flags |= MSM_SUBSYSTEM_ALIGN_IOVA_8K;	addr->mapped_buffer =	msm_subsystem_map_buffer((unsigned long)addr->alloced_phys_addr,	alloc_size, flags, &vidc_mmu_subsystem[index],	sizeof(vidc_mmu_subsystem[index])/sizeof(unsigned int));	if (IS_ERR(addr->mapped_buffer)) {		pr_err(" %s() buffer map failed", __func__);		goto free_acm_alloc;	}	mapped_buffer = addr->mapped_buffer;	if (!mapped_buffer->vaddr || !mapped_buffer->iova[0]) {		pr_err("%s() map buffers failed/n", __func__);		goto free_map_buffers;	}	addr->physical_base_addr = (u8 *)mapped_buffer->iova[0];	addr->virtual_base_addr = mapped_buffer->vaddr;	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;	return addr->virtual_base_addr;free_map_buffers:	msm_subsystem_unmap_buffer(addr->mapped_buffer);	addr->mapped_buffer = NULL;free_acm_alloc:	free_contiguous_memory_by_paddr(		(unsigned long)addr->alloced_phys_addr);	addr->alloced_phys_addr = (phys_addr_t)NULL;bail_out:	return NULL;}

u32 ddl_set_property(u32 *ddl_handle,	struct vcd_property_hdr *property_hdr, void *property_value){	struct ddl_context *ddl_context;	struct ddl_client_context *ddl =		(struct ddl_client_context *) ddl_handle;	u32 vcd_status;	DDL_MSG_HIGH("ddl_set_property");	if (!property_hdr || !property_value) {		DDL_MSG_ERROR("ddl_set_prop:Bad_argument");		return VCD_ERR_ILLEGAL_PARM;	}	ddl_context = ddl_get_context();	if (!DDL_IS_INITIALIZED(ddl_context)) {		DDL_MSG_ERROR("ddl_set_prop:Not_inited");		return VCD_ERR_ILLEGAL_OP;	}	if (!ddl) {		DDL_MSG_ERROR("ddl_set_prop:Bad_handle");		return VCD_ERR_BAD_HANDLE;	}	if (ddl->decoding)		vcd_status = ddl_set_dec_property(ddl, property_hdr,				property_value);	else		vcd_status = ddl_set_enc_property(ddl, property_hdr,				property_value);	if (vcd_status)		DDL_MSG_ERROR("ddl_set_prop:FAILED");	return vcd_status;}

static u32 ddl_handle_client_fatal_errors(	struct ddl_client_context_type *p_ddl){	struct ddl_context_type *p_ddl_context = p_ddl->p_ddl_context;	u32 b_status = FALSE;	switch (p_ddl_context->n_cmd_err_status) {	case VIDC_1080P_ERROR_UNSUPPORTED_FEATURE_IN_PROFILE:	case VIDC_1080P_ERROR_RESOLUTION_NOT_SUPPORTED:	case VIDC_1080P_ERROR_FRAME_RATE_NOT_SUPPORTED:	case VIDC_1080P_ERROR_INVALID_QP_VALUE:	case VIDC_1080P_ERROR_INVALID_RC_REACTION_COEFFICIENT:	case VIDC_1080P_ERROR_INVALID_CPB_SIZE_AT_GIVEN_LEVEL:	case VIDC_1080P_ERROR_ALLOC_DPB_SIZE_NOT_SUFFICIENT:	case VIDC_1080P_ERROR_NUM_DPB_OUT_OF_RANGE:	case VIDC_1080P_ERROR_NULL_METADATA_INPUT_POINTER:	case VIDC_1080P_ERROR_NULL_DPB_POINTER:	case VIDC_1080P_ERROR_NULL_OTH_EXT_BUFADDR:	case VIDC_1080P_ERROR_NULL_MV_POINTER:		b_status = TRUE;		DDL_MSG_ERROR("VIDC_CLIENT_FATAL!!");	break;	default:	break;	}	if (!b_status)		DDL_MSG_ERROR("VIDC_UNKNOWN_OP_FAILED");	ddl_client_fatal_cb(p_ddl);	return TRUE;}

static void *res_trk_pmem_alloc	(struct ddl_buf_addr *addr, size_t sz, u32 alignment){	u32 alloc_size;	struct ddl_context *ddl_context;	DBG_PMEM("/n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);	if (!addr) {		DDL_MSG_ERROR("/n%s() Invalid Parameters", __func__);		goto bail_out;	}	ddl_context = ddl_get_context();	res_trk_set_mem_type(addr->mem_type);	alloc_size = (sz + alignment);	if (res_trk_get_enable_ion()) {		if (!ddl_context->video_ion_client)			ddl_context->video_ion_client =				res_trk_get_ion_client();		if (!ddl_context->video_ion_client) {			DDL_MSG_ERROR("%s() :DDL ION Client Invalid handle/n",						 __func__);			goto bail_out;		}		alloc_size = (alloc_size+4095) & ~4095;		addr->alloc_handle = ion_alloc(		ddl_context->video_ion_client, alloc_size, SZ_4K,			res_trk_get_mem_type());		if (IS_ERR_OR_NULL(addr->alloc_handle)) {			DDL_MSG_ERROR("%s() :DDL ION alloc failed/n",						 __func__);			goto free_acm_ion_alloc;		}		return (void *) addr->alloc_handle;	} else {		addr->alloced_phys_addr = (phys_addr_t)		allocate_contiguous_memory_nomap(alloc_size,			res_trk_get_mem_type(), SZ_4K);		if (!addr->alloced_phys_addr) {			DDL_MSG_ERROR("%s() : acm alloc failed (%d)/n",					 __func__, alloc_size);			goto bail_out;		}		addr->buffer_size = sz;		return (void *)addr->alloced_phys_addr;	}free_acm_ion_alloc:	if (ddl_context->video_ion_client) {		if (addr->alloc_handle) {			ion_free(ddl_context->video_ion_client,				addr->alloc_handle);			addr->alloc_handle = NULL;		}	}bail_out:	return NULL;}

static void res_trk_pmem_free(struct ddl_buf_addr *addr){	struct ddl_context *ddl_context;	if (!addr) {		DDL_MSG_ERROR("/n%s() NULL address", __func__);		return;	}	ddl_context = ddl_get_context();	if (ddl_context->video_ion_client) {		if (addr->alloc_handle) {			ion_free(ddl_context->video_ion_client,			 addr->alloc_handle);			addr->alloc_handle = NULL;		}	} else {		if (addr->mapped_buffer)			msm_subsystem_unmap_buffer(addr->mapped_buffer);		if (addr->alloced_phys_addr)			free_contiguous_memory_by_paddr(			(unsigned long)addr->alloced_phys_addr);	}	memset(addr, 0 , sizeof(struct ddl_buf_addr));}

static void ddl_handle_npf_decoding_error(struct ddl_client_context_type *p_ddl){	struct vidc_1080p_dec_disp_info_type *p_dec_disp_info =		&(p_ddl->codec_data.decoder.dec_disp_info);	if (!p_ddl->b_decoding) {		DDL_MSG_ERROR("VIDC_FW_ISSUE_ENC_NPF");		ddl_client_fatal_cb(p_ddl);	} else {		vidc_sm_get_frame_tags(			&p_ddl->shared_mem[p_ddl->n_command_channel],			&p_dec_disp_info->n_tag_top,			&p_dec_disp_info->n_tag_bottom);		ddl_vidc_decode_dynamic_property(p_ddl, FALSE);		p_ddl->output_frame.vcd_frm.n_ip_frm_tag =			p_dec_disp_info->n_tag_top;		p_ddl->output_frame.vcd_frm.p_physical = NULL;		p_ddl->output_frame.vcd_frm.p_virtual = NULL;		p_ddl->output_frame.b_frm_trans_end = FALSE;		p_ddl->p_ddl_context->ddl_callback(VCD_EVT_RESP_OUTPUT_DONE,			VCD_ERR_INTRLCD_FIELD_DROP, &(p_ddl->output_frame),			sizeof(struct ddl_frame_data_type_tag),			(u32 *) p_ddl, p_ddl->p_client_data);		ddl_vidc_decode_frame_run(p_ddl);	}}

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_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_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_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 u32 ddl_get_decoded_frame(struct vcd_frame_data  *frame,	enum vidc_1080p_decode_frame frame_type){	u32 status = true;	switch (frame_type) {	case VIDC_1080P_DECODE_FRAMETYPE_I:		frame->flags |= VCD_FRAME_FLAG_SYNCFRAME;		frame->frame = VCD_FRAME_I;	break;	case VIDC_1080P_DECODE_FRAMETYPE_P:		frame->frame = VCD_FRAME_P;	break;	case VIDC_1080P_DECODE_FRAMETYPE_B:		frame->frame = VCD_FRAME_B;	break;	case VIDC_1080P_DECODE_FRAMETYPE_NOT_CODED:		frame->frame = VCD_FRAME_NOTCODED;		frame->data_len = 0;		DDL_MSG_HIGH("DDL_INFO:Decoder:NotCodedFrame>");	break;	case VIDC_1080P_DECODE_FRAMETYPE_OTHERS:		frame->frame = VCD_FRAME_YUV;	break;	case VIDC_1080P_DECODE_FRAMETYPE_32BIT:	default:		DDL_MSG_ERROR("UNKNOWN-FRAMETYPE");		status = false;	break;	}	return status;}

u32 ddl_get_property(u32 *ddl_handle,	struct vcd_property_hdr *property_hdr, void *property_value){	struct ddl_context *ddl_context;	struct ddl_client_context *ddl =		(struct ddl_client_context *) ddl_handle;	u32 vcd_status = VCD_ERR_ILLEGAL_PARM;	DDL_MSG_HIGH("ddl_get_property");	if (!property_hdr || !property_value)		return VCD_ERR_ILLEGAL_PARM;	if (property_hdr->prop_id == DDL_I_CAPABILITY) {		if (sizeof(struct ddl_property_capability) ==			property_hdr->sz) {			struct ddl_property_capability *ddl_capability =				(struct ddl_property_capability *)				property_value;			ddl_capability->max_num_client = VCD_MAX_NO_CLIENT;			ddl_capability->exclusive = VCD_COMMAND_EXCLUSIVE;			ddl_capability->frame_command_depth =				VCD_FRAME_COMMAND_DEPTH;			ddl_capability->general_command_depth =				VCD_GENEVIDC_COMMAND_DEPTH;			ddl_capability->ddl_time_out_in_ms =				DDL_HW_TIMEOUT_IN_MS;			vcd_status = VCD_S_SUCCESS;		}		return vcd_status;	}	ddl_context = ddl_get_context();	if (!DDL_IS_INITIALIZED(ddl_context))		return VCD_ERR_ILLEGAL_OP;	if (!ddl)		return VCD_ERR_BAD_HANDLE;	if (ddl->decoding)		vcd_status = ddl_get_dec_property(ddl, property_hdr,				property_value);	else		vcd_status = ddl_get_enc_property(ddl, property_hdr,				property_value);	if (vcd_status)		DDL_MSG_ERROR("ddl_get_prop:FAILED");	else		DDL_MSG_ERROR("ddl_get_prop:SUCCESS");	return vcd_status;}

u32 ddl_handle_core_errors(struct ddl_context_type *p_ddl_context){	struct ddl_client_context_type *p_ddl;	u32 n_channel_inst_id, b_status = FALSE;	if (!p_ddl_context->n_cmd_err_status &&		!p_ddl_context->n_disp_pic_err_status) {		DDL_MSG_ERROR("VIDC_NO_ERROR");	} else {		vidc_1080p_get_returned_channel_inst_id(&n_channel_inst_id);		vidc_1080p_clear_returned_channel_inst_id();		p_ddl = ddl_get_current_ddl_client_for_channel_id(p_ddl_context,			p_ddl_context->n_response_cmd_ch_id);		if (!p_ddl) {			DDL_MSG_ERROR("VIDC_SPURIOUS_INTERRUPT_ERROR");			b_status = TRUE;		} else {			u32 b_disp_status;			if (p_ddl_context->n_cmd_err_status)				print_core_errors(					p_ddl_context->n_cmd_err_status);			if (p_ddl_context->n_disp_pic_err_status)				print_core_errors(					p_ddl_context->n_disp_pic_err_status);			b_status = ddl_handle_core_warnings(				p_ddl_context->n_cmd_err_status);			b_disp_status = ddl_handle_core_warnings(				p_ddl_context->n_disp_pic_err_status);			if (!b_status && !b_disp_status) {				DDL_MSG_ERROR("ddl_warning:Unknown");				b_status = ddl_handle_hw_fatal_errors(p_ddl);				if (!b_status)					b_status =					ddl_handle_core_recoverable_errors(						p_ddl);				if (!b_status)					b_status =					ddl_handle_client_fatal_errors(p_ddl);			}		}	}	return b_status;}

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);	}}

u32 ddl_encode_start(u32 *ddl_handle, void *client_data){	struct ddl_client_context *ddl =		(struct ddl_client_context *) ddl_handle;	struct ddl_context *ddl_context;	struct ddl_encoder_data *encoder;	void *ptr;	u32 status = VCD_S_SUCCESS;	DDL_MSG_HIGH("ddl_encode_start");#ifdef DDL_PROFILE	if (first_time < 2) {		ddl_reset_time_variables(1);		first_time++;	 }	ddl_get_core_start_time(1);#endif	ddl_context = ddl_get_context();	if (!DDL_IS_INITIALIZED(ddl_context)) {		DDL_MSG_ERROR("ddl_enc_start:Not_inited");		return VCD_ERR_ILLEGAL_OP;	}	if (DDL_IS_BUSY(ddl_context)) {		DDL_MSG_ERROR("ddl_enc_start:Ddl_busy");		return VCD_ERR_BUSY;	}	if (!ddl || ddl->decoding) {		DDL_MSG_ERROR("ddl_enc_start:Bad_handle");		return VCD_ERR_BAD_HANDLE;	}	if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN)) {		DDL_MSG_ERROR("ddl_enc_start:Not_opened");		return VCD_ERR_ILLEGAL_OP;	}	if (!ddl_encoder_ready_to_start(ddl)) {		DDL_MSG_ERROR("ddl_enc_start:Err_param_settings");		return VCD_ERR_ILLEGAL_OP;	}	encoder = &ddl->codec_data.encoder;	status = ddl_allocate_enc_hw_buffers(ddl);	if (status)		return status;#ifdef DDL_BUF_LOG	ddl_list_buffers(ddl);#endif	ptr = ddl_pmem_alloc(&encoder->seq_header,		DDL_ENC_SEQHEADER_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES);	if (!ptr) {		ddl_free_enc_hw_buffers(ddl);		DDL_MSG_ERROR("ddl_enc_start:Seq_hdr_alloc_failed");		return VCD_ERR_ALLOC_FAIL;	}	if (!ddl_take_command_channel(ddl_context, ddl, client_data))		return VCD_ERR_BUSY;	ddl_vidc_channel_set(ddl);	return status;}

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_decoder_ready_to_start(struct ddl_client_context *ddl,	struct vcd_sequence_hdr  *header){	struct ddl_decoder_data *decoder =		&(ddl->codec_data.decoder);	if (!decoder->codec.codec) {		DDL_MSG_ERROR("ddl_dec_start_check:Codec_not_set");		return false;	}	if ((!header) && (!decoder->client_frame_size.height ||		!decoder->client_frame_size.width)) {		DDL_MSG_ERROR("ddl_dec_start_check:/			Client_height_width_default");		return false;	}

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 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);	}}

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;}