__s32 BSP_disp_tv_open(__u32 sel) { if((!(gdisp.screen[sel].status & TV_ON))) { __disp_tv_mode_t tv_mod; __panel_para_t para; memset(¶, 0, sizeof(__panel_para_t)); tv_mod = gdisp.screen[sel].tv_mode; lcdc_clk_on(sel, 0, 0); disp_clk_cfg(sel, DISP_OUTPUT_TYPE_TV, tv_mod); lcdc_clk_on(sel, 0, 1); drc_clk_open(sel,0); tcon_init(sel); image_clk_on(sel, 1); Image_open(sel);//set image normal channel start bit , because every de_clk_off( )will reset this bit BSP_disp_set_output_csc(sel, DISP_OUT_CSC_TYPE_LCD, BSP_disp_drc_get_input_csc(sel)); //LCD -->GM7121, rgb fmt DE_BE_set_display_size(sel, tv_mode_to_width(tv_mod), tv_mode_to_height(tv_mod)); DE_BE_Output_Select(sel, sel); disp_tv_get_timing(¶, tv_mod); tcon0_cfg(sel,(__panel_para_t*)¶); tcon0_src_select(sel,4); if(gdisp.screen[sel].tv_ops.tv_power_on) { gdisp.screen[sel].tv_ops.tv_power_on(1); msleep(500); } disp_tv_pin_cfg(1); tcon0_open(sel,(__panel_para_t*)¶); if(gdisp.screen[sel].tv_ops.tv_open) { gdisp.screen[sel].tv_ops.tv_open(); } Disp_Switch_Dram_Mode(DISP_OUTPUT_TYPE_TV, tv_mod); gdisp.screen[sel].b_out_interlace = Disp_get_screen_scan_mode(tv_mod); gdisp.screen[sel].status = TV_ON; gdisp.screen[sel].lcdc_status |= LCDC_TCON0_USED; gdisp.screen[sel].output_type = DISP_OUTPUT_TYPE_TV; gdisp.screen[sel].output_csc_type = DISP_OUT_CSC_TYPE_LCD;//LCD -->GM7121, rgb fmt if(BSP_disp_cmu_get_enable(sel) ==1) { IEP_CMU_Set_Imgsize(sel, BSP_disp_get_screen_width(sel), BSP_disp_get_screen_height(sel)); } Disp_set_out_interlace(sel); #ifdef __LINUX_OSAL__ Display_set_fb_timming(sel); #endif tcon0_src_select(sel,0); } return DIS_SUCCESS; }
__s32 Disp_iep_init(__u32 sel) { #ifdef DRC_DEFAULT_ENABLE __disp_rect_t regn; #endif memset(giep, 0, sizeof(giep)); memset(gpwrsv, 0, sizeof(gpwrsv)); if (sel == 0) { iep_clk_init(sel); pttab = kmalloc(sizeof(pwrsv_lgc_tab), GFP_KERNEL | __GFP_ZERO); memcpy(pttab, pwrsv_lgc_tab, sizeof(pwrsv_lgc_tab)); #ifdef DRC_DEFAULT_ENABLE #ifdef DRC_DEMO regn.x = BSP_disp_get_screen_width(sel) / 2; regn.y = 0; regn.width = BSP_disp_get_screen_width(sel) / 2; regn.height = BSP_disp_get_screen_height(sel); #else regn.x = 0; regn.y = 0; regn.width = BSP_disp_get_screen_width(sel); regn.height = BSP_disp_get_screen_height(sel); #endif BSP_disp_iep_drc_enable(sel, 1); BSP_disp_iep_set_demo_win(sel, 2, ®n); #endif return 0; } else { return -1; } }
__s32 Disp_de_flicker_init(__u32 sel) { __u32 scn_width, scn_height; scn_width = BSP_disp_get_screen_width(sel); scn_height = BSP_disp_get_screen_height(sel); if (sel == 0) { DE_IEP_Set_Mode(sel, 1); DE_IEP_Set_Display_Size(sel, scn_width, scn_height); DE_IEP_Set_Csc_Coeff(sel, 1); giep[sel].deflicker_win_en = 1; giep[sel].deflicker_win.x = 0; giep[sel].deflicker_win.y = 0; giep[sel].deflicker_win.width = scn_width; giep[sel].deflicker_win.height = scn_height; return 0; } else { return -1; } }
__s32 BSP_disp_iep_set_demo_win(__u32 sel, __u32 mode, __disp_rect_t *regn) { __u32 scn_width, scn_height; if (regn == NULL) { DE_WRN("BSP_disp_iep_set_demo_win: parameters invalid!\n"); return DIS_PARA_FAILED; } scn_width = BSP_disp_get_screen_width(sel); scn_height = BSP_disp_get_screen_height(sel); if ((regn->x < 0) || ((regn->x + regn->width) > scn_width) || (regn->y < 0) || ((regn->y + regn->height) > scn_height)) { DE_WRN("BSP_disp_iep_set_demo_win: win_x: %d, win_y: %d, " "win_width: %d, win_height: %d.\n", regn->x, regn->y, regn->width, regn->height); DE_WRN("IEP Windows Size Invalid!\n"); return DIS_PARA_FAILED; } if (mode == 2) { /* drc */ memcpy(&giep[sel].drc_win, regn, sizeof(__disp_rect_t)); DE_INF("BSP_disp_iep_set_demo_win: drc window win_x: %d, " "win_y: %d, win_width: %d, win_height: %d.\n", giep[sel].drc_win.x, giep[sel].drc_win.y, giep[sel].drc_win.width, giep[sel].drc_win.height); } else if (mode == 1) { /* de-flicker */ memcpy(&giep[sel].deflicker_win, regn, sizeof(__disp_rect_t)); DE_INF("BSP_disp_iep_set_demo_win: drc window win_x: %d, " "win_y: %d, win_width: %d, win_height: %d.\n", giep[sel].drc_win.x, giep[sel].drc_win.y, giep[sel].drc_win.width, giep[sel].drc_win.height); } return DIS_SUCCESS; }
long disp_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct dev_disp_data *filp_data = filp->private_data; unsigned long karg[4]; unsigned long ubuffer[4] = { 0 }; __s32 ret = 0; if (copy_from_user ((void *)karg, (void __user *)arg, 4 * sizeof(unsigned long))) { __wrn("copy_from_user fail\n"); 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)); /* Verify version handshake first. */ if (filp_data->version == SUNXI_DISP_VERSION_PENDING) { if (cmd == DISP_CMD_VERSION) { int version = *((int *) karg); if (version < 0) { pr_err("disp: process %d (%s) provided an " "invalid version.\n", current->pid, current->comm); filp_data->version = SUNXI_DISP_VERSION_SKIPPED; return -EINVAL; } if (version != SUNXI_DISP_VERSION) pr_warn("disp: process %d (%s) has a different " "version: %d.%d (vs. %d.%d)\n", current->pid, current->comm, SUNXI_DISP_VERSION_MAJOR_GET(version), SUNXI_DISP_VERSION_MINOR_GET(version), SUNXI_DISP_VERSION_MAJOR, SUNXI_DISP_VERSION_MINOR); /* Add compatibility checks here */ filp_data->version = version; return SUNXI_DISP_VERSION; } else { pr_err("disp: process %d (%s) has skipped the version " "handshake.\n", current->pid, current->comm); filp_data->version = SUNXI_DISP_VERSION_SKIPPED; } } 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) DE_WRN("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\n"); 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\n"); 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\n"); 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\n"); 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_set_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_BRIGHT: ret = BSP_disp_get_bright(ubuffer[0]); break; case DISP_CMD_SET_CONTRAST: ret = BSP_disp_set_contrast(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_CONTRAST: ret = BSP_disp_get_contrast(ubuffer[0]); break; case DISP_CMD_SET_SATURATION: ret = BSP_disp_set_saturation(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_SATURATION: ret = BSP_disp_get_saturation(ubuffer[0]); break; case DISP_CMD_SET_HUE: ret = BSP_disp_set_hue(ubuffer[0], ubuffer[1]); break; case DISP_CMD_GET_HUE: ret = BSP_disp_get_hue(ubuffer[0]); break; #ifdef CONFIG_ARCH_SUN4I case DISP_CMD_ENHANCE_ON: ret = BSP_disp_enhance_enable(ubuffer[0], 1); break; case DISP_CMD_ENHANCE_OFF: ret = BSP_disp_enhance_enable(ubuffer[0], 0); break; case DISP_CMD_GET_ENHANCE_EN: ret = BSP_disp_get_enhance_enable(ubuffer[0]); break; #endif 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; /* ----iep---- */ case DISP_CMD_DE_FLICKER_ON: #ifdef CONFIG_ARCH_SUN4I ret = BSP_disp_de_flicker_enable(ubuffer[0], 1); #else ret = BSP_disp_iep_deflicker_enable(ubuffer[0], 1); #endif break; case DISP_CMD_DE_FLICKER_OFF: #ifdef CONFIG_ARCH_SUN4I ret = BSP_disp_de_flicker_enable(ubuffer[0], 0); #else ret = BSP_disp_iep_deflicker_enable(ubuffer[0], 0); #endif break; #ifdef CONFIG_ARCH_SUN5I case DISP_CMD_GET_DE_FLICKER_EN: ret = BSP_disp_iep_get_deflicker_enable(ubuffer[0]); break; case DISP_CMD_DRC_ON: ret = BSP_disp_iep_drc_enable(ubuffer[0], 1); break; case DISP_CMD_DRC_OFF: ret = BSP_disp_iep_drc_enable(ubuffer[0], 0); break; case DISP_CMD_GET_DRC_EN: ret = BSP_disp_iep_get_drc_enable(ubuffer[0]); break; case DISP_CMD_DE_FLICKER_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_iep_set_demo_win(ubuffer[0], 1, ¶); 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_iep_set_demo_win(ubuffer[0], 2, ¶); break; } #endif /* ----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\n"); 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\n"); 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\n"); 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\n"); 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_layer_set_bright(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_BRIGHT: ret = BSP_disp_layer_get_bright(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_CONTRAST: ret = BSP_disp_layer_set_contrast(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_CONTRAST: ret = BSP_disp_layer_get_contrast(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_SATURATION: ret = BSP_disp_layer_set_saturation(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_SATURATION: ret = BSP_disp_layer_get_saturation(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_HUE: ret = BSP_disp_layer_set_hue(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_HUE: ret = BSP_disp_layer_get_hue(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_ENHANCE_ON: ret = BSP_disp_layer_enhance_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_ENHANCE_OFF: ret = BSP_disp_layer_enhance_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_GET_ENHANCE_EN: ret = BSP_disp_layer_get_enhance_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_VPP_ON: ret = BSP_disp_layer_vpp_enable(ubuffer[0], ubuffer[1], 1); break; case DISP_CMD_LAYER_VPP_OFF: ret = BSP_disp_layer_vpp_enable(ubuffer[0], ubuffer[1], 0); break; case DISP_CMD_LAYER_GET_VPP_EN: ret = BSP_disp_layer_get_vpp_enable(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_LUMA_SHARP_LEVEL: ret = BSP_disp_layer_set_luma_sharp_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_LUMA_SHARP_LEVEL: ret = BSP_disp_layer_get_luma_sharp_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_CHROMA_SHARP_LEVEL: ret = BSP_disp_layer_set_chroma_sharp_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_CHROMA_SHARP_LEVEL: ret = BSP_disp_layer_get_chroma_sharp_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_WHITE_EXTEN_LEVEL: ret = BSP_disp_layer_set_white_exten_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_WHITE_EXTEN_LEVEL: ret = BSP_disp_layer_get_white_exten_level(ubuffer[0], ubuffer[1]); break; case DISP_CMD_LAYER_SET_BLACK_EXTEN_LEVEL: ret = BSP_disp_layer_set_black_exten_level(ubuffer[0], ubuffer[1], ubuffer[2]); break; case DISP_CMD_LAYER_GET_BLACK_EXTEN_LEVEL: ret = BSP_disp_layer_get_black_exten_level(ubuffer[0], ubuffer[1]); 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\n"); return -EFAULT; } ret = BSP_disp_scaler_start(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\n"); 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\n"); 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\n"); 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\n"); 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]); 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: #ifdef CONFIG_ARCH_SUN4I ret = BSP_disp_lcd_set_bright(ubuffer[0], ubuffer[1]); #else ret = BSP_disp_lcd_set_bright(ubuffer[0], ubuffer[1], 0); #endif 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; /* ----pwm---- */ case DISP_CMD_PWM_SET_PARA: ret = pwm_set_para(ubuffer[0], (__pwm_info_t *) ubuffer[1]); break; case DISP_CMD_PWM_GET_PARA: ret = pwm_get_para(ubuffer[0], (__pwm_info_t *) ubuffer[1]); 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]); 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; } /* ----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\n"); 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; } case DISP_CMD_MEM_REQUEST: ret = disp_mem_request(ubuffer[0], ubuffer[1]); break; /* ----for test---- */ 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_SUSPEND: { pm_message_t state = { }; ret = disp_suspend(NULL, state); break; } case DISP_CMD_RESUME: ret = disp_resume(NULL); break; case DISP_CMD_PRINT_REG: ret = BSP_disp_print_reg(1, ubuffer[0]); break; default: break; } return ret; }
__s32 Fb_Init(__u32 from) { __s32 i; __bool need_open_hdmi = 0; __disp_fb_create_para_t fb_para = { .primary_screen_id = 0, }; __inf("Fb_Init:%d\n", from); if (from == 0) { /* call from lcd driver */ #ifdef CONFIG_FB_SUNXI_RESERVED_MEM __inf("fbmem: fb_start=%lu, fb_size=%lu\n", fb_start, fb_size); disp_create_heap((unsigned long)(__va(fb_start)), fb_size); #endif for (i = 0; i < SUNXI_MAX_FB; i++) { g_fbi.fbinfo[i] = framebuffer_alloc(0, g_fbi.dev); g_fbi.fbinfo[i]->fbops = &dispfb_ops; g_fbi.fbinfo[i]->flags = 0; g_fbi.fbinfo[i]->device = g_fbi.dev; g_fbi.fbinfo[i]->par = &g_fbi; g_fbi.fbinfo[i]->var.xoffset = 0; g_fbi.fbinfo[i]->var.yoffset = 0; g_fbi.fbinfo[i]->var.xres = 800; g_fbi.fbinfo[i]->var.yres = 480; g_fbi.fbinfo[i]->var.xres_virtual = 800; g_fbi.fbinfo[i]->var.yres_virtual = 480 * 2; g_fbi.fbinfo[i]->var.nonstd = 0; g_fbi.fbinfo[i]->var.grayscale = 0; g_fbi.fbinfo[i]->var.bits_per_pixel = 32; g_fbi.fbinfo[i]->var.transp.length = 8; g_fbi.fbinfo[i]->var.red.length = 8; g_fbi.fbinfo[i]->var.green.length = 8; g_fbi.fbinfo[i]->var.blue.length = 8; g_fbi.fbinfo[i]->var.transp.offset = 24; g_fbi.fbinfo[i]->var.red.offset = 16; g_fbi.fbinfo[i]->var.green.offset = 8; g_fbi.fbinfo[i]->var.blue.offset = 0; g_fbi.fbinfo[i]->var.activate = FB_ACTIVATE_FORCE; g_fbi.fbinfo[i]->fix.type = FB_TYPE_PACKED_PIXELS; g_fbi.fbinfo[i]->fix.type_aux = 0; g_fbi.fbinfo[i]->fix.visual = FB_VISUAL_TRUECOLOR; g_fbi.fbinfo[i]->fix.xpanstep = 1; g_fbi.fbinfo[i]->fix.ypanstep = 1; g_fbi.fbinfo[i]->fix.ywrapstep = 0; g_fbi.fbinfo[i]->fix.accel = FB_ACCEL_NONE; g_fbi.fbinfo[i]->fix.line_length = g_fbi.fbinfo[i]->var.xres_virtual * 4; g_fbi.fbinfo[i]->fix.smem_len = g_fbi.fbinfo[i]->fix.line_length * g_fbi.fbinfo[i]->var.yres_virtual * 2; g_fbi.fbinfo[i]->screen_base = NULL; g_fbi.fbinfo[i]->pseudo_palette = g_fbi.pseudo_palette[i]; g_fbi.fbinfo[i]->fix.smem_start = 0x0; g_fbi.fbinfo[i]->fix.mmio_start = 0; g_fbi.fbinfo[i]->fix.mmio_len = 0; if (fb_alloc_cmap(&g_fbi.fbinfo[i]->cmap, 256, 1) < 0) return -ENOMEM; } parser_disp_init_para(&(g_fbi.disp_init)); } if (g_fbi.disp_init.b_init) { __u32 sel = 0; for (sel = 0; sel < 2; sel++) { if (((sel == 0) && (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN1)) || ((sel == 1) && (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN0))) { if (g_fbi.disp_init.output_type[sel] == DISP_OUTPUT_TYPE_HDMI) need_open_hdmi = 1; } } } if (need_open_hdmi == 1 && from == 0) /* it is called from lcd driver, but hdmi need to be opened */ return 0; else if (need_open_hdmi == 0 && from == 1) /* it is called from hdmi driver, but hdmi need not be opened */ return 0; if (g_fbi.disp_init.b_init) { __u32 fb_num = 0, sel = 0; for (sel = 0; sel < 2; sel++) { if (((sel == 0) && (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN1)) || ((sel == 1) && (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN0))) { if (g_fbi.disp_init.output_type[sel] == DISP_OUTPUT_TYPE_LCD) { DRV_lcd_open(sel); } else if (g_fbi.disp_init.output_type[sel] == DISP_OUTPUT_TYPE_TV) { BSP_disp_tv_set_mode(sel, g_fbi.disp_init. tv_mode[sel]); BSP_disp_tv_open(sel); } else if (g_fbi.disp_init.output_type[sel] == DISP_OUTPUT_TYPE_HDMI) { BSP_disp_hdmi_set_mode(sel, g_fbi.disp_init. tv_mode[sel]); BSP_disp_hdmi_open(sel); } else if (g_fbi.disp_init.output_type[sel] == DISP_OUTPUT_TYPE_VGA) { BSP_disp_vga_set_mode(sel, g_fbi.disp_init. vga_mode[sel]); BSP_disp_vga_open(sel); } } } fb_num = (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_TWO_DIFF_SCREEN) ? 2 : 1; for (i = 0; i < fb_num; i++) { __u32 screen_id = i; disp_fb_to_var(g_fbi.disp_init.format[i], g_fbi.disp_init.seq[i], g_fbi.disp_init.br_swap[i], &(g_fbi.fbinfo[i]->var)); if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_SCREEN1) screen_id = 1; fb_para.buffer_num = g_fbi.disp_init.buffer_num[i]; fb_para.width = BSP_disp_get_screen_width(screen_id); fb_para.height = BSP_disp_get_screen_height(screen_id); fb_para.output_width = BSP_disp_get_screen_width(screen_id); fb_para.output_height = BSP_disp_get_screen_height(screen_id); fb_para.mode = (g_fbi.disp_init.scaler_mode[i] == 0) ? DISP_LAYER_WORK_MODE_NORMAL : DISP_LAYER_WORK_MODE_SCALER; if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_SCREEN0) { fb_para.fb_mode = FB_MODE_SCREEN0; } else if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_SCREEN1) { fb_para.fb_mode = FB_MODE_SCREEN1; } else if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_TWO_DIFF_SCREEN) { if (i == 0) fb_para.fb_mode = FB_MODE_SCREEN0; else fb_para.fb_mode = FB_MODE_SCREEN1; } else if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_TWO_SAME_SCREEN) { fb_para.fb_mode = FB_MODE_DUAL_SAME_SCREEN_TB; fb_para.height *= 2; fb_para.output_height *= 2; } else if (g_fbi.disp_init.disp_mode == DISP_INIT_MODE_TWO_DIFF_SCREEN_SAME_CONTENTS) { fb_para.fb_mode = FB_MODE_DUAL_DIFF_SCREEN_SAME_CONTENTS; fb_para.output_width = BSP_disp_get_screen_width(fb_para. primary_screen_id); fb_para.output_height = BSP_disp_get_screen_height(fb_para. primary_screen_id); fb_para.aux_output_width = BSP_disp_get_screen_width(1 - fb_para. primary_screen_id); fb_para.aux_output_height = BSP_disp_get_screen_height(1 - fb_para. primary_screen_id); } Display_Fb_Request(i, &fb_para); #if 0 fb_draw_colorbar((__u32)g_fbi.fbinfo[i]->screen_base, fb_para.width, fb_para.height * fb_para.buffer_num, &(g_fbi.fbinfo[i]->var)); #endif } for (i = 0; i < SUNXI_MAX_FB; i++) /* Register framebuffers after they are initialized */ register_framebuffer(g_fbi.fbinfo[i]); if (g_fbi.disp_init.scaler_mode[0]) BSP_disp_print_reg(0, DISP_REG_SCALER0); if (g_fbi.disp_init.scaler_mode[1]) BSP_disp_print_reg(0, DISP_REG_SCALER1); if (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN1) { BSP_disp_print_reg(0, DISP_REG_IMAGE0); BSP_disp_print_reg(0, DISP_REG_LCDC0); if ((g_fbi.disp_init.output_type[0] == DISP_OUTPUT_TYPE_TV) || (g_fbi.disp_init.output_type[0] == DISP_OUTPUT_TYPE_VGA)) BSP_disp_print_reg(0, DISP_REG_TVEC0); } if (g_fbi.disp_init.disp_mode != DISP_INIT_MODE_SCREEN0) { BSP_disp_print_reg(0, DISP_REG_IMAGE1); BSP_disp_print_reg(0, DISP_REG_LCDC1); if ((g_fbi.disp_init.output_type[1] == DISP_OUTPUT_TYPE_TV) || (g_fbi.disp_init.output_type[1] == DISP_OUTPUT_TYPE_VGA)) BSP_disp_print_reg(0, DISP_REG_TVEC1); } BSP_disp_print_reg(0, DISP_REG_CCMU); BSP_disp_print_reg(0, DISP_REG_PWM); BSP_disp_print_reg(0, DISP_REG_PIOC); } __inf("Fb_Init: END\n"); return 0; } EXPORT_SYMBOL(Fb_Init); __s32 Fb_Exit(void) { __u8 fb_id = 0; for (fb_id = 0; fb_id < SUNXI_MAX_FB; fb_id++) { if (g_fbi.fbinfo[fb_id] == NULL) continue; Display_Fb_Release(fb_id); unregister_framebuffer(g_fbi.fbinfo[fb_id]); framebuffer_release(g_fbi.fbinfo[fb_id]); g_fbi.fbinfo[fb_id] = NULL; } return 0; }
__s32 Disp_drc_init(__u32 sel) { __u32 scn_width, scn_height; scn_width = BSP_disp_get_screen_width(sel); scn_height = BSP_disp_get_screen_height(sel); if (sel == 0) { /* to prevent BE OUTCSC output YUV when IEP CSC not ready */ //BSP_disp_cfg_start(sel); /* IEP clk */ iep_clk_open(sel); /* another module */ /* when running drc mode, debe must output yuv format */ #if 0 DE_BE_Output_Cfg_Csc_Coeff(sel, DISP_OUTPUT_TYPE_TV, 0); BSP_disp_set_output_csc(sel, gdisp.screen[sel].output_type, 1); #endif /* IEP module */ DE_IEP_Set_Mode(sel, 2); DE_IEP_Set_Display_Size(sel, scn_width, scn_height); //DE_IEP_Set_Csc_Coeff(sel, 3); DE_IEP_Drc_Set_Spa_Coeff(sel, spatial_coeff); DE_IEP_Drc_Set_Int_Coeff(sel, intensity_coeff); /* default: no adjust */ DE_IEP_Drc_Adjust_Enable(sel, 0); /* default: autoload enable */ DE_IEP_Drc_Set_Lgc_Autoload_Disable(sel, 0); DE_IEP_Lh_Set_Mode(sel, 0); /* default: histogram normal mode */ //DE_IEP_Lh_Set_Mode(sel, 1); /* histogram average mode */ //DE_IEP_Lh_Set_Thres(sel, hist_thres_drc); DE_IEP_Lh_Set_Thres(sel, hist_thres_pwrsv); //gpwrsv[sel].user_bl = gdisp.screen[sel].lcd_bright; memset(gpwrsv[sel].min_adj_index_hist, 255, sizeof(__u8) * IEP_LH_PWRSV_NUM); //giep[sel].drc_en = 1; giep[sel].drc_win_en = 1; #if 0 giep[sel].drc_win.x = 0; giep[sel].drc_win.y = 0; giep[sel].drc_win.width = scn_width; /* * will clear when drc enable actually, but apps dont know when, * so delete it. */ giep[sel].drc_win.height = scn_height; #endif /* set 1 to make sure first frame wont get a random lgc table */ giep[sel].waitframe = 1; giep[sel].runframe = 0; /* to prevent BE OUTCSC output YUV when IEP CSC not ready */ //BSP_disp_cfg_finish(sel); return 0; } else { return -1; } }
__s32 BSP_disp_capture_screen(__u32 sel, __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_idx = 0; __s32 ret = 0; if(para==NULL) { DE_WRN("input parameter can't be null!\n"); return DIS_FAIL; } scaler_idx = Scaler_Request(0xff); if(scaler_idx < 0) { DE_WRN("request scaler fail in BSP_disp_capture_screen\n"); return DIS_FAIL; } else { gdisp.scaler[sel].screen_index = 0xff; } in_type.mod= Scaler_sw_para_to_reg(1,DISP_MOD_INTERLEAVED); in_type.fmt= Scaler_sw_para_to_reg(0,DISP_FORMAT_ARGB8888); in_type.ps= Scaler_sw_para_to_reg(2,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.format); } 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.seq); out_size.width = para->output_fb.size.width; out_size.height = para->output_fb.size.height; if(BSP_disp_get_output_type(sel) != DISP_OUTPUT_TYPE_NONE) { in_size.src_width = BSP_disp_get_screen_width(sel); in_size.src_height = BSP_disp_get_screen_height(sel); in_size.x_off = 0; in_size.y_off = 0; in_size.scal_width= BSP_disp_get_screen_width(sel); in_size.scal_height= BSP_disp_get_screen_height(sel); } 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(sel) == DISP_OUTPUT_TYPE_NONE) { DE_SCAL_Input_Select(scaler_idx, 6 + sel); DE_BE_set_display_size(sel, para->screen_size.width, para->screen_size.height); DE_BE_Output_Select(sel, 6 + scaler_idx); image_clk_on(sel); Image_open(sel); DE_BE_Cfg_Ready(sel); } else { DE_SCAL_Input_Select(scaler_idx, 4 + sel); DE_BE_Output_Select(sel, 2 + (scaler_idx * 2) + sel); } DE_SCAL_Config_Src(scaler_idx,&in_addr,&in_size,&in_type,FALSE,FALSE); DE_SCAL_Set_Scaling_Factor(scaler_idx, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type); DE_SCAL_Set_Init_Phase(scaler_idx, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type, FALSE); DE_SCAL_Set_CSC_Coef(scaler_idx, 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_idx, &in_scan, &in_size, &in_type, &out_scan, &out_size, &out_type, DISP_VIDEO_NATUAL); DE_SCAL_Set_Out_Format(scaler_idx, &out_type); DE_SCAL_Set_Out_Size(scaler_idx, &out_scan,&out_type, &out_size); DE_SCAL_Set_Writeback_Addr(scaler_idx,&out_addr); DE_SCAL_Output_Select(scaler_idx, 3); DE_SCAL_ClearINT(scaler_idx,DE_WB_END_IE); DE_SCAL_EnableINT(scaler_idx,DE_WB_END_IE); DE_SCAL_Set_Reg_Rdy(scaler_idx); DE_SCAL_Writeback_Enable(scaler_idx); DE_SCAL_Start(scaler_idx); DE_INF("capture begin\n"); #ifndef __LINUX_OSAL__ while(!(DE_SCAL_QueryINT(scaler_idx) & DE_WB_END_IE) ) { } #else { long timeout = (100 * HZ)/1000;//100ms init_waitqueue_head(&(gdisp.scaler[scaler_idx].scaler_queue)); gdisp.scaler[scaler_idx].b_scaler_finished = 1; DE_SCAL_Writeback_Enable(scaler_idx); timeout = wait_event_interruptible_timeout(gdisp.scaler[scaler_idx].scaler_queue, gdisp.scaler[scaler_idx].b_scaler_finished == 2, timeout); gdisp.scaler[scaler_idx].b_scaler_finished = 0; if(timeout == 0) { __wrn("wait scaler %d finished timeout\n", scaler_idx); return -1; } } #endif DE_SCAL_Reset(scaler_idx); Scaler_Release(scaler_idx, FALSE); if(BSP_disp_get_output_type(sel) == DISP_OUTPUT_TYPE_NONE) { Image_close(sel); image_clk_off(sel); } DE_BE_Output_Select(sel, sel); 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; }
/* **************************************************************************************************** * * DRV_DE_IOCTRL * * Description: 驱动提供的io操作函数,通常用于扩展操作 * * * Parameters: mid: 模块编号,驱动编写者可以不用关心 * cmd: 驱动提供的操作命令 * aux: 用户传进的整型参数 * pbuffer: 用户传进的指针型参数 * * Return value: * 0 * -1 **************************************************************************************************** */ __s32 DRV_DE_IOCTRL(__u32 hd, __u32 cmd, __s32 aux, void *pbuffer) { __u32 para0=0, para1=0, para2=0; if(pbuffer != NULL) { para0 = *((__u32*)pbuffer); para1 = *((__u32*)((__u32)pbuffer+4)); para2 = *((__u32*)((__u32)pbuffer+8)); } switch(cmd) { //----disp global---- case DISP_CMD_SET_BKCOLOR: return BSP_disp_set_bk_color(aux, (__disp_color_t*)para0); case DISP_CMD_SET_COLORKEY: return BSP_disp_set_color_key(aux, (__disp_colorkey_t *)para0); case DISP_CMD_SET_PALETTE_TBL: return BSP_disp_set_palette_table(aux, (__u32 *)para0, para1, para2); case DISP_CMD_GET_PALETTE_TBL: return BSP_disp_get_palette_table(aux, (__u32 *)para0, para1, para2); case DISP_CMD_START_CMD_CACHE: return BSP_disp_cmd_cache(aux); case DISP_CMD_EXECUTE_CMD_AND_STOP_CACHE: return BSP_disp_cmd_submit(aux); case DISP_CMD_GET_OUTPUT_TYPE: return BSP_disp_get_output_type(aux); case DISP_CMD_SCN_GET_WIDTH: return BSP_disp_get_screen_width(aux); case DISP_CMD_SCN_GET_HEIGHT: return BSP_disp_get_screen_height(aux); case DISP_CMD_SET_EXIT_MODE: return DRV_set_exit_mode(aux); case DISP_CMD_SET_GAMMA_TABLE: return BSP_disp_set_gamma_table(aux, (__u32 *)para0, para1); case DISP_CMD_GAMMA_CORRECTION_ON: return BSP_disp_gamma_correction_enable(aux); case DISP_CMD_GAMMA_CORRECTION_OFF: return BSP_disp_gamma_correction_disable(aux); //----layer---- case DISP_CMD_LAYER_REQUEST: return BSP_disp_layer_request(aux, (__disp_layer_work_mode_t)para0); case DISP_CMD_LAYER_RELEASE: return BSP_disp_layer_release(aux, para0); case DISP_CMD_LAYER_OPEN: return BSP_disp_layer_open(aux, para0); case DISP_CMD_LAYER_CLOSE: return BSP_disp_layer_close(aux, para0); case DISP_CMD_LAYER_SET_FB: return BSP_disp_layer_set_framebuffer(aux, para0, (__disp_fb_t*)para1); case DISP_CMD_LAYER_GET_FB: return BSP_disp_layer_get_framebuffer(aux, para0, (__disp_fb_t*)para1); case DISP_CMD_LAYER_SET_SRC_WINDOW: return BSP_disp_layer_set_src_window(aux,para0, (__disp_rect_t*)para1); case DISP_CMD_LAYER_GET_SRC_WINDOW: return BSP_disp_layer_get_src_window(aux,para0, (__disp_rect_t*)para1); case DISP_CMD_LAYER_SET_SCN_WINDOW: return BSP_disp_layer_set_screen_window(aux,para0, (__disp_rect_t*)para1); case DISP_CMD_LAYER_GET_SCN_WINDOW: return BSP_disp_layer_get_screen_window(aux,para0, (__disp_rect_t*)para1); case DISP_CMD_LAYER_SET_PARA: return BSP_disp_layer_set_para(aux, para0, (__disp_layer_info_t *)para1); case DISP_CMD_LAYER_GET_PARA: return BSP_disp_layer_get_para(aux, para0, (__disp_layer_info_t *)para1); case DISP_CMD_LAYER_TOP: return BSP_disp_layer_set_top(aux, para0); case DISP_CMD_LAYER_BOTTOM: return BSP_disp_layer_set_bottom(aux, para0); case DISP_CMD_LAYER_ALPHA_ON: return BSP_disp_layer_alpha_enable(aux, para0, 1); case DISP_CMD_LAYER_ALPHA_OFF: return BSP_disp_layer_alpha_enable(aux, para0, 0); case DISP_CMD_LAYER_SET_ALPHA_VALUE: return BSP_disp_layer_set_alpha_value(aux, para0, para1); case DISP_CMD_LAYER_CK_ON: return BSP_disp_layer_colorkey_enable(aux, para0, 1); case DISP_CMD_LAYER_CK_OFF: return BSP_disp_layer_colorkey_enable(aux, para0, 0); case DISP_CMD_LAYER_SET_PIPE: return BSP_disp_layer_set_pipe(aux, para0, para1); case DISP_CMD_LAYER_GET_ALPHA_VALUE: return BSP_disp_layer_get_alpha_value(aux, para0); case DISP_CMD_LAYER_GET_ALPHA_EN: return BSP_disp_layer_get_alpha_enable(aux, para0); case DISP_CMD_LAYER_GET_CK_EN: return BSP_disp_layer_get_colorkey_enable(aux, para0); case DISP_CMD_LAYER_GET_PRIO: return BSP_disp_layer_get_piro(aux, para0); case DISP_CMD_LAYER_GET_PIPE: return BSP_disp_layer_get_pipe(aux, para0); case DISP_CMD_LAYER_SET_SMOOTH: return BSP_disp_layer_set_smooth(aux, para0,(__disp_video_smooth_t) para1); case DISP_CMD_LAYER_GET_SMOOTH: return BSP_disp_layer_get_smooth(aux, para0); //----scaler---- case DISP_CMD_SCALER_REQUEST: return BSP_disp_scaler_request(); case DISP_CMD_SCALER_RELEASE: return BSP_disp_scaler_release(para0); case DISP_CMD_SCALER_EXECUTE: return BSP_disp_scaler_start(para0,(__disp_scaler_para_t *)para1); //----hwc---- case DISP_CMD_HWC_OPEN: return BSP_disp_hwc_enable(aux, 1); case DISP_CMD_HWC_CLOSE: return BSP_disp_hwc_enable(aux, 0); case DISP_CMD_HWC_SET_POS: return BSP_disp_hwc_set_pos(aux, (__disp_pos_t*)para0); case DISP_CMD_HWC_GET_POS: return BSP_disp_hwc_get_pos(aux, (__disp_pos_t *)para0); case DISP_CMD_HWC_SET_FB: return BSP_disp_hwc_set_framebuffer(aux, (__disp_hwc_pattern_t *)para0); case DISP_CMD_HWC_SET_PALETTE_TABLE: return BSP_disp_hwc_set_palette(aux, (void*)para0, para1, para2); //----video---- case DISP_CMD_VIDEO_START: return BSP_disp_video_start(aux, para0); case DISP_CMD_VIDEO_STOP: return BSP_disp_video_stop(aux, para0); case DISP_CMD_VIDEO_SET_FB: return BSP_disp_video_set_fb(aux, para0, (__disp_video_fb_t *)para1); case DISP_CMD_VIDEO_GET_FRAME_ID: return BSP_disp_video_get_frame_id(aux, para0); case DISP_CMD_VIDEO_GET_DIT_INFO: return BSP_disp_video_get_dit_info(aux, para0,(__disp_dit_info_t *)para1); //----lcd---- case DISP_CMD_LCD_ON: return DRV_lcd_open(aux); case DISP_CMD_LCD_OFF: return DRV_lcd_close(aux); case DISP_CMD_LCD_SET_BRIGHTNESS: return BSP_disp_lcd_set_bright(aux, para0); case DISP_CMD_LCD_GET_BRIGHTNESS: return BSP_disp_lcd_get_bright(aux); case DISP_CMD_LCD_CPUIF_XY_SWITCH: return BSP_disp_lcd_xy_switch(aux, para0); case DISP_CMD_LCD_SET_SRC: return BSP_disp_lcd_set_src(aux, (__disp_lcdc_src_t)para0); case DISP_CMD_LCD_CHECK_OPEN_FINISH: return DRV_lcd_check_open_finished(aux); case DISP_CMD_LCD_CHECK_CLOSE_FINISH: return DRV_lcd_check_close_finished(aux); //----tv---- case DISP_CMD_TV_ON: return BSP_disp_tv_open(aux); case DISP_CMD_TV_OFF: return BSP_disp_tv_close(aux); case DISP_CMD_TV_SET_MODE: return BSP_disp_tv_set_mode(aux, (__disp_tv_mode_t)para0); case DISP_CMD_TV_GET_MODE: return BSP_disp_tv_get_mode(aux); case DISP_CMD_TV_AUTOCHECK_ON: return BSP_disp_tv_auto_check_enable(aux); case DISP_CMD_TV_AUTOCHECK_OFF: return BSP_disp_tv_auto_check_disable(aux); case DISP_CMD_TV_GET_INTERFACE: return BSP_disp_tv_get_interface(aux); case DISP_CMD_TV_SET_SRC: return BSP_disp_tv_set_src(aux, (__disp_lcdc_src_t)para0); case DISP_CMD_TV_GET_DAC_STATUS: return BSP_disp_tv_get_dac_status(aux, para0); case DISP_CMD_TV_SET_DAC_SOURCE: return BSP_disp_tv_set_dac_source(aux, para0, (__disp_tv_dac_source)para1); case DISP_CMD_TV_GET_DAC_SOURCE: return BSP_disp_tv_get_dac_source(aux, para0); //----hdmi---- case DISP_CMD_HDMI_ON: return BSP_disp_hdmi_open(aux); case DISP_CMD_HDMI_OFF: return BSP_disp_hdmi_close(aux); case DISP_CMD_HDMI_SET_MODE: return BSP_disp_hdmi_set_mode(aux, (__disp_tv_mode_t)para0); case DISP_CMD_HDMI_GET_MODE: return BSP_disp_hdmi_get_mode(aux); case DISP_CMD_HDMI_GET_HPD_STATUS: return BSP_disp_hdmi_get_hpd_status(aux); case DISP_CMD_HDMI_SUPPORT_MODE: return BSP_disp_hdmi_check_support_mode(aux, para0); case DISP_CMD_HDMI_SET_SRC: return BSP_disp_hdmi_set_src(aux, (__disp_lcdc_src_t)para0); //----vga---- case DISP_CMD_VGA_ON: return BSP_disp_vga_open(aux); case DISP_CMD_VGA_OFF: return BSP_disp_vga_close(aux); case DISP_CMD_VGA_SET_MODE: return BSP_disp_vga_set_mode(aux, (__disp_vga_mode_t)para0); case DISP_CMD_VGA_GET_MODE: return BSP_disp_vga_get_mode(aux); case DISP_CMD_VGA_SET_SRC: return BSP_disp_vga_set_src(aux, (__disp_lcdc_src_t)para0); //----sprite---- case DISP_CMD_SPRITE_OPEN: return BSP_disp_sprite_open(aux); case DISP_CMD_SPRITE_CLOSE: return BSP_disp_sprite_close(aux); case DISP_CMD_SPRITE_SET_FORMAT: return BSP_disp_sprite_set_format(aux, (__disp_pixel_fmt_t)para0, (__disp_pixel_seq_t)para1); case DISP_CMD_SPRITE_GLOBAL_ALPHA_ENABLE: return BSP_disp_sprite_alpha_enable(aux); case DISP_CMD_SPRITE_GLOBAL_ALPHA_DISABLE: return BSP_disp_sprite_alpha_disable(aux); case DISP_CMD_SPRITE_GET_GLOBAL_ALPHA_ENABLE: return BSP_disp_sprite_get_alpha_enable(aux); case DISP_CMD_SPRITE_SET_GLOBAL_ALPHA_VALUE: return BSP_disp_sprite_set_alpha_vale(aux, para0); case DISP_CMD_SPRITE_GET_GLOBAL_ALPHA_VALUE: return BSP_disp_sprite_get_alpha_value(aux); case DISP_CMD_SPRITE_SET_ORDER: return BSP_disp_sprite_set_order(aux, para0,para1); case DISP_CMD_SPRITE_GET_TOP_BLOCK: return BSP_disp_sprite_get_top_block(aux); case DISP_CMD_SPRITE_GET_BOTTOM_BLOCK: return BSP_disp_sprite_get_bottom_block(aux); case DISP_CMD_SPRITE_SET_PALETTE_TBL: return BSP_disp_sprite_set_palette_table(aux, (__u32 * )para0,para1,para2); case DISP_CMD_SPRITE_GET_BLOCK_NUM: return BSP_disp_sprite_get_block_number(aux); case DISP_CMD_SPRITE_BLOCK_REQUEST: return BSP_disp_sprite_block_request(aux, (__disp_sprite_block_para_t*)para0); case DISP_CMD_SPRITE_BLOCK_RELEASE: return BSP_disp_sprite_block_release(aux, para0); case DISP_CMD_SPRITE_BLOCK_SET_SCREEN_WINDOW: return BSP_disp_sprite_block_set_screen_win(aux, para0,(__disp_rect_t *)para1); case DISP_CMD_SPRITE_BLOCK_GET_SCREEN_WINDOW: return BSP_disp_sprite_block_get_srceen_win(aux, para0,(__disp_rect_t *)para1); case DISP_CMD_SPRITE_BLOCK_SET_SOURCE_WINDOW: return BSP_disp_sprite_block_set_src_win(aux, para0,(__disp_rect_t *)para1); case DISP_CMD_SPRITE_BLOCK_GET_SOURCE_WINDOW: return BSP_disp_sprite_block_get_src_win(aux, para0,(__disp_rect_t *)para1); case DISP_CMD_SPRITE_BLOCK_SET_FB: return BSP_disp_sprite_block_set_framebuffer(aux, para0,(__disp_fb_t *)para1); case DISP_CMD_SPRITE_BLOCK_GET_FB: return BSP_disp_sprite_block_get_framebufer(aux, para0,(__disp_fb_t *)para1); case DISP_CMD_SPRITE_BLOCK_SET_TOP: return BSP_disp_sprite_block_set_top(aux, para0); case DISP_CMD_SPRITE_BLOCK_SET_BOTTOM: return BSP_disp_sprite_block_set_bottom(aux, para0); case DISP_CMD_SPRITE_BLOCK_GET_PREV_BLOCK: return BSP_disp_sprite_block_get_pre_block(aux, para0); case DISP_CMD_SPRITE_BLOCK_GET_NEXT_BLOCK: return BSP_disp_sprite_block_get_next_block(aux, para0); case DISP_CMD_SPRITE_BLOCK_GET_PRIO: return BSP_disp_sprite_block_get_prio(aux, para0); case DISP_CMD_SPRITE_BLOCK_OPEN: return BSP_disp_sprite_block_open(aux, para0); case DISP_CMD_SPRITE_BLOCK_CLOSE: return BSP_disp_sprite_block_close(aux, para0); case DISP_CMD_SPRITE_BLOCK_SET_PARA: return BSP_disp_sprite_block_set_para(aux, para0,(__disp_sprite_block_para_t*)para1); case DISP_CMD_SPRITE_BLOCK_GET_PARA: return BSP_disp_sprite_block_get_para(aux, para0,(__disp_sprite_block_para_t*)para1); default: __wrn("not supported display cmd:%x\n",cmd); return eGON2_FAIL; } }