int ext_disp_trigger(int blocking, void *callback, unsigned int userdata) { int ret = 0; EXT_DISP_FUNC(); if((is_hdmi_active() == false)|| pgc->state == EXTD_DEINIT || pgc->state == EXTD_SUSPEND || pgc->need_trigger_overlay < 1) { EXT_DISP_LOG("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(); } pgc->state = EXTD_RESUME; _ext_disp_path_unlock(); EXT_DISP_LOG("ext_disp_trigger done \n"); return ret; }
static int _build_path_direct_link(void) { int ret = 0; DISP_MODULE_ENUM dst_module = 0; EXT_DISP_FUNC(); pgc->mode = EXTD_DIRECT_LINK_MODE; pgc->dpmgr_handle = dpmgr_create_path(DDP_SCENARIO_SUB_DISP, pgc->cmdq_handle_config); if(pgc->dpmgr_handle) { EXT_DISP_LOG("dpmgr create path SUCCESS(%p)\n", pgc->dpmgr_handle); } else { EXT_DISP_LOG("dpmgr create path FAIL\n"); return -1; } dst_module = DISP_MODULE_DPI; dpmgr_path_set_dst_module(pgc->dpmgr_handle, dst_module); //EXT_DISP_LOG("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) { EXT_DISP_LOG("config M4U Port %s to %s SUCCESS\n",ddp_get_module_name(M4U_PORT_DISP_OVL1), ext_disp_use_m4u?"virtual":"physical"); } else { EXT_DISP_LOG("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 ext_disp_deinit(char *lcm_name) { EXT_DISP_FUNC(); _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; EXT_DISP_LOG("ext_disp_deinit done \n" ); return 0; }
static void _cmdq_stop_trigger_loop(void) { int ret = 0; // this should be called only once because trigger loop will nevet stop ret = cmdqRecStopLoop(pgc->cmdq_handle_trigger); EXT_DISP_LOG("ext display STOP cmdq trigger loop finished\n"); }
int ext_disp_switch_cmdq_cpu(CMDQ_SWITCH use_cmdq) { _ext_disp_path_lock(); ext_disp_use_cmdq = use_cmdq; EXT_DISP_LOG("display driver use %s to config register now\n", (use_cmdq==CMDQ_ENABLE)?"CMDQ":"CPU"); _ext_disp_path_unlock(); return ext_disp_use_cmdq; }
int ext_disp_resume(void) { EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK; EXT_DISP_FUNC(); _ext_disp_path_lock(); if(pgc->state != EXTD_SUSPEND) { EXT_DISP_ERR("EXTD_DEINIT/EXTD_INIT/EXTD_RESUME \n"); goto done; } if(_should_reset_cmdq_config_handle()) { _cmdq_reset_config_handle(); } dpmgr_path_power_on(pgc->dpmgr_handle, CMDQ_DISABLE); extd_drv_resume(pgc->plcm); if(ext_disp_use_cmdq == CMDQ_ENABLE) { _cmdq_start_trigger_loop(); } if(dpmgr_path_is_busy(pgc->dpmgr_handle)) { EXT_DISP_LOG("stop display path failed, still busy\n"); ret = -1; goto done; } pgc->state = EXTD_RESUME; done: _ext_disp_path_unlock(); EXT_DISP_LOG("ext_disp_resume 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; EXT_DISP_LOG("_get_context set is_context_inited\n"); } return &g_context; }
static enum hrtimer_restart _DISP_CmdModeTimer_handler(struct hrtimer *timer) { EXT_DISP_LOG("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 ext_disp_diagnose(void) { int ret = 0; if(is_context_inited > 0) { EXT_DISP_LOG("ext_disp_diagnose, is_context_inited --%d\n", is_context_inited); dpmgr_check_status(pgc->dpmgr_handle); ///ddp_dpi_dump(DISP_MODULE_DPI , 0); } else // ddp_dpi_dump(DISP_MODULE_DPI , 0); return ret; }
static void _cmdq_start_trigger_loop(void) { int ret = 0; // this should be called only once because trigger loop will nevet stop ret = cmdqRecStartLoop(pgc->cmdq_handle_trigger); if(!ext_disp_is_video_mode()) { // need to set STREAM_EOF for the first time, otherwise we will stuck in dead loop cmdqCoreSetEvent(CMDQ_SYNC_TOKEN_STREAM_EOF); ///dprec_event_op(DPREC_EVENT_CMDQ_SET_EVENT_ALLOW); } EXT_DISP_LOG("START cmdq trigger loop finished\n"); }
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); EXT_DISP_LOG("[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; }
int ext_disp_wait_for_vsync(void *config) { disp_session_vsync_config *c = (disp_session_vsync_config *)config; int ret = 0; ret = dpmgr_wait_event(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC); ///dprec_logger_trigger(DPREC_LOGGER_VSYNC); if(ret == -2) { EXT_DISP_LOG("vsync for ext display path not enabled yet\n"); return -1; } //EXT_DISP_LOG("vsync signaled\n"); c->vsync_ts = get_current_time_us(); c->vsync_cnt ++; return ret; }
int ext_disp_suspend(void) { EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK; EXT_DISP_FUNC(); _ext_disp_path_lock(); if(pgc->state == EXTD_DEINIT || pgc->state == EXTD_SUSPEND) { EXT_DISP_ERR("status is not EXTD_RESUME\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); 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); } dpmgr_path_reset(pgc->dpmgr_handle, CMDQ_DISABLE); extd_drv_suspend(pgc->plcm); pgc->state = EXTD_SUSPEND; done: _ext_disp_path_unlock(); EXT_DISP_LOG("ext_disp_suspend done \n"); return ret; }
static void _cmdq_build_trigger_loop(void) { int ret = 0; cmdqRecCreate(CMDQ_SCENARIO_TRIGGER_LOOP, &(pgc->cmdq_handle_trigger)); EXT_DISP_LOG("ext_disp path trigger thread cmd handle=%p\n", pgc->cmdq_handle_trigger); cmdqRecReset(pgc->cmdq_handle_trigger); if(ext_disp_is_video_mode()) { // wait and clear stream_done, HW will assert mutex enable automatically in frame done reset. // todo: should let dpmanager to decide wait which mutex's eof. ret = cmdqRecWait(pgc->cmdq_handle_trigger, dpmgr_path_get_mutex(pgc->dpmgr_handle) + CMDQ_EVENT_MUTEX0_STREAM_EOF); ///dpmgr_path_get_mutex(pgc->dpmgr_handle) // for some module(like COLOR) to read hw register to GPR after frame done dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_AFTER_STREAM_EOF); } else { // DSI command mode doesn't have mutex_stream_eof, need use CMDQ token instead ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_CONFIG_DIRTY); //ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_EVENT_MDP_DSI0_TE_SOF); // for operations before frame transfer, such as waiting for DSI TE dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_BEFORE_STREAM_SOF); // cleat frame done token, now the config thread will not allowed to config registers. // remember that config thread's priority is higher than trigger thread, so all the config queued before will be applied then STREAM_EOF token be cleared // this is what CMDQ did as "Merge" ret = cmdqRecClearEventToken(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_STREAM_EOF); // enable mutex, only cmd mode need this // this is what CMDQ did as "Trigger" dpmgr_path_trigger(pgc->dpmgr_handle, pgc->cmdq_handle_trigger, CMDQ_ENABLE); //ret = cmdqRecWrite(pgc->cmdq_handle_trigger, (unsigned int)(DISP_REG_CONFIG_MUTEX_EN(0))&0x1fffffff, 1, ~0); // waiting for frame done, because we can't use mutex stream eof here, so need to let dpmanager help to decide which event to wait // most time we wait rdmax frame done event. ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_EVENT_DISP_RDMA1_EOF); dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_WAIT_STREAM_EOF_EVENT); // dsi is not idle rightly after rdma frame done, so we need to polling about 1us for dsi returns to idle // do not polling dsi idle directly which will decrease CMDQ performance dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_CHECK_IDLE_AFTER_STREAM_EOF); // for some module(like COLOR) to read hw register to GPR after frame done dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_AFTER_STREAM_EOF); // polling DSI idle //ret = cmdqRecPoll(pgc->cmdq_handle_trigger, 0x1401b00c, 0, 0x80000000); // polling wdma frame done //ret = cmdqRecPoll(pgc->cmdq_handle_trigger, 0x140060A0, 1, 0x1); // now frame done, config thread is allowed to config register now ret = cmdqRecSetEventToken(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_STREAM_EOF); // RUN forever!!!! BUG_ON(ret < 0); } // dump trigger loop instructions to check whether dpmgr_path_build_cmdq works correctly cmdqRecDumpCommand(pgc->cmdq_handle_trigger); EXT_DISP_LOG("ext display BUILD cmdq trigger loop finished\n"); return; }
int ext_disp_config_input(ext_disp_input_config* input) { int ret = 0; int i=0; int layer =0; ///EXT_DISP_FUNC(); disp_ddp_path_config *data_config; if((is_hdmi_active() == false)|| ext_disp_is_sleepd()) { EXT_DISP_LOG("ext disp is already sleeped\n"); return 0; } _ext_disp_path_lock(); data_config = dpmgr_path_get_last_config(pgc->dpmgr_handle); if(input->layer_en) { if(input->vaddr) { ///_debug_pattern(0x00000000, input->vaddr, input->dst_w, input->dst_h, input->src_pitch, 0x00000000, input->layer, input->buff_idx); } else { ///_debug_pattern(input->addr,0x00000000, input->dst_w, input->dst_h, input->src_pitch, 0x00000000, input->layer, input->buff_idx); } } #ifdef EXTD_DBG_USE_INNER_BUF if(input->fmt == eYUY2) { ///input->layer_en = 1; ///memset(input, 0, sizeof(ext_disp_input_config)); input->layer_en = 1; input->addr = hdmi_mva_r ; input->vaddr = hdmi_va ; input->fmt = eRGB888; ///eRGBA8888 eYUY2 input->src_w = 1280; input->src_h = 720; input->src_x = 0; input->src_y = 0; input->src_pitch = 1280*3; input->dst_w = 1280; input->dst_h = 720; input->dst_x = 0; input->dst_y = 0; input->aen = 0; input->alpha = 0xff; } #endif // hope we can use only 1 input struct for input config, just set layer number if(_should_config_ovl_input()) { ret = _convert_disp_input_to_ovl(&(data_config->ovl_config[input->layer]), input); data_config->ovl_dirty = 1; } else { ret = _convert_disp_input_to_rdma(&(data_config->rdma_config), input); data_config->rdma_dirty= 1; } ///EXT_DISP_ERR("ext_disp_config_input cmdq %d wi %d ovl %d vm %d\n", ext_disp_cmdq_enabled(), _should_wait_path_idle(), _should_config_ovl_input(), ext_disp_is_video_mode()); if(_should_wait_path_idle()) { dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/2); } memcpy(&(data_config->dispif_config), &(extd_dpi_params.dispif_config), sizeof(LCM_PARAMS)); ret = dpmgr_path_config(pgc->dpmgr_handle, data_config, ext_disp_cmdq_enabled()? pgc->cmdq_handle_config : NULL); // this is used for decouple mode, to indicate whether we need to trigger ovl pgc->need_trigger_overlay = 1; ///EXT_DISP_LOG("ext_disp_config_input done \n"); _ext_disp_path_unlock(); return ret; }
int ext_disp_init(char *lcm_name, unsigned int session) { EXT_DISP_FUNC(); EXT_DISP_STATUS ret = EXT_DISP_STATUS_OK; //DISP_MODULE_ENUM dst_module = 0; LCM_PARAMS *lcm_param = NULL; //LCM_INTERFACE_ID lcm_id = LCM_INTERFACE_NOTDEFINED; dpmgr_init(); extd_mutex_init(&(pgc->lock)); _ext_disp_path_lock(); pgc->plcm = extd_drv_probe( lcm_name, LCM_INTERFACE_NOTDEFINED); if(pgc->plcm == NULL) { EXT_DISP_LOG("disp_lcm_probe returns null\n"); ret = EXT_DISP_STATUS_ERROR; //goto done; //Donglei } lcm_param = extd_drv_get_params(pgc->plcm); if(lcm_param == NULL) { EXT_DISP_ERR("get lcm params FAILED\n"); ret = EXT_DISP_STATUS_ERROR; goto done; } #if 0 ret = cmdqCoreRegisterCB(CMDQ_GROUP_DISP, cmdqDdpClockOn, cmdqDdpDumpInfo, cmdqDdpResetEng, cmdqDdpClockOff); if(ret) { EXT_DISP_ERR("cmdqCoreRegisterCB failed, ret=%d \n", ret); ret = EXT_DISP_STATUS_ERROR; goto done; } #endif ret = cmdqRecCreate(CMDQ_SCENARIO_MHL_DISP, &(pgc->cmdq_handle_config)); if(ret) { EXT_DISP_LOG("cmdqRecCreate FAIL, ret=%d \n", ret); ret = EXT_DISP_STATUS_ERROR; goto done; } else { EXT_DISP_LOG("cmdqRecCreate SUCCESS, g_cmdq_handle=%p \n", pgc->cmdq_handle_config); } if(ext_disp_mode == EXTD_DIRECT_LINK_MODE) { _build_path_direct_link(); // EXT_DISP_LOG("ext_disp display is DIRECT LINK MODE\n"); } else if(ext_disp_mode == EXTD_DECOUPLE_MODE) { _build_path_decouple(); // EXT_DISP_LOG("ext_disp display is DECOUPLE MODE\n"); } else if(ext_disp_mode == EXTD_SINGLE_LAYER_MODE) { _build_path_single_layer(); // EXT_DISP_LOG("ext_disp display is SINGLE LAYER MODE\n"); } else if(ext_disp_mode == EXTD_RDMA_DPI_MODE) { _build_path_rdma_dpi(); // EXT_DISP_LOG("ext_disp display is RDMA to dpi MODE\n"); } else { EXT_DISP_LOG("ext_disp display mode is WRONG\n"); } if(ext_disp_use_cmdq == CMDQ_ENABLE) { _cmdq_build_trigger_loop(); EXT_DISP_LOG("ext_disp display BUILD cmdq trigger loop finished\n"); _cmdq_start_trigger_loop(); } pgc->session = session; EXT_DISP_LOG("ext_disp display START cmdq trigger loop finished\n"); dpmgr_path_set_video_mode(pgc->dpmgr_handle, ext_disp_is_video_mode()); dpmgr_path_init(pgc->dpmgr_handle, CMDQ_DISABLE); disp_ddp_path_config *data_config = (disp_ddp_path_config *)vmalloc(sizeof(disp_ddp_path_config)); if(data_config) { memset((void*)data_config, 0, sizeof(disp_ddp_path_config)); memcpy(&(data_config->dispif_config), &(extd_dpi_params.dispif_config), sizeof(LCM_PARAMS)); data_config->dst_w = lcm_param->width; data_config->dst_h = lcm_param->height; data_config->dst_dirty = 1; init_roi = 0; ret = dpmgr_path_config(pgc->dpmgr_handle, data_config, CMDQ_DISABLE); } else { EXT_DISP_LOG("allocate buffer failed!!!\n"); } if(!extd_drv_is_inited(pgc->plcm)) { ret = extd_drv_init(pgc->plcm); } // this will be set to always enable cmdq later if(ext_disp_is_video_mode()) { dpmgr_map_event_to_irq(pgc->dpmgr_handle, DISP_PATH_EVENT_IF_VSYNC, DDP_IRQ_RDMA1_DONE); } if(ext_disp_use_cmdq == CMDQ_ENABLE) { _cmdq_reset_config_handle(); //_cmdq_insert_wait_frame_done_token(); //Fixed me: why insert EOF event before the first frame start } dpmgr_path_power_on(pgc->dpmgr_handle, CMDQ_DISABLE); pgc->state = EXTD_INIT; done: _ext_disp_path_unlock(); dpmgr_path_stop(pgc->dpmgr_handle, CMDQ_DISABLE); EXT_DISP_LOG("ext_disp_init done \n"); return ret; }
int ext_disp_config_input_multiple(ext_disp_input_config* input, int idx) { int ret = 0; int i=0; int layer =0; ///EXT_DISP_FUNC(); disp_ddp_path_config *data_config; if((is_hdmi_active() == false) || (pgc->state != EXTD_INIT && pgc->state != EXTD_RESUME) ) { EXT_DISP_LOG("[Donglei]config ext disp is already sleeped, hdmi_active:%d, state:%d\n", is_hdmi_active(), pgc->state); MMProfileLogEx(ddp_mmp_get_events()->Extd_ErrorInfo, MMProfileFlagPulse, Config, idx ); return -2; } _ext_disp_path_lock(); // all dirty should be cleared in dpmgr_path_get_last_config() data_config = dpmgr_path_get_last_config(pgc->dpmgr_handle); // hope we can use only 1 input struct for input config, just set layer number if(_should_config_ovl_input()) { for(i = 0;i<HW_OVERLAY_COUNT;i++) { if(input[i].dirty) { ret = _convert_disp_input_to_ovl(&(data_config->ovl_config[input[i].layer]), &input[i]); dprec_mmp_dump_ovl_layer(&(data_config->ovl_config[input[i].layer]), input[i].layer, 2); } if (init_roi == 1) { LCM_PARAMS *lcm_param = extd_drv_get_params(pgc->plcm); memcpy(&(data_config->dispif_config), &(extd_dpi_params.dispif_config), sizeof(LCM_PARAMS)); if(lcm_param != NULL) { EXT_DISP_LOG("set dest w:%d, h:%d\n", lcm_param->width, lcm_param->height); data_config->dst_w = lcm_param->width; data_config->dst_h = lcm_param->height; } data_config->dst_dirty = 1; data_config->rdma_config.address = 0; } data_config->ovl_dirty = 1; } } else { OVL_CONFIG_STRUCT ovl_config; _convert_disp_input_to_ovl(&ovl_config, input); dprec_mmp_dump_ovl_layer(&ovl_config, input->layer, 2); ret = _convert_disp_input_to_rdma(&(data_config->rdma_config), input); if (data_config->rdma_config.address) { data_config->rdma_dirty = 1; } } if(_should_wait_path_idle()) { dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/2); } memcpy(&(data_config->dispif_config), &(extd_dpi_params.dispif_config), sizeof(LCM_PARAMS)); ret = dpmgr_path_config(pgc->dpmgr_handle, data_config, ext_disp_cmdq_enabled()? pgc->cmdq_handle_config : NULL); // this is used for decouple mode, to indicate whether we need to trigger ovl pgc->need_trigger_overlay = 1; init_roi = 0; _ext_disp_path_unlock(); if (data_config->ovl_dirty) { EXT_DISP_LOG("config_input_multiple idx:%d -w:%d, h:%d, pitch:%d\n", idx ,data_config->ovl_config[0].src_w, data_config->ovl_config[0].src_h, data_config->ovl_config[0].src_pitch); }else{ EXT_DISP_LOG("config_input_multiple idx:%d -w:%d, h:%d, pitch:%d, mva:%p\n", idx ,data_config->rdma_config.width, data_config->rdma_config.height, data_config->rdma_config.pitch, data_config->rdma_config.address); } return ret; }
static int _trigger_display_interface(int blocking, void *callback, unsigned int userdata) { ///EXT_DISP_FUNC(); int i = 0; bool reg_flush = false; if(_should_wait_path_idle()) { dpmgr_wait_event_timeout(pgc->dpmgr_handle, DISP_PATH_EVENT_FRAME_DONE, HZ/2); } if(_should_update_lcm()) { extd_drv_update(pgc->plcm, 0, 0, pgc->plcm->params->width, pgc->plcm->params->height, 0); } if(_should_start_path()) { reg_flush = true; dpmgr_path_start(pgc->dpmgr_handle, ext_disp_cmdq_enabled()); MMProfileLogEx(ddp_mmp_get_events()->Extd_State, MMProfileFlagPulse, Trigger, 1); } if(_should_trigger_path()) { // trigger_loop_handle is used only for build trigger loop, which should always be NULL for config thread dpmgr_path_trigger(pgc->dpmgr_handle, NULL, ext_disp_cmdq_enabled()); } if(_should_set_cmdq_dirty()) { _cmdq_set_config_handle_dirty(); } ///if(reg_flush == false) { #if 0 if(reg_flush == false) { if(_should_insert_wait_frame_done_token()) { _cmdq_insert_wait_frame_done_token(); } } if(_should_flush_cmdq_config_handle()) { _cmdq_flush_config_handle(reg_flush); } if(_should_reset_cmdq_config_handle()) { _cmdq_reset_config_handle(); } if(reg_flush == true) { if(_should_insert_wait_frame_done_token()) { _cmdq_insert_wait_frame_done_token(); } } ///cmdqRecDumpCommand(cmdqRecHandle handle) #else if(_should_flush_cmdq_config_handle()) { if(reg_flush) { MMProfileLogEx(ddp_mmp_get_events()->Extd_State, MMProfileFlagPulse, Trigger, 2); } if(_should_start_path()) { EXT_DISP_LOG("Wait Main Display Vsync\n"); disp_session_vsync_config vsync_config; primary_display_wait_for_vsync(&vsync_config); } _cmdq_flush_config_handle(blocking, callback, userdata); } if(_should_reset_cmdq_config_handle()) { _cmdq_reset_config_handle(); } if(_should_insert_wait_frame_done_token()) { _cmdq_insert_wait_frame_done_token(); } #endif } return 0; }