xref: /openbmc/linux/drivers/input/serio/userio.c (revision f5c27da4) 
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 __poll_t 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 EPOLLIN | EPOLLRDNORM;
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");
286