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 ext_disp_trigger(int blocking, void *callback, unsigned int userdata)
{
int ret = 0;
///DISPFUNC();
if((is_hdmi_active() == false)|| (pgc->state != EXTD_RESUME) || pgc->need_trigger_overlay < 1)
{
DISPMSG("trigger ext display is already sleeped\n");
MMProfileLogEx(ddp_mmp_get_events()->Extd_ErrorInfo, MMProfileFlagPulse, Trigger, 0 );
return -1;
}
_ext_disp_path_lock();
if(_should_trigger_interface())
{
_trigger_display_interface(blocking, callback, userdata);
}
else
{
_trigger_overlay_engine();
}
_ext_disp_path_unlock();
DISPMSG("ext_disp_trigger done \n");
return ret;
}
static int ovl2mem_callback(unsigned int userdata)
{
int fence_idx = 0;
int layid = 0;
DISPMSG("ovl2mem_callback(%x), current tick=%d, release tick: %d\n",
pgc->session, get_ovl2mem_ticket(), userdata);
for (layid = 0; layid < (HW_OVERLAY_COUNT + 1); layid++) {
fence_idx = mtkfb_query_idx_by_ticket(pgc->session, layid, userdata);
if (fence_idx >= 0) {
disp_ddp_path_config *data_config = dpmgr_path_get_last_config(pgc->dpmgr_handle);
WDMA_CONFIG_STRUCT wdma_layer;
wdma_layer.dstAddress = 0;
if (data_config && (layid >= HW_OVERLAY_COUNT)) {
wdma_layer.dstAddress = mtkfb_query_buf_mva(pgc->session, layid, fence_idx);
wdma_layer.outputFormat = data_config->wdma_config.outputFormat;
wdma_layer.srcWidth = data_config->wdma_config.srcWidth;
wdma_layer.srcHeight = data_config->wdma_config.srcHeight;
wdma_layer.dstPitch = data_config->wdma_config.dstPitch;
DISPMSG("mem_seq %x-seq+ %d\n", pgc->session, mtkfb_query_frm_seq_by_addr(pgc->session,
layid, wdma_layer.dstAddress));
dprec_logger_frame_seq_end(pgc->session, mtkfb_query_frm_seq_by_addr(pgc->session,
layid, wdma_layer.dstAddress));
dprec_mmp_dump_wdma_layer(&wdma_layer, 1);
}
mtkfb_release_fence(pgc->session, layid, fence_idx);
}
}
atomic_set(&g_release_ticket, userdata);
}
unsigned int disp_allocate_mva(unsigned int pa, unsigned int size, M4U_PORT_ID port)
{
int ret = 0;
unsigned int mva = 0;
m4u_client_t *client = NULL;
struct sg_table *sg_table = kzalloc(sizeof(struct sg_table), GFP_ATOMIC);
sg_alloc_table(sg_table, 1, GFP_KERNEL);
sg_dma_address(sg_table->sgl) = pa;
sg_dma_len(sg_table->sgl) = size;
client = m4u_create_client();
if (IS_ERR_OR_NULL(client))
DISPMSG("create client fail!\n");
mva = pa;
ret = m4u_alloc_mva(client, port, 0, sg_table, size, M4U_PROT_READ | M4U_PROT_WRITE,
M4U_FLAGS_FIX_MVA, &mva);
/* m4u_alloc_mva(M4U_PORT_DISP_OVL0, pa_start, (pa_end - pa_start + 1), 0, 0, mva); */
if (ret)
DISPMSG("m4u_alloc_mva returns fail: %d\n", ret);
DISPMSG("[DISPHAL] FB MVA is 0x%08X PA is 0x%08X\n", mva, pa);
return mva;
}
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;
}
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;
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;
}
void debug_info_dump_to_printk(char *buf, int buf_len)
{
int i = 0;
int n = buf_len;
for(i=0;i<n;i+=256)
DISPMSG("%s", buf+i);
}
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 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 disp_lcm_is_video_mode(disp_lcm_handle *plcm)
{
//DISPFUNC();
LCM_PARAMS *lcm_param = NULL;
LCM_INTERFACE_ID lcm_id = LCM_INTERFACE_NOTDEFINED;
if(_is_lcm_inited(plcm))
lcm_param = plcm->params;
else
ASSERT(0);
switch(lcm_param->type)
{
case LCM_TYPE_DBI:
return FALSE;
break;
case LCM_TYPE_DSI:
break;
case LCM_TYPE_DPI:
return TRUE;
break;
default:
DISPMSG("[LCM] TYPE: unknown\n");
break;
}
if(lcm_param->type == LCM_TYPE_DSI)
{
switch(lcm_param->dsi.mode)
{
case CMD_MODE:
return FALSE;
break;
case SYNC_PULSE_VDO_MODE:
case SYNC_EVENT_VDO_MODE:
case BURST_VDO_MODE:
return TRUE;
break;
default:
DISPMSG("[LCM] DSI Mode: Unknown\n");
break;
}
}
ASSERT(0);
}
static unsigned int cmdqDdpDumpInfo(uint64_t engineFlag, char *pOutBuf, unsigned int bufSize)
{
DISPMSG("ovl2mem cmdq timeout:%llu\n", engineFlag);
if (pgc->dpmgr_handle)
dpmgr_check_status(pgc->dpmgr_handle);
return 0;
}
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;
}
static int __init disp_init(void)
{
int ret = 0;
DISPMSG("Register the disp driver\n");
proc_entry = proc_create(DISP_DEVNAME,0644, NULL,&disp_fops);
if(proc_entry == NULL)
{
ret = -ENOMEM;
}
return ret;
}
int ovl2mem_output_config(ovl2mem_out_config* out)
{
int ret = -1;
int i = 0;
///DISPFUNC();
_ovl2mem_path_lock(__func__);
disp_ddp_path_config *data_config;
// 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 = 1;
data_config->dst_h = out->h;
data_config->dst_w = out->w;
data_config->ovl_dirty = 0;
data_config->rdma_dirty = 0;
data_config->wdma_dirty = 1;
data_config->wdma_config.dstAddress = out->addr;
data_config->wdma_config.srcHeight = out->h;
data_config->wdma_config.srcWidth = out->w;
data_config->wdma_config.clipX = out->x;
data_config->wdma_config.clipY = out->y;
data_config->wdma_config.clipHeight = out->h;
data_config->wdma_config.clipWidth = out->w;
data_config->wdma_config.outputFormat = out->fmt;
data_config->wdma_config.dstPitch = out->pitch;
data_config->wdma_config.useSpecifiedAlpha = 1;
data_config->wdma_config.alpha = 0xFF;
if(pgc->state == 0)
{
DISPMSG("ovl2mem is already sleeped\n");
_ovl2mem_path_unlock(__func__);
return 0;
}
if(dpmgr_path_is_busy(pgc->dpmgr_handle))
{
dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/5);
}
ret = dpmgr_path_config(pgc->dpmgr_handle, data_config, pgc->cmdq_handle_config);
pgc->need_trigger_path = 1;
_ovl2mem_path_unlock(__func__);
///DISPMSG("ovl2mem_output_config done\n");
return ret;
}
static ext_disp_path_context* _get_context(void)
{
static ext_disp_path_context g_context;
if(!is_context_inited)
{
memset((void*)&g_context, 0, sizeof(ext_disp_path_context));
is_context_inited = 1;
DISPMSG("_get_context set is_context_inited\n");
}
return &g_context;
}
static enum hrtimer_restart _DISP_CmdModeTimer_handler(struct hrtimer *timer)
{
DISPMSG("fake timer, wake up\n");
dpmgr_signal_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);
#if 0
if((get_current_time_us() - pgc->last_vsync_tick) > 16666)
{
dpmgr_signal_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC);
pgc->last_vsync_tick = get_current_time_us();
}
#endif
return HRTIMER_RESTART;
}
int disp_lcm_is_video_mode(disp_lcm_handle *plcm)
{
/* DISPFUNC(); */
LCM_PARAMS *lcm_param = NULL;
if (_is_lcm_inited(plcm))
lcm_param = plcm->params;
else
BUG();
switch (lcm_param->type) {
case LCM_TYPE_DBI:
return false;
case LCM_TYPE_DSI:
break;
case LCM_TYPE_DPI:
return true;
default:
DISPMSG("[LCM] TYPE: unknown\n");
break;
}
if (lcm_param->type == LCM_TYPE_DSI) {
switch (lcm_param->dsi.mode) {
case CMD_MODE:
return false;
case SYNC_PULSE_VDO_MODE:
case SYNC_EVENT_VDO_MODE:
case BURST_VDO_MODE:
return true;
default:
DISPMSG("[LCM] DSI Mode: Unknown\n");
break;
}
}
BUG();
return 0;
}
int disp_helper_get_option_list(char *stringbuf, int buf_len)
{
int len = 0;
int i = 0;
for (i = 0; i < DISP_HELPER_OPTION_NUM; i++) {
DISPMSG("Option: [%s] Value: [%d]\n", disp_helper_option_spy(i),
disp_helper_get_option(i));
len += scnprintf(stringbuf + len, buf_len - len,
"Option: [%d][%s] Value: [%d]\n", i, disp_helper_option_spy(i),
disp_helper_get_option(i));
}
return len;
}
static void _draw_block(unsigned long addr, unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned int linepitch, unsigned int color)
{
int i = 0;
int j = 0;
unsigned long start_addr = addr+linepitch*y+x*4;
DISPMSG("addr=0x%lx, start_addr=0x%lx, x=%d,y=%d,w=%d,h=%d,linepitch=%d, color=0x%08x\n", addr, start_addr, x,y,w,h,linepitch,color);
for(j=0;j<h;j++)
{
for(i = 0;i<w;i++)
{
*(unsigned long*)(start_addr + i*4 + j*linepitch) = color;
}
}
}
static int _init_vsync_fake_monitor(int fps)
{
static struct hrtimer cmd_mode_update_timer;
static ktime_t cmd_mode_update_timer_period;
if(fps == 0)
fps = 60;
cmd_mode_update_timer_period = ktime_set(0 , 1000/fps*1000);
DISPMSG("[MTKFB] vsync timer_period=%d \n", 1000/fps);
hrtimer_init(&cmd_mode_update_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
cmd_mode_update_timer.function = _DISP_CmdModeTimer_handler;
return 0;
}
static int ovl2mem_callback(unsigned int userdata)
{
int fence_idx = 0;
int layid = 0;
DISPMSG("ovl2mem_callback(%x), current tick=%d, release tick: %d\n", pgc->session, get_ovl2mem_ticket(), userdata);
for(layid = 0; layid < (HW_OVERLAY_COUNT + 1); layid++)
{
fence_idx = mtkfb_query_idx_by_ticket(pgc->session, layid, userdata);
if(fence_idx <0)
{
if(fence_idx == -1)
{
//DISPPR_ERROR("find fence idx for layer %d,addr 0x%08x fail, unregistered addr%d\n", layid, userdata, fence_idx);
}
else if(fence_idx == -2)
{
}
else
{
///DISPPR_ERROR("find fence idx for layer %d,addr 0x%08x fail,reason unknown%d\n", layid, userdata, fence_idx);
}
}
else
{
disp_ddp_path_config *data_config= dpmgr_path_get_last_config(pgc->dpmgr_handle);
if(data_config && (layid == 4))
{
WDMA_CONFIG_STRUCT wdma_layer;
wdma_layer.dstAddress = mtkfb_query_buf_mva(pgc->session, layid, fence_idx);
wdma_layer.outputFormat = data_config->wdma_config.outputFormat;
wdma_layer.srcWidth = data_config->wdma_config.srcWidth;
wdma_layer.srcHeight = data_config->wdma_config.srcHeight;
wdma_layer.dstPitch = data_config->wdma_config.dstPitch;
dprec_mmp_dump_wdma_layer(&wdma_layer, 1);
}
mtkfb_release_fence(pgc->session, layid, fence_idx);
}
}
atomic_set(&g_release_ticket, userdata);
}
void dprec_logger_event_init(dprec_logger_event *p, char *name, uint32_t level, MMP_Event *mmp_root)
{
if(p)
{
scnprintf(p->name, sizeof(p->name)/sizeof(p->name[0]), name);
if(mmp_root)
p->mmp = MMProfileRegisterEvent(mmp_root, name);
else
p->mmp = MMProfileRegisterEvent(ddp_mmp_get_events()->DDP, name);
MMProfileEnableEventRecursive(p->mmp, 1);
p->level = level;
memset((void*)&p->logger, 0, sizeof(p->logger));
DISPMSG("dprec logger event init, name=%s, level=0x%08x\n", name, level);
}
}
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 ext_disp_resume(void)
{
EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK;
_ext_disp_path_lock();
if(pgc->state < EXTD_INIT)
{
DISPERR("EXTD_DEINIT \n");
goto done;
}
dpmgr_path_power_on(pgc->dpmgr_handle, CMDQ_DISABLE);
extd_drv_resume(pgc->plcm);
///dpmgr_path_start(pgc->dpmgr_handle, CMDQ_DISABLE);
if(ext_disp_use_cmdq == CMDQ_ENABLE)
_cmdq_start_trigger_loop();
if(dpmgr_path_is_busy(pgc->dpmgr_handle))
{
DISPCHECK("stop display path failed, still busy\n");
ret = -1;
goto done;
}
pgc->state = EXTD_RESUME;
done:
_ext_disp_path_unlock();
DISPMSG("ext_disp_resume done \n");
return ret;
}
extd_drv_handle* extd_drv_probe(char* plcm_name, LCM_INTERFACE_ID lcm_id)
{
///DISPFUNC();
int ret = 0;
bool isLCMFound = false;
bool isLCMInited = false;
LCM_DRIVER *lcm_drv = NULL;
LCM_PARAMS *lcm_param = NULL;
extd_drv_handle *plcm = NULL;
DISPMSG("plcm_name=%s\n", plcm_name);
if(_extd_drv_count() == 0)
{
DISPERR("no lcm driver defined in linux kernel driver\n");
return NULL;
}
else if(_extd_drv_count() == 1)
{
if(plcm_name == NULL)
{
lcm_drv = NULL;
isLCMFound = true;
isLCMInited = true;
}
else
{
lcm_drv = NULL;
isLCMInited = true;
isLCMFound = true;
}
}
if(isLCMFound == false)
{
DISPERR("FATAL ERROR!!!No LCM Driver defined\n");
return NULL;
}
plcm = kzalloc(sizeof(uint8_t*) *sizeof(extd_drv_handle), GFP_KERNEL);
lcm_param = kzalloc(sizeof(uint8_t*) *sizeof(LCM_PARAMS), GFP_KERNEL);
if(plcm && lcm_param)
{
lcm_param->type = LCM_TYPE_DPI;
lcm_param->ctrl = LCM_CTRL_NONE;
lcm_param->lcm_if = LCM_INTERFACE_DPI0;
lcm_param->width = hdmi_get_width();
lcm_param->height = hdmi_get_height();
lcm_param->physical_width = lcm_param->width;
lcm_param->physical_height = lcm_param->height;
plcm->params = lcm_param;
plcm->drv = NULL;
plcm->is_inited = isLCMInited;
plcm->lcm_if_id = LCM_INTERFACE_DPI0;
}
else
{
DISPERR("FATAL ERROR!!!kzalloc plcm and plcm->params failed\n");
goto FAIL;
}
{
lcm_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)
{
_dump_extd_drv_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;
}
static void __exit disp_exit(void)
{
remove_proc_entry(DISP_DEVNAME,proc_entry);
DISPMSG("Done\n");
}
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;
}
static void process_dbg_opt(const char *opt)
{
if (0 == strncmp(opt, "stop_trigger_loop", 17))
{
_cmdq_stop_trigger_loop();
return;
}
else if (0 == strncmp(opt, "start_trigger_loop", 18))
{
_cmdq_start_trigger_loop();
return;
}
else if (0 == strncmp(opt, "cmdqregw:", 9))
{
char *p = (char *)opt + 9;
unsigned int addr = simple_strtoul(p, &p, 16);
unsigned int val = simple_strtoul(p + 1, &p, 16);
if (addr) {
primary_display_cmdq_set_reg(addr, val);
} else {
return;
}
}
else if (0 == strncmp(opt, "idle_switch_DC", 14))
{
if (0 == strncmp(opt + 14, "on", 2))
{
enable_screen_idle_switch_decouple();
printk("enable screen_idle_switch_decouple\n");
}
else if (0 == strncmp(opt + 14, "off", 3))
{
disable_screen_idle_switch_decouple();
printk("disable screen_idle_switch_decouple\n");
}
}
else if (0 == strncmp(opt, "shortpath", 9))
{
char *p = (char *)opt + 10;
int s = simple_strtoul(p, &p, 10);
DISPMSG("will %s use shorter decouple path\n", s?"":"not");
disp_helper_set_option(DISP_HELPER_OPTION_TWO_PIPE_INTERFACE_PATH, s);
}
else if (0 == strncmp(opt, "helper", 6))
{
char *p = (char *)opt + 7;
int option = simple_strtoul(p, &p, 10);
int value = simple_strtoul(p + 1, &p, 10);
DISPMSG("will set option %d to %d\n", option, value);
disp_helper_set_option(option, value);
}
else if (0 == strncmp(opt, "dc565", 5))
{
char *p = (char *)opt + 6;
int s = simple_strtoul(p, &p, 10);
DISPMSG("will %s use RGB565 decouple path\n", s?"":"not");
disp_helper_set_option(DISP_HELPER_OPTION_DECOUPLE_MODE_USE_RGB565, s);
}
else if (0 == strncmp(opt, "switch_mode:", 12))
{
int session_id = MAKE_DISP_SESSION(DISP_SESSION_PRIMARY,0);
char *p = (char *)opt + 12;
unsigned long sess_mode = simple_strtoul(p, &p, 10);
primary_display_switch_mode(sess_mode, session_id, 1);
}
else if (0 == strncmp(opt, "dsipattern", 10))
{
char *p = (char *)opt + 11;
unsigned int pattern = (unsigned int) simple_strtoul(p, &p, 16);
if (pattern)
{
DSI_BIST_Pattern_Test(DISP_MODULE_DSI0,NULL,true,pattern);
DISPMSG("enable dsi pattern: 0x%08x\n", pattern);
}
else
{
primary_display_manual_lock();
DSI_BIST_Pattern_Test(DISP_MODULE_DSI0,NULL,false,0);
primary_display_manual_unlock();
return;
}
}
else if (0 == strncmp(opt, "rdma_color:", 11))
{
printk("zeng: rdma_color\n");
if (0 == strncmp(opt + 11, "on", 2))
{
printk("zeng:rdma_color on\n");
char *p = (char *)opt + 14;
unsigned int red = simple_strtoul(p, &p, 10);
unsigned int green = simple_strtoul(p + 1, &p, 10);
unsigned int blue = simple_strtoul(p + 1, &p, 10);
rdma_color_matrix matrix = {0};
rdma_color_pre pre = {0};
rdma_color_post post = {255, 0, 0};
post.ADD0 = red;
post.ADD1 = green;
post.ADD2 = blue;
rdma_set_color_matrix(DISP_MODULE_RDMA0, &matrix, &pre, &post);
rdma_enable_color_transform(DISP_MODULE_RDMA0);
}
else if (0 == strncmp(opt + 11, "off", 3))
{
printk("zeng:rdma_color off\n");
rdma_disable_color_transform(DISP_MODULE_RDMA0);
}
}
else if (0 == strncmp(opt, "diagnose", 8))
{
primary_display_diagnose();
return;
}
else if (0 == strncmp(opt, "_efuse_test", 11))
{
primary_display_check_test();
}
else if (0 == strncmp(opt, "dprec_reset", 11))
{
dprec_logger_reset_all();
return;
}
else if (0 == strncmp(opt, "suspend", 4))
{
primary_display_suspend();
return;
}
else if (0 == strncmp(opt, "ata",3))
{
mtkfb_fm_auto_test();
return;
}
else if (0 == strncmp(opt, "resume", 4))
{
primary_display_resume();
}
else if (0 == strncmp(opt, "dalprintf", 9))
{
DAL_Printf("display aee layer test\n");
}
else if (0 == strncmp(opt, "dalclean", 8))
{
DAL_Clean();
}
else if(0 == strncmp(opt, "lfr_setting:",12))
{
char *p = (char *)opt + 12;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 12);
unsigned int mode = (unsigned int)simple_strtoul(p+1, &p, 12);
LCM_PARAMS lcm_param;
//unsigned int mode=3;
unsigned int type=0;
unsigned int skip_num = 1;
printk("--------------enable/disable lfr--------------\n");
if (enable)
{
printk("lfr enable %d mode =%d\n",enable,mode);
enable=1;
DSI_Set_LFR(DISP_MODULE_DSI0, NULL,mode,type,enable,skip_num);
}else{
printk("lfr disable %d mode=%d\n",enable,mode);
enable=0;
DSI_Set_LFR(DISP_MODULE_DSI0, NULL,mode,type,enable,skip_num);
}
}
else if(0 == strncmp(opt, "vsync_switch:",13))
{
char *p = (char *)opt + 13;
unsigned int method = 0;
method =(unsigned int) simple_strtoul(p, &p, 13);
primary_display_vsync_switch(method);
}
else if (0 == strncmp(opt, "DP", 2))
{
char *p = (char *)opt + 3;
unsigned int pattern = (unsigned int) simple_strtoul(p, &p, 16);
g_display_debug_pattern_index = pattern;
return;
}
else if(0==strncmp(opt,"dsi0_clk:",9))
{
char*p=(char*)opt+9;
UINT32 clk=simple_strtoul(p, &p, 10);
// DSI_ChangeClk(DISP_MODULE_DSI0,clk);
}
else if (0 == strncmp(opt, "diagnose", 8))
{
primary_display_diagnose();
return;
}
else if (0 == strncmp(opt, "switch:", 7))
{
char*p=(char*)opt+7;
UINT32 mode=simple_strtoul(p, &p, 10);
primary_display_switch_dst_mode(mode%2);
return;
}
else if (0 == strncmp(opt, "regw:", 5))
{
char *p = (char *)opt + 5;
unsigned long addr = simple_strtoul(p, &p, 16);
unsigned long val = simple_strtoul(p + 1, &p, 16);
if (addr) {
OUTREG32(addr, val);
} else {
return;
}
}
else if (0 == strncmp(opt, "regr:", 5))
{
char *p = (char *)opt + 5;
unsigned long addr = (unsigned int) simple_strtoul(p, &p, 16);
if (addr) {
printk("Read register 0x%lx: 0x%08x\n", addr, INREG32(addr));
} else {
return;
}
}
else if (0 == strncmp(opt, "cmmva_dprec", 11))
{
dprec_handle_option(0x7);
}
else if (0 == strncmp(opt, "cmmpa_dprec", 11))
{
dprec_handle_option(0x3);
}
else if (0 == strncmp(opt, "dprec", 5))
{
char *p = (char *)opt + 6;
unsigned int option = (unsigned int) simple_strtoul(p, &p, 16);
dprec_handle_option(option);
}
else if (0 == strncmp(opt, "cmdq", 4))
{
char *p = (char *)opt + 5;
unsigned int option = (unsigned int) simple_strtoul(p, &p, 16);
if(option)
primary_display_switch_cmdq_cpu(CMDQ_ENABLE);
else
primary_display_switch_cmdq_cpu(CMDQ_DISABLE);
}
else if (0 == strncmp(opt, "maxlayer", 8))
{
char *p = (char *)opt + 9;
unsigned int maxlayer = (unsigned int) simple_strtoul(p, &p, 10);
if(maxlayer)
primary_display_set_max_layer(maxlayer);
else
DISPERR("can't set max layer to 0\n");
}
else if (0 == strncmp(opt, "primary_reset", 13))
{
primary_display_reset();
}
else if(0 == strncmp(opt, "esd_check", 9))
{
char *p = (char *)opt + 10;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 10);
primary_display_esd_check_enable(enable);
}
else if(0 == strncmp(opt, "esd_recovery", 12))
{
primary_display_esd_recovery();
}
else if(0 == strncmp(opt, "lcm0_reset", 10))
{
#if 1
DISP_CPU_REG_SET(DISPSYS_CONFIG_BASE+0x150, 1);
msleep(10);
DISP_CPU_REG_SET(DISPSYS_CONFIG_BASE+0x150, 0);
msleep(10);
DISP_CPU_REG_SET(DISPSYS_CONFIG_BASE+0x150, 1);
#else
#if 0
mt_set_gpio_mode(GPIO106|0x80000000, GPIO_MODE_00);
mt_set_gpio_dir(GPIO106|0x80000000, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO106|0x80000000, GPIO_OUT_ONE);
msleep(10);
mt_set_gpio_out(GPIO106|0x80000000, GPIO_OUT_ZERO);
msleep(10);
mt_set_gpio_out(GPIO106|0x80000000, GPIO_OUT_ONE);
#endif
#endif
}
else if(0 == strncmp(opt, "lcm0_reset0", 11))
{
DISP_CPU_REG_SET(DDP_REG_BASE_MMSYS_CONFIG+0x150,0);
}
else if(0 == strncmp(opt, "lcm0_reset1", 11))
{
DISP_CPU_REG_SET(DDP_REG_BASE_MMSYS_CONFIG+0x150,1);
}
else if (0 == strncmp(opt, "cg", 2))
{
char *p = (char *)opt + 2;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 10);
primary_display_enable_path_cg(enable);
}
else if (0 == strncmp(opt, "ovl2mem:", 8))
{
if (0 == strncmp(opt + 8, "on", 2))
switch_ovl1_to_mem(true);
else
switch_ovl1_to_mem(false);
}
else if (0 == strncmp(opt, "dump_layer:", 11))
{
if (0 == strncmp(opt + 11, "on", 2))
{
char *p = (char *)opt + 14;
gCapturePriLayerDownX = simple_strtoul(p, &p, 10);
gCapturePriLayerDownY = simple_strtoul(p+1, &p, 10);
gCapturePriLayerNum= simple_strtoul(p+1, &p, 10);
gCapturePriLayerEnable = 1;
gCaptureWdmaLayerEnable = 1;
if(gCapturePriLayerDownX==0)
gCapturePriLayerDownX = 20;
if(gCapturePriLayerDownY==0)
gCapturePriLayerDownY = 20;
printk("dump_layer En %d DownX %d DownY %d,Num %d",gCapturePriLayerEnable,gCapturePriLayerDownX,gCapturePriLayerDownY,gCapturePriLayerNum);
}
else if (0 == strncmp(opt + 11, "off", 3))
{
gCapturePriLayerEnable = 0;
gCaptureWdmaLayerEnable = 0;
gCapturePriLayerNum = OVL_LAYER_NUM;
printk("dump_layer En %d\n",gCapturePriLayerEnable);
}
}
#ifdef MTK_TODO
#error
if (0 == strncmp(opt, "hdmion", 6))
{
// hdmi_force_init();
}
else if (0 == strncmp(opt, "fps:", 4))
{
if (0 == strncmp(opt + 4, "on", 2)) {
dbg_opt.en_fps_log = 1;
} else if (0 == strncmp(opt + 4, "off", 3)) {
dbg_opt.en_fps_log = 0;
} else {
goto Error;
}
reset_fps_logger();
}
else if (0 == strncmp(opt, "tl:", 3))
{
if (0 == strncmp(opt + 3, "on", 2)) {
dbg_opt.en_touch_latency_log = 1;
} else if (0 == strncmp(opt + 3, "off", 3)) {
dbg_opt.en_touch_latency_log = 0;
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "black", 5))
{
mtkfb_clear_lcm();
}
else if (0 == strncmp(opt, "suspend", 4))
{
DISP_PanelEnable(FALSE);
DISP_PowerEnable(FALSE);
}
else if (0 == strncmp(opt, "resume", 4))
{
DISP_PowerEnable(TRUE);
DISP_PanelEnable(TRUE);
}
else if (0 == strncmp(opt, "lcm:", 4))
{
if (0 == strncmp(opt + 4, "on", 2)) {
DISP_PanelEnable(TRUE);
} else if (0 == strncmp(opt + 4, "off", 3)) {
DISP_PanelEnable(FALSE);
}
else if (0 == strncmp(opt + 4, "init", 4)) {
if (NULL != lcm_drv && NULL != lcm_drv->init) {
lcm_drv->init();
}
}else {
goto Error;
}
}
else if (0 == strncmp(opt, "cabc:", 5))
{
if (0 == strncmp(opt + 5, "ui", 2)) {
mtkfb_set_backlight_mode(1);
}else if (0 == strncmp(opt + 5, "mov", 3)) {
mtkfb_set_backlight_mode(3);
}else if (0 == strncmp(opt + 5, "still", 5)) {
mtkfb_set_backlight_mode(2);
}else {
goto Error;
}
}
else if (0 == strncmp(opt, "lcd:", 4))
{
if (0 == strncmp(opt + 4, "on", 2)) {
DISP_PowerEnable(TRUE);
} else if (0 == strncmp(opt + 4, "off", 3)) {
DISP_PowerEnable(FALSE);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "vsynclog:", 9))
{
if (0 == strncmp(opt + 9, "on", 2))
{
EnableVSyncLog = 1;
} else if (0 == strncmp(opt + 9, "off", 3))
{
EnableVSyncLog = 0;
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "layer", 5))
{
dump_layer_info();
}
else if (0 == strncmp(opt, "regw:", 5))
{
char *p = (char *)opt + 5;
unsigned long addr = simple_strtoul(p, &p, 16);
unsigned long val = simple_strtoul(p + 1, &p, 16);
if (addr) {
OUTREG32(addr, val);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "regr:", 5))
{
char *p = (char *)opt + 5;
unsigned int addr = (unsigned int) simple_strtoul(p, &p, 16);
if (addr) {
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "Read register 0x%08x: 0x%08x\n", addr, INREG32(addr));
} else {
goto Error;
}
}
else if(0 == strncmp(opt, "bkl:", 4))
{
char *p = (char *)opt + 4;
unsigned int level = (unsigned int) simple_strtoul(p, &p, 10);
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "process_dbg_opt(), set backlight level = %d\n", level);
DISP_SetBacklight(level);
}
else if(0 == strncmp(opt, "dither:", 7))
{
unsigned lrs, lgs, lbs, dbr, dbg, dbb;
char *p = (char *)opt + 7;
lrs = (unsigned int) simple_strtoul(p, &p, 16);
p++;
lgs = (unsigned int) simple_strtoul(p, &p, 16);
p++;
lbs = (unsigned int) simple_strtoul(p, &p, 16);
p++;
dbr = (unsigned int) simple_strtoul(p, &p, 16);
p++;
dbg = (unsigned int) simple_strtoul(p, &p, 16);
p++;
dbb = (unsigned int) simple_strtoul(p, &p, 16);
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "process_dbg_opt(), %d %d %d %d %d %d\n", lrs, lgs, lbs, dbr, dbg, dbb);
}
else if (0 == strncmp(opt, "mtkfblog:", 9))
{
if (0 == strncmp(opt + 9, "on", 2)) {
mtkfb_log_enable(true);
} else if (0 == strncmp(opt + 9, "off", 3)) {
mtkfb_log_enable(false);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "displog:", 8))
{
if (0 == strncmp(opt + 8, "on", 2)) {
disp_log_enable(true);
} else if (0 == strncmp(opt + 8, "off", 3)) {
disp_log_enable(false);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "mtkfb_vsynclog:", 15))
{
if (0 == strncmp(opt + 15, "on", 2)) {
mtkfb_vsync_log_enable(true);
} else if (0 == strncmp(opt + 15, "off", 3)) {
mtkfb_vsync_log_enable(false);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "log:", 4))
{
if (0 == strncmp(opt + 4, "on", 2)) {
mtkfb_log_enable(true);
disp_log_enable(true);
} else if (0 == strncmp(opt + 4, "off", 3)) {
mtkfb_log_enable(false);
disp_log_enable(false);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "update", 6))
{
DISP_UpdateScreen(0, 0, DISP_GetScreenWidth(), DISP_GetScreenHeight());
}
else if (0 == strncmp(opt, "pan_disp", 8))
{
mtkfb_pan_disp_test();
}
else if (0 == strncmp(opt, "sem_cnt", 7))
{
mtkfb_show_sem_cnt();
}
else if (0 == strncmp(opt, "hang:", 5))
{
if (0 == strncmp(opt + 5, "on", 2)) {
mtkfb_hang_test(true);
} else if (0 == strncmp(opt + 5, "off", 3)) {
mtkfb_hang_test(false);
} else{
goto Error;
}
}
else if (0 == strncmp(opt, "cpfbonly:", 9))
{
if (0 == strncmp(opt + 9, "on", 2))
{
mtkfb_capture_fb_only(true);
}
else if (0 == strncmp(opt + 9, "off", 3))
{
mtkfb_capture_fb_only(false);
}
}
else if (0 == strncmp(opt, "esd:", 4))
{
if (0 == strncmp(opt + 4, "on", 2))
{
esd_recovery_pause(FALSE);
}
else if (0 == strncmp(opt + 4, "off", 3))
{
esd_recovery_pause(TRUE);
}
}
else if (0 == strncmp(opt, "HQA:", 4))
{
if (0 == strncmp(opt + 4, "NormalToFactory", 15))
{
mtkfb_switch_normal_to_factory();
}
else if (0 == strncmp(opt + 4, "FactoryToNormal", 15))
{
mtkfb_switch_factory_to_normal();
}
}
else if (0 == strncmp(opt, "mmp", 3))
{
init_mtkfb_mmp_events();
}
else if (0 == strncmp(opt, "dump_ovl:", 9))
{
if (0 == strncmp(opt + 9, "on", 2))
{
char *p = (char *)opt + 12;
gCaptureOvlDownX = simple_strtoul(p, &p, 10);
gCaptureOvlDownY = simple_strtoul(p+1, &p, 10);
gCaptureOvlThreadEnable = 1;
wake_up_process(captureovl_task);
}
else if (0 == strncmp(opt + 9, "off", 3))
{
gCaptureOvlThreadEnable = 0;
}
}
else if (0 == strncmp(opt, "dump_fb:", 8))
{
if (0 == strncmp(opt + 8, "on", 2))
{
char *p = (char *)opt + 11;
gCaptureFBDownX = simple_strtoul(p, &p, 10);
gCaptureFBDownY = simple_strtoul(p+1, &p, 10);
gCaptureFBPeriod = simple_strtoul(p+1, &p, 10);
gCaptureFBEnable = 1;
wake_up_interruptible(&gCaptureFBWQ);
}
else if (0 == strncmp(opt + 8, "off", 3))
{
gCaptureFBEnable = 0;
}
}
else
{
if (disphal_process_dbg_opt(opt))
goto Error;
}
return;
Error:
DISP_LOG_PRINT(ANDROID_LOG_INFO, "ERROR", "parse command error!\n\n%s", STR_HELP);
#endif
}
