Lines Matching refs:serio
17 #include <linux/serio.h>
29 * serio_mutex protects entire serio subsystem and is taken every time
30 * serio port or driver registered or unregistered.
36 static void serio_add_port(struct serio *serio);
37 static int serio_reconnect_port(struct serio *serio);
38 static void serio_disconnect_port(struct serio *serio);
39 static void serio_reconnect_subtree(struct serio *serio);
42 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
46 mutex_lock(&serio->drv_mutex);
47 retval = drv->connect(serio, drv);
48 mutex_unlock(&serio->drv_mutex);
53 static int serio_reconnect_driver(struct serio *serio)
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);
65 static void serio_disconnect_driver(struct serio *serio)
67 mutex_lock(&serio->drv_mutex);
68 if (serio->drv)
69 serio->drv->disconnect(serio);
70 mutex_unlock(&serio->drv_mutex);
73 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
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))
87 * Basic serio -> driver core mappings
90 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
94 if (serio_match_port(drv->id_table, serio)) {
96 serio->dev.driver = &drv->driver;
97 if (serio_connect_driver(serio, drv)) {
98 serio->dev.driver = NULL;
102 error = device_bind_driver(&serio->dev);
104 dev_warn(&serio->dev,
106 serio->phys, serio->name,
108 serio_disconnect_driver(serio);
109 serio->dev.driver = NULL;
116 static void serio_find_driver(struct serio *serio)
120 error = device_attach(&serio->dev);
122 dev_warn(&serio->dev,
124 serio->phys, serio->name, error);
250 * Scan event list for the other events for the same serio port,
293 * object, be it serio port or driver.
313 * Locate child serio port (if any) that has not been fully registered yet.
318 static struct serio *serio_get_pending_child(struct serio *parent)
321 struct serio *serio, *child = NULL;
328 serio = event->object;
329 if (serio->parent == parent) {
330 child = serio;
346 struct serio *serio = to_serio_port(dev);
347 return sprintf(buf, "%s\n", serio->name);
352 struct serio *serio = to_serio_port(dev);
354 return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
355 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
360 struct serio *serio = to_serio_port(dev);
361 return sprintf(buf, "%02x\n", serio->id.type);
366 struct serio *serio = to_serio_port(dev);
367 return sprintf(buf, "%02x\n", serio->id.proto);
372 struct serio *serio = to_serio_port(dev);
373 return sprintf(buf, "%02x\n", serio->id.id);
378 struct serio *serio = to_serio_port(dev);
379 return sprintf(buf, "%02x\n", serio->id.extra);
384 struct serio *serio = to_serio_port(dev);
393 serio_disconnect_port(serio);
395 serio_reconnect_subtree(serio);
397 serio_disconnect_port(serio);
398 serio_find_driver(serio);
399 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
401 serio_disconnect_port(serio);
402 error = serio_bind_driver(serio, to_serio_driver(drv));
403 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
415 struct serio *serio = to_serio_port(dev);
416 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
421 struct serio *serio = to_serio_port(dev);
426 serio->manual_bind = true;
428 serio->manual_bind = false;
438 struct serio *serio = to_serio_port(dev);
440 return sprintf(buf, "%s\n", serio->firmware_id);
488 struct serio *serio = to_serio_port(dev);
490 kfree(serio);
495 * Prepare serio port for registration.
497 static void serio_init_port(struct serio *serio)
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",
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;
518 serio->depth = 0;
519 lockdep_set_subclass(&serio->lock, serio->depth);
523 * Complete serio port registration.
526 static void serio_add_port(struct serio *serio)
528 struct serio *parent = serio->parent;
533 list_add_tail(&serio->child_node, &parent->children);
537 list_add_tail(&serio->node, &serio_list);
539 if (serio->start)
540 serio->start(serio);
542 error = device_add(&serio->dev);
544 dev_err(&serio->dev,
546 serio->phys, serio->name, error);
553 static void serio_destroy_port(struct serio *serio)
555 struct serio *child;
557 while ((child = serio_get_pending_child(serio)) != NULL) {
562 if (serio->stop)
563 serio->stop(serio);
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;
572 if (device_is_registered(&serio->dev))
573 device_del(&serio->dev);
575 list_del_init(&serio->node);
576 serio_remove_pending_events(serio);
577 put_device(&serio->dev);
581 * Reconnect serio port (re-initialize attached device).
586 static int serio_reconnect_port(struct serio *serio)
588 int error = serio_reconnect_driver(serio);
591 serio_disconnect_port(serio);
592 serio_find_driver(serio);
599 * Reconnect serio port and all its children (re-initialize attached
602 static void serio_reconnect_subtree(struct serio *root)
604 struct serio *s = root;
616 struct serio, child_node);
627 struct serio *parent = s->parent;
631 struct serio, child_node);
644 static void serio_disconnect_port(struct serio *serio)
646 struct serio *s = serio;
652 while (!list_empty(&serio->children)) {
657 struct serio, child_node);
663 if (s != serio) {
664 struct serio *parent = s->parent;
676 device_release_driver(&serio->dev);
679 void serio_rescan(struct serio *serio)
681 serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
685 void serio_reconnect(struct serio *serio)
687 serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE);
695 void __serio_register_port(struct serio *serio, struct module *owner)
697 serio_init_port(serio);
698 serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
703 * Synchronously unregisters serio port.
705 void serio_unregister_port(struct serio *serio)
708 serio_disconnect_port(serio);
709 serio_destroy_port(serio);
717 void serio_unregister_child_port(struct serio *serio)
719 struct serio *s, *next;
722 list_for_each_entry_safe(s, next, &serio->children, child_node) {
775 struct serio *serio = to_serio_port(dev);
778 return serio_connect_driver(serio, drv);
783 struct serio *serio = to_serio_port(dev);
785 serio_disconnect_driver(serio);
789 static void serio_cleanup(struct serio *serio)
791 mutex_lock(&serio->drv_mutex);
792 if (serio->drv && serio->drv->cleanup)
793 serio->drv->cleanup(serio);
794 mutex_unlock(&serio->drv_mutex);
799 struct serio *serio = to_serio_port(dev);
801 serio_cleanup(serio);
855 struct serio *serio;
863 list_for_each_entry(serio, &serio_list, node) {
864 if (serio->drv == drv) {
865 serio_disconnect_port(serio);
866 serio_find_driver(serio);
877 static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
879 serio_pause_rx(serio);
880 serio->drv = drv;
881 serio_continue_rx(serio);
886 struct serio *serio = to_serio_port(dev);
889 if (serio->manual_bind || serio_drv->manual_bind)
892 return serio_match_port(serio_drv->id_table, serio);
904 struct serio *serio;
909 serio = to_serio_port(dev);
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);
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);
919 if (serio->firmware_id[0])
921 serio->firmware_id);
930 struct serio *serio = to_serio_port(dev);
932 serio_cleanup(serio);
939 struct serio *serio = to_serio_port(dev);
942 mutex_lock(&serio->drv_mutex);
943 if (serio->drv && serio->drv->fast_reconnect) {
944 error = serio->drv->fast_reconnect(serio);
949 mutex_unlock(&serio->drv_mutex);
956 serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
971 int serio_open(struct serio *serio, struct serio_driver *drv)
973 serio_set_drv(serio, drv);
975 if (serio->open && serio->open(serio)) {
976 serio_set_drv(serio, NULL);
984 void serio_close(struct serio *serio)
986 if (serio->close)
987 serio->close(serio);
989 serio_set_drv(serio, NULL);
993 irqreturn_t serio_interrupt(struct serio *serio,
999 spin_lock_irqsave(&serio->lock, flags);
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);
1008 spin_unlock_irqrestore(&serio->lock, flags);
1015 .name = "serio",
1034 pr_err("Failed to register serio bus, error: %d\n", error);