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