__s32 lvds_clk_init(void)
{
	DE_INF("lvds clk init \n");
	h_lvdsmclk = OSAL_CCMU_OpenMclk(MOD_CLK_LVDS);
#ifdef RESET_OSAL
	OSAL_CCMU_MclkReset(h_lvdsmclk, RST_INVAILD);
#endif
	return DIS_SUCCESS;
}
static struct disp_smbl_private_data *disp_smbl_get_priv(struct disp_smbl *smbl)
{
	if(NULL == smbl) {
		DE_INF("NULL hdl!\n");
		return NULL;
	}

	return &smbl_private[smbl->disp];
}
static s32 disp_smbl_disable(struct disp_smbl* smbl)
{
	struct disp_smbl_private_data *smblp = disp_smbl_get_priv(smbl);

	if((NULL == smbl) || (NULL == smblp)) {
		DE_INF("NULL hdl!\n");
		return -1;
	}
	DE_INF("smbl %d disable\n", smbl->disp);

	disp_sys_lock((void *)&smblp->mlock);
	smblp->info.enable = 0;
	smblp->info.flags |= SMBL_DIRTY_ENABLE;
	disp_smbl_apply(smbl);
	disp_sys_unlock((void *)&smblp->mlock);

	return 0;
}
s32 disp_init_connections(void)
{
	u32 disp = 0;
	u32 num_screens = 0;
	u32 num_layers = 0,layer_id = 0;

	DE_INF("disp_init_connections\n");

	num_screens = bsp_disp_feat_get_num_screens();
	for(disp=0; disp<num_screens; disp++) {
		struct disp_manager *mgr;
		struct disp_layer *lyr;
		struct disp_device *lcd = NULL;
		struct disp_enhance *enhance = NULL;
		struct disp_smbl *smbl = NULL;
		struct disp_capture *cptr = NULL;

		mgr = disp_get_layer_manager(disp);
		if(!mgr)
			continue;

		/* connect layer & it's manager */
		num_layers = bsp_disp_feat_get_num_layers(disp);
		for(layer_id=0; layer_id<num_layers; layer_id++) {
			lyr = disp_get_layer_1(disp, layer_id);
			if(NULL != lyr) {
				lyr->set_manager(lyr, mgr);
			}
		}

		/* connect device & it's manager */
		if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_LCD)) {
			lcd = disp_get_lcd(disp);
			if((lcd) && (lcd->set_manager))
				lcd->set_manager(lcd, mgr);
		} else {
			//other device
		}

		enhance = disp_get_enhance(disp);
		if(enhance && (enhance->set_manager)) {
			enhance->set_manager(enhance, mgr);
		}

		smbl = disp_get_smbl(disp);
		if(smbl && (smbl->set_manager)) {
			smbl->set_manager(smbl, mgr);
		}

		cptr = disp_get_capture(disp);
		if(cptr && (cptr->set_manager)) {
			cptr->set_manager(cptr, mgr);
		}
	}

	return 0;
}
static struct disp_enhance_private_data *disp_enhance_get_priv(struct disp_enhance *enhance)
{
	if(NULL == enhance) {
		DE_INF("NULL hdl!\n");
		return NULL;
	}

