u32 vcd_init_device_context(struct vcd_drv_ctxt *drv_ctxt,
u32 ev_code)
{
struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;
u32 rc;
struct ddl_init_config ddl_init;
VCD_MSG_LOW("vcd_init_device_context:");
dev_ctxt->pending_cmd = VCD_CMD_NONE;
rc = vcd_power_event(dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_BEGIN);
VCD_FAILED_RETURN(rc, "VCD_EVT_PWR_DEV_INIT_BEGIN failed");
VCD_MSG_HIGH("Device powered ON and clocked");
rc = vcd_sched_create(&dev_ctxt->sched_clnt_list);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("rc = 0x%x. Failed: vcd_sched_create", rc);
(void)vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_FAIL);
return rc;
}
VCD_MSG_HIGH("Created scheduler instance.");
ddl_init.core_virtual_base_addr = dev_ctxt->device_base_addr;
ddl_init.interrupt_clr = dev_ctxt->config.interrupt_clr;
ddl_init.ddl_callback = vcd_ddl_callback;
rc = ddl_device_init(&ddl_init, NULL);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("rc = 0x%x. Failed: ddl_device_init", rc);
vcd_sched_destroy(&dev_ctxt->sched_clnt_list);
(void)vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_FAIL);
} else {
vcd_device_timer_start(dev_ctxt);
vcd_do_device_state_transition(drv_ctxt,
VCD_DEVICE_STATE_INITING,
ev_code);
}
#if 0// FEATURE_PANTECH_MMP_QCOM_CR, QC_Case#01099598, bump clock to turbo mode for clip which's macroblock count per second goes beyond 1080p 30fps
dev_ctxt->turbo_mode_set = 0;
#endif
return rc;
}
u32 vcd_init_device_context(struct vcd_drv_ctxt *drv_ctxt,
u32 ev_code)
{
struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;
u32 rc;
struct ddl_init_config ddl_init;
VCD_MSG_LOW("vcd_init_device_context:");
dev_ctxt->pending_cmd = VCD_CMD_NONE;
rc = vcd_power_event(dev_ctxt, NULL, VCD_EVT_PWR_DEV_INIT_BEGIN);
VCD_FAILED_RETURN(rc, "VCD_EVT_PWR_DEV_INIT_BEGIN failed");
VCD_MSG_HIGH("Device powered ON and clocked");
rc = vcd_sched_create(&dev_ctxt->sched_clnt_list);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("rc = 0x%x. Failed: vcd_sched_create", rc);
(void)vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_FAIL);
return rc;
}
VCD_MSG_HIGH("Created scheduler instance.");
ddl_init.core_virtual_base_addr = dev_ctxt->device_base_addr;
ddl_init.interrupt_clr = dev_ctxt->config.interrupt_clr;
ddl_init.ddl_callback = vcd_ddl_callback;
rc = ddl_device_init(&ddl_init, NULL);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("rc = 0x%x. Failed: ddl_device_init", rc);
vcd_sched_destroy(&dev_ctxt->sched_clnt_list);
(void)vcd_power_event(dev_ctxt, NULL,
VCD_EVT_PWR_DEV_INIT_FAIL);
} else {
vcd_device_timer_start(dev_ctxt);
vcd_do_device_state_transition(drv_ctxt,
VCD_DEVICE_STATE_INITING,
ev_code);
}
dev_ctxt->turbo_mode_set = 0;
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));
}
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));
}
u32 vcd_reset_device_context(struct vcd_drv_ctxt *drv_ctxt,
u32 ev_code)
{
struct vcd_dev_ctxt *dev_ctxt = &drv_ctxt->dev_ctxt;
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_reset_device_context:");
vcd_reset_device_channels(dev_ctxt);
rc = vcd_power_event(&drv_ctxt->dev_ctxt, NULL,
VCD_EVT_PWR_DEV_TERM_BEGIN);
VCD_FAILED_RETURN(rc, "VCD_EVT_PWR_DEV_TERM_BEGIN failed");
if (ddl_reset_hw(0))
VCD_MSG_HIGH("HW Reset done");
else
VCD_MSG_FATAL("HW Reset failed");
(void)vcd_power_event(dev_ctxt, NULL, VCD_EVT_PWR_DEV_TERM_END);
return VCD_S_SUCCESS;
}
static u32 vcd_stop_in_run(struct vcd_clnt_ctxt *cctxt)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_stop_in_run:");
rc = vcd_stop_cmn(cctxt);
if (!VCD_FAILED(rc) &&
(cctxt->status.mask & VCD_FIRST_IP_RCVD)) {
rc = vcd_power_event(cctxt->dev_ctxt,
cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);
}
return rc;
}
static u32 vcd_stop_in_run(struct vcd_clnt_ctxt_type_t *p_cctxt)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_stop_in_run:");
rc = vcd_stop_cmn(p_cctxt);
if (!VCD_FAILED(rc) && p_cctxt->status.b_first_ip_frame_recvd) {
rc = vcd_power_event(p_cctxt->p_dev_ctxt,
p_cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);
}
return rc;
}
static u32 vcd_stop_in_eos(struct vcd_clnt_ctxt *cctxt)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_stop_in_eos:");
if (cctxt->status.mask & VCD_EOS_WAIT_OP_BUF) {
rc = vcd_stop_cmn(cctxt);
if (!VCD_FAILED(rc)) {
rc = vcd_power_event(cctxt->dev_ctxt,
cctxt, VCD_EVT_PWR_CLNT_LAST_FRAME);
cctxt->status.mask &= ~VCD_EOS_WAIT_OP_BUF;
}
} else
cctxt->status.mask |= VCD_STOP_PENDING;
return rc;
}
static u32 vcd_pause_in_run(struct vcd_clnt_ctxt_type_t *p_cctxt)
{
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_pause_in_run:");
if (p_cctxt->b_sched_clnt_valid) {
rc = vcd_map_sched_status(sched_suspend_resume_client
(p_cctxt->p_dev_ctxt->sched_hdl,
p_cctxt->sched_clnt_hdl, FALSE));
}
VCD_FAILED_RETURN(rc, "Failed: sched_suspend_resume_client");
if (p_cctxt->status.n_frame_submitted > 0) {
vcd_do_client_state_transition(p_cctxt,
VCD_CLIENT_STATE_PAUSING,
CLIENT_STATE_EVENT_NUMBER
(pf_pause));
} else {
VCD_MSG_HIGH("No client frames are currently being processed");
vcd_do_client_state_transition(p_cctxt,
VCD_CLIENT_STATE_PAUSED,
CLIENT_STATE_EVENT_NUMBER
(pf_pause));
p_cctxt->callback(VCD_EVT_RESP_PAUSE,
VCD_S_SUCCESS,
NULL, 0, p_cctxt, p_cctxt->p_client_data);
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");
}
return VCD_S_SUCCESS;
}
static u32 vcd_resume_in_paused(struct vcd_clnt_ctxt_type_t *p_cctxt)
{
struct vcd_dev_ctxt_type *p_dev_ctxt = p_cctxt->p_dev_ctxt;
u32 rc = VCD_S_SUCCESS;
VCD_MSG_LOW("vcd_resume_in_paused:");
if (p_cctxt->b_sched_clnt_valid) {
rc = vcd_power_event(p_cctxt->p_dev_ctxt,
p_cctxt, VCD_EVT_PWR_CLNT_RESUME);
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR("VCD_EVT_PWR_CLNT_RESUME failed");
} else {
rc = vcd_map_sched_status(sched_suspend_resume_client
(p_cctxt->p_dev_ctxt->
sched_hdl,
p_cctxt->sched_clnt_hdl,
TRUE));
if (VCD_FAILED(rc)) {
VCD_MSG_ERROR
("rc = 0x%x. Failed: "
"sched_suspend_resume_client",
rc);
}
}
if (!VCD_FAILED(rc))
vcd_try_submit_frame(p_dev_ctxt);
}
if (!VCD_FAILED(rc)) {
vcd_do_client_state_transition(p_cctxt,
VCD_CLIENT_STATE_RUN,
CLIENT_STATE_EVENT_NUMBER
(pf_resume));
}
return rc;
}
//LGE_S NEXTi dongkyu31.lee
//static u32 vcd_pause_in_run(struct vcd_clnt_ctxt *cctxt)
static u32 vcd_pause_cmn(struct vcd_clnt_ctxt *cctxt)
{
u32 rc = VCD_S_SUCCESS;
//VCD_MSG_LOW("vcd_pause_in_run:");
VCD_MSG_LOW("vcd_pause_cmn:");
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_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 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_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_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_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");
}
}
}
}
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_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");
}
}
}
