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, transc = 0x%x\n", (u32)transc); if (transc) { VCD_MSG_ERROR("transc->in_use = %u, " "transc->cctxt = 0x%x\n", transc->in_use, (u32)transc->cctxt); } } 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; } } }
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 *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_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"); } } }