	return &enhance_private[enhance->disp];
}
void LCD_vbi_event_proc(__u32 sel, __u32 tcon_index)
{    
        __u32 cur_line = 0, start_delay = 0;
        __u32 i = 0;

        //add by heyihang.Jan 28, 2013
        if(gdisp.screen[sel].vsync_event_en && gdisp.init_para.vsync_event)
        {
                gdisp.init_para.vsync_event(sel);
        }
        
	Video_Operation_In_Vblanking(sel, tcon_index);
        
        cur_line = LCDC_get_cur_line(sel, tcon_index);
        start_delay = LCDC_get_start_delay(sel, tcon_index);
        if(cur_line > start_delay-3)
	{
	      //DE_INF("cur_line(%d) >= start_delay(%d)-3 in LCD_vbi_event_proc\n", cur_line, start_delay);
		return ;
	}

        if(gdisp.screen[sel].LCD_CPUIF_ISR)
        {
        	(*gdisp.screen[sel].LCD_CPUIF_ISR)();
        }

        if(gdisp.screen[sel].cache_flag == FALSE )//&& gdisp.screen[sel].cfg_cnt == 0)
        {
                for(i=0; i<2; i++)
                {
                        if((gdisp.scaler[i].status & SCALER_USED) && (gdisp.scaler[i].screen_index == sel))
                        {
                                DE_SCAL_Set_Reg_Rdy(i);
                                //DE_SCAL_Reset(i);
                                //DE_SCAL_Start(i);
                                gdisp.scaler[i].b_reg_change = FALSE;
                        }
                        if(gdisp.scaler[i].b_close == TRUE)
                        {
                                Scaler_close(i);
                                gdisp.scaler[i].b_close = FALSE;
                        }
                }
                DE_BE_Cfg_Ready(sel);
        	gdisp.screen[sel].have_cfg_reg = TRUE;
        }
#if 0
    cur_line = LCDC_get_cur_line(sel, tcon_index);
    
	if(cur_line > 5)
	{
    	DE_INF("%d\n", cur_line);
    }
#endif

    return ;
}
__s32 lcdc_clk_init(__u32 screen_id)
{
	DE_INF("lcd %d clk init\n", screen_id);
	if(screen_id == 0) {
		h_lcd0ahbclk   = OSAL_CCMU_OpenMclk(AHB_CLK_LCD0);
		h_lcd0ch0mclk0 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD0CH0);
		#if (!defined CONFIG_ARCH_SUN7I)
		h_lcd0ch1mclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD0CH1);
		#else
		h_lcd0ch1mclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD0CH1_S1);
		h_lcd0ch1mclk2 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD0CH1_S2);
		#endif
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_lcd0ch0mclk0, RST_INVAILD);
#endif
		OSAL_CCMU_SetMclkSrc(h_lcd0ch0mclk0, CLK_LCD_CH0_SRC);
		OSAL_CCMU_SetMclkSrc(h_lcd0ch1mclk1, CLK_LCD_CH1_SRC);
		OSAL_CCMU_SetMclkDiv(h_lcd0ch1mclk1, 10);
		OSAL_CCMU_SetMclkDiv(h_lcd0ch1mclk2, 10);


		OSAL_CCMU_MclkOnOff(h_lcd0ahbclk, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd0ahbclk, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_lcd0ch0mclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd0ch0mclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_lcd0ch1mclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd0ch1mclk1, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_lcd0ch1mclk2, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd0ch1mclk2, CLK_OFF);
	}	else if(screen_id == 1)	{
		h_lcd1ahbclk   = OSAL_CCMU_OpenMclk(AHB_CLK_LCD1);
		h_lcd1ch0mclk0 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD1CH0);
		#if (!defined CONFIG_ARCH_SUN7I)
		h_lcd1ch1mclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD1CH1);
		#else
		h_lcd1ch1mclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD1CH1_S1);
		h_lcd1ch1mclk2 = OSAL_CCMU_OpenMclk(MOD_CLK_LCD1CH1_S2);
		#endif
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_lcd1ch0mclk0, RST_INVAILD);
#endif
		OSAL_CCMU_SetMclkSrc(h_lcd1ch0mclk0, CLK_LCD_CH0_SRC);
		OSAL_CCMU_SetMclkSrc(h_lcd1ch1mclk1, CLK_LCD_CH1_SRC);
		OSAL_CCMU_SetMclkDiv(h_lcd1ch1mclk1, 10);
		OSAL_CCMU_SetMclkDiv(h_lcd1ch1mclk2, 10);


		OSAL_CCMU_MclkOnOff(h_lcd1ahbclk, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd1ahbclk, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_lcd1ch0mclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd1ch0mclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_lcd1ch1mclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_lcd1ch1mclk1, CLK_OFF);
	}
	return DIS_SUCCESS;
}
Beispiel #8
0
__s32 Disp_drc_proc(__u32 sel, __u32 tcon_index)
{
	__u32 top, bot, left, right;
	__u32 lgcaddr;

	if (sel == 0) {
		if (giep[sel].runframe < giep[sel].waitframe) {
			/*
			 * first  frame, wont get the valid histogram, so open
			 * a "zero" window
			 */
			top = 0;
			bot = 0;
			left = 0;
			right = 0;

			DE_IEP_Set_Demo_Win_Para(sel, top, bot, left, right);
			DE_IEP_Demo_Win_Enable(sel, 1);	/* enable here */
			/* 12-04-01 debug flicker in LCD opening */
			DE_IEP_Set_Csc_Coeff(sel, 3);
			BSP_disp_set_output_csc(sel,
						gdisp.screen[sel].output_type,
						1);

			lgcaddr = (__u32) pttab + ((128 - 1) << 9);
			lgcaddr = __pa(lgcaddr);
			/* set "gain=1" tab to lgc */
			DE_IEP_Drc_Set_Lgc_Addr(sel, lgcaddr);
			DE_IEP_Enable(sel); /* enable here */
#if 0
			DE_INF("waitting for runframe %d up to%d!\n",
			       giep.runframe, giep.waitframe);
#endif
			giep[sel].runframe++;
		} else {
			if (giep[sel].drc_win_en) {
				/* convert rectangle to register */
				top = giep[sel].drc_win.y;
				bot = giep[sel].drc_win.y +
					giep[sel].drc_win.height - 1;
				left = giep[sel].drc_win.x;
				right = giep[sel].drc_win.x +
					giep[sel].drc_win.width - 1;

				DE_IEP_Set_Demo_Win_Para(sel, top, bot, left,
							 right);
			}
			/* BACKLIGHT Control ALG */
			PWRSAVE_CORE(sel);
		}

		return 0;
	} else {
		return -1;
	}
}
Beispiel #9
0
__s32 deu_clk_init(__u32 sel)
{
	__u32 pll_freq;
	__u32 mclk_div;

	DE_INF("deu %d clk init\n", sel);
	if(!sel) {
		h_deuahbclk0 = OSAL_CCMU_OpenMclk(AHB_CLK_DEU0);
		h_deudramclk0 = OSAL_CCMU_OpenMclk(DRAM_CLK_DEU0);
		h_deumclk0 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDEU0);


		OSAL_CCMU_SetMclkSrc(h_deumclk0, CLK_FE_SRC);	//FIX CONNECT TO  PLL10
		OSAL_CCMU_SetMclkDiv(h_deumclk0, 1);
		pll_freq = OSAL_CCMU_GetSrcFreq(CLK_FE_SRC);
		mclk_div = 1;
		while((pll_freq / mclk_div) > 300000000) {
			mclk_div ++;
		}
		OSAL_CCMU_SetMclkDiv(h_deumclk0, mclk_div);

		OSAL_CCMU_MclkOnOff(h_deuahbclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deuahbclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_deudramclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deudramclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_deumclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deumclk0, CLK_OFF);
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_deumclk0, RST_INVAILD);
#endif
	}	else {
		h_deuahbclk1 = OSAL_CCMU_OpenMclk(AHB_CLK_DEU1);
		h_deudramclk1 = OSAL_CCMU_OpenMclk(DRAM_CLK_DEU1);
		h_deumclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDEU1);

		OSAL_CCMU_SetMclkSrc(h_deumclk1, CLK_FE_SRC);	//FIX CONNECT TO PLL9
		OSAL_CCMU_SetMclkDiv(h_deumclk1, 1);
		pll_freq = OSAL_CCMU_GetSrcFreq(CLK_FE_SRC);
		mclk_div = 1;
		while((pll_freq / mclk_div) > 300000000) {
			mclk_div ++;
		}
		OSAL_CCMU_SetMclkDiv(h_deumclk1, mclk_div);

		OSAL_CCMU_MclkOnOff(h_deuahbclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deuahbclk1, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_deudramclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deudramclk1, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_deumclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deumclk1, CLK_OFF);
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_deumclk1, RST_INVAILD);
#endif
	}
	return DIS_SUCCESS;
}
Beispiel #10
0
//en : 0-close when vbi
//en : 1- open when vbi
//en : 2-close immediately
__s32 drc_enable(__u32 sel, __u32 en)
{
	switch(en) {
	case 0:
		if(g_iep_status[sel] & DRC_USED) {
			g_iep_status[sel] |= DRC_NEED_CLOSED;
		}	else {
			DE_INF("[iep_drc.c]DRC hasn't opened yet !\n");
		}
		break;

	case 1:
		if(g_iep_status[sel] & DRC_REQUIRED) {
			//if((gdisp.screen[sel].output_type == DISP_OUTPUT_TYPE_LCD) && (gdisp.screen[sel].status & LCD_ON))
			//{
			if(!(g_iep_status[sel] & DRC_USED)) {
				drc_init(sel);
				g_iep_status[sel] |= DRC_USED;
				DE_INF("[iep_drc.c]DRC open now!\n");
			}	else {
				DE_INF("[iep_drc.c]DRC has already opened before !\n");
			}
			//}
			//else
			//{
			//  DE_INF("[iep_drc.c]Will OPEN DRC when output to LCD !\n");
			//}
		}	else {
			DE_INF("[iep_drc.c]Run DISP_CMD_DRC_ON will open DRC !\n");
		}
		break;

	case 2:
		if(g_iep_status[sel] & DRC_USED) {
			drc_close_proc(sel);
		}	else {
			DE_INF("[iep_drc.c]DRC hasn't opened yet !\n");
		}
		break;

	}
	return DIS_SUCCESS;
}
Beispiel #11
0
__s32 BSP_disp_close_lcd_backlight(__u32 sel)
{
	user_gpio_set_t gpio_info[1];
	__hdle hdl;
	int value, ret;
	char primary_key[20];
	sprintf(primary_key, "lcd%d_para", sel);
	value = 1;
	ret = script_parser_fetch(primary_key, "lcd_bl_en_used", &value, 1);
	if (value == 0) {
		DE_INF("%s.lcd_bl_en is not used\n", primary_key);
	} else {
		ret =
		    script_parser_fetch(primary_key, "lcd_bl_en",
					(int *)gpio_info,
					sizeof(user_gpio_set_t) / sizeof(int));
		if (ret < 0) {
			DE_INF("%s.lcd_bl_en not exist\n", primary_key);
		} else {
			gpio_info->data = (gpio_info->data == 0) ? 1 : 0;
			hdl = OSAL_GPIO_Request(gpio_info, 1);
			OSAL_GPIO_Release(hdl, 2);
		}
	}
	value = 1;
	ret = script_parser_fetch(primary_key, "lcd_pwm_used", &value, 1);
	if (value == 0) {
		DE_INF("%s.lcd_pwm is not used\n", primary_key);
	} else {
		ret = script_parser_fetch(primary_key, "lcd_pwm",
					  (int *)gpio_info,
					  sizeof(user_gpio_set_t) /
					  sizeof(int));
		if (ret < 0) {
			DE_INF("%s.lcd_pwm not exist\n", primary_key);
		} else {
			gpio_info->mul_sel = 0;
			hdl = OSAL_GPIO_Request(gpio_info, 1);
			OSAL_GPIO_Release(hdl, 2);
		}
	}
	return 0;
}
Beispiel #12
0
__s32 Scaler_open(__u32 sel)
{
    DE_INF("scaler %d open\n", sel);

    scaler_clk_on(sel);
    DE_SCAL_Reset(sel);
    DE_SCAL_Enable(sel);

    return DIS_SUCCESS;
}
Beispiel #13
0
__s32 drc_clk_init(__u32 sel)
{
	__u32 pll_freq;
	__u32 mclk_div;

	DE_INF("drc %d clk init\n", sel);
	if(!sel) {
		h_drcahbclk0 = OSAL_CCMU_OpenMclk(AHB_CLK_DRC0);
		h_drcdramclk0 = OSAL_CCMU_OpenMclk(DRAM_CLK_DRC0);
		h_drcmclk0 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDRC0);

		OSAL_CCMU_SetMclkSrc(h_drcmclk0, CLK_BE_SRC);

		pll_freq = OSAL_CCMU_GetSrcFreq(CLK_BE_SRC);
		mclk_div = 1;
		while((pll_freq / mclk_div) > 300000000) {
			mclk_div ++;
		}
		OSAL_CCMU_SetMclkDiv(h_drcmclk0, mclk_div);

		OSAL_CCMU_MclkOnOff(h_drcahbclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcahbclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_drcdramclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcdramclk0, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_drcmclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcmclk0, CLK_OFF);
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_drcmclk0, RST_INVAILD);
#endif
	}	else {
		h_drcahbclk1 = OSAL_CCMU_OpenMclk(AHB_CLK_DRC1);
		h_drcdramclk1 = OSAL_CCMU_OpenMclk(DRAM_CLK_DRC1);
		h_drcmclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDRC1);

		OSAL_CCMU_SetMclkSrc(h_drcmclk1, CLK_BE_SRC);

		pll_freq = OSAL_CCMU_GetSrcFreq(CLK_BE_SRC);
		mclk_div = 1;
		while((pll_freq / mclk_div) > 300000000) {
			mclk_div ++;
		}
		OSAL_CCMU_SetMclkDiv(h_drcmclk1, mclk_div);

		OSAL_CCMU_MclkOnOff(h_drcahbclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcahbclk1, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_drcdramclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcdramclk1, CLK_OFF);
		OSAL_CCMU_MclkOnOff(h_drcmclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_drcmclk1, CLK_OFF);
