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