1
2
3
4
5
6
7
8
9
10
11
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/stddef.h>
16#include <linux/module.h>
17#include <linux/serio.h>
18#include <linux/errno.h>
19#include <linux/sched.h>
20#include <linux/slab.h>
21#include <linux/workqueue.h>
22#include <linux/mutex.h>
23
24MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
25MODULE_DESCRIPTION("Serio abstraction core");
26MODULE_LICENSE("GPL");
27
28
29
30
31
32static DEFINE_MUTEX(serio_mutex);
33
34static LIST_HEAD(serio_list);
35
36static void serio_add_port(struct serio *serio);
37static int serio_reconnect_port(struct serio *serio);
38static void serio_disconnect_port(struct serio *serio);
39static void serio_reconnect_subtree(struct serio *serio);
40static void serio_attach_driver(struct serio_driver *drv);
41
42static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
43{
44 int retval;
45
46 mutex_lock(&serio->drv_mutex);
47 retval = drv->connect(serio, drv);
48 mutex_unlock(&serio->drv_mutex);
49
50 return retval;
51}
52
53static int serio_reconnect_driver(struct serio *serio)
54{
55 int retval = -1;
56
57 mutex_lock(&serio->drv_mutex);
58 if (serio->drv && serio->drv->reconnect)
59 retval = serio->drv->reconnect(serio);
60 mutex_unlock(&serio->drv_mutex);
61
62 return retval;
63}
64
65static void serio_disconnect_driver(struct serio *serio)
66{
67 mutex_lock(&serio->drv_mutex);
68 if (serio->drv)
69 serio->drv->disconnect(serio);
70 mutex_unlock(&serio->drv_mutex);
71}
72
73static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
74{
75 while (ids->type || ids->proto) {
76 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
77 (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
78 (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
79 (ids->id == SERIO_ANY || ids->id == serio->id.id))
80 return 1;
81 ids++;
82 }
83 return 0;
84}
85
86
87
88
89
90static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
91{
92 int error;
93
94 if (serio_match_port(drv->id_table, serio)) {
95
96 serio->dev.driver = &drv->driver;
97 if (serio_connect_driver(serio, drv)) {
98 serio->dev.driver = NULL;
99 return -ENODEV;
100 }
101
102 error = device_bind_driver(&serio->dev);
103 if (error) {
104 dev_warn(&serio->dev,
105 "device_bind_driver() failed for %s (%s) and %s, error: %d\n",
106 serio->phys, serio->name,
107 drv->description, error);
108 serio_disconnect_driver(serio);
109 serio->dev.driver = NULL;
110 return error;
111 }
112 }
113 return 0;
114}
115
116static void serio_find_driver(struct serio *serio)
117{
118 int error;
119
120 error = device_attach(&serio->dev);
121 if (error < 0 && error != -EPROBE_DEFER)
122 dev_warn(&serio->dev,
123 "device_attach() failed for %s (%s), error: %d\n",
124 serio->phys, serio->name, error);
125}
126
127
128
129
130
131
132enum serio_event_type {
133 SERIO_RESCAN_PORT,
134 SERIO_RECONNECT_PORT,
135 SERIO_RECONNECT_SUBTREE,
136 SERIO_REGISTER_PORT,
137 SERIO_ATTACH_DRIVER,
138};
139
140struct serio_event {
141 enum serio_event_type type;
142 void *object;
143 struct module *owner;
144 struct list_head node;
145};
146
147static DEFINE_SPINLOCK(serio_event_lock);
148static LIST_HEAD(serio_event_list);
149
150static struct serio_event *serio_get_event(void)
151{
152 struct serio_event *event = NULL;
153 unsigned long flags;
154
155 spin_lock_irqsave(&serio_event_lock, flags);
156
157 if (!list_empty(&serio_event_list)) {
158 event = list_first_entry(&serio_event_list,
159 struct serio_event, node);
160 list_del_init(&event->node);
161 }
162
163 spin_unlock_irqrestore(&serio_event_lock, flags);
164 return event;
165}
166
167static void serio_free_event(struct serio_event *event)
168{
169 module_put(event->owner);
170 kfree(event);
171}
172
173static void serio_remove_duplicate_events(void *object,
174 enum serio_event_type type)
175{
176 struct serio_event *e, *next;
177 unsigned long flags;
178
179 spin_lock_irqsave(&serio_event_lock, flags);
180
181 list_for_each_entry_safe(e, next, &serio_event_list, node) {
182 if (object == e->object) {
183
184
185
186
187
188 if (type != e->type)
189 break;
190
191 list_del_init(&e->node);
192 serio_free_event(e);
193 }
194 }
195
196 spin_unlock_irqrestore(&serio_event_lock, flags);
197}
198
199static void serio_handle_event(struct work_struct *work)
200{
201 struct serio_event *event;
202
203 mutex_lock(&serio_mutex);
204
205 while ((event = serio_get_event())) {
206
207 switch (event->type) {
208
209 case SERIO_REGISTER_PORT:
210 serio_add_port(event->object);
211 break;
212
213 case SERIO_RECONNECT_PORT:
214 serio_reconnect_port(event->object);
215 break;
216
217 case SERIO_RESCAN_PORT:
218 serio_disconnect_port(event->object);
219 serio_find_driver(event->object);
220 break;
221
222 case SERIO_RECONNECT_SUBTREE:
223 serio_reconnect_subtree(event->object);
224 break;
225
226 case SERIO_ATTACH_DRIVER:
227 serio_attach_driver(event->object);
228 break;
229 }
230
231 serio_remove_duplicate_events(event->object, event->type);
232 serio_free_event(event);
233 }
234
235 mutex_unlock(&serio_mutex);
236}
237
238static DECLARE_WORK(serio_event_work, serio_handle_event);
239
240static int serio_queue_event(void *object, struct module *owner,
241 enum serio_event_type event_type)
242{
243 unsigned long flags;
244 struct serio_event *event;
245 int retval = 0;
246
247 spin_lock_irqsave(&serio_event_lock, flags);
248
249
250
251
252
253
254
255
256 list_for_each_entry_reverse(event, &serio_event_list, node) {
257 if (event->object == object) {
258 if (event->type == event_type)
259 goto out;
260 break;
261 }
262 }
263
264 event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
265 if (!event) {
266 pr_err("Not enough memory to queue event %d\n", event_type);
267 retval = -ENOMEM;
268 goto out;
269 }
270
271 if (!try_module_get(owner)) {
272 pr_warn("Can't get module reference, dropping event %d\n",
273 event_type);
274 kfree(event);
275 retval = -EINVAL;
276 goto out;
277 }
278
279 event->type = event_type;
280 event->object = object;
281 event->owner = owner;
282
283 list_add_tail(&event->node, &serio_event_list);
284 queue_work(system_long_wq, &serio_event_work);
285
286out:
287 spin_unlock_irqrestore(&serio_event_lock, flags);
288 return retval;
289}
290
291
292
293
294
295static void serio_remove_pending_events(void *object)
296{
297 struct serio_event *event, *next;
298 unsigned long flags;
299
300 spin_lock_irqsave(&serio_event_lock, flags);
301
302 list_for_each_entry_safe(event, next, &serio_event_list, node) {
303 if (event->object == object) {
304 list_del_init(&event->node);
305 serio_free_event(event);
306 }
307 }
308
309 spin_unlock_irqrestore(&serio_event_lock, flags);
310}
311
312
313
314
315
316
317
318static struct serio *serio_get_pending_child(struct serio *parent)
319{
320 struct serio_event *event;
321 struct serio *serio, *child = NULL;
322 unsigned long flags;
323
324 spin_lock_irqsave(&serio_event_lock, flags);
325
326 list_for_each_entry(event, &serio_event_list, node) {
327 if (event->type == SERIO_REGISTER_PORT) {
328 serio = event->object;
329 if (serio->parent == parent) {
330 child = serio;
331 break;
332 }
333 }
334 }
335
336 spin_unlock_irqrestore(&serio_event_lock, flags);
337 return child;
338}
339
340
341
342
343
344static ssize_t serio_show_description(struct device *dev, struct device_attribute *attr, char *buf)
345{
346 struct serio *serio = to_serio_port(dev);
347 return sprintf(buf, "%s\n", serio->name);
348}
349
350static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
351{
352 struct serio *serio = to_serio_port(dev);
353
354 return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
355 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
356}
357
358static ssize_t type_show(struct device *dev, struct device_attribute *attr, char *buf)
359{
360 struct serio *serio = to_serio_port(dev);
361 return sprintf(buf, "%02x\n", serio->id.type);
362}
363
364static ssize_t proto_show(struct device *dev, struct device_attribute *attr, char *buf)
365{
366 struct serio *serio = to_serio_port(dev);
367 return sprintf(buf, "%02x\n", serio->id.proto);
368}
369
370static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
371{
372 struct serio *serio = to_serio_port(dev);
373 return sprintf(buf, "%02x\n", serio->id.id);
374}
375
376static ssize_t extra_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.extra);
380}
381
382static ssize_t drvctl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
383{
384 struct serio *serio = to_serio_port(dev);
385 struct device_driver *drv;
386 int error;
387
388 error = mutex_lock_interruptible(&serio_mutex);
389 if (error)
390 return error;
391
392 if (!strncmp(buf, "none", count)) {
393 serio_disconnect_port(serio);
394 } else if (!strncmp(buf, "reconnect", count)) {
395 serio_reconnect_subtree(serio);
396 } else if (!strncmp(buf, "rescan", count)) {
397 serio_disconnect_port(serio);
398 serio_find_driver(serio);
399 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
400 } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
401 serio_disconnect_port(serio);
402 error = serio_bind_driver(serio, to_serio_driver(drv));
403 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
404 } else {
405 error = -EINVAL;
406 }
407
408 mutex_unlock(&serio_mutex);
409
410 return error ? error : count;
411}
412
413static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
414{
415 struct serio *serio = to_serio_port(dev);
416 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
417}
418
419static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
420{
421 struct serio *serio = to_serio_port(dev);
422 int retval;
423
424 retval = count;
425 if (!strncmp(buf, "manual", count)) {
426 serio->manual_bind = true;
427 } else if (!strncmp(buf, "auto", count)) {
428 serio->manual_bind = false;
429 } else {
430 retval = -EINVAL;
431 }
432
433 return retval;
434}
435
436static ssize_t firmware_id_show(struct device *dev, struct device_attribute *attr, char *buf)
437{
438 struct serio *serio = to_serio_port(dev);
439
440 return sprintf(buf, "%s\n", serio->firmware_id);
441}
442
443static DEVICE_ATTR_RO(type);
444static DEVICE_ATTR_RO(proto);
445static DEVICE_ATTR_RO(id);
446static DEVICE_ATTR_RO(extra);
447
448static struct attribute *serio_device_id_attrs[] = {
449 &dev_attr_type.attr,
450 &dev_attr_proto.attr,
451 &dev_attr_id.attr,
452 &dev_attr_extra.attr,
453 NULL
454};
455
456static const struct attribute_group serio_id_attr_group = {
457 .name = "id",
458 .attrs = serio_device_id_attrs,
459};
460
461static DEVICE_ATTR_RO(modalias);
462static DEVICE_ATTR_WO(drvctl);
463static DEVICE_ATTR(description, S_IRUGO, serio_show_description, NULL);
464static DEVICE_ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode);
465static DEVICE_ATTR_RO(firmware_id);
466
467static struct attribute *serio_device_attrs[] = {
468 &dev_attr_modalias.attr,
469 &dev_attr_description.attr,
470 &dev_attr_drvctl.attr,
471 &dev_attr_bind_mode.attr,
472 &dev_attr_firmware_id.attr,
473 NULL
474};
475
476static const struct attribute_group serio_device_attr_group = {
477 .attrs = serio_device_attrs,
478};
479
480static const struct attribute_group *serio_device_attr_groups[] = {
481 &serio_id_attr_group,
482 &serio_device_attr_group,
483 NULL
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(-1);
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%lu",
510 (unsigned long)atomic_inc_return(&serio_no));
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 description_show(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}
740static DRIVER_ATTR_RO(description);
741
742static ssize_t bind_mode_show(struct device_driver *drv, char *buf)
743{
744 struct serio_driver *serio_drv = to_serio_driver(drv);
745 return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
746}
747
748static ssize_t bind_mode_store(struct device_driver *drv, const char *buf, size_t count)
749{
750 struct serio_driver *serio_drv = to_serio_driver(drv);
751 int retval;
752
753 retval = count;
754 if (!strncmp(buf, "manual", count)) {
755 serio_drv->manual_bind = true;
756 } else if (!strncmp(buf, "auto", count)) {
757 serio_drv->manual_bind = false;
758 } else {
759 retval = -EINVAL;
760 }
761
762 return retval;
763}
764static DRIVER_ATTR_RW(bind_mode);
765
766static struct attribute *serio_driver_attrs[] = {
767 &driver_attr_description.attr,
768 &driver_attr_bind_mode.attr,
769 NULL,
770};
771ATTRIBUTE_GROUPS(serio_driver);
772
773static int serio_driver_probe(struct device *dev)
774{
775 struct serio *serio = to_serio_port(dev);
776 struct serio_driver *drv = to_serio_driver(dev->driver);
777
778 return serio_connect_driver(serio, drv);
779}
780
781static int serio_driver_remove(struct device *dev)
782{
783 struct serio *serio = to_serio_port(dev);
784
785 serio_disconnect_driver(serio);
786 return 0;
787}
788
789static void serio_cleanup(struct serio *serio)
790{
791 mutex_lock(&serio->drv_mutex);
792 if (serio->drv && serio->drv->cleanup)
793 serio->drv->cleanup(serio);
794 mutex_unlock(&serio->drv_mutex);
795}
796
797static void serio_shutdown(struct device *dev)
798{
799 struct serio *serio = to_serio_port(dev);
800
801 serio_cleanup(serio);
802}
803
804static void serio_attach_driver(struct serio_driver *drv)
805{
806 int error;
807
808 error = driver_attach(&drv->driver);
809 if (error)
810 pr_warn("driver_attach() failed for %s with error %d\n",
811 drv->driver.name, error);
812}
813
814int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
815{
816 bool manual_bind = drv->manual_bind;
817 int error;
818
819 drv->driver.bus = &serio_bus;
820 drv->driver.owner = owner;
821 drv->driver.mod_name = mod_name;
822
823
824
825
826
827 drv->manual_bind = true;
828
829 error = driver_register(&drv->driver);
830 if (error) {
831 pr_err("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#define SERIO_ADD_UEVENT_VAR(fmt, val...) \
896 do { \
897 int err = add_uevent_var(env, fmt, val); \
898 if (err) \
899 return err; \
900 } while (0)
901
902static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
903{
904 struct serio *serio;
905
906 if (!dev)
907 return -ENODEV;
908
909 serio = to_serio_port(dev);
910
911 SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
912 SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
913 SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
914 SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
915
916 SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
917 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
918
919 if (serio->firmware_id[0])
920 SERIO_ADD_UEVENT_VAR("SERIO_FIRMWARE_ID=%s",
921 serio->firmware_id);
922
923 return 0;
924}
925#undef SERIO_ADD_UEVENT_VAR
926
927#ifdef CONFIG_PM
928static int serio_suspend(struct device *dev)
929{
930 struct serio *serio = to_serio_port(dev);
931
932 serio_cleanup(serio);
933
934 return 0;
935}
936
937static int serio_resume(struct device *dev)
938{
939 struct serio *serio = to_serio_port(dev);
940 int error = -ENOENT;
941
942 mutex_lock(&serio->drv_mutex);
943 if (serio->drv && serio->drv->fast_reconnect) {
944 error = serio->drv->fast_reconnect(serio);
945 if (error && error != -ENOENT)
946 dev_warn(dev, "fast reconnect failed with error %d\n",
947 error);
948 }
949 mutex_unlock(&serio->drv_mutex);
950
951 if (error) {
952
953
954
955
956 serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
957 }
958
959 return 0;
960}
961
962static const struct dev_pm_ops serio_pm_ops = {
963 .suspend = serio_suspend,
964 .resume = serio_resume,
965 .poweroff = serio_suspend,
966 .restore = serio_resume,
967};
968#endif
969
970
971int serio_open(struct serio *serio, struct serio_driver *drv)
972{
973 serio_set_drv(serio, drv);
974
975 if (serio->open && serio->open(serio)) {
976 serio_set_drv(serio, NULL);
977 return -1;
978 }
979 return 0;
980}
981EXPORT_SYMBOL(serio_open);
982
983
984void serio_close(struct serio *serio)
985{
986 if (serio->close)
987 serio->close(serio);
988
989 serio_set_drv(serio, NULL);
990}
991EXPORT_SYMBOL(serio_close);
992
993irqreturn_t serio_interrupt(struct serio *serio,
994 unsigned char data, unsigned int dfl)
995{
996 unsigned long flags;
997 irqreturn_t ret = IRQ_NONE;
998
999 spin_lock_irqsave(&serio->lock, flags);
1000
1001 if (likely(serio->drv)) {
1002 ret = serio->drv->interrupt(serio, data, dfl);
1003 } else if (!dfl && device_is_registered(&serio->dev)) {
1004 serio_rescan(serio);
1005 ret = IRQ_HANDLED;
1006 }
1007
1008 spin_unlock_irqrestore(&serio->lock, flags);
1009
1010 return ret;
1011}
1012EXPORT_SYMBOL(serio_interrupt);
1013
1014struct bus_type serio_bus = {
1015 .name = "serio",
1016 .drv_groups = serio_driver_groups,
1017 .match = serio_bus_match,
1018 .uevent = serio_uevent,
1019 .probe = serio_driver_probe,
1020 .remove = serio_driver_remove,
1021 .shutdown = serio_shutdown,
1022#ifdef CONFIG_PM
1023 .pm = &serio_pm_ops,
1024#endif
1025};
1026EXPORT_SYMBOL(serio_bus);
1027
1028static int __init serio_init(void)
1029{
1030 int error;
1031
1032 error = bus_register(&serio_bus);
1033 if (error) {
1034 pr_err("Failed to register serio bus, error: %d\n", error);
1035 return error;
1036 }
1037
1038 return 0;
1039}
1040
1041static void __exit serio_exit(void)
1042{
1043 bus_unregister(&serio_bus);
1044
1045
1046
1047
1048
1049 cancel_work_sync(&serio_event_work);
1050}
1051
1052subsys_initcall(serio_init);
1053module_exit(serio_exit);
1054