static u32 vcd_decode_start_in_open
(struct vcd_clnt_ctxt *cctxt,
struct vcd_sequence_hdr *seq_hdr)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_decode_start_in_open:");
if (!cctxt->decoding) {
VCD_MSG_ERROR("vcd_decode_init for encoder client");
return VCD_ERR_ILLEGAL_OP;
}
if (seq_hdr) {
VCD_MSG_HIGH("Seq hdr supplied. len = %d",
seq_hdr->sequence_header_len);
rc = vcd_store_seq_hdr(cctxt, seq_hdr);
} else {
VCD_MSG_HIGH("Seq hdr not supplied");
cctxt->seq_hdr.sequence_header_len = 0;
cctxt->seq_hdr.sequence_header = NULL;
}
VCD_FAILED_RETURN(rc, "Err processing seq hdr");
rc = vcd_process_cmd_sess_start(cctxt);
if (!VCD_FAILED(rc)) {
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_STARTING,
CLIENT_STATE_EVENT_NUMBER
(decode_start));
}
return rc;
}
static u32 vcd_resume_in_paused(struct vcd_clnt_ctxt *cctxt)
{
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_resume_in_paused:");
if (cctxt->sched_clnt_hdl) {
rc = vcd_power_event(cctxt->dev_ctxt,
cctxt, VCD_EVT_PWR_CLNT_RESUME);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_RESUME failed");
} else {
rc = vcd_sched_suspend_resume_clnt(cctxt, true);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("rc = 0x%x. Failed: "
"vcd_sched_suspend_resume_clnt",
rc);
}
}
if (!VCD_FAILED(rc)) {
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_RUN,
CLIENT_STATE_EVENT_NUMBER
(resume));
vcd_try_submit_frame(dev_ctxt);
}
} else {
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_RUN,
CLIENT_STATE_EVENT_NUMBER
(resume));
}
return rc;
}
static u32 vcd_close_in_ready
(struct vcd_drv_ctxt *drv_ctxt,
struct vcd_clnt_ctxt *cctxt) {
u32 rc;
VCD_MSG_LOW("vcd_close_in_dev_ready:");
if (cctxt->clnt_state.state_table->ev_hdlr.close) {
rc = cctxt->clnt_state.state_table->ev_hdlr.
close(cctxt);
} else {
VCD_MSG_ERROR("Unsupported API in client state %d",
cctxt->clnt_state.state);
rc = VCD_ERR_BAD_STATE;
}
if (!VCD_FAILED(rc))
vcd_handle_for_last_clnt_close(&drv_ctxt->dev_ctxt, true);
return rc;
}
static u32 vcd_close_in_ready
(struct vcd_drv_ctxt_type_t *p_drv_ctxt,
struct vcd_clnt_ctxt_type_t *p_cctxt) {
u32 rc;
VCD_MSG_LOW("vcd_close_in_dev_ready:");
if (p_cctxt->clnt_state.p_state_table->ev_hdlr.pf_close) {
rc = p_cctxt->clnt_state.p_state_table->ev_hdlr.
pf_close(p_cctxt);
} else {
VCD_MSG_ERROR("Unsupported API in client state %d",
p_cctxt->clnt_state.e_state);
rc = VCD_ERR_BAD_STATE;
}
if (!VCD_FAILED(rc))
vcd_handle_for_last_clnt_close(&p_drv_ctxt->dev_ctxt, TRUE);
return rc;
}
static u32 vcd_pause_in_run(struct vcd_clnt_ctxt *cctxt)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_pause_in_run:");
if (cctxt->sched_clnt_hdl) {
rc = vcd_sched_suspend_resume_clnt(cctxt, false);
VCD_FAILED_RETURN(rc, "Failed: vcd_sched_suspend_resume_clnt");
}
if (cctxt->status.frame_submitted > 0) {
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_PAUSING,
CLIENT_STATE_EVENT_NUMBER
(pause));
} else {
VCD_MSG_HIGH("No client frames are currently being processed");
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_PAUSED,
CLIENT_STATE_EVENT_NUMBER
(pause));
cctxt->callback(VCD_EVT_RESP_PAUSE,
VCD_S_SUCCESS,
NULL, 0, cctxt, cctxt->client_data);
rc = vcd_power_event(cctxt->dev_ctxt, cctxt,
VCD_EVT_PWR_CLNT_PAUSE);
if (VCD_FAILED(rc))
VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_PAUSE_END failed");
}
return VCD_S_SUCCESS;
}
static u32 vcd_close_in_dev_invalid(struct vcd_drv_ctxt *drv_ctxt,
struct vcd_clnt_ctxt *cctxt)
{
u32 rc;
VCD_MSG_LOW("vcd_close_in_dev_invalid:");
if (cctxt->clnt_state.state_table->ev_hdlr.close) {
rc = cctxt->clnt_state.state_table->
ev_hdlr.close(cctxt);
} else {
VCD_MSG_ERROR("Unsupported API in client state %d",
cctxt->clnt_state.state);
rc = VCD_ERR_BAD_STATE;
}
if (!VCD_FAILED(rc) && !drv_ctxt->dev_ctxt.
cctxt_list_head) {
VCD_MSG_HIGH("All INVALID clients are closed");
vcd_do_device_state_transition(drv_ctxt,
VCD_DEVICE_STATE_NOT_INIT,
DEVICE_STATE_EVENT_NUMBER(close));
}
return rc;
}
static u32 vcd_flush_cmn(struct vcd_clnt_ctxt_type_t *p_cctxt, u32 n_mode)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_flush_cmn in %d:", p_cctxt->clnt_state.e_state);
rc = vcd_flush_buffers(p_cctxt, n_mode);
VCD_FAILED_RETURN(rc, "Failed: vcd_flush_buffers");
if (p_cctxt->status.n_frame_submitted > 0) {
vcd_do_client_state_transition(p_cctxt,
VCD_CLIENT_STATE_FLUSHING,
CLIENT_STATE_EVENT_NUMBER
(pf_flush));
} else {
VCD_MSG_HIGH("All buffers are flushed");
p_cctxt->status.n_flush_mode = n_mode;
vcd_send_flush_done(p_cctxt, VCD_S_SUCCESS);
}
return rc;
}
void vcd_handle_device_err_fatal(struct vcd_dev_ctxt_type *p_dev_ctxt,
struct vcd_clnt_ctxt_type_t *p_trig_clnt)
{
struct vcd_clnt_ctxt_type_t *p_cctxt = p_dev_ctxt->p_cctxt_list_head;
struct vcd_clnt_ctxt_type_t *p_tmp_clnt = NULL;
VCD_MSG_LOW("vcd_handle_device_err_fatal:");
while (p_cctxt) {
p_tmp_clnt = p_cctxt;
p_cctxt = p_cctxt->p_next;
if (p_tmp_clnt != p_trig_clnt)
vcd_clnt_handle_device_err_fatal(p_tmp_clnt,
VCD_EVT_IND_HWERRFATAL);
}
p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_RESET;
if (!p_dev_ctxt->p_cctxt_list_head)
vcd_do_device_state_transition(vcd_get_drv_context(),
VCD_DEVICE_STATE_NOT_INIT,
DEVICE_STATE_EVENT_NUMBER(pf_timeout));
else
vcd_do_device_state_transition(vcd_get_drv_context(),
VCD_DEVICE_STATE_INVALID,
DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));
}
static u32 vcd_flush_cmn(struct vcd_clnt_ctxt *cctxt, u32 mode)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_flush_cmn in %d:", cctxt->clnt_state.state);
rc = vcd_flush_buffers(cctxt, mode);
VCD_FAILED_RETURN(rc, "Failed: vcd_flush_buffers");
if (cctxt->status.frame_submitted > 0) {
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_FLUSHING,
CLIENT_STATE_EVENT_NUMBER
(flush));
} else {
VCD_MSG_HIGH("All buffers are flushed");
cctxt->status.mask |= (mode & VCD_FLUSH_ALL);
vcd_send_flush_done(cctxt, VCD_S_SUCCESS);
}
return rc;
}
void vcd_handle_device_err_fatal(struct vcd_dev_ctxt *dev_ctxt,
struct vcd_clnt_ctxt *trig_clnt)
{
struct vcd_clnt_ctxt *cctxt = dev_ctxt->cctxt_list_head;
struct vcd_clnt_ctxt *tmp_clnt = NULL;
VCD_MSG_LOW("vcd_handle_device_err_fatal:");
while (cctxt) {
tmp_clnt = cctxt;
cctxt = cctxt->next;
if (tmp_clnt != trig_clnt)
vcd_clnt_handle_device_err_fatal(tmp_clnt,
tmp_clnt->status.last_evt);
}
dev_ctxt->pending_cmd = VCD_CMD_DEVICE_RESET;
if (!dev_ctxt->cctxt_list_head)
vcd_do_device_state_transition(vcd_get_drv_context(),
VCD_DEVICE_STATE_NOT_INIT,
DEVICE_STATE_EVENT_NUMBER(timeout));
else
vcd_do_device_state_transition(vcd_get_drv_context(),
VCD_DEVICE_STATE_INVALID,
DEVICE_STATE_EVENT_NUMBER(dev_cb));
}
static u32 vcd_set_dev_pwr_in_ready
(struct vcd_drv_ctxt *drv_ctxt,
enum vcd_power_state pwr_state)
{
u32 rc = VCD_S_SUCCESS;
struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;
VCD_MSG_LOW("vcd_set_dev_pwr_in_ready:");
switch (pwr_state) {
case VCD_PWR_STATE_SLEEP:
{
if (dev_ctxt->pwr_state == VCD_PWR_STATE_ON)
vcd_pause_all_sessions(dev_ctxt);
dev_ctxt->pwr_state = VCD_PWR_STATE_SLEEP;
break;
}
case VCD_PWR_STATE_ON:
{
if (dev_ctxt->pwr_state == VCD_PWR_STATE_SLEEP)
vcd_resume_all_sessions(dev_ctxt);
dev_ctxt->pwr_state = VCD_PWR_STATE_ON;
break;
}
default:
{
VCD_MSG_ERROR("Invalid power state requested %d",
pwr_state);
break;
}
}
return rc;
}
static u32 vcd_allocate_buffer_cmn
(struct vcd_clnt_ctxt_type_t *p_cctxt,
enum vcd_buffer_type e_buffer,
u32 n_buf_size, u8 **pp_vir_buf_addr, u8 **pp_phy_buf_addr)
{
u32 rc;
struct vcd_buffer_pool_type *p_buf_pool;
VCD_MSG_LOW("vcd_allocate_buffer_cmn in %d:",
p_cctxt->clnt_state.e_state);
rc = vcd_common_allocate_set_buffer(p_cctxt, e_buffer, n_buf_size,
&p_buf_pool);
if (!VCD_FAILED(rc)) {
rc = vcd_allocate_buffer_internal(p_cctxt,
p_buf_pool,
n_buf_size,
pp_vir_buf_addr,
pp_phy_buf_addr);
}
return rc;
}
static u32 vcd_open_in_ready
(struct vcd_drv_ctxt *drv_ctxt,
s32 driver_handle,
u32 decoding,
void (*callback) (u32 event, u32 status, void *info, size_t sz,
void *handle, void *const client_data),
void *client_data)
{
struct vcd_clnt_ctxt *cctxt;
struct vcd_handle_container container;
u32 rc;
VCD_MSG_LOW("vcd_open_in_dev_ready:");
rc = vcd_open_cmn(drv_ctxt, driver_handle, decoding, callback,
client_data, &cctxt);
VCD_FAILED_RETURN(rc, "Failed: vcd_open_cmn");
rc = vcd_init_client_context(cctxt);
if (!VCD_FAILED(rc)) {
container.handle = (void *)cctxt;
callback(VCD_EVT_RESP_OPEN,
VCD_S_SUCCESS,
&container,
sizeof(container), container.handle, client_data);
} else {
VCD_MSG_ERROR("rc = 0x%x. Failed: vcd_init_client_context", rc);
vcd_destroy_client_context(cctxt);
}
return rc;
}
static u32 vcd_allocate_buffer_cmn
(struct vcd_clnt_ctxt *cctxt,
enum vcd_buffer_type buffer,
u32 buf_size, u8 **vir_buf_addr, u8 **phy_buf_addr)
{
u32 rc;
struct vcd_buffer_pool *buf_pool;
VCD_MSG_LOW("vcd_allocate_buffer_cmn in %d:",
cctxt->clnt_state.state);
rc = vcd_common_allocate_set_buffer(cctxt, buffer, buf_size,
&buf_pool);
if (!VCD_FAILED(rc)) {
rc = vcd_allocate_buffer_internal(cctxt,
buf_pool,
buf_size,
vir_buf_addr,
phy_buf_addr);
}
return rc;
}
static int is_session_invalid(u32 decoding, u32 flags)
{
int is_secure;
struct client_security_info sec_info;
int client_count = 0;
int secure_session_running = 0;
is_secure = (flags & VCD_CP_SESSION) ? 1 : 0;
client_count = vcd_get_clients_security_info(&sec_info);
secure_session_running = (sec_info.secure_enc > 0) ||
(sec_info.secure_dec > 0);
if (!decoding && is_secure) {
if ((sec_info.secure_dec == 1)) {
VCD_MSG_LOW("SE-SD: SUCCESS\n");
}
else {
VCD_MSG_LOW("SE is permitted only with SD: FAILURE\n");
return -EACCES;
}
} else if (!decoding && !is_secure) {
if (secure_session_running) {
VCD_MSG_LOW("SD-NSE: FAILURE\n");
VCD_MSG_LOW("SE-NSE: FAILURE\n");
return -EACCES;
}
} else if (decoding && is_secure) {
if (client_count > 0) {
VCD_MSG_LOW("S/NS-SD: FAILURE\n");
if (sec_info.secure_enc > 0 ||
sec_info.non_secure_enc > 0) {
return -EAGAIN;
}
return -EACCES;
}
} else {
if (sec_info.secure_dec > 0) {
VCD_MSG_LOW("SD-NSD: FAILURE\n");
return -EACCES;
}
}
return 0;
}
static u32 vcd_set_property_cmn
(struct vcd_clnt_ctxt *cctxt,
struct vcd_property_hdr *prop_hdr, void *prop_val)
{
u32 rc;
VCD_MSG_LOW("vcd_set_property_cmn in %d:", cctxt->clnt_state.state);
VCD_MSG_LOW("property Id = %d", prop_hdr->prop_id);
if (!prop_hdr->sz || !prop_hdr->prop_id) {
VCD_MSG_MED("Bad parameters");
return VCD_ERR_ILLEGAL_PARM;
}
rc = ddl_set_property(cctxt->ddl_handle, prop_hdr, prop_val);
if (rc) {
/* Some properties aren't known to ddl that we can handle */
if (prop_hdr->prop_id != VCD_I_VOP_TIMING_CONSTANT_DELTA)
VCD_FAILED_RETURN(rc, "Failed: ddl_set_property");
}
switch (prop_hdr->prop_id) {
case VCD_I_META_BUFFER_MODE:
{
struct vcd_property_live *live =
(struct vcd_property_live *)prop_val;
cctxt->meta_mode = live->live;
break;
}
case VCD_I_LIVE:
{
struct vcd_property_live *live =
(struct vcd_property_live *)prop_val;
cctxt->live = live->live;
break;
}
case VCD_I_FRAME_RATE:
{
if (cctxt->sched_clnt_hdl) {
rc = vcd_set_frame_rate(cctxt,
(struct vcd_property_frame_rate *)
prop_val);
}
break;
}
case VCD_I_FRAME_SIZE:
{
if (cctxt->sched_clnt_hdl) {
rc = vcd_set_frame_size(cctxt,
(struct vcd_property_frame_size *)
prop_val);
}
break;
}
case VCD_I_INTRA_PERIOD:
{
struct vcd_property_i_period *iperiod =
(struct vcd_property_i_period *)prop_val;
cctxt->bframe = iperiod->b_frames;
break;
}
case VCD_REQ_PERF_LEVEL:
rc = vcd_req_perf_level(cctxt,
(struct vcd_property_perf_level *)prop_val);
break;
case VCD_I_VOP_TIMING_CONSTANT_DELTA:
{
struct vcd_property_vop_timing_constant_delta *delta =
prop_val;
if (delta->constant_delta > 0) {
cctxt->time_frame_delta = delta->constant_delta;
rc = VCD_S_SUCCESS;
} else {
VCD_MSG_ERROR("Frame delta must be positive");
rc = VCD_ERR_ILLEGAL_PARM;
}
break;
}
default:
{
break;
}
}
return rc;
}
static u32 vcd_set_property_cmn
(struct vcd_clnt_ctxt *cctxt,
struct vcd_property_hdr *prop_hdr, void *prop_val)
{
u32 rc;
VCD_MSG_LOW("vcd_set_property_cmn in %d:", cctxt->clnt_state.state);
VCD_MSG_LOW("property Id = %d", prop_hdr->prop_id);
if (!prop_hdr->sz || !prop_hdr->prop_id) {
VCD_MSG_MED("Bad parameters");
return VCD_ERR_ILLEGAL_PARM;
}
rc = ddl_set_property(cctxt->ddl_handle, prop_hdr, prop_val);
VCD_FAILED_RETURN(rc, "Failed: ddl_set_property");
switch (prop_hdr->prop_id) {
case VCD_I_META_BUFFER_MODE:
{
struct vcd_property_live *live =
(struct vcd_property_live *)prop_val;
cctxt->meta_mode = live->live;
break;
}
case VCD_I_LIVE:
{
struct vcd_property_live *live =
(struct vcd_property_live *)prop_val;
cctxt->live = live->live;
break;
}
case VCD_I_FRAME_RATE:
{
if (cctxt->sched_clnt_hdl) {
rc = vcd_set_frame_rate(cctxt,
(struct vcd_property_frame_rate *)
prop_val);
}
break;
}
case VCD_I_FRAME_SIZE:
{
if (cctxt->sched_clnt_hdl) {
rc = vcd_set_frame_size(cctxt,
(struct vcd_property_frame_size *)
prop_val);
}
break;
}
case VCD_I_INTRA_PERIOD:
{
struct vcd_property_i_period *iperiod =
(struct vcd_property_i_period *)prop_val;
cctxt->bframe = iperiod->b_frames;
break;
}
default:
{
break;
}
}
return rc;
}
void vcd_continue(void)
{
struct vcd_drv_ctxt_type_t *p_drv_ctxt;
struct vcd_dev_ctxt_type *p_dev_ctxt;
u32 b_continue;
struct vcd_transc_type *p_transc;
u32 rc;
VCD_MSG_LOW("vcd_continue:");
p_drv_ctxt = vcd_get_drv_context();
p_dev_ctxt = &p_drv_ctxt->dev_ctxt;
p_dev_ctxt->b_continue = FALSE;
if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_INIT) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_INIT is pending");
p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;
(void)vcd_init_device_context(p_drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(pf_open));
} else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_TERM) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_TERM is pending");
p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;
(void)vcd_deinit_device_context(p_drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(pf_close));
} else if (p_dev_ctxt->e_pending_cmd == VCD_CMD_DEVICE_RESET) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_RESET is pending");
p_dev_ctxt->e_pending_cmd = VCD_CMD_NONE;
(void)vcd_reset_device_context(p_drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(pf_dev_cb));
} else {
if (p_dev_ctxt->b_set_perf_lvl_pending) {
rc = vcd_power_event(p_dev_ctxt, NULL,
VCD_EVT_PWR_DEV_SET_PERFLVL);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("VCD_EVT_PWR_CLNT_SET_PERFLVL failed");
VCD_MSG_HIGH
("Not running at desired perf level."
"curr=%d, reqd=%d",
p_dev_ctxt->n_curr_perf_lvl,
p_dev_ctxt->n_reqd_perf_lvl);
} else {
p_dev_ctxt->b_set_perf_lvl_pending = FALSE;
}
}
do {
b_continue = FALSE;
if (vcd_get_command_channel_in_loop
(p_dev_ctxt, &p_transc)) {
if (vcd_submit_command_in_continue(p_dev_ctxt,
p_transc))
b_continue = TRUE;
else {
VCD_MSG_MED
("No more commands to submit");
vcd_release_command_channel(p_dev_ctxt,
p_transc);
vcd_release_interim_command_channels
(p_dev_ctxt);
}
}
} while (b_continue);
do {
b_continue = FALSE;
if (vcd_get_frame_channel_in_loop
(p_dev_ctxt, &p_transc)) {
if (vcd_try_submit_frame_in_continue(p_dev_ctxt,
p_transc)) {
b_continue = TRUE;
} else {
VCD_MSG_MED("No more frames to submit");
vcd_release_frame_channel(p_dev_ctxt,
p_transc);
vcd_release_interim_frame_channels
(p_dev_ctxt);
}
}
} while (b_continue);
if (!vcd_core_is_busy(p_dev_ctxt)) {
rc = vcd_power_event(p_dev_ctxt, NULL,
VCD_EVT_PWR_CLNT_CMD_END);
if (VCD_FAILED(rc))
VCD_MSG_ERROR("Failed:"
"VCD_EVT_PWR_CLNT_CMD_END");
}
}
}
static void vcd_clnt_cb_in_invalid(
struct vcd_clnt_ctxt *cctxt, u32 event, u32 status,
void *payload, size_t sz, u32 *ddl_handle,
void *const client_data
)
{
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
VCD_MSG_LOW("vcd_clnt_cb_in_invalid:");
if (cctxt->ddl_handle != ddl_handle) {
VCD_MSG_ERROR("ddl_handle mismatch");
return;
}
switch (event) {
case VCD_EVT_RESP_STOP:
{
vcd_handle_stop_done_in_invalid(cctxt,
(struct vcd_transc *)client_data,
status);
break;
}
case VCD_EVT_RESP_INPUT_DONE:
case VCD_EVT_RESP_OUTPUT_REQ:
{
if (cctxt->status.frame_submitted)
cctxt->status.frame_submitted--;
if (payload && ((struct ddl_frame_data_tag *)
payload)->frm_trans_end)
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
case VCD_EVT_RESP_OUTPUT_DONE:
{
if (payload && ((struct ddl_frame_data_tag *)
payload)->frm_trans_end)
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
case VCD_EVT_RESP_TRANSACTION_PENDING:
{
if (cctxt->status.frame_submitted)
cctxt->status.frame_submitted--;
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
case VCD_EVT_IND_HWERRFATAL:
{
if (status == VCD_ERR_HW_FATAL)
vcd_handle_stop_done_in_invalid(cctxt,
(struct vcd_transc *)client_data,
status);
break;
}
case VCD_EVT_RESP_EOS_DONE:
{
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
case VCD_EVT_IND_OUTPUT_RECONFIG:
{
if (cctxt->status.frame_submitted > 0)
cctxt->status.frame_submitted--;
else
cctxt->status.frame_delayed--;
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
default:
{
VCD_MSG_ERROR("Unexpected callback event=%d status=%d"
"from DDL", event, status);
dev_ctxt->command_continue = false;
break;
}
}
}
static void vcd_clnt_cb_in_pausing
(struct vcd_clnt_ctxt *cctxt,
u32 event,
u32 status,
void *payload, size_t sz, u32 *ddl_handle, void *const client_data)
{
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
u32 rc = VCD_S_SUCCESS;
u32 frm_trans_end = false;
VCD_MSG_LOW("vcd_clnt_cb_in_pausing:");
if (cctxt->ddl_handle != ddl_handle) {
VCD_MSG_ERROR("ddl_handle mismatch");
return;
}
switch (event) {
case VCD_EVT_RESP_INPUT_DONE:
{
rc = vcd_handle_input_done(cctxt, payload, event,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_DONE:
{
rc = vcd_handle_frame_done(cctxt, payload, event,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_REQ:
{
rc = vcd_handle_output_required(cctxt, payload,
status);
break;
}
case VCD_EVT_IND_OUTPUT_RECONFIG:
{
rc = vcd_handle_ind_output_reconfig(cctxt,
payload, status);
if (!VCD_FAILED(rc)) {
frm_trans_end = true;
payload = NULL;
}
break;
}
case VCD_EVT_IND_HWERRFATAL:
{
vcd_handle_ind_hw_err_fatal(cctxt,
VCD_EVT_RESP_PAUSE, status);
rc = VCD_ERR_FAIL;
break;
}
default:
{
VCD_MSG_ERROR
("Unexpected callback event=%d status=%d from DDL",
event, status);
dev_ctxt->command_continue = false;
break;
}
}
if (!VCD_FAILED(rc)) {
if (payload &&
((struct ddl_frame_data_tag *)\
payload)->frm_trans_end) {
vcd_mark_frame_channel(cctxt->dev_ctxt);
frm_trans_end = true;
}
if (frm_trans_end && !cctxt->status.frame_submitted) {
VCD_MSG_HIGH
("All pending frames recvd from DDL");
cctxt->callback(VCD_EVT_RESP_PAUSE,
VCD_S_SUCCESS,
NULL,
0,
cctxt,
cctxt->client_data);
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_PAUSED,
CLIENT_STATE_EVENT_NUMBER
(clnt_cb));
rc = vcd_power_event(cctxt->dev_ctxt,
cctxt,
VCD_EVT_PWR_CLNT_PAUSE);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("VCD_EVT_PWR_CLNT_PAUSE_END"
"failed");
}
}
}
}
static void vcd_clnt_cb_in_stopping
(struct vcd_clnt_ctxt *cctxt,
u32 event,
u32 status,
void *payload, size_t sz, u32 *ddl_handle, void *const client_data) {
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
u32 rc = VCD_S_SUCCESS;
u32 frm_trans_end = false;
VCD_MSG_LOW("vcd_clnt_cb_in_stopping:");
if (cctxt->ddl_handle != ddl_handle) {
VCD_MSG_ERROR("ddl_handle mismatch");
return;
}
switch (event) {
case VCD_EVT_RESP_INPUT_DONE:
{
rc = vcd_handle_input_done(cctxt,
payload,
VCD_EVT_RESP_INPUT_FLUSHED,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_DONE:
{
rc = vcd_handle_frame_done(cctxt,
payload,
VCD_EVT_RESP_OUTPUT_FLUSHED,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_REQ:
{
rc = vcd_handle_output_required_in_flushing(cctxt,
payload);
break;
}
case VCD_EVT_RESP_STOP:
{
vcd_handle_stop_done(cctxt,
(struct vcd_transc *)
client_data, status);
break;
}
case VCD_EVT_IND_OUTPUT_RECONFIG:
{
(void) vcd_handle_ind_output_reconfig(cctxt,
payload, status);
frm_trans_end = true;
payload = NULL;
break;
}
case VCD_EVT_IND_HWERRFATAL:
{
vcd_handle_ind_hw_err_fatal(cctxt, VCD_EVT_RESP_STOP,
status);
break;
}
default:
{
VCD_MSG_ERROR
("Unexpected callback event=%d status=%d from DDL",
event, status);
dev_ctxt->command_continue = false;
break;
}
}
if (!VCD_FAILED(rc) && ((event == VCD_EVT_RESP_INPUT_DONE ||
event == VCD_EVT_RESP_OUTPUT_DONE) ||
event == VCD_EVT_RESP_OUTPUT_REQ ||
event == VCD_EVT_IND_OUTPUT_RECONFIG)) {
if (payload &&
((struct ddl_frame_data_tag *)\
payload)->frm_trans_end) {
vcd_mark_frame_channel(cctxt->dev_ctxt);
frm_trans_end = true;
}
if (frm_trans_end && !cctxt->status.frame_submitted) {
VCD_MSG_HIGH
("All pending frames recvd from DDL");
vcd_flush_bframe_buffers(cctxt,
VCD_FLUSH_INPUT);
vcd_flush_output_buffers(cctxt);
cctxt->status.mask &= ~VCD_FLUSH_ALL;
vcd_release_all_clnt_frm_transc(cctxt);
VCD_MSG_HIGH
("All buffers flushed. Enqueuing stop cmd");
vcd_client_cmd_flush_and_en_q(cctxt,
VCD_CMD_CODEC_STOP);
}
}
}
void vcd_continue(void)
{
struct vcd_drv_ctxt *drv_ctxt;
struct vcd_dev_ctxt *dev_ctxt;
u32 command_continue;
struct vcd_transc *transc;
u32 rc;
VCD_MSG_LOW("vcd_continue:");
drv_ctxt = vcd_get_drv_context();
dev_ctxt = &drv_ctxt->dev_ctxt;
dev_ctxt->command_continue = false;
if (dev_ctxt->pending_cmd == VCD_CMD_DEVICE_INIT) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_INIT is pending");
dev_ctxt->pending_cmd = VCD_CMD_NONE;
(void)vcd_init_device_context(drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(open));
} else if (dev_ctxt->pending_cmd == VCD_CMD_DEVICE_TERM) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_TERM is pending");
dev_ctxt->pending_cmd = VCD_CMD_NONE;
(void)vcd_deinit_device_context(drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(close));
} else if (dev_ctxt->pending_cmd == VCD_CMD_DEVICE_RESET) {
VCD_MSG_HIGH("VCD_CMD_DEVICE_RESET is pending");
dev_ctxt->pending_cmd = VCD_CMD_NONE;
(void)vcd_reset_device_context(drv_ctxt,
DEVICE_STATE_EVENT_NUMBER(dev_cb));
} else {
if (dev_ctxt->set_perf_lvl_pending) {
rc = vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_SET_PERFLVL);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("VCD_EVT_PWR_CLNT_SET_PERFLVL failed");
VCD_MSG_HIGH
("Not running at desired perf level."
"curr=%d, reqd=%d",
dev_ctxt->curr_perf_lvl,
dev_ctxt->reqd_perf_lvl);
} else {
dev_ctxt->set_perf_lvl_pending = false;
}
}
do {
command_continue = false;
if (vcd_get_command_channel_in_loop
(dev_ctxt, &transc)) {
if (vcd_submit_command_in_continue(dev_ctxt,
transc))
command_continue = true;
else {
VCD_MSG_MED
("No more commands to submit");
vcd_release_command_channel(dev_ctxt,
transc);
vcd_release_interim_command_channels
(dev_ctxt);
}
}
} while (command_continue);
do {
command_continue = false;
if (vcd_get_frame_channel_in_loop
(dev_ctxt, &transc)) {
if (vcd_try_submit_frame_in_continue(dev_ctxt,
transc)) {
command_continue = true;
} else {
VCD_MSG_MED("No more frames to submit");
vcd_release_frame_channel(dev_ctxt,
transc);
vcd_release_interim_frame_channels
(dev_ctxt);
}
}
} while (command_continue);
if (!vcd_core_is_busy(dev_ctxt)) {
rc = vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_CLNT_CMD_END);
if (VCD_FAILED(rc))
VCD_MSG_ERROR("Failed:"
"VCD_EVT_PWR_CLNT_CMD_END");
}
}
}
void vcd_read_and_clear_interrupt(void)
{
VCD_MSG_LOW("vcd_read_and_clear_interrupt:");
ddl_read_and_clear_interrupt();
}
static void vcd_dev_cb_in_initing
(struct vcd_drv_ctxt *drv_ctxt,
u32 event,
u32 status,
void *payload, size_t sz, u32 *ddl_handle, void *const client_data)
{
struct vcd_dev_ctxt *dev_ctxt;
struct vcd_clnt_ctxt *client;
struct vcd_clnt_ctxt *tmp_client;
struct vcd_handle_container container;
u32 rc = VCD_S_SUCCESS;
u32 client_inited = false;
u32 fail_all_open = false;
VCD_MSG_LOW("vcd_dev_cb_in_initing:");
if (event != VCD_EVT_RESP_DEVICE_INIT) {
VCD_MSG_ERROR("vcd_dev_cb_in_initing: Unexpected event %d",
(int)event);
return;
}
dev_ctxt = &drv_ctxt->dev_ctxt;
dev_ctxt->command_continue = false;
if (VCD_FAILED(status)) {
vcd_handle_device_init_failed(drv_ctxt, status);
return;
}
vcd_do_device_state_transition(drv_ctxt,
VCD_DEVICE_STATE_READY,
DEVICE_STATE_EVENT_NUMBER(open));
if (!dev_ctxt->cctxt_list_head) {
VCD_MSG_HIGH("All clients are closed");
dev_ctxt->pending_cmd = VCD_CMD_DEVICE_TERM;
return;
}
if (!dev_ctxt->ddl_cmd_ch_depth
|| !dev_ctxt->trans_tbl)
rc = vcd_setup_with_ddl_capabilities(dev_ctxt);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("rc = 0x%x: Failed vcd_setup_with_ddl_capabilities",
rc);
fail_all_open = true;
}
client = dev_ctxt->cctxt_list_head;
while (client) {
if (!fail_all_open)
rc = vcd_init_client_context(client);
if (!VCD_FAILED(rc)) {
container.handle = (void *)client;
client->callback(VCD_EVT_RESP_OPEN,
VCD_S_SUCCESS,
&container,
sizeof(container),
container.handle,
client->client_data);
client = client->next;
client_inited = true;
} else {
VCD_MSG_ERROR
("rc = 0x%x, Failed: vcd_init_client_context",
rc);
client->callback(VCD_EVT_RESP_OPEN,
rc,
NULL, 0, 0, client->client_data);
tmp_client = client;
client = client->next;
vcd_destroy_client_context(tmp_client);
}
}
if (!client_inited || fail_all_open) {
VCD_MSG_ERROR("All client open requests failed");
dev_ctxt->pending_cmd = VCD_CMD_DEVICE_TERM;
} else {
if (vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_END)) {
VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_END failed");
}
}
}
void vcd_ddl_callback(u32 event, u32 status, void *p_payload,
u32 n_size, u32 *ddl_handle, void *const p_client_data)
{
struct vcd_drv_ctxt_type_t *p_drv_ctxt;
struct vcd_dev_ctxt_type *p_dev_ctxt;
struct vcd_dev_state_ctxt_type_t *p_dev_state;
struct vcd_clnt_ctxt_type_t *p_cctxt;
struct vcd_transc_type *p_transc;
VCD_MSG_LOW("vcd_ddl_callback:");
VCD_MSG_LOW("event=0x%x status=0x%x", event, status);
p_drv_ctxt = vcd_get_drv_context();
p_dev_ctxt = &p_drv_ctxt->dev_ctxt;
p_dev_state = &p_drv_ctxt->dev_state;
p_dev_ctxt->b_continue = TRUE;
vcd_device_timer_stop(p_dev_ctxt);
switch (p_dev_state->e_state) {
case VCD_DEVICE_STATE_NULL:
{
VCD_MSG_HIGH("Callback unexpected in NULL state");
break;
}
case VCD_DEVICE_STATE_NOT_INIT:
{
VCD_MSG_HIGH("Callback unexpected in NOT_INIT state");
break;
}
case VCD_DEVICE_STATE_INITING:
{
if (p_dev_state->p_state_table->ev_hdlr.pf_dev_cb) {
p_dev_state->p_state_table->ev_hdlr.
pf_dev_cb(p_drv_ctxt, event, status,
p_payload, n_size, ddl_handle,
p_client_data);
} else {
VCD_MSG_HIGH("No device handler in %d state",
p_dev_state->e_state);
}
break;
}
case VCD_DEVICE_STATE_READY:
{
p_transc = (struct vcd_transc_type *)p_client_data;
if (!p_transc || !p_transc->b_in_use
|| !p_transc->p_cctxt) {
VCD_MSG_ERROR("Invalid clientdata "
"received from DDL ");
} else {
p_cctxt = p_transc->p_cctxt;
if (p_cctxt->clnt_state.p_state_table->ev_hdlr.
pf_clnt_cb) {
p_cctxt->clnt_state.p_state_table->
ev_hdlr.pf_clnt_cb(p_cctxt,
event, status, p_payload,
n_size, ddl_handle,
p_client_data);
} else {
VCD_MSG_HIGH
("No client handler in"
" (dsm:READY, csm:%d) state",
(int)p_cctxt->clnt_state.e_state);
if (VCD_FAILED(status)) {
VCD_MSG_FATAL("DDL callback"
" returned failure 0x%x",
status);
}
}
}
break;
}
default:
{
VCD_MSG_ERROR("Unknown state");
break;
}
}
}
void vcd_ddl_callback(u32 event, u32 status, void *payload,
size_t sz, u32 *ddl_handle, void *const client_data)
{
struct vcd_drv_ctxt *drv_ctxt;
struct vcd_dev_ctxt *dev_ctxt;
struct vcd_dev_state_ctxt *dev_state;
struct vcd_clnt_ctxt *cctxt;
struct vcd_transc *transc;
VCD_MSG_LOW("vcd_ddl_callback:");
VCD_MSG_LOW("event=0x%x status=0x%x", event, status);
drv_ctxt = vcd_get_drv_context();
dev_ctxt = &drv_ctxt->dev_ctxt;
dev_state = &drv_ctxt->dev_state;
dev_ctxt->command_continue = true;
vcd_device_timer_stop(dev_ctxt);
switch (dev_state->state) {
case VCD_DEVICE_STATE_NULL:
{
VCD_MSG_HIGH("Callback unexpected in NULL state");
break;
}
case VCD_DEVICE_STATE_NOT_INIT:
{
VCD_MSG_HIGH("Callback unexpected in NOT_INIT state");
break;
}
case VCD_DEVICE_STATE_INITING:
{
if (dev_state->state_table->ev_hdlr.dev_cb) {
dev_state->state_table->ev_hdlr.
dev_cb(drv_ctxt, event, status,
payload, sz, ddl_handle,
client_data);
} else {
VCD_MSG_HIGH("No device handler in %d state",
dev_state->state);
}
break;
}
case VCD_DEVICE_STATE_READY:
{
transc = (struct vcd_transc *)client_data;
if (!transc || !transc->in_use
|| !transc->cctxt) {
VCD_MSG_ERROR("Invalid clientdata "
"received from DDL ");
} else {
cctxt = transc->cctxt;
if (cctxt->clnt_state.state_table->ev_hdlr.
clnt_cb) {
cctxt->clnt_state.state_table->
ev_hdlr.clnt_cb(cctxt,
event, status, payload,
sz, ddl_handle,
client_data);
} else {
VCD_MSG_HIGH
("No client handler in"
" (dsm:READY, csm:%d) state",
(int)cctxt->clnt_state.state);
if (VCD_FAILED(status)) {
VCD_MSG_FATAL("DDL callback"
" returned failure 0x%x",
status);
}
}
}
break;
}
default:
{
VCD_MSG_ERROR("Unknown state");
break;
}
}
}
static u32 vcd_set_buffer_requirements_cmn
(struct vcd_clnt_ctxt *cctxt,
enum vcd_buffer_type buffer,
struct vcd_buffer_requirement *buffer_req)
{
struct vcd_property_hdr Prop_hdr;
u32 rc = VCD_S_SUCCESS;
struct vcd_buffer_pool *buf_pool;
u32 first_frm_recvd = 0;
VCD_MSG_LOW("vcd_set_buffer_requirements_cmn in %d:",
cctxt->clnt_state.state);
if (!cctxt->decoding &&
cctxt->clnt_state.state != VCD_CLIENT_STATE_OPEN) {
VCD_MSG_ERROR("Bad state (%d) for encoder",
cctxt->clnt_state.state);
return VCD_ERR_BAD_STATE;
}
VCD_MSG_MED("Buffer type = %d", buffer);
if (buffer == VCD_BUFFER_INPUT) {
Prop_hdr.prop_id = DDL_I_INPUT_BUF_REQ;
buf_pool = &cctxt->in_buf_pool;
first_frm_recvd = VCD_FIRST_IP_RCVD;
} else if (buffer == VCD_BUFFER_OUTPUT) {
Prop_hdr.prop_id = DDL_I_OUTPUT_BUF_REQ;
buf_pool = &cctxt->out_buf_pool;
first_frm_recvd = VCD_FIRST_OP_RCVD;
} else {
rc = VCD_ERR_ILLEGAL_PARM;
}
VCD_FAILED_RETURN(rc, "Invalid buffer type provided");
if (buf_pool->validated > 0) {
VCD_MSG_ERROR("Need to free allocated buffers");
return VCD_ERR_ILLEGAL_OP;
}
first_frm_recvd &= cctxt->status.mask;
if (first_frm_recvd) {
VCD_MSG_ERROR("VCD SetBufReq called when data path is active");
return VCD_ERR_BAD_STATE;
}
Prop_hdr.sz = sizeof(*buffer_req);
rc = ddl_set_property(cctxt->ddl_handle, &Prop_hdr, buffer_req);
VCD_FAILED_RETURN(rc, "Failed: ddl_set_property");
if (buf_pool->entries) {
VCD_MSG_MED("Resetting buffer requirements");
vcd_free_buffer_pool_entries(buf_pool);
}
rc = vcd_alloc_buffer_pool_entries(buf_pool, buffer_req);
return rc;
}
static void vcd_dev_cb_in_initing
(struct vcd_drv_ctxt_type_t *p_drv_ctxt,
u32 event,
u32 status,
void *p_payload, u32 size, u32 *ddl_handle, void *const p_client_data)
{
struct vcd_dev_ctxt_type *p_dev_ctxt;
struct vcd_clnt_ctxt_type_t *p_client;
struct vcd_clnt_ctxt_type_t *p_tmp_client;
struct vcd_handle_container_type container;
u32 rc = VCD_S_SUCCESS;
u32 b_client_inited = FALSE;
u32 b_fail_all_open = FALSE;
VCD_MSG_LOW("vcd_dev_cb_in_initing:");
if (event != VCD_EVT_RESP_DEVICE_INIT) {
VCD_MSG_ERROR("vcd_dev_cb_in_initing: Unexpected event %d",
(int)event);
return;
}
p_dev_ctxt = &p_drv_ctxt->dev_ctxt;
p_dev_ctxt->b_continue = FALSE;
if (VCD_FAILED(status)) {
vcd_handle_device_init_failed(p_drv_ctxt, status);
return;
}
vcd_do_device_state_transition(p_drv_ctxt,
VCD_DEVICE_STATE_READY,
DEVICE_STATE_EVENT_NUMBER(pf_open));
if (!p_dev_ctxt->p_cctxt_list_head) {
VCD_MSG_HIGH("All clients are closed");
p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_TERM;
return;
}
if (!p_dev_ctxt->n_ddl_cmd_ch_depth
|| !p_dev_ctxt->a_trans_tbl)
rc = vcd_setup_with_ddl_capabilities(p_dev_ctxt);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("rc = 0x%x: Failed vcd_setup_with_ddl_capabilities",
rc);
b_fail_all_open = TRUE;
}
p_client = p_dev_ctxt->p_cctxt_list_head;
while (p_client) {
if (!b_fail_all_open)
rc = vcd_init_client_context(p_client);
if (!VCD_FAILED(rc)) {
container.handle = (void *)p_client;
p_client->callback(VCD_EVT_RESP_OPEN,
VCD_S_SUCCESS,
&container,
sizeof(container),
container.handle,
p_client->p_client_data);
p_client = p_client->p_next;
b_client_inited = TRUE;
} else {
VCD_MSG_ERROR
("rc = 0x%x, Failed: vcd_init_client_context",
rc);
p_client->callback(VCD_EVT_RESP_OPEN,
rc,
NULL, 0, 0, p_client->p_client_data);
p_tmp_client = p_client;
p_client = p_client->p_next;
vcd_destroy_client_context(p_tmp_client);
}
}
if (!b_client_inited || b_fail_all_open) {
VCD_MSG_ERROR("All client open requests failed");
p_dev_ctxt->e_pending_cmd = VCD_CMD_DEVICE_TERM;
} else {
if (vcd_power_event(p_dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_END)) {
VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_END failed");
}
}
}
static void vcd_clnt_cb_in_eos
(struct vcd_clnt_ctxt *cctxt,
u32 event,
u32 status,
void *payload, size_t sz, u32 *ddl_handle, void *const client_data) {
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
struct vcd_transc *transc = NULL;
u32 frm_trans_end = false, rc = VCD_S_SUCCESS;
if (cctxt->ddl_handle != ddl_handle) {
VCD_MSG_ERROR("ddl_handle mismatch");
return;
}
switch (event) {
case VCD_EVT_RESP_INPUT_DONE:
{
rc = vcd_handle_input_done_in_eos(cctxt, payload,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_DONE:
{
rc = vcd_handle_frame_done_in_eos(cctxt, payload,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_REQ:
{
rc = vcd_handle_output_required(cctxt, payload,
status);
break;
}
case VCD_EVT_RESP_EOS_DONE:
{
transc = (struct vcd_transc *)client_data;
vcd_handle_eos_done(cctxt, transc, status);
vcd_mark_frame_channel(cctxt->dev_ctxt);
break;
}
case VCD_EVT_IND_OUTPUT_RECONFIG:
{
rc = vcd_handle_ind_output_reconfig(cctxt,
payload, status);
if (!VCD_FAILED(rc)) {
frm_trans_end = true;
payload = NULL;
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_RUN,
CLIENT_STATE_EVENT_NUMBER
(clnt_cb));
VCD_MSG_LOW
("RECONFIGinEOS:Suspending Client");
rc = vcd_sched_suspend_resume_clnt(cctxt,
false);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("Failed: suspend_resume_clnt. rc=0x%x",
rc);
}
}
break;
}
case VCD_EVT_IND_HWERRFATAL:
{
vcd_handle_ind_hw_err_fatal(cctxt,
VCD_EVT_IND_HWERRFATAL, status);
break;
}
case VCD_EVT_IND_INFO_OUTPUT_RECONFIG:
{
vcd_handle_ind_info_output_reconfig(cctxt, status);
break;
}
default:
{
VCD_MSG_ERROR
("Unexpected callback event=%d status=%d from DDL",
event, status);
dev_ctxt->command_continue = false;
break;
}
}
if (!VCD_FAILED(rc) &&
(event == VCD_EVT_RESP_INPUT_DONE ||
event == VCD_EVT_RESP_OUTPUT_DONE ||
event == VCD_EVT_RESP_OUTPUT_REQ ||
event == VCD_EVT_IND_OUTPUT_RECONFIG)) {
if (payload && ((struct ddl_frame_data_tag *)
payload)->frm_trans_end) {
vcd_mark_frame_channel(cctxt->dev_ctxt);
frm_trans_end = true;
}
if (frm_trans_end && !cctxt->status.frame_submitted)
vcd_handle_eos_trans_end(cctxt);
}
}
static void vcd_clnt_cb_in_flushing
(struct vcd_clnt_ctxt *cctxt,
u32 event,
u32 status,
void *payload, size_t sz, u32 *ddl_handle, void *const client_data) {
struct vcd_dev_ctxt *dev_ctxt = cctxt->dev_ctxt;
u32 rc = VCD_S_SUCCESS;
u32 frm_trans_end = false;
VCD_MSG_LOW("vcd_clnt_cb_in_flushing:");
if (cctxt->ddl_handle != ddl_handle) {
VCD_MSG_ERROR("ddl_handle mismatch");
return;
}
switch (event) {
case VCD_EVT_RESP_INPUT_DONE:
{
rc = vcd_handle_input_done(cctxt,
payload,
VCD_EVT_RESP_INPUT_FLUSHED,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_DONE:
{
rc = vcd_handle_frame_done(cctxt,
payload,
VCD_EVT_RESP_OUTPUT_FLUSHED,
status);
break;
}
case VCD_EVT_RESP_OUTPUT_REQ:
{
rc = vcd_handle_output_required_in_flushing(cctxt,
payload);
break;
}
case VCD_EVT_IND_OUTPUT_RECONFIG:
{
rc = vcd_handle_ind_output_reconfig(cctxt,
payload, status);
if (!VCD_FAILED(rc)) {
frm_trans_end = true;
payload = NULL;
}
break;
}
case VCD_EVT_IND_HWERRFATAL:
{
vcd_handle_ind_hw_err_fatal(cctxt,
VCD_EVT_IND_HWERRFATAL, status);
break;
}
default:
{
VCD_MSG_ERROR
("Unexpected callback event=%d status=%d from DDL",
event, status);
dev_ctxt->command_continue = false;
break;
}
}
if (!VCD_FAILED(rc) && ((event == VCD_EVT_RESP_INPUT_DONE ||
event == VCD_EVT_RESP_OUTPUT_DONE ||
event == VCD_EVT_RESP_OUTPUT_REQ ||
event == VCD_EVT_IND_OUTPUT_RECONFIG))) {
if (payload &&
((struct ddl_frame_data_tag *)\
payload)->frm_trans_end) {
vcd_mark_frame_channel(cctxt->dev_ctxt);
frm_trans_end = true;
}
if (frm_trans_end && !cctxt->status.frame_submitted) {
VCD_MSG_HIGH
("All pending frames recvd from DDL");
if (cctxt->status.mask & VCD_FLUSH_INPUT)
vcd_flush_bframe_buffers(cctxt,
VCD_FLUSH_INPUT);
if (cctxt->status.mask & VCD_FLUSH_OUTPUT)
vcd_flush_output_buffers(cctxt);
vcd_send_flush_done(cctxt, VCD_S_SUCCESS);
vcd_release_interim_frame_channels(dev_ctxt);
VCD_MSG_HIGH("Flush complete");
vcd_do_client_state_transition(cctxt,
VCD_CLIENT_STATE_RUN,
CLIENT_STATE_EVENT_NUMBER
(clnt_cb));
}
}
}
