__s32 disp_video_exit()
{
__u32 num_screen;
__u32 num_scalers;
__u32 scaler_id;
num_screen = bsp_disp_feat_get_num_screens();
num_scalers = bsp_disp_feat_get_num_scalers();
#ifdef __LINUX_OSAL__
for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
if(maf_flag_mem[scaler_id][0]) {
kfree(maf_flag_mem[scaler_id][0]);
}
if(maf_flag_mem[scaler_id][1]) {
kfree(maf_flag_mem[scaler_id][1]);
}
}
#else
for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
if(maf_flag_mem[scaler_id][0]) {
OSAL_PhyFree(maf_flag_mem[scaler_id][0], maf_flag_mem_len);
}
if(maf_flag_mem[scaler_id][1]) {
OSAL_PhyFree(maf_flag_mem[scaler_id][1], maf_flag_mem_len);
}
}
#endif
memset(g_video,0,sizeof(g_video));
return DIS_SUCCESS;
}
static int Fb_setcolreg(unsigned regno,unsigned red, unsigned green, unsigned blue,unsigned transp, struct fb_info *info)
{
__u32 sel = 0;
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
__inf("Fb_setcolreg,regno=%d,a=%d,r=%d,g=%d,b=%d\n",regno, transp,red, green, blue);
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
unsigned int val;
switch (info->fix.visual) {
case FB_VISUAL_PSEUDOCOLOR:
if (regno < 256) {
val = (transp<<24) | (red<<16) | (green<<8) | blue;
bsp_disp_set_palette_table(sel, &val, regno*4, 4);
}
break;
default:
break;
}
}
}
return 0;
}
__s32 Display_Fb_Release(__u32 fb_id)
{
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
__inf("Display_Fb_Release, fb_id:%d\n", fb_id);
if((fb_id >= 0) && g_fbi.fb_enable[fb_id]) {
__u32 sel = 0;
struct fb_info * info = g_fbi.fbinfo[fb_id];
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[fb_id] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[fb_id] != FB_MODE_SCREEN0))) {
__s32 layer_hdl = g_fbi.layer_hdl[fb_id][sel];
bsp_disp_layer_release(sel, layer_hdl);
}
}
g_fbi.layer_hdl[fb_id][0] = 0;
g_fbi.layer_hdl[fb_id][1] = 0;
g_fbi.fb_mode[fb_id] = FB_MODE_SCREEN0;
memset(&g_fbi.fb_para[fb_id], 0, sizeof(__disp_fb_create_para_t));
g_fbi.fb_enable[fb_id] = 0;
Fb_unmap_video_memory(info);
return DIS_SUCCESS;
} else {
__wrn("invalid paras fb_id:%d in Display_Fb_Release\n", fb_id);
return DIS_FAIL;
}
}
__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 bsp_disp_init(disp_bsp_init_para * para)
{
u32 num_screens, disp;
memset(&gdisp,0x00,sizeof(disp_dev_t));
memcpy(&gdisp.init_para,para,sizeof(disp_bsp_init_para));
para->shadow_protect = bsp_disp_shadow_protect;
disp_init_feat();
num_screens = bsp_disp_feat_get_num_screens();
for(disp = 0; disp < num_screens; disp++) {
#if defined(__LINUX_PLAT__)
spin_lock_init(&gdisp.screen[disp].flag_lock);
#endif
}
bsp_disp_set_print_level(DEFAULT_PRINT_LEVLE);
disp_init_al(para);
disp_init_mgr(para);
disp_init_lcd(para);
disp_init_enhance(para);
disp_init_smbl(para);
disp_init_capture(para);
disp_init_connections();
return DIS_SUCCESS;
}
static int Fb_wait_for_vsync(struct fb_info *info)
{
unsigned long count;
__u32 sel = 0;
int ret;
int num_screens;
num_screens = bsp_disp_feat_get_num_screens();
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
if(bsp_disp_get_output_type(sel) == DISP_OUTPUT_TYPE_NONE) {
return 0;
}
count = g_fbi.wait_count[sel];
ret = wait_event_interruptible_timeout(g_fbi.wait[sel], count != g_fbi.wait_count[sel], msecs_to_jiffies(50));
if (ret == 0) {
__inf("timeout\n");
return -ETIMEDOUT;
}
}
}
return 0;
}
s32 bsp_disp_lcd_register_panel(sunxi_lcd_panel *panel)
{
u32 disp = 0;
u32 num_screens = 0;
s32 ret = 0, registered_cnt = 0;
DE_INF("panel %s\n", panel->name);
num_screens = bsp_disp_feat_get_num_screens();
for(disp=0; disp<num_screens; disp++) {
if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_LCD)) {
struct disp_device *dispdev;
struct disp_lcd *lcd;
dispdev = disp_get_lcd(disp);
if(NULL == dispdev)
continue;
lcd = container_of(dispdev, struct disp_lcd, dispdev);
if(NULL == lcd)
continue;
if((lcd) && (lcd->register_panel)) {
ret = lcd->register_panel(lcd, panel);
if(0 == ret) {
gdisp.lcd_registered[disp] = 1;
registered_cnt ++;
}
}
}
}
if(0 != registered_cnt && gdisp.init_para.start_process)
gdisp.init_para.start_process();
return 0;
}
s32 bsp_disp_set_hdmi_func(disp_hdmi_func * func)
{
u32 disp = 0;
u32 num_screens = 0;
s32 ret = 0, registered_cnt = 0;
DE_INF("\n");
num_screens = bsp_disp_feat_get_num_screens();
for(disp=0; disp<num_screens; disp++) {
struct disp_device *hdmi;
hdmi = disp_device_get(disp, DISP_OUTPUT_TYPE_HDMI);
if(hdmi) {
ret = hdmi->set_func(hdmi, func);
if(0 == ret)
registered_cnt ++;
}
}
if(0 != registered_cnt) {
DE_INF("registered!!\n");
gdisp.hdmi_registered = 1;
if(gdisp.init_para.start_process)
gdisp.init_para.start_process();
return 0;
}
return -1;
}
s32 bsp_disp_lcd_set_panel_funs(char *name, disp_lcd_panel_fun * lcd_cfg)
{
struct disp_lcd* lcd;
u32 num_screens;
u32 screen_id;
char drv_name[32];
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->get_panel_driver_name) && (lcd->set_panel_func)) {
lcd->get_panel_driver_name(lcd, drv_name);
if(!strcmp(drv_name, name)) {
if(!lcd->set_panel_func(lcd, lcd_cfg)) {
gdisp.lcd_registered[screen_id] = 1;
DE_INF("panel driver %s register\n", name);
}
if(!strcmp("gm7121", drv_name)) {
lcd->type = DISP_OUTPUT_TYPE_TV;//DISP_OUTPUT_TYPE_HDMI;
}
}
}
}
if(gdisp.init_para.start_process) {
DE_INF("gdisp.init_para.start_process\n");
gdisp.init_para.start_process();
}
return 0;
}
s32 bsp_disp_is_in_vb(void)
{
u32 num_screens, screen_id;
s32 ret = 1;
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;
static disp_panel_para info;
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(info.lcd_if == LCD_IF_EDP) {
ret = disp_al_edp_int(EDP_IRQ_VBLK);
} else {
ret = tcon_irq_query(screen_id,LCD_IRQ_TCON0_VBLK) | dsi_irq_query(screen_id,DSI_IRQ_VIDEO_VBLK);
}
} else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) {
/* FIXME: add hdmi */
}
}
return ret;
}
static int Fb_pan_display(struct fb_var_screeninfo *var,struct fb_info *info)
{
__u32 sel = 0;
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
//__inf("Fb_pan_display\n");
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
__s32 layer_hdl = g_fbi.layer_hdl[info->node][sel];
__disp_layer_info_t layer_para;
__u32 buffer_num = 1;
__u32 y_offset = 0;
if(g_fbi.fb_mode[info->node] == FB_MODE_DUAL_DIFF_SCREEN_SAME_CONTENTS) {
if(sel != var->reserved[0]) {
return -1;
}
}
if(g_fbi.fb_mode[info->node] == FB_MODE_DUAL_SAME_SCREEN_TB) {
buffer_num = 2;
}
if((sel==0) && (g_fbi.fb_mode[info->node] == FB_MODE_DUAL_SAME_SCREEN_TB)) {
y_offset = var->yres / 2;
}
bsp_disp_layer_get_para(sel, layer_hdl, &layer_para);
if(layer_para.mode == DISP_LAYER_WORK_MODE_SCALER) {
layer_para.src_win.x = var->xoffset;
layer_para.src_win.y = var->yoffset + y_offset;
layer_para.src_win.width = var->xres;
layer_para.src_win.height = var->yres / buffer_num;
bsp_disp_layer_set_src_window(sel, layer_hdl, &(layer_para.src_win));
} else {
layer_para.src_win.x = var->xoffset;
layer_para.src_win.y = var->yoffset + y_offset;
layer_para.src_win.width = var->xres;
layer_para.src_win.height = var->yres / buffer_num;
layer_para.scn_win.width = var->xres;
layer_para.scn_win.height = var->yres / buffer_num;
bsp_disp_layer_set_src_window(sel, layer_hdl, &(layer_para.src_win));
bsp_disp_layer_set_screen_window(sel, layer_hdl, &(layer_para.scn_win));
}
}
}
Fb_wait_for_vsync(info);
return 0;
}
s32 disp_init_connections(void)
{
u32 disp = 0;
u32 num_screens = 0;
u32 num_layers = 0,layer_id = 0;
DE_INF("disp_init_connections\n");
num_screens = bsp_disp_feat_get_num_screens();
for(disp=0; disp<num_screens; disp++) {
struct disp_manager *mgr;
struct disp_layer *lyr;
struct disp_device *lcd = NULL;
struct disp_enhance *enhance = NULL;
struct disp_smbl *smbl = NULL;
struct disp_capture *cptr = NULL;
mgr = disp_get_layer_manager(disp);
if(!mgr)
continue;
/* connect layer & it's manager */
num_layers = bsp_disp_feat_get_num_layers(disp);
for(layer_id=0; layer_id<num_layers; layer_id++) {
lyr = disp_get_layer_1(disp, layer_id);
if(NULL != lyr) {
lyr->set_manager(lyr, mgr);
}
}
/* connect device & it's manager */
if(bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_LCD)) {
lcd = disp_get_lcd(disp);
if((lcd) && (lcd->set_manager))
lcd->set_manager(lcd, mgr);
} else {
//other device
}
enhance = disp_get_enhance(disp);
if(enhance && (enhance->set_manager)) {
enhance->set_manager(enhance, mgr);
}
smbl = disp_get_smbl(disp);
if(smbl && (smbl->set_manager)) {
smbl->set_manager(smbl, mgr);
}
cptr = disp_get_capture(disp);
if(cptr && (cptr->set_manager)) {
cptr->set_manager(cptr, mgr);
}
}
return 0;
}
s32 bsp_disp_init(__disp_bsp_init_para * para)
{
u32 num_screens, screen_id;
#if defined(CONFIG_ARCH_SUN9IW1P1)
u32 temp;
#endif
memset(&gdisp,0x00,sizeof(__disp_dev_t));
memset(fps_data, 0x00, sizeof(disp_fps_data) * 3);
memcpy(&gdisp.init_para,para,sizeof(__disp_bsp_init_para));
para->shadow_protect = bsp_disp_shadow_protect;
disp_init_feat();
num_screens = bsp_disp_feat_get_num_screens();
for(screen_id = 0; screen_id < num_screens; screen_id++) {
#if defined(__LINUX_PLAT__)
spin_lock_init(&gdisp.screen[screen_id].flag_lock);
init_waitqueue_head(&gdisp.screen[screen_id].wait);
gdisp.screen[screen_id].wait_count = 0;
#endif
}
#if defined(CONFIG_ARCH_SUN9IW1P1)
{
u32 addr;
//FIXME
temp = *((volatile u32*)(0xf60005a8));
temp = temp | 0x4;
*((volatile u32*)(0xf60005a8)) = temp;
addr = para->reg_base[DISP_MOD_TOP];
writel(0xffffffff, (void __iomem *)(addr + 0xc));
}
#endif
bsp_disp_set_print_level(DEFAULT_PRINT_LEVLE);
disp_notifier_init();
disp_init_al(para);
disp_init_lcd(para);
#if defined(CONFIG_ARCH_SUN9IW1P1)
disp_init_hdmi(para);
disp_init_cursor(para);
#endif
disp_init_mgr(para);
disp_init_lyr(para);
//capture
disp_init_capture(para);
disp_init_smcl(para);
disp_init_smbl(para);
disp_init_connections();
return DIS_SUCCESS;
}
struct disp_enhance* disp_get_enhance(u32 disp)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(disp >= num_screens) {
DE_WRN("disp %d out of range\n", disp);
return NULL;
}
return &enhances[disp];
}
struct disp_device* disp_get_tv(u32 disp)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(disp >= num_screens || !bsp_disp_feat_is_supported_output_types(disp, DISP_OUTPUT_TYPE_TV)) {
DE_WRN("disp %d not support TV output\n", disp);
return NULL;
}
return &g_ptv_devices[disp];
}
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;
}
struct disp_lcd* disp_get_lcd(u32 screen_id)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(screen_id >= num_screens) {
DE_WRN("screen_id %d out of range\n", screen_id);
return NULL;
}
return &lcds[screen_id];
}
struct disp_smbl* disp_get_smbl(u32 disp)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(disp >= num_screens) {
DE_WRN("disp %d out of range\n", disp);
return NULL;
}
DE_INF("get smbl%d ok\n", disp);
return &smbls[disp];
}
s32 bsp_disp_exit(u32 mode)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(mode == DISP_EXIT_MODE_CLEAN_ALL) {
/* close all mod and unregister all irq */
} else if(mode == DISP_EXIT_MODE_CLEAN_PARTLY) {
/* unregister all irq */
}
return DIS_SUCCESS;
}
s32 bsp_disp_init(__disp_bsp_init_para * para)
{
u32 num_screens, screen_id;
#if defined(CONFIG_ARCH_SUN9IW1P1)
u32 temp;
#endif
memset(&gdisp,0x00,sizeof(__disp_dev_t));
memcpy(&gdisp.init_para,para,sizeof(__disp_bsp_init_para));
para->shadow_protect = bsp_disp_shadow_protect;
disp_init_feat();
num_screens = bsp_disp_feat_get_num_screens();
for(screen_id = 0; screen_id < num_screens; screen_id++) {
#if defined(__LINUX_PLAT__)
spin_lock_init(&gdisp.screen[screen_id].flag_lock);
#endif
}
#if defined(CONFIG_ARCH_SUN9IW1P1)
//for_test
// temp = *((volatile u32*)(0x060005a8));
// temp = temp | 0x4;
// *((volatile u32*)(0x060005a8)) = temp;
temp = smc_readl(0x060005a8);
temp |= 4;
smc_writel(temp, 0x060005a8);
#endif
//bsp_disp_set_print_level(DEFAULT_PRINT_LEVLE);
disp_notifier_init();
disp_init_al(para);
disp_init_lcd(para);
#if defined(CONFIG_ARCH_SUN9IW1P1)
disp_init_hdmi(para);
disp_init_cursor(para);
#endif
disp_init_mgr(para);
disp_init_lyr(para);
disp_init_smcl(para);
disp_init_smbl(para);
disp_init_connections();
return DIS_SUCCESS;
}
s32 bsp_disp_device_switch(int disp, disp_output_type output_type, disp_tv_mode mode)
{
int num_screens = 0;
int disp_dev;
int ret = -1;
ret = disp_device_attached_and_enable(disp, disp, output_type, mode);
if(0 != ret) {
num_screens = bsp_disp_feat_get_num_screens();
for(disp_dev=0; disp_dev<num_screens; disp_dev++) {
ret = disp_device_attached_and_enable(disp, disp_dev, output_type, mode);
if(0 == ret)
break;
}
}
return ret;
}
/* 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_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;
}
static int Fb_set_par(struct fb_info *info)//todo
{
__u32 sel = 0;
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
__inf("Fb_set_par\n");
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
struct fb_var_screeninfo *var = &info->var;
struct fb_fix_screeninfo * fix = &info->fix;
__s32 layer_hdl = g_fbi.layer_hdl[info->node][sel];
__disp_layer_info_t layer_para;
__u32 buffer_num = 1;
__u32 y_offset = 0;
if(g_fbi.fb_mode[info->node] == FB_MODE_DUAL_SAME_SCREEN_TB) {
buffer_num = 2;
}
if((sel==0) && (g_fbi.fb_mode[info->node] == FB_MODE_DUAL_SAME_SCREEN_TB)) {
y_offset = var->yres / 2;
}
bsp_disp_layer_get_para(sel, layer_hdl, &layer_para);
var_to_disp_fb(&(layer_para.fb), var, fix);
layer_para.src_win.x = var->xoffset;
layer_para.src_win.y = var->yoffset + y_offset;
layer_para.src_win.width = var->xres;
layer_para.src_win.height = var->yres / buffer_num;
if(layer_para.mode != DISP_LAYER_WORK_MODE_SCALER) {
layer_para.scn_win.width = layer_para.src_win.width;
layer_para.scn_win.height = layer_para.src_win.height;
}
bsp_disp_layer_set_para(sel, layer_hdl, &layer_para);
}
}
return 0;
}
__s32 disp_video_init()
{
__u32 num_screens;
__u32 num_scalers;
__u32 scaler_id;
num_screens = bsp_disp_feat_get_num_screens();
num_scalers = bsp_disp_feat_get_num_scalers();
memset(g_video,0,sizeof(g_video));
#ifdef __LINUX_OSAL__
for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
if((bsp_disp_feat_get_layer_feats(scaler_id, DISP_LAYER_WORK_MODE_SCALER, scaler_id)
& DISP_LAYER_FEAT_DE_INTERLACE))
bsp_disp_lcd_delay_ms(10);
maf_flag_mem[scaler_id][0] = (void*)__pa((char __iomem *)kmalloc(maf_flag_mem_len, GFP_KERNEL | __GFP_ZERO));
maf_flag_mem[scaler_id][1] = (void*)__pa((char __iomem *)kmalloc(maf_flag_mem_len, GFP_KERNEL | __GFP_ZERO));
DE_INF("maf_flag_mem[%d][%d]=0x%8x, maf_flag_mem[%d][%d]=0x%8x\n",scaler_id, 0,
(unsigned int)maf_flag_mem[scaler_id][0], scaler_id, 1, (unsigned int)maf_flag_mem[scaler_id][1]);
if((maf_flag_mem[scaler_id][0] == NULL) || (maf_flag_mem[scaler_id][1] == NULL)) {
DE_WRN("maf memory[%d] request fail\n", scaler_id);
}
}
#else
for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
if((bsp_disp_feat_get_layer_feats(scaler_id, DISP_LAYER_WORK_MODE_SCALER, scaler_id)
& DISP_LAYER_FEAT_DE_INTERLACE))
maf_flag_mem[scaler_id][0] = OSAL_PhyAlloc(maf_flag_mem_len);
maf_flag_mem[scaler_id][1] = OSAL_PhyAlloc(maf_flag_mem_len);
DE_INF("maf_flag_mem[%d][%d]=0x%8x, maf_flag_mem[%d][%d]=0x%8x\n",scaler_id, 0,
(unsigned int)maf_flag_mem[scaler_id][0], scaler_id, 1, (unsigned int)maf_flag_mem[scaler_id][1]);
if((maf_flag_mem[scaler_id][0] == NULL) || (maf_flag_mem[scaler_id][1] == NULL)) {
DE_WRN("maf memory[%d] request fail\n", scaler_id);
}
}
#endif
for(scaler_id=0; scaler_id<num_scalers; scaler_id++) {
dit_mode_default[scaler_id] = DIT_MODE_MAF;
}
return DIS_SUCCESS;
}
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;
}
struct disp_hdmi* disp_get_hdmi(u32 screen_id)
{
u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
if(screen_id >= num_screens) {
DE_WRN("screen_id %d out of range\n", screen_id);
return NULL;
}
if(!(bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI)) {
DE_WRN("screen_id %d do not support HDMI TYPE!\n", screen_id);
return NULL;
}
if(!disp_al_query_hdmi_mod(screen_id)) {
DE_WRN("hdmi %d is not registered\n", screen_id);
return NULL;
}
return &hdmis[screen_id];
}
s32 bsp_disp_get_vb_time(void)
{
u32 cur_line;
u32 num_screens, screen_id;
disp_video_timing tt;
u32 vb_time = 0;
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;
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);
}
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;
vb_time = (start_delay) * time_per_line;
} else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) {
/* FIXME: add hdmi */
}
}
}
return vb_time;
}
static int Fb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
__u32 sel = 0;
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
__inf("Fb_setcmap\n");
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
unsigned int j = 0, val = 0;
unsigned char hred, hgreen, hblue, htransp = 0xff;
unsigned short *red, *green, *blue, *transp;
red = cmap->red;
green = cmap->green;
blue = cmap->blue;
transp = cmap->transp;
for (j = 0; j < cmap->len; j++) {
hred = (*red++)&0xff;
hgreen = (*green++)&0xff;
hblue = (*blue++)&0xff;
if (transp) {
htransp = (*transp++)&0xff;
} else {
htransp = 0xff;
}
val = (htransp<<24) | (hred<<16) | (hgreen<<8) |hblue;
bsp_disp_set_palette_table(sel, &val, (cmap->start + j) * 4, 4);
}
}
}
return 0;
}
int Fb_blank(int blank_mode, struct fb_info *info)
{
__u32 sel = 0;
__u32 num_screens;
num_screens = bsp_disp_feat_get_num_screens();
__inf("Fb_blank,mode:%d\n",blank_mode);
for(sel = 0; sel < num_screens; sel++) {
if(((sel==0) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN1))
|| ((sel==1) && (g_fbi.fb_mode[info->node] != FB_MODE_SCREEN0))) {
__s32 layer_hdl = g_fbi.layer_hdl[info->node][sel];
if (blank_mode == FB_BLANK_POWERDOWN) {
bsp_disp_layer_close(sel, layer_hdl);
} else {
bsp_disp_layer_open(sel, layer_hdl);
}
//DRV_disp_wait_cmd_finish(sel);
}
}
return 0;
}
