u32 vcd_term(s32 driver_handle) { u32 rc = VCD_S_SUCCESS; struct vcd_drv_ctxt *drv_ctxt; VCD_MSG_MED("vcd_term:"); drv_ctxt = vcd_get_drv_context(); mutex_lock(&drv_ctxt->dev_mutex); if (drv_ctxt->dev_state.state_table->ev_hdlr.term) { rc = drv_ctxt->dev_state.state_table->ev_hdlr. term(drv_ctxt, driver_handle); } else { VCD_MSG_ERROR("Unsupported API in device state %d", drv_ctxt->dev_state.state); rc = VCD_ERR_BAD_STATE; } mutex_unlock(&drv_ctxt->dev_mutex); return rc; }
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_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; }
u32 vcd_disable_clock(struct vcd_dev_ctxt *dev_ctxt) { u32 rc = VCD_S_SUCCESS; if (dev_ctxt->pwr_clk_state == VCD_PWRCLK_STATE_OFF) { VCD_MSG_ERROR("vcd_disable_clock(): Already in state " "VCD_PWRCLK_STATE_OFF\n"); rc = VCD_ERR_FAIL; } else if (dev_ctxt->pwr_clk_state == VCD_PWRCLK_STATE_ON_CLOCKED || dev_ctxt->pwr_clk_state == VCD_PWRCLK_STATE_ON_CLOCKGATED) { dev_ctxt->active_clnts--; if (!dev_ctxt->active_clnts) { if (!res_trk_disable_clocks()) rc = VCD_ERR_FAIL; dev_ctxt->pwr_clk_state = VCD_PWRCLK_STATE_ON_NOTCLOCKED; dev_ctxt->curr_perf_lvl = 0; } } return rc; }
u32 get_res_trk_perf_level(enum vcd_perf_level perf_level) { u32 res_trk_perf_level; switch (perf_level) { case VCD_PERF_LEVEL0: res_trk_perf_level = RESTRK_1080P_VGA_PERF_LEVEL; break; case VCD_PERF_LEVEL1: res_trk_perf_level = RESTRK_1080P_720P_PERF_LEVEL; break; case VCD_PERF_LEVEL2: res_trk_perf_level = RESTRK_1080P_MAX_PERF_LEVEL; break; case VCD_PERF_LEVEL_TURBO: res_trk_perf_level = RESTRK_1080P_TURBO_PERF_LEVEL; break; default: VCD_MSG_ERROR("Invalid perf level: %d\n", perf_level); res_trk_perf_level = -EINVAL; } VCDRES_MSG_MED("%s: res_trk_perf_level = %u", __func__, res_trk_perf_level); return res_trk_perf_level; }
void vcd_do_client_state_transition(struct vcd_clnt_ctxt *cctxt, enum vcd_clnt_state_enum to_state, u32 ev_code) { struct vcd_clnt_state_ctxt *state_ctxt; if (!cctxt || to_state >= VCD_CLIENT_STATE_MAX) { VCD_MSG_ERROR("Bad parameters. cctxt=%p, to_state=%d", cctxt, to_state); } if (!cctxt) return; state_ctxt = &cctxt->clnt_state; if (state_ctxt->state) { if (state_ctxt->state == to_state) { VCD_MSG_HIGH("Client already in requested to_state=%d", to_state); return; } } VCD_MSG_MED("vcd_do_client_state_transition: C%d -> C%d, for api %d", (int)state_ctxt->state, (int)to_state, ev_code); if (state_ctxt->state_table->exit) state_ctxt->state_table->exit(cctxt, ev_code); state_ctxt->state = to_state; state_ctxt->state_table = vcd_clnt_state_table[to_state]; if (state_ctxt->state_table->entry) state_ctxt->state_table->entry(cctxt, ev_code); }
void vcd_do_device_state_transition(struct vcd_drv_ctxt *drv_ctxt, enum vcd_dev_state_enum to_state, u32 ev_code) { struct vcd_dev_state_ctxt *state_ctxt; if (!drv_ctxt || to_state >= VCD_DEVICE_STATE_MAX) { VCD_MSG_ERROR("Bad parameters. drv_ctxt=%p, to_state=%d", drv_ctxt, to_state); /*HTC_START*/ if (!drv_ctxt) return; /*HTC_END*/ } state_ctxt = &drv_ctxt->dev_state; if (state_ctxt->state == to_state) { VCD_MSG_HIGH("Device already in requested to_state=%d", to_state); return; } VCD_MSG_MED("vcd_do_device_state_transition: D%d -> D%d, for api %d", (int)state_ctxt->state, (int)to_state, ev_code); if (state_ctxt->state_table->exit) state_ctxt->state_table->exit(drv_ctxt, ev_code); state_ctxt->state = to_state; state_ctxt->state_table = vcd_dev_state_table[to_state]; if (state_ctxt->state_table->entry) state_ctxt->state_table->entry(drv_ctxt, ev_code); }
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); } } }
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)); } } }
static void vcd_clnt_cb_in_stopping (struct vcd_clnt_ctxt_type_t *p_cctxt, u32 event, u32 status, void *p_payload, u32 n_size, u32 *ddl_handle, void *const p_client_data) { struct vcd_dev_ctxt_type *p_dev_ctxt = p_cctxt->p_dev_ctxt; u32 rc = VCD_S_SUCCESS; u32 b_frm_trans_end = FALSE; VCD_MSG_LOW("vcd_clnt_cb_in_stopping:"); if (p_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(p_cctxt, p_payload, VCD_EVT_RESP_INPUT_FLUSHED, status); break; } case VCD_EVT_RESP_OUTPUT_DONE: { rc = vcd_handle_frame_done(p_cctxt, p_payload, VCD_EVT_RESP_OUTPUT_FLUSHED, status); break; } case VCD_EVT_RESP_OUTPUT_REQ: { rc = vcd_handle_output_required_in_flushing(p_cctxt, p_payload); break; } case VCD_EVT_RESP_STOP: { vcd_handle_stop_done(p_cctxt, (struct vcd_transc_type *) p_client_data, status); break; } case VCD_EVT_IND_OUTPUT_RECONFIG: { (void) vcd_handle_ind_output_reconfig(p_cctxt, p_payload, status); vcd_mark_frame_channel(p_cctxt->p_dev_ctxt); b_frm_trans_end = TRUE; p_payload = NULL; break; } case VCD_EVT_IND_HWERRFATAL: { vcd_handle_ind_hw_err_fatal(p_cctxt, VCD_EVT_RESP_STOP, status); break; } default: { VCD_MSG_ERROR ("Unexpected callback event=%d status=%d from DDL", event, status); p_dev_ctxt->b_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 (p_payload && ((struct ddl_frame_data_type_tag *)\ p_payload)->b_frm_trans_end) { vcd_mark_frame_channel(p_cctxt->p_dev_ctxt); b_frm_trans_end = TRUE; } if (b_frm_trans_end && !p_cctxt->status.n_frame_submitted) { VCD_MSG_HIGH ("All pending frames recvd from DDL"); vcd_flush_output_buffers(p_cctxt); p_cctxt->status.n_flush_mode = 0; vcd_release_all_clnt_frm_transc(p_cctxt); VCD_MSG_HIGH ("All buffers flushed. Enqueuing stop cmd"); vcd_client_cmd_flush_and_en_q(p_cctxt, VCD_CMD_CODEC_STOP); } } }
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"); } } }
static void vcd_clnt_cb_in_eos (struct vcd_clnt_ctxt_type_t *p_cctxt, u32 event, u32 status, void *p_payload, u32 n_size, u32 *ddl_handle, void *const p_client_data) { struct vcd_dev_ctxt_type *p_dev_ctxt = p_cctxt->p_dev_ctxt; struct vcd_transc_type *p_transc = NULL; u32 b_frm_trans_end = FALSE; if (p_cctxt->ddl_handle != ddl_handle) { VCD_MSG_ERROR("ddl_handle mismatch"); return; } switch (event) { case VCD_EVT_RESP_INPUT_DONE: { vcd_handle_input_done_in_eos(p_cctxt, p_payload, status); break; } case VCD_EVT_RESP_OUTPUT_DONE: { vcd_handle_frame_done_in_eos(p_cctxt, p_payload, status); break; } case VCD_EVT_RESP_OUTPUT_REQ: { (void)vcd_handle_output_required(p_cctxt, p_payload, status); break; } case VCD_EVT_RESP_EOS_DONE: { p_transc = (struct vcd_transc_type *)p_client_data; vcd_handle_eos_done(p_cctxt, p_transc, status); break; } case VCD_EVT_IND_OUTPUT_RECONFIG: { (void) vcd_handle_ind_output_reconfig(p_cctxt, p_payload, status); b_frm_trans_end = TRUE; p_payload = NULL; break; } case VCD_EVT_IND_HWERRFATAL: { vcd_handle_ind_hw_err_fatal(p_cctxt, VCD_EVT_IND_HWERRFATAL, status); break; } default: { VCD_MSG_ERROR ("Unexpected callback event=%d status=%d from DDL", event, status); p_dev_ctxt->b_continue = FALSE; break; } } if (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 (p_payload && ((struct ddl_frame_data_type_tag *) p_payload)->b_frm_trans_end) { vcd_mark_frame_channel(p_cctxt->p_dev_ctxt); b_frm_trans_end = TRUE; } if (b_frm_trans_end && !p_cctxt->status.n_frame_submitted) vcd_handle_eos_trans_end(p_cctxt); } }
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 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; }
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"); } } }
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"); } } }
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_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 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_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_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_flushing (struct vcd_clnt_ctxt_type_t *p_cctxt, 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 = p_cctxt->p_dev_ctxt; u32 rc = VCD_S_SUCCESS; u32 b_frm_trans_end = FALSE; VCD_MSG_LOW("vcd_clnt_cb_in_flushing:"); if (p_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(p_cctxt, p_payload, VCD_EVT_RESP_INPUT_FLUSHED, status); break; } case VCD_EVT_RESP_OUTPUT_DONE: { rc = vcd_handle_frame_done(p_cctxt, p_payload, VCD_EVT_RESP_OUTPUT_FLUSHED, status); break; } case VCD_EVT_RESP_OUTPUT_REQ: { rc = vcd_handle_output_required_in_flushing(p_cctxt, p_payload); break; } case VCD_EVT_IND_OUTPUT_RECONFIG: { (void) vcd_handle_ind_output_reconfig(p_cctxt, p_payload, status); b_frm_trans_end = TRUE; p_payload = NULL; break; } case VCD_EVT_IND_HWERRFATAL: { vcd_handle_ind_hw_err_fatal(p_cctxt, VCD_EVT_IND_HWERRFATAL, status); break; } default: { VCD_MSG_ERROR ("Unexpected callback event=%d status=%d from DDL", event, status); p_dev_ctxt->b_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 (p_payload && ((struct ddl_frame_data_type_tag *)\ p_payload)->b_frm_trans_end) { vcd_mark_frame_channel(p_cctxt->p_dev_ctxt); b_frm_trans_end = TRUE; } if (b_frm_trans_end && !p_cctxt->status.n_frame_submitted) { VCD_MSG_HIGH ("All pending frames recvd from DDL"); if (p_cctxt->status. n_flush_mode & VCD_FLUSH_OUTPUT) { vcd_flush_output_buffers(p_cctxt); vcd_release_all_clnt_frm_transc (p_cctxt); } vcd_send_flush_done(p_cctxt, VCD_S_SUCCESS); vcd_release_interim_frame_channels(p_dev_ctxt); VCD_MSG_HIGH("Flush complete"); vcd_release_all_clnt_def_frm_transc(p_cctxt); vcd_do_client_state_transition(p_cctxt, VCD_CLIENT_STATE_RUN, CLIENT_STATE_EVENT_NUMBER (pf_clnt_cb)); } } }
static void vcd_clnt_cb_in_run (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; 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); break; } case VCD_EVT_RESP_TRANSACTION_PENDING: { vcd_handle_trans_pending(cctxt); 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)) { if (((struct ddl_frame_data_tag *) payload)->frm_trans_end) vcd_mark_frame_channel(cctxt->dev_ctxt); } }
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 void vcd_clnt_cb_in_pausing (struct vcd_clnt_ctxt_type_t *p_cctxt, 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 = p_cctxt->p_dev_ctxt; u32 rc = VCD_S_SUCCESS; u32 b_frm_trans_end = FALSE; VCD_MSG_LOW("vcd_clnt_cb_in_pausing:"); if (p_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(p_cctxt, p_payload, event, status); break; } case VCD_EVT_RESP_OUTPUT_DONE: { rc = vcd_handle_frame_done(p_cctxt, p_payload, event, status); break; } case VCD_EVT_RESP_OUTPUT_REQ: { rc = vcd_handle_output_required(p_cctxt, p_payload, status); break; } case VCD_EVT_IND_OUTPUT_RECONFIG: { (void) vcd_handle_ind_output_reconfig(p_cctxt, p_payload, status); b_frm_trans_end = TRUE; p_payload = NULL; break; } case VCD_EVT_IND_HWERRFATAL: { vcd_handle_ind_hw_err_fatal(p_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); p_dev_ctxt->b_continue = FALSE; break; } } if (!VCD_FAILED(rc)) { if (p_payload && ((struct ddl_frame_data_type_tag *)\ p_payload)->b_frm_trans_end) { vcd_mark_frame_channel(p_cctxt->p_dev_ctxt); b_frm_trans_end = TRUE; } if (b_frm_trans_end && !p_cctxt->status.n_frame_submitted) { VCD_MSG_HIGH ("All pending frames recvd from DDL"); p_cctxt->callback(VCD_EVT_RESP_PAUSE, VCD_S_SUCCESS, NULL, 0, p_cctxt, p_cctxt->p_client_data); vcd_do_client_state_transition(p_cctxt, VCD_CLIENT_STATE_PAUSED, CLIENT_STATE_EVENT_NUMBER (pf_clnt_cb)); rc = vcd_power_event(p_cctxt->p_dev_ctxt, p_cctxt, VCD_EVT_PWR_CLNT_PAUSE); if (VCD_FAILED(rc)) { VCD_MSG_ERROR ("VCD_EVT_PWR_CLNT_PAUSE_END" "failed"); } } } }
static u32 vcd_set_buffer_requirements_cmn (struct vcd_clnt_ctxt_type_t *p_cctxt, enum vcd_buffer_type e_buffer, struct vcd_buffer_requirement_type *p_buffer_req) { struct vcd_property_hdr_type Prop_hdr; u32 rc = VCD_S_SUCCESS; struct vcd_buffer_pool_type *p_buf_pool; u32 b_first_frm_recvd = FALSE; VCD_MSG_LOW("vcd_set_buffer_requirements_cmn in %d:", p_cctxt->clnt_state.e_state); if (!p_cctxt->b_decoding && p_cctxt->clnt_state.e_state != VCD_CLIENT_STATE_OPEN) { VCD_MSG_ERROR("Bad state (%d) for encoder", p_cctxt->clnt_state.e_state); return VCD_ERR_BAD_STATE; } VCD_MSG_MED("Buffer type = %d", e_buffer); if (e_buffer == VCD_BUFFER_INPUT) { Prop_hdr.prop_id = DDL_I_INPUT_BUF_REQ; p_buf_pool = &p_cctxt->in_buf_pool; b_first_frm_recvd = p_cctxt->status.b_first_ip_frame_recvd; } else if (e_buffer == VCD_BUFFER_OUTPUT) { Prop_hdr.prop_id = DDL_I_OUTPUT_BUF_REQ; p_buf_pool = &p_cctxt->out_buf_pool; b_first_frm_recvd = p_cctxt->status.b_first_op_frame_recvd; } else { rc = VCD_ERR_ILLEGAL_PARM; } VCD_FAILED_RETURN(rc, "Invalid buffer type provided"); if (p_buf_pool->n_validated > 0) { VCD_MSG_ERROR("Need to free allocated buffers"); return VCD_ERR_ILLEGAL_OP; } if (b_first_frm_recvd) { VCD_MSG_ERROR("VCD SetBufReq called when data path is active"); return VCD_ERR_BAD_STATE; } Prop_hdr.n_size = sizeof(*p_buffer_req); rc = ddl_set_property(p_cctxt->ddl_handle, &Prop_hdr, p_buffer_req); VCD_FAILED_RETURN(rc, "Failed: ddl_set_property"); if (p_buf_pool->a_entries) { VCD_MSG_MED("Resetting buffer requirements"); vcd_free_buffer_pool_entries(p_buf_pool); } rc = vcd_alloc_buffer_pool_entries(p_buf_pool, p_buffer_req); return rc; }