root / include / sysemu / char.h @ dccfcd0e
History | View | Annotate | Download (8.9 kB)
1 |
#ifndef QEMU_CHAR_H
|
---|---|
2 |
#define QEMU_CHAR_H
|
3 |
|
4 |
#include "qemu-common.h" |
5 |
#include "qemu/queue.h" |
6 |
#include "qemu/option.h" |
7 |
#include "qemu/config-file.h" |
8 |
#include "block/aio.h" |
9 |
#include "qapi/qmp/qobject.h" |
10 |
#include "qapi/qmp/qstring.h" |
11 |
#include "qemu/main-loop.h" |
12 |
|
13 |
/* character device */
|
14 |
|
15 |
#define CHR_EVENT_BREAK 0 /* serial break char */ |
16 |
#define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */ |
17 |
#define CHR_EVENT_OPENED 2 /* new connection established */ |
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 */ |
20 |
#define CHR_EVENT_CLOSED 5 /* connection closed */ |
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 |
42 |
#define CHR_IOCTL_PP_DATA_DIR 12 |
43 |
|
44 |
#define CHR_IOCTL_SERIAL_SET_TIOCM 13 |
45 |
#define CHR_IOCTL_SERIAL_GET_TIOCM 14 |
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 |
|
54 |
typedef void IOEventHandler(void *opaque, int event); |
55 |
|
56 |
struct CharDriverState {
|
57 |
void (*init)(struct CharDriverState *s); |
58 |
int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len); |
59 |
GSource *(*chr_add_watch)(struct CharDriverState *s, GIOCondition cond);
|
60 |
void (*chr_update_read_handler)(struct CharDriverState *s); |
61 |
int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg); |
62 |
int (*get_msgfd)(struct CharDriverState *s); |
63 |
int (*chr_add_client)(struct CharDriverState *chr, int fd); |
64 |
IOEventHandler *chr_event; |
65 |
IOCanReadHandler *chr_can_read; |
66 |
IOReadHandler *chr_read; |
67 |
void *handler_opaque;
|
68 |
void (*chr_close)(struct CharDriverState *chr); |
69 |
void (*chr_accept_input)(struct CharDriverState *chr); |
70 |
void (*chr_set_echo)(struct CharDriverState *chr, bool echo); |
71 |
void (*chr_set_fe_open)(struct CharDriverState *chr, int fe_open); |
72 |
void *opaque;
|
73 |
int idle_tag;
|
74 |
char *label;
|
75 |
char *filename;
|
76 |
int be_open;
|
77 |
int fe_open;
|
78 |
int explicit_fe_open;
|
79 |
int avail_connections;
|
80 |
QemuOpts *opts; |
81 |
QTAILQ_ENTRY(CharDriverState) next; |
82 |
}; |
83 |
|
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 |
*/
|
94 |
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, |
95 |
void (*init)(struct CharDriverState *s), |
96 |
Error **errp); |
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 |
*/
|
128 |
void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo); |
129 |
|
130 |
/**
|
131 |
* @qemu_chr_fe_set_open:
|
132 |
*
|
133 |
* Set character frontend open status. This is an indication that the
|
134 |
* front end is ready (or not) to begin doing I/O.
|
135 |
*/
|
136 |
void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open); |
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 |
*/
|
145 |
void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...) |
146 |
GCC_FMT_ATTR(2, 3); |
147 |
|
148 |
int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
|
149 |
GIOFunc func, void *user_data);
|
150 |
|
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 |
*/
|
162 |
int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len); |
163 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
268 |
void qemu_chr_add_handlers(CharDriverState *s,
|
269 |
IOCanReadHandler *fd_can_read, |
270 |
IOReadHandler *fd_read, |
271 |
IOEventHandler *fd_event, |
272 |
void *opaque);
|
273 |
|
274 |
void qemu_chr_be_generic_open(CharDriverState *s);
|
275 |
void qemu_chr_accept_input(CharDriverState *s);
|
276 |
int qemu_chr_add_client(CharDriverState *s, int fd); |
277 |
void qemu_chr_info_print(Monitor *mon, const QObject *ret_data); |
278 |
void qemu_chr_info(Monitor *mon, QObject **ret_data);
|
279 |
CharDriverState *qemu_chr_find(const char *name); |
280 |
|
281 |
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
282 |
|
283 |
void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *)); |
284 |
void register_char_driver_qapi(const char *name, int kind, |
285 |
void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp));
|
286 |
|
287 |
/* add an eventfd to the qemu devices that are polled */
|
288 |
CharDriverState *qemu_chr_open_eventfd(int eventfd);
|
289 |
|
290 |
extern int term_escape_char; |
291 |
|
292 |
/* memory chardev */
|
293 |
void qemu_chr_init_mem(CharDriverState *chr);
|
294 |
void qemu_chr_close_mem(CharDriverState *chr);
|
295 |
QString *qemu_chr_mem_to_qs(CharDriverState *chr); |
296 |
size_t qemu_chr_mem_osize(const CharDriverState *chr);
|
297 |
|
298 |
CharDriverState *qemu_char_get_next_serial(void);
|
299 |
|
300 |
/* msmouse */
|
301 |
CharDriverState *qemu_chr_open_msmouse(void);
|
302 |
|
303 |
/* baum.c */
|
304 |
CharDriverState *chr_baum_init(void);
|
305 |
|
306 |
#endif
|