445 lines
9.9 KiB
C
445 lines
9.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/compat.h>
|
|
#include <linux/console.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/fbcon.h>
|
|
#include <linux/major.h>
|
|
|
|
#include "fb_internal.h"
|
|
|
|
/*
|
|
* We hold a reference to the fb_info in file->private_data,
|
|
* but if the current registered fb has changed, we don't
|
|
* actually want to use it.
|
|
*
|
|
* So look up the fb_info using the inode minor number,
|
|
* and just verify it against the reference we have.
|
|
*/
|
|
static struct fb_info *file_fb_info(struct file *file)
|
|
{
|
|
struct inode *inode = file_inode(file);
|
|
int fbidx = iminor(inode);
|
|
struct fb_info *info = registered_fb[fbidx];
|
|
|
|
if (info != file->private_data)
|
|
info = NULL;
|
|
return info;
|
|
}
|
|
|
|
static ssize_t fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
struct fb_info *info = file_fb_info(file);
|
|
|
|
if (!info)
|
|
return -ENODEV;
|
|
|
|
if (fb_WARN_ON_ONCE(info, !info->fbops->fb_read))
|
|
return -EINVAL;
|
|
|
|
if (info->state != FBINFO_STATE_RUNNING)
|
|
return -EPERM;
|
|
|
|
return info->fbops->fb_read(info, buf, count, ppos);
|
|
}
|
|
|
|
static ssize_t fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
struct fb_info *info = file_fb_info(file);
|
|
|
|
if (!info)
|
|
return -ENODEV;
|
|
|
|
if (fb_WARN_ON_ONCE(info, !info->fbops->fb_write))
|
|
return -EINVAL;
|
|
|
|
if (info->state != FBINFO_STATE_RUNNING)
|
|
return -EPERM;
|
|
|
|
return info->fbops->fb_write(info, buf, count, ppos);
|
|
}
|
|
|
|
static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
const struct fb_ops *fb;
|
|
struct fb_var_screeninfo var;
|
|
struct fb_fix_screeninfo fix;
|
|
struct fb_cmap cmap_from;
|
|
struct fb_cmap_user cmap;
|
|
void __user *argp = (void __user *)arg;
|
|
long ret = 0;
|
|
|
|
switch (cmd) {
|
|
case FBIOGET_VSCREENINFO:
|
|
lock_fb_info(info);
|
|
var = info->var;
|
|
unlock_fb_info(info);
|
|
|
|
ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;
|
|
break;
|
|
case FBIOPUT_VSCREENINFO:
|
|
if (copy_from_user(&var, argp, sizeof(var)))
|
|
return -EFAULT;
|
|
/* only for kernel-internal use */
|
|
var.activate &= ~FB_ACTIVATE_KD_TEXT;
|
|
console_lock();
|
|
lock_fb_info(info);
|
|
ret = fbcon_modechange_possible(info, &var);
|
|
if (!ret)
|
|
ret = fb_set_var(info, &var);
|
|
if (!ret)
|
|
fbcon_update_vcs(info, var.activate & FB_ACTIVATE_ALL);
|
|
unlock_fb_info(info);
|
|
console_unlock();
|
|
if (!ret && copy_to_user(argp, &var, sizeof(var)))
|
|
ret = -EFAULT;
|
|
break;
|
|
case FBIOGET_FSCREENINFO:
|
|
lock_fb_info(info);
|
|
memcpy(&fix, &info->fix, sizeof(fix));
|
|
if (info->flags & FBINFO_HIDE_SMEM_START)
|
|
fix.smem_start = 0;
|
|
unlock_fb_info(info);
|
|
|
|
ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
|
|
break;
|
|
case FBIOPUTCMAP:
|
|
if (copy_from_user(&cmap, argp, sizeof(cmap)))
|
|
return -EFAULT;
|
|
ret = fb_set_user_cmap(&cmap, info);
|
|
break;
|
|
case FBIOGETCMAP:
|
|
if (copy_from_user(&cmap, argp, sizeof(cmap)))
|
|
return -EFAULT;
|
|
lock_fb_info(info);
|
|
cmap_from = info->cmap;
|
|
unlock_fb_info(info);
|
|
ret = fb_cmap_to_user(&cmap_from, &cmap);
|
|
break;
|
|
case FBIOPAN_DISPLAY:
|
|
if (copy_from_user(&var, argp, sizeof(var)))
|
|
return -EFAULT;
|
|
console_lock();
|
|
lock_fb_info(info);
|
|
ret = fb_pan_display(info, &var);
|
|
unlock_fb_info(info);
|
|
console_unlock();
|
|
if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
|
|
return -EFAULT;
|
|
break;
|
|
case FBIO_CURSOR:
|
|
ret = -EINVAL;
|
|
break;
|
|
case FBIOGET_CON2FBMAP:
|
|
ret = fbcon_get_con2fb_map_ioctl(argp);
|
|
break;
|
|
case FBIOPUT_CON2FBMAP:
|
|
ret = fbcon_set_con2fb_map_ioctl(argp);
|
|
break;
|
|
case FBIOBLANK:
|
|
if (arg > FB_BLANK_POWERDOWN)
|
|
return -EINVAL;
|
|
console_lock();
|
|
lock_fb_info(info);
|
|
ret = fb_blank(info, arg);
|
|
/* might again call into fb_blank */
|
|
fbcon_fb_blanked(info, arg);
|
|
unlock_fb_info(info);
|
|
console_unlock();
|
|
break;
|
|
default:
|
|
lock_fb_info(info);
|
|
fb = info->fbops;
|
|
if (fb->fb_ioctl)
|
|
ret = fb->fb_ioctl(info, cmd, arg);
|
|
else
|
|
ret = -ENOTTY;
|
|
unlock_fb_info(info);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct fb_info *info = file_fb_info(file);
|
|
|
|
if (!info)
|
|
return -ENODEV;
|
|
return do_fb_ioctl(info, cmd, arg);
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
struct fb_fix_screeninfo32 {
|
|
char id[16];
|
|
compat_caddr_t smem_start;
|
|
u32 smem_len;
|
|
u32 type;
|
|
u32 type_aux;
|
|
u32 visual;
|
|
u16 xpanstep;
|
|
u16 ypanstep;
|
|
u16 ywrapstep;
|
|
u32 line_length;
|
|
compat_caddr_t mmio_start;
|
|
u32 mmio_len;
|
|
u32 accel;
|
|
u16 reserved[3];
|
|
};
|
|
|
|
struct fb_cmap32 {
|
|
u32 start;
|
|
u32 len;
|
|
compat_caddr_t red;
|
|
compat_caddr_t green;
|
|
compat_caddr_t blue;
|
|
compat_caddr_t transp;
|
|
};
|
|
|
|
static int fb_getput_cmap(struct fb_info *info, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
struct fb_cmap32 cmap32;
|
|
struct fb_cmap cmap_from;
|
|
struct fb_cmap_user cmap;
|
|
|
|
if (copy_from_user(&cmap32, compat_ptr(arg), sizeof(cmap32)))
|
|
return -EFAULT;
|
|
|
|
cmap = (struct fb_cmap_user) {
|
|
.start = cmap32.start,
|
|
.len = cmap32.len,
|
|
.red = compat_ptr(cmap32.red),
|
|
.green = compat_ptr(cmap32.green),
|
|
.blue = compat_ptr(cmap32.blue),
|
|
.transp = compat_ptr(cmap32.transp),
|
|
};
|
|
|
|
if (cmd == FBIOPUTCMAP)
|
|
return fb_set_user_cmap(&cmap, info);
|
|
|
|
lock_fb_info(info);
|
|
cmap_from = info->cmap;
|
|
unlock_fb_info(info);
|
|
|
|
return fb_cmap_to_user(&cmap_from, &cmap);
|
|
}
|
|
|
|
static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix,
|
|
struct fb_fix_screeninfo32 __user *fix32)
|
|
{
|
|
__u32 data;
|
|
int err;
|
|
|
|
err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id));
|
|
|
|
data = (__u32) (unsigned long) fix->smem_start;
|
|
err |= put_user(data, &fix32->smem_start);
|
|
|
|
err |= put_user(fix->smem_len, &fix32->smem_len);
|
|
err |= put_user(fix->type, &fix32->type);
|
|
err |= put_user(fix->type_aux, &fix32->type_aux);
|
|
err |= put_user(fix->visual, &fix32->visual);
|
|
err |= put_user(fix->xpanstep, &fix32->xpanstep);
|
|
err |= put_user(fix->ypanstep, &fix32->ypanstep);
|
|
err |= put_user(fix->ywrapstep, &fix32->ywrapstep);
|
|
err |= put_user(fix->line_length, &fix32->line_length);
|
|
|
|
data = (__u32) (unsigned long) fix->mmio_start;
|
|
err |= put_user(data, &fix32->mmio_start);
|
|
|
|
err |= put_user(fix->mmio_len, &fix32->mmio_len);
|
|
err |= put_user(fix->accel, &fix32->accel);
|
|
err |= copy_to_user(fix32->reserved, fix->reserved,
|
|
sizeof(fix->reserved));
|
|
|
|
if (err)
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
|
|
static int fb_get_fscreeninfo(struct fb_info *info, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
struct fb_fix_screeninfo fix;
|
|
|
|
lock_fb_info(info);
|
|
fix = info->fix;
|
|
if (info->flags & FBINFO_HIDE_SMEM_START)
|
|
fix.smem_start = 0;
|
|
unlock_fb_info(info);
|
|
return do_fscreeninfo_to_user(&fix, compat_ptr(arg));
|
|
}
|
|
|
|
static long fb_compat_ioctl(struct file *file, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
struct fb_info *info = file_fb_info(file);
|
|
const struct fb_ops *fb;
|
|
long ret = -ENOIOCTLCMD;
|
|
|
|
if (!info)
|
|
return -ENODEV;
|
|
fb = info->fbops;
|
|
switch (cmd) {
|
|
case FBIOGET_VSCREENINFO:
|
|
case FBIOPUT_VSCREENINFO:
|
|
case FBIOPAN_DISPLAY:
|
|
case FBIOGET_CON2FBMAP:
|
|
case FBIOPUT_CON2FBMAP:
|
|
arg = (unsigned long) compat_ptr(arg);
|
|
fallthrough;
|
|
case FBIOBLANK:
|
|
ret = do_fb_ioctl(info, cmd, arg);
|
|
break;
|
|
|
|
case FBIOGET_FSCREENINFO:
|
|
ret = fb_get_fscreeninfo(info, cmd, arg);
|
|
break;
|
|
|
|
case FBIOGETCMAP:
|
|
case FBIOPUTCMAP:
|
|
ret = fb_getput_cmap(info, cmd, arg);
|
|
break;
|
|
|
|
default:
|
|
if (fb->fb_compat_ioctl)
|
|
ret = fb->fb_compat_ioctl(info, cmd, arg);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static int fb_mmap(struct file *file, struct vm_area_struct *vma)
|
|
{
|
|
struct fb_info *info = file_fb_info(file);
|
|
int res;
|
|
|
|
if (!info)
|
|
return -ENODEV;
|
|
|
|
if (fb_WARN_ON_ONCE(info, !info->fbops->fb_mmap))
|
|
return -ENODEV;
|
|
|
|
mutex_lock(&info->mm_lock);
|
|
res = info->fbops->fb_mmap(info, vma);
|
|
mutex_unlock(&info->mm_lock);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int fb_open(struct inode *inode, struct file *file)
|
|
__acquires(&info->lock)
|
|
__releases(&info->lock)
|
|
{
|
|
int fbidx = iminor(inode);
|
|
struct fb_info *info;
|
|
int res = 0;
|
|
|
|
info = get_fb_info(fbidx);
|
|
if (!info) {
|
|
request_module("fb%d", fbidx);
|
|
info = get_fb_info(fbidx);
|
|
if (!info)
|
|
return -ENODEV;
|
|
}
|
|
if (IS_ERR(info))
|
|
return PTR_ERR(info);
|
|
|
|
lock_fb_info(info);
|
|
if (!try_module_get(info->fbops->owner)) {
|
|
res = -ENODEV;
|
|
goto out;
|
|
}
|
|
file->private_data = info;
|
|
if (info->fbops->fb_open) {
|
|
res = info->fbops->fb_open(info, 1);
|
|
if (res)
|
|
module_put(info->fbops->owner);
|
|
}
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
if (info->fbdefio)
|
|
fb_deferred_io_open(info, inode, file);
|
|
#endif
|
|
out:
|
|
unlock_fb_info(info);
|
|
if (res)
|
|
put_fb_info(info);
|
|
return res;
|
|
}
|
|
|
|
static int fb_release(struct inode *inode, struct file *file)
|
|
__acquires(&info->lock)
|
|
__releases(&info->lock)
|
|
{
|
|
struct fb_info * const info = file->private_data;
|
|
|
|
lock_fb_info(info);
|
|
#if IS_ENABLED(CONFIG_FB_DEFERRED_IO)
|
|
if (info->fbdefio)
|
|
fb_deferred_io_release(info);
|
|
#endif
|
|
if (info->fbops->fb_release)
|
|
info->fbops->fb_release(info, 1);
|
|
module_put(info->fbops->owner);
|
|
unlock_fb_info(info);
|
|
put_fb_info(info);
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA) && !defined(CONFIG_MMU)
|
|
static unsigned long get_fb_unmapped_area(struct file *filp,
|
|
unsigned long addr, unsigned long len,
|
|
unsigned long pgoff, unsigned long flags)
|
|
{
|
|
struct fb_info * const info = filp->private_data;
|
|
unsigned long fb_size = PAGE_ALIGN(info->fix.smem_len);
|
|
|
|
if (pgoff > fb_size || len > fb_size - pgoff)
|
|
return -EINVAL;
|
|
|
|
return (unsigned long)info->screen_base + pgoff;
|
|
}
|
|
#endif
|
|
|
|
static const struct file_operations fb_fops = {
|
|
.owner = THIS_MODULE,
|
|
.read = fb_read,
|
|
.write = fb_write,
|
|
.unlocked_ioctl = fb_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = fb_compat_ioctl,
|
|
#endif
|
|
.mmap = fb_mmap,
|
|
.open = fb_open,
|
|
.release = fb_release,
|
|
#if defined(HAVE_ARCH_FB_UNMAPPED_AREA) || \
|
|
(defined(CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA) && \
|
|
!defined(CONFIG_MMU))
|
|
.get_unmapped_area = get_fb_unmapped_area,
|
|
#endif
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
.fsync = fb_deferred_io_fsync,
|
|
#endif
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
int fb_register_chrdev(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = register_chrdev(FB_MAJOR, "fb", &fb_fops);
|
|
if (ret) {
|
|
pr_err("Unable to get major %d for fb devs\n", FB_MAJOR);
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void fb_unregister_chrdev(void)
|
|
{
|
|
unregister_chrdev(FB_MAJOR, "fb");
|
|
}
|