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