qemu/hw/virtio-serial.h
Anthony Liguori 39bffca203 qdev: register all types natively through QEMU Object Model
This was done in a mostly automated fashion.  I did it in three steps and then
rebased it into a single step which avoids repeatedly touching every file in
the tree.

The first step was a sed-based addition of the parent type to the subclass
registration functions.

The second step was another sed-based removal of subclass registration functions
while also adding virtual functions from the base class into a class_init
function as appropriate.

Finally, a python script was used to convert the DeviceInfo structures and
qdev_register_subclass functions to TypeInfo structures, class_init functions,
and type_register_static calls.

We are almost fully converted to QOM after this commit.

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2012-02-03 10:41:06 -06:00

209 lines
5.9 KiB
C

/*
* Virtio Serial / Console Support
*
* Copyright IBM, Corp. 2008
* Copyright Red Hat, Inc. 2009, 2010
*
* Authors:
* Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
* Amit Shah <amit.shah@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
*/
#ifndef _QEMU_VIRTIO_SERIAL_H
#define _QEMU_VIRTIO_SERIAL_H
#include "qdev.h"
#include "virtio.h"
/* == Interface shared between the guest kernel and qemu == */
/* The Virtio ID for virtio console / serial ports */
#define VIRTIO_ID_CONSOLE 3
/* Features supported */
#define VIRTIO_CONSOLE_F_MULTIPORT 1
#define VIRTIO_CONSOLE_BAD_ID (~(uint32_t)0)
struct virtio_console_config {
/*
* These two fields are used by VIRTIO_CONSOLE_F_SIZE which
* isn't implemented here yet
*/
uint16_t cols;
uint16_t rows;
uint32_t max_nr_ports;
} QEMU_PACKED;
struct virtio_console_control {
uint32_t id; /* Port number */
uint16_t event; /* The kind of control event (see below) */
uint16_t value; /* Extra information for the key */
};
struct virtio_serial_conf {
/* Max. number of ports we can have for a virtio-serial device */
uint32_t max_virtserial_ports;
};
/* Some events for the internal messages (control packets) */
#define VIRTIO_CONSOLE_DEVICE_READY 0
#define VIRTIO_CONSOLE_PORT_ADD 1
#define VIRTIO_CONSOLE_PORT_REMOVE 2
#define VIRTIO_CONSOLE_PORT_READY 3
#define VIRTIO_CONSOLE_CONSOLE_PORT 4
#define VIRTIO_CONSOLE_RESIZE 5
#define VIRTIO_CONSOLE_PORT_OPEN 6
#define VIRTIO_CONSOLE_PORT_NAME 7
/* == In-qemu interface == */
#define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port"
#define VIRTIO_SERIAL_PORT(obj) \
OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT)
#define VIRTIO_SERIAL_PORT_CLASS(klass) \
OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT)
#define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \
OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT)
typedef struct VirtIOSerial VirtIOSerial;
typedef struct VirtIOSerialBus VirtIOSerialBus;
typedef struct VirtIOSerialPort VirtIOSerialPort;
typedef struct VirtIOSerialPortClass {
DeviceClass parent_class;
/* Is this a device that binds with hvc in the guest? */
bool is_console;
/*
* The per-port (or per-app) init function that's called when a
* new device is found on the bus.
*/
int (*init)(VirtIOSerialPort *port);
/*
* Per-port exit function that's called when a port gets
* hot-unplugged or removed.
*/
int (*exit)(VirtIOSerialPort *port);
/* Callbacks for guest events */
/* Guest opened device. */
void (*guest_open)(VirtIOSerialPort *port);
/* Guest closed device. */
void (*guest_close)(VirtIOSerialPort *port);
/* Guest is now ready to accept data (virtqueues set up). */
void (*guest_ready)(VirtIOSerialPort *port);
/*
* Guest wrote some data to the port. This data is handed over to
* the app via this callback. The app can return a size less than
* 'len'. In this case, throttling will be enabled for this port.
*/
ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf,
size_t len);
} VirtIOSerialPortClass;
/*
* This is the state that's shared between all the ports. Some of the
* state is configurable via command-line options. Some of it can be
* set by individual devices in their initfn routines. Some of the
* state is set by the generic qdev device init routine.
*/
struct VirtIOSerialPort {
DeviceState dev;
QTAILQ_ENTRY(VirtIOSerialPort) next;
/*
* This field gives us the virtio device as well as the qdev bus
* that we are associated with
*/
VirtIOSerial *vser;
VirtQueue *ivq, *ovq;
/*
* This name is sent to the guest and exported via sysfs.
* The guest could create symlinks based on this information.
* The name is in the reverse fqdn format, like org.qemu.console.0
*/
char *name;
/*
* This id helps identify ports between the guest and the host.
* The guest sends a "header" with this id with each data packet
* that it sends and the host can then find out which associated
* device to send out this data to
*/
uint32_t id;
/*
* This is the elem that we pop from the virtqueue. A slow
* backend that consumes guest data (e.g. the file backend for
* qemu chardevs) can cause the guest to block till all the output
* is flushed. This isn't desired, so we keep a note of the last
* element popped and continue consuming it once the backend
* becomes writable again.
*/
VirtQueueElement elem;
/*
* The index and the offset into the iov buffer that was popped in
* elem above.
*/
uint32_t iov_idx;
uint64_t iov_offset;
/*
* When unthrottling we use a bottom-half to call flush_queued_data.
*/
QEMUBH *bh;
/* Is the corresponding guest device open? */
bool guest_connected;
/* Is this device open for IO on the host? */
bool host_connected;
/* Do apps not want to receive data? */
bool throttled;
};
/* Interface to the virtio-serial bus */
/*
* Open a connection to the port
* Returns 0 on success (always).
*/
int virtio_serial_open(VirtIOSerialPort *port);
/*
* Close the connection to the port
* Returns 0 on success (always).
*/
int virtio_serial_close(VirtIOSerialPort *port);
/*
* Send data to Guest
*/
ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
size_t size);
/*
* Query whether a guest is ready to receive data.
*/
size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
/*
* Flow control: Ports can signal to the virtio-serial core to stop
* sending data or re-start sending data, depending on the 'throttle'
* value here.
*/
void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
#endif