]>
Commit | Line | Data |
---|---|---|
87ecb68b PB |
1 | #ifndef QEMU_CHAR_H |
2 | #define QEMU_CHAR_H | |
3 | ||
376253ec | 4 | #include "qemu-common.h" |
1de7afc9 PB |
5 | #include "qemu/queue.h" |
6 | #include "qemu/option.h" | |
7 | #include "qemu/config-file.h" | |
737e150e | 8 | #include "block/aio.h" |
7b1b5d19 PB |
9 | #include "qapi/qmp/qobject.h" |
10 | #include "qapi/qmp/qstring.h" | |
1de7afc9 | 11 | #include "qemu/main-loop.h" |
376253ec | 12 | |
87ecb68b PB |
13 | /* character device */ |
14 | ||
2724b180 AL |
15 | #define CHR_EVENT_BREAK 0 /* serial break char */ |
16 | #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */ | |
b6b8df56 | 17 | #define CHR_EVENT_OPENED 2 /* new connection established */ |
2724b180 AL |
18 | #define CHR_EVENT_MUX_IN 3 /* mux-focus was set to this terminal */ |
19 | #define CHR_EVENT_MUX_OUT 4 /* mux-focus will move on */ | |
793cbfb5 | 20 | #define CHR_EVENT_CLOSED 5 /* connection closed */ |
87ecb68b PB |
21 | |
22 | ||
23 | #define CHR_IOCTL_SERIAL_SET_PARAMS 1 | |
24 | typedef struct { | |
25 | int speed; | |
26 | int parity; | |
27 | int data_bits; | |
28 | int stop_bits; | |
29 | } QEMUSerialSetParams; | |
30 | ||
31 | #define CHR_IOCTL_SERIAL_SET_BREAK 2 | |
32 | ||
33 | #define CHR_IOCTL_PP_READ_DATA 3 | |
34 | #define CHR_IOCTL_PP_WRITE_DATA 4 | |
35 | #define CHR_IOCTL_PP_READ_CONTROL 5 | |
36 | #define CHR_IOCTL_PP_WRITE_CONTROL 6 | |
37 | #define CHR_IOCTL_PP_READ_STATUS 7 | |
38 | #define CHR_IOCTL_PP_EPP_READ_ADDR 8 | |
39 | #define CHR_IOCTL_PP_EPP_READ 9 | |
40 | #define CHR_IOCTL_PP_EPP_WRITE_ADDR 10 | |
41 | #define CHR_IOCTL_PP_EPP_WRITE 11 | |
563e3c6e | 42 | #define CHR_IOCTL_PP_DATA_DIR 12 |
87ecb68b | 43 | |
f0664048 AJ |
44 | #define CHR_IOCTL_SERIAL_SET_TIOCM 13 |
45 | #define CHR_IOCTL_SERIAL_GET_TIOCM 14 | |
81174dae AL |
46 | |
47 | #define CHR_TIOCM_CTS 0x020 | |
48 | #define CHR_TIOCM_CAR 0x040 | |
49 | #define CHR_TIOCM_DSR 0x100 | |
50 | #define CHR_TIOCM_RI 0x080 | |
51 | #define CHR_TIOCM_DTR 0x002 | |
52 | #define CHR_TIOCM_RTS 0x004 | |
53 | ||
87ecb68b PB |
54 | typedef void IOEventHandler(void *opaque, int event); |
55 | ||
56 | struct CharDriverState { | |
ceecf1d1 | 57 | void (*init)(struct CharDriverState *s); |
87ecb68b | 58 | int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len); |
23673ca7 | 59 | GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond); |
87ecb68b PB |
60 | void (*chr_update_read_handler)(struct CharDriverState *s); |
61 | int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg); | |
7d174059 | 62 | int (*get_msgfd)(struct CharDriverState *s); |
13661089 | 63 | int (*chr_add_client)(struct CharDriverState *chr, int fd); |
87ecb68b | 64 | IOEventHandler *chr_event; |
7b27a769 | 65 | IOCanReadHandler *chr_can_read; |
87ecb68b PB |
66 | IOReadHandler *chr_read; |
67 | void *handler_opaque; | |
87ecb68b | 68 | void (*chr_close)(struct CharDriverState *chr); |
bd9bdce6 | 69 | void (*chr_accept_input)(struct CharDriverState *chr); |
c48855e1 | 70 | void (*chr_set_echo)(struct CharDriverState *chr, bool echo); |
574b711a | 71 | void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open); |
87ecb68b | 72 | void *opaque; |
9f939df9 | 73 | int idle_tag; |
5ccfae10 AL |
74 | char *label; |
75 | char *filename; | |
16665b94 | 76 | int be_open; |
c0c4bd2c | 77 | int fe_open; |
19083228 | 78 | int explicit_fe_open; |
d5b27167 | 79 | int avail_connections; |
2274ae9d | 80 | QemuOpts *opts; |
72cf2d4f | 81 | QTAILQ_ENTRY(CharDriverState) next; |
87ecb68b PB |
82 | }; |
83 | ||
2011fe56 AL |
84 | /** |
85 | * @qemu_chr_new_from_opts: | |
86 | * | |
87 | * Create a new character backend from a QemuOpts list. | |
88 | * | |
89 | * @opts see qemu-config.c for a list of valid options | |
90 | * @init not sure.. | |
91 | * | |
92 | * Returns: a new character backend | |
93 | */ | |
f69554b9 | 94 | CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, |
bd2d80b2 GH |
95 | void (*init)(struct CharDriverState *s), |
96 | Error **errp); | |
2011fe56 AL |
97 | |
98 | /** | |
99 | * @qemu_chr_new: | |
100 | * | |
101 | * Create a new character backend from a URI. | |
102 | * | |
103 | * @label the name of the backend | |
104 | * @filename the URI | |
105 | * @init not sure.. | |
106 | * | |
107 | * Returns: a new character backend | |
108 | */ | |
109 | CharDriverState *qemu_chr_new(const char *label, const char *filename, | |
110 | void (*init)(struct CharDriverState *s)); | |
111 | ||
112 | /** | |
113 | * @qemu_chr_delete: | |
114 | * | |
115 | * Destroy a character backend. | |
116 | */ | |
117 | void qemu_chr_delete(CharDriverState *chr); | |
118 | ||
119 | /** | |
120 | * @qemu_chr_fe_set_echo: | |
121 | * | |
122 | * Ask the backend to override its normal echo setting. This only really | |
123 | * applies to the stdio backend and is used by the QMP server such that you | |
124 | * can see what you type if you try to type QMP commands. | |
125 | * | |
126 | * @echo true to enable echo, false to disable echo | |
127 | */ | |
15f31519 | 128 | void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo); |
2011fe56 AL |
129 | |
130 | /** | |
8e25daa8 | 131 | * @qemu_chr_fe_set_open: |
2011fe56 | 132 | * |
8e25daa8 HG |
133 | * Set character frontend open status. This is an indication that the |
134 | * front end is ready (or not) to begin doing I/O. | |
2011fe56 | 135 | */ |
8e25daa8 | 136 | void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open); |
2011fe56 AL |
137 | |
138 | /** | |
139 | * @qemu_chr_fe_printf: | |
140 | * | |
141 | * Write to a character backend using a printf style interface. | |
142 | * | |
143 | * @fmt see #printf | |
144 | */ | |
e7e71b0e | 145 | void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...) |
8b7968f7 | 146 | GCC_FMT_ATTR(2, 3); |
2011fe56 | 147 | |
2c8a5942 KW |
148 | int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond, |
149 | GIOFunc func, void *user_data); | |
23673ca7 | 150 | |
2011fe56 AL |
151 | /** |
152 | * @qemu_chr_fe_write: | |
153 | * | |
154 | * Write data to a character backend from the front end. This function will | |
155 | * send data from the front end to the back end. | |
156 | * | |
157 | * @buf the data | |
158 | * @len the number of bytes to send | |
159 | * | |
160 | * Returns: the number of bytes consumed | |
161 | */ | |
2cc6e0a1 | 162 | int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len); |
2011fe56 | 163 | |
cd18720a AL |
164 | /** |
165 | * @qemu_chr_fe_write_all: | |
166 | * | |
167 | * Write data to a character backend from the front end. This function will | |
168 | * send data from the front end to the back end. Unlike @qemu_chr_fe_write, | |
169 | * this function will block if the back end cannot consume all of the data | |
170 | * attempted to be written. | |
171 | * | |
172 | * @buf the data | |
173 | * @len the number of bytes to send | |
174 | * | |
175 | * Returns: the number of bytes consumed | |
176 | */ | |
177 | int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len); | |
178 | ||
2011fe56 AL |
179 | /** |
180 | * @qemu_chr_fe_ioctl: | |
181 | * | |
182 | * Issue a device specific ioctl to a backend. | |
183 | * | |
184 | * @cmd see CHR_IOCTL_* | |
185 | * @arg the data associated with @cmd | |
186 | * | |
187 | * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the | |
188 | * return value depends on the semantics of @cmd | |
189 | */ | |
190 | int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg); | |
191 | ||
192 | /** | |
193 | * @qemu_chr_fe_get_msgfd: | |
194 | * | |
195 | * For backends capable of fd passing, return the latest file descriptor passed | |
196 | * by a client. | |
197 | * | |
198 | * Returns: -1 if fd passing isn't supported or there is no pending file | |
199 | * descriptor. If a file descriptor is returned, subsequent calls to | |
200 | * this function will return -1 until a client sends a new file | |
201 | * descriptor. | |
202 | */ | |
203 | int qemu_chr_fe_get_msgfd(CharDriverState *s); | |
204 | ||
44c473de HG |
205 | /** |
206 | * @qemu_chr_fe_claim: | |
207 | * | |
208 | * Claim a backend before using it, should be called before calling | |
209 | * qemu_chr_add_handlers(). | |
210 | * | |
211 | * Returns: -1 if the backend is already in use by another frontend, 0 on | |
212 | * success. | |
213 | */ | |
214 | int qemu_chr_fe_claim(CharDriverState *s); | |
215 | ||
216 | /** | |
217 | * @qemu_chr_fe_claim_no_fail: | |
218 | * | |
219 | * Like qemu_chr_fe_claim, but will exit qemu with an error when the | |
220 | * backend is already in use. | |
221 | */ | |
222 | void qemu_chr_fe_claim_no_fail(CharDriverState *s); | |
223 | ||
224 | /** | |
225 | * @qemu_chr_fe_claim: | |
226 | * | |
227 | * Release a backend for use by another frontend. | |
228 | * | |
229 | * Returns: -1 if the backend is already in use by another frontend, 0 on | |
230 | * success. | |
231 | */ | |
232 | void qemu_chr_fe_release(CharDriverState *s); | |
233 | ||
2011fe56 AL |
234 | /** |
235 | * @qemu_chr_be_can_write: | |
236 | * | |
237 | * Determine how much data the front end can currently accept. This function | |
238 | * returns the number of bytes the front end can accept. If it returns 0, the | |
239 | * front end cannot receive data at the moment. The function must be polled | |
240 | * to determine when data can be received. | |
241 | * | |
242 | * Returns: the number of bytes the front end can receive via @qemu_chr_be_write | |
243 | */ | |
244 | int qemu_chr_be_can_write(CharDriverState *s); | |
245 | ||
246 | /** | |
247 | * @qemu_chr_be_write: | |
248 | * | |
249 | * Write data from the back end to the front end. Before issuing this call, | |
250 | * the caller should call @qemu_chr_be_can_write to determine how much data | |
251 | * the front end can currently accept. | |
252 | * | |
253 | * @buf a buffer to receive data from the front end | |
254 | * @len the number of bytes to receive from the front end | |
255 | */ | |
256 | void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len); | |
257 | ||
a425d23f HG |
258 | |
259 | /** | |
260 | * @qemu_chr_be_event: | |
261 | * | |
262 | * Send an event from the back end to the front end. | |
263 | * | |
264 | * @event the event to send | |
265 | */ | |
266 | void qemu_chr_be_event(CharDriverState *s, int event); | |
267 | ||
87ecb68b | 268 | void qemu_chr_add_handlers(CharDriverState *s, |
7b27a769 | 269 | IOCanReadHandler *fd_can_read, |
87ecb68b PB |
270 | IOReadHandler *fd_read, |
271 | IOEventHandler *fd_event, | |
272 | void *opaque); | |
2011fe56 | 273 | |
fee204fd | 274 | void qemu_chr_be_generic_open(CharDriverState *s); |
bd9bdce6 | 275 | void qemu_chr_accept_input(CharDriverState *s); |
13661089 | 276 | int qemu_chr_add_client(CharDriverState *s, int fd); |
588b3832 LC |
277 | void qemu_chr_info_print(Monitor *mon, const QObject *ret_data); |
278 | void qemu_chr_info(Monitor *mon, QObject **ret_data); | |
c845f401 | 279 | CharDriverState *qemu_chr_find(const char *name); |
87ecb68b | 280 | |
2011fe56 AL |
281 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
282 | ||
d654f34e | 283 | void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *)); |
2c5f4882 GH |
284 | void register_char_driver_qapi(const char *name, int kind, |
285 | void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp)); | |
d654f34e | 286 | |
6cbf4c8c CM |
287 | /* add an eventfd to the qemu devices that are polled */ |
288 | CharDriverState *qemu_chr_open_eventfd(int eventfd); | |
289 | ||
0e82f34d AL |
290 | extern int term_escape_char; |
291 | ||
0beb4942 AL |
292 | CharDriverState *qemu_char_get_next_serial(void); |
293 | ||
f5a51cab GH |
294 | /* msmouse */ |
295 | CharDriverState *qemu_chr_open_msmouse(void); | |
296 | ||
2d57286d GH |
297 | /* baum.c */ |
298 | CharDriverState *chr_baum_init(void); | |
299 | ||
87ecb68b | 300 | #endif |