2 * linux/drivers/video/vfb.c -- Virtual frame buffer device
4 * Copyright (C) 2002 James Simmons
6 * Copyright (C) 1997 Geert Uytterhoeven
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file COPYING in the main directory of this archive for
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
18 #include <linux/vmalloc.h>
19 #include <linux/delay.h>
20 #include <linux/interrupt.h>
21 #include <linux/platform_device.h>
24 #include <linux/init.h>
27 * RAM we reserve for the frame buffer. This defines the maximum screen
30 * The default can be overridden if the driver is compiled as a module
33 #define VIDEOMEMSIZE (1*1024*1024) /* 1 MB */
35 static void *videomemory;
36 static u_long videomemorysize = VIDEOMEMSIZE;
37 module_param(videomemorysize, ulong, 0);
38 MODULE_PARM_DESC(videomemorysize, "RAM available to frame buffer (in bytes)");
40 static char *mode_option = NULL;
41 module_param(mode_option, charp, 0);
42 MODULE_PARM_DESC(mode_option, "Preferred video mode (e.g. 640x480-8@60)");
44 static const struct fb_videomode vfb_default = {
54 .vmode = FB_VMODE_NONINTERLACED,
57 static struct fb_fix_screeninfo vfb_fix = {
59 .type = FB_TYPE_PACKED_PIXELS,
60 .visual = FB_VISUAL_PSEUDOCOLOR,
64 .accel = FB_ACCEL_NONE,
67 static bool vfb_enable __initdata = 0; /* disabled by default */
68 module_param(vfb_enable, bool, 0);
69 MODULE_PARM_DESC(vfb_enable, "Enable Virtual FB driver");
71 static int vfb_check_var(struct fb_var_screeninfo *var,
72 struct fb_info *info);
73 static int vfb_set_par(struct fb_info *info);
74 static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
75 u_int transp, struct fb_info *info);
76 static int vfb_pan_display(struct fb_var_screeninfo *var,
77 struct fb_info *info);
78 static int vfb_mmap(struct fb_info *info,
79 struct vm_area_struct *vma);
81 static const struct fb_ops vfb_ops = {
83 .fb_read = fb_sys_read,
84 .fb_write = fb_sys_write,
85 .fb_check_var = vfb_check_var,
86 .fb_set_par = vfb_set_par,
87 .fb_setcolreg = vfb_setcolreg,
88 .fb_pan_display = vfb_pan_display,
89 .fb_fillrect = sys_fillrect,
90 .fb_copyarea = sys_copyarea,
91 .fb_imageblit = sys_imageblit,
99 static u_long get_line_length(int xres_virtual, int bpp)
103 length = xres_virtual * bpp;
104 length = (length + 31) & ~31;
110 * Setting the video mode has been split into two parts.
111 * First part, xxxfb_check_var, must not write anything
112 * to hardware, it should only verify and adjust var.
113 * This means it doesn't alter par but it does use hardware
114 * data from it to check this var.
117 static int vfb_check_var(struct fb_var_screeninfo *var,
118 struct fb_info *info)
123 * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal!
124 * as FB_VMODE_SMOOTH_XPAN is only used internally
127 if (var->vmode & FB_VMODE_CONUPDATE) {
128 var->vmode |= FB_VMODE_YWRAP;
129 var->xoffset = info->var.xoffset;
130 var->yoffset = info->var.yoffset;
134 * Some very basic checks
140 if (var->xres > var->xres_virtual)
141 var->xres_virtual = var->xres;
142 if (var->yres > var->yres_virtual)
143 var->yres_virtual = var->yres;
144 if (var->bits_per_pixel <= 1)
145 var->bits_per_pixel = 1;
146 else if (var->bits_per_pixel <= 8)
147 var->bits_per_pixel = 8;
148 else if (var->bits_per_pixel <= 16)
149 var->bits_per_pixel = 16;
150 else if (var->bits_per_pixel <= 24)
151 var->bits_per_pixel = 24;
152 else if (var->bits_per_pixel <= 32)
153 var->bits_per_pixel = 32;
157 if (var->xres_virtual < var->xoffset + var->xres)
158 var->xres_virtual = var->xoffset + var->xres;
159 if (var->yres_virtual < var->yoffset + var->yres)
160 var->yres_virtual = var->yoffset + var->yres;
166 get_line_length(var->xres_virtual, var->bits_per_pixel);
167 if (line_length * var->yres_virtual > videomemorysize)
171 * Now that we checked it we alter var. The reason being is that the video
172 * mode passed in might not work but slight changes to it might make it
173 * work. This way we let the user know what is acceptable.
175 switch (var->bits_per_pixel) {
180 var->green.offset = 0;
181 var->green.length = 8;
182 var->blue.offset = 0;
183 var->blue.length = 8;
184 var->transp.offset = 0;
185 var->transp.length = 0;
187 case 16: /* RGBA 5551 */
188 if (var->transp.length) {
191 var->green.offset = 5;
192 var->green.length = 5;
193 var->blue.offset = 10;
194 var->blue.length = 5;
195 var->transp.offset = 15;
196 var->transp.length = 1;
197 } else { /* RGB 565 */
200 var->green.offset = 5;
201 var->green.length = 6;
202 var->blue.offset = 11;
203 var->blue.length = 5;
204 var->transp.offset = 0;
205 var->transp.length = 0;
208 case 24: /* RGB 888 */
211 var->green.offset = 8;
212 var->green.length = 8;
213 var->blue.offset = 16;
214 var->blue.length = 8;
215 var->transp.offset = 0;
216 var->transp.length = 0;
218 case 32: /* RGBA 8888 */
221 var->green.offset = 8;
222 var->green.length = 8;
223 var->blue.offset = 16;
224 var->blue.length = 8;
225 var->transp.offset = 24;
226 var->transp.length = 8;
229 var->red.msb_right = 0;
230 var->green.msb_right = 0;
231 var->blue.msb_right = 0;
232 var->transp.msb_right = 0;
237 /* This routine actually sets the video mode. It's in here where we
238 * the hardware state info->par and fix which can be affected by the
239 * change in par. For this driver it doesn't do much.
241 static int vfb_set_par(struct fb_info *info)
243 switch (info->var.bits_per_pixel) {
245 info->fix.visual = FB_VISUAL_MONO01;
248 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
253 info->fix.visual = FB_VISUAL_TRUECOLOR;
257 info->fix.line_length = get_line_length(info->var.xres_virtual,
258 info->var.bits_per_pixel);
264 * Set a single color register. The values supplied are already
265 * rounded down to the hardware's capabilities (according to the
266 * entries in the var structure). Return != 0 for invalid regno.
269 static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
270 u_int transp, struct fb_info *info)
272 if (regno >= 256) /* no. of hw registers */
275 * Program hardware... do anything you want with transp
278 /* grayscale works only partially under directcolor */
279 if (info->var.grayscale) {
280 /* grayscale = 0.30*R + 0.59*G + 0.11*B */
282 (red * 77 + green * 151 + blue * 28) >> 8;
286 * var->{color}.offset contains start of bitfield
287 * var->{color}.length contains length of bitfield
288 * {hardwarespecific} contains width of RAMDAC
289 * cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset)
290 * RAMDAC[X] is programmed to (red, green, blue)
293 * var->{color}.offset is 0 unless the palette index takes less than
294 * bits_per_pixel bits and is stored in the upper
295 * bits of the pixel value
296 * var->{color}.length is set so that 1 << length is the number of available
299 * RAMDAC[X] is programmed to (red, green, blue)
302 * does not use DAC. Usually 3 are present.
303 * var->{color}.offset contains start of bitfield
304 * var->{color}.length contains length of bitfield
305 * cmap is programmed to (red << red.offset) | (green << green.offset) |
306 * (blue << blue.offset) | (transp << transp.offset)
307 * RAMDAC does not exist
309 #define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
310 switch (info->fix.visual) {
311 case FB_VISUAL_TRUECOLOR:
312 case FB_VISUAL_PSEUDOCOLOR:
313 red = CNVT_TOHW(red, info->var.red.length);
314 green = CNVT_TOHW(green, info->var.green.length);
315 blue = CNVT_TOHW(blue, info->var.blue.length);
316 transp = CNVT_TOHW(transp, info->var.transp.length);
318 case FB_VISUAL_DIRECTCOLOR:
319 red = CNVT_TOHW(red, 8); /* expect 8 bit DAC */
320 green = CNVT_TOHW(green, 8);
321 blue = CNVT_TOHW(blue, 8);
322 /* hey, there is bug in transp handling... */
323 transp = CNVT_TOHW(transp, 8);
327 /* Truecolor has hardware independent palette */
328 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
334 v = (red << info->var.red.offset) |
335 (green << info->var.green.offset) |
336 (blue << info->var.blue.offset) |
337 (transp << info->var.transp.offset);
338 switch (info->var.bits_per_pixel) {
342 ((u32 *) (info->pseudo_palette))[regno] = v;
346 ((u32 *) (info->pseudo_palette))[regno] = v;
355 * Pan or Wrap the Display
357 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
360 static int vfb_pan_display(struct fb_var_screeninfo *var,
361 struct fb_info *info)
363 if (var->vmode & FB_VMODE_YWRAP) {
364 if (var->yoffset >= info->var.yres_virtual ||
368 if (var->xoffset + info->var.xres > info->var.xres_virtual ||
369 var->yoffset + info->var.yres > info->var.yres_virtual)
372 info->var.xoffset = var->xoffset;
373 info->var.yoffset = var->yoffset;
374 if (var->vmode & FB_VMODE_YWRAP)
375 info->var.vmode |= FB_VMODE_YWRAP;
377 info->var.vmode &= ~FB_VMODE_YWRAP;
382 * Most drivers don't need their own mmap function
385 static int vfb_mmap(struct fb_info *info,
386 struct vm_area_struct *vma)
388 return remap_vmalloc_range(vma, (void *)info->fix.smem_start, vma->vm_pgoff);
393 * The virtual framebuffer driver is only enabled if explicitly
394 * requested by passing 'video=vfb:' (or any actual options).
396 static int __init vfb_setup(char *options)
410 while ((this_opt = strsep(&options, ",")) != NULL) {
413 /* Test disable for backwards compatibility */
414 if (!strcmp(this_opt, "disable"))
417 mode_option = this_opt;
427 static int vfb_probe(struct platform_device *dev)
429 struct fb_info *info;
430 unsigned int size = PAGE_ALIGN(videomemorysize);
431 int retval = -ENOMEM;
434 * For real video cards we use ioremap.
436 if (!(videomemory = vmalloc_32_user(size)))
439 info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev);
443 info->screen_buffer = videomemory;
444 info->fbops = &vfb_ops;
446 if (!fb_find_mode(&info->var, info, mode_option,
447 NULL, 0, &vfb_default, 8)){
448 fb_err(info, "Unable to find usable video mode.\n");
453 vfb_fix.smem_start = (unsigned long) videomemory;
454 vfb_fix.smem_len = videomemorysize;
456 info->pseudo_palette = info->par;
459 retval = fb_alloc_cmap(&info->cmap, 256, 0);
463 retval = register_framebuffer(info);
466 platform_set_drvdata(dev, info);
470 fb_info(info, "Virtual frame buffer device, using %ldK of video memory\n",
471 videomemorysize >> 10);
474 fb_dealloc_cmap(&info->cmap);
476 framebuffer_release(info);
482 static void vfb_remove(struct platform_device *dev)
484 struct fb_info *info = platform_get_drvdata(dev);
487 unregister_framebuffer(info);
489 fb_dealloc_cmap(&info->cmap);
490 framebuffer_release(info);
494 static struct platform_driver vfb_driver = {
496 .remove_new = vfb_remove,
502 static struct platform_device *vfb_device;
504 static int __init vfb_init(void)
511 if (fb_get_options("vfb", &option))
519 ret = platform_driver_register(&vfb_driver);
522 vfb_device = platform_device_alloc("vfb", 0);
525 ret = platform_device_add(vfb_device);
530 platform_device_put(vfb_device);
531 platform_driver_unregister(&vfb_driver);
538 module_init(vfb_init);
541 static void __exit vfb_exit(void)
543 platform_device_unregister(vfb_device);
544 platform_driver_unregister(&vfb_driver);
547 module_exit(vfb_exit);
549 MODULE_LICENSE("GPL");