[deliverable/linux.git] / drivers / video / vfb.c

/*
 *  linux/drivers/video/vfb.c -- Virtual frame buffer device
 *
 *      Copyright (C) 2002 James Simmons
 *
 *	Copyright (C) 1997 Geert Uytterhoeven
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License. See the file COPYING in the main directory of this archive for
 *  more details.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>

#include <linux/fb.h>
#include <linux/init.h>

    /*
     *  RAM we reserve for the frame buffer. This defines the maximum screen
     *  size
     *
     *  The default can be overridden if the driver is compiled as a module
     */

#define VIDEOMEMSIZE	(1*1024*1024)	/* 1 MB */

static void *videomemory;
static u_long videomemorysize = VIDEOMEMSIZE;
module_param(videomemorysize, ulong, 0);

/**********************************************************************
 *
 * Memory management
 *
 **********************************************************************/
static void *rvmalloc(unsigned long size)
{
	void *mem;
	unsigned long adr;

	size = PAGE_ALIGN(size);
	mem = vmalloc_32(size);
	if (!mem)
		return NULL;

	memset(mem, 0, size); /* Clear the ram out, no junk to the user */
	adr = (unsigned long) mem;
	while (size > 0) {
		SetPageReserved(vmalloc_to_page((void *)adr));
		adr += PAGE_SIZE;
		size -= PAGE_SIZE;
	}

	return mem;
}

static void rvfree(void *mem, unsigned long size)
{
	unsigned long adr;

	if (!mem)
		return;

	adr = (unsigned long) mem;
	while ((long) size > 0) {
		ClearPageReserved(vmalloc_to_page((void *)adr));
		adr += PAGE_SIZE;
		size -= PAGE_SIZE;
	}
	vfree(mem);
}

static struct fb_var_screeninfo vfb_default __initdata = {
	.xres =		640,
	.yres =		480,
	.xres_virtual =	640,
	.yres_virtual =	480,
	.bits_per_pixel = 8,
	.red =		{ 0, 8, 0 },
      	.green =	{ 0, 8, 0 },
      	.blue =		{ 0, 8, 0 },
      	.activate =	FB_ACTIVATE_TEST,
      	.height =	-1,
      	.width =	-1,
      	.pixclock =	20000,
      	.left_margin =	64,
      	.right_margin =	64,
      	.upper_margin =	32,
      	.lower_margin =	32,
      	.hsync_len =	64,
      	.vsync_len =	2,
      	.vmode =	FB_VMODE_NONINTERLACED,
};

static struct fb_fix_screeninfo vfb_fix __initdata = {
	.id =		"Virtual FB",
	.type =		FB_TYPE_PACKED_PIXELS,
	.visual =	FB_VISUAL_PSEUDOCOLOR,
	.xpanstep =	1,
	.ypanstep =	1,
	.ywrapstep =	1,
	.accel =	FB_ACCEL_NONE,
};

static int vfb_enable __initdata = 0;	/* disabled by default */
module_param(vfb_enable, bool, 0);

static int vfb_check_var(struct fb_var_screeninfo *var,
			 struct fb_info *info);
static int vfb_set_par(struct fb_info *info);
static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
			 u_int transp, struct fb_info *info);
static int vfb_pan_display(struct fb_var_screeninfo *var,
			   struct fb_info *info);
static int vfb_mmap(struct fb_info *info,
		    struct vm_area_struct *vma);

static struct fb_ops vfb_ops = {
	.fb_read        = fb_sys_read,
	.fb_write       = fb_sys_write,
	.fb_check_var	= vfb_check_var,
	.fb_set_par	= vfb_set_par,
	.fb_setcolreg	= vfb_setcolreg,
	.fb_pan_display	= vfb_pan_display,
	.fb_fillrect	= sys_fillrect,
	.fb_copyarea	= sys_copyarea,
	.fb_imageblit	= sys_imageblit,
	.fb_mmap	= vfb_mmap,
};

    /*
     *  Internal routines
     */

static u_long get_line_length(int xres_virtual, int bpp)
{
	u_long length;

	length = xres_virtual * bpp;
	length = (length + 31) & ~31;
	length >>= 3;
	return (length);
}

    /*
     *  Setting the video mode has been split into two parts.
     *  First part, xxxfb_check_var, must not write anything
     *  to hardware, it should only verify and adjust var.
     *  This means it doesn't alter par but it does use hardware
     *  data from it to check this var. 
     */

static int vfb_check_var(struct fb_var_screeninfo *var,
			 struct fb_info *info)
{
	u_long line_length;

	/*
	 *  FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal!
	 *  as FB_VMODE_SMOOTH_XPAN is only used internally
	 */

