]>
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); |
7c32c4fe HG |
71 | void (*chr_guest_open)(struct CharDriverState *chr); |
72 | void (*chr_guest_close)(struct CharDriverState *chr); | |
87ecb68b | 73 | void *opaque; |
9f939df9 | 74 | int idle_tag; |
5ccfae10 AL |
75 | char *label; |
76 | char *filename; | |
16665b94 | 77 | int be_open; |
c0c4bd2c | 78 | int fe_open; |
19083228 | 79 | int explicit_fe_open; |
d5b27167 | 80 | int avail_connections; |
2274ae9d | 81 | QemuOpts *opts; |
72cf2d4f | 82 | QTAILQ_ENTRY(CharDriverState) next; |
87ecb68b PB |
83 | }; |
84 | ||
2011fe56 AL |
85 | /** |
86 | * @qemu_chr_new_from_opts: | |
87 | * | |
88 | * Create a new character backend from a QemuOpts list. | |
89 | * | |
90 | * @opts see qemu-config.c for a list of valid options | |
91 | * @init not sure.. | |
92 | * | |
93 | * Returns: a new character backend | |
94 | */ | |
f69554b9 | 95 | CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, |
bd2d80b2 GH |
96 | void (*init)(struct CharDriverState *s), |
97 | Error **errp); | |
2011fe56 AL |
98 | |
99 | /** | |
100 | * @qemu_chr_new: | |
101 | * | |
102 | * Create a new character backend from a URI. | |
103 | * | |
104 | * @label the name of the backend | |
105 | * @filename the URI | |
106 | * @init not sure.. | |
107 | * | |
108 | * Returns: a new character backend | |
109 | */ | |
110 | CharDriverState *qemu_chr_new(const char *label, const char *filename, | |
111 | void (*init)(struct CharDriverState *s)); | |
112 | ||
113 | /** | |
114 | * @qemu_chr_delete: | |
115 | * | |
116 | * Destroy a character backend. | |
117 | */ | |
118 | void qemu_chr_delete(CharDriverState *chr); | |
119 | ||
120 | /** | |
121 | * @qemu_chr_fe_set_echo: | |
122 | * | |
123 | * Ask the backend to override its normal echo setting. This only really | |
124 | * applies to the stdio backend and is used by the QMP server such that you | |
125 | * can see what you type if you try to type QMP commands. | |
126 | * | |
127 | * @echo true to enable echo, false to disable echo | |
128 | */ | |
15f31519 | 129 | void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo); |
2011fe56 AL |
130 | |
131 | /** | |
132 | * @qemu_chr_fe_open: | |
133 | * | |
134 | * Open a character backend. This function call is an indication that the | |
135 | * front end is ready to begin doing I/O. | |
136 | */ | |
c9d830ed | 137 | void qemu_chr_fe_open(struct CharDriverState *chr); |
2011fe56 AL |
138 | |
139 | /** | |
140 | * @qemu_chr_fe_close: | |
141 | * | |
142 | * Close a character backend. This function call indicates that the front end | |
143 | * no longer is able to process I/O. To process I/O again, the front end will | |
144 | * call @qemu_chr_fe_open. | |
145 | */ | |
2817822d | 146 | void qemu_chr_fe_close(struct CharDriverState *chr); |
2011fe56 AL |
147 | |
148 | /** | |
149 | * @qemu_chr_fe_printf: | |
150 | * | |
151 | * Write to a character backend using a printf style interface. | |
152 | * | |
153 | * @fmt see #printf | |
154 | */ | |
e7e71b0e | 155 | void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...) |
8b7968f7 | 156 | GCC_FMT_ATTR(2, 3); |
2011fe56 | 157 | |
2c8a5942 KW |
158 | int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond, |
159 | GIOFunc func, void *user_data); | |
23673ca7 | 160 | |
2011fe56 AL |
161 | /** |
162 | * @qemu_chr_fe_write: | |
163 | * | |
164 | * Write data to a character backend from the front end. This function will | |
165 | * send data from the front end to the back end. | |
166 | * | |
167 | * @buf the data | |
168 | * @len the number of bytes to send | |
169 | * | |
170 | * Returns: the number of bytes consumed | |
171 | */ | |
2cc6e0a1 | 172 | int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len); |
2011fe56 | 173 | |
cd18720a AL |
174 | /** |
175 | * @qemu_chr_fe_write_all: | |
176 | * | |
177 | * Write data to a character backend from the front end. This function will | |
178 | * send data from the front end to the back end. Unlike @qemu_chr_fe_write, | |
179 | * this function will block if the back end cannot consume all of the data | |
180 | * attempted to be written. | |
181 | * | |
182 | * @buf the data | |
183 | * @len the number of bytes to send | |
184 | * | |
185 | * Returns: the number of bytes consumed | |
186 | */ | |
187 | int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len); | |
188 | ||
2011fe56 AL |
189 | /** |
190 | * @qemu_chr_fe_ioctl: | |
191 | * | |
192 | * Issue a device specific ioctl to a backend. | |
193 | * | |
194 | * @cmd see CHR_IOCTL_* | |
195 | * @arg the data associated with @cmd | |
196 | * | |
197 | * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the | |
198 | * return value depends on the semantics of @cmd | |
199 | */ | |
200 | int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg); | |
201 | ||
202 | /** | |
203 | * @qemu_chr_fe_get_msgfd: | |
204 | * | |
205 | * For backends capable of fd passing, return the latest file descriptor passed | |
206 | * by a client. | |
207 | * | |
208 | * Returns: -1 if fd passing isn't supported or there is no pending file | |
209 | * descriptor. If a file descriptor is returned, subsequent calls to | |
210 | * this function will return -1 until a client sends a new file | |
211 | * descriptor. | |
212 | */ | |
213 | int qemu_chr_fe_get_msgfd(CharDriverState *s); | |
214 | ||
215 | /** | |
216 | * @qemu_chr_be_can_write: | |
217 | * | |
218 | * Determine how much data the front end can currently accept. This function | |
219 | * returns the number of bytes the front end can accept. If it returns 0, the | |
220 | * front end cannot receive data at the moment. The function must be polled | |
221 | * to determine when data can be received. | |
222 | * | |
223 | * Returns: the number of bytes the front end can receive via @qemu_chr_be_write | |
224 | */ | |
225 | int qemu_chr_be_can_write(CharDriverState *s); | |
226 | ||
227 | /** | |
228 | * @qemu_chr_be_write: | |
229 | * | |
230 | * Write data from the back end to the front end. Before issuing this call, | |
231 | * the caller should call @qemu_chr_be_can_write to determine how much data | |
232 | * the front end can currently accept. | |
233 | * | |
234 | * @buf a buffer to receive data from the front end | |
235 | * @len the number of bytes to receive from the front end | |
236 | */ | |
237 | void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len); | |
238 | ||
a425d23f HG |
239 | |
240 | /** | |
241 | * @qemu_chr_be_event: | |
242 | * | |
243 | * Send an event from the back end to the front end. | |
244 | * | |
245 | * @event the event to send | |
246 | */ | |
247 | void qemu_chr_be_event(CharDriverState *s, int event); | |
248 | ||
87ecb68b | 249 | void qemu_chr_add_handlers(CharDriverState *s, |
7b27a769 | 250 | IOCanReadHandler *fd_can_read, |
87ecb68b PB |
251 | IOReadHandler *fd_read, |
252 | IOEventHandler *fd_event, | |
253 | void *opaque); | |
2011fe56 | 254 | |
fee204fd | 255 | void qemu_chr_be_generic_open(CharDriverState *s); |
bd9bdce6 | 256 | void qemu_chr_accept_input(CharDriverState *s); |
13661089 | 257 | int qemu_chr_add_client(CharDriverState *s, int fd); |
588b3832 LC |
258 | void qemu_chr_info_print(Monitor *mon, const QObject *ret_data); |
259 | void qemu_chr_info(Monitor *mon, QObject **ret_data); | |
c845f401 | 260 | CharDriverState *qemu_chr_find(const char *name); |
87ecb68b | 261 | |
2011fe56 AL |
262 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
263 | ||
d654f34e | 264 | void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *)); |
2c5f4882 GH |
265 | void register_char_driver_qapi(const char *name, int kind, |
266 | void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp)); | |
d654f34e | 267 | |
6cbf4c8c CM |
268 | /* add an eventfd to the qemu devices that are polled */ |
269 | CharDriverState *qemu_chr_open_eventfd(int eventfd); | |
270 | ||
0e82f34d AL |
271 | extern int term_escape_char; |
272 | ||
999bd67c LC |
273 | /* memory chardev */ |
274 | void qemu_chr_init_mem(CharDriverState *chr); | |
275 | void qemu_chr_close_mem(CharDriverState *chr); | |
276 | QString *qemu_chr_mem_to_qs(CharDriverState *chr); | |
277 | size_t qemu_chr_mem_osize(const CharDriverState *chr); | |
278 | ||
0beb4942 AL |
279 | CharDriverState *qemu_char_get_next_serial(void); |
280 | ||
f5a51cab GH |
281 | /* msmouse */ |
282 | CharDriverState *qemu_chr_open_msmouse(void); | |
283 | ||
2d57286d GH |
284 | /* baum.c */ |
285 | CharDriverState *chr_baum_init(void); | |
286 | ||
87ecb68b | 287 | #endif |