type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <asm/arch/disp_drv_platform.h> |
includes | #include <linux/delay.h> |
includes | #include <linux/fb.h> |
includes | #include <asm/uaccess.h> |
includes | #include <disp_drv_platform.h> |
includes |
#include <linux/disp_assert_layer.h> |
includes |
#include <linux/interrupt.h> |
includes | #include <linux/sched.h> |
includes | #include <linux/semaphore.h> |
includes | #include <linux/module.h> |
includes | #include <linux/wait.h> |
includes | #include <linux/kthread.h> |
includes | #include <linux/mutex.h> |
includes | #include <linux/vmalloc.h> |
defines |
#define LCM_ESD_CHECK_MAX_COUNT 5 |
defines | #define ALIGN_TO_POW_OF_2(x, n) \ |
defines |
#define ALIGN_TO(x, n) \ |
defines | #define DISP_LOG(fmt, arg...) \ |
defines |
#define DISP_FUNC() \ |
defines |
#define DISP_CB_MAXCNT 2 |
structs | struct DBG_OVL_CONFIGS
{
OVL_CONFIG_STRUCT Layer0;
OVL_CONFIG_STRUCT Layer1;
OVL_CONFIG_STRUCT Layer2;
OVL_CONFIG_STRUCT Layer3;
}; |
functions | void disp_log_enable(int enable)
{
disp_log_on = enable;
DISP_LOG("disp common log %s\n", enable?"enabled":"disabled");
} |
functions | void lcm_set_reset_pin(UINT32 value)
{
int ret = 0;
if(LCM_TYPE_DSI == lcm_params->type){
ret = enable_clock(MT_CG_DISP1_DBI_ENGINE, "DSI_LRST");
} |
functions | void lcm_udelay(UINT32 us)
{
udelay(us);
} |
functions | void lcm_mdelay(UINT32 ms)
{
msleep(ms);
} |
functions | void lcm_send_cmd(UINT32 cmd)
{
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_LOW,
cmd, lcm_params->dbi.cpu_write_bits));
} |
functions | 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));
} |
functions | UINT32 lcm_read_data(void)
{
UINT32 data = 0;
if(lcm_params== NULL)
return 0;
ASSERT(LCM_CTRL_SERIAL_DBI == lcm_params->ctrl ||
LCM_CTRL_PARALLEL_DBI == lcm_params->ctrl);
LCD_CHECK_RET(LCD_ReadIF(ctrl_if, LCD_IF_A0_HIGH,
&data, lcm_params->dbi.cpu_write_bits));
return data;
} |
functions | LCD_IF_WIDTH to_lcd_if_width(LCM_DBI_DATA_WIDTH data_width)
{
switch(data_width)
{
case LCM_DBI_DATA_WIDTH_8BITS : return LCD_IF_WIDTH_8_BITS;
case LCM_DBI_DATA_WIDTH_9BITS : return LCD_IF_WIDTH_9_BITS;
case LCM_DBI_DATA_WIDTH_16BITS : return LCD_IF_WIDTH_16_BITS;
case LCM_DBI_DATA_WIDTH_18BITS : return LCD... |
functions | void disp_drv_set_driving_current(LCM_PARAMS *lcm)
{
LCD_Set_DrivingCurrent(lcm);
} |
functions | void disp_drv_init_io_pad(LCM_PARAMS *lcm)
{
LCD_Init_IO_pad(lcm);
} |
functions | void disp_drv_init_ctrl_if(void)
{
const LCM_DBI_PARAMS *dbi = NULL;
if(lcm_params== NULL)
return;
dbi = &(lcm_params->dbi);
switch(lcm_params->ctrl)
{
case LCM_CTRL_NONE :
case LCM_CTRL_GPIO : return;
case LCM_CTRL_SERIAL_DBI :
ASSERT(dbi->port <= 1);
#ifdef MT65XX_NEW_DISP
LCD_CHECK_RET... |
functions | end
if(LCM_TYPE_DSI == lcm_params->type){
init_dsi(FALSE);
} |
functions | void disp_dump_lcm_parameters(LCM_PARAMS *lcm_params)
{
unsigned char *LCM_TYPE_NAME[] = {"DBI", "DPI", "DSI"} |
functions | BOOL disp_get_lcm_name_boot(char *cmdline)
{
BOOL ret = FALSE;
char *p, *q;
p = strstr(cmdline, "lcm=");
if(p == NULL)
{
// we can't find lcm string in the command line,
// the uboot should be old version, or the kernel is loaded by ICE debugger
return DISP_SelectDeviceBoot(NULL);
} |
functions | BOOL disp_drv_init_context(void)
{
if (disp_drv != NULL && lcm_drv != NULL){
return TRUE;
} |
functions | BOOL DISP_IsLCDBusy(void)
{
return LCD_IsBusy();
} |
functions | BOOL DISP_IsLcmFound(void)
{
return isLCMFound;
} |
functions | BOOL DISP_IsContextInited(void)
{
if(lcm_params && disp_drv && lcm_drv)
return TRUE;
else
return FALSE;
} |
functions | BOOL DISP_SelectDeviceBoot(const char* lcm_name)
{
LCM_DRIVER *lcm = NULL;
int i;
printk("%s\n", __func__);
if(lcm_name == NULL)
{
// we can't do anything in boot stage if lcm_name is NULL
return false;
} |
functions | line
if(lcm_count == 1)
{
lcm_drv = lcm;
isLCMFound = true;
u4IndexOfLCMList = 0;
break;
} |
functions | BOOL DISP_SelectDevice(const char* lcm_name)
{
#ifndef MT65XX_NEW_DISP
LCD_STATUS ret;
ret = LCD_Init();
printk("ret of LCD_Init() = %d\n", ret);
#endif
lcm_drv = disp_drv_get_lcm_driver(lcm_name);
if (NULL == lcm_drv)
{
printk("%s, disp_drv_get_lcm_driver() returns NULL\n", __func__);
return FALSE;
} |
functions | BOOL DISP_DetectDevice(void)
{
#ifndef MT65XX_NEW_DISP
LCD_STATUS ret;
ret = LCD_Init();
printk("ret of LCD_Init() = %d\n", ret);
#endif
lcm_drv = disp_drv_get_lcm_driver(NULL);
if (NULL == lcm_drv)
{
printk("%s, disp_drv_get_lcm_driver() returns NULL\n", __func__);
return FALSE;
} |
functions | DISP_STATUS DISP_Init(UINT32 fbVA, UINT32 fbPA, BOOL isLcmInited)
{
DISP_STATUS r = DISP_STATUS_OK;
#ifdef MT65XX_NEW_DISP
#if 0
//OUTREG32(DISPSYS_BASE + 0x104, 0xffffffff);//set CG
OUTREG32(DISPSYS_BASE + 0x108, 0xffffffff);
//OUTREG32(DISPSYS_BASE + 0x114, 0xffffffff);
OUTREG32(DISPSYS_BASE + 0x118, 0xfffff... |
functions | else if(dispif_info[MTKFB_DISPIF_PRIMARY_LCD].displayWidth * dispif_info[MTKFB_DISPIF_PRIMARY_LCD].displayHeight <= 320*480)
{
dispif_info[MTKFB_DISPIF_PRIMARY_LCD].xDPI = dispif_info[MTKFB_DISPIF_PRIMARY_LCD].yDPI = 160;
} |
functions | else if(dispif_info[MTKFB_DISPIF_PRIMARY_LCD].displayWidth * dispif_info[MTKFB_DISPIF_PRIMARY_LCD].displayHeight <= 480*854)
{
dispif_info[MTKFB_DISPIF_PRIMARY_LCD].xDPI = dispif_info[MTKFB_DISPIF_PRIMARY_LCD].yDPI = 240;
} |
functions | DISP_STATUS DISP_Deinit(void)
{
DISP_CHECK_RET(DISP_PanelEnable(FALSE));
DISP_CHECK_RET(DISP_PowerEnable(FALSE));
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_PowerEnable(BOOL enable)
{
DISP_STATUS ret = DISP_STATUS_OK;
#ifdef BUILD_UBOOT
static BOOL s_enabled = FALSE;
#else
static BOOL s_enabled = TRUE;
#endif
if (enable != s_enabled)
s_enabled = enable;
else
return ret;
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't ge... |
functions | DISP_STATUS DISP_PanelEnable(BOOL enable)
{
#ifdef BUILD_UBOOT
static BOOL s_enabled = FALSE;
#else
static BOOL s_enabled = TRUE;
#endif
DISP_STATUS ret = DISP_STATUS_OK;
DISP_LOG("panel is %s\n", enable?"enabled":"disabled");
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't get sem_upd... |
functions | 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(... |
functions | DISP_STATUS DISP_LCDPowerEnable(BOOL enable)
{
if (enable)
{
LCD_CHECK_RET(LCD_PowerOn());
#if defined(MTK_M4U_SUPPORT)
LCD_CHECK_RET(LCD_M4UPowerOn());
#endif
} |
functions | DISP_STATUS DISP_SetBacklight(UINT32 level)
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't get sem_update_screen in DISP_SetBacklight()\n");
return DISP_STATUS_ERROR;
} |
functions | DISP_STATUS DISP_SetBacklight_mode(UINT32 mode)
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't get sem_update_screen in DISP_SetBacklight_mode()\n");
return DISP_STATUS_ERROR;
} |
functions | DISP_STATUS DISP_SetPWM(UINT32 divider)
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't get sem_update_screen in DISP_SetPWM()\n");
return DISP_STATUS_ERROR;
} |
functions | DISP_STATUS DISP_GetPWM(UINT32 divider, unsigned int *freq)
{
DISP_STATUS ret = DISP_STATUS_OK;
disp_drv_init_context();
if (!lcm_drv->get_pwm) {
ret = DISP_STATUS_NOT_IMPLEMENTED;
goto End;
} |
functions | DISP_STATUS DISP_Set3DPWM(BOOL enable, BOOL landscape)
{
#if 1
unsigned int temp_reg;
if (enable && (!ispwmenabled || ismodechanged))
{
struct pwm_easy_config pwm_setting;
// Set GPIO66, GPIO67, GPIO68 to PWM2, PWM1, PWM3
mt_set_gpio_mode(GPIO187, GPIO_MODE_GPIO);
mt_set_gpio_out(GPIO187, GPIO_OUT_ONE);
... |
functions | else if (!enable && ispwmenabled)
{
mt_set_gpio_mode(GPIO187, GPIO_MODE_GPIO);
mt_set_gpio_out(GPIO187, GPIO_OUT_ZERO);
mt_set_gpio_mode(GPIO66, GPIO_MODE_GPIO);
mt_set_gpio_mode(GPIO67, GPIO_MODE_GPIO);
mt_set_gpio_mode(GPIO68, GPIO_MODE_GPIO);
ispwmenabled = FALSE;
DISP_LOG("3D PWM is disabled ... |
functions | BOOL DISP_Is3DEnabled(void)
{
is3denabled = LCD_Is3DEnabled();
return is3denabled;
} |
functions | BOOL DISP_is3DLandscapeMode(void)
{
gCurrentMode = LCD_Is3DLandscapeMode();
if (gCurrentMode != gUsingMode)
ismodechanged = TRUE;
else
ismodechanged = FALSE;
gUsingMode = gCurrentMode;
return LCD_Is3DLandscapeMode();
} |
functions | DISP_STATUS DISP_SetFrameBufferAddr(UINT32 fbPhysAddr)
{
LCD_CHECK_RET(LCD_LayerSetAddress(FB_LAYER, fbPhysAddr));
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_EnterOverlayMode(void)
{
DISP_FUNC();
if (is_overlaying) {
return DISP_STATUS_ALREADY_SET;
} |
functions | DISP_STATUS DISP_LeaveOverlayMode(void)
{
DISP_FUNC();
if (!is_overlaying) {
return DISP_STATUS_ALREADY_SET;
} |
functions | DISP_STATUS DISP_EnableDirectLinkMode(UINT32 layer)
{
///since MT6573 we do not support DC mode
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_DisableDirectLinkMode(UINT32 layer)
{
///since MT6573 we do not support DC mode
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_UpdateScreen(UINT32 x, UINT32 y, UINT32 width, UINT32 height)
{
unsigned int is_video_mode;
DISP_LOG("update screen, (%d,%d),(%d,%d)\n", x, y, width, height);
if ((lcm_params->type==LCM_TYPE_DPI) ||
((lcm_params->type==LCM_TYPE_DSI) && (lcm_params->dsi.mode != CMD_MODE)))
is_video_mode ... |
functions | endif
if (-1 != direct_link_layer) {
//MT6516IDP_EnableDirectLink(); // FIXME
} |
functions | void _DISP_InterruptCallbackProxy(DISP_INTERRUPT_EVENTS eventID)
{
UINT32 offset;
if(eventID >= DISP_LCD_INTERRUPT_EVENTS_START && eventID <= DISP_LCD_INTERRUPT_EVENTS_END )
{
offset = eventID - DISP_LCD_INTERRUPT_EVENTS_START;
if(DISP_CallbackArray[offset].pFunc)
{
DISP... |
functions | else if(eventID >= DISP_DSI_INTERRUPT_EVENTS_START && eventID <= DISP_DSI_INTERRUPT_EVENTS_END )
{
offset = eventID - DISP_DSI_INTERRUPT_EVENTS_START + DISP_LCD_INTERRUPT_EVENTS_NUMBER;
if(DISP_CallbackArray[offset].pFunc)
{
DISP_CallbackArray[offset].pFunc(DISP_CallbackArray[off... |
functions | 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;
if(DISP_CallbackArray[offset].pFunc)
{
DISP_CallbackArray[o... |
functions | DISP_STATUS DISP_SetInterruptCallback(DISP_INTERRUPT_EVENTS eventID, DISP_INTERRUPT_CALLBACK_STRUCT *pCBStruct)
{
UINT32 offset;
ASSERT(pCBStruct != NULL);
disp_drv_init_context();
if(eventID >= DISP_LCD_INTERRUPT_EVENTS_START && eventID <= DISP_LCD_INTERRUPT_EVENTS_END )
{
///register ca... |
functions | 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[offse... |
functions | 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... |
functions | DISP_STATUS DISP_WaitForLCDNotBusy(void)
{
LCD_WaitForNotBusy();
return DISP_STATUS_OK;
} |
functions | DISP_STATUS _DISP_ConfigUpdateScreen(UINT32 x, UINT32 y, UINT32 width, UINT32 height)
{
#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 |... |
functions | void GetUpdateMutex(void)
{
mutex_lock(&UpdateRegMutex);
} |
functions | int TryGetUpdateMutex(void)
{
return mutex_trylock(&UpdateRegMutex);
} |
functions | void ReleaseUpdateMutex(void)
{
mutex_unlock(&UpdateRegMutex);
} |
functions | int DISP_RegisterExTriggerSource(DISP_EXTRA_CHECKUPDATE_PTR pCheckUpdateFunc , DISP_EXTRA_CONFIG_PTR pConfFunc)
{
int index = 0;
int hit = 0;
if((NULL == pCheckUpdateFunc) || (NULL == pConfFunc))
{
printk("Warnning! [Func]%s register NULL function : %p,%p\n", __func__ , pCheckUpdateFunc , pConfF... |
functions | void DISP_UnRegisterExTriggerSource(int u4ID)
{
if(DISP_CB_MAXCNT < (u4ID+1))
{
printk("Warnning! [Func]%s unregister a never registered function : %d\n", __func__ , u4ID);
return;
} |
functions | int _DISP_CaptureFBKThread(void *data)
{
struct fb_info* pInfo = (struct fb_info*) data;
MMP_MetaDataBitmap_t Bitmap;
while(1)
{
wait_event_interruptible(gCaptureFBWQ, gCaptureFBEnable);
Bitmap.data1 = pInfo->var.yoffset;
Bitmap.width = DISP_GetScreenWidth();
Bitmap.height = DISP_GetScreenHeight() * 2... |
functions | int _DISP_CaptureOvlKThread(void *data)
{
unsigned int index = 0;
unsigned int mva[2];
void* va[2];
unsigned int buf_size;
M4U_PORT_STRUCT portStruct;
unsigned int init = 0;
unsigned int enabled = 0;
MMP_MetaDataBitmap_t Bitmap;
buf_size = DISP_GetScreenWidth() * DISP_GetScreenHeight() * 4;
while... |
functions | void _DISP_DumpLayer(OVL_CONFIG_STRUCT* pLayer)
{
if (gCaptureLayerEnable && pLayer->layer_en)
{
MMP_MetaDataBitmap_t Bitmap;
Bitmap.data1 = pLayer->vaddr;
Bitmap.width = pLayer->dst_w;
Bitmap.height = pLayer->dst_h;
switch (pLayer->fmt)
{
case OVL_INPUT_F... |
functions | void DISP_StartConfigUpdate(void)
{
if(((LCM_TYPE_DSI == lcm_params->type) && (CMD_MODE == lcm_params->dsi.mode)) || (LCM_TYPE_DBI == lcm_params->type))
{
config_update_task_wakeup = 1;
wake_up_interruptible(&config_update_wq);
} |
functions | int _DISP_ConfigUpdateKThread(void *data)
{
int i;
int dirty = 0;
int overlay_dirty = 0;
int aal_dirty = 0;
int index = 0;
unsigned int esd_check_count;
struct disp_path_config_mem_out_struct mem_out_config;
struct sched_param param = { .sched_priority = RTPM_PRIO_SCRN_UPDATE } |
functions | void _DISP_HWDoneCallback(void* pParam)
{
MMProfileLogEx(MTKFB_MMP_Events.DispDone, MMProfileFlagPulse, is_early_suspended, 0);
// For DPI, this callback is called each time DPI VSync arrives.
// So trigger disp done event only in early suspend.
if ((lcm_params->type != LCM_TYPE_DPI) || (is_early_suspen... |
functions | void _DISP_VSyncCallback(void* pParam)
{
MMProfileLog(MTKFB_MMP_Events.VSync, MMProfileFlagPulse);
vsync_wq_flag = 1;
wake_up_interruptible(&vsync_wq);
} |
functions | void _DISP_RegUpdateCallback(void* pParam)
{
MMProfileLog(MTKFB_MMP_Events.RegUpdate, MMProfileFlagPulse);
realtime_layer_config = captured_layer_config;
if ((lcm_params->type == LCM_TYPE_DPI) ||
((lcm_params->type == LCM_TYPE_DSI) && (lcm_params->dsi.mode != CMD_MODE)))
{
if ((PanDispSetti... |
functions | void _DISP_TargetLineCallback(void* pParam)
{
//tasklet_hi_schedule(&ConfigUpdateTask);
MMProfileLogEx(MTKFB_MMP_Events.UpdateConfig, MMProfileFlagPulse, 0, 0);
config_update_task_wakeup = 1;
wake_up_interruptible(&config_update_wq);
} |
functions | void _DISP_CmdDoneCallback(void* pParam)
{
//tasklet_hi_schedule(&ConfigUpdateTask);
MMProfileLogEx(MTKFB_MMP_Events.UpdateConfig, MMProfileFlagPulse, 1, 0);
config_update_task_wakeup = 1;
wake_up_interruptible(&config_update_wq);
_DISP_HWDoneCallback(NULL);
} |
functions | hrtimer_restart _DISP_CmdModeTimer_handler(struct hrtimer *timer)
{
MMProfileLogEx(MTKFB_MMP_Events.UpdateConfig, MMProfileFlagPulse, 2, 0);
config_update_task_wakeup = 1;
wake_up_interruptible(&config_update_wq);
return HRTIMER_NORESTART;
} |
functions | void DISP_InitVSYNC(unsigned int vsync_interval)
{
#ifndef MT65XX_NEW_DISP
if((LCM_TYPE_DBI == lcm_params->type) ||
(LCM_TYPE_DSI == lcm_params->type && lcm_params->dsi.mode == CMD_MODE)){
LCD_InitVSYNC(vsync_interval);
} |
functions | else if (LCM_TYPE_DPI == lcm_params->type)
{
RDMASetTargetLine(0, DISP_GetScreenHeight()*4/5);
cb.pFunc = _DISP_VSyncCallback;
DISP_SetInterruptCallback(DISP_DPI_VSYNC_INT, &cb);
cb.pFunc = _DISP_TargetLineCallback;
DISP_SetInterruptCallback(DISP_DPI_TARGET_LINE_INT, &cb);
... |
functions | else if (LCM_TYPE_DSI == lcm_params->type)
{
if (CMD_MODE == lcm_params->dsi.mode)
{
DSI_InitVSYNC(vsync_interval);
cmd_mode_update_timer_period = ktime_set(0 , vsync_interval*1000);//ktime_set(0, 14285714); // 70Hz
hrtimer_init(&cmd_mode_update_timer, CLOCK_MONOT... |
functions | void DISP_WaitVSYNC(void)
{
MMProfileLog(MTKFB_MMP_Events.WaitVSync, MMProfileFlagStart);
#ifndef MT65XX_NEW_DISP
if((LCM_TYPE_DBI == lcm_params->type) ||
(LCM_TYPE_DSI == lcm_params->type && lcm_params->dsi.mode == CMD_MODE)){
LCD_WaitTE();
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type && lcm_params->dsi.mode == CMD_MODE)
{
// DSI_WaitTE();
vsync_wq_flag = 0;
if (wait_event_interruptible_timeout(vsync_wq, vsync_wq_flag, HZ/10) == 0)
{
printk("[DISP] Wait VSync timeout. early_suspend=%d\n", is_early_suspended);
... |
functions | DISP_STATUS DISP_PauseVsync(BOOL enable)
{
if((LCM_TYPE_DBI == lcm_params->type) ||
(LCM_TYPE_DSI == lcm_params->type && lcm_params->dsi.mode == CMD_MODE)){
if (enable)
hrtimer_cancel(&cmd_mode_update_timer);
LCD_PauseVSYNC(enable);
} |
functions | DISP_STATUS DISP_ConfigDither(int lrs, int lgs, int lbs, int dbr, int dbg, int dbb)
{
DISP_LOG("DISP_ConfigDither lrs:0x%x, lgs:0x%x, lbs:0x%x, dbr:0x%x, dbg:0x%x, dbb:0x%x \n", lrs, lgs, lbs, dbr, dbg, dbb);
if(LCD_STATUS_OK == LCD_ConfigDither(lrs, lgs, lbs, dbr, dbg, dbb))
{
return DISP_STATUS_O... |
functions | BOOL DISP_IsVideoMode(void)
{
disp_drv_init_context();
if(lcm_params)
return lcm_params->type==LCM_TYPE_DPI || (lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE);
else
{
printk("WARNING!! DISP_IsVideoMode is called before display driver inited!\n");
return 0;
... |
functions | UINT32 DISP_GetScreenWidth(void)
{
disp_drv_init_context();
if(lcm_params)
return lcm_params->width;
else
{
printk("WARNING!! get screen width before display driver inited!\n");
return 0;
} |
functions | UINT32 DISP_GetScreenHeight(void)
{
disp_drv_init_context();
if(lcm_params)
return lcm_params->height;
else
{
printk("WARNING!! get screen height before display driver inited!\n");
return 0;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.