static int hdmi_parse_config(void)
{
disp_gpio_set_t *gpio_info;
int i, ret;
char io_name[32];
for(i=0; i<28; i++) {
gpio_info = &(hdmi_io[i]);
sprintf(io_name, "hdmi_d%d", i);
ret = disp_sys_script_get_item(key_name, io_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 3) {
hdmi_io_used[i]= 1;
}
}
for(i=0; i<sizeof(hdmi_gpio); i++) {
gpio_info = &(hdmi_gpio[i]);
sprintf(io_name, "gpio%d", i);
ret = disp_sys_script_get_item(key_name, io_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 3) {
hdmi_gpio_used[i]= 1;
}
}
return 0;
}
static int hdmi_i2c_init(void)
{
int ret;
int value;
ret = disp_sys_script_get_item(key_name, "hdmi_twi_used", &value, 1);
if(1 == ret) {
hdmi_i2c_used = value;
if(hdmi_i2c_used == 1) {
ret = disp_sys_script_get_item(key_name, "hdmi_twi_id", &value, 1);
hdmi_i2c_id = (ret == 1)? value : hdmi_i2c_id;
return i2c_add_driver(&hdmi_i2c_driver);
}
}
return 0;
}
s32 drv_disp_check_spec(void)
{
unsigned int lcd_used = 0;
unsigned int lcd_x = 0, lcd_y = 0;
int ret = 0;
int value = 0;
int limit_w = 0xffff, limit_h = 0xffff;
#if defined(CONFIG_ARCH_SUN8IW6)
limit_w = 2048;
limit_h = 1536;
#endif
ret = disp_sys_script_get_item("lcd0_para", "lcd_used", &value, 1);
if(ret == 1)
{
lcd_used = value;
}
if(1 == lcd_used) {
ret = disp_sys_script_get_item("lcd0_para", "lcd_x", &value, 1);
if(ret == 1)
{
lcd_x = value;
}
ret = disp_sys_script_get_item("lcd0_para", "lcd_y", &value, 1);
if(ret == 1)
{
lcd_y = value;
}
if(((lcd_x > limit_w) && (lcd_y > limit_h))
|| ((lcd_x > limit_h) && (lcd_y > limit_w))) {
printf("fatal err: cannot support lcd with resolution(%d*%d) larger than %d*%d, the system will shut down!\n",
lcd_x, lcd_y,limit_w,limit_h);
sunxi_board_shutdown();
}
}
return 0;
}
static int tv_i2c_init(void)
{
int ret;
int value;
ret = disp_sys_script_get_item("tv_para", "tv_twi_used", &value, 1);
if(1 == ret)
{
tv_i2c_used = value;
if(tv_i2c_used == 1)
{
ret = disp_sys_script_get_item("tv_para", "tv_twi_id", &value, 1);
tv_i2c_id = (ret == 1)? value:tv_i2c_id;
ret = disp_sys_script_get_item("tv_para", "tv_twi_addr", &value, 1);
normal_i2c[0] = (ret == 1)? value:normal_i2c[0];
return i2c_add_driver(&tv_i2c_driver);
}
}
return 0;
}
static int tv_parse_config(void)
{
disp_gpio_set_t *gpio_info;
int i, ret;
char io_name[32];
for(i=0; i<28; i++) {
gpio_info = &(tv_io[i]);
sprintf(io_name, "tv_d%d", i);
ret = disp_sys_script_get_item("tv_para", io_name, (int *)gpio_info, sizeof(disp_gpio_set_t)/sizeof(int));
if(ret == 3)
{
tv_io_used[i]= 1;
}
}
return 0;
}
static void LCD_panel_init(u32 sel)
{
__u32 i;
char model_name[25];
disp_sys_script_get_item("lcd0","lcd_model_name", (int*)model_name, 25);
sunxi_lcd_dsi_clk_enable(sel);
sunxi_lcd_delay_ms(20);
sunxi_lcd_dsi_dcs_write_0para(sel,DSI_DCS_SOFT_RESET);
sunxi_lcd_delay_ms(10);
for(i=0;;i++)
{
if(LCM_LT080B21BA94_setting[i].count == REGFLAG_END_OF_TABLE)
break;
else if (LCM_LT080B21BA94_setting[i].count == REGFLAG_DELAY)
sunxi_lcd_delay_ms(LCM_LT080B21BA94_setting[i].para_list[0]);
else
dsi_dcs_wr(sel,LCM_LT080B21BA94_setting[i].cmd,LCM_LT080B21BA94_setting[i].para_list,LCM_LT080B21BA94_setting[i].count);
//break;
}
return;
}
int de_smbl_init(unsigned int sel, unsigned int reg_base)
{
unsigned int base;
void *memory;
unsigned int lcdgamma;
int value = 1;
char primary_key[20];
char sub_key[20];
int ret;
base = reg_base + (sel+1)*0x00100000 + SMBL_OFST;
smbl_hw_base[sel] = base;
__inf("sel %d, smbl_base=0x%x\n", sel, base);
memory = disp_sys_malloc(sizeof(__smbl_reg_t));
if(NULL == memory) {
__wrn("malloc smbl[%d] memory fail! size=0x%x\n", sel, sizeof(__smbl_reg_t));
return -1;
}
smbl_enable_block[sel].off = base;
smbl_enable_block[sel].val = memory;
smbl_enable_block[sel].size = 0x4;
smbl_enable_block[sel].dirty = 0;
smbl_ctrl_block[sel].off = base + 0x4;
smbl_ctrl_block[sel].val = memory + 0x4;
smbl_ctrl_block[sel].size = 0x38;
smbl_ctrl_block[sel].dirty = 0;
smbl_hist_block[sel].off = base + 0x60;
smbl_hist_block[sel].val = memory + 0x60;
smbl_hist_block[sel].size = 0x20;
smbl_hist_block[sel].dirty = 0;
smbl_csc_block[sel].off = base + 0xc0;
smbl_csc_block[sel].val = memory + 0xc0;
smbl_csc_block[sel].size = 0x30;
smbl_csc_block[sel].dirty = 0;
smbl_filter_block[sel].off = base + 0xf0;
smbl_filter_block[sel].val = memory + 0xf0;
smbl_filter_block[sel].size = 0x110;
smbl_filter_block[sel].dirty = 0;
smbl_lut_block[sel].off = base + 0x200;
smbl_lut_block[sel].val = memory + 0x200;
smbl_lut_block[sel].size = 0x200;
smbl_lut_block[sel].dirty = 0;
de_smbl_set_reg_base(sel, (unsigned int)memory);
g_smbl_status[sel] = disp_sys_malloc(sizeof(__smbl_status_t));
if(NULL == g_smbl_status[sel]) {
__wrn("malloc g_smbl_status[%d] memory fail! size=0x%x\n", sel, sizeof(__smbl_status_t));
return -1;
}
g_smbl_status[sel]->IsEnable = 0;
g_smbl_status[sel]->Runtime = 0;
g_smbl_status[sel]->dimming = 256;
sprintf(primary_key, "lcd%d_para", sel);
ret = disp_sys_script_get_item(primary_key, "lcdgamma4iep", &value, 1);
if(ret != 1) {
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;
}
}
pttab[sel] = (unsigned int *)pwrsv_lgc_tab[128*lcdgamma];
ret = disp_sys_script_get_item(primary_key, "smartbl_low_limit", &value, 1);
if(ret != 1) {
//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;
}
}
sprintf(sub_key, "lcd%d_backlight", sel);
ret = disp_sys_script_get_item("disp_init", sub_key, &value, 1);
if(1 == ret)
g_smbl_status[sel]->backlight = value;
return 0;
}
s32 disp_init_tv(disp_bsp_init_para * para) //call by disp_display
{
s32 val;
s32 type;
type = disp_sys_script_get_item("tv_para", "tv_used", &val, 1);
if(1 == type)
g_tv_used = val;
if(g_tv_used ) {
__u32 num_screens;
__u32 disp;
struct disp_device* p_tv;
struct disp_device_private_data* p_tvp;
DE_WRN("[boot]disp_init_tv\n");
#if defined(__LINUX_PLAT__)
spin_lock_init(&g_tv_data_lock);
#endif
DE_WRN("[DISP_TV] disp_init_tv enter g_tv_used\n");
num_screens = bsp_disp_feat_get_num_screens();
g_ptv_devices = (struct disp_device *)disp_sys_malloc(sizeof(struct disp_device) * num_screens);
if(NULL == g_ptv_devices) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
g_ptv_private = (struct disp_device_private_data *)disp_sys_malloc(sizeof(struct disp_device_private_data) * num_screens);
if(NULL == g_ptv_private) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
for(disp=0; disp<num_screens; disp++) {
p_tv = &g_ptv_devices[disp];
p_tvp = &g_ptv_private[disp];
if(!bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_TV)) { //modify 1
DE_WRN("screen %d do not support TV TYPE!\n", disp);
continue;
}
p_tv->disp = disp;
sprintf(p_tv->name, "tv%d", disp);
p_tv->type = DISP_OUTPUT_TYPE_TV;
p_tvp->tv_mode = DISP_TV_MOD_PAL; //modifyed
p_tvp->irq_no = para->irq_no[DISP_MOD_LCD0 + disp]; //modify
p_tvp->clk = "tcon1";
p_tvp->clk_parent = "pll_video0";
p_tv->set_manager = disp_device_set_manager;
p_tv->unset_manager = disp_device_unset_manager;
p_tv->get_resolution = disp_device_get_resolution;
p_tv->get_timings = disp_device_get_timings;
p_tv->init = disp_tv_init;
p_tv->exit = disp_tv_exit;
p_tv->set_tv_func = disp_tv_set_func;
p_tv->enable = disp_tv_enable;
p_tv->disable = disp_tv_disable;
p_tv->is_enabled = disp_tv_is_enabled;
p_tv->set_mode = disp_tv_set_mode;
p_tv->get_mode = disp_tv_get_mode;
p_tv->check_support_mode = disp_tv_check_support_mode;
p_tv->get_input_csc = disp_tv_get_input_csc;
p_tv->detect = disp_tv_detect;
p_tv->suspend = disp_tv_suspend;
p_tv->resume = disp_tv_resume;
p_tv->init(p_tv);
if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_TV))
disp_device_register(p_tv);
DE_WRN("[BOOOT_DISP_TV] disp tv device_registered\n");
}
}
return 0;
}
s32 tv_init(void)
{
disp_tv_func disp_func;
s32 i = 0;
s32 val;
s32 type;
char sub_key[20];
u32 sid = 0;
g_suspend = 0;
int sid_turn = 0;
memset(&g_tv_info, 0, sizeof(tv_info_t));
type = disp_sys_script_get_item("tv_para", "tv_used", &val, 1);
if(1 == type)
g_used = val;
if(g_used) {
g_tv_info.screen[0].base_address = 0x01e00000;
type = disp_sys_script_get_item("tv_para", "tv_cali_offset", &val, 1);
if(1 == type) {
g_tv_info.screen[0].cali_offset = val;
g_tv_info.screen[1].cali_offset = g_tv_info.screen[0].cali_offset;
}
sid = tve_low_get_sid(0x10);
if (0 == sid) {
g_tv_info.screen[0].sid = 0x200;
g_tv_info.screen[1].sid = g_tv_info.screen[0].sid;
}
else {
if(sid & (1<<9))
sid_turn = 0 + (sid & 0x1ff);
else
sid_turn = 0 - (sid & 0x1ff);
sid_turn += 91;
if(sid_turn >= 0)
sid_turn = (1<<9) | sid_turn;
else
sid_turn = 0 - sid_turn;
sid = (u32)sid_turn;
g_tv_info.screen[0].sid = sid;
g_tv_info.screen[1].sid = g_tv_info.screen[0].sid;
}
for(i=0; i <SCREEN_COUNT; i++) {
tve_low_set_reg_base(i, g_tv_info.screen[i].base_address);
tve_clk_init(i);
tve_clk_enable(i);
tve_low_init(i, g_tv_info.screen[i].sid, g_tv_info.screen[i].cali_offset);
}
g_tv_info.screen[0].tv_mode = DISP_TV_MOD_PAL;
g_tv_info.screen[1].tv_mode = DISP_TV_MOD_PAL;
type = disp_sys_script_get_item("tv_para", "tv_dac_used", &val, 1);
if(1 == type)
g_dac_used = val;
if(g_dac_used) {
g_tv_info.dac_count = 1;
for(i=0; i<4; i++) {
type = disp_sys_script_get_item("tv_para", sub_key, &val, 1);
if(1 == type) {
g_tv_info.screen[0].dac_source[i] = val;
g_tv_info.screen[1].dac_source[i] = val;
g_tv_info.dac_count++;
}
else
break;
}
}
tve_low_dac_autocheck_enable(1, 0);
disp_func.tv_enable = tv_enable;
disp_func.tv_disable = tv_disable;
disp_func.tv_resume = tv_resume;
disp_func.tv_suspend = tv_suspend;
disp_func.tv_get_mode = tv_get_mode;
disp_func.tv_set_mode = tv_set_mode;
disp_func.tv_get_video_timing_info = tv_get_video_timing_info;
disp_func.tv_get_input_csc = tv_get_input_csc;
disp_func.tv_mode_support = tv_mode_support;
disp_func.tv_get_dac_hpd = tv_get_dac_hpd; //modify add disp_dunc
disp_set_tv_func(&disp_func);
}
return 0;
}
s32 disp_init_hdmi(disp_bsp_init_para * para)
{
s32 ret;
s32 value;
//get sysconfig hdmi_used
ret = disp_sys_script_get_item("hdmi_para", "hdmi_used", &value, 1);
if(ret == 1)
hdmi_used = value;
if(hdmi_used) {
u32 num_screens;
u32 disp;
struct disp_device* hdmi;
struct disp_device_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_device *)disp_sys_malloc(sizeof(struct disp_device) * num_screens);
if(NULL == hdmis) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
hdmi_private = (struct disp_device_private_data *)disp_sys_malloc(sizeof(struct disp_device_private_data) * num_screens);
if(NULL == hdmi_private) {
DE_WRN("malloc memory fail!\n");
return DIS_FAIL;
}
for(disp=0; disp<num_screens; disp++) {
hdmi = &hdmis[disp];
hdmip = &hdmi_private[disp];
if(!bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_HDMI)) {
continue;
}
hdmi->disp = disp;
sprintf(hdmi->name, "hdmi%d", disp);
hdmi->type = DISP_OUTPUT_TYPE_HDMI;
hdmip->mode = DISP_TV_MOD_720P_50HZ;
hdmip->irq_no = para->irq_no[DISP_MOD_LCD0 + disp];
switch(disp) {
case 0:
hdmip->clk = DE_LCD_CLK0;
break;
case 1:
hdmip->clk = DE_LCD_CLK1;//TCON clk
break;
default:
hdmip->clk = DE_LCD_CLK0;
}
hdmip->clk_parent = DE_HDMI_CLK_SRC;
hdmi->set_manager = disp_device_set_manager;
hdmi->unset_manager = disp_device_unset_manager;
hdmi->get_resolution = disp_device_get_resolution;
hdmi->get_timings = disp_device_get_timings;
hdmi->is_interlace = disp_device_is_interlace;
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->get_input_color_range = disp_hdmi_get_input_color_range;
hdmi->suspend = disp_hdmi_suspend;
hdmi->resume = disp_hdmi_resume;
hdmi->detect = disp_hdmi_detect;
if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_HDMI)) {
hdmi->init(hdmi);
disp_device_register(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_para * init_para)
{
int value;
int i;
memset(init_para, 0, sizeof(disp_init_para));
if(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("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[1] == DISP_OUTPUT_TYPE_VGA) {
init_para->output_mode[1]= value;
}
//screen2
if(disp_sys_script_get_item("disp_init", "screen2_output_type", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen2_output_type fail\n");
}
if(value == 0) {
init_para->output_type[2] = DISP_OUTPUT_TYPE_NONE;
} else if(value == 1) {
init_para->output_type[2] = DISP_OUTPUT_TYPE_LCD;
} else if(value == 2) {
init_para->output_type[2] = DISP_OUTPUT_TYPE_TV;
} else if(value == 3) {
init_para->output_type[2] = DISP_OUTPUT_TYPE_HDMI;
} else if(value == 4) {
init_para->output_type[2] = DISP_OUTPUT_TYPE_VGA;
} else {
__wrn("invalid screen0_output_type %d\n", init_para->output_type[2]);
}
if(disp_sys_script_get_item("disp_init", "screen2_output_mode", &value, 1) < 0) {
__wrn("fetch script data disp_init.screen2_output_mode fail\n");
}
if(init_para->output_type[2] == DISP_OUTPUT_TYPE_TV || init_para->output_type[2] == DISP_OUTPUT_TYPE_HDMI
|| init_para->output_type[2] == DISP_OUTPUT_TYPE_VGA) {
init_para->output_mode[2]= value;
}
//fb0
init_para->buffer_num[0]= 2;
if(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("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(disp_sys_script_get_item("disp_init", "fb1_format", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_format fail\n");
}
init_para->format[1]= value;
if(disp_sys_script_get_item("disp_init", "fb1_width", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_width fail\n");
}
init_para->fb_width[1]= value;
if(disp_sys_script_get_item("disp_init", "fb1_height", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb1_height fail\n");
}
init_para->fb_height[1]= value;
//fb2
init_para->buffer_num[2]= 2;
if(disp_sys_script_get_item("disp_init", "fb2_format", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb2_format fail\n");
}
init_para->format[2]= value;
if(disp_sys_script_get_item("disp_init", "fb2_width", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb2_width fail\n");
}
init_para->fb_width[2]= value;
if(disp_sys_script_get_item("disp_init", "fb2_height", &value, 1) < 0) {
__wrn("fetch script data disp_init.fb2_height fail\n");
}
init_para->fb_height[2]= 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<3; 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<3; i++) {
__inf("buffer_num[%d]:%d\n", i, init_para->buffer_num[i]);
__inf("format[%d]:%d\n", i, init_para->format[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;
}
