2 * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 /* Driver for VirtIO console devices. */
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/malloc.h>
36 #include <sys/module.h>
39 #include <sys/mutex.h>
40 #include <sys/sglist.h>
41 #include <sys/sysctl.h>
42 #include <sys/taskqueue.h>
43 #include <sys/queue.h>
49 #include <machine/bus.h>
50 #include <machine/resource.h>
53 #include <dev/virtio/virtio.h>
54 #include <dev/virtio/virtqueue.h>
55 #include <dev/virtio/console/virtio_console.h>
57 #include "virtio_if.h"
59 #define VTCON_MAX_PORTS 32
60 #define VTCON_TTY_PREFIX "V"
61 #define VTCON_BULK_BUFSZ 128
64 * The buffer cannot cross more than one page boundary due to the
65 * size of the sglist segment array used.
67 CTASSERT(VTCON_BULK_BUFSZ <= PAGE_SIZE);
70 struct vtcon_softc_port;
73 struct mtx vtcport_mtx;
74 struct vtcon_softc *vtcport_sc;
75 struct vtcon_softc_port *vtcport_scport;
76 struct tty *vtcport_tty;
77 struct virtqueue *vtcport_invq;
78 struct virtqueue *vtcport_outvq;
81 #define VTCON_PORT_FLAG_GONE 0x01
82 #define VTCON_PORT_FLAG_CONSOLE 0x02
85 int vtcport_alt_break_state;
89 #define VTCON_PORT_LOCK(_port) mtx_lock(&(_port)->vtcport_mtx)
90 #define VTCON_PORT_UNLOCK(_port) mtx_unlock(&(_port)->vtcport_mtx)
92 struct vtcon_softc_port {
93 struct vtcon_softc *vcsp_sc;
94 struct vtcon_port *vcsp_port;
95 struct virtqueue *vcsp_invq;
96 struct virtqueue *vcsp_outvq;
101 struct mtx vtcon_mtx;
102 uint64_t vtcon_features;
103 uint32_t vtcon_max_ports;
104 uint32_t vtcon_flags;
105 #define VTCON_FLAG_DETACHED 0x01
106 #define VTCON_FLAG_SIZE 0x02
107 #define VTCON_FLAG_MULTIPORT 0x04
110 * Ports can be added and removed during runtime, but we have
111 * to allocate all the virtqueues during attach. This array is
112 * indexed by the port ID.
114 struct vtcon_softc_port *vtcon_ports;
116 struct task vtcon_ctrl_task;
117 struct virtqueue *vtcon_ctrl_rxvq;
118 struct virtqueue *vtcon_ctrl_txvq;
119 struct mtx vtcon_ctrl_tx_mtx;
122 #define VTCON_LOCK(_sc) mtx_lock(&(_sc)->vtcon_mtx)
123 #define VTCON_UNLOCK(_sc) mtx_unlock(&(_sc)->vtcon_mtx)
124 #define VTCON_LOCK_ASSERT(_sc) \
125 mtx_assert(&(_sc)->vtcon_mtx, MA_OWNED)
126 #define VTCON_LOCK_ASSERT_NOTOWNED(_sc) \
127 mtx_assert(&(_sc)->vtcon_mtx, MA_NOTOWNED)
129 #define VTCON_CTRL_TX_LOCK(_sc) mtx_lock(&(_sc)->vtcon_ctrl_tx_mtx)
130 #define VTCON_CTRL_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->vtcon_ctrl_tx_mtx)
132 #define VTCON_ASSERT_VALID_PORTID(_sc, _id) \
133 KASSERT((_id) >= 0 && (_id) < (_sc)->vtcon_max_ports, \
134 ("%s: port ID %d out of range", __func__, _id))
136 #define VTCON_FEATURES VIRTIO_CONSOLE_F_MULTIPORT
138 static struct virtio_feature_desc vtcon_feature_desc[] = {
139 { VIRTIO_CONSOLE_F_SIZE, "ConsoleSize" },
140 { VIRTIO_CONSOLE_F_MULTIPORT, "MultiplePorts" },
141 { VIRTIO_CONSOLE_F_EMERG_WRITE, "EmergencyWrite" },
146 static int vtcon_modevent(module_t, int, void *);
147 static void vtcon_drain_all(void);
149 static int vtcon_probe(device_t);
150 static int vtcon_attach(device_t);
151 static int vtcon_detach(device_t);
152 static int vtcon_config_change(device_t);
154 static void vtcon_setup_features(struct vtcon_softc *);
155 static void vtcon_negotiate_features(struct vtcon_softc *);
156 static int vtcon_alloc_scports(struct vtcon_softc *);
157 static int vtcon_alloc_virtqueues(struct vtcon_softc *);
158 static void vtcon_read_config(struct vtcon_softc *,
159 struct virtio_console_config *);
161 static void vtcon_determine_max_ports(struct vtcon_softc *,
162 struct virtio_console_config *);
163 static void vtcon_destroy_ports(struct vtcon_softc *);
164 static void vtcon_stop(struct vtcon_softc *);
166 static int vtcon_ctrl_event_enqueue(struct vtcon_softc *,
167 struct virtio_console_control *);
168 static int vtcon_ctrl_event_create(struct vtcon_softc *);
169 static void vtcon_ctrl_event_requeue(struct vtcon_softc *,
170 struct virtio_console_control *);
171 static int vtcon_ctrl_event_populate(struct vtcon_softc *);
172 static void vtcon_ctrl_event_drain(struct vtcon_softc *);
173 static int vtcon_ctrl_init(struct vtcon_softc *);
174 static void vtcon_ctrl_deinit(struct vtcon_softc *);
175 static void vtcon_ctrl_port_add_event(struct vtcon_softc *, int);
176 static void vtcon_ctrl_port_remove_event(struct vtcon_softc *, int);
177 static void vtcon_ctrl_port_console_event(struct vtcon_softc *, int);
178 static void vtcon_ctrl_port_open_event(struct vtcon_softc *, int);
179 static void vtcon_ctrl_port_name_event(struct vtcon_softc *, int,
180 const char *, size_t);
181 static void vtcon_ctrl_process_event(struct vtcon_softc *,
182 struct virtio_console_control *, void *, size_t);
183 static void vtcon_ctrl_task_cb(void *, int);
184 static void vtcon_ctrl_event_intr(void *);
185 static void vtcon_ctrl_poll(struct vtcon_softc *,
186 struct virtio_console_control *control);
187 static void vtcon_ctrl_send_control(struct vtcon_softc *, uint32_t,
190 static int vtcon_port_enqueue_buf(struct vtcon_port *, void *, size_t);
191 static int vtcon_port_create_buf(struct vtcon_port *);
192 static void vtcon_port_requeue_buf(struct vtcon_port *, void *);
193 static int vtcon_port_populate(struct vtcon_port *);
194 static void vtcon_port_destroy(struct vtcon_port *);
195 static int vtcon_port_create(struct vtcon_softc *, int);
196 static void vtcon_port_drain_bufs(struct virtqueue *);
197 static void vtcon_port_drain(struct vtcon_port *);
198 static void vtcon_port_teardown(struct vtcon_port *);
199 static void vtcon_port_change_size(struct vtcon_port *, uint16_t,
201 static void vtcon_port_update_console_size(struct vtcon_softc *);
202 static void vtcon_port_enable_intr(struct vtcon_port *);
203 static void vtcon_port_disable_intr(struct vtcon_port *);
204 static void vtcon_port_in(struct vtcon_port *);
205 static void vtcon_port_intr(void *);
206 static void vtcon_port_out(struct vtcon_port *, void *, int);
207 static void vtcon_port_submit_event(struct vtcon_port *, uint16_t,
210 static int vtcon_tty_open(struct tty *);
211 static void vtcon_tty_close(struct tty *);
212 static void vtcon_tty_outwakeup(struct tty *);
213 static void vtcon_tty_free(void *);
215 static void vtcon_get_console_size(struct vtcon_softc *, uint16_t *,
218 static void vtcon_enable_interrupts(struct vtcon_softc *);
219 static void vtcon_disable_interrupts(struct vtcon_softc *);
221 static int vtcon_pending_free;
223 static struct ttydevsw vtcon_tty_class = {
225 .tsw_open = vtcon_tty_open,
226 .tsw_close = vtcon_tty_close,
227 .tsw_outwakeup = vtcon_tty_outwakeup,
228 .tsw_free = vtcon_tty_free,
231 static device_method_t vtcon_methods[] = {
232 /* Device methods. */
233 DEVMETHOD(device_probe, vtcon_probe),
234 DEVMETHOD(device_attach, vtcon_attach),
235 DEVMETHOD(device_detach, vtcon_detach),
237 /* VirtIO methods. */
238 DEVMETHOD(virtio_config_change, vtcon_config_change),
243 static driver_t vtcon_driver = {
246 sizeof(struct vtcon_softc)
248 static devclass_t vtcon_devclass;
250 DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass,
252 MODULE_VERSION(virtio_console, 1);
253 MODULE_DEPEND(virtio_console, virtio, 1, 1, 1);
256 vtcon_modevent(module_t mod, int type, void *unused)
283 vtcon_drain_all(void)
287 for (first = 1; vtcon_pending_free != 0; first = 0) {
289 printf("virtio_console: Waiting for all detached TTY "
290 "devices to have open fds closed.\n");
292 pause("vtcondra", hz);
297 vtcon_probe(device_t dev)
300 if (virtio_get_device_type(dev) != VIRTIO_ID_CONSOLE)
303 device_set_desc(dev, "VirtIO Console Adapter");
305 return (BUS_PROBE_DEFAULT);
309 vtcon_attach(device_t dev)
311 struct vtcon_softc *sc;
312 struct virtio_console_config concfg;
315 sc = device_get_softc(dev);
318 mtx_init(&sc->vtcon_mtx, "vtconmtx", NULL, MTX_DEF);
319 mtx_init(&sc->vtcon_ctrl_tx_mtx, "vtconctrlmtx", NULL, MTX_DEF);
321 virtio_set_feature_desc(dev, vtcon_feature_desc);
322 vtcon_setup_features(sc);
324 vtcon_read_config(sc, &concfg);
325 vtcon_determine_max_ports(sc, &concfg);
327 error = vtcon_alloc_scports(sc);
329 device_printf(dev, "cannot allocate softc port structures\n");
333 error = vtcon_alloc_virtqueues(sc);
335 device_printf(dev, "cannot allocate virtqueues\n");
339 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
340 TASK_INIT(&sc->vtcon_ctrl_task, 0, vtcon_ctrl_task_cb, sc);
341 error = vtcon_ctrl_init(sc);
345 error = vtcon_port_create(sc, 0);
348 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
349 vtcon_port_update_console_size(sc);
352 error = virtio_setup_intr(dev, INTR_TYPE_TTY);
354 device_printf(dev, "cannot setup virtqueue interrupts\n");
358 vtcon_enable_interrupts(sc);
360 vtcon_ctrl_send_control(sc, VIRTIO_CONSOLE_BAD_ID,
361 VIRTIO_CONSOLE_DEVICE_READY, 1);
371 vtcon_detach(device_t dev)
373 struct vtcon_softc *sc;
375 sc = device_get_softc(dev);
378 sc->vtcon_flags |= VTCON_FLAG_DETACHED;
379 if (device_is_attached(dev))
383 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
384 taskqueue_drain(taskqueue_thread, &sc->vtcon_ctrl_task);
385 vtcon_ctrl_deinit(sc);
388 vtcon_destroy_ports(sc);
389 mtx_destroy(&sc->vtcon_mtx);
390 mtx_destroy(&sc->vtcon_ctrl_tx_mtx);
396 vtcon_config_change(device_t dev)
398 struct vtcon_softc *sc;
400 sc = device_get_softc(dev);
403 * When the multiport feature is negotiated, all configuration
404 * changes are done through control virtqueue events.
406 if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0) {
407 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
408 vtcon_port_update_console_size(sc);
415 vtcon_negotiate_features(struct vtcon_softc *sc)
421 features = VTCON_FEATURES;
423 sc->vtcon_features = virtio_negotiate_features(dev, features);
427 vtcon_setup_features(struct vtcon_softc *sc)
433 vtcon_negotiate_features(sc);
435 if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_SIZE))
436 sc->vtcon_flags |= VTCON_FLAG_SIZE;
437 if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_MULTIPORT))
438 sc->vtcon_flags |= VTCON_FLAG_MULTIPORT;
441 #define VTCON_GET_CONFIG(_dev, _feature, _field, _cfg) \
442 if (virtio_with_feature(_dev, _feature)) { \
443 virtio_read_device_config(_dev, \
444 offsetof(struct virtio_console_config, _field), \
445 &(_cfg)->_field, sizeof((_cfg)->_field)); \
449 vtcon_read_config(struct vtcon_softc *sc, struct virtio_console_config *concfg)
455 bzero(concfg, sizeof(struct virtio_console_config));
457 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, cols, concfg);
458 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, rows, concfg);
459 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_MULTIPORT, max_nr_ports, concfg);
462 #undef VTCON_GET_CONFIG
465 vtcon_alloc_scports(struct vtcon_softc *sc)
467 struct vtcon_softc_port *scport;
470 max = sc->vtcon_max_ports;
472 sc->vtcon_ports = malloc(sizeof(struct vtcon_softc_port) * max,
473 M_DEVBUF, M_NOWAIT | M_ZERO);
474 if (sc->vtcon_ports == NULL)
477 for (i = 0; i < max; i++) {
478 scport = &sc->vtcon_ports[i];
479 scport->vcsp_sc = sc;
486 vtcon_alloc_virtqueues(struct vtcon_softc *sc)
489 struct vq_alloc_info *info;
490 struct vtcon_softc_port *scport;
491 int i, idx, portidx, nvqs, error;
495 nvqs = sc->vtcon_max_ports * 2;
496 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
499 info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT);
503 for (i = 0, idx = 0, portidx = 0; i < nvqs / 2; i++, idx += 2) {
506 /* The control virtqueues are after the first port. */
507 VQ_ALLOC_INFO_INIT(&info[idx], 0,
508 vtcon_ctrl_event_intr, sc, &sc->vtcon_ctrl_rxvq,
509 "%s-control rx", device_get_nameunit(dev));
510 VQ_ALLOC_INFO_INIT(&info[idx+1], 0,
511 NULL, sc, &sc->vtcon_ctrl_txvq,
512 "%s-control tx", device_get_nameunit(dev));
516 scport = &sc->vtcon_ports[portidx];
518 VQ_ALLOC_INFO_INIT(&info[idx], 0, vtcon_port_intr,
519 scport, &scport->vcsp_invq, "%s-port%d in",
520 device_get_nameunit(dev), i);
521 VQ_ALLOC_INFO_INIT(&info[idx+1], 0, NULL,
522 NULL, &scport->vcsp_outvq, "%s-port%d out",
523 device_get_nameunit(dev), i);
528 error = virtio_alloc_virtqueues(dev, 0, nvqs, info);
535 vtcon_determine_max_ports(struct vtcon_softc *sc,
536 struct virtio_console_config *concfg)
539 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
540 sc->vtcon_max_ports =
541 min(concfg->max_nr_ports, VTCON_MAX_PORTS);
542 if (sc->vtcon_max_ports == 0)
543 sc->vtcon_max_ports = 1;
545 sc->vtcon_max_ports = 1;
549 vtcon_destroy_ports(struct vtcon_softc *sc)
551 struct vtcon_softc_port *scport;
552 struct vtcon_port *port;
553 struct virtqueue *vq;
556 if (sc->vtcon_ports == NULL)
560 for (i = 0; i < sc->vtcon_max_ports; i++) {
561 scport = &sc->vtcon_ports[i];
563 port = scport->vcsp_port;
565 scport->vcsp_port = NULL;
566 VTCON_PORT_LOCK(port);
568 vtcon_port_teardown(port);
572 vq = scport->vcsp_invq;
574 vtcon_port_drain_bufs(vq);
578 free(sc->vtcon_ports, M_DEVBUF);
579 sc->vtcon_ports = NULL;
583 vtcon_stop(struct vtcon_softc *sc)
586 vtcon_disable_interrupts(sc);
587 virtio_stop(sc->vtcon_dev);
591 vtcon_ctrl_event_enqueue(struct vtcon_softc *sc,
592 struct virtio_console_control *control)
594 struct sglist_seg segs[2];
596 struct virtqueue *vq;
599 vq = sc->vtcon_ctrl_rxvq;
601 sglist_init(&sg, 2, segs);
602 error = sglist_append(&sg, control,
603 sizeof(struct virtio_console_control) + VTCON_BULK_BUFSZ);
604 KASSERT(error == 0, ("%s: error %d adding control to sglist",
607 return (virtqueue_enqueue(vq, control, &sg, 0, sg.sg_nseg));
611 vtcon_ctrl_event_create(struct vtcon_softc *sc)
613 struct virtio_console_control *control;
617 sizeof(struct virtio_console_control) + VTCON_BULK_BUFSZ,
618 M_DEVBUF, M_ZERO | M_NOWAIT);
623 error = vtcon_ctrl_event_enqueue(sc, control);
625 free(control, M_DEVBUF);
631 vtcon_ctrl_event_requeue(struct vtcon_softc *sc,
632 struct virtio_console_control *control)
636 bzero(control, sizeof(struct virtio_console_control) +
639 error = vtcon_ctrl_event_enqueue(sc, control);
641 ("%s: cannot requeue control buffer %d", __func__, error));
645 vtcon_ctrl_event_populate(struct vtcon_softc *sc)
647 struct virtqueue *vq;
650 vq = sc->vtcon_ctrl_rxvq;
653 for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
654 error = vtcon_ctrl_event_create(sc);
660 virtqueue_notify(vq);
668 vtcon_ctrl_event_drain(struct vtcon_softc *sc)
670 struct virtio_console_control *control;
671 struct virtqueue *vq;
674 vq = sc->vtcon_ctrl_rxvq;
681 while ((control = virtqueue_drain(vq, &last)) != NULL)
682 free(control, M_DEVBUF);
687 vtcon_ctrl_init(struct vtcon_softc *sc)
691 error = vtcon_ctrl_event_populate(sc);
697 vtcon_ctrl_deinit(struct vtcon_softc *sc)
700 vtcon_ctrl_event_drain(sc);
704 vtcon_ctrl_port_add_event(struct vtcon_softc *sc, int id)
711 /* This single thread only way for ports to be created. */
712 if (sc->vtcon_ports[id].vcsp_port != NULL) {
713 device_printf(dev, "%s: adding port %d, but already exists\n",
718 error = vtcon_port_create(sc, id);
720 device_printf(dev, "%s: cannot create port %d: %d\n",
721 __func__, id, error);
722 vtcon_ctrl_send_control(sc, id, VIRTIO_CONSOLE_PORT_READY, 0);
728 vtcon_ctrl_port_remove_event(struct vtcon_softc *sc, int id)
731 struct vtcon_softc_port *scport;
732 struct vtcon_port *port;
735 scport = &sc->vtcon_ports[id];
738 port = scport->vcsp_port;
741 device_printf(dev, "%s: remove port %d, but does not exist\n",
746 scport->vcsp_port = NULL;
747 VTCON_PORT_LOCK(port);
749 vtcon_port_teardown(port);
753 vtcon_ctrl_port_console_event(struct vtcon_softc *sc, int id)
756 struct vtcon_softc_port *scport;
757 struct vtcon_port *port;
760 scport = &sc->vtcon_ports[id];
763 port = scport->vcsp_port;
766 device_printf(dev, "%s: console port %d, but does not exist\n",
771 VTCON_PORT_LOCK(port);
773 port->vtcport_flags |= VTCON_PORT_FLAG_CONSOLE;
774 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
775 VTCON_PORT_UNLOCK(port);
779 vtcon_ctrl_port_open_event(struct vtcon_softc *sc, int id)
782 struct vtcon_softc_port *scport;
783 struct vtcon_port *port;
786 scport = &sc->vtcon_ports[id];
789 port = scport->vcsp_port;
792 device_printf(dev, "%s: open port %d, but does not exist\n",
797 VTCON_PORT_LOCK(port);
799 vtcon_port_enable_intr(port);
800 VTCON_PORT_UNLOCK(port);
804 vtcon_ctrl_port_name_event(struct vtcon_softc *sc, int id, const char *name,
808 struct vtcon_softc_port *scport;
809 struct vtcon_port *port;
812 scport = &sc->vtcon_ports[id];
814 port = scport->vcsp_port;
816 device_printf(dev, "%s: name port %d, but does not exist\n",
821 tty_makealias(port->vtcport_tty, "vtcon/%*s", (int)len, name);
825 vtcon_ctrl_process_event(struct vtcon_softc *sc,
826 struct virtio_console_control *control, void *payload, size_t plen)
834 if (id < 0 || id >= sc->vtcon_max_ports) {
835 device_printf(dev, "%s: invalid port ID %d\n", __func__, id);
839 switch (control->event) {
840 case VIRTIO_CONSOLE_PORT_ADD:
841 vtcon_ctrl_port_add_event(sc, id);
844 case VIRTIO_CONSOLE_PORT_REMOVE:
845 vtcon_ctrl_port_remove_event(sc, id);
848 case VIRTIO_CONSOLE_CONSOLE_PORT:
849 vtcon_ctrl_port_console_event(sc, id);
852 case VIRTIO_CONSOLE_RESIZE:
855 case VIRTIO_CONSOLE_PORT_OPEN:
856 vtcon_ctrl_port_open_event(sc, id);
859 case VIRTIO_CONSOLE_PORT_NAME:
860 if (payload != NULL && plen > 0)
861 vtcon_ctrl_port_name_event(sc, id,
862 (const char *)payload, plen);
868 vtcon_ctrl_task_cb(void *xsc, int pending)
870 struct vtcon_softc *sc;
871 struct virtqueue *vq;
872 struct virtio_console_control *control;
879 vq = sc->vtcon_ctrl_rxvq;
883 while ((detached = (sc->vtcon_flags & VTCON_FLAG_DETACHED)) == 0) {
884 control = virtqueue_dequeue(vq, &len);
891 if (len > sizeof(*control)) {
892 payload = (void *)(control + 1);
893 plen = len - sizeof(*control);
897 vtcon_ctrl_process_event(sc, control, payload, plen);
899 vtcon_ctrl_event_requeue(sc, control);
903 virtqueue_notify(vq);
904 if (virtqueue_enable_intr(vq) != 0)
905 taskqueue_enqueue(taskqueue_thread,
906 &sc->vtcon_ctrl_task);
913 vtcon_ctrl_event_intr(void *xsc)
915 struct vtcon_softc *sc;
920 * Only some events require us to potentially block, but it
921 * easier to just defer all event handling to the taskqueue.
923 taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task);
927 vtcon_ctrl_poll(struct vtcon_softc *sc,
928 struct virtio_console_control *control)
930 struct sglist_seg segs[2];
932 struct virtqueue *vq;
935 vq = sc->vtcon_ctrl_txvq;
937 sglist_init(&sg, 2, segs);
938 error = sglist_append(&sg, control,
939 sizeof(struct virtio_console_control));
940 KASSERT(error == 0, ("%s: error %d adding control to sglist",
944 * We cannot use the softc lock to serialize access to this
945 * virtqueue since this is called from the tty layer with the
946 * port lock held. Acquiring the softc would violate our lock
949 VTCON_CTRL_TX_LOCK(sc);
950 KASSERT(virtqueue_empty(vq),
951 ("%s: virtqueue is not emtpy", __func__));
952 error = virtqueue_enqueue(vq, control, &sg, sg.sg_nseg, 0);
954 virtqueue_notify(vq);
955 virtqueue_poll(vq, NULL);
957 VTCON_CTRL_TX_UNLOCK(sc);
961 vtcon_ctrl_send_control(struct vtcon_softc *sc, uint32_t portid,
962 uint16_t event, uint16_t value)
964 struct virtio_console_control control;
966 if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0)
970 control.event = event;
971 control.value = value;
973 vtcon_ctrl_poll(sc, &control);
977 vtcon_port_enqueue_buf(struct vtcon_port *port, void *buf, size_t len)
979 struct sglist_seg segs[2];
981 struct virtqueue *vq;
984 vq = port->vtcport_invq;
986 sglist_init(&sg, 2, segs);
987 error = sglist_append(&sg, buf, len);
989 ("%s: error %d adding buffer to sglist", __func__, error));
991 error = virtqueue_enqueue(vq, buf, &sg, 0, sg.sg_nseg);
997 vtcon_port_create_buf(struct vtcon_port *port)
1002 buf = malloc(VTCON_BULK_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
1006 error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1008 free(buf, M_DEVBUF);
1014 vtcon_port_requeue_buf(struct vtcon_port *port, void *buf)
1018 error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1020 ("%s: cannot requeue input buffer %d", __func__, error));
1024 vtcon_port_populate(struct vtcon_port *port)
1026 struct virtqueue *vq;
1029 vq = port->vtcport_invq;
1032 for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
1033 error = vtcon_port_create_buf(port);
1039 virtqueue_notify(vq);
1047 vtcon_port_destroy(struct vtcon_port *port)
1050 port->vtcport_sc = NULL;
1051 port->vtcport_scport = NULL;
1052 port->vtcport_invq = NULL;
1053 port->vtcport_outvq = NULL;
1054 port->vtcport_id = -1;
1055 mtx_destroy(&port->vtcport_mtx);
1056 free(port, M_DEVBUF);
1060 vtcon_port_init_vqs(struct vtcon_port *port)
1062 struct vtcon_softc_port *scport;
1065 scport = port->vtcport_scport;
1067 port->vtcport_invq = scport->vcsp_invq;
1068 port->vtcport_outvq = scport->vcsp_outvq;
1071 * Free any data left over from when this virtqueue was in use by a
1072 * prior port. We have not yet notified the host that the port is
1073 * ready, so assume nothing in the virtqueue can be for us.
1075 vtcon_port_drain(port);
1077 KASSERT(virtqueue_empty(port->vtcport_invq),
1078 ("%s: in virtqueue is not empty", __func__));
1079 KASSERT(virtqueue_empty(port->vtcport_outvq),
1080 ("%s: out virtqueue is not empty", __func__));
1082 error = vtcon_port_populate(port);
1090 vtcon_port_create(struct vtcon_softc *sc, int id)
1093 struct vtcon_softc_port *scport;
1094 struct vtcon_port *port;
1097 dev = sc->vtcon_dev;
1098 scport = &sc->vtcon_ports[id];
1100 VTCON_ASSERT_VALID_PORTID(sc, id);
1101 MPASS(scport->vcsp_port == NULL);
1103 port = malloc(sizeof(struct vtcon_port), M_DEVBUF, M_NOWAIT | M_ZERO);
1107 port->vtcport_sc = sc;
1108 port->vtcport_scport = scport;
1109 port->vtcport_id = id;
1110 mtx_init(&port->vtcport_mtx, "vtcpmtx", NULL, MTX_DEF);
1111 port->vtcport_tty = tty_alloc_mutex(&vtcon_tty_class, port,
1112 &port->vtcport_mtx);
1114 error = vtcon_port_init_vqs(port);
1116 VTCON_PORT_LOCK(port);
1117 vtcon_port_teardown(port);
1122 VTCON_PORT_LOCK(port);
1123 scport->vcsp_port = port;
1124 vtcon_port_enable_intr(port);
1125 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_READY, 1);
1126 VTCON_PORT_UNLOCK(port);
1129 tty_makedev(port->vtcport_tty, NULL, "%s%r.%r", VTCON_TTY_PREFIX,
1130 device_get_unit(dev), id);
1136 vtcon_port_drain_bufs(struct virtqueue *vq)
1143 while ((buf = virtqueue_drain(vq, &last)) != NULL)
1144 free(buf, M_DEVBUF);
1148 vtcon_port_drain(struct vtcon_port *port)
1151 vtcon_port_drain_bufs(port->vtcport_invq);
1155 vtcon_port_teardown(struct vtcon_port *port)
1159 tp = port->vtcport_tty;
1161 port->vtcport_flags |= VTCON_PORT_FLAG_GONE;
1164 atomic_add_int(&vtcon_pending_free, 1);
1167 vtcon_port_destroy(port);
1171 vtcon_port_change_size(struct vtcon_port *port, uint16_t cols, uint16_t rows)
1176 tp = port->vtcport_tty;
1181 bzero(&sz, sizeof(struct winsize));
1185 tty_set_winsize(tp, &sz);
1189 vtcon_port_update_console_size(struct vtcon_softc *sc)
1191 struct vtcon_port *port;
1192 struct vtcon_softc_port *scport;
1193 uint16_t cols, rows;
1195 vtcon_get_console_size(sc, &cols, &rows);
1198 * For now, assume the first (only) port is the console. Note
1199 * QEMU does not implement this feature yet.
1201 scport = &sc->vtcon_ports[0];
1204 port = scport->vcsp_port;
1207 VTCON_PORT_LOCK(port);
1209 vtcon_port_change_size(port, cols, rows);
1210 VTCON_PORT_UNLOCK(port);
1216 vtcon_port_enable_intr(struct vtcon_port *port)
1220 * NOTE: The out virtqueue is always polled, so its interrupt
1223 virtqueue_enable_intr(port->vtcport_invq);
1227 vtcon_port_disable_intr(struct vtcon_port *port)
1230 if (port->vtcport_invq != NULL)
1231 virtqueue_disable_intr(port->vtcport_invq);
1232 if (port->vtcport_outvq != NULL)
1233 virtqueue_disable_intr(port->vtcport_outvq);
1237 vtcon_port_in(struct vtcon_port *port)
1239 struct virtqueue *vq;
1245 tp = port->vtcport_tty;
1246 vq = port->vtcport_invq;
1251 while ((buf = virtqueue_dequeue(vq, &len)) != NULL) {
1252 for (i = 0; i < len; i++) {
1254 if (port->vtcport_flags & VTCON_PORT_FLAG_CONSOLE)
1255 kdb_alt_break(buf[i],
1256 &port->vtcport_alt_break_state);
1258 ttydisc_rint(tp, buf[i], 0);
1260 vtcon_port_requeue_buf(port, buf);
1263 ttydisc_rint_done(tp);
1266 virtqueue_notify(vq);
1268 if (virtqueue_enable_intr(vq) != 0)
1273 vtcon_port_intr(void *scportx)
1275 struct vtcon_softc_port *scport;
1276 struct vtcon_softc *sc;
1277 struct vtcon_port *port;
1280 sc = scport->vcsp_sc;
1283 port = scport->vcsp_port;
1288 VTCON_PORT_LOCK(port);
1290 if ((port->vtcport_flags & VTCON_PORT_FLAG_GONE) == 0)
1291 vtcon_port_in(port);
1292 VTCON_PORT_UNLOCK(port);
1296 vtcon_port_out(struct vtcon_port *port, void *buf, int bufsize)
1298 struct sglist_seg segs[2];
1300 struct virtqueue *vq;
1303 vq = port->vtcport_outvq;
1304 KASSERT(virtqueue_empty(vq),
1305 ("%s: port %p out virtqueue not emtpy", __func__, port));
1307 sglist_init(&sg, 2, segs);
1308 error = sglist_append(&sg, buf, bufsize);
1309 KASSERT(error == 0, ("%s: error %d adding buffer to sglist",
1312 error = virtqueue_enqueue(vq, buf, &sg, sg.sg_nseg, 0);
1314 virtqueue_notify(vq);
1315 virtqueue_poll(vq, NULL);
1320 vtcon_port_submit_event(struct vtcon_port *port, uint16_t event,
1323 struct vtcon_softc *sc;
1325 sc = port->vtcport_sc;
1327 vtcon_ctrl_send_control(sc, port->vtcport_id, event, value);
1331 vtcon_tty_open(struct tty *tp)
1333 struct vtcon_port *port;
1335 port = tty_softc(tp);
1337 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1340 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1346 vtcon_tty_close(struct tty *tp)
1348 struct vtcon_port *port;
1350 port = tty_softc(tp);
1352 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1355 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1359 vtcon_tty_outwakeup(struct tty *tp)
1361 struct vtcon_port *port;
1362 char buf[VTCON_BULK_BUFSZ];
1365 port = tty_softc(tp);
1367 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1370 while ((len = ttydisc_getc(tp, buf, sizeof(buf))) != 0)
1371 vtcon_port_out(port, buf, len);
1375 vtcon_tty_free(void *xport)
1377 struct vtcon_port *port;
1381 vtcon_port_destroy(port);
1382 atomic_subtract_int(&vtcon_pending_free, 1);
1386 vtcon_get_console_size(struct vtcon_softc *sc, uint16_t *cols, uint16_t *rows)
1388 struct virtio_console_config concfg;
1390 KASSERT(sc->vtcon_flags & VTCON_FLAG_SIZE,
1391 ("%s: size feature not negotiated", __func__));
1393 vtcon_read_config(sc, &concfg);
1395 *cols = concfg.cols;
1396 *rows = concfg.rows;
1400 vtcon_enable_interrupts(struct vtcon_softc *sc)
1402 struct vtcon_softc_port *scport;
1403 struct vtcon_port *port;
1408 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1409 virtqueue_enable_intr(sc->vtcon_ctrl_rxvq);
1411 for (i = 0; i < sc->vtcon_max_ports; i++) {
1412 scport = &sc->vtcon_ports[i];
1414 port = scport->vcsp_port;
1418 VTCON_PORT_LOCK(port);
1419 vtcon_port_enable_intr(port);
1420 VTCON_PORT_UNLOCK(port);
1427 vtcon_disable_interrupts(struct vtcon_softc *sc)
1429 struct vtcon_softc_port *scport;
1430 struct vtcon_port *port;
1433 VTCON_LOCK_ASSERT(sc);
1435 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1436 virtqueue_disable_intr(sc->vtcon_ctrl_rxvq);
1438 for (i = 0; i < sc->vtcon_max_ports; i++) {
1439 scport = &sc->vtcon_ports[i];
1441 port = scport->vcsp_port;
1445 VTCON_PORT_LOCK(port);
1446 vtcon_port_disable_intr(port);
1447 VTCON_PORT_UNLOCK(port);