Author: bryanv
Date: Thu Oct 23 04:47:32 2014
New Revision: 273515
URL: https://svnweb.freebsd.org/changeset/base/273515
Log:
Add VirtIO console driver
Support for the multiport feature is mostly implemented, but currently
disabled due to some potential races in the hot plug code paths.
Requested by: marcel
MFC after: 1 month
Relnotes: yes
Added:
head/share/man/man4/virtio_console.4 (contents, props changed)
head/sys/dev/virtio/console/
head/sys/dev/virtio/console/virtio_console.c (contents, props changed)
head/sys/dev/virtio/console/virtio_console.h (contents, props changed)
head/sys/modules/virtio/console/
head/sys/modules/virtio/console/Makefile (contents, props changed)
Modified:
head/share/man/man4/Makefile
head/share/man/man4/virtio.4
head/sys/modules/virtio/Makefile
Modified: head/share/man/man4/Makefile
==============================================================================
--- head/share/man/man4/Makefile Thu Oct 23 03:13:14 2014
(r273514)
+++ head/share/man/man4/Makefile Thu Oct 23 04:47:32 2014
(r273515)
@@ -563,6 +563,7 @@ MAN= aac.4 \
${_virtio.4} \
${_virtio_balloon.4} \
${_virtio_blk.4} \
+ ${_virtio_console.4} \
${_virtio_random.4} \
${_virtio_scsi.4} \
vkbd.4 \
@@ -814,6 +815,7 @@ _nxge.4= nxge.4
_virtio.4= virtio.4
_virtio_balloon.4=virtio_balloon.4
_virtio_blk.4= virtio_blk.4
+_virtio_console.4=virtio_console.4
_virtio_random.4= virtio_random.4
_virtio_scsi.4= virtio_scsi.4
_vmx.4= vmx.4
Modified: head/share/man/man4/virtio.4
==============================================================================
--- head/share/man/man4/virtio.4 Thu Oct 23 03:13:14 2014
(r273514)
+++ head/share/man/man4/virtio.4 Thu Oct 23 04:47:32 2014
(r273515)
@@ -85,6 +85,7 @@ device driver.
.Sh SEE ALSO
.Xr virtio_balloon 4 ,
.Xr virtio_blk 4 ,
+.Xr virtio_console 4 ,
.Xr virtio_scsi 4 ,
.Xr vtnet 4
.Sh HISTORY
Added: head/share/man/man4/virtio_console.4
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/share/man/man4/virtio_console.4 Thu Oct 23 04:47:32 2014
(r273515)
@@ -0,0 +1,66 @@
+.\" Copyright (c) 2014 Bryan Venteicher
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd October 22, 2014
+.Dt VIRTIO_CONSOLE 4
+.Os
+.Sh NAME
+.Nm virtio_console
+.Nd VirtIO Console driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device virtio_console"
+.Ed
+.Pp
+Alternatively, to load the driver as a
+module at boot time, place the following line in
+.Xr loader.conf 5 :
+.Bd -literal -offset indent
+virtio_console_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+device driver provides support for VirtIO console devices.
+.Pp
+The console device may have one or more ports.
+Each port is similar to a simple serial interface, and
+each port is accessible through
+.Xr tty 4 .
+.Sh FILES
+.Bl -tag -width ".Pa /dev/ttyV?.??" -compact
+.It Pa /dev/ttyV?.??
+.Sh SEE ALSO
+.Xr tty 4
+.Xr virtio 4
+.Sh HISTORY
+The
+.Nm
+driver was written by
+.An Bryan Venteicher Aq bry...@freebsd.org .
Added: head/sys/dev/virtio/console/virtio_console.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/sys/dev/virtio/console/virtio_console.c Thu Oct 23 04:47:32
2014 (r273515)
@@ -0,0 +1,1238 @@
+/*-
+ * Copyright (c) 2014, Bryan Venteicher <bry...@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice unmodified, this list of conditions, and the following
+ * disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Driver for VirtIO console devices. */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/sglist.h>
+#include <sys/sysctl.h>
+#include <sys/taskqueue.h>
+#include <sys/queue.h>
+
+#include <sys/conf.h>
+#include <sys/cons.h>
+#include <sys/tty.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <sys/bus.h>
+
+#include <dev/virtio/virtio.h>
+#include <dev/virtio/virtqueue.h>
+#include <dev/virtio/console/virtio_console.h>
+
+#include "virtio_if.h"
+
+#define VTCON_MAX_PORTS 1
+#define VTCON_TTY_PREFIX "V"
+#define VTCON_BULK_BUFSZ 128
+
+struct vtcon_softc;
+
+struct vtcon_port {
+ struct vtcon_softc *vtcport_sc;
+ TAILQ_ENTRY(vtcon_port) vtcport_next;
+ struct mtx vtcport_mtx;
+ int vtcport_id;
+ struct tty *vtcport_tty;
+ struct virtqueue *vtcport_invq;
+ struct virtqueue *vtcport_outvq;
+ char vtcport_name[16];
+};
+
+#define VTCON_PORT_MTX(_port) &(_port)->vtcport_mtx
+#define VTCON_PORT_LOCK_INIT(_port) \
+ mtx_init(VTCON_PORT_MTX((_port)), (_port)->vtcport_name, NULL, MTX_DEF)
+#define VTCON_PORT_LOCK(_port) mtx_lock(VTCON_PORT_MTX((_port)))
+#define VTCON_PORT_UNLOCK(_port) mtx_unlock(VTCON_PORT_MTX((_port)))
+#define VTCON_PORT_LOCK_DESTROY(_port) mtx_destroy(VTCON_PORT_MTX((_port)))
+#define VTCON_PORT_LOCK_ASSERT(_port) \
+ mtx_assert(VTCON_PORT_MTX((_port)), MA_OWNED)
+#define VTCON_PORT_LOCK_ASSERT_NOTOWNED(_port) \
+ mtx_assert(VTCON_PORT_MTX((_port)), MA_NOTOWNED)
+
+struct vtcon_softc {
+ device_t vtcon_dev;
+ struct mtx vtcon_mtx;
+ uint64_t vtcon_features;
+ uint32_t vtcon_flags;
+#define VTCON_FLAG_DETACHED 0x0001
+#define VTCON_FLAG_SIZE 0x0010
+#define VTCON_FLAG_MULTIPORT 0x0020
+
+ struct task vtcon_ctrl_task;
+ struct virtqueue *vtcon_ctrl_rxvq;
+ struct virtqueue *vtcon_ctrl_txvq;
+
+ uint32_t vtcon_max_ports;
+ TAILQ_HEAD(, vtcon_port)
+ vtcon_ports;
+
+ /*
+ * Ports can be added and removed during runtime, but we have
+ * to allocate all the virtqueues during attach. This array is
+ * indexed by the port ID.
+ */
+ struct vtcon_port_extra {
+ struct vtcon_port *port;
+ struct virtqueue *invq;
+ struct virtqueue *outvq;
+ } *vtcon_portsx;
+};
+
+#define VTCON_MTX(_sc) &(_sc)->vtcon_mtx
+#define VTCON_LOCK_INIT(_sc, _name) \
+ mtx_init(VTCON_MTX((_sc)), (_name), NULL, MTX_DEF)
+#define VTCON_LOCK(_sc) mtx_lock(VTCON_MTX((_sc)))
+#define VTCON_UNLOCK(_sc) mtx_unlock(VTCON_MTX((_sc)))
+#define VTCON_LOCK_DESTROY(_sc) mtx_destroy(VTCON_MTX((_sc)))
+#define VTCON_LOCK_ASSERT(_sc) mtx_assert(VTCON_MTX((_sc)), MA_OWNED)
+#define VTCON_LOCK_ASSERT_NOTOWNED(_sc) \
+ mtx_assert(VTCON_MTX((_sc)), MA_NOTOWNED)
+
+#define VTCON_ASSERT_VALID_PORTID(_sc, _id) \
+ KASSERT((_id) >= 0 && (_id) < (_sc)->vtcon_max_ports, \
+ ("%s: port ID %d out of range", __func__, _id))
+
+#define VTCON_FEATURES 0
+
+static struct virtio_feature_desc vtcon_feature_desc[] = {
+ { VIRTIO_CONSOLE_F_SIZE, "ConsoleSize" },
+ { VIRTIO_CONSOLE_F_MULTIPORT, "MultiplePorts" },
+
+ { 0, NULL }
+};
+
+static int vtcon_modevent(module_t, int, void *);
+
+static int vtcon_probe(device_t);
+static int vtcon_attach(device_t);
+static int vtcon_detach(device_t);
+static int vtcon_config_change(device_t);
+
+static void vtcon_negotiate_features(struct vtcon_softc *);
+static int vtcon_alloc_virtqueues(struct vtcon_softc *);
+static void vtcon_read_config(struct vtcon_softc *,
+ struct virtio_console_config *);
+
+static void vtcon_determine_max_ports(struct vtcon_softc *,
+ struct virtio_console_config *);
+static void vtcon_deinit_ports(struct vtcon_softc *);
+static void vtcon_stop(struct vtcon_softc *);
+
+static void vtcon_ctrl_rx_vq_intr(void *);
+static int vtcon_ctrl_enqueue_msg(struct vtcon_softc *,
+ struct virtio_console_control *);
+static int vtcon_ctrl_add_msg(struct vtcon_softc *);
+static void vtcon_ctrl_readd_msg(struct vtcon_softc *,
+ struct virtio_console_control *);
+static int vtcon_ctrl_populate(struct vtcon_softc *);
+static void vtcon_ctrl_send_msg(struct vtcon_softc *,
+ struct virtio_console_control *control);
+static void vtcon_ctrl_send_event(struct vtcon_softc *, uint32_t,
+ uint16_t, uint16_t);
+static int vtcon_ctrl_init(struct vtcon_softc *);
+static void vtcon_ctrl_drain(struct vtcon_softc *);
+static void vtcon_ctrl_deinit(struct vtcon_softc *);
+static void vtcon_ctrl_port_add_event(struct vtcon_softc *, int);
+static void vtcon_ctrl_port_remove_event(struct vtcon_softc *, int);
+static void vtcon_ctrl_port_console_event(struct vtcon_softc *, int);
+static void vtcon_ctrl_port_open_event(struct vtcon_softc *, int);
+static void vtcon_ctrl_process_msg(struct vtcon_softc *,
+ struct virtio_console_control *);
+static void vtcon_ctrl_task_cb(void *, int);
+
+static int vtcon_port_add_inbuf(struct vtcon_port *);
+static void vtcon_port_readd_inbuf(struct vtcon_port *, void *);
+static int vtcon_port_populate(struct vtcon_port *);
+static void vtcon_port_destroy(struct vtcon_port *);
+static int vtcon_port_create(struct vtcon_softc *, int,
+ struct vtcon_port **);
+static void vtcon_port_drain_inbufs(struct vtcon_port *);
+static void vtcon_port_teardown(struct vtcon_port *, int);
+static void vtcon_port_change_size(struct vtcon_port *, uint16_t,
+ uint16_t);
+static void vtcon_port_enable_intr(struct vtcon_port *);
+static void vtcon_port_disable_intr(struct vtcon_port *);
+static void vtcon_port_intr(struct vtcon_port *);
+static void vtcon_port_in_vq_intr(void *);
+static void vtcon_port_put(struct vtcon_port *, void *, int);
+static void vtcon_port_send_ctrl_msg(struct vtcon_port *, uint16_t,
+ uint16_t);
+static struct vtcon_port *vtcon_port_lookup_by_id(struct vtcon_softc *, int);
+
+static int vtcon_tty_open(struct tty *);
+static void vtcon_tty_close(struct tty *);
+static void vtcon_tty_outwakeup(struct tty *);
+static void vtcon_tty_free(void *);
+
+static void vtcon_get_console_size(struct vtcon_softc *, uint16_t *,
+ uint16_t *);
+
+static void vtcon_enable_interrupts(struct vtcon_softc *);
+static void vtcon_disable_interrupts(struct vtcon_softc *);
+
+static int vtcon_pending_free;
+
+static struct ttydevsw vtcon_tty_class = {
+ .tsw_flags = 0,
+ .tsw_open = vtcon_tty_open,
+ .tsw_close = vtcon_tty_close,
+ .tsw_outwakeup = vtcon_tty_outwakeup,
+ .tsw_free = vtcon_tty_free,
+};
+
+static device_method_t vtcon_methods[] = {
+ /* Device methods. */
+ DEVMETHOD(device_probe, vtcon_probe),
+ DEVMETHOD(device_attach, vtcon_attach),
+ DEVMETHOD(device_detach, vtcon_detach),
+
+ /* VirtIO methods. */
+ DEVMETHOD(virtio_config_change, vtcon_config_change),
+
+ DEVMETHOD_END
+};
+
+static driver_t vtcon_driver = {
+ "vtcon",
+ vtcon_methods,
+ sizeof(struct vtcon_softc)
+};
+static devclass_t vtcon_devclass;
+
+DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass,
+ vtcon_modevent, 0);
+MODULE_VERSION(virtio_console, 1);
+MODULE_DEPEND(virtio_console, virtio, 1, 1, 1);
+
+static int
+vtcon_modevent(module_t mod, int type, void *unused)
+{
+ int error;
+
+ switch (type) {
+ case MOD_LOAD:
+ error = 0;
+ break;
+ case MOD_QUIESCE:
+ case MOD_UNLOAD:
+ error = vtcon_pending_free != 0 ? EBUSY : 0;
+ /* error = EOPNOTSUPP; */
+ break;
+ case MOD_SHUTDOWN:
+ error = 0;
+ break;
+ default:
+ error = EOPNOTSUPP;
+ break;
+ }
+
+ return (error);
+}
+
+static int
+vtcon_probe(device_t dev)
+{
+
+ if (virtio_get_device_type(dev) != VIRTIO_ID_CONSOLE)
+ return (ENXIO);
+
+ device_set_desc(dev, "VirtIO Console Adapter");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+vtcon_attach(device_t dev)
+{
+ struct vtcon_softc *sc;
+ struct virtio_console_config concfg;
+ int error;
+
+ sc = device_get_softc(dev);
+ sc->vtcon_dev = dev;
+
+ VTCON_LOCK_INIT(sc, device_get_nameunit(dev));
+ TASK_INIT(&sc->vtcon_ctrl_task, 0, vtcon_ctrl_task_cb, sc);
+ TAILQ_INIT(&sc->vtcon_ports);
+
+ virtio_set_feature_desc(dev, vtcon_feature_desc);
+ vtcon_negotiate_features(sc);
+
+ if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_SIZE))
+ sc->vtcon_flags |= VTCON_FLAG_SIZE;
+ if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_MULTIPORT))
+ sc->vtcon_flags |= VTCON_FLAG_MULTIPORT;
+
+ vtcon_read_config(sc, &concfg);
+ vtcon_determine_max_ports(sc, &concfg);
+
+ error = vtcon_alloc_virtqueues(sc);
+ if (error) {
+ device_printf(dev, "cannot allocate virtqueues\n");
+ goto fail;
+ }
+
+ if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
+ error = vtcon_ctrl_init(sc);
+ else
+ error = vtcon_port_create(sc, 0, NULL);
+ if (error)
+ goto fail;
+
+ error = virtio_setup_intr(dev, INTR_TYPE_TTY);
+ if (error) {
+ device_printf(dev, "cannot setup virtqueue interrupts\n");
+ goto fail;
+ }
+
+ vtcon_enable_interrupts(sc);
+
+ vtcon_ctrl_send_event(sc, VIRTIO_CONSOLE_BAD_ID,
+ VIRTIO_CONSOLE_DEVICE_READY, 1);
+
+fail:
+ if (error)
+ vtcon_detach(dev);
+
+ return (error);
+}
+
+static int
+vtcon_detach(device_t dev)
+{
+ struct vtcon_softc *sc;
+
+ sc = device_get_softc(dev);
+
+ VTCON_LOCK(sc);
+ sc->vtcon_flags |= VTCON_FLAG_DETACHED;
+ if (device_is_attached(dev))
+ vtcon_stop(sc);
+ VTCON_UNLOCK(sc);
+
+ taskqueue_drain(taskqueue_thread, &sc->vtcon_ctrl_task);
+
+ if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
+ vtcon_ctrl_deinit(sc);
+
+ vtcon_deinit_ports(sc);
+
+ VTCON_LOCK_DESTROY(sc);
+
+ return (0);
+}
+
+static int
+vtcon_config_change(device_t dev)
+{
+ struct vtcon_softc *sc;
+ struct vtcon_port *port;
+ uint16_t cols, rows;
+
+ sc = device_get_softc(dev);
+
+ /*
+ * With the multiport feature, all configuration changes are
+ * done through control virtqueue events. This is a spurious
+ * interrupt.
+ */
+ if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
+ return (0);
+
+ if (sc->vtcon_flags & VTCON_FLAG_SIZE) {
+ /*
+ * For now, assume the first (only) port is the 'console'.
+ * Note QEMU does not implement this feature yet.
+ */
+ VTCON_LOCK(sc);
+ if ((port = vtcon_port_lookup_by_id(sc, 0)) != NULL) {
+ vtcon_get_console_size(sc, &cols, &rows);
+ vtcon_port_change_size(port, cols, rows);
+ }
+ VTCON_UNLOCK(sc);
+ }
+
+ return (0);
+}
+
+static void
+vtcon_negotiate_features(struct vtcon_softc *sc)
+{
+ device_t dev;
+ uint64_t features;
+
+ dev = sc->vtcon_dev;
+ features = VTCON_FEATURES;
+
+ sc->vtcon_features = virtio_negotiate_features(dev, features);
+}
+
+#define VTCON_GET_CONFIG(_dev, _feature, _field, _cfg) \
+ if (virtio_with_feature(_dev, _feature)) { \
+ virtio_read_device_config(_dev, \
+ offsetof(struct virtio_console_config, _field), \
+ &(_cfg)->_field, sizeof((_cfg)->_field)); \
+ }
+
+static void
+vtcon_read_config(struct vtcon_softc *sc, struct virtio_console_config *concfg)
+{
+ device_t dev;
+
+ dev = sc->vtcon_dev;
+
+ bzero(concfg, sizeof(struct virtio_console_config));
+
+ /* Read the configuration if the feature was negotiated. */
+ VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, cols, concfg);
+ VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, rows, concfg);
+ VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_MULTIPORT, max_nr_ports, concfg);
+}
+
+#undef VTCON_GET_CONFIG
+
+static int
+vtcon_alloc_virtqueues(struct vtcon_softc *sc)
+{
+ device_t dev;
+ struct vq_alloc_info *info;
+ struct vtcon_port_extra *portx;
+ int i, idx, portidx, nvqs, error;
+
+ dev = sc->vtcon_dev;
+
+ sc->vtcon_portsx = malloc(sizeof(struct vtcon_port_extra) *
+ sc->vtcon_max_ports, M_DEVBUF, M_NOWAIT | M_ZERO);
+ if (sc->vtcon_portsx == NULL)
+ return (ENOMEM);
+
+ nvqs = sc->vtcon_max_ports * 2;
+ if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
+ nvqs += 2;
+
+ info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT);
+ if (info == NULL)
+ return (ENOMEM);
+
+ for (i = 0, idx = 0, portidx = 0; i < nvqs / 2; i++, idx+=2) {
+
+ if (i == 1) {
+ /* The control virtqueues are after the first port. */
+ VQ_ALLOC_INFO_INIT(&info[idx], 0,
+ vtcon_ctrl_rx_vq_intr, sc, &sc->vtcon_ctrl_rxvq,
+ "%s-control rx", device_get_nameunit(dev));
+ VQ_ALLOC_INFO_INIT(&info[idx+1], 0,
+ NULL, sc, &sc->vtcon_ctrl_txvq,
+ "%s-control tx", device_get_nameunit(dev));
+ continue;
+ }
+
+ portx = &sc->vtcon_portsx[portidx];
+
+ VQ_ALLOC_INFO_INIT(&info[idx], 0, vtcon_port_in_vq_intr,
+ portx, &portx->invq, "%s-port%d in",
+ device_get_nameunit(dev), portidx);
+ VQ_ALLOC_INFO_INIT(&info[idx+1], 0, NULL,
+ NULL, &portx->outvq, "%s-port%d out",
+ device_get_nameunit(dev), portidx);
+
+ portidx++;
+ }
+
+ error = virtio_alloc_virtqueues(dev, 0, nvqs, info);
+ free(info, M_TEMP);
+
+ return (error);
+}
+
+static void
+vtcon_determine_max_ports(struct vtcon_softc *sc,
+ struct virtio_console_config *concfg)
+{
+
+ if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
+ sc->vtcon_max_ports =
+ min(concfg->max_nr_ports, VTCON_MAX_PORTS);
+ if (sc->vtcon_max_ports == 0)
+ sc->vtcon_max_ports = 1;
+ } else
+ sc->vtcon_max_ports = 1;
+}
+
+static void
+vtcon_deinit_ports(struct vtcon_softc *sc)
+{
+ struct vtcon_port *port, *tmp;
+
+ TAILQ_FOREACH_SAFE(port, &sc->vtcon_ports, vtcport_next, tmp) {
+ vtcon_port_teardown(port, 1);
+ }
+
+ if (sc->vtcon_portsx != NULL) {
+ free(sc->vtcon_portsx, M_DEVBUF);
+ sc->vtcon_portsx = NULL;
+ }
+}
+
+static void
+vtcon_stop(struct vtcon_softc *sc)
+{
+
+ vtcon_disable_interrupts(sc);
+ virtio_stop(sc->vtcon_dev);
+}
+
+static void
+vtcon_ctrl_rx_vq_intr(void *xsc)
+{
+ struct vtcon_softc *sc;
+
+ sc = xsc;
+
+ /*
+ * Some events require us to potentially block, but it easier
+ * to just defer all event handling to a seperate thread.
+ */
+ taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task);
+}
+
+static int
+vtcon_ctrl_enqueue_msg(struct vtcon_softc *sc,
+ struct virtio_console_control *control)
+{
+ struct sglist_seg segs[1];
+ struct sglist sg;
+ struct virtqueue *vq;
+ int error __unused;
+
+ vq = sc->vtcon_ctrl_rxvq;
+
+ sglist_init(&sg, 1, segs);
+ error = sglist_append(&sg, control, sizeof(*control));
+ KASSERT(error == 0 && sg.sg_nseg == 1,
+ ("%s: error %d adding control msg to sglist", __func__, error));
+
+ return (virtqueue_enqueue(vq, control, &sg, 0, 1));
+}
+
+static int
+vtcon_ctrl_add_msg(struct vtcon_softc *sc)
+{
+ struct virtio_console_control *control;
+ int error;
+
+ control = malloc(sizeof(*control), M_DEVBUF, M_ZERO | M_NOWAIT);
+ if (control == NULL)
+ return (ENOMEM);
+
+ error = vtcon_ctrl_enqueue_msg(sc, control);
+ if (error)
+ free(control, M_DEVBUF);
+
+ return (error);
+}
+
+static void
+vtcon_ctrl_readd_msg(struct vtcon_softc *sc,
+ struct virtio_console_control *control)
+{
+ int error;
+
+ bzero(control, sizeof(*control));
+
+ error = vtcon_ctrl_enqueue_msg(sc, control);
+ KASSERT(error == 0,
+ ("%s: cannot requeue control buffer %d", __func__, error));
+}
+
+static int
+vtcon_ctrl_populate(struct vtcon_softc *sc)
+{
+ struct virtqueue *vq;
+ int nbufs, error;
+
+ vq = sc->vtcon_ctrl_rxvq;
+ error = ENOSPC;
+
+ for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
+ error = vtcon_ctrl_add_msg(sc);
+ if (error)
+ break;
+ }
+
+ if (nbufs > 0) {
+ virtqueue_notify(vq);
+ /*
+ * EMSGSIZE signifies the virtqueue did not have enough
+ * entries available to hold the last buf. This is not
+ * an error.
+ */
+ if (error == EMSGSIZE)
+ error = 0;
+ }
+
+ return (error);
+}
+
+static void
+vtcon_ctrl_send_msg(struct vtcon_softc *sc,
+ struct virtio_console_control *control)
+{
+ struct sglist_seg segs[1];
+ struct sglist sg;
+ struct virtqueue *vq;
+ int error;
+
+ vq = sc->vtcon_ctrl_txvq;
+ KASSERT(virtqueue_empty(vq),
+ ("%s: virtqueue is not emtpy", __func__));
+
+ sglist_init(&sg, 1, segs);
+ error = sglist_append(&sg, control, sizeof(*control));
+ KASSERT(error == 0 && sg.sg_nseg == 1,
+ ("%s: error %d adding control msg to sglist", __func__, error));
+
+ error = virtqueue_enqueue(vq, control, &sg, 1, 0);
+ if (error == 0) {
+ virtqueue_notify(vq);
+ virtqueue_poll(vq, NULL);
+ }
+}
+
+static void
+vtcon_ctrl_send_event(struct vtcon_softc *sc, uint32_t portid, uint16_t event,
+ uint16_t value)
+{
+ struct virtio_console_control control;
+
+ if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0)
+ return;
+
+ control.id = portid;
+ control.event = event;
+ control.value = value;
+
+ vtcon_ctrl_send_msg(sc, &control);
+}
+
+static int
+vtcon_ctrl_init(struct vtcon_softc *sc)
+{
+ int error;
+
+ error = vtcon_ctrl_populate(sc);
+
+ return (error);
+}
+
+static void
+vtcon_ctrl_drain(struct vtcon_softc *sc)
+{
+ struct virtio_console_control *control;
+ struct virtqueue *vq;
+ int last;
+
+ vq = sc->vtcon_ctrl_rxvq;
+ last = 0;
+
+ if (vq == NULL)
+ return;
+
+ while ((control = virtqueue_drain(vq, &last)) != NULL)
+ free(control, M_DEVBUF);
+}
+
+static void
+vtcon_ctrl_deinit(struct vtcon_softc *sc)
+{
+
+ vtcon_ctrl_drain(sc);
+}
+
+static void
+vtcon_ctrl_port_add_event(struct vtcon_softc *sc, int id)
+{
+ device_t dev;
+ struct vtcon_port *port;
+ int error;
+
+ dev = sc->vtcon_dev;
+
+ if (vtcon_port_lookup_by_id(sc, id) != NULL) {
+ device_printf(dev, "%s: adding port %d, but already exists\n",
+ __func__, id);
+ return;
+ }
+
+ error = vtcon_port_create(sc, id, &port);
+ if (error) {
+ device_printf(dev, "%s: cannot create port %d: %d\n",
+ __func__, id, error);
+ return;
+ }
+
+ vtcon_port_send_ctrl_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
+}
+
+static void
+vtcon_ctrl_port_remove_event(struct vtcon_softc *sc, int id)
+{
+ device_t dev;
+ struct vtcon_port *port;
+
+ dev = sc->vtcon_dev;
+
+ port = vtcon_port_lookup_by_id(sc, id);
+ if (port == NULL) {
+ device_printf(dev, "%s: remove port %d, but does not exist\n",
+ __func__, id);
+ return;
+ }
+
+ vtcon_port_teardown(port, 1);
+}
+
+static void
+vtcon_ctrl_port_console_event(struct vtcon_softc *sc, int id)
+{
+ device_t dev;
+
+ dev = sc->vtcon_dev;
+
+ /*
+ * BMV: I don't think we need to do anything.
+ */
+ device_printf(dev, "%s: port %d console event\n", __func__, id);
+}
+
+static void
+vtcon_ctrl_port_open_event(struct vtcon_softc *sc, int id)
+{
+ device_t dev;
+ struct vtcon_port *port;
+
+ dev = sc->vtcon_dev;
+
+ port = vtcon_port_lookup_by_id(sc, id);
+ if (port == NULL) {
+ device_printf(dev, "%s: open port %d, but does not exist\n",
+ __func__, id);
+ return;
+ }
+
+ vtcon_port_enable_intr(port);
+}
+
+static void
+vtcon_ctrl_process_msg(struct vtcon_softc *sc,
+ struct virtio_console_control *control)
+{
+ device_t dev;
+ int id;
+
+ dev = sc->vtcon_dev;
+ id = control->id;
+
+ if (id < 0 || id >= sc->vtcon_max_ports) {
+ device_printf(dev, "%s: invalid port ID %d\n", __func__, id);
+ return;
+ }
+
+ switch (control->event) {
+ case VIRTIO_CONSOLE_PORT_ADD:
+ vtcon_ctrl_port_add_event(sc, id);
+ break;
+
+ case VIRTIO_CONSOLE_PORT_REMOVE:
+ vtcon_ctrl_port_remove_event(sc, id);
+ break;
+
+ case VIRTIO_CONSOLE_CONSOLE_PORT:
+ vtcon_ctrl_port_console_event(sc, id);
+ break;
+
+ case VIRTIO_CONSOLE_RESIZE:
+ break;
+
+ case VIRTIO_CONSOLE_PORT_OPEN:
+ vtcon_ctrl_port_open_event(sc, id);
+ break;
+
+ case VIRTIO_CONSOLE_PORT_NAME:
+ break;
+ }
+}
+
+static void
+vtcon_ctrl_task_cb(void *xsc, int pending)
+{
+ struct vtcon_softc *sc;
+ struct virtqueue *vq;
+ struct virtio_console_control *control;
+
+ sc = xsc;
+ vq = sc->vtcon_ctrl_rxvq;
+
+ VTCON_LOCK(sc);
+ while ((sc->vtcon_flags & VTCON_FLAG_DETACHED) == 0) {
+ control = virtqueue_dequeue(vq, NULL);
+ if (control == NULL)
+ break;
+
+ VTCON_UNLOCK(sc);
+ vtcon_ctrl_process_msg(sc, control);
+ VTCON_LOCK(sc);
+ vtcon_ctrl_readd_msg(sc, control);
+ }
+ VTCON_UNLOCK(sc);
+
+ if (virtqueue_enable_intr(vq) != 0)
+ taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task);
+}
+
+static int
+vtcon_port_enqueue_inbuf(struct vtcon_port *port, void *buf, size_t len)
+{
+ struct sglist_seg segs[1];
+ struct sglist sg;
+ struct virtqueue *vq;
+ int error;
+
+ vq = port->vtcport_invq;
+
+ sglist_init(&sg, 1, segs);
+ error = sglist_append(&sg, buf, len);
+ KASSERT(error == 0 && sg.sg_nseg == 1,
+ ("%s: error %d adding buffer to sglist", __func__, error));
+
+ return (virtqueue_enqueue(vq, buf, &sg, 0, 1));
+}
+
+static int
+vtcon_port_add_inbuf(struct vtcon_port *port)
+{
+ void *buf;
+ int error;
+
+ buf = malloc(VTCON_BULK_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
+ if (buf == NULL)
+ return (ENOMEM);
+
+ error = vtcon_port_enqueue_inbuf(port, buf, VTCON_BULK_BUFSZ);
+ if (error)
+ free(buf, M_DEVBUF);
+
+ return (error);
+}
+
+static void
+vtcon_port_readd_inbuf(struct vtcon_port *port, void *buf)
+{
+ int error __unused;
+
+ error = vtcon_port_enqueue_inbuf(port, buf, VTCON_BULK_BUFSZ);
+ KASSERT(error == 0,
+ ("%s: cannot requeue input buffer %d", __func__, error));
+}
+
+static int
+vtcon_port_populate(struct vtcon_port *port)
+{
+ struct virtqueue *vq;
+ int nbufs, error;
+
+ vq = port->vtcport_invq;
+ error = ENOSPC;
+
+ for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
+ error = vtcon_port_add_inbuf(port);
+ if (error)
+ break;
+ }
+
+ if (nbufs > 0) {
+ virtqueue_notify(vq);
+ /*
+ * EMSGSIZE signifies the virtqueue did not have enough
+ * entries available to hold the last buf. This is not
+ * an error.
+ */
+ if (error == EMSGSIZE)
+ error = 0;
+ }
+
+ return (error);
+}
+
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-all@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"
