blob: 7c8d0399ae820ae6996f888f07910126bc3607f6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Raw serio device providing access to a raw byte stream from underlying
3 * serio port. Closely emulates behavior of pre-2.6 /dev/psaux device
4 *
5 * Copyright (c) 2004 Dmitry Torokhov
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 */
11
12#include <linux/slab.h>
13#include <linux/poll.h>
14#include <linux/module.h>
15#include <linux/serio.h>
16#include <linux/init.h>
17#include <linux/major.h>
18#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/miscdevice.h>
20#include <linux/wait.h>
Arjan van de Venc4e32e92006-02-19 00:21:55 -050021#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23#define DRIVER_DESC "Raw serio driver"
24
25MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
26MODULE_DESCRIPTION(DRIVER_DESC);
27MODULE_LICENSE("GPL");
28
29#define SERIO_RAW_QUEUE_LEN 64
30struct serio_raw {
31 unsigned char queue[SERIO_RAW_QUEUE_LEN];
32 unsigned int tail, head;
33
34 char name[16];
35 unsigned int refcnt;
36 struct serio *serio;
37 struct miscdevice dev;
38 wait_queue_head_t wait;
39 struct list_head list;
40 struct list_head node;
41};
42
43struct serio_raw_list {
44 struct fasync_struct *fasync;
45 struct serio_raw *serio_raw;
46 struct list_head node;
47};
48
Arjan van de Venc4e32e92006-02-19 00:21:55 -050049static DEFINE_MUTEX(serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050static LIST_HEAD(serio_raw_list);
51static unsigned int serio_raw_no;
52
53/*********************************************************************
54 * Interface with userspace (file operations) *
55 *********************************************************************/
56
57static int serio_raw_fasync(int fd, struct file *file, int on)
58{
59 struct serio_raw_list *list = file->private_data;
60 int retval;
61
62 retval = fasync_helper(fd, file, on, &list->fasync);
63 return retval < 0 ? retval : 0;
64}
65
66static struct serio_raw *serio_raw_locate(int minor)
67{
68 struct serio_raw *serio_raw;
69
70 list_for_each_entry(serio_raw, &serio_raw_list, node) {
71 if (serio_raw->dev.minor == minor)
72 return serio_raw;
73 }
74
75 return NULL;
76}
77
78static int serio_raw_open(struct inode *inode, struct file *file)
79{
80 struct serio_raw *serio_raw;
81 struct serio_raw_list *list;
82 int retval = 0;
83
Arjan van de Venc4e32e92006-02-19 00:21:55 -050084 retval = mutex_lock_interruptible(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 if (retval)
86 return retval;
87
88 if (!(serio_raw = serio_raw_locate(iminor(inode)))) {
89 retval = -ENODEV;
90 goto out;
91 }
92
93 if (!serio_raw->serio) {
94 retval = -ENODEV;
95 goto out;
96 }
97
Eric Sesterhennb39787a2006-03-14 00:09:16 -050098 if (!(list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 retval = -ENOMEM;
100 goto out;
101 }
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 list->serio_raw = serio_raw;
104 file->private_data = list;
105
106 serio_raw->refcnt++;
107 list_add_tail(&list->node, &serio_raw->list);
108
109out:
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500110 mutex_unlock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 return retval;
112}
113
114static int serio_raw_cleanup(struct serio_raw *serio_raw)
115{
116 if (--serio_raw->refcnt == 0) {
117 misc_deregister(&serio_raw->dev);
118 list_del_init(&serio_raw->node);
119 kfree(serio_raw);
120
121 return 1;
122 }
123
124 return 0;
125}
126
127static int serio_raw_release(struct inode *inode, struct file *file)
128{
129 struct serio_raw_list *list = file->private_data;
130 struct serio_raw *serio_raw = list->serio_raw;
131
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500132 mutex_lock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134 serio_raw_fasync(-1, file, 0);
135 serio_raw_cleanup(serio_raw);
136
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500137 mutex_unlock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 return 0;
139}
140
141static int serio_raw_fetch_byte(struct serio_raw *serio_raw, char *c)
142{
143 unsigned long flags;
144 int empty;
145
146 spin_lock_irqsave(&serio_raw->serio->lock, flags);
147
148 empty = serio_raw->head == serio_raw->tail;
149 if (!empty) {
150 *c = serio_raw->queue[serio_raw->tail];
151 serio_raw->tail = (serio_raw->tail + 1) % SERIO_RAW_QUEUE_LEN;
152 }
153
154 spin_unlock_irqrestore(&serio_raw->serio->lock, flags);
155
156 return !empty;
157}
158
159static ssize_t serio_raw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
160{
161 struct serio_raw_list *list = file->private_data;
162 struct serio_raw *serio_raw = list->serio_raw;
163 char c;
164 ssize_t retval = 0;
165
166 if (!serio_raw->serio)
167 return -ENODEV;
168
169 if (serio_raw->head == serio_raw->tail && (file->f_flags & O_NONBLOCK))
170 return -EAGAIN;
171
172 retval = wait_event_interruptible(list->serio_raw->wait,
173 serio_raw->head != serio_raw->tail || !serio_raw->serio);
174 if (retval)
175 return retval;
176
177 if (!serio_raw->serio)
178 return -ENODEV;
179
180 while (retval < count && serio_raw_fetch_byte(serio_raw, &c)) {
181 if (put_user(c, buffer++))
182 return -EFAULT;
183 retval++;
184 }
185
186 return retval;
187}
188
189static ssize_t serio_raw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
190{
191 struct serio_raw_list *list = file->private_data;
192 ssize_t written = 0;
193 int retval;
194 unsigned char c;
195
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500196 retval = mutex_lock_interruptible(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (retval)
198 return retval;
199
200 if (!list->serio_raw->serio) {
201 retval = -ENODEV;
202 goto out;
203 }
204
205 if (count > 32)
206 count = 32;
207
208 while (count--) {
209 if (get_user(c, buffer++)) {
210 retval = -EFAULT;
211 goto out;
212 }
213 if (serio_write(list->serio_raw->serio, c)) {
214 retval = -EIO;
215 goto out;
216 }
217 written++;
218 };
219
220out:
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500221 mutex_unlock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return written;
223}
224
225static unsigned int serio_raw_poll(struct file *file, poll_table *wait)
226{
227 struct serio_raw_list *list = file->private_data;
228
229 poll_wait(file, &list->serio_raw->wait, wait);
230
231 if (list->serio_raw->head != list->serio_raw->tail)
232 return POLLIN | POLLRDNORM;
233
234 return 0;
235}
236
237static struct file_operations serio_raw_fops = {
238 .owner = THIS_MODULE,
239 .open = serio_raw_open,
240 .release = serio_raw_release,
241 .read = serio_raw_read,
242 .write = serio_raw_write,
243 .poll = serio_raw_poll,
244 .fasync = serio_raw_fasync,
245};
246
247
248/*********************************************************************
249 * Interface with serio port *
250 *********************************************************************/
251
252static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data,
David Howells7d12e782006-10-05 14:55:46 +0100253 unsigned int dfl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 struct serio_raw *serio_raw = serio_get_drvdata(serio);
256 struct serio_raw_list *list;
257 unsigned int head = serio_raw->head;
258
259 /* we are holding serio->lock here so we are prootected */
260 serio_raw->queue[head] = data;
261 head = (head + 1) % SERIO_RAW_QUEUE_LEN;
262 if (likely(head != serio_raw->tail)) {
263 serio_raw->head = head;
264 list_for_each_entry(list, &serio_raw->list, node)
265 kill_fasync(&list->fasync, SIGIO, POLL_IN);
266 wake_up_interruptible(&serio_raw->wait);
267 }
268
269 return IRQ_HANDLED;
270}
271
272static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
273{
274 struct serio_raw *serio_raw;
275 int err;
276
Eric Sesterhennb39787a2006-03-14 00:09:16 -0500277 if (!(serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 printk(KERN_ERR "serio_raw.c: can't allocate memory for a device\n");
279 return -ENOMEM;
280 }
281
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500282 mutex_lock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++);
285 serio_raw->refcnt = 1;
286 serio_raw->serio = serio;
287 INIT_LIST_HEAD(&serio_raw->list);
288 init_waitqueue_head(&serio_raw->wait);
289
290 serio_set_drvdata(serio, serio_raw);
291
292 err = serio_open(serio, drv);
293 if (err)
294 goto out_free;
295
296 list_add_tail(&serio_raw->node, &serio_raw_list);
297
298 serio_raw->dev.minor = PSMOUSE_MINOR;
299 serio_raw->dev.name = serio_raw->name;
Greg Kroah-Hartman94fbcde2006-07-27 16:16:04 -0700300 serio_raw->dev.parent = &serio->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 serio_raw->dev.fops = &serio_raw_fops;
302
303 err = misc_register(&serio_raw->dev);
304 if (err) {
305 serio_raw->dev.minor = MISC_DYNAMIC_MINOR;
306 err = misc_register(&serio_raw->dev);
307 }
308
309 if (err) {
310 printk(KERN_INFO "serio_raw: failed to register raw access device for %s\n",
311 serio->phys);
312 goto out_close;
313 }
314
315 printk(KERN_INFO "serio_raw: raw access enabled on %s (%s, minor %d)\n",
316 serio->phys, serio_raw->name, serio_raw->dev.minor);
317 goto out;
318
319out_close:
320 serio_close(serio);
321 list_del_init(&serio_raw->node);
322out_free:
323 serio_set_drvdata(serio, NULL);
324 kfree(serio_raw);
325out:
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500326 mutex_unlock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return err;
328}
329
330static int serio_raw_reconnect(struct serio *serio)
331{
332 struct serio_raw *serio_raw = serio_get_drvdata(serio);
333 struct serio_driver *drv = serio->drv;
334
335 if (!drv || !serio_raw) {
336 printk(KERN_DEBUG "serio_raw: reconnect request, but serio is disconnected, ignoring...\n");
337 return -1;
338 }
339
340 /*
341 * Nothing needs to be done here, we just need this method to
342 * keep the same device.
343 */
344 return 0;
345}
346
347static void serio_raw_disconnect(struct serio *serio)
348{
349 struct serio_raw *serio_raw;
350
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500351 mutex_lock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353 serio_raw = serio_get_drvdata(serio);
354
355 serio_close(serio);
356 serio_set_drvdata(serio, NULL);
357
358 serio_raw->serio = NULL;
359 if (!serio_raw_cleanup(serio_raw))
360 wake_up_interruptible(&serio_raw->wait);
361
Arjan van de Venc4e32e92006-02-19 00:21:55 -0500362 mutex_unlock(&serio_raw_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363}
364
365static struct serio_device_id serio_raw_serio_ids[] = {
366 {
367 .type = SERIO_8042,
368 .proto = SERIO_ANY,
369 .id = SERIO_ANY,
370 .extra = SERIO_ANY,
371 },
372 { 0 }
373};
374
375MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids);
376
377static struct serio_driver serio_raw_drv = {
378 .driver = {
379 .name = "serio_raw",
380 },
381 .description = DRIVER_DESC,
382 .id_table = serio_raw_serio_ids,
383 .interrupt = serio_raw_interrupt,
384 .connect = serio_raw_connect,
385 .reconnect = serio_raw_reconnect,
386 .disconnect = serio_raw_disconnect,
387 .manual_bind = 1,
388};
389
390static int __init serio_raw_init(void)
391{
392 serio_register_driver(&serio_raw_drv);
393 return 0;
394}
395
396static void __exit serio_raw_exit(void)
397{
398 serio_unregister_driver(&serio_raw_drv);
399}
400
401module_init(serio_raw_init);
402module_exit(serio_raw_exit);