Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh...
[linux-2.6] / drivers / input / serio / serio.c
1 /*
2  *  The Serio abstraction module
3  *
4  *  Copyright (c) 1999-2004 Vojtech Pavlik
5  *  Copyright (c) 2004 Dmitry Torokhov
6  *  Copyright (c) 2003 Daniele Bellucci
7  */
8
9 /*
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.
14  *
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.
19  *
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
23  *
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
27  */
28
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/sched.h>
35 #include <linux/slab.h>
36 #include <linux/kthread.h>
37 #include <linux/mutex.h>
38 #include <linux/freezer.h>
39
40 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
41 MODULE_DESCRIPTION("Serio abstraction core");
42 MODULE_LICENSE("GPL");
43
44 EXPORT_SYMBOL(serio_interrupt);
45 EXPORT_SYMBOL(__serio_register_port);
46 EXPORT_SYMBOL(serio_unregister_port);
47 EXPORT_SYMBOL(serio_unregister_child_port);
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);
54
55 /*
56  * serio_mutex protects entire serio subsystem and is taken every time
57  * serio port or driver registrered or unregistered.
58  */
59 static DEFINE_MUTEX(serio_mutex);
60
61 static LIST_HEAD(serio_list);
62
63 static struct bus_type serio_bus;
64
65 static void serio_add_port(struct serio *serio);
66 static void serio_reconnect_port(struct serio *serio);
67 static void serio_disconnect_port(struct serio *serio);
68 static void serio_attach_driver(struct serio_driver *drv);
69
70 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
71 {
72         int retval;
73
74         mutex_lock(&serio->drv_mutex);
75         retval = drv->connect(serio, drv);
76         mutex_unlock(&serio->drv_mutex);
77
78         return retval;
79 }
80
81 static int serio_reconnect_driver(struct serio *serio)
82 {
83         int retval = -1;
84
85         mutex_lock(&serio->drv_mutex);
86         if (serio->drv && serio->drv->reconnect)
87                 retval = serio->drv->reconnect(serio);
88         mutex_unlock(&serio->drv_mutex);
89
90         return retval;
91 }
92
93 static void serio_disconnect_driver(struct serio *serio)
94 {
95         mutex_lock(&serio->drv_mutex);
96         if (serio->drv)
97                 serio->drv->disconnect(serio);
98         mutex_unlock(&serio->drv_mutex);
99 }
100
101 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
102 {
103         while (ids->type || ids->proto) {
104                 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
105                     (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
106                     (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
107                     (ids->id == SERIO_ANY || ids->id == serio->id.id))
108                         return 1;
109                 ids++;
110         }
111         return 0;
112 }
113
114 /*
115  * Basic serio -> driver core mappings
116  */
117
118 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
119 {
120         int error;
121
122         if (serio_match_port(drv->id_table, serio)) {
123
124                 serio->dev.driver = &drv->driver;
125                 if (serio_connect_driver(serio, drv)) {
126                         serio->dev.driver = NULL;
127                         return -ENODEV;
128                 }
129
130                 error = device_bind_driver(&serio->dev);
131                 if (error) {
132                         printk(KERN_WARNING
133                                 "serio: device_bind_driver() failed "
134                                 "for %s (%s) and %s, error: %d\n",
135                                 serio->phys, serio->name,
136                                 drv->description, error);
137                         serio_disconnect_driver(serio);
138                         serio->dev.driver = NULL;
139                         return error;
140                 }
141         }
142         return 0;
143 }
144
145 static void serio_find_driver(struct serio *serio)
146 {
147         int error;
148
149         error = device_attach(&serio->dev);
150         if (error < 0)
151                 printk(KERN_WARNING
152                         "serio: device_attach() failed for %s (%s), error: %d\n",
153                         serio->phys, serio->name, error);
154 }
155
156
157 /*
158  * Serio event processing.
159  */
160
161 enum serio_event_type {
162         SERIO_RESCAN_PORT,
163         SERIO_RECONNECT_PORT,
164         SERIO_REGISTER_PORT,
165         SERIO_ATTACH_DRIVER,
166 };
167
168 struct serio_event {
169         enum serio_event_type type;
170         void *object;
171         struct module *owner;
172         struct list_head node;
173 };
174
175 static DEFINE_SPINLOCK(serio_event_lock);       /* protects serio_event_list */
176 static LIST_HEAD(serio_event_list);
177 static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
178 static struct task_struct *serio_task;
179
180 static int serio_queue_event(void *object, struct module *owner,
181                              enum serio_event_type event_type)
182 {
183         unsigned long flags;
184         struct serio_event *event;
185         int retval = 0;
186
187         spin_lock_irqsave(&serio_event_lock, flags);
188
189         /*
190          * Scan event list for the other events for the same serio port,
191          * starting with the most recent one. If event is the same we
192          * do not need add new one. If event is of different type we
193          * need to add this event and should not look further because
194          * we need to preseve sequence of distinct events.
195          */
196         list_for_each_entry_reverse(event, &serio_event_list, node) {
197                 if (event->object == object) {
198                         if (event->type == event_type)
199                                 goto out;
200                         break;
201                 }
202         }
203
204         event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
205         if (!event) {
206                 printk(KERN_ERR
207                         "serio: Not enough memory to queue event %d\n",
208                         event_type);
209                 retval = -ENOMEM;
210                 goto out;
211         }
212
213         if (!try_module_get(owner)) {
214                 printk(KERN_WARNING
215                         "serio: Can't get module reference, dropping event %d\n",
216                         event_type);
217                 kfree(event);
218                 retval = -EINVAL;
219                 goto out;
220         }
221
222         event->type = event_type;
223         event->object = object;
224         event->owner = owner;
225
226         list_add_tail(&event->node, &serio_event_list);
227         wake_up(&serio_wait);
228
229 out:
230         spin_unlock_irqrestore(&serio_event_lock, flags);
231         return retval;
232 }
233
234 static void serio_free_event(struct serio_event *event)
235 {
236         module_put(event->owner);
237         kfree(event);
238 }
239
240 static void serio_remove_duplicate_events(struct serio_event *event)
241 {
242         struct list_head *node, *next;
243         struct serio_event *e;
244         unsigned long flags;
245
246         spin_lock_irqsave(&serio_event_lock, flags);
247
248         list_for_each_safe(node, next, &serio_event_list) {
249                 e = list_entry(node, struct serio_event, node);
250                 if (event->object == e->object) {
251                         /*
252                          * If this event is of different type we should not
253                          * look further - we only suppress duplicate events
254                          * that were sent back-to-back.
255                          */
256                         if (event->type != e->type)
257                                 break;
258
259                         list_del_init(node);
260                         serio_free_event(e);
261                 }
262         }
263
264         spin_unlock_irqrestore(&serio_event_lock, flags);
265 }
266
267
268 static struct serio_event *serio_get_event(void)
269 {
270         struct serio_event *event;
271         struct list_head *node;
272         unsigned long flags;
273
274         spin_lock_irqsave(&serio_event_lock, flags);
275
276         if (list_empty(&serio_event_list)) {
277                 spin_unlock_irqrestore(&serio_event_lock, flags);
278                 return NULL;
279         }
280
281         node = serio_event_list.next;
282         event = list_entry(node, struct serio_event, node);
283         list_del_init(node);
284
285         spin_unlock_irqrestore(&serio_event_lock, flags);
286
287         return event;
288 }
289
290 static void serio_handle_event(void)
291 {
292         struct serio_event *event;
293
294         mutex_lock(&serio_mutex);
295
296         /*
297          * Note that we handle only one event here to give swsusp
298          * a chance to freeze kseriod thread. Serio events should
299          * be pretty rare so we are not concerned about taking
300          * performance hit.
301          */
302         if ((event = serio_get_event())) {
303
304                 switch (event->type) {
305                         case SERIO_REGISTER_PORT:
306                                 serio_add_port(event->object);
307                                 break;
308
309                         case SERIO_RECONNECT_PORT:
310                                 serio_reconnect_port(event->object);
311                                 break;
312
313                         case SERIO_RESCAN_PORT:
314                                 serio_disconnect_port(event->object);
315                                 serio_find_driver(event->object);
316                                 break;
317
318                         case SERIO_ATTACH_DRIVER:
319                                 serio_attach_driver(event->object);
320                                 break;
321
322                         default:
323                                 break;
324                 }
325
326                 serio_remove_duplicate_events(event);
327                 serio_free_event(event);
328         }
329
330         mutex_unlock(&serio_mutex);
331 }
332
333 /*
334  * Remove all events that have been submitted for a given serio port.
335  */
336 static void serio_remove_pending_events(struct serio *serio)
337 {
338         struct list_head *node, *next;
339         struct serio_event *event;
340         unsigned long flags;
341
342         spin_lock_irqsave(&serio_event_lock, flags);
343
344         list_for_each_safe(node, next, &serio_event_list) {
345                 event = list_entry(node, struct serio_event, node);
346                 if (event->object == serio) {
347                         list_del_init(node);
348                         serio_free_event(event);
349                 }
350         }
351
352         spin_unlock_irqrestore(&serio_event_lock, flags);
353 }
354
355 /*
356  * Destroy child serio port (if any) that has not been fully registered yet.
357  *
358  * Note that we rely on the fact that port can have only one child and therefore
359  * only one child registration request can be pending. Additionally, children
360  * are registered by driver's connect() handler so there can't be a grandchild
361  * pending registration together with a child.
362  */
363 static struct serio *serio_get_pending_child(struct serio *parent)
364 {
365         struct serio_event *event;
366         struct serio *serio, *child = NULL;
367         unsigned long flags;
368
369         spin_lock_irqsave(&serio_event_lock, flags);
370
371         list_for_each_entry(event, &serio_event_list, node) {
372                 if (event->type == SERIO_REGISTER_PORT) {
373                         serio = event->object;
374                         if (serio->parent == parent) {
375                                 child = serio;
376                                 break;
377                         }
378                 }
379         }
380
381         spin_unlock_irqrestore(&serio_event_lock, flags);
382         return child;
383 }
384
385 static int serio_thread(void *nothing)
386 {
387         set_freezable();
388         do {
389                 serio_handle_event();
390                 wait_event_interruptible(serio_wait,
391                         kthread_should_stop() || !list_empty(&serio_event_list));
392                 try_to_freeze();
393         } while (!kthread_should_stop());
394
395         printk(KERN_DEBUG "serio: kseriod exiting\n");
396         return 0;
397 }
398
399
400 /*
401  * Serio port operations
402  */
403
404 static ssize_t serio_show_description(struct device *dev, struct device_attribute *attr, char *buf)
405 {
406         struct serio *serio = to_serio_port(dev);
407         return sprintf(buf, "%s\n", serio->name);
408 }
409
410 static ssize_t serio_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
411 {
412         struct serio *serio = to_serio_port(dev);
413
414         return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
415                         serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
416 }
417
418 static ssize_t serio_show_id_type(struct device *dev, struct device_attribute *attr, char *buf)
419 {
420         struct serio *serio = to_serio_port(dev);
421         return sprintf(buf, "%02x\n", serio->id.type);
422 }
423
424 static ssize_t serio_show_id_proto(struct device *dev, struct device_attribute *attr, char *buf)
425 {
426         struct serio *serio = to_serio_port(dev);
427         return sprintf(buf, "%02x\n", serio->id.proto);
428 }
429
430 static ssize_t serio_show_id_id(struct device *dev, struct device_attribute *attr, char *buf)
431 {
432         struct serio *serio = to_serio_port(dev);
433         return sprintf(buf, "%02x\n", serio->id.id);
434 }
435
436 static ssize_t serio_show_id_extra(struct device *dev, struct device_attribute *attr, char *buf)
437 {
438         struct serio *serio = to_serio_port(dev);
439         return sprintf(buf, "%02x\n", serio->id.extra);
440 }
441
442 static DEVICE_ATTR(type, S_IRUGO, serio_show_id_type, NULL);
443 static DEVICE_ATTR(proto, S_IRUGO, serio_show_id_proto, NULL);
444 static DEVICE_ATTR(id, S_IRUGO, serio_show_id_id, NULL);
445 static DEVICE_ATTR(extra, S_IRUGO, serio_show_id_extra, NULL);
446
447 static struct attribute *serio_device_id_attrs[] = {
448         &dev_attr_type.attr,
449         &dev_attr_proto.attr,
450         &dev_attr_id.attr,
451         &dev_attr_extra.attr,
452         NULL
453 };
454
455 static struct attribute_group serio_id_attr_group = {
456         .name   = "id",
457         .attrs  = serio_device_id_attrs,
458 };
459
460 static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
461 {
462         struct serio *serio = to_serio_port(dev);
463         struct device_driver *drv;
464         int error;
465
466         error = mutex_lock_interruptible(&serio_mutex);
467         if (error)
468                 return error;
469
470         if (!strncmp(buf, "none", count)) {
471                 serio_disconnect_port(serio);
472         } else if (!strncmp(buf, "reconnect", count)) {
473                 serio_reconnect_port(serio);
474         } else if (!strncmp(buf, "rescan", count)) {
475                 serio_disconnect_port(serio);
476                 serio_find_driver(serio);
477         } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
478                 serio_disconnect_port(serio);
479                 error = serio_bind_driver(serio, to_serio_driver(drv));
480                 put_driver(drv);
481         } else {
482                 error = -EINVAL;
483         }
484
485         mutex_unlock(&serio_mutex);
486
487         return error ? error : count;
488 }
489
490 static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
491 {
492         struct serio *serio = to_serio_port(dev);
493         return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
494 }
495
496 static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
497 {
498         struct serio *serio = to_serio_port(dev);
499         int retval;
500
501         retval = count;
502         if (!strncmp(buf, "manual", count)) {
503                 serio->manual_bind = 1;
504         } else if (!strncmp(buf, "auto", count)) {
505                 serio->manual_bind = 0;
506         } else {
507                 retval = -EINVAL;
508         }
509
510         return retval;
511 }
512
513 static struct device_attribute serio_device_attrs[] = {
514         __ATTR(description, S_IRUGO, serio_show_description, NULL),
515         __ATTR(modalias, S_IRUGO, serio_show_modalias, NULL),
516         __ATTR(drvctl, S_IWUSR, NULL, serio_rebind_driver),
517         __ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode),
518         __ATTR_NULL
519 };
520
521
522 static void serio_release_port(struct device *dev)
523 {
524         struct serio *serio = to_serio_port(dev);
525
526         kfree(serio);
527         module_put(THIS_MODULE);
528 }
529
530 /*
531  * Prepare serio port for registration.
532  */
533 static void serio_init_port(struct serio *serio)
534 {
535         static atomic_t serio_no = ATOMIC_INIT(0);
536
537         __module_get(THIS_MODULE);
538
539         INIT_LIST_HEAD(&serio->node);
540         spin_lock_init(&serio->lock);
541         mutex_init(&serio->drv_mutex);
542         device_initialize(&serio->dev);
543         snprintf(serio->dev.bus_id, sizeof(serio->dev.bus_id),
544                  "serio%ld", (long)atomic_inc_return(&serio_no) - 1);
545         serio->dev.bus = &serio_bus;
546         serio->dev.release = serio_release_port;
547         if (serio->parent) {
548                 serio->dev.parent = &serio->parent->dev;
549                 serio->depth = serio->parent->depth + 1;
550         } else
551                 serio->depth = 0;
552         lockdep_set_subclass(&serio->lock, serio->depth);
553 }
554
555 /*
556  * Complete serio port registration.
557  * Driver core will attempt to find appropriate driver for the port.
558  */
559 static void serio_add_port(struct serio *serio)
560 {
561         int error;
562
563         if (serio->parent) {
564                 serio_pause_rx(serio->parent);
565                 serio->parent->child = serio;
566                 serio_continue_rx(serio->parent);
567         }
568
569         list_add_tail(&serio->node, &serio_list);
570         if (serio->start)
571                 serio->start(serio);
572         error = device_add(&serio->dev);
573         if (error)
574                 printk(KERN_ERR
575                         "serio: device_add() failed for %s (%s), error: %d\n",
576                         serio->phys, serio->name, error);
577         else {
578                 serio->registered = 1;
579                 error = sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
580                 if (error)
581                         printk(KERN_ERR
582                                 "serio: sysfs_create_group() failed for %s (%s), error: %d\n",
583                                 serio->phys, serio->name, error);
584         }
585 }
586
587 /*
588  * serio_destroy_port() completes deregistration process and removes
589  * port from the system
590  */
591 static void serio_destroy_port(struct serio *serio)
592 {
593         struct serio *child;
594
595         child = serio_get_pending_child(serio);
596         if (child) {
597                 serio_remove_pending_events(child);
598                 put_device(&child->dev);
599         }
600
601         if (serio->stop)
602                 serio->stop(serio);
603
604         if (serio->parent) {
605                 serio_pause_rx(serio->parent);
606                 serio->parent->child = NULL;
607                 serio_continue_rx(serio->parent);
608                 serio->parent = NULL;
609         }
610
611         if (serio->registered) {
612                 sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);
613                 device_del(&serio->dev);
614                 serio->registered = 0;
615         }
616
617         list_del_init(&serio->node);
618         serio_remove_pending_events(serio);
619         put_device(&serio->dev);
620 }
621
622 /*
623  * Reconnect serio port and all its children (re-initialize attached devices)
624  */
625 static void serio_reconnect_port(struct serio *serio)
626 {
627         do {
628                 if (serio_reconnect_driver(serio)) {
629                         serio_disconnect_port(serio);
630                         serio_find_driver(serio);
631                         /* Ok, old children are now gone, we are done */
632                         break;
633                 }
634                 serio = serio->child;
635         } while (serio);
636 }
637
638 /*
639  * serio_disconnect_port() unbinds a port from its driver. As a side effect
640  * all child ports are unbound and destroyed.
641  */
642 static void serio_disconnect_port(struct serio *serio)
643 {
644         struct serio *s, *parent;
645
646         if (serio->child) {
647                 /*
648                  * Children ports should be disconnected and destroyed
649                  * first, staring with the leaf one, since we don't want
650                  * to do recursion
651                  */
652                 for (s = serio; s->child; s = s->child)
653                         /* empty */;
654
655                 do {
656                         parent = s->parent;
657
658                         device_release_driver(&s->dev);
659                         serio_destroy_port(s);
660                 } while ((s = parent) != serio);
661         }
662
663         /*
664          * Ok, no children left, now disconnect this port
665          */
666         device_release_driver(&serio->dev);
667 }
668
669 void serio_rescan(struct serio *serio)
670 {
671         serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
672 }
673
674 void serio_reconnect(struct serio *serio)
675 {
676         serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
677 }
678
679 /*
680  * Submits register request to kseriod for subsequent execution.
681  * Note that port registration is always asynchronous.
682  */
683 void __serio_register_port(struct serio *serio, struct module *owner)
684 {
685         serio_init_port(serio);
686         serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
687 }
688
689 /*
690  * Synchronously unregisters serio port.
691  */
692 void serio_unregister_port(struct serio *serio)
693 {
694         mutex_lock(&serio_mutex);
695         serio_disconnect_port(serio);
696         serio_destroy_port(serio);
697         mutex_unlock(&serio_mutex);
698 }
699
700 /*
701  * Safely unregisters child port if one is present.
702  */
703 void serio_unregister_child_port(struct serio *serio)
704 {
705         mutex_lock(&serio_mutex);
706         if (serio->child) {
707                 serio_disconnect_port(serio->child);
708                 serio_destroy_port(serio->child);
709         }
710         mutex_unlock(&serio_mutex);
711 }
712
713
714 /*
715  * Serio driver operations
716  */
717
718 static ssize_t serio_driver_show_description(struct device_driver *drv, char *buf)
719 {
720         struct serio_driver *driver = to_serio_driver(drv);
721         return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
722 }
723
724 static ssize_t serio_driver_show_bind_mode(struct device_driver *drv, char *buf)
725 {
726         struct serio_driver *serio_drv = to_serio_driver(drv);
727         return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
728 }
729
730 static ssize_t serio_driver_set_bind_mode(struct device_driver *drv, const char *buf, size_t count)
731 {
732         struct serio_driver *serio_drv = to_serio_driver(drv);
733         int retval;
734
735         retval = count;
736         if (!strncmp(buf, "manual", count)) {
737                 serio_drv->manual_bind = 1;
738         } else if (!strncmp(buf, "auto", count)) {
739                 serio_drv->manual_bind = 0;
740         } else {
741                 retval = -EINVAL;
742         }
743
744         return retval;
745 }
746
747
748 static struct driver_attribute serio_driver_attrs[] = {
749         __ATTR(description, S_IRUGO, serio_driver_show_description, NULL),
750         __ATTR(bind_mode, S_IWUSR | S_IRUGO,
751                 serio_driver_show_bind_mode, serio_driver_set_bind_mode),
752         __ATTR_NULL
753 };
754
755 static int serio_driver_probe(struct device *dev)
756 {
757         struct serio *serio = to_serio_port(dev);
758         struct serio_driver *drv = to_serio_driver(dev->driver);
759
760         return serio_connect_driver(serio, drv);
761 }
762
763 static int serio_driver_remove(struct device *dev)
764 {
765         struct serio *serio = to_serio_port(dev);
766
767         serio_disconnect_driver(serio);
768         return 0;
769 }
770
771 static void serio_cleanup(struct serio *serio)
772 {
773         mutex_lock(&serio->drv_mutex);
774         if (serio->drv && serio->drv->cleanup)
775                 serio->drv->cleanup(serio);
776         mutex_unlock(&serio->drv_mutex);
777 }
778
779 static void serio_shutdown(struct device *dev)
780 {
781         struct serio *serio = to_serio_port(dev);
782
783         serio_cleanup(serio);
784 }
785
786 static void serio_attach_driver(struct serio_driver *drv)
787 {
788         int error;
789
790         error = driver_attach(&drv->driver);
791         if (error)
792                 printk(KERN_WARNING
793                         "serio: driver_attach() failed for %s with error %d\n",
794                         drv->driver.name, error);
795 }
796
797 int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
798 {
799         int manual_bind = drv->manual_bind;
800         int error;
801
802         drv->driver.bus = &serio_bus;
803         drv->driver.owner = owner;
804         drv->driver.mod_name = mod_name;
805
806         /*
807          * Temporarily disable automatic binding because probing
808          * takes long time and we are better off doing it in kseriod
809          */
810         drv->manual_bind = 1;
811
812         error = driver_register(&drv->driver);
813         if (error) {
814                 printk(KERN_ERR
815                         "serio: driver_register() failed for %s, error: %d\n",
816                         drv->driver.name, error);
817                 return error;
818         }
819
820         /*
821          * Restore original bind mode and let kseriod bind the
822          * driver to free ports
823          */
824         if (!manual_bind) {
825                 drv->manual_bind = 0;
826                 error = serio_queue_event(drv, NULL, SERIO_ATTACH_DRIVER);
827                 if (error) {
828                         driver_unregister(&drv->driver);
829                         return error;
830                 }
831         }
832
833         return 0;
834 }
835
836 void serio_unregister_driver(struct serio_driver *drv)
837 {
838         struct serio *serio;
839
840         mutex_lock(&serio_mutex);
841         drv->manual_bind = 1;   /* so serio_find_driver ignores it */
842
843 start_over:
844         list_for_each_entry(serio, &serio_list, node) {
845                 if (serio->drv == drv) {
846                         serio_disconnect_port(serio);
847                         serio_find_driver(serio);
848                         /* we could've deleted some ports, restart */
849                         goto start_over;
850                 }
851         }
852
853         driver_unregister(&drv->driver);
854         mutex_unlock(&serio_mutex);
855 }
856
857 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
858 {
859         serio_pause_rx(serio);
860         serio->drv = drv;
861         serio_continue_rx(serio);
862 }
863
864 static int serio_bus_match(struct device *dev, struct device_driver *drv)
865 {
866         struct serio *serio = to_serio_port(dev);
867         struct serio_driver *serio_drv = to_serio_driver(drv);
868
869         if (serio->manual_bind || serio_drv->manual_bind)
870                 return 0;
871
872         return serio_match_port(serio_drv->id_table, serio);
873 }
874
875 #ifdef CONFIG_HOTPLUG
876
877 #define SERIO_ADD_UEVENT_VAR(fmt, val...)                               \
878         do {                                                            \
879                 int err = add_uevent_var(envp, num_envp, &i,    \
880                                         buffer, buffer_size, &len,      \
881                                         fmt, val);                      \
882                 if (err)                                                \
883                         return err;                                     \
884         } while (0)
885
886 static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
887 {
888         struct serio *serio;
889         int i = 0;
890         int len = 0;
891
892         if (!dev)
893                 return -ENODEV;
894
895         serio = to_serio_port(dev);
896
897         SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
898         SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
899         SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
900         SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
901         SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
902                                 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
903         envp[i] = NULL;
904
905         return 0;
906 }
907 #undef SERIO_ADD_UEVENT_VAR
908
909 #else
910
911 static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
912 {
913         return -ENODEV;
914 }
915
916 #endif /* CONFIG_HOTPLUG */
917
918 #ifdef CONFIG_PM
919 static int serio_suspend(struct device *dev, pm_message_t state)
920 {
921         if (dev->power.power_state.event != state.event) {
922                 if (state.event == PM_EVENT_SUSPEND)
923                         serio_cleanup(to_serio_port(dev));
924
925                 dev->power.power_state = state;
926         }
927
928         return 0;
929 }
930
931 static int serio_resume(struct device *dev)
932 {
933         struct serio *serio = to_serio_port(dev);
934
935         if (dev->power.power_state.event != PM_EVENT_ON &&
936             serio_reconnect_driver(serio)) {
937                 /*
938                  * Driver re-probing can take a while, so better let kseriod
939                  * deal with it.
940                  */
941                 serio_rescan(serio);
942         }
943
944         dev->power.power_state = PMSG_ON;
945
946         return 0;
947 }
948 #endif /* CONFIG_PM */
949
950 /* called from serio_driver->connect/disconnect methods under serio_mutex */
951 int serio_open(struct serio *serio, struct serio_driver *drv)
952 {
953         serio_set_drv(serio, drv);
954
955         if (serio->open && serio->open(serio)) {
956                 serio_set_drv(serio, NULL);
957                 return -1;
958         }
959         return 0;
960 }
961
962 /* called from serio_driver->connect/disconnect methods under serio_mutex */
963 void serio_close(struct serio *serio)
964 {
965         if (serio->close)
966                 serio->close(serio);
967
968         serio_set_drv(serio, NULL);
969 }
970
971 irqreturn_t serio_interrupt(struct serio *serio,
972                 unsigned char data, unsigned int dfl)
973 {
974         unsigned long flags;
975         irqreturn_t ret = IRQ_NONE;
976
977         spin_lock_irqsave(&serio->lock, flags);
978
979         if (likely(serio->drv)) {
980                 ret = serio->drv->interrupt(serio, data, dfl);
981         } else if (!dfl && serio->registered) {
982                 serio_rescan(serio);
983                 ret = IRQ_HANDLED;
984         }
985
986         spin_unlock_irqrestore(&serio->lock, flags);
987
988         return ret;
989 }
990
991 static struct bus_type serio_bus = {
992         .name           = "serio",
993         .dev_attrs      = serio_device_attrs,
994         .drv_attrs      = serio_driver_attrs,
995         .match          = serio_bus_match,
996         .uevent         = serio_uevent,
997         .probe          = serio_driver_probe,
998         .remove         = serio_driver_remove,
999         .shutdown       = serio_shutdown,
1000 #ifdef CONFIG_PM
1001         .suspend        = serio_suspend,
1002         .resume         = serio_resume,
1003 #endif
1004 };
1005
1006 static int __init serio_init(void)
1007 {
1008         int error;
1009
1010         error = bus_register(&serio_bus);
1011         if (error) {
1012                 printk(KERN_ERR "serio: failed to register serio bus, error: %d\n", error);
1013                 return error;
1014         }
1015
1016         serio_task = kthread_run(serio_thread, NULL, "kseriod");
1017         if (IS_ERR(serio_task)) {
1018                 bus_unregister(&serio_bus);
1019                 error = PTR_ERR(serio_task);
1020                 printk(KERN_ERR "serio: Failed to start kseriod, error: %d\n", error);
1021                 return error;
1022         }
1023
1024         return 0;
1025 }
1026
1027 static void __exit serio_exit(void)
1028 {
1029         bus_unregister(&serio_bus);
1030         kthread_stop(serio_task);
1031 }
1032
1033 subsys_initcall(serio_init);
1034 module_exit(serio_exit);