[mirror_qemu.git] / hw / virtio-serial.h

/*
 * 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 "hw/qdev.h"
#include "hw/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/closed device. */
    void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected);

        /* 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;
};

/* The virtio-serial bus on top of which the ports will ride as devices */
struct VirtIOSerialBus {
    BusState qbus;

    /* This is the parent device that provides the bus for ports. */
    VirtIOSerial *vser;

    /* The maximum number of ports that can ride on top of this bus */
    uint32_t max_nr_ports;
};

typedef struct VirtIOSerialPostLoad {
    QEMUTimer *timer;
    uint32_t nr_active_ports;
    struct {
        VirtIOSerialPort *port;
        uint8_t host_connected;
    } *connected;
} VirtIOSerialPostLoad;

struct VirtIOSerial {
    VirtIODevice vdev;

    VirtQueue *c_ivq, *c_ovq;
    /* Arrays of ivqs and ovqs: one per port */
    VirtQueue **ivqs, **ovqs;

    VirtIOSerialBus bus;

    DeviceState *qdev;

    QTAILQ_HEAD(, VirtIOSerialPort) ports;

    /* bitmap for identifying active ports */
    uint32_t *ports_map;

    struct virtio_console_config config;

    struct VirtIOSerialPostLoad *post_load;
};

/* 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
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 PB	18	#include "hw/qdev.h"
83c9f4ca PB	19	#include "hw/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)
055b889f AS	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. */
b2c1394a HG	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? */
9ed7b059 AS	171	bool throttled;
98b19252 AS	172	};
98b19252 AS	173
f1b24e84 FK	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;
	213	};
	214
98b19252 AS	215	/* Interface to the virtio-serial bus */
98b19252 AS	216
98b19252 AS	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
9ed7b059 AS	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
98b19252	247	#endif