	if (var->vmode & FB_VMODE_CONUPDATE) {
		var->vmode |= FB_VMODE_YWRAP;
		var->xoffset = info->var.xoffset;
		var->yoffset = info->var.yoffset;
	}

	/*
	 *  Some very basic checks
	 */
	if (!var->xres)
		var->xres = 1;
	if (!var->yres)
		var->yres = 1;
	if (var->xres > var->xres_virtual)
		var->xres_virtual = var->xres;
	if (var->yres > var->yres_virtual)
		var->yres_virtual = var->yres;
	if (var->bits_per_pixel <= 1)
		var->bits_per_pixel = 1;
	else if (var->bits_per_pixel <= 8)
		var->bits_per_pixel = 8;
	else if (var->bits_per_pixel <= 16)
		var->bits_per_pixel = 16;
	else if (var->bits_per_pixel <= 24)
		var->bits_per_pixel = 24;
	else if (var->bits_per_pixel <= 32)
		var->bits_per_pixel = 32;
	else
		return -EINVAL;

	if (var->xres_virtual < var->xoffset + var->xres)
		var->xres_virtual = var->xoffset + var->xres;
	if (var->yres_virtual < var->yoffset + var->yres)
		var->yres_virtual = var->yoffset + var->yres;

	/*
	 *  Memory limit
	 */
	line_length =
	    get_line_length(var->xres_virtual, var->bits_per_pixel);
	if (line_length * var->yres_virtual > videomemorysize)
		return -ENOMEM;

	/*
	 * Now that we checked it we alter var. The reason being is that the video
	 * mode passed in might not work but slight changes to it might make it 
	 * work. This way we let the user know what is acceptable.
	 */
	switch (var->bits_per_pixel) {
	case 1:
	case 8:
		var->red.offset = 0;
		var->red.length = 8;
		var->green.offset = 0;
		var->green.length = 8;
		var->blue.offset = 0;
		var->blue.length = 8;
		var->transp.offset = 0;
		var->transp.length = 0;
		break;
	case 16:		/* RGBA 5551 */
		if (var->transp.length) {
			var->red.offset = 0;
			var->red.length = 5;
			var->green.offset = 5;
			var->green.length = 5;
			var->blue.offset = 10;
			var->blue.length = 5;
			var->transp.offset = 15;
			var->transp.length = 1;
		} else {	/* RGB 565 */
			var->red.offset = 0;
			var->red.length = 5;
			var->green.offset = 5;
			var->green.length = 6;
			var->blue.offset = 11;
			var->blue.length = 5;
			var->transp.offset = 0;
			var->transp.length = 0;
		}
		break;
	case 24:		/* RGB 888 */
		var->red.offset = 0;
		var->red.length = 8;
		var->green.offset = 8;
		var->green.length = 8;
		var->blue.offset = 16;
		var->blue.length = 8;
		var->transp.offset = 0;
		var->transp.length = 0;
		break;
	case 32:		/* RGBA 8888 */
		var->red.offset = 0;
		var->red.length = 8;
		var->green.offset = 8;
		var->green.length = 8;
		var->blue.offset = 16;
		var->blue.length = 8;
		var->transp.offset = 24;
		var->transp.length = 8;
		break;
	}
	var->red.msb_right = 0;
	var->green.msb_right = 0;
	var->blue.msb_right = 0;
	var->transp.msb_right = 0;

	return 0;
}

/* This routine actually sets the video mode. It's in here where we
 * the hardware state info->par and fix which can be affected by the 
 * change in par. For this driver it doesn't do much. 
 */
static int vfb_set_par(struct fb_info *info)
{
	info->fix.line_length = get_line_length(info->var.xres_virtual,
						info->var.bits_per_pixel);
	return 0;
}

    /*
     *  Set a single color register. The values supplied are already
     *  rounded down to the hardware's capabilities (according to the
     *  entries in the var structure). Return != 0 for invalid regno.
     */

