drivers/input/serio/userio.c

   1 /*
   2  * userio kernel serio device emulation module
   3  * Copyright (C) 2015 Red Hat
   4  * Copyright (C) 2015 Stephen Chandler Paul <thatslyude@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
  14  * General Public License for more details.
  15  */
  16
  17 #include <linux/circ_buf.h>
  18 #include <linux/mutex.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/kernel.h>
  22 #include <linux/serio.h>
  23 #include <linux/slab.h>
  24 #include <linux/fs.h>
  25 #include <linux/miscdevice.h>
  26 #include <linux/sched.h>
  27 #include <linux/poll.h>
  28 #include <uapi/linux/userio.h>
  29
  30 #define USERIO_NAME             "userio"
  31 #define USERIO_BUFSIZE          16
  32
  33 static struct miscdevice userio_misc;
  34
  35 struct userio_device {
  36         struct serio *serio;
  37         struct mutex mutex;
  38
  39         bool running;
  40
  41         u8 head;
  42         u8 tail;
  43
  44         spinlock_t buf_lock;
  45         unsigned char buf[USERIO_BUFSIZE];
  46
  47         wait_queue_head_t waitq;
  48 };
  49
  50 /**
  51  * userio_device_write - Write data from serio to a userio device in userspace
  52  * @id: The serio port for the userio device
  53  * @val: The data to write to the device
  54  */
  55 static int userio_device_write(struct serio *id, unsigned char val)
  56 {
  57         struct userio_device *userio = id->port_data;
  58         unsigned long flags;
  59
  60         spin_lock_irqsave(&userio->buf_lock, flags);
  61
  62         userio->buf[userio->head] = val;
  63         userio->head = (userio->head + 1) % USERIO_BUFSIZE;
  64
  65         if (userio->head == userio->tail)
  66                 dev_warn(userio_misc.this_device,
  67                          "Buffer overflowed, userio client isn't keeping up");
  68
  69         spin_unlock_irqrestore(&userio->buf_lock, flags);
  70
  71         wake_up_interruptible(&userio->waitq);
  72
  73         return 0;
  74 }
  75
  76 static int userio_char_open(struct inode *inode, struct file *file)
  77 {
  78         struct userio_device *userio;
  79
  80         userio = kzalloc(sizeof(struct userio_device), GFP_KERNEL);
  81         if (!userio)
  82                 return -ENOMEM;
  83
  84         mutex_init(&userio->mutex);
  85         spin_lock_init(&userio->buf_lock);
  86         init_waitqueue_head(&userio->waitq);
  87
  88         userio->serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
  89         if (!userio->serio) {
  90                 kfree(userio);
  91                 return -ENOMEM;
  92         }
  93
  94         userio->serio->write = userio_device_write;
  95         userio->serio->port_data = userio;
  96
  97         file->private_data = userio;
  98
  99         return 0;
 100 }
 101
 102 static int userio_char_release(struct inode *inode, struct file *file)
 103 {
 104         struct userio_device *userio = file->private_data;
 105
 106         if (userio->running) {
 107                 /*
 108                  * Don't free the serio port here, serio_unregister_port()
 109                  * does it for us.
 110                  */
 111                 serio_unregister_port(userio->serio);
 112         } else {
 113                 kfree(userio->serio);
 114         }
 115
 116         kfree(userio);
 117
 118         return 0;
 119 }
 120
 121 static ssize_t userio_char_read(struct file *file, char __user *user_buffer,
 122                                 size_t count, loff_t *ppos)
 123 {
 124         struct userio_device *userio = file->private_data;
 125         int error;
 126         size_t nonwrap_len, copylen;
 127         unsigned char buf[USERIO_BUFSIZE];
 128         unsigned long flags;
 129
 130         /*
 131          * By the time we get here, the data that was waiting might have
 132          * been taken by another thread. Grab the buffer lock and check if
 133          * there's still any data waiting, otherwise repeat this process
 134          * until we have data (unless the file descriptor is non-blocking
 135          * of course).
 136          */
 137         for (;;) {
 138                 spin_lock_irqsave(&userio->buf_lock, flags);
 139
 140                 nonwrap_len = CIRC_CNT_TO_END(userio->head,
 141                                               userio->tail,
 142                                               USERIO_BUFSIZE);
 143                 copylen = min(nonwrap_len, count);
 144                 if (copylen) {
 145                         memcpy(buf, &userio->buf[userio->tail], copylen);
 146                         userio->tail = (userio->tail + copylen) %
 147                                                         USERIO_BUFSIZE;
 148                 }
 149
 150                 spin_unlock_irqrestore(&userio->buf_lock, flags);
 151
 152                 if (nonwrap_len)
 153                         break;
 154
 155                 /* buffer was/is empty */
 156                 if (file->f_flags & O_NONBLOCK)
 157                         return -EAGAIN;
 158
 159                 /*
 160                  * count == 0 is special - no IO is done but we check
 161                  * for error conditions (see above).
 162                  */
 163                 if (count == 0)
 164                         return 0;
 165
 166                 error = wait_event_interruptible(userio->waitq,
 167                                                  userio->head != userio->tail);
 168                 if (error)
 169                         return error;
 170         }
 171
 172         if (copylen)
 173                 if (copy_to_user(user_buffer, buf, copylen))
 174                         return -EFAULT;
 175
 176         return copylen;
 177 }
 178
 179 static ssize_t userio_char_write(struct file *file, const char __user *buffer,
 180                                  size_t count, loff_t *ppos)
 181 {
 182         struct userio_device *userio = file->private_data;
 183         struct userio_cmd cmd;
 184         int error;
 185
 186         if (count != sizeof(cmd)) {
 187                 dev_warn(userio_misc.this_device, "Invalid payload size\n");
 188                 return -EINVAL;
 189         }
 190
 191         if (copy_from_user(&cmd, buffer, sizeof(cmd)))
 192                 return -EFAULT;
 193
 194         error = mutex_lock_interruptible(&userio->mutex);
 195         if (error)
 196                 return error;
 197
 198         switch (cmd.type) {
 199         case USERIO_CMD_REGISTER:
 200                 if (!userio->serio->id.type) {
 201                         dev_warn(userio_misc.this_device,
 202                                  "No port type given on /dev/userio\n");
 203
 204                         error = -EINVAL;
 205                         goto out;
 206                 }
 207
 208                 if (userio->running) {
 209                         dev_warn(userio_misc.this_device,
 210                                  "Begin command sent, but we're already running\n");
 211                         error = -EBUSY;
 212                         goto out;
 213                 }
 214
 215                 userio->running = true;
 216                 serio_register_port(userio->serio);
 217                 break;
 218
 219         case USERIO_CMD_SET_PORT_TYPE:
 220                 if (userio->running) {
 221                         dev_warn(userio_misc.this_device,
 222                                  "Can't change port type on an already running userio instance\n");
 223                         error = -EBUSY;
 224                         goto out;
 225                 }
 226
 227                 userio->serio->id.type = cmd.data;
 228                 break;
 229
 230         case USERIO_CMD_SEND_INTERRUPT:
 231                 if (!userio->running) {
 232                         dev_warn(userio_misc.this_device,
 233                                  "The device must be registered before sending interrupts\n");
 234                         error = -ENODEV;
 235                         goto out;
 236                 }
 237
 238                 serio_interrupt(userio->serio, cmd.data, 0);
 239                 break;
 240
 241         default:
 242                 error = -EOPNOTSUPP;
 243                 goto out;
 244         }
 245
 246 out:
 247         mutex_unlock(&userio->mutex);
 248         return error ?: count;
 249 }
 250
 251 static unsigned int userio_char_poll(struct file *file, poll_table *wait)
 252 {
 253         struct userio_device *userio = file->private_data;
 254
 255         poll_wait(file, &userio->waitq, wait);
 256
 257         if (userio->head != userio->tail)
 258                 return POLLIN | POLLRDNORM;
 259
 260         return 0;
 261 }
 262
 263 static const struct file_operations userio_fops = {
 264         .owner          = THIS_MODULE,
 265         .open           = userio_char_open,
 266         .release        = userio_char_release,
 267         .read           = userio_char_read,
 268         .write          = userio_char_write,
 269         .poll           = userio_char_poll,
 270         .llseek         = no_llseek,
 271 };
 272
 273 static struct miscdevice userio_misc = {
 274         .fops   = &userio_fops,
 275         .minor  = USERIO_MINOR,
 276         .name   = USERIO_NAME,
 277 };
 278 module_driver(userio_misc, misc_register, misc_deregister);
 279
 280 MODULE_ALIAS_MISCDEV(USERIO_MINOR);
 281 MODULE_ALIAS("devname:" USERIO_NAME);
 282
 283 MODULE_AUTHOR("Stephen Chandler Paul <thatslyude@gmail.com>");
 284 MODULE_DESCRIPTION("Virtual Serio Device Support");
 285 MODULE_LICENSE("GPL");