sys/dev/virtio/console/virtio_console.c

   1 /*-
   2  * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  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.
  14  *
  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.
  25  */
  26
  27 /* Driver for VirtIO console devices. */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/ctype.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/kdb.h>
  39 #include <sys/lock.h>
  40 #include <sys/mutex.h>
  41 #include <sys/sglist.h>
  42 #include <sys/sysctl.h>
  43 #include <sys/taskqueue.h>
  44 #include <sys/queue.h>
  45
  46 #include <sys/conf.h>
  47 #include <sys/cons.h>
  48 #include <sys/tty.h>
  49
  50 #include <machine/bus.h>
  51 #include <machine/resource.h>
  52 #include <sys/bus.h>
  53
  54 #include <dev/virtio/virtio.h>
  55 #include <dev/virtio/virtqueue.h>
  56 #include <dev/virtio/console/virtio_console.h>
  57
  58 #include "virtio_if.h"
  59
  60 #define VTCON_MAX_PORTS 32
  61 #define VTCON_TTY_PREFIX "V"
  62 #define VTCON_TTY_ALIAS_PREFIX "vtcon"
  63 #define VTCON_BULK_BUFSZ 128
  64 #define VTCON_CTRL_BUFSZ 128
  65
  66 /*
  67  * The buffers cannot cross more than one page boundary due to the
  68  * size of the sglist segment array used.
  69  */
  70 CTASSERT(VTCON_BULK_BUFSZ <= PAGE_SIZE);
  71 CTASSERT(VTCON_CTRL_BUFSZ <= PAGE_SIZE);
  72
  73 CTASSERT(sizeof(struct virtio_console_config) <= VTCON_CTRL_BUFSZ);
  74
  75 struct vtcon_softc;
  76 struct vtcon_softc_port;
  77
  78 struct vtcon_port {
  79         struct mtx                       vtcport_mtx;
  80         struct vtcon_softc              *vtcport_sc;
  81         struct vtcon_softc_port         *vtcport_scport;
  82         struct tty                      *vtcport_tty;
  83         struct virtqueue                *vtcport_invq;
  84         struct virtqueue                *vtcport_outvq;
  85         int                              vtcport_id;
  86         int                              vtcport_flags;
  87 #define VTCON_PORT_FLAG_GONE    0x01
  88 #define VTCON_PORT_FLAG_CONSOLE 0x02
  89 #define VTCON_PORT_FLAG_ALIAS   0x04
  90
  91 #if defined(KDB)
  92         int                              vtcport_alt_break_state;
  93 #endif
  94 };
  95
  96 #define VTCON_PORT_LOCK(_port)          mtx_lock(&(_port)->vtcport_mtx)
  97 #define VTCON_PORT_UNLOCK(_port)        mtx_unlock(&(_port)->vtcport_mtx)
  98
  99 struct vtcon_softc_port {
 100         struct vtcon_softc      *vcsp_sc;
 101         struct vtcon_port       *vcsp_port;
 102         struct virtqueue        *vcsp_invq;
 103         struct virtqueue        *vcsp_outvq;
 104 };
 105
 106 struct vtcon_softc {
 107         device_t                 vtcon_dev;
 108         struct mtx               vtcon_mtx;
 109         uint64_t                 vtcon_features;
 110         uint32_t                 vtcon_max_ports;
 111         uint32_t                 vtcon_flags;
 112 #define VTCON_FLAG_DETACHED     0x01
 113 #define VTCON_FLAG_SIZE         0x02
 114 #define VTCON_FLAG_MULTIPORT    0x04
 115
 116         /*
 117          * Ports can be added and removed during runtime, but we have
 118          * to allocate all the virtqueues during attach. This array is
 119          * indexed by the port ID.
 120          */
 121         struct vtcon_softc_port *vtcon_ports;
 122
 123         struct task              vtcon_ctrl_task;
 124         struct virtqueue        *vtcon_ctrl_rxvq;
 125         struct virtqueue        *vtcon_ctrl_txvq;
 126         struct mtx               vtcon_ctrl_tx_mtx;
 127 };
 128
 129 #define VTCON_LOCK(_sc)                 mtx_lock(&(_sc)->vtcon_mtx)
 130 #define VTCON_UNLOCK(_sc)               mtx_unlock(&(_sc)->vtcon_mtx)
 131 #define VTCON_LOCK_ASSERT(_sc)          \
 132     mtx_assert(&(_sc)->vtcon_mtx, MA_OWNED)
 133 #define VTCON_LOCK_ASSERT_NOTOWNED(_sc) \
 134     mtx_assert(&(_sc)->vtcon_mtx, MA_NOTOWNED)
 135
 136 #define VTCON_CTRL_TX_LOCK(_sc)         mtx_lock(&(_sc)->vtcon_ctrl_tx_mtx)
 137 #define VTCON_CTRL_TX_UNLOCK(_sc)       mtx_unlock(&(_sc)->vtcon_ctrl_tx_mtx)
 138
 139 #define VTCON_ASSERT_VALID_PORTID(_sc, _id)                     \
 140     KASSERT((_id) >= 0 && (_id) < (_sc)->vtcon_max_ports,       \
 141         ("%s: port ID %d out of range", __func__, _id))
 142
 143 #define VTCON_FEATURES  VIRTIO_CONSOLE_F_MULTIPORT
 144
 145 static struct virtio_feature_desc vtcon_feature_desc[] = {
 146         { VIRTIO_CONSOLE_F_SIZE,        "ConsoleSize"   },
 147         { VIRTIO_CONSOLE_F_MULTIPORT,   "MultiplePorts" },
 148         { VIRTIO_CONSOLE_F_EMERG_WRITE, "EmergencyWrite" },
 149
 150         { 0, NULL }
 151 };
 152
 153 static int       vtcon_modevent(module_t, int, void *);
 154 static void      vtcon_drain_all(void);
 155
 156 static int       vtcon_probe(device_t);
 157 static int       vtcon_attach(device_t);
 158 static int       vtcon_detach(device_t);
 159 static int       vtcon_config_change(device_t);
 160
 161 static void      vtcon_setup_features(struct vtcon_softc *);
 162 static void      vtcon_negotiate_features(struct vtcon_softc *);
 163 static int       vtcon_alloc_scports(struct vtcon_softc *);
 164 static int       vtcon_alloc_virtqueues(struct vtcon_softc *);
 165 static void      vtcon_read_config(struct vtcon_softc *,
 166                      struct virtio_console_config *);
 167
 168 static void      vtcon_determine_max_ports(struct vtcon_softc *,
 169                      struct virtio_console_config *);
 170 static void      vtcon_destroy_ports(struct vtcon_softc *);
 171 static void      vtcon_stop(struct vtcon_softc *);
 172
 173 static int       vtcon_ctrl_event_enqueue(struct vtcon_softc *,
 174                      struct virtio_console_control *);
 175 static int       vtcon_ctrl_event_create(struct vtcon_softc *);
 176 static void      vtcon_ctrl_event_requeue(struct vtcon_softc *,
 177                      struct virtio_console_control *);
 178 static int       vtcon_ctrl_event_populate(struct vtcon_softc *);
 179 static void      vtcon_ctrl_event_drain(struct vtcon_softc *);
 180 static int       vtcon_ctrl_init(struct vtcon_softc *);
 181 static void      vtcon_ctrl_deinit(struct vtcon_softc *);
 182 static void      vtcon_ctrl_port_add_event(struct vtcon_softc *, int);
 183 static void      vtcon_ctrl_port_remove_event(struct vtcon_softc *, int);
 184 static void      vtcon_ctrl_port_console_event(struct vtcon_softc *, int);
 185 static void      vtcon_ctrl_port_open_event(struct vtcon_softc *, int);
 186 static void      vtcon_ctrl_port_name_event(struct vtcon_softc *, int,
 187                      const char *, size_t);
 188 static void      vtcon_ctrl_process_event(struct vtcon_softc *,
 189                      struct virtio_console_control *, void *, size_t);
 190 static void      vtcon_ctrl_task_cb(void *, int);
 191 static void      vtcon_ctrl_event_intr(void *);
 192 static void      vtcon_ctrl_poll(struct vtcon_softc *,
 193                      struct virtio_console_control *control);
 194 static void      vtcon_ctrl_send_control(struct vtcon_softc *, uint32_t,
 195                      uint16_t, uint16_t);
 196
 197 static int       vtcon_port_enqueue_buf(struct vtcon_port *, void *, size_t);
 198 static int       vtcon_port_create_buf(struct vtcon_port *);
 199 static void      vtcon_port_requeue_buf(struct vtcon_port *, void *);
 200 static int       vtcon_port_populate(struct vtcon_port *);
 201 static void      vtcon_port_destroy(struct vtcon_port *);
 202 static int       vtcon_port_create(struct vtcon_softc *, int);
 203 static void      vtcon_port_dev_alias(struct vtcon_port *, const char *,
 204                      size_t);
 205 static void      vtcon_port_drain_bufs(struct virtqueue *);
 206 static void      vtcon_port_drain(struct vtcon_port *);
 207 static void      vtcon_port_teardown(struct vtcon_port *);
 208 static void      vtcon_port_change_size(struct vtcon_port *, uint16_t,
 209                      uint16_t);
 210 static void      vtcon_port_update_console_size(struct vtcon_softc *);
 211 static void      vtcon_port_enable_intr(struct vtcon_port *);
 212 static void      vtcon_port_disable_intr(struct vtcon_port *);
 213 static void      vtcon_port_in(struct vtcon_port *);
 214 static void      vtcon_port_intr(void *);
 215 static void      vtcon_port_out(struct vtcon_port *, void *, int);
 216 static void      vtcon_port_submit_event(struct vtcon_port *, uint16_t,
 217                      uint16_t);
 218
 219 static int       vtcon_tty_open(struct tty *);
 220 static void      vtcon_tty_close(struct tty *);
 221 static void      vtcon_tty_outwakeup(struct tty *);
 222 static void      vtcon_tty_free(void *);
 223
 224 static void      vtcon_get_console_size(struct vtcon_softc *, uint16_t *,
 225                      uint16_t *);
 226
 227 static void      vtcon_enable_interrupts(struct vtcon_softc *);
 228 static void      vtcon_disable_interrupts(struct vtcon_softc *);
 229
 230 static int       vtcon_pending_free;
 231
 232 static struct ttydevsw vtcon_tty_class = {
 233         .tsw_flags      = 0,
 234         .tsw_open       = vtcon_tty_open,
 235         .tsw_close      = vtcon_tty_close,
 236         .tsw_outwakeup  = vtcon_tty_outwakeup,
 237         .tsw_free       = vtcon_tty_free,
 238 };
 239
 240 static device_method_t vtcon_methods[] = {
 241         /* Device methods. */
 242         DEVMETHOD(device_probe,         vtcon_probe),
 243         DEVMETHOD(device_attach,        vtcon_attach),
 244         DEVMETHOD(device_detach,        vtcon_detach),
 245
 246         /* VirtIO methods. */
 247         DEVMETHOD(virtio_config_change, vtcon_config_change),
 248
 249         DEVMETHOD_END
 250 };
 251
 252 static driver_t vtcon_driver = {
 253         "vtcon",
 254         vtcon_methods,
 255         sizeof(struct vtcon_softc)
 256 };
 257 static devclass_t vtcon_devclass;
 258
 259 DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass,
 260     vtcon_modevent, 0);
 261 MODULE_VERSION(virtio_console, 1);
 262 MODULE_DEPEND(virtio_console, virtio, 1, 1, 1);
 263
 264 static int
 265 vtcon_modevent(module_t mod, int type, void *unused)
 266 {
 267         int error;
 268
 269         switch (type) {
 270         case MOD_LOAD:
 271                 error = 0;
 272                 break;
 273         case MOD_QUIESCE:
 274                 error = 0;
 275                 break;
 276         case MOD_UNLOAD:
 277                 vtcon_drain_all();
 278                 error = 0;
 279                 break;
 280         case MOD_SHUTDOWN:
 281                 error = 0;
 282                 break;
 283         default:
 284                 error = EOPNOTSUPP;
 285                 break;
 286         }
 287
 288         return (error);
 289 }
 290
 291 static void
 292 vtcon_drain_all(void)
 293 {
 294         int first;
 295
 296         for (first = 1; vtcon_pending_free != 0; first = 0) {
 297                 if (first != 0) {
 298                         printf("virtio_console: Waiting for all detached TTY "
 299                             "devices to have open fds closed.\n");
 300                 }
 301                 pause("vtcondra", hz);
 302         }
 303 }
 304
 305 static int
 306 vtcon_probe(device_t dev)
 307 {
 308
 309         if (virtio_get_device_type(dev) != VIRTIO_ID_CONSOLE)
 310                 return (ENXIO);
 311
 312         device_set_desc(dev, "VirtIO Console Adapter");
 313
 314         return (BUS_PROBE_DEFAULT);
 315 }
 316
 317 static int
 318 vtcon_attach(device_t dev)
 319 {
 320         struct vtcon_softc *sc;
 321         struct virtio_console_config concfg;
 322         int error;
 323
 324         sc = device_get_softc(dev);
 325         sc->vtcon_dev = dev;
 326
 327         mtx_init(&sc->vtcon_mtx, "vtconmtx", NULL, MTX_DEF);
 328         mtx_init(&sc->vtcon_ctrl_tx_mtx, "vtconctrlmtx", NULL, MTX_DEF);
 329
 330         virtio_set_feature_desc(dev, vtcon_feature_desc);
 331         vtcon_setup_features(sc);
 332
 333         vtcon_read_config(sc, &concfg);
 334         vtcon_determine_max_ports(sc, &concfg);
 335
 336         error = vtcon_alloc_scports(sc);
 337         if (error) {
 338                 device_printf(dev, "cannot allocate softc port structures\n");
 339                 goto fail;
 340         }
 341
 342         error = vtcon_alloc_virtqueues(sc);
 343         if (error) {
 344                 device_printf(dev, "cannot allocate virtqueues\n");
 345                 goto fail;
 346         }
 347
 348         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
 349                 TASK_INIT(&sc->vtcon_ctrl_task, 0, vtcon_ctrl_task_cb, sc);
 350                 error = vtcon_ctrl_init(sc);
 351                 if (error)
 352                         goto fail;
 353         } else {
 354                 error = vtcon_port_create(sc, 0);
 355                 if (error)
 356                         goto fail;
 357                 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
 358                         vtcon_port_update_console_size(sc);
 359         }
 360
 361         error = virtio_setup_intr(dev, INTR_TYPE_TTY);
 362         if (error) {
 363                 device_printf(dev, "cannot setup virtqueue interrupts\n");
 364                 goto fail;
 365         }
 366
 367         vtcon_enable_interrupts(sc);
 368
 369         vtcon_ctrl_send_control(sc, VIRTIO_CONSOLE_BAD_ID,
 370             VIRTIO_CONSOLE_DEVICE_READY, 1);
 371
 372 fail:
 373         if (error)
 374                 vtcon_detach(dev);
 375
 376         return (error);
 377 }
 378
 379 static int
 380 vtcon_detach(device_t dev)
 381 {
 382         struct vtcon_softc *sc;
 383
 384         sc = device_get_softc(dev);
 385
 386         VTCON_LOCK(sc);
 387         sc->vtcon_flags |= VTCON_FLAG_DETACHED;
 388         if (device_is_attached(dev))
 389                 vtcon_stop(sc);
 390         VTCON_UNLOCK(sc);
 391
 392         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
 393                 taskqueue_drain(taskqueue_thread, &sc->vtcon_ctrl_task);
 394                 vtcon_ctrl_deinit(sc);
 395         }
 396
 397         vtcon_destroy_ports(sc);
 398         mtx_destroy(&sc->vtcon_mtx);
 399         mtx_destroy(&sc->vtcon_ctrl_tx_mtx);
 400
 401         return (0);
 402 }
 403
 404 static int
 405 vtcon_config_change(device_t dev)
 406 {
 407         struct vtcon_softc *sc;
 408
 409         sc = device_get_softc(dev);
 410
 411         /*
 412          * When the multiport feature is negotiated, all configuration
 413          * changes are done through control virtqueue events.
 414          */
 415         if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0) {
 416                 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
 417                         vtcon_port_update_console_size(sc);
 418         }
 419
 420         return (0);
 421 }
 422
 423 static void
 424 vtcon_negotiate_features(struct vtcon_softc *sc)
 425 {
 426         device_t dev;
 427         uint64_t features;
 428
 429         dev = sc->vtcon_dev;
 430         features = VTCON_FEATURES;
 431
 432         sc->vtcon_features = virtio_negotiate_features(dev, features);
 433 }
 434
 435 static void
 436 vtcon_setup_features(struct vtcon_softc *sc)
 437 {
 438         device_t dev;
 439
 440         dev = sc->vtcon_dev;
 441
 442         vtcon_negotiate_features(sc);
 443
 444         if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_SIZE))
 445                 sc->vtcon_flags |= VTCON_FLAG_SIZE;
 446         if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_MULTIPORT))
 447                 sc->vtcon_flags |= VTCON_FLAG_MULTIPORT;
 448 }
 449
 450 #define VTCON_GET_CONFIG(_dev, _feature, _field, _cfg)                  \
 451         if (virtio_with_feature(_dev, _feature)) {                      \
 452                 virtio_read_device_config(_dev,                         \
 453                     offsetof(struct virtio_console_config, _field),     \
 454                     &(_cfg)->_field, sizeof((_cfg)->_field));           \
 455         }
 456
 457 static void
 458 vtcon_read_config(struct vtcon_softc *sc, struct virtio_console_config *concfg)
 459 {
 460         device_t dev;
 461
 462         dev = sc->vtcon_dev;
 463
 464         bzero(concfg, sizeof(struct virtio_console_config));
 465
 466         VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, cols, concfg);
 467         VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, rows, concfg);
 468         VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_MULTIPORT, max_nr_ports, concfg);
 469 }
 470
 471 #undef VTCON_GET_CONFIG
 472
 473 static int
 474 vtcon_alloc_scports(struct vtcon_softc *sc)
 475 {
 476         struct vtcon_softc_port *scport;
 477         u_int max, i;
 478
 479         max = sc->vtcon_max_ports;
 480
 481         sc->vtcon_ports = mallocarray(max, sizeof(struct vtcon_softc_port),
 482             M_DEVBUF, M_NOWAIT | M_ZERO);
 483         if (sc->vtcon_ports == NULL)
 484                 return (ENOMEM);
 485
 486         for (i = 0; i < max; i++) {
 487                 scport = &sc->vtcon_ports[i];
 488                 scport->vcsp_sc = sc;
 489         }
 490
 491         return (0);
 492 }
 493
 494 static int
 495 vtcon_alloc_virtqueues(struct vtcon_softc *sc)
 496 {
 497         device_t dev;
 498         struct vq_alloc_info *info;
 499         struct vtcon_softc_port *scport;
 500         u_int i, idx, portidx, nvqs;
 501         int error;
 502
 503         dev = sc->vtcon_dev;
 504
 505         nvqs = sc->vtcon_max_ports * 2;
 506         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
 507                 nvqs += 2;
 508
 509         info = mallocarray(nvqs, sizeof(struct vq_alloc_info), M_TEMP,
 510             M_NOWAIT);
 511         if (info == NULL)
 512                 return (ENOMEM);
 513
 514         for (i = 0, idx = 0, portidx = 0; i < nvqs / 2; i++, idx += 2) {
 515
 516                 if (i == 1) {
 517                         /* The control virtqueues are after the first port. */
 518                         VQ_ALLOC_INFO_INIT(&info[idx], 0,
 519                             vtcon_ctrl_event_intr, sc, &sc->vtcon_ctrl_rxvq,
 520                             "%s-control rx", device_get_nameunit(dev));
 521                         VQ_ALLOC_INFO_INIT(&info[idx+1], 0,
 522                             NULL, sc, &sc->vtcon_ctrl_txvq,
 523                             "%s-control tx", device_get_nameunit(dev));
 524                         continue;
 525                 }
 526
 527                 scport = &sc->vtcon_ports[portidx];
 528
 529                 VQ_ALLOC_INFO_INIT(&info[idx], 0, vtcon_port_intr,
 530                     scport, &scport->vcsp_invq, "%s-port%d in",
 531                     device_get_nameunit(dev), i);
 532                 VQ_ALLOC_INFO_INIT(&info[idx+1], 0, NULL,
 533                     NULL, &scport->vcsp_outvq, "%s-port%d out",
 534                     device_get_nameunit(dev), i);
 535
 536                 portidx++;
 537         }
 538
 539         error = virtio_alloc_virtqueues(dev, 0, nvqs, info);
 540         free(info, M_TEMP);
 541
 542         return (error);
 543 }
 544
 545 static void
 546 vtcon_determine_max_ports(struct vtcon_softc *sc,
 547     struct virtio_console_config *concfg)
 548 {
 549
 550         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
 551                 sc->vtcon_max_ports =
 552                     min(concfg->max_nr_ports, VTCON_MAX_PORTS);
 553                 if (sc->vtcon_max_ports == 0)
 554                         sc->vtcon_max_ports = 1;
 555         } else
 556                 sc->vtcon_max_ports = 1;
 557 }
 558
 559 static void
 560 vtcon_destroy_ports(struct vtcon_softc *sc)
 561 {
 562         struct vtcon_softc_port *scport;
 563         struct vtcon_port *port;
 564         struct virtqueue *vq;
 565         int i;
 566
 567         if (sc->vtcon_ports == NULL)
 568                 return;
 569
 570         VTCON_LOCK(sc);
 571         for (i = 0; i < sc->vtcon_max_ports; i++) {
 572                 scport = &sc->vtcon_ports[i];
 573
 574                 port = scport->vcsp_port;
 575                 if (port != NULL) {
 576                         scport->vcsp_port = NULL;
 577                         VTCON_PORT_LOCK(port);
 578                         VTCON_UNLOCK(sc);
 579                         vtcon_port_teardown(port);
 580                         VTCON_LOCK(sc);
 581                 }
 582
 583                 vq = scport->vcsp_invq;
 584                 if (vq != NULL)
 585                         vtcon_port_drain_bufs(vq);
 586         }
 587         VTCON_UNLOCK(sc);
 588
 589         free(sc->vtcon_ports, M_DEVBUF);
 590         sc->vtcon_ports = NULL;
 591 }
 592
 593 static void
 594 vtcon_stop(struct vtcon_softc *sc)
 595 {
 596
 597         vtcon_disable_interrupts(sc);
 598         virtio_stop(sc->vtcon_dev);
 599 }
 600
 601 static int
 602 vtcon_ctrl_event_enqueue(struct vtcon_softc *sc,
 603     struct virtio_console_control *control)
 604 {
 605         struct sglist_seg segs[2];
 606         struct sglist sg;
 607         struct virtqueue *vq;
 608         int error;
 609
 610         vq = sc->vtcon_ctrl_rxvq;
 611
 612         sglist_init(&sg, 2, segs);
 613         error = sglist_append(&sg, control, VTCON_CTRL_BUFSZ);
 614         KASSERT(error == 0, ("%s: error %d adding control to sglist",
 615             __func__, error));
 616
 617         return (virtqueue_enqueue(vq, control, &sg, 0, sg.sg_nseg));
 618 }
 619
 620 static int
 621 vtcon_ctrl_event_create(struct vtcon_softc *sc)
 622 {
 623         struct virtio_console_control *control;
 624         int error;
 625
 626         control = malloc(VTCON_CTRL_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
 627         if (control == NULL)
 628                 return (ENOMEM);
 629
 630         error = vtcon_ctrl_event_enqueue(sc, control);
 631         if (error)
 632                 free(control, M_DEVBUF);
 633
 634         return (error);
 635 }
 636
 637 static void
 638 vtcon_ctrl_event_requeue(struct vtcon_softc *sc,
 639     struct virtio_console_control *control)
 640 {
 641         int error;
 642
 643         bzero(control, VTCON_CTRL_BUFSZ);
 644
 645         error = vtcon_ctrl_event_enqueue(sc, control);
 646         KASSERT(error == 0,
 647             ("%s: cannot requeue control buffer %d", __func__, error));
 648 }
 649
 650 static int
 651 vtcon_ctrl_event_populate(struct vtcon_softc *sc)
 652 {
 653         struct virtqueue *vq;
 654         int nbufs, error;
 655
 656         vq = sc->vtcon_ctrl_rxvq;
 657         error = ENOSPC;
 658
 659         for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
 660                 error = vtcon_ctrl_event_create(sc);
 661                 if (error)
 662                         break;
 663         }
 664
 665         if (nbufs > 0) {
 666                 virtqueue_notify(vq);
 667                 error = 0;
 668         }
 669
 670         return (error);
 671 }
 672
 673 static void
 674 vtcon_ctrl_event_drain(struct vtcon_softc *sc)
 675 {
 676         struct virtio_console_control *control;
 677         struct virtqueue *vq;
 678         int last;
 679
 680         vq = sc->vtcon_ctrl_rxvq;
 681         last = 0;
 682
 683         if (vq == NULL)
 684                 return;
 685
 686         VTCON_LOCK(sc);
 687         while ((control = virtqueue_drain(vq, &last)) != NULL)
 688                 free(control, M_DEVBUF);
 689         VTCON_UNLOCK(sc);
 690 }
 691
 692 static int
 693 vtcon_ctrl_init(struct vtcon_softc *sc)
 694 {
 695         int error;
 696
 697         error = vtcon_ctrl_event_populate(sc);
 698
 699         return (error);
 700 }
 701
 702 static void
 703 vtcon_ctrl_deinit(struct vtcon_softc *sc)
 704 {
 705
 706         vtcon_ctrl_event_drain(sc);
 707 }
 708
 709 static void
 710 vtcon_ctrl_port_add_event(struct vtcon_softc *sc, int id)
 711 {
 712         device_t dev;
 713         int error;
 714
 715         dev = sc->vtcon_dev;
 716
 717         /* This single thread only way for ports to be created. */
 718         if (sc->vtcon_ports[id].vcsp_port != NULL) {
 719                 device_printf(dev, "%s: adding port %d, but already exists\n",
 720                     __func__, id);
 721                 return;
 722         }
 723
 724         error = vtcon_port_create(sc, id);
 725         if (error) {
 726                 device_printf(dev, "%s: cannot create port %d: %d\n",
 727                     __func__, id, error);
 728                 vtcon_ctrl_send_control(sc, id, VIRTIO_CONSOLE_PORT_READY, 0);
 729                 return;
 730         }
 731 }
 732
 733 static void
 734 vtcon_ctrl_port_remove_event(struct vtcon_softc *sc, int id)
 735 {
 736         device_t dev;
 737         struct vtcon_softc_port *scport;
 738         struct vtcon_port *port;
 739
 740         dev = sc->vtcon_dev;
 741         scport = &sc->vtcon_ports[id];
 742
 743         VTCON_LOCK(sc);
 744         port = scport->vcsp_port;
 745         if (port == NULL) {
 746                 VTCON_UNLOCK(sc);
 747                 device_printf(dev, "%s: remove port %d, but does not exist\n",
 748                     __func__, id);
 749                 return;
 750         }
 751
 752         scport->vcsp_port = NULL;
 753         VTCON_PORT_LOCK(port);
 754         VTCON_UNLOCK(sc);
 755         vtcon_port_teardown(port);
 756 }
 757
 758 static void
 759 vtcon_ctrl_port_console_event(struct vtcon_softc *sc, int id)
 760 {
 761         device_t dev;
 762         struct vtcon_softc_port *scport;
 763         struct vtcon_port *port;
 764
 765         dev = sc->vtcon_dev;
 766         scport = &sc->vtcon_ports[id];
 767
 768         VTCON_LOCK(sc);
 769         port = scport->vcsp_port;
 770         if (port == NULL) {
 771                 VTCON_UNLOCK(sc);
 772                 device_printf(dev, "%s: console port %d, but does not exist\n",
 773                     __func__, id);
 774                 return;
 775         }
 776
 777         VTCON_PORT_LOCK(port);
 778         VTCON_UNLOCK(sc);
 779         port->vtcport_flags |= VTCON_PORT_FLAG_CONSOLE;
 780         vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
 781         VTCON_PORT_UNLOCK(port);
 782 }
 783
 784 static void
 785 vtcon_ctrl_port_open_event(struct vtcon_softc *sc, int id)
 786 {
 787         device_t dev;
 788         struct vtcon_softc_port *scport;
 789         struct vtcon_port *port;
 790
 791         dev = sc->vtcon_dev;
 792         scport = &sc->vtcon_ports[id];
 793
 794         VTCON_LOCK(sc);
 795         port = scport->vcsp_port;
 796         if (port == NULL) {
 797                 VTCON_UNLOCK(sc);
 798                 device_printf(dev, "%s: open port %d, but does not exist\n",
 799                     __func__, id);
 800                 return;
 801         }
 802
 803         VTCON_PORT_LOCK(port);
 804         VTCON_UNLOCK(sc);
 805         vtcon_port_enable_intr(port);
 806         VTCON_PORT_UNLOCK(port);
 807 }
 808
 809 static void
 810 vtcon_ctrl_port_name_event(struct vtcon_softc *sc, int id, const char *name,
 811     size_t len)
 812 {
 813         device_t dev;
 814         struct vtcon_softc_port *scport;
 815         struct vtcon_port *port;
 816
 817         dev = sc->vtcon_dev;
 818         scport = &sc->vtcon_ports[id];
 819
 820         /*
 821          * The VirtIO specification says the NUL terminator is not included in
 822          * the length, but QEMU includes it. Adjust the length if needed.
 823          */
 824         if (name == NULL || len == 0)
 825                 return;
 826         if (name[len - 1] == '\0') {
 827                 len--;
 828                 if (len == 0)
 829                         return;
 830         }
 831
 832         VTCON_LOCK(sc);
 833         port = scport->vcsp_port;
 834         if (port == NULL) {
 835                 VTCON_UNLOCK(sc);
 836                 device_printf(dev, "%s: name port %d, but does not exist\n",
 837                     __func__, id);
 838                 return;
 839         }
 840
 841         VTCON_PORT_LOCK(port);
 842         VTCON_UNLOCK(sc);
 843         vtcon_port_dev_alias(port, name, len);
 844         VTCON_PORT_UNLOCK(port);
 845 }
 846
 847 static void
 848 vtcon_ctrl_process_event(struct vtcon_softc *sc,
 849     struct virtio_console_control *control, void *data, size_t data_len)
 850 {
 851         device_t dev;
 852         int id;
 853
 854         dev = sc->vtcon_dev;
 855         id = control->id;
 856
 857         if (id < 0 || id >= sc->vtcon_max_ports) {
 858                 device_printf(dev, "%s: invalid port ID %d\n", __func__, id);
 859                 return;
 860         }
 861
 862         switch (control->event) {
 863         case VIRTIO_CONSOLE_PORT_ADD:
 864                 vtcon_ctrl_port_add_event(sc, id);
 865                 break;
 866
 867         case VIRTIO_CONSOLE_PORT_REMOVE:
 868                 vtcon_ctrl_port_remove_event(sc, id);
 869                 break;
 870
 871         case VIRTIO_CONSOLE_CONSOLE_PORT:
 872                 vtcon_ctrl_port_console_event(sc, id);
 873                 break;
 874
 875         case VIRTIO_CONSOLE_RESIZE:
 876                 break;
 877
 878         case VIRTIO_CONSOLE_PORT_OPEN:
 879                 vtcon_ctrl_port_open_event(sc, id);
 880                 break;
 881
 882         case VIRTIO_CONSOLE_PORT_NAME:
 883                 vtcon_ctrl_port_name_event(sc, id, (const char *)data, data_len);
 884                 break;
 885         }
 886 }
 887
 888 static void
 889 vtcon_ctrl_task_cb(void *xsc, int pending)
 890 {
 891         struct vtcon_softc *sc;
 892         struct virtqueue *vq;
 893         struct virtio_console_control *control;
 894         void *data;
 895         size_t data_len;
 896         int detached;
 897         uint32_t len;
 898
 899         sc = xsc;
 900         vq = sc->vtcon_ctrl_rxvq;
 901
 902         VTCON_LOCK(sc);
 903
 904         while ((detached = (sc->vtcon_flags & VTCON_FLAG_DETACHED)) == 0) {
 905                 control = virtqueue_dequeue(vq, &len);
 906                 if (control == NULL)
 907                         break;
 908
 909                 if (len > sizeof(struct virtio_console_control)) {
 910                         data = (void *) &control[1];
 911                         data_len = len - sizeof(struct virtio_console_control);
 912                 } else {
 913                         data = NULL;
 914                         data_len = 0;
 915                 }
 916
 917                 VTCON_UNLOCK(sc);
 918                 vtcon_ctrl_process_event(sc, control, data, data_len);
 919                 VTCON_LOCK(sc);
 920                 vtcon_ctrl_event_requeue(sc, control);
 921         }
 922
 923         if (!detached) {
 924                 virtqueue_notify(vq);
 925                 if (virtqueue_enable_intr(vq) != 0)
 926                         taskqueue_enqueue(taskqueue_thread,
 927                             &sc->vtcon_ctrl_task);
 928         }
 929
 930         VTCON_UNLOCK(sc);
 931 }
 932
 933 static void
 934 vtcon_ctrl_event_intr(void *xsc)
 935 {
 936         struct vtcon_softc *sc;
 937
 938         sc = xsc;
 939
 940         /*
 941          * Only some events require us to potentially block, but it
 942          * easier to just defer all event handling to the taskqueue.
 943          */
 944         taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task);
 945 }
 946
 947 static void
 948 vtcon_ctrl_poll(struct vtcon_softc *sc,
 949     struct virtio_console_control *control)
 950 {
 951         struct sglist_seg segs[2];
 952         struct sglist sg;
 953         struct virtqueue *vq;
 954         int error;
 955
 956         vq = sc->vtcon_ctrl_txvq;
 957
 958         sglist_init(&sg, 2, segs);
 959         error = sglist_append(&sg, control,
 960             sizeof(struct virtio_console_control));
 961         KASSERT(error == 0, ("%s: error %d adding control to sglist",
 962             __func__, error));
 963
 964         /*
 965          * We cannot use the softc lock to serialize access to this
 966          * virtqueue since this is called from the tty layer with the
 967          * port lock held. Acquiring the softc would violate our lock
 968          * ordering.
 969          */
 970         VTCON_CTRL_TX_LOCK(sc);
 971         KASSERT(virtqueue_empty(vq),
 972             ("%s: virtqueue is not emtpy", __func__));
 973         error = virtqueue_enqueue(vq, control, &sg, sg.sg_nseg, 0);
 974         if (error == 0) {
 975                 virtqueue_notify(vq);
 976                 virtqueue_poll(vq, NULL);
 977         }
 978         VTCON_CTRL_TX_UNLOCK(sc);
 979 }
 980
 981 static void
 982 vtcon_ctrl_send_control(struct vtcon_softc *sc, uint32_t portid,
 983     uint16_t event, uint16_t value)
 984 {
 985         struct virtio_console_control control;
 986
 987         if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0)
 988                 return;
 989
 990         control.id = portid;
 991         control.event = event;
 992         control.value = value;
 993
 994         vtcon_ctrl_poll(sc, &control);
 995 }
 996
 997 static int
 998 vtcon_port_enqueue_buf(struct vtcon_port *port, void *buf, size_t len)
 999 {
1000         struct sglist_seg segs[2];
1001         struct sglist sg;
1002         struct virtqueue *vq;
1003         int error;
1004
1005         vq = port->vtcport_invq;
1006
1007         sglist_init(&sg, 2, segs);
1008         error = sglist_append(&sg, buf, len);
1009         KASSERT(error == 0,
1010             ("%s: error %d adding buffer to sglist", __func__, error));
1011
1012         error = virtqueue_enqueue(vq, buf, &sg, 0, sg.sg_nseg);
1013
1014         return (error);
1015 }
1016
1017 static int
1018 vtcon_port_create_buf(struct vtcon_port *port)
1019 {
1020         void *buf;
1021         int error;
1022
1023         buf = malloc(VTCON_BULK_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
1024         if (buf == NULL)
1025                 return (ENOMEM);
1026
1027         error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1028         if (error)
1029                 free(buf, M_DEVBUF);
1030
1031         return (error);
1032 }
1033
1034 static void
1035 vtcon_port_requeue_buf(struct vtcon_port *port, void *buf)
1036 {
1037         int error;
1038
1039         error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1040         KASSERT(error == 0,
1041             ("%s: cannot requeue input buffer %d", __func__, error));
1042 }
1043
1044 static int
1045 vtcon_port_populate(struct vtcon_port *port)
1046 {
1047         struct virtqueue *vq;
1048         int nbufs, error;
1049
1050         vq = port->vtcport_invq;
1051         error = ENOSPC;
1052
1053         for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
1054                 error = vtcon_port_create_buf(port);
1055                 if (error)
1056                         break;
1057         }
1058
1059         if (nbufs > 0) {
1060                 virtqueue_notify(vq);
1061                 error = 0;
1062         }
1063
1064         return (error);
1065 }
1066
1067 static void
1068 vtcon_port_destroy(struct vtcon_port *port)
1069 {
1070
1071         port->vtcport_sc = NULL;
1072         port->vtcport_scport = NULL;
1073         port->vtcport_invq = NULL;
1074         port->vtcport_outvq = NULL;
1075         port->vtcport_id = -1;
1076         mtx_destroy(&port->vtcport_mtx);
1077         free(port, M_DEVBUF);
1078 }
1079
1080 static int
1081 vtcon_port_init_vqs(struct vtcon_port *port)
1082 {
1083         struct vtcon_softc_port *scport;
1084         int error;
1085
1086         scport = port->vtcport_scport;
1087
1088         port->vtcport_invq = scport->vcsp_invq;
1089         port->vtcport_outvq = scport->vcsp_outvq;
1090
1091         /*
1092          * Free any data left over from when this virtqueue was in use by a
1093          * prior port. We have not yet notified the host that the port is
1094          * ready, so assume nothing in the virtqueue can be for us.
1095          */
1096         vtcon_port_drain(port);
1097
1098         KASSERT(virtqueue_empty(port->vtcport_invq),
1099             ("%s: in virtqueue is not empty", __func__));
1100         KASSERT(virtqueue_empty(port->vtcport_outvq),
1101             ("%s: out virtqueue is not empty", __func__));
1102
1103         error = vtcon_port_populate(port);
1104         if (error)
1105                 return (error);
1106
1107         return (0);
1108 }
1109
1110 static int
1111 vtcon_port_create(struct vtcon_softc *sc, int id)
1112 {
1113         device_t dev;
1114         struct vtcon_softc_port *scport;
1115         struct vtcon_port *port;
1116         int error;
1117
1118         dev = sc->vtcon_dev;
1119         scport = &sc->vtcon_ports[id];
1120
1121         VTCON_ASSERT_VALID_PORTID(sc, id);
1122         MPASS(scport->vcsp_port == NULL);
1123
1124         port = malloc(sizeof(struct vtcon_port), M_DEVBUF, M_NOWAIT | M_ZERO);
1125         if (port == NULL)
1126                 return (ENOMEM);
1127
1128         port->vtcport_sc = sc;
1129         port->vtcport_scport = scport;
1130         port->vtcport_id = id;
1131         mtx_init(&port->vtcport_mtx, "vtcpmtx", NULL, MTX_DEF);
1132         port->vtcport_tty = tty_alloc_mutex(&vtcon_tty_class, port,
1133             &port->vtcport_mtx);
1134
1135         error = vtcon_port_init_vqs(port);
1136         if (error) {
1137                 VTCON_PORT_LOCK(port);
1138                 vtcon_port_teardown(port);
1139                 return (error);
1140         }
1141
1142         VTCON_LOCK(sc);
1143         VTCON_PORT_LOCK(port);
1144         scport->vcsp_port = port;
1145         vtcon_port_enable_intr(port);
1146         vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_READY, 1);
1147         VTCON_PORT_UNLOCK(port);
1148         VTCON_UNLOCK(sc);
1149
1150         tty_makedev(port->vtcport_tty, NULL, "%s%r.%r", VTCON_TTY_PREFIX,
1151             device_get_unit(dev), id);
1152
1153         return (0);
1154 }
1155
1156 static void
1157 vtcon_port_dev_alias(struct vtcon_port *port, const char *name, size_t len)
1158 {
1159         struct vtcon_softc *sc;
1160         struct cdev *pdev;
1161         struct tty *tp;
1162         int i, error;
1163
1164         sc = port->vtcport_sc;
1165         tp = port->vtcport_tty;
1166
1167         if (port->vtcport_flags & VTCON_PORT_FLAG_ALIAS)
1168                 return;
1169
1170         /* Port name is UTF-8, but we can only handle ASCII. */
1171         for (i = 0; i < len; i++) {
1172                 if (!isascii(name[i]))
1173                         return;
1174         }
1175
1176         /*
1177          * Port name may not conform to the devfs requirements so we cannot use
1178          * tty_makealias() because the MAKEDEV_CHECKNAME flag must be specified.
1179          */
1180         error = make_dev_alias_p(MAKEDEV_NOWAIT | MAKEDEV_CHECKNAME, &pdev,
1181             tp->t_dev, "%s/%*s", VTCON_TTY_ALIAS_PREFIX, (int)len, name);
1182         if (error) {
1183                 device_printf(sc->vtcon_dev,
1184                     "%s: cannot make dev alias (%s/%*s) error %d\n", __func__,
1185                     VTCON_TTY_ALIAS_PREFIX, (int)len, name, error);
1186         } else
1187                 port->vtcport_flags |= VTCON_PORT_FLAG_ALIAS;
1188 }
1189
1190 static void
1191 vtcon_port_drain_bufs(struct virtqueue *vq)
1192 {
1193         void *buf;
1194         int last;
1195
1196         last = 0;
1197
1198         while ((buf = virtqueue_drain(vq, &last)) != NULL)
1199                 free(buf, M_DEVBUF);
1200 }
1201
1202 static void
1203 vtcon_port_drain(struct vtcon_port *port)
1204 {
1205
1206         vtcon_port_drain_bufs(port->vtcport_invq);
1207 }
1208
1209 static void
1210 vtcon_port_teardown(struct vtcon_port *port)
1211 {
1212         struct tty *tp;
1213
1214         tp = port->vtcport_tty;
1215
1216         port->vtcport_flags |= VTCON_PORT_FLAG_GONE;
1217
1218         if (tp != NULL) {
1219                 atomic_add_int(&vtcon_pending_free, 1);
1220                 tty_rel_gone(tp);
1221         } else
1222                 vtcon_port_destroy(port);
1223 }
1224
1225 static void
1226 vtcon_port_change_size(struct vtcon_port *port, uint16_t cols, uint16_t rows)
1227 {
1228         struct tty *tp;
1229         struct winsize sz;
1230
1231         tp = port->vtcport_tty;
1232
1233         if (tp == NULL)
1234                 return;
1235
1236         bzero(&sz, sizeof(struct winsize));
1237         sz.ws_col = cols;
1238         sz.ws_row = rows;
1239
1240         tty_set_winsize(tp, &sz);
1241 }
1242
1243 static void
1244 vtcon_port_update_console_size(struct vtcon_softc *sc)
1245 {
1246         struct vtcon_port *port;
1247         struct vtcon_softc_port *scport;
1248         uint16_t cols, rows;
1249
1250         vtcon_get_console_size(sc, &cols, &rows);
1251
1252         /*
1253          * For now, assume the first (only) port is the console. Note
1254          * QEMU does not implement this feature yet.
1255          */
1256         scport = &sc->vtcon_ports[0];
1257
1258         VTCON_LOCK(sc);
1259         port = scport->vcsp_port;
1260
1261         if (port != NULL) {
1262                 VTCON_PORT_LOCK(port);
1263                 VTCON_UNLOCK(sc);
1264                 vtcon_port_change_size(port, cols, rows);
1265                 VTCON_PORT_UNLOCK(port);
1266         } else
1267                 VTCON_UNLOCK(sc);
1268 }
1269
1270 static void
1271 vtcon_port_enable_intr(struct vtcon_port *port)
1272 {
1273
1274         /*
1275          * NOTE: The out virtqueue is always polled, so its interrupt
1276          * kept disabled.
1277          */
1278         virtqueue_enable_intr(port->vtcport_invq);
1279 }
1280
1281 static void
1282 vtcon_port_disable_intr(struct vtcon_port *port)
1283 {
1284
1285         if (port->vtcport_invq != NULL)
1286                 virtqueue_disable_intr(port->vtcport_invq);
1287         if (port->vtcport_outvq != NULL)
1288                 virtqueue_disable_intr(port->vtcport_outvq);
1289 }
1290
1291 static void
1292 vtcon_port_in(struct vtcon_port *port)
1293 {
1294         struct virtqueue *vq;
1295         struct tty *tp;
1296         char *buf;
1297         uint32_t len;
1298         int i, deq;
1299
1300         tp = port->vtcport_tty;
1301         vq = port->vtcport_invq;
1302
1303 again:
1304         deq = 0;
1305
1306         while ((buf = virtqueue_dequeue(vq, &len)) != NULL) {
1307                 for (i = 0; i < len; i++) {
1308 #if defined(KDB)
1309                         if (port->vtcport_flags & VTCON_PORT_FLAG_CONSOLE)
1310                                 kdb_alt_break(buf[i],
1311                                     &port->vtcport_alt_break_state);
1312 #endif
1313                         ttydisc_rint(tp, buf[i], 0);
1314                 }
1315                 vtcon_port_requeue_buf(port, buf);
1316                 deq++;
1317         }
1318         ttydisc_rint_done(tp);
1319
1320         if (deq > 0)
1321                 virtqueue_notify(vq);
1322
1323         if (virtqueue_enable_intr(vq) != 0)
1324                 goto again;
1325 }
1326
1327 static void
1328 vtcon_port_intr(void *scportx)
1329 {
1330         struct vtcon_softc_port *scport;
1331         struct vtcon_softc *sc;
1332         struct vtcon_port *port;
1333
1334         scport = scportx;
1335         sc = scport->vcsp_sc;
1336
1337         VTCON_LOCK(sc);
1338         port = scport->vcsp_port;
1339         if (port == NULL) {
1340                 VTCON_UNLOCK(sc);
1341                 return;
1342         }
1343         VTCON_PORT_LOCK(port);
1344         VTCON_UNLOCK(sc);
1345         if ((port->vtcport_flags & VTCON_PORT_FLAG_GONE) == 0)
1346                 vtcon_port_in(port);
1347         VTCON_PORT_UNLOCK(port);
1348 }
1349
1350 static void
1351 vtcon_port_out(struct vtcon_port *port, void *buf, int bufsize)
1352 {
1353         struct sglist_seg segs[2];
1354         struct sglist sg;
1355         struct virtqueue *vq;
1356         int error;
1357
1358         vq = port->vtcport_outvq;
1359         KASSERT(virtqueue_empty(vq),
1360             ("%s: port %p out virtqueue not emtpy", __func__, port));
1361
1362         sglist_init(&sg, 2, segs);
1363         error = sglist_append(&sg, buf, bufsize);
1364         KASSERT(error == 0, ("%s: error %d adding buffer to sglist",
1365             __func__, error));
1366
1367         error = virtqueue_enqueue(vq, buf, &sg, sg.sg_nseg, 0);
1368         if (error == 0) {
1369                 virtqueue_notify(vq);
1370                 virtqueue_poll(vq, NULL);
1371         }
1372 }
1373
1374 static void
1375 vtcon_port_submit_event(struct vtcon_port *port, uint16_t event,
1376     uint16_t value)
1377 {
1378         struct vtcon_softc *sc;
1379
1380         sc = port->vtcport_sc;
1381
1382         vtcon_ctrl_send_control(sc, port->vtcport_id, event, value);
1383 }
1384
1385 static int
1386 vtcon_tty_open(struct tty *tp)
1387 {
1388         struct vtcon_port *port;
1389
1390         port = tty_softc(tp);
1391
1392         if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1393                 return (ENXIO);
1394
1395         vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1396
1397         return (0);
1398 }
1399
1400 static void
1401 vtcon_tty_close(struct tty *tp)
1402 {
1403         struct vtcon_port *port;
1404
1405         port = tty_softc(tp);
1406
1407         if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1408                 return;
1409
1410         vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1411 }
1412
1413 static void
1414 vtcon_tty_outwakeup(struct tty *tp)
1415 {
1416         struct vtcon_port *port;
1417         char buf[VTCON_BULK_BUFSZ];
1418         int len;
1419
1420         port = tty_softc(tp);
1421
1422         if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1423                 return;
1424
1425         while ((len = ttydisc_getc(tp, buf, sizeof(buf))) != 0)
1426                 vtcon_port_out(port, buf, len);
1427 }
1428
1429 static void
1430 vtcon_tty_free(void *xport)
1431 {
1432         struct vtcon_port *port;
1433
1434         port = xport;
1435
1436         vtcon_port_destroy(port);
1437         atomic_subtract_int(&vtcon_pending_free, 1);
1438 }
1439
1440 static void
1441 vtcon_get_console_size(struct vtcon_softc *sc, uint16_t *cols, uint16_t *rows)
1442 {
1443         struct virtio_console_config concfg;
1444
1445         KASSERT(sc->vtcon_flags & VTCON_FLAG_SIZE,
1446             ("%s: size feature not negotiated", __func__));
1447
1448         vtcon_read_config(sc, &concfg);
1449
1450         *cols = concfg.cols;
1451         *rows = concfg.rows;
1452 }
1453
1454 static void
1455 vtcon_enable_interrupts(struct vtcon_softc *sc)
1456 {
1457         struct vtcon_softc_port *scport;
1458         struct vtcon_port *port;
1459         int i;
1460
1461         VTCON_LOCK(sc);
1462
1463         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1464                 virtqueue_enable_intr(sc->vtcon_ctrl_rxvq);
1465
1466         for (i = 0; i < sc->vtcon_max_ports; i++) {
1467                 scport = &sc->vtcon_ports[i];
1468
1469                 port = scport->vcsp_port;
1470                 if (port == NULL)
1471                         continue;
1472
1473                 VTCON_PORT_LOCK(port);
1474                 vtcon_port_enable_intr(port);
1475                 VTCON_PORT_UNLOCK(port);
1476         }
1477
1478         VTCON_UNLOCK(sc);
1479 }
1480
1481 static void
1482 vtcon_disable_interrupts(struct vtcon_softc *sc)
1483 {
1484         struct vtcon_softc_port *scport;
1485         struct vtcon_port *port;
1486         int i;
1487
1488         VTCON_LOCK_ASSERT(sc);
1489
1490         if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1491                 virtqueue_disable_intr(sc->vtcon_ctrl_rxvq);
1492
1493         for (i = 0; i < sc->vtcon_max_ports; i++) {
1494                 scport = &sc->vtcon_ports[i];
1495
1496                 port = scport->vcsp_port;
1497                 if (port == NULL)
1498                         continue;
1499
1500                 VTCON_PORT_LOCK(port);
1501                 vtcon_port_disable_intr(port);
1502                 VTCON_PORT_UNLOCK(port);
1503         }
1504 }