#ifdef RESET_OSAL
		OSAL_CCMU_MclkReset(h_drcmclk1, RST_INVAILD);
#endif
	}
	return DIS_SUCCESS;
}
Beispiel #14
0
__s32 BSP_disp_set_output_csc(__u32 sel, __u32 out_type, __u32 drc_en)
{
    __disp_color_range_t out_color_range = DISP_COLOR_RANGE_0_255;
    __u32 out_csc = 0;//out_csc: 0:rgb  1:yuv  2:igb
    
    if(out_type == DISP_OUTPUT_TYPE_HDMI)
    {
        __s32 ret = 0;
        __s32 value = 0;
        
        out_color_range = DISP_COLOR_RANGE_16_255;

        ret = OSAL_Script_FetchParser_Data("disp_init", "screen0_out_color_range", &value, 1);
        if(ret < 0)
        {
            DE_INF("fetch script data disp_init.screen0_out_color_range fail\n");
        }
        else
        {
            out_color_range = value;
            DE_INF("screen0_out_color_range = %d\n", value);
        }
        out_csc = 0;
    }
    else if(out_type == DISP_OUTPUT_TYPE_LCD)
    {
        out_csc = 0;
    }
    else if(out_type == DISP_OUTPUT_TYPE_TV)
    {
        out_csc = 1;
    }
    
    if(drc_en)
    {
        out_csc = 2;
    }
    
    DE_BE_Set_Enhance(sel, out_csc, out_color_range, gdisp.screen[sel].bright, gdisp.screen[sel].contrast, gdisp.screen[sel].saturation, gdisp.screen[sel].hue);

    return DIS_SUCCESS;
}
//should protect width @mlock
static s32 disp_smbl_update_backlight(struct disp_smbl* smbl, unsigned int bl)
{
	if(NULL == smbl) {
		DE_INF("NULL hdl!\n");
		return -1;
	}

	smbl->backlight = bl;

	return 0;
}
/* seem no meaning */
static bool disp_enhance_is_enabled(struct disp_enhance* enhance)
{
	struct disp_enhance_private_data *enhancep = disp_enhance_get_priv(enhance);

	if((NULL == enhance) || (NULL == enhancep)) {
		DE_INF("NULL hdl!\n");
		return false;
	}

	return enhancep->enabled;
}
static s32 disp_enhance_exit(struct disp_enhance *enhance)
{
	struct disp_enhance_private_data *enhancep = disp_enhance_get_priv(enhance);

	if((NULL == enhance) || (NULL == enhancep)) {
		DE_INF("NULL hdl!\n");
		return -1;
	}

	return 0;
}
Beispiel #18
0
__s32 bsp_disp_scaler_release(__u32 handle)
{
	__u32 scaler_index = 0;

	scaler_index = SCALER_HANDTOID(handle);
	if(gdisp.scaler[scaler_index].screen_index == 0xff) {
		return Scaler_Release(scaler_index, FALSE);
	}
	DE_INF("bsp_disp_scaler_release, scaler %d not a independent scaler\n", scaler_index);
	return 0;
}
Beispiel #19
0
s32 bsp_disp_set_hdmi_func(u32 screen_id, disp_hdmi_func * func)
{
	struct disp_hdmi* hdmi;
	s32 ret = -1;
	hdmi = disp_get_hdmi(screen_id);
	if(!hdmi) {
	    DE_INF("get hdmi%d failed!\n", screen_id);
	    return DIS_FAIL;
	    }

	gdisp.hdmi_registered = 1;
	if(hdmi->set_func)
	    ret = hdmi->set_func(hdmi, func);

	if(gdisp.init_para.start_process) {
		DE_INF("gdisp.init_para.start_process\n");
		gdisp.init_para.start_process();
	}
	return ret;
}
static s32 disp_smbl_exit(struct disp_smbl *smbl)
{
	struct disp_smbl_private_data *smblp = disp_smbl_get_priv(smbl);

	if((NULL == smbl) || (NULL == smblp)) {
		DE_INF("NULL hdl!\n");
		return -1;
	}

	return 0;
}
Beispiel #21
0
__s32 Display_Hdmi_Init(void)
{
    __s32 ret;
    __u32 value;
    hdmi_clk_init();
    
    ret = OSAL_Script_FetchParser_Data("disp_init", "hdmi_cts_compatibility", &value, 1);
    if(ret < 0)
    {
        DE_INF("disp_init.hdmi_cts_compatibility not exit\n");
    }
    else
    {
        DE_INF("disp_init.hdmi_cts_compatibility = %d\n", value);
        gdisp.init_para.hdmi_cts_compatibility = value;
    }
    gdisp.screen[0].hdmi_mode = DISP_TV_MOD_720P_50HZ;
    gdisp.screen[1].hdmi_mode = DISP_TV_MOD_720P_50HZ;
    return DIS_SUCCESS;
}
static bool disp_smbl_is_enabled(struct disp_smbl* smbl)
{
	struct disp_smbl_private_data *smblp = disp_smbl_get_priv(smbl);

	if((NULL == smbl) || (NULL == smblp)) {
		DE_INF("NULL hdl!\n");
		return false;
	}

	return (smblp->info.enable == 1);
}
Beispiel #23
0
__s32 disp_video_init()
{
	__u32 num_screens;
	__u32 num_scalers;
	__u32 scaler_id;

	num_screens = bsp_disp_feat_get_num_screens();
	num_scalers = bsp_disp_feat_get_num_scalers();
	memset(g_video,0,sizeof(g_video));
#ifdef __LINUX_OSAL__
	for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
		if((bsp_disp_feat_get_layer_feats(scaler_id, DISP_LAYER_WORK_MODE_SCALER, scaler_id)
				    & DISP_LAYER_FEAT_DE_INTERLACE))
			bsp_disp_lcd_delay_ms(10);
			maf_flag_mem[scaler_id][0] = (void*)__pa((char __iomem *)kmalloc(maf_flag_mem_len, GFP_KERNEL |  __GFP_ZERO));
			maf_flag_mem[scaler_id][1] = (void*)__pa((char __iomem *)kmalloc(maf_flag_mem_len, GFP_KERNEL |  __GFP_ZERO));
			DE_INF("maf_flag_mem[%d][%d]=0x%8x, maf_flag_mem[%d][%d]=0x%8x\n",scaler_id, 0,
				(unsigned int)maf_flag_mem[scaler_id][0], scaler_id, 1, (unsigned int)maf_flag_mem[scaler_id][1]);
			if((maf_flag_mem[scaler_id][0] == NULL) || (maf_flag_mem[scaler_id][1] == NULL)) {
				DE_WRN("maf memory[%d] request fail\n", scaler_id);
			}
	}