static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
			 u_int transp, struct fb_info *info)
{
	if (regno >= 256)	/* no. of hw registers */
		return 1;
	/*
	 * Program hardware... do anything you want with transp
	 */

	/* grayscale works only partially under directcolor */
	if (info->var.grayscale) {
		/* grayscale = 0.30*R + 0.59*G + 0.11*B */
		red = green = blue =
		    (red * 77 + green * 151 + blue * 28) >> 8;
	}

	/* Directcolor:
	 *   var->{color}.offset contains start of bitfield
	 *   var->{color}.length contains length of bitfield
	 *   {hardwarespecific} contains width of RAMDAC
	 *   cmap[X] is programmed to (X << red.offset) | (X << green.offset) | (X << blue.offset)
	 *   RAMDAC[X] is programmed to (red, green, blue)
	 * 
	 * Pseudocolor:
	 *    uses offset = 0 && length = RAMDAC register width.
	 *    var->{color}.offset is 0
	 *    var->{color}.length contains widht of DAC
	 *    cmap is not used
	 *    RAMDAC[X] is programmed to (red, green, blue)
	 * Truecolor:
	 *    does not use DAC. Usually 3 are present.
	 *    var->{color}.offset contains start of bitfield
	 *    var->{color}.length contains length of bitfield
	 *    cmap is programmed to (red << red.offset) | (green << green.offset) |
	 *                      (blue << blue.offset) | (transp << transp.offset)
	 *    RAMDAC does not exist
	 */
#define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
	switch (info->fix.visual) {
	case FB_VISUAL_TRUECOLOR:
	case FB_VISUAL_PSEUDOCOLOR:
		red = CNVT_TOHW(red, info->var.red.length);
		green = CNVT_TOHW(green, info->var.green.length);
		blue = CNVT_TOHW(blue, info->var.blue.length);
		transp = CNVT_TOHW(transp, info->var.transp.length);
		break;
	case FB_VISUAL_DIRECTCOLOR:
		red = CNVT_TOHW(red, 8);	/* expect 8 bit DAC */
		green = CNVT_TOHW(green, 8);
		blue = CNVT_TOHW(blue, 8);
		/* hey, there is bug in transp handling... */
		transp = CNVT_TOHW(transp, 8);
		break;
	}
#undef CNVT_TOHW
	/* Truecolor has hardware independent palette */
	if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
		u32 v;

		if (regno >= 16)
			return 1;

		v = (red << info->var.red.offset) |
		    (green << info->var.green.offset) |
		    (blue << info->var.blue.offset) |
		    (transp << info->var.transp.offset);
		switch (info->var.bits_per_pixel) {
		case 8:
			break;
		case 16:
			((u32 *) (info->pseudo_palette))[regno] = v;
			break;
		case 24:
		case 32:
			((u32 *) (info->pseudo_palette))[regno] = v;
			break;
		}
		return 0;
	}
	return 0;
}

    /*
     *  Pan or Wrap the Display
     *
     *  This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
     */

static int vfb_pan_display(struct fb_var_screeninfo *var,
			   struct fb_info *info)
{
	if (var->vmode & FB_VMODE_YWRAP) {
		if (var->yoffset < 0
		    || var->yoffset >= info->var.yres_virtual
		    || var->xoffset)
			return -EINVAL;
	} else {
		if (var->xoffset + var->xres > info->var.xres_virtual ||
		    var->yoffset + var->yres > info->var.yres_virtual)
			return -EINVAL;
	}
	info->var.xoffset = var->xoffset;
	info->var.yoffset = var->yoffset;
	if (var->vmode & FB_VMODE_YWRAP)
		info->var.vmode |= FB_VMODE_YWRAP;
	else
		info->var.vmode &= ~FB_VMODE_YWRAP;
	return 0;
}

    /*
     *  Most drivers don't need their own mmap function 
     */

static int vfb_mmap(struct fb_info *info,
		    struct vm_area_struct *vma)
{
	unsigned long start = vma->vm_start;
	unsigned long size = vma->vm_end - vma->vm_start;
	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
	unsigned long page, pos;

	if (offset + size > info->fix.smem_len) {
		return -EINVAL;
	}

	pos = (unsigned long)info->fix.smem_start + offset;

	while (size > 0) {
		page = vmalloc_to_pfn((void *)pos);
		if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
			return -EAGAIN;
		}
		start += PAGE_SIZE;
		pos += PAGE_SIZE;
		if (size > PAGE_SIZE)
			size -= PAGE_SIZE;
		else
			size = 0;
	}

	vma->vm_flags |= VM_RESERVED;	/* avoid to swap out this VMA */
	return 0;

}

#ifndef MODULE
/*
 * The virtual framebuffer driver is only enabled if explicitly
 * requested by passing 'video=vfb:' (or any actual options).
 */
static int __init vfb_setup(char *options)
{
	char *this_opt;

	vfb_enable = 0;

	if (!options)
		return 1;

	vfb_enable = 1;

	if (!*options)
		return 1;

	while ((this_opt = strsep(&options, ",")) != NULL) {
		if (!*this_opt)
			continue;
		/* Test disable for backwards compatibility */
		if (!strcmp(this_opt, "disable"))
			vfb_enable = 0;
	}
	return 1;
}
#endif  /*  MODULE  */

    /*
     *  Initialisation
     */

