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