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

/* sbuslib.c: Helper library for SBUS framebuffer drivers.
 *
 * Copyright (C) 2003 David S. Miller (davem@redhat.com)
 */

#include <linux/compat.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/fb.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/of_device.h>

#include <asm/fbio.h>

#include "sbuslib.h"

void sbusfb_fill_var(struct fb_var_screeninfo *var, struct device_node *dp,
		     int bpp)
{
	memset(var, 0, sizeof(*var));

	var->xres = of_getintprop_default(dp, "width", 1152);
	var->yres = of_getintprop_default(dp, "height", 900);
	var->xres_virtual = var->xres;
	var->yres_virtual = var->yres;
	var->bits_per_pixel = bpp;
}

EXPORT_SYMBOL(sbusfb_fill_var);

static unsigned long sbusfb_mmapsize(long size, unsigned long fbsize)
{
	if (size == SBUS_MMAP_EMPTY) return 0;
	if (size >= 0) return size;
	return fbsize * (-size);
}

int sbusfb_mmap_helper(struct sbus_mmap_map *map,
		       unsigned long physbase,
		       unsigned long fbsize,
		       unsigned long iospace,
		       struct vm_area_struct *vma)
{
	unsigned int size, page, r, map_size;
	unsigned long map_offset = 0;
	unsigned long off;
	int i;
                                        
	if (!(vma->vm_flags & (VM_SHARED | VM_MAYSHARE)))
		return -EINVAL;

	size = vma->vm_end - vma->vm_start;
	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
		return -EINVAL;

	off = vma->vm_pgoff << PAGE_SHIFT;

	/* To stop the swapper from even considering these pages */
	vma->vm_flags |= (VM_IO | VM_RESERVED);
	
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	/* Each page, see which map applies */
	for (page = 0; page < size; ){
		map_size = 0;
		for (i = 0; map[i].size; i++)
			if (map[i].voff == off+page) {
				map_size = sbusfb_mmapsize(map[i].size, fbsize);
#ifdef __sparc_v9__
#define POFF_MASK	(PAGE_MASK|0x1UL)
#else
#define POFF_MASK	(PAGE_MASK)
#endif				
				map_offset = (physbase + map[i].poff) & POFF_MASK;
				break;
			}
		if (!map_size){
			page += PAGE_SIZE;
			continue;
		}
		if (page + map_size > size)
			map_size = size - page;
		r = io_remap_pfn_range(vma,
					vma->vm_start + page,
					MK_IOSPACE_PFN(iospace,
						map_offset >> PAGE_SHIFT),
					map_size,
					vma->vm_page_prot);
		if (r)
			return -EAGAIN;
		page += map_size;
	}

	return 0;
}
EXPORT_SYMBOL(sbusfb_mmap_helper);