static int __init vfb_probe(struct platform_device *dev)
{
	struct fb_info *info;
	int retval = -ENOMEM;

	/*
	 * For real video cards we use ioremap.
	 */
	if (!(videomemory = rvmalloc(videomemorysize)))
		return retval;

	/*
	 * VFB must clear memory to prevent kernel info
	 * leakage into userspace
	 * VGA-based drivers MUST NOT clear memory if
	 * they want to be able to take over vgacon
	 */
	memset(videomemory, 0, videomemorysize);

	info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev);
	if (!info)
		goto err;

	info->screen_base = (char __iomem *)videomemory;
	info->fbops = &vfb_ops;

	retval = fb_find_mode(&info->var, info, NULL,
			      NULL, 0, NULL, 8);

	if (!retval || (retval == 4))
		info->var = vfb_default;
	vfb_fix.smem_start = (unsigned long) videomemory;
	vfb_fix.smem_len = videomemorysize;
	info->fix = vfb_fix;
	info->pseudo_palette = info->par;
	info->par = NULL;
	info->flags = FBINFO_FLAG_DEFAULT;

	retval = fb_alloc_cmap(&info->cmap, 256, 0);
	if (retval < 0)
		goto err1;

	retval = register_framebuffer(info);
	if (retval < 0)
		goto err2;
	platform_set_drvdata(dev, info);

	printk(KERN_INFO
	       "fb%d: Virtual frame buffer device, using %ldK of video memory\n",
	       info->node, videomemorysize >> 10);
	return 0;
err2:
	fb_dealloc_cmap(&info->cmap);
err1:
	framebuffer_release(info);
err:
	rvfree(videomemory, videomemorysize);
	return retval;
}

static int vfb_remove(struct platform_device *dev)
{
	struct fb_info *info = platform_get_drvdata(dev);

	if (info) {
		unregister_framebuffer(info);
		rvfree(videomemory, videomemorysize);
		framebuffer_release(info);
	}
	return 0;
}

static struct platform_driver vfb_driver = {
	.probe	= vfb_probe,
	.remove = vfb_remove,
	.driver = {
		.name	= "vfb",
	},
};

static struct platform_device *vfb_device;

static int __init vfb_init(void)
{
	int ret = 0;

#ifndef MODULE
	char *option = NULL;

	if (fb_get_options("vfb", &option))
		return -ENODEV;
	vfb_setup(option);
#endif

	if (!vfb_enable)
		return -ENXIO;

	ret = platform_driver_register(&vfb_driver);

	if (!ret) {
		vfb_device = platform_device_alloc("vfb", 0);

		if (vfb_device)
			ret = platform_device_add(vfb_device);
		else
			ret = -ENOMEM;

		if (ret) {
			platform_device_put(vfb_device);
			platform_driver_unregister(&vfb_driver);
		}
	}

	return ret;
}

module_init(vfb_init);

#ifdef MODULE
static void __exit vfb_exit(void)
{
	platform_device_unregister(vfb_device);
	platform_driver_unregister(&vfb_driver);
}

module_exit(vfb_exit);

MODULE_LICENSE("GPL");
#endif				/* MODULE */
Commit	Line	Data
1da177e4 LT	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>
1da177e4 LT	18	#include <linux/slab.h>
	19	#include <linux/vmalloc.h>
	20	#include <linux/delay.h>
	21	#include <linux/interrupt.h>
d052d1be RK	22	#include <linux/platform_device.h>
d052d1be RK	23
1da177e4 LT	24	#include <linux/fb.h>
	25	#include <linux/init.h>
	26
	27	/*
	28	* RAM we reserve for the frame buffer. This defines the maximum screen
	29	* size
	30	*
	31	* The default can be overridden if the driver is compiled as a module
	32	*/
	33
	34	#define VIDEOMEMSIZE (110241024) /* 1 MB */
	35
	36	static void *videomemory;
	37	static u_long videomemorysize = VIDEOMEMSIZE;
	38	module_param(videomemorysize, ulong, 0);
	39
68e5e9d7 IY	40	/**********************************************************************
	41	*
	42	* Memory management
	43	*
	44	**********************************************************************/
	45	static void *rvmalloc(unsigned long size)
	46	{
	47	void *mem;
	48	unsigned long adr;
	49
	50	size = PAGE_ALIGN(size);
	51	mem = vmalloc_32(size);
	52	if (!mem)
	53	return NULL;
	54
	55	memset(mem, 0, size); /* Clear the ram out, no junk to the user */
	56	adr = (unsigned long) mem;
	57	while (size > 0) {
	58	SetPageReserved(vmalloc_to_page((void *)adr));
	59	adr += PAGE_SIZE;
	60	size -= PAGE_SIZE;
	61	}
	62
	63	return mem;
	64	}
	65
	66	static void rvfree(void *mem, unsigned long size)
	67	{
	68	unsigned long adr;
	69
	70	if (!mem)
	71	return;
	72
	73	adr = (unsigned long) mem;
	74	while ((long) size > 0) {
	75	ClearPageReserved(vmalloc_to_page((void *)adr));
	76	adr += PAGE_SIZE;
	77	size -= PAGE_SIZE;
	78	}
	79	vfree(mem);
	80	}
	81
