Exemple #1
0
__s32 Disp_lcdc_init(__u32 sel)
{
    lcdc_clk_init(sel);
    lcdc_clk_on(sel);	//??need to be open
    LCDC_init(sel);
    lcdc_clk_off(sel);
    Disp_pwm_cfg(sel);

    if(sel == 0)
    {
        LCD_get_panel_funs_0(&lcd_panel_fun[sel]);
        OSAL_RegISR(INTC_IRQNO_LCDC0,0,Disp_lcdc_event_proc,(void*)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_LCDC0);
    }
    else
    {
        LCD_get_panel_funs_1(&lcd_panel_fun[sel]);
        OSAL_RegISR(INTC_IRQNO_LCDC1,0,Disp_lcdc_event_proc,(void*)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_LCDC1);
    }
    lcd_panel_fun[sel].cfg_panel_info(&gpanel_info[sel]);


    return DIS_SUCCESS;
}
Exemple #2
0
__s32 Image_init(__u32 screen_id)
{
	image_clk_init(screen_id);
	/* when access image registers, must open MODULE CLOCK of image */
	image_clk_on(screen_id, 0);
	DE_BE_Reg_Init(screen_id);

	Image_open(screen_id);

	DE_BE_EnableINT(screen_id, DE_IMG_REG_LOAD_FINISH);
	DE_BE_reg_auto_load_en(screen_id, 0);

	if(screen_id == 0) {
		OSAL_RegISR(gdisp.init_para.irq[DISP_MOD_BE0],0,scaler_event_proc, (void *)screen_id,0,0);
#ifndef __LINUX_OSAL__
		OSAL_InterruptEnable(gdisp.init_para.irq[DISP_MOD_BE0]);
#endif
	}	else if(screen_id == 1) {
		OSAL_RegISR(gdisp.init_para.irq[DISP_MOD_BE1],0,scaler_event_proc, (void *)screen_id,0,0);
#ifndef __LINUX_OSAL__
		OSAL_InterruptEnable(gdisp.init_para.irq[DISP_MOD_BE1]);
#endif
	}
	return DIS_SUCCESS;
}
Exemple #3
0
__s32 Image_init(__u32 sel)
{

    image_clk_init(sel);
	image_clk_on(sel);	//when access image registers, must open MODULE CLOCK of image
	DE_BE_Reg_Init(sel);

    if(sel == 0)
    {
        BSP_disp_sprite_init(sel);
    }
    //DE_BE_Ready_Enable(sel, TRUE);
    Image_open(sel);

	if(sel == 0)
	{
    	DE_BE_EnableINT(sel, DE_IMG_IRDY_IE);
	}//DE_BE_EnableINT(sel , DE_IMG_IRDY_IE);	//when sel == 1, can't process when image0 module clk close
	//image_clk_off(sel);	//close MODULE CLOCK of image

    if(sel == 0)
    {
        OSAL_RegISR(INTC_IRQNO_IMAGE0,0,Image_event_proc, (void *)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_IMAGE0);
    }
    else if(sel == 1)
    {
        OSAL_RegISR(INTC_IRQNO_IMAGE1,0,Image_event_proc, (void *)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_IMAGE1);
    }

    return DIS_SUCCESS;
}
Exemple #4
0
__s32 Scaler_Init(__u32 scaler_index)
{
	scaler_clk_init(scaler_index);
	DE_SCAL_DisableINT(scaler_index,DE_WB_END_IE);

	if(scaler_index == 0) {
		OSAL_RegISR(gdisp.init_para.irq[DISP_MOD_FE0],0,scaler_event_proc, (void *)scaler_index,0,0);
#ifndef __LINUX_OSAL__
		OSAL_InterruptEnable(gdisp.init_para.irq[DISP_MOD_FE0]);
#endif
	}	else if(scaler_index == 1) {
		OSAL_RegISR(gdisp.init_para.irq[DISP_MOD_FE1],0,scaler_event_proc, (void *)scaler_index,0,0);
#ifndef __LINUX_OSAL__
		OSAL_InterruptEnable(gdisp.init_para.irq[DISP_MOD_FE1]);
#endif
	}
	return DIS_SUCCESS;
}
__s32 Scaler_Init(__u32 sel)
{
    scaler_clk_init(sel);
    DE_SCAL_EnableINT(sel,DE_WB_END_IE);

    if(sel == 0)
    {
        OSAL_RegISR(INTC_IRQNO_SCALER0,0,Scaler_event_proc, (void *)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_SCALER0);
    }
    else if(sel == 1)
    {
        OSAL_RegISR(INTC_IRQNO_SCALER1,0,Scaler_event_proc, (void *)sel,0,0);
        //OSAL_InterruptEnable(INTC_IRQNO_SCALER1);
    }

   	return DIS_SUCCESS;
}
Exemple #6
0
__s32 Disp_lcdc_init(__u32 sel)
{
    LCD_get_sys_config(sel, &(gdisp.screen[sel].lcd_cfg));

    lcdc_clk_init(sel);
    lvds_clk_init();
    lcdc_clk_on(sel);	//??need to be open
    LCDC_init(sel);
    lcdc_clk_off(sel);

    if(sel == 0)
    {
        OSAL_RegISR(INTC_IRQNO_LCDC0,0,Disp_lcdc_event_proc,(void*)sel,0,0);
#ifndef __LINUX_OSAL__
        OSAL_InterruptEnable(INTC_IRQNO_LCDC0);
        LCD_get_panel_funs_0(&lcd_panel_fun[sel]);
#endif
    }
    else
    {
        OSAL_RegISR(INTC_IRQNO_LCDC1,0,Disp_lcdc_event_proc,(void*)sel,0,0);
#ifndef __LINUX_OSAL__
        OSAL_InterruptEnable(INTC_IRQNO_LCDC1);
        LCD_get_panel_funs_1(&lcd_panel_fun[sel]);
#endif
    }

    if(gdisp.screen[sel].lcd_cfg.lcd_used)
    {
        if(lcd_panel_fun[sel].cfg_panel_info)
        {
            lcd_panel_fun[sel].cfg_panel_info(&gpanel_info[sel]);
        }
        else
        {
            LCD_get_panel_para(sel, &gpanel_info[sel]);
        }
        gpanel_info[sel].tcon_index = 0;

        if((OSAL_sw_get_ic_ver() != 0xA) && (gpanel_info[sel].lcd_pwm_not_used == 0))
        {
            __pwm_info_t pwm_info;

            pwm_info.enable = 0;
            pwm_info.active_state = 1;
            pwm_info.period_ns = 1000000 / gpanel_info[sel].lcd_pwm_freq;
            if(gpanel_info[sel].lcd_pwm_pol == 0)
            {
                pwm_info.duty_ns = (192 * pwm_info.period_ns) / 256;
            }
            else
            {
                pwm_info.duty_ns = ((256 - 192) * pwm_info.period_ns) / 256;
            }
            pwm_set_para(gpanel_info[sel].lcd_pwm_ch, &pwm_info);
        }
        LCD_GPIO_init(sel);
    }

    return DIS_SUCCESS;
}
s32 disp_lcd_init(struct disp_lcd* lcd)
{
	struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
	struct disp_notifier_block *nb;

	if((NULL == lcd) || (NULL == lcdp)) {
		DE_WRN("NULL hdl!\n");
		return DIS_FAIL;
	}

	/* register one notifier for all lcd */
	if(0 == lcd->channel_id) {
		nb = (struct disp_notifier_block *)OSAL_malloc(sizeof(struct disp_notifier_block));
		if(nb) {
			nb->notifier_call = &disp_lcd_notifier_callback;
			disp_notifier_register(nb);
		} else
			DE_WRN("malloc memory fail!\n");
	}

	lcd_get_sys_config(lcd->channel_id, &lcdp->lcd_cfg);
	lcd_parse_panel_para(lcd->channel_id, &lcdp->panel_info);
	if(disp_lcd_is_used(lcd)) {
		if(lcdp->panel_info.lcd_pwm_used) {
			lcdp->pwm_info.channel = lcdp->panel_info.lcd_pwm_ch;
			lcdp->pwm_info.polarity = lcdp->panel_info.lcd_pwm_pol;
//			lcdp->pwm_info.dev = OSAL_Pwm_request(lcdp->panel_info.lcd_pwm_ch);
		}
		disp_lcd_backlight_disable(lcd);
	}

	lcd_clk_init(lcd);
	lcd_clk_enable(lcd);
	disp_al_lcd_init(lcd->channel_id);
	lcd_clk_disable(lcd);

	if(disp_al_query_lcd_mod(lcd->channel_id)) {
		OSAL_RegISR(lcdp->irq_no,0,disp_lcd_event_proc,(void*)lcd->channel_id,0,0);
#if !defined(__LINUX_PLAT__)
		OSAL_InterruptEnable(lcdp->irq_no);
#endif
	}

	if(LCD_IF_DSI == lcdp->panel_info.lcd_if)	{
		OSAL_RegISR(lcdp->irq_no_dsi,0,disp_lcd_event_proc,(void*)lcd->channel_id,0,0);
#if !defined(__LINUX_PLAT__)
		OSAL_InterruptEnable(lcdp->irq_no_dsi);
#endif
	} else if(LCD_IF_EDP == lcdp->panel_info.lcd_if)	{
		/* todo? register edp vint proc */
	}

	__u64 backlight_bright;
	__u64 period_ns, duty_ns;

	if(lcdp->panel_info.lcd_pwm_freq != 0) {
		period_ns = 1000*1000*1000 / lcdp->panel_info.lcd_pwm_freq;
	} else {
		DE_WRN("lcd%d.lcd_pwm_freq is ZERO\n", lcd->channel_id);
		period_ns = 1000*1000*1000 / 1000;  //default 1khz
	}

	backlight_bright = lcdp->lcd_cfg.backlight_bright;

	duty_ns = (backlight_bright * period_ns) / 256;
//		DE_DBG("[PWM]backlight_bright=%d,period_ns=%d,duty_ns=%d\n",(u32)backlight_bright,(u32)period_ns, (u32)duty_ns);
	sunxi_pwm_set_polarity(lcdp->pwm_info.channel, lcdp->pwm_info.polarity);
	sunxi_pwm_config(lcdp->pwm_info.channel, duty_ns, period_ns);
	lcdp->pwm_info.duty_ns = duty_ns;
	lcdp->pwm_info.period_ns = period_ns;

	return 0;
}