286 lines
6.5 KiB
C
286 lines
6.5 KiB
C
|
/*
|
||
|
|
* 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");
|