[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 <asm/oplib.h>
#include <asm/fbio.h>

#include "sbuslib.h"

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

	var->xres = prom_getintdefault(prom_node, "width", 1152);
	var->yres = prom_getintdefault(prom_node, "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);
	
	/* 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
struct  fbcmap32 {
	int             index;          /* first element (0 origin) */
	int             count;
	u32		red;
	u32		green;
	u32		blue;
};

#define FBIOPUTCMAP32	_IOW('F', 3, struct fbcmap32)
#define FBIOGETCMAP32	_IOW('F', 4, struct fbcmap32)

static int fbiogetputcmap(struct file *file, 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(file->f_dentry->d_inode, file,
			(cmd == FBIOPUTCMAP32) ?
			FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC,
			(unsigned long)p, info);
}

struct fbcursor32 {
	short set;		/* what to set, choose from the list above */
	short enable;		/* cursor on/off */
	struct fbcurpos pos;	/* cursor position */
	struct fbcurpos hot;	/* cursor hot spot */
	struct fbcmap32 cmap;	/* color map info */
	struct fbcurpos size;	/* cursor bit map size */
	u32	image;		/* cursor image bits */
	u32	mask;		/* cursor mask bits */
};

#define FBIOSCURSOR32	_IOW('F', 24, struct fbcursor32)
#define FBIOGCURSOR32	_IOW('F', 25, struct fbcursor32)

static int fbiogscursor(struct file *file, 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(file->f_dentry->d_inode, file,
			FBIOSCURSOR, (unsigned long)p, info);
}

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