DISP_STATUS DISP_UpdateScreen(UINT32 x, UINT32 y, UINT32 width, UINT32 height)
{
LCD_CHECK_RET(LCD_WaitForNotBusy());
if ((lcm_drv->update) &&
((lcm_params->type==LCM_TYPE_DBI) || ((lcm_params->type==LCM_TYPE_DSI) && (lcm_params->dsi.mode==CMD_MODE))))
{
lcm_drv->update(x, y, width, height);
}
LCD_CHECK_RET(LCD_SetRoiWindow(x, y, width, height));
LCD_CHECK_RET(LCD_FBSetStartCoord(x, y));
LCD_CHECK_RET(LCD_StartTransfer(FALSE));
if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode==CMD_MODE) {
DSI_clk_HS_mode(1);
DSI_CHECK_RET(DSI_EnableClk());
}
else if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode!=CMD_MODE) {
DSI_clk_HS_mode(1);
DPI_CHECK_RET(DPI_EnableClk());
DSI_CHECK_RET(DSI_EnableClk());
}
return DISP_STATUS_OK;
}
static ssize_t layer_debug_read(struct file *file,
char __user *ubuf, size_t count, loff_t *ppos)
{
int ret;
MTKFB_LAYER_DBG_OPTIONS *dbgopt = (MTKFB_LAYER_DBG_OPTIONS *)file->private_data;
UINT32 aligned_buffer;
if(dbgopt->working_buf == 0)
{
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "No working buffer is available \n");
return 0;
}
///if LCD layer is enabled
if(!LCD_IsLayerEnable(dbgopt->layer_index))
{
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "The layer %d is not enabled \n", dbgopt->layer_index);
return 0;
}
aligned_buffer = (dbgopt->working_buf + 32) & 0xFFFFFFC0;
if(*ppos == 0)
{
extern struct semaphore sem_flipping;
extern struct semaphore sem_early_suspend;
extern struct semaphore sem_update_screen;
extern BOOL is_early_suspended;
ret = down_interruptible(&sem_flipping);
ret = down_interruptible(&sem_early_suspend);
if (is_early_suspended) {
up(&sem_early_suspend);
up(&sem_flipping);
return 0;
}
ret = down_interruptible(&sem_update_screen);
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "This is layer %d capturing \n", dbgopt->layer_index);
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DBG", "This layer width:%d , height:%d\n", LCD_REG->LAYER[dbgopt->layer_index].SIZE.WIDTH, LCD_REG->LAYER[dbgopt->layer_index].SIZE.HEIGHT);
if(lcm_params->type == LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE)
{
DSI_CHECK_RET(DSI_WaitForNotBusy());
LCD_CHECK_RET(LCD_EnableDCtoDsi(FALSE));
}
LCD_Capture_Layerbuffer(dbgopt->layer_index,aligned_buffer,16);
if(lcm_params->type == LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE)
{
LCD_CHECK_RET(LCD_EnableDCtoDsi(TRUE));
}
up(&sem_update_screen);
up(&sem_early_suspend);
up(&sem_flipping);
}
return simple_read_from_buffer(ubuf, count, ppos, (void *)aligned_buffer, DISP_GetScreenWidth()*DISP_GetScreenHeight()*2);
}
// protected by sem_early_suspend
DISP_STATUS dsi_capture_framebuffer(UINT32 pvbuf, UINT32 bpp)
{
DSI_CHECK_RET(DSI_WaitForNotBusy());
DDMS_capturing=1;
if(lcm_params->dsi.mode == CMD_MODE)
{
LCD_CHECK_RET(LCD_EnableDCtoDsi(FALSE));
LCD_CHECK_RET(LCD_Capture_Framebuffer(pvbuf, bpp));
}
else
{
DPI_CHECK_RET(DPI_Capture_Framebuffer(pvbuf, bpp));
}
if(lcm_params->dsi.mode == CMD_MODE)
{
LCD_CHECK_RET(LCD_EnableDCtoDsi(TRUE));
}
DDMS_capturing=0;
return DISP_STATUS_OK;
}
// protected by sem_early_suspend
DISP_STATUS dsi_capture_framebuffer(UINT32 pvbuf, UINT32 bpp)
{
DSI_CHECK_RET(DSI_WaitForNotBusy());
DDMS_capturing=1;
if(lcm_params->dsi.mode == CMD_MODE)
{
LCD_CHECK_RET(LCD_EnableDCtoDsi(FALSE));
#ifndef MT65XX_NEW_DISP
LCD_CHECK_RET(LCD_Capture_Framebuffer(pvbuf, bpp));
#else
DSI_CHECK_RET(DSI_Capture_Framebuffer(pvbuf, bpp, true));//cmd mode
#endif
}
else
{
#ifndef MT65XX_NEW_DISP
DPI_CHECK_RET(DPI_Capture_Framebuffer(pvbuf, bpp));
#else
DSI_CHECK_RET(DSI_Capture_Framebuffer(pvbuf, bpp, false));//video mode
#endif
}
if(lcm_params->dsi.mode == CMD_MODE)
{
LCD_CHECK_RET(LCD_EnableDCtoDsi(TRUE));
}
DDMS_capturing=0;
return DISP_STATUS_OK;
}
UINT32 mt65xx_disp_get_lcd_time(void)
{
#if 0
UINT32 time0, time1, lcd_time;
mt65xx_disp_update(0, 0, CFG_DISPLAY_WIDTH, CFG_DISPLAY_HEIGHT);
LCD_CHECK_RET(LCD_WaitForNotBusy());
time0 = gpt4_tick2time_us(gpt4_get_current_tick());
LCD_CHECK_RET(LCD_StartTransfer(FALSE));
if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode==CMD_MODE) {
DSI_clk_HS_mode(1);
DSI_CHECK_RET(DSI_EnableClk());
}
else if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode!=CMD_MODE) {
DSI_clk_HS_mode(1);
DPI_CHECK_RET(DPI_EnableClk());
DSI_CHECK_RET(DSI_EnableClk());
}
LCD_CHECK_RET(LCD_WaitForNotBusy());
time1 = gpt4_tick2time_us(gpt4_get_current_tick());
lcd_time = time1 - time0;
printf("lcd one %d \n", lcd_time);
if(0 != lcd_time)
return (100000000/lcd_time);
else
#endif
return (6000);
}
static void disp_drv_init_ctrl_if(void)
{
const LCM_DBI_PARAMS *dbi = &(lcm_params->dbi);
if(lcm_params == NULL)
return;
switch(lcm_params->ctrl)
{
case LCM_CTRL_NONE :
case LCM_CTRL_GPIO : return;
case LCM_CTRL_SERIAL_DBI :
ASSERT(dbi->port <= 1);
ctrl_if = LCD_IF_SERIAL_0 + dbi->port;
LCD_ConfigSerialIF(ctrl_if,
(LCD_IF_SERIAL_BITS)dbi->data_width,
dbi->serial.sif_3wire,
dbi->serial.sif_sdi,
dbi->serial.sif_1st_pol,
dbi->serial.sif_sck_def,
dbi->serial.sif_div2,
dbi->serial.sif_hw_cs,
dbi->serial.css,
dbi->serial.csh,
dbi->serial.rd_1st,
dbi->serial.rd_2nd,
dbi->serial.wr_1st,
dbi->serial.wr_2nd);
break;
case LCM_CTRL_PARALLEL_DBI :
ASSERT(dbi->port <= 2);
ctrl_if = LCD_IF_PARALLEL_0 + dbi->port;
LCD_ConfigParallelIF(ctrl_if,
(LCD_IF_PARALLEL_BITS)dbi->data_width,
(LCD_IF_PARALLEL_CLK_DIV)dbi->clock_freq,
dbi->parallel.write_setup,
dbi->parallel.write_hold,
dbi->parallel.write_wait,
dbi->parallel.read_setup,
dbi->parallel.read_hold,
dbi->parallel.read_latency,
dbi->parallel.wait_period,
dbi->parallel.cs_high_width);
break;
default : ASSERT(0);
}
LCD_CHECK_RET(LCD_SelectWriteIF(ctrl_if));
LCD_CHECK_RET(LCD_ConfigIfFormat(dbi->data_format.color_order,
dbi->data_format.trans_seq,
dbi->data_format.padding,
dbi->data_format.format,
to_lcd_if_width(dbi->data_format.width)));
}
DISP_STATUS DISP_ConfigAssertLayerMva()
{
unsigned int mva;
ASSERT(DAL_layerPA);
LCD_CHECK_RET(LCD_AllocUIMva(DAL_layerPA, &mva, DAL_GetLayerSize()));
DISP_LOG("DAL Layer PA = DAL_layerPA = 0x%x, MVA = 0x%x\n", DAL_layerPA, mva);
LCD_CHECK_RET(LCD_LayerSetAddress(ASSERT_LAYER, mva));
return DISP_STATUS_OK;
}
static DISP_STATUS dbi_enable_power(BOOL enable)
{
if (enable) {
LCD_CHECK_RET(LCD_PowerOn());
init_io_pad();
} else {
LCD_CHECK_RET(LCD_PowerOff());
}
return DISP_STATUS_OK;
}
DISP_STATUS DISP_DisableDirectLinkMode(UINT32 layer)
{
if (layer == direct_link_layer) {
LCD_CHECK_RET(LCD_EnableHwTrigger(FALSE));
direct_link_layer = -1;
}
LCD_CHECK_RET(LCD_LayerSetTriggerMode(layer, LCD_SW_TRIGGER));
return DISP_STATUS_OK;
}
static DISP_STATUS dpi_update_screen(void)
{
#ifndef MT65XX_NEW_DISP
LCD_CHECK_RET(LCD_StartTransfer(FALSE));
#else
disp_path_get_mutex();
LCD_CHECK_RET(LCD_ConfigOVL());
disp_path_release_mutex();
#endif
return DISP_STATUS_OK;
}
DISP_STATUS DISP_EnableDirectLinkMode(UINT32 layer)
{
if (layer != direct_link_layer) {
LCD_CHECK_RET(LCD_LayerSetTriggerMode(layer, LCD_HW_TRIGGER_DIRECT_COUPLE));
LCD_CHECK_RET(LCD_LayerSetHwTriggerSrc(layer, LCD_HW_TRIGGER_SRC_IBW2));
LCD_CHECK_RET(LCD_EnableHwTrigger(TRUE));
LCD_CHECK_RET(LCD_StartTransfer(FALSE));
direct_link_layer = layer;
}
return DISP_STATUS_OK;
}
static DISP_STATUS dpi_update_screen(BOOL isMuextLocked)
{
#ifndef MT65XX_NEW_DISP
LCD_CHECK_RET(LCD_StartTransfer(FALSE, isMuextLocked));
#else
if (!isMuextLocked)
disp_path_get_mutex();
LCD_CHECK_RET(LCD_ConfigOVL());
if (!isMuextLocked)
disp_path_release_mutex();
#endif
return DISP_STATUS_OK;
}
static DISP_STATUS dbi_update_screen(void)
{
LCD_CHECK_RET(LCD_StartTransfer(FALSE));
return DISP_STATUS_OK;
}
DPI_STATUS DPI_StartTransfer(bool isMutexLocked)
{
// needStartDSI = 1: For command mode or the first time of video mode.
// After the first time of video mode. Configuration is applied in ConfigurationUpdateTask.
extern struct mutex OverlaySettingMutex;
MMProfileLogMetaStringEx(MTKFB_MMP_Events.Debug, MMProfileFlagPulse, isMutexLocked, 0, "StartTransfer");
if (!isMutexLocked)
disp_path_get_mutex();
mutex_lock(&OverlaySettingMutex);
LCD_CHECK_RET(LCD_ConfigOVL());
// Insert log for trigger point.
DBG_OnTriggerLcd();
// To trigger frame update.
DPI_EnableClk();
mutex_unlock(&OverlaySettingMutex);
if (!isMutexLocked)
disp_path_release_mutex();
return DPI_STATUS_OK;
}
DAL_STATUS DAL_Clean(void)
{
const UINT32 BG_COLOR = MAKE_TWO_RGB565_COLOR(DAL_BG_COLOR, DAL_BG_COLOR);
UINT32 i, *ptr;
if (NULL == mfc_handle)
return DAL_STATUS_NOT_READY;
DAL_LOCK();
MFC_CHECK_RET(MFC_ResetCursor(mfc_handle));
LCD_CHECK_RET(LCD_LayerEnable(ASSERT_LAYER, FALSE));
ptr = (UINT32 *)dal_fb_addr;
for(i = 0; i < DAL_GetLayerSize() / sizeof(UINT32); ++ i) {
*ptr ++ = BG_COLOR;
}
dal_shown = FALSE;
DAL_UNLOCK();
return DAL_STATUS_OK;
}
static DISP_STATUS dbi_update_screen(BOOL isMuextLocked)
{
LCD_CHECK_RET(LCD_StartTransfer(FALSE, isMuextLocked));
return DISP_STATUS_OK;
}
DAL_STATUS DAL_Printf(const char *fmt, ...)
{
va_list args;
uint i;
char printbuffer[1024] = "";
if (NULL == mfc_handle)
return DAL_STATUS_NOT_READY;
if (NULL == fmt)
return DAL_STATUS_INVALID_ARGUMENT;
DAL_LOCK();
va_start (args, fmt);
i = vsprintf(printbuffer, fmt, args);
va_end (args);
MFC_CHECK_RET(MFC_Print(mfc_handle, printbuffer));
if (!dal_shown) {
LCD_CHECK_RET(LCD_LayerEnable(ASSERT_LAYER, TRUE));
dal_shown = TRUE;
}
flush_cache_all();
DISP_CHECK_RET(DISP_UpdateScreen(0, 0,
DAL_WIDTH,
DAL_HEIGHT));
DAL_UNLOCK();
return DAL_STATUS_OK;
}
static void init_lcd(void)
{
/* Config LCD Controller */
LCD_CHECK_RET(LCD_LayerEnable(LCD_LAYER_ALL, FALSE));
LCD_CHECK_RET(LCD_LayerSetTriggerMode(LCD_LAYER_ALL, LCD_SW_TRIGGER));
LCD_CHECK_RET(LCD_EnableHwTrigger(FALSE));
LCD_CHECK_RET(LCD_SetBackgroundColor(0));
LCD_CHECK_RET(LCD_SetRoiWindow(0, 0, lcm_params->width, lcm_params->height));
LCD_CHECK_RET(LCD_SetOutputMode(LCD_OUTPUT_TO_LCM));
LCD_CHECK_RET(LCD_WaitDPIIndication(FALSE));
LCD_CHECK_RET(LCD_FBEnable(LCD_FB_0, FALSE));
LCD_CHECK_RET(LCD_FBEnable(LCD_FB_1, FALSE));
LCD_CHECK_RET(LCD_FBEnable(LCD_FB_2, FALSE));
}
static void init_lcd_te_control(void)
{
const LCM_DBI_PARAMS *dbi = &(lcm_params->dbi);
LCD_CHECK_RET(LCD_TE_Enable(FALSE));
if(!DISP_IsLcmFound())
return;
#ifdef BUILD_UBOOT
{
extern BOOTMODE g_boot_mode;
printf("boot_mode = %d\n",g_boot_mode);
if(g_boot_mode == META_BOOT)
return;
}
#endif
if (LCM_DBI_TE_MODE_DISABLED == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_Enable(FALSE));
return;
}
if (LCM_DBI_TE_MODE_VSYNC_ONLY == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_SetMode(LCD_TE_MODE_VSYNC_ONLY));
} else if (LCM_DBI_TE_MODE_VSYNC_OR_HSYNC == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_SetMode(LCD_TE_MODE_VSYNC_OR_HSYNC));
LCD_CHECK_RET(LCD_TE_ConfigVHSyncMode(dbi->te_hs_delay_cnt,
dbi->te_vs_width_cnt,
(LCD_TE_VS_WIDTH_CNT_DIV)dbi->te_vs_width_cnt_div));
} else ASSERT(0);
LCD_CHECK_RET(LCD_TE_SetEdgePolarity(dbi->te_edge_polarity));
LCD_CHECK_RET(LCD_TE_Enable(TRUE));
}
static void init_lcd_te_control(void)
{
const LCM_DBI_PARAMS *dbi = &(lcm_params->dbi);
/* The board may not connect to LCM in META test mode,
force disalbe TE to avoid blocked in LCD controller
*/
/* but for uboot, the boot mode selection is done after lcd init, so we have to disable te always in uboot. */
LCD_CHECK_RET(LCD_TE_Enable(FALSE));
if (!DISP_IsLcmFound())
return;
if (LCM_DBI_TE_MODE_DISABLED == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_Enable(FALSE));
return;
}
if (LCM_DBI_TE_MODE_VSYNC_ONLY == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_SetMode(LCD_TE_MODE_VSYNC_ONLY));
} else if (LCM_DBI_TE_MODE_VSYNC_OR_HSYNC == dbi->te_mode) {
LCD_CHECK_RET(LCD_TE_SetMode(LCD_TE_MODE_VSYNC_OR_HSYNC));
LCD_CHECK_RET(LCD_TE_ConfigVHSyncMode(dbi->te_hs_delay_cnt,
dbi->te_vs_width_cnt,
(LCD_TE_VS_WIDTH_CNT_DIV) dbi->te_vs_width_cnt_div));
} else
ASSERT(0);
LCD_CHECK_RET(LCD_TE_SetEdgePolarity(dbi->te_edge_polarity));
LCD_CHECK_RET(LCD_TE_Enable(TRUE));
}
static DISP_STATUS dpi_enable_power(BOOL enable)
{
if (enable) {
DPI_CHECK_RET(DPI_PowerOn());
init_mipi_pll();//for MT6573 and later chip, Must re-init mipi pll for dpi, because pll register have located in
//MMSYS1 except MT6516
init_io_pad();
LCD_CHECK_RET(LCD_PowerOn());
DPI_CHECK_RET(DPI_EnableClk());
} else {
DPI_CHECK_RET(DPI_DisableClk());
DPI_CHECK_RET(DPI_PowerOff());
LCD_CHECK_RET(LCD_PowerOff());
DPI_mipi_switch(false);
}
return DISP_STATUS_OK;
}
int disphal_panel_enable(const LCM_DRIVER *lcm_drv, struct mutex* pLcmCmdMutex, BOOL enable)
{
if (enable)
{
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
DSI_SetMode(CMD_MODE);
}
mutex_lock(pLcmCmdMutex);
//#ifdef MTK_DISP_CONFIG_SUPPORT
if(get_fbconfig_start_lcm_config())
{
fbconfig_apply_new_lcm_setting();
//do not call lcm_init if you have ever started LCM config until you reset lcm config ;
}
else
//#endif
lcm_drv->resume();
mutex_unlock(pLcmCmdMutex);
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
//DSI_clk_HS_mode(1);
DSI_WaitForNotBusy();
DSI_SetMode(lcm_params->dsi.mode);
}
}
else
{
LCD_CHECK_RET(LCD_WaitForNotBusy());
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE)
DSI_CHECK_RET(DSI_WaitForNotBusy());
if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
DPI_CHECK_RET(DPI_DisableClk());
//msleep(200);
DSI_Reset();
DSI_clk_HS_mode(0);
DSI_SetMode(CMD_MODE);
}
mutex_lock(pLcmCmdMutex);
//#ifdef MTK_DISP_CONFIG_SUPPORT
if(get_fbconfig_start_lcm_config())
{
fbconfig_apply_new_lcm_setting();
//do not call lcm_init if you have ever started LCM config until you reset lcm config ;
}
else
//#endif
lcm_drv->suspend();
mutex_unlock(pLcmCmdMutex);
}
return 0;
}
void TVDVT_prepare_source(unsigned int src_pa)
{
//static char data = 0x10;
//memset(src_buf_va, data++, BUFFER_SIZE);
__cpuc_flush_user_all();
outer_clean_all();
LCD_CHECK_RET(LCD_LayerSetAddress(LCD_LAYER_0, src_pa));
}
DAL_STATUS DAL_Init(UINT32 layerVA, UINT32 layerPA)
{
dal_fb_addr = (void *)layerVA;
MFC_CHECK_RET(MFC_Open(&mfc_handle, dal_fb_addr,
DAL_WIDTH, DAL_HEIGHT, DAL_BPP,
DAL_FG_COLOR, DAL_BG_COLOR));
DAL_Clean();
LCD_CHECK_RET(LCD_LayerSetAddress(ASSERT_LAYER, layerPA));
LCD_CHECK_RET(LCD_LayerSetFormat(ASSERT_LAYER, DAL_FORMAT));
LCD_CHECK_RET(LCD_LayerSetAlphaBlending(ASSERT_LAYER, TRUE, 0x80));
LCD_CHECK_RET(LCD_LayerSetOffset(ASSERT_LAYER, 0, 0));
LCD_CHECK_RET(LCD_LayerSetSize(ASSERT_LAYER,
DAL_WIDTH,
DAL_HEIGHT));
return DAL_STATUS_OK;
}
DISP_STATUS DISP_SetInterruptCallback(DISP_INTERRUPT_EVENTS eventID, DISP_INTERRUPT_CALLBACK_STRUCT *pCBStruct)
{
UINT32 offset;
ASSERT(pCBStruct != NULL);
if(eventID >= DISP_LCD_INTERRUPT_EVENTS_START && eventID <= DISP_LCD_INTERRUPT_EVENTS_END )
{
///register callback
offset = eventID - DISP_LCD_INTERRUPT_EVENTS_START;
DISP_CallbackArray[offset].pFunc = pCBStruct->pFunc;
DISP_CallbackArray[offset].pParam = pCBStruct->pParam;
LCD_CHECK_RET(LCD_SetInterruptCallback(_DISP_InterruptCallbackProxy));
LCD_CHECK_RET(LCD_EnableInterrupt(eventID));
}
else if(eventID >= DISP_DSI_INTERRUPT_EVENTS_START && eventID <= DISP_DSI_INTERRUPT_EVENTS_END )
{
///register callback
offset = eventID - DISP_DSI_INTERRUPT_EVENTS_START + DISP_LCD_INTERRUPT_EVENTS_NUMBER;
DISP_CallbackArray[offset].pFunc = pCBStruct->pFunc;
DISP_CallbackArray[offset].pParam = pCBStruct->pParam;
DSI_CHECK_RET(DSI_SetInterruptCallback(_DISP_InterruptCallbackProxy));
DSI_CHECK_RET(DSI_EnableInterrupt(eventID));
}
else if(eventID >= DISP_DPI_INTERRUPT_EVENTS_START && eventID <= DISP_DPI_INTERRUPT_EVENTS_END )
{
offset = eventID - DISP_DPI_INTERRUPT_EVENTS_START + DISP_LCD_INTERRUPT_EVENTS_NUMBER + DISP_DSI_INTERRUPT_EVENTS_NUMBER;
DISP_CallbackArray[offset].pFunc = pCBStruct->pFunc;
DISP_CallbackArray[offset].pParam = pCBStruct->pParam;
DPI_CHECK_RET(DPI_SetInterruptCallback(_DISP_InterruptCallbackProxy));
DPI_CHECK_RET(DPI_EnableInterrupt(eventID));
}
else
{
printk("Invalid event id: %d\n", eventID);
ASSERT(0);
return DISP_STATUS_ERROR; ///TODO: error log
}
return DISP_STATUS_OK;
}
static void lcm_send_data(UINT32 data)
{
if(lcm_params == NULL)
return;
ASSERT(LCM_CTRL_SERIAL_DBI == lcm_params->ctrl ||
LCM_CTRL_PARALLEL_DBI == lcm_params->ctrl);
LCD_CHECK_RET(LCD_WriteIF(ctrl_if, LCD_IF_A0_HIGH,
data, lcm_params->dbi.cpu_write_bits));
}
// protected by sem_flipping, sem_early_suspend, sem_overlay_buffer, sem_update_screen
static DISP_STATUS dsi_update_screen(BOOL isMuextLocked)
{
disp_drv_dsi_init_context();
DSI_CHECK_RET(DSI_enable_MIPI_txio(TRUE));
//DSI_CHECK_RET(DSI_handle_TE());
DSI_SetMode(lcm_params->dsi.mode);
#ifndef MT65XX_NEW_DISP
LCD_CHECK_RET(LCD_StartTransfer(FALSE, isMuextLocked));
#endif
if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE && !DDMS_capturing) {
//if(1 != lcm_params->dsi.compatibility_for_nvk)
if(1)
{
DSI_clk_HS_mode(1);
}
#ifndef MT65XX_NEW_DISP
DSI_CHECK_RET(DSI_Start());
#else
DSI_CHECK_RET(DSI_StartTransfer(isMuextLocked));
#endif
}
else if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE && !DDMS_capturing)
{
DSI_clk_HS_mode(1);
#ifndef MT65XX_NEW_DISP
DPI_CHECK_RET(DPI_EnableClk());
DSI_CHECK_RET(DSI_Start());
#else
DSI_CHECK_RET(DSI_StartTransfer(isMuextLocked));
#endif
#ifndef BUILD_UBOOT
is_video_mode_running = true;
if(lcm_params->dsi.noncont_clock)
DSI_set_noncont_clk(true, lcm_params->dsi.noncont_clock_period);
if(lcm_params->dsi.lcm_int_te_monitor)
DSI_set_int_TE(true, lcm_params->dsi.lcm_int_te_period);
#endif
}
if (DDMS_capturing)
DISP_LOG_PRINT(ANDROID_LOG_INFO, "DSI", "[DISP] kernel - dsi_update_screen. DDMS is capturing. Skip one frame. \n");
return DISP_STATUS_OK;
}
DISP_STATUS DISP_ChangeLCDWriteCycle()// this function is called when bootanimation start and stop in Surfaceflinger on 6573, because 6573 LCDC DBI write speed not stable when bootup
{
#if 0 //defined(only for MT6573)
if(LCM_TYPE_DBI == lcm_params.type){//DBI
DISP_LOG("DISP_ChangeLCDWriteCycle():DBI interface\n");
LCD_CHECK_RET(LCD_Change_WriteCycle_ex(ctrl_if));
}
else{//DPI and DSI has not this issue, so not need change
DISP_LOG("DPI or DSI interface not need change write cycles\n");
}
#endif
return DISP_STATUS_OK;
}
DISP_STATUS DISP_PanelEnable(BOOL enable)
{
static BOOL s_enabled = FALSE;
disp_drv_init_context();
if (!lcm_drv->suspend || !lcm_drv->resume) {
return DISP_STATUS_NOT_IMPLEMENTED;
}
if (enable && !s_enabled) {
s_enabled = TRUE;
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
DSI_SetMode(CMD_MODE);
}
lcm_drv->resume();
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
//DSI_clk_HS_mode(1);
DSI_SetMode(lcm_params->dsi.mode);
//DPI_CHECK_RET(DPI_EnableClk());
//DSI_CHECK_RET(DSI_EnableClk());
}
}
else if (!enable && s_enabled)
{
LCD_CHECK_RET(LCD_WaitForNotBusy());
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE)
DSI_CHECK_RET(DSI_WaitForNotBusy());
s_enabled = FALSE;
if (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
DPI_CHECK_RET(DPI_DisableClk());
udelay(200*1000);
DSI_Reset();
DSI_clk_HS_mode(0);
DSI_SetMode(CMD_MODE);
}
lcm_drv->suspend();
}
return DISP_STATUS_OK;
}
DISP_STATUS DISP_UpdateScreen(UINT32 x, UINT32 y, UINT32 width, UINT32 height)
{
DISP_LOG("update screen, (%d,%d),(%d,%d)\n", x, y, width, height);
if (down_interruptible(&sem_update_screen)) {
DISP_LOG("ERROR: Can't get sem_update_screen in DISP_UpdateScreen()\n");
return DISP_STATUS_ERROR;
}
#if defined(MTK_LCD_HW_3D_SUPPORT)
LCD_CHECK_RET(DISP_Set3DPWM( DISP_Is3DEnabled(), DISP_is3DLandscapeMode() ));
#endif
// if LCM is powered down, LCD would never recieve the TE signal
//
if (is_lcm_in_suspend_mode || is_engine_in_suspend_mode) goto End;
LCD_CHECK_RET(LCD_WaitForNotBusy());
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode == CMD_MODE)
DSI_CHECK_RET(DSI_WaitForNotBusy());
if (lcm_drv->update) {
lcm_drv->update(x, y, width, height);
}
LCD_CHECK_RET(LCD_SetRoiWindow(x, y, width, height));
LCD_CHECK_RET(LCD_FBSetStartCoord(x, y));
if (-1 != direct_link_layer) {
//MT6516IDP_EnableDirectLink(); // FIXME
} else {
disp_drv->update_screen();
}
End:
up(&sem_update_screen);
return DISP_STATUS_OK;
}
