| /linux-4.1.27/drivers/input/serio/ |
| H A D | serio.c | 33 #include <linux/serio.h>
45 * serio_mutex protects entire serio subsystem and is taken every time
46 * serio port or driver registered or unregistered.
54 static void serio_add_port(struct serio *serio);
55 static int serio_reconnect_port(struct serio *serio);
56 static void serio_disconnect_port(struct serio *serio);
57 static void serio_reconnect_subtree(struct serio *serio);
60 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv) serio_connect_driver() argument
64 mutex_lock(&serio->drv_mutex); serio_connect_driver()
65 retval = drv->connect(serio, drv); serio_connect_driver()
66 mutex_unlock(&serio->drv_mutex); serio_connect_driver()
71 static int serio_reconnect_driver(struct serio *serio) serio_reconnect_driver() argument
75 mutex_lock(&serio->drv_mutex); serio_reconnect_driver()
76 if (serio->drv && serio->drv->reconnect) serio_reconnect_driver()
77 retval = serio->drv->reconnect(serio); serio_reconnect_driver()
78 mutex_unlock(&serio->drv_mutex); serio_reconnect_driver()
83 static void serio_disconnect_driver(struct serio *serio) serio_disconnect_driver() argument
85 mutex_lock(&serio->drv_mutex); serio_disconnect_driver()
86 if (serio->drv) serio_disconnect_driver()
87 serio->drv->disconnect(serio); serio_disconnect_driver()
88 mutex_unlock(&serio->drv_mutex); serio_disconnect_driver()
91 static int serio_match_port(const struct serio_device_id *ids, struct serio *serio) serio_match_port() argument
94 if ((ids->type == SERIO_ANY || ids->type == serio->id.type) && serio_match_port()
95 (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) && serio_match_port()
96 (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) && serio_match_port()
97 (ids->id == SERIO_ANY || ids->id == serio->id.id)) serio_match_port()
105 * Basic serio -> driver core mappings
108 static int serio_bind_driver(struct serio *serio, struct serio_driver *drv) serio_bind_driver() argument
112 if (serio_match_port(drv->id_table, serio)) { serio_bind_driver()
114 serio->dev.driver = &drv->driver; serio_bind_driver()
115 if (serio_connect_driver(serio, drv)) { serio_bind_driver()
116 serio->dev.driver = NULL; serio_bind_driver()
120 error = device_bind_driver(&serio->dev); serio_bind_driver()
122 dev_warn(&serio->dev, serio_bind_driver()
124 serio->phys, serio->name, serio_bind_driver()
126 serio_disconnect_driver(serio); serio_bind_driver()
127 serio->dev.driver = NULL; serio_bind_driver()
134 static void serio_find_driver(struct serio *serio) serio_find_driver() argument
138 error = device_attach(&serio->dev); serio_find_driver()
140 dev_warn(&serio->dev, serio_find_driver()
142 serio->phys, serio->name, error); serio_find_driver()
268 * Scan event list for the other events for the same serio port, serio_queue_event()
311 * object, be it serio port or driver.
331 * Locate child serio port (if any) that has not been fully registered yet.
336 static struct serio *serio_get_pending_child(struct serio *parent) serio_get_pending_child()
339 struct serio *serio, *child = NULL; serio_get_pending_child() local
346 serio = event->object; serio_get_pending_child()
347 if (serio->parent == parent) { serio_get_pending_child()
348 child = serio; serio_get_pending_child()
364 struct serio *serio = to_serio_port(dev); serio_show_description() local
365 return sprintf(buf, "%s\n", serio->name); serio_show_description()
370 struct serio *serio = to_serio_port(dev); modalias_show() local
372 return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n", modalias_show()
373 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra); modalias_show()
378 struct serio *serio = to_serio_port(dev); type_show() local
379 return sprintf(buf, "%02x\n", serio->id.type); type_show()
384 struct serio *serio = to_serio_port(dev); proto_show() local
385 return sprintf(buf, "%02x\n", serio->id.proto); proto_show()
390 struct serio *serio = to_serio_port(dev); id_show() local
391 return sprintf(buf, "%02x\n", serio->id.id); id_show()
396 struct serio *serio = to_serio_port(dev); extra_show() local
397 return sprintf(buf, "%02x\n", serio->id.extra); extra_show()
402 struct serio *serio = to_serio_port(dev); drvctl_store() local
411 serio_disconnect_port(serio); drvctl_store()
413 serio_reconnect_subtree(serio); drvctl_store()
415 serio_disconnect_port(serio); drvctl_store()
416 serio_find_driver(serio); drvctl_store()
417 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT); drvctl_store()
419 serio_disconnect_port(serio); drvctl_store()
420 error = serio_bind_driver(serio, to_serio_driver(drv)); drvctl_store()
421 serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT); drvctl_store()
433 struct serio *serio = to_serio_port(dev); serio_show_bind_mode() local
434 return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto"); serio_show_bind_mode()
439 struct serio *serio = to_serio_port(dev); serio_set_bind_mode() local
444 serio->manual_bind = true; serio_set_bind_mode()
446 serio->manual_bind = false; serio_set_bind_mode()
456 struct serio *serio = to_serio_port(dev); firmware_id_show() local
458 return sprintf(buf, "%s\n", serio->firmware_id); firmware_id_show()
506 struct serio *serio = to_serio_port(dev); serio_release_port() local
508 kfree(serio); serio_release_port()
513 * Prepare serio port for registration.
515 static void serio_init_port(struct serio *serio) serio_init_port() argument
521 INIT_LIST_HEAD(&serio->node); serio_init_port()
522 INIT_LIST_HEAD(&serio->child_node); serio_init_port()
523 INIT_LIST_HEAD(&serio->children); serio_init_port()
524 spin_lock_init(&serio->lock); serio_init_port()
525 mutex_init(&serio->drv_mutex); serio_init_port()
526 device_initialize(&serio->dev); serio_init_port()
527 dev_set_name(&serio->dev, "serio%lu", serio_init_port()
529 serio->dev.bus = &serio_bus; serio_init_port()
530 serio->dev.release = serio_release_port; serio_init_port()
531 serio->dev.groups = serio_device_attr_groups; serio_init_port()
532 if (serio->parent) { serio_init_port()
533 serio->dev.parent = &serio->parent->dev; serio_init_port()
534 serio->depth = serio->parent->depth + 1; serio_init_port()
536 serio->depth = 0; serio_init_port()
537 lockdep_set_subclass(&serio->lock, serio->depth); serio_init_port()
541 * Complete serio port registration.
544 static void serio_add_port(struct serio *serio) serio_add_port() argument
546 struct serio *parent = serio->parent; serio_add_port()
551 list_add_tail(&serio->child_node, &parent->children); serio_add_port()
555 list_add_tail(&serio->node, &serio_list); serio_add_port()
557 if (serio->start) serio_add_port()
558 serio->start(serio); serio_add_port()
560 error = device_add(&serio->dev); serio_add_port()
562 dev_err(&serio->dev, serio_add_port()
564 serio->phys, serio->name, error); serio_add_port()
571 static void serio_destroy_port(struct serio *serio) serio_destroy_port() argument
573 struct serio *child; serio_destroy_port()
575 while ((child = serio_get_pending_child(serio)) != NULL) { serio_destroy_port()
580 if (serio->stop) serio_destroy_port()
581 serio->stop(serio); serio_destroy_port()
583 if (serio->parent) { serio_destroy_port()
584 serio_pause_rx(serio->parent); serio_destroy_port()
585 list_del_init(&serio->child_node); serio_destroy_port()
586 serio_continue_rx(serio->parent); serio_destroy_port()
587 serio->parent = NULL; serio_destroy_port()
590 if (device_is_registered(&serio->dev)) serio_destroy_port()
591 device_del(&serio->dev); serio_destroy_port()
593 list_del_init(&serio->node); serio_destroy_port()
594 serio_remove_pending_events(serio); serio_destroy_port()
595 put_device(&serio->dev); serio_destroy_port()
599 * Reconnect serio port (re-initialize attached device).
604 static int serio_reconnect_port(struct serio *serio) serio_reconnect_port() argument
606 int error = serio_reconnect_driver(serio); serio_reconnect_port()
609 serio_disconnect_port(serio); serio_reconnect_port()
610 serio_find_driver(serio); serio_reconnect_port()
617 * Reconnect serio port and all its children (re-initialize attached
620 static void serio_reconnect_subtree(struct serio *root) serio_reconnect_subtree()
622 struct serio *s = root; serio_reconnect_subtree()
634 struct serio, child_node); serio_reconnect_subtree()
645 struct serio *parent = s->parent; serio_reconnect_subtree()
649 struct serio, child_node); serio_reconnect_subtree()
662 static void serio_disconnect_port(struct serio *serio) serio_disconnect_port() argument
664 struct serio *s = serio; serio_disconnect_port()
670 while (!list_empty(&serio->children)) { serio_disconnect_port()
675 struct serio, child_node); serio_disconnect_port()
681 if (s != serio) { serio_disconnect_port()
682 struct serio *parent = s->parent; serio_disconnect_port()
694 device_release_driver(&serio->dev); serio_disconnect_port()
697 void serio_rescan(struct serio *serio) serio_rescan() argument
699 serio_queue_event(serio, NULL, SERIO_RESCAN_PORT); serio_rescan()
703 void serio_reconnect(struct serio *serio) serio_reconnect() argument
705 serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE); serio_reconnect()
713 void __serio_register_port(struct serio *serio, struct module *owner) __serio_register_port() argument
715 serio_init_port(serio); __serio_register_port()
716 serio_queue_event(serio, owner, SERIO_REGISTER_PORT); __serio_register_port()
721 * Synchronously unregisters serio port.
723 void serio_unregister_port(struct serio *serio) serio_unregister_port() argument
726 serio_disconnect_port(serio); serio_unregister_port()
727 serio_destroy_port(serio); serio_unregister_port()
735 void serio_unregister_child_port(struct serio *serio) serio_unregister_child_port() argument
737 struct serio *s, *next; serio_unregister_child_port()
740 list_for_each_entry_safe(s, next, &serio->children, child_node) { serio_unregister_child_port()
793 struct serio *serio = to_serio_port(dev); serio_driver_probe() local
796 return serio_connect_driver(serio, drv); serio_driver_probe()
801 struct serio *serio = to_serio_port(dev); serio_driver_remove() local
803 serio_disconnect_driver(serio); serio_driver_remove()
807 static void serio_cleanup(struct serio *serio) serio_cleanup() argument
809 mutex_lock(&serio->drv_mutex); serio_cleanup()
810 if (serio->drv && serio->drv->cleanup) serio_cleanup()
811 serio->drv->cleanup(serio); serio_cleanup()
812 mutex_unlock(&serio->drv_mutex); serio_cleanup()
817 struct serio *serio = to_serio_port(dev); serio_shutdown() local
819 serio_cleanup(serio); serio_shutdown()
873 struct serio *serio; serio_unregister_driver() local
881 list_for_each_entry(serio, &serio_list, node) { serio_unregister_driver()
882 if (serio->drv == drv) { serio_unregister_driver()
883 serio_disconnect_port(serio); serio_unregister_driver()
884 serio_find_driver(serio); serio_unregister_driver()
895 static void serio_set_drv(struct serio *serio, struct serio_driver *drv) serio_set_drv() argument
897 serio_pause_rx(serio); serio_set_drv()
898 serio->drv = drv; serio_set_drv()
899 serio_continue_rx(serio); serio_set_drv()
904 struct serio *serio = to_serio_port(dev); serio_bus_match() local
907 if (serio->manual_bind || serio_drv->manual_bind) serio_bus_match()
910 return serio_match_port(serio_drv->id_table, serio); serio_bus_match()
922 struct serio *serio; serio_uevent() local
927 serio = to_serio_port(dev); serio_uevent()
929 SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type); serio_uevent()
930 SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto); serio_uevent()
931 SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id); serio_uevent()
932 SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra); serio_uevent()
934 SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X", serio_uevent()
935 serio->id.type, serio->id.proto, serio->id.id, serio->id.extra); serio_uevent()
937 if (serio->firmware_id[0]) serio_uevent()
939 serio->firmware_id); serio_uevent()
948 struct serio *serio = to_serio_port(dev); serio_suspend() local
950 serio_cleanup(serio); serio_suspend()
957 struct serio *serio = to_serio_port(dev); serio_resume() local
963 serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT); serio_resume()
977 int serio_open(struct serio *serio, struct serio_driver *drv) serio_open() argument
979 serio_set_drv(serio, drv); serio_open()
981 if (serio->open && serio->open(serio)) { serio_open()
982 serio_set_drv(serio, NULL); serio_open()
990 void serio_close(struct serio *serio) serio_close() argument
992 if (serio->close) serio_close()
993 serio->close(serio); serio_close()
995 serio_set_drv(serio, NULL); serio_close()
999 irqreturn_t serio_interrupt(struct serio *serio, serio_interrupt() argument
1005 spin_lock_irqsave(&serio->lock, flags); serio_interrupt()
1007 if (likely(serio->drv)) { serio_interrupt()
1008 ret = serio->drv->interrupt(serio, data, dfl); serio_interrupt()
1009 } else if (!dfl && device_is_registered(&serio->dev)) { serio_interrupt()
1010 serio_rescan(serio); serio_interrupt()
1014 spin_unlock_irqrestore(&serio->lock, flags); serio_interrupt()
1021 .name = "serio",
1039 pr_err("Failed to register serio bus, error: %d\n", error); serio_init()
|
| H A D | ps2mult.c | 15 #include <linux/serio.h>
29 struct serio *serio; member in struct:ps2mult_port
39 struct serio *mx_serio;
65 MODULE_DEVICE_TABLE(serio, ps2mult_serio_ids);
69 struct serio *mx_serio = psm->mx_serio; ps2mult_select_port()
76 static int ps2mult_serio_write(struct serio *serio, unsigned char data) ps2mult_serio_write() argument
78 struct serio *mx_port = serio->parent; ps2mult_serio_write()
80 struct ps2mult_port *port = serio->port_data; ps2mult_serio_write()
91 dev_dbg(&serio->dev, ps2mult_serio_write()
104 static int ps2mult_serio_start(struct serio *serio) ps2mult_serio_start() argument
106 struct ps2mult *psm = serio_get_drvdata(serio->parent); ps2mult_serio_start()
107 struct ps2mult_port *port = serio->port_data; ps2mult_serio_start()
117 static void ps2mult_serio_stop(struct serio *serio) ps2mult_serio_stop() argument
119 struct ps2mult *psm = serio_get_drvdata(serio->parent); ps2mult_serio_stop()
120 struct ps2mult_port *port = serio->port_data; ps2mult_serio_stop()
130 struct serio *mx_serio = psm->mx_serio; ps2mult_create_port()
131 struct serio *serio; ps2mult_create_port() local
133 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); ps2mult_create_port()
134 if (!serio) ps2mult_create_port()
137 strlcpy(serio->name, "TQC PS/2 Multiplexer", sizeof(serio->name)); ps2mult_create_port()
138 snprintf(serio->phys, sizeof(serio->phys), ps2mult_create_port()
140 serio->id.type = SERIO_8042; ps2mult_create_port()
141 serio->write = ps2mult_serio_write; ps2mult_create_port()
142 serio->start = ps2mult_serio_start; ps2mult_create_port()
143 serio->stop = ps2mult_serio_stop; ps2mult_create_port()
144 serio->parent = psm->mx_serio; ps2mult_create_port()
145 serio->port_data = &psm->ports[i]; ps2mult_create_port()
147 psm->ports[i].serio = serio; ps2mult_create_port()
166 static int ps2mult_connect(struct serio *serio, struct serio_driver *drv) ps2mult_connect() argument
172 if (!serio->write) ps2mult_connect()
180 psm->mx_serio = serio; ps2mult_connect()
191 serio_set_drvdata(serio, psm); ps2mult_connect()
192 error = serio_open(serio, drv); ps2mult_connect()
199 struct serio *s = psm->ports[i].serio; ps2mult_connect()
201 dev_info(&serio->dev, "%s port at %s\n", s->name, serio->phys); ps2mult_connect()
209 kfree(psm->ports[i].serio); ps2mult_connect()
214 static void ps2mult_disconnect(struct serio *serio) ps2mult_disconnect() argument
216 struct ps2mult *psm = serio_get_drvdata(serio); ps2mult_disconnect()
218 /* Note that serio core already take care of children ports */ ps2mult_disconnect()
219 serio_write(serio, PS2MULT_SESSION_END); ps2mult_disconnect()
220 serio_close(serio); ps2mult_disconnect()
223 serio_set_drvdata(serio, NULL); ps2mult_disconnect()
226 static int ps2mult_reconnect(struct serio *serio) ps2mult_reconnect() argument
228 struct ps2mult *psm = serio_get_drvdata(serio); ps2mult_reconnect()
235 static irqreturn_t ps2mult_interrupt(struct serio *serio, ps2mult_interrupt() argument
238 struct ps2mult *psm = serio_get_drvdata(serio); ps2mult_interrupt()
242 dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, dfl); ps2mult_interrupt()
250 serio_interrupt(in_port->serio, data, dfl); ps2mult_interrupt()
256 dev_dbg(&serio->dev, "ESCAPE\n"); ps2mult_interrupt()
261 dev_dbg(&serio->dev, "BSYNC\n"); ps2mult_interrupt()
266 dev_dbg(&serio->dev, "SS\n"); ps2mult_interrupt()
270 dev_dbg(&serio->dev, "SE\n"); ps2mult_interrupt()
274 dev_dbg(&serio->dev, "KB\n"); ps2mult_interrupt()
279 dev_dbg(&serio->dev, "MS\n"); ps2mult_interrupt()
286 serio_interrupt(in_port->serio, data, dfl); ps2mult_interrupt()
|
| H A D | serio_raw.c | 2 * Raw serio device providing access to a raw byte stream from underlying
3 * serio port. Closely emulates behavior of pre-2.6 /dev/psaux device
17 #include <linux/serio.h>
24 #define DRIVER_DESC "Raw serio driver"
37 struct serio *serio; member in struct:serio_raw
109 serio_pause_rx(serio_raw->serio); serio_raw_open()
111 serio_continue_rx(serio_raw->serio); serio_raw_open()
123 put_device(&serio_raw->serio->dev); serio_raw_free()
132 serio_pause_rx(serio_raw->serio); serio_raw_release()
134 serio_continue_rx(serio_raw->serio); serio_raw_release()
147 serio_pause_rx(serio_raw->serio); serio_raw_fetch_byte()
155 serio_continue_rx(serio_raw->serio); serio_raw_fetch_byte()
227 if (serio_write(serio_raw->serio, c)) { serio_raw_write()
270 * Interface with serio port *
273 static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data, serio_raw_interrupt() argument
276 struct serio_raw *serio_raw = serio_get_drvdata(serio); serio_raw_interrupt()
280 /* we are holding serio->lock here so we are protected */ serio_raw_interrupt()
293 static int serio_raw_connect(struct serio *serio, struct serio_driver *drv) serio_raw_connect() argument
301 dev_dbg(&serio->dev, "can't allocate memory for a device\n"); serio_raw_connect()
311 serio_raw->serio = serio; serio_raw_connect()
312 get_device(&serio->dev); serio_raw_connect()
314 serio_set_drvdata(serio, serio_raw); serio_raw_connect()
316 err = serio_open(serio, drv); serio_raw_connect()
329 serio_raw->dev.parent = &serio->dev; serio_raw_connect()
339 dev_err(&serio->dev, serio_raw_connect()
341 serio->phys); serio_raw_connect()
345 dev_info(&serio->dev, "raw access enabled on %s (%s, minor %d)\n", serio_raw_connect()
346 serio->phys, serio_raw->name, serio_raw->dev.minor); serio_raw_connect()
352 serio_close(serio); serio_raw_connect()
354 serio_set_drvdata(serio, NULL); serio_raw_connect()
359 static int serio_raw_reconnect(struct serio *serio) serio_raw_reconnect() argument
361 struct serio_raw *serio_raw = serio_get_drvdata(serio); serio_raw_reconnect()
362 struct serio_driver *drv = serio->drv; serio_raw_reconnect()
365 dev_dbg(&serio->dev, serio_raw_reconnect()
366 "reconnect request, but serio is disconnected, ignoring...\n"); serio_raw_reconnect()
385 serio_pause_rx(serio_raw->serio); serio_raw_hangup()
388 serio_continue_rx(serio_raw->serio); serio_raw_hangup()
394 static void serio_raw_disconnect(struct serio *serio) serio_raw_disconnect() argument
396 struct serio_raw *serio_raw = serio_get_drvdata(serio); serio_raw_disconnect()
407 serio_close(serio); serio_raw_disconnect()
410 serio_set_drvdata(serio, NULL); serio_raw_disconnect()
429 MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids);
|
| H A D | altera_ps2.c | 16 #include <linux/serio.h>
26 struct serio *io;
51 static int altera_ps2_write(struct serio *io, unsigned char val) altera_ps2_write()
59 static int altera_ps2_open(struct serio *io) altera_ps2_open()
71 static void altera_ps2_close(struct serio *io) altera_ps2_close()
85 struct serio *serio; altera_ps2_probe() local
108 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); altera_ps2_probe()
109 if (!serio) altera_ps2_probe()
112 serio->id.type = SERIO_8042; altera_ps2_probe()
113 serio->write = altera_ps2_write; altera_ps2_probe()
114 serio->open = altera_ps2_open; altera_ps2_probe()
115 serio->close = altera_ps2_close; altera_ps2_probe()
116 strlcpy(serio->name, dev_name(&pdev->dev), sizeof(serio->name)); altera_ps2_probe()
117 strlcpy(serio->phys, dev_name(&pdev->dev), sizeof(serio->phys)); altera_ps2_probe()
118 serio->port_data = ps2if; altera_ps2_probe()
119 serio->dev.parent = &pdev->dev; altera_ps2_probe()
120 ps2if->io = serio; altera_ps2_probe()
|
| H A D | rpckbd.c | 32 #include <linux/serio.h>
51 static int rpckbd_write(struct serio *port, unsigned char val) rpckbd_write()
63 struct serio *port = dev_id; rpckbd_rx()
81 static int rpckbd_open(struct serio *port) rpckbd_open()
104 static void rpckbd_close(struct serio *port) rpckbd_close()
113 * Allocate and initialize serio structure for subsequent registration
114 * with serio core.
119 struct serio *serio; rpckbd_probe() local
130 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); rpckbd_probe()
132 if (!serio || !rpckbd) { rpckbd_probe()
134 kfree(serio); rpckbd_probe()
141 serio->id.type = SERIO_8042; rpckbd_probe()
142 serio->write = rpckbd_write; rpckbd_probe()
143 serio->open = rpckbd_open; rpckbd_probe()
144 serio->close = rpckbd_close; rpckbd_probe()
145 serio->dev.parent = &dev->dev; rpckbd_probe()
146 serio->port_data = rpckbd; rpckbd_probe()
147 strlcpy(serio->name, "RiscPC PS/2 kbd port", sizeof(serio->name)); rpckbd_probe()
148 strlcpy(serio->phys, "rpckbd/serio0", sizeof(serio->phys)); rpckbd_probe()
150 platform_set_drvdata(dev, serio); rpckbd_probe()
151 serio_register_port(serio); rpckbd_probe()
157 struct serio *serio = platform_get_drvdata(dev); rpckbd_remove() local
158 struct rpckbd_data *rpckbd = serio->port_data; rpckbd_remove()
160 serio_unregister_port(serio); rpckbd_remove()
|
| H A D | serport.c | 22 #include <linux/serio.h>
38 struct serio *serio; member in struct:serport
45 * Callback functions from the serio code.
48 static int serport_serio_write(struct serio *serio, unsigned char data) serport_serio_write() argument
50 struct serport *serport = serio->port_data; serport_serio_write()
54 static int serport_serio_open(struct serio *serio) serport_serio_open() argument
56 struct serport *serport = serio->port_data; serport_serio_open()
67 static void serport_serio_close(struct serio *serio) serport_serio_close() argument
69 struct serport *serport = serio->port_data; serport_serio_close()
82 * discipline on a tty. It prepares the serio struct.
153 serio_interrupt(serport->serio, cp[i], ch_flags); serport_ldisc_receive()
162 * However, when the serio driver closes the serio port, it finishes,
169 struct serio *serio; serport_ldisc_read() local
175 serport->serio = serio = kzalloc(sizeof(struct serio), GFP_KERNEL); serport_ldisc_read()
176 if (!serio) serport_ldisc_read()
179 strlcpy(serio->name, "Serial port", sizeof(serio->name)); serport_ldisc_read()
180 snprintf(serio->phys, sizeof(serio->phys), "%s/serio0", tty_name(tty, name)); serport_ldisc_read()
181 serio->id = serport->id; serport_ldisc_read()
182 serio->id.type = SERIO_RS232; serport_ldisc_read()
183 serio->write = serport_serio_write; serport_ldisc_read()
184 serio->open = serport_serio_open; serport_ldisc_read()
185 serio->close = serport_serio_close; serport_ldisc_read()
186 serio->port_data = serport; serport_ldisc_read()
187 serio->dev.parent = tty->dev; serport_ldisc_read()
189 serio_register_port(serport->serio); serport_ldisc_read()
190 printk(KERN_INFO "serio: Serial port %s\n", tty_name(tty, name)); serport_ldisc_read()
193 serio_unregister_port(serport->serio); serport_ldisc_read()
194 serport->serio = NULL; serport_ldisc_read()
259 serio_drv_write_wakeup(serport->serio); serport_ldisc_write_wakeup()
|
| H A D | maceps2.c | 12 #include <linux/serio.h>
55 static struct serio *maceps2_port[2];
58 static int maceps2_write(struct serio *dev, unsigned char val) maceps2_write()
76 struct serio *dev = dev_id; maceps2_interrupt()
88 static int maceps2_open(struct serio *dev) maceps2_open()
109 static void maceps2_close(struct serio *dev) maceps2_close()
119 static struct serio *maceps2_allocate_port(int idx) maceps2_allocate_port()
121 struct serio *serio; maceps2_allocate_port() local
123 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); maceps2_allocate_port()
124 if (serio) { maceps2_allocate_port()
125 serio->id.type = SERIO_8042; maceps2_allocate_port()
126 serio->write = maceps2_write; maceps2_allocate_port()
127 serio->open = maceps2_open; maceps2_allocate_port()
128 serio->close = maceps2_close; maceps2_allocate_port()
129 snprintf(serio->name, sizeof(serio->name), "MACE PS/2 port%d", idx); maceps2_allocate_port()
130 snprintf(serio->phys, sizeof(serio->phys), "mace/serio%d", idx); maceps2_allocate_port()
131 serio->port_data = &port_data[idx]; maceps2_allocate_port()
132 serio->dev.parent = &maceps2_device->dev; maceps2_allocate_port()
135 return serio; maceps2_allocate_port()
|
| H A D | pcips2.c | 2 * linux/drivers/input/serio/pcips2.c
19 #include <linux/serio.h>
41 struct serio *io;
46 static int pcips2_write(struct serio *io, unsigned char val) pcips2_write()
102 static int pcips2_open(struct serio *io) pcips2_open()
120 static void pcips2_close(struct serio *io) pcips2_close()
132 struct serio *serio; pcips2_probe() local
144 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); pcips2_probe()
145 if (!ps2if || !serio) { pcips2_probe()
151 serio->id.type = SERIO_8042; pcips2_probe()
152 serio->write = pcips2_write; pcips2_probe()
153 serio->open = pcips2_open; pcips2_probe()
154 serio->close = pcips2_close; pcips2_probe()
155 strlcpy(serio->name, pci_name(dev), sizeof(serio->name)); pcips2_probe()
156 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); pcips2_probe()
157 serio->port_data = ps2if; pcips2_probe()
158 serio->dev.parent = &dev->dev; pcips2_probe()
159 ps2if->io = serio; pcips2_probe()
170 kfree(serio); pcips2_probe()
|
| H A D | sun4i-ps2.c | 9 #include <linux/serio.h>
80 struct serio *serio; member in struct:sun4i_ps2data
130 serio_interrupt(drvdata->serio, byte, rxflags); sun4i_ps2_interrupt()
141 static int sun4i_ps2_open(struct serio *serio) sun4i_ps2_open() argument
143 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_open()
180 static void sun4i_ps2_close(struct serio *serio) sun4i_ps2_close() argument
182 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_close()
192 static int sun4i_ps2_write(struct serio *serio, unsigned char val) sun4i_ps2_write() argument
195 struct sun4i_ps2data *drvdata = serio->port_data; sun4i_ps2_write()
211 struct serio *serio; sun4i_ps2_probe() local
217 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); sun4i_ps2_probe()
218 if (!drvdata || !serio) { sun4i_ps2_probe()
253 serio->id.type = SERIO_8042; sun4i_ps2_probe()
254 serio->write = sun4i_ps2_write; sun4i_ps2_probe()
255 serio->open = sun4i_ps2_open; sun4i_ps2_probe()
256 serio->close = sun4i_ps2_close; sun4i_ps2_probe()
257 serio->port_data = drvdata; sun4i_ps2_probe()
258 serio->dev.parent = dev; sun4i_ps2_probe()
259 strlcpy(serio->name, dev_name(dev), sizeof(serio->name)); sun4i_ps2_probe()
260 strlcpy(serio->phys, dev_name(dev), sizeof(serio->phys)); sun4i_ps2_probe()
274 drvdata->serio = serio; sun4i_ps2_probe()
285 serio_register_port(serio); sun4i_ps2_probe()
297 kfree(serio); sun4i_ps2_probe()
306 serio_unregister_port(drvdata->serio); sun4i_ps2_remove()
|
| H A D | i8042.c | 21 #include <linux/serio.h>
116 struct serio *serio; member in struct:i8042_port
139 struct serio *serio);
154 struct serio *serio)) i8042_install_filter()
175 struct serio *port)) i8042_remove_filter()
321 static int i8042_kbd_write(struct serio *port, unsigned char c) i8042_kbd_write()
342 static int i8042_aux_write(struct serio *serio, unsigned char c) i8042_aux_write() argument
344 struct i8042_port *port = serio->port_data; i8042_aux_write()
357 static void i8042_port_close(struct serio *serio) i8042_port_close() argument
363 if (serio == i8042_ports[I8042_AUX_PORT_NO].serio) { i8042_port_close()
392 * i8042_start() is called by serio core when port is about to finish
396 static int i8042_start(struct serio *serio) i8042_start() argument
398 struct i8042_port *port = serio->port_data; i8042_start()
406 * i8042_stop() marks serio port as non-existing so i8042_interrupt
408 * The function is called by serio core as part of unregister procedure.
410 static void i8042_stop(struct serio *serio) i8042_stop() argument
412 struct i8042_port *port = serio->port_data; i8042_stop()
423 port->serio = NULL; i8042_stop()
432 struct serio *serio) i8042_filter()
443 if (i8042_platform_filter && i8042_platform_filter(data, str, serio)) { i8042_filter()
460 struct serio *serio; i8042_interrupt() local
498 * rest assume that the data came from the same serio last byte i8042_interrupt()
529 serio = port->exists ? port->serio : NULL; i8042_interrupt()
536 filtered = i8042_filter(data, str, serio); i8042_interrupt()
541 serio_interrupt(serio, data, dfl); i8042_interrupt()
1147 } else if (i8042_ports[I8042_AUX_PORT_NO].serio) i8042_controller_resume()
1150 if (i8042_ports[I8042_KBD_PORT_NO].serio) i8042_controller_resume()
1169 /* Set up serio interrupts for system wakeup. */ i8042_pm_suspend()
1171 struct serio *serio = i8042_ports[i].serio; i8042_pm_suspend() local
1173 if (serio && device_may_wakeup(&serio->dev)) i8042_pm_suspend()
1185 struct serio *serio = i8042_ports[i].serio; i8042_pm_resume() local
1187 if (serio && device_may_wakeup(&serio->dev)) i8042_pm_resume()
1240 struct serio *serio; i8042_create_kbd_port() local
1243 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); i8042_create_kbd_port()
1244 if (!serio) i8042_create_kbd_port()
1247 serio->id.type = i8042_direct ? SERIO_8042 : SERIO_8042_XL; i8042_create_kbd_port()
1248 serio->write = i8042_dumbkbd ? NULL : i8042_kbd_write; i8042_create_kbd_port()
1249 serio->start = i8042_start; i8042_create_kbd_port()
1250 serio->stop = i8042_stop; i8042_create_kbd_port()
1251 serio->close = i8042_port_close; i8042_create_kbd_port()
1252 serio->port_data = port; i8042_create_kbd_port()
1253 serio->dev.parent = &i8042_platform_device->dev; i8042_create_kbd_port()
1254 strlcpy(serio->name, "i8042 KBD port", sizeof(serio->name)); i8042_create_kbd_port()
1255 strlcpy(serio->phys, I8042_KBD_PHYS_DESC, sizeof(serio->phys)); i8042_create_kbd_port()
1256 strlcpy(serio->firmware_id, i8042_kbd_firmware_id, i8042_create_kbd_port()
1257 sizeof(serio->firmware_id)); i8042_create_kbd_port()
1259 port->serio = serio; i8042_create_kbd_port()
1267 struct serio *serio; i8042_create_aux_port() local
1271 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); i8042_create_aux_port()
1272 if (!serio) i8042_create_aux_port()
1275 serio->id.type = SERIO_8042; i8042_create_aux_port()
1276 serio->write = i8042_aux_write; i8042_create_aux_port()
1277 serio->start = i8042_start; i8042_create_aux_port()
1278 serio->stop = i8042_stop; i8042_create_aux_port()
1279 serio->port_data = port; i8042_create_aux_port()
1280 serio->dev.parent = &i8042_platform_device->dev; i8042_create_aux_port()
1282 strlcpy(serio->name, "i8042 AUX port", sizeof(serio->name)); i8042_create_aux_port()
1283 strlcpy(serio->phys, I8042_AUX_PHYS_DESC, sizeof(serio->phys)); i8042_create_aux_port()
1284 strlcpy(serio->firmware_id, i8042_aux_firmware_id, i8042_create_aux_port()
1285 sizeof(serio->firmware_id)); i8042_create_aux_port()
1286 serio->close = i8042_port_close; i8042_create_aux_port()
1288 snprintf(serio->name, sizeof(serio->name), "i8042 AUX%d port", idx); i8042_create_aux_port()
1289 snprintf(serio->phys, sizeof(serio->phys), I8042_MUX_PHYS_DESC, idx + 1); i8042_create_aux_port()
1290 strlcpy(serio->firmware_id, i8042_aux_firmware_id, i8042_create_aux_port()
1291 sizeof(serio->firmware_id)); i8042_create_aux_port()
1294 port->serio = serio; i8042_create_aux_port()
1303 kfree(i8042_ports[I8042_KBD_PORT_NO].serio); i8042_free_kbd_port()
1304 i8042_ports[I8042_KBD_PORT_NO].serio = NULL; i8042_free_kbd_port()
1312 kfree(i8042_ports[i].serio); i8042_free_aux_ports()
1313 i8042_ports[i].serio = NULL; i8042_free_aux_ports()
1322 struct serio *serio = i8042_ports[i].serio; i8042_register_ports() local
1324 if (serio) { i8042_register_ports()
1325 printk(KERN_INFO "serio: %s at %#lx,%#lx irq %d\n", i8042_register_ports()
1326 serio->name, i8042_register_ports()
1330 serio_register_port(serio); i8042_register_ports()
1331 device_set_wakeup_capable(&serio->dev, true); i8042_register_ports()
1341 if (i8042_ports[i].serio) { i8042_unregister_ports()
1342 serio_unregister_port(i8042_ports[i].serio); i8042_unregister_ports()
1343 i8042_ports[i].serio = NULL; i8042_unregister_ports()
1351 bool i8042_check_port_owner(const struct serio *port) i8042_check_port_owner()
1356 if (i8042_ports[i].serio == port) i8042_check_port_owner()
1474 * Ok, everything is ready, let's register all serio ports i8042_probe()
153 i8042_install_filter(bool (filter)unsigned char data, unsigned char str, struct serio *serio)) i8042_install_filter() argument
431 i8042_filter(unsigned char data, unsigned char str, struct serio *serio) i8042_filter() argument
|
| H A D | parkbd.c | 51 #include <linux/serio.h>
75 static struct serio *parkbd_port;
87 static int parkbd_write(struct serio *port, unsigned char c) parkbd_write()
171 static struct serio * __init parkbd_allocate_serio(void) parkbd_allocate_serio()
173 struct serio *serio; parkbd_allocate_serio() local
175 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); parkbd_allocate_serio()
176 if (serio) { parkbd_allocate_serio()
177 serio->id.type = parkbd_mode; parkbd_allocate_serio()
178 serio->write = parkbd_write, parkbd_allocate_serio()
179 strlcpy(serio->name, "PARKBD AT/XT keyboard adapter", sizeof(serio->name)); parkbd_allocate_serio()
180 snprintf(serio->phys, sizeof(serio->phys), "%s/serio0", parkbd_dev->port->name); parkbd_allocate_serio()
183 return serio; parkbd_allocate_serio()
204 printk(KERN_INFO "serio: PARKBD %s adapter on %s\n", parkbd_init()
|
| H A D | xilinx_ps2.c | 19 #include <linux/serio.h>
76 struct serio *serio; /* serio */ member in struct:xps2data
139 serio_interrupt(drvdata->serio, c, drvdata->flags); xps2_interrupt()
148 /* serio callbacks */
153 * @pserio: pointer to the serio structure of the PS/2 port
161 static int sxps2_write(struct serio *pserio, unsigned char c) sxps2_write()
184 * @pserio: pointer to the serio structure of the PS/2 device
188 static int sxps2_open(struct serio *pserio) sxps2_open()
212 * @pserio: pointer to the serio structure of the PS/2 device
216 static void sxps2_close(struct serio *pserio) sxps2_close()
240 struct serio *serio; xps2_of_probe() local
264 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); xps2_of_probe()
265 if (!drvdata || !serio) { xps2_of_probe()
272 drvdata->serio = serio; xps2_of_probe()
304 serio->id.type = SERIO_8042; xps2_of_probe()
305 serio->write = sxps2_write; xps2_of_probe()
306 serio->open = sxps2_open; xps2_of_probe()
307 serio->close = sxps2_close; xps2_of_probe()
308 serio->port_data = drvdata; xps2_of_probe()
309 serio->dev.parent = dev; xps2_of_probe()
310 snprintf(serio->name, sizeof(serio->name), xps2_of_probe()
312 snprintf(serio->phys, sizeof(serio->phys), xps2_of_probe()
313 "xilinxps2/serio at %08llX", (unsigned long long)phys_addr); xps2_of_probe()
315 serio_register_port(serio); xps2_of_probe()
323 kfree(serio); xps2_of_probe()
342 serio_unregister_port(drvdata->serio); xps2_of_remove()
|
| H A D | ams_delta_serio.c | 25 #include <linux/serio.h>
38 static struct serio *ams_delta_serio;
76 * and then pass it on the serio ams_delta_serio_interrupt()
92 static int ams_delta_serio_open(struct serio *serio) ams_delta_serio_open() argument
100 static void ams_delta_serio_close(struct serio *serio) ams_delta_serio_close() argument
110 .label = "serio-data",
115 .label = "serio-clock",
120 .label = "serio-power",
125 .label = "serio-dataout",
136 ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL); ams_delta_serio_init()
152 goto serio; ams_delta_serio_init()
157 "ams-delta-serio", 0); ams_delta_serio_init()
178 serio: ams_delta_serio_init()
|
| H A D | libps2.c | 19 #include <linux/serio.h>
39 serio_pause_rx(ps2dev->serio); ps2_sendbyte()
42 serio_continue_rx(ps2dev->serio); ps2_sendbyte()
44 if (serio_write(ps2dev->serio, byte) == 0) ps2_sendbyte()
49 serio_pause_rx(ps2dev->serio); ps2_sendbyte()
51 serio_continue_rx(ps2dev->serio); ps2_sendbyte()
61 if (i8042_check_port_owner(ps2dev->serio)) ps2_begin_command()
68 if (i8042_check_port_owner(ps2dev->serio)) ps2_end_command()
89 serio_pause_rx(ps2dev->serio); ps2_drain()
92 serio_continue_rx(ps2dev->serio); ps2_drain()
151 serio_pause_rx(ps2dev->serio); ps2_adjust_timeout()
153 serio_continue_rx(ps2dev->serio); ps2_adjust_timeout()
162 serio_pause_rx(ps2dev->serio); ps2_adjust_timeout()
164 serio_continue_rx(ps2dev->serio); ps2_adjust_timeout()
201 serio_pause_rx(ps2dev->serio); __ps2_command()
207 serio_continue_rx(ps2dev->serio); __ps2_command()
247 serio_pause_rx(ps2dev->serio); __ps2_command()
249 serio_continue_rx(ps2dev->serio); __ps2_command()
271 void ps2_init(struct ps2dev *ps2dev, struct serio *serio) ps2_init() argument
274 lockdep_set_subclass(&ps2dev->cmd_mutex, serio->depth); ps2_init()
276 ps2dev->serio = serio; ps2_init()
|
| H A D | sa1111ps2.c | 2 * linux/drivers/input/serio/sa1111ps2.c
13 #include <linux/serio.h>
47 struct serio *io;
114 static int ps2_write(struct serio *io, unsigned char val) ps2_write()
141 static int ps2_open(struct serio *io) ps2_open()
177 static void ps2_close(struct serio *io) ps2_close()
257 struct serio *serio; ps2_probe() local
261 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); ps2_probe()
262 if (!ps2if || !serio) { ps2_probe()
268 serio->id.type = SERIO_8042; ps2_probe()
269 serio->write = ps2_write; ps2_probe()
270 serio->open = ps2_open; ps2_probe()
271 serio->close = ps2_close; ps2_probe()
272 strlcpy(serio->name, dev_name(&dev->dev), sizeof(serio->name)); ps2_probe()
273 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); ps2_probe()
274 serio->port_data = ps2if; ps2_probe()
275 serio->dev.parent = &dev->dev; ps2_probe()
276 ps2if->io = serio; ps2_probe()
330 kfree(serio); ps2_probe()
|
| H A D | gscps2.c | 2 * drivers/input/serio/gscps2.c
28 #include <linux/serio.h>
92 struct serio *port;
283 static int gscps2_write(struct serio *port, unsigned char data) gscps2_write()
299 static int gscps2_open(struct serio *port) gscps2_open()
317 static void gscps2_close(struct serio *port) gscps2_close()
331 struct serio *serio; gscps2_probe() local
343 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); gscps2_probe()
344 if (!ps2port || !serio) { gscps2_probe()
351 ps2port->port = serio; gscps2_probe()
359 snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s", gscps2_probe()
361 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); gscps2_probe()
362 serio->id.type = SERIO_8042; gscps2_probe()
363 serio->write = gscps2_write; gscps2_probe()
364 serio->open = gscps2_open; gscps2_probe()
365 serio->close = gscps2_close; gscps2_probe()
366 serio->port_data = ps2port; gscps2_probe()
367 serio->dev.parent = &dev->dev; gscps2_probe()
385 printk(KERN_INFO "serio: %s port at 0x%p irq %d @ %s\n", gscps2_probe()
406 kfree(serio); gscps2_probe()
|
| H A D | olpc_apsp.c | 2 * OLPC serio driver for multiplexed input from Marvell MMP security processor
19 #include <linux/serio.h>
37 * is multiplexed through this system. We create a serio port for each one,
74 struct serio *kbio;
75 struct serio *padio;
81 static int olpc_apsp_write(struct serio *port, unsigned char val) olpc_apsp_write()
114 struct serio *serio; olpc_apsp_rx() local
130 serio = priv->kbio; olpc_apsp_rx()
132 serio = priv->padio; olpc_apsp_rx()
134 serio_interrupt(serio, w & DATA_MASK, 0); olpc_apsp_rx()
144 static int olpc_apsp_open(struct serio *port) olpc_apsp_open()
158 static void olpc_apsp_close(struct serio *port) olpc_apsp_close()
172 struct serio *kb_serio, *pad_serio; olpc_apsp_probe()
202 kb_serio = kzalloc(sizeof(struct serio), GFP_KERNEL); olpc_apsp_probe()
217 pad_serio = kzalloc(sizeof(struct serio), GFP_KERNEL); olpc_apsp_probe()
280 MODULE_DESCRIPTION("OLPC AP-SP serio driver");
|
| H A D | ambakmi.c | 2 * linux/drivers/input/serio/ambakmi.c
13 #include <linux/serio.h>
31 struct serio *io;
54 static int amba_kmi_write(struct serio *io, unsigned char val) amba_kmi_write()
68 static int amba_kmi_open(struct serio *io) amba_kmi_open()
100 static void amba_kmi_close(struct serio *io) amba_kmi_close()
114 struct serio *io; amba_kmi_probe()
122 io = kzalloc(sizeof(struct serio), GFP_KERNEL); amba_kmi_probe()
182 /* kick the serio layer to rescan this port */ amba_kmi_resume()
|
| H A D | arc_ps2.c | 15 #include <linux/serio.h>
38 struct serio *io;
90 static int arc_ps2_write(struct serio *io, unsigned char val) arc_ps2_write()
111 static int arc_ps2_open(struct serio *io) arc_ps2_open()
120 static void arc_ps2_close(struct serio *io) arc_ps2_close()
159 struct serio *io; arc_ps2_create_port()
161 io = kzalloc(sizeof(struct serio), GFP_KERNEL); arc_ps2_create_port()
170 snprintf(io->phys, sizeof(io->phys), "arc/serio%d", index); arc_ps2_create_port()
|
| H A D | hil_mlc.c | 2 * HIL MLC state machine and serio interface driver
66 MODULE_DESCRIPTION("HIL MLC serio");
167 struct serio *serio; hil_mlc_send_polls() local
172 serio = did ? mlc->serio[mlc->di_map[did - 1]] : NULL; hil_mlc_send_polls()
173 drv = (serio != NULL) ? serio->drv : NULL; hil_mlc_send_polls()
181 drv->interrupt(serio, 0, 0); hil_mlc_send_polls()
182 drv->interrupt(serio, HIL_ERR_INT >> 16, 0); hil_mlc_send_polls()
183 drv->interrupt(serio, HIL_PKT_CMD >> 8, 0); hil_mlc_send_polls()
184 drv->interrupt(serio, HIL_CMD_POL + cnt, 0); hil_mlc_send_polls()
188 serio = did ? mlc->serio[mlc->di_map[did-1]] : NULL; hil_mlc_send_polls()
189 drv = (serio != NULL) ? serio->drv : NULL; hil_mlc_send_polls()
197 drv->interrupt(serio, (p >> 24), 0); hil_mlc_send_polls()
198 drv->interrupt(serio, (p >> 16) & 0xff, 0); hil_mlc_send_polls()
199 drv->interrupt(serio, (p >> 8) & ~HIL_PKT_ADDR_MASK, 0); hil_mlc_send_polls()
200 drv->interrupt(serio, p & 0xff, 0); hil_mlc_send_polls()
257 serio_rescan(mlc->serio[rc]); hilse_match()
798 static int hil_mlc_serio_write(struct serio *serio, unsigned char c) hil_mlc_serio_write() argument
805 map = serio->port_data; hil_mlc_serio_write()
841 drv = serio->drv; hil_mlc_serio_write()
849 drv->interrupt(serio, 0, 0); hil_mlc_serio_write()
850 drv->interrupt(serio, HIL_ERR_INT >> 16, 0); hil_mlc_serio_write()
851 drv->interrupt(serio, 0, 0); hil_mlc_serio_write()
852 drv->interrupt(serio, *idx, 0); hil_mlc_serio_write()
855 drv->interrupt(serio, 0, 0); hil_mlc_serio_write()
856 drv->interrupt(serio, HIL_ERR_INT >> 16, 0); hil_mlc_serio_write()
857 drv->interrupt(serio, HIL_PKT_CMD >> 8, 0); hil_mlc_serio_write()
858 drv->interrupt(serio, *idx, 0); hil_mlc_serio_write()
866 static int hil_mlc_serio_open(struct serio *serio) hil_mlc_serio_open() argument
871 if (serio_get_drvdata(serio) != NULL) hil_mlc_serio_open()
874 map = serio->port_data; hil_mlc_serio_open()
883 static void hil_mlc_serio_close(struct serio *serio) hil_mlc_serio_close() argument
888 map = serio->port_data; hil_mlc_serio_close()
894 serio_set_drvdata(serio, NULL); hil_mlc_serio_close()
895 serio->drv = NULL; hil_mlc_serio_close()
930 struct serio *mlc_serio; hil_mlc_register()
933 mlc->serio[i] = mlc_serio; hil_mlc_register()
934 if (!mlc->serio[i]) { hil_mlc_register()
936 kfree(mlc->serio[i]); hil_mlc_register()
989 serio_unregister_port(mlc->serio[i]); hil_mlc_unregister()
990 mlc->serio[i] = NULL; hil_mlc_unregister()
|
| H A D | q40kbd.c | 33 #include <linux/serio.h>
54 struct serio *port;
103 static int q40kbd_open(struct serio *port) q40kbd_open()
116 static void q40kbd_close(struct serio *port) q40kbd_close()
127 struct serio *port; q40kbd_probe()
131 port = kzalloc(sizeof(struct serio), GFP_KERNEL); q40kbd_probe()
160 printk(KERN_INFO "serio: Q40 kbd registered\n"); q40kbd_probe()
|
| H A D | apbps2.c | 23 #include <linux/serio.h>
57 struct serio *io;
86 static int apbps2_write(struct serio *io, unsigned char val) apbps2_write()
106 static int apbps2_open(struct serio *io) apbps2_open()
126 static void apbps2_close(struct serio *io) apbps2_close()
175 priv->io = kzalloc(sizeof(struct serio), GFP_KERNEL); apbps2_of_probe()
|
| H A D | ct82c710.c | 34 #include <linux/serio.h>
64 static struct serio *ct82c710_port;
98 static void ct82c710_close(struct serio *serio) ct82c710_close() argument
111 static int ct82c710_open(struct serio *serio) ct82c710_open() argument
146 static int ct82c710_write(struct serio *port, unsigned char c) ct82c710_write()
180 ct82c710_port = kzalloc(sizeof(struct serio), GFP_KERNEL); ct82c710_probe()
196 printk(KERN_INFO "serio: C&T 82c710 mouse port at %#llx irq %d\n", ct82c710_probe()
|
| H A D | hyperv-keyboard.c | 19 #include <linux/serio.h>
99 struct serio *hv_serio;
156 * Inject the information through the serio interrupt. hv_kbd_on_receive()
321 static int hv_kbd_start(struct serio *serio) hv_kbd_start() argument
323 struct hv_kbd_dev *kbd_dev = serio->port_data; hv_kbd_start()
333 static void hv_kbd_stop(struct serio *serio) hv_kbd_stop() argument
335 struct hv_kbd_dev *kbd_dev = serio->port_data; hv_kbd_stop()
347 struct serio *hv_serio; hv_kbd_probe()
351 hv_serio = kzalloc(sizeof(struct serio), GFP_KERNEL); hv_kbd_probe()
|
| H A D | at32psif.c | 14 #include <linux/serio.h>
98 struct serio *io;
131 static int psif_write(struct serio *io, unsigned char val) psif_write()
155 static int psif_open(struct serio *io) psif_open()
172 static void psif_close(struct serio *io) psif_close()
207 struct serio *io; psif_probe()
220 io = kzalloc(sizeof(struct serio), GFP_KERNEL); psif_probe()
277 snprintf(io->phys, sizeof(io->phys), "at32psif/serio%d", pdev->id); psif_probe()
|
| H A D | i8042-ip22io.h | 19 #define I8042_MUX_PHYS_DESC "hpc3ps2/serio%d"
|
| H A D | i8042-jazzio.h | 18 #define I8042_MUX_PHYS_DESC "R4030/serio%d"
|
| H A D | i8042-ppcio.h | 17 #define I8042_MUX_PHYS_DESC "walnutps2/serio%d"
|
| H A D | i8042-snirm.h | 18 #define I8042_MUX_PHYS_DESC "onboard/serio%d"
|
| H A D | i8042-unicore32io.h | 21 #define I8042_MUX_PHYS_DESC "isa0060/serio%d"
|
| H A D | i8042-io.h | 16 #define I8042_MUX_PHYS_DESC "isa0060/serio%d"
|
| H A D | i8042-sparcio.h | 17 #define I8042_MUX_PHYS_DESC "sparcps2/serio%d"
|
| H A D | i8042-x86ia64io.h | 20 #define I8042_MUX_PHYS_DESC "isa0060/serio%d"
|
| /linux-4.1.27/include/linux/ |
| H A D | serio.h | 19 #include <uapi/linux/serio.h>
21 struct serio { struct
34 int (*write)(struct serio *, unsigned char);
35 int (*open)(struct serio *);
36 void (*close)(struct serio *);
37 int (*start)(struct serio *);
38 void (*stop)(struct serio *);
40 struct serio *parent;
43 unsigned int depth; /* level of nesting in serio hierarchy */
45 struct serio_driver *drv; /* accessed from interrupt, must be protected by serio->lock and serio->sem */
46 struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
52 #define to_serio_port(d) container_of(d, struct serio, dev)
60 void (*write_wakeup)(struct serio *);
61 irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int);
62 int (*connect)(struct serio *, struct serio_driver *drv);
63 int (*reconnect)(struct serio *);
64 void (*disconnect)(struct serio *);
65 void (*cleanup)(struct serio *);
71 int serio_open(struct serio *serio, struct serio_driver *drv);
72 void serio_close(struct serio *serio);
73 void serio_rescan(struct serio *serio);
74 void serio_reconnect(struct serio *serio);
75 irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags);
77 void __serio_register_port(struct serio *serio, struct module *owner);
80 #define serio_register_port(serio) \
81 __serio_register_port(serio, THIS_MODULE)
83 void serio_unregister_port(struct serio *serio);
84 void serio_unregister_child_port(struct serio *serio);
96 * module_serio_driver() - Helper macro for registering a serio driver
99 * Helper macro for serio drivers which do not do anything special in
108 static inline int serio_write(struct serio *serio, unsigned char data) serio_write() argument
110 if (serio->write) serio_write()
111 return serio->write(serio, data); serio_write()
116 static inline void serio_drv_write_wakeup(struct serio *serio) serio_drv_write_wakeup() argument
118 if (serio->drv && serio->drv->write_wakeup) serio_drv_write_wakeup()
119 serio->drv->write_wakeup(serio); serio_drv_write_wakeup()
123 * Use the following functions to manipulate serio's per-port
126 static inline void *serio_get_drvdata(struct serio *serio) serio_get_drvdata() argument
128 return dev_get_drvdata(&serio->dev); serio_get_drvdata()
131 static inline void serio_set_drvdata(struct serio *serio, void *data) serio_set_drvdata() argument
133 dev_set_drvdata(&serio->dev, data); serio_set_drvdata()
140 static inline void serio_pause_rx(struct serio *serio) serio_pause_rx() argument
142 spin_lock_irq(&serio->lock); serio_pause_rx()
145 static inline void serio_continue_rx(struct serio *serio) serio_continue_rx() argument
147 spin_unlock_irq(&serio->lock); serio_continue_rx()
|
| H A D | i8042.h | 58 struct serio;
65 bool i8042_check_port_owner(const struct serio *);
67 struct serio *serio));
69 struct serio *serio));
86 static inline bool i8042_check_port_owner(const struct serio *serio) i8042_check_port_owner() argument
92 struct serio *serio)) i8042_install_filter()
98 struct serio *serio)) i8042_remove_filter()
91 i8042_install_filter(bool (filter)unsigned char data, unsigned char str, struct serio *serio)) i8042_install_filter() argument
97 i8042_remove_filter(bool (filter)unsigned char data, unsigned char str, struct serio *serio)) i8042_remove_filter() argument
|
| H A D | libps2.h | 30 struct serio *serio; member in struct:ps2dev
44 void ps2_init(struct ps2dev *ps2dev, struct serio *serio);
|
| H A D | hil_mlc.h | 38 #include <linux/serio.h>
156 struct serio *serio[HIL_MLC_DEVMEM]; member in struct:hil_mlc
|
| H A D | gameport.h | 46 struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */
|
| /linux-4.1.27/drivers/input/touchscreen/ |
| H A D | touchright.c | 22 #include <linux/serio.h>
51 struct serio *serio; member in struct:tr
57 static irqreturn_t tr_interrupt(struct serio *serio, tr_interrupt() argument
60 struct tr *tr = serio_get_drvdata(serio); tr_interrupt()
85 static void tr_disconnect(struct serio *serio) tr_disconnect() argument
87 struct tr *tr = serio_get_drvdata(serio); tr_disconnect()
91 serio_close(serio); tr_disconnect()
92 serio_set_drvdata(serio, NULL); tr_disconnect()
99 * new serio device that supports the Touchright protocol and registers it as
103 static int tr_connect(struct serio *serio, struct serio_driver *drv) tr_connect() argument
116 tr->serio = serio; tr_connect()
118 snprintf(tr->phys, sizeof(tr->phys), "%s/input0", serio->phys); tr_connect()
126 input_dev->dev.parent = &serio->dev; tr_connect()
132 serio_set_drvdata(serio, tr); tr_connect()
134 err = serio_open(serio, drv); tr_connect()
144 fail3: serio_close(serio); tr_connect()
145 fail2: serio_set_drvdata(serio, NULL); tr_connect()
152 * The serio driver structure.
165 MODULE_DEVICE_TABLE(serio, tr_serio_ids);
|
| H A D | tsc40.c | 13 #include <linux/serio.h>
18 struct serio *serio; member in struct:tsc_ser
41 static irqreturn_t tsc_interrupt(struct serio *serio, tsc_interrupt() argument
44 struct tsc_ser *ptsc = serio_get_drvdata(serio); tsc_interrupt()
51 dev_dbg(&serio->dev, tsc_interrupt()
64 dev_dbg(&serio->dev, tsc_interrupt()
80 static int tsc_connect(struct serio *serio, struct serio_driver *drv) tsc_connect() argument
93 ptsc->serio = serio; tsc_connect()
95 snprintf(ptsc->phys, sizeof(ptsc->phys), "%s/input0", serio->phys); tsc_connect()
103 input_dev->dev.parent = &serio->dev; tsc_connect()
110 serio_set_drvdata(serio, ptsc); tsc_connect()
112 error = serio_open(serio, drv); tsc_connect()
123 serio_close(serio); tsc_connect()
125 serio_set_drvdata(serio, NULL); tsc_connect()
132 static void tsc_disconnect(struct serio *serio) tsc_disconnect() argument
134 struct tsc_ser *ptsc = serio_get_drvdata(serio); tsc_disconnect()
136 serio_close(serio); tsc_disconnect()
141 serio_set_drvdata(serio, NULL); tsc_disconnect()
153 MODULE_DEVICE_TABLE(serio, tsc_serio_ids);
|
| H A D | fujitsu_ts.c | 18 #include <linux/serio.h>
33 struct serio *serio; member in struct:fujitsu
47 static irqreturn_t fujitsu_interrupt(struct serio *serio, fujitsu_interrupt() argument
50 struct fujitsu *fujitsu = serio_get_drvdata(serio); fujitsu_interrupt()
83 static void fujitsu_disconnect(struct serio *serio) fujitsu_disconnect() argument
85 struct fujitsu *fujitsu = serio_get_drvdata(serio); fujitsu_disconnect()
89 serio_close(serio); fujitsu_disconnect()
90 serio_set_drvdata(serio, NULL); fujitsu_disconnect()
97 * new serio device that supports the Fujitsu protocol and registers it
100 static int fujitsu_connect(struct serio *serio, struct serio_driver *drv) fujitsu_connect() argument
113 fujitsu->serio = serio; fujitsu_connect()
116 "%s/input0", serio->phys); fujitsu_connect()
129 serio_set_drvdata(serio, fujitsu); fujitsu_connect()
131 err = serio_open(serio, drv); fujitsu_connect()
142 serio_close(serio); fujitsu_connect()
144 serio_set_drvdata(serio, NULL); fujitsu_connect()
152 * The serio driver structure.
164 MODULE_DEVICE_TABLE(serio, fujitsu_serio_ids);
|
| H A D | dynapro.c | 26 #include <linux/serio.h>
57 struct serio *serio; member in struct:dynapro
78 static irqreturn_t dynapro_interrupt(struct serio *serio, dynapro_interrupt() argument
81 struct dynapro *pdynapro = serio_get_drvdata(serio); dynapro_interrupt()
88 dev_dbg(&serio->dev, "unknown/unsynchronized data: %x\n", dynapro_interrupt()
94 static void dynapro_disconnect(struct serio *serio) dynapro_disconnect() argument
96 struct dynapro *pdynapro = serio_get_drvdata(serio); dynapro_disconnect()
100 serio_close(serio); dynapro_disconnect()
101 serio_set_drvdata(serio, NULL); dynapro_disconnect()
108 * new serio device that supports dynapro protocol and registers it as
112 static int dynapro_connect(struct serio *serio, struct serio_driver *drv) dynapro_connect() argument
125 pdynapro->serio = serio; dynapro_connect()
128 "%s/input0", serio->phys); dynapro_connect()
136 input_dev->dev.parent = &serio->dev; dynapro_connect()
144 serio_set_drvdata(serio, pdynapro); dynapro_connect()
146 err = serio_open(serio, drv); dynapro_connect()
156 fail3: serio_close(serio); dynapro_connect()
157 fail2: serio_set_drvdata(serio, NULL); dynapro_connect()
164 * The serio driver structure.
177 MODULE_DEVICE_TABLE(serio, dynapro_serio_ids);
|
| H A D | gunze.c | 34 #include <linux/serio.h>
54 struct serio *serio; member in struct:gunze
76 static irqreturn_t gunze_interrupt(struct serio *serio, gunze_interrupt() argument
79 struct gunze* gunze = serio_get_drvdata(serio); gunze_interrupt()
95 static void gunze_disconnect(struct serio *serio) gunze_disconnect() argument
97 struct gunze *gunze = serio_get_drvdata(serio); gunze_disconnect()
101 serio_close(serio); gunze_disconnect()
102 serio_set_drvdata(serio, NULL); gunze_disconnect()
109 * new serio device that supports Gunze protocol and registers it as
113 static int gunze_connect(struct serio *serio, struct serio_driver *drv) gunze_connect() argument
126 gunze->serio = serio; gunze_connect()
128 snprintf(gunze->phys, sizeof(serio->phys), "%s/input0", serio->phys); gunze_connect()
136 input_dev->dev.parent = &serio->dev; gunze_connect()
142 serio_set_drvdata(serio, gunze); gunze_connect()
144 err = serio_open(serio, drv); gunze_connect()
154 fail3: serio_close(serio); gunze_connect()
155 fail2: serio_set_drvdata(serio, NULL); gunze_connect()
162 * The serio driver structure.
175 MODULE_DEVICE_TABLE(serio, gunze_serio_ids);
|
| H A D | hampshire.c | 25 #include <linux/serio.h>
56 struct serio *serio; member in struct:hampshire
77 static irqreturn_t hampshire_interrupt(struct serio *serio, hampshire_interrupt() argument
80 struct hampshire *phampshire = serio_get_drvdata(serio); hampshire_interrupt()
87 dev_dbg(&serio->dev, "unknown/unsynchronized data: %x\n", hampshire_interrupt()
93 static void hampshire_disconnect(struct serio *serio) hampshire_disconnect() argument
95 struct hampshire *phampshire = serio_get_drvdata(serio); hampshire_disconnect()
99 serio_close(serio); hampshire_disconnect()
100 serio_set_drvdata(serio, NULL); hampshire_disconnect()
107 * new serio device that supports hampshire protocol and registers it as
111 static int hampshire_connect(struct serio *serio, struct serio_driver *drv) hampshire_connect() argument
124 phampshire->serio = serio; hampshire_connect()
127 "%s/input0", serio->phys); hampshire_connect()
135 input_dev->dev.parent = &serio->dev; hampshire_connect()
143 serio_set_drvdata(serio, phampshire); hampshire_connect()
145 err = serio_open(serio, drv); hampshire_connect()
155 fail3: serio_close(serio); hampshire_connect()
156 fail2: serio_set_drvdata(serio, NULL); hampshire_connect()
163 * The serio driver structure.
176 MODULE_DEVICE_TABLE(serio, hampshire_serio_ids);
|
| H A D | touchit213.c | 23 #include <linux/serio.h>
79 struct serio *serio; member in struct:touchit213
86 static irqreturn_t touchit213_interrupt(struct serio *serio, touchit213_interrupt() argument
89 struct touchit213 *touchit213 = serio_get_drvdata(serio); touchit213_interrupt()
122 static void touchit213_disconnect(struct serio *serio) touchit213_disconnect() argument
124 struct touchit213 *touchit213 = serio_get_drvdata(serio); touchit213_disconnect()
128 serio_close(serio); touchit213_disconnect()
129 serio_set_drvdata(serio, NULL); touchit213_disconnect()
136 * new serio device that supports the Touchright protocol and registers it as
140 static int touchit213_connect(struct serio *serio, struct serio_driver *drv) touchit213_connect() argument
153 touchit213->serio = serio; touchit213_connect()
156 "%s/input0", serio->phys); touchit213_connect()
164 input_dev->dev.parent = &serio->dev; touchit213_connect()
172 serio_set_drvdata(serio, touchit213); touchit213_connect()
174 err = serio_open(serio, drv); touchit213_connect()
184 fail3: serio_close(serio); touchit213_connect()
185 fail2: serio_set_drvdata(serio, NULL); touchit213_connect()
192 * The serio driver structure.
205 MODULE_DEVICE_TABLE(serio, touchit213_serio_ids);
|
| H A D | touchwin.c | 29 #include <linux/serio.h>
54 struct serio *serio; member in struct:tw
61 static irqreturn_t tw_interrupt(struct serio *serio, tw_interrupt() argument
64 struct tw *tw = serio_get_drvdata(serio); tw_interrupt()
92 static void tw_disconnect(struct serio *serio) tw_disconnect() argument
94 struct tw *tw = serio_get_drvdata(serio); tw_disconnect()
98 serio_close(serio); tw_disconnect()
99 serio_set_drvdata(serio, NULL); tw_disconnect()
106 * new serio device that supports the Touchwin protocol and registers it as
110 static int tw_connect(struct serio *serio, struct serio_driver *drv) tw_connect() argument
123 tw->serio = serio; tw_connect()
125 snprintf(tw->phys, sizeof(tw->phys), "%s/input0", serio->phys); tw_connect()
133 input_dev->dev.parent = &serio->dev; tw_connect()
139 serio_set_drvdata(serio, tw); tw_connect()
141 err = serio_open(serio, drv); tw_connect()
151 fail3: serio_close(serio); tw_connect()
152 fail2: serio_set_drvdata(serio, NULL); tw_connect()
159 * The serio driver structure.
172 MODULE_DEVICE_TABLE(serio, tw_serio_ids);
|
| H A D | inexio.c | 25 #include <linux/serio.h>
59 struct serio *serio; member in struct:inexio
79 static irqreturn_t inexio_interrupt(struct serio *serio, inexio_interrupt() argument
82 struct inexio* pinexio = serio_get_drvdata(serio); inexio_interrupt()
98 static void inexio_disconnect(struct serio *serio) inexio_disconnect() argument
100 struct inexio* pinexio = serio_get_drvdata(serio); inexio_disconnect()
104 serio_close(serio); inexio_disconnect()
105 serio_set_drvdata(serio, NULL); inexio_disconnect()
112 * new serio device that supports iNexio protocol and registers it as
116 static int inexio_connect(struct serio *serio, struct serio_driver *drv) inexio_connect() argument
129 pinexio->serio = serio; inexio_connect()
131 snprintf(pinexio->phys, sizeof(pinexio->phys), "%s/input0", serio->phys); inexio_connect()
139 input_dev->dev.parent = &serio->dev; inexio_connect()
145 serio_set_drvdata(serio, pinexio); inexio_connect()
147 err = serio_open(serio, drv); inexio_connect()
157 fail3: serio_close(serio); inexio_connect()
158 fail2: serio_set_drvdata(serio, NULL); inexio_connect()
165 * The serio driver structure.
178 MODULE_DEVICE_TABLE(serio, inexio_serio_ids);
|
| H A D | mtouch.c | 23 #include <linux/serio.h>
59 struct serio *serio; member in struct:mtouch
90 static irqreturn_t mtouch_interrupt(struct serio *serio, mtouch_interrupt() argument
93 struct mtouch* mtouch = serio_get_drvdata(serio); mtouch_interrupt()
111 static void mtouch_disconnect(struct serio *serio) mtouch_disconnect() argument
113 struct mtouch* mtouch = serio_get_drvdata(serio); mtouch_disconnect()
117 serio_close(serio); mtouch_disconnect()
118 serio_set_drvdata(serio, NULL); mtouch_disconnect()
125 * new serio device that supports MicroTouch (Format Tablet) protocol and registers it as
129 static int mtouch_connect(struct serio *serio, struct serio_driver *drv) mtouch_connect() argument
142 mtouch->serio = serio; mtouch_connect()
144 snprintf(mtouch->phys, sizeof(mtouch->phys), "%s/input0", serio->phys); mtouch_connect()
152 input_dev->dev.parent = &serio->dev; mtouch_connect()
158 serio_set_drvdata(serio, mtouch); mtouch_connect()
160 err = serio_open(serio, drv); mtouch_connect()
170 fail3: serio_close(serio); mtouch_connect()
171 fail2: serio_set_drvdata(serio, NULL); mtouch_connect()
178 * The serio driver structure.
191 MODULE_DEVICE_TABLE(serio, mtouch_serio_ids);
|
| H A D | elo.c | 24 #include <linux/serio.h>
57 struct serio *serio; member in struct:elo
79 dev_dbg(&elo->serio->dev, elo_process_data_10()
88 dev_dbg(&elo->serio->dev, elo_process_data_10()
95 dev_dbg(&elo->serio->dev, elo_process_data_10()
201 static irqreturn_t elo_interrupt(struct serio *serio, elo_interrupt() argument
204 struct elo *elo = serio_get_drvdata(serio); elo_interrupt()
232 serio_pause_rx(elo->serio); elo_command_10()
235 serio_continue_rx(elo->serio); elo_command_10()
237 if (serio_write(elo->serio, ELO10_LEAD_BYTE)) elo_command_10()
242 if (serio_write(elo->serio, packet[i])) elo_command_10()
246 if (serio_write(elo->serio, csum)) elo_command_10()
278 dev_info(&elo->serio->dev, elo_setup_10()
290 static void elo_disconnect(struct serio *serio) elo_disconnect() argument
292 struct elo *elo = serio_get_drvdata(serio); elo_disconnect()
296 serio_close(serio); elo_disconnect()
297 serio_set_drvdata(serio, NULL); elo_disconnect()
304 * new serio device that supports Gunze protocol and registers it as
308 static int elo_connect(struct serio *serio, struct serio_driver *drv) elo_connect() argument
321 elo->serio = serio; elo_connect()
322 elo->id = serio->id.id; elo_connect()
327 snprintf(elo->phys, sizeof(elo->phys), "%s/input0", serio->phys); elo_connect()
335 input_dev->dev.parent = &serio->dev; elo_connect()
340 serio_set_drvdata(serio, elo); elo_connect()
341 err = serio_open(serio, drv); elo_connect()
373 fail3: serio_close(serio); elo_connect()
374 fail2: serio_set_drvdata(serio, NULL); elo_connect()
381 * The serio driver structure.
394 MODULE_DEVICE_TABLE(serio, elo_serio_ids);
|
| H A D | penmount.c | 23 #include <linux/serio.h>
56 struct serio *serio; member in struct:pm
165 static irqreturn_t pm_interrupt(struct serio *serio, pm_interrupt() argument
168 struct pm *pm = serio_get_drvdata(serio); pm_interrupt()
181 static void pm_disconnect(struct serio *serio) pm_disconnect() argument
183 struct pm *pm = serio_get_drvdata(serio); pm_disconnect()
185 serio_close(serio); pm_disconnect()
190 serio_set_drvdata(serio, NULL); pm_disconnect()
195 * new serio device that supports PenMount protocol and registers it as
199 static int pm_connect(struct serio *serio, struct serio_driver *drv) pm_connect() argument
213 pm->serio = serio; pm_connect()
215 snprintf(pm->phys, sizeof(pm->phys), "%s/input0", serio->phys); pm_connect()
224 input_dev->dev.parent = &serio->dev; pm_connect()
229 switch (serio->id.id) { pm_connect()
273 serio_set_drvdata(serio, pm); pm_connect()
275 err = serio_open(serio, drv); pm_connect()
285 fail3: serio_close(serio); pm_connect()
286 fail2: serio_set_drvdata(serio, NULL); pm_connect()
293 * The serio driver structure.
306 MODULE_DEVICE_TABLE(serio, pm_serio_ids);
310 .name = "serio-penmount",
|
| H A D | wacom_w8001.c | 20 #include <linux/serio.h>
84 struct serio *serio; member in struct:w8001
281 static irqreturn_t w8001_interrupt(struct serio *serio, w8001_interrupt() argument
284 struct w8001 *w8001 = serio_get_drvdata(serio); w8001_interrupt()
358 rc = serio_write(w8001->serio, command); w8001_command()
499 static void w8001_disconnect(struct serio *serio) w8001_disconnect() argument
501 struct w8001 *w8001 = serio_get_drvdata(serio); w8001_disconnect()
503 serio_close(serio); w8001_disconnect()
508 serio_set_drvdata(serio, NULL); w8001_disconnect()
513 * new serio device that supports the w8001 protocol and registers it as
517 static int w8001_connect(struct serio *serio, struct serio_driver *drv) w8001_connect() argument
530 w8001->serio = serio; w8001_connect()
533 snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys); w8001_connect()
535 serio_set_drvdata(serio, w8001); w8001_connect()
536 err = serio_open(serio, drv); w8001_connect()
550 input_dev->dev.parent = &serio->dev; w8001_connect()
564 serio_close(serio); w8001_connect()
566 serio_set_drvdata(serio, NULL); w8001_connect()
583 MODULE_DEVICE_TABLE(serio, w8001_serio_ids);
|
| H A D | bcm_iproc_tsc.c | 25 #include <linux/serio.h>
|
| /linux-4.1.27/drivers/input/joystick/iforce/ |
| H A D | iforce-serio.c | 52 serio_write(iforce->serio, 0x2b); iforce_serial_xmit()
54 serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]); iforce_serial_xmit()
59 serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]); iforce_serial_xmit()
64 serio_write(iforce->serio, cs); iforce_serial_xmit()
74 static void iforce_serio_write_wakeup(struct serio *serio) iforce_serio_write_wakeup() argument
76 struct iforce *iforce = serio_get_drvdata(serio); iforce_serio_write_wakeup()
81 static irqreturn_t iforce_serio_irq(struct serio *serio, iforce_serio_irq() argument
84 struct iforce *iforce = serio_get_drvdata(serio); iforce_serio_irq()
127 static int iforce_serio_connect(struct serio *serio, struct serio_driver *drv) iforce_serio_connect() argument
137 iforce->serio = serio; iforce_serio_connect()
139 serio_set_drvdata(serio, iforce); iforce_serio_connect()
141 err = serio_open(serio, drv); iforce_serio_connect()
151 fail2: serio_close(serio); iforce_serio_connect()
152 fail1: serio_set_drvdata(serio, NULL); iforce_serio_connect()
157 static void iforce_serio_disconnect(struct serio *serio) iforce_serio_disconnect() argument
159 struct iforce *iforce = serio_get_drvdata(serio); iforce_serio_disconnect()
162 serio_close(serio); iforce_serio_disconnect()
163 serio_set_drvdata(serio, NULL); iforce_serio_disconnect()
177 MODULE_DEVICE_TABLE(serio, iforce_serio_ids);
|
| H A D | Makefile | 10 iforce-$(CONFIG_JOYSTICK_IFORCE_232) += iforce-serio.o
|
| H A D | iforce.h | 34 #include <linux/serio.h>
111 struct serio *serio; /* RS232 transfer */ member in struct:iforce
148 /* iforce-serio.c */
|
| H A D | iforce-main.c | 288 input_dev->dev.parent = &iforce->serio->dev; iforce_init_device()
|
| /linux-4.1.27/drivers/input/keyboard/ |
| H A D | newtonkbd.c | 32 #include <linux/serio.h>
62 struct serio *serio; member in struct:nkbd
66 static irqreturn_t nkbd_interrupt(struct serio *serio, nkbd_interrupt() argument
69 struct nkbd *nkbd = serio_get_drvdata(serio); nkbd_interrupt()
78 printk(KERN_INFO "input: %s on %s\n", nkbd->dev->name, serio->phys); nkbd_interrupt()
83 static int nkbd_connect(struct serio *serio, struct serio_driver *drv) nkbd_connect() argument
95 nkbd->serio = serio; nkbd_connect()
97 snprintf(nkbd->phys, sizeof(nkbd->phys), "%s/input0", serio->phys); nkbd_connect()
106 input_dev->dev.parent = &serio->dev; nkbd_connect()
116 serio_set_drvdata(serio, nkbd); nkbd_connect()
118 err = serio_open(serio, drv); nkbd_connect()
128 fail3: serio_close(serio); nkbd_connect()
129 fail2: serio_set_drvdata(serio, NULL); nkbd_connect()
135 static void nkbd_disconnect(struct serio *serio) nkbd_disconnect() argument
137 struct nkbd *nkbd = serio_get_drvdata(serio); nkbd_disconnect()
139 serio_close(serio); nkbd_disconnect()
140 serio_set_drvdata(serio, NULL); nkbd_disconnect()
155 MODULE_DEVICE_TABLE(serio, nkbd_serio_ids);
|
| H A D | stowaway.c | 35 #include <linux/serio.h>
68 struct serio *serio; member in struct:skbd
72 static irqreturn_t skbd_interrupt(struct serio *serio, unsigned char data, skbd_interrupt() argument
75 struct skbd *skbd = serio_get_drvdata(serio); skbd_interrupt()
87 static int skbd_connect(struct serio *serio, struct serio_driver *drv) skbd_connect() argument
99 skbd->serio = serio; skbd_connect()
101 snprintf(skbd->phys, sizeof(skbd->phys), "%s/input0", serio->phys); skbd_connect()
110 input_dev->dev.parent = &serio->dev; skbd_connect()
120 serio_set_drvdata(serio, skbd); skbd_connect()
122 err = serio_open(serio, drv); skbd_connect()
132 fail3: serio_close(serio); skbd_connect()
133 fail2: serio_set_drvdata(serio, NULL); skbd_connect()
139 static void skbd_disconnect(struct serio *serio) skbd_disconnect() argument
141 struct skbd *skbd = serio_get_drvdata(serio); skbd_disconnect()
143 serio_close(serio); skbd_disconnect()
144 serio_set_drvdata(serio, NULL); skbd_disconnect()
159 MODULE_DEVICE_TABLE(serio, skbd_serio_ids);
|
| H A D | xtkbd.c | 32 #include <linux/serio.h>
59 struct serio *serio; member in struct:xtkbd
63 static irqreturn_t xtkbd_interrupt(struct serio *serio, xtkbd_interrupt() argument
66 struct xtkbd *xtkbd = serio_get_drvdata(serio); xtkbd_interrupt()
85 static int xtkbd_connect(struct serio *serio, struct serio_driver *drv) xtkbd_connect() argument
97 xtkbd->serio = serio; xtkbd_connect()
99 snprintf(xtkbd->phys, sizeof(xtkbd->phys), "%s/input0", serio->phys); xtkbd_connect()
108 input_dev->dev.parent = &serio->dev; xtkbd_connect()
119 serio_set_drvdata(serio, xtkbd); xtkbd_connect()
121 err = serio_open(serio, drv); xtkbd_connect()
131 fail3: serio_close(serio); xtkbd_connect()
132 fail2: serio_set_drvdata(serio, NULL); xtkbd_connect()
138 static void xtkbd_disconnect(struct serio *serio) xtkbd_disconnect() argument
140 struct xtkbd *xtkbd = serio_get_drvdata(serio); xtkbd_disconnect()
142 serio_close(serio); xtkbd_disconnect()
143 serio_set_drvdata(serio, NULL); xtkbd_disconnect()
158 MODULE_DEVICE_TABLE(serio, xtkbd_serio_ids);
|
| H A D | sunkbd.c | 35 #include <linux/serio.h>
78 struct serio *serio; member in struct:sunkbd
94 static irqreturn_t sunkbd_interrupt(struct serio *serio, sunkbd_interrupt() argument
97 struct sunkbd *sunkbd = serio_get_drvdata(serio); sunkbd_interrupt()
162 serio_write(sunkbd->serio, SUNKBD_CMD_SETLED); sunkbd_event()
163 serio_write(sunkbd->serio, sunkbd_event()
175 serio_write(sunkbd->serio, SUNKBD_CMD_NOCLICK - value); sunkbd_event()
179 serio_write(sunkbd->serio, SUNKBD_CMD_BELLOFF - value); sunkbd_event()
197 serio_write(sunkbd->serio, SUNKBD_CMD_RESET); sunkbd_initialize()
206 serio_write(sunkbd->serio, SUNKBD_CMD_LAYOUT); sunkbd_initialize()
229 serio_write(sunkbd->serio, SUNKBD_CMD_SETLED); sunkbd_reinit()
230 serio_write(sunkbd->serio, sunkbd_reinit()
235 serio_write(sunkbd->serio, sunkbd_reinit()
237 serio_write(sunkbd->serio, sunkbd_reinit()
243 serio_pause_rx(sunkbd->serio); sunkbd_enable()
245 serio_continue_rx(sunkbd->serio); sunkbd_enable()
253 static int sunkbd_connect(struct serio *serio, struct serio_driver *drv) sunkbd_connect() argument
265 sunkbd->serio = serio; sunkbd_connect()
269 snprintf(sunkbd->phys, sizeof(sunkbd->phys), "%s/input0", serio->phys); sunkbd_connect()
271 serio_set_drvdata(serio, sunkbd); sunkbd_connect()
273 err = serio_open(serio, drv); sunkbd_connect()
292 input_dev->dev.parent = &serio->dev; sunkbd_connect()
320 fail3: serio_close(serio); sunkbd_connect()
321 fail2: serio_set_drvdata(serio, NULL); sunkbd_connect()
331 static void sunkbd_disconnect(struct serio *serio) sunkbd_disconnect() argument
333 struct sunkbd *sunkbd = serio_get_drvdata(serio); sunkbd_disconnect()
337 serio_close(serio); sunkbd_disconnect()
338 serio_set_drvdata(serio, NULL); sunkbd_disconnect()
358 MODULE_DEVICE_TABLE(serio, sunkbd_serio_ids);
|
| H A D | hil_kbd.c | 36 #include <linux/serio.h>
48 MODULE_ALIAS("serio:ty03pr25id00ex*"); /* HIL keyboard */
49 MODULE_ALIAS("serio:ty03pr25id0Fex*"); /* HIL mouse */
71 struct serio *serio; member in struct:hil_dev
274 static irqreturn_t hil_dev_interrupt(struct serio *serio, hil_dev_interrupt() argument
281 dev = serio_get_drvdata(serio); hil_dev_interrupt()
314 static void hil_dev_disconnect(struct serio *serio) hil_dev_disconnect() argument
316 struct hil_dev *dev = serio_get_drvdata(serio); hil_dev_disconnect()
320 serio_close(serio); hil_dev_disconnect()
322 serio_set_drvdata(serio, NULL); hil_dev_disconnect()
443 static int hil_dev_connect(struct serio *serio, struct serio_driver *drv) hil_dev_connect() argument
457 dev->serio = serio; hil_dev_connect()
460 error = serio_open(serio, drv); hil_dev_connect()
464 serio_set_drvdata(serio, dev); hil_dev_connect()
468 serio_write(serio, 0); hil_dev_connect()
469 serio_write(serio, 0); hil_dev_connect()
470 serio_write(serio, HIL_PKT_CMD >> 8); hil_dev_connect()
471 serio_write(serio, HIL_CMD_IDD); hil_dev_connect()
477 serio_write(serio, 0); hil_dev_connect()
478 serio_write(serio, 0); hil_dev_connect()
479 serio_write(serio, HIL_PKT_CMD >> 8); hil_dev_connect()
480 serio_write(serio, HIL_CMD_RSC); hil_dev_connect()
486 serio_write(serio, 0); hil_dev_connect()
487 serio_write(serio, 0); hil_dev_connect()
488 serio_write(serio, HIL_PKT_CMD >> 8); hil_dev_connect()
489 serio_write(serio, HIL_CMD_RNM); hil_dev_connect()
495 serio_write(serio, 0); hil_dev_connect()
496 serio_write(serio, 0); hil_dev_connect()
497 serio_write(serio, HIL_PKT_CMD >> 8); hil_dev_connect()
498 serio_write(serio, HIL_CMD_EXD); hil_dev_connect()
536 input_dev->dev.parent = &serio->dev; hil_dev_connect()
539 serio_write(serio, 0); hil_dev_connect()
540 serio_write(serio, 0); hil_dev_connect()
541 serio_write(serio, HIL_PKT_CMD >> 8); hil_dev_connect()
543 serio_write(serio, HIL_CMD_EK1); hil_dev_connect()
554 serio_close(serio); hil_dev_connect()
555 serio_set_drvdata(serio, NULL); hil_dev_connect()
572 MODULE_DEVICE_TABLE(serio, hil_dev_ids);
|
| H A D | lkkbd.c | 69 #include <linux/serio.h>
281 struct serio *serio; member in struct:lkkbd
438 static irqreturn_t lkkbd_interrupt(struct serio *serio, lkkbd_interrupt() argument
441 struct lkkbd *lk = serio_get_drvdata(serio); lkkbd_interrupt()
502 struct serio *serio = lk->serio; lkkbd_toggle_leds() local
511 serio_write(serio, LK_CMD_LED_ON); lkkbd_toggle_leds()
512 serio_write(serio, leds_on); lkkbd_toggle_leds()
515 serio_write(serio, LK_CMD_LED_OFF); lkkbd_toggle_leds()
516 serio_write(serio, leds_off); lkkbd_toggle_leds()
522 struct serio *serio = lk->serio; lkkbd_toggle_keyclick() local
526 serio_write(serio, LK_CMD_ENABLE_KEYCLICK); lkkbd_toggle_keyclick()
527 serio_write(serio, volume_to_hw(lk->keyclick_volume)); lkkbd_toggle_keyclick()
528 serio_write(serio, LK_CMD_ENABLE_CTRCLICK); lkkbd_toggle_keyclick()
529 serio_write(serio, volume_to_hw(lk->ctrlclick_volume)); lkkbd_toggle_keyclick()
532 serio_write(serio, LK_CMD_DISABLE_KEYCLICK); lkkbd_toggle_keyclick()
533 serio_write(serio, LK_CMD_DISABLE_CTRCLICK); lkkbd_toggle_keyclick()
559 serio_write(lk->serio, LK_CMD_SOUND_BELL); lkkbd_event()
584 serio_write(lk->serio, LK_CMD_REQUEST_ID); lkkbd_reinit()
587 serio_write(lk->serio, LK_CMD_SET_DEFAULTS); lkkbd_reinit()
597 serio_write(lk->serio, LK_CMD_ENABLE_LK401); lkkbd_reinit()
601 serio_write(lk->serio, lkkbd_reinit()
605 serio_write(lk->serio, LK_CMD_ENABLE_BELL); lkkbd_reinit()
606 serio_write(lk->serio, volume_to_hw(lk->bell_volume)); lkkbd_reinit()
613 serio_write(lk->serio, LK_CMD_SOUND_BELL); lkkbd_reinit()
619 static int lkkbd_connect(struct serio *serio, struct serio_driver *drv) lkkbd_connect() argument
633 lk->serio = serio; lkkbd_connect()
642 snprintf(lk->phys, sizeof(lk->phys), "%s/input0", serio->phys); lkkbd_connect()
650 input_dev->dev.parent = &serio->dev; lkkbd_connect()
674 serio_set_drvdata(serio, lk); lkkbd_connect()
676 err = serio_open(serio, drv); lkkbd_connect()
684 serio_write(lk->serio, LK_CMD_POWERCYCLE_RESET); lkkbd_connect()
688 fail3: serio_close(serio); lkkbd_connect()
689 fail2: serio_set_drvdata(serio, NULL); lkkbd_connect()
698 static void lkkbd_disconnect(struct serio *serio) lkkbd_disconnect() argument
700 struct lkkbd *lk = serio_get_drvdata(serio); lkkbd_disconnect()
704 serio_close(serio); lkkbd_disconnect()
705 serio_set_drvdata(serio, NULL); lkkbd_disconnect()
720 MODULE_DEVICE_TABLE(serio, lkkbd_serio_ids);
|
| H A D | atkbd.c | 26 #include <linux/serio.h>
372 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, atkbd_interrupt() argument
375 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_interrupt()
382 dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags); atkbd_interrupt()
386 dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags); atkbd_interrupt()
387 serio_write(serio, ATKBD_CMD_RESEND); atkbd_interrupt()
426 serio_reconnect(atkbd->ps2dev.serio); atkbd_interrupt()
440 dev_warn(&serio->dev, atkbd_interrupt()
443 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys); atkbd_interrupt()
447 dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n", atkbd_interrupt()
448 serio->phys); atkbd_interrupt()
467 dev_warn(&serio->dev, atkbd_interrupt()
471 atkbd->set, code, serio->phys); atkbd_interrupt()
472 dev_warn(&serio->dev, atkbd_interrupt()
670 serio_pause_rx(atkbd->ps2dev.serio); atkbd_enable()
672 serio_continue_rx(atkbd->ps2dev.serio); atkbd_enable()
682 serio_pause_rx(atkbd->ps2dev.serio); atkbd_disable()
684 serio_continue_rx(atkbd->ps2dev.serio); atkbd_disable()
696 dev_err(&ps2dev->serio->dev, atkbd_activate()
698 ps2dev->serio->phys); atkbd_activate()
715 dev_err(&ps2dev->serio->dev, atkbd_deactivate()
717 ps2dev->serio->phys); atkbd_deactivate()
721 * atkbd_probe() probes for an AT keyboard on a serio port.
737 dev_warn(&ps2dev->serio->dev, atkbd_probe()
739 ps2dev->serio->phys); atkbd_probe()
769 dev_err(&ps2dev->serio->dev, atkbd_probe()
881 static void atkbd_cleanup(struct serio *serio) atkbd_cleanup() argument
883 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_cleanup()
894 static void atkbd_disconnect(struct serio *serio) atkbd_disconnect() argument
896 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_disconnect()
898 sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); atkbd_disconnect()
908 * accessing freed input device or serio port. atkbd_disconnect()
912 serio_close(serio); atkbd_disconnect()
913 serio_set_drvdata(serio, NULL); atkbd_disconnect()
1071 "%s/input0", atkbd->ps2dev.serio->phys); atkbd_set_device_attrs()
1080 input_dev->dev.parent = &atkbd->ps2dev.serio->dev; atkbd_set_device_attrs()
1127 * atkbd_connect() is called when the serio module finds an interface
1133 static int atkbd_connect(struct serio *serio, struct serio_driver *drv) atkbd_connect() argument
1145 ps2_init(&atkbd->ps2dev, serio); atkbd_connect()
1149 switch (serio->id.type) { atkbd_connect()
1156 if (serio->write) atkbd_connect()
1168 serio_set_drvdata(serio, atkbd); atkbd_connect()
1170 err = serio_open(serio, drv); atkbd_connect()
1192 err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group); atkbd_connect()
1197 if (serio->write) atkbd_connect()
1206 fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group); atkbd_connect()
1207 fail3: serio_close(serio); atkbd_connect()
1208 fail2: serio_set_drvdata(serio, NULL); atkbd_connect()
1219 static int atkbd_reconnect(struct serio *serio) atkbd_reconnect() argument
1221 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_reconnect()
1222 struct serio_driver *drv = serio->drv; atkbd_reconnect()
1226 dev_dbg(&serio->dev, atkbd_reconnect()
1227 "reconnect request, but serio is disconnected, ignoring...\n"); atkbd_reconnect()
1295 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1313 struct serio *serio = to_serio_port(dev); atkbd_attr_show_helper() local
1314 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_attr_show_helper()
1322 struct serio *serio = to_serio_port(dev); atkbd_attr_set_helper() local
1323 struct atkbd *atkbd = serio_get_drvdata(serio); atkbd_attr_set_helper()
|
| /linux-4.1.27/drivers/input/joystick/ |
| H A D | magellan.c | 33 #include <linux/serio.h>
112 static irqreturn_t magellan_interrupt(struct serio *serio, magellan_interrupt() argument
115 struct magellan* magellan = serio_get_drvdata(serio); magellan_interrupt()
131 static void magellan_disconnect(struct serio *serio) magellan_disconnect() argument
133 struct magellan* magellan = serio_get_drvdata(serio); magellan_disconnect()
135 serio_close(serio); magellan_disconnect()
136 serio_set_drvdata(serio, NULL); magellan_disconnect()
143 * new serio device that supports Magellan protocol and registers it as
147 static int magellan_connect(struct serio *serio, struct serio_driver *drv) magellan_connect() argument
160 snprintf(magellan->phys, sizeof(magellan->phys), "%s/input0", serio->phys); magellan_connect()
168 input_dev->dev.parent = &serio->dev; magellan_connect()
178 serio_set_drvdata(serio, magellan); magellan_connect()
180 err = serio_open(serio, drv); magellan_connect()
190 fail3: serio_close(serio); magellan_connect()
191 fail2: serio_set_drvdata(serio, NULL); magellan_connect()
198 * The serio driver structure.
211 MODULE_DEVICE_TABLE(serio, magellan_serio_ids);
|
| H A D | stinger.c | 34 #include <linux/serio.h>
96 static irqreturn_t stinger_interrupt(struct serio *serio, stinger_interrupt() argument
99 struct stinger *stinger = serio_get_drvdata(serio); stinger_interrupt()
118 static void stinger_disconnect(struct serio *serio) stinger_disconnect() argument
120 struct stinger *stinger = serio_get_drvdata(serio); stinger_disconnect()
122 serio_close(serio); stinger_disconnect()
123 serio_set_drvdata(serio, NULL); stinger_disconnect()
130 * new serio device that supports Stinger protocol and registers it as
134 static int stinger_connect(struct serio *serio, struct serio_driver *drv) stinger_connect() argument
146 snprintf(stinger->phys, sizeof(stinger->phys), "%s/serio0", serio->phys); stinger_connect()
154 input_dev->dev.parent = &serio->dev; stinger_connect()
164 serio_set_drvdata(serio, stinger); stinger_connect()
166 err = serio_open(serio, drv); stinger_connect()
176 fail3: serio_close(serio); stinger_connect()
177 fail2: serio_set_drvdata(serio, NULL); stinger_connect()
184 * The serio driver structure.
197 MODULE_DEVICE_TABLE(serio, stinger_serio_ids);
|
| H A D | warrior.c | 33 #include <linux/serio.h>
98 static irqreturn_t warrior_interrupt(struct serio *serio, warrior_interrupt() argument
101 struct warrior *warrior = serio_get_drvdata(serio); warrior_interrupt()
124 static void warrior_disconnect(struct serio *serio) warrior_disconnect() argument
126 struct warrior *warrior = serio_get_drvdata(serio); warrior_disconnect()
128 serio_close(serio); warrior_disconnect()
129 serio_set_drvdata(serio, NULL); warrior_disconnect()
136 * new serio device. It looks for the Warrior, and if found, registers
140 static int warrior_connect(struct serio *serio, struct serio_driver *drv) warrior_connect() argument
152 snprintf(warrior->phys, sizeof(warrior->phys), "%s/input0", serio->phys); warrior_connect()
160 input_dev->dev.parent = &serio->dev; warrior_connect()
173 serio_set_drvdata(serio, warrior); warrior_connect()
175 err = serio_open(serio, drv); warrior_connect()
185 fail3: serio_close(serio); warrior_connect()
186 fail2: serio_set_drvdata(serio, NULL); warrior_connect()
193 * The serio driver structure.
206 MODULE_DEVICE_TABLE(serio, warrior_serio_ids);
|
| H A D | spaceball.c | 37 #include <linux/serio.h>
148 static irqreturn_t spaceball_interrupt(struct serio *serio, spaceball_interrupt() argument
151 struct spaceball *spaceball = serio_get_drvdata(serio); spaceball_interrupt()
186 static void spaceball_disconnect(struct serio *serio) spaceball_disconnect() argument
188 struct spaceball* spaceball = serio_get_drvdata(serio); spaceball_disconnect()
190 serio_close(serio); spaceball_disconnect()
191 serio_set_drvdata(serio, NULL); spaceball_disconnect()
198 * new serio device that supports Spaceball protocol and registers it as
202 static int spaceball_connect(struct serio *serio, struct serio_driver *drv) spaceball_connect() argument
209 if ((id = serio->id.id) > SPACEBALL_MAX_ID) spaceball_connect()
218 snprintf(spaceball->phys, sizeof(spaceball->phys), "%s/input0", serio->phys); spaceball_connect()
226 input_dev->dev.parent = &serio->dev; spaceball_connect()
252 serio_set_drvdata(serio, spaceball); spaceball_connect()
254 err = serio_open(serio, drv); spaceball_connect()
264 fail3: serio_close(serio); spaceball_connect()
265 fail2: serio_set_drvdata(serio, NULL); spaceball_connect()
272 * The serio driver structure.
285 MODULE_DEVICE_TABLE(serio, spaceball_serio_ids);
|
| H A D | spaceorb.c | 36 #include <linux/serio.h>
128 static irqreturn_t spaceorb_interrupt(struct serio *serio, spaceorb_interrupt() argument
131 struct spaceorb* spaceorb = serio_get_drvdata(serio); spaceorb_interrupt()
146 static void spaceorb_disconnect(struct serio *serio) spaceorb_disconnect() argument
148 struct spaceorb* spaceorb = serio_get_drvdata(serio); spaceorb_disconnect()
150 serio_close(serio); spaceorb_disconnect()
151 serio_set_drvdata(serio, NULL); spaceorb_disconnect()
158 * new serio device that supports SpaceOrb/Avenger protocol and registers
162 static int spaceorb_connect(struct serio *serio, struct serio_driver *drv) spaceorb_connect() argument
175 snprintf(spaceorb->phys, sizeof(spaceorb->phys), "%s/input0", serio->phys); spaceorb_connect()
183 input_dev->dev.parent = &serio->dev; spaceorb_connect()
193 serio_set_drvdata(serio, spaceorb); spaceorb_connect()
195 err = serio_open(serio, drv); spaceorb_connect()
205 fail3: serio_close(serio); spaceorb_connect()
206 fail2: serio_set_drvdata(serio, NULL); spaceorb_connect()
213 * The serio driver structure.
226 MODULE_DEVICE_TABLE(serio, spaceorb_serio_ids);
|
| H A D | twidjoy.c | 54 #include <linux/serio.h>
137 static irqreturn_t twidjoy_interrupt(struct serio *serio, unsigned char data, unsigned int flags) twidjoy_interrupt() argument
139 struct twidjoy *twidjoy = serio_get_drvdata(serio); twidjoy_interrupt()
165 static void twidjoy_disconnect(struct serio *serio) twidjoy_disconnect() argument
167 struct twidjoy *twidjoy = serio_get_drvdata(serio); twidjoy_disconnect()
169 serio_close(serio); twidjoy_disconnect()
170 serio_set_drvdata(serio, NULL); twidjoy_disconnect()
177 * new serio device. It looks for the Twiddler, and if found, registers
181 static int twidjoy_connect(struct serio *serio, struct serio_driver *drv) twidjoy_connect() argument
195 snprintf(twidjoy->phys, sizeof(twidjoy->phys), "%s/input0", serio->phys); twidjoy_connect()
203 input_dev->dev.parent = &serio->dev; twidjoy_connect()
213 serio_set_drvdata(serio, twidjoy); twidjoy_connect()
215 err = serio_open(serio, drv); twidjoy_connect()
225 fail3: serio_close(serio); twidjoy_connect()
226 fail2: serio_set_drvdata(serio, NULL); twidjoy_connect()
233 * The serio driver structure.
246 MODULE_DEVICE_TABLE(serio, twidjoy_serio_ids);
|
| H A D | zhenhua.c | 51 #include <linux/serio.h>
109 static irqreturn_t zhenhua_interrupt(struct serio *serio, unsigned char data, unsigned int flags) zhenhua_interrupt() argument
111 struct zhenhua *zhenhua = serio_get_drvdata(serio); zhenhua_interrupt()
137 static void zhenhua_disconnect(struct serio *serio) zhenhua_disconnect() argument
139 struct zhenhua *zhenhua = serio_get_drvdata(serio); zhenhua_disconnect()
141 serio_close(serio); zhenhua_disconnect()
142 serio_set_drvdata(serio, NULL); zhenhua_disconnect()
149 * new serio device. It looks for the Twiddler, and if found, registers
153 static int zhenhua_connect(struct serio *serio, struct serio_driver *drv) zhenhua_connect() argument
165 snprintf(zhenhua->phys, sizeof(zhenhua->phys), "%s/input0", serio->phys); zhenhua_connect()
173 input_dev->dev.parent = &serio->dev; zhenhua_connect()
181 serio_set_drvdata(serio, zhenhua); zhenhua_connect()
183 err = serio_open(serio, drv); zhenhua_connect()
193 fail3: serio_close(serio); zhenhua_connect()
194 fail2: serio_set_drvdata(serio, NULL); zhenhua_connect()
201 * The serio driver structure.
214 MODULE_DEVICE_TABLE(serio, zhenhua_serio_ids);
|
| /linux-4.1.27/drivers/i2c/busses/ |
| H A D | i2c-taos-evm.c | 23 #include <linux/serio.h>
70 struct serio *serio = adapter->algo_data; taos_smbus_xfer() local
71 struct taos_data *taos = serio_get_drvdata(serio); taos_smbus_xfer()
104 serio_write(serio, *p); taos_smbus_xfer()
111 serio_write(serio, read_write == I2C_SMBUS_WRITE ? '>' : '<'); taos_smbus_xfer()
151 static irqreturn_t taos_interrupt(struct serio *serio, unsigned char data, taos_interrupt() argument
154 struct taos_data *taos = serio_get_drvdata(serio); taos_interrupt()
201 static int taos_connect(struct serio *serio, struct serio_driver *drv) taos_connect() argument
214 serio_set_drvdata(serio, taos); taos_connect()
216 err = serio_open(serio, drv); taos_connect()
223 adapter->algo_data = serio; taos_connect()
224 adapter->dev.parent = &serio->dev; taos_connect()
227 serio_write(serio, TAOS_CMD_RESET); taos_connect()
233 dev_err(&serio->dev, "TAOS EVM reset failed (state=%d, " taos_connect()
241 dev_err(&serio->dev, "TAOS EVM identification failed\n"); taos_connect()
248 serio_write(serio, TAOS_CMD_ECHO_OFF); taos_connect()
254 dev_err(&serio->dev, "TAOS EVM echo off failed " taos_connect()
262 dev_info(&serio->dev, "Connected to TAOS EVM\n"); taos_connect()
268 serio_close(serio); taos_connect()
275 static void taos_disconnect(struct serio *serio) taos_disconnect() argument
277 struct taos_data *taos = serio_get_drvdata(serio); taos_disconnect()
282 serio_close(serio); taos_disconnect()
285 dev_info(&serio->dev, "Disconnected from TAOS EVM\n"); taos_disconnect()
297 MODULE_DEVICE_TABLE(serio, taos_serio_ids);
|
| /linux-4.1.27/drivers/input/mouse/ |
| H A D | sermouse.c | 34 #include <linux/serio.h>
206 static irqreturn_t sermouse_interrupt(struct serio *serio, sermouse_interrupt() argument
209 struct sermouse *sermouse = serio_get_drvdata(serio); sermouse_interrupt()
229 static void sermouse_disconnect(struct serio *serio) sermouse_disconnect() argument
231 struct sermouse *sermouse = serio_get_drvdata(serio); sermouse_disconnect()
233 serio_close(serio); sermouse_disconnect()
234 serio_set_drvdata(serio, NULL); sermouse_disconnect()
240 * sermouse_connect() is a callback form the serio module when
241 * an unhandled serio port is found.
244 static int sermouse_connect(struct serio *serio, struct serio_driver *drv) sermouse_connect() argument
248 unsigned char c = serio->id.extra; sermouse_connect()
257 snprintf(sermouse->phys, sizeof(sermouse->phys), "%s/input0", serio->phys); sermouse_connect()
258 sermouse->type = serio->id.proto; sermouse_connect()
266 input_dev->dev.parent = &serio->dev; sermouse_connect()
279 serio_set_drvdata(serio, sermouse); sermouse_connect()
281 err = serio_open(serio, drv); sermouse_connect()
291 fail3: serio_close(serio); sermouse_connect()
292 fail2: serio_set_drvdata(serio, NULL); sermouse_connect()
344 MODULE_DEVICE_TABLE(serio, sermouse_serio_ids);
|
| H A D | psmouse-base.c | 22 #include <linux/serio.h>
237 * counters while holding serio lock so fighting with interrupt handler
243 serio_pause_rx(psmouse->ps2dev.serio); psmouse_set_state()
245 serio_continue_rx(psmouse->ps2dev.serio); psmouse_set_state()
268 serio_reconnect(psmouse->ps2dev.serio); psmouse_handle_byte()
296 static irqreturn_t psmouse_interrupt(struct serio *serio, psmouse_interrupt() argument
299 struct psmouse *psmouse = serio_get_drvdata(serio); psmouse_interrupt()
351 serio_reconnect(serio); psmouse_interrupt()
494 struct serio *serio = psmouse->ps2dev.serio; psmouse_matches_pnp_id() local
498 if (strncmp(serio->firmware_id, "PNP: ", 5)) psmouse_matches_pnp_id()
501 fw_id_copy = kstrndup(&serio->firmware_id[5], psmouse_matches_pnp_id()
502 sizeof(serio->firmware_id) - 5, psmouse_matches_pnp_id()
1200 ps2dev->serio->phys); psmouse_probe()
1230 psmouse->ps2dev.serio->phys); psmouse_activate()
1247 psmouse->ps2dev.serio->phys); psmouse_deactivate()
1264 struct serio *serio = psmouse->ps2dev.serio; psmouse_resync() local
1274 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_resync()
1275 parent = serio_get_drvdata(serio->parent); psmouse_resync()
1335 psmouse->ps2dev.serio->phys); psmouse_resync()
1343 serio_reconnect(serio); psmouse_resync()
1357 static void psmouse_cleanup(struct serio *serio) psmouse_cleanup() argument
1359 struct psmouse *psmouse = serio_get_drvdata(serio); psmouse_cleanup()
1364 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_cleanup()
1365 parent = serio_get_drvdata(serio->parent); psmouse_cleanup()
1376 psmouse->ps2dev.serio->phys); psmouse_cleanup()
1406 static void psmouse_disconnect(struct serio *serio) psmouse_disconnect() argument
1410 psmouse = serio_get_drvdata(serio); psmouse_disconnect()
1412 sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group); psmouse_disconnect()
1423 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_disconnect()
1424 parent = serio_get_drvdata(serio->parent); psmouse_disconnect()
1436 serio_close(serio); psmouse_disconnect()
1437 serio_set_drvdata(serio, NULL); psmouse_disconnect()
1453 input_dev->dev.parent = &psmouse->ps2dev.serio->dev; psmouse_switch_protocol()
1505 * psmouse_connect() is a callback from the serio module when
1506 * an unhandled serio port is found.
1508 static int psmouse_connect(struct serio *serio, struct serio_driver *drv) psmouse_connect() argument
1520 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_connect()
1521 parent = serio_get_drvdata(serio->parent); psmouse_connect()
1530 ps2_init(&psmouse->ps2dev, serio); psmouse_connect()
1533 snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys); psmouse_connect()
1537 serio_set_drvdata(serio, psmouse); psmouse_connect()
1539 error = serio_open(serio, drv); psmouse_connect()
1566 error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group); psmouse_connect()
1590 serio_close(serio); psmouse_connect()
1592 serio_set_drvdata(serio, NULL); psmouse_connect()
1602 static int psmouse_reconnect(struct serio *serio) psmouse_reconnect() argument
1604 struct psmouse *psmouse = serio_get_drvdata(serio); psmouse_reconnect()
1611 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_reconnect()
1612 parent = serio_get_drvdata(serio->parent); psmouse_reconnect()
1671 MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
1689 struct serio *serio = to_serio_port(dev); psmouse_attr_show_helper() local
1693 psmouse = serio_get_drvdata(serio); psmouse_attr_show_helper()
1701 struct serio *serio = to_serio_port(dev); psmouse_attr_set_helper() local
1710 psmouse = serio_get_drvdata(serio); psmouse_attr_set_helper()
1718 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_attr_set_helper()
1719 parent = serio_get_drvdata(serio->parent); psmouse_attr_set_helper()
1771 struct serio *serio = psmouse->ps2dev.serio; psmouse_attr_set_protocol() local
1789 while (!list_empty(&serio->children)) { psmouse_attr_set_protocol()
1798 serio_unregister_child_port(serio); psmouse_attr_set_protocol()
1801 if (serio->drv != &psmouse_drv) { psmouse_attr_set_protocol()
1812 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { psmouse_attr_set_protocol()
1813 parent = serio_get_drvdata(serio->parent); psmouse_attr_set_protocol()
|
| H A D | vsxxxaa.c | 84 #include <linux/serio.h>
115 struct serio *serio; member in struct:vsxxxaa
380 serio_write(mouse->serio, 'S'); /* Standard format */ vsxxxaa_handle_POR_packet()
382 serio_write(mouse->serio, 'R'); /* Incremental */ vsxxxaa_handle_POR_packet()
384 serio_write(mouse->serio, 'L'); /* 72 samples/sec */ vsxxxaa_handle_POR_packet()
447 static irqreturn_t vsxxxaa_interrupt(struct serio *serio, vsxxxaa_interrupt() argument
450 struct vsxxxaa *mouse = serio_get_drvdata(serio); vsxxxaa_interrupt()
458 static void vsxxxaa_disconnect(struct serio *serio) vsxxxaa_disconnect() argument
460 struct vsxxxaa *mouse = serio_get_drvdata(serio); vsxxxaa_disconnect()
462 serio_close(serio); vsxxxaa_disconnect()
463 serio_set_drvdata(serio, NULL); vsxxxaa_disconnect()
468 static int vsxxxaa_connect(struct serio *serio, struct serio_driver *drv) vsxxxaa_connect() argument
480 mouse->serio = serio; vsxxxaa_connect()
483 snprintf(mouse->phys, sizeof(mouse->phys), "%s/input0", serio->phys); vsxxxaa_connect()
488 input_dev->dev.parent = &serio->dev; vsxxxaa_connect()
502 serio_set_drvdata(serio, mouse); vsxxxaa_connect()
504 err = serio_open(serio, drv); vsxxxaa_connect()
512 serio_write(serio, 'T'); /* Test */ vsxxxaa_connect()
520 fail3: serio_close(serio); vsxxxaa_connect()
521 fail2: serio_set_drvdata(serio, NULL); vsxxxaa_connect()
537 MODULE_DEVICE_TABLE(serio, vsxxaa_serio_ids);
|
| H A D | psmouse.h | 173 dev_dbg(&(psmouse)->ps2dev.serio->dev, \
176 dev_info(&(psmouse)->ps2dev.serio->dev, \
179 dev_warn(&(psmouse)->ps2dev.serio->dev, \
182 dev_err(&(psmouse)->ps2dev.serio->dev, \
185 dev_notice(&(psmouse)->ps2dev.serio->dev, \
189 &(psmouse)->ps2dev.serio->dev, \
|
| H A D | synaptics.c | 30 #include <linux/serio.h>
561 static int synaptics_pt_write(struct serio *serio, unsigned char c) synaptics_pt_write() argument
563 struct psmouse *parent = serio_get_drvdata(serio->parent); synaptics_pt_write()
573 static int synaptics_pt_start(struct serio *serio) synaptics_pt_start() argument
575 struct psmouse *parent = serio_get_drvdata(serio->parent); synaptics_pt_start()
578 serio_pause_rx(parent->ps2dev.serio); synaptics_pt_start()
579 priv->pt_port = serio; synaptics_pt_start()
580 serio_continue_rx(parent->ps2dev.serio); synaptics_pt_start()
585 static void synaptics_pt_stop(struct serio *serio) synaptics_pt_stop() argument
587 struct psmouse *parent = serio_get_drvdata(serio->parent); synaptics_pt_stop()
590 serio_pause_rx(parent->ps2dev.serio); synaptics_pt_stop()
592 serio_continue_rx(parent->ps2dev.serio); synaptics_pt_stop()
601 struct serio *ptport, synaptics_pass_pt_packet()
638 struct serio *serio; synaptics_pt_create() local
640 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); synaptics_pt_create()
641 if (!serio) { synaptics_pt_create()
647 serio->id.type = SERIO_PS_PSTHRU; synaptics_pt_create()
648 strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name)); synaptics_pt_create()
649 strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name)); synaptics_pt_create()
650 serio->write = synaptics_pt_write; synaptics_pt_create()
651 serio->start = synaptics_pt_start; synaptics_pt_create()
652 serio->stop = synaptics_pt_stop; synaptics_pt_create()
653 serio->parent = psmouse->ps2dev.serio; synaptics_pt_create()
657 psmouse_info(psmouse, "serio: %s port at %s\n", synaptics_pt_create()
658 serio->name, psmouse->phys); synaptics_pt_create()
659 serio_register_port(serio); synaptics_pt_create()
1304 device_remove_file(&psmouse->ps2dev.serio->dev, synaptics_disconnect()
1539 err = device_create_file(&psmouse->ps2dev.serio->dev, __synaptics_init()
|
| H A D | lifebook.c | 16 #include <linux/serio.h>
263 strcmp(psmouse->ps2dev.serio->phys, desired_serio_phys)) lifebook_detect()
287 "%s/input1", psmouse->ps2dev.serio->phys); lifebook_create_relative_device()
295 dev2->dev.parent = &psmouse->ps2dev.serio->dev; lifebook_create_relative_device()
|
| H A D | touchkit_ps2.c | 31 #include <linux/serio.h>
|
| H A D | hgpk.c | 36 #include <linux/serio.h>
765 if (psmouse->ps2dev.serio->dev.power.power_state.event != hgpk_reconnect()
905 device_remove_file(&psmouse->ps2dev.serio->dev, hgpk_disconnect()
907 device_remove_file(&psmouse->ps2dev.serio->dev, hgpk_disconnect()
911 device_remove_file(&psmouse->ps2dev.serio->dev, hgpk_disconnect()
946 err = device_create_file(&psmouse->ps2dev.serio->dev, hgpk_register()
953 err = device_create_file(&psmouse->ps2dev.serio->dev, hgpk_register()
963 err = device_create_file(&psmouse->ps2dev.serio->dev, hgpk_register()
975 device_remove_file(&psmouse->ps2dev.serio->dev, hgpk_register()
978 device_remove_file(&psmouse->ps2dev.serio->dev, hgpk_register()
|
| H A D | logips2pp.c | 13 #include <linux/serio.h>
199 device_remove_file(&psmouse->ps2dev.serio->dev, &psmouse_attr_smartscroll.dattr); ps2pp_disconnect()
405 error = device_create_file(&psmouse->ps2dev.serio->dev, ps2pp_init()
|
| H A D | trackpoint.c | 13 #include <linux/serio.h>
349 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, &trackpoint_attr_group); trackpoint_disconnect()
411 error = sysfs_create_group(&ps2dev->serio->dev.kobj, &trackpoint_attr_group); trackpoint_detect()
|
| H A D | synaptics.h | 185 struct serio *pt_port; /* Pass-through serio port */
|
| H A D | vmmouse.c | 17 #include <linux/serio.h>
463 psmouse->ps2dev.serio->phys); vmmouse_init()
474 abs_dev->dev.parent = &psmouse->ps2dev.serio->dev; vmmouse_init()
|
| H A D | elantech.c | 19 #include <linux/serio.h>
1461 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, elantech_disconnect()
1667 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, elantech_init()
1687 psmouse->ps2dev.serio->phys); elantech_init()
1694 tp_dev->dev.parent = &psmouse->ps2dev.serio->dev; elantech_init()
1719 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, elantech_init()
|
| H A D | focaltech.c | 21 #include <linux/serio.h>
|
| H A D | sentelic.c | 27 #include <linux/serio.h>
1009 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, fsp_disconnect()
1073 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, fsp_init()
|
| H A D | alps.c | 21 #include <linux/serio.h>
1339 psmouse->ps2dev.serio->phys, alps_register_bare_ps2_mouse()
1353 dev3->dev.parent = &psmouse->ps2dev.serio->dev; alps_register_bare_ps2_mouse()
1504 serio_pause_rx(psmouse->ps2dev.serio); alps_flush_packet()
1525 serio_continue_rx(psmouse->ps2dev.serio); alps_flush_packet()
2921 psmouse->ps2dev.serio->phys); alps_init()
2934 dev2->dev.parent = &psmouse->ps2dev.serio->dev; alps_init()
|
| H A D | cypress_ps2.c | 21 #include <linux/serio.h>
|
| /linux-4.1.27/drivers/input/tablet/ |
| H A D | wacom_serial4.c | 113 #include <linux/serio.h>
375 static irqreturn_t wacom_interrupt(struct serio *serio, unsigned char data, wacom_interrupt() argument
378 struct wacom *wacom = serio_get_drvdata(serio); wacom_interrupt()
414 static void wacom_disconnect(struct serio *serio) wacom_disconnect() argument
416 struct wacom *wacom = serio_get_drvdata(serio); wacom_disconnect()
418 serio_close(serio); wacom_disconnect()
419 serio_set_drvdata(serio, NULL); wacom_disconnect()
424 static int wacom_send(struct serio *serio, const u8 *command) wacom_send() argument
429 err = serio_write(serio, *command); wacom_send()
434 static int wacom_send_setup_string(struct wacom *wacom, struct serio *serio) wacom_send_setup_string() argument
464 return wacom_send(serio, cmd); wacom_send_setup_string()
467 static int wacom_send_and_wait(struct wacom *wacom, struct serio *serio, wacom_send_and_wait() argument
476 err = wacom_send(serio, cmd); wacom_send_and_wait()
490 static int wacom_setup(struct wacom *wacom, struct serio *serio) wacom_setup() argument
497 err = wacom_send_and_wait(wacom, serio, REQUEST_MODEL_AND_ROM_VERSION, wacom_setup()
503 err = wacom_send_and_wait(wacom, serio, wacom_setup()
511 err = wacom_send_and_wait(wacom, serio, wacom_setup()
518 return wacom_send_setup_string(wacom, serio); wacom_setup()
521 static int wacom_connect(struct serio *serio, struct serio_driver *drv) wacom_connect() argument
536 snprintf(wacom->phys, sizeof(wacom->phys), "%s/input0", serio->phys); wacom_connect()
540 input_dev->id.product = serio->id.extra; wacom_connect()
541 input_dev->dev.parent = &serio->dev; wacom_connect()
555 serio_set_drvdata(serio, wacom); wacom_connect()
557 err = serio_open(serio, drv); wacom_connect()
561 err = wacom_setup(wacom, serio); wacom_connect()
589 serio_close(serio); wacom_connect()
591 serio_set_drvdata(serio, NULL); wacom_connect()
607 MODULE_DEVICE_TABLE(serio, wacom_serio_ids);
|
| /linux-4.1.27/drivers/staging/nvec/ |
| H A D | nvec_ps2.c | 18 #include <linux/serio.h>
46 struct serio *ser_dev;
53 static int ps2_startstreaming(struct serio *ser_dev) ps2_startstreaming()
60 static void ps2_stopstreaming(struct serio *ser_dev) ps2_stopstreaming()
67 static int ps2_sendcommand(struct serio *ser_dev, unsigned char cmd) ps2_sendcommand()
108 struct serio *ser_dev; nvec_mouse_probe()
111 ser_dev = devm_kzalloc(&pdev->dev, sizeof(struct serio), GFP_KERNEL); nvec_mouse_probe()
|
| /linux-4.1.27/drivers/tty/serial/ |
| H A D | sunsu.c | 34 #include <linux/serio.h>
102 struct serio serio; member in struct:uart_sunsu_port
512 serio_interrupt(&up->serio, ch, 0); receive_kbd_ms_chars()
526 serio_interrupt(&up->serio, ch, 0); receive_kbd_ms_chars()
989 static int sunsu_serio_write(struct serio *serio, unsigned char ch) sunsu_serio_write() argument
991 struct uart_sunsu_port *up = serio->port_data; sunsu_serio_write()
1009 static int sunsu_serio_open(struct serio *serio) sunsu_serio_open() argument
1011 struct uart_sunsu_port *up = serio->port_data; sunsu_serio_open()
1026 static void sunsu_serio_close(struct serio *serio) sunsu_serio_close() argument
1028 struct uart_sunsu_port *up = serio->port_data; sunsu_serio_close()
1199 struct serio *serio; sunsu_kbd_ms_init() local
1222 serio = &up->serio; sunsu_kbd_ms_init()
1223 serio->port_data = up; sunsu_kbd_ms_init()
1225 serio->id.type = SERIO_RS232; sunsu_kbd_ms_init()
1227 serio->id.proto = SERIO_SUNKBD; sunsu_kbd_ms_init()
1228 strlcpy(serio->name, "sukbd", sizeof(serio->name)); sunsu_kbd_ms_init()
1230 serio->id.proto = SERIO_SUN; sunsu_kbd_ms_init()
1231 serio->id.extra = 1; sunsu_kbd_ms_init()
1232 strlcpy(serio->name, "sums", sizeof(serio->name)); sunsu_kbd_ms_init()
1234 strlcpy(serio->phys, sunsu_kbd_ms_init()
1236 sizeof(serio->phys)); sunsu_kbd_ms_init()
1238 serio->write = sunsu_serio_write; sunsu_kbd_ms_init()
1239 serio->open = sunsu_serio_open; sunsu_kbd_ms_init()
1240 serio->close = sunsu_serio_close; sunsu_kbd_ms_init()
1241 serio->dev.parent = up->port.dev; sunsu_kbd_ms_init()
1243 serio_register_port(serio); sunsu_kbd_ms_init()
1517 serio_unregister_port(&up->serio); su_remove()
|
| H A D | sunzilog.c | 32 #include <linux/serio.h>
101 struct serio serio; member in struct:uart_sunzilog_port
304 serio_interrupt(&up->serio, ch, 0); sunzilog_kbdms_receive_chars()
319 serio_interrupt(&up->serio, ch, 0); sunzilog_kbdms_receive_chars()
1157 static int sunzilog_serio_write(struct serio *serio, unsigned char ch) sunzilog_serio_write() argument
1159 struct uart_sunzilog_port *up = serio->port_data; sunzilog_serio_write()
1171 static int sunzilog_serio_open(struct serio *serio) sunzilog_serio_open() argument
1173 struct uart_sunzilog_port *up = serio->port_data; sunzilog_serio_open()
1188 static void sunzilog_serio_close(struct serio *serio) sunzilog_serio_close() argument
1190 struct uart_sunzilog_port *up = serio->port_data; sunzilog_serio_close()
1306 struct serio *serio = &up->serio; sunzilog_register_serio() local
1308 serio->port_data = up; sunzilog_register_serio()
1310 serio->id.type = SERIO_RS232; sunzilog_register_serio()
1312 serio->id.proto = SERIO_SUNKBD; sunzilog_register_serio()
1313 strlcpy(serio->name, "zskbd", sizeof(serio->name)); sunzilog_register_serio()
1315 serio->id.proto = SERIO_SUN; sunzilog_register_serio()
1316 serio->id.extra = 1; sunzilog_register_serio()
1317 strlcpy(serio->name, "zsms", sizeof(serio->name)); sunzilog_register_serio()
1319 strlcpy(serio->phys, sunzilog_register_serio()
1322 sizeof(serio->phys)); sunzilog_register_serio()
1324 serio->write = sunzilog_serio_write; sunzilog_register_serio()
1325 serio->open = sunzilog_serio_open; sunzilog_register_serio()
1326 serio->close = sunzilog_serio_close; sunzilog_register_serio()
1327 serio->dev.parent = up->port.dev; sunzilog_register_serio()
1329 serio_register_port(serio); sunzilog_register_serio()
1513 serio_unregister_port(&up->serio); zs_remove_one()
|
| /linux-4.1.27/drivers/input/misc/ |
| H A D | ideapad_slidebar.c | 87 #include <linux/serio.h>
140 struct serio *port) slidebar_i8042_filter()
|
| /linux-4.1.27/drivers/platform/x86/ |
| H A D | hp_accel.c | 41 #include <linux/serio.h>
308 struct serio *port) hp_accel_i8042_filter()
|
| H A D | msi-laptop.c | 819 struct serio *port) msi_laptop_i8042_filter()
|
| H A D | dell-laptop.c | 621 struct serio *port) dell_laptop_i8042_filter()
|
| H A D | toshiba_acpi.c | 2418 struct serio *port) toshiba_acpi_i8042_filter()
|
| /linux-4.1.27/arch/mips/include/asm/ip32/ |
| H A D | mace.h | 236 * -> drivers/input/serio/maceps2.c */
|
| /linux-4.1.27/scripts/mod/ |
| H A D | file2alias.c | 494 /* Looks like: "serio:tyNprNidNexN" */ do_serio_entry()
503 strcpy(alias, "serio:"); do_serio_entry()
512 ADD_TO_DEVTABLE("serio", serio_device_id, do_serio_entry);
|