__s32 Disp_TVEC_Init(__u32 screen_id)
{
__s32 ret = 0, value = 0;
tve_clk_init(screen_id);
tve_clk_on(screen_id);
TVE_init(screen_id);
tve_clk_off(screen_id);
gdisp.screen[screen_id].dac_source[0] = DISP_TV_DAC_SRC_Y;
gdisp.screen[screen_id].dac_source[1] = DISP_TV_DAC_SRC_PB;
gdisp.screen[screen_id].dac_source[2] = DISP_TV_DAC_SRC_PR;
gdisp.screen[screen_id].dac_source[3] = DISP_TV_DAC_SRC_COMPOSITE;
ret = OSAL_Script_FetchParser_Data("tv_out_dac_para", "dac_used", &value, 1);
if(ret == 0) {
if(value != 0) {
__s32 i = 0;
char sub_key[20];
for(i=0; i<4; i++) {
sprintf(sub_key, "dac%d_src", i);
ret = OSAL_Script_FetchParser_Data("tv_out_dac_para", sub_key, &value, 1);
if(ret == 0) {
gdisp.screen[screen_id].dac_source[i] = value;
}
}
}
}
gdisp.screen[screen_id].tv_mode = DISP_TV_MOD_720P_50HZ;
return DIS_SUCCESS;
}
__s32 disp_hdmi_init(void)
{
__s32 ret;
__u32 value;
__u32 num_screens;
__u32 screen_id;
num_screens = bsp_disp_feat_get_num_screens();
ret = OSAL_Script_FetchParser_Data("hdmi_para", "hdmi_used", (int *)&value, 1);
if(ret == 0) {
if(value) {
ret = OSAL_Script_FetchParser_Data("hdmi_para", "hdmi_cts_compatibility", (int *)&value, 1);
if(ret < 0) {
DE_INF("disp_init.hdmi_cts_compatibility not exist\n");
} else {
DE_INF("disp_init.hdmi_cts_compatibility = %d\n", value);
gdisp.init_para.hdmi_cts_compatibility = value;
}
hdmi_clk_init();
hdmi_clk_on();
}
for(screen_id=0; screen_id<num_screens; screen_id++)
{
gdisp.screen[screen_id].hdmi_mode = DISP_TV_MOD_720P_50HZ;
gdisp.screen[screen_id].hdmi_test_mode = 0xff;
gdisp.screen[screen_id].hdmi_used = value;
}
}
return DIS_SUCCESS;
}
__s32 Disp_TVEC_Init(__u32 sel)
{
__s32 ret = 0, value = 0;
tve_clk_init(sel);
tve_clk_on(sel);
TVE_init(sel);
tve_clk_off(sel);
gdisp.screen[sel].dac_source[0] = DISP_TV_DAC_SRC_Y;
gdisp.screen[sel].dac_source[1] = DISP_TV_DAC_SRC_PB;
gdisp.screen[sel].dac_source[2] = DISP_TV_DAC_SRC_PR;
gdisp.screen[sel].dac_source[3] = DISP_TV_DAC_SRC_COMPOSITE;
ret = OSAL_Script_FetchParser_Data("tv_out_dac_para", "dac_used", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data tv_out_dac_para.dac_used fail\n");
}
else
{
DE_INF("tv_out_dac_para.dac_used=%d\n",value);
if(value != 0)
{
__s32 i = 0;
char sub_key[20];
for(i=0; i<4; i++)
{
sprintf(sub_key, "dac%d_src", i);
ret = OSAL_Script_FetchParser_Data("tv_out_dac_para", sub_key, &value, 1);
if(ret < 0)
{
DE_INF("fetch script data tv_out_dac_para.%s fail\n", sub_key);
}
else
{
gdisp.screen[sel].dac_source[i] = value;
DE_INF("tv_out_dac_para.%s = %d\n", sub_key, value);
}
}
}
}
gdisp.screen[sel].tv_mode = DISP_TV_MOD_720P_50HZ;
return DIS_SUCCESS;
}
__s32 IEP_Deu_Init(__u32 sel)
{
int ret;
int value = 1;
char primary_key[20];
g_strtab_addr = (__u32 *)kmalloc(512, GFP_KERNEL | __GFP_ZERO);
memcpy(g_strtab_addr, deu_str_tab, 512);
deu_clk_init(sel);
sprintf(primary_key, "lcd%d_para", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, "deu_mode", &value, 1);
if(ret < 0) {
DE_WRN("deu_mode%d not exist.\n", sel);
plptab = &deu_lp_tab_s[0][0][0];
} else {
DE_INF("deu_mode%d = %d.\n", sel, value);
if(value > 1 || value < 0) {
DE_WRN("deu_mode%d invalid.\n",sel);
plptab = &deu_lp_tab_s[0][0][0];
} else {
plptab = (value == 1)? (&deu_lp_tab_l[0][0][0]):(&deu_lp_tab_s[0][0][0]);
}
}
return DIS_SUCCESS;
}
static s32 disp_hdmi_init(struct disp_hdmi* hdmi)
{
s32 ret;
u32 value = 0;
struct disp_hdmi_private_data *hdmip = disp_hdmi_get_priv(hdmi);
if(!hdmi || !hdmip) {
DE_WRN("hdmi init null hdl!\n");
return DIS_FAIL;
}
if(!disp_al_query_hdmi_mod(hdmi->channel_id)) {
DE_WRN("hdmi %d is not register\n", hdmi->channel_id);
return DIS_FAIL;
}
ret = OSAL_Script_FetchParser_Data("hdmi_para", "hdmi_4k", &value, 1);
if(ret == 0)
hdmip->support_4k = value;
if((NULL != hdmi->p_sw_init_flag) && (0 != *(hdmi->p_sw_init_flag))) {
disp_al_hdmi_init_sw(hdmi->channel_id, hdmip->support_4k);
} else {
hdmi_clk_init(hdmi);
disp_al_hdmi_init(hdmi->channel_id, hdmip->support_4k);
}
return 0;
}
__s32 BSP_disp_set_output_csc(__u32 sel, __disp_output_type_t type)
{
__disp_color_range_t out_color_range = DISP_COLOR_RANGE_0_255;
__u32 out_csc = 0;
if(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 = 2;
}
else if(type == DISP_OUTPUT_TYPE_TV)
{
out_csc = 1;
}
DE_BE_Output_Cfg_Csc_Coeff(sel, out_csc, out_color_range);
return DIS_SUCCESS;
}
__s32 BSP_disp_set_output_csc(__u32 sel, __disp_output_type_t type)
{
__disp_color_range_t out_color_range = DISP_COLOR_RANGE_0_255;
__u32 out_csc = 0;
__u32 enhance_en, bright, contrast, saturation, hue;
enhance_en = gdisp.screen[sel].enhance_en;
bright = gdisp.screen[sel].bright;
contrast = gdisp.screen[sel].contrast;
saturation = gdisp.screen[sel].saturation;
hue = gdisp.screen[sel].hue;
if(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 = 2;
}
else if(type == DISP_OUTPUT_TYPE_TV)
{
out_csc = 1;
}
else if(type == DISP_OUTPUT_TYPE_LCD)
{
if(enhance_en == 0)
{
enhance_en = 1;
bright = gdisp.screen[sel].lcd_cfg.lcd_bright;
contrast = gdisp.screen[sel].lcd_cfg.lcd_contrast;
saturation = gdisp.screen[sel].lcd_cfg.lcd_saturation;
hue = gdisp.screen[sel].lcd_cfg.lcd_hue;
}
}
gdisp.screen[sel].out_color_range = out_color_range;
gdisp.screen[sel].out_csc = out_csc;
DE_BE_Set_Enhance_ex(sel, gdisp.screen[sel].out_csc, gdisp.screen[sel].out_color_range, enhance_en, bright, contrast, saturation, hue);
return DIS_SUCCESS;
}
__s32 bsp_disp_tv_close(__u32 screen_id)
{
if(gdisp.screen[screen_id].status & TV_ON)
{
Image_close(screen_id);
tcon1_close(screen_id);
Disp_TVEC_Close(screen_id);
tve_clk_off(screen_id);
image_clk_off(screen_id, 1);
lcdc_clk_off(screen_id);
#if (defined CONFIG_ARCH_SUN5I)
__u32 scaler_index = 0;
//disp_de_flicker_enable(screen_id, 2); //must close immediately, because vbi may not come
DE_BE_Set_Outitl_enable(screen_id, FALSE);
for(scaler_index=0; scaler_index<2; scaler_index++)
{
if((gdisp.scaler[scaler_index].status & SCALER_USED) && (gdisp.scaler[scaler_index].screen_index == screen_id))
{
Scaler_Set_Outitl(scaler_index, FALSE);
}
}
#endif
#ifdef __LINUX_OSAL__
{
disp_gpio_set_t gpio_info[1];
__hdle gpio_pa_shutdown;
__s32 ret;
memset(gpio_info, 0, sizeof(disp_gpio_set_t));
ret = OSAL_Script_FetchParser_Data("audio_para","audio_pa_ctrl", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret < 0) {
DE_WRN("fetch script data audio_para.audio_pa_ctrl fail\n");
} else {
gpio_pa_shutdown = OSAL_GPIO_Request(gpio_info, 1);
if(!gpio_pa_shutdown) {
DE_WRN("audio codec_wakeup request gpio fail!\n");
} else {
OSAL_GPIO_DevWRITE_ONEPIN_DATA(gpio_pa_shutdown, 1, "audio_pa_ctrl");
}
}
}
#endif
gdisp.screen[screen_id].b_out_interlace = 0;
gdisp.screen[screen_id].status &= TV_OFF;
gdisp.screen[screen_id].lcdc_status &= LCDC_TCON1_USED_MASK;
gdisp.screen[screen_id].output_type = DISP_OUTPUT_TYPE_NONE;
gdisp.screen[screen_id].pll_use_status &= ((gdisp.screen[screen_id].pll_use_status == VIDEO_PLL0_USED)? VIDEO_PLL0_USED_MASK : VIDEO_PLL1_USED_MASK);
Disp_set_out_interlace(screen_id);
}
return DIS_SUCCESS;
}
__s32 Disp_TVEC_Init(__u32 sel)
{
__s32 ret = 0, value = 0;
char primary_key[25];
sprintf(primary_key, "tv%d_para", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, "tv_used", &value, 1);
if(ret == 0)
{
gdisp.screen[sel].tv_used = value;
}
gdisp.screen[sel].tv_mode = DISP_TV_MOD_PAL;
return DIS_SUCCESS;
}
__s32 BSP_disp_tv_close(__u32 sel)
{
if(gdisp.screen[sel].status & TV_ON)
{
Image_close(sel);
TCON1_close(sel);
Disp_TVEC_Close(sel);
tve_clk_off(sel);
image_clk_off(sel);
lcdc_clk_off(sel);
#ifdef __LINUX_OSAL__
{
user_gpio_set_t gpio_info[1];
__hdle gpio_pa_shutdown;
__s32 ret;
memset(gpio_info, 0, sizeof(user_gpio_set_t));
ret = OSAL_Script_FetchParser_Data("audio_para","audio_pa_ctrl", (int *)gpio_info, sizeof(user_gpio_set_t)/sizeof(int));
if(ret < 0)
{
DE_WRN("fetch script data audio_para.audio_pa_ctrl fail\n");
}
else
{
gpio_pa_shutdown = OSAL_GPIO_Request(gpio_info, 1);
if(!gpio_pa_shutdown)
{
DE_WRN("audio codec_wakeup request gpio fail!\n");
}
else
{
OSAL_GPIO_DevWRITE_ONEPIN_DATA(gpio_pa_shutdown, 1, "audio_pa_ctrl");
}
}
}
#endif
gdisp.screen[sel].b_out_interlace = 0;
gdisp.screen[sel].status &= TV_OFF;
gdisp.screen[sel].lcdc_status &= LCDC_TCON1_USED_MASK;
gdisp.screen[sel].output_type = DISP_OUTPUT_TYPE_NONE;
gdisp.screen[sel].pll_use_status &= ((gdisp.screen[sel].pll_use_status == VIDEO_PLL0_USED)? VIDEO_PLL0_USED_MASK : VIDEO_PLL1_USED_MASK);
Disp_set_out_interlace(sel);
}
return DIS_SUCCESS;
}
s32 disp_lcd_get_driver_name(struct disp_lcd *lcd, char* name)
{
char primary_key[20];
s32 ret;
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
if((NULL == lcd) || (NULL == lcdp)) {
DE_WRN("NULL hdl!\n");
return DIS_FAIL;
}
sprintf(primary_key, "lcd%d_para", lcd->channel_id);
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_driver_name", (int*)name, 32);
DE_INF("disp_lcd_get_driver_name, %s\n", name);
return ret;
}
__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;
}
__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;
}
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;
}
// 0:ARGB 1:BRGA 2:ABGR 3:RGBA
//seq ARGB BRGA ARGB BRGA
//br_swqp 0 0 1 1
__s32 parser_disp_init_para(__disp_init_t * init_para)
{
int value;
int i;
memset(init_para, 0, sizeof(__disp_init_t));
if(OSAL_Script_FetchParser_Data("disp_init", "disp_init_enable", &value, 1) < 0) {
__wrn("fetch script data disp_init.disp_init_enable fail\n");
return -1;
}
init_para->b_init = value;
if(OSAL_Script_FetchParser_Data("disp_init", "disp_mode", &value, 1) < 0) {
__wrn("fetch script data disp_init.disp_mode fail\n");
return -1;
}
init_para->disp_mode= value;
//screen0
if(OSAL_Script_FetchParser_Data("disp_init", "screen0_output_type", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen0_output_type fail\n");
return -1;
}
if(value == 0) {
init_para->output_type[0] = DISP_OUTPUT_TYPE_NONE;
} else if(value == 1) {
init_para->output_type[0] = DISP_OUTPUT_TYPE_LCD;
} else if(value == 2) {
init_para->output_type[0] = DISP_OUTPUT_TYPE_TV;
} else if(value == 3) {
init_para->output_type[0] = DISP_OUTPUT_TYPE_HDMI;
} else if(value == 4) {
init_para->output_type[0] = DISP_OUTPUT_TYPE_VGA;
} else {
__wrn("invalid screen0_output_type %d\n", init_para->output_type[0]);
return -1;
}
if(OSAL_Script_FetchParser_Data("disp_init", "screen0_output_mode", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen0_output_mode fail\n");
return -1;
}
if(init_para->output_type[0] == DISP_OUTPUT_TYPE_TV || init_para->output_type[0] == DISP_OUTPUT_TYPE_HDMI
|| init_para->output_type[0] == DISP_OUTPUT_TYPE_VGA) {
init_para->output_mode[0]= value;
}
//screen1
if(OSAL_Script_FetchParser_Data("disp_init", "screen1_output_type", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen1_output_type fail\n");
return -1;
}
if(value == 0) {
init_para->output_type[1] = DISP_OUTPUT_TYPE_NONE;
} else if(value == 1) {
init_para->output_type[1] = DISP_OUTPUT_TYPE_LCD;
} else if(value == 2) {
init_para->output_type[1] = DISP_OUTPUT_TYPE_TV;
} else if(value == 3) {
init_para->output_type[1] = DISP_OUTPUT_TYPE_HDMI;
} else if(value == 4) {
init_para->output_type[1] = DISP_OUTPUT_TYPE_VGA;
} else {
__wrn("invalid screen1_output_type %d\n", init_para->output_type[1]);
return -1;
}
if(OSAL_Script_FetchParser_Data("disp_init", "screen1_output_mode", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen1_output_mode fail\n");
return -1;
}
if(init_para->output_type[1] == DISP_OUTPUT_TYPE_TV || init_para->output_type[1] == DISP_OUTPUT_TYPE_HDMI
|| init_para->output_type[0] == DISP_OUTPUT_TYPE_VGA) {
init_para->output_mode[1]= value;
}
//fb0
init_para->buffer_num[0]= 2;
if(OSAL_Script_FetchParser_Data("disp_init", "fb0_format", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb0_format fail\n");
return -1;
}
init_para->format[0]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb0_pixel_sequence", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb0_pixel_sequence fail\n");
return -1;
}
init_para->seq[0]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb0_scaler_mode_enable", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb0_scaler_mode_enable fail\n");
return -1;
}
init_para->scaler_mode[0]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb0_width", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb0_width fail\n");
return -1;
}
init_para->fb_width[0]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb0_height", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb0_height fail\n");
return -1;
}
init_para->fb_height[0]= value;
//fb1
init_para->buffer_num[1]= 2;
if(OSAL_Script_FetchParser_Data("disp_init", "fb1_format", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_format fail\n");
return -1;
}
init_para->format[1]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb1_pixel_sequence", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_pixel_sequence fail\n");
return -1;
}
init_para->seq[1]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb1_scaler_mode_enable", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_scaler_mode_enable fail\n");
return -1;
}
init_para->scaler_mode[1]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb1_width", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_width fail\n");
return -1;
}
init_para->fb_width[1]= value;
if(OSAL_Script_FetchParser_Data("disp_init", "fb1_height", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_height fail\n");
return -1;
}
init_para->fb_height[1]= value;
__inf("====display init para begin====\n");
__inf("b_init:%d\n", init_para->b_init);
__inf("disp_mode:%d\n\n", init_para->disp_mode);
for(i=0; i<2; i++) {
__inf("output_type[%d]:%d\n", i, init_para->output_type[i]);
__inf("output_mode[%d]:%d\n", i, init_para->output_mode[i]);
}
for(i=0; i<2; i++) {
__inf("buffer_num[%d]:%d\n", i, init_para->buffer_num[i]);
__inf("format[%d]:%d\n", i, init_para->format[i]);
__inf("seq[%d]:%d\n", i, init_para->seq[i]);
__inf("br_swap[%d]:%d\n", i, init_para->br_swap[i]);
__inf("b_scaler_mode[%d]:%d\n", i, init_para->scaler_mode[i]);
__inf("fb_width[%d]:%d\n", i, init_para->fb_width[i]);
__inf("fb_height[%d]:%d\n", i, init_para->fb_height[i]);
}
__inf("====display init para end====\n");
return 0;
}
void lcd_get_sys_config(u32 screen_id, __disp_lcd_cfg_t *lcd_cfg)
{
static char io_name[28][20] = {"lcdd0", "lcdd1", "lcdd2", "lcdd3", "lcdd4", "lcdd5", "lcdd6", "lcdd7", "lcdd8", "lcdd9", "lcdd10", "lcdd11",
"lcdd12", "lcdd13", "lcdd14", "lcdd15", "lcdd16", "lcdd17", "lcdd18", "lcdd19", "lcdd20", "lcdd21", "lcdd22",
"lcdd23", "lcdclk", "lcdde", "lcdhsync", "lcdvsync"};
disp_gpio_set_t *gpio_info;
int value = 1;
char primary_key[20], sub_name[25];
int i = 0;
int ret;
sprintf(primary_key, "lcd%d_para", screen_id);
//lcd_used
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_used", &value, 1);
if(ret == 0)
{
lcd_cfg->lcd_used = value;
}
if(lcd_cfg->lcd_used == 0) //no need to get lcd config if lcd_used eq 0
return ;
//lcd_bl_en
lcd_cfg->lcd_bl_en_used = 0;
gpio_info = &(lcd_cfg->lcd_bl_en);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_bl_en", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_bl_en_used = 1;
}
//lcd_power0
for(i=0; i<3; i++)
{
if(i==0)
sprintf(sub_name, "lcd_power");
else
sprintf(sub_name, "lcd_power%d", i);
lcd_cfg->lcd_power_used[i] = 0;
gpio_info = &(lcd_cfg->lcd_power[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,sub_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0) {
lcd_cfg->lcd_power_used[i] = 1;
}
}
//lcd_gpio
for(i=0; i<4; i++)
{
sprintf(sub_name, "lcd_gpio_%d", i);
gpio_info = &(lcd_cfg->lcd_gpio[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,sub_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[i]= 1;
}
}
//lcd_gpio_scl,lcd_gpio_sda
gpio_info = &(lcd_cfg->lcd_gpio[LCD_GPIO_SCL]);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_gpio_scl", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[LCD_GPIO_SCL]= 1;
}
gpio_info = &(lcd_cfg->lcd_gpio[LCD_GPIO_SDA]);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_gpio_sda", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[LCD_GPIO_SDA]= 1;
}
//lcd io
for(i=0; i<28; i++)
{
gpio_info = &(lcd_cfg->lcd_io[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,io_name[i], (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_io_used[i]= 1;
}
}
//backlight adjust
for(i = 0; i < 101; i++) {
sprintf(sub_name, "lcd_bl_%d_percent", i);
lcd_cfg->backlight_curve_adjust[i] = 0;
if(i == 100)
lcd_cfg->backlight_curve_adjust[i] = 255;
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret == 0) {
value = (value > 100)? 100:value;
value = value * 255 / 100;
lcd_cfg->backlight_curve_adjust[i] = value;
}
}
//init_bright
sprintf(primary_key, "disp_init");
sprintf(sub_name, "lcd%d_backlight", screen_id);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->backlight_bright = 197;
}
else
{
if(value > 256)
{
value = 256;
}
lcd_cfg->backlight_bright = value;
}
//bright,constraction,saturation,hue
sprintf(primary_key, "disp_init");
sprintf(sub_name, "lcd%d_bright", screen_id);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_bright = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_bright = value;
}
sprintf(sub_name, "lcd%d_contrast", screen_id);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_contrast = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_contrast = value;
}
sprintf(sub_name, "lcd%d_saturation", screen_id);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_saturation = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_saturation = value;
}
sprintf(sub_name, "lcd%d_hue", screen_id);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_hue = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_hue = value;
}
}
__s32 bsp_disp_tv_open(__u32 screen_id)
{
if(!(gdisp.screen[screen_id].status & TV_ON))
{
__disp_tv_mode_t tv_mod;
tv_mod = gdisp.screen[screen_id].tv_mode;
image_clk_on(screen_id, 1);
Image_open(screen_id);//set image normal channel start bit , because every de_clk_off( )will reset this bit
disp_clk_cfg(screen_id,DISP_OUTPUT_TYPE_TV, tv_mod);
tve_clk_on(screen_id);
lcdc_clk_on(screen_id, 1, 0);
lcdc_clk_on(screen_id, 1, 1);
tcon_init(screen_id);
gdisp.screen[screen_id].output_csc_type = DISP_OUT_CSC_TYPE_TV;
bsp_disp_set_output_csc(screen_id, gdisp.screen[screen_id].output_csc_type, bsp_disp_drc_get_input_csc(screen_id));
DE_BE_set_display_size(screen_id, tv_mode_to_width(tv_mod), tv_mode_to_height(tv_mod));
DE_BE_Output_Select(screen_id, screen_id);
#if (defined CONFIG_ARCH_SUN5I)
__u32 scaler_index = 0;
DE_BE_Set_Outitl_enable(screen_id , disp_get_screen_scan_mode(tv_mod));
for(scaler_index=0; scaler_index<2; scaler_index++)
{
if((gdisp.scaler[scaler_index].status & SCALER_USED) && (gdisp.scaler[scaler_index].screen_index == screen_id))
{
if(disp_get_screen_scan_mode(tv_mod) == 1)//interlace output
{
Scaler_Set_Outitl(scaler_index, TRUE);
}
else
{
Scaler_Set_Outitl(scaler_index, FALSE);
}
}
}
#endif
tcon1_set_tv_mode(screen_id,tv_mod);
TVE_set_tv_mode(screen_id, tv_mod);
Disp_TVEC_DacCfg(screen_id, tv_mod);
tcon1_open(screen_id);
Disp_TVEC_Open(screen_id);
Disp_Switch_Dram_Mode(DISP_OUTPUT_TYPE_TV, tv_mod);
#ifdef __LINUX_OSAL__
{
disp_gpio_set_t gpio_info[1];
__hdle gpio_pa_shutdown;
__s32 ret;
memset(gpio_info, 0, sizeof(disp_gpio_set_t));
ret = OSAL_Script_FetchParser_Data("audio_para","audio_pa_ctrl", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0) {
gpio_pa_shutdown = OSAL_GPIO_Request(gpio_info, 1);
if(!gpio_pa_shutdown) {
DE_WRN("audio codec_wakeup request gpio fail!\n");
} else {
OSAL_GPIO_DevWRITE_ONEPIN_DATA(gpio_pa_shutdown, 0, "audio_pa_ctrl");
}
}
}
#endif
gdisp.screen[screen_id].b_out_interlace = disp_get_screen_scan_mode(tv_mod);
gdisp.screen[screen_id].status |= TV_ON;
gdisp.screen[screen_id].lcdc_status |= LCDC_TCON1_USED;
gdisp.screen[screen_id].output_type = DISP_OUTPUT_TYPE_TV;
#if (defined CONFIG_ARCH_SUN7I)
Disp_set_out_interlace(screen_id);
#endif
#ifdef __LINUX_OSAL__
Display_set_fb_timming(screen_id);
#endif
}
return DIS_SUCCESS;
}
s32 lcd_parse_panel_para(u32 screen_id, disp_panel_para * info)
{
s32 ret = 0;
char primary_key[25];
s32 value = 0;
sprintf(primary_key, "lcd%d_para", screen_id);
//lcd_used
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_used", &value, 1);
if(value == 0) //no need to get panel para if !lcd_used
return -1;
sprintf(primary_key, "lcd%d_para", screen_id);
memset(info, 0, sizeof(disp_panel_para));
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_x", &value, 1);
if(ret == 0)
{
info->lcd_x = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_y", &value, 1);
if(ret == 0)
{
info->lcd_y = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_width", &value, 1);
if(ret == 0)
{
info->lcd_width = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_height", &value, 1);
if(ret == 0)
{
info->lcd_height = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dclk_freq", &value, 1);
if(ret == 0)
{
info->lcd_dclk_freq = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_used", &value, 1);
if(ret == 0)
{
info->lcd_pwm_used = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_ch", &value, 1);
if(ret == 0)
{
info->lcd_pwm_ch = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_freq", &value, 1);
if(ret == 0)
{
info->lcd_pwm_freq = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_pol", &value, 1);
if(ret == 0)
{
info->lcd_pwm_pol = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_if", &value, 1);
if(ret == 0)
{
info->lcd_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hbp", &value, 1);
if(ret == 0)
{
info->lcd_hbp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_ht", &value, 1);
if(ret == 0)
{
info->lcd_ht = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vbp", &value, 1);
if(ret == 0)
{
info->lcd_vbp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vt", &value, 1);
if(ret == 0)
{
info->lcd_vt = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_if", &value, 1);
if(ret == 0)
{
info->lcd_hv_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vspw", &value, 1);
if(ret == 0)
{
info->lcd_vspw = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hspw", &value, 1);
if(ret == 0)
{
info->lcd_hspw = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_if", &value, 1);
if(ret == 0)
{
info->lcd_lvds_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_mode", &value, 1);
if(ret == 0)
{
info->lcd_lvds_mode = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_colordepth", &value, 1);
if(ret == 0)
{
info->lcd_lvds_colordepth= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_io_polarity", &value, 1);
if(ret == 0)
{
info->lcd_lvds_io_polarity = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cpu_if", &value, 1);
if(ret == 0)
{
info->lcd_cpu_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cpu_te", &value, 1);
if(ret == 0)
{
info->lcd_cpu_te = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_frm", &value, 1);
if(ret == 0)
{
info->lcd_frm = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_if", &value, 1);
if(ret == 0)
{
info->lcd_dsi_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_lane", &value, 1);
if(ret == 0)
{
info->lcd_dsi_lane = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_format", &value, 1);
if(ret == 0)
{
info->lcd_dsi_format = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_eotp", &value, 1);
if(ret == 0)
{
info->lcd_dsi_eotp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_te", &value, 1);
if(ret == 0)
{
info->lcd_dsi_te = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_ic", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_ic= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_rate", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_rate = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_lane", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_lane= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_colordepth", &value, 1);
if(ret == 0)
{
info->lcd_edp_colordepth = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_clk_phase", &value, 1);
if(ret == 0)
{
info->lcd_hv_clk_phase = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_sync_polarity", &value, 1);
if(ret == 0)
{
info->lcd_hv_sync_polarity = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_gamma_en", &value, 1);
if(ret == 0)
{
info->lcd_gamma_en = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cmap_en", &value, 1);
if(ret == 0)
{
info->lcd_cmap_en = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_xtal_freq", &value, 1);
if(ret == 0)
{
info->lcd_xtal_freq = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_size", (int*)info->lcd_size, 2);
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_model_name", (int*)info->lcd_model_name, 2);
return 0;
}
__s32 LCD_get_panel_para(__u32 sel, __panel_para_t * info)
{
__s32 ret = 0;
char primary_key[20];
__s32 value = 0;
__u32 i = 0;
sprintf(primary_key, "lcd%d_para", sel);
memset(info, 0, sizeof(__panel_para_t));
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_x", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_x fail\n", primary_key);
}
else
{
info->lcd_x = value;
DE_INF("lcd_x = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_y", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_y fail\n", primary_key);
}
else
{
info->lcd_y = value;
DE_INF("lcd_y = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dclk_freq", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_dclk_freq fail\n", primary_key);
}
else
{
info->lcd_dclk_freq = value;
DE_INF("lcd_dclk_freq = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_not_used", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_pwm_not_used fail\n", primary_key);
}
else
{
info->lcd_pwm_not_used = value;
DE_INF("lcd_pwm_not_used = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_ch", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_pwm_ch fail\n", primary_key);
}
else
{
info->lcd_pwm_ch = value;
DE_INF("lcd_pwm_ch = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_freq", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_pwm_freq fail\n", primary_key);
}
else
{
info->lcd_pwm_freq = value;
DE_INF("lcd_pwm_freq = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_pol", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_pwm_pol fail\n", primary_key);
}
else
{
info->lcd_pwm_pol = value;
DE_INF("lcd_pwm_pol = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_if", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_if fail\n", primary_key);
}
else
{
info->lcd_if = value;
DE_INF("lcd_if = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hbp", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_hbp fail\n", primary_key);
}
else
{
info->lcd_hbp = value;
DE_INF("lcd_hbp = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_ht", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_ht fail\n", primary_key);
}
else
{
info->lcd_ht = value;
DE_INF("lcd_ht = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vbp", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_vbp fail\n", primary_key);
}
else
{
info->lcd_vbp = value;
DE_INF("lcd_vbp = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vt", &value, 1);
if(ret < 0)
{
DE_WRN("fetch script data %s.lcd_vt fail\n", primary_key);
}
else
{
info->lcd_vt = value;
DE_INF("lcd_vt = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_if", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_if fail\n", primary_key);
}
else
{
info->lcd_hv_if = value;
DE_INF("lcd_hv_if = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_smode", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_smode fail\n", primary_key);
}
else
{
info->lcd_hv_smode = value;
DE_INF("lcd_hv_smode = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_s888_if", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_s888_if fail\n", primary_key);
}
else
{
info->lcd_hv_s888_if = value;
DE_INF("lcd_hv_s888_if = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_syuv_if", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_syuv_if fail\n", primary_key);
}
else
{
info->lcd_hv_syuv_if = value;
DE_INF("lcd_hv_syuv_if = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_vspw", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_vspw fail\n", primary_key);
}
else
{
info->lcd_hv_vspw = value;
DE_INF("lcd_hv_vspw = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_hspw", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_hv_hspw fail\n", primary_key);
}
else
{
info->lcd_hv_hspw = value;
DE_INF("lcd_hv_hspw = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_ch", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_lvds_ch fail\n", primary_key);
}
else
{
info->lcd_lvds_ch = value;
DE_INF("lcd_lvds_ch = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_mode", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_lvds_mode fail\n", primary_key);
}
else
{
info->lcd_lvds_mode = value;
DE_INF("lcd_lvds_mode = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_bitwidth", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_lvds_bitwidth fail\n", primary_key);
}
else
{
info->lcd_lvds_bitwidth = value;
DE_INF("lcd_lvds_bitwidth = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_io_cross", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_lvds_io_cross fail\n", primary_key);
}
else
{
info->lcd_lvds_io_cross = value;
DE_INF("lcd_lvds_io_cross = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cpu_if", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_cpu_if fail\n", primary_key);
}
else
{
info->lcd_cpu_if = value;
DE_INF("lcd_cpu_if = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_frm", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_frm fail\n", primary_key);
}
else
{
info->lcd_frm = value;
DE_INF("lcd_frm = %d\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_io_cfg0", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_io_cfg0 fail\n", primary_key);
}
else
{
info->lcd_io_cfg0 = value;
DE_INF("lcd_io_cfg0 = 0x%08x\n", value);
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_gamma_correction_en", &value, 1);
if(ret < 0)
{
DE_INF("fetch script data %s.lcd_gamma_correction_en fail\n", primary_key);
}
else
{
info->lcd_gamma_correction_en = value;
DE_INF("lcd_gamma_correction_en = %d\n", value);
}
if(info->lcd_gamma_correction_en)
{
for(i=0; i<256; i++)
{
char name[20];
sprintf(name, "lcd_gamma_tbl_%d", i);
ret = OSAL_Script_FetchParser_Data(primary_key, name, &value, 1);
if(ret < 0)
{
info->lcd_gamma_tbl[i] = (i<<16) | (i<<8) | i;
DE_INF("fetch script data %s.%s fail\n", primary_key, name);
}
else
{
info->lcd_gamma_tbl[i] = value;
DE_INF("%s = 0x%x\n", name, value);
}
}
}
return 0;
}
__s32 IEP_Drc_Init(__u32 sel)
{
#ifdef DRC_DEFAULT_ENABLE
__disp_rect_t regn;
#endif
__u32 lcdgamma;
int value = 1;
char primary_key[20];
int ret;
memset(&giep[sel], 0, sizeof(__drc_t));
memset(&gpwrsv[sel], 0, sizeof(__drc_pwrsv_t));
drc_clk_init(sel);
drc_clk_open(sel, 0);
#ifdef __LINUX_OSAL__
pttab[sel] = kmalloc(IEP_LGC_TAB_SIZE, GFP_KERNEL | __GFP_ZERO);
#else
pttab[sel] = OSAL_PhyAlloc(IEP_LGC_TAB_SIZE);
#endif
sprintf(primary_key, "lcd%d_para", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, "lcdgamma4iep", &value, 1);
if(ret < 0) {
DE_WRN("lcdgamma4iep for lcd%d not exist.\n", sel);
lcdgamma = 6; //default gamma = 2.2;
} else {
DE_INF("lcdgamma4iep for lcd%d = %d.\n", sel, value);
if(value > 30 || value < 10) {
DE_WRN("lcdgamma4iep for lcd%d too small or too large. default value 22 will be set. please set it between 10 and 30 to make it valid.\n",sel);
lcdgamma = 6;//default gamma = 2.2;
} else {
lcdgamma = (value - 10)/2;
}
}
memcpy(pttab[sel], pwrsv_lgc_tab[128*lcdgamma], IEP_LGC_TAB_SIZE);
ret = OSAL_Script_FetchParser_Data(primary_key, "smartbl_low_limit", &value, 1);
if(ret < 0) {
DE_INF("smartbl_low_limit for lcd%d not exist.\n", sel);
} else {
DE_INF("smartbl_low_limit for lcd%d = %d.\n", sel, value);
if(value > 255 || value < 20) {
DE_INF("smartbl_low_limit for lcd%d too small or too large. default value 85 will be set. please set it between 20 and 255 to make it valid.\n",sel);
} else {
PWRSAVE_PROC_THRES = value;
}
}
#ifdef DRC_DEFAULT_ENABLE
#ifdef DRC_DEMO_HALF_SCREEN
regn.x = bsp_disp_get_screen_width(sel)/2; //TBD
regn.y = 0;
regn.width = bsp_disp_get_screen_width(sel)/2;
regn.height = bsp_disp_get_screen_height(sel);
#else
regn.x = 0;
regn.y = 0;
regn.width = bsp_disp_get_screen_width(sel);
regn.height = bsp_disp_get_screen_height(sel);
#endif
IEP_Drc_Set_Mode(sel, 0); //default running HSV mode when default open when DRC_DEFAULT_ENABLE==1
IEP_Drc_Enable(sel, 1);
IEP_Drc_Set_Winodw(sel, regn);
#endif
return DIS_SUCCESS;
}
void sunxi_lcd_parse_sys_config(struct sunxi_panel *panel, __disp_lcd_cfg_t *lcd_cfg)
{
static char io_name[28][20] = {"lcdd0", "lcdd1", "lcdd2", "lcdd3", "lcdd4", "lcdd5", "lcdd6", "lcdd7", "lcdd8", "lcdd9", "lcdd10", "lcdd11",
"lcdd12", "lcdd13", "lcdd14", "lcdd15", "lcdd16", "lcdd17", "lcdd18", "lcdd19", "lcdd20", "lcdd21", "lcdd22",
"lcdd23", "lcdclk", "lcdde", "lcdhsync", "lcdvsync"};
disp_gpio_set_t *gpio_info;
int value = 1;
char primary_key[20], sub_name[25];
int i = 0;
int ret;
__u32 sel = panel->screen_id;
sprintf(primary_key, "lcd%d_para", sel);
//lcd_used
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_used", &value, 1);
if(ret == 0)
{
lcd_cfg->lcd_used = value;
}
if(lcd_cfg->lcd_used == 0) //no need to get lcd config if lcd_used eq 0
return ;
//lcd_bl_en
lcd_cfg->lcd_bl_en_used = 0;
gpio_info = &(lcd_cfg->lcd_bl_en);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_bl_en", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_bl_en_used = 1;
}
//lcd_power
lcd_cfg->lcd_power_used= 0;
gpio_info = &(lcd_cfg->lcd_power);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_power", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_power_used= 1;
}
//lcd_pwm
lcd_cfg->lcd_pwm_used= 0;
gpio_info = &(lcd_cfg->lcd_pwm);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_pwm", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
#if 0
#ifdef __LINUX_OSAL__
lcd_cfg->lcd_pwm_used= 1;
if(gpio_info->gpio == GPIOH(13))//ph13
{
lcd_cfg->lcd_pwm_ch = 0;
}
else if((gpio_info->gpio == GPIOH(9)) && (gpio_info->gpio == GPIOH(10)))//ph9,ph10
{
lcd_cfg->lcd_pwm_ch = 1;
}
else if((gpio_info->gpio == GPIOH(11)) && (gpio_info->gpio == GPIOH(12)))//ph11,ph12
{
lcd_cfg->lcd_pwm_ch = 2;
}
else if((gpio_info->gpio == GPIOA(19)) && (gpio_info->gpio == GPIOA(20)))//ph19 pa20
{
lcd_cfg->lcd_pwm_ch = 3;
}
else
{
lcd_cfg->lcd_pwm_used = 0;
}
__inf("lcd_pwm_used=%d,lcd_pwm_ch=%d\n", lcd_cfg->lcd_pwm_used, lcd_cfg->lcd_pwm_ch);
#endif
#endif
}
//lcd_gpio
for(i=0; i<4; i++)
{
sprintf(sub_name, "lcd_gpio_%d", i);
gpio_info = &(lcd_cfg->lcd_gpio[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,sub_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[i]= 1;
}
}
//lcd_gpio_scl,lcd_gpio_sda
gpio_info = &(lcd_cfg->lcd_gpio[4]);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_gpio_scl", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[4]= 1;
}
gpio_info = &(lcd_cfg->lcd_gpio[5]);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_gpio_sda", (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_gpio_used[5]= 1;
}
//lcd io
for(i=0; i<28; i++)
{
gpio_info = &(lcd_cfg->lcd_io[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,io_name[i], (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 0)
{
lcd_cfg->lcd_io_used[i]= 1;
}
}
lcd_cfg->backlight_max_limit = 150;
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_max_limit", &value, 1);
if(ret == 0)
{
lcd_cfg->backlight_max_limit = (value > 255)? 255:value;
}
//init_bright
sprintf(primary_key, "disp_init");
sprintf(sub_name, "lcd%d_backlight", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->backlight_bright = 197;
}
else
{
if(value > 256)
{
value = 256;
}
lcd_cfg->backlight_bright = value;
}
//bright,constraction,saturation,hue
sprintf(primary_key, "disp_init");
sprintf(sub_name, "lcd%d_bright", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_bright = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_bright = value;
}
sprintf(sub_name, "lcd%d_contrast", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_contrast = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_contrast = value;
}
sprintf(sub_name, "lcd%d_saturation", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_saturation = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_saturation = value;
}
sprintf(sub_name, "lcd%d_hue", sel);
ret = OSAL_Script_FetchParser_Data(primary_key, sub_name, &value, 1);
if(ret < 0)
{
lcd_cfg->lcd_hue = 50;
}
else
{
if(value > 100)
{
value = 100;
}
lcd_cfg->lcd_hue = value;
}
}
/**
* sunxi_lcd_parse_panel_para - parse panel para from sys_config file.
* @screen_id: The index of screen.
* @info: The pointer to panel para.
*/
__s32 sunxi_lcd_parse_panel_para(struct sunxi_panel *panel, __panel_para_t * info)
{
__s32 ret = 0;
char primary_key[25];
__s32 value = 0;
__u32 sel = panel->screen_id;
sprintf(primary_key, "lcd%d_para", sel);
memset(info, 0, sizeof(__panel_para_t));
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_x", &value, 1);
if(ret == 0)
{
info->lcd_x = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_y", &value, 1);
if(ret == 0)
{
info->lcd_y = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_width", &value, 1);
if(ret == 0)
{
info->lcd_width = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_height", &value, 1);
if(ret == 0)
{
info->lcd_height = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dclk_freq", &value, 1);
if(ret == 0)
{
info->lcd_dclk_freq = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_freq", &value, 1);
if(ret == 0)
{
info->lcd_pwm_freq = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_pol", &value, 1);
if(ret == 0)
{
info->lcd_pwm_pol = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_if", &value, 1);
if(ret == 0)
{
info->lcd_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hbp", &value, 1);
if(ret == 0)
{
info->lcd_hbp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_ht", &value, 1);
if(ret == 0)
{
info->lcd_ht = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vbp", &value, 1);
if(ret == 0)
{
info->lcd_vbp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vt", &value, 1);
if(ret == 0)
{
info->lcd_vt = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_if", &value, 1);
if(ret == 0)
{
info->lcd_hv_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_vspw", &value, 1);
if(ret == 0)
{
info->lcd_vspw = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hspw", &value, 1);
if(ret == 0)
{
info->lcd_hspw = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_if", &value, 1);
if(ret == 0)
{
info->lcd_lvds_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_mode", &value, 1);
if(ret == 0)
{
info->lcd_lvds_mode = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_colordepth", &value, 1);
if(ret == 0)
{
info->lcd_lvds_colordepth= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_lvds_io_polarity", &value, 1);
if(ret == 0)
{
info->lcd_lvds_io_polarity = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cpu_if", &value, 1);
if(ret == 0)
{
info->lcd_cpu_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cpu_te", &value, 1);
if(ret == 0)
{
info->lcd_cpu_te = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_frm", &value, 1);
if(ret == 0)
{
info->lcd_frm = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_if", &value, 1);
if(ret == 0)
{
info->lcd_dsi_if = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_lane", &value, 1);
if(ret == 0)
{
info->lcd_dsi_lane = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_format", &value, 1);
if(ret == 0)
{
info->lcd_dsi_format = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_eotp", &value, 1);
if(ret == 0)
{
info->lcd_dsi_eotp = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_dsi_te", &value, 1);
if(ret == 0)
{
info->lcd_dsi_te = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_ic", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_ic= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_rate", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_rate = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_tx_lane", &value, 1);
if(ret == 0)
{
info->lcd_edp_tx_lane= value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_edp_colordepth", &value, 1);
if(ret == 0)
{
info->lcd_edp_colordepth = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_clk_phase", &value, 1);
if(ret == 0)
{
info->lcd_hv_clk_phase = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_hv_sync_polarity", &value, 1);
if(ret == 0)
{
info->lcd_hv_sync_polarity = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_gamma_en", &value, 1);
if(ret == 0)
{
info->lcd_gamma_en = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_cmap_en", &value, 1);
if(ret == 0)
{
info->lcd_cmap_en = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_bright_curve_en", &value, 1);
if(ret == 0)
{
info->lcd_bright_curve_en = value;
}
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_size", (int*)info->lcd_size, 2);
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_model_name", (int*)info->lcd_model_name, 2);
return 0;
}
void LCD_get_sys_config(__u32 sel, __disp_lcd_cfg_t *lcd_cfg)
{
char io_name[28][20] = {"lcdd0", "lcdd1", "lcdd2", "lcdd3", "lcdd4", "lcdd5", "lcdd6", "lcdd7", "lcdd8", "lcdd9", "lcdd10", "lcdd11",
"lcdd12", "lcdd13", "lcdd14", "lcdd15", "lcdd16", "lcdd17", "lcdd18", "lcdd19", "lcdd20", "lcdd21", "lcdd22",
"lcdd23", "lcdclk", "lcdde", "lcdhsync", "lcdvsync"};
user_gpio_set_t *gpio_info;
int value = 1;
char primary_key[20];
int i = 0;
int ret;
sprintf(primary_key, "lcd%d_para", sel);
//lcd_used
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_used", &value, 1);
if(ret < 0)
{
DE_WRN("%s.lcd_used not exit\n", primary_key);
lcd_cfg->lcd_used = 0;
}
else
{
DE_INF("%s.lcd_used = %d\n", primary_key, value);
lcd_cfg->lcd_used = value;
}
//lcd_bl_en
lcd_cfg->lcd_bl_en_used = 0;
value = 1;
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_bl_en_used", &value, 1);
if(value == 0)
{
DE_INF("%s.lcd_bl_en is not used\n", primary_key);
}
else
{
gpio_info = &(lcd_cfg->lcd_bl_en);
ret = OSAL_Script_FetchParser_Data(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
{
DE_INF("%s.lcd_bl_en gpio_port=%d,gpio_port_num:%d, data:%d\n",primary_key, gpio_info->port, gpio_info->port_num, gpio_info->data);
lcd_cfg->lcd_bl_en_used = 1;
}
}
//lcd_power
lcd_cfg->lcd_power_used= 0;
value = 1;
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_power_used", &value, 1);
if(value == 0)
{
DE_INF("%s.lcd_power is not used\n", primary_key);
}
else
{
gpio_info = &(lcd_cfg->lcd_power);
ret = OSAL_Script_FetchParser_Data(primary_key,"lcd_power", (int *)gpio_info, sizeof(user_gpio_set_t)/sizeof(int));
if(ret < 0)
{
DE_INF("%s.lcd_power not exist\n", primary_key);
}
else
{
DE_INF("%s.lcd_power gpio_port=%d,gpio_port_num:%d, data:%d\n",primary_key, gpio_info->port, gpio_info->port_num, gpio_info->data);
lcd_cfg->lcd_power_used= 1;
}
}
//lcd_pwm
lcd_cfg->lcd_pwm_used= 0;
value = 1;
ret = OSAL_Script_FetchParser_Data(primary_key, "lcd_pwm_used", &value, 1);
if(value == 0)
{
DE_INF("%s.lcd_pwm is not used\n", primary_key);
}
else
{
gpio_info = &(lcd_cfg->lcd_pwm);
ret = OSAL_Script_FetchParser_Data(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
{
DE_INF("%s.lcd_pwm gpio_port=%d,gpio_port_num:%d, data:%d\n",primary_key, gpio_info->port, gpio_info->port_num, gpio_info->data);
lcd_cfg->lcd_pwm_used= 1;
}
}
//lcd_gpio
for(i=0; i<4; i++)
{
char sub_name[20];
sprintf(sub_name, "lcd_gpio_%d", i);
gpio_info = &(lcd_cfg->lcd_gpio[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,sub_name, (int *)gpio_info, sizeof(user_gpio_set_t)/sizeof(int));
if(ret < 0)
{
DE_INF("%s.%s not exist\n",primary_key, sub_name);
lcd_cfg->lcd_gpio_used[i]= 0;
}
else
{
DE_INF("%s.%s gpio_port=%d,gpio_port_num:%d, mul_sel:%d\n",primary_key, sub_name, gpio_info->port, gpio_info->port_num, gpio_info->mul_sel);
lcd_cfg->lcd_gpio_used[i]= 1;
}
}
//lcd io
for(i=0; i<28; i++)
{
gpio_info = &(lcd_cfg->lcd_io[i]);
ret = OSAL_Script_FetchParser_Data(primary_key,io_name[i], (int *)gpio_info, sizeof(user_gpio_set_t)/sizeof(int));
if(ret < 0)
{
DE_INF("%s.%s not exist\n",primary_key, io_name[i]);
lcd_cfg->lcd_io_used[i]= 0;
}
else
{
DE_INF("%s.%s gpio_port=%d,gpio_port_num:%d, mul_sel:%d\n",primary_key, io_name[i], gpio_info->port, gpio_info->port_num, gpio_info->mul_sel);
lcd_cfg->lcd_io_used[i]= 1;
}
}
}
__s32 bsp_disp_set_output_csc(__u32 screen_id, __disp_out_csc_type_t out_type, __u32 drc_csc)
{
__disp_color_range_t out_color_range = DISP_COLOR_RANGE_0_255;
__u32 out_csc = 0;
__u32 enhance_en, bright, contrast, saturation, hue;
enhance_en = gdisp.screen[screen_id].enhance_en;
bright = gdisp.screen[screen_id].bright;
contrast = gdisp.screen[screen_id].contrast;
saturation = gdisp.screen[screen_id].saturation;
hue = gdisp.screen[screen_id].hue;
if(out_type == DISP_OUT_CSC_TYPE_HDMI_YUV) {
__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 = 2;
} else if(out_type == DISP_OUT_CSC_TYPE_HDMI_RGB) {
__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_OUT_CSC_TYPE_TV) {
out_csc = 1;
} else if(out_type == DISP_OUT_CSC_TYPE_LCD) {
if(enhance_en == 0)
{
enhance_en = 1;
bright = 50;//gdisp.screen[screen_id].lcd_cfg.lcd_bright;
contrast = 50;//gdisp.screen[screen_id].lcd_cfg.lcd_contrast;
saturation = 57;//gdisp.screen[screen_id].lcd_cfg.lcd_saturation;
hue = 50;//gdisp.screen[screen_id].lcd_cfg.lcd_hue;
}
out_csc = 0;
}
/* if drc csc eq 1, indicate yuv for drc */
if(drc_csc) {
out_csc = 3;
}
gdisp.screen[screen_id].out_color_range = out_color_range;
gdisp.screen[screen_id].out_csc = out_csc;
DE_BE_Set_Enhance_ex(screen_id, gdisp.screen[screen_id].out_csc, gdisp.screen[screen_id].out_color_range, enhance_en, bright, contrast, saturation, hue);
return DIS_SUCCESS;
}
__s32 BSP_disp_tv_open(__u32 sel)
{
if(!(gdisp.screen[sel].status & TV_ON))
{
__disp_tv_mode_t tv_mod;
tv_mod = gdisp.screen[sel].tv_mode;
image_clk_on(sel);
Image_open(sel);//set image normal channel start bit , because every de_clk_off( )will reset this bit
disp_clk_cfg(sel,DISP_OUTPUT_TYPE_TV, tv_mod);
tve_clk_on(sel);
lcdc_clk_on(sel);
BSP_disp_set_output_csc(sel, DISP_OUTPUT_TYPE_TV);
DE_BE_set_display_size(sel, tv_mode_to_width(tv_mod), tv_mode_to_height(tv_mod));
DE_BE_Output_Select(sel, sel);
TCON1_set_tv_mode(sel,tv_mod);
TVE_set_tv_mode(sel, tv_mod);
Disp_TVEC_DacCfg(sel, tv_mod);
TCON1_open(sel);
Disp_TVEC_Open(sel);
Disp_Switch_Dram_Mode(DISP_OUTPUT_TYPE_TV, tv_mod);
#ifdef __LINUX_OSAL__
{
user_gpio_set_t gpio_info[1];
__hdle gpio_pa_shutdown;
__s32 ret;
memset(gpio_info, 0, sizeof(user_gpio_set_t));
ret = OSAL_Script_FetchParser_Data("audio_para","audio_pa_ctrl", (int *)gpio_info, sizeof(user_gpio_set_t)/sizeof(int));
if(ret < 0)
{
DE_WRN("fetch script data audio_para.audio_pa_ctrl fail\n");
}
else
{
gpio_pa_shutdown = OSAL_GPIO_Request(gpio_info, 1);
if(!gpio_pa_shutdown)
{
DE_WRN("audio codec_wakeup request gpio fail!\n");
}
else
{
OSAL_GPIO_DevWRITE_ONEPIN_DATA(gpio_pa_shutdown, 0, "audio_pa_ctrl");
}
}
}
#endif
gdisp.screen[sel].b_out_interlace = Disp_get_screen_scan_mode(tv_mod);
gdisp.screen[sel].status |= TV_ON;
gdisp.screen[sel].lcdc_status |= LCDC_TCON1_USED;
gdisp.screen[sel].output_type = DISP_OUTPUT_TYPE_TV;
Disp_set_out_interlace(sel);
#ifdef __LINUX_OSAL__
Display_set_fb_timming(sel);
#endif
}
return DIS_SUCCESS;
}
