ppc/pnv: Add a HIOMAP erase command
[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
16 #ifndef QEMU_VIRTIO_SERIAL_H
17 #define QEMU_VIRTIO_SERIAL_H
18
19 #include "standard-headers/linux/virtio_console.h"
20 #include "hw/virtio/virtio.h"
21
22 struct virtio_serial_conf {
23 /* Max. number of ports we can have for a virtio-serial device */
24 uint32_t max_virtserial_ports;
25 };
26
27 #define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port"
28 #define VIRTIO_SERIAL_PORT(obj) \
29 OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT)
30 #define VIRTIO_SERIAL_PORT_CLASS(klass) \
31 OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT)
32 #define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \
33 OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT)
34
35 typedef struct VirtIOSerial VirtIOSerial;
36
37 #define TYPE_VIRTIO_SERIAL_BUS "virtio-serial-bus"
38 typedef struct VirtIOSerialBus VirtIOSerialBus;
39 #define VIRTIO_SERIAL_BUS(obj) \
40 OBJECT_CHECK(VirtIOSerialBus, (obj), TYPE_VIRTIO_SERIAL_BUS)
41
42 typedef struct VirtIOSerialPort VirtIOSerialPort;
43
44 typedef struct VirtIOSerialPortClass {
45 DeviceClass parent_class;
46
47 /* Is this a device that binds with hvc in the guest? */
48 bool is_console;
49
50 /*
51 * The per-port (or per-app) realize function that's called when a
52 * new device is found on the bus.
53 */
54 DeviceRealize realize;
55 /*
56 * Per-port unrealize function that's called when a port gets
57 * hot-unplugged or removed.
58 */
59 DeviceUnrealize unrealize;
60
61 /* Callbacks for guest events */
62 /* Guest opened/closed device. */
63 void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected);
64
65 /* Enable/disable backend for virtio serial port */
66 void (*enable_backend)(VirtIOSerialPort *port, bool enable);
67
68 /* Guest is now ready to accept data (virtqueues set up). */
69 void (*guest_ready)(VirtIOSerialPort *port);
70
71 /*
72 * Guest has enqueued a buffer for the host to write into.
73 * Called each time a buffer is enqueued by the guest;
74 * irrespective of whether there already were free buffers the
75 * host could have consumed.
76 *
77 * This is dependent on both the guest and host end being
78 * connected.
79 */
80 void (*guest_writable)(VirtIOSerialPort *port);
81
82 /*
83 * Guest wrote some data to the port. This data is handed over to
84 * the app via this callback. The app can return a size less than
85 * 'len'. In this case, throttling will be enabled for this port.
86 */
87 ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf,
88 ssize_t len);
89 } VirtIOSerialPortClass;
90
91 /*
92 * This is the state that's shared between all the ports. Some of the
93 * state is configurable via command-line options. Some of it can be
94 * set by individual devices in their initfn routines. Some of the
95 * state is set by the generic qdev device init routine.
96 */
97 struct VirtIOSerialPort {
98 DeviceState dev;
99
100 QTAILQ_ENTRY(VirtIOSerialPort) next;
101
102 /*
103 * This field gives us the virtio device as well as the qdev bus
104 * that we are associated with
105 */
106 VirtIOSerial *vser;
107
108 VirtQueue *ivq, *ovq;
109
110 /*
111 * This name is sent to the guest and exported via sysfs.
112 * The guest could create symlinks based on this information.
113 * The name is in the reverse fqdn format, like org.qemu.console.0
114 */
115 char *name;
116
117 /*
118 * This id helps identify ports between the guest and the host.
119 * The guest sends a "header" with this id with each data packet
120 * that it sends and the host can then find out which associated
121 * device to send out this data to
122 */
123 uint32_t id;
124
125 /*
126 * This is the elem that we pop from the virtqueue. A slow
127 * backend that consumes guest data (e.g. the file backend for
128 * qemu chardevs) can cause the guest to block till all the output
129 * is flushed. This isn't desired, so we keep a note of the last
130 * element popped and continue consuming it once the backend
131 * becomes writable again.
132 */
133 VirtQueueElement *elem;
134
135 /*
136 * The index and the offset into the iov buffer that was popped in
137 * elem above.
138 */
139 uint32_t iov_idx;
140 uint64_t iov_offset;
141
142 /*
143 * When unthrottling we use a bottom-half to call flush_queued_data.
144 */
145 QEMUBH *bh;
146
147 /* Is the corresponding guest device open? */
148 bool guest_connected;
149 /* Is this device open for IO on the host? */
150 bool host_connected;
151 /* Do apps not want to receive data? */
152 bool throttled;
153 };
154
155 /* The virtio-serial bus on top of which the ports will ride as devices */
156 struct VirtIOSerialBus {
157 BusState qbus;
158
159 /* This is the parent device that provides the bus for ports. */
160 VirtIOSerial *vser;
161
162 /* The maximum number of ports that can ride on top of this bus */
163 uint32_t max_nr_ports;
164 };
165
166 typedef struct VirtIOSerialPostLoad {
167 QEMUTimer *timer;
168 uint32_t nr_active_ports;
169 struct {
170 VirtIOSerialPort *port;
171 uint8_t host_connected;
172 } *connected;
173 } VirtIOSerialPostLoad;
174
175 struct VirtIOSerial {
176 VirtIODevice parent_obj;
177
178 VirtQueue *c_ivq, *c_ovq;
179 /* Arrays of ivqs and ovqs: one per port */
180 VirtQueue **ivqs, **ovqs;
181
182 VirtIOSerialBus bus;
183
184 QTAILQ_HEAD(, VirtIOSerialPort) ports;
185
186 QLIST_ENTRY(VirtIOSerial) next;
187
188 /* bitmap for identifying active ports */
189 uint32_t *ports_map;
190
191 struct VirtIOSerialPostLoad *post_load;
192
193 virtio_serial_conf serial;
194
195 uint64_t host_features;
196 };
197
198 /* Interface to the virtio-serial bus */
199
200 /*
201 * Open a connection to the port
202 * Returns 0 on success (always).
203 */
204 int virtio_serial_open(VirtIOSerialPort *port);
205
206 /*
207 * Close the connection to the port
208 * Returns 0 on success (always).
209 */
210 int virtio_serial_close(VirtIOSerialPort *port);
211
212 /*
213 * Send data to Guest
214 */
215 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
216 size_t size);
217
218 /*
219 * Query whether a guest is ready to receive data.
220 */
221 size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
222
223 /*
224 * Flow control: Ports can signal to the virtio-serial core to stop
225 * sending data or re-start sending data, depending on the 'throttle'
226 * value here.
227 */
228 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
229
230 #define TYPE_VIRTIO_SERIAL "virtio-serial-device"
231 #define VIRTIO_SERIAL(obj) \
232 OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL)
233
234 #endif