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 modalias_show(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 type_show(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 proto_show(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 id_show(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 extra_show(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 ssize_t drvctl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
401{
402 struct serio *serio = to_serio_port(dev);
403 struct device_driver *drv;
404 int error;
405
406 error = mutex_lock_interruptible(&serio_mutex);
407 if (error)
408 return error;
409
410 if (!strncmp(buf, "none", count)) {
411 serio_disconnect_port(serio);
412 } else if (!strncmp(buf, "reconnect", count)) {
413 serio_reconnect_subtree(serio);
414 } else if (!strncmp(buf, "rescan", count)) {
415 serio_disconnect_port(serio);
416 serio_find_driver(serio);
417 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
418 } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
419 serio_disconnect_port(serio);
420 error = serio_bind_driver(serio, to_serio_driver(drv));
421 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
422 } else {
423 error = -EINVAL;
424 }
425
426 mutex_unlock(&serio_mutex);
427
428 return error ? error : count;
429}
430
431static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
432{
433 struct serio *serio = to_serio_port(dev);
434 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
435}
436
437static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
438{
439 struct serio *serio = to_serio_port(dev);
440 int retval;
441
442 retval = count;
443 if (!strncmp(buf, "manual", count)) {
444 serio->manual_bind = true;
445 } else if (!strncmp(buf, "auto", count)) {
446 serio->manual_bind = false;
447 } else {
448 retval = -EINVAL;
449 }
450
451 return retval;
452}
453
454static ssize_t firmware_id_show(struct device *dev, struct device_attribute *attr, char *buf)
455{
456 struct serio *serio = to_serio_port(dev);
457
458 return sprintf(buf, "%s\n", serio->firmware_id);
459}
460
461static DEVICE_ATTR_RO(type);
462static DEVICE_ATTR_RO(proto);
463static DEVICE_ATTR_RO(id);
464static DEVICE_ATTR_RO(extra);
465
466static struct attribute *serio_device_id_attrs[] = {
467 &dev_attr_type.attr,
468 &dev_attr_proto.attr,
469 &dev_attr_id.attr,
470 &dev_attr_extra.attr,
471 NULL
472};
473
474static struct attribute_group serio_id_attr_group = {
475 .name = "id",
476 .attrs = serio_device_id_attrs,
477};
478
479static DEVICE_ATTR_RO(modalias);
480static DEVICE_ATTR_WO(drvctl);
481static DEVICE_ATTR(description, S_IRUGO, serio_show_description, NULL);
482static DEVICE_ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode);
483static DEVICE_ATTR_RO(firmware_id);
484
485static struct attribute *serio_device_attrs[] = {
486 &dev_attr_modalias.attr,
487 &dev_attr_description.attr,
488 &dev_attr_drvctl.attr,
489 &dev_attr_bind_mode.attr,
490 &dev_attr_firmware_id.attr,
491 NULL
492};
493
494static struct attribute_group serio_device_attr_group = {
495 .attrs = serio_device_attrs,
496};
497
498static const struct attribute_group *serio_device_attr_groups[] = {
499 &serio_id_attr_group,
500 &serio_device_attr_group,
501 NULL
502};
503
504static void serio_release_port(struct device *dev)
505{
506 struct serio *serio = to_serio_port(dev);
507
508 kfree(serio);
509 module_put(THIS_MODULE);
510}
511
512
513
514
515static void serio_init_port(struct serio *serio)
516{
517 static atomic_t serio_no = ATOMIC_INIT(-1);
518
519 __module_get(THIS_MODULE);
520
521 INIT_LIST_HEAD(&serio->node);
522 INIT_LIST_HEAD(&serio->child_node);
523 INIT_LIST_HEAD(&serio->children);
524 spin_lock_init(&serio->lock);
525 mutex_init(&serio->drv_mutex);
526 device_initialize(&serio->dev);
527 dev_set_name(&serio->dev, "serio%lu",
528 (unsigned long)atomic_inc_return(&serio_no));
529 serio->dev.bus = &serio_bus;
530 serio->dev.release = serio_release_port;
531 serio->dev.groups = serio_device_attr_groups;
532 if (serio->parent) {
533 serio->dev.parent = &serio->parent->dev;
534 serio->depth = serio->parent->depth + 1;
535 } else
536 serio->depth = 0;
537 lockdep_set_subclass(&serio->lock, serio->depth);
538}
539
540
541
542
543
544static void serio_add_port(struct serio *serio)
545{
546 struct serio *parent = serio->parent;
547 int error;
548
549 if (parent) {
550 serio_pause_rx(parent);
551 list_add_tail(&serio->child_node, &parent->children);
552 serio_continue_rx(parent);
553 }
554
555 list_add_tail(&serio->node, &serio_list);
556
557 if (serio->start)
558 serio->start(serio);
559
560 error = device_add(&serio->dev);
561 if (error)
562 dev_err(&serio->dev,
563 "device_add() failed for %s (%s), error: %d\n",
564 serio->phys, serio->name, error);
565}
566
567
568
569
570
571static void serio_destroy_port(struct serio *serio)
572{
573 struct serio *child;
574
575 while ((child = serio_get_pending_child(serio)) != NULL) {
576 serio_remove_pending_events(child);
577 put_device(&child->dev);
578 }
579
580 if (serio->stop)
581 serio->stop(serio);
582
583 if (serio->parent) {
584 serio_pause_rx(serio->parent);
585 list_del_init(&serio->child_node);
586 serio_continue_rx(serio->parent);
587 serio->parent = NULL;
588 }
589
590 if (device_is_registered(&serio->dev))
591 device_del(&serio->dev);
592
593 list_del_init(&serio->node);
594 serio_remove_pending_events(serio);
595 put_device(&serio->dev);
596}
597
598
599
600
601
602
603
604static int serio_reconnect_port(struct serio *serio)
605{
606 int error = serio_reconnect_driver(serio);
607
608 if (error) {
609 serio_disconnect_port(serio);
610 serio_find_driver(serio);
611 }
612
613 return error;
614}
615
616
617
618
619
620static void serio_reconnect_subtree(struct serio *root)
621{
622 struct serio *s = root;
623 int error;
624
625 do {
626 error = serio_reconnect_port(s);
627 if (!error) {
628
629
630
631
632 if (!list_empty(&s->children)) {
633 s = list_first_entry(&s->children,
634 struct serio, child_node);
635 continue;
636 }
637 }
638
639
640
641
642
643
644 while (s != root) {
645 struct serio *parent = s->parent;
646
647 if (!list_is_last(&s->child_node, &parent->children)) {
648 s = list_entry(s->child_node.next,
649 struct serio, child_node);
650 break;
651 }
652
653 s = parent;
654 }
655 } while (s != root);
656}
657
658
659
660
661
662static void serio_disconnect_port(struct serio *serio)
663{
664 struct serio *s = serio;
665
666
667
668
669
670 while (!list_empty(&serio->children)) {
671
672
673 while (!list_empty(&s->children))
674 s = list_first_entry(&s->children,
675 struct serio, child_node);
676
677
678
679
680
681 if (s != serio) {
682 struct serio *parent = s->parent;
683
684 device_release_driver(&s->dev);
685 serio_destroy_port(s);
686
687 s = parent;
688 }
689 }
690
691
692
693
694 device_release_driver(&serio->dev);
695}
696
697void serio_rescan(struct serio *serio)
698{
699 serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
700}
701EXPORT_SYMBOL(serio_rescan);
702
703void serio_reconnect(struct serio *serio)
704{
705 serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE);
706}
707EXPORT_SYMBOL(serio_reconnect);
708
709
710
711
712
713void __serio_register_port(struct serio *serio, struct module *owner)
714{
715 serio_init_port(serio);
716 serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
717}
718EXPORT_SYMBOL(__serio_register_port);
719
720
721
722
723void serio_unregister_port(struct serio *serio)
724{
725 mutex_lock(&serio_mutex);
726 serio_disconnect_port(serio);
727 serio_destroy_port(serio);
728 mutex_unlock(&serio_mutex);
729}
730EXPORT_SYMBOL(serio_unregister_port);
731
732
733
734
735void serio_unregister_child_port(struct serio *serio)
736{
737 struct serio *s, *next;
738
739 mutex_lock(&serio_mutex);
740 list_for_each_entry_safe(s, next, &serio->children, child_node) {
741 serio_disconnect_port(s);
742 serio_destroy_port(s);
743 }
744 mutex_unlock(&serio_mutex);
745}
746EXPORT_SYMBOL(serio_unregister_child_port);
747
748
749
750
751
752
753static ssize_t description_show(struct device_driver *drv, char *buf)
754{
755 struct serio_driver *driver = to_serio_driver(drv);
756 return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
757}
758static DRIVER_ATTR_RO(description);
759
760static ssize_t bind_mode_show(struct device_driver *drv, char *buf)
761{
762 struct serio_driver *serio_drv = to_serio_driver(drv);
763 return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
764}
765
766static ssize_t bind_mode_store(struct device_driver *drv, const char *buf, size_t count)
767{
768 struct serio_driver *serio_drv = to_serio_driver(drv);
769 int retval;
770
771 retval = count;
772 if (!strncmp(buf, "manual", count)) {
773 serio_drv->manual_bind = true;
774 } else if (!strncmp(buf, "auto", count)) {
775 serio_drv->manual_bind = false;
776 } else {
777 retval = -EINVAL;
778 }
779
780 return retval;
781}
782static DRIVER_ATTR_RW(bind_mode);
783
784static struct attribute *serio_driver_attrs[] = {
785 &driver_attr_description.attr,
786 &driver_attr_bind_mode.attr,
787 NULL,
788};
789ATTRIBUTE_GROUPS(serio_driver);
790
791static int serio_driver_probe(struct device *dev)
792{
793 struct serio *serio = to_serio_port(dev);
794 struct serio_driver *drv = to_serio_driver(dev->driver);
795
796 return serio_connect_driver(serio, drv);
797}
798
799static int serio_driver_remove(struct device *dev)
800{
801 struct serio *serio = to_serio_port(dev);
802
803 serio_disconnect_driver(serio);
804 return 0;
805}
806
807static void serio_cleanup(struct serio *serio)
808{
809 mutex_lock(&serio->drv_mutex);
810 if (serio->drv && serio->drv->cleanup)
811 serio->drv->cleanup(serio);
812 mutex_unlock(&serio->drv_mutex);
813}
814
815static void serio_shutdown(struct device *dev)
816{
817 struct serio *serio = to_serio_port(dev);
818
819 serio_cleanup(serio);
820}
821
822static void serio_attach_driver(struct serio_driver *drv)
823{
824 int error;
825
826 error = driver_attach(&drv->driver);
827 if (error)
828 pr_warning("driver_attach() failed for %s with error %d\n",
829 drv->driver.name, error);
830}
831
832int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
833{
834 bool manual_bind = drv->manual_bind;
835 int error;
836
837 drv->driver.bus = &serio_bus;
838 drv->driver.owner = owner;
839 drv->driver.mod_name = mod_name;
840
841
842
843
844
845 drv->manual_bind = true;
846
847 error = driver_register(&drv->driver);
848 if (error) {
849 pr_err("driver_register() failed for %s, error: %d\n",
850 drv->driver.name, error);
851 return error;
852 }
853
854
855
856
857
858 if (!manual_bind) {
859 drv->manual_bind = false;
860 error = serio_queue_event(drv, NULL, SERIO_ATTACH_DRIVER);
861 if (error) {
862 driver_unregister(&drv->driver);
863 return error;
864 }
865 }
866
867 return 0;
868}
869EXPORT_SYMBOL(__serio_register_driver);
870
871void serio_unregister_driver(struct serio_driver *drv)
872{
873 struct serio *serio;
874
875 mutex_lock(&serio_mutex);
876
877 drv->manual_bind = true;
878 serio_remove_pending_events(drv);
879
880start_over:
881 list_for_each_entry(serio, &serio_list, node) {
882 if (serio->drv == drv) {
883 serio_disconnect_port(serio);
884 serio_find_driver(serio);
885
886 goto start_over;
887 }
888 }
889
890 driver_unregister(&drv->driver);
891 mutex_unlock(&serio_mutex);
892}
893EXPORT_SYMBOL(serio_unregister_driver);
894
895static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
896{
897 serio_pause_rx(serio);
898 serio->drv = drv;
899 serio_continue_rx(serio);
900}
901
902static int serio_bus_match(struct device *dev, struct device_driver *drv)
903{
904 struct serio *serio = to_serio_port(dev);
905 struct serio_driver *serio_drv = to_serio_driver(drv);
906
907 if (serio->manual_bind || serio_drv->manual_bind)
908 return 0;
909
910 return serio_match_port(serio_drv->id_table, serio);
911}
912
913#define SERIO_ADD_UEVENT_VAR(fmt, val...) \
914 do { \
915 int err = add_uevent_var(env, fmt, val); \
916 if (err) \
917 return err; \
918 } while (0)
919
920static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
921{
922 struct serio *serio;
923
924 if (!dev)
925 return -ENODEV;
926
927 serio = to_serio_port(dev);
928
929 SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
930 SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
931 SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
932 SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
933
934 SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
935 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
936
937 if (serio->firmware_id[0])
938 SERIO_ADD_UEVENT_VAR("SERIO_FIRMWARE_ID=%s",
939 serio->firmware_id);
940
941 return 0;
942}
943#undef SERIO_ADD_UEVENT_VAR
944
945#ifdef CONFIG_PM
946static int serio_suspend(struct device *dev)
947{
948 struct serio *serio = to_serio_port(dev);
949
950 serio_cleanup(serio);
951
952 return 0;
953}
954
955static int serio_resume(struct device *dev)
956{
957 struct serio *serio = to_serio_port(dev);
958
959
960
961
962
963 serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
964
965 return 0;
966}
967
968static const struct dev_pm_ops serio_pm_ops = {
969 .suspend = serio_suspend,
970 .resume = serio_resume,
971 .poweroff = serio_suspend,
972 .restore = serio_resume,
973};
974#endif
975
976
977int serio_open(struct serio *serio, struct serio_driver *drv)
978{
979 serio_set_drv(serio, drv);
980
981 if (serio->open && serio->open(serio)) {
982 serio_set_drv(serio, NULL);
983 return -1;
984 }
985 return 0;
986}
987EXPORT_SYMBOL(serio_open);
988
989
990void serio_close(struct serio *serio)
991{
992 if (serio->close)
993 serio->close(serio);
994
995 serio_set_drv(serio, NULL);
996}
997EXPORT_SYMBOL(serio_close);
998
999irqreturn_t serio_interrupt(struct serio *serio,
1000 unsigned char data, unsigned int dfl)
1001{
1002 unsigned long flags;
1003 irqreturn_t ret = IRQ_NONE;
1004
1005 spin_lock_irqsave(&serio->lock, flags);
1006
1007 if (likely(serio->drv)) {
1008 ret = serio->drv->interrupt(serio, data, dfl);
1009 } else if (!dfl && device_is_registered(&serio->dev)) {
1010 serio_rescan(serio);
1011 ret = IRQ_HANDLED;
1012 }
1013
1014 spin_unlock_irqrestore(&serio->lock, flags);
1015
1016 return ret;
1017}
1018EXPORT_SYMBOL(serio_interrupt);
1019
1020static struct bus_type serio_bus = {
1021 .name = "serio",
1022 .drv_groups = serio_driver_groups,
1023 .match = serio_bus_match,
1024 .uevent = serio_uevent,
1025 .probe = serio_driver_probe,
1026 .remove = serio_driver_remove,
1027 .shutdown = serio_shutdown,
1028#ifdef CONFIG_PM
1029 .pm = &serio_pm_ops,
1030#endif
1031};
1032
1033static int __init serio_init(void)
1034{
1035 int error;
1036
1037 error = bus_register(&serio_bus);
1038 if (error) {
1039 pr_err("Failed to register serio bus, error: %d\n", error);
1040 return error;
1041 }
1042
1043 return 0;
1044}
1045
1046static void __exit serio_exit(void)
1047{
1048 bus_unregister(&serio_bus);
1049
1050
1051
1052
1053
1054 cancel_work_sync(&serio_event_work);
1055}
1056
1057subsys_initcall(serio_init);
1058module_exit(serio_exit);
1059