GNU Linux-libre 4.14.266-gnu1
[releases.git] / 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");