int disp_lcm_resume(disp_lcm_handle *plcm)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->resume_power)
{
lcm_drv->resume_power();
}
if(lcm_drv->resume)
{
lcm_drv->resume();
}
else
{
DISPERR("FATAL ERROR, lcm_drv->resume is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("lcm_drv is null\n");
return -1;
}
}
int disp_lcm_set_cmd(disp_lcm_handle *plcm, void* handle,int* lcm_cmd,unsigned int cmd_num)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->set_cmd)
{
lcm_drv->set_cmd(handle,lcm_cmd,cmd_num);
}
else
{
DISPERR("FATAL ERROR, lcm_drv->set_cmd is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("lcm_drv is null\n");
return -1;
}
}
int ext_disp_deinit(char *lcm_name)
{
DISPFUNC();
_ext_disp_path_lock();
if(pgc->state == EXTD_DEINIT)
goto deinit_exit;
dpmgr_path_deinit(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_destroy_path(pgc->dpmgr_handle,NULL);
cmdqRecDestroy(pgc->cmdq_handle_config);
cmdqRecDestroy(pgc->cmdq_handle_trigger);
pgc->state = EXTD_DEINIT;
deinit_exit:
_ext_disp_path_unlock();
is_context_inited = 0;
hdmi_smb_kpd_disable();
DISPMSG("ext_disp_deinit done \n" );
}
int extd_drv_init(extd_drv_handle *plcm)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
return 0;
if(_is_extd_drv_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->init)
{
lcm_drv->init();
}
else
{
DISPERR("FATAL ERROR, lcm_drv->init is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("plcm is null\n");
return -1;
}
}
int disp_lcm_esd_recover(disp_lcm_handle *plcm)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->esd_recover)
{
lcm_drv->esd_recover();
}
else
{
DISPERR("FATAL ERROR, lcm_drv->esd_check is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("lcm_drv is null\n");
return -1;
}
}
unsigned int disp_lcm_ATA(disp_lcm_handle *plcm)
{
unsigned int ret = 0;
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->ata_check)
{
ret = lcm_drv->ata_check(NULL);
}
else
{
DISPERR("FATAL ERROR, lcm_drv->ata_check is null\n");
return 0;
}
return ret;
}
else
{
DISPERR("lcm_drv is null\n");
return 0;
}
}
int ovl2mem_deinit(void)
{
int ret = -1;
DISPFUNC();
_ovl2mem_path_lock(__func__);
if (pgc->state == 0)
goto Exit;
ovl2mem_wait_done();
dpmgr_path_stop(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_path_deinit(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_destroy_path(pgc->dpmgr_handle, NULL);
cmdqRecDestroy(pgc->cmdq_handle_config);
pgc->dpmgr_handle = NULL;
pgc->cmdq_handle_config = NULL;
pgc->state = 0;
pgc->need_trigger_path = 0;
atomic_set(&g_trigger_ticket, 1);
atomic_set(&g_release_ticket, 1);
ovl2mem_layer_num = 0;
Exit:
_ovl2mem_path_unlock(__func__);
DISPMSG("ovl2mem_deinit done\n");
return ret;
}
int debug_get_info(unsigned char *stringbuf, int buf_len)
{
int i = 0;
int n = 0;
DISPFUNC();
n += mtkfb_get_debug_state(stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += primary_display_get_debug_state(stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += disp_sync_get_debug_info(stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += dprec_logger_get_result_string_all(stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += primary_display_check_path(stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += dprec_logger_get_buf(DPREC_LOGGER_ERROR, stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += dprec_logger_get_buf(DPREC_LOGGER_FENCE, stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
n += dprec_logger_get_buf(DPREC_LOGGER_HWOP, stringbuf + n, buf_len-n); DISPMSG("%s,%d, n=%d\n", __func__, __LINE__, n);
stringbuf[n++] = 0;
return n;
}
int ovl2mem_trigger(int blocking, void *callback, unsigned int userdata)
{
int ret = -1;
DISPFUNC();
if(pgc->need_trigger_path == 0)
{
DISPMSG("ovl2mem_trigger do not trigger\n");
return ret;
}
_ovl2mem_path_lock(__func__);
dpmgr_path_start(pgc->dpmgr_handle, ovl2mem_cmdq_enabled());
dpmgr_path_trigger(pgc->dpmgr_handle, pgc->cmdq_handle_config, ovl2mem_cmdq_enabled());
cmdqRecWait(pgc->cmdq_handle_config, CMDQ_EVENT_DISP_WDMA1_EOF);
dpmgr_path_stop(pgc->dpmgr_handle, ovl2mem_cmdq_enabled());
///cmdqRecDumpCommand(pgc->cmdq_handle_config);
cmdqRecFlushAsyncCallback(pgc->cmdq_handle_config, ovl2mem_callback, atomic_read(&g_trigger_ticket));
cmdqRecReset(pgc->cmdq_handle_config);
pgc->need_trigger_path = 0;
atomic_add(1, &g_trigger_ticket );
_ovl2mem_path_unlock(__func__);
DISPMSG("ovl2mem_trigger done %d\n", get_ovl2mem_ticket());
return ret;
}
int extd_drv_resume(extd_drv_handle *plcm)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
return 0;
if(_is_extd_drv_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->resume)
{
lcm_drv->resume();
}
else
{
DISPERR("FATAL ERROR, lcm_drv->esd_check is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("lcm_drv is null\n");
return -1;
}
}
int disp_lcm_set_backlight(disp_lcm_handle *plcm, void* handle,int level)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->set_backlight_cmdq)
{
lcm_drv->set_backlight_cmdq(handle,level);
}
else
{
DISPERR("FATAL ERROR, lcm_drv->set_backlight is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("lcm_drv is null\n");
return -1;
}
}
int ovl2mem_input_config(ovl2mem_in_config *input)
{
int ret = -1;
int i = 0;
disp_ddp_path_config *data_config;
DISPFUNC();
_ovl2mem_path_lock(__func__);
/* all dirty should be cleared in dpmgr_path_get_last_config() */
data_config = dpmgr_path_get_last_config(pgc->dpmgr_handle);
data_config->dst_dirty = 0;
data_config->ovl_dirty = 0;
data_config->rdma_dirty = 0;
if (pgc->state == 0) {
DISPMSG("ovl2mem is already slept\n");
_ovl2mem_path_unlock(__func__);
return 0;
}
/* hope we can use only 1 input struct for input config, just set layer number */
for (i = 0; i < HW_OVERLAY_COUNT; i++) {
dprec_logger_start(DPREC_LOGGER_PRIMARY_CONFIG,
input->layer | (input->layer_en << 16), input->addr);
if (input[i].layer_en) {
if (input[i].vaddr)
/* / _debug_pattern(0x00000000, input[i].vaddr, input[i].dst_w, input[i].dst_h,
input[i].src_pitch, 0x00000000, input[i].layer, input[i].buff_idx);
*/
;
else
/* /_debug_pattern(input[i].addr,0x00000000, input[i].dst_w, input[i].dst_h,
input[i].src_pitch, 0x00000000, input[i].layer, input[i].buff_idx);
*/
;
}
/* /DISPMSG("[primary], i:%d, layer:%d, layer_en:%d, dirty:%d -0x%x\n",
i, input[i].layer, input[i].layer_en, input[i].dirty, input[i].addr);
*/
if (input[i].dirty)
ret = _convert_disp_input_to_ovl(&(data_config->ovl_config[input[i].layer]),
(primary_disp_input_config *)&input[i]);
data_config->ovl_dirty = 1;
dprec_logger_done(DPREC_LOGGER_PRIMARY_CONFIG, input->src_x, input->src_y);
}
if (dpmgr_path_is_busy(pgc->dpmgr_handle))
dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_COMPLETE, HZ / 5);
ret = dpmgr_path_config(pgc->dpmgr_handle, data_config, pgc->cmdq_handle_config);
_ovl2mem_path_unlock(__func__);
DISPMSG("ovl2mem_input_config done\n");
return ret;
}
LCM_INTERFACE_ID disp_lcm_get_interface_id(disp_lcm_handle *plcm)
{
DISPFUNC();
if(_is_lcm_inited(plcm))
return plcm->lcm_if_id;
else
return LCM_INTERFACE_NOTDEFINED;
}
LCM_INTERFACE_ID extd_drv_get_interface_id(extd_drv_handle *plcm)
{
DISPFUNC();
if(_is_extd_drv_inited(plcm))
return plcm->lcm_if_id;
else
return LCM_INTERFACE_NOTDEFINED;
}
int ext_disp_suspend(void)
{
EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK;
DISPFUNC();
_ext_disp_path_lock();
if(pgc->state == EXTD_DEINIT || pgc->state == EXTD_SUSPEND)
{
DISPERR("EXTD_DEINIT or EXTD_SUSPEND\n");
goto done;
}
pgc->need_trigger_overlay = 0;
if(dpmgr_path_is_busy(pgc->dpmgr_handle))
{
dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/30);
}
if(ext_disp_use_cmdq == CMDQ_ENABLE)
_cmdq_stop_trigger_loop();
dpmgr_path_stop(pgc->dpmgr_handle, CMDQ_DISABLE);
//ALPS01857347+
dpmgr_path_power_off(pgc->dpmgr_handle, CMDQ_DISABLE);
//-
if(dpmgr_path_is_busy(pgc->dpmgr_handle))
{
dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/30);
}
///if(dpmgr_path_is_busy(pgc->dpmgr_handle))
dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE);
#if 0///(dpmgr_path_is_busy2(pgc->dpmgr_handle))
{
dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_check_status(pgc->dpmgr_handle);
}
#endif
extd_drv_suspend(pgc->plcm);
///dpmgr_path_power_off(pgc->dpmgr_handle, CMDQ_DISABLE);
pgc->state = EXTD_SUSPEND;
done:
_ext_disp_path_unlock();
DISPMSG("ext_disp_suspend done \n");
return ret;
}
int ext_disp_is_alive(void)
{
unsigned int temp = 0;
DISPFUNC();
_ext_disp_path_lock();
temp = pgc->state;
_ext_disp_path_unlock();
return temp;
}
// register rdma done event
int ext_disp_wait_for_idle(void)
{
EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK;
DISPFUNC();
_ext_disp_path_lock();
done:
_ext_disp_path_unlock();
return ret;
}
static ssize_t debug_read(struct file *file,
char __user *ubuf, size_t count, loff_t *ppos)
{
const int debug_bufmax = sizeof(debug_buffer) - 1;
int i = 0;
int n = 0;
DISPFUNC();
n += debug_get_info(debug_buffer + n, debug_bufmax-n);
//debug_info_dump_to_printk();
return simple_read_from_buffer(ubuf, count, ppos, debug_buffer, n);
}
static int _build_path_direct_link(void)
{
int ret = 0;
DISP_MODULE_ENUM dst_module = 0;
DISPFUNC();
pgc->mode = EXTD_DIRECT_LINK_MODE;
pgc->dpmgr_handle = dpmgr_create_path(DDP_SCENARIO_SUB_DISP, pgc->cmdq_handle_config);
if(pgc->dpmgr_handle)
{
DISPCHECK("dpmgr create path SUCCESS(%p)\n", pgc->dpmgr_handle);
}
else
{
DISPCHECK("dpmgr create path FAIL\n");
return -1;
}
dst_module = DISP_MODULE_DPI;
dpmgr_path_set_dst_module(pgc->dpmgr_handle, dst_module);
DISPCHECK("dpmgr set dst module FINISHED(%s)\n", ddp_get_module_name(dst_module));
{
M4U_PORT_STRUCT sPort;
sPort.ePortID = M4U_PORT_DISP_OVL1;
sPort.Virtuality = ext_disp_use_m4u;
sPort.Security = 0;
sPort.Distance = 1;
sPort.Direction = 0;
ret = m4u_config_port(&sPort);
if(ret == 0)
{
DISPCHECK("config M4U Port %s to %s SUCCESS\n",ddp_get_module_name(M4U_PORT_DISP_OVL1), ext_disp_use_m4u?"virtual":"physical");
}
else
{
DISPCHECK("config M4U Port %s to %s FAIL(ret=%d)\n",ddp_get_module_name(M4U_PORT_DISP_OVL1), ext_disp_use_m4u?"virtual":"physical", ret);
return -1;
}
}
dpmgr_set_lcm_utils(pgc->dpmgr_handle, pgc->plcm->drv);
dpmgr_enable_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);
dpmgr_enable_event(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE);
dpmgr_enable_event(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_START);
return ret;
}
int ovl2mem_trigger(int blocking, void *callback, unsigned int userdata)
{
int ret = -1;
int fence_idx = 0;
int layid = 0;
DISPFUNC();
if(pgc->need_trigger_path == 0)
{
DISPMSG("ovl2mem_trigger do not trigger\n");
if ((atomic_read(&g_trigger_ticket) - atomic_read(&g_release_ticket)) == 1)
{
DISPMSG("ovl2mem_trigger(%x), configue input, but does not config output!!\n", pgc->session);
for(layid = 0; layid < (HW_OVERLAY_COUNT + 1); layid++)
{
fence_idx = mtkfb_query_idx_by_ticket(pgc->session, layid, atomic_read(&g_trigger_ticket));
if(fence_idx >=0)
{
mtkfb_release_fence(pgc->session, layid, fence_idx);
}
}
}
return ret;
}
_ovl2mem_path_lock(__func__);
dpmgr_path_start(pgc->dpmgr_handle, ovl2mem_cmdq_enabled());
dpmgr_path_trigger(pgc->dpmgr_handle, pgc->cmdq_handle_config, ovl2mem_cmdq_enabled());
cmdqRecWait(pgc->cmdq_handle_config, CMDQ_EVENT_DISP_WDMA1_EOF);
dpmgr_path_stop(pgc->dpmgr_handle, ovl2mem_cmdq_enabled());
///cmdqRecDumpCommand(pgc->cmdq_handle_config);
cmdqRecFlushAsyncCallback(pgc->cmdq_handle_config, ovl2mem_callback, atomic_read(&g_trigger_ticket));
cmdqRecReset(pgc->cmdq_handle_config);
pgc->need_trigger_path = 0;
atomic_add(1, &g_trigger_ticket );
_ovl2mem_path_unlock(__func__);
dprec_logger_frame_seq_begin(pgc->session, mtkfb_query_frm_seq_by_addr(pgc->session, 0, 0));
DISPMSG("ovl2mem_trigger ovl2mem_seq %d-seq %d\n", get_ovl2mem_ticket(), mtkfb_query_frm_seq_by_addr(pgc->session, 0, 0));
return ret;
}
/* return 0: esd check pass */
int disp_lcm_esd_check(disp_lcm_handle *plcm)
{
LCM_DRIVER *lcm_drv = NULL;
DISPFUNC();
if (_is_lcm_inited(plcm)) {
lcm_drv = plcm->drv;
if (lcm_drv->esd_check)
return lcm_drv->esd_check();
DISPERR("FATAL ERROR, lcm_drv->esd_check is null\n");
return 0;
}
DISPERR("lcm_drv is null\n");
return 0;
}
void ovl2mem_wait_done(void)
{
int loop_cnt = 0;
if ((atomic_read(&g_trigger_ticket) - atomic_read(&g_release_ticket)) <= 1)
return;
DISPFUNC();
while ((atomic_read(&g_trigger_ticket) - atomic_read(&g_release_ticket)) > 1) {
dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_COMPLETE,
HZ / 30);
if (loop_cnt > 5)
break;
loop_cnt++;
}
DISPMSG("ovl2mem_wait_done loop %d, trigger tick:%d, release tick:%d\n", loop_cnt,
atomic_read(&g_trigger_ticket), atomic_read(&g_release_ticket));
}
int ovl2mem_deinit(void)
{
int ret = -1;
int loop_cnt = 0;
DISPFUNC();
_ovl2mem_path_lock(__func__);
if (pgc->state == 0)
goto Exit;
/* ovl2mem_wait_done(); */
ovl2mem_layer_num = 0;
while (((atomic_read(&g_trigger_ticket) - atomic_read(&g_release_ticket)) != 1) && (loop_cnt < 10)) {
msleep(5);
/* wait the last configuration done */
loop_cnt++;
}
dpmgr_path_stop(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_path_deinit(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_destroy_path(pgc->dpmgr_handle, NULL);
cmdqRecDestroy(pgc->cmdq_handle_config);
pgc->dpmgr_handle = NULL;
pgc->cmdq_handle_config = NULL;
pgc->state = 0;
pgc->need_trigger_path = 0;
atomic_set(&g_trigger_ticket, 1);
atomic_set(&g_release_ticket, 1);
Exit:
_ovl2mem_path_unlock(__func__);
DISPMSG("ovl2mem_deinit done\n");
return ret;
}
int disp_lcm_init(disp_lcm_handle *plcm, int force)
{
DISPFUNC();
LCM_DRIVER *lcm_drv = NULL;
if(_is_lcm_inited(plcm))
{
lcm_drv = plcm->drv;
if(lcm_drv->init_power)
{
if(!disp_lcm_is_inited(plcm) || force)
{
lcm_drv->init_power();
}
}
if(lcm_drv->init)
{
if(!disp_lcm_is_inited(plcm) || force)
{
lcm_drv->init();
}
}
else
{
DISPERR("FATAL ERROR, lcm_drv->init is null\n");
return -1;
}
return 0;
}
else
{
DISPERR("plcm is null\n");
return -1;
}
}
int disp_lcm_suspend(disp_lcm_handle *plcm)
{
LCM_DRIVER *lcm_drv = NULL;
DISPFUNC();
if (_is_lcm_inited(plcm)) {
lcm_drv = plcm->drv;
if (lcm_drv->suspend) {
lcm_drv->suspend();
} else {
DISPERR("FATAL ERROR, lcm_drv->suspend is null\n");
return -1;
}
if (lcm_drv->suspend_power)
lcm_drv->suspend_power();
return 0;
}
DISPERR("lcm_drv is null\n");
return -1;
}
int extd_drv_set_backlight(extd_drv_handle *plcm, int level)
{
DISPFUNC();
return 0;
}
int extd_drv_esd_recover(extd_drv_handle *plcm)
{
DISPFUNC();
return 0;
}
int extd_drv_esd_check(extd_drv_handle *plcm)
{
DISPFUNC();
return 0;
}
disp_lcm_handle* disp_lcm_probe(char* plcm_name, LCM_INTERFACE_ID lcm_id)
{
DISPFUNC();
int ret = 0;
int lcmindex = 0;
bool isLCMFound = false;
bool isLCMInited = false;
LCM_DRIVER *lcm_drv = NULL;
LCM_PARAMS *lcm_param = NULL;
disp_lcm_handle *plcm = NULL;
DISPCHECK("plcm_name=%s\n", plcm_name);
if(_lcm_count() == 0)
{
DISPERR("no lcm driver defined in linux kernel driver\n");
return NULL;
}
else if(_lcm_count() == 1)
{
if(plcm_name == NULL)
{
lcm_drv = lcm_driver_list[0];
isLCMFound = true;
isLCMInited = false;
}
else
{
lcm_drv = lcm_driver_list[0];
if(strcmp(lcm_drv->name, plcm_name))
{
DISPERR("FATAL ERROR!!!LCM Driver defined in kernel(%s) is different with LK(%s)\n",
lcm_drv->name, plcm_name);
return NULL;
}
isLCMInited = true;
isLCMFound = true;
}
lcmindex = 0;
}
else
{
if(plcm_name == NULL)
{
// TODO: we need to detect all the lcm driver
}
else
{
int i = 0;
for(i=0;i<_lcm_count();i++)
{
lcm_drv = lcm_driver_list[i];
if(!strcmp(lcm_drv->name, plcm_name))
{
isLCMFound = true;
isLCMInited = true;
lcmindex = i;
break;
}
}
DISPERR("FATAL ERROR: can't found lcm driver:%s in linux kernel driver\n", plcm_name);
}
// TODO:
}
if(isLCMFound == false)
{
DISPERR("FATAL ERROR!!!No LCM Driver defined\n");
return NULL;
}
plcm = kzalloc(sizeof(uint8_t*) *sizeof(disp_lcm_handle), GFP_KERNEL);
lcm_param = kzalloc(sizeof(uint8_t*) *sizeof(LCM_PARAMS), GFP_KERNEL);
if(plcm && lcm_param)
{
plcm->params = lcm_param;
plcm->drv = lcm_drv;
plcm->is_inited = isLCMInited;
plcm->index = lcmindex;
}
else
{
DISPERR("FATAL ERROR!!!kzalloc plcm and plcm->params failed\n");
goto FAIL;
}
{
plcm->drv->get_params(plcm->params);
plcm->lcm_if_id = plcm->params->lcm_if;
// below code is for lcm driver forward compatible
if(plcm->params->type == LCM_TYPE_DSI && plcm->params->lcm_if == LCM_INTERFACE_NOTDEFINED) plcm->lcm_if_id = LCM_INTERFACE_DSI0;
if(plcm->params->type == LCM_TYPE_DPI && plcm->params->lcm_if == LCM_INTERFACE_NOTDEFINED) plcm->lcm_if_id = LCM_INTERFACE_DPI0;
if(plcm->params->type == LCM_TYPE_DBI && plcm->params->lcm_if == LCM_INTERFACE_NOTDEFINED) plcm->lcm_if_id = LCM_INTERFACE_DBI0;
if((lcm_id == LCM_INTERFACE_NOTDEFINED) || lcm_id == plcm->lcm_if_id)
{
plcm->lcm_original_width = plcm->params->width;
plcm->lcm_original_height = plcm->params->height;
_dump_lcm_info(plcm);
return plcm;
}
else
{
DISPERR("the specific LCM Interface [%d] didn't define any lcm driver\n", lcm_id);
goto FAIL;
}
}
FAIL:
if(plcm) kfree(plcm);
if(lcm_param) kfree(lcm_param);
return NULL;
}
int ovl2mem_init(unsigned int session)
{
int ret = -1;
DISPFUNC();
dpmgr_init();
mutex_init(&(pgc->lock));
_ovl2mem_path_lock(__func__);
if(pgc->state > 0)
goto Exit;
#if 0
ret = cmdqCoreRegisterCB(CMDQ_GROUP_DISP, cmdqDdpClockOn,cmdqDdpDumpInfo,cmdqDdpResetEng,cmdqDdpClockOff);
if(ret)
{
DISPERR("cmdqCoreRegisterCB failed, ret=%d \n", ret);
goto done;
}
#endif
ret = cmdqRecCreate(CMDQ_SCENARIO_SUB_DISP,&(pgc->cmdq_handle_config));
if(ret)
{
DISPCHECK("cmdqRecCreate FAIL, ret=%d \n", ret);
goto Exit;
}
else
{
DISPCHECK("cmdqRecCreate SUCCESS, cmdq_handle=%p\n", pgc->cmdq_handle_config);
}
pgc->dpmgr_handle = dpmgr_create_path(DDP_SCENARIO_SUB_OVL_MEMOUT, pgc->cmdq_handle_config);
if(pgc->dpmgr_handle)
{
DISPCHECK("dpmgr create path SUCCESS(%p)\n", pgc->dpmgr_handle);
}
else
{
DISPCHECK("dpmgr create path FAIL\n");
goto Exit;
}
M4U_PORT_STRUCT sPort;
sPort.ePortID = M4U_PORT_DISP_OVL1;
sPort.Virtuality = ovl2mem_use_m4u;
sPort.Security = 0;
sPort.Distance = 1;
sPort.Direction = 0;
ret = m4u_config_port(&sPort);
sPort.ePortID = M4U_PORT_DISP_WDMA1;
sPort.Virtuality = ovl2mem_use_m4u;
sPort.Security = 0;
sPort.Distance = 1;
sPort.Direction = 0;
ret = m4u_config_port(&sPort);
if(ret == 0)
{
DISPCHECK("config M4U Port %s to %s SUCCESS\n",ddp_get_module_name(DISP_MODULE_OVL1), ovl2mem_use_m4u?"virtual":"physical");
}
else
{
DISPCHECK("config M4U Port %s to %s FAIL(ret=%d)\n",ddp_get_module_name(DISP_MODULE_OVL1), ovl2mem_use_m4u?"virtual":"physical", ret);
goto Exit;
}
dpmgr_path_set_video_mode(pgc->dpmgr_handle, ovl2mem_cmdq_enabled());
dpmgr_path_init(pgc->dpmgr_handle, CMDQ_DISABLE);
dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE);
//dpmgr_path_set_dst_module(pgc->dpmgr_handle,DISP_MODULE_ENUM dst_module)
dpmgr_enable_event(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_COMPLETE);
pgc->max_layer = 4;
pgc->state = 1;
pgc->session = session;
atomic_set(&g_trigger_ticket, 1);
atomic_set(&g_release_ticket, 1);
Exit:
_ovl2mem_path_unlock(__func__);
DISPMSG("ovl2mem_init done\n");
return ret;
}
