sbuslib.c

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