1da177e4 LT	82	static struct fb_var_screeninfo vfb_default __initdata = {
	83	.xres = 640,
	84	.yres = 480,
	85	.xres_virtual = 640,
	86	.yres_virtual = 480,
	87	.bits_per_pixel = 8,
	88	.red = { 0, 8, 0 },
	89	.green = { 0, 8, 0 },
	90	.blue = { 0, 8, 0 },
	91	.activate = FB_ACTIVATE_TEST,
	92	.height = -1,
	93	.width = -1,
	94	.pixclock = 20000,
	95	.left_margin = 64,
	96	.right_margin = 64,
	97	.upper_margin = 32,
	98	.lower_margin = 32,
	99	.hsync_len = 64,
	100	.vsync_len = 2,
	101	.vmode = FB_VMODE_NONINTERLACED,
	102	};
	103
	104	static struct fb_fix_screeninfo vfb_fix __initdata = {
	105	.id = "Virtual FB",
	106	.type = FB_TYPE_PACKED_PIXELS,
	107	.visual = FB_VISUAL_PSEUDOCOLOR,
	108	.xpanstep = 1,
	109	.ypanstep = 1,
	110	.ywrapstep = 1,
	111	.accel = FB_ACCEL_NONE,
	112	};
	113
	114	static int vfb_enable __initdata = 0; /* disabled by default */
	115	module_param(vfb_enable, bool, 0);
	116
	117	static int vfb_check_var(struct fb_var_screeninfo *var,
	118	struct fb_info *info);
	119	static int vfb_set_par(struct fb_info *info);
	120	static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
	121	u_int transp, struct fb_info *info);
	122	static int vfb_pan_display(struct fb_var_screeninfo *var,
	123	struct fb_info *info);
