2 * The Serio abstraction module
4 * Copyright (c) 1999-2004 Vojtech Pavlik
5 * Copyright (c) 2004 Dmitry Torokhov
6 * Copyright (c) 2003 Daniele Bellucci
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * Should you need to contact me, the author, you can do so either by
25 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
29 #include <linux/stddef.h>
30 #include <linux/module.h>
31 #include <linux/serio.h>
32 #include <linux/errno.h>
33 #include <linux/wait.h>
34 #include <linux/completion.h>
35 #include <linux/sched.h>
36 #include <linux/smp_lock.h>
37 #include <linux/slab.h>
39 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
40 MODULE_DESCRIPTION("Serio abstraction core");
41 MODULE_LICENSE("GPL");
43 EXPORT_SYMBOL(serio_interrupt);
44 EXPORT_SYMBOL(serio_register_port);
45 EXPORT_SYMBOL(serio_register_port_delayed);
46 EXPORT_SYMBOL(serio_unregister_port);
47 EXPORT_SYMBOL(serio_unregister_port_delayed);
48 EXPORT_SYMBOL(serio_register_driver);
49 EXPORT_SYMBOL(serio_unregister_driver);
50 EXPORT_SYMBOL(serio_open);
51 EXPORT_SYMBOL(serio_close);
52 EXPORT_SYMBOL(serio_rescan);
53 EXPORT_SYMBOL(serio_reconnect);
55 static DECLARE_MUTEX(serio_sem); /* protects serio_list and serio_diriver_list */
56 static LIST_HEAD(serio_list);
57 static LIST_HEAD(serio_driver_list);
58 static unsigned int serio_no;
60 struct bus_type serio_bus = {
64 static void serio_find_driver(struct serio *serio);
65 static void serio_create_port(struct serio *serio);
66 static void serio_destroy_port(struct serio *serio);
67 static void serio_connect_port(struct serio *serio, struct serio_driver *drv);
68 static void serio_reconnect_port(struct serio *serio);
69 static void serio_disconnect_port(struct serio *serio);
71 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
73 get_driver(&drv->driver);
75 drv->connect(serio, drv);
77 down_write(&serio_bus.subsys.rwsem);
78 serio->dev.driver = &drv->driver;
79 device_bind_driver(&serio->dev);
80 up_write(&serio_bus.subsys.rwsem);
84 put_driver(&drv->driver);
88 /* serio_find_driver() must be called with serio_sem down. */
89 static void serio_find_driver(struct serio *serio)
91 struct serio_driver *drv;
93 list_for_each_entry(drv, &serio_driver_list, node)
94 if (!drv->manual_bind)
95 if (serio_bind_driver(serio, drv))
100 * Serio event processing.
106 struct list_head node;
109 enum serio_event_type {
113 SERIO_UNREGISTER_PORT,
116 static DEFINE_SPINLOCK(serio_event_lock); /* protects serio_event_list */
117 static LIST_HEAD(serio_event_list);
118 static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
119 static DECLARE_COMPLETION(serio_exited);
120 static int serio_pid;
122 static void serio_queue_event(struct serio *serio, int event_type)
125 struct serio_event *event;
127 spin_lock_irqsave(&serio_event_lock, flags);
129 if ((event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC))) {
130 event->type = event_type;
131 event->serio = serio;
133 list_add_tail(&event->node, &serio_event_list);
134 wake_up(&serio_wait);
137 spin_unlock_irqrestore(&serio_event_lock, flags);
140 static struct serio_event *serio_get_event(void)
142 struct serio_event *event;
143 struct list_head *node;
146 spin_lock_irqsave(&serio_event_lock, flags);
148 if (list_empty(&serio_event_list)) {
149 spin_unlock_irqrestore(&serio_event_lock, flags);
153 node = serio_event_list.next;
154 event = container_of(node, struct serio_event, node);
157 spin_unlock_irqrestore(&serio_event_lock, flags);
162 static void serio_handle_events(void)
164 struct serio_event *event;
166 while ((event = serio_get_event())) {
170 switch (event->type) {
171 case SERIO_REGISTER_PORT :
172 serio_create_port(event->serio);
173 serio_connect_port(event->serio, NULL);
176 case SERIO_UNREGISTER_PORT :
177 serio_disconnect_port(event->serio);
178 serio_destroy_port(event->serio);
181 case SERIO_RECONNECT :
182 serio_reconnect_port(event->serio);
186 serio_disconnect_port(event->serio);
187 serio_connect_port(event->serio, NULL);
198 static void serio_remove_pending_events(struct serio *serio)
200 struct list_head *node, *next;
201 struct serio_event *event;
204 spin_lock_irqsave(&serio_event_lock, flags);
206 list_for_each_safe(node, next, &serio_event_list) {
207 event = container_of(node, struct serio_event, node);
208 if (event->serio == serio) {
214 spin_unlock_irqrestore(&serio_event_lock, flags);
218 static int serio_thread(void *nothing)
221 daemonize("kseriod");
222 allow_signal(SIGTERM);
225 serio_handle_events();
226 wait_event_interruptible(serio_wait, !list_empty(&serio_event_list));
227 try_to_freeze(PF_FREEZE);
228 } while (!signal_pending(current));
230 printk(KERN_DEBUG "serio: kseriod exiting\n");
233 complete_and_exit(&serio_exited, 0);
238 * Serio port operations
241 static ssize_t serio_show_description(struct device *dev, char *buf)
243 struct serio *serio = to_serio_port(dev);
244 return sprintf(buf, "%s\n", serio->name);
247 static ssize_t serio_rebind_driver(struct device *dev, const char *buf, size_t count)
249 struct serio *serio = to_serio_port(dev);
250 struct device_driver *drv;
253 retval = down_interruptible(&serio_sem);
258 if (!strncmp(buf, "none", count)) {
259 serio_disconnect_port(serio);
260 } else if (!strncmp(buf, "reconnect", count)) {
261 serio_reconnect_port(serio);
262 } else if (!strncmp(buf, "rescan", count)) {
263 serio_disconnect_port(serio);
264 serio_connect_port(serio, NULL);
265 } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
266 serio_disconnect_port(serio);
267 serio_connect_port(serio, to_serio_driver(drv));
278 static ssize_t serio_show_bind_mode(struct device *dev, char *buf)
280 struct serio *serio = to_serio_port(dev);
281 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
284 static ssize_t serio_set_bind_mode(struct device *dev, const char *buf, size_t count)
286 struct serio *serio = to_serio_port(dev);
290 if (!strncmp(buf, "manual", count)) {
291 serio->manual_bind = 1;
292 } else if (!strncmp(buf, "auto", count)) {
293 serio->manual_bind = 0;
301 static struct device_attribute serio_device_attrs[] = {
302 __ATTR(description, S_IRUGO, serio_show_description, NULL),
303 __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
304 __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
309 static void serio_release_port(struct device *dev)
311 struct serio *serio = to_serio_port(dev);
314 module_put(THIS_MODULE);
317 static void serio_create_port(struct serio *serio)
319 try_module_get(THIS_MODULE);
321 spin_lock_init(&serio->lock);
322 init_MUTEX(&serio->drv_sem);
323 list_add_tail(&serio->node, &serio_list);
324 snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id), "serio%d", serio_no++);
325 serio->dev.bus = &serio_bus;
326 serio->dev.release = serio_release_port;
328 serio->dev.parent = &serio->parent->dev;
329 device_register(&serio->dev);
333 * serio_destroy_port() completes deregistration process and removes
334 * port from the system
336 static void serio_destroy_port(struct serio *serio)
338 struct serio_driver *drv = serio->drv;
341 serio_remove_pending_events(serio);
342 list_del_init(&serio->node);
345 drv->disconnect(serio);
346 down_write(&serio_bus.subsys.rwsem);
347 device_release_driver(&serio->dev);
348 up_write(&serio_bus.subsys.rwsem);
349 put_driver(&drv->driver);
353 spin_lock_irqsave(&serio->parent->lock, flags);
354 serio->parent->child = NULL;
355 spin_unlock_irqrestore(&serio->parent->lock, flags);
358 device_unregister(&serio->dev);
362 * serio_connect_port() tries to bind the port and possible all its
363 * children to appropriate drivers. If driver passed in the function will not
364 * try otehr drivers when binding parent port.
366 static void serio_connect_port(struct serio *serio, struct serio_driver *drv)
369 WARN_ON(serio->child);
372 serio_bind_driver(serio, drv);
373 else if (!serio->manual_bind)
374 serio_find_driver(serio);
376 /* Ok, now bind children, if any */
377 while (serio->child) {
378 serio = serio->child;
381 WARN_ON(serio->child);
383 serio_create_port(serio);
385 if (!serio->manual_bind) {
387 * With children we just _prefer_ passed in driver,
388 * but we will try other options in case preferred
391 if (!drv || !serio_bind_driver(serio, drv))
392 serio_find_driver(serio);
400 static void serio_reconnect_port(struct serio *serio)
403 if (!serio->drv || !serio->drv->reconnect || serio->drv->reconnect(serio)) {
404 serio_disconnect_port(serio);
405 serio_connect_port(serio, NULL);
406 /* Ok, old children are now gone, we are done */
409 serio = serio->child;
414 * serio_disconnect_port() unbinds a port from its driver. As a side effect
415 * all child ports are unbound and destroyed.
417 static void serio_disconnect_port(struct serio *serio)
419 struct serio_driver *drv = serio->drv;
424 * Children ports should be disconnected and destroyed
425 * first, staring with the leaf one, since we don't want
434 serio_destroy_port(s->child);
439 * Ok, no children left, now disconnect this port
442 drv->disconnect(serio);
443 down_write(&serio_bus.subsys.rwsem);
444 device_release_driver(&serio->dev);
445 up_write(&serio_bus.subsys.rwsem);
446 put_driver(&drv->driver);
450 void serio_rescan(struct serio *serio)
452 serio_queue_event(serio, SERIO_RESCAN);
455 void serio_reconnect(struct serio *serio)
457 serio_queue_event(serio, SERIO_RECONNECT);
460 void serio_register_port(struct serio *serio)
463 serio_create_port(serio);
464 serio_connect_port(serio, NULL);
469 * Submits register request to kseriod for subsequent execution.
470 * Can be used when it is not obvious whether the serio_sem is
471 * taken or not and when delayed execution is feasible.
473 void serio_register_port_delayed(struct serio *serio)
475 serio_queue_event(serio, SERIO_REGISTER_PORT);
478 void serio_unregister_port(struct serio *serio)
481 serio_disconnect_port(serio);
482 serio_destroy_port(serio);
487 * Submits unregister request to kseriod for subsequent execution.
488 * Can be used when it is not obvious whether the serio_sem is
489 * taken or not and when delayed execution is feasible.
491 void serio_unregister_port_delayed(struct serio *serio)
493 serio_queue_event(serio, SERIO_UNREGISTER_PORT);
498 * Serio driver operations
501 static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
503 struct serio_driver *driver = to_serio_driver(drv);
504 return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
507 static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
509 struct serio_driver *serio_drv = to_serio_driver(drv);
510 return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
513 static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
515 struct serio_driver *serio_drv = to_serio_driver(drv);
519 if (!strncmp(buf, "manual", count)) {
520 serio_drv->manual_bind = 1;
521 } else if (!strncmp(buf, "auto", count)) {
522 serio_drv->manual_bind = 0;
531 static struct driver_attribute serio_driver_attrs[] = {
532 __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
533 __ATTR(bind_mode, S_IWUSR | S_IRUGO,
534 serio_driver_show_bind_mode, serio_driver_set_bind_mode),
538 void serio_register_driver(struct serio_driver *drv)
544 list_add_tail(&drv->node, &serio_driver_list);
546 drv->driver.bus = &serio_bus;
547 driver_register(&drv->driver);
549 if (drv->manual_bind)
553 list_for_each_entry(serio, &serio_list, node) {
555 serio_connect_port(serio, drv);
557 * if new child appeared then the list is changed,
558 * we need to start over
569 void serio_unregister_driver(struct serio_driver *drv)
575 list_del_init(&drv->node);
578 list_for_each_entry(serio, &serio_list, node) {
579 if (serio->drv == drv) {
580 serio_disconnect_port(serio);
581 serio_connect_port(serio, NULL);
582 /* we could've deleted some ports, restart */
587 driver_unregister(&drv->driver);
592 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
594 down(&serio->drv_sem);
595 serio_pause_rx(serio);
597 serio_continue_rx(serio);
601 /* called from serio_driver->connect/disconnect methods under serio_sem */
602 int serio_open(struct serio *serio, struct serio_driver *drv)
604 serio_set_drv(serio, drv);
606 if (serio->open && serio->open(serio)) {
607 serio_set_drv(serio, NULL);
613 /* called from serio_driver->connect/disconnect methods under serio_sem */
614 void serio_close(struct serio *serio)
619 serio_set_drv(serio, NULL);
622 irqreturn_t serio_interrupt(struct serio *serio,
623 unsigned char data, unsigned int dfl, struct pt_regs *regs)
626 irqreturn_t ret = IRQ_NONE;
628 spin_lock_irqsave(&serio->lock, flags);
630 if (likely(serio->drv)) {
631 ret = serio->drv->interrupt(serio, data, dfl, regs);
634 if ((serio->type != SERIO_8042 &&
635 serio->type != SERIO_8042_XL) || (data == 0xaa)) {
642 spin_unlock_irqrestore(&serio->lock, flags);
647 static int __init serio_init(void)
649 if (!(serio_pid = kernel_thread(serio_thread, NULL, CLONE_KERNEL))) {
650 printk(KERN_WARNING "serio: Failed to start kseriod\n");
654 serio_bus.dev_attrs = serio_device_attrs;
655 serio_bus.drv_attrs = serio_driver_attrs;
656 bus_register(&serio_bus);
661 static void __exit serio_exit(void)
663 bus_unregister(&serio_bus);
664 kill_proc(serio_pid, SIGTERM, 1);
665 wait_for_completion(&serio_exited);
668 module_init(serio_init);
669 module_exit(serio_exit);