Lines Matching refs:serio
14 #include <linux/serio.h>
26 * serio_mutex protects entire serio subsystem and is taken every time
27 * serio port or driver registered or unregistered.
33 static void serio_add_port(struct serio *serio);
34 static int serio_reconnect_port(struct serio *serio);
35 static void serio_disconnect_port(struct serio *serio);
36 static void serio_reconnect_subtree(struct serio *serio);
39 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
43 mutex_lock(&serio->drv_mutex);
44 retval = drv->connect(serio, drv);
45 mutex_unlock(&serio->drv_mutex);
50 static int serio_reconnect_driver(struct serio *serio)
54 mutex_lock(&serio->drv_mutex);
55 if (serio->drv && serio->drv->reconnect)
56 retval = serio->drv->reconnect(serio);
57 mutex_unlock(&serio->drv_mutex);
62 static void serio_disconnect_driver(struct serio *serio)
64 mutex_lock(&serio->drv_mutex);
65 if (serio->drv)
66 serio->drv->disconnect(serio);
67 mutex_unlock(&serio->drv_mutex);
70 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
73 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
74 (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
75 (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
76 (ids->id == SERIO_ANY || ids->id == serio->id.id))
84 * Basic serio -> driver core mappings
87 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
91 if (serio_match_port(drv->id_table, serio)) {
93 serio->dev.driver = &drv->driver;
94 if (serio_connect_driver(serio, drv)) {
95 serio->dev.driver = NULL;
99 error = device_bind_driver(&serio->dev);
101 dev_warn(&serio->dev,
103 serio->phys, serio->name,
105 serio_disconnect_driver(serio);
106 serio->dev.driver = NULL;
113 static void serio_find_driver(struct serio *serio)
117 error = device_attach(&serio->dev);
119 dev_warn(&serio->dev,
121 serio->phys, serio->name, error);
247 * Scan event list for the other events for the same serio port,
290 * object, be it serio port or driver.
310 * Locate child serio port (if any) that has not been fully registered yet.
315 static struct serio *serio_get_pending_child(struct serio *parent)
318 struct serio *serio, *child = NULL;
325 serio = event->object;
326 if (serio->parent == parent) {
327 child = serio;
343 struct serio *serio = to_serio_port(dev);
344 return sprintf(buf, "%s\n", serio->name);
349 struct serio *serio = to_serio_port(dev);
351 return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
352 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
357 struct serio *serio = to_serio_port(dev);
358 return sprintf(buf, "%02x\n", serio->id.type);
363 struct serio *serio = to_serio_port(dev);
364 return sprintf(buf, "%02x\n", serio->id.proto);
369 struct serio *serio = to_serio_port(dev);
370 return sprintf(buf, "%02x\n", serio->id.id);
375 struct serio *serio = to_serio_port(dev);
376 return sprintf(buf, "%02x\n", serio->id.extra);
381 struct serio *serio = to_serio_port(dev);
390 serio_disconnect_port(serio);
392 serio_reconnect_subtree(serio);
394 serio_disconnect_port(serio);
395 serio_find_driver(serio);
396 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
398 serio_disconnect_port(serio);
399 error = serio_bind_driver(serio, to_serio_driver(drv));
400 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
412 struct serio *serio = to_serio_port(dev);
413 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
418 struct serio *serio = to_serio_port(dev);
423 serio->manual_bind = true;
425 serio->manual_bind = false;
435 struct serio *serio = to_serio_port(dev);
437 return sprintf(buf, "%s\n", serio->firmware_id);
485 struct serio *serio = to_serio_port(dev);
487 kfree(serio);
492 * Prepare serio port for registration.
494 static void serio_init_port(struct serio *serio)
500 INIT_LIST_HEAD(&serio->node);
501 INIT_LIST_HEAD(&serio->child_node);
502 INIT_LIST_HEAD(&serio->children);
503 spin_lock_init(&serio->lock);
504 mutex_init(&serio->drv_mutex);
505 device_initialize(&serio->dev);
506 dev_set_name(&serio->dev, "serio%lu",
508 serio->dev.bus = &serio_bus;
509 serio->dev.release = serio_release_port;
510 serio->dev.groups = serio_device_attr_groups;
511 if (serio->parent) {
512 serio->dev.parent = &serio->parent->dev;
513 serio->depth = serio->parent->depth + 1;
515 serio->depth = 0;
516 lockdep_set_subclass(&serio->lock, serio->depth);
520 * Complete serio port registration.
523 static void serio_add_port(struct serio *serio)
525 struct serio *parent = serio->parent;
530 list_add_tail(&serio->child_node, &parent->children);
534 list_add_tail(&serio->node, &serio_list);
536 if (serio->start)
537 serio->start(serio);
539 error = device_add(&serio->dev);
541 dev_err(&serio->dev,
543 serio->phys, serio->name, error);
550 static void serio_destroy_port(struct serio *serio)
552 struct serio *child;
554 while ((child = serio_get_pending_child(serio)) != NULL) {
559 if (serio->stop)
560 serio->stop(serio);
562 if (serio->parent) {
563 serio_pause_rx(serio->parent);
564 list_del_init(&serio->child_node);
565 serio_continue_rx(serio->parent);
566 serio->parent = NULL;
569 if (device_is_registered(&serio->dev))
570 device_del(&serio->dev);
572 list_del_init(&serio->node);
573 serio_remove_pending_events(serio);
574 put_device(&serio->dev);
578 * Reconnect serio port (re-initialize attached device).
583 static int serio_reconnect_port(struct serio *serio)
585 int error = serio_reconnect_driver(serio);
588 serio_disconnect_port(serio);
589 serio_find_driver(serio);
596 * Reconnect serio port and all its children (re-initialize attached
599 static void serio_reconnect_subtree(struct serio *root)
601 struct serio *s = root;
613 struct serio, child_node);
624 struct serio *parent = s->parent;
628 struct serio, child_node);
641 static void serio_disconnect_port(struct serio *serio)
643 struct serio *s = serio;
649 while (!list_empty(&serio->children)) {
654 struct serio, child_node);
660 if (s != serio) {
661 struct serio *parent = s->parent;
673 device_release_driver(&serio->dev);
676 void serio_rescan(struct serio *serio)
678 serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
682 void serio_reconnect(struct serio *serio)
684 serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE);
692 void __serio_register_port(struct serio *serio, struct module *owner)
694 serio_init_port(serio);
695 serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
700 * Synchronously unregisters serio port.
702 void serio_unregister_port(struct serio *serio)
705 serio_disconnect_port(serio);
706 serio_destroy_port(serio);
714 void serio_unregister_child_port(struct serio *serio)
716 struct serio *s, *next;
719 list_for_each_entry_safe(s, next, &serio->children, child_node) {
772 struct serio *serio = to_serio_port(dev);
775 return serio_connect_driver(serio, drv);
780 struct serio *serio = to_serio_port(dev);
782 serio_disconnect_driver(serio);
785 static void serio_cleanup(struct serio *serio)
787 mutex_lock(&serio->drv_mutex);
788 if (serio->drv && serio->drv->cleanup)
789 serio->drv->cleanup(serio);
790 mutex_unlock(&serio->drv_mutex);
795 struct serio *serio = to_serio_port(dev);
797 serio_cleanup(serio);
851 struct serio *serio;
859 list_for_each_entry(serio, &serio_list, node) {
860 if (serio->drv == drv) {
861 serio_disconnect_port(serio);
862 serio_find_driver(serio);
873 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
875 serio_pause_rx(serio);
876 serio->drv = drv;
877 serio_continue_rx(serio);
882 struct serio *serio = to_serio_port(dev);
885 if (serio->manual_bind || serio_drv->manual_bind)
888 return serio_match_port(serio_drv->id_table, serio);
900 const struct serio *serio;
905 serio = to_serio_port(dev);
907 SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
908 SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
909 SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
910 SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
912 SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
913 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
915 if (serio->firmware_id[0])
917 serio->firmware_id);
926 struct serio *serio = to_serio_port(dev);
928 serio_cleanup(serio);
935 struct serio *serio = to_serio_port(dev);
938 mutex_lock(&serio->drv_mutex);
939 if (serio->drv && serio->drv->fast_reconnect) {
940 error = serio->drv->fast_reconnect(serio);
945 mutex_unlock(&serio->drv_mutex);
952 serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
967 int serio_open(struct serio *serio, struct serio_driver *drv)
969 serio_set_drv(serio, drv);
971 if (serio->open && serio->open(serio)) {
972 serio_set_drv(serio, NULL);
980 void serio_close(struct serio *serio)
982 if (serio->close)
983 serio->close(serio);
985 serio_set_drv(serio, NULL);
989 irqreturn_t serio_interrupt(struct serio *serio,
995 spin_lock_irqsave(&serio->lock, flags);
997 if (likely(serio->drv)) {
998 ret = serio->drv->interrupt(serio, data, dfl);
999 } else if (!dfl && device_is_registered(&serio->dev)) {
1000 serio_rescan(serio);
1004 spin_unlock_irqrestore(&serio->lock, flags);
1011 .name = "serio",
1030 pr_err("Failed to register serio bus, error: %d\n", error);