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;
}
s32 bsp_disp_get_screen_physical_height(u32 screen_id)
{
u32 width = 0, height = 0;
struct disp_lcd *lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->get_physical_size) {
lcd->get_physical_size(lcd, &width, &height);
}
return height;
}
s32 bsp_disp_get_cur_vb_time(void)
{
u32 cur_line;
u32 num_screens, screen_id;
disp_video_timing tt;
u32 vb_time = 200;
num_screens = bsp_disp_feat_get_num_screens();
for(screen_id=0; screen_id<num_screens; screen_id++) {
if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) {
struct disp_lcd* lcd;
u32 time_per_line = 0;
u32 start_delay = 0;
static disp_panel_para info;
start_delay = disp_al_lcd_get_start_delay(screen_id);
cur_line = disp_al_lcd_get_cur_line(screen_id);
lcd = disp_get_lcd(screen_id);
if(!lcd) {
DE_WRN("get lcd%d fail\n", screen_id);
}
memset(&info, 0, sizeof(disp_panel_para));
if(lcd->get_panel_info)
lcd->get_panel_info(lcd, &info);
if(LCD_IF_EDP != info.lcd_if) {
if(lcd->get_timing) {
u32 fps = 0;
lcd->get_timing(lcd, &tt);
if((tt.ver_total_time != 0) && (tt.hor_total_time != 0))
fps = tt.pixel_clk*1000/(tt.ver_total_time*tt.hor_total_time);
fps = (0 == fps)? 60:fps;
time_per_line = 1000000 / fps / tt.ver_total_time;
if(cur_line > start_delay)
vb_time = 0;
else
vb_time = (start_delay - cur_line) * time_per_line;
}
} else {
/* EDP PANEL */
#if defined(__LINUX_PLAT__)
u32 count = gdisp.screen[screen_id].wait_count;
wait_event_interruptible_timeout(gdisp.screen[screen_id].wait, count != gdisp.screen[screen_id].wait_count, msecs_to_jiffies(50));
vb_time = 150;
#endif
}
} else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) {
/* FIXME: add hdmi */
}
}
return vb_time;
}
s32 bsp_disp_get_panel_info(u32 screen_id, disp_panel_para *info)
{
struct disp_lcd* lcd;
lcd = disp_get_lcd(screen_id);
if(!lcd)
DE_WRN("get lcd%d fail\n", screen_id);
if(lcd->get_panel_info)
return lcd->get_panel_info(lcd, info);
return DIS_FAIL;
}
s32 bsp_disp_get_panel_info(u32 disp, disp_panel_para *info)
{
struct disp_device* lcd;
lcd = disp_get_lcd(disp);
if(!lcd)
DE_WRN("get lcd%d fail\n", disp);
if(lcd && lcd->get_panel_info)
return lcd->get_panel_info(lcd, info);
return DIS_FAIL;
}
s32 bsp_disp_lcd_pwm_enable(u32 screen_id)
{
s32 ret = -1;
struct disp_lcd* lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->pwm_enable) {
ret = lcd->pwm_enable(lcd);
}
return ret;
}
s32 bsp_disp_lcd_backlight_disable(u32 screen_id)
{
s32 ret = -1;
struct disp_lcd* lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->backlight_disable) {
ret = lcd->backlight_disable(lcd);
}
return ret;
}
disp_lcd_flow * bsp_disp_lcd_get_close_flow(u32 disp)
{
struct disp_device* lcd;
disp_lcd_flow *flow = NULL;
lcd = disp_get_lcd(disp);
if(lcd && lcd->get_close_flow) {
flow = lcd->get_close_flow(lcd);
}
return flow;
}
s32 bsp_disp_lcd_power_disable(u32 screen_id, u32 power_id)
{
s32 ret = -1;
struct disp_lcd* lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->pwm_disable) {
ret = lcd->power_disable(lcd, power_id);
}
return ret;
}
disp_lcd_flow * bsp_disp_lcd_get_close_flow(u32 screen_id)
{
struct disp_lcd* lcd;
disp_lcd_flow *flow = NULL;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->get_close_flow) {
flow = lcd->get_close_flow(lcd);
}
return flow;
}
s32 bsp_disp_lcd_set_bright(u32 screen_id, u32 bright)
{
s32 ret = -1;
struct disp_lcd* lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->set_bright) {
ret = lcd->set_bright(lcd, bright);
}
return ret;
}
s32 bsp_disp_get_screen_width_from_output_type(u32 screen_id, u32 output_type, u32 output_mode)
{
u32 width = 0, height = 0;
if(DISP_OUTPUT_TYPE_LCD == output_type) {
struct disp_lcd *lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->get_resolution) {
lcd->get_resolution(lcd, &width, &height);
}
} else if((DISP_OUTPUT_TYPE_HDMI == output_type) || (DISP_OUTPUT_TYPE_TV == output_type)) {
switch(output_mode) {
case DISP_TV_MOD_NTSC:
case DISP_TV_MOD_480I:
case DISP_TV_MOD_480P:
width = 720;
height = 480;
break;
case DISP_TV_MOD_PAL:
case DISP_TV_MOD_576I:
case DISP_TV_MOD_576P:
width = 720;
height = 576;
break;
case DISP_TV_MOD_720P_50HZ:
case DISP_TV_MOD_720P_60HZ:
width = 1280;
height = 720;
break;
case DISP_TV_MOD_1080I_50HZ:
case DISP_TV_MOD_1080I_60HZ:
case DISP_TV_MOD_1080P_50HZ:
case DISP_TV_MOD_1080P_60HZ:
case DISP_TV_MOD_1080P_30HZ:
case DISP_TV_MOD_1080P_24HZ:
width = 1920;
height = 1080;
break;
case DISP_TV_MOD_3840_2160P_30HZ:
case DISP_TV_MOD_3840_2160P_25HZ:
case DISP_TV_MOD_3840_2160P_24HZ:
width = 3840;
height = 2160;
break;
default:
printk("err:function:%s, line:%d,output_mode=%d\n", __func__, __LINE__, output_mode);
}
}
/* FIXME: add other output device res */
return width;
}
s32 bsp_disp_get_screen_height_from_output_type(u32 screen_id, u32 output_type, u32 output_mode)
{
u32 width = 0, height = 0;
if(DISP_OUTPUT_TYPE_LCD == output_type) {
struct disp_lcd *lcd;
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->get_resolution) {
lcd->get_resolution(lcd, &width, &height);
}
} else if(DISP_OUTPUT_TYPE_HDMI == output_type) {
switch(output_mode) {
case DISP_TV_MOD_NTSC:
case DISP_TV_MOD_480I:
case DISP_TV_MOD_480P:
width = 720;
height = 480;
break;
case DISP_TV_MOD_PAL:
case DISP_TV_MOD_576I:
case DISP_TV_MOD_576P:
width = 720;
height = 576;
break;
case DISP_TV_MOD_720P_50HZ:
case DISP_TV_MOD_720P_60HZ:
width = 1280;
height = 720;
break;
case DISP_TV_MOD_1080I_50HZ:
case DISP_TV_MOD_1080I_60HZ:
case DISP_TV_MOD_1080P_50HZ:
case DISP_TV_MOD_1080P_60HZ:
case DISP_TV_MOD_1080P_30HZ:
case DISP_TV_MOD_1080P_24HZ:
width = 1920;
height = 1080;
break;
case DISP_TV_MOD_3840_2160P_30HZ:
case DISP_TV_MOD_3840_2160P_25HZ:
case DISP_TV_MOD_3840_2160P_24HZ:
width = 3840;
height = 2160;
break;
default:
DE_WRN("err:get_screen_height,output_mode=%d\n", output_mode);
}
}
return height;
}
s32 bsp_disp_get_lcd_output_type(u32 screen_id)
{
struct disp_lcd *lcd = disp_get_lcd(screen_id);
u32 output_type = DISP_OUTPUT_TYPE_NONE;
if(lcd) {
output_type = lcd->type;
} else {
DE_WRN("get lcd%d output type fail\n", screen_id);
}
return output_type;
}
s32 bsp_disp_lcd_tcon_enable(u32 screen_id)
{
s32 ret = -1;
struct disp_lcd* lcd;
__inf("bsp_disp_lcd_tcon_enable, sel=%d\n", screen_id);
lcd = disp_get_lcd(screen_id);
if(lcd && lcd->tcon_enable) {
ret = lcd->tcon_enable(lcd);
}
return ret;
}
s32 bsp_disp_lcd_pwm_enable(u32 disp)
{
s32 ret = -1;
struct disp_device *lcd;
lcd = disp_get_lcd(disp);
if(NULL == lcd)
return ret;
if(lcd && lcd->pwm_enable) {
ret = lcd->pwm_enable(lcd);
}
return ret;
}
s32 bsp_disp_lcd_power_disable(u32 disp, u32 power_id)
{
s32 ret = -1;
struct disp_device *lcd;
lcd = disp_get_lcd(disp);
if(NULL == lcd)
return ret;
if(lcd && lcd->power_disable) {
ret = lcd->power_disable(lcd, power_id);
}
return ret;
}
s32 bsp_disp_lcd_set_bright(u32 disp, u32 bright)
{
s32 ret = -1;
struct disp_device *lcd;
lcd = disp_get_lcd(disp);
if(NULL == lcd)
return ret;
if(lcd && lcd->set_bright) {
ret = lcd->set_bright(lcd, bright);
}
return ret;
}
s32 bsp_disp_lcd_get_bright(u32 disp)
{
u32 bright = 0;
struct disp_device *dispdev;
struct disp_lcd *lcd;
dispdev = disp_get_lcd(disp);
if(NULL == dispdev)
return bright;
lcd = container_of(dispdev, struct disp_lcd, dispdev);
if(lcd && lcd->get_bright)
bright = lcd->get_bright(lcd);
return bright;
}
s32 bsp_disp_get_timming(u32 screen_id, disp_video_timing * tt)
{
memset(tt, 0, sizeof(disp_video_timing));
if(DISP_OUTPUT_TYPE_LCD == bsp_disp_get_output_type(screen_id)) {
struct disp_lcd *lcd;
lcd = disp_get_lcd(screen_id);
if(!lcd) {
DE_WRN("get lcd%d failed\n", screen_id);
return DIS_FAIL;
}
if(lcd->get_timing)
return lcd->get_timing(lcd, tt);
}
#if 0
struct disp_hdmi* hdmi;
else if(DISP_OUTPUT_TYPE_HDMI == bsp_disp_get_output_type(screen_id)) {
s32 bsp_disp_lcd_post_enable(u32 screen_id)
{
struct disp_lcd* lcd;
int ret = 0;
lcd = disp_get_lcd(screen_id);
if(!lcd) {
DE_WRN("get lcd%d fail\n", screen_id);
}
if(lcd->post_enable)
ret = lcd->post_enable(lcd);
#if defined(__LINUX_PLAT__)
Display_set_fb_timming(screen_id);
#endif
return ret;
}
s32 bsp_disp_lcd_backlight_disable(u32 disp)
{
s32 ret = -1;
struct disp_device *dispdev;
struct disp_lcd *lcd;
dispdev = disp_get_lcd(disp);
if(NULL == dispdev)
return ret;
lcd = container_of(dispdev, struct disp_lcd, dispdev);
if(lcd && lcd->backlight_disable) {
ret = lcd->backlight_disable(lcd);
}
return ret;
}
s32 bsp_disp_lcd_power_disable(u32 disp, u32 power_id)
{
s32 ret = -1;
struct disp_device *dispdev;
struct disp_lcd *lcd;
dispdev = disp_get_lcd(disp);
if(NULL == dispdev)
return ret;
lcd = container_of(dispdev, struct disp_lcd, dispdev);
if(lcd && lcd->power_disable) {
ret = lcd->power_disable(lcd, power_id);
}
return ret;
}
s32 bsp_disp_lcd_set_bright(u32 disp, u32 bright)
{
s32 ret = -1;
struct disp_device *dispdev;
struct disp_lcd *lcd;
dispdev = disp_get_lcd(disp);
if(NULL == dispdev)
return ret;
lcd = container_of(dispdev, struct disp_lcd, dispdev);
if(lcd && lcd->set_bright) {
ret = lcd->set_bright(lcd, bright);
}
return ret;
}
void sync_finish_event_proc(u32 screen_id)
{
#if defined(__LINUX_PLAT__)
unsigned long flags;
#endif
//disp_lint_checkin(screen_id);
if(gdisp.screen[screen_id].vsync_event_en && gdisp.init_para.vsync_event) {
gdisp.init_para.vsync_event(screen_id);
}
#if defined(__LINUX_PLAT__)
#ifdef CONFIG_DEVFREQ_DRAM_FREQ_IN_VSYNC
if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) {
struct disp_lcd* lcd = NULL;
static disp_panel_para info;
lcd = disp_get_lcd(screen_id);
if(NULL != lcd) {
memset(&info, 0, sizeof(disp_panel_para));
if(lcd->get_panel_info)
lcd->get_panel_info(lcd, &info);
if(LCD_IF_EDP == info.lcd_if) {
gdisp.screen[screen_id].wait_count++;
wake_up_interruptible(&gdisp.screen[screen_id].wait);
}
}
}
#endif
#endif
#if defined(__LINUX_PLAT__)
spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags);
#endif
if(gdisp.screen[screen_id].have_cfg_reg) {
gdisp.screen[screen_id].have_cfg_reg = false;
#if defined(__LINUX_PLAT__)
spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags);
#endif
if(gdisp.init_para.disp_int_process)
gdisp.init_para.disp_int_process(screen_id);
} else {
#if defined(__LINUX_PLAT__)
spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags);
#endif
}
}
/* returns: us */
s32 bsp_disp_get_next_vb_time(void)
{
u32 cur_line;
u32 num_screens, screen_id;
disp_video_timing tt;
u32 next_time = 16000;
num_screens = bsp_disp_feat_get_num_screens();
for(screen_id=0; screen_id<num_screens; screen_id++) {
if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) {
struct disp_lcd* lcd;
u32 time_per_line = 0;
static disp_panel_para info;
cur_line = disp_al_lcd_get_cur_line(screen_id);
lcd = disp_get_lcd(screen_id);
if(!lcd) {
DE_WRN("get lcd%d fail\n", screen_id);
}
memset(&info, 0, sizeof(disp_panel_para));
if(lcd && lcd->get_panel_info)
lcd->get_panel_info(lcd, &info);
if(LCD_IF_EDP != info.lcd_if) {
if(lcd && lcd->get_timing) {
u32 fps = 0;
lcd->get_timing(lcd, &tt);
if((tt.ver_total_time != 0) && (tt.hor_total_time != 0))
fps = tt.pixel_clk*1000/(tt.ver_total_time*tt.hor_total_time);
fps = (0 == fps)? 60:fps;
time_per_line = 1000000 / fps / tt.ver_total_time;
next_time = (tt.ver_total_time - cur_line) * time_per_line;
}
} else {
/* EDP PANEL */
next_time = 16000;//fix to 16ms
}
} else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) {
/* FIXME: add hdmi */
}
}
return next_time;
}
s32 bsp_disp_lcd_pre_disable(u32 screen_id)
{
struct disp_lcd* lcd;
struct disp_manager *mgr;
mgr = disp_get_layer_manager(screen_id);
lcd = disp_get_lcd(screen_id);
if(!mgr || !lcd) {
DE_WRN("get lcd%d or mgr%d fail\n", screen_id, screen_id);
return -1;
}
if(mgr->set_output_type)
mgr->set_output_type(mgr, DISP_OUTPUT_TYPE_NONE);
if(lcd->pre_disable) {
return lcd->pre_disable(lcd);
}
return DIS_FAIL;
}
s32 bsp_disp_exit(u32 mode)
{
u32 num_screens;
u32 screen_id;
u32 num_scalers;
u32 scaler_id;
struct disp_lcd *lcd;
struct disp_manager *manager;
num_screens = bsp_disp_feat_get_num_screens();
num_scalers = bsp_disp_feat_get_num_scalers();
if(mode == DISP_EXIT_MODE_CLEAN_ALL) {
/* close all mod and unregister all irq */
for(scaler_id = 0; scaler_id < num_scalers; scaler_id++) {
scaler_close(scaler_id);
}
scaler_exit();
for(screen_id = 0; screen_id < num_screens; screen_id++) {
lcd = disp_get_lcd(screen_id);
manager = disp_get_layer_manager(screen_id);
manager->exit(manager);
lcd->exit(lcd);
}
} else if(mode == DISP_EXIT_MODE_CLEAN_PARTLY) {
/* unregister all irq */
// OSAL_InterruptDisable(AW_IRQ_DEBE0);
// OSAL_UnRegISR(AW_IRQ_DEBE0, manager_event_proc, (void*)0);
OSAL_InterruptDisable(AW_IRQ_LCD0);
OSAL_UnRegISR(AW_IRQ_LCD0, disp_lcd_event_proc, (void*)0);
// OSAL_InterruptDisable(AW_IRQ_DEBE1);
// OSAL_UnRegISR(AW_IRQ_DEBE1, manager_event_proc, (void*)0);
OSAL_InterruptDisable(AW_IRQ_LCD1);
OSAL_UnRegISR(AW_IRQ_LCD1, disp_lcd_event_proc, (void*)0);
}
return DIS_SUCCESS;
}
s32 bsp_disp_lcd_post_disable(u32 screen_id)
{
struct disp_lcd* lcd;
struct disp_manager *mgr;
s32 ret = -1;
mgr = disp_get_layer_manager(screen_id);
lcd = disp_get_lcd(screen_id);
if(!mgr || !lcd) {
DE_WRN("get lcd%d or mgr%d fail\n", screen_id, screen_id);
return -1;
}
if(lcd->post_disable)
ret = lcd->post_disable(lcd);
if(mgr->disable)
mgr->disable(mgr);
return ret;
}
s32 bsp_disp_lcd_set_panel_funs(char *name, disp_lcd_panel_fun * lcd_cfg)
{
struct disp_device* lcd;
u32 num_screens;
u32 screen_id;
u32 registered_cnt = 0;
num_screens = bsp_disp_feat_get_num_screens();
for(screen_id=0; screen_id<num_screens; screen_id++) {
lcd = disp_get_lcd(screen_id);
if(lcd && (lcd->set_panel_func)) {
if(!lcd->set_panel_func(lcd, name, lcd_cfg)) {
gdisp.lcd_registered[screen_id] = 1;
registered_cnt ++;
DE_INF("panel driver %s register\n", name);
}
}
}
return 0;
}