216d526c	124	static int vfb_mmap(struct fb_info *info,
1da177e4 LT	125	struct vm_area_struct *vma);
	126
	127	static struct fb_ops vfb_ops = {
52102c07 AD	128	.fb_read = fb_sys_read,
52102c07 AD	129	.fb_write = fb_sys_write,
1da177e4 LT	130	.fb_check_var = vfb_check_var,
	131	.fb_set_par = vfb_set_par,
	132	.fb_setcolreg = vfb_setcolreg,
	133	.fb_pan_display = vfb_pan_display,
87b48849 AD	134	.fb_fillrect = sys_fillrect,
	135	.fb_copyarea = sys_copyarea,
	136	.fb_imageblit = sys_imageblit,
1da177e4 LT	137	.fb_mmap = vfb_mmap,
	138	};
	139
	140	/*
	141	* Internal routines
	142	*/
	143
	144	static u_long get_line_length(int xres_virtual, int bpp)
	145	{
	146	u_long length;
	147
	148	length = xres_virtual * bpp;
	149	length = (length + 31) & ~31;
	150	length >>= 3;
	151	return (length);
	152	}
	153
	154	/*
	155	* Setting the video mode has been split into two parts.
	156	* First part, xxxfb_check_var, must not write anything
	157	* to hardware, it should only verify and adjust var.
	158	* This means it doesn't alter par but it does use hardware
	159	* data from it to check this var.
	160	*/
	161
	162	static int vfb_check_var(struct fb_var_screeninfo *var,
	163	struct fb_info *info)
	164	{
	165	u_long line_length;
	166
	167	/*
	168	* FB_VMODE_CONUPDATE and FB_VMODE_SMOOTH_XPAN are equal!
	169	* as FB_VMODE_SMOOTH_XPAN is only used internally
	170	*/
	171
	172	if (var->vmode & FB_VMODE_CONUPDATE) {
	173	var->vmode \|= FB_VMODE_YWRAP;
	174	var->xoffset = info->var.xoffset;
	175	var->yoffset = info->var.yoffset;
	176	}
	177
	178	/*
	179	* Some very basic checks
	180	*/
	181	if (!var->xres)
	182	var->xres = 1;
	183	if (!var->yres)
	184	var->yres = 1;
	185	if (var->xres > var->xres_virtual)
	186	var->xres_virtual = var->xres;
	187	if (var->yres > var->yres_virtual)
	188	var->yres_virtual = var->yres;
	189	if (var->bits_per_pixel <= 1)
	190	var->bits_per_pixel = 1;
	191	else if (var->bits_per_pixel <= 8)
	192	var->bits_per_pixel = 8;
	193	else if (var->bits_per_pixel <= 16)
	194	var->bits_per_pixel = 16;
	195	else if (var->bits_per_pixel <= 24)
	196	var->bits_per_pixel = 24;
	197	else if (var->bits_per_pixel <= 32)
	198	var->bits_per_pixel = 32;
	199	else
	200	return -EINVAL;
201
202	if (var->xres_virtual < var->xoffset + var->xres)
203	var->xres_virtual = var->xoffset + var->xres;
204	if (var->yres_virtual < var->yoffset + var->yres)
205	var->yres_virtual = var->yoffset + var->yres;
206
207	/*
208	* Memory limit
209	*/
210	line_length =
211	get_line_length(var->xres_virtual, var->bits_per_pixel);
212	if (line_length * var->yres_virtual > videomemorysize)
213	return -ENOMEM;
214
215	/*
216	* Now that we checked it we alter var. The reason being is that the video
217	* mode passed in might not work but slight changes to it might make it
218	* work. This way we let the user know what is acceptable.
219	*/
220	switch (var->bits_per_pixel) {
221	case 1:
222	case 8:
223	var->red.offset = 0;
224	var->red.length = 8;
225	var->green.offset = 0;
226	var->green.length = 8;
227	var->blue.offset = 0;
228	var->blue.length = 8;
229	var->transp.offset = 0;
230	var->transp.length = 0;
231	break;
232	case 16: /* RGBA 5551 */
233	if (var->transp.length) {
234	var->red.offset = 0;
235	var->red.length = 5;
236	var->green.offset = 5;
237	var->green.length = 5;
238	var->blue.offset = 10;
239	var->blue.length = 5;
240	var->transp.offset = 15;
241	var->transp.length = 1;
242	} else { /* RGB 565 */
243	var->red.offset = 0;
244	var->red.length = 5;
245	var->green.offset = 5;
246	var->green.length = 6;
247	var->blue.offset = 11;
248	var->blue.length = 5;
249	var->transp.offset = 0;
250	var->transp.length = 0;
251	}
252	break;
253	case 24: /* RGB 888 */
254	var->red.offset = 0;
255	var->red.length = 8;
256	var->green.offset = 8;
257	var->green.length = 8;
258	var->blue.offset = 16;
259	var->blue.length = 8;
260	var->transp.offset = 0;
261	var->transp.length = 0;
262	break;
263	case 32: /* RGBA 8888 */
264	var->red.offset = 0;
265	var->red.length = 8;
266	var->green.offset = 8;
267	var->green.length = 8;
268	var->blue.offset = 16;
269	var->blue.length = 8;
270	var->transp.offset = 24;
271	var->transp.length = 8;
272	break;
273	}
274	var->red.msb_right = 0;
275	var->green.msb_right = 0;
276	var->blue.msb_right = 0;
277	var->transp.msb_right = 0;
278
279	return 0;
280	}
281
282	/* This routine actually sets the video mode. It's in here where we
283	* the hardware state info->par and fix which can be affected by the
284	* change in par. For this driver it doesn't do much.
285	*/
286	static int vfb_set_par(struct fb_info *info)
287	{
288	info->fix.line_length = get_line_length(info->var.xres_virtual,
289	info->var.bits_per_pixel);
290	return 0;
291	}
292
293	/*
294	* Set a single color register. The values supplied are already
295	* rounded down to the hardware's capabilities (according to the
296	* entries in the var structure). Return != 0 for invalid regno.
297	*/
298
299	static int vfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
300	u_int transp, struct fb_info *info)
301	{
302	if (regno >= 256) /* no. of hw registers */
303	return 1;
304	/*
305	* Program hardware... do anything you want with transp
306	*/
307
308	/* grayscale works only partially under directcolor */
309	if (info->var.grayscale) {
310	/* grayscale = 0.30R + 0.59G + 0.11B /
311	red = green = blue =
312	(red * 77 + green * 151 + blue * 28) >> 8;
313	}
314
315	/* Directcolor:
316	* var->{color}.offset contains start of bitfield
317	* var->{color}.length contains length of bitfield
318	* {hardwarespecific} contains width of RAMDAC
319	* cmap[X] is programmed to (X << red.offset) \| (X << green.offset) \| (X << blue.offset)
320	* RAMDAC[X] is programmed to (red, green, blue)
321	*
322	* Pseudocolor:
323	* uses offset = 0 && length = RAMDAC register width.
324	* var->{color}.offset is 0
325	* var->{color}.length contains widht of DAC
326	* cmap is not used
327	* RAMDAC[X] is programmed to (red, green, blue)
328	* Truecolor:
329	* does not use DAC. Usually 3 are present.
330	* var->{color}.offset contains start of bitfield
331	* var->{color}.length contains length of bitfield
332	* cmap is programmed to (red << red.offset) \| (green << green.offset) \|
333	* (blue << blue.offset) \| (transp << transp.offset)
334	* RAMDAC does not exist
335	*/
336	#define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16)
337	switch (info->fix.visual) {
338	case FB_VISUAL_TRUECOLOR:
339	case FB_VISUAL_PSEUDOCOLOR:
340	red = CNVT_TOHW(red, info->var.red.length);
341	green = CNVT_TOHW(green, info->var.green.length);
342	blue = CNVT_TOHW(blue, info->var.blue.length);
343	transp = CNVT_TOHW(transp, info->var.transp.length);
344	break;
345	case FB_VISUAL_DIRECTCOLOR:
346	red = CNVT_TOHW(red, 8); /* expect 8 bit DAC */
347	green = CNVT_TOHW(green, 8);
348	blue = CNVT_TOHW(blue, 8);
349	/* hey, there is bug in transp handling... */
350	transp = CNVT_TOHW(transp, 8);
351	break;
352	}
353	#undef CNVT_TOHW
354	/* Truecolor has hardware independent palette */
355	if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
356	u32 v;
357
358	if (regno >= 16)
359	return 1;
360
361	v = (red << info->var.red.offset) \|
362	(green << info->var.green.offset) \|
363	(blue << info->var.blue.offset) \|
364	(transp << info->var.transp.offset);
365	switch (info->var.bits_per_pixel) {
366	case 8:
367	break;
368	case 16:
369	((u32 *) (info->pseudo_palette))[regno] = v;
370	break;
371	case 24:
372	case 32:
373	((u32 *) (info->pseudo_palette))[regno] = v;
374	break;
375	}
376	return 0;
377	}
378	return 0;
379	}
380
381	/*
382	* Pan or Wrap the Display
383	*
384	* This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
385	*/
386
387	static int vfb_pan_display(struct fb_var_screeninfo *var,
388	struct fb_info *info)
389	{
390	if (var->vmode & FB_VMODE_YWRAP) {
391	if (var->yoffset < 0
392	\|\| var->yoffset >= info->var.yres_virtual
393	\|\| var->xoffset)
394	return -EINVAL;
395	} else {
396	if (var->xoffset + var->xres > info->var.xres_virtual \|\|
397	var->yoffset + var->yres > info->var.yres_virtual)
398	return -EINVAL;
399	}
400	info->var.xoffset = var->xoffset;
401	info->var.yoffset = var->yoffset;
402	if (var->vmode & FB_VMODE_YWRAP)
403	info->var.vmode \|= FB_VMODE_YWRAP;
404	else
405	info->var.vmode &= ~FB_VMODE_YWRAP;
406	return 0;
407	}
408
409	/*
410	* Most drivers don't need their own mmap function
411	*/
412
216d526c	413	static int vfb_mmap(struct fb_info *info,
1da177e4 LT	414	struct vm_area_struct *vma)
1da177e4 LT	415	{
68e5e9d7 IY	416	unsigned long start = vma->vm_start;
	417	unsigned long size = vma->vm_end - vma->vm_start;
	418	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
	419	unsigned long page, pos;
	420
	421	if (offset + size > info->fix.smem_len) {
	422	return -EINVAL;
	423	}
	424
	425	pos = (unsigned long)info->fix.smem_start + offset;
	426
	427	while (size > 0) {
	428	page = vmalloc_to_pfn((void *)pos);
	429	if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
	430	return -EAGAIN;
	431	}
	432	start += PAGE_SIZE;
	433	pos += PAGE_SIZE;
	434	if (size > PAGE_SIZE)
	435	size -= PAGE_SIZE;
	436	else
	437	size = 0;
	438	}
	439
	440	vma->vm_flags \|= VM_RESERVED; /* avoid to swap out this VMA */
	441	return 0;
	442
