/*
 * userio kernel serio device emulation module
 * Copyright (C) 2015 Red Hat
 * Copyright (C) 2015 Stephen Chandler Paul <thatslyude@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
 * General Public License for more details.
 */

#include <linux/circ_buf.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/serio.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <uapi/linux/userio.h>

#define USERIO_NAME             "userio"
#define USERIO_BUFSIZE          16

static struct miscdevice userio_misc;

struct userio_device {
        struct serio *serio;
        struct mutex mutex;

        bool running;

        u8 head;
        u8 tail;

        spinlock_t buf_lock;
        unsigned char buf[USERIO_BUFSIZE];

        wait_queue_head_t waitq;
};

/**
 * userio_device_write - Write data from serio to a userio device in userspace
 * @id: The serio port for the userio device
 * @val: The data to write to the device
 */
static int userio_device_write(struct serio *id, unsigned char val)
{
        struct userio_device *userio = id->port_data;
        unsigned long flags;

        spin_lock_irqsave(&userio->buf_lock, flags);

        userio->buf[userio->head] = val;
        userio->head = (userio->head + 1) % USERIO_BUFSIZE;

        if (userio->head == userio->tail)
                dev_warn(userio_misc.this_device,
                         "Buffer overflowed, userio client isn't keeping up");

        spin_unlock_irqrestore(&userio->buf_lock, flags);

        wake_up_interruptible(&userio->waitq);

        return 0;
}

static int userio_char_open(struct inode *inode, struct file *file)
{
        struct userio_device *userio;

        userio = kzalloc(sizeof(struct userio_device), GFP_KERNEL);
        if (!userio)
                return -ENOMEM;

        mutex_init(&userio->mutex);
        spin_lock_init(&userio->buf_lock);
        init_waitqueue_head(&userio->waitq);

        userio->serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
        if (!userio->serio) {
                kfree(userio);
                return -ENOMEM;
        }

        userio->serio->write = userio_device_write;
        userio->serio->port_data = userio;

        file->private_data = userio;

        return 0;
}

static int userio_char_release(struct inode *inode, struct file *file)
{
        struct userio_device *userio = file->private_data;

        if (userio->running) {
                /*
                 * Don't free the serio port here, serio_unregister_port()
                 * does it for us.
                 */
                serio_unregister_port(userio->serio);
        } else {
                kfree(userio->serio);
        }

        kfree(userio);

        return 0;
}

static ssize_t userio_char_read(struct file *file, char __user *user_buffer,
                                size_t count, loff_t *ppos)
{
        struct userio_device *userio = file->private_data;
        int error;
        size_t nonwrap_len, copylen;
        unsigned char buf[USERIO_BUFSIZE];
        unsigned long flags;

        /*
         * By the time we get here, the data that was waiting might have
         * been taken by another thread. Grab the buffer lock and check if
         * there's still any data waiting, otherwise repeat this process
         * until we have data (unless the file descriptor is non-blocking
         * of course).
         */
        for (;;) {
                spin_lock_irqsave(&userio->buf_lock, flags);

                nonwrap_len = CIRC_CNT_TO_END(userio->head,
                                              userio->tail,
                                              USERIO_BUFSIZE);
                copylen = min(nonwrap_len, count);
                if (copylen) {
                        memcpy(buf, &userio->buf[userio->tail], copylen);
                        userio->tail = (userio->tail + copylen) %
                                                        USERIO_BUFSIZE;
                }

                spin_unlock_irqrestore(&userio->buf_lock, flags);

                if (nonwrap_len)
                        break;

                /* buffer was/is empty */
                if (file->f_flags & O_NONBLOCK)
                        return -EAGAIN;

                /*
                 * count == 0 is special - no IO is done but we check
                 * for error conditions (see above).
                 */
                if (count == 0)
                        return 0;

                error = wait_event_interruptible(userio->waitq,
                                                 userio->head != userio->tail);
                if (error)
                        return error;
        }

        if (copylen)
                if (copy_to_user(user_buffer, buf, copylen))
                        return -EFAULT;

        return copylen;
}

static ssize_t userio_char_write(struct file *file, const char __user *buffer,
                                 size_t count, loff_t *ppos)
{
        struct userio_device *userio = file->private_data;
        struct userio_cmd cmd;
        int error;

        if (count != sizeof(cmd)) {
                dev_warn(userio_misc.this_device, "Invalid payload size\n");
                return -EINVAL;
        }

        if (copy_from_user(&cmd, buffer, sizeof(cmd)))
                return -EFAULT;

        error = mutex_lock_interruptible(&userio->mutex);
        if (error)
                return error;

        switch (cmd.type) {
        case USERIO_CMD_REGISTER:
                if (!userio->serio->id.type) {
                        dev_warn(userio_misc.this_device,
                                 "No port type given on /dev/userio\n");

                        error = -EINVAL;
                        goto out;
                }

                if (userio->running) {
                        dev_warn(userio_misc.this_device,
                                 "Begin command sent, but we're already running\n");
                        error = -EBUSY;
                        goto out;
                }

                userio->running = true;
                serio_register_port(userio->serio);
                break;

        case USERIO_CMD_SET_PORT_TYPE:
                if (userio->running) {
                        dev_warn(userio_misc.this_device,
                                 "Can't change port type on an already running userio instance\n");
                        error = -EBUSY;
                        goto out;
                }

                userio->serio->id.type = cmd.data;
                break;

        case USERIO_CMD_SEND_INTERRUPT:
                if (!userio->running) {
                        dev_warn(userio_misc.this_device,
                                 "The device must be registered before sending interrupts\n");
                        error = -ENODEV;
                        goto out;
                }

                serio_interrupt(userio->serio, cmd.data, 0);
                break;

        default:
                error = -EOPNOTSUPP;
                goto out;
        }

out:
        mutex_unlock(&userio->mutex);
        return error ?: count;
}

static __poll_t userio_char_poll(struct file *file, poll_table *wait)
{
        struct userio_device *userio = file->private_data;

        poll_wait(file, &userio->waitq, wait);

        if (userio->head != userio->tail)
                return EPOLLIN | EPOLLRDNORM;

        return 0;
}

static const struct file_operations userio_fops = {
        .owner          = THIS_MODULE,
        .open           = userio_char_open,
        .release        = userio_char_release,
        .read           = userio_char_read,
        .write          = userio_char_write,
        .poll           = userio_char_poll,
        .llseek         = no_llseek,
};

static struct miscdevice userio_misc = {
        .fops   = &userio_fops,
        .minor  = USERIO_MINOR,
        .name   = USERIO_NAME,
};
module_driver(userio_misc, misc_register, misc_deregister);

MODULE_ALIAS_MISCDEV(USERIO_MINOR);
MODULE_ALIAS("devname:" USERIO_NAME);

MODULE_AUTHOR("Stephen Chandler Paul <thatslyude@gmail.com>");
MODULE_DESCRIPTION("Virtual Serio Device Support");
MODULE_LICENSE("GPL");