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
5 * Copyright (c) 2004 Dmitry Torokhov
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.
12 #include <linux/kref.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/poll.h>
16 #include <linux/module.h>
17 #include <linux/serio.h>
18 #include <linux/major.h>
19 #include <linux/device.h>
20 #include <linux/miscdevice.h>
21 #include <linux/wait.h>
22 #include <linux/mutex.h>
24 #define DRIVER_DESC "Raw serio driver"
26 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
27 MODULE_DESCRIPTION(DRIVER_DESC
);
28 MODULE_LICENSE("GPL");
30 #define SERIO_RAW_QUEUE_LEN 64
32 unsigned char queue
[SERIO_RAW_QUEUE_LEN
];
33 unsigned int tail
, head
;
38 struct miscdevice dev
;
39 wait_queue_head_t wait
;
40 struct list_head client_list
;
41 struct list_head node
;
45 struct serio_raw_client
{
46 struct fasync_struct
*fasync
;
47 struct serio_raw
*serio_raw
;
48 struct list_head node
;
51 static DEFINE_MUTEX(serio_raw_mutex
);
52 static LIST_HEAD(serio_raw_list
);
54 /*********************************************************************
55 * Interface with userspace (file operations) *
56 *********************************************************************/
58 static int serio_raw_fasync(int fd
, struct file
*file
, int on
)
60 struct serio_raw_client
*client
= file
->private_data
;
62 return fasync_helper(fd
, file
, on
, &client
->fasync
);
65 static struct serio_raw
*serio_raw_locate(int minor
)
67 struct serio_raw
*serio_raw
;
69 list_for_each_entry(serio_raw
, &serio_raw_list
, node
) {
70 if (serio_raw
->dev
.minor
== minor
)
77 static int serio_raw_open(struct inode
*inode
, struct file
*file
)
79 struct serio_raw
*serio_raw
;
80 struct serio_raw_client
*client
;
83 retval
= mutex_lock_interruptible(&serio_raw_mutex
);
87 serio_raw
= serio_raw_locate(iminor(inode
));
93 if (serio_raw
->dead
) {
98 client
= kzalloc(sizeof(struct serio_raw_client
), GFP_KERNEL
);
104 client
->serio_raw
= serio_raw
;
105 file
->private_data
= client
;
107 kref_get(&serio_raw
->kref
);
109 serio_pause_rx(serio_raw
->serio
);
110 list_add_tail(&client
->node
, &serio_raw
->client_list
);
111 serio_continue_rx(serio_raw
->serio
);
114 mutex_unlock(&serio_raw_mutex
);
118 static void serio_raw_free(struct kref
*kref
)
120 struct serio_raw
*serio_raw
=
121 container_of(kref
, struct serio_raw
, kref
);
123 put_device(&serio_raw
->serio
->dev
);
127 static int serio_raw_release(struct inode
*inode
, struct file
*file
)
129 struct serio_raw_client
*client
= file
->private_data
;
130 struct serio_raw
*serio_raw
= client
->serio_raw
;
132 serio_pause_rx(serio_raw
->serio
);
133 list_del(&client
->node
);
134 serio_continue_rx(serio_raw
->serio
);
138 kref_put(&serio_raw
->kref
, serio_raw_free
);
143 static bool serio_raw_fetch_byte(struct serio_raw
*serio_raw
, char *c
)
147 serio_pause_rx(serio_raw
->serio
);
149 empty
= serio_raw
->head
== serio_raw
->tail
;
151 *c
= serio_raw
->queue
[serio_raw
->tail
];
152 serio_raw
->tail
= (serio_raw
->tail
+ 1) % SERIO_RAW_QUEUE_LEN
;
155 serio_continue_rx(serio_raw
->serio
);
160 static ssize_t
serio_raw_read(struct file
*file
, char __user
*buffer
,
161 size_t count
, loff_t
*ppos
)
163 struct serio_raw_client
*client
= file
->private_data
;
164 struct serio_raw
*serio_raw
= client
->serio_raw
;
165 char uninitialized_var(c
);
173 if (serio_raw
->head
== serio_raw
->tail
&&
174 (file
->f_flags
& O_NONBLOCK
))
180 while (read
< count
&& serio_raw_fetch_byte(serio_raw
, &c
)) {
181 if (put_user(c
, buffer
++))
189 if (!(file
->f_flags
& O_NONBLOCK
)) {
190 error
= wait_event_interruptible(serio_raw
->wait
,
191 serio_raw
->head
!= serio_raw
->tail
||
201 static ssize_t
serio_raw_write(struct file
*file
, const char __user
*buffer
,
202 size_t count
, loff_t
*ppos
)
204 struct serio_raw_client
*client
= file
->private_data
;
205 struct serio_raw
*serio_raw
= client
->serio_raw
;
209 retval
= mutex_lock_interruptible(&serio_raw_mutex
);
213 if (serio_raw
->dead
) {
222 if (get_user(c
, buffer
++)) {
227 if (serio_write(serio_raw
->serio
, c
)) {
228 /* Either signal error or partial write */
238 mutex_unlock(&serio_raw_mutex
);
242 static unsigned int serio_raw_poll(struct file
*file
, poll_table
*wait
)
244 struct serio_raw_client
*client
= file
->private_data
;
245 struct serio_raw
*serio_raw
= client
->serio_raw
;
248 poll_wait(file
, &serio_raw
->wait
, wait
);
250 mask
= serio_raw
->dead
? POLLHUP
| POLLERR
: POLLOUT
| POLLWRNORM
;
251 if (serio_raw
->head
!= serio_raw
->tail
)
252 mask
|= POLLIN
| POLLRDNORM
;
257 static const struct file_operations serio_raw_fops
= {
258 .owner
= THIS_MODULE
,
259 .open
= serio_raw_open
,
260 .release
= serio_raw_release
,
261 .read
= serio_raw_read
,
262 .write
= serio_raw_write
,
263 .poll
= serio_raw_poll
,
264 .fasync
= serio_raw_fasync
,
265 .llseek
= noop_llseek
,
269 /*********************************************************************
270 * Interface with serio port *
271 *********************************************************************/
273 static irqreturn_t
serio_raw_interrupt(struct serio
*serio
, unsigned char data
,
276 struct serio_raw
*serio_raw
= serio_get_drvdata(serio
);
277 struct serio_raw_client
*client
;
278 unsigned int head
= serio_raw
->head
;
280 /* we are holding serio->lock here so we are protected */
281 serio_raw
->queue
[head
] = data
;
282 head
= (head
+ 1) % SERIO_RAW_QUEUE_LEN
;
283 if (likely(head
!= serio_raw
->tail
)) {
284 serio_raw
->head
= head
;
285 list_for_each_entry(client
, &serio_raw
->client_list
, node
)
286 kill_fasync(&client
->fasync
, SIGIO
, POLL_IN
);
287 wake_up_interruptible(&serio_raw
->wait
);
293 static int serio_raw_connect(struct serio
*serio
, struct serio_driver
*drv
)
295 static atomic_t serio_raw_no
= ATOMIC_INIT(0);
296 struct serio_raw
*serio_raw
;
299 serio_raw
= kzalloc(sizeof(struct serio_raw
), GFP_KERNEL
);
301 dev_dbg(&serio
->dev
, "can't allocate memory for a device\n");
305 snprintf(serio_raw
->name
, sizeof(serio_raw
->name
),
306 "serio_raw%ld", (long)atomic_inc_return(&serio_raw_no
) - 1);
307 kref_init(&serio_raw
->kref
);
308 INIT_LIST_HEAD(&serio_raw
->client_list
);
309 init_waitqueue_head(&serio_raw
->wait
);
311 serio_raw
->serio
= serio
;
312 get_device(&serio
->dev
);
314 serio_set_drvdata(serio
, serio_raw
);
316 err
= serio_open(serio
, drv
);
320 err
= mutex_lock_killable(&serio_raw_mutex
);
324 list_add_tail(&serio_raw
->node
, &serio_raw_list
);
325 mutex_unlock(&serio_raw_mutex
);
327 serio_raw
->dev
.minor
= PSMOUSE_MINOR
;
328 serio_raw
->dev
.name
= serio_raw
->name
;
329 serio_raw
->dev
.parent
= &serio
->dev
;
330 serio_raw
->dev
.fops
= &serio_raw_fops
;
332 err
= misc_register(&serio_raw
->dev
);
334 serio_raw
->dev
.minor
= MISC_DYNAMIC_MINOR
;
335 err
= misc_register(&serio_raw
->dev
);
340 "failed to register raw access device for %s\n",
345 dev_info(&serio
->dev
, "raw access enabled on %s (%s, minor %d)\n",
346 serio
->phys
, serio_raw
->name
, serio_raw
->dev
.minor
);
350 list_del_init(&serio_raw
->node
);
354 serio_set_drvdata(serio
, NULL
);
355 kref_put(&serio_raw
->kref
, serio_raw_free
);
359 static int serio_raw_reconnect(struct serio
*serio
)
361 struct serio_raw
*serio_raw
= serio_get_drvdata(serio
);
362 struct serio_driver
*drv
= serio
->drv
;
364 if (!drv
|| !serio_raw
) {
366 "reconnect request, but serio is disconnected, ignoring...\n");
371 * Nothing needs to be done here, we just need this method to
372 * keep the same device.
378 * Wake up users waiting for IO so they can disconnect from
381 static void serio_raw_hangup(struct serio_raw
*serio_raw
)
383 struct serio_raw_client
*client
;
385 serio_pause_rx(serio_raw
->serio
);
386 list_for_each_entry(client
, &serio_raw
->client_list
, node
)
387 kill_fasync(&client
->fasync
, SIGIO
, POLL_HUP
);
388 serio_continue_rx(serio_raw
->serio
);
390 wake_up_interruptible(&serio_raw
->wait
);
394 static void serio_raw_disconnect(struct serio
*serio
)
396 struct serio_raw
*serio_raw
= serio_get_drvdata(serio
);
398 misc_deregister(&serio_raw
->dev
);
400 mutex_lock(&serio_raw_mutex
);
401 serio_raw
->dead
= true;
402 list_del_init(&serio_raw
->node
);
403 mutex_unlock(&serio_raw_mutex
);
405 serio_raw_hangup(serio_raw
);
408 kref_put(&serio_raw
->kref
, serio_raw_free
);
410 serio_set_drvdata(serio
, NULL
);
413 static struct serio_device_id serio_raw_serio_ids
[] = {
421 .type
= SERIO_8042_XL
,
429 MODULE_DEVICE_TABLE(serio
, serio_raw_serio_ids
);
431 static struct serio_driver serio_raw_drv
= {
435 .description
= DRIVER_DESC
,
436 .id_table
= serio_raw_serio_ids
,
437 .interrupt
= serio_raw_interrupt
,
438 .connect
= serio_raw_connect
,
439 .reconnect
= serio_raw_reconnect
,
440 .disconnect
= serio_raw_disconnect
,
444 module_serio_driver(serio_raw_drv
);