int sbusfb_ioctl_helper(unsigned long cmd, unsigned long arg,
			struct fb_info *info,
			int type, int fb_depth, unsigned long fb_size)
{
	switch(cmd) {
	case FBIOGTYPE: {
		struct fbtype __user *f = (struct fbtype __user *) arg;

		if (put_user(type, &f->fb_type) ||
		    __put_user(info->var.yres, &f->fb_height) ||
		    __put_user(info->var.xres, &f->fb_width) ||
		    __put_user(fb_depth, &f->fb_depth) ||
		    __put_user(0, &f->fb_cmsize) ||
		    __put_user(fb_size, &f->fb_cmsize))
			return -EFAULT;
		return 0;
	}
	case FBIOPUTCMAP_SPARC: {
		struct fbcmap __user *c = (struct fbcmap __user *) arg;
		struct fb_cmap cmap;
		u16 red, green, blue;
		u8 red8, green8, blue8;
		unsigned char __user *ured;
		unsigned char __user *ugreen;
		unsigned char __user *ublue;
		int index, count, i;

		if (get_user(index, &c->index) ||
		    __get_user(count, &c->count) ||
		    __get_user(ured, &c->red) ||
		    __get_user(ugreen, &c->green) ||
		    __get_user(ublue, &c->blue))
			return -EFAULT;

		cmap.len = 1;
		cmap.red = &red;
		cmap.green = &green;
		cmap.blue = &blue;
		cmap.transp = NULL;
		for (i = 0; i < count; i++) {
			int err;

			if (get_user(red8, &ured[i]) ||
			    get_user(green8, &ugreen[i]) ||
			    get_user(blue8, &ublue[i]))
				return -EFAULT;

			red = red8 << 8;
			green = green8 << 8;
			blue = blue8 << 8;

			cmap.start = index + i;
			err = fb_set_cmap(&cmap, info);
			if (err)
				return err;
		}
		return 0;
	}
	case FBIOGETCMAP_SPARC: {
		struct fbcmap __user *c = (struct fbcmap __user *) arg;
		unsigned char __user *ured;
		unsigned char __user *ugreen;
		unsigned char __user *ublue;
		struct fb_cmap *cmap = &info->cmap;
		int index, count, i;
		u8 red, green, blue;

		if (get_user(index, &c->index) ||
		    __get_user(count, &c->count) ||
		    __get_user(ured, &c->red) ||
		    __get_user(ugreen, &c->green) ||
		    __get_user(ublue, &c->blue))
			return -EFAULT;

		if (index + count > cmap->len)
			return -EINVAL;

		for (i = 0; i < count; i++) {
			red = cmap->red[index + i] >> 8;
			green = cmap->green[index + i] >> 8;
			blue = cmap->blue[index + i] >> 8;
			if (put_user(red, &ured[i]) ||
			    put_user(green, &ugreen[i]) ||
			    put_user(blue, &ublue[i]))
				return -EFAULT;
		}
		return 0;
	}
	default:
		return -EINVAL;
	};
}
EXPORT_SYMBOL(sbusfb_ioctl_helper);

#ifdef CONFIG_COMPAT
static int fbiogetputcmap(struct fb_info *info, unsigned int cmd, unsigned long arg)
{
	struct fbcmap32 __user *argp = (void __user *)arg;
	struct fbcmap __user *p = compat_alloc_user_space(sizeof(*p));
	u32 addr;
	int ret;

	ret = copy_in_user(p, argp, 2 * sizeof(int));
	ret |= get_user(addr, &argp->red);
	ret |= put_user(compat_ptr(addr), &p->red);
	ret |= get_user(addr, &argp->green);
	ret |= put_user(compat_ptr(addr), &p->green);
	ret |= get_user(addr, &argp->blue);
	ret |= put_user(compat_ptr(addr), &p->blue);
	if (ret)
		return -EFAULT;
	return info->fbops->fb_ioctl(info,
			(cmd == FBIOPUTCMAP32) ?
			FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC,
			(unsigned long)p);
}

static int fbiogscursor(struct fb_info *info, unsigned long arg)
{
	struct fbcursor __user *p = compat_alloc_user_space(sizeof(*p));
	struct fbcursor32 __user *argp =  (void __user *)arg;
	compat_uptr_t addr;
	int ret;

	ret = copy_in_user(p, argp,
			      2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
	ret |= copy_in_user(&p->size, &argp->size, sizeof(struct fbcurpos));
	ret |= copy_in_user(&p->cmap, &argp->cmap, 2 * sizeof(int));
	ret |= get_user(addr, &argp->cmap.red);
	ret |= put_user(compat_ptr(addr), &p->cmap.red);
	ret |= get_user(addr, &argp->cmap.green);
	ret |= put_user(compat_ptr(addr), &p->cmap.green);
	ret |= get_user(addr, &argp->cmap.blue);
	ret |= put_user(compat_ptr(addr), &p->cmap.blue);
	ret |= get_user(addr, &argp->mask);
	ret |= put_user(compat_ptr(addr), &p->mask);
	ret |= get_user(addr, &argp->image);
	ret |= put_user(compat_ptr(addr), &p->image);
	if (ret)
		return -EFAULT;
	return info->fbops->fb_ioctl(info, FBIOSCURSOR, (unsigned long)p);
}

int sbusfb_compat_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case FBIOGTYPE:
	case FBIOSATTR:
	case FBIOGATTR:
	case FBIOSVIDEO:
	case FBIOGVIDEO:
	case FBIOGCURSOR32:	/* This is not implemented yet.
				   Later it should be converted... */
	case FBIOSCURPOS:
	case FBIOGCURPOS:
	case FBIOGCURMAX:
		return info->fbops->fb_ioctl(info, cmd, arg);
	case FBIOPUTCMAP32:
		return fbiogetputcmap(info, cmd, arg);
	case FBIOGETCMAP32:
		return fbiogetputcmap(info, cmd, arg);
	case FBIOSCURSOR32:
		return fbiogscursor(info, arg);
	default:
		return -ENOIOCTLCMD;
	}
}
EXPORT_SYMBOL(sbusfb_compat_ioctl);
#endif
Commit	Line	Data
1da177e4 LT	1	/* sbuslib.c: Helper library for SBUS framebuffer drivers.
	2	*
	3	* Copyright (C) 2003 David S. Miller (davem@redhat.com)
	4	*/
	5
