mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Robert Reif](/assets/img/avatar_default.png)
Replace remaining open boot prom code with of. Boot tested on sparc32 and compile tested on sparc64. Signed-off-by: Robert Reif <reif@earthlink.net> Signed-off-by: David S. Miller <davem@davemloft.net>
268 lines
6.9 KiB
C
268 lines
6.9 KiB
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
|