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