Home | History | Annotate | Line # | Download | only in goldfish 
      1 /*	$NetBSD: gftty.c,v 1.3 2024/01/06 17:52:43 thorpej Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2023, 2024 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jason R. Thorpe.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Support for the Goldfish virtual TTY.
     34  */
     35 
     36 #include <sys/cdefs.h>
     37 __KERNEL_RCSID(0, "$NetBSD: gftty.c,v 1.3 2024/01/06 17:52:43 thorpej Exp $");
     38 
     39 #include <sys/param.h>
     40 #include <sys/conf.h>
     41 #include <sys/fcntl.h>
     42 #include <sys/systm.h>
     43 #include <sys/bus.h>
     44 #include <sys/device.h>
     45 #include <sys/kauth.h>
     46 #include <sys/kmem.h>
     47 #include <sys/tty.h>
     48 
     49 #include <uvm/uvm_extern.h>
     50 
     51 #include <dev/cons.h>
     52 
     53 #include <dev/goldfish/gfttyvar.h>
     54 
     55 #include "ioconf.h"
     56 
     57 /*
     58  * Goldfish TTY registers.
     59  */
     60 #define	GFTTY_PUT_CHAR		0x00	/* 8 bit output value */
     61 #define	GFTTY_BYTES_READY	0x04	/* number of input bytes available */
     62 #define	GFTTY_CMD		0x08	/* command */
     63 #define	GFTTY_DATA_PTR		0x10	/* DMA pointer */
     64 #define	GFTTY_DATA_LEN		0x14	/* DMA length */
     65 #define	GFTTY_DATA_PTR_HIGH	0x18	/* DMA pointer (64-bit) */
     66 #define	GFTTY_VERSION		0x20	/* TTY version */
     67 
     68 #define	CMD_INT_DISABLE		0x00
     69 #define	CMD_INT_ENABLE		0x01
     70 #define	CMD_WRITE_BUFFER	0x02
     71 #define	CMD_READ_BUFFER		0x03
     72 
     73 #define	REG_READ0(c, r)		\
     74 	bus_space_read_4((c)->c_bst, (c)->c_bsh, (r))
     75 #define	REG_WRITE0(c, r, v)	\
     76 	bus_space_write_4((c)->c_bst, (c)->c_bsh, (r), (v))
     77 
     78 #define	REG_READ(sc, r)		REG_READ0((sc)->sc_config, (r))
     79 #define	REG_WRITE(sc, r, v)	REG_WRITE0((sc)->sc_config, (r), (v))
     80 
     81 static int	gftty_cngetc(dev_t);
     82 static void	gftty_cnputc(dev_t, int);
     83 static void	gftty_cnpollc(dev_t, int);
     84 
     85 static struct gftty_config gftty_cnconfig;
     86 static struct cnm_state gftty_cnmagic_state;
     87 static struct consdev gftty_consdev = {
     88 	.cn_getc  = gftty_cngetc,
     89 	.cn_putc  = gftty_cnputc,
     90 	.cn_pollc = gftty_cnpollc,
     91 	.cn_dev   = NODEV,
     92 	.cn_pri   = CN_NORMAL,
     93 };
     94 
     95 static dev_type_open(gftty_open);
     96 static dev_type_close(gftty_close);
     97 static dev_type_read(gftty_read);
     98 static dev_type_write(gftty_write);
     99 static dev_type_ioctl(gftty_ioctl);
    100 static dev_type_stop(gftty_stop);
    101 static dev_type_tty(gftty_tty);
    102 static dev_type_poll(gftty_poll);
    103 
    104 const struct cdevsw gftty_cdevsw = {
    105 	.d_open     = gftty_open,
    106 	.d_close    = gftty_close,
    107 	.d_read     = gftty_read,
    108 	.d_write    = gftty_write,
    109 	.d_ioctl    = gftty_ioctl,
    110 	.d_stop     = gftty_stop,
    111 	.d_tty      = gftty_tty,
    112 	.d_poll     = gftty_poll,
    113 	.d_mmap     = nommap,
    114 	.d_kqfilter = ttykqfilter,
    115 	.d_discard  = nodiscard,
    116 	.d_flag     = D_TTY,
    117 };
    118 
    119 static void	gftty_start(struct tty *);
    120 static int	gftty_param_locked(struct tty *, struct termios *);
    121 static int	gftty_param(struct tty *, struct termios *);
    122 
    123 static void	gftty_softrx(void *);
    124 
    125 #define	GFTTY_UNIT(x)		minor(x)
    126 #define	GFTTY_DMASIZE		(64 * 1024)	/* XXX TTY_MAXQSIZE */
    127 #define	GFTTY_MAXSEGS		((GFTTY_DMASIZE / PAGE_SIZE) + 1)
    128 #define	GFTTY_RXBUFSIZE		128
    129 #define	GFTTY_RXBUFALLOC	(128 << 1)
    130 
    131 static void
    132 gftty_reset_rxptrs(struct gftty_softc *sc)
    133 {
    134 	sc->sc_rxpos = 0;
    135 	sc->sc_rxcur = 0;
    136 	sc->sc_rxbuf = sc->sc_rxbufs[sc->sc_rxcur];
    137 	sc->sc_rxaddr = sc->sc_rxaddrs[sc->sc_rxcur];
    138 }
    139 
    140 /*
    141  * gftty_attach --
    142  *	Attach a Goldfish virual TTY.
    143  */
    144 void
    145 gftty_attach(struct gftty_softc *sc)
    146 {
    147 	device_t self = sc->sc_dev;
    148 	int error;
    149 	bool is_console;
    150 
    151 	aprint_naive("\n");
    152 	aprint_normal(": Google Goldfish TTY\n");
    153 
    154 	/* If we got here without a config, we're the console. */
    155 	if ((is_console = (sc->sc_config == NULL))) {
    156 		KASSERT(gftty_is_console(sc));
    157 		sc->sc_config = &gftty_cnconfig;
    158 		aprint_normal_dev(sc->sc_dev, "console\n");
    159 	}
    160 
    161 	if (sc->sc_config->c_version == 0) {
    162 		aprint_normal_dev(self,
    163 		    "WARNING: version 0 device -- uncharted territory!\n");
    164 	}
    165 
    166 	/* Register our Rx soft interrupt. */
    167 	sc->sc_rx_si = softint_establish(SOFTINT_SERIAL, gftty_softrx, sc);
    168 	if (sc->sc_rx_si == NULL) {
    169 		aprint_error_dev(self,
    170 		    "Unable to register software interrupt.\n");
    171 		return;
    172 	}
    173 
    174 	error = bus_dmamap_create(sc->sc_dmat, GFTTY_DMASIZE,
    175 	    GFTTY_MAXSEGS, GFTTY_DMASIZE, 0, BUS_DMA_WAITOK,
    176 	    &sc->sc_tx_dma);
    177 	if (error != 0) {
    178 		aprint_error_dev(self,
    179 		    "unable to create Tx DMA map, error %d.\n", error);
    180 		return;
    181 	}
    182 	error = bus_dmamap_create(sc->sc_dmat, GFTTY_RXBUFALLOC,
    183 	    1, GFTTY_RXBUFALLOC, 0, BUS_DMA_WAITOK,
    184 	    &sc->sc_rx_dma);
    185 	if (error != 0) {
    186 		aprint_error_dev(self,
    187 		    "unable to create Rx DMA map, error %d.\n", error);
    188 		bus_dmamap_destroy(sc->sc_dmat, sc->sc_tx_dma);
    189 		sc->sc_tx_dma = NULL;
    190 		return;
    191 	}
    192 
    193 	sc->sc_rxbuf = kmem_zalloc(GFTTY_RXBUFALLOC, KM_SLEEP);
    194 	error = bus_dmamap_load(sc->sc_dmat, sc->sc_rx_dma,
    195 	    sc->sc_rxbuf, GFTTY_RXBUFALLOC, NULL, BUS_DMA_WAITOK);
    196 	if (error != 0) {
    197 		aprint_error_dev(self,
    198 		    "unable to load Rx DMA map, error %d.\n", error);
    199 		kmem_free(sc->sc_rxbuf, GFTTY_RXBUFALLOC);
    200 		bus_dmamap_destroy(sc->sc_dmat, sc->sc_rx_dma);
    201 		sc->sc_rx_dma = NULL;
    202 		bus_dmamap_destroy(sc->sc_dmat, sc->sc_tx_dma);
    203 		sc->sc_tx_dma = NULL;
    204 		return;
    205 	}
    206 	sc->sc_rxbufs[0] = sc->sc_rxbuf;
    207 	sc->sc_rxbufs[1] = sc->sc_rxbufs[0] + GFTTY_RXBUFSIZE;
    208 	if (sc->sc_config->c_version == 0) {
    209 		sc->sc_rxaddrs[0] = (bus_addr_t)sc->sc_rxbufs[0];
    210 	} else {
    211 		sc->sc_rxaddrs[0] = sc->sc_rx_dma->dm_segs[0].ds_addr;
    212 	}
    213 	sc->sc_rxaddrs[1] = sc->sc_rxaddrs[0] + GFTTY_RXBUFSIZE;
    214 	gftty_reset_rxptrs(sc);
    215 
    216 	struct tty *tp = tty_alloc();
    217 	tp->t_oproc = gftty_start;
    218 	tp->t_param = gftty_param;
    219 	tp->t_softc = sc;
    220 
    221 	mutex_init(&sc->sc_hwlock, MUTEX_DEFAULT, IPL_TTY);
    222 
    223 	if (is_console) {
    224 		/* Locate the major number. */
    225 		int maj = cdevsw_lookup_major(&gftty_cdevsw);
    226 		tp->t_dev = cn_tab->cn_dev = makedev(maj, device_unit(self));
    227 	}
    228 
    229 	mutex_spin_enter(&tty_lock);
    230 	sc->sc_tty = tp;
    231 	mutex_spin_exit(&tty_lock);
    232 
    233 	tty_attach(tp);
    234 }
    235 
    236 /*
    237  * gftty_is_console --
    238  *	Returns true if the specified gftty instance is currently
    239  *	the console.
    240  */
    241 bool
    242 gftty_is_console(struct gftty_softc *sc)
    243 {
    244 	if (cn_tab == &gftty_consdev) {
    245 		bool val;
    246 
    247 		if (prop_dictionary_get_bool(device_properties(sc->sc_dev),
    248 					     "is-console", &val)) {
    249 			return val;
    250 		}
    251 	}
    252 	return false;
    253 }
    254 
    255 /*
    256  * gftty_init_config --
    257  *	Initialize a config structure.
    258  */
    259 static void
    260 gftty_init_config(struct gftty_config *c, bus_space_tag_t bst,
    261     bus_space_handle_t bsh)
    262 {
    263 	c->c_bst = bst;
    264 	c->c_bsh = bsh;
    265 	c->c_version = REG_READ0(c, GFTTY_VERSION);
    266 }
    267 
    268 /*
    269  * gftty_alloc_config --
    270  *	Allocate a config structure, initialize it, and assign
    271  *	it to this device.
    272  */
    273 void
    274 gftty_alloc_config(struct gftty_softc *sc, bus_space_tag_t bst,
    275     bus_space_handle_t bsh)
    276 {
    277 	struct gftty_config *c = kmem_zalloc(sizeof(*c), KM_SLEEP);
    278 
    279 	gftty_init_config(c, bst, bsh);
    280 	sc->sc_config = c;
    281 }
    282 
    283 /*
    284  * gftty_set_buffer --
    285  *	Set the buffer address / length for an I/O operation.
    286  */
    287 static void
    288 gftty_set_buffer(struct gftty_config *c, bus_addr_t addr, bus_size_t size)
    289 {
    290 	REG_WRITE0(c, GFTTY_DATA_PTR, BUS_ADDR_LO32(addr));
    291 	if (sizeof(bus_addr_t) == 8) {
    292 		REG_WRITE0(c, GFTTY_DATA_PTR_HIGH, BUS_ADDR_HI32(addr));
    293 	}
    294 	REG_WRITE0(c, GFTTY_DATA_LEN, (uint32_t)size);
    295 }
    296 
    297 /*
    298  * gftty_flush --
    299  *	Flush input bytes.
    300  */
    301 static bool
    302 gftty_flush(struct gftty_softc *sc)
    303 {
    304 	uint32_t count;
    305 	bool claimed = false;
    306 
    307 	KASSERT(ttylocked(sc->sc_tty));
    308 
    309 	mutex_spin_enter(&sc->sc_hwlock);
    310 
    311 	while ((count = REG_READ(sc, GFTTY_BYTES_READY)) != 0) {
    312 		claimed = true;
    313 		if (count > GFTTY_RXBUFALLOC) {
    314 			count = GFTTY_RXBUFALLOC;
    315 		}
    316 		gftty_set_buffer(sc->sc_config,
    317 		    sc->sc_rx_dma->dm_segs[0].ds_addr, count);
    318 		REG_WRITE(sc, GFTTY_CMD, CMD_READ_BUFFER);
    319 	}
    320 
    321 	mutex_spin_exit(&sc->sc_hwlock);
    322 
    323 	gftty_reset_rxptrs(sc);
    324 
    325 	return claimed;
    326 }
    327 
    328 /*
    329  * gftty_rx --
    330  *	Receive from the virtual TTY.
    331  */
    332 static bool
    333 gftty_rx(struct gftty_softc *sc)
    334 {
    335 	uint32_t count, avail;
    336 	bool claimed = false;
    337 
    338 	KASSERT(ttylocked(sc->sc_tty));
    339 
    340 	mutex_spin_enter(&sc->sc_hwlock);
    341 
    342 	count = REG_READ(sc, GFTTY_BYTES_READY);
    343 	if (count != 0) {
    344 		claimed = true;
    345 		avail = GFTTY_RXBUFSIZE - sc->sc_rxpos;
    346 		if (count > avail) {
    347 			/*
    348 			 * Receive what we can, but disable the interrupt
    349 			 * until the buffer can be drained.
    350 			 */
    351 			REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
    352 			count = avail;
    353 		}
    354 		if (count != 0) {
    355 			bus_addr_t syncoff =
    356 			    (sc->sc_rxaddr - sc->sc_rxaddrs[0]) + sc->sc_rxpos;
    357 
    358 			bus_dmamap_sync(sc->sc_dmat, sc->sc_rx_dma,
    359 			    syncoff, count, BUS_DMASYNC_PREREAD);
    360 			gftty_set_buffer(sc->sc_config,
    361 			    sc->sc_rxaddr + sc->sc_rxpos, count);
    362 			REG_WRITE(sc, GFTTY_CMD, CMD_READ_BUFFER);
    363 			sc->sc_rxpos += count;
    364 			bus_dmamap_sync(sc->sc_dmat, sc->sc_rx_dma,
    365 			    syncoff, count, BUS_DMASYNC_POSTREAD);
    366 		}
    367 		softint_schedule(sc->sc_rx_si);
    368 	}
    369 
    370 	mutex_spin_exit(&sc->sc_hwlock);
    371 
    372 	return claimed;
    373 }
    374 
    375 /*
    376  * gftty_softrx --
    377  *	Software interrupt to comple Rx processing.
    378  */
    379 static void
    380 gftty_softrx(void *v)
    381 {
    382 	struct gftty_softc *sc = v;
    383 	struct tty *tp = sc->sc_tty;
    384 	int i, len;
    385 	char *cp;
    386 
    387 	ttylock(tp);
    388 	cp = sc->sc_rxbuf;
    389 	len = sc->sc_rxpos;
    390 	sc->sc_rxcur ^= 1;
    391 	sc->sc_rxbuf = sc->sc_rxbufs[sc->sc_rxcur];
    392 	sc->sc_rxaddr = sc->sc_rxaddrs[sc->sc_rxcur];
    393 	sc->sc_rxpos = 0;
    394 	if (ISSET(tp->t_state, TS_ISOPEN)) {
    395 		REG_WRITE(sc, GFTTY_CMD, CMD_INT_ENABLE);
    396 	}
    397 	ttyunlock(tp);
    398 
    399 	for (i = 0; i < len; i++) {
    400 		(*tp->t_linesw->l_rint)(*cp++, tp);
    401 	}
    402 }
    403 
    404 /*
    405  * gftty_intr --
    406  *	Interrupt service routine.
    407  */
    408 int
    409 gftty_intr(void *v)
    410 {
    411 	struct gftty_softc *sc = v;
    412 	struct tty *tp = sc->sc_tty;
    413 	bool claimed;
    414 
    415 	ttylock(tp);
    416 	if (ISSET(tp->t_state, TS_ISOPEN)) {
    417 		claimed = gftty_rx(sc);
    418 	} else {
    419 		claimed = gftty_flush(sc);
    420 	}
    421 	ttyunlock(tp);
    422 
    423 	return claimed;
    424 }
    425 
    426 /*
    427  * gftty_open --
    428  *	cdevsw open routine.
    429  */
    430 static int
    431 gftty_open(dev_t dev, int flag, int mode, struct lwp *l)
    432 {
    433 	struct gftty_softc *sc =
    434 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    435 	struct tty *tp;
    436 
    437 	if (sc == NULL) {
    438 		return ENXIO;
    439 	}
    440 
    441 	mutex_spin_enter(&tty_lock);
    442 	tp = sc->sc_tty;
    443 	mutex_spin_exit(&tty_lock);
    444 	if (tp == NULL) {
    445 		return ENXIO;
    446 	}
    447 
    448 	if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)) {
    449 		return EBUSY;
    450 	}
    451 
    452 	ttylock(tp);
    453 
    454 	if (ISSET(tp->t_state, TS_KERN_ONLY)) {
    455 		ttyunlock(tp);
    456 		return EBUSY;
    457 	}
    458 
    459 	tp->t_oproc = gftty_start;
    460 	tp->t_param = gftty_param;
    461 	tp->t_dev = dev;
    462 
    463 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    464 		struct termios t;
    465 
    466 		ttychars(tp);
    467 		tp->t_iflag = TTYDEF_IFLAG;
    468 		tp->t_oflag = TTYDEF_OFLAG;
    469 		tp->t_lflag = TTYDEF_LFLAG;
    470 		t.c_cflag = TTYDEF_CFLAG;
    471 		t.c_ispeed = t.c_ospeed = TTYDEF_SPEED;
    472 		(void) gftty_param_locked(tp, &t);
    473 		ttsetwater(tp);
    474 
    475 		gftty_flush(sc);
    476 		REG_WRITE(sc, GFTTY_CMD, CMD_INT_ENABLE);
    477 	}
    478 	SET(tp->t_state, TS_CARR_ON);
    479 
    480 	ttyunlock(tp);
    481 
    482 	int error = ttyopen(tp, 0, ISSET(flag, O_NONBLOCK));
    483 	if (error == 0) {
    484 		error = (*tp->t_linesw->l_open)(dev, tp);
    485 		if (error != 0) {
    486 			ttyclose(tp);
    487 		}
    488 	}
    489 
    490 	if (error != 0 &&
    491 	    !ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    492 		REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
    493 	}
    494 
    495 	return error;
    496 }
    497 
    498 /*
    499  * gftty_close --
    500  *	cdevsw close routine.
    501  */
    502 static int
    503 gftty_close(dev_t dev, int flag, int mode, struct lwp *l)
    504 {
    505 	struct gftty_softc *sc =
    506 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    507 
    508 	KASSERT(sc != NULL);
    509 
    510 	struct tty *tp = sc->sc_tty;
    511 
    512 	ttylock(tp);
    513 
    514 	/* XXX This is for cons.c. */
    515 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    516 		ttyunlock(tp);
    517 		return 0;
    518 	}
    519 
    520 	if (ISSET(tp->t_state, TS_KERN_ONLY)) {
    521 		ttyunlock(tp);
    522 		return 0;
    523 	}
    524 
    525 	ttyunlock(tp);
    526 
    527 	(*tp->t_linesw->l_close)(tp, flag);
    528 	ttyclose(tp);
    529 
    530 	ttylock(tp);
    531 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    532 		REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
    533 	}
    534 	ttyunlock(tp);
    535 
    536 	return 0;
    537 }
    538 
    539 /*
    540  * gftty_read --
    541  *	cdevsw read routine.
    542  */
    543 static int
    544 gftty_read(dev_t dev, struct uio *uio, int flag)
    545 {
    546 	struct gftty_softc *sc =
    547 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    548 
    549 	KASSERT(sc != NULL);
    550 
    551 	struct tty *tp = sc->sc_tty;
    552 	return (*tp->t_linesw->l_read)(tp, uio, flag);
    553 }
    554 
    555 /*
    556  * gftty_write --
    557  *	cdevsw write routine.
    558  */
    559 static int
    560 gftty_write(dev_t dev, struct uio *uio, int flag)
    561 {
    562 	struct gftty_softc *sc =
    563 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    564 
    565 	KASSERT(sc != NULL);
    566 
    567 	struct tty *tp = sc->sc_tty;
    568 	return (*tp->t_linesw->l_write)(tp, uio, flag);
    569 }
    570 
    571 /*
    572  * gftty_poll --
    573  *	cdevsw poll routine.
    574  */
    575 static int
    576 gftty_poll(dev_t dev, int events, struct lwp *l)
    577 {
    578 	struct gftty_softc *sc =
    579 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    580 
    581 	KASSERT(sc != NULL);
    582 
    583 	struct tty *tp = sc->sc_tty;
    584 	return (*tp->t_linesw->l_poll)(tp, events, l);
    585 }
    586 
    587 /*
    588  * gftty_tty --
    589  *	cdevsw tty routine.
    590  */
    591 static struct tty *
    592 gftty_tty(dev_t dev)
    593 {
    594 	struct gftty_softc *sc =
    595 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    596 
    597 	KASSERT(sc != NULL);
    598 
    599 	return sc->sc_tty;
    600 }
    601 
    602 /*
    603  * gftty_ioctl --
    604  *	cdevsw ioctl routine.
    605  */
    606 static int
    607 gftty_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
    608 {
    609 	struct gftty_softc *sc =
    610 	    device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
    611 
    612 	KASSERT(sc != NULL);
    613 
    614 	struct tty *tp = sc->sc_tty;
    615 	int error;
    616 
    617 	/* Do the line discipline ioctls first. */
    618 	error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
    619 	if (error != EPASSTHROUGH) {
    620 		return error;
    621 	}
    622 
    623 	/* Next, the TTY ioctls. */
    624 	error = ttioctl(tp, cmd, data, flag, l);
    625 	if (error != EPASSTHROUGH) {
    626 		return error;
    627 	}
    628 
    629 	/* None at this layer. */
    630 	return EPASSTHROUGH;
    631 }
    632 
    633 /*
    634  * gftty_tx --
    635  *	Transmit a buffer on the virtual TTY using DMA.
    636  */
    637 static void
    638 gftty_tx(struct gftty_softc *sc, void *buf, size_t len)
    639 {
    640 	int error, i;
    641 
    642 	KASSERT(len <= GFTTY_DMASIZE);
    643 
    644 	error = bus_dmamap_load(sc->sc_dmat, sc->sc_tx_dma, buf, len,
    645 	    NULL, BUS_DMA_NOWAIT);
    646 	if (error) {
    647 		/* XXX report error */
    648 		return;
    649 	}
    650 	bus_dmamap_sync(sc->sc_dmat, sc->sc_tx_dma, 0, len,
    651 	    BUS_DMASYNC_PREWRITE);
    652 
    653 	mutex_spin_enter(&sc->sc_hwlock);
    654 	for (i = 0; i < sc->sc_tx_dma->dm_nsegs; i++) {
    655 		gftty_set_buffer(sc->sc_config,
    656 		    sc->sc_tx_dma->dm_segs[i].ds_addr,
    657 		    sc->sc_tx_dma->dm_segs[i].ds_len);
    658 		REG_WRITE(sc, GFTTY_CMD, CMD_WRITE_BUFFER);
    659 	}
    660 	mutex_spin_exit(&sc->sc_hwlock);
    661 
    662 	bus_dmamap_sync(sc->sc_dmat, sc->sc_tx_dma, 0, len,
    663 	    BUS_DMASYNC_POSTWRITE);
    664 	bus_dmamap_unload(sc->sc_dmat, sc->sc_tx_dma);
    665 }
    666 
    667 /*
    668  * gftty_start --
    669  *	TTY oproc routine.
    670  */
    671 static void
    672 gftty_start(struct tty *tp)
    673 {
    674 	struct gftty_softc *sc = tp->t_softc;
    675 	u_char *tbuf;
    676 	int n;
    677 
    678 	KASSERT(ttylocked(tp));
    679 
    680 	if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP) ||
    681 	    ttypull(tp) == 0) {
    682 		return;
    683 	}
    684 	SET(tp->t_state, TS_BUSY);
    685 
    686 	/*
    687 	 * Drain the output from the ring buffer.  This will normally
    688 	 * be one contiguous chunk, but we have to do it in two pieces
    689 	 * when the ring wraps.
    690 	 */
    691 
    692 	n = ndqb(&tp->t_outq, 0);
    693 	tbuf = tp->t_outq.c_cf;
    694 	gftty_tx(sc, tbuf, n);
    695 	ndflush(&tp->t_outq, n);
    696 
    697 	if ((n = ndqb(&tp->t_outq, 0)) > 0) {
    698 		tbuf = tp->t_outq.c_cf;
    699 		gftty_tx(sc, tbuf, n);
    700 		ndflush(&tp->t_outq, n);
    701 	}
    702 
    703 	CLR(tp->t_state, TS_BUSY);
    704 	/* Come back if there's more to do. */
    705 	if (ttypull(tp)) {
    706 		SET(tp->t_state, TS_TIMEOUT);
    707 		callout_schedule(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1);
    708 	}
    709 }
    710 
    711 /*
    712  * gftty_stop --
    713  *	cdevsw stop routine.
    714  */
    715 static void
    716 gftty_stop(struct tty *tp, int flag)
    717 {
    718 	KASSERT(ttylocked(tp));
    719 
    720 	if (ISSET(tp->t_state, TS_BUSY)) {
    721 		if (!ISSET(tp->t_state, TS_TTSTOP)) {
    722 			SET(tp->t_state, TS_FLUSH);
    723 		}
    724 	}
    725 }
    726 
    727 /*
    728  * gftty_param_locked --
    729  *	Set TTY parameters.  TTY must be locked.
    730  */
    731 static int
    732 gftty_param_locked(struct tty *tp, struct termios *t)
    733 {
    734 
    735 	KASSERT(ttylocked(tp));
    736 
    737 	tp->t_ispeed = t->c_ispeed;
    738 	tp->t_ospeed = t->c_ospeed;
    739 	tp->t_cflag = t->c_cflag;
    740 
    741 	return 0;
    742 }
    743 
    744 /*
    745  * gftty_param --
    746  *	TTY param routine.
    747  */
    748 static int
    749 gftty_param(struct tty *tp, struct termios *t)
    750 {
    751 	int rv;
    752 
    753 	ttylock(tp);
    754 	rv = gftty_param_locked(tp, t);
    755 	ttyunlock(tp);
    756 
    757 	return rv;
    758 }
    759 
    760 /*
    761  * gftty console routines.
    762  */
    763 static int
    764 gftty_cngetc(dev_t dev)
    765 {
    766 	struct gftty_config * const c = &gftty_cnconfig;
    767 
    768 	if (REG_READ0(c, GFTTY_BYTES_READY) == 0) {
    769 		return -1;
    770 	}
    771 
    772 	/*
    773 	 * XXX This is all terrible and should burn to the ground.
    774 	 * XXX This device desperately needs to be improved with
    775 	 * XXX a GET_CHAR register.
    776 	 */
    777 	bus_addr_t addr;
    778 	uint8_t buf[1];
    779 
    780 	if (c->c_version == 0) {
    781 		addr = (bus_addr_t)buf;
    782 	} else {
    783 		addr = vtophys((vaddr_t)buf);
    784 	}
    785 
    786 	gftty_set_buffer(c, addr, sizeof(buf));
    787 	REG_WRITE0(c, GFTTY_CMD, CMD_READ_BUFFER);
    788 
    789 	return buf[0];
    790 }
    791 
    792 static void
    793 gftty_cnputc(dev_t dev, int ch)
    794 {
    795 	REG_WRITE0(&gftty_cnconfig, GFTTY_PUT_CHAR, (unsigned char)ch);
    796 }
    797 
    798 static void
    799 gftty_cnpollc(dev_t dev, int on)
    800 {
    801 	/* XXX */
    802 }
    803 
    804 /*
    805  * gftty_cnattach --
    806  *	Attach a Goldfish virtual TTY console.
    807  */
    808 void
    809 gftty_cnattach(bus_space_tag_t bst, bus_space_handle_t bsh)
    810 {
    811 	gftty_init_config(&gftty_cnconfig, bst, bsh);
    812 
    813 	cn_tab = &gftty_consdev;
    814 	cn_init_magic(&gftty_cnmagic_state);
    815 	cn_set_magic("+++++");
    816 }
    817