]>
Commit | Line | Data |
---|---|---|
98b19252 AS |
1 | /* |
2 | * Virtio Serial / Console Support | |
3 | * | |
4 | * Copyright IBM, Corp. 2008 | |
71c092e9 | 5 | * Copyright Red Hat, Inc. 2009, 2010 |
98b19252 AS |
6 | * |
7 | * Authors: | |
8 | * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com> | |
9 | * Amit Shah <amit.shah@redhat.com> | |
10 | * | |
11 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
12 | * the COPYING file in the top-level directory. | |
13 | * | |
14 | */ | |
15 | #ifndef _QEMU_VIRTIO_SERIAL_H | |
16 | #define _QEMU_VIRTIO_SERIAL_H | |
17 | ||
83c9f4ca | 18 | #include "hw/qdev.h" |
0d09e41a | 19 | #include "hw/virtio/virtio.h" |
98b19252 AS |
20 | |
21 | /* == Interface shared between the guest kernel and qemu == */ | |
22 | ||
23 | /* The Virtio ID for virtio console / serial ports */ | |
24 | #define VIRTIO_ID_CONSOLE 3 | |
25 | ||
26 | /* Features supported */ | |
27 | #define VIRTIO_CONSOLE_F_MULTIPORT 1 | |
28 | ||
055b889f AS |
29 | #define VIRTIO_CONSOLE_BAD_ID (~(uint32_t)0) |
30 | ||
98b19252 AS |
31 | struct virtio_console_config { |
32 | /* | |
33 | * These two fields are used by VIRTIO_CONSOLE_F_SIZE which | |
34 | * isn't implemented here yet | |
35 | */ | |
36 | uint16_t cols; | |
37 | uint16_t rows; | |
38 | ||
39 | uint32_t max_nr_ports; | |
541dc0d4 | 40 | } QEMU_PACKED; |
98b19252 AS |
41 | |
42 | struct virtio_console_control { | |
43 | uint32_t id; /* Port number */ | |
44 | uint16_t event; /* The kind of control event (see below) */ | |
45 | uint16_t value; /* Extra information for the key */ | |
46 | }; | |
47 | ||
6b331efb AS |
48 | struct virtio_serial_conf { |
49 | /* Max. number of ports we can have for a virtio-serial device */ | |
50 | uint32_t max_virtserial_ports; | |
51 | }; | |
52 | ||
98b19252 | 53 | /* Some events for the internal messages (control packets) */ |
055b889f AS |
54 | #define VIRTIO_CONSOLE_DEVICE_READY 0 |
55 | #define VIRTIO_CONSOLE_PORT_ADD 1 | |
56 | #define VIRTIO_CONSOLE_PORT_REMOVE 2 | |
57 | #define VIRTIO_CONSOLE_PORT_READY 3 | |
58 | #define VIRTIO_CONSOLE_CONSOLE_PORT 4 | |
59 | #define VIRTIO_CONSOLE_RESIZE 5 | |
60 | #define VIRTIO_CONSOLE_PORT_OPEN 6 | |
61 | #define VIRTIO_CONSOLE_PORT_NAME 7 | |
98b19252 AS |
62 | |
63 | /* == In-qemu interface == */ | |
64 | ||
f82e35e3 AL |
65 | #define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port" |
66 | #define VIRTIO_SERIAL_PORT(obj) \ | |
67 | OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT) | |
68 | #define VIRTIO_SERIAL_PORT_CLASS(klass) \ | |
69 | OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT) | |
70 | #define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \ | |
71 | OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT) | |
72 | ||
98b19252 AS |
73 | typedef struct VirtIOSerial VirtIOSerial; |
74 | typedef struct VirtIOSerialBus VirtIOSerialBus; | |
75 | typedef struct VirtIOSerialPort VirtIOSerialPort; | |
f82e35e3 AL |
76 | |
77 | typedef struct VirtIOSerialPortClass { | |
78 | DeviceClass parent_class; | |
79 | ||
80 | /* Is this a device that binds with hvc in the guest? */ | |
81 | bool is_console; | |
82 | ||
83 | /* | |
84 | * The per-port (or per-app) init function that's called when a | |
85 | * new device is found on the bus. | |
86 | */ | |
87 | int (*init)(VirtIOSerialPort *port); | |
88 | /* | |
89 | * Per-port exit function that's called when a port gets | |
90 | * hot-unplugged or removed. | |
91 | */ | |
92 | int (*exit)(VirtIOSerialPort *port); | |
93 | ||
94 | /* Callbacks for guest events */ | |
b2c1394a HG |
95 | /* Guest opened/closed device. */ |
96 | void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected); | |
f82e35e3 AL |
97 | |
98 | /* Guest is now ready to accept data (virtqueues set up). */ | |
99 | void (*guest_ready)(VirtIOSerialPort *port); | |
100 | ||
101 | /* | |
102 | * Guest wrote some data to the port. This data is handed over to | |
103 | * the app via this callback. The app can return a size less than | |
104 | * 'len'. In this case, throttling will be enabled for this port. | |
105 | */ | |
106 | ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf, | |
107 | size_t len); | |
108 | } VirtIOSerialPortClass; | |
98b19252 | 109 | |
98b19252 AS |
110 | /* |
111 | * This is the state that's shared between all the ports. Some of the | |
112 | * state is configurable via command-line options. Some of it can be | |
113 | * set by individual devices in their initfn routines. Some of the | |
114 | * state is set by the generic qdev device init routine. | |
115 | */ | |
116 | struct VirtIOSerialPort { | |
117 | DeviceState dev; | |
98b19252 AS |
118 | |
119 | QTAILQ_ENTRY(VirtIOSerialPort) next; | |
120 | ||
121 | /* | |
122 | * This field gives us the virtio device as well as the qdev bus | |
123 | * that we are associated with | |
124 | */ | |
125 | VirtIOSerial *vser; | |
126 | ||
127 | VirtQueue *ivq, *ovq; | |
128 | ||
160600fd AS |
129 | /* |
130 | * This name is sent to the guest and exported via sysfs. | |
131 | * The guest could create symlinks based on this information. | |
132 | * The name is in the reverse fqdn format, like org.qemu.console.0 | |
133 | */ | |
134 | char *name; | |
135 | ||
98b19252 AS |
136 | /* |
137 | * This id helps identify ports between the guest and the host. | |
138 | * The guest sends a "header" with this id with each data packet | |
139 | * that it sends and the host can then find out which associated | |
140 | * device to send out this data to | |
141 | */ | |
142 | uint32_t id; | |
143 | ||
f1925dff AS |
144 | /* |
145 | * This is the elem that we pop from the virtqueue. A slow | |
146 | * backend that consumes guest data (e.g. the file backend for | |
147 | * qemu chardevs) can cause the guest to block till all the output | |
148 | * is flushed. This isn't desired, so we keep a note of the last | |
149 | * element popped and continue consuming it once the backend | |
150 | * becomes writable again. | |
151 | */ | |
152 | VirtQueueElement elem; | |
153 | ||
154 | /* | |
155 | * The index and the offset into the iov buffer that was popped in | |
156 | * elem above. | |
157 | */ | |
158 | uint32_t iov_idx; | |
159 | uint64_t iov_offset; | |
160 | ||
199646d8 AL |
161 | /* |
162 | * When unthrottling we use a bottom-half to call flush_queued_data. | |
163 | */ | |
164 | QEMUBH *bh; | |
165 | ||
6663a195 AS |
166 | /* Is the corresponding guest device open? */ |
167 | bool guest_connected; | |
168 | /* Is this device open for IO on the host? */ | |
169 | bool host_connected; | |
9ed7b059 AS |
170 | /* Do apps not want to receive data? */ |
171 | bool throttled; | |
98b19252 AS |
172 | }; |
173 | ||
f1b24e84 KF |
174 | /* The virtio-serial bus on top of which the ports will ride as devices */ |
175 | struct VirtIOSerialBus { | |
176 | BusState qbus; | |
177 | ||
178 | /* This is the parent device that provides the bus for ports. */ | |
179 | VirtIOSerial *vser; | |
180 | ||
181 | /* The maximum number of ports that can ride on top of this bus */ | |
182 | uint32_t max_nr_ports; | |
183 | }; | |
184 | ||
185 | typedef struct VirtIOSerialPostLoad { | |
186 | QEMUTimer *timer; | |
187 | uint32_t nr_active_ports; | |
188 | struct { | |
189 | VirtIOSerialPort *port; | |
190 | uint8_t host_connected; | |
191 | } *connected; | |
192 | } VirtIOSerialPostLoad; | |
193 | ||
194 | struct VirtIOSerial { | |
195 | VirtIODevice vdev; | |
196 | ||
197 | VirtQueue *c_ivq, *c_ovq; | |
198 | /* Arrays of ivqs and ovqs: one per port */ | |
199 | VirtQueue **ivqs, **ovqs; | |
200 | ||
201 | VirtIOSerialBus bus; | |
202 | ||
203 | DeviceState *qdev; | |
204 | ||
205 | QTAILQ_HEAD(, VirtIOSerialPort) ports; | |
206 | ||
207 | /* bitmap for identifying active ports */ | |
208 | uint32_t *ports_map; | |
209 | ||
210 | struct virtio_console_config config; | |
211 | ||
212 | struct VirtIOSerialPostLoad *post_load; | |
2cd2b016 KF |
213 | |
214 | virtio_serial_conf serial; | |
f1b24e84 KF |
215 | }; |
216 | ||
98b19252 AS |
217 | /* Interface to the virtio-serial bus */ |
218 | ||
98b19252 AS |
219 | /* |
220 | * Open a connection to the port | |
221 | * Returns 0 on success (always). | |
222 | */ | |
223 | int virtio_serial_open(VirtIOSerialPort *port); | |
224 | ||
225 | /* | |
226 | * Close the connection to the port | |
227 | * Returns 0 on success (always). | |
228 | */ | |
229 | int virtio_serial_close(VirtIOSerialPort *port); | |
230 | ||
231 | /* | |
232 | * Send data to Guest | |
233 | */ | |
234 | ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf, | |
235 | size_t size); | |
236 | ||
237 | /* | |
238 | * Query whether a guest is ready to receive data. | |
239 | */ | |
240 | size_t virtio_serial_guest_ready(VirtIOSerialPort *port); | |
241 | ||
9ed7b059 AS |
242 | /* |
243 | * Flow control: Ports can signal to the virtio-serial core to stop | |
244 | * sending data or re-start sending data, depending on the 'throttle' | |
245 | * value here. | |
246 | */ | |
247 | void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle); | |
248 | ||
2cd2b016 KF |
249 | #define TYPE_VIRTIO_SERIAL "virtio-serial-device" |
250 | #define VIRTIO_SERIAL(obj) \ | |
251 | OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL) | |
252 | ||
253 | #define DEFINE_VIRTIO_SERIAL_PROPERTIES(_state, _field) \ | |
254 | DEFINE_PROP_UINT32("max_ports", _state, _field.max_virtserial_ports, 31) | |
255 | ||
98b19252 | 256 | #endif |