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