aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/video/fbdev/sbuslib.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/video/fbdev/sbuslib.c')
-rw-r--r--drivers/video/fbdev/sbuslib.c267
1 files changed, 267 insertions, 0 deletions
diff --git a/drivers/video/fbdev/sbuslib.c b/drivers/video/fbdev/sbuslib.c
new file mode 100644
index 000000000000..a350209ffbd3
--- /dev/null
+++ b/drivers/video/fbdev/sbuslib.c
@@ -0,0 +1,267 @@
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#include <linux/of_device.h>
14
15#include <asm/fbio.h>
16
17#include "sbuslib.h"
18
19void sbusfb_fill_var(struct fb_var_screeninfo *var, struct device_node *dp,
20 int bpp)
21{
22 memset(var, 0, sizeof(*var));
23
24 var->xres = of_getintprop_default(dp, "width", 1152);
25 var->yres = of_getintprop_default(dp, "height", 900);
26 var->xres_virtual = var->xres;
27 var->yres_virtual = var->yres;
28 var->bits_per_pixel = bpp;
29}
30
31EXPORT_SYMBOL(sbusfb_fill_var);
32
33static 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
40int 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
51 if (!(vma->vm_flags & (VM_SHARED | VM_MAYSHARE)))
52 return -EINVAL;
53
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 /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
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}
97EXPORT_SYMBOL(sbusfb_mmap_helper);
98
99int 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}
191EXPORT_SYMBOL(sbusfb_ioctl_helper);
192
193#ifdef CONFIG_COMPAT
194static 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
216static 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
242int 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}
266EXPORT_SYMBOL(sbusfb_compat_ioctl);
267#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-05-29 13:27:26 -0400