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