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; }
s32 bsp_disp_get_timming(u32 screen_id, disp_video_timing * tt) { //struct disp_hdmi* hdmi; 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 else if(DISP_OUTPUT_TYPE_HDMI == bsp_disp_get_output_type(screen_id)) { //FIXME? hdmi = disp_get_hdmi(screen_id); if(!hdmi) { DE_WRN("get hdmi%d failed!\n", screen_id); return DIS_FAIL; } } #endif return 0; }
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; }
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_drc_get_window(__u32 screen_id,__disp_rect_t *regn) { if(DISP_OUTPUT_TYPE_LCD == bsp_disp_get_output_type(screen_id)) { memcpy(regn, &gdisp.screen[screen_id].drc.rect, sizeof(__disp_rect_t)); return DIS_SUCCESS; } return DIS_NOT_SUPPORT; }
/* 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; }
//type 0: decrease //type 1: resume __s32 disp_clk_adjust(__u32 screen_id, __u32 type) { if((gpanel_info[screen_id].lcd_x >= 2048) || (gpanel_info[screen_id].lcd_y >= 1536)) { if(type == 0) { gpanel_info[screen_id].lcd_dclk_freq_original = gpanel_info[screen_id].lcd_dclk_freq; gpanel_info[screen_id].lcd_dclk_freq = gpanel_info[screen_id].lcd_dclk_freq * 2 /3; //40fps if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) { disp_clk_cfg(screen_id, DISP_OUTPUT_TYPE_LCD, DIS_NULL); } } else if(type == 1) { gpanel_info[screen_id].lcd_dclk_freq = gpanel_info[screen_id].lcd_dclk_freq_original; if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) { disp_clk_cfg(screen_id, DISP_OUTPUT_TYPE_LCD, DIS_NULL); } } } return DIS_SUCCESS; }
static ssize_t disp_hdmi_show(struct device *dev, struct device_attribute *attr, char *buf) { if(bsp_disp_get_output_type(sel) == DISP_OUTPUT_TYPE_HDMI) { return sprintf(buf, "screen%d hdmi on, mode=%d\n", sel, bsp_disp_hdmi_get_mode(sel)); } else { return sprintf(buf, "screen%d hdmi off!\n", sel); } }
static ssize_t disp_lcd_show(struct device *dev, struct device_attribute *attr, char *buf) { if(bsp_disp_get_output_type(sel) == DISP_OUTPUT_TYPE_LCD) { return sprintf(buf, "screen%d lcd on!\n", sel); } else { return sprintf(buf, "screen%d lcd off!\n", sel); } }
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; }
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 } }
//todo : csc->set_mode or set_mode->csc? __s32 bsp_disp_drc_enable(__u32 screen_id, __u32 en) { if((DISP_OUTPUT_TYPE_LCD == bsp_disp_get_output_type(screen_id)) && disp_drc_get_support(screen_id)) { __iep_drc_t *drc; drc = &gdisp.screen[screen_id].drc; if((1 == en) && (0 == drc->enable)) { IEP_Drc_Set_Imgsize(screen_id, bsp_disp_get_screen_width(screen_id), bsp_disp_get_screen_height(screen_id)); IEP_Drc_Set_Winodw(screen_id, drc->rect); IEP_Drc_Set_Mode(screen_id,drc->mode); bsp_disp_cfg_start(screen_id); /* video mode */ if(drc->mode == IEP_DRC_MODE_VIDEO) { //todo? yuv output DE_BE_Set_Enhance_ex(screen_id, 3, DISP_COLOR_RANGE_0_255, 0,50, 50, 50,50); } /* UI mode */ else { DE_BE_Set_Enhance_ex(screen_id, 0,DISP_COLOR_RANGE_0_255, 0,50, 50, 50,50); } IEP_Drc_Enable(screen_id,TRUE); bsp_disp_cfg_finish(screen_id); gdisp.screen[screen_id].drc.enable = 1; } else if((0 == en) && (1 == drc->enable)) { bsp_disp_cfg_start(screen_id); IEP_Drc_Enable(screen_id,en); /* video mode */ if(drc->mode == IEP_DRC_MODE_VIDEO) { //todo? change to RGB output DE_BE_Set_Enhance_ex(screen_id, 0,DISP_COLOR_RANGE_0_255, 0,50, 50, 50,50); } bsp_disp_cfg_finish(screen_id); gdisp.screen[screen_id].drc.enable = 0; } return DIS_SUCCESS; } return DIS_NOT_SUPPORT; }
__s32 Scaler_Release(__u32 scaler_index, __bool b_display) { __u32 screen_index = 0xff; __bool b_display_off = TRUE; DE_INF("Scaler_Release:%d\n", scaler_index); DE_SCAL_Set_Di_Ctrl(scaler_index, 0, 0, 0, 0); screen_index = gdisp.scaler[scaler_index].screen_index; if((screen_index != 0xff) && (bsp_disp_get_output_type(screen_index) != DISP_OUTPUT_TYPE_NONE)) { b_display_off = FALSE; } if((b_display == FALSE) || b_display_off) { Scaler_close(scaler_index); } else { gdisp.scaler[scaler_index].b_close = TRUE; } return DIS_SUCCESS; }
long disp_ioctl(void *hd, unsigned int cmd, void *arg) { unsigned long karg[4]; unsigned long ubuffer[4] = {0}; s32 ret = 0; int num_screens = 2; num_screens = bsp_disp_feat_get_num_screens(); if (copy_from_user((void*)karg,(void*)arg, 4*sizeof(unsigned long))) { __wrn("copy_from_user fail\n"); return -1; } ubuffer[0] = *(unsigned long*)karg; ubuffer[1] = (*(unsigned long*)(karg+1)); ubuffer[2] = (*(unsigned long*)(karg+2)); ubuffer[3] = (*(unsigned long*)(karg+3)); if(cmd < DISP_CMD_FB_REQUEST) { if(ubuffer[0] >= num_screens) { __wrn("para err in disp_ioctl, cmd = 0x%x,screen id = %d\n", cmd, (int)ubuffer[0]); return -1; } } if(DISPLAY_DEEP_SLEEP == suspend_status) { __wrn("ioctl:%x fail when in suspend!\n", cmd); return -1; } if(cmd == disp_cmd_print) { // OSAL_PRINTF("cmd:0x%x,%ld,%ld\n",cmd, ubuffer[0], ubuffer[1]); } switch(cmd) { //----disp global---- case DISP_CMD_SET_BKCOLOR: { disp_color_info para; if(copy_from_user(¶, (void*)ubuffer[1],sizeof(disp_color_info))) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_set_back_color(ubuffer[0], ¶); break; } case DISP_CMD_GET_OUTPUT_TYPE: if(DISPLAY_NORMAL == suspend_status) { ret = bsp_disp_get_output_type(ubuffer[0]); } else { ret = suspend_output_type[ubuffer[0]]; } if(DISP_OUTPUT_TYPE_LCD == ret) { ret = bsp_disp_get_lcd_output_type(ubuffer[0]); } break; case DISP_CMD_GET_SCN_WIDTH: ret = bsp_disp_get_screen_width(ubuffer[0]); break; case DISP_CMD_GET_SCN_HEIGHT: ret = bsp_disp_get_screen_height(ubuffer[0]); break; case DISP_CMD_SHADOW_PROTECT: ret = bsp_disp_shadow_protect(ubuffer[0], ubuffer[1]); break; case DISP_CMD_VSYNC_EVENT_EN: ret = bsp_disp_vsync_event_enable(ubuffer[0], ubuffer[1]); break; //----layer---- case DISP_CMD_LAYER_ENABLE: ret = bsp_disp_layer_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_DISABLE: ret = bsp_disp_layer_disable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_INFO: { disp_layer_info para; if(copy_from_user(¶, (void*)ubuffer[2],sizeof(disp_layer_info))) { return -1; } ret = bsp_disp_layer_set_info(ubuffer[0], ubuffer[1], ¶); break; } case DISP_CMD_LAYER_GET_INFO: { disp_layer_info para; ret = bsp_disp_layer_get_info(ubuffer[0], ubuffer[1], ¶); if(copy_to_user((void*)ubuffer[2],¶, sizeof(disp_layer_info))) { __wrn("copy_to_user fail\n"); return -1; } break; } case DISP_CMD_LAYER_GET_FRAME_ID: ret = bsp_disp_layer_get_frame_id(ubuffer[0], ubuffer[1]); break; //----lcd---- case DISP_CMD_LCD_ENABLE: ret = drv_lcd_enable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_LCD; break; case DISP_CMD_LCD_DISABLE: ret = drv_lcd_disable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; break; case DISP_CMD_LCD_SET_BRIGHTNESS: ret = bsp_disp_lcd_set_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LCD_GET_BRIGHTNESS: ret = bsp_disp_lcd_get_bright(ubuffer[0]); break; case DISP_CMD_LCD_BACKLIGHT_ENABLE: if(DISPLAY_NORMAL == suspend_status) { ret = bsp_disp_lcd_backlight_enable(ubuffer[0]); } break; case DISP_CMD_LCD_BACKLIGHT_DISABLE: if(DISPLAY_NORMAL == suspend_status) { ret = bsp_disp_lcd_backlight_disable(ubuffer[0]); } break; #if (defined CONFIG_ARCH_SUN9IW1P1) //----hdmi---- case DISP_CMD_HDMI_ENABLE: ret = bsp_disp_hdmi_enable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_HDMI; break; case DISP_CMD_HDMI_DISABLE: ret = bsp_disp_hdmi_disable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; break; case DISP_CMD_HDMI_SET_MODE: ret = bsp_disp_hdmi_set_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_HDMI_GET_MODE: ret = bsp_disp_hdmi_get_mode(ubuffer[0]); break; case DISP_CMD_HDMI_SUPPORT_MODE: ret = bsp_disp_hdmi_check_support_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_HDMI_GET_HPD_STATUS: ret = bsp_disp_hdmi_get_hpd_status(ubuffer[0]); break; #endif #if 0 case DISP_CMD_HDMI_SUPPORT_MODE: ret = bsp_disp_hdmi_check_support_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_HDMI_SET_SRC: ret = bsp_disp_hdmi_set_src(ubuffer[0], (disp_lcd_src)ubuffer[1]); break; //----framebuffer---- case DISP_CMD_FB_REQUEST: { disp_fb_create_info para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(disp_fb_create_info))) { __wrn("copy_from_user fail\n"); return -1; } ret = Display_Fb_Request(ubuffer[0], ¶); break; } case DISP_CMD_FB_RELEASE: ret = Display_Fb_Release(ubuffer[0]); break; case DISP_CMD_FB_GET_PARA: { disp_fb_create_info para; ret = Display_Fb_get_para(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1],¶, sizeof(disp_fb_create_info))) { __wrn("copy_to_user fail\n"); return -1; } break; } case DISP_CMD_GET_DISP_INIT_PARA: { disp_init_para para; ret = Display_get_disp_init_para(¶); if(copy_to_user((void __user *)ubuffer[0],¶, sizeof(disp_init_para))) { __wrn("copy_to_user fail\n"); return -1; } break; } #endif //----enhance---- case DISP_CMD_SET_BRIGHT: ret = bsp_disp_smcl_set_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_BRIGHT: ret = bsp_disp_smcl_get_bright(ubuffer[0]); break; case DISP_CMD_SET_CONTRAST: ret = bsp_disp_smcl_set_contrast(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_CONTRAST: ret = bsp_disp_smcl_get_contrast(ubuffer[0]); break; case DISP_CMD_SET_SATURATION: ret = bsp_disp_smcl_set_saturation(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_SATURATION: ret = bsp_disp_smcl_get_saturation(ubuffer[0]); break; case DISP_CMD_SET_HUE: ret = bsp_disp_smcl_set_hue(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_HUE: ret = bsp_disp_smcl_get_hue(ubuffer[0]); break; case DISP_CMD_ENHANCE_ENABLE: ret = bsp_disp_smcl_enable(ubuffer[0]); break; case DISP_CMD_ENHANCE_DISABLE: ret = bsp_disp_smcl_disable(ubuffer[0]); break; case DISP_CMD_GET_ENHANCE_EN: ret = bsp_disp_smcl_is_enabled(ubuffer[0]); break; case DISP_CMD_SET_ENHANCE_MODE: ret = bsp_disp_smcl_set_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_ENHANCE_MODE: ret = bsp_disp_smcl_get_mode(ubuffer[0]); break; case DISP_CMD_SET_ENHANCE_WINDOW: { disp_window para; if(copy_from_user(¶, (void*)ubuffer[1],sizeof(disp_window))) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_smcl_set_window(ubuffer[0], ¶); break; } case DISP_CMD_GET_ENHANCE_WINDOW: { disp_window para; ret = bsp_disp_smcl_get_window(ubuffer[0], ¶); if(copy_to_user((void*)ubuffer[1],¶, sizeof(disp_window))) { __wrn("copy_to_user fail\n"); return -1; } break; } case DISP_CMD_DRC_ENABLE: ret = bsp_disp_smbl_enable(ubuffer[0]); break; case DISP_CMD_DRC_DISABLE: ret = bsp_disp_smbl_disable(ubuffer[0]); break; case DISP_CMD_GET_DRC_EN: ret = bsp_disp_smbl_is_enabled(ubuffer[0]); break; case DISP_CMD_DRC_SET_WINDOW: { disp_window para; if(copy_from_user(¶, (void*)ubuffer[1],sizeof(disp_window))) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_smbl_set_window(ubuffer[0], ¶); break; } case DISP_CMD_DRC_GET_WINDOW: { disp_window para; ret = bsp_disp_smbl_get_window(ubuffer[0], ¶); if(copy_to_user((void*)ubuffer[1],¶, sizeof(disp_window))) { __wrn("copy_to_user fail\n"); return -1; } break; } #if defined(CONFIG_ARCH_SUN9IW1P1) //---- cursor ---- case DISP_CMD_CURSOR_ENABLE: ret = bsp_disp_cursor_enable(ubuffer[0]); break; case DISP_CMD_CURSOR_DISABLE: ret = bsp_disp_cursor_disable(ubuffer[0]); break; case DISP_CMD_CURSOR_SET_POS: { disp_position para; if(copy_from_user(¶, (void*)ubuffer[1],sizeof(disp_position))) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_cursor_set_pos(ubuffer[0], ¶); break; } case DISP_CMD_CURSOR_GET_POS: { disp_position para; ret = bsp_disp_cursor_get_pos(ubuffer[0], ¶); if(copy_to_user((void*)ubuffer[1],¶, sizeof(disp_position))) { __wrn("copy_to_user fail\n"); return -1; } break; } case DISP_CMD_CURSOR_SET_FB: { disp_cursor_fb para; if(copy_from_user(¶, (void*)ubuffer[1],sizeof(disp_cursor_fb))) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_cursor_set_fb(ubuffer[0], ¶); break; } case DISP_CMD_CURSOR_SET_PALETTE: if((ubuffer[1] == 0) || ((int)ubuffer[3] <= 0)) { __wrn("para invalid in display ioctrl DISP_CMD_HWC_SET_PALETTE_TABLE,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[3]); return -1; } if(copy_from_user(gbuffer, (void*)ubuffer[1],ubuffer[3])) { __wrn("copy_from_user fail\n"); return -1; } ret = bsp_disp_cursor_set_palette(ubuffer[0], (void*)gbuffer, ubuffer[2], ubuffer[3]); break; #if 0 //----for test---- case DISP_CMD_MEM_REQUEST: ret = disp_mem_request(ubuffer[0],ubuffer[1]); break; case DISP_CMD_MEM_RELEASE: ret = disp_mem_release(ubuffer[0]); break; case DISP_CMD_MEM_SELIDX: g_disp_mm_sel = ubuffer[0]; break; case DISP_CMD_MEM_GETADR: ret = g_disp_mm[ubuffer[0]].mem_start; break; // case DISP_CMD_PRINT_REG: // ret = bsp_disp_print_reg(1, ubuffer[0], 0); // break; #endif #endif case DISP_CMD_SET_EXIT_MODE: ret = g_disp_drv.exit_mode = ubuffer[0]; break; case DISP_CMD_LCD_CHECK_OPEN_FINISH: ret = drv_lcd_check_open_finished(ubuffer[0]); break; case DISP_CMD_LCD_CHECK_CLOSE_FINISH: ret = drv_lcd_check_close_finished(ubuffer[0]); break; #if defined(CONFIG_ARCH_TV) //----for tv ---- case DISP_CMD_TV_ON: #if defined(CONFIG_ARCH_SUN9IW1P1) ret = drv_lcd_enable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_LCD; #endif break; case DISP_CMD_TV_OFF: #if defined(CONFIG_ARCH_SUN9IW1P1) ret = drv_lcd_disable(ubuffer[0]); suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; #endif break; case DISP_CMD_TV_GET_MODE: #if defined(CONFIG_ARCH_SUN9IW1P1) ret = bsp_disp_lcd_get_tv_mode(ubuffer[0]); #endif break; case DISP_CMD_TV_SET_MODE: #if defined(CONFIG_ARCH_SUN9IW1P1) ret = bsp_disp_lcd_set_tv_mode(ubuffer[0], ubuffer[1]); #endif break; #endif //#if defined(CONFIG_ARCH_TV) default: break; } return ret; }
void LCD_vbi_event_proc(__u32 screen_id, __u32 tcon_index) { __u32 cur_line = 0, start_delay = 0; __u32 i = 0; __u32 num_scalers; #ifdef __LINUX_OSAL__ unsigned long flags; #endif num_scalers = bsp_disp_feat_get_num_scalers(); disp_vint_checkin(screen_id); disp_lcd_set_fps(screen_id); Video_Operation_In_Vblanking(screen_id, tcon_index); disp_capture_screen_proc(screen_id); cur_line = TCON_get_cur_line(screen_id, tcon_index); start_delay = TCON_get_start_delay(screen_id, tcon_index); if(cur_line > start_delay-4) { //DE_INF("int:%d,%d\n", cur_line,start_delay); /* return while not trigger mode */ if(gpanel_info[screen_id].lcd_fresh_mode == 0) { return ; } } #ifdef __LINUX_OSAL__ spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags); #endif if(gdisp.screen[screen_id].cache_flag == FALSE && gdisp.screen[screen_id].cfg_cnt == 0) { gdisp.screen[screen_id].have_cfg_reg = TRUE; #ifdef __LINUX_OSAL__ spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif DE_BE_Cfg_Ready(screen_id); IEP_CMU_Operation_In_Vblanking(screen_id); for(i=0; i<num_scalers; i++) { if((gdisp.scaler[i].status & SCALER_USED) && (gdisp.scaler[i].screen_index == screen_id)) { __u32 hid; if(gdisp.scaler[i].b_close == TRUE) { Scaler_close(i); gdisp.scaler[i].b_close = FALSE; } else { hid = gdisp.scaler[i].layer_id; DE_SCAL_Set_Reg_Rdy(i); //DE_SCAL_Reset(i); //DE_SCAL_Start(i); disp_deu_set_frame_info(screen_id, IDTOHAND(hid)); disp_deu_output_select(screen_id, IDTOHAND(hid), screen_id); IEP_Deu_Operation_In_Vblanking(i); } gdisp.scaler[i].b_reg_change = FALSE; } } if(DISP_OUTPUT_TYPE_LCD == bsp_disp_get_output_type(screen_id)) { IEP_Drc_Operation_In_Vblanking(screen_id); } if(gdisp.init_para.take_effect) { gdisp.init_para.take_effect(screen_id); } } else { #ifdef __LINUX_OSAL__ spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif } #if 0 cur_line = LCDC_get_cur_line(screen_id, tcon_index); if(cur_line > 5) { DE_INF("%d\n", cur_line); } #endif return ; }
void sync_event_proc(u32 screen_id) { u32 cur_line = 0, start_delay = 0; #if defined(__LINUX_PLAT__) unsigned long flags; #endif bsp_disp_layer_deinterlace_cfg(screen_id);//de-interlace reg-config #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(CONFIG_ARCH_SUN9IW1P1) if(screen_id < 2) { cur_line = disp_al_lcd_get_cur_line(screen_id); start_delay = disp_al_lcd_get_start_delay(screen_id); if(cur_line > start_delay-4) { fcount_data.skip_count[screen_id] ++; return ; } } #else if(screen_id < 2) { if(disp_al_lcd_check_time(screen_id, 200)) { fcount_data.skip_count[screen_id] ++; return ; } } #endif #if defined(__LINUX_PLAT__) spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags); #endif if(0 == bsp_disp_cfg_get(screen_id)) { gdisp.screen[screen_id].have_cfg_reg = true; #if defined(__LINUX_PLAT__) spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif disp_sync_all(screen_id); } else { #if defined(__LINUX_PLAT__) spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif } if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) { struct disp_lcd* m_lcd = NULL; static disp_panel_para m_info; m_lcd = disp_get_lcd(screen_id); if(NULL != m_lcd) { memset(&m_info, 0, sizeof(disp_panel_para)); if(m_lcd->get_panel_info) m_lcd->get_panel_info(m_lcd, &m_info); if(LCD_IF_EDP != m_info.lcd_if) { cur_line = disp_al_lcd_get_cur_line(screen_id); start_delay = disp_al_lcd_get_start_delay(screen_id); if(cur_line >= (start_delay-1)) printk("LCD:%d\n", cur_line); } } } return ; }
s32 bsp_disp_shadow_protect(u32 screen_id, bool protect) { s32 ret = -1; u32 cnt = 0; u32 max_cnt = 50; u32 delay = 10;//us disp_video_timing tt; #ifdef __LINUX_PLAT__ unsigned long flags; #endif 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 fail\n", screen_id); } if(lcd && lcd->get_timing) { u32 load_reg_time; u32 start_delay; u32 fps; lcd->get_timing(lcd, &tt); start_delay = disp_al_lcd_get_start_delay(screen_id); start_delay = (0 == start_delay)? 32:start_delay; fps = tt.pixel_clk*1000/(tt.ver_total_time*tt.hor_total_time); fps = (0 == fps)? 60:fps; load_reg_time = (1*1000*1000)/(fps*tt.ver_total_time)*start_delay; max_cnt = load_reg_time/delay + 1; max_cnt = max_cnt * 2; } } else if(DISP_OUTPUT_TYPE_HDMI == bsp_disp_get_output_type(screen_id)) { //FIXME } if(protect) { while((0 != ret) && (cnt < max_cnt)) { #ifdef __LINUX_PLAT__ spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags); #endif cnt ++; if(gdisp.screen[screen_id].have_cfg_reg == false) { gdisp.screen[screen_id].cfg_cnt++; ret = 0; } #ifdef __LINUX_PLAT__ spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif if(0 != ret) bsp_disp_delay_us(delay); } if(0 != ret) { DE_INF("wait for reg load finish time out\n"); #if defined(__LINUX_PLAT__) spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags); #endif gdisp.screen[screen_id].cfg_cnt++; #if defined(__LINUX_PLAT__) spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif } } else { #if defined(__LINUX_PLAT__) spin_lock_irqsave(&gdisp.screen[screen_id].flag_lock, flags); #endif gdisp.screen[screen_id].cfg_cnt--; #if defined(__LINUX_PLAT__) spin_unlock_irqrestore(&gdisp.screen[screen_id].flag_lock, flags); #endif } return DIS_SUCCESS; }
static ssize_t disp_sys_status_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; int num_screens, screen_id; int num_layers, layer_id; num_screens = bsp_disp_feat_get_num_screens(); for(screen_id=0; screen_id < num_screens; screen_id ++) { count += sprintf(buf + count, "screen %d:\n", screen_id); /* output */ if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) { count += sprintf(buf + count, "\tlcd output\tbacklight(%3d)", bsp_disp_lcd_get_bright(screen_id)); } else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) { count += sprintf(buf + count, "\thdmi output"); if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_720P_50HZ) { count += sprintf(buf + count, "%16s", "720p50hz"); } else if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_720P_60HZ) { count += sprintf(buf + count, "%16s", "720p60hz"); } else if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080P_60HZ) { count += sprintf(buf + count, "%16s", "1080p60hz"); } else if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080P_50HZ) { count += sprintf(buf + count, "%16s", "1080p50hz"); } else if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080I_50HZ) { count += sprintf(buf + count, "%16s", "1080i50hz"); } else if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080I_60HZ) { count += sprintf(buf + count, "%16s", "1080i60hz"); } } if(bsp_disp_get_output_type(screen_id) != DISP_OUTPUT_TYPE_NONE) { count += sprintf(buf + count, "\t%4dx%4d", bsp_disp_get_screen_width(screen_id), bsp_disp_get_screen_height(screen_id)); count += sprintf(buf + count, "\tfps(%3d.%1d)", bsp_disp_get_fps(screen_id)/10, bsp_disp_get_fps(screen_id)%10); count += sprintf(buf + count, "\n"); } /* hdmi hpd */ if((bsp_disp_feat_get_supported_output_types(screen_id) & DISP_OUTPUT_TYPE_HDMI)) { int hpd; hpd = bsp_disp_hdmi_get_hpd_status(screen_id); count += sprintf(buf + count, "\t%11s\n", hpd? "hdmi plugin":"hdmi unplug"); } count += sprintf(buf + count, " type | status | id | pipe | z | pre_mult | alpha | colorkey | format | framebuffer | source crop | frame | trd | address\n"); count += sprintf(buf + count, "----------+---------+----+------+---+----------+------------+----------+----------+-------------+-----------------------+-----------------------+---------+-----------------------------\n"); num_layers = bsp_disp_feat_get_num_layers(screen_id); /* layer info */ for(layer_id=0; layer_id<num_layers; layer_id++) { __disp_layer_info_t layer_para; int ret; ret = bsp_disp_layer_get_para(screen_id, IDTOHAND(layer_id), &layer_para); if(ret == 0) { count += sprintf(buf + count, " %8s |", (layer_para.mode == DISP_LAYER_WORK_MODE_SCALER)? "SCALER":"NORAML"); count += sprintf(buf + count, " %7s |", bsp_disp_layer_is_open(screen_id, IDTOHAND(layer_id))?"enable":"disable"); count += sprintf(buf + count, " %2d |", layer_id); count += sprintf(buf + count, " %4d |", layer_para.pipe); count += sprintf(buf + count, " %1d |", layer_para.prio); count += sprintf(buf + count, " %8s |", (layer_para.fb.pre_multiply)? "Y":"N"); count += sprintf(buf + count, " %5s(%3d) |", (layer_para.alpha_en)? "globl":"pixel", layer_para.alpha_val); count += sprintf(buf + count, " %8s |", (layer_para.ck_enable)? "enable":"disable"); count += sprintf(buf + count, " %2d,%2d,%2d |", layer_para.fb.mode, layer_para.fb.format, layer_para.fb.seq); count += sprintf(buf + count, " [%4d,%4d] |", layer_para.fb.size.width, layer_para.fb.size.height); count += sprintf(buf + count, " [%4d,%4d,%4d,%4d] |", layer_para.src_win.x, layer_para.src_win.y, layer_para.src_win.width, layer_para.src_win.height); count += sprintf(buf + count, " [%4d,%4d,%4d,%4d] |", layer_para.scn_win.x, layer_para.scn_win.y, layer_para.scn_win.width, layer_para.scn_win.height); count += sprintf(buf + count, " [%1d%1d,%1d%1d] |", layer_para.fb.b_trd_src, layer_para.fb.trd_mode, layer_para.b_trd_out, layer_para.out_trd_mode); count += sprintf(buf + count, " [%8x,%8x,%8x]", layer_para.fb.addr[0], layer_para.fb.addr[1], layer_para.fb.addr[2]); count += sprintf(buf + count, "\n"); } } if(bsp_disp_feat_get_smart_backlight_support(screen_id)) { __disp_rect_t window; count += sprintf(buf + count, "\n\tsmart backlight: %s", bsp_disp_drc_get_enable(screen_id)? "enable":"disable"); if(bsp_disp_drc_get_enable(screen_id)) { bsp_disp_drc_get_window(screen_id, &window); count += sprintf(buf + count, "\twindow[%4d,%4d,%4d,%4d]", window.x, window.y, window.width, window.height); } count += sprintf(buf + count, "\n"); } } return count; }
__s32 bsp_disp_deu_enable(__u8 screen_id, __u32 hid, __u32 enable) { __layer_man_t * layer_man; __scal_out_type_t out_type; hid= HANDTOID(hid); HLID_ASSERT(hid, gdisp.screen[screen_id].max_layers); layer_man = &gdisp.screen[screen_id].layer_manage[hid]; if((layer_man->status & LAYER_USED) && (layer_man->para.mode == DISP_LAYER_WORK_MODE_SCALER)) { if((bsp_disp_feat_get_layer_feats(screen_id, DISP_LAYER_WORK_MODE_SCALER, layer_man->scaler_index) & DISP_LAYER_FEAT_DETAIL_ENHANCE)) { __disp_scaler_t * scaler; scaler = &(gdisp.scaler[layer_man->scaler_index]); if((enable == 1) && (!gdisp.scaler[layer_man->scaler_index].deu.enable)) { disp_deu_set_frame_info(screen_id, IDTOHAND(hid)); IEP_Deu_Set_Luma_Sharpness_Level(layer_man->scaler_index, scaler->deu.luma_sharpe_level); IEP_Deu_Set_Chroma_Sharpness_Level(layer_man->scaler_index, scaler->deu.chroma_sharpe_level); IEP_Deu_Set_Black_Level_Extension(layer_man->scaler_index, scaler->deu.black_exten_level); IEP_Deu_Set_White_Level_Extension(layer_man->scaler_index, scaler->deu.while_exten_level); bsp_disp_cfg_start(screen_id); //Scaler_Set_Para(layer_man->scaler_index,scaler); { scaler->out_fb.mode = DISP_MOD_NON_MB_PLANAR; scaler->out_fb.seq = DISP_SEQ_P3210; scaler->out_fb.format= DISP_FORMAT_YUV444; if(get_fb_type(scaler->out_fb.format) == DISP_FB_TYPE_YUV) { if(scaler->out_fb.mode == DISP_MOD_NON_MB_PLANAR) { out_type.fmt = Scaler_sw_para_to_reg(3, scaler->out_fb.mode, scaler->out_fb.format, scaler->out_fb.seq); } else { DE_WRN("output mode:%d invalid in bsp_disp_deu_enable\n",scaler->out_fb.mode); return DIS_FAIL; } } else { if(scaler->out_fb.mode == DISP_MOD_NON_MB_PLANAR && (scaler->out_fb.format == DISP_FORMAT_RGB888 || scaler->out_fb.format == DISP_FORMAT_ARGB8888)) { out_type.fmt = DE_SCAL_OUTPRGB888; } else if(scaler->out_fb.mode == DISP_MOD_INTERLEAVED && scaler->out_fb.format == DISP_FORMAT_ARGB8888 && scaler->out_fb.seq == DISP_SEQ_ARGB) { out_type.fmt = DE_SCAL_OUTI1RGB888; } else if(scaler->out_fb.mode == DISP_MOD_INTERLEAVED && scaler->out_fb.format == DISP_FORMAT_ARGB8888 && scaler->out_fb.seq == DISP_SEQ_BGRA) { out_type.fmt = DE_SCAL_OUTI0RGB888; } else { DE_WRN("output para invalid in bsp_disp_deu_enable,mode:%d,format:%d\n",scaler->out_fb.mode, scaler->out_fb.format); return DIS_FAIL; } } out_type.byte_seq = Scaler_sw_para_to_reg(2,scaler->out_fb.mode, scaler->out_fb.format, scaler->out_fb.seq); out_type.alpha_en = 1; out_type.alpha_coef_type = 0; DE_SCAL_Set_CSC_Coef(layer_man->scaler_index, scaler->in_fb.cs_mode, DISP_BT601, get_fb_type(scaler->in_fb.format), get_fb_type(scaler->out_fb.format), scaler->in_fb.br_swap, 0); DE_SCAL_Set_Out_Format(layer_man->scaler_index, &out_type); } IEP_Deu_Enable(layer_man->scaler_index, enable); bsp_disp_cfg_finish(screen_id); } else if((enable == 0) && (gdisp.scaler[layer_man->scaler_index].deu.enable)) { bsp_disp_cfg_start(screen_id); //Scaler_Set_Para(layer_man->scaler_index,scaler); { scaler->out_fb.mode = DISP_MOD_INTERLEAVED; scaler->out_fb.seq= DISP_SEQ_ARGB; scaler->out_fb.format= DISP_FORMAT_ARGB8888; if(get_fb_type(scaler->out_fb.format) == DISP_FB_TYPE_YUV) { if(scaler->out_fb.mode == DISP_MOD_NON_MB_PLANAR) { out_type.fmt = Scaler_sw_para_to_reg(3, scaler->out_fb.mode, scaler->out_fb.format, scaler->out_fb.seq); } else { DE_WRN("output mode:%d invalid in bsp_disp_deu_enable\n",scaler->out_fb.mode); return DIS_FAIL; } } else { if(scaler->out_fb.mode == DISP_MOD_NON_MB_PLANAR && (scaler->out_fb.format == DISP_FORMAT_RGB888 || scaler->out_fb.format == DISP_FORMAT_ARGB8888)) { out_type.fmt = DE_SCAL_OUTPRGB888; } else if(scaler->out_fb.mode == DISP_MOD_INTERLEAVED && scaler->out_fb.format == DISP_FORMAT_ARGB8888 && scaler->out_fb.seq == DISP_SEQ_ARGB) { out_type.fmt = DE_SCAL_OUTI1RGB888; } else if(scaler->out_fb.mode == DISP_MOD_INTERLEAVED && scaler->out_fb.format == DISP_FORMAT_ARGB8888 && scaler->out_fb.seq == DISP_SEQ_BGRA) { out_type.fmt = DE_SCAL_OUTI0RGB888; } else { DE_WRN("output para invalid in bsp_disp_deu_enable,mode:%d,format:%d\n",scaler->out_fb.mode, scaler->out_fb.format); return DIS_FAIL; } } out_type.byte_seq = Scaler_sw_para_to_reg(2,scaler->out_fb.mode, scaler->out_fb.format, scaler->out_fb.seq); out_type.alpha_en = 1; out_type.alpha_coef_type = 0; DE_SCAL_Set_CSC_Coef(layer_man->scaler_index, scaler->in_fb.cs_mode, DISP_BT601, get_fb_type(scaler->in_fb.format), get_fb_type(scaler->out_fb.format), scaler->in_fb.br_swap, 0); DE_SCAL_Set_Out_Format(layer_man->scaler_index, &out_type); } enable = (bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_NONE)? 2:0; IEP_Deu_Enable(layer_man->scaler_index, enable); bsp_disp_cfg_finish(screen_id); } gdisp.scaler[layer_man->scaler_index].deu.enable = enable; return DIS_SUCCESS; } } return DIS_NOT_SUPPORT; }
long disp_ioctl(void *hd, unsigned int cmd, void *arg) { unsigned long karg[4]; unsigned long ubuffer[4] = {0}; __s32 ret = 0; if(!display_opens) { printf("de not open\n"); return -1; } if (copy_from_user((void*)karg,(void __user*)arg,4*sizeof(unsigned long))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ubuffer[0] = *(unsigned long*)karg; ubuffer[1] = (*(unsigned long*)(karg+1)); ubuffer[2] = (*(unsigned long*)(karg+2)); ubuffer[3] = (*(unsigned long*)(karg+3)); if(cmd < DISP_CMD_FB_REQUEST) { if((ubuffer[0] != 0) && (ubuffer[0] != 1)) { __wrn("para err in disp_ioctl, cmd = 0x%x,screen id = %d\n", cmd, (int)ubuffer[0]); return -1; } } if(suspend_status & 2) { __wrn("ioctl:%x fail when in suspend!\n", cmd); return -1; } #if 0 if(cmd!=DISP_CMD_TV_GET_INTERFACE && cmd!=DISP_CMD_HDMI_GET_HPD_STATUS && cmd!=DISP_CMD_GET_OUTPUT_TYPE && cmd!=DISP_CMD_SCN_GET_WIDTH && cmd!=DISP_CMD_SCN_GET_HEIGHT && cmd!=DISP_CMD_VIDEO_SET_FB && cmd!=DISP_CMD_VIDEO_GET_FRAME_ID) { OSAL_PRINTF("cmd:0x%x,%ld,%ld\n",cmd, ubuffer[0], ubuffer[1]); } #endif switch(cmd) { //----disp global---- case DISP_CMD_SET_BKCOLOR: { __disp_color_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_color_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_set_bk_color(ubuffer[0], ¶); break; } case DISP_CMD_SET_COLORKEY: { __disp_colorkey_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_colorkey_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_set_color_key(ubuffer[0], ¶); break; } case DISP_CMD_SET_PALETTE_TBL: if((ubuffer[1] == 0) || ((int)ubuffer[3] <= 0)) { __wrn("para invalid in disp ioctrl DISP_CMD_SET_PALETTE_TBL,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[3]); return -1; } if(copy_from_user(gbuffer, (void __user *)ubuffer[1],ubuffer[3])) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_set_palette_table(ubuffer[0], (__u32 *)gbuffer, ubuffer[2], ubuffer[3]); break; case DISP_CMD_GET_PALETTE_TBL: if((ubuffer[1] == 0) || ((int)ubuffer[3] <= 0)) { __wrn("para invalid in disp ioctrl DISP_CMD_GET_PALETTE_TBL,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[3]); return -1; } ret = bsp_disp_get_palette_table(ubuffer[0], (__u32 *)gbuffer, ubuffer[2], ubuffer[3]); if(copy_to_user((void __user *)ubuffer[1], gbuffer,ubuffer[3])) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; case DISP_CMD_START_CMD_CACHE: ret = bsp_disp_cmd_cache(ubuffer[0]); break; case DISP_CMD_EXECUTE_CMD_AND_STOP_CACHE: ret = bsp_disp_cmd_submit(ubuffer[0]); break; case DISP_CMD_GET_OUTPUT_TYPE: ret = bsp_disp_get_output_type(ubuffer[0]); break; case DISP_CMD_SCN_GET_WIDTH: ret = bsp_disp_get_screen_width(ubuffer[0]); break; case DISP_CMD_SCN_GET_HEIGHT: ret = bsp_disp_get_screen_height(ubuffer[0]); break; case DISP_CMD_SET_GAMMA_TABLE: if((ubuffer[1] == 0) || ((int)ubuffer[2] <= 0)) { __wrn("para invalid in disp ioctrl DISP_CMD_SET_GAMMA_TABLE,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[2]); return -1; } if(copy_from_user(gbuffer, (void __user *)ubuffer[1],ubuffer[2])) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_set_gamma_table(ubuffer[0], (__u32 *)gbuffer, ubuffer[2]); break; case DISP_CMD_GAMMA_CORRECTION_ON: ret = bsp_disp_gamma_correction_enable(ubuffer[0]); break; case DISP_CMD_GAMMA_CORRECTION_OFF: ret = bsp_disp_gamma_correction_disable(ubuffer[0]); break; case DISP_CMD_SET_BRIGHT: ret = bsp_disp_cmu_set_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_BRIGHT: ret = bsp_disp_cmu_get_bright(ubuffer[0]); break; case DISP_CMD_SET_CONTRAST: ret = bsp_disp_cmu_set_contrast(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_CONTRAST: ret = bsp_disp_cmu_get_contrast(ubuffer[0]); break; case DISP_CMD_SET_SATURATION: ret = bsp_disp_cmu_set_saturation(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_SATURATION: ret = bsp_disp_cmu_get_saturation(ubuffer[0]); break; case DISP_CMD_SET_HUE: ret = bsp_disp_cmu_set_hue(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_HUE: ret = bsp_disp_cmu_get_hue(ubuffer[0]); break; case DISP_CMD_ENHANCE_ON: ret = bsp_disp_cmu_enable(ubuffer[0], 1); break; case DISP_CMD_ENHANCE_OFF: ret = bsp_disp_cmu_enable(ubuffer[0], 0); break; case DISP_CMD_GET_ENHANCE_EN: ret = bsp_disp_cmu_get_enable(ubuffer[0]); break; case DISP_CMD_SET_ENHANCE_MODE: ret = bsp_disp_cmu_set_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_ENHANCE_MODE: ret = bsp_disp_cmu_get_mode(ubuffer[0]); break; case DISP_CMD_SET_ENHANCE_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_cmu_set_window(ubuffer[0], ¶); break; } case DISP_CMD_GET_ENHANCE_WINDOW: { __disp_rect_t para; ret = bsp_disp_cmu_get_window(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1],¶, sizeof(__disp_layer_info_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_CAPTURE_SCREEN: ret = bsp_disp_capture_screen(ubuffer[0], (__disp_capture_screen_para_t *)ubuffer[1]); break; case DISP_CMD_SET_SCREEN_SIZE: ret = bsp_disp_set_screen_size(ubuffer[0], (__disp_rectsz_t*)ubuffer[1]); break; case DISP_CMD_DE_FLICKER_ON: ret = bsp_disp_de_flicker_enable(ubuffer[0], 1); break; case DISP_CMD_DE_FLICKER_OFF: ret = bsp_disp_de_flicker_enable(ubuffer[0], 0); break; case DISP_CMD_DRC_ON: ret = bsp_disp_drc_enable(ubuffer[0], 1); break; case DISP_CMD_DRC_OFF: ret = bsp_disp_drc_enable(ubuffer[0], 0); break; case DISP_CMD_GET_DRC_EN: ret = bsp_disp_drc_get_enable(ubuffer[0]); break; case DISP_CMD_DRC_SET_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_drc_set_window(ubuffer[0], ¶); break; } case DISP_CMD_DRC_GET_WINDOW: { __disp_rect_t para; ret = bsp_disp_drc_get_window(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1], ¶,sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } return ret; break; } //----layer---- case DISP_CMD_LAYER_REQUEST: ret = bsp_disp_layer_request(ubuffer[0], (__disp_layer_work_mode_t)ubuffer[1]); break; case DISP_CMD_LAYER_RELEASE: ret = bsp_disp_layer_release(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_OPEN: ret = bsp_disp_layer_open(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_CLOSE: ret = bsp_disp_layer_close(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_FB: { __disp_fb_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_fb_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_layer_set_framebuffer(ubuffer[0], ubuffer[1], ¶); //DRV_disp_wait_cmd_finish(ubuffer[0]); break; } case DISP_CMD_LAYER_GET_FB: { __disp_fb_t para; ret = bsp_disp_layer_get_framebuffer(ubuffer[0], ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2], ¶,sizeof(__disp_fb_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_LAYER_SET_SRC_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_layer_set_src_window(ubuffer[0],ubuffer[1], ¶); //DRV_disp_wait_cmd_finish(ubuffer[0]); break; } case DISP_CMD_LAYER_GET_SRC_WINDOW: { __disp_rect_t para; ret = bsp_disp_layer_get_src_window(ubuffer[0],ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2], ¶, sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_LAYER_SET_SCN_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_layer_set_screen_window(ubuffer[0],ubuffer[1], ¶); //DRV_disp_wait_cmd_finish(ubuffer[0]); break; } case DISP_CMD_LAYER_GET_SCN_WINDOW: { __disp_rect_t para; ret = bsp_disp_layer_get_screen_window(ubuffer[0],ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2], ¶, sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_LAYER_SET_PARA: { __disp_layer_info_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_layer_info_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_layer_set_para(ubuffer[0], ubuffer[1], ¶); //DRV_disp_wait_cmd_finish(ubuffer[0]); break; } case DISP_CMD_LAYER_GET_PARA: { __disp_layer_info_t para; ret = bsp_disp_layer_get_para(ubuffer[0], ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_layer_info_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_LAYER_TOP: ret = bsp_disp_layer_set_top(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_BOTTOM: ret = bsp_disp_layer_set_bottom(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_ALPHA_ON: ret = bsp_disp_layer_alpha_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_ALPHA_OFF: ret = bsp_disp_layer_alpha_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_SET_ALPHA_VALUE: ret = bsp_disp_layer_set_alpha_value(ubuffer[0], ubuffer[1], ubuffer[2]); //DRV_disp_wait_cmd_finish(ubuffer[0]); break; case DISP_CMD_LAYER_CK_ON: ret = bsp_disp_layer_colorkey_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_CK_OFF: ret = bsp_disp_layer_colorkey_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_SET_PIPE: ret = bsp_disp_layer_set_pipe(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_ALPHA_VALUE: ret = bsp_disp_layer_get_alpha_value(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_GET_ALPHA_EN: ret = bsp_disp_layer_get_alpha_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_GET_CK_EN: ret = bsp_disp_layer_get_colorkey_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_GET_PRIO: ret = bsp_disp_layer_get_piro(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_GET_PIPE: ret = bsp_disp_layer_get_pipe(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_SMOOTH: ret = bsp_disp_layer_set_smooth(ubuffer[0], ubuffer[1],(__disp_video_smooth_t) ubuffer[2]); break; case DISP_CMD_LAYER_GET_SMOOTH: ret = bsp_disp_layer_get_smooth(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_BRIGHT: ret = bsp_disp_cmu_layer_set_bright(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_BRIGHT: ret = bsp_disp_cmu_layer_get_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_CONTRAST: ret = bsp_disp_cmu_layer_set_contrast(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_CONTRAST: ret = bsp_disp_cmu_layer_get_contrast(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_SATURATION: ret = bsp_disp_cmu_layer_set_saturation(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_SATURATION: ret = bsp_disp_cmu_layer_get_saturation(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_HUE: ret = bsp_disp_cmu_layer_set_hue(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_HUE: ret = bsp_disp_cmu_layer_get_hue(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_ENHANCE_ON: ret = bsp_disp_cmu_layer_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_ENHANCE_OFF: ret = bsp_disp_cmu_layer_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_GET_ENHANCE_EN: ret = bsp_disp_cmu_layer_get_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_ENHANCE_MODE: ret = bsp_disp_cmu_layer_set_mode(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_ENHANCE_MODE: ret = bsp_disp_cmu_layer_get_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_ENHANCE_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_cmu_layer_set_window(ubuffer[0], ubuffer[1], ¶); break; } case DISP_CMD_LAYER_GET_ENHANCE_WINDOW: { __disp_rect_t para; ret = bsp_disp_cmu_layer_get_window(ubuffer[0], ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_layer_info_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_LAYER_VPP_ON: ret = bsp_disp_deu_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_VPP_OFF: ret = bsp_disp_deu_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_GET_VPP_EN: ret = bsp_disp_deu_get_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_LUMA_SHARP_LEVEL: ret = bsp_disp_deu_set_luma_sharp_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_LUMA_SHARP_LEVEL: ret = bsp_disp_deu_get_luma_sharp_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_CHROMA_SHARP_LEVEL: ret = bsp_disp_deu_set_chroma_sharp_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_CHROMA_SHARP_LEVEL: ret = bsp_disp_deu_get_chroma_sharp_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_WHITE_EXTEN_LEVEL: ret = bsp_disp_deu_set_white_exten_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_WHITE_EXTEN_LEVEL: ret = bsp_disp_deu_get_white_exten_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_BLACK_EXTEN_LEVEL: ret = bsp_disp_deu_set_black_exten_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_BLACK_EXTEN_LEVEL: ret = bsp_disp_deu_get_black_exten_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_VPP_SET_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_deu_set_window(ubuffer[0], ubuffer[1], ¶); break; } case DISP_CMD_LAYER_VPP_GET_WINDOW: { __disp_rect_t para; ret = bsp_disp_deu_get_window(ubuffer[0], ubuffer[1], ¶); if(copy_to_user((void __user *)ubuffer[2], ¶,sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } return ret; break; } //----scaler---- case DISP_CMD_SCALER_REQUEST: ret = bsp_disp_scaler_request(); break; case DISP_CMD_SCALER_RELEASE: ret = bsp_disp_scaler_release(ubuffer[1]); break; case DISP_CMD_SCALER_EXECUTE: { __disp_scaler_para_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_scaler_para_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_scaler_start(ubuffer[1],¶); break; } case DISP_CMD_SCALER_EXECUTE_EX: { __disp_scaler_para_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_scaler_para_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_scaler_start_ex(ubuffer[1],¶); break; } //----hwc---- case DISP_CMD_HWC_OPEN: ret = bsp_disp_hwc_enable(ubuffer[0], 1); break; case DISP_CMD_HWC_CLOSE: ret = bsp_disp_hwc_enable(ubuffer[0], 0); break; case DISP_CMD_HWC_SET_POS: { __disp_pos_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_pos_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_hwc_set_pos(ubuffer[0], ¶); break; } case DISP_CMD_HWC_GET_POS: { __disp_pos_t para; ret = bsp_disp_hwc_get_pos(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1],¶, sizeof(__disp_pos_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_HWC_SET_FB: { __disp_hwc_pattern_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_hwc_pattern_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_hwc_set_framebuffer(ubuffer[0], ¶); break; } case DISP_CMD_HWC_SET_PALETTE_TABLE: if((ubuffer[1] == 0) || ((int)ubuffer[3] <= 0)) { __wrn("para invalid in display ioctrl DISP_CMD_HWC_SET_PALETTE_TABLE,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[3]); return -1; } if(copy_from_user(gbuffer, (void __user *)ubuffer[1],ubuffer[3])) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_hwc_set_palette(ubuffer[0], (void*)gbuffer, ubuffer[2], ubuffer[3]); break; //----video---- case DISP_CMD_VIDEO_START: ret = bsp_disp_video_start(ubuffer[0], ubuffer[1]); break; case DISP_CMD_VIDEO_STOP: ret = bsp_disp_video_stop(ubuffer[0], ubuffer[1]); break; case DISP_CMD_VIDEO_SET_FB: { __disp_video_fb_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_video_fb_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = bsp_disp_video_set_fb(ubuffer[0], ubuffer[1], ¶); break; } case DISP_CMD_VIDEO_GET_FRAME_ID: ret = bsp_disp_video_get_frame_id(ubuffer[0], ubuffer[1]); break; case DISP_CMD_VIDEO_GET_DIT_INFO: { __disp_dit_info_t para; ret = bsp_disp_video_get_dit_info(ubuffer[0], ubuffer[1],¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_dit_info_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } //----lcd---- case DISP_CMD_LCD_ON: ret = DRV_lcd_open(ubuffer[0]); output_type = DISP_OUTPUT_TYPE_LCD; if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_LCD; } break; case DISP_CMD_LCD_OFF: ret = DRV_lcd_close(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; } break; case DISP_CMD_LCD_SET_BRIGHTNESS: ret = bsp_disp_lcd_set_bright(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LCD_GET_BRIGHTNESS: ret = bsp_disp_lcd_get_bright(ubuffer[0]); break; // case DISP_CMD_LCD_CPUIF_XY_SWITCH: // ret = bsp_disp_lcd_xy_switch(ubuffer[0], ubuffer[1]); // break; case DISP_CMD_LCD_SET_SRC: ret = bsp_disp_lcd_set_src(ubuffer[0], (__disp_lcdc_src_t)ubuffer[1]); break; case DISP_CMD_LCD_USER_DEFINED_FUNC: ret = bsp_disp_lcd_user_defined_func(ubuffer[0], ubuffer[1], ubuffer[2], ubuffer[3]); break; //----tv---- case DISP_CMD_TV_ON: ret = bsp_disp_tv_open(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_TV; } break; case DISP_CMD_TV_OFF: ret = bsp_disp_tv_close(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; } break; case DISP_CMD_TV_SET_MODE: ret = bsp_disp_tv_set_mode(ubuffer[0], (__disp_tv_mode_t)ubuffer[1]); break; case DISP_CMD_TV_GET_MODE: ret = bsp_disp_tv_get_mode(ubuffer[0]); break; case DISP_CMD_TV_AUTOCHECK_ON: ret = bsp_disp_tv_auto_check_enable(ubuffer[0]); break; case DISP_CMD_TV_AUTOCHECK_OFF: ret = bsp_disp_tv_auto_check_disable(ubuffer[0]); break; case DISP_CMD_TV_GET_INTERFACE: if(suspend_status != 0) { ret = DISP_TV_NONE; } else { ret = bsp_disp_tv_get_interface(ubuffer[0]); } break; case DISP_CMD_TV_SET_SRC: ret = bsp_disp_tv_set_src(ubuffer[0], (__disp_lcdc_src_t)ubuffer[1]); break; case DISP_CMD_TV_GET_DAC_STATUS: if(suspend_status != 0) { ret = 0; } else { ret = bsp_disp_tv_get_dac_status(ubuffer[0], ubuffer[1]); } break; case DISP_CMD_TV_SET_DAC_SOURCE: ret = bsp_disp_tv_set_dac_source(ubuffer[0], ubuffer[1], (__disp_tv_dac_source)ubuffer[2]); break; case DISP_CMD_TV_GET_DAC_SOURCE: ret = bsp_disp_tv_get_dac_source(ubuffer[0], ubuffer[1]); break; //----hdmi---- case DISP_CMD_HDMI_ON: ret = bsp_disp_hdmi_open(ubuffer[0]); output_type = DISP_OUTPUT_TYPE_HDMI; if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_HDMI; } break; case DISP_CMD_HDMI_OFF: ret = bsp_disp_hdmi_close(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; } break; case DISP_CMD_HDMI_SET_MODE: ret = bsp_disp_hdmi_set_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_HDMI_GET_MODE: ret = bsp_disp_hdmi_get_mode(ubuffer[0]); break; case DISP_CMD_HDMI_GET_HPD_STATUS: if(suspend_status != 0) { ret = 0; } else { ret = bsp_disp_hdmi_get_hpd_status(ubuffer[0]); } break; case DISP_CMD_HDMI_SUPPORT_MODE: ret = bsp_disp_hdmi_check_support_mode(ubuffer[0], ubuffer[1]); break; case DISP_CMD_HDMI_SET_SRC: ret = bsp_disp_hdmi_set_src(ubuffer[0], (__disp_lcdc_src_t)ubuffer[1]); break; //----vga---- case DISP_CMD_VGA_ON: ret = bsp_disp_vga_open(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_VGA; } break; case DISP_CMD_VGA_OFF: ret = bsp_disp_vga_close(ubuffer[0]); if(suspend_status != 0) { suspend_output_type[ubuffer[0]] = DISP_OUTPUT_TYPE_NONE; } break; case DISP_CMD_VGA_SET_MODE: ret = bsp_disp_vga_set_mode(ubuffer[0], (__disp_vga_mode_t)ubuffer[1]); break; case DISP_CMD_VGA_GET_MODE: ret = bsp_disp_vga_get_mode(ubuffer[0]); break; case DISP_CMD_VGA_SET_SRC: ret = bsp_disp_vga_set_src(ubuffer[0], (__disp_lcdc_src_t)ubuffer[1]); break; //----sprite---- /* case DISP_CMD_SPRITE_OPEN: ret = bsp_disp_sprite_open(ubuffer[0]); break; case DISP_CMD_SPRITE_CLOSE: ret = bsp_disp_sprite_close(ubuffer[0]); break; case DISP_CMD_SPRITE_SET_FORMAT: ret = bsp_disp_sprite_set_format(ubuffer[0], (__disp_pixel_fmt_t)ubuffer[1], (__disp_pixel_seq_t)ubuffer[2]); break; case DISP_CMD_SPRITE_GLOBAL_ALPHA_ENABLE: ret = bsp_disp_sprite_alpha_enable(ubuffer[0]); break; case DISP_CMD_SPRITE_GLOBAL_ALPHA_DISABLE: ret = bsp_disp_sprite_alpha_disable(ubuffer[0]); break; case DISP_CMD_SPRITE_GET_GLOBAL_ALPHA_ENABLE: ret = bsp_disp_sprite_get_alpha_enable(ubuffer[0]); break; case DISP_CMD_SPRITE_SET_GLOBAL_ALPHA_VALUE: ret = bsp_disp_sprite_set_alpha_vale(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_GET_GLOBAL_ALPHA_VALUE: ret = bsp_disp_sprite_get_alpha_value(ubuffer[0]); break; case DISP_CMD_SPRITE_SET_ORDER: ret = bsp_disp_sprite_set_order(ubuffer[0], ubuffer[1],ubuffer[2]); break; case DISP_CMD_SPRITE_GET_TOP_BLOCK: ret = bsp_disp_sprite_get_top_block(ubuffer[0]); break; case DISP_CMD_SPRITE_GET_BOTTOM_BLOCK: ret = bsp_disp_sprite_get_bottom_block(ubuffer[0]); break; case DISP_CMD_SPRITE_SET_PALETTE_TBL: if((ubuffer[1] == 0) || ((int)ubuffer[3] <= 0)) { __wrn("para invalid in display ioctrl DISP_CMD_SPRITE_SET_PALETTE_TBL,buffer:0x%x, size:0x%x\n", (unsigned int)ubuffer[1], (unsigned int)ubuffer[3]); return -1; } if(copy_from_user(gbuffer, (void __user *)ubuffer[1],ubuffer[3])) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_set_palette_table(ubuffer[0], (__u32 * )gbuffer,ubuffer[2],ubuffer[3]); break; case DISP_CMD_SPRITE_GET_BLOCK_NUM: ret = bsp_disp_sprite_get_block_number(ubuffer[0]); break; case DISP_CMD_SPRITE_BLOCK_REQUEST: { __disp_sprite_block_para_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_sprite_block_para_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_block_request(ubuffer[0], ¶); break; } case DISP_CMD_SPRITE_BLOCK_RELEASE: ret = bsp_disp_sprite_block_release(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_SET_SCREEN_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_block_set_screen_win(ubuffer[0], ubuffer[1],¶); break; } case DISP_CMD_SPRITE_BLOCK_GET_SCREEN_WINDOW: { __disp_rect_t para; ret = bsp_disp_sprite_block_get_srceen_win(ubuffer[0], ubuffer[1],¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_SPRITE_BLOCK_SET_SOURCE_WINDOW: { __disp_rect_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_rect_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_block_set_src_win(ubuffer[0], ubuffer[1],¶); break; } case DISP_CMD_SPRITE_BLOCK_GET_SOURCE_WINDOW: { __disp_rect_t para; ret = bsp_disp_sprite_block_get_src_win(ubuffer[0], ubuffer[1],¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_rect_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_SPRITE_BLOCK_SET_FB: { __disp_fb_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_fb_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_block_set_framebuffer(ubuffer[0], ubuffer[1],¶); break; } case DISP_CMD_SPRITE_BLOCK_GET_FB: { __disp_fb_t para; ret = bsp_disp_sprite_block_get_framebufer(ubuffer[0], ubuffer[1],¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_fb_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_SPRITE_BLOCK_SET_TOP: ret = bsp_disp_sprite_block_set_top(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_SET_BOTTOM: ret = bsp_disp_sprite_block_set_bottom(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_GET_PREV_BLOCK: ret = bsp_disp_sprite_block_get_pre_block(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_GET_NEXT_BLOCK: ret = bsp_disp_sprite_block_get_next_block(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_GET_PRIO: ret = bsp_disp_sprite_block_get_prio(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_OPEN: ret = bsp_disp_sprite_block_open(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_CLOSE: ret = bsp_disp_sprite_block_close(ubuffer[0], ubuffer[1]); break; case DISP_CMD_SPRITE_BLOCK_SET_PARA: { __disp_sprite_block_para_t para; if(copy_from_user(¶, (void __user *)ubuffer[2],sizeof(__disp_sprite_block_para_t))) { __wrn("copy_from_user fail\n"); return -EFAULT; } ret = bsp_disp_sprite_block_set_para(ubuffer[0], ubuffer[1],¶); break; } case DISP_CMD_SPRITE_BLOCK_GET_PARA: { __disp_sprite_block_para_t para; ret = bsp_disp_sprite_block_get_para(ubuffer[0], ubuffer[1],¶); if(copy_to_user((void __user *)ubuffer[2],¶, sizeof(__disp_sprite_block_para_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } */ #ifdef __LINUX_OSAL__ //----framebuffer---- case DISP_CMD_FB_REQUEST: { __disp_fb_create_para_t para; if(copy_from_user(¶, (void __user *)ubuffer[1],sizeof(__disp_fb_create_para_t))) { __wrn("copy_from_user fail %d \n",__LINE__); return -EFAULT; } ret = Display_Fb_Request(ubuffer[0], ¶); break; } case DISP_CMD_FB_RELEASE: ret = Display_Fb_Release(ubuffer[0]); break; case DISP_CMD_FB_GET_PARA: { __disp_fb_create_para_t para; ret = Display_Fb_get_para(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1],¶, sizeof(__disp_fb_create_para_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_GET_DISP_INIT_PARA: { __disp_init_t para; ret = Display_get_disp_init_para(¶); if(copy_to_user((void __user *)ubuffer[0],¶, sizeof(__disp_init_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } //----for test---- case DISP_CMD_MEM_REQUEST: ret = disp_mem_request(ubuffer[0]); break; case DISP_CMD_MEM_RELASE: ret = disp_mem_release(ubuffer[0]); break; case DISP_CMD_MEM_SELIDX: g_disp_mm_sel = ubuffer[0]; break; case DISP_CMD_MEM_GETADR: ret = g_disp_mm[ubuffer[0]].mem_start; break; case DISP_CMD_MEM_GET_INFO: { __disp_mm_t para; ret = disp_mem_get_info(ubuffer[0], ¶); if(copy_to_user((void __user *)ubuffer[1],¶, sizeof(__disp_mm_t))) { __wrn("copy_to_user fail\n"); return -EFAULT; } break; } case DISP_CMD_SUSPEND: { pm_message_t state; ret = disp_suspend(0, state); break; } case DISP_CMD_RESUME: ret = disp_resume(0); break; #endif case DISP_CMD_SET_EXIT_MODE: ret = g_disp_drv.exit_mode = ubuffer[0]; break; case DISP_CMD_LCD_CHECK_OPEN_FINISH: ret = DRV_lcd_check_open_finished(ubuffer[0]); break; case DISP_CMD_LCD_CHECK_CLOSE_FINISH: ret = DRV_lcd_check_close_finished(ubuffer[0]); break; case DISP_CMD_PRINT_REG: ret = bsp_disp_print_reg(1, ubuffer[0]); break; default: break; } return ret; }
__s32 bsp_disp_capture_screen(__u32 screen_id, __disp_capture_screen_para_t * para) { __scal_buf_addr_t in_addr; __scal_buf_addr_t out_addr; __scal_src_size_t in_size; __scal_out_size_t out_size; __scal_src_type_t in_type; __scal_out_type_t out_type; __scal_scan_mod_t in_scan; __scal_scan_mod_t out_scan; __u32 size = 0; __s32 scaler_index = 0; __s32 ret = 0; if(para==NULL) { DE_WRN("input parameter can't be null!\n"); return DIS_FAIL; } scaler_index = Scaler_Request(0xff); if(scaler_index < 0) { DE_WRN("request scaler fail in bsp_disp_capture_screen\n"); return DIS_FAIL; } in_type.fmt= Scaler_sw_para_to_reg(0,DISP_MOD_INTERLEAVED, DISP_FORMAT_ARGB8888, DISP_SEQ_ARGB); in_type.mod= Scaler_sw_para_to_reg(1,DISP_MOD_INTERLEAVED, DISP_FORMAT_ARGB8888, DISP_SEQ_ARGB); in_type.ps= Scaler_sw_para_to_reg(2,DISP_MOD_INTERLEAVED, DISP_FORMAT_ARGB8888, (__u8)DISP_SEQ_ARGB); in_type.byte_seq = 0; in_type.sample_method = 0; if(get_fb_type(para->output_fb.format) == DISP_FB_TYPE_YUV) { if(para->output_fb.mode == DISP_MOD_NON_MB_PLANAR) { out_type.fmt = Scaler_sw_para_to_reg(3, para->output_fb.mode, para->output_fb.format, para->output_fb.seq); } else { DE_WRN("output mode:%d invalid in Display_Scaler_Start\n",para->output_fb.mode); return DIS_FAIL; } } else { if(para->output_fb.mode == DISP_MOD_NON_MB_PLANAR && (para->output_fb.format == DISP_FORMAT_RGB888 || para->output_fb.format == DISP_FORMAT_ARGB8888)) { out_type.fmt = DE_SCAL_OUTPRGB888; } else if(para->output_fb.mode == DISP_MOD_INTERLEAVED && para->output_fb.format == DISP_FORMAT_ARGB8888) { out_type.fmt = DE_SCAL_OUTI0RGB888; } else { DE_WRN("output para invalid in Display_Scaler_Start,mode:%d,format:%d\n",para->output_fb.mode, para->output_fb.format); return DIS_FAIL; } para->output_fb.br_swap= FALSE; } out_type.byte_seq = Scaler_sw_para_to_reg(2,para->output_fb.mode, para->output_fb.format, para->output_fb.seq); out_type.alpha_en = 1; out_type.alpha_coef_type = 0; out_size.width = para->output_fb.size.width; out_size.height = para->output_fb.size.height; if(bsp_disp_get_output_type(screen_id) != DISP_OUTPUT_TYPE_NONE) { in_size.src_width = bsp_disp_get_screen_width(screen_id); in_size.src_height = bsp_disp_get_screen_height(screen_id); in_size.x_off = 0; in_size.y_off = 0; in_size.scal_width= bsp_disp_get_screen_width(screen_id); in_size.scal_height= bsp_disp_get_screen_height(screen_id); } else { in_size.src_width = para->screen_size.width; in_size.src_height= para->screen_size.height; in_size.x_off = 0; in_size.y_off = 0; in_size.scal_width= para->screen_size.width; in_size.scal_height= para->screen_size.height; } in_scan.field = FALSE; in_scan.bottom = FALSE; out_scan.field = FALSE; //when use scaler as writeback, won't be outinterlaced for any display device out_scan.bottom = FALSE; in_addr.ch0_addr = 0; in_addr.ch1_addr = 0; in_addr.ch2_addr = 0; out_addr.ch0_addr = (__u32)OSAL_VAtoPA((void*)(para->output_fb.addr[0])); out_addr.ch1_addr = (__u32)OSAL_VAtoPA((void*)(para->output_fb.addr[1])); out_addr.ch2_addr = (__u32)OSAL_VAtoPA((void*)(para->output_fb.addr[2])); size = (para->output_fb.size.width * para->output_fb.size.height * de_format_to_bpp(para->output_fb.format) + 7)/8; OSAL_CacheRangeFlush((void *)para->output_fb.addr[0],size ,CACHE_FLUSH_D_CACHE_REGION); if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_NONE) { DE_SCAL_Input_Select(scaler_index, 6 + screen_id); DE_BE_set_display_size(screen_id, para->screen_size.width, para->screen_size.height); DE_BE_Output_Select(screen_id, 6 + scaler_index); image_clk_on(screen_id, 1); Image_open(screen_id); DE_BE_Cfg_Ready(screen_id); } else { DE_SCAL_Input_Select(scaler_index, 4 + screen_id); DE_BE_Output_Select(screen_id, 2 + (scaler_index * 2) + screen_id); } DE_SCAL_Config_Src(scaler_index,&in_addr,&in_size,&in_type,FALSE,FALSE); DE_SCAL_Set_Scaling_Factor(scaler_index, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type); DE_SCAL_Set_Init_Phase(scaler_index, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type, FALSE); DE_SCAL_Set_CSC_Coef(scaler_index, DISP_BT601, para->output_fb.cs_mode, DISP_FB_TYPE_RGB, get_fb_type(para->output_fb.format), 0, 0); DE_SCAL_Set_Scaling_Coef(scaler_index, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type, DISP_VIDEO_NATUAL); DE_SCAL_Set_Out_Format(scaler_index, &out_type); DE_SCAL_Set_Out_Size(scaler_index, &out_scan,&out_type, &out_size); DE_SCAL_Set_Writeback_Addr(scaler_index,&out_addr); DE_SCAL_Output_Select(scaler_index, 3); DE_SCAL_ClearINT(scaler_index,DE_WB_END_IE); DE_SCAL_EnableINT(scaler_index,DE_WB_END_IE); DE_SCAL_Set_Reg_Rdy(scaler_index); DE_SCAL_Writeback_Enable(scaler_index); DE_SCAL_Start(scaler_index); DE_INF("capture begin\n"); #ifndef __LINUX_OSAL__ while(!(DE_SCAL_QueryINT(scaler_index) & DE_WB_END_IE)) { } #else { long timeout = (100 * HZ)/1000;//100ms init_waitqueue_head(&(gdisp.scaler[scaler_index].scaler_queue)); gdisp.scaler[scaler_index].b_scaler_finished = 1; DE_SCAL_Writeback_Enable(scaler_index); timeout = wait_event_interruptible_timeout(gdisp.scaler[scaler_index].scaler_queue, gdisp.scaler[scaler_index].b_scaler_finished == 2, timeout); gdisp.scaler[scaler_index].b_scaler_finished = 0; if(timeout == 0) { __wrn("wait scaler %d finished timeout\n", scaler_index); return -1; } } #endif DE_SCAL_Reset(scaler_index); Scaler_Release(scaler_index, FALSE); if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_NONE) { Image_close(screen_id); image_clk_off(screen_id, 1); } DE_BE_Output_Select(screen_id, screen_id); DE_SCAL_ClearINT(scaler_index,DE_WB_END_IE); DE_SCAL_DisableINT(scaler_index,DE_WB_END_IE); return ret; }
static ssize_t disp_sys_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; int num_screens, screen_id; int num_layers, layer_id; //int hpd; num_screens = bsp_disp_feat_get_num_screens(); for(screen_id=0; screen_id < num_screens; screen_id ++) { count += sprintf(buf + count, "screen %d:\n", screen_id); /* output */ if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_LCD) { count += sprintf(buf + count, "\tlcd output\tbacklight(%3d)", bsp_disp_lcd_get_bright(screen_id)); count += sprintf(buf + count, "\t%4dx%4d\n", bsp_disp_get_screen_width(screen_id), bsp_disp_get_screen_height(screen_id)); } #if 0 else if(bsp_disp_get_output_type(screen_id) == DISP_OUTPUT_TYPE_HDMI) { count += sprintf(buf + count, "\thdmi output"); if(bsp_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_720P_50HZ) { count += sprintf(buf + count, "\t%16s", "720p50hz"); } else if(BSP_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_720P_60HZ) { count += sprintf(buf + count, "\t%16s", "720p60hz"); } else if(BSP_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080P_60HZ) { count += sprintf(buf + count, "\t%16s", "1080p60hz"); } else if(BSP_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080P_50HZ) { count += sprintf(buf + count, "\t%16s", "1080p50hz"); } else if(BSP_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080I_50HZ) { count += sprintf(buf + count, "\t%16s", "1080i50hz"); } else if(BSP_disp_hdmi_get_mode(screen_id) == DISP_TV_MOD_1080I_60HZ) { count += sprintf(buf + count, "\t%16s", "1080i60hz"); } count += sprintf(buf + count, "\t%4dx%4d\n", BSP_disp_get_screen_width(screen_id), BSP_disp_get_screen_height(screen_id)); } hpd = bsp_disp_hdmi_get_hpd_status(screen_id); count += sprintf(buf + count, "\t%11s\n", hpd? "hdmi plugin":"hdmi unplug"); #endif count += sprintf(buf + count, " type | status | id | pipe | z | pre_mult | alpha | colorkey | fmt | framebuffer | source crop | frame | trd | address\n"); count += sprintf(buf + count, "----------+--------+------+------+---+----------+------------+----------+-----+-------------+-----------------------+-------------------+---------+-----------------------------\n"); num_layers = bsp_disp_feat_get_num_layers(screen_id); /* layer info */ for(layer_id=0; layer_id<num_layers; layer_id++) { disp_layer_info layer_para; int ret; int enabled = 0; ret = bsp_disp_layer_get_info(screen_id, layer_id, &layer_para); enabled = bsp_disp_layer_is_enabled(screen_id, layer_id); if(ret == 0) { count += sprintf(buf + count, " %8s |", (layer_para.mode == DISP_LAYER_WORK_MODE_SCALER)? "SCALER":"NORAML"); count += sprintf(buf + count, " %8s |", (enabled==1)?"enable":"disable"); count += sprintf(buf + count, " %4d |", layer_id); count += sprintf(buf + count, " %4d |", layer_para.pipe); count += sprintf(buf + count, " %1d |", layer_para.zorder); count += sprintf(buf + count, " %8s |", (layer_para.fb.pre_multiply)? "Y":"N"); count += sprintf(buf + count, " %5s(%3d) |", (layer_para.alpha_mode)? "globl":"pixel", layer_para.alpha_value); count += sprintf(buf + count, " %8s |", (layer_para.ck_enable)? "enable":"disable"); count += sprintf(buf + count, " %3d |", layer_para.fb.format); count += sprintf(buf + count, " [%4d,%4d] |", layer_para.fb.size.width, layer_para.fb.size.height); count += sprintf(buf + count, " [%4d,%4d,%4d,%4d] |", layer_para.fb.src_win.x, layer_para.fb.src_win.y, layer_para.fb.src_win.width, layer_para.fb.src_win.height); count += sprintf(buf + count, " [%4d,%4d,%4d,%4d] |", layer_para.screen_win.x, layer_para.screen_win.y, layer_para.screen_win.width, layer_para.screen_win.height); count += sprintf(buf + count, " [%1d%1d,%1d%1d] |", layer_para.fb.b_trd_src, layer_para.fb.trd_mode, layer_para.b_trd_out, layer_para.out_trd_mode); count += sprintf(buf + count, " [%8x,%8x,%8x] |", layer_para.fb.addr[0], layer_para.fb.addr[1], layer_para.fb.addr[2]); count += sprintf(buf + count, "\n"); } } //count += sprintf(buf + count, "\n\tsmart backlight: %s\n", bsp_disp_drc_get_enable(screen_id)? "enable":"disable"); } return count; }