Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/input/serio/serio_raw.c

  1 /*
  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/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>
 23 
 24 #define DRIVER_DESC     "Raw serio driver"
 25 
 26 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
 27 MODULE_DESCRIPTION(DRIVER_DESC);
 28 MODULE_LICENSE("GPL");
 29 
 30 #define SERIO_RAW_QUEUE_LEN     64
 31 struct serio_raw {
 32         unsigned char queue[SERIO_RAW_QUEUE_LEN];
 33         unsigned int tail, head;
 34 
 35         char name[16];
 36         struct kref kref;
 37         struct serio *serio;
 38         struct miscdevice dev;
 39         wait_queue_head_t wait;
 40         struct list_head client_list;
 41         struct list_head node;
 42         bool dead;
 43 };
 44 
 45 struct serio_raw_client {
 46         struct fasync_struct *fasync;
 47         struct serio_raw *serio_raw;
 48         struct list_head node;
 49 };
 50 
 51 static DEFINE_MUTEX(serio_raw_mutex);
 52 static LIST_HEAD(serio_raw_list);
 53 
 54 /*********************************************************************
 55  *             Interface with userspace (file operations)            *
 56  *********************************************************************/
 57 
 58 static int serio_raw_fasync(int fd, struct file *file, int on)
 59 {
 60         struct serio_raw_client *client = file->private_data;
 61 
 62         return fasync_helper(fd, file, on, &client->fasync);
 63 }
 64 
 65 static struct serio_raw *serio_raw_locate(int minor)
 66 {
 67         struct serio_raw *serio_raw;
 68 
 69         list_for_each_entry(serio_raw, &serio_raw_list, node) {
 70                 if (serio_raw->dev.minor == minor)
 71                         return serio_raw;
 72         }
 73 
 74         return NULL;
 75 }
 76 
 77 static int serio_raw_open(struct inode *inode, struct file *file)
 78 {
 79         struct serio_raw *serio_raw;
 80         struct serio_raw_client *client;
 81         int retval;
 82 
 83         retval = mutex_lock_interruptible(&serio_raw_mutex);
 84         if (retval)
 85                 return retval;
 86 
 87         serio_raw = serio_raw_locate(iminor(inode));
 88         if (!serio_raw) {
 89                 retval = -ENODEV;
 90                 goto out;
 91         }
 92 
 93         if (serio_raw->dead) {
 94                 retval = -ENODEV;
 95                 goto out;
 96         }
 97 
 98         client = kzalloc(sizeof(struct serio_raw_client), GFP_KERNEL);
 99         if (!client) {
100                 retval = -ENOMEM;
101                 goto out;
102         }
103 
104         client->serio_raw = serio_raw;
105         file->private_data = client;
106 
107         kref_get(&serio_raw->kref);
108 
109         serio_pause_rx(serio_raw->serio);
110         list_add_tail(&client->node, &serio_raw->client_list);
111         serio_continue_rx(serio_raw->serio);
112 
113 out:
114         mutex_unlock(&serio_raw_mutex);
115         return retval;
116 }
117 
118 static void serio_raw_free(struct kref *kref)
119 {
120         struct serio_raw *serio_raw =
121                         container_of(kref, struct serio_raw, kref);
122 
123         put_device(&serio_raw->serio->dev);
124         kfree(serio_raw);
125 }
126 
127 static int serio_raw_release(struct inode *inode, struct file *file)
128 {
129         struct serio_raw_client *client = file->private_data;
130         struct serio_raw *serio_raw = client->serio_raw;
131 
132         serio_pause_rx(serio_raw->serio);
133         list_del(&client->node);
134         serio_continue_rx(serio_raw->serio);
135 
136         kfree(client);
137 
138         kref_put(&serio_raw->kref, serio_raw_free);
139 
140         return 0;
141 }
142 
143 static bool serio_raw_fetch_byte(struct serio_raw *serio_raw, char *c)
144 {
145         bool empty;
146 
147         serio_pause_rx(serio_raw->serio);
148 
149         empty = serio_raw->head == serio_raw->tail;
150         if (!empty) {
151                 *c = serio_raw->queue[serio_raw->tail];
152                 serio_raw->tail = (serio_raw->tail + 1) % SERIO_RAW_QUEUE_LEN;
153         }
154 
155         serio_continue_rx(serio_raw->serio);
156 
157         return !empty;
158 }
159 
160 static ssize_t serio_raw_read(struct file *file, char __user *buffer,
161                               size_t count, loff_t *ppos)
162 {
163         struct serio_raw_client *client = file->private_data;
164         struct serio_raw *serio_raw = client->serio_raw;
165         char uninitialized_var(c);
166         ssize_t read = 0;
167         int error;
168 
169         for (;;) {
170                 if (serio_raw->dead)
171                         return -ENODEV;
172 
173                 if (serio_raw->head == serio_raw->tail &&
174                     (file->f_flags & O_NONBLOCK))
175                         return -EAGAIN;
176 
177                 if (count == 0)
178                         break;
179 
180                 while (read < count && serio_raw_fetch_byte(serio_raw, &c)) {
181                         if (put_user(c, buffer++))
182                                 return -EFAULT;
183                         read++;
184                 }
185 
186                 if (read)
187                         break;
188 
189                 if (!(file->f_flags & O_NONBLOCK)) {
190                         error = wait_event_interruptible(serio_raw->wait,
191                                         serio_raw->head != serio_raw->tail ||
192                                         serio_raw->dead);
193                         if (error)
194                                 return error;
195                 }
196         }
197 
198         return read;
199 }
200 
201 static ssize_t serio_raw_write(struct file *file, const char __user *buffer,
202                                size_t count, loff_t *ppos)
203 {
204         struct serio_raw_client *client = file->private_data;
205         struct serio_raw *serio_raw = client->serio_raw;
206         int retval = 0;
207         unsigned char c;
208 
209         retval = mutex_lock_interruptible(&serio_raw_mutex);
210         if (retval)
211                 return retval;
212 
213         if (serio_raw->dead) {
214                 retval = -ENODEV;
215                 goto out;
216         }
217 
218         if (count > 32)
219                 count = 32;
220 
221         while (count--) {
222                 if (get_user(c, buffer++)) {
223                         retval = -EFAULT;
224                         goto out;
225                 }
226 
227                 if (serio_write(serio_raw->serio, c)) {
228                         /* Either signal error or partial write */
229                         if (retval == 0)
230                                 retval = -EIO;
231                         goto out;
232                 }
233 
234                 retval++;
235         }
236 
237 out:
238         mutex_unlock(&serio_raw_mutex);
239         return retval;
240 }
241 
242 static unsigned int serio_raw_poll(struct file *file, poll_table *wait)
243 {
244         struct serio_raw_client *client = file->private_data;
245         struct serio_raw *serio_raw = client->serio_raw;
246         unsigned int mask;
247 
248         poll_wait(file, &serio_raw->wait, wait);
249 
250         mask = serio_raw->dead ? POLLHUP | POLLERR : POLLOUT | POLLWRNORM;
251         if (serio_raw->head != serio_raw->tail)
252                 mask |= POLLIN | POLLRDNORM;
253 
254         return mask;
255 }
256 
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,
266 };
267 
268 
269 /*********************************************************************
270  *                   Interface with serio port                       *
271  *********************************************************************/
272 
273 static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data,
274                                         unsigned int dfl)
275 {
276         struct serio_raw *serio_raw = serio_get_drvdata(serio);
277         struct serio_raw_client *client;
278         unsigned int head = serio_raw->head;
279 
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);
288         }
289 
290         return IRQ_HANDLED;
291 }
292 
293 static int serio_raw_connect(struct serio *serio, struct serio_driver *drv)
294 {
295         static atomic_t serio_raw_no = ATOMIC_INIT(0);
296         struct serio_raw *serio_raw;
297         int err;
298 
299         serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL);
300         if (!serio_raw) {
301                 dev_dbg(&serio->dev, "can't allocate memory for a device\n");
302                 return -ENOMEM;
303         }
304 
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);
310 
311         serio_raw->serio = serio;
312         get_device(&serio->dev);
313 
314         serio_set_drvdata(serio, serio_raw);
315 
316         err = serio_open(serio, drv);
317         if (err)
318                 goto err_free;
319 
320         err = mutex_lock_killable(&serio_raw_mutex);
321         if (err)
322                 goto err_close;
323 
324         list_add_tail(&serio_raw->node, &serio_raw_list);
325         mutex_unlock(&serio_raw_mutex);
326 
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;
331 
332         err = misc_register(&serio_raw->dev);
333         if (err) {
334                 serio_raw->dev.minor = MISC_DYNAMIC_MINOR;
335                 err = misc_register(&serio_raw->dev);
336         }
337 
338         if (err) {
339                 dev_err(&serio->dev,
340                         "failed to register raw access device for %s\n",
341                         serio->phys);
342                 goto err_unlink;
343         }
344 
345         dev_info(&serio->dev, "raw access enabled on %s (%s, minor %d)\n",
346                  serio->phys, serio_raw->name, serio_raw->dev.minor);
347         return 0;
348 
349 err_unlink:
350         list_del_init(&serio_raw->node);
351 err_close:
352         serio_close(serio);
353 err_free:
354         serio_set_drvdata(serio, NULL);
355         kref_put(&serio_raw->kref, serio_raw_free);
356         return err;
357 }
358 
359 static int serio_raw_reconnect(struct serio *serio)
360 {
361         struct serio_raw *serio_raw = serio_get_drvdata(serio);
362         struct serio_driver *drv = serio->drv;
363 
364         if (!drv || !serio_raw) {
365                 dev_dbg(&serio->dev,
366                         "reconnect request, but serio is disconnected, ignoring...\n");
367                 return -1;
368         }
369 
370         /*
371          * Nothing needs to be done here, we just need this method to
372          * keep the same device.
373          */
374         return 0;
375 }
376 
377 /*
378  * Wake up users waiting for IO so they can disconnect from
379  * dead device.
380  */
381 static void serio_raw_hangup(struct serio_raw *serio_raw)
382 {
383         struct serio_raw_client *client;
384 
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);
389 
390         wake_up_interruptible(&serio_raw->wait);
391 }
392 
393 
394 static void serio_raw_disconnect(struct serio *serio)
395 {
396         struct serio_raw *serio_raw = serio_get_drvdata(serio);
397 
398         misc_deregister(&serio_raw->dev);
399 
400         mutex_lock(&serio_raw_mutex);
401         serio_raw->dead = true;
402         list_del_init(&serio_raw->node);
403         mutex_unlock(&serio_raw_mutex);
404 
405         serio_raw_hangup(serio_raw);
406 
407         serio_close(serio);
408         kref_put(&serio_raw->kref, serio_raw_free);
409 
410         serio_set_drvdata(serio, NULL);
411 }
412 
413 static struct serio_device_id serio_raw_serio_ids[] = {
414         {
415                 .type   = SERIO_8042,
416                 .proto  = SERIO_ANY,
417                 .id     = SERIO_ANY,
418                 .extra  = SERIO_ANY,
419         },
420         {
421                 .type   = SERIO_8042_XL,
422                 .proto  = SERIO_ANY,
423                 .id     = SERIO_ANY,
424                 .extra  = SERIO_ANY,
425         },
426         { 0 }
427 };
428 
429 MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids);
430 
431 static struct serio_driver serio_raw_drv = {
432         .driver         = {
433                 .name   = "serio_raw",
434         },
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,
441         .manual_bind    = true,
442 };
443 
444 module_serio_driver(serio_raw_drv);
445 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us