blob: a9b99b01bd8e377f2656058bd29b09accb7ef6ea [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/video/vfb.c -- Virtual frame buffer device
3 *
4 * Copyright (C) 2002 James Simmons
5 *
6 * Copyright (C) 1997 Geert Uytterhoeven
7 *
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
10 * more details.
11 */
12
13#include <linux/module.h>
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/string.h>
17#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/slab.h>
19#include <linux/vmalloc.h>
20#include <linux/delay.h>
21#include <linux/interrupt.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010022#include <linux/platform_device.h>
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/uaccess.h>
25#include <linux/fb.h>
26#include <linux/init.h>
27
28 /*
29 * RAM we reserve for the frame buffer. This defines the maximum screen
30 * size
31 *
32 * The default can be overridden if the driver is compiled as a module
33 */
34
35#define VIDEOMEMSIZE (1*1024*1024) /* 1 MB */
36
37static void *videomemory;
38static u_long videomemorysize = VIDEOMEMSIZE;
39module_param(videomemorysize, ulong, 0);
40
41static struct fb_var_screeninfo vfb_default __initdata = {
42 .xres = 640,
43 .yres = 480,
44 .xres_virtual = 640,
45 .yres_virtual = 480,
46 .bits_per_pixel = 8,
47 .red = { 0, 8, 0 },
48 .green = { 0, 8, 0 },
49 .blue = { 0, 8, 0 },
50 .activate = FB_ACTIVATE_TEST,
51 .height = -1,
52 .width = -1,
53 .pixclock = 20000,
54 .left_margin = 64,
55 .right_margin = 64,
56 .upper_margin = 32,
57 .lower_margin = 32,
58 .hsync_len = 64,
59 .vsync_len = 2,
60 .vmode = FB_VMODE_NONINTERLACED,
61};
62
63static struct fb_fix_screeninfo vfb_fix __initdata = {
64 .id = "Virtual FB",
65 .type = FB_TYPE_PACKED_PIXELS,
66 .visual = FB_VISUAL_PSEUDOCOLOR,
67 .xpanstep = 1,
68 .ypanstep = 1,
69 .ywrapstep = 1,
70 .accel = FB_ACCEL_NONE,
71};
72
73static int vfb_enable __initdata = 0; /* disabled by default */
74module_param(vfb_enable, bool, 0);
75
76static int vfb_check_var(struct fb_var_screeninfo *var,
77 struct fb_info *info);
78static int vfb_set_par(struct fb_info *info);
79static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
80 u_int transp, struct fb_info *info);
81static int vfb_pan_display(struct fb_var_screeninfo *var,
82 struct fb_info *info);
Christoph Hellwig216d5262006-01-14 13:21:25 -080083static int vfb_mmap(struct fb_info *info,
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 struct vm_area_struct *vma);
85
86static struct fb_ops vfb_ops = {
87 .fb_check_var = vfb_check_var,
88 .fb_set_par = vfb_set_par,
89 .fb_setcolreg = vfb_setcolreg,
90 .fb_pan_display = vfb_pan_display,
91 .fb_fillrect = cfb_fillrect,
92 .fb_copyarea = cfb_copyarea,
93 .fb_imageblit = cfb_imageblit,
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 .fb_mmap = vfb_mmap,
95};
96
97 /*
98 * Internal routines
99 */
100
101static u_long get_line_length(int xres_virtual, int bpp)
102{
103 u_long length;
104
105 length = xres_virtual * bpp;
106 length = (length + 31) & ~31;
107 length >>= 3;
108 return (length);
109}
110
111 /*
112 * Setting the video mode has been split into two parts.
113 * First part, xxxfb_check_var, must not write anything
114 * to hardware, it should only verify and adjust var.
115 * This means it doesn't alter par but it does use hardware
116 * data from it to check this var.
117 */
118
119static int vfb_check_var(struct fb_var_screeninfo *var,
120 struct fb_info *info)
121{
122 u_long line_length;
123
124 /*
125 * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal!
126 * as FB_VMODE_SMOOTH_XPAN is only used internally
127 */
128
129 if (var->vmode & FB_VMODE_CONUPDATE) {
130 var->vmode |= FB_VMODE_YWRAP;
131 var->xoffset = info->var.xoffset;
132 var->yoffset = info->var.yoffset;
133 }
134
135 /*
136 * Some very basic checks
137 */
138 if (!var->xres)
139 var->xres = 1;
140 if (!var->yres)
141 var->yres = 1;
142 if (var->xres > var->xres_virtual)
143 var->xres_virtual = var->xres;
144 if (var->yres > var->yres_virtual)
145 var->yres_virtual = var->yres;
146 if (var->bits_per_pixel <= 1)
147 var->bits_per_pixel = 1;
148 else if (var->bits_per_pixel <= 8)
149 var->bits_per_pixel = 8;
150 else if (var->bits_per_pixel <= 16)
151 var->bits_per_pixel = 16;
152 else if (var->bits_per_pixel <= 24)
153 var->bits_per_pixel = 24;
154 else if (var->bits_per_pixel <= 32)
155 var->bits_per_pixel = 32;
156 else
157 return -EINVAL;
158
159 if (var->xres_virtual < var->xoffset + var->xres)
160 var->xres_virtual = var->xoffset + var->xres;
161 if (var->yres_virtual < var->yoffset + var->yres)
162 var->yres_virtual = var->yoffset + var->yres;
163
164 /*
165 * Memory limit
166 */
167 line_length =
168 get_line_length(var->xres_virtual, var->bits_per_pixel);
169 if (line_length * var->yres_virtual > videomemorysize)
170 return -ENOMEM;
171
172 /*
173 * Now that we checked it we alter var. The reason being is that the video
174 * mode passed in might not work but slight changes to it might make it
175 * work. This way we let the user know what is acceptable.
176 */
177 switch (var->bits_per_pixel) {
178 case 1:
179 case 8:
180 var->red.offset = 0;
181 var->red.length = 8;
182 var->green.offset = 0;
183 var->green.length = 8;
184 var->blue.offset = 0;
185 var->blue.length = 8;
186 var->transp.offset = 0;
187 var->transp.length = 0;
188 break;
189 case 16: /* RGBA 5551 */
190 if (var->transp.length) {
191 var->red.offset = 0;
192 var->red.length = 5;
193 var->green.offset = 5;
194 var->green.length = 5;
195 var->blue.offset = 10;
196 var->blue.length = 5;
197 var->transp.offset = 15;
198 var->transp.length = 1;
199 } else { /* RGB 565 */
200 var->red.offset = 0;
201 var->red.length = 5;
202 var->green.offset = 5;
203 var->green.length = 6;
204 var->blue.offset = 11;
205 var->blue.length = 5;
206 var->transp.offset = 0;
207 var->transp.length = 0;
208 }
209 break;
210 case 24: /* RGB 888 */
211 var->red.offset = 0;
212 var->red.length = 8;
213 var->green.offset = 8;
214 var->green.length = 8;
215 var->blue.offset = 16;
216 var->blue.length = 8;
217 var->transp.offset = 0;
218 var->transp.length = 0;
219 break;
220 case 32: /* RGBA 8888 */
221 var->red.offset = 0;
222 var->red.length = 8;
223 var->green.offset = 8;
224 var->green.length = 8;
225 var->blue.offset = 16;
226 var->blue.length = 8;
227 var->transp.offset = 24;
228 var->transp.length = 8;
229 break;
230 }
231 var->red.msb_right = 0;
232 var->green.msb_right = 0;
233 var->blue.msb_right = 0;
234 var->transp.msb_right = 0;
235
236 return 0;
237}
238
239/* This routine actually sets the video mode. It's in here where we
240 * the hardware state info->par and fix which can be affected by the
241 * change in par. For this driver it doesn't do much.
242 */
243static int vfb_set_par(struct fb_info *info)
244{
245 info->fix.line_length = get_line_length(info->var.xres_virtual,
246 info->var.bits_per_pixel);
247 return 0;
248}
249
250 /*
251 * Set a single color register. The values supplied are already
252 * rounded down to the hardware's capabilities (according to the
253 * entries in the var structure). Return != 0 for invalid regno.
254 */
255
256static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
257 u_int transp, struct fb_info *info)
258{
259 if (regno >= 256) /* no. of hw registers */
260 return 1;
261 /*
262 * Program hardware... do anything you want with transp
263 */
264
265 /* grayscale works only partially under directcolor */
266 if (info->var.grayscale) {
267 /* grayscale = 0.30*R + 0.59*G + 0.11*B */
268 red = green = blue =
269 (red * 77 + green * 151 + blue * 28) >> 8;
270 }
271
272 /* Directcolor:
273 * var->{color}.offset contains start of bitfield
274 * var->{color}.length contains length of bitfield
275 * {hardwarespecific} contains width of RAMDAC
276 * cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset)
277 * RAMDAC[X] is programmed to (red, green, blue)
278 *
279 * Pseudocolor:
280 * uses offset = 0 && length = RAMDAC register width.
281 * var->{color}.offset is 0
282 * var->{color}.length contains widht of DAC
283 * cmap is not used
284 * RAMDAC[X] is programmed to (red, green, blue)
285 * Truecolor:
286 * does not use DAC. Usually 3 are present.
287 * var->{color}.offset contains start of bitfield
288 * var->{color}.length contains length of bitfield
289 * cmap is programmed to (red << red.offset) | (green << green.offset) |
290 * (blue << blue.offset) | (transp << transp.offset)
291 * RAMDAC does not exist
292 */
293#define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
294 switch (info->fix.visual) {
295 case FB_VISUAL_TRUECOLOR:
296 case FB_VISUAL_PSEUDOCOLOR:
297 red = CNVT_TOHW(red, info->var.red.length);
298 green = CNVT_TOHW(green, info->var.green.length);
299 blue = CNVT_TOHW(blue, info->var.blue.length);
300 transp = CNVT_TOHW(transp, info->var.transp.length);
301 break;
302 case FB_VISUAL_DIRECTCOLOR:
303 red = CNVT_TOHW(red, 8); /* expect 8 bit DAC */
304 green = CNVT_TOHW(green, 8);
305 blue = CNVT_TOHW(blue, 8);
306 /* hey, there is bug in transp handling... */
307 transp = CNVT_TOHW(transp, 8);
308 break;
309 }
310#undef CNVT_TOHW
311 /* Truecolor has hardware independent palette */
312 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
313 u32 v;
314
315 if (regno >= 16)
316 return 1;
317
318 v = (red << info->var.red.offset) |
319 (green << info->var.green.offset) |
320 (blue << info->var.blue.offset) |
321 (transp << info->var.transp.offset);
322 switch (info->var.bits_per_pixel) {
323 case 8:
324 break;
325 case 16:
326 ((u32 *) (info->pseudo_palette))[regno] = v;
327 break;
328 case 24:
329 case 32:
330 ((u32 *) (info->pseudo_palette))[regno] = v;
331 break;
332 }
333 return 0;
334 }
335 return 0;
336}
337
338 /*
339 * Pan or Wrap the Display
340 *
341 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
342 */
343
344static int vfb_pan_display(struct fb_var_screeninfo *var,
345 struct fb_info *info)
346{
347 if (var->vmode & FB_VMODE_YWRAP) {
348 if (var->yoffset < 0
349 || var->yoffset >= info->var.yres_virtual
350 || var->xoffset)
351 return -EINVAL;
352 } else {
353 if (var->xoffset + var->xres > info->var.xres_virtual ||
354 var->yoffset + var->yres > info->var.yres_virtual)
355 return -EINVAL;
356 }
357 info->var.xoffset = var->xoffset;
358 info->var.yoffset = var->yoffset;
359 if (var->vmode & FB_VMODE_YWRAP)
360 info->var.vmode |= FB_VMODE_YWRAP;
361 else
362 info->var.vmode &= ~FB_VMODE_YWRAP;
363 return 0;
364}
365
366 /*
367 * Most drivers don't need their own mmap function
368 */
369
Christoph Hellwig216d5262006-01-14 13:21:25 -0800370static int vfb_mmap(struct fb_info *info,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 struct vm_area_struct *vma)
372{
373 return -EINVAL;
374}
375
376#ifndef MODULE
377static int __init vfb_setup(char *options)
378{
379 char *this_opt;
380
381 vfb_enable = 1;
382
383 if (!options || !*options)
384 return 1;
385
386 while ((this_opt = strsep(&options, ",")) != NULL) {
387 if (!*this_opt)
388 continue;
389 if (!strncmp(this_opt, "disable", 7))
390 vfb_enable = 0;
391 }
392 return 1;
393}
394#endif /* MODULE */
395
396 /*
397 * Initialisation
398 */
399
Russell King3ae5eae2005-11-09 22:32:44 +0000400static int __init vfb_probe(struct platform_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct fb_info *info;
403 int retval = -ENOMEM;
404
405 /*
406 * For real video cards we use ioremap.
407 */
408 if (!(videomemory = vmalloc(videomemorysize)))
409 return retval;
410
411 /*
412 * VFB must clear memory to prevent kernel info
413 * leakage into userspace
414 * VGA-based drivers MUST NOT clear memory if
415 * they want to be able to take over vgacon
416 */
417 memset(videomemory, 0, videomemorysize);
418
419 info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev);
420 if (!info)
421 goto err;
422
423 info->screen_base = (char __iomem *)videomemory;
424 info->fbops = &vfb_ops;
425
426 retval = fb_find_mode(&info->var, info, NULL,
427 NULL, 0, NULL, 8);
428
429 if (!retval || (retval == 4))
430 info->var = vfb_default;
431 info->fix = vfb_fix;
432 info->pseudo_palette = info->par;
433 info->par = NULL;
434 info->flags = FBINFO_FLAG_DEFAULT;
435
436 retval = fb_alloc_cmap(&info->cmap, 256, 0);
437 if (retval < 0)
438 goto err1;
439
440 retval = register_framebuffer(info);
441 if (retval < 0)
442 goto err2;
Russell King3ae5eae2005-11-09 22:32:44 +0000443 platform_set_drvdata(dev, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
445 printk(KERN_INFO
446 "fb%d: Virtual frame buffer device, using %ldK of video memory\n",
447 info->node, videomemorysize >> 10);
448 return 0;
449err2:
450 fb_dealloc_cmap(&info->cmap);
451err1:
452 framebuffer_release(info);
453err:
454 vfree(videomemory);
455 return retval;
456}
457
Russell King3ae5eae2005-11-09 22:32:44 +0000458static int vfb_remove(struct platform_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Russell King3ae5eae2005-11-09 22:32:44 +0000460 struct fb_info *info = platform_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 if (info) {
463 unregister_framebuffer(info);
464 vfree(videomemory);
465 framebuffer_release(info);
466 }
467 return 0;
468}
469
Russell King3ae5eae2005-11-09 22:32:44 +0000470static struct platform_driver vfb_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 .probe = vfb_probe,
472 .remove = vfb_remove,
Russell King3ae5eae2005-11-09 22:32:44 +0000473 .driver = {
474 .name = "vfb",
475 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476};
477
Antonino A. Daplas20cecf62006-06-26 00:26:34 -0700478static struct platform_device *vfb_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480static int __init vfb_init(void)
481{
482 int ret = 0;
483
484#ifndef MODULE
485 char *option = NULL;
486
487 if (fb_get_options("vfb", &option))
488 return -ENODEV;
489 vfb_setup(option);
490#endif
491
492 if (!vfb_enable)
493 return -ENXIO;
494
Russell King3ae5eae2005-11-09 22:32:44 +0000495 ret = platform_driver_register(&vfb_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 if (!ret) {
Antonino A. Daplas20cecf62006-06-26 00:26:34 -0700498 vfb_device = platform_device_alloc("vfb", 0);
499
500 if (vfb_device)
501 ret = platform_device_add(vfb_device);
502 else
503 ret = -ENOMEM;
504
505 if (ret) {
506 platform_device_put(vfb_device);
Russell King3ae5eae2005-11-09 22:32:44 +0000507 platform_driver_unregister(&vfb_driver);
Antonino A. Daplas20cecf62006-06-26 00:26:34 -0700508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Antonino A. Daplas20cecf62006-06-26 00:26:34 -0700510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 return ret;
512}
513
514module_init(vfb_init);
515
516#ifdef MODULE
517static void __exit vfb_exit(void)
518{
Antonino A. Daplas20cecf62006-06-26 00:26:34 -0700519 platform_device_unregister(vfb_device);
Russell King3ae5eae2005-11-09 22:32:44 +0000520 platform_driver_unregister(&vfb_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521}
522
523module_exit(vfb_exit);
524
525MODULE_LICENSE("GPL");
526#endif /* MODULE */