int s3cfb_close_fifo(int id, int (*do_priv) (void *), void *param) { struct s3cfb_global *fbdev = get_fimd_global(id); struct s3cfb_window *win = fbdev->fb[id]->par; win->path = DATA_PATH_DMA; dev_dbg(fbdev->dev, "[fb%d] close fifo\n", win->id); if (do_priv) { s3cfb_display_off(fbdev); if (do_priv(param)) { dev_err(fbdev->dev, "failed to run for" "private fifo close\n"); s3cfb_enable_window(fbdev, id); s3cfb_display_on(fbdev); return -EFAULT; } s3cfb_disable_window(fbdev, id); s3cfb_disable_localpath(fbdev, id); s3cfb_display_on(fbdev); } else { s3cfb_disable_window(fbdev, id); s3cfb_disable_localpath(fbdev, id); } return 0; }
static int s3cfb_sysfs_store_win_power(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct s3c_platform_fb *pdata = to_fb_plat(dev); char temp[4] = { 0, }; const char *p = buf; int id, to; while (*p != '\0') { if (!isspace(*p)) strncat(temp, p, 1); p++; } if (strlen(temp) != 2) return -EINVAL; id = simple_strtoul(temp, NULL, 10) / 10; to = simple_strtoul(temp, NULL, 10) % 10; if (id < 0 || id > pdata->nr_wins) return -EINVAL; if (to != 0 && to != 1) return -EINVAL; if (to == 0) s3cfb_disable_window(id); else s3cfb_enable_window(id); return len; }
/* new function to close fifo */ int s3cfb_close_fifo(int id, int (*do_priv)(void *), void *param, int sleep) { struct s3cfb_window *win = ctrl->fb[id]->par; dev_dbg(ctrl->dev, "[fb%d] close fifo\n", win->id); if (sleep) win->path = DATA_PATH_FIFO; else win->path = DATA_PATH_DMA; s3cfb_set_vsync_interrupt(ctrl, 1); s3cfb_wait_for_vsync(); s3cfb_set_vsync_interrupt(ctrl, 0); s3cfb_display_off(ctrl); s3cfb_check_line_count(ctrl); s3cfb_disable_window(id); if (do_priv) { if (do_priv(param)) { dev_err(ctrl->dev, "failed to run for private fifo close\n"); s3cfb_enable_window(id); s3cfb_display_on(ctrl); return -EFAULT; } } s3cfb_display_on(ctrl); return 0; }
static int s3cfb_blank(int blank_mode, struct fb_info *fb) { struct s3cfb_window *win = fb->par; dev_dbg(ctrl->dev, "change blank mode\n"); switch (blank_mode) { case FB_BLANK_UNBLANK: if (fb->fix.smem_start) s3cfb_enable_window(win->id); else dev_info(ctrl->dev, "[fb%d] no allocated memory for unblank\n", win->id); break; case FB_BLANK_POWERDOWN: s3cfb_disable_window(win->id); break; default: dev_dbg(ctrl->dev, "unsupported blank mode\n"); return -EINVAL; } return 0; }
/* for backward compatibilities */ void s3cfb_enable_dma(int id) { struct s3cfb_window *win = ctrl->fb[id]->par; win->path = DATA_PATH_DMA; s3cfb_set_vsync_interrupt(ctrl, 1); s3cfb_wait_for_vsync(); s3cfb_set_vsync_interrupt(ctrl, 0); s3cfb_disable_window(id); s3cfb_display_off(ctrl); s3cfb_set_window_control(ctrl, id); s3cfb_display_on(ctrl); }
static int s3cfb_release_window(struct fb_info *fb) { struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); struct s3cfb_window *win = fb->par; if (win->id != pdata->default_win) { s3cfb_disable_window(win->id); s3cfb_unmap_video_memory(fb); s3cfb_set_buffer_address(fbdev, win->id); } win->x = 0; win->y = 0; return 0; }
int s3cfb_blank(int blank_mode, struct fb_info *fb) { struct s3cfb_window *win = fb->par; struct s3cfb_window *tmp_win; struct s3cfb_global *fbdev = get_fimd_global(fb->node); struct platform_device *pdev = to_platform_device(fbdev->dev); struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); int enabled_win = 0; int i; dev_dbg(fbdev->dev, "change blank mode\n"); switch (blank_mode) { case FB_BLANK_UNBLANK: if (!fb->fix.smem_start) { dev_info(fbdev->dev, \ "[fb%d] no allocated memory for unblank\n", win->id); break; } if (win->power_state == FB_BLANK_UNBLANK) { dev_info(fbdev->dev, \ "[fb%d] already in FB_BLANK_UNBLANK\n", win->id); break; } else { s3cfb_update_power_state(fbdev, win->id, FB_BLANK_UNBLANK); } enabled_win = atomic_read(&fbdev->enabled_win); if (enabled_win == 0) { pdata->clk_on(pdev, &fbdev->clock); s3cfb_init_global(fbdev); s3cfb_set_clock(fbdev); for (i = 0; i < pdata->nr_wins; i++) { tmp_win = fbdev->fb[i]->par; if (tmp_win->owner == DMA_MEM_FIMD) s3cfb_set_win_params(fbdev, tmp_win->id); } } if (win->enabled) /* from FB_BLANK_NORMAL */ s3cfb_win_map_off(fbdev, win->id); else /* from FB_BLANK_POWERDOWN */ s3cfb_enable_window(fbdev, win->id); if (enabled_win == 0) { s3cfb_display_on(fbdev); if (pdata->backlight_on) pdata->backlight_on(pdev); if (pdata->lcd_on) pdata->lcd_on(pdev); if (fbdev->lcd->init_ldi) fbdev->lcd->init_ldi(); } break; case FB_BLANK_NORMAL: if (win->power_state == FB_BLANK_NORMAL) { dev_info(fbdev->dev, \ "[fb%d] already in FB_BLANK_NORMAL\n", win->id); break; } else { s3cfb_update_power_state(fbdev, win->id, FB_BLANK_NORMAL); } enabled_win = atomic_read(&fbdev->enabled_win); if (enabled_win == 0) { pdata->clk_on(pdev, &fbdev->clock); s3cfb_init_global(fbdev); s3cfb_set_clock(fbdev); for (i = 0; i < pdata->nr_wins; i++) { tmp_win = fbdev->fb[i]->par; if (tmp_win->owner == DMA_MEM_FIMD) s3cfb_set_win_params(fbdev, tmp_win->id); } } s3cfb_win_map_on(fbdev, win->id, 0x0); if (!win->enabled) /* from FB_BLANK_POWERDOWN */ s3cfb_enable_window(fbdev, win->id); if (enabled_win == 0) { s3cfb_display_on(fbdev); if (pdata->backlight_on) pdata->backlight_on(pdev); if (pdata->lcd_on) pdata->lcd_on(pdev); if (fbdev->lcd->init_ldi) fbdev->lcd->init_ldi(); } break; case FB_BLANK_POWERDOWN: if (win->power_state == FB_BLANK_POWERDOWN) { dev_info(fbdev->dev, \ "[fb%d] already in FB_BLANK_POWERDOWN\n", win->id); break; } else { s3cfb_update_power_state(fbdev, win->id, FB_BLANK_POWERDOWN); } s3cfb_disable_window(fbdev, win->id); s3cfb_win_map_off(fbdev, win->id); if (atomic_read(&fbdev->enabled_win) == 0) { if (pdata->backlight_off) pdata->backlight_off(pdev); if (fbdev->lcd->deinit_ldi) fbdev->lcd->deinit_ldi(); if (pdata->lcd_off) pdata->lcd_off(pdev); s3cfb_display_off(fbdev); pdata->clk_off(pdev, &fbdev->clock); } break; case FB_BLANK_VSYNC_SUSPEND: /* fall through */ case FB_BLANK_HSYNC_SUSPEND: /* fall through */ default: dev_dbg(fbdev->dev, "unsupported blank mode\n"); return -EINVAL; } return 0; }
int s3cfb_direct_ioctl(int id, unsigned int cmd, unsigned long arg) { struct s3cfb_global *fbdev = get_fimd_global(id); struct fb_info *fb = fbdev->fb[id]; struct fb_var_screeninfo *var = &fb->var; struct fb_fix_screeninfo *fix = &fb->fix; struct s3cfb_window *win = fb->par; struct s3cfb_lcd *lcd = fbdev->lcd; struct s3cfb_user_window user_win; void *argp = (void *)arg; int ret = 0; switch (cmd) { case FBIOGET_FSCREENINFO: ret = memcpy(argp, &fb->fix, sizeof(fb->fix)) ? 0 : -EFAULT; break; case FBIOGET_VSCREENINFO: ret = memcpy(argp, &fb->var, sizeof(fb->var)) ? 0 : -EFAULT; break; case FBIOPUT_VSCREENINFO: ret = s3cfb_check_var((struct fb_var_screeninfo *)argp, fb); if (ret) { dev_err(fbdev->dev, "invalid vscreeninfo\n"); break; } ret = memcpy(&fb->var, (struct fb_var_screeninfo *)argp, sizeof(fb->var)) ? 0 : -EFAULT; if (ret) { dev_err(fbdev->dev, "failed to put new vscreeninfo\n"); break; } fix->line_length = var->xres_virtual * var->bits_per_pixel / 8; fix->smem_len = fix->line_length * var->yres_virtual; s3cfb_set_win_params(fbdev, id); break; case S3CFB_WIN_POSITION: ret = memcpy(&user_win, (struct s3cfb_user_window __user *)arg, sizeof(user_win)) ? 0 : -EFAULT; if (ret) { dev_err(fbdev->dev, "failed to S3CFB_WIN_POSITION\n"); break; } if (user_win.x < 0) user_win.x = 0; if (user_win.y < 0) user_win.y = 0; if (user_win.x + var->xres > lcd->width) win->x = lcd->width - var->xres; else win->x = user_win.x; if (user_win.y + var->yres > lcd->height) win->y = lcd->height - var->yres; else win->y = user_win.y; s3cfb_set_window_position(fbdev, win->id); break; case S3CFB_GET_LCD_WIDTH: ret = memcpy(argp, &lcd->width, sizeof(int)) ? 0 : -EFAULT; if (ret) { dev_err(fbdev->dev, "failed to S3CFB_GET_LCD_WIDTH\n"); break; } break; case S3CFB_GET_LCD_HEIGHT: ret = memcpy(argp, &lcd->height, sizeof(int)) ? 0 : -EFAULT; if (ret) { dev_err(fbdev->dev, "failed to S3CFB_GET_LCD_HEIGHT\n"); break; } break; case S3CFB_SET_WRITEBACK: if ((u32)argp == 1) fbdev->output = OUTPUT_WB_RGB; else fbdev->output = OUTPUT_RGB; s3cfb_set_output(fbdev); break; case S3CFB_SET_WIN_ON: s3cfb_enable_window(fbdev, id); break; case S3CFB_SET_WIN_OFF: s3cfb_disable_window(fbdev, id); break; case S3CFB_SET_WIN_PATH: win->path = (enum s3cfb_data_path_t)argp; break; case S3CFB_SET_WIN_ADDR: fix->smem_start = (unsigned long)argp; s3cfb_set_buffer_address(fbdev, id); break; case S3CFB_SET_WIN_MEM: win->owner = (enum s3cfb_mem_owner_t)argp; break; case S3CFB_SET_VSYNC_INT: if (argp) s3cfb_set_global_interrupt(fbdev, 1); s3cfb_set_vsync_interrupt(fbdev, (int)argp); break; case S3CFB_GET_VSYNC_INT_STATUS: ret = s3cfb_get_vsync_interrupt(fbdev); break; default: ret = s3cfb_ioctl(fb, cmd, arg); break; } return ret; }
static int s3cfb_ioctl(struct fb_info *fb, unsigned int cmd, unsigned long arg) { struct s3c_platform_fb *pdata = to_fb_plat(ctrl->dev); struct fb_var_screeninfo *var = &fb->var; struct s3cfb_window *win = fb->par, *win_temp; struct s3cfb_lcd *lcd = ctrl->lcd; int ret = 0, i; union { struct s3cfb_user_window user_window; struct s3cfb_user_plane_alpha user_alpha; struct s3cfb_user_chroma user_chroma; int vsync; } p; switch (cmd) { case FBIO_WAITFORVSYNC: s3cfb_wait_for_vsync(); break; case S3CFB_WIN_ON: s3cfb_enable_window(win->id); break; case S3CFB_WIN_OFF: s3cfb_disable_window(win->id); break; case S3CFB_WIN_OFF_ALL: for (i = 0; i < pdata->nr_wins; i++) { win_temp = ctrl->fb[i]->par; s3cfb_disable_window(win_temp->id); } break; case S3CFB_WIN_POSITION: if (copy_from_user(&p.user_window, (struct s3cfb_user_window __user *) arg, sizeof(p.user_window))) ret = -EFAULT; else { if (p.user_window.x < 0) p.user_window.x = 0; if (p.user_window.y < 0) p.user_window.y = 0; if (p.user_window.x + var->xres > lcd->width) win->x = lcd->width - var->xres; else win->x = p.user_window.x; if (p.user_window.y + var->yres > lcd->height) win->y = lcd->height - var->yres; else win->y = p.user_window.y; s3cfb_set_window_position(ctrl, win->id); } break; case S3CFB_WIN_SET_PLANE_ALPHA: if (copy_from_user(&p.user_alpha, (struct s3cfb_user_plane_alpha __user *) arg, sizeof(p.user_alpha))) ret = -EFAULT; else { win->alpha.mode = PLANE_BLENDING; win->alpha.channel = p.user_alpha.channel; win->alpha.value = S3CFB_AVALUE(p.user_alpha.red, p.user_alpha.green, p.user_alpha.blue); s3cfb_set_alpha_blending(ctrl, win->id); } break; case S3CFB_WIN_SET_CHROMA: if (copy_from_user(&p.user_chroma, (struct s3cfb_user_chroma __user *) arg, sizeof(p.user_chroma))) ret = -EFAULT; else { win->chroma.enabled = p.user_chroma.enabled; win->chroma.key = S3CFB_CHROMA(p.user_chroma.red, p.user_chroma.green, p.user_chroma.blue); s3cfb_set_chroma_key(ctrl, win->id); } break; case S3CFB_SET_VSYNC_INT: if (get_user(p.vsync, (int __user *) arg)) ret = -EFAULT; else { if (p.vsync) s3cfb_set_global_interrupt(ctrl, 1); s3cfb_set_vsync_interrupt(ctrl, p.vsync); } break; } return ret; }