fbdev.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <sys/uaccess.h>
#include <core/module.h>
 
#include <dev/fbdev.h>
#include <dev/ramdev.h>
 
#include <fs/vfs.h>
#include <fs/devfs.h>
#include <fs/posix.h>
 
#define MAX_FBDEV   2
 
static struct fbdev registered_fbs[MAX_FBDEV];
static size_t fbdev_cnt = 0;

int fbdev_register(int type, void *data)
{
    if (fbdev_cnt == MAX_FBDEV)
        return -ENOSPC;
 
    registered_fbs[fbdev_cnt].type = type;
    registered_fbs[fbdev_cnt++].data = data;
 
    return 0;
}

static struct fbdev *fbdev_get(struct devid *dd)
{
    if (dd->minor >= fbdev_cnt)
        return NULL;
 
    return &registered_fbs[dd->minor];
}

struct fbdev *fbdev_primary(void)
{
    if (!fbdev_cnt || !registered_fbs[0].fix_screeninfo)
        return NULL;
 
    return &registered_fbs[0];
}

static ssize_t fbdev_write(struct devid *dd, off_t offset, struct iobuf *io)
{
    struct fbdev *fb = fbdev_get(dd);
 
    if (!fb || !fb->write)
        return -ENXIO;
 
    return fb->write(fb, offset, io);
}

static int fbdev_ioctl(struct devid *dd, int request, void *argp)
{
    struct fbdev *fb = fbdev_get(dd);
 
    if (!fb)
        return -ENXIO;
 
    switch (request) {
    case FBIOGET_FSCREENINFO:
        if (!fb->fix_screeninfo)
            return -ENXIO;
        return copyout(argp, fb->fix_screeninfo, sizeof(struct fb_fix_screeninfo));
    case FBIOGET_VSCREENINFO:
        if (!fb->var_screeninfo)
            return -ENXIO;
        return copyout(argp, fb->var_screeninfo, sizeof(struct fb_var_screeninfo));
    case FBIOPUT_VSCREENINFO: {
        /* the mode can't be changed: only a request for the mode it is
         * already succeeds, and the caller gets the mode back */
        struct fb_var_screeninfo *var = fb->var_screeninfo, _new, *new = &_new;
 
        if (!var)
            return -ENXIO;
        if (copyin(new, argp, sizeof(*new)))
            return -EFAULT;
 
        if (new->xres != var->xres || new->yres != var->yres ||
            new->xres_virtual > var->xres_virtual ||
            new->yres_virtual > var->yres_virtual ||
            (new->bits_per_pixel && new->bits_per_pixel != var->bits_per_pixel) ||
            new->xoffset || new->yoffset)
            return -EINVAL;
 
        return copyout(argp, var, sizeof(struct fb_var_screeninfo));
    }
    case FBIOPAN_DISPLAY: {
        /* no panning: the virtual screen is the visible one */
        struct fb_var_screeninfo new;
 
        if (copyin(&new, argp, sizeof(new)))
            return -EFAULT;
 
        return new.xoffset || new.yoffset ? -EINVAL : 0;
    }
    }
 
    return -ENOTTY;
}

static int fbdev_map(struct devid *dd, struct vm_space *vm_space, struct vm_entry *vm_entry)
{
    struct fbdev *fb = fbdev_get(dd);
 
    if (!fb || !fb->map)
        return -ENXIO;
 
    return fb->map(fb, vm_space, vm_entry);
}

int fbdev_probe()
{
    for (size_t i = 0; i < fbdev_cnt; ++i) {
        struct fbdev *fb = &registered_fbs[i];
 
        switch (fb->type) {
            case FBDEV_TYPE_VESA:
                fbdev_vesa.probe(i, fb);
                break;
        }
    }
 
    kdev_chrdev_register(29, &fbdev);
    return 0;
}
 
struct dev fbdev = {
    .name = "fbdev",
 
    .probe  = fbdev_probe,
    .write  = fbdev_write,
    .ioctl  = fbdev_ioctl,
    .map    = fbdev_map,
 
    /* no driver can read the screen back (vesa's only writes), so there
     * is no read() */
    .fops = {
        .open  = posix_file_open,
        .write = posix_file_write,
        .ioctl = posix_file_ioctl,
        .lseek = posix_file_lseek,
 
        .can_write = __vfs_can_always,
        .can_read  = __vfs_can_never,
        .eof       = __vfs_eof_never,
    },
};
 
MODULE_INIT(fbdev, fbdev_probe, NULL)