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 */
userio_device_write(struct serio * id,unsigned char val)55 static int userio_device_write(struct serio *id, unsigned char val)
56 {
57 struct userio_device *userio = id->port_data;
58
59 scoped_guard(spinlock_irqsave, &userio->buf_lock) {
60 userio->buf[userio->head] = val;
61 userio->head = (userio->head + 1) % USERIO_BUFSIZE;
62
63 if (userio->head == userio->tail)
64 dev_warn(userio_misc.this_device,
65 "Buffer overflowed, userio client isn't keeping up");
66 }
67
68 wake_up_interruptible(&userio->waitq);
69
70 return 0;
71 }
72
userio_char_open(struct inode * inode,struct file * file)73 static int userio_char_open(struct inode *inode, struct file *file)
74 {
75 struct userio_device *userio __free(kfree) =
76 kzalloc(sizeof(*userio), GFP_KERNEL);
77 if (!userio)
78 return -ENOMEM;
79
80 mutex_init(&userio->mutex);
81 spin_lock_init(&userio->buf_lock);
82 init_waitqueue_head(&userio->waitq);
83
84 userio->serio = kzalloc(sizeof(*userio->serio), GFP_KERNEL);
85 if (!userio->serio)
86 return -ENOMEM;
87
88 userio->serio->write = userio_device_write;
89 userio->serio->port_data = userio;
90
91 file->private_data = no_free_ptr(userio);
92
93 return 0;
94 }
95
userio_char_release(struct inode * inode,struct file * file)96 static int userio_char_release(struct inode *inode, struct file *file)
97 {
98 struct userio_device *userio = file->private_data;
99
100 if (userio->running) {
101 /*
102 * Don't free the serio port here, serio_unregister_port()
103 * does it for us.
104 */
105 serio_unregister_port(userio->serio);
106 } else {
107 kfree(userio->serio);
108 }
109
110 kfree(userio);
111
112 return 0;
113 }
114
userio_fetch_data(struct userio_device * userio,u8 * buf,size_t count,size_t * copylen)115 static size_t userio_fetch_data(struct userio_device *userio, u8 *buf,
116 size_t count, size_t *copylen)
117 {
118 size_t available, len;
119
120 guard(spinlock_irqsave)(&userio->buf_lock);
121
122 available = CIRC_CNT_TO_END(userio->head, userio->tail,
123 USERIO_BUFSIZE);
124 len = min(available, count);
125 if (len) {
126 memcpy(buf, &userio->buf[userio->tail], len);
127 userio->tail = (userio->tail + len) % USERIO_BUFSIZE;
128 }
129
130 *copylen = len;
131 return available;
132 }
133
userio_char_read(struct file * file,char __user * user_buffer,size_t count,loff_t * ppos)134 static ssize_t userio_char_read(struct file *file, char __user *user_buffer,
135 size_t count, loff_t *ppos)
136 {
137 struct userio_device *userio = file->private_data;
138 int error;
139 size_t available, copylen;
140 u8 buf[USERIO_BUFSIZE];
141
142 /*
143 * By the time we get here, the data that was waiting might have
144 * been taken by another thread. Grab the buffer lock and check if
145 * there's still any data waiting, otherwise repeat this process
146 * until we have data (unless the file descriptor is non-blocking
147 * of course).
148 */
149 for (;;) {
150 available = userio_fetch_data(userio, buf, count, ©len);
151 if (available)
152 break;
153
154 /* buffer was/is empty */
155 if (file->f_flags & O_NONBLOCK)
156 return -EAGAIN;
157
158 /*
159 * count == 0 is special - no IO is done but we check
160 * for error conditions (see above).
161 */
162 if (count == 0)
163 return 0;
164
165 error = wait_event_interruptible(userio->waitq,
166 userio->head != userio->tail);
167 if (error)
168 return error;
169 }
170
171 if (copylen)
172 if (copy_to_user(user_buffer, buf, copylen))
173 return -EFAULT;
174
175 return copylen;
176 }
177
userio_execute_cmd(struct userio_device * userio,const struct userio_cmd * cmd)178 static int userio_execute_cmd(struct userio_device *userio,
179 const struct userio_cmd *cmd)
180 {
181 switch (cmd->type) {
182 case USERIO_CMD_REGISTER:
183 if (!userio->serio->id.type) {
184 dev_warn(userio_misc.this_device,
185 "No port type given on /dev/userio\n");
186 return -EINVAL;
187 }
188
189 if (userio->running) {
190 dev_warn(userio_misc.this_device,
191 "Begin command sent, but we're already running\n");
192 return -EBUSY;
193 }
194
195 userio->running = true;
196 serio_register_port(userio->serio);
197 break;
198
199 case USERIO_CMD_SET_PORT_TYPE:
200 if (userio->running) {
201 dev_warn(userio_misc.this_device,
202 "Can't change port type on an already running userio instance\n");
203 return -EBUSY;
204 }
205
206 userio->serio->id.type = cmd->data;
207 break;
208
209 case USERIO_CMD_SEND_INTERRUPT:
210 if (!userio->running) {
211 dev_warn(userio_misc.this_device,
212 "The device must be registered before sending interrupts\n");
213 return -ENODEV;
214 }
215
216 serio_interrupt(userio->serio, cmd->data, 0);
217 break;
218
219 default:
220 return -EOPNOTSUPP;
221 }
222
223 return 0;
224 }
225
userio_char_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)226 static ssize_t userio_char_write(struct file *file, const char __user *buffer,
227 size_t count, loff_t *ppos)
228 {
229 struct userio_device *userio = file->private_data;
230 struct userio_cmd cmd;
231 int error;
232
233 if (count != sizeof(cmd)) {
234 dev_warn(userio_misc.this_device, "Invalid payload size\n");
235 return -EINVAL;
236 }
237
238 if (copy_from_user(&cmd, buffer, sizeof(cmd)))
239 return -EFAULT;
240
241 scoped_cond_guard(mutex_intr, return -EINTR, &userio->mutex) {
242 error = userio_execute_cmd(userio, &cmd);
243 if (error)
244 return error;
245 }
246
247 return count;
248 }
249
userio_char_poll(struct file * file,poll_table * wait)250 static __poll_t userio_char_poll(struct file *file, poll_table *wait)
251 {
252 struct userio_device *userio = file->private_data;
253
254 poll_wait(file, &userio->waitq, wait);
255
256 if (userio->head != userio->tail)
257 return EPOLLIN | EPOLLRDNORM;
258
259 return 0;
260 }
261
262 static const struct file_operations userio_fops = {
263 .owner = THIS_MODULE,
264 .open = userio_char_open,
265 .release = userio_char_release,
266 .read = userio_char_read,
267 .write = userio_char_write,
268 .poll = userio_char_poll,
269 };
270
271 static struct miscdevice userio_misc = {
272 .fops = &userio_fops,
273 .minor = USERIO_MINOR,
274 .name = USERIO_NAME,
275 };
276 module_driver(userio_misc, misc_register, misc_deregister);
277
278 MODULE_ALIAS_MISCDEV(USERIO_MINOR);
279 MODULE_ALIAS("devname:" USERIO_NAME);
280
281 MODULE_AUTHOR("Stephen Chandler Paul <thatslyude@gmail.com>");
282 MODULE_DESCRIPTION("Virtual Serio Device Support");
283 MODULE_LICENSE("GPL");
284