//申请一个新的结点,并初始化
static list_head_t * List_New_Sprite_Block(__u32 sel, __disp_sprite_block_para_t * para)
{
list_head_t * node = NULL;
sprite_block_data_t * data = NULL;
__s32 id;
id = Sprite_Get_Idle_Block_id(sel);
if(id != DIS_NO_RES)
{
data = (sprite_block_data_t *)OSAL_malloc(sizeof(sprite_block_data_t));
data->enable = FALSE;
data->id = id;
data->src_win.x = para->src_win.x;
data->src_win.y = para->src_win.y;
data->scn_win.x = para->scn_win.x;
data->scn_win.y = para->scn_win.y;
data->scn_win.width = para->scn_win.width;
data->scn_win.height = para->scn_win.height;
data->address = (__u32)para->fb.addr[0];
data->size.width = para->fb.size.width;
node = (list_head_t *)OSAL_malloc(sizeof(list_head_t));
node->next = node->prev = node;
node->data = data;
return node;
}
else
{
return NULL;
}
}
static void LCD_panel_exit(__u32 sel)
{
__panel_para_t *info = OSAL_malloc(sizeof(__panel_para_t));
sunxi_lcd_get_panel_para(sel, info);
lp079x01_exit(info);
OSAL_free(info);
return;
}
s32 disp_init_hdmi(__disp_bsp_init_para * para)
{
s32 ret;
s32 value;
//get sysconfig hdmi_used
ret = OSAL_Script_FetchParser_Data("hdmi_para", "hdmi_used", &value, 1);
if(ret == 0)
hdmi_used = value;
if(hdmi_used) {
u32 num_screens;
u32 screen_id;
struct disp_hdmi* hdmi;
struct disp_hdmi_private_data* hdmip;
DE_INF("disp_init_hdmi\n");
#if defined(__LINUX_PLAT__)
spin_lock_init(&hdmi_data_lock);
#endif
num_screens = bsp_disp_feat_get_num_screens();
hdmis = (struct disp_hdmi *)OSAL_malloc(sizeof(struct disp_hdmi) * num_screens);
if(NULL == hdmis) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
hdmi_private = (struct disp_hdmi_private_data *)OSAL_malloc(sizeof(struct disp_hdmi_private_data) * num_screens);
if(NULL == hdmi_private) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
for(screen_id=0; screen_id<num_screens; screen_id++) {
hdmi = &hdmis[screen_id];
hdmip = &hdmi_private[screen_id];
if(!disp_al_query_hdmi_mod(screen_id)) {
DE_WRN("hdmi mod %d is not registered\n", screen_id);
continue;
}
if(!(bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI)) {
DE_WRN("screen %d do not support HDMI TYPE!\n", screen_id);
continue;
}
switch(screen_id) {
case 0:
hdmi->channel_id = 0;
hdmi->name = "hdmi0";
hdmi->type = DISP_OUTPUT_TYPE_HDMI;
hdmip->hdmi_clk.clk = MOD_CLK_HDMI;
hdmip->hdmi_ddc_clk.clk = MOD_CLK_HDMI_DDC;
hdmip->lcd_clk.clk = MOD_CLK_LCD0CH1;
hdmip->drc_clk.clk = MOD_CLK_IEPDRC0;
hdmip->drc_clk.clk_div = 3;
break;
case 1:
hdmi->channel_id = 1;
hdmi->name = "hdmi1";
hdmi->type = DISP_OUTPUT_TYPE_HDMI;
hdmip->hdmi_clk.clk = MOD_CLK_HDMI;
hdmip->hdmi_ddc_clk.clk = MOD_CLK_HDMI_DDC;
hdmip->lcd_clk.clk = MOD_CLK_LCD1CH1;
hdmip->drc_clk.clk = MOD_CLK_IEPDRC1;
hdmip->drc_clk.clk_div = 3;
break;
case 2:
break;
default :
break;
}
hdmip->mode = DISP_TV_MOD_720P_50HZ;
hdmi->init = disp_hdmi_init;
hdmi->exit = disp_hdmi_exit;
hdmi->set_func = disp_hdmi_set_func;
hdmi->enable = disp_hdmi_enable;
hdmi->disable = disp_hdmi_disable;
hdmi->is_enabled = disp_hdmi_is_enabled;
hdmi->set_mode = disp_hdmi_set_mode;
hdmi->get_mode = disp_hdmi_get_mode;
hdmi->check_support_mode = disp_hdmi_check_support_mode;
hdmi->get_input_csc = disp_hdmi_get_input_csc;
hdmi->hdmi_get_HPD_status = disp_hdmi_get_HPD_status;
hdmi->init(hdmi);
}
}
return 0;
}
s32 disp_init_lcd(__disp_bsp_init_para * para)
{
u32 num_screens;
u32 screen_id;
DE_INF("disp_init_lcd\n");
#if defined(__LINUX_PLAT__)
spin_lock_init(&lcd_data_lock);
#endif
num_screens = bsp_disp_feat_get_num_screens();
lcds = (struct disp_lcd *)OSAL_malloc(sizeof(struct disp_lcd) * num_screens);
if(NULL == lcds) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
lcd_private = (struct disp_lcd_private_data *)OSAL_malloc(sizeof(struct disp_lcd_private_data) * num_screens);
if(NULL == lcd_private) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
for(screen_id=0; screen_id<num_screens; screen_id++) {
struct disp_lcd *lcd = &lcds[screen_id];
struct disp_lcd_private_data *lcdp = &lcd_private[screen_id];
switch(screen_id) {
case 0:
lcd->name = "lcd0";
lcd->channel_id = 0;
lcd->type = DISP_OUTPUT_TYPE_LCD;
lcdp->irq_no = para->irq_no[DISP_MOD_LCD0];
lcdp->irq_no_dsi = para->irq_no[DISP_MOD_DSI0];
lcdp->reg_base = para->reg_base[DISP_MOD_LCD0];
lcdp->reg_base_dsi = para->reg_base[DISP_MOD_DSI0];
lcdp->lcd_clk.clk = DISP_MOD_LCD0;
lcdp->lcd_clk.clk_src = CLK_LCD_SRC;
lcdp->lvds_clk.clk = DISP_MOD_LVDS;
lcdp->dsi_clk.clk = DISP_MOD_DSI0;
lcdp->dsi_clk.clk_src = CLK_DSI_SRC;
lcdp->dsi_clk.clk_div = 1;
lcdp->extra_clk.clk = DISP_MOD_DRC0;
lcdp->extra_clk.clk_src = CLK_BE_SRC;
lcdp->extra_clk.clk_div = 3;
break;
case 1:
lcd->name = "lcd1";
lcd->channel_id = 1;
lcd->type = DISP_OUTPUT_TYPE_LCD;
lcdp->irq_no = para->irq_no[DISP_MOD_LCD1];
lcdp->irq_no_dsi = para->irq_no[DISP_MOD_DSI1];
lcdp->reg_base = para->reg_base[DISP_MOD_LCD1];
lcdp->reg_base_dsi = para->reg_base[DISP_MOD_DSI1];
lcdp->lcd_clk.clk = DISP_MOD_LCD1;
lcdp->lcd_clk.clk_src = CLK_LCD_SRC;
lcdp->lvds_clk.clk = DISP_MOD_LVDS;
lcdp->dsi_clk.clk = DISP_MOD_DSI1;
lcdp->dsi_clk.clk_src = CLK_DSI_SRC;
lcdp->dsi_clk.clk_div = 1;
lcdp->extra_clk.clk = DISP_MOD_DRC1;
lcdp->extra_clk.clk_src = CLK_BE_SRC;
lcdp->extra_clk.clk_div = 3;
break;
case 2:
break;
}
DE_INF("lcd %d, reg_base=0x%x, irq_no=%d, reg_base_dsi=0x%x, irq_no_dsi=%d\n",\
screen_id, lcdp->reg_base, lcdp->irq_no, lcdp->reg_base_dsi, lcdp->irq_no_dsi);
lcd->is_enabled = disp_lcd_is_enabled;
lcd->is_used = disp_lcd_is_used;
lcd->get_resolution = disp_lcd_get_resolution;
lcd->get_physical_size = disp_lcd_get_physical_size;
lcd->get_input_csc = disp_lcd_get_input_csc;
lcd->init = disp_lcd_init;
lcd->exit = disp_lcd_exit;
//lcd->apply
// lcd->early_suspend
// lcd->late_resume
// lcd->suspend
// lcd->resume
lcd->backlight_enable = disp_lcd_backlight_enable;
lcd->backlight_disable = disp_lcd_backlight_disable;
lcd->pwm_enable = disp_lcd_pwm_enable;
lcd->pwm_disable = disp_lcd_pwm_disable;
lcd->power_enable = disp_lcd_power_enable;
lcd->power_disable = disp_lcd_power_disable;
lcd->pin_cfg = disp_lcd_pin_cfg;
lcd->set_bright = disp_lcd_set_bright;
lcd->get_bright = disp_lcd_get_bright;
lcd->get_timing = disp_lcd_get_timing;
lcd->get_open_flow = disp_lcd_get_open_flow;
lcd->get_close_flow = disp_lcd_get_close_flow;
lcd->pre_enable = disp_lcd_pre_enable;
lcd->post_enable = disp_lcd_post_enable;;
lcd->pre_disable = disp_lcd_pre_disable;
lcd->post_disable = disp_lcd_post_disable;
lcd->tcon_enable = disp_lcd_tcon_enable;
lcd->tcon_disable = disp_lcd_tcon_disable;
lcd->set_panel_func = disp_lcd_set_panel_funs;
lcd->set_open_func = disp_lcd_set_open_func;
lcd->set_close_func = disp_lcd_set_close_func;
lcd->get_panel_driver_name = disp_lcd_get_driver_name;
lcd->init(lcd);
}
return 0;
}
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;
}
