void vcd_handle_device_init_failed(struct vcd_drv_ctxt *drv_ctxt, u32 status) { struct vcd_clnt_ctxt *client; struct vcd_clnt_ctxt *tmp_client; VCD_MSG_ERROR("Device init failed. status = %d", status); client = drv_ctxt->dev_ctxt.cctxt_list_head; while (client) { client->callback(VCD_EVT_RESP_OPEN, status, NULL, 0, 0, client->client_data); tmp_client = client; client = client->next; vcd_destroy_client_context(tmp_client); } if (ddl_device_release(NULL)) VCD_MSG_ERROR("Failed: ddl_device_release"); vcd_sched_destroy(&drv_ctxt->dev_ctxt.sched_clnt_list); if (vcd_power_event(&drv_ctxt->dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_FAIL)) VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_FAIL failed"); vcd_do_device_state_transition(drv_ctxt, VCD_DEVICE_STATE_NOT_INIT, DEVICE_STATE_EVENT_NUMBER(dev_cb)); }
static u32 vcd_open_in_not_init (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; u32 rc; VCD_MSG_LOW("vcd_open_in_dev_not_init:"); rc = vcd_open_cmn(drv_ctxt, driver_handle, decoding, callback, client_data, &cctxt); VCD_FAILED_RETURN(rc, "Failed: vcd_open_cmn"); rc = vcd_init_device_context(drv_ctxt, DEVICE_STATE_EVENT_NUMBER(open)); if (VCD_FAILED(rc)) vcd_destroy_client_context(cctxt); return rc; }
void vcd_handle_device_init_failed(struct vcd_drv_ctxt_type_t *p_drv_ctxt, u32 status) { struct vcd_clnt_ctxt_type_t *p_client; struct vcd_clnt_ctxt_type_t *p_tmp_client; VCD_MSG_ERROR("Device init failed. status = %d", status); p_client = p_drv_ctxt->dev_ctxt.p_cctxt_list_head; while (p_client) { p_client->callback(VCD_EVT_RESP_OPEN, status, 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 (ddl_device_release(NULL)) VCD_MSG_ERROR("Failed: ddl_device_release"); (void)sched_destroy(p_drv_ctxt->dev_ctxt.sched_hdl); p_drv_ctxt->dev_ctxt.sched_hdl = NULL; if (vcd_power_event(&p_drv_ctxt->dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_FAIL)) VCD_MSG_ERROR("VCD_EVT_PWR_DEV_INIT_FAIL failed"); vcd_do_device_state_transition(p_drv_ctxt, VCD_DEVICE_STATE_NOT_INIT, DEVICE_STATE_EVENT_NUMBER(pf_dev_cb)); }
static u32 vcd_close_in_open(struct vcd_clnt_ctxt *cctxt) { u32 rc = VCD_S_SUCCESS; VCD_MSG_LOW("vcd_close_in_open:"); if (cctxt->in_buf_pool.allocated || cctxt->out_buf_pool.allocated) { VCD_MSG_ERROR("\n Allocated buffers are not freed yet"); return VCD_ERR_ILLEGAL_OP; } vcd_destroy_client_context(cctxt); return rc; }
static u32 vcd_close_in_invalid(struct vcd_clnt_ctxt *cctxt) { VCD_MSG_LOW("vcd_close_in_invalid:"); if (cctxt->in_buf_pool.allocated || cctxt->out_buf_pool.allocated){ VCD_MSG_ERROR("Allocated buffers are not freed yet"); return VCD_ERR_ILLEGAL_OP; } if (cctxt->status.mask & VCD_CLEANING_UP) cctxt->status.mask |= VCD_CLOSE_PENDING; else vcd_destroy_client_context(cctxt); return VCD_S_SUCCESS; }
static u32 vcd_close_in_invalid(struct vcd_clnt_ctxt_type_t *p_cctxt) { VCD_MSG_LOW("vcd_close_in_invalid:"); if (p_cctxt->in_buf_pool.n_allocated || p_cctxt->out_buf_pool.n_allocated){ VCD_MSG_ERROR("Allocated buffers are not freed yet"); return VCD_ERR_ILLEGAL_OP; } if (p_cctxt->status.b_cleaning_up) p_cctxt->status.b_close_pending = TRUE; else vcd_destroy_client_context(p_cctxt); return VCD_S_SUCCESS; }
void vcd_clnt_handle_device_err_fatal(struct vcd_clnt_ctxt *cctxt, u32 event) { if (cctxt->clnt_state.state != VCD_CLIENT_STATE_NULL) { cctxt->callback(VCD_EVT_RESP_OPEN, VCD_ERR_HW_FATAL, NULL, 0, cctxt, cctxt->client_data); vcd_destroy_client_context(cctxt); return; } if (cctxt->clnt_state.state != VCD_CLIENT_STATE_INVALID) { cctxt->callback(event, VCD_ERR_HW_FATAL, NULL, 0, cctxt, cctxt->client_data); vcd_flush_buffers_in_err_fatal(cctxt); vcd_do_client_state_transition(cctxt, VCD_CLIENT_STATE_INVALID, CLIENT_STATE_EVENT_NUMBER(clnt_cb)); } }
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); vcd_destroy_client_context(cctxt); 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_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 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_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"); } } }