9ffb83bc	6	#include <linux/compat.h>
1da177e4 LT	7	#include <linux/kernel.h>
	8	#include <linux/module.h>
	9	#include <linux/string.h>
	10	#include <linux/fb.h>
	11	#include <linux/mm.h>
631a9dca	12	#include <linux/uaccess.h>
6cd5a86b	13	#include <linux/of_device.h>
1da177e4	14
1da177e4 LT	15	#include <asm/fbio.h>
	16
	17	#include "sbuslib.h"
	18
6cd5a86b RR	19	void sbusfb_fill_var(struct fb_var_screeninfo var, struct device_node dp,
6cd5a86b RR	20	int bpp)
1da177e4 LT	21	{
	22	memset(var, 0, sizeof(*var));
	23
6cd5a86b RR	24	var->xres = of_getintprop_default(dp, "width", 1152);
6cd5a86b RR	25	var->yres = of_getintprop_default(dp, "height", 900);
1da177e4 LT	26	var->xres_virtual = var->xres;
	27	var->yres_virtual = var->yres;
	28	var->bits_per_pixel = bpp;
	29	}
	30
	31	EXPORT_SYMBOL(sbusfb_fill_var);
	32
	33	static unsigned long sbusfb_mmapsize(long size, unsigned long fbsize)
	34	{
	35	if (size == SBUS_MMAP_EMPTY) return 0;
	36	if (size >= 0) return size;
	37	return fbsize * (-size);
	38	}
	39
	40	int sbusfb_mmap_helper(struct sbus_mmap_map *map,
	41	unsigned long physbase,
	42	unsigned long fbsize,
	43	unsigned long iospace,
	44	struct vm_area_struct *vma)
	45	{
	46	unsigned int size, page, r, map_size;
	47	unsigned long map_offset = 0;
	48	unsigned long off;
	49	int i;
	50
e445ee65 DM	51	if (!(vma->vm_flags & (VM_SHARED \| VM_MAYSHARE)))
	52	return -EINVAL;
	53
1da177e4 LT	54	size = vma->vm_end - vma->vm_start;
	55	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
	56	return -EINVAL;
	57
	58	off = vma->vm_pgoff << PAGE_SHIFT;
	59
	60	/* To stop the swapper from even considering these pages */
	61	vma->vm_flags \|= (VM_IO \| VM_RESERVED);
	62
14778d90 DM	63	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
14778d90 DM	64
1da177e4 LT	65	/* Each page, see which map applies */
	66	for (page = 0; page < size; ){
	67	map_size = 0;
	68	for (i = 0; map[i].size; i++)
	69	if (map[i].voff == off+page) {
	70	map_size = sbusfb_mmapsize(map[i].size, fbsize);
	71	#ifdef __sparc_v9__
	72	#define POFF_MASK (PAGE_MASK\|0x1UL)
	73	#else
	74	#define POFF_MASK (PAGE_MASK)
	75	#endif
	76	map_offset = (physbase + map[i].poff) & POFF_MASK;
	77	break;
	78	}
	79	if (!map_size){
	80	page += PAGE_SIZE;
	81	continue;
	82	}
	83	if (page + map_size > size)
	84	map_size = size - page;
	85	r = io_remap_pfn_range(vma,
	86	vma->vm_start + page,
	87	MK_IOSPACE_PFN(iospace,
	88	map_offset >> PAGE_SHIFT),
	89	map_size,
	90	vma->vm_page_prot);
	91	if (r)
	92	return -EAGAIN;
	93	page += map_size;
	94	}
	95
	96	return 0;
	97	}
	98	EXPORT_SYMBOL(sbusfb_mmap_helper);
	99
	100	int sbusfb_ioctl_helper(unsigned long cmd, unsigned long arg,
	101	struct fb_info *info,
	102	int type, int fb_depth, unsigned long fb_size)
	103	{
	104	switch(cmd) {
	105	case FBIOGTYPE: {
	106	struct fbtype __user f = (struct fbtype __user ) arg;
	107
	108	if (put_user(type, &f->fb_type) \|\|
	109	__put_user(info->var.yres, &f->fb_height) \|\|
	110	__put_user(info->var.xres, &f->fb_width) \|\|
	111	__put_user(fb_depth, &f->fb_depth) \|\|
	112	__put_user(0, &f->fb_cmsize) \|\|
	113	__put_user(fb_size, &f->fb_cmsize))
	114	return -EFAULT;
	115	return 0;
	116	}
	117	case FBIOPUTCMAP_SPARC: {
	118	struct fbcmap __user c = (struct fbcmap __user ) arg;
	119	struct fb_cmap cmap;
	120	u16 red, green, blue;
	121	u8 red8, green8, blue8;
	122	unsigned char __user *ured;
	123	unsigned char __user *ugreen;
	124	unsigned char __user *ublue;
	125	int index, count, i;
	126
	127	if (get_user(index, &c->index) \|\|
	128	__get_user(count, &c->count) \|\|
129	__get_user(ured, &c->red) \|\|
130	__get_user(ugreen, &c->green) \|\|
131	__get_user(ublue, &c->blue))
132	return -EFAULT;
133
134	cmap.len = 1;
135	cmap.red = &red;
136	cmap.green = &green;
137	cmap.blue = &blue;
138	cmap.transp = NULL;
139	for (i = 0; i < count; i++) {
140	int err;
141
142	if (get_user(red8, &ured[i]) \|\|
143	get_user(green8, &ugreen[i]) \|\|
144	get_user(blue8, &ublue[i]))
145	return -EFAULT;
146
147	red = red8 << 8;
148	green = green8 << 8;
149	blue = blue8 << 8;
150
151	cmap.start = index + i;
152	err = fb_set_cmap(&cmap, info);
153	if (err)
154	return err;
155	}
156	return 0;
157	}
158	case FBIOGETCMAP_SPARC: {
159	struct fbcmap __user c = (struct fbcmap __user ) arg;
160	unsigned char __user *ured;
161	unsigned char __user *ugreen;
162	unsigned char __user *ublue;
163	struct fb_cmap *cmap = &info->cmap;
164	int index, count, i;
165	u8 red, green, blue;
166
167	if (get_user(index, &c->index) \|\|
168	__get_user(count, &c->count) \|\|
169	__get_user(ured, &c->red) \|\|
170	__get_user(ugreen, &c->green) \|\|
171	__get_user(ublue, &c->blue))
172	return -EFAULT;
173
174	if (index + count > cmap->len)
175	return -EINVAL;
176
177	for (i = 0; i < count; i++) {
178	red = cmap->red[index + i] >> 8;
179	green = cmap->green[index + i] >> 8;
180	blue = cmap->blue[index + i] >> 8;
181	if (put_user(red, &ured[i]) \|\|
182	put_user(green, &ugreen[i]) \|\|
183	put_user(blue, &ublue[i]))
184	return -EFAULT;
185	}
186	return 0;
187	}
188	default:
189	return -EINVAL;
190	};
191	}
192	EXPORT_SYMBOL(sbusfb_ioctl_helper);
9ffb83bc CH	193
9ffb83bc CH	194	#ifdef CONFIG_COMPAT
c7006638	195	static int fbiogetputcmap(struct fb_info *info, unsigned int cmd, unsigned long arg)
9ffb83bc CH	196	{
	197	struct fbcmap32 __user argp = (void __user )arg;
	198	struct fbcmap __user p = compat_alloc_user_space(sizeof(p));
	199	u32 addr;
	200	int ret;
	201
	202	ret = copy_in_user(p, argp, 2 * sizeof(int));
	203	ret \|= get_user(addr, &argp->red);
	204	ret \|= put_user(compat_ptr(addr), &p->red);
	205	ret \|= get_user(addr, &argp->green);
	206	ret \|= put_user(compat_ptr(addr), &p->green);
	207	ret \|= get_user(addr, &argp->blue);
	208	ret \|= put_user(compat_ptr(addr), &p->blue);
	209	if (ret)
	210	return -EFAULT;
5ebdce72	211	return info->fbops->fb_ioctl(info,
9ffb83bc CH	212	(cmd == FBIOPUTCMAP32) ?
9ffb83bc CH	213	FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC,
5ebdce72	214	(unsigned long)p);
9ffb83bc CH	215	}
9ffb83bc CH	216
c7006638	217	static int fbiogscursor(struct fb_info *info, unsigned long arg)
9ffb83bc CH	218	{
	219	struct fbcursor __user p = compat_alloc_user_space(sizeof(p));
	220	struct fbcursor32 __user argp = (void __user )arg;
	221	compat_uptr_t addr;
	222	int ret;
	223
	224	ret = copy_in_user(p, argp,
	225	2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
	226	ret \|= copy_in_user(&p->size, &argp->size, sizeof(struct fbcurpos));
	227	ret \|= copy_in_user(&p->cmap, &argp->cmap, 2 * sizeof(int));
	228	ret \|= get_user(addr, &argp->cmap.red);
	229	ret \|= put_user(compat_ptr(addr), &p->cmap.red);
	230	ret \|= get_user(addr, &argp->cmap.green);
	231	ret \|= put_user(compat_ptr(addr), &p->cmap.green);
	232	ret \|= get_user(addr, &argp->cmap.blue);
	233	ret \|= put_user(compat_ptr(addr), &p->cmap.blue);
	234	ret \|= get_user(addr, &argp->mask);
	235	ret \|= put_user(compat_ptr(addr), &p->mask);
	236	ret \|= get_user(addr, &argp->image);
	237	ret \|= put_user(compat_ptr(addr), &p->image);
	238	if (ret)
	239	return -EFAULT;
5ebdce72	240	return info->fbops->fb_ioctl(info, FBIOSCURSOR, (unsigned long)p);
9ffb83bc CH	241	}
9ffb83bc CH	242
c7006638	243	int sbusfb_compat_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
9ffb83bc CH	244	{
	245	switch (cmd) {
	246	case FBIOGTYPE:
	247	case FBIOSATTR:
	248	case FBIOGATTR:
	249	case FBIOSVIDEO:
	250	case FBIOGVIDEO:
	251	case FBIOGCURSOR32: /* This is not implemented yet.
	252	Later it should be converted... */
	253	case FBIOSCURPOS:
	254	case FBIOGCURPOS:
	255	case FBIOGCURMAX:
5ebdce72	256	return info->fbops->fb_ioctl(info, cmd, arg);
9ffb83bc	257	case FBIOPUTCMAP32:
5ebdce72	258	return fbiogetputcmap(info, cmd, arg);
9ffb83bc	259	case FBIOGETCMAP32:
5ebdce72	260	return fbiogetputcmap(info, cmd, arg);
9ffb83bc	261	case FBIOSCURSOR32:
5ebdce72	262	return fbiogscursor(info, arg);
9ffb83bc CH	263	default:
	264	return -ENOIOCTLCMD;
	265	}
	266	}
	267	EXPORT_SYMBOL(sbusfb_compat_ioctl);
	268	#endif