Input: add userio module

			      The userio Protocol

	     (c) 2015 Stephen Chandler Paul <thatslyude@gmail.com>

			      Sponsored by Red Hat

--------------------------------------------------------------------------------

1. Introduction

~~~~~~~~~~~~~~~

  This module is intended to try to make the lives of input driver developers

easier by allowing them to test various serio devices (mainly the various

touchpads found on laptops) without having to have the physical device in front

of them. userio accomplishes this by allowing any privileged userspace program

to directly interact with the kernel's serio driver and control a virtual serio

port from there.

2. Usage overview

~~~~~~~~~~~~~~~~~

  In order to interact with the userio kernel module, one simply opens the

/dev/userio character device in their applications. Commands are sent to the

kernel module by writing to the device, and any data received from the serio

driver is read as-is from the /dev/userio device. All of the structures and

macros you need to interact with the device are defined in <linux/userio.h> and

<linux/serio.h>.

3. Command Structure

~~~~~~~~~~~~~~~~~~~~

  The struct used for sending commands to /dev/userio is as follows:

	struct userio_cmd {

		__u8 type;

		__u8 data;

	};

  "type" describes the type of command that is being sent. This can be any one

of the USERIO_CMD macros defined in <linux/userio.h>. "data" is the argument

that goes along with the command. In the event that the command doesn't have an

argument, this field can be left untouched and will be ignored by the kernel.

Each command should be sent by writing the struct directly to the character

device. In the event that the command you send is invalid, an error will be

returned by the character device and a more descriptive error will be printed

to the kernel log. Only one command can be sent at a time, any additional data

written to the character device after the initial command will be ignored.

  To close the virtual serio port, just close /dev/userio.

4. Commands

~~~~~~~~~~~

4.1 USERIO_CMD_REGISTER

~~~~~~~~~~~~~~~~~~~~~~~

  Registers the port with the serio driver and begins transmitting data back and

forth. Registration can only be performed once a port type is set with

USERIO_CMD_SET_PORT_TYPE. Has no argument.

4.2 USERIO_CMD_SET_PORT_TYPE

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Sets the type of port we're emulating, where "data" is the port type being

set. Can be any of the macros from <linux/serio.h>. For example: SERIO_8042

would set the port type to be a normal PS/2 port.

4.3 USERIO_CMD_SEND_INTERRUPT

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Sends an interrupt through the virtual serio port to the serio driver, where

"data" is the interrupt data being sent.

5. Userspace tools

~~~~~~~~~~~~~~~~~~

  The userio userspace tools are able to record PS/2 devices using some of the

debugging information from i8042, and play back the devices on /dev/userio. The

latest version of these tools can be found at:

	https://github.com/Lyude/ps2emu

F:	drivers/media/v4l2-core/videobuf2-*

F:	include/media/videobuf2-*

VIRTUAL SERIO DEVICE DRIVER

M:	Stephen Chandler Paul <thatslyude@gmail.com>

S:	Maintained

F:	drivers/input/serio/userio.c

F:	include/uapi/linux/userio.h

VIRTIO CONSOLE DRIVER

M:	Amit Shah <amit.shah@redhat.com>

L:	virtualization@lists.linux-foundation.org

	  To compile this driver as a module, choose M here: the

	  module will be called sun4i-ps2.

config USERIO

	tristate "User space serio port driver support"

	help

	  Say Y here if you want to support user level drivers for serio

	  subsystem accessible under char device 10:240 - /dev/userio. Using

	  this facility userspace programs can implement serio ports that

	  will be used by the standard in-kernel serio consumer drivers,

	  such as psmouse and atkbd.

	  To compile this driver as a module, choose M here: the module will be

	  called userio.

	  If you are unsure, say N.

endif

obj-$(CONFIG_SERIO_OLPC_APSP)	+= olpc_apsp.o

obj-$(CONFIG_HYPERV_KEYBOARD)	+= hyperv-keyboard.o

obj-$(CONFIG_SERIO_SUN4I_PS2)	+= sun4i-ps2.o

obj-$(CONFIG_USERIO)		+= userio.o

/*

 * 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 unsigned int 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 POLLIN | POLLRDNORM;

	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");