root / include / char / char.h @ 5cc11c46
History | View | Annotate | Download (8 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_guest_open)(struct CharDriverState *chr); |
72 |
void (*chr_guest_close)(struct CharDriverState *chr); |
73 |
void *opaque;
|
74 |
int idle_tag;
|
75 |
char *label;
|
76 |
char *filename;
|
77 |
int opened;
|
78 |
int avail_connections;
|
79 |
QemuOpts *opts; |
80 |
QTAILQ_ENTRY(CharDriverState) next; |
81 |
}; |
82 |
|
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 |
*/
|
93 |
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, |
94 |
void (*init)(struct CharDriverState *s), |
95 |
Error **errp); |
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 |
*/
|
127 |
void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo); |
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 |
*/
|
135 |
void qemu_chr_fe_open(struct CharDriverState *chr); |
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 |
*/
|
144 |
void qemu_chr_fe_close(struct CharDriverState *chr); |
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 |
*/
|
153 |
void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...) |
154 |
GCC_FMT_ATTR(2, 3); |
155 |
|
156 |
int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
|
157 |
GIOFunc func, void *user_data);
|
158 |
|
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 |
*/
|
170 |
int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len); |
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 |
|
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 |
|
232 |
void qemu_chr_add_handlers(CharDriverState *s,
|
233 |
IOCanReadHandler *fd_can_read, |
234 |
IOReadHandler *fd_read, |
235 |
IOEventHandler *fd_event, |
236 |
void *opaque);
|
237 |
|
238 |
void qemu_chr_generic_open(CharDriverState *s);
|
239 |
void qemu_chr_accept_input(CharDriverState *s);
|
240 |
int qemu_chr_add_client(CharDriverState *s, int fd); |
241 |
void qemu_chr_info_print(Monitor *mon, const QObject *ret_data); |
242 |
void qemu_chr_info(Monitor *mon, QObject **ret_data);
|
243 |
CharDriverState *qemu_chr_find(const char *name); |
244 |
|
245 |
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); |
246 |
|
247 |
void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *)); |
248 |
void register_char_driver_qapi(const char *name, int kind, |
249 |
void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp));
|
250 |
|
251 |
/* add an eventfd to the qemu devices that are polled */
|
252 |
CharDriverState *qemu_chr_open_eventfd(int eventfd);
|
253 |
|
254 |
extern int term_escape_char; |
255 |
|
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 |
|
262 |
CharDriverState *qemu_char_get_next_serial(void);
|
263 |
|
264 |
/* msmouse */
|
265 |
CharDriverState *qemu_chr_open_msmouse(void);
|
266 |
|
267 |
/* baum.c */
|
268 |
CharDriverState *chr_baum_init(void);
|
269 |
|
270 |
#endif
|