video/fbdev/sbuslib.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* sbuslib.c: Helper library for SBUS framebuffer drivers.
0003  *
0004  * Copyright (C) 2003 David S. Miller (davem@redhat.com)
0005  */
0006
0007 #include <linux/compat.h>
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/string.h>
0011 #include <linux/fb.h>
0012 #include <linux/mm.h>
0013 #include <linux/uaccess.h>
0014 #include <linux/of_device.h>
0015
0016 #include <asm/fbio.h>
0017
0018 #include "sbuslib.h"
0019
0020 void sbusfb_fill_var(struct fb_var_screeninfo *var, struct device_node *dp,
0021              int bpp)
0022 {
0023     memset(var, 0, sizeof(*var));
0024
0025     var->xres = of_getintprop_default(dp, "width", 1152);
0026     var->yres = of_getintprop_default(dp, "height", 900);
0027     var->xres_virtual = var->xres;
0028     var->yres_virtual = var->yres;
0029     var->bits_per_pixel = bpp;
0030 }
0031
0032 EXPORT_SYMBOL(sbusfb_fill_var);
0033
0034 static unsigned long sbusfb_mmapsize(long size, unsigned long fbsize)
0035 {
0036     if (size == SBUS_MMAP_EMPTY) return 0;
0037     if (size >= 0) return size;
0038     return fbsize * (-size);
0039 }
0040
0041 int sbusfb_mmap_helper(struct sbus_mmap_map *map,
0042                unsigned long physbase,
0043                unsigned long fbsize,
0044                unsigned long iospace,
0045                struct vm_area_struct *vma)
0046 {
0047     unsigned int size, page, r, map_size;
0048     unsigned long map_offset = 0;
0049     unsigned long off;
0050     int i;
0051
0052     if (!(vma->vm_flags & (VM_SHARED | VM_MAYSHARE)))
0053         return -EINVAL;
0054
0055     size = vma->vm_end - vma->vm_start;
0056     if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
0057         return -EINVAL;
0058
0059     off = vma->vm_pgoff << PAGE_SHIFT;
0060
0061     /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
0062
0063     vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
0064
0065     /* Each page, see which map applies */
0066     for (page = 0; page < size; ){
0067         map_size = 0;
0068         for (i = 0; map[i].size; i++)
0069             if (map[i].voff == off+page) {
0070                 map_size = sbusfb_mmapsize(map[i].size, fbsize);
0071 #ifdef __sparc_v9__
0072 #define POFF_MASK   (PAGE_MASK|0x1UL)
0073 #else
0074 #define POFF_MASK   (PAGE_MASK)
0075 #endif
0076                 map_offset = (physbase + map[i].poff) & POFF_MASK;
0077                 break;
0078             }
0079         if (!map_size) {
0080             page += PAGE_SIZE;
0081             continue;
0082         }
0083         if (page + map_size > size)
0084             map_size = size - page;
0085         r = io_remap_pfn_range(vma,
0086                     vma->vm_start + page,
0087                     MK_IOSPACE_PFN(iospace,
0088                         map_offset >> PAGE_SHIFT),
0089                     map_size,
0090                     vma->vm_page_prot);
0091         if (r)
0092             return -EAGAIN;
0093         page += map_size;
0094     }
0095
0096     return 0;
0097 }
0098 EXPORT_SYMBOL(sbusfb_mmap_helper);
0099
0100 int sbusfb_ioctl_helper(unsigned long cmd, unsigned long arg,
0101             struct fb_info *info,
0102             int type, int fb_depth, unsigned long fb_size)
0103 {
0104     switch(cmd) {
0105     case FBIOGTYPE: {
0106         struct fbtype __user *f = (struct fbtype __user *) arg;
0107
0108         if (put_user(type, &f->fb_type) ||
0109             put_user(info->var.yres, &f->fb_height) ||
0110             put_user(info->var.xres, &f->fb_width) ||
0111             put_user(fb_depth, &f->fb_depth) ||
0112             put_user(0, &f->fb_cmsize) ||
0113             put_user(fb_size, &f->fb_cmsize))
0114             return -EFAULT;
0115         return 0;
0116     }
0117     case FBIOPUTCMAP_SPARC: {
0118         struct fbcmap __user *c = (struct fbcmap __user *) arg;
0119         struct fb_cmap cmap;
0120         u16 red, green, blue;
0121         u8 red8, green8, blue8;
0122         unsigned char __user *ured;
0123         unsigned char __user *ugreen;
0124         unsigned char __user *ublue;
0125         unsigned int index, count, i;
0126
0127         if (get_user(index, &c->index) ||
0128             get_user(count, &c->count) ||
0129             get_user(ured, &c->red) ||
0130             get_user(ugreen, &c->green) ||
0131             get_user(ublue, &c->blue))
0132             return -EFAULT;
0133
0134         cmap.len = 1;
0135         cmap.red = &red;
0136         cmap.green = &green;
0137         cmap.blue = &blue;
0138         cmap.transp = NULL;
0139         for (i = 0; i < count; i++) {
0140             int err;
0141
0142             if (get_user(red8, &ured[i]) ||
0143                 get_user(green8, &ugreen[i]) ||
0144                 get_user(blue8, &ublue[i]))
0145                 return -EFAULT;
0146
0147             red = red8 << 8;
0148             green = green8 << 8;
0149             blue = blue8 << 8;
0150
0151             cmap.start = index + i;
0152             err = fb_set_cmap(&cmap, info);
0153             if (err)
0154                 return err;
0155         }
0156         return 0;
0157     }
0158     case FBIOGETCMAP_SPARC: {
0159         struct fbcmap __user *c = (struct fbcmap __user *) arg;
0160         unsigned char __user *ured;
0161         unsigned char __user *ugreen;
0162         unsigned char __user *ublue;
0163         struct fb_cmap *cmap = &info->cmap;
0164         unsigned int index, count, i;
0165         u8 red, green, blue;
0166
0167         if (get_user(index, &c->index) ||
0168             get_user(count, &c->count) ||
0169             get_user(ured, &c->red) ||
0170             get_user(ugreen, &c->green) ||
0171             get_user(ublue, &c->blue))
0172             return -EFAULT;
0173
0174         if (index > cmap->len || count > cmap->len - index)
0175             return -EINVAL;
0176
0177         for (i = 0; i < count; i++) {
0178             red = cmap->red[index + i] >> 8;
0179             green = cmap->green[index + i] >> 8;
0180             blue = cmap->blue[index + i] >> 8;
0181             if (put_user(red, &ured[i]) ||
0182                 put_user(green, &ugreen[i]) ||
0183                 put_user(blue, &ublue[i]))
0184                 return -EFAULT;
0185         }
0186         return 0;
0187     }
0188     default:
0189         return -EINVAL;
0190     }
0191 }
0192 EXPORT_SYMBOL(sbusfb_ioctl_helper);
0193
0194 #ifdef CONFIG_COMPAT
0195 int sbusfb_compat_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
0196 {
0197     switch (cmd) {
0198     case FBIOGTYPE:
0199     case FBIOSATTR:
0200     case FBIOGATTR:
0201     case FBIOSVIDEO:
0202     case FBIOGVIDEO:
0203     case FBIOSCURSOR32:
0204     case FBIOGCURSOR32: /* This is not implemented yet.
0205                    Later it should be converted... */
0206     case FBIOSCURPOS:
0207     case FBIOGCURPOS:
0208     case FBIOGCURMAX:
0209         return info->fbops->fb_ioctl(info, cmd, arg);
0210     case FBIOPUTCMAP32:
0211     case FBIOPUTCMAP_SPARC: {
0212         struct fbcmap32 c;
0213         struct fb_cmap cmap;
0214         u16 red, green, blue;
0215         u8 red8, green8, blue8;
0216         unsigned char __user *ured;
0217         unsigned char __user *ugreen;
0218         unsigned char __user *ublue;
0219         unsigned int i;
0220
0221         if (copy_from_user(&c, compat_ptr(arg), sizeof(c)))
0222             return -EFAULT;
0223         ured = compat_ptr(c.red);
0224         ugreen = compat_ptr(c.green);
0225         ublue = compat_ptr(c.blue);
0226
0227         cmap.len = 1;
0228         cmap.red = &red;
0229         cmap.green = &green;
0230         cmap.blue = &blue;
0231         cmap.transp = NULL;
0232         for (i = 0; i < c.count; i++) {
0233             int err;
0234
0235             if (get_user(red8, &ured[i]) ||
0236                 get_user(green8, &ugreen[i]) ||
0237                 get_user(blue8, &ublue[i]))
0238                 return -EFAULT;
0239
0240             red = red8 << 8;
0241             green = green8 << 8;
0242             blue = blue8 << 8;
0243
0244             cmap.start = c.index + i;
0245             err = fb_set_cmap(&cmap, info);
0246             if (err)
0247                 return err;
0248         }
0249         return 0;
0250     }
0251     case FBIOGETCMAP32: {
0252         struct fbcmap32 c;
0253         unsigned char __user *ured;
0254         unsigned char __user *ugreen;
0255         unsigned char __user *ublue;
0256         struct fb_cmap *cmap = &info->cmap;
0257         unsigned int index, i;
0258         u8 red, green, blue;
0259
0260         if (copy_from_user(&c, compat_ptr(arg), sizeof(c)))
0261             return -EFAULT;
0262         index = c.index;
0263         ured = compat_ptr(c.red);
0264         ugreen = compat_ptr(c.green);
0265         ublue = compat_ptr(c.blue);
0266
0267         if (index > cmap->len || c.count > cmap->len - index)
0268             return -EINVAL;
0269
0270         for (i = 0; i < c.count; i++) {
0271             red = cmap->red[index + i] >> 8;
0272             green = cmap->green[index + i] >> 8;
0273             blue = cmap->blue[index + i] >> 8;
0274             if (put_user(red, &ured[i]) ||
0275                 put_user(green, &ugreen[i]) ||
0276                 put_user(blue, &ublue[i]))
0277                 return -EFAULT;
0278         }
0279         return 0;
0280     }
0281     default:
0282         return -ENOIOCTLCMD;
0283     }
0284 }
0285 EXPORT_SYMBOL(sbusfb_compat_ioctl);
0286 #endif