1/* 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> 18#include <linux/slab.h> 19#include <linux/vmalloc.h> 20#include <linux/delay.h> 21#include <linux/interrupt.h> 22#include <linux/platform_device.h> 23 24#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); 83static int vfb_mmap(struct fb_info *info, 84 struct vm_area_struct *vma); 85 86static struct fb_ops vfb_ops = { 87 .fb_read = fb_sys_read, 88 .fb_write = fb_sys_write, 89 .fb_check_var = vfb_check_var, 90 .fb_set_par = vfb_set_par, 91 .fb_setcolreg = vfb_setcolreg, 92 .fb_pan_display = vfb_pan_display, 93 .fb_fillrect = sys_fillrect, 94 .fb_copyarea = sys_copyarea, 95 .fb_imageblit = sys_imageblit, 96 .fb_mmap = vfb_mmap, 97}; 98 99 /* 100 * Internal routines 101 */ 102 103static u_long get_line_length(int xres_virtual, int bpp) 104{ 105 u_long length; 106 107 length = xres_virtual * bpp; 108 length = (length + 31) & ~31; 109 length >>= 3; 110 return (length); 111} 112 113 /* 114 * Setting the video mode has been split into two parts. 115 * First part, xxxfb_check_var, must not write anything 116 * to hardware, it should only verify and adjust var. 117 * This means it doesn't alter par but it does use hardware 118 * data from it to check this var. 119 */ 120 121static int vfb_check_var(struct fb_var_screeninfo *var, 122 struct fb_info *info) 123{ 124 u_long line_length; 125 126 /* 127 * FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal! 128 * as FB_VMODE_SMOOTH_XPAN is only used internally 129 */ 130 131 if (var->vmode & FB_VMODE_CONUPDATE) { 132 var->vmode |= FB_VMODE_YWRAP; 133 var->xoffset = info->var.xoffset; 134 var->yoffset = info->var.yoffset; 135 } 136 137 /* 138 * Some very basic checks 139 */ 140 if (!var->xres) 141 var->xres = 1; 142 if (!var->yres) 143 var->yres = 1; 144 if (var->xres > var->xres_virtual) 145 var->xres_virtual = var->xres; 146 if (var->yres > var->yres_virtual) 147 var->yres_virtual = var->yres; 148 if (var->bits_per_pixel <= 1) 149 var->bits_per_pixel = 1; 150 else if (var->bits_per_pixel <= 8) 151 var->bits_per_pixel = 8; 152 else if (var->bits_per_pixel <= 16) 153 var->bits_per_pixel = 16; 154 else if (var->bits_per_pixel <= 24) 155 var->bits_per_pixel = 24; 156 else if (var->bits_per_pixel <= 32) 157 var->bits_per_pixel = 32; 158 else 159 return -EINVAL; 160 161 if (var->xres_virtual < var->xoffset + var->xres) 162 var->xres_virtual = var->xoffset + var->xres; 163 if (var->yres_virtual < var->yoffset + var->yres) 164 var->yres_virtual = var->yoffset + var->yres; 165 166 /* 167 * Memory limit 168 */ 169 line_length = 170 get_line_length(var->xres_virtual, var->bits_per_pixel); 171 if (line_length * var->yres_virtual > videomemorysize) 172 return -ENOMEM; 173 174 /* 175 * Now that we checked it we alter var. The reason being is that the video 176 * mode passed in might not work but slight changes to it might make it 177 * work. This way we let the user know what is acceptable. 178 */ 179 switch (var->bits_per_pixel) { 180 case 1: 181 case 8: 182 var->red.offset = 0; 183 var->red.length = 8; 184 var->green.offset = 0; 185 var->green.length = 8; 186 var->blue.offset = 0; 187 var->blue.length = 8; 188 var->transp.offset = 0; 189 var->transp.length = 0; 190 break; 191 case 16: /* RGBA 5551 */ 192 if (var->transp.length) { 193 var->red.offset = 0; 194 var->red.length = 5; 195 var->green.offset = 5; 196 var->green.length = 5; 197 var->blue.offset = 10; 198 var->blue.length = 5; 199 var->transp.offset = 15; 200 var->transp.length = 1; 201 } else { /* RGB 565 */ 202 var->red.offset = 0; 203 var->red.length = 5; 204 var->green.offset = 5; 205 var->green.length = 6; 206 var->blue.offset = 11; 207 var->blue.length = 5; 208 var->transp.offset = 0; 209 var->transp.length = 0; 210 } 211 break; 212 case 24: /* RGB 888 */ 213 var->red.offset = 0; 214 var->red.length = 8; 215 var->green.offset = 8; 216 var->green.length = 8; 217 var->blue.offset = 16; 218 var->blue.length = 8; 219 var->transp.offset = 0; 220 var->transp.length = 0; 221 break; 222 case 32: /* RGBA 8888 */ 223 var->red.offset = 0; 224 var->red.length = 8; 225 var->green.offset = 8; 226 var->green.length = 8; 227 var->blue.offset = 16; 228 var->blue.length = 8; 229 var->transp.offset = 24; 230 var->transp.length = 8; 231 break; 232 } 233 var->red.msb_right = 0; 234 var->green.msb_right = 0; 235 var->blue.msb_right = 0; 236 var->transp.msb_right = 0; 237 238 return 0; 239} 240 241/* This routine actually sets the video mode. It's in here where we 242 * the hardware state info->par and fix which can be affected by the 243 * change in par. For this driver it doesn't do much. 244 */ 245static int vfb_set_par(struct fb_info *info) 246{ 247 info->fix.line_length = get_line_length(info->var.xres_virtual, 248 info->var.bits_per_pixel); 249 return 0; 250} 251 252 /* 253 * Set a single color register. The values supplied are already 254 * rounded down to the hardware's capabilities (according to the 255 * entries in the var structure). Return != 0 for invalid regno. 256 */ 257 258static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, 259 u_int transp, struct fb_info *info) 260{ 261 if (regno >= 256) /* no. of hw registers */ 262 return 1; 263 /* 264 * Program hardware... do anything you want with transp 265 */ 266 267 /* grayscale works only partially under directcolor */ 268 if (info->var.grayscale) { 269 /* grayscale = 0.30*R + 0.59*G + 0.11*B */ 270 red = green = blue = 271 (red * 77 + green * 151 + blue * 28) >> 8; 272 } 273 274 /* Directcolor: 275 * var->{color}.offset contains start of bitfield 276 * var->{color}.length contains length of bitfield 277 * {hardwarespecific} contains width of RAMDAC 278 * cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset) 279 * RAMDAC[X] is programmed to (red, green, blue) 280 * 281 * Pseudocolor: 282 * uses offset = 0 && length = RAMDAC register width. 283 * var->{color}.offset is 0 284 * var->{color}.length contains widht of DAC 285 * cmap is not used 286 * RAMDAC[X] is programmed to (red, green, blue) 287 * Truecolor: 288 * does not use DAC. Usually 3 are present. 289 * var->{color}.offset contains start of bitfield 290 * var->{color}.length contains length of bitfield 291 * cmap is programmed to (red << red.offset) | (green << green.offset) | 292 * (blue << blue.offset) | (transp << transp.offset) 293 * RAMDAC does not exist 294 */ 295#define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16) 296 switch (info->fix.visual) { 297 case FB_VISUAL_TRUECOLOR: 298 case FB_VISUAL_PSEUDOCOLOR: 299 red = CNVT_TOHW(red, info->var.red.length); 300 green = CNVT_TOHW(green, info->var.green.length); 301 blue = CNVT_TOHW(blue, info->var.blue.length); 302 transp = CNVT_TOHW(transp, info->var.transp.length); 303 break; 304 case FB_VISUAL_DIRECTCOLOR: 305 red = CNVT_TOHW(red, 8); /* expect 8 bit DAC */ 306 green = CNVT_TOHW(green, 8); 307 blue = CNVT_TOHW(blue, 8); 308 /* hey, there is bug in transp handling... */ 309 transp = CNVT_TOHW(transp, 8); 310 break; 311 } 312#undef CNVT_TOHW 313 /* Truecolor has hardware independent palette */ 314 if (info->fix.visual == FB_VISUAL_TRUECOLOR) { 315 u32 v; 316 317 if (regno >= 16) 318 return 1; 319 320 v = (red << info->var.red.offset) | 321 (green << info->var.green.offset) | 322 (blue << info->var.blue.offset) | 323 (transp << info->var.transp.offset); 324 switch (info->var.bits_per_pixel) { 325 case 8: 326 break; 327 case 16: 328 ((u32 *) (info->pseudo_palette))[regno] = v; 329 break; 330 case 24: 331 case 32: 332 ((u32 *) (info->pseudo_palette))[regno] = v; 333 break; 334 } 335 return 0; 336 } 337 return 0; 338} 339 340 /* 341 * Pan or Wrap the Display 342 * 343 * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag 344 */ 345 346static int vfb_pan_display(struct fb_var_screeninfo *var, 347 struct fb_info *info) 348{ 349 if (var->vmode & FB_VMODE_YWRAP) { 350 if (var->yoffset < 0 351 || var->yoffset >= info->var.yres_virtual 352 || var->xoffset) 353 return -EINVAL; 354 } else { 355 if (var->xoffset + var->xres > info->var.xres_virtual || 356 var->yoffset + var->yres > info->var.yres_virtual) 357 return -EINVAL; 358 } 359 info->var.xoffset = var->xoffset; 360 info->var.yoffset = var->yoffset; 361 if (var->vmode & FB_VMODE_YWRAP) 362 info->var.vmode |= FB_VMODE_YWRAP; 363 else 364 info->var.vmode &= ~FB_VMODE_YWRAP; 365 return 0; 366} 367 368 /* 369 * Most drivers don't need their own mmap function 370 */ 371 372static int vfb_mmap(struct fb_info *info, 373 struct vm_area_struct *vma) 374{ 375 return -EINVAL; 376} 377 378#ifndef MODULE 379static int __init vfb_setup(char *options) 380{ 381 char *this_opt; 382 383 vfb_enable = 1; 384 385 if (!options || !*options) 386 return 1; 387 388 while ((this_opt = strsep(&options, ",")) != NULL) { 389 if (!*this_opt) 390 continue; 391 if (!strncmp(this_opt, "disable", 7)) 392 vfb_enable = 0; 393 } 394 return 1; 395} 396#endif /* MODULE */ 397 398 /* 399 * Initialisation 400 */ 401 402static int __init vfb_probe(struct platform_device *dev) 403{ 404 struct fb_info *info; 405 int retval = -ENOMEM; 406 407 /* 408 * For real video cards we use ioremap. 409 */ 410 if (!(videomemory = vmalloc(videomemorysize))) 411 return retval; 412 413 /* 414 * VFB must clear memory to prevent kernel info 415 * leakage into userspace 416 * VGA-based drivers MUST NOT clear memory if 417 * they want to be able to take over vgacon 418 */ 419 memset(videomemory, 0, videomemorysize); 420 421 info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev); 422 if (!info) 423 goto err; 424 425 info->screen_base = (char __iomem *)videomemory; 426 info->fbops = &vfb_ops; 427 428 retval = fb_find_mode(&info->var, info, NULL, 429 NULL, 0, NULL, 8); 430 431 if (!retval || (retval == 4)) 432 info->var = vfb_default; 433 info->fix = vfb_fix; 434 info->pseudo_palette = info->par; 435 info->par = NULL; 436 info->flags = FBINFO_FLAG_DEFAULT; 437 438 retval = fb_alloc_cmap(&info->cmap, 256, 0); 439 if (retval < 0) 440 goto err1; 441 442 retval = register_framebuffer(info); 443 if (retval < 0) 444 goto err2; 445 platform_set_drvdata(dev, info); 446 447 printk(KERN_INFO 448 "fb%d: Virtual frame buffer device, using %ldK of video memory\n", 449 info->node, videomemorysize >> 10); 450 return 0; 451err2: 452 fb_dealloc_cmap(&info->cmap); 453err1: 454 framebuffer_release(info); 455err: 456 vfree(videomemory); 457 return retval; 458} 459 460static int vfb_remove(struct platform_device *dev) 461{ 462 struct fb_info *info = platform_get_drvdata(dev); 463 464 if (info) { 465 unregister_framebuffer(info); 466 vfree(videomemory); 467 framebuffer_release(info); 468 } 469 return 0; 470} 471 472static struct platform_driver vfb_driver = { 473 .probe = vfb_probe, 474 .remove = vfb_remove, 475 .driver = { 476 .name = "vfb", 477 }, 478}; 479 480static struct platform_device *vfb_device; 481 482static int __init vfb_init(void) 483{ 484 int ret = 0; 485 486#ifndef MODULE 487 char *option = NULL; 488 489 if (fb_get_options("vfb", &option)) 490 return -ENODEV; 491 vfb_setup(option); 492#endif 493 494 if (!vfb_enable) 495 return -ENXIO; 496 497 ret = platform_driver_register(&vfb_driver); 498 499 if (!ret) { 500 vfb_device = platform_device_alloc("vfb", 0); 501 502 if (vfb_device) 503 ret = platform_device_add(vfb_device); 504 else 505 ret = -ENOMEM; 506 507 if (ret) { 508 platform_device_put(vfb_device); 509 platform_driver_unregister(&vfb_driver); 510 } 511 } 512 513 return ret; 514} 515 516module_init(vfb_init); 517 518#ifdef MODULE 519static void __exit vfb_exit(void) 520{ 521 platform_device_unregister(vfb_device); 522 platform_driver_unregister(&vfb_driver); 523} 524 525module_exit(vfb_exit); 526 527MODULE_LICENSE("GPL"); 528#endif /* MODULE */ 529