1da177e4 LT	443	}
	444
	445	#ifndef MODULE
b604838a FP	446	/*
	447	* The virtual framebuffer driver is only enabled if explicitly
	448	* requested by passing 'video=vfb:' (or any actual options).
	449	*/
1da177e4 LT	450	static int __init vfb_setup(char *options)
	451	{
	452	char *this_opt;
	453
b604838a FP	454	vfb_enable = 0;
	455
	456	if (!options)
	457	return 1;
	458
1da177e4 LT	459	vfb_enable = 1;
1da177e4 LT	460
b604838a	461	if (!*options)
1da177e4 LT	462	return 1;
	463
	464	while ((this_opt = strsep(&options, ",")) != NULL) {
	465	if (!*this_opt)
	466	continue;
b604838a FP	467	/* Test disable for backwards compatibility */
b604838a FP	468	if (!strcmp(this_opt, "disable"))
1da177e4 LT	469	vfb_enable = 0;
	470	}
	471	return 1;
	472	}
	473	#endif /* MODULE */
	474
	475	/*
	476	* Initialisation
	477	*/
	478
3ae5eaec	479	static int __init vfb_probe(struct platform_device *dev)
1da177e4	480	{
1da177e4 LT	481	struct fb_info *info;
	482	int retval = -ENOMEM;
	483
	484	/*
	485	* For real video cards we use ioremap.
	486	*/
68e5e9d7	487	if (!(videomemory = rvmalloc(videomemorysize)))
1da177e4 LT	488	return retval;
	489
	490	/*
	491	* VFB must clear memory to prevent kernel info
	492	* leakage into userspace
	493	* VGA-based drivers MUST NOT clear memory if
	494	* they want to be able to take over vgacon
	495	*/
	496	memset(videomemory, 0, videomemorysize);
	497
	498	info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev);
	499	if (!info)
	500	goto err;
	501
	502	info->screen_base = (char __iomem *)videomemory;
	503	info->fbops = &vfb_ops;
	504
	505	retval = fb_find_mode(&info->var, info, NULL,
	506	NULL, 0, NULL, 8);
	507
	508	if (!retval \|\| (retval == 4))
	509	info->var = vfb_default;
