]> git.proxmox.com Git - mirror_qemu.git/blob - qemu-char.h
usb: Call wakeup when data becomes available for all devices with int eps
[mirror_qemu.git] / qemu-char.h
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.h"
8 #include "qemu-aio.h"
9 #include "qobject.h"
10 #include "qstring.h"
11 #include "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 void (*chr_update_read_handler)(struct CharDriverState *s);
60 int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
61 int (*get_msgfd)(struct CharDriverState *s);
62 int (*chr_add_client)(struct CharDriverState *chr, int fd);
63 IOEventHandler *chr_event;
64 IOCanReadHandler *chr_can_read;
65 IOReadHandler *chr_read;
66 void *handler_opaque;
67 void (*chr_close)(struct CharDriverState *chr);
68 void (*chr_accept_input)(struct CharDriverState *chr);
69 void (*chr_set_echo)(struct CharDriverState *chr, bool echo);
70 void (*chr_guest_open)(struct CharDriverState *chr);
71 void (*chr_guest_close)(struct CharDriverState *chr);
72 void *opaque;
73 QEMUTimer *open_timer;
74 char *label;
75 char *filename;
76 int opened;
77 int avail_connections;
78 QTAILQ_ENTRY(CharDriverState) next;
79 };
80
81 /**
82 * @qemu_chr_new_from_opts:
83 *
84 * Create a new character backend from a QemuOpts list.
85 *
86 * @opts see qemu-config.c for a list of valid options
87 * @init not sure..
88 *
89 * Returns: a new character backend
90 */
91 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
92 void (*init)(struct CharDriverState *s));
93
94 /**
95 * @qemu_chr_new:
96 *
97 * Create a new character backend from a URI.
98 *
99 * @label the name of the backend
100 * @filename the URI
101 * @init not sure..
102 *
103 * Returns: a new character backend
104 */
105 CharDriverState *qemu_chr_new(const char *label, const char *filename,
106 void (*init)(struct CharDriverState *s));
107
108 /**
109 * @qemu_chr_delete:
110 *
111 * Destroy a character backend.
112 */
113 void qemu_chr_delete(CharDriverState *chr);
114
115 /**
116 * @qemu_chr_fe_set_echo:
117 *
118 * Ask the backend to override its normal echo setting. This only really
119 * applies to the stdio backend and is used by the QMP server such that you
120 * can see what you type if you try to type QMP commands.
121 *
122 * @echo true to enable echo, false to disable echo
123 */
124 void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo);
125
126 /**
127 * @qemu_chr_fe_open:
128 *
129 * Open a character backend. This function call is an indication that the
130 * front end is ready to begin doing I/O.
131 */
132 void qemu_chr_fe_open(struct CharDriverState *chr);
133
134 /**
135 * @qemu_chr_fe_close:
136 *
137 * Close a character backend. This function call indicates that the front end
138 * no longer is able to process I/O. To process I/O again, the front end will
139 * call @qemu_chr_fe_open.
140 */
141 void qemu_chr_fe_close(struct CharDriverState *chr);
142
143 /**
144 * @qemu_chr_fe_printf:
145 *
146 * Write to a character backend using a printf style interface.
147 *
148 * @fmt see #printf
149 */
150 void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
151 GCC_FMT_ATTR(2, 3);
152
153 /**
154 * @qemu_chr_fe_write:
155 *
156 * Write data to a character backend from the front end. This function will
157 * send data from the front end to the back end.
158 *
159 * @buf the data
160 * @len the number of bytes to send
161 *
162 * Returns: the number of bytes consumed
163 */
164 int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len);
165
166 /**
167 * @qemu_chr_fe_ioctl:
168 *
169 * Issue a device specific ioctl to a backend.
170 *
171 * @cmd see CHR_IOCTL_*
172 * @arg the data associated with @cmd
173 *
174 * Returns: if @cmd is not supported by the backend, -ENOTSUP, otherwise the
175 * return value depends on the semantics of @cmd
176 */
177 int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg);
178
179 /**
180 * @qemu_chr_fe_get_msgfd:
181 *
182 * For backends capable of fd passing, return the latest file descriptor passed
183 * by a client.
184 *
185 * Returns: -1 if fd passing isn't supported or there is no pending file
186 * descriptor. If a file descriptor is returned, subsequent calls to
187 * this function will return -1 until a client sends a new file
188 * descriptor.
189 */
190 int qemu_chr_fe_get_msgfd(CharDriverState *s);
191
192 /**
193 * @qemu_chr_be_can_write:
194 *
195 * Determine how much data the front end can currently accept. This function
196 * returns the number of bytes the front end can accept. If it returns 0, the
197 * front end cannot receive data at the moment. The function must be polled
198 * to determine when data can be received.
199 *
200 * Returns: the number of bytes the front end can receive via @qemu_chr_be_write
201 */
202 int qemu_chr_be_can_write(CharDriverState *s);
203
204 /**
205 * @qemu_chr_be_write:
206 *
207 * Write data from the back end to the front end. Before issuing this call,
208 * the caller should call @qemu_chr_be_can_write to determine how much data
209 * the front end can currently accept.
210 *
211 * @buf a buffer to receive data from the front end
212 * @len the number of bytes to receive from the front end
213 */
214 void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len);
215
216
217 /**
218 * @qemu_chr_be_event:
219 *
220 * Send an event from the back end to the front end.
221 *
222 * @event the event to send
223 */
224 void qemu_chr_be_event(CharDriverState *s, int event);
225
226 void qemu_chr_add_handlers(CharDriverState *s,
227 IOCanReadHandler *fd_can_read,
228 IOReadHandler *fd_read,
229 IOEventHandler *fd_event,
230 void *opaque);
231
232 void qemu_chr_generic_open(CharDriverState *s);
233 void qemu_chr_accept_input(CharDriverState *s);
234 int qemu_chr_add_client(CharDriverState *s, int fd);
235 void qemu_chr_info_print(Monitor *mon, const QObject *ret_data);
236 void qemu_chr_info(Monitor *mon, QObject **ret_data);
237 CharDriverState *qemu_chr_find(const char *name);
238
239 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
240
241 /* add an eventfd to the qemu devices that are polled */
242 CharDriverState *qemu_chr_open_eventfd(int eventfd);
243
244 extern int term_escape_char;
245
246 /* memory chardev */
247 void qemu_chr_init_mem(CharDriverState *chr);
248 void qemu_chr_close_mem(CharDriverState *chr);
249 QString *qemu_chr_mem_to_qs(CharDriverState *chr);
250 size_t qemu_chr_mem_osize(const CharDriverState *chr);
251
252 CharDriverState *qemu_char_get_next_serial(void);
253
254 #endif