]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - include/linux/serio.h
1 /* SPDX-License-Identifier: GPL-2.0-only */
3 * Copyright (C) 1999-2002 Vojtech Pavlik
9 #include <linux/types.h>
10 #include <linux/interrupt.h>
11 #include <linux/list.h>
12 #include <linux/spinlock.h>
13 #include <linux/mutex.h>
14 #include <linux/device.h>
15 #include <linux/mod_devicetable.h>
16 #include <uapi/linux/serio.h>
18 extern struct bus_type serio_bus
;
25 char firmware_id
[128];
29 struct serio_device_id id
;
31 /* Protects critical sections from port's interrupt handler */
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
*);
41 /* Entry in parent->children list */
42 struct list_head child_node
;
43 struct list_head children
;
44 /* Level of nesting in serio hierarchy */
48 * serio->drv is accessed from interrupt handlers; when modifying
49 * caller should acquire serio->drv_mutex and serio->lock.
51 struct serio_driver
*drv
;
52 /* Protects serio->drv so attributes can pin current driver */
53 struct mutex drv_mutex
;
57 struct list_head node
;
60 * For use by PS/2 layer when several ports share hardware and
61 * may get indigestion when exposed to concurrent access (i8042).
63 struct mutex
*ps2_cmd_mutex
;
65 #define to_serio_port(d) container_of(d, struct serio, dev)
68 const char *description
;
70 const struct serio_device_id
*id_table
;
73 void (*write_wakeup
)(struct serio
*);
74 irqreturn_t (*interrupt
)(struct serio
*, unsigned char, unsigned int);
75 int (*connect
)(struct serio
*, struct serio_driver
*drv
);
76 int (*reconnect
)(struct serio
*);
77 int (*fast_reconnect
)(struct serio
*);
78 void (*disconnect
)(struct serio
*);
79 void (*cleanup
)(struct serio
*);
81 struct device_driver driver
;
83 #define to_serio_driver(d) container_of(d, struct serio_driver, driver)
85 int serio_open(struct serio
*serio
, struct serio_driver
*drv
);
86 void serio_close(struct serio
*serio
);
87 void serio_rescan(struct serio
*serio
);
88 void serio_reconnect(struct serio
*serio
);
89 irqreturn_t
serio_interrupt(struct serio
*serio
, unsigned char data
, unsigned int flags
);
91 void __serio_register_port(struct serio
*serio
, struct module
*owner
);
93 /* use a define to avoid include chaining to get THIS_MODULE */
94 #define serio_register_port(serio) \
95 __serio_register_port(serio, THIS_MODULE)
97 void serio_unregister_port(struct serio
*serio
);
98 void serio_unregister_child_port(struct serio
*serio
);
100 int __must_check
__serio_register_driver(struct serio_driver
*drv
,
101 struct module
*owner
, const char *mod_name
);
103 /* use a define to avoid include chaining to get THIS_MODULE & friends */
104 #define serio_register_driver(drv) \
105 __serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
107 void serio_unregister_driver(struct serio_driver
*drv
);
110 * module_serio_driver() - Helper macro for registering a serio driver
111 * @__serio_driver: serio_driver struct
113 * Helper macro for serio drivers which do not do anything special in
114 * module init/exit. This eliminates a lot of boilerplate. Each module
115 * may only use this macro once, and calling it replaces module_init()
118 #define module_serio_driver(__serio_driver) \
119 module_driver(__serio_driver, serio_register_driver, \
120 serio_unregister_driver)
122 static inline int serio_write(struct serio
*serio
, unsigned char data
)
125 return serio
->write(serio
, data
);
130 static inline void serio_drv_write_wakeup(struct serio
*serio
)
132 if (serio
->drv
&& serio
->drv
->write_wakeup
)
133 serio
->drv
->write_wakeup(serio
);
137 * Use the following functions to manipulate serio's per-port
138 * driver-specific data.
140 static inline void *serio_get_drvdata(struct serio
*serio
)
142 return dev_get_drvdata(&serio
->dev
);
145 static inline void serio_set_drvdata(struct serio
*serio
, void *data
)
147 dev_set_drvdata(&serio
->dev
, data
);
151 * Use the following functions to protect critical sections in
152 * driver code from port's interrupt handler
154 static inline void serio_pause_rx(struct serio
*serio
)
156 spin_lock_irq(&serio
->lock
);
159 static inline void serio_continue_rx(struct serio
*serio
)
161 spin_unlock_irq(&serio
->lock
);