68e5e9d7 IY	510	vfb_fix.smem_start = (unsigned long) videomemory;
68e5e9d7 IY	511	vfb_fix.smem_len = videomemorysize;
1da177e4 LT	512	info->fix = vfb_fix;
	513	info->pseudo_palette = info->par;
	514	info->par = NULL;
	515	info->flags = FBINFO_FLAG_DEFAULT;
	516
	517	retval = fb_alloc_cmap(&info->cmap, 256, 0);
	518	if (retval < 0)
	519	goto err1;
	520
	521	retval = register_framebuffer(info);
	522	if (retval < 0)
	523	goto err2;
3ae5eaec	524	platform_set_drvdata(dev, info);
1da177e4 LT	525
	526	printk(KERN_INFO
	527	"fb%d: Virtual frame buffer device, using %ldK of video memory\n",
	528	info->node, videomemorysize >> 10);
	529	return 0;
	530	err2:
	531	fb_dealloc_cmap(&info->cmap);
	532	err1:
	533	framebuffer_release(info);
	534	err:
68e5e9d7	535	rvfree(videomemory, videomemorysize);
1da177e4 LT	536	return retval;
	537	}
	538
3ae5eaec	539	static int vfb_remove(struct platform_device *dev)
1da177e4	540	{
3ae5eaec	541	struct fb_info *info = platform_get_drvdata(dev);
1da177e4 LT	542
	543	if (info) {
	544	unregister_framebuffer(info);
68e5e9d7	545	rvfree(videomemory, videomemorysize);
1da177e4 LT	546	framebuffer_release(info);
	547	}
	548	return 0;
	549	}
	550
3ae5eaec	551	static struct platform_driver vfb_driver = {
1da177e4 LT	552	.probe = vfb_probe,
1da177e4 LT	553	.remove = vfb_remove,
3ae5eaec RK	554	.driver = {
	555	.name = "vfb",
	556	},
1da177e4 LT	557	};
1da177e4 LT	558
20cecf6a	559	static struct platform_device *vfb_device;
1da177e4 LT	560
	561	static int __init vfb_init(void)
	562	{
	563	int ret = 0;
	564
	565	#ifndef MODULE
	566	char *option = NULL;
	567
	568	if (fb_get_options("vfb", &option))
	569	return -ENODEV;
	570	vfb_setup(option);
	571	#endif
	572
	573	if (!vfb_enable)
	574	return -ENXIO;
	575
3ae5eaec	576	ret = platform_driver_register(&vfb_driver);
1da177e4 LT	577
1da177e4 LT	578	if (!ret) {
20cecf6a AD	579	vfb_device = platform_device_alloc("vfb", 0);
	580
	581	if (vfb_device)
	582	ret = platform_device_add(vfb_device);
	583	else
	584	ret = -ENOMEM;
	585
	586	if (ret) {
	587	platform_device_put(vfb_device);
3ae5eaec	588	platform_driver_unregister(&vfb_driver);
20cecf6a	589	}
1da177e4	590	}
20cecf6a	591
1da177e4 LT	592	return ret;
	593	}
	594
	595	module_init(vfb_init);
	596
	597	#ifdef MODULE
	598	static void __exit vfb_exit(void)
	599	{
20cecf6a	600	platform_device_unregister(vfb_device);
3ae5eaec	601	platform_driver_unregister(&vfb_driver);
1da177e4 LT	602	}
	603
	604	module_exit(vfb_exit);
	605
	606	MODULE_LICENSE("GPL");
	607	#endif /* MODULE */