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/tty.h>
19 #include <linux/slab.h>
20 #include <linux/vmalloc.h>
21 #include <linux/delay.h>
22 #include <linux/interrupt.h>
23 #include <asm/uaccess.h>
25 #include <linux/init.h>
28 * RAM we reserve for the frame buffer. This defines the maximum screen
31 * The default can be overridden if the driver is compiled as a module
34 #define VIDEOMEMSIZE (1*1024*1024) /* 1 MB */
36 static void *videomemory
;
37 static u_long videomemorysize
= VIDEOMEMSIZE
;
38 MODULE_PARM(videomemorysize
, "l");
40 static struct fb_info fb_info
;
41 static u32 vfb_pseudo_palette
[17];
43 static struct fb_var_screeninfo vfb_default __initdata
= {
52 .activate
= FB_ACTIVATE_TEST
,
62 .vmode
= FB_VMODE_NONINTERLACED
,
65 static struct fb_fix_screeninfo vfb_fix __initdata
= {
67 .type
= FB_TYPE_PACKED_PIXELS
,
68 .visual
= FB_VISUAL_PSEUDOCOLOR
,
72 .accel
= FB_ACCEL_NONE
,
75 static int vfb_enable __initdata
= 0; /* disabled by default */
76 MODULE_PARM(vfb_enable
, "i");
79 * Interface used by the world
82 int vfb_setup(char *);
84 static int vfb_check_var(struct fb_var_screeninfo
*var
,
85 struct fb_info
*info
);
86 static int vfb_set_par(struct fb_info
*info
);
87 static int vfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
88 u_int transp
, struct fb_info
*info
);
89 static int vfb_pan_display(struct fb_var_screeninfo
*var
,
90 struct fb_info
*info
);
91 static int vfb_mmap(struct fb_info
*info
, struct file
*file
,
92 struct vm_area_struct
*vma
);
94 static struct fb_ops vfb_ops
= {
95 .fb_check_var
= vfb_check_var
,
96 .fb_set_par
= vfb_set_par
,
97 .fb_setcolreg
= vfb_setcolreg
,
98 .fb_pan_display
= vfb_pan_display
,
99 .fb_fillrect
= cfb_fillrect
,
100 .fb_copyarea
= cfb_copyarea
,
101 .fb_imageblit
= cfb_imageblit
,
102 .fb_cursor
= soft_cursor
,
110 static u_long
get_line_length(int xres_virtual
, int bpp
)
114 length
= xres_virtual
* bpp
;
115 length
= (length
+ 31) & ~31;
121 * Setting the video mode has been split into two parts.
122 * First part, xxxfb_check_var, must not write anything
123 * to hardware, it should only verify and adjust var.
124 * This means it doesn't alter par but it does use hardware
125 * data from it to check this var.
128 static int vfb_check_var(struct fb_var_screeninfo
*var
,
129 struct fb_info
*info
)
134 * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal!
135 * as FB_VMODE_SMOOTH_XPAN is only used internally
138 if (var
->vmode
& FB_VMODE_CONUPDATE
) {
139 var
->vmode
|= FB_VMODE_YWRAP
;
140 var
->xoffset
= info
->var
.xoffset
;
141 var
->yoffset
= info
->var
.yoffset
;
145 * Some very basic checks
151 if (var
->xres
> var
->xres_virtual
)
152 var
->xres_virtual
= var
->xres
;
153 if (var
->yres
> var
->yres_virtual
)
154 var
->yres_virtual
= var
->yres
;
155 if (var
->bits_per_pixel
<= 1)
156 var
->bits_per_pixel
= 1;
157 else if (var
->bits_per_pixel
<= 8)
158 var
->bits_per_pixel
= 8;
159 else if (var
->bits_per_pixel
<= 16)
160 var
->bits_per_pixel
= 16;
161 else if (var
->bits_per_pixel
<= 24)
162 var
->bits_per_pixel
= 24;
163 else if (var
->bits_per_pixel
<= 32)
164 var
->bits_per_pixel
= 32;
168 if (var
->xres_virtual
< var
->xoffset
+ var
->xres
)
169 var
->xres_virtual
= var
->xoffset
+ var
->xres
;
170 if (var
->yres_virtual
< var
->yoffset
+ var
->yres
)
171 var
->yres_virtual
= var
->yoffset
+ var
->yres
;
177 get_line_length(var
->xres_virtual
, var
->bits_per_pixel
);
178 if (line_length
* var
->yres_virtual
> videomemorysize
)
182 * Now that we checked it we alter var. The reason being is that the video
183 * mode passed in might not work but slight changes to it might make it
184 * work. This way we let the user know what is acceptable.
186 switch (var
->bits_per_pixel
) {
191 var
->green
.offset
= 0;
192 var
->green
.length
= 8;
193 var
->blue
.offset
= 0;
194 var
->blue
.length
= 8;
195 var
->transp
.offset
= 0;
196 var
->transp
.length
= 0;
198 case 16: /* RGBA 5551 */
199 if (var
->transp
.length
) {
202 var
->green
.offset
= 5;
203 var
->green
.length
= 5;
204 var
->blue
.offset
= 10;
205 var
->blue
.length
= 5;
206 var
->transp
.offset
= 15;
207 var
->transp
.length
= 1;
208 } else { /* RGB 565 */
211 var
->green
.offset
= 5;
212 var
->green
.length
= 6;
213 var
->blue
.offset
= 11;
214 var
->blue
.length
= 5;
215 var
->transp
.offset
= 0;
216 var
->transp
.length
= 0;
219 case 24: /* RGB 888 */
222 var
->green
.offset
= 8;
223 var
->green
.length
= 8;
224 var
->blue
.offset
= 16;
225 var
->blue
.length
= 8;
226 var
->transp
.offset
= 0;
227 var
->transp
.length
= 0;
229 case 32: /* RGBA 8888 */
232 var
->green
.offset
= 8;
233 var
->green
.length
= 8;
234 var
->blue
.offset
= 16;
235 var
->blue
.length
= 8;
236 var
->transp
.offset
= 24;
237 var
->transp
.length
= 8;
240 var
->red
.msb_right
= 0;
241 var
->green
.msb_right
= 0;
242 var
->blue
.msb_right
= 0;
243 var
->transp
.msb_right
= 0;
248 /* This routine actually sets the video mode. It's in here where we
249 * the hardware state info->par and fix which can be affected by the
250 * change in par. For this driver it doesn't do much.
252 static int vfb_set_par(struct fb_info
*info
)
254 info
->fix
.line_length
= get_line_length(info
->var
.xres_virtual
,
255 info
->var
.bits_per_pixel
);
260 * Set a single color register. The values supplied are already
261 * rounded down to the hardware's capabilities (according to the
262 * entries in the var structure). Return != 0 for invalid regno.
265 static int vfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
266 u_int transp
, struct fb_info
*info
)
268 if (regno
>= 256) /* no. of hw registers */
271 * Program hardware... do anything you want with transp
274 /* grayscale works only partially under directcolor */
275 if (info
->var
.grayscale
) {
276 /* grayscale = 0.30*R + 0.59*G + 0.11*B */
278 (red
* 77 + green
* 151 + blue
* 28) >> 8;
282 * var->{color}.offset contains start of bitfield
283 * var->{color}.length contains length of bitfield
284 * {hardwarespecific} contains width of RAMDAC
285 * cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset)
286 * RAMDAC[X] is programmed to (red, green, blue)
289 * uses offset = 0 && length = RAMDAC register width.
290 * var->{color}.offset is 0
291 * var->{color}.length contains widht of DAC
293 * RAMDAC[X] is programmed to (red, green, blue)
295 * does not use DAC. Usually 3 are present.
296 * var->{color}.offset contains start of bitfield
297 * var->{color}.length contains length of bitfield
298 * cmap is programmed to (red << red.offset) | (green << green.offset) |
299 * (blue << blue.offset) | (transp << transp.offset)
300 * RAMDAC does not exist
302 #define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
303 switch (info
->fix
.visual
) {
304 case FB_VISUAL_TRUECOLOR
:
305 case FB_VISUAL_PSEUDOCOLOR
:
306 red
= CNVT_TOHW(red
, info
->var
.red
.length
);
307 green
= CNVT_TOHW(green
, info
->var
.green
.length
);
308 blue
= CNVT_TOHW(blue
, info
->var
.blue
.length
);
309 transp
= CNVT_TOHW(transp
, info
->var
.transp
.length
);
311 case FB_VISUAL_DIRECTCOLOR
:
312 red
= CNVT_TOHW(red
, 8); /* expect 8 bit DAC */
313 green
= CNVT_TOHW(green
, 8);
314 blue
= CNVT_TOHW(blue
, 8);
315 /* hey, there is bug in transp handling... */
316 transp
= CNVT_TOHW(transp
, 8);
320 /* Truecolor has hardware independent palette */
321 if (info
->fix
.visual
== FB_VISUAL_TRUECOLOR
) {
327 v
= (red
<< info
->var
.red
.offset
) |
328 (green
<< info
->var
.green
.offset
) |
329 (blue
<< info
->var
.blue
.offset
) |
330 (transp
<< info
->var
.transp
.offset
);
331 switch (info
->var
.bits_per_pixel
) {
335 ((u32
*) (info
->pseudo_palette
))[regno
] = v
;
339 ((u32
*) (info
->pseudo_palette
))[regno
] = v
;
348 * Pan or Wrap the Display
350 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
353 static int vfb_pan_display(struct fb_var_screeninfo
*var
,
354 struct fb_info
*info
)
356 if (var
->vmode
& FB_VMODE_YWRAP
) {
358 || var
->yoffset
>= info
->var
.yres_virtual
362 if (var
->xoffset
+ var
->xres
> info
->var
.xres_virtual
||
363 var
->yoffset
+ var
->yres
> info
->var
.yres_virtual
)
366 info
->var
.xoffset
= var
->xoffset
;
367 info
->var
.yoffset
= var
->yoffset
;
368 if (var
->vmode
& FB_VMODE_YWRAP
)
369 info
->var
.vmode
|= FB_VMODE_YWRAP
;
371 info
->var
.vmode
&= ~FB_VMODE_YWRAP
;
376 * Most drivers don't need their own mmap function
379 static int vfb_mmap(struct fb_info
*info
, struct file
*file
,
380 struct vm_area_struct
*vma
)
385 int __init
vfb_setup(char *options
)
391 if (!options
|| !*options
)
394 while ((this_opt
= strsep(&options
, ",")) != NULL
) {
397 if (!strncmp(this_opt
, "disable", 7))
407 int __init
vfb_init(void)
415 * For real video cards we use ioremap.
417 if (!(videomemory
= vmalloc(videomemorysize
)))
421 * VFB must clear memory to prevent kernel info
422 * leakage into userspace
423 * VGA-based drivers MUST NOT clear memory if
424 * they want to be able to take over vgacon
426 memset(videomemory
, 0, videomemorysize
);
428 fb_info
.screen_base
= videomemory
;
429 fb_info
.fbops
= &vfb_ops
;
431 retval
= fb_find_mode(&fb_info
.var
, &fb_info
, NULL
,
434 if (!retval
|| (retval
== 4))
435 fb_info
.var
= vfb_default
;
436 fb_info
.fix
= vfb_fix
;
437 fb_info
.pseudo_palette
= &vfb_pseudo_palette
;
438 fb_info
.flags
= FBINFO_FLAG_DEFAULT
;
440 fb_alloc_cmap(&fb_info
.cmap
, 256, 0);
442 if (register_framebuffer(&fb_info
) < 0) {
448 "fb%d: Virtual frame buffer device, using %ldK of video memory\n",
449 fb_info
.node
, videomemorysize
>> 10);
455 static void __exit
vfb_cleanup(void)
457 unregister_framebuffer(&fb_info
);
461 module_init(vfb_init
);
462 module_exit(vfb_cleanup
);
464 MODULE_LICENSE("GPL");