Home | History | Annotate | Line # | Download | only in wscons
wsdisplay.c revision 1.134.8.1
      1 /* $NetBSD: wsdisplay.c,v 1.134.8.1 2012/02/18 07:35:14 mrg Exp $ */
      2 
      3 /*
      4  * Copyright (c) 1996, 1997 Christopher G. Demetriou.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following 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  * 3. All advertising materials mentioning features or use of this software
     15  *    must display the following acknowledgement:
     16  *      This product includes software developed by Christopher G. Demetriou
     17  *	for the NetBSD Project.
     18  * 4. The name of the author may not be used to endorse or promote products
     19  *    derived from this software without specific prior written permission
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 #include <sys/cdefs.h>
     34 __KERNEL_RCSID(0, "$NetBSD: wsdisplay.c,v 1.134.8.1 2012/02/18 07:35:14 mrg Exp $");
     35 
     36 #include "opt_wsdisplay_compat.h"
     37 #include "opt_wsmsgattrs.h"
     38 #include "wskbd.h"
     39 #include "wsmux.h"
     40 #include "wsdisplay.h"
     41 
     42 #include <sys/param.h>
     43 #include <sys/conf.h>
     44 #include <sys/device.h>
     45 #include <sys/ioctl.h>
     46 #include <sys/poll.h>
     47 #include <sys/kernel.h>
     48 #include <sys/proc.h>
     49 #include <sys/malloc.h>
     50 #include <sys/syslog.h>
     51 #include <sys/systm.h>
     52 #include <sys/tty.h>
     53 #include <sys/signalvar.h>
     54 #include <sys/errno.h>
     55 #include <sys/fcntl.h>
     56 #include <sys/vnode.h>
     57 #include <sys/kauth.h>
     58 
     59 #include <dev/wscons/wsconsio.h>
     60 #include <dev/wscons/wseventvar.h>
     61 #include <dev/wscons/wsmuxvar.h>
     62 #include <dev/wscons/wsdisplayvar.h>
     63 #include <dev/wscons/wsksymvar.h>
     64 #include <dev/wscons/wsksymdef.h>
     65 #include <dev/wscons/wsemulvar.h>
     66 #include <dev/wscons/wscons_callbacks.h>
     67 #include <dev/cons.h>
     68 
     69 #include "locators.h"
     70 
     71 struct wsscreen_internal {
     72 	const struct wsdisplay_emulops *emulops;
     73 	void	*emulcookie;
     74 
     75 	const struct wsscreen_descr *scrdata;
     76 
     77 	const struct wsemul_ops *wsemul;
     78 	void	*wsemulcookie;
     79 };
     80 
     81 struct wsscreen {
     82 	struct wsscreen_internal *scr_dconf;
     83 
     84 	struct tty *scr_tty;
     85 	int	scr_hold_screen;		/* hold tty output */
     86 
     87 	int scr_flags;
     88 #define SCR_OPEN 1		/* is it open? */
     89 #define SCR_WAITACTIVE 2	/* someone waiting on activation */
     90 #define SCR_GRAPHICS 4		/* graphics mode, no text (emulation) output */
     91 #define	SCR_DUMBFB 8		/* in use as a dumb fb (iff SCR_GRAPHICS) */
     92 	const struct wscons_syncops *scr_syncops;
     93 	void *scr_synccookie;
     94 
     95 #ifdef WSDISPLAY_COMPAT_RAWKBD
     96 	int scr_rawkbd;
     97 #endif
     98 
     99 	struct wsdisplay_softc *sc;
    100 
    101 #ifdef DIAGNOSTIC
    102 	/* XXX this is to support a hack in emulinput, see comment below */
    103 	int scr_in_ttyoutput;
    104 #endif
    105 };
    106 
    107 struct wsscreen *wsscreen_attach(struct wsdisplay_softc *, int,
    108 				 const char *,
    109 				 const struct wsscreen_descr *, void *,
    110 				 int, int, long);
    111 void wsscreen_detach(struct wsscreen *);
    112 int wsdisplay_addscreen(struct wsdisplay_softc *, int, const char *, const char *);
    113 static void wsdisplay_addscreen_print(struct wsdisplay_softc *, int, int);
    114 static void wsdisplay_closescreen(struct wsdisplay_softc *, struct wsscreen *);
    115 int wsdisplay_delscreen(struct wsdisplay_softc *, int, int);
    116 
    117 #define WSDISPLAY_MAXSCREEN 8
    118 
    119 struct wsdisplay_softc {
    120 	device_t sc_dev;
    121 
    122 	const struct wsdisplay_accessops *sc_accessops;
    123 	void	*sc_accesscookie;
    124 
    125 	const struct wsscreen_list *sc_scrdata;
    126 #ifdef WSDISPLAY_SCROLLSUPPORT
    127 	struct wsdisplay_scroll_data sc_scroll_values;
    128 #endif
    129 
    130 	struct wsscreen *sc_scr[WSDISPLAY_MAXSCREEN];
    131 	int sc_focusidx;	/* available only if sc_focus isn't null */
    132 	struct wsscreen *sc_focus;
    133 
    134 	struct wseventvar evar;
    135 
    136 	int	sc_isconsole;
    137 
    138 	int sc_flags;
    139 #define SC_SWITCHPENDING 1
    140 #define SC_SWITCHERROR 2
    141 #define SC_XATTACHED 4 /* X server active */
    142 	kmutex_t sc_flagsmtx; /* for flags, might also be used for focus */
    143 	kcondvar_t sc_flagscv;
    144 
    145 	int sc_screenwanted, sc_oldscreen; /* valid with SC_SWITCHPENDING */
    146 
    147 #if NWSKBD > 0
    148 	struct wsevsrc *sc_input;
    149 #ifdef WSDISPLAY_COMPAT_RAWKBD
    150 	int sc_rawkbd;
    151 #endif
    152 #endif /* NWSKBD > 0 */
    153 };
    154 
    155 #ifdef WSDISPLAY_SCROLLSUPPORT
    156 
    157 struct wsdisplay_scroll_data wsdisplay_default_scroll_values = {
    158 	WSDISPLAY_SCROLL_DOALL,
    159 	25,
    160 	2,
    161 };
    162 #endif
    163 
    164 extern struct cfdriver wsdisplay_cd;
    165 
    166 /* Autoconfiguration definitions. */
    167 static int wsdisplay_emul_match(device_t , cfdata_t, void *);
    168 static void wsdisplay_emul_attach(device_t, device_t, void *);
    169 static int wsdisplay_emul_detach(device_t, int);
    170 static int wsdisplay_noemul_match(device_t, cfdata_t, void *);
    171 static void wsdisplay_noemul_attach(device_t, device_t, void *);
    172 static bool wsdisplay_suspend(device_t, const pmf_qual_t *);
    173 
    174 CFATTACH_DECL_NEW(wsdisplay_emul, sizeof (struct wsdisplay_softc),
    175     wsdisplay_emul_match, wsdisplay_emul_attach, wsdisplay_emul_detach, NULL);
    176 
    177 CFATTACH_DECL_NEW(wsdisplay_noemul, sizeof (struct wsdisplay_softc),
    178     wsdisplay_noemul_match, wsdisplay_noemul_attach, NULL, NULL);
    179 
    180 dev_type_open(wsdisplayopen);
    181 dev_type_close(wsdisplayclose);
    182 dev_type_read(wsdisplayread);
    183 dev_type_write(wsdisplaywrite);
    184 dev_type_ioctl(wsdisplayioctl);
    185 dev_type_stop(wsdisplaystop);
    186 dev_type_tty(wsdisplaytty);
    187 dev_type_poll(wsdisplaypoll);
    188 dev_type_mmap(wsdisplaymmap);
    189 dev_type_kqfilter(wsdisplaykqfilter);
    190 
    191 const struct cdevsw wsdisplay_cdevsw = {
    192 	wsdisplayopen, wsdisplayclose, wsdisplayread, wsdisplaywrite,
    193 	wsdisplayioctl, wsdisplaystop, wsdisplaytty, wsdisplaypoll,
    194 	wsdisplaymmap, wsdisplaykqfilter, D_TTY
    195 };
    196 
    197 static void wsdisplaystart(struct tty *);
    198 static int wsdisplayparam(struct tty *, struct termios *);
    199 
    200 
    201 #define	WSDISPLAYUNIT(dev)	(minor(dev) >> 8)
    202 #define	WSDISPLAYSCREEN(dev)	(minor(dev) & 0xff)
    203 #define ISWSDISPLAYSTAT(dev)	(WSDISPLAYSCREEN(dev) == 254)
    204 #define ISWSDISPLAYCTL(dev)	(WSDISPLAYSCREEN(dev) == 255)
    205 #define WSDISPLAYMINOR(unit, screen)	(((unit) << 8) | (screen))
    206 
    207 #define	WSSCREEN_HAS_EMULATOR(scr)	((scr)->scr_dconf->wsemul != NULL)
    208 #define	WSSCREEN_HAS_TTY(scr)	((scr)->scr_tty != NULL)
    209 
    210 static void wsdisplay_common_attach(struct wsdisplay_softc *sc,
    211 	    int console, int kbdmux, const struct wsscreen_list *,
    212 	    const struct wsdisplay_accessops *accessops,
    213 	    void *accesscookie);
    214 
    215 #ifdef WSDISPLAY_COMPAT_RAWKBD
    216 int wsdisplay_update_rawkbd(struct wsdisplay_softc *,
    217 				 struct wsscreen *);
    218 #endif
    219 
    220 static int wsdisplay_console_initted;
    221 static int wsdisplay_console_attached;
    222 static struct wsdisplay_softc *wsdisplay_console_device;
    223 static struct wsscreen_internal wsdisplay_console_conf;
    224 
    225 static int wsdisplay_getc_dummy(dev_t);
    226 static void wsdisplay_pollc(dev_t, int);
    227 
    228 static int wsdisplay_cons_pollmode;
    229 static void (*wsdisplay_cons_kbd_pollc)(dev_t, int);
    230 
    231 static struct consdev wsdisplay_cons = {
    232 	NULL, NULL, wsdisplay_getc_dummy, wsdisplay_cnputc,
    233 	wsdisplay_pollc, NULL, NULL, NULL, NODEV, CN_NORMAL
    234 };
    235 
    236 #ifndef WSDISPLAY_DEFAULTSCREENS
    237 # define WSDISPLAY_DEFAULTSCREENS	0
    238 #endif
    239 int wsdisplay_defaultscreens = WSDISPLAY_DEFAULTSCREENS;
    240 
    241 static int wsdisplay_switch1(device_t, int, int);
    242 static void wsdisplay_switch1_cb(void *, int, int);
    243 static int wsdisplay_switch2(device_t, int, int);
    244 static void wsdisplay_switch2_cb(void *, int, int);
    245 static int wsdisplay_switch3(device_t, int, int);
    246 static void wsdisplay_switch3_cb(void *, int, int);
    247 
    248 int wsdisplay_clearonclose;
    249 
    250 struct wsscreen *
    251 wsscreen_attach(struct wsdisplay_softc *sc, int console, const char *emul,
    252 	const struct wsscreen_descr *type, void *cookie, int ccol,
    253 	int crow, long defattr)
    254 {
    255 	struct wsscreen_internal *dconf;
    256 	struct wsscreen *scr;
    257 
    258 	scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_WAITOK);
    259 	if (!scr)
    260 		return (NULL);
    261 
    262 	if (console) {
    263 		dconf = &wsdisplay_console_conf;
    264 		/*
    265 		 * If there's an emulation, tell it about the callback argument.
    266 		 * The other stuff is already there.
    267 		 */
    268 		if (dconf->wsemul != NULL)
    269 			(*dconf->wsemul->attach)(1, 0, 0, 0, 0, scr, 0);
    270 	} else { /* not console */
    271 		dconf = malloc(sizeof(struct wsscreen_internal),
    272 			       M_DEVBUF, M_NOWAIT);
    273 		dconf->emulops = type->textops;
    274 		dconf->emulcookie = cookie;
    275 		if (dconf->emulops) {
    276 			dconf->wsemul = wsemul_pick(emul);
    277 			if (dconf->wsemul == NULL) {
    278 				free(dconf, M_DEVBUF);
    279 				free(scr, M_DEVBUF);
    280 				return (NULL);
    281 			}
    282 			dconf->wsemulcookie =
    283 			  (*dconf->wsemul->attach)(0, type, cookie,
    284 						   ccol, crow, scr, defattr);
    285 		} else
    286 			dconf->wsemul = NULL;
    287 		dconf->scrdata = type;
    288 	}
    289 
    290 	scr->scr_dconf = dconf;
    291 
    292 	scr->scr_tty = tty_alloc();
    293 	tty_attach(scr->scr_tty);
    294 	scr->scr_hold_screen = 0;
    295 	if (WSSCREEN_HAS_EMULATOR(scr))
    296 		scr->scr_flags = 0;
    297 	else
    298 		scr->scr_flags = SCR_GRAPHICS;
    299 
    300 	scr->scr_syncops = 0;
    301 	scr->sc = sc;
    302 #ifdef WSDISPLAY_COMPAT_RAWKBD
    303 	scr->scr_rawkbd = 0;
    304 #endif
    305 	return (scr);
    306 }
    307 
    308 void
    309 wsscreen_detach(struct wsscreen *scr)
    310 {
    311 	u_int ccol, crow; /* XXX */
    312 
    313 	if (WSSCREEN_HAS_TTY(scr)) {
    314 		tty_detach(scr->scr_tty);
    315 		tty_free(scr->scr_tty);
    316 	}
    317 	if (WSSCREEN_HAS_EMULATOR(scr)) {
    318 		(*scr->scr_dconf->wsemul->detach)(scr->scr_dconf->wsemulcookie,
    319 						  &ccol, &crow);
    320 		wsemul_drop(scr->scr_dconf->wsemul);
    321 	}
    322 	free(scr->scr_dconf, M_DEVBUF);
    323 	free(scr, M_DEVBUF);
    324 }
    325 
    326 const struct wsscreen_descr *
    327 wsdisplay_screentype_pick(const struct wsscreen_list *scrdata, const char *name)
    328 {
    329 	int i;
    330 	const struct wsscreen_descr *scr;
    331 
    332 	KASSERT(scrdata->nscreens > 0);
    333 
    334 	if (name == NULL)
    335 		return (scrdata->screens[0]);
    336 
    337 	for (i = 0; i < scrdata->nscreens; i++) {
    338 		scr = scrdata->screens[i];
    339 		if (!strcmp(name, scr->name))
    340 			return (scr);
    341 	}
    342 
    343 	return (0);
    344 }
    345 
    346 /*
    347  * print info about attached screen
    348  */
    349 static void
    350 wsdisplay_addscreen_print(struct wsdisplay_softc *sc, int idx, int count)
    351 {
    352 	aprint_verbose_dev(sc->sc_dev, "screen %d", idx);
    353 	if (count > 1)
    354 		aprint_verbose("-%d", idx + (count-1));
    355 	aprint_verbose(" added (%s", sc->sc_scr[idx]->scr_dconf->scrdata->name);
    356 	if (WSSCREEN_HAS_EMULATOR(sc->sc_scr[idx])) {
    357 		aprint_verbose(", %s emulation",
    358 			sc->sc_scr[idx]->scr_dconf->wsemul->name);
    359 	}
    360 	aprint_verbose(")\n");
    361 }
    362 
    363 int
    364 wsdisplay_addscreen(struct wsdisplay_softc *sc, int idx,
    365 	const char *screentype, const char *emul)
    366 {
    367 	const struct wsscreen_descr *scrdesc;
    368 	int error;
    369 	void *cookie;
    370 	int ccol, crow;
    371 	long defattr;
    372 	struct wsscreen *scr;
    373 	int s;
    374 
    375 	if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
    376 		return (EINVAL);
    377 	if (sc->sc_scr[idx] != NULL)
    378 		return (EBUSY);
    379 
    380 	scrdesc = wsdisplay_screentype_pick(sc->sc_scrdata, screentype);
    381 	if (!scrdesc)
    382 		return (ENXIO);
    383 	error = (*sc->sc_accessops->alloc_screen)(sc->sc_accesscookie,
    384 			scrdesc, &cookie, &ccol, &crow, &defattr);
    385 	if (error)
    386 		return (error);
    387 
    388 	scr = wsscreen_attach(sc, 0, emul, scrdesc,
    389 			      cookie, ccol, crow, defattr);
    390 	if (scr == NULL) {
    391 		(*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
    392 						 cookie);
    393 		return (ENXIO);
    394 	}
    395 
    396 	sc->sc_scr[idx] = scr;
    397 
    398 	/* if no screen has focus yet, activate the first we get */
    399 	s = spltty();
    400 	if (!sc->sc_focus) {
    401 		(*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
    402 						 scr->scr_dconf->emulcookie,
    403 						 0, 0, 0);
    404 		sc->sc_focusidx = idx;
    405 		sc->sc_focus = scr;
    406 	}
    407 	splx(s);
    408 	return (0);
    409 }
    410 
    411 static void
    412 wsdisplay_closescreen(struct wsdisplay_softc *sc, struct wsscreen *scr)
    413 {
    414 	int maj, mn, idx;
    415 
    416 	/* hangup */
    417 	if (WSSCREEN_HAS_TTY(scr)) {
    418 		struct tty *tp = scr->scr_tty;
    419 		(*tp->t_linesw->l_modem)(tp, 0);
    420 	}
    421 
    422 	/* locate the major number */
    423 	maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
    424 	/* locate the screen index */
    425 	for (idx = 0; idx < WSDISPLAY_MAXSCREEN; idx++)
    426 		if (scr == sc->sc_scr[idx])
    427 			break;
    428 #ifdef DIAGNOSTIC
    429 	if (idx == WSDISPLAY_MAXSCREEN)
    430 		panic("wsdisplay_forceclose: bad screen");
    431 #endif
    432 
    433 	/* nuke the vnodes */
    434 	mn = WSDISPLAYMINOR(device_unit(sc->sc_dev), idx);
    435 	vdevgone(maj, mn, mn, VCHR);
    436 }
    437 
    438 #ifdef WSDISPLAY_SCROLLSUPPORT
    439 void
    440 wsdisplay_scroll(void *arg, int op)
    441 {
    442 	device_t dv = arg;
    443 	struct wsdisplay_softc *sc = device_private(dv);
    444 	struct wsscreen *scr;
    445 	int lines;
    446 
    447 	scr = sc->sc_focus;
    448 
    449 	if (!scr)
    450 		return;
    451 
    452 	if (op == WSDISPLAY_SCROLL_RESET)
    453 		lines = 0;
    454 	else {
    455 		lines = (op & WSDISPLAY_SCROLL_LOW) ?
    456 			sc->sc_scroll_values.slowlines :
    457 			sc->sc_scroll_values.fastlines;
    458 		if (op & WSDISPLAY_SCROLL_BACKWARD)
    459 			lines = -(lines);
    460 	}
    461 
    462 	if (sc->sc_accessops->scroll) {
    463 		(*sc->sc_accessops->scroll)(sc->sc_accesscookie,
    464 		    sc->sc_focus->scr_dconf->emulcookie, lines);
    465 	}
    466 }
    467 #endif
    468 
    469 int
    470 wsdisplay_delscreen(struct wsdisplay_softc *sc, int idx, int flags)
    471 {
    472 	struct wsscreen *scr;
    473 	int s;
    474 	void *cookie;
    475 
    476 	if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
    477 		return (EINVAL);
    478 	if ((scr = sc->sc_scr[idx]) == NULL)
    479 		return (ENXIO);
    480 
    481 	if (scr->scr_dconf == &wsdisplay_console_conf ||
    482 	    scr->scr_syncops ||
    483 	    ((scr->scr_flags & SCR_OPEN) && !(flags & WSDISPLAY_DELSCR_FORCE)))
    484 		return(EBUSY);
    485 
    486 	wsdisplay_closescreen(sc, scr);
    487 
    488 	/*
    489 	 * delete pointers, so neither device entries
    490 	 * nor keyboard input can reference it anymore
    491 	 */
    492 	s = spltty();
    493 	if (sc->sc_focus == scr) {
    494 		sc->sc_focus = 0;
    495 #ifdef WSDISPLAY_COMPAT_RAWKBD
    496 		wsdisplay_update_rawkbd(sc, 0);
    497 #endif
    498 	}
    499 	sc->sc_scr[idx] = 0;
    500 	splx(s);
    501 
    502 	/*
    503 	 * Wake up processes waiting for the screen to
    504 	 * be activated. Sleepers must check whether
    505 	 * the screen still exists.
    506 	 */
    507 	if (scr->scr_flags & SCR_WAITACTIVE)
    508 		wakeup(scr);
    509 
    510 	/* save a reference to the graphics screen */
    511 	cookie = scr->scr_dconf->emulcookie;
    512 
    513 	wsscreen_detach(scr);
    514 
    515 	(*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
    516 					 cookie);
    517 
    518 	aprint_verbose_dev(sc->sc_dev, "screen %d deleted\n", idx);
    519 	return (0);
    520 }
    521 
    522 /*
    523  * Autoconfiguration functions.
    524  */
    525 int
    526 wsdisplay_emul_match(device_t parent, cfdata_t match, void *aux)
    527 {
    528 	struct wsemuldisplaydev_attach_args *ap = aux;
    529 
    530 	if (match->cf_loc[WSEMULDISPLAYDEVCF_CONSOLE] !=
    531 	    WSEMULDISPLAYDEVCF_CONSOLE_DEFAULT) {
    532 		/*
    533 		 * If console-ness of device specified, either match
    534 		 * exactly (at high priority), or fail.
    535 		 */
    536 		if (match->cf_loc[WSEMULDISPLAYDEVCF_CONSOLE] != 0 &&
    537 		    ap->console != 0)
    538 			return (10);
    539 		else
    540 			return (0);
    541 	}
    542 
    543 	/* If console-ness unspecified, it wins. */
    544 	return (1);
    545 }
    546 
    547 void
    548 wsdisplay_emul_attach(device_t parent, device_t self, void *aux)
    549 {
    550 	struct wsdisplay_softc *sc = device_private(self);
    551 	struct wsemuldisplaydev_attach_args *ap = aux;
    552 
    553 	sc->sc_dev = self;
    554 
    555 	/* Don't allow more than one console to attach */
    556 	if (wsdisplay_console_attached && ap->console)
    557 		ap->console = 0;
    558 
    559 	wsdisplay_common_attach(sc, ap->console,
    560 	     device_cfdata(self)->cf_loc[WSEMULDISPLAYDEVCF_KBDMUX],
    561 	     ap->scrdata, ap->accessops, ap->accesscookie);
    562 
    563 	if (ap->console) {
    564 		int maj;
    565 
    566 		/* locate the major number */
    567 		maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
    568 
    569 		cn_tab->cn_dev = makedev(maj, WSDISPLAYMINOR(device_unit(self),
    570 					 0));
    571 	}
    572 }
    573 
    574 /* Print function (for parent devices). */
    575 int
    576 wsemuldisplaydevprint(void *aux, const char *pnp)
    577 {
    578 #if 0 /* -Wunused */
    579 	struct wsemuldisplaydev_attach_args *ap = aux;
    580 #endif
    581 
    582 	if (pnp)
    583 		aprint_normal("wsdisplay at %s", pnp);
    584 #if 0 /* don't bother; it's ugly */
    585 	aprint_normal(" console %d", ap->console);
    586 #endif
    587 
    588 	return (UNCONF);
    589 }
    590 
    591 int
    592 wsdisplay_emul_detach(device_t dev, int how)
    593 {
    594 	struct wsdisplay_softc *sc = device_private(dev);
    595 	int flag, i, res;
    596 
    597 	flag = (how & DETACH_FORCE ? WSDISPLAY_DELSCR_FORCE : 0);
    598 	for (i = 0; i < WSDISPLAY_MAXSCREEN; i++)
    599 		if (sc->sc_scr[i]) {
    600 			res = wsdisplay_delscreen(sc, i, flag);
    601 			if (res)
    602 				return res;
    603 		}
    604 
    605 	cv_destroy(&sc->sc_flagscv);
    606 	mutex_destroy(&sc->sc_flagsmtx);
    607 	return 0;
    608 }
    609 
    610 int
    611 wsdisplay_noemul_match(device_t parent, cfdata_t match, void *aux)
    612 {
    613 #if 0 /* -Wunused */
    614 	struct wsdisplaydev_attach_args *ap = aux;
    615 #endif
    616 
    617 	/* Always match. */
    618 	return (1);
    619 }
    620 
    621 void
    622 wsdisplay_noemul_attach(device_t parent, device_t self, void *aux)
    623 {
    624 	struct wsdisplay_softc *sc = device_private(self);
    625 	struct wsdisplaydev_attach_args *ap = aux;
    626 
    627 	sc->sc_dev = self;
    628 
    629 	wsdisplay_common_attach(sc, 0,
    630 	    device_cfdata(self)->cf_loc[WSDISPLAYDEVCF_KBDMUX], NULL,
    631 	    ap->accessops, ap->accesscookie);
    632 }
    633 
    634 static void
    635 wsdisplay_swdone_cb(void *arg, int error, int waitok)
    636 {
    637 	struct wsdisplay_softc *sc = arg;
    638 
    639 	mutex_enter(&sc->sc_flagsmtx);
    640 	KASSERT(sc->sc_flags & SC_SWITCHPENDING);
    641 	if (error)
    642 		sc->sc_flags |= SC_SWITCHERROR;
    643 	sc->sc_flags &= ~SC_SWITCHPENDING;
    644 	cv_signal(&sc->sc_flagscv);
    645 	mutex_exit(&sc->sc_flagsmtx);
    646 }
    647 
    648 static int
    649 wsdisplay_dosync(struct wsdisplay_softc *sc, int attach)
    650 {
    651 	struct wsscreen *scr;
    652 	int (*op)(void *, int, void (*)(void *, int, int), void *);
    653 	int res;
    654 
    655 	scr = sc->sc_focus;
    656 	if (!scr || !scr->scr_syncops)
    657 		return 0; /* XXX check SCR_GRAPHICS? */
    658 
    659 	sc->sc_flags |= SC_SWITCHPENDING;
    660 	sc->sc_flags &= ~SC_SWITCHERROR;
    661 	if (attach)
    662 		op = scr->scr_syncops->attach;
    663 	else
    664 		op = scr->scr_syncops->detach;
    665 	res = (*op)(scr->scr_synccookie, 1, wsdisplay_swdone_cb, sc);
    666 	if (res == EAGAIN) {
    667 		/* wait for callback */
    668 		mutex_enter(&sc->sc_flagsmtx);
    669 		while (sc->sc_flags & SC_SWITCHPENDING)
    670 			cv_wait_sig(&sc->sc_flagscv, &sc->sc_flagsmtx);
    671 		mutex_exit(&sc->sc_flagsmtx);
    672 		if (sc->sc_flags & SC_SWITCHERROR)
    673 			return (EIO); /* XXX pass real error */
    674 	} else {
    675 		sc->sc_flags &= ~SC_SWITCHPENDING;
    676 		if (res)
    677 			return (res);
    678 	}
    679 	if (attach)
    680 		sc->sc_flags |= SC_XATTACHED;
    681 	else
    682 		sc->sc_flags &= ~SC_XATTACHED;
    683 	return 0;
    684 }
    685 
    686 int
    687 wsdisplay_handlex(int resume)
    688 {
    689 	int i, res;
    690 	device_t dv;
    691 
    692 	for (i = 0; i < wsdisplay_cd.cd_ndevs; i++) {
    693 		dv = device_lookup(&wsdisplay_cd, i);
    694 		if (!dv)
    695 			continue;
    696 		res = wsdisplay_dosync(device_private(dv), resume);
    697 		if (res)
    698 			return (res);
    699 	}
    700 	return (0);
    701 }
    702 
    703 static bool
    704 wsdisplay_suspend(device_t dv, const pmf_qual_t *qual)
    705 {
    706 	struct wsdisplay_softc *sc = device_private(dv);
    707 #ifdef DIAGNOSTIC
    708 	struct wsscreen *scr = sc->sc_focus;
    709 	if (sc->sc_flags & SC_XATTACHED) {
    710 		KASSERT(scr && scr->scr_syncops);
    711 	}
    712 #endif
    713 #if 1
    714 	/*
    715 	 * XXX X servers should have been detached earlier.
    716 	 * pmf currently ignores our return value and suspends the system
    717 	 * after device suspend failures. We try to avoid bigger damage
    718 	 * and try to detach the X server here. This is not safe because
    719 	 * other parts of the system which the X server deals with
    720 	 * might already be suspended.
    721 	 */
    722 	if (sc->sc_flags & SC_XATTACHED) {
    723 		printf("%s: emergency X server detach\n", device_xname(dv));
    724 		wsdisplay_dosync(sc, 0);
    725 	}
    726 #endif
    727 	return (!(sc->sc_flags & SC_XATTACHED));
    728 }
    729 
    730 /* Print function (for parent devices). */
    731 int
    732 wsdisplaydevprint(void *aux, const char *pnp)
    733 {
    734 #if 0 /* -Wunused */
    735 	struct wsdisplaydev_attach_args *ap = aux;
    736 #endif
    737 
    738 	if (pnp)
    739 		aprint_normal("wsdisplay at %s", pnp);
    740 
    741 	return (UNCONF);
    742 }
    743 
    744 static void
    745 wsdisplay_common_attach(struct wsdisplay_softc *sc, int console, int kbdmux,
    746 	const struct wsscreen_list *scrdata,
    747 	const struct wsdisplay_accessops *accessops,
    748 	void *accesscookie)
    749 {
    750 	int i, start=0;
    751 #if NWSKBD > 0
    752 	struct wsevsrc *kme;
    753 #if NWSMUX > 0
    754 	struct wsmux_softc *mux;
    755 
    756 	if (kbdmux >= 0)
    757 		mux = wsmux_getmux(kbdmux);
    758 	else
    759 		mux = wsmux_create("dmux", device_unit(sc->sc_dev));
    760 	/* XXX panic()ing isn't nice, but attach cannot fail */
    761 	if (mux == NULL)
    762 		panic("wsdisplay_common_attach: no memory");
    763 	sc->sc_input = &mux->sc_base;
    764 	mux->sc_base.me_dispdv = sc->sc_dev;
    765 	aprint_normal(" kbdmux %d", kbdmux);
    766 #else
    767 	if (kbdmux >= 0)
    768 		aprint_normal(" (kbdmux ignored)");
    769 #endif
    770 #endif
    771 
    772 	sc->sc_isconsole = console;
    773 
    774 	if (console) {
    775 		KASSERT(wsdisplay_console_initted);
    776 		KASSERT(wsdisplay_console_device == NULL);
    777 
    778 		sc->sc_scr[0] = wsscreen_attach(sc, 1, 0, 0, 0, 0, 0, 0);
    779 		wsdisplay_console_device = sc;
    780 
    781 		aprint_normal(": console (%s, %s emulation)",
    782 		       wsdisplay_console_conf.scrdata->name,
    783 		       wsdisplay_console_conf.wsemul->name);
    784 
    785 #if NWSKBD > 0
    786 		kme = wskbd_set_console_display(sc->sc_dev, sc->sc_input);
    787 		if (kme != NULL)
    788 			aprint_normal(", using %s", device_xname(kme->me_dv));
    789 #if NWSMUX == 0
    790 		sc->sc_input = kme;
    791 #endif
    792 #endif
    793 
    794 		sc->sc_focusidx = 0;
    795 		sc->sc_focus = sc->sc_scr[0];
    796 		start = 1;
    797 
    798 		wsdisplay_console_attached = 1;
    799 	}
    800 	aprint_normal("\n");
    801 	aprint_naive("\n");
    802 
    803 #if NWSKBD > 0 && NWSMUX > 0
    804 	wsmux_set_display(mux, sc->sc_dev);
    805 #endif
    806 
    807 	mutex_init(&sc->sc_flagsmtx, MUTEX_DEFAULT, IPL_NONE);
    808 	cv_init(&sc->sc_flagscv, "wssw");
    809 
    810 	sc->sc_accessops = accessops;
    811 	sc->sc_accesscookie = accesscookie;
    812 	sc->sc_scrdata = scrdata;
    813 
    814 #ifdef WSDISPLAY_SCROLLSUPPORT
    815 	sc->sc_scroll_values = wsdisplay_default_scroll_values;
    816 #endif
    817 
    818 	/*
    819 	 * Set up a number of virtual screens if wanted. The
    820 	 * WSDISPLAYIO_ADDSCREEN ioctl is more flexible, so this code
    821 	 * is for special cases like installation kernels.
    822 	 */
    823 	for (i = start; i < wsdisplay_defaultscreens; i++) {
    824 		if (wsdisplay_addscreen(sc, i, 0, 0))
    825 			break;
    826 	}
    827 
    828 	if (i > start)
    829 		wsdisplay_addscreen_print(sc, start, i-start);
    830 
    831 	if (!pmf_device_register(sc->sc_dev, wsdisplay_suspend, NULL))
    832 		aprint_error_dev(sc->sc_dev, "couldn't establish power handler\n");
    833 }
    834 
    835 void
    836 wsdisplay_cnattach(const struct wsscreen_descr *type, void *cookie,
    837 	int ccol, int crow, long defattr)
    838 {
    839 	const struct wsemul_ops *wsemul;
    840 
    841 	KASSERT(wsdisplay_console_initted < 2);
    842 	KASSERT(type->nrows > 0);
    843 	KASSERT(type->ncols > 0);
    844 	KASSERT(crow < type->nrows);
    845 	KASSERT(ccol < type->ncols);
    846 
    847 	wsdisplay_console_conf.emulops = type->textops;
    848 	wsdisplay_console_conf.emulcookie = cookie;
    849 	wsdisplay_console_conf.scrdata = type;
    850 
    851 	wsemul = wsemul_pick(0); /* default */
    852 	wsdisplay_console_conf.wsemul = wsemul;
    853 	wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
    854 								  ccol, crow,
    855 								  defattr);
    856 
    857 	cn_tab = &wsdisplay_cons;
    858 	wsdisplay_console_initted = 2;
    859 }
    860 
    861 void
    862 wsdisplay_preattach(const struct wsscreen_descr *type, void *cookie,
    863 	int ccol, int crow, long defattr)
    864 {
    865 	const struct wsemul_ops *wsemul;
    866 
    867 	KASSERT(!wsdisplay_console_initted);
    868 	KASSERT(type->nrows > 0);
    869 	KASSERT(type->ncols > 0);
    870 	KASSERT(crow < type->nrows);
    871 	KASSERT(ccol < type->ncols);
    872 
    873 	wsdisplay_console_conf.emulops = type->textops;
    874 	wsdisplay_console_conf.emulcookie = cookie;
    875 	wsdisplay_console_conf.scrdata = type;
    876 
    877 	wsemul = wsemul_pick(0); /* default */
    878 	wsdisplay_console_conf.wsemul = wsemul;
    879 	wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
    880 								  ccol, crow,
    881 								  defattr);
    882 
    883 	cn_tab = &wsdisplay_cons;
    884 	wsdisplay_console_initted = 1;
    885 }
    886 
    887 /*
    888  * Tty and cdevsw functions.
    889  */
    890 int
    891 wsdisplayopen(dev_t dev, int flag, int mode, struct lwp *l)
    892 {
    893 	struct wsdisplay_softc *sc;
    894 	struct tty *tp;
    895 	int newopen, error;
    896 	struct wsscreen *scr;
    897 
    898 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
    899 	if (sc == NULL)			/* make sure it was attached */
    900 		return (ENXIO);
    901 
    902 	if (ISWSDISPLAYSTAT(dev)) {
    903 		wsevent_init(&sc->evar, l->l_proc);
    904 		return (0);
    905 	}
    906 
    907 	if (ISWSDISPLAYCTL(dev))
    908 		return (0);
    909 
    910 	if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
    911 		return (ENXIO);
    912 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
    913 		return (ENXIO);
    914 
    915 	if (WSSCREEN_HAS_TTY(scr)) {
    916 		tp = scr->scr_tty;
    917 		tp->t_oproc = wsdisplaystart;
    918 		tp->t_param = wsdisplayparam;
    919 		tp->t_dev = dev;
    920 		newopen = (tp->t_state & TS_ISOPEN) == 0;
    921 
    922 		if (kauth_authorize_device_tty(l->l_cred,
    923 			KAUTH_DEVICE_TTY_OPEN, tp))
    924 			return (EBUSY);
    925 
    926 		if (newopen) {
    927 			ttychars(tp);
    928 			tp->t_iflag = TTYDEF_IFLAG;
    929 			tp->t_oflag = TTYDEF_OFLAG;
    930 			tp->t_cflag = TTYDEF_CFLAG;
    931 			tp->t_lflag = TTYDEF_LFLAG;
    932 			tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
    933 			wsdisplayparam(tp, &tp->t_termios);
    934 			ttsetwater(tp);
    935 		}
    936 		tp->t_state |= TS_CARR_ON;
    937 
    938 		error = ((*tp->t_linesw->l_open)(dev, tp));
    939 		if (error)
    940 			return (error);
    941 
    942 		if (newopen && WSSCREEN_HAS_EMULATOR(scr)) {
    943 			/* set window sizes as appropriate, and reset
    944 			 the emulation */
    945 			tp->t_winsize.ws_row = scr->scr_dconf->scrdata->nrows;
    946 			tp->t_winsize.ws_col = scr->scr_dconf->scrdata->ncols;
    947 
    948 			/* wsdisplay_set_emulation() */
    949 		}
    950 	}
    951 
    952 	scr->scr_flags |= SCR_OPEN;
    953 	return (0);
    954 }
    955 
    956 int
    957 wsdisplayclose(dev_t dev, int flag, int mode, struct lwp *l)
    958 {
    959 	device_t dv;
    960 	struct wsdisplay_softc *sc;
    961 	struct tty *tp;
    962 	struct wsscreen *scr;
    963 
    964 	dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
    965 	sc = device_private(dv);
    966 
    967 	if (ISWSDISPLAYSTAT(dev)) {
    968 		wsevent_fini(&sc->evar);
    969 		return (0);
    970 	}
    971 
    972 	if (ISWSDISPLAYCTL(dev))
    973 		return (0);
    974 
    975 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
    976 		return (0);
    977 
    978 	if (WSSCREEN_HAS_TTY(scr)) {
    979 		if (scr->scr_hold_screen) {
    980 			int s;
    981 
    982 			/* XXX RESET KEYBOARD LEDS, etc. */
    983 			s = spltty();	/* avoid conflict with keyboard */
    984 			wsdisplay_kbdholdscreen(dv, 0);
    985 			splx(s);
    986 		}
    987 		tp = scr->scr_tty;
    988 		(*tp->t_linesw->l_close)(tp, flag);
    989 		ttyclose(tp);
    990 	}
    991 
    992 	if (scr->scr_syncops)
    993 		(*scr->scr_syncops->destroy)(scr->scr_synccookie);
    994 
    995 	if (WSSCREEN_HAS_EMULATOR(scr)) {
    996 		scr->scr_flags &= ~SCR_GRAPHICS;
    997 		(*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
    998 						 WSEMUL_RESET);
    999 		if (wsdisplay_clearonclose)
   1000 			(*scr->scr_dconf->wsemul->reset)
   1001 				(scr->scr_dconf->wsemulcookie,
   1002 				 WSEMUL_CLEARSCREEN);
   1003 	}
   1004 
   1005 #ifdef WSDISPLAY_COMPAT_RAWKBD
   1006 	if (scr->scr_rawkbd) {
   1007 		int kbmode = WSKBD_TRANSLATED;
   1008 		(void)wsdisplay_internal_ioctl(sc, scr, WSKBDIO_SETMODE,
   1009 					       (void *)&kbmode, 0, l);
   1010 	}
   1011 #endif
   1012 
   1013 	scr->scr_flags &= ~SCR_OPEN;
   1014 
   1015 	return (0);
   1016 }
   1017 
   1018 int
   1019 wsdisplayread(dev_t dev, struct uio *uio, int flag)
   1020 {
   1021 	struct wsdisplay_softc *sc;
   1022 	struct tty *tp;
   1023 	struct wsscreen *scr;
   1024 	int error;
   1025 
   1026 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1027 
   1028 	if (ISWSDISPLAYSTAT(dev)) {
   1029 		error = wsevent_read(&sc->evar, uio, flag);
   1030 		return (error);
   1031 	}
   1032 
   1033 	if (ISWSDISPLAYCTL(dev))
   1034 		return (0);
   1035 
   1036 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1037 		return (ENXIO);
   1038 
   1039 	if (!WSSCREEN_HAS_TTY(scr))
   1040 		return (ENODEV);
   1041 
   1042 	tp = scr->scr_tty;
   1043 	return ((*tp->t_linesw->l_read)(tp, uio, flag));
   1044 }
   1045 
   1046 int
   1047 wsdisplaywrite(dev_t dev, struct uio *uio, int flag)
   1048 {
   1049 	struct wsdisplay_softc *sc;
   1050 	struct tty *tp;
   1051 	struct wsscreen *scr;
   1052 
   1053 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1054 
   1055 	if (ISWSDISPLAYSTAT(dev)) {
   1056 		return (0);
   1057 	}
   1058 
   1059 	if (ISWSDISPLAYCTL(dev))
   1060 		return (0);
   1061 
   1062 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1063 		return (ENXIO);
   1064 
   1065 	if (!WSSCREEN_HAS_TTY(scr))
   1066 		return (ENODEV);
   1067 
   1068 	tp = scr->scr_tty;
   1069 	return ((*tp->t_linesw->l_write)(tp, uio, flag));
   1070 }
   1071 
   1072 int
   1073 wsdisplaypoll(dev_t dev, int events, struct lwp *l)
   1074 {
   1075 	struct wsdisplay_softc *sc;
   1076 	struct tty *tp;
   1077 	struct wsscreen *scr;
   1078 
   1079 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1080 
   1081 	if (ISWSDISPLAYSTAT(dev))
   1082 		return (wsevent_poll(&sc->evar, events, l));
   1083 
   1084 	if (ISWSDISPLAYCTL(dev))
   1085 		return (0);
   1086 
   1087 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1088 		return (POLLHUP);
   1089 
   1090 	if (!WSSCREEN_HAS_TTY(scr))
   1091 		return (POLLERR);
   1092 
   1093 	tp = scr->scr_tty;
   1094 	return ((*tp->t_linesw->l_poll)(tp, events, l));
   1095 }
   1096 
   1097 int
   1098 wsdisplaykqfilter(dev_t dev, struct knote *kn)
   1099 {
   1100 	struct wsdisplay_softc *sc;
   1101 	struct wsscreen *scr;
   1102 
   1103 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1104 
   1105 	if (ISWSDISPLAYCTL(dev))
   1106 		return (1);
   1107 
   1108 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1109 		return (1);
   1110 
   1111 
   1112 	if (WSSCREEN_HAS_TTY(scr))
   1113 		return (ttykqfilter(dev, kn));
   1114 	else
   1115 		return (1);
   1116 }
   1117 
   1118 struct tty *
   1119 wsdisplaytty(dev_t dev)
   1120 {
   1121 	struct wsdisplay_softc *sc;
   1122 	struct wsscreen *scr;
   1123 
   1124 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1125 
   1126 	if (ISWSDISPLAYSTAT(dev))
   1127 		panic("wsdisplaytty() on status device");
   1128 
   1129 	if (ISWSDISPLAYCTL(dev))
   1130 		panic("wsdisplaytty() on ctl device");
   1131 
   1132 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1133 		return NULL;
   1134 
   1135 	return (scr->scr_tty);
   1136 }
   1137 
   1138 int
   1139 wsdisplayioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
   1140 {
   1141 	device_t dv;
   1142 	struct wsdisplay_softc *sc;
   1143 	struct tty *tp;
   1144 	int error;
   1145 	struct wsscreen *scr;
   1146 
   1147 	dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1148 	sc = device_private(dv);
   1149 
   1150 #ifdef WSDISPLAY_COMPAT_USL
   1151 	error = wsdisplay_usl_ioctl1(dv, cmd, data, flag, l);
   1152 	if (error != EPASSTHROUGH)
   1153 		return (error);
   1154 #endif
   1155 
   1156 	if (ISWSDISPLAYSTAT(dev))
   1157 		return (wsdisplay_stat_ioctl(sc, cmd, data, flag, l));
   1158 
   1159 	if (ISWSDISPLAYCTL(dev))
   1160 		return (wsdisplay_cfg_ioctl(sc, cmd, data, flag, l));
   1161 
   1162 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1163 		return (ENXIO);
   1164 
   1165 	if (WSSCREEN_HAS_TTY(scr)) {
   1166 		tp = scr->scr_tty;
   1167 
   1168 /* printf("disc\n"); */
   1169 		/* do the line discipline ioctls first */
   1170 		error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
   1171 		if (error != EPASSTHROUGH)
   1172 			return (error);
   1173 
   1174 /* printf("tty\n"); */
   1175 		/* then the tty ioctls */
   1176 		error = ttioctl(tp, cmd, data, flag, l);
   1177 		if (error != EPASSTHROUGH)
   1178 			return (error);
   1179 	}
   1180 
   1181 #ifdef WSDISPLAY_COMPAT_USL
   1182 	error = wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, l);
   1183 	if (error != EPASSTHROUGH)
   1184 		return (error);
   1185 #endif
   1186 
   1187 	return (wsdisplay_internal_ioctl(sc, scr, cmd, data, flag, l));
   1188 }
   1189 
   1190 int
   1191 wsdisplay_param(device_t dv, u_long cmd, struct wsdisplay_param *dp)
   1192 {
   1193 	struct wsdisplay_softc *sc = device_private(dv);
   1194 	return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
   1195 					   sc->sc_focus->scr_dconf->emulcookie,
   1196 					   cmd, (void *)dp, 0, NULL));
   1197 }
   1198 
   1199 int
   1200 wsdisplay_internal_ioctl(struct wsdisplay_softc *sc, struct wsscreen *scr,
   1201 	u_long cmd, void *data, int flag, struct lwp *l)
   1202 {
   1203 	int error;
   1204 	char namebuf[16];
   1205 	struct wsdisplay_font fd;
   1206 #ifdef WSDISPLAY_SCROLLSUPPORT
   1207 	struct wsdisplay_scroll_data *ksdp, *usdp;
   1208 #endif
   1209 
   1210 #if NWSKBD > 0
   1211 	struct wsevsrc *inp;
   1212 
   1213 #ifdef WSDISPLAY_COMPAT_RAWKBD
   1214 	switch (cmd) {
   1215 	case WSKBDIO_SETMODE:
   1216 		scr->scr_rawkbd = (*(int *)data == WSKBD_RAW);
   1217 		return (wsdisplay_update_rawkbd(sc, scr));
   1218 	case WSKBDIO_GETMODE:
   1219 		*(int *)data = (scr->scr_rawkbd ?
   1220 				WSKBD_RAW : WSKBD_TRANSLATED);
   1221 		return (0);
   1222 	}
   1223 #endif
   1224 	inp = sc->sc_input;
   1225 	if (inp == NULL)
   1226 		return (ENXIO);
   1227 	error = wsevsrc_display_ioctl(inp, cmd, data, flag, l);
   1228 	if (error != EPASSTHROUGH)
   1229 		return (error);
   1230 #endif /* NWSKBD > 0 */
   1231 
   1232 	switch (cmd) {
   1233 	case WSDISPLAYIO_GMODE:
   1234 		if (scr->scr_flags & SCR_GRAPHICS) {
   1235 			if (scr->scr_flags & SCR_DUMBFB)
   1236 				*(u_int *)data = WSDISPLAYIO_MODE_DUMBFB;
   1237 			else
   1238 				*(u_int *)data = WSDISPLAYIO_MODE_MAPPED;
   1239 		} else
   1240 			*(u_int *)data = WSDISPLAYIO_MODE_EMUL;
   1241 		return (0);
   1242 
   1243 	case WSDISPLAYIO_SMODE:
   1244 #define d (*(int *)data)
   1245 		if (d != WSDISPLAYIO_MODE_EMUL &&
   1246 		    d != WSDISPLAYIO_MODE_MAPPED &&
   1247 		    d != WSDISPLAYIO_MODE_DUMBFB)
   1248 			return (EINVAL);
   1249 
   1250 	    if (WSSCREEN_HAS_EMULATOR(scr)) {
   1251 		    scr->scr_flags &= ~SCR_GRAPHICS;
   1252 		    if (d == WSDISPLAYIO_MODE_MAPPED ||
   1253 			d == WSDISPLAYIO_MODE_DUMBFB)
   1254 			    scr->scr_flags |= SCR_GRAPHICS |
   1255 				    ((d == WSDISPLAYIO_MODE_DUMBFB) ? SCR_DUMBFB : 0);
   1256 	    } else if (d == WSDISPLAYIO_MODE_EMUL)
   1257 		    return (EINVAL);
   1258 
   1259 	    (void)(*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
   1260 	        scr->scr_dconf->emulcookie, cmd, data, flag, l);
   1261 
   1262 	    return (0);
   1263 #undef d
   1264 
   1265 #ifdef WSDISPLAY_SCROLLSUPPORT
   1266 #define	SETSCROLLLINES(dstp, srcp, dfltp)				\
   1267     do {								\
   1268 	(dstp)->fastlines = ((srcp)->which &				\
   1269 			     WSDISPLAY_SCROLL_DOFASTLINES) ?		\
   1270 			     (srcp)->fastlines : (dfltp)->fastlines;	\
   1271 	(dstp)->slowlines = ((srcp)->which &				\
   1272 			     WSDISPLAY_SCROLL_DOSLOWLINES) ?		\
   1273 			     (srcp)->slowlines : (dfltp)->slowlines;	\
   1274 	(dstp)->which = WSDISPLAY_SCROLL_DOALL;				\
   1275     } while (0)
   1276 
   1277 
   1278 	case WSDISPLAYIO_DSSCROLL:
   1279 		usdp = (struct wsdisplay_scroll_data *)data;
   1280 		ksdp = &sc->sc_scroll_values;
   1281 		SETSCROLLLINES(ksdp, usdp, ksdp);
   1282 		return (0);
   1283 
   1284 	case WSDISPLAYIO_DGSCROLL:
   1285 		usdp = (struct wsdisplay_scroll_data *)data;
   1286 		ksdp = &sc->sc_scroll_values;
   1287 		SETSCROLLLINES(usdp, ksdp, ksdp);
   1288 		return (0);
   1289 #else
   1290 	case WSDISPLAYIO_DSSCROLL:
   1291 	case WSDISPLAYIO_DGSCROLL:
   1292 		return ENODEV;
   1293 #endif
   1294 
   1295 	case WSDISPLAYIO_SFONT:
   1296 #define d ((struct wsdisplay_usefontdata *)data)
   1297 		if (!sc->sc_accessops->load_font)
   1298 			return (EINVAL);
   1299 		if (d->name) {
   1300 			error = copyinstr(d->name, namebuf, sizeof(namebuf), 0);
   1301 			if (error)
   1302 				return (error);
   1303 			fd.name = namebuf;
   1304 		} else
   1305 			fd.name = 0;
   1306 		fd.data = 0;
   1307 		error = (*sc->sc_accessops->load_font)(sc->sc_accesscookie,
   1308 					scr->scr_dconf->emulcookie, &fd);
   1309 		if (!error && WSSCREEN_HAS_EMULATOR(scr))
   1310 			(*scr->scr_dconf->wsemul->reset)
   1311 				(scr->scr_dconf->wsemulcookie, WSEMUL_SYNCFONT);
   1312 		return (error);
   1313 #undef d
   1314 
   1315 #ifdef WSDISPLAY_CUSTOM_OUTPUT
   1316 	case WSDISPLAYIO_GMSGATTRS:
   1317 #define d ((struct wsdisplay_msgattrs *)data)
   1318 		(*scr->scr_dconf->wsemul->getmsgattrs)
   1319 		    (scr->scr_dconf->wsemulcookie, d);
   1320 		return (0);
   1321 #undef d
   1322 
   1323 	case WSDISPLAYIO_SMSGATTRS: {
   1324 #define d ((struct wsdisplay_msgattrs *)data)
   1325 		int i;
   1326 		for (i = 0; i < WSDISPLAY_MAXSCREEN; i++)
   1327 			if (sc->sc_scr[i] != NULL)
   1328 				(*sc->sc_scr[i]->scr_dconf->wsemul->setmsgattrs)
   1329 				    (sc->sc_scr[i]->scr_dconf->wsemulcookie,
   1330 				     sc->sc_scr[i]->scr_dconf->scrdata,
   1331 				     d);
   1332 		}
   1333 		return (0);
   1334 #undef d
   1335 #else
   1336 	case WSDISPLAYIO_GMSGATTRS:
   1337 	case WSDISPLAYIO_SMSGATTRS:
   1338 		return (ENODEV);
   1339 #endif
   1340 	case WSDISPLAYIO_SETVERSION:
   1341 		return wsevent_setversion(&sc->evar, *(int *)data);
   1342 	}
   1343 
   1344 	/* check ioctls for display */
   1345 	return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
   1346 	    scr->scr_dconf->emulcookie, cmd, data, flag, l));
   1347 }
   1348 
   1349 int
   1350 wsdisplay_stat_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
   1351 	int flag, struct lwp *l)
   1352 {
   1353 	switch (cmd) {
   1354 	case WSDISPLAYIO_GETACTIVESCREEN:
   1355 		*(int*)data = wsdisplay_getactivescreen(sc);
   1356 		return (0);
   1357 	}
   1358 
   1359 	return (EPASSTHROUGH);
   1360 }
   1361 
   1362 int
   1363 wsdisplay_cfg_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
   1364 	int flag, struct lwp *l)
   1365 {
   1366 	int error;
   1367 	char *type, typebuf[16], *emul, emulbuf[16];
   1368 	void *tbuf;
   1369 	u_int fontsz;
   1370 #if defined(COMPAT_14) && NWSKBD > 0
   1371 	struct wsmux_device wsmuxdata;
   1372 #endif
   1373 #if NWSKBD > 0
   1374 	struct wsevsrc *inp;
   1375 #endif
   1376 
   1377 	switch (cmd) {
   1378 	case WSDISPLAYIO_ADDSCREEN:
   1379 #define d ((struct wsdisplay_addscreendata *)data)
   1380 		if (d->screentype) {
   1381 			error = copyinstr(d->screentype, typebuf,
   1382 					  sizeof(typebuf), 0);
   1383 			if (error)
   1384 				return (error);
   1385 			type = typebuf;
   1386 		} else
   1387 			type = 0;
   1388 		if (d->emul) {
   1389 			error = copyinstr(d->emul, emulbuf, sizeof(emulbuf),0);
   1390 			if (error)
   1391 				return (error);
   1392 			emul = emulbuf;
   1393 		} else
   1394 			emul = 0;
   1395 
   1396 		if ((error = wsdisplay_addscreen(sc, d->idx, type, emul)) == 0)
   1397 			wsdisplay_addscreen_print(sc, d->idx, 0);
   1398 		return (error);
   1399 #undef d
   1400 	case WSDISPLAYIO_DELSCREEN:
   1401 #define d ((struct wsdisplay_delscreendata *)data)
   1402 		return (wsdisplay_delscreen(sc, d->idx, d->flags));
   1403 #undef d
   1404 	case WSDISPLAYIO_LDFONT:
   1405 #define d ((struct wsdisplay_font *)data)
   1406 		if (!sc->sc_accessops->load_font)
   1407 			return (EINVAL);
   1408 		if (d->name) {
   1409 			error = copyinstr(d->name, typebuf, sizeof(typebuf), 0);
   1410 			if (error)
   1411 				return (error);
   1412 			d->name = typebuf;
   1413 		} else
   1414 			d->name = "loaded"; /* ??? */
   1415 		fontsz = d->fontheight * d->stride * d->numchars;
   1416 		if (fontsz > WSDISPLAY_MAXFONTSZ)
   1417 			return (EINVAL);
   1418 
   1419 		tbuf = malloc(fontsz, M_DEVBUF, M_WAITOK);
   1420 		error = copyin(d->data, tbuf, fontsz);
   1421 		if (error) {
   1422 			free(tbuf, M_DEVBUF);
   1423 			return (error);
   1424 		}
   1425 		d->data = tbuf;
   1426 		error =
   1427 		  (*sc->sc_accessops->load_font)(sc->sc_accesscookie, 0, d);
   1428 		free(tbuf, M_DEVBUF);
   1429 #undef d
   1430 		return (error);
   1431 
   1432 #if NWSKBD > 0
   1433 #ifdef COMPAT_14
   1434 	case _O_WSDISPLAYIO_SETKEYBOARD:
   1435 #define d ((struct wsdisplay_kbddata *)data)
   1436 		inp = sc->sc_input;
   1437 		if (inp == NULL)
   1438 			return (ENXIO);
   1439 		switch (d->op) {
   1440 		case _O_WSDISPLAY_KBD_ADD:
   1441 			if (d->idx == -1) {
   1442 				d->idx = wskbd_pickfree();
   1443 				if (d->idx == -1)
   1444 					return (ENXIO);
   1445 			}
   1446 			wsmuxdata.type = WSMUX_KBD;
   1447 			wsmuxdata.idx = d->idx;
   1448 			return (wsevsrc_ioctl(inp, WSMUX_ADD_DEVICE,
   1449 					      &wsmuxdata, flag, l));
   1450 		case _O_WSDISPLAY_KBD_DEL:
   1451 			wsmuxdata.type = WSMUX_KBD;
   1452 			wsmuxdata.idx = d->idx;
   1453 			return (wsevsrc_ioctl(inp, WSMUX_REMOVE_DEVICE,
   1454 					      &wsmuxdata, flag, l));
   1455 		default:
   1456 			return (EINVAL);
   1457 		}
   1458 #undef d
   1459 #endif
   1460 
   1461 	case WSMUXIO_ADD_DEVICE:
   1462 #define d ((struct wsmux_device *)data)
   1463 		if (d->idx == -1 && d->type == WSMUX_KBD)
   1464 			d->idx = wskbd_pickfree();
   1465 #undef d
   1466 		/* fall into */
   1467 	case WSMUXIO_INJECTEVENT:
   1468 	case WSMUXIO_REMOVE_DEVICE:
   1469 	case WSMUXIO_LIST_DEVICES:
   1470 		inp = sc->sc_input;
   1471 		if (inp == NULL)
   1472 			return (ENXIO);
   1473 		return (wsevsrc_ioctl(inp, cmd, data, flag, l));
   1474 #endif /* NWSKBD > 0 */
   1475 
   1476 	}
   1477 	return (EPASSTHROUGH);
   1478 }
   1479 
   1480 int
   1481 wsdisplay_stat_inject(device_t dv, u_int type, int value)
   1482 {
   1483 	struct wsdisplay_softc *sc = device_private(dv);
   1484 	struct wseventvar *evar;
   1485 	struct wscons_event event;
   1486 
   1487 	evar = &sc->evar;
   1488 
   1489 	if (evar == NULL)
   1490 		return (0);
   1491 
   1492 	if (evar->q == NULL)
   1493 		return (1);
   1494 
   1495 	event.type = type;
   1496 	event.value = value;
   1497 	if (wsevent_inject(evar, &event, 1) != 0) {
   1498 		log(LOG_WARNING, "wsdisplay: event queue overflow\n");
   1499 		return (1);
   1500 	}
   1501 
   1502 	return (0);
   1503 }
   1504 
   1505 paddr_t
   1506 wsdisplaymmap(dev_t dev, off_t offset, int prot)
   1507 {
   1508 	struct wsdisplay_softc *sc;
   1509 	struct wsscreen *scr;
   1510 
   1511 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
   1512 
   1513 	if (ISWSDISPLAYSTAT(dev))
   1514 		return (-1);
   1515 
   1516 	if (ISWSDISPLAYCTL(dev))
   1517 		return (-1);
   1518 
   1519 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
   1520 		return (-1);
   1521 
   1522 	if (!(scr->scr_flags & SCR_GRAPHICS))
   1523 		return (-1);
   1524 
   1525 	/* pass mmap to display */
   1526 	return ((*sc->sc_accessops->mmap)(sc->sc_accesscookie,
   1527 	    scr->scr_dconf->emulcookie, offset, prot));
   1528 }
   1529 
   1530 void
   1531 wsdisplaystart(struct tty *tp)
   1532 {
   1533 	struct wsdisplay_softc *sc;
   1534 	struct wsscreen *scr;
   1535 	int s, n;
   1536 	u_char *tbuf;
   1537 
   1538 	s = spltty();
   1539 	if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {
   1540 		splx(s);
   1541 		return;
   1542 	}
   1543 	sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(tp->t_dev));
   1544 	if ((scr = sc->sc_scr[WSDISPLAYSCREEN(tp->t_dev)]) == NULL) {
   1545 		splx(s);
   1546 		return;
   1547 	}
   1548 
   1549 	if (scr->scr_hold_screen) {
   1550 		tp->t_state |= TS_TIMEOUT;
   1551 		splx(s);
   1552 		return;
   1553 	}
   1554 	tp->t_state |= TS_BUSY;
   1555 	splx(s);
   1556 
   1557 #ifdef DIAGNOSTIC
   1558 	scr->scr_in_ttyoutput = 1;
   1559 #endif
   1560 
   1561 	/*
   1562 	 * Drain output from ring buffer.
   1563 	 * The output will normally be in one contiguous chunk, but when the
   1564 	 * ring wraps, it will be in two pieces.. one at the end of the ring,
   1565 	 * the other at the start.  For performance, rather than loop here,
   1566 	 * we output one chunk, see if there's another one, and if so, output
   1567 	 * it too.
   1568 	 */
   1569 
   1570 	n = ndqb(&tp->t_outq, 0);
   1571 	tbuf = tp->t_outq.c_cf;
   1572 
   1573 	if (!(scr->scr_flags & SCR_GRAPHICS)) {
   1574 		KASSERT(WSSCREEN_HAS_EMULATOR(scr));
   1575 		(*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
   1576 						  tbuf, n, 0);
   1577 	}
   1578 	ndflush(&tp->t_outq, n);
   1579 
   1580 	if ((n = ndqb(&tp->t_outq, 0)) > 0) {
   1581 		tbuf = tp->t_outq.c_cf;
   1582 
   1583 		if (!(scr->scr_flags & SCR_GRAPHICS)) {
   1584 			KASSERT(WSSCREEN_HAS_EMULATOR(scr));
   1585 			(*scr->scr_dconf->wsemul->output)
   1586 			    (scr->scr_dconf->wsemulcookie, tbuf, n, 0);
   1587 		}
   1588 		ndflush(&tp->t_outq, n);
   1589 	}
   1590 
   1591 #ifdef DIAGNOSTIC
   1592 	scr->scr_in_ttyoutput = 0;
   1593 #endif
   1594 
   1595 	s = spltty();
   1596 	tp->t_state &= ~TS_BUSY;
   1597 	/* Come back if there's more to do */
   1598 	if (ttypull(tp)) {
   1599 		tp->t_state |= TS_TIMEOUT;
   1600 		callout_schedule(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1);
   1601 	}
   1602 	splx(s);
   1603 }
   1604 
   1605 void
   1606 wsdisplaystop(struct tty *tp, int flag)
   1607 {
   1608 	int s;
   1609 
   1610 	s = spltty();
   1611 	if (ISSET(tp->t_state, TS_BUSY))
   1612 		if (!ISSET(tp->t_state, TS_TTSTOP))
   1613 			SET(tp->t_state, TS_FLUSH);
   1614 	splx(s);
   1615 }
   1616 
   1617 /* Set line parameters. */
   1618 int
   1619 wsdisplayparam(struct tty *tp, struct termios *t)
   1620 {
   1621 
   1622 	tp->t_ispeed = t->c_ispeed;
   1623 	tp->t_ospeed = t->c_ospeed;
   1624 	tp->t_cflag = t->c_cflag;
   1625 	return 0;
   1626 }
   1627 
   1628 /*
   1629  * Callbacks for the emulation code.
   1630  */
   1631 void
   1632 wsdisplay_emulbell(void *v)
   1633 {
   1634 	struct wsscreen *scr = v;
   1635 
   1636 	if (scr == NULL)		/* console, before real attach */
   1637 		return;
   1638 
   1639 	if (scr->scr_flags & SCR_GRAPHICS) /* can this happen? */
   1640 		return;
   1641 
   1642 	(void) wsdisplay_internal_ioctl(scr->sc, scr, WSKBDIO_BELL, NULL,
   1643 					FWRITE, NULL);
   1644 }
   1645 
   1646 void
   1647 wsdisplay_emulinput(void *v, const u_char *data, u_int count)
   1648 {
   1649 	struct wsscreen *scr = v;
   1650 	struct tty *tp;
   1651 	int (*ifcn)(int, struct tty *);
   1652 
   1653 	if (v == NULL)			/* console, before real attach */
   1654 		return;
   1655 
   1656 	if (scr->scr_flags & SCR_GRAPHICS) /* XXX can't happen */
   1657 		return;
   1658 	if (!WSSCREEN_HAS_TTY(scr))
   1659 		return;
   1660 
   1661 	tp = scr->scr_tty;
   1662 
   1663 	/*
   1664 	 * XXX bad hack to work around locking problems in tty.c:
   1665 	 * ttyinput() will try to lock again, causing deadlock.
   1666 	 * We assume that wsdisplay_emulinput() can only be called
   1667 	 * from within wsdisplaystart(), and thus the tty lock
   1668 	 * is already held. Use an entry point which doesn't lock.
   1669 	 */
   1670 	KASSERT(scr->scr_in_ttyoutput);
   1671 	ifcn = tp->t_linesw->l_rint;
   1672 	if (ifcn == ttyinput)
   1673 		ifcn = ttyinput_wlock;
   1674 
   1675 	while (count-- > 0)
   1676 		(*ifcn)(*data++, tp);
   1677 }
   1678 
   1679 /*
   1680  * Calls from the keyboard interface.
   1681  */
   1682 void
   1683 wsdisplay_kbdinput(device_t dv, keysym_t ks)
   1684 {
   1685 	struct wsdisplay_softc *sc = device_private(dv);
   1686 	struct wsscreen *scr;
   1687 	const char *dp;
   1688 	int count;
   1689 	struct tty *tp;
   1690 
   1691 	KASSERT(sc != NULL);
   1692 
   1693 	scr = sc->sc_focus;
   1694 
   1695 	if (!scr || !WSSCREEN_HAS_TTY(scr))
   1696 		return;
   1697 
   1698 	tp = scr->scr_tty;
   1699 
   1700 	if (KS_GROUP(ks) == KS_GROUP_Plain && KS_VALUE(ks) <= 0x7f)
   1701 		(*tp->t_linesw->l_rint)(KS_VALUE(ks), tp);
   1702 	else if (WSSCREEN_HAS_EMULATOR(scr)) {
   1703 		count = (*scr->scr_dconf->wsemul->translate)
   1704 		    (scr->scr_dconf->wsemulcookie, ks, &dp);
   1705 		while (count-- > 0)
   1706 			(*tp->t_linesw->l_rint)((unsigned char)(*dp++), tp);
   1707 	}
   1708 }
   1709 
   1710 #if defined(WSDISPLAY_COMPAT_RAWKBD)
   1711 int
   1712 wsdisplay_update_rawkbd(struct wsdisplay_softc *sc, struct wsscreen *scr)
   1713 {
   1714 #if NWSKBD > 0
   1715 	int s, raw, data, error;
   1716 	struct wsevsrc *inp;
   1717 
   1718 	s = spltty();
   1719 
   1720 	raw = (scr ? scr->scr_rawkbd : 0);
   1721 
   1722 	if (scr != sc->sc_focus ||
   1723 	    sc->sc_rawkbd == raw) {
   1724 		splx(s);
   1725 		return (0);
   1726 	}
   1727 
   1728 	data = raw ? WSKBD_RAW : WSKBD_TRANSLATED;
   1729 	inp = sc->sc_input;
   1730 	if (inp == NULL) {
   1731 		splx(s);
   1732 		return (ENXIO);
   1733 	}
   1734 	error = wsevsrc_display_ioctl(inp, WSKBDIO_SETMODE, &data, 0, 0);
   1735 	if (!error)
   1736 		sc->sc_rawkbd = raw;
   1737 	splx(s);
   1738 	return (error);
   1739 #else
   1740 	return (0);
   1741 #endif
   1742 }
   1743 #endif
   1744 
   1745 static void
   1746 wsdisplay_switch3_cb(void *arg, int error, int waitok)
   1747 {
   1748 	device_t dv = arg;
   1749 
   1750 	wsdisplay_switch3(dv, error, waitok);
   1751 }
   1752 
   1753 static int
   1754 wsdisplay_switch3(device_t dv, int error, int waitok)
   1755 {
   1756 	struct wsdisplay_softc *sc = device_private(dv);
   1757 	int no;
   1758 	struct wsscreen *scr;
   1759 
   1760 	if (!(sc->sc_flags & SC_SWITCHPENDING)) {
   1761 		aprint_error_dev(dv, "wsdisplay_switch3: not switching\n");
   1762 		return (EINVAL);
   1763 	}
   1764 
   1765 	no = sc->sc_screenwanted;
   1766 	if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
   1767 		panic("wsdisplay_switch3: invalid screen %d", no);
   1768 	scr = sc->sc_scr[no];
   1769 	if (!scr) {
   1770 		aprint_error_dev(dv,
   1771 		    "wsdisplay_switch3: screen %d disappeared\n", no);
   1772 		error = ENXIO;
   1773 	}
   1774 
   1775 	if (error) {
   1776 		/* try to recover, avoid recursion */
   1777 
   1778 		if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
   1779 			aprint_error_dev(dv, "wsdisplay_switch3: giving up\n");
   1780 			sc->sc_focus = 0;
   1781 #ifdef WSDISPLAY_COMPAT_RAWKBD
   1782 			wsdisplay_update_rawkbd(sc, 0);
   1783 #endif
   1784 			sc->sc_flags &= ~SC_SWITCHPENDING;
   1785 			return (error);
   1786 		}
   1787 
   1788 		sc->sc_screenwanted = sc->sc_oldscreen;
   1789 		sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
   1790 		return (wsdisplay_switch1(dv, 0, waitok));
   1791 	}
   1792 
   1793 	if (scr->scr_syncops && !error)
   1794 		sc->sc_flags |= SC_XATTACHED;
   1795 
   1796 	sc->sc_flags &= ~SC_SWITCHPENDING;
   1797 
   1798 	if (!error && (scr->scr_flags & SCR_WAITACTIVE))
   1799 		wakeup(scr);
   1800 	return (error);
   1801 }
   1802 
   1803 static void
   1804 wsdisplay_switch2_cb(void *arg, int error, int waitok)
   1805 {
   1806 	device_t dv = arg;
   1807 
   1808 	wsdisplay_switch2(dv, error, waitok);
   1809 }
   1810 
   1811 static int
   1812 wsdisplay_switch2(device_t dv, int error, int waitok)
   1813 {
   1814 	struct wsdisplay_softc *sc = device_private(dv);
   1815 	int no;
   1816 	struct wsscreen *scr;
   1817 
   1818 	if (!(sc->sc_flags & SC_SWITCHPENDING)) {
   1819 		aprint_error_dev(dv, "wsdisplay_switch2: not switching\n");
   1820 		return (EINVAL);
   1821 	}
   1822 
   1823 	no = sc->sc_screenwanted;
   1824 	if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
   1825 		panic("wsdisplay_switch2: invalid screen %d", no);
   1826 	scr = sc->sc_scr[no];
   1827 	if (!scr) {
   1828 		aprint_error_dev(dv,
   1829 		    "wsdisplay_switch2: screen %d disappeared\n", no);
   1830 		error = ENXIO;
   1831 	}
   1832 
   1833 	if (error) {
   1834 		/* try to recover, avoid recursion */
   1835 
   1836 		if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
   1837 			aprint_error_dev(dv, "wsdisplay_switch2: giving up\n");
   1838 			sc->sc_focus = 0;
   1839 			sc->sc_flags &= ~SC_SWITCHPENDING;
   1840 			return (error);
   1841 		}
   1842 
   1843 		sc->sc_screenwanted = sc->sc_oldscreen;
   1844 		sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
   1845 		return (wsdisplay_switch1(dv, 0, waitok));
   1846 	}
   1847 
   1848 	sc->sc_focusidx = no;
   1849 	sc->sc_focus = scr;
   1850 
   1851 #ifdef WSDISPLAY_COMPAT_RAWKBD
   1852 	(void) wsdisplay_update_rawkbd(sc, scr);
   1853 #endif
   1854 	/* keyboard map??? */
   1855 
   1856 	if (scr->scr_syncops &&
   1857 	    !(sc->sc_isconsole && wsdisplay_cons_pollmode)) {
   1858 		error = (*scr->scr_syncops->attach)(scr->scr_synccookie, waitok,
   1859 						    wsdisplay_switch3_cb, dv);
   1860 		if (error == EAGAIN) {
   1861 			/* switch will be done asynchronously */
   1862 			return (0);
   1863 		}
   1864 	}
   1865 
   1866 	return (wsdisplay_switch3(dv, error, waitok));
   1867 }
   1868 
   1869 static void
   1870 wsdisplay_switch1_cb(void *arg, int error, int waitok)
   1871 {
   1872 	device_t dv = arg;
   1873 
   1874 	wsdisplay_switch1(dv, error, waitok);
   1875 }
   1876 
   1877 static int
   1878 wsdisplay_switch1(device_t dv, int error, int waitok)
   1879 {
   1880 	struct wsdisplay_softc *sc = device_private(dv);
   1881 	int no;
   1882 	struct wsscreen *scr;
   1883 
   1884 	if (!(sc->sc_flags & SC_SWITCHPENDING)) {
   1885 		aprint_error_dev(dv, "wsdisplay_switch1: not switching\n");
   1886 		return (EINVAL);
   1887 	}
   1888 
   1889 	no = sc->sc_screenwanted;
   1890 	if (no == WSDISPLAY_NULLSCREEN) {
   1891 		sc->sc_flags &= ~SC_SWITCHPENDING;
   1892 		if (!error) {
   1893 			sc->sc_flags &= ~SC_XATTACHED;
   1894 			sc->sc_focus = 0;
   1895 		}
   1896 		wakeup(sc);
   1897 		return (error);
   1898 	}
   1899 	if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
   1900 		panic("wsdisplay_switch1: invalid screen %d", no);
   1901 	scr = sc->sc_scr[no];
   1902 	if (!scr) {
   1903 		aprint_error_dev(dv, "wsdisplay_switch1: screen %d disappeared\n", no);
   1904 		error = ENXIO;
   1905 	}
   1906 
   1907 	if (error) {
   1908 		sc->sc_flags &= ~SC_SWITCHPENDING;
   1909 		return (error);
   1910 	}
   1911 
   1912 	sc->sc_flags &= ~SC_XATTACHED;
   1913 
   1914 	error = (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
   1915 						 scr->scr_dconf->emulcookie,
   1916 						 waitok,
   1917 	  sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsdisplay_switch2_cb, dv);
   1918 	if (error == EAGAIN) {
   1919 		/* switch will be done asynchronously */
   1920 		return (0);
   1921 	}
   1922 
   1923 	return (wsdisplay_switch2(dv, error, waitok));
   1924 }
   1925 
   1926 int
   1927 wsdisplay_switch(device_t dv, int no, int waitok)
   1928 {
   1929 	struct wsdisplay_softc *sc = device_private(dv);
   1930 	int s, res = 0;
   1931 	struct wsscreen *scr;
   1932 
   1933 	if (no != WSDISPLAY_NULLSCREEN) {
   1934 		if ((no < 0 || no >= WSDISPLAY_MAXSCREEN))
   1935 			return (EINVAL);
   1936 		if (sc->sc_scr[no] == NULL)
   1937 			return (ENXIO);
   1938 	}
   1939 
   1940 	wsdisplay_stat_inject(dv, WSCONS_EVENT_SCREEN_SWITCH, no);
   1941 
   1942 	s = spltty();
   1943 
   1944 	if ((sc->sc_focus && no == sc->sc_focusidx) ||
   1945 	    (sc->sc_focus == NULL && no == WSDISPLAY_NULLSCREEN)) {
   1946 		splx(s);
   1947 		return (0);
   1948 	}
   1949 
   1950 	if (sc->sc_flags & SC_SWITCHPENDING) {
   1951 		splx(s);
   1952 		return (EBUSY);
   1953 	}
   1954 
   1955 	sc->sc_flags |= SC_SWITCHPENDING;
   1956 	sc->sc_screenwanted = no;
   1957 
   1958 	splx(s);
   1959 
   1960 	scr = sc->sc_focus;
   1961 	if (!scr) {
   1962 		sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
   1963 		return (wsdisplay_switch1(dv, 0, waitok));
   1964 	} else
   1965 		sc->sc_oldscreen = sc->sc_focusidx;
   1966 
   1967 	if (scr->scr_syncops) {
   1968 		if (!(sc->sc_flags & SC_XATTACHED) ||
   1969 		    (sc->sc_isconsole && wsdisplay_cons_pollmode)) {
   1970 			/* nothing to do here */
   1971 			return (wsdisplay_switch1(dv, 0, waitok));
   1972 		}
   1973 		res = (*scr->scr_syncops->detach)(scr->scr_synccookie, waitok,
   1974 						  wsdisplay_switch1_cb, dv);
   1975 		if (res == EAGAIN) {
   1976 			/* switch will be done asynchronously */
   1977 			return (0);
   1978 		}
   1979 	} else if (scr->scr_flags & SCR_GRAPHICS) {
   1980 		/* no way to save state */
   1981 		res = EBUSY;
   1982 	}
   1983 
   1984 	return (wsdisplay_switch1(dv, res, waitok));
   1985 }
   1986 
   1987 void
   1988 wsdisplay_reset(device_t dv, enum wsdisplay_resetops op)
   1989 {
   1990 	struct wsdisplay_softc *sc = device_private(dv);
   1991 	struct wsscreen *scr;
   1992 
   1993 	KASSERT(sc != NULL);
   1994 	scr = sc->sc_focus;
   1995 
   1996 	if (!scr)
   1997 		return;
   1998 
   1999 	switch (op) {
   2000 	case WSDISPLAY_RESETEMUL:
   2001 		if (!WSSCREEN_HAS_EMULATOR(scr))
   2002 			break;
   2003 		(*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
   2004 						 WSEMUL_RESET);
   2005 		break;
   2006 	case WSDISPLAY_RESETCLOSE:
   2007 		wsdisplay_closescreen(sc, scr);
   2008 		break;
   2009 	}
   2010 }
   2011 
   2012 /*
   2013  * Interface for (external) VT switch / process synchronization code
   2014  */
   2015 int
   2016 wsscreen_attach_sync(struct wsscreen *scr, const struct wscons_syncops *ops,
   2017 	void *cookie)
   2018 {
   2019 	if (scr->scr_syncops) {
   2020 		/*
   2021 		 * The screen is already claimed.
   2022 		 * Check if the owner is still alive.
   2023 		 */
   2024 		if ((*scr->scr_syncops->check)(scr->scr_synccookie))
   2025 			return (EBUSY);
   2026 	}
   2027 	scr->scr_syncops = ops;
   2028 	scr->scr_synccookie = cookie;
   2029 	if (scr == scr->sc->sc_focus)
   2030 		scr->sc->sc_flags |= SC_XATTACHED;
   2031 	return (0);
   2032 }
   2033 
   2034 int
   2035 wsscreen_detach_sync(struct wsscreen *scr)
   2036 {
   2037 	if (!scr->scr_syncops)
   2038 		return (EINVAL);
   2039 	scr->scr_syncops = 0;
   2040 	if (scr == scr->sc->sc_focus)
   2041 		scr->sc->sc_flags &= ~SC_XATTACHED;
   2042 	return (0);
   2043 }
   2044 
   2045 int
   2046 wsscreen_lookup_sync(struct wsscreen *scr,
   2047 	const struct wscons_syncops *ops, /* used as ID */
   2048 	void **cookiep)
   2049 {
   2050 	if (!scr->scr_syncops || ops != scr->scr_syncops)
   2051 		return (EINVAL);
   2052 	*cookiep = scr->scr_synccookie;
   2053 	return (0);
   2054 }
   2055 
   2056 /*
   2057  * Interface to virtual screen stuff
   2058  */
   2059 int
   2060 wsdisplay_maxscreenidx(struct wsdisplay_softc *sc)
   2061 {
   2062 	return (WSDISPLAY_MAXSCREEN - 1);
   2063 }
   2064 
   2065 int
   2066 wsdisplay_screenstate(struct wsdisplay_softc *sc, int idx)
   2067 {
   2068 	if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
   2069 		return (EINVAL);
   2070 	if (!sc->sc_scr[idx])
   2071 		return (ENXIO);
   2072 	return ((sc->sc_scr[idx]->scr_flags & SCR_OPEN) ? EBUSY : 0);
   2073 }
   2074 
   2075 int
   2076 wsdisplay_getactivescreen(struct wsdisplay_softc *sc)
   2077 {
   2078 	return (sc->sc_focus ? sc->sc_focusidx : WSDISPLAY_NULLSCREEN);
   2079 }
   2080 
   2081 int
   2082 wsscreen_switchwait(struct wsdisplay_softc *sc, int no)
   2083 {
   2084 	struct wsscreen *scr;
   2085 	int s, res = 0;
   2086 
   2087 	if (no == WSDISPLAY_NULLSCREEN) {
   2088 		s = spltty();
   2089 		while (sc->sc_focus && res == 0) {
   2090 			res = tsleep(sc, PCATCH, "wswait", 0);
   2091 		}
   2092 		splx(s);
   2093 		return (res);
   2094 	}
   2095 
   2096 	if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
   2097 		return (ENXIO);
   2098 	scr = sc->sc_scr[no];
   2099 	if (!scr)
   2100 		return (ENXIO);
   2101 
   2102 	s = spltty();
   2103 	if (scr != sc->sc_focus) {
   2104 		scr->scr_flags |= SCR_WAITACTIVE;
   2105 		res = tsleep(scr, PCATCH, "wswait", 0);
   2106 		if (scr != sc->sc_scr[no])
   2107 			res = ENXIO; /* disappeared in the meantime */
   2108 		else
   2109 			scr->scr_flags &= ~SCR_WAITACTIVE;
   2110 	}
   2111 	splx(s);
   2112 	return (res);
   2113 }
   2114 
   2115 void
   2116 wsdisplay_kbdholdscreen(device_t dv, int hold)
   2117 {
   2118 	struct wsdisplay_softc *sc = device_private(dv);
   2119 	struct wsscreen *scr;
   2120 
   2121 	scr = sc->sc_focus;
   2122 
   2123 	if (!scr)
   2124 		return;
   2125 
   2126 	if (hold)
   2127 		scr->scr_hold_screen = 1;
   2128 	else {
   2129 		scr->scr_hold_screen = 0;
   2130 		callout_schedule(&scr->scr_tty->t_rstrt_ch, 0);
   2131 	}
   2132 }
   2133 
   2134 #if NWSKBD > 0
   2135 void
   2136 wsdisplay_set_console_kbd(struct wsevsrc *src)
   2137 {
   2138 	if (wsdisplay_console_device == NULL) {
   2139 		src->me_dispdv = NULL;
   2140 		return;
   2141 	}
   2142 #if NWSMUX > 0
   2143 	if (wsmux_attach_sc((struct wsmux_softc *)
   2144 			    wsdisplay_console_device->sc_input, src)) {
   2145 		src->me_dispdv = NULL;
   2146 		return;
   2147 	}
   2148 #else
   2149 	wsdisplay_console_device->sc_input = src;
   2150 #endif
   2151 	src->me_dispdv = wsdisplay_console_device->sc_dev;
   2152 }
   2153 #endif /* NWSKBD > 0 */
   2154 
   2155 /*
   2156  * Console interface.
   2157  */
   2158 void
   2159 wsdisplay_cnputc(dev_t dev, int i)
   2160 {
   2161 	struct wsscreen_internal *dc;
   2162 	u_char c = i;
   2163 
   2164 	if (!wsdisplay_console_initted)
   2165 		return;
   2166 
   2167 	if ((wsdisplay_console_device != NULL) &&
   2168 	    (wsdisplay_console_device->sc_scr[0] != NULL) &&
   2169 	    (wsdisplay_console_device->sc_scr[0]->scr_flags & SCR_GRAPHICS))
   2170 		return;
   2171 
   2172 	dc = &wsdisplay_console_conf;
   2173 	(*dc->wsemul->output)(dc->wsemulcookie, &c, 1, 1);
   2174 }
   2175 
   2176 static int
   2177 wsdisplay_getc_dummy(dev_t dev)
   2178 {
   2179 	/* panic? */
   2180 	return (0);
   2181 }
   2182 
   2183 static void
   2184 wsdisplay_pollc(dev_t dev, int on)
   2185 {
   2186 
   2187 	wsdisplay_cons_pollmode = on;
   2188 
   2189 	/* notify to fb drivers */
   2190 	if (wsdisplay_console_device != NULL &&
   2191 	    wsdisplay_console_device->sc_accessops->pollc != NULL)
   2192 		(*wsdisplay_console_device->sc_accessops->pollc)
   2193 			(wsdisplay_console_device->sc_accesscookie, on);
   2194 
   2195 	/* notify to kbd drivers */
   2196 	if (wsdisplay_cons_kbd_pollc)
   2197 		(*wsdisplay_cons_kbd_pollc)(NODEV, on);
   2198 }
   2199 
   2200 void
   2201 wsdisplay_set_cons_kbd(int (*get)(dev_t), void (*poll)(dev_t, int),
   2202 	void (*bell)(dev_t, u_int, u_int, u_int))
   2203 {
   2204 	wsdisplay_cons.cn_getc = get;
   2205 	wsdisplay_cons.cn_bell = bell;
   2206 	wsdisplay_cons_kbd_pollc = poll;
   2207 }
   2208 
   2209 void
   2210 wsdisplay_unset_cons_kbd(void)
   2211 {
   2212 	wsdisplay_cons.cn_getc = wsdisplay_getc_dummy;
   2213 	wsdisplay_cons.cn_bell = NULL;
   2214 	wsdisplay_cons_kbd_pollc = 0;
   2215 }
   2216