virtio-serial-port: Convert to QOM realize/unrealize
[qemu.git] / include / hw / virtio / virtio-serial.h
1 /*
2 * Virtio Serial / Console Support
3 *
4 * Copyright IBM, Corp. 2008
5 * Copyright Red Hat, Inc. 2009, 2010
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
18 #include "hw/qdev.h"
19 #include "hw/virtio/virtio.h"
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
29 #define VIRTIO_CONSOLE_BAD_ID (~(uint32_t)0)
30
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;
40 } QEMU_PACKED;
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
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
53 /* Some events for the internal messages (control packets) */
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
62
63 /* == In-qemu interface == */
64
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
73 typedef struct VirtIOSerial VirtIOSerial;
74 typedef struct VirtIOSerialBus VirtIOSerialBus;
75 typedef struct VirtIOSerialPort VirtIOSerialPort;
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) realize function that's called when a
85 * new device is found on the bus.
86 */
87 DeviceRealize realize;
88 /*
89 * Per-port unrealize function that's called when a port gets
90 * hot-unplugged or removed.
91 */
92 DeviceUnrealize unrealize;
93
94 /* Callbacks for guest events */
95 /* Guest opened/closed device. */
96 void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected);
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 ssize_t len);
108 } VirtIOSerialPortClass;
109
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;
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
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
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
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
161 /*
162 * When unthrottling we use a bottom-half to call flush_queued_data.
163 */
164 QEMUBH *bh;
165
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;
170 /* Do apps not want to receive data? */
171 bool throttled;
172 };
173
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 parent_obj;
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 QTAILQ_HEAD(, VirtIOSerialPort) ports;
204
205 /* bitmap for identifying active ports */
206 uint32_t *ports_map;
207
208 struct virtio_console_config config;
209
210 struct VirtIOSerialPostLoad *post_load;
211
212 virtio_serial_conf serial;
213 };
214
215 /* Interface to the virtio-serial bus */
216
217 /*
218 * Open a connection to the port
219 * Returns 0 on success (always).
220 */
221 int virtio_serial_open(VirtIOSerialPort *port);
222
223 /*
224 * Close the connection to the port
225 * Returns 0 on success (always).
226 */
227 int virtio_serial_close(VirtIOSerialPort *port);
228
229 /*
230 * Send data to Guest
231 */
232 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
233 size_t size);
234
235 /*
236 * Query whether a guest is ready to receive data.
237 */
238 size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
239
240 /*
241 * Flow control: Ports can signal to the virtio-serial core to stop
242 * sending data or re-start sending data, depending on the 'throttle'
243 * value here.
244 */
245 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
246
247 #define TYPE_VIRTIO_SERIAL "virtio-serial-device"
248 #define VIRTIO_SERIAL(obj) \
249 OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL)
250
251 #define DEFINE_VIRTIO_SERIAL_PROPERTIES(_state, _field) \
252 DEFINE_PROP_UINT32("max_ports", _state, _field.max_virtserial_ports, 31)
253
254 #endif