#else
	for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
		if((bsp_disp_feat_get_layer_feats(scaler_id, DISP_LAYER_WORK_MODE_SCALER, scaler_id)
			    & DISP_LAYER_FEAT_DE_INTERLACE))
			maf_flag_mem[scaler_id][0] = OSAL_PhyAlloc(maf_flag_mem_len);
			maf_flag_mem[scaler_id][1] = OSAL_PhyAlloc(maf_flag_mem_len);
			DE_INF("maf_flag_mem[%d][%d]=0x%8x, maf_flag_mem[%d][%d]=0x%8x\n",scaler_id, 0,
				(unsigned int)maf_flag_mem[scaler_id][0], scaler_id, 1, (unsigned int)maf_flag_mem[scaler_id][1]);
			if((maf_flag_mem[scaler_id][0] == NULL) || (maf_flag_mem[scaler_id][1] == NULL)) {
				DE_WRN("maf memory[%d] request fail\n", scaler_id);
			}
	}
#endif
	for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
		dit_mode_default[scaler_id] = DIT_MODE_MAF;
	}

	return DIS_SUCCESS;
}
Beispiel #24
0
s32 bsp_disp_lcd_pin_cfg(u32 screen_id, u32 bon)
{
	struct disp_lcd* lcd;
	DE_INF("bsp_disp_lcd_pin_cfg, sel=%d, %s\n", screen_id, (bon)? "on":"off");

	lcd = disp_get_lcd(screen_id);
	if(lcd && lcd->pin_cfg) {
		return lcd->pin_cfg(lcd, bon);
	}

	return DIS_FAIL;
}
static s32 disp_enhance_update_regs(struct disp_enhance* enhance)
{
	unsigned long flags;
	struct disp_enhance_private_data *enhancep = disp_enhance_get_priv(enhance);

	if((NULL == enhance) || (NULL == enhancep)) {
		DE_INF("NULL hdl!\n");
		return -1;
	}

	if(enhancep->applied) {
		DE_INF("enhance %d, enable=%d\n", enhance->disp, enhancep->config.info.enable);
		disp_al_enhance_update_regs(enhance->disp);
	}

	disp_sys_irqlock((void*)&enhance_data_lock, &flags);
	enhancep->applied = false;
	disp_sys_irqunlock((void*)&enhance_data_lock, &flags);

	return 0;
}
Beispiel #26
0
__s32 Scaler_open(__u32 scaler_index)
{
	DE_INF("scaler %d open\n", scaler_index);

	scaler_clk_on(scaler_index);
	deu_clk_open(scaler_index, 0);
	DE_SCAL_Reset(scaler_index);
	DE_SCAL_DisableINT(scaler_index,DE_WB_END_IE);
	DE_SCAL_Enable(scaler_index);

	return DIS_SUCCESS;
}
Beispiel #27
0
__s32 deu_clk_init(__u32 sel)
{
    __u32 pll_freq;
    __u32 mclk_div;

    DE_INF("deu %d clk init\n", sel);
	if(!sel)
	{
	    h_deuahbclk0 = OSAL_CCMU_OpenMclk(AHB_CLK_DEU0);
	    h_deudramclk0 = OSAL_CCMU_OpenMclk(DRAM_CLK_DEU0);
	    h_deumclk0 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDEU0);

		OSAL_CCMU_MclkReset(h_deumclk0, RST_INVAILD);
		
		OSAL_CCMU_SetMclkSrc(h_deumclk0, SYS_CLK_PLL10);	//FIX CONNECT TO  PLL10
		OSAL_CCMU_SetMclkDiv(h_deumclk0, 1);
        pll_freq = OSAL_CCMU_GetSrcFreq(SYS_CLK_PLL10);
        mclk_div = 1;
        while((pll_freq / mclk_div) > 300000000)
        {
            mclk_div ++;
        }
		OSAL_CCMU_SetMclkDiv(h_deumclk0, mclk_div);
		
		OSAL_CCMU_MclkOnOff(h_deuahbclk0, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deumclk0, CLK_ON);

		g_deu_clk_status  |= (CLK_DEU0_AHB_ON | CLK_DEU0_MOD_ON);
	}
	else
	{
		h_deuahbclk1 = OSAL_CCMU_OpenMclk(AHB_CLK_DEU1);
	    h_deudramclk1 = OSAL_CCMU_OpenMclk(DRAM_CLK_DEU1);
	    h_deumclk1 = OSAL_CCMU_OpenMclk(MOD_CLK_IEPDEU1);

		OSAL_CCMU_MclkReset(h_deumclk1, RST_INVAILD);
		OSAL_CCMU_SetMclkSrc(h_deumclk1, SYS_CLK_PLL10);	//FIX CONNECT TO PLL10
		OSAL_CCMU_SetMclkDiv(h_deumclk1, 1);
        pll_freq = OSAL_CCMU_GetSrcFreq(SYS_CLK_PLL10);
        mclk_div = 1;
        while((pll_freq / mclk_div) > 300000000)
        {
            mclk_div ++;
        }
		OSAL_CCMU_SetMclkDiv(h_deumclk1, mclk_div);
		
		OSAL_CCMU_MclkOnOff(h_deuahbclk1, CLK_ON);
		OSAL_CCMU_MclkOnOff(h_deumclk1, CLK_ON);

		g_deu_clk_status  |= (CLK_DEU1_AHB_ON | CLK_DEU1_MOD_ON);
	}
	return DIS_SUCCESS;
}
//should protect width @mlock
static s32 disp_smbl_apply(struct disp_smbl* smbl)
{
	unsigned long flags;
	struct disp_smbl_private_data *smblp = disp_smbl_get_priv(smbl);
	struct disp_smbl_info info;

	if((NULL == smbl) || (NULL == smblp)) {
		DE_INF("NULL hdl!\n");
		return -1;
	}
	DE_INF("smbl %d apply, en=%d, win=<%d,%d,%d,%d>\n", smbl->disp,
	smblp->info.enable, smblp->info.window.x, smblp->info.window.y,
	smblp->info.window.width, smblp->info.window.height);

	memset(&info, 0, sizeof(struct disp_smbl_info));

	//disp_sys_lock((void *)&smblp->mlock);
	if(smbl->backlight != smblp->info.backlight) {
		smblp->info.backlight = smbl->backlight;
		smblp->info.flags |= SMBL_DIRTY_BL;
	}
	//FIXME
	smblp->info.backlight = 255;
	if(SMBL_DIRTY_NONE != smblp->info.flags) {
		memcpy(&info, &smblp->info, sizeof(struct disp_smbl_info));
		smblp->info.flags = SMBL_DIRTY_NONE;
	}
	//disp_sys_unlock((void *)&smblp->mlock);

	if(SMBL_DIRTY_NONE != info.flags) {
		disp_smbl_shadow_protect(smbl, true);
		disp_al_smbl_apply(smbl->disp, &info);
		disp_smbl_shadow_protect(smbl, false);
		disp_sys_irqlock((void*)&smbl_data_lock, &flags);
		smblp->applied = true;
		disp_sys_irqunlock((void*)&smbl_data_lock, &flags);
	}

	return 0;
}
Beispiel #29
0
struct disp_hdmi* disp_get_hdmi(u32 screen_id)
{
	u32 num_screens;

	num_screens = bsp_disp_feat_get_num_screens();
	if(screen_id >= num_screens) {
		DE_WRN("screen_id %d out of range\n", screen_id);
		return NULL;
	}

	if(!(bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI)) {
	    DE_INF("screen_id %d do not support HDMI TYPE!\n", screen_id);
	    return NULL;
	}

	if(!disp_al_query_hdmi_mod(screen_id)) {
		DE_INF("hdmi %d is not registered\n", screen_id);
		return NULL;
	}

	return &hdmis[screen_id];
}
struct disp_smbl* disp_get_smbl(u32 disp)
{
	u32 num_screens;

	num_screens = bsp_disp_feat_get_num_screens();
	if(disp >= num_screens) {
		DE_WRN("disp %d out of range\n", disp);
		return NULL;
	}
	DE_INF("get smbl%d ok\n", disp);

	return &smbls[disp];
}