xref: /freebsd/sys/dev/vt/vt_core.c (revision 9e5787d2284e187abb5b654d924394a65772e004)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2009, 2013 The FreeBSD Foundation
5  * All rights reserved.
6  *
7  * This software was developed by Ed Schouten under sponsorship from the
8  * FreeBSD Foundation.
9  *
10  * Portions of this software were developed by Oleksandr Rybalko
11  * under sponsorship from the FreeBSD Foundation.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37 
38 #include <sys/param.h>
39 #include <sys/consio.h>
40 #include <sys/eventhandler.h>
41 #include <sys/fbio.h>
42 #include <sys/kbio.h>
43 #include <sys/kdb.h>
44 #include <sys/kernel.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/mutex.h>
48 #include <sys/power.h>
49 #include <sys/priv.h>
50 #include <sys/proc.h>
51 #include <sys/random.h>
52 #include <sys/reboot.h>
53 #include <sys/systm.h>
54 #include <sys/terminal.h>
55 
56 #include <dev/kbd/kbdreg.h>
57 #include <dev/vt/vt.h>
58 
59 #if defined(__i386__) || defined(__amd64__)
60 #include <machine/psl.h>
61 #include <machine/frame.h>
62 #endif
63 
64 static tc_bell_t	vtterm_bell;
65 static tc_cursor_t	vtterm_cursor;
66 static tc_putchar_t	vtterm_putchar;
67 static tc_fill_t	vtterm_fill;
68 static tc_copy_t	vtterm_copy;
69 static tc_pre_input_t	vtterm_pre_input;
70 static tc_post_input_t	vtterm_post_input;
71 static tc_param_t	vtterm_param;
72 static tc_done_t	vtterm_done;
73 
74 static tc_cnprobe_t	vtterm_cnprobe;
75 static tc_cngetc_t	vtterm_cngetc;
76 
77 static tc_cngrab_t	vtterm_cngrab;
78 static tc_cnungrab_t	vtterm_cnungrab;
79 
80 static tc_opened_t	vtterm_opened;
81 static tc_ioctl_t	vtterm_ioctl;
82 static tc_mmap_t	vtterm_mmap;
83 
84 const struct terminal_class vt_termclass = {
85 	.tc_bell	= vtterm_bell,
86 	.tc_cursor	= vtterm_cursor,
87 	.tc_putchar	= vtterm_putchar,
88 	.tc_fill	= vtterm_fill,
89 	.tc_copy	= vtterm_copy,
90 	.tc_pre_input	= vtterm_pre_input,
91 	.tc_post_input	= vtterm_post_input,
92 	.tc_param	= vtterm_param,
93 	.tc_done	= vtterm_done,
94 
95 	.tc_cnprobe	= vtterm_cnprobe,
96 	.tc_cngetc	= vtterm_cngetc,
97 
98 	.tc_cngrab	= vtterm_cngrab,
99 	.tc_cnungrab	= vtterm_cnungrab,
100 
101 	.tc_opened	= vtterm_opened,
102 	.tc_ioctl	= vtterm_ioctl,
103 	.tc_mmap	= vtterm_mmap,
104 };
105 
106 /*
107  * Use a constant timer of 25 Hz to redraw the screen.
108  *
109  * XXX: In theory we should only fire up the timer when there is really
110  * activity. Unfortunately we cannot always start timers. We really
111  * don't want to process kernel messages synchronously, because it
112  * really slows down the system.
113  */
114 #define	VT_TIMERFREQ	25
115 
116 /* Bell pitch/duration. */
117 #define	VT_BELLDURATION	((5 * hz + 99) / 100)
118 #define	VT_BELLPITCH	800
119 
120 #define	VT_UNIT(vw)	((vw)->vw_device->vd_unit * VT_MAXWINDOWS + \
121 			(vw)->vw_number)
122 
123 static SYSCTL_NODE(_kern, OID_AUTO, vt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
124     "vt(9) parameters");
125 static VT_SYSCTL_INT(enable_altgr, 1, "Enable AltGr key (Do not assume R.Alt as Alt)");
126 static VT_SYSCTL_INT(enable_bell, 1, "Enable bell");
127 static VT_SYSCTL_INT(debug, 0, "vt(9) debug level");
128 static VT_SYSCTL_INT(deadtimer, 15, "Time to wait busy process in VT_PROCESS mode");
129 static VT_SYSCTL_INT(suspendswitch, 1, "Switch to VT0 before suspend");
130 
131 /* Allow to disable some keyboard combinations. */
132 static VT_SYSCTL_INT(kbd_halt, 1, "Enable halt keyboard combination.  "
133     "See kbdmap(5) to configure.");
134 static VT_SYSCTL_INT(kbd_poweroff, 1, "Enable Power Off keyboard combination.  "
135     "See kbdmap(5) to configure.");
136 static VT_SYSCTL_INT(kbd_reboot, 1, "Enable reboot keyboard combination.  "
137     "See kbdmap(5) to configure (typically Ctrl-Alt-Delete).");
138 static VT_SYSCTL_INT(kbd_debug, 1, "Enable key combination to enter debugger.  "
139     "See kbdmap(5) to configure (typically Ctrl-Alt-Esc).");
140 static VT_SYSCTL_INT(kbd_panic, 0, "Enable request to panic.  "
141     "See kbdmap(5) to configure.");
142 
143 /* Used internally, not a tunable. */
144 int vt_draw_logo_cpus;
145 VT_SYSCTL_INT(splash_cpu, 0, "Show logo CPUs during boot");
146 VT_SYSCTL_INT(splash_ncpu, 0, "Override number of logos displayed "
147     "(0 = do not override)");
148 VT_SYSCTL_INT(splash_cpu_style, 2, "Draw logo style "
149     "(0 = Alternate beastie, 1 = Beastie, 2 = Orb)");
150 VT_SYSCTL_INT(splash_cpu_duration, 10, "Hide logos after (seconds)");
151 
152 static unsigned int vt_unit = 0;
153 static MALLOC_DEFINE(M_VT, "vt", "vt device");
154 struct vt_device *main_vd = &vt_consdev;
155 
156 /* Boot logo. */
157 extern unsigned int vt_logo_width;
158 extern unsigned int vt_logo_height;
159 extern unsigned int vt_logo_depth;
160 extern unsigned char vt_logo_image[];
161 #ifndef DEV_SPLASH
162 #define	vtterm_draw_cpu_logos(...)	do {} while (0)
163 const unsigned int vt_logo_sprite_height;
164 #endif
165 
166 /* Font. */
167 extern struct vt_font vt_font_default;
168 #ifndef SC_NO_CUTPASTE
169 extern struct vt_mouse_cursor vt_default_mouse_pointer;
170 #endif
171 
172 static int signal_vt_rel(struct vt_window *);
173 static int signal_vt_acq(struct vt_window *);
174 static int finish_vt_rel(struct vt_window *, int, int *);
175 static int finish_vt_acq(struct vt_window *);
176 static int vt_window_switch(struct vt_window *);
177 static int vt_late_window_switch(struct vt_window *);
178 static int vt_proc_alive(struct vt_window *);
179 static void vt_resize(struct vt_device *);
180 static void vt_update_static(void *);
181 #ifndef SC_NO_CUTPASTE
182 static void vt_mouse_paste(void);
183 #endif
184 static void vt_suspend_handler(void *priv);
185 static void vt_resume_handler(void *priv);
186 
187 SET_DECLARE(vt_drv_set, struct vt_driver);
188 
189 #define	_VTDEFH	MAX(100, PIXEL_HEIGHT(VT_FB_MAX_HEIGHT))
190 #define	_VTDEFW	MAX(200, PIXEL_WIDTH(VT_FB_MAX_WIDTH))
191 
192 struct terminal	vt_consterm;
193 static struct vt_window	vt_conswindow;
194 #ifndef SC_NO_CONSDRAWN
195 static term_char_t vt_consdrawn[PIXEL_HEIGHT(VT_FB_MAX_HEIGHT) * PIXEL_WIDTH(VT_FB_MAX_WIDTH)];
196 static term_color_t vt_consdrawnfg[PIXEL_HEIGHT(VT_FB_MAX_HEIGHT) * PIXEL_WIDTH(VT_FB_MAX_WIDTH)];
197 static term_color_t vt_consdrawnbg[PIXEL_HEIGHT(VT_FB_MAX_HEIGHT) * PIXEL_WIDTH(VT_FB_MAX_WIDTH)];
198 #endif
199 struct vt_device	vt_consdev = {
200 	.vd_driver = NULL,
201 	.vd_softc = NULL,
202 	.vd_prev_driver = NULL,
203 	.vd_prev_softc = NULL,
204 	.vd_flags = VDF_INVALID,
205 	.vd_windows = { [VT_CONSWINDOW] =  &vt_conswindow, },
206 	.vd_curwindow = &vt_conswindow,
207 	.vd_kbstate = 0,
208 
209 #ifndef SC_NO_CUTPASTE
210 	.vd_pastebuf = {
211 		.vpb_buf = NULL,
212 		.vpb_bufsz = 0,
213 		.vpb_len = 0
214 	},
215 	.vd_mcursor = &vt_default_mouse_pointer,
216 	.vd_mcursor_fg = TC_WHITE,
217 	.vd_mcursor_bg = TC_BLACK,
218 #endif
219 
220 #ifndef SC_NO_CONSDRAWN
221 	.vd_drawn = vt_consdrawn,
222 	.vd_drawnfg = vt_consdrawnfg,
223 	.vd_drawnbg = vt_consdrawnbg,
224 #endif
225 };
226 static term_char_t vt_constextbuf[(_VTDEFW) * (VBF_DEFAULT_HISTORY_SIZE)];
227 static term_char_t *vt_constextbufrows[VBF_DEFAULT_HISTORY_SIZE];
228 static struct vt_window	vt_conswindow = {
229 	.vw_number = VT_CONSWINDOW,
230 	.vw_flags = VWF_CONSOLE,
231 	.vw_buf = {
232 		.vb_buffer = &vt_constextbuf[0],
233 		.vb_rows = &vt_constextbufrows[0],
234 		.vb_history_size = VBF_DEFAULT_HISTORY_SIZE,
235 		.vb_curroffset = 0,
236 		.vb_roffset = 0,
237 		.vb_flags = VBF_STATIC,
238 		.vb_mark_start = {.tp_row = 0, .tp_col = 0,},
239 		.vb_mark_end = {.tp_row = 0, .tp_col = 0,},
240 		.vb_scr_size = {
241 			.tp_row = _VTDEFH,
242 			.tp_col = _VTDEFW,
243 		},
244 	},
245 	.vw_device = &vt_consdev,
246 	.vw_terminal = &vt_consterm,
247 	.vw_kbdmode = K_XLATE,
248 	.vw_grabbed = 0,
249 };
250 struct terminal vt_consterm = {
251 	.tm_class = &vt_termclass,
252 	.tm_softc = &vt_conswindow,
253 	.tm_flags = TF_CONS,
254 };
255 static struct consdev vt_consterm_consdev = {
256 	.cn_ops = &termcn_cnops,
257 	.cn_arg = &vt_consterm,
258 	.cn_name = "ttyv0",
259 };
260 
261 /* Add to set of consoles. */
262 DATA_SET(cons_set, vt_consterm_consdev);
263 
264 /*
265  * Right after kmem is done to allow early drivers to use locking and allocate
266  * memory.
267  */
268 SYSINIT(vt_update_static, SI_SUB_KMEM, SI_ORDER_ANY, vt_update_static,
269     &vt_consdev);
270 /* Delay until all devices attached, to not waste time. */
271 SYSINIT(vt_early_cons, SI_SUB_INT_CONFIG_HOOKS, SI_ORDER_ANY, vt_upgrade,
272     &vt_consdev);
273 
274 /* Initialize locks/mem depended members. */
275 static void
276 vt_update_static(void *dummy)
277 {
278 
279 	if (!vty_enabled(VTY_VT))
280 		return;
281 	if (main_vd->vd_driver != NULL)
282 		printf("VT(%s): %s %ux%u\n", main_vd->vd_driver->vd_name,
283 		    (main_vd->vd_flags & VDF_TEXTMODE) ? "text" : "resolution",
284 		    main_vd->vd_width, main_vd->vd_height);
285 	else
286 		printf("VT: init without driver.\n");
287 
288 	mtx_init(&main_vd->vd_lock, "vtdev", NULL, MTX_DEF);
289 	cv_init(&main_vd->vd_winswitch, "vtwswt");
290 }
291 
292 static void
293 vt_schedule_flush(struct vt_device *vd, int ms)
294 {
295 
296 	if (ms <= 0)
297 		/* Default to initial value. */
298 		ms = 1000 / VT_TIMERFREQ;
299 
300 	callout_schedule(&vd->vd_timer, hz / (1000 / ms));
301 }
302 
303 void
304 vt_resume_flush_timer(struct vt_window *vw, int ms)
305 {
306 	struct vt_device *vd = vw->vw_device;
307 
308 	if (vd->vd_curwindow != vw)
309 		return;
310 
311 	if (!(vd->vd_flags & VDF_ASYNC) ||
312 	    !atomic_cmpset_int(&vd->vd_timer_armed, 0, 1))
313 		return;
314 
315 	vt_schedule_flush(vd, ms);
316 }
317 
318 static void
319 vt_suspend_flush_timer(struct vt_device *vd)
320 {
321 	/*
322 	 * As long as this function is called locked, callout_stop()
323 	 * has the same effect like callout_drain() with regard to
324 	 * preventing the callback function from executing.
325 	 */
326 	VT_LOCK_ASSERT(vd, MA_OWNED);
327 
328 	if (!(vd->vd_flags & VDF_ASYNC) ||
329 	    !atomic_cmpset_int(&vd->vd_timer_armed, 1, 0))
330 		return;
331 
332 	callout_stop(&vd->vd_timer);
333 }
334 
335 static void
336 vt_switch_timer(void *arg)
337 {
338 
339 	(void)vt_late_window_switch((struct vt_window *)arg);
340 }
341 
342 static int
343 vt_save_kbd_mode(struct vt_window *vw, keyboard_t *kbd)
344 {
345 	int mode, ret;
346 
347 	mode = 0;
348 	ret = kbdd_ioctl(kbd, KDGKBMODE, (caddr_t)&mode);
349 	if (ret == ENOIOCTL)
350 		ret = ENODEV;
351 	if (ret != 0)
352 		return (ret);
353 
354 	vw->vw_kbdmode = mode;
355 
356 	return (0);
357 }
358 
359 static int
360 vt_update_kbd_mode(struct vt_window *vw, keyboard_t *kbd)
361 {
362 	int ret;
363 
364 	ret = kbdd_ioctl(kbd, KDSKBMODE, (caddr_t)&vw->vw_kbdmode);
365 	if (ret == ENOIOCTL)
366 		ret = ENODEV;
367 
368 	return (ret);
369 }
370 
371 static int
372 vt_save_kbd_state(struct vt_window *vw, keyboard_t *kbd)
373 {
374 	int state, ret;
375 
376 	state = 0;
377 	ret = kbdd_ioctl(kbd, KDGKBSTATE, (caddr_t)&state);
378 	if (ret == ENOIOCTL)
379 		ret = ENODEV;
380 	if (ret != 0)
381 		return (ret);
382 
383 	vw->vw_kbdstate &= ~LOCK_MASK;
384 	vw->vw_kbdstate |= state & LOCK_MASK;
385 
386 	return (0);
387 }
388 
389 static int
390 vt_update_kbd_state(struct vt_window *vw, keyboard_t *kbd)
391 {
392 	int state, ret;
393 
394 	state = vw->vw_kbdstate & LOCK_MASK;
395 	ret = kbdd_ioctl(kbd, KDSKBSTATE, (caddr_t)&state);
396 	if (ret == ENOIOCTL)
397 		ret = ENODEV;
398 
399 	return (ret);
400 }
401 
402 static int
403 vt_save_kbd_leds(struct vt_window *vw, keyboard_t *kbd)
404 {
405 	int leds, ret;
406 
407 	leds = 0;
408 	ret = kbdd_ioctl(kbd, KDGETLED, (caddr_t)&leds);
409 	if (ret == ENOIOCTL)
410 		ret = ENODEV;
411 	if (ret != 0)
412 		return (ret);
413 
414 	vw->vw_kbdstate &= ~LED_MASK;
415 	vw->vw_kbdstate |= leds & LED_MASK;
416 
417 	return (0);
418 }
419 
420 static int
421 vt_update_kbd_leds(struct vt_window *vw, keyboard_t *kbd)
422 {
423 	int leds, ret;
424 
425 	leds = vw->vw_kbdstate & LED_MASK;
426 	ret = kbdd_ioctl(kbd, KDSETLED, (caddr_t)&leds);
427 	if (ret == ENOIOCTL)
428 		ret = ENODEV;
429 
430 	return (ret);
431 }
432 
433 static int
434 vt_window_preswitch(struct vt_window *vw, struct vt_window *curvw)
435 {
436 
437 	DPRINTF(40, "%s\n", __func__);
438 	curvw->vw_switch_to = vw;
439 	/* Set timer to allow switch in case when process hang. */
440 	callout_reset(&vw->vw_proc_dead_timer, hz * vt_deadtimer,
441 	    vt_switch_timer, (void *)vw);
442 	/* Notify process about vt switch attempt. */
443 	DPRINTF(30, "%s: Notify process.\n", __func__);
444 	signal_vt_rel(curvw);
445 
446 	return (0);
447 }
448 
449 static int
450 vt_window_postswitch(struct vt_window *vw)
451 {
452 
453 	signal_vt_acq(vw);
454 	return (0);
455 }
456 
457 /* vt_late_window_switch will do VT switching for regular case. */
458 static int
459 vt_late_window_switch(struct vt_window *vw)
460 {
461 	struct vt_window *curvw;
462 	int ret;
463 
464 	callout_stop(&vw->vw_proc_dead_timer);
465 
466 	ret = vt_window_switch(vw);
467 	if (ret != 0) {
468 		/*
469 		 * If the switch hasn't happened, then return the VT
470 		 * to the current owner, if any.
471 		 */
472 		curvw = vw->vw_device->vd_curwindow;
473 		if (curvw->vw_smode.mode == VT_PROCESS)
474 			(void)vt_window_postswitch(curvw);
475 		return (ret);
476 	}
477 
478 	/* Notify owner process about terminal availability. */
479 	if (vw->vw_smode.mode == VT_PROCESS) {
480 		ret = vt_window_postswitch(vw);
481 	}
482 	return (ret);
483 }
484 
485 /* Switch window. */
486 static int
487 vt_proc_window_switch(struct vt_window *vw)
488 {
489 	struct vt_window *curvw;
490 	struct vt_device *vd;
491 	int ret;
492 
493 	/* Prevent switching to NULL */
494 	if (vw == NULL) {
495 		DPRINTF(30, "%s: Cannot switch: vw is NULL.", __func__);
496 		return (EINVAL);
497 	}
498 	vd = vw->vw_device;
499 	curvw = vd->vd_curwindow;
500 
501 	/* Check if virtual terminal is locked */
502 	if (curvw->vw_flags & VWF_VTYLOCK)
503 		return (EBUSY);
504 
505 	/* Check if switch already in progress */
506 	if (curvw->vw_flags & VWF_SWWAIT_REL) {
507 		/* Check if switching to same window */
508 		if (curvw->vw_switch_to == vw) {
509 			DPRINTF(30, "%s: Switch in progress to same vw.", __func__);
510 			return (0);	/* success */
511 		}
512 		DPRINTF(30, "%s: Switch in progress to different vw.", __func__);
513 		return (EBUSY);
514 	}
515 
516 	/* Avoid switching to already selected window */
517 	if (vw == curvw) {
518 		DPRINTF(30, "%s: Cannot switch: vw == curvw.", __func__);
519 		return (0);	/* success */
520 	}
521 
522 	/*
523 	 * Early check for an attempt to switch to a non-functional VT.
524 	 * The same check is done in vt_window_switch(), but it's better
525 	 * to fail as early as possible to avoid needless pre-switch
526 	 * actions.
527 	 */
528 	VT_LOCK(vd);
529 	if ((vw->vw_flags & (VWF_OPENED|VWF_CONSOLE)) == 0) {
530 		VT_UNLOCK(vd);
531 		return (EINVAL);
532 	}
533 	VT_UNLOCK(vd);
534 
535 	/* Ask current process permission to switch away. */
536 	if (curvw->vw_smode.mode == VT_PROCESS) {
537 		DPRINTF(30, "%s: VT_PROCESS ", __func__);
538 		if (vt_proc_alive(curvw) == FALSE) {
539 			DPRINTF(30, "Dead. Cleaning.");
540 			/* Dead */
541 		} else {
542 			DPRINTF(30, "%s: Signaling process.\n", __func__);
543 			/* Alive, try to ask him. */
544 			ret = vt_window_preswitch(vw, curvw);
545 			/* Wait for process answer or timeout. */
546 			return (ret);
547 		}
548 		DPRINTF(30, "\n");
549 	}
550 
551 	ret = vt_late_window_switch(vw);
552 	return (ret);
553 }
554 
555 /* Switch window ignoring process locking. */
556 static int
557 vt_window_switch(struct vt_window *vw)
558 {
559 	struct vt_device *vd = vw->vw_device;
560 	struct vt_window *curvw = vd->vd_curwindow;
561 	keyboard_t *kbd;
562 
563 	if (kdb_active) {
564 		/*
565 		 * When grabbing the console for the debugger, avoid
566 		 * locks as that can result in deadlock.  While this
567 		 * could use try locks, that wouldn't really make a
568 		 * difference as there are sufficient barriers in
569 		 * debugger entry/exit to be equivalent to
570 		 * successfully try-locking here.
571 		 */
572 		if (curvw == vw)
573 			return (0);
574 		if (!(vw->vw_flags & (VWF_OPENED|VWF_CONSOLE)))
575 			return (EINVAL);
576 
577 		vd->vd_curwindow = vw;
578 		vd->vd_flags |= VDF_INVALID;
579 		if (vd->vd_driver->vd_postswitch)
580 			vd->vd_driver->vd_postswitch(vd);
581 		return (0);
582 	}
583 
584 	VT_LOCK(vd);
585 	if (curvw == vw) {
586 		/* Nothing to do. */
587 		VT_UNLOCK(vd);
588 		return (0);
589 	}
590 	if (!(vw->vw_flags & (VWF_OPENED|VWF_CONSOLE))) {
591 		VT_UNLOCK(vd);
592 		return (EINVAL);
593 	}
594 
595 	vt_suspend_flush_timer(vd);
596 
597 	vd->vd_curwindow = vw;
598 	vd->vd_flags |= VDF_INVALID;
599 	cv_broadcast(&vd->vd_winswitch);
600 	VT_UNLOCK(vd);
601 
602 	if (vd->vd_driver->vd_postswitch)
603 		vd->vd_driver->vd_postswitch(vd);
604 
605 	vt_resume_flush_timer(vw, 0);
606 
607 	/* Restore per-window keyboard mode. */
608 	mtx_lock(&Giant);
609 	if ((kbd = vd->vd_keyboard) != NULL) {
610 		if (curvw->vw_kbdmode == K_XLATE)
611 			vt_save_kbd_state(curvw, kbd);
612 
613 		vt_update_kbd_mode(vw, kbd);
614 		vt_update_kbd_state(vw, kbd);
615 	}
616 	mtx_unlock(&Giant);
617 	DPRINTF(10, "%s(ttyv%d) done\n", __func__, vw->vw_number);
618 
619 	return (0);
620 }
621 
622 void
623 vt_termsize(struct vt_device *vd, struct vt_font *vf, term_pos_t *size)
624 {
625 
626 	size->tp_row = vd->vd_height;
627 	if (vt_draw_logo_cpus)
628 		size->tp_row -= vt_logo_sprite_height;
629 	size->tp_col = vd->vd_width;
630 	if (vf != NULL) {
631 		size->tp_row /= vf->vf_height;
632 		size->tp_col /= vf->vf_width;
633 	}
634 }
635 
636 static inline void
637 vt_termrect(struct vt_device *vd, struct vt_font *vf, term_rect_t *rect)
638 {
639 
640 	rect->tr_begin.tp_row = rect->tr_begin.tp_col = 0;
641 	if (vt_draw_logo_cpus)
642 		rect->tr_begin.tp_row = vt_logo_sprite_height;
643 
644 	rect->tr_end.tp_row = vd->vd_height;
645 	rect->tr_end.tp_col = vd->vd_width;
646 
647 	if (vf != NULL) {
648 		rect->tr_begin.tp_row =
649 		    howmany(rect->tr_begin.tp_row, vf->vf_height);
650 
651 		rect->tr_end.tp_row /= vf->vf_height;
652 		rect->tr_end.tp_col /= vf->vf_width;
653 	}
654 }
655 
656 void
657 vt_winsize(struct vt_device *vd, struct vt_font *vf, struct winsize *size)
658 {
659 
660 	size->ws_ypixel = vd->vd_height;
661 	if (vt_draw_logo_cpus)
662 		size->ws_ypixel -= vt_logo_sprite_height;
663 	size->ws_row = size->ws_ypixel;
664 	size->ws_col = size->ws_xpixel = vd->vd_width;
665 	if (vf != NULL) {
666 		size->ws_row /= vf->vf_height;
667 		size->ws_col /= vf->vf_width;
668 	}
669 }
670 
671 void
672 vt_compute_drawable_area(struct vt_window *vw)
673 {
674 	struct vt_device *vd;
675 	struct vt_font *vf;
676 	vt_axis_t height;
677 
678 	vd = vw->vw_device;
679 
680 	if (vw->vw_font == NULL) {
681 		vw->vw_draw_area.tr_begin.tp_col = 0;
682 		vw->vw_draw_area.tr_begin.tp_row = 0;
683 		if (vt_draw_logo_cpus)
684 			vw->vw_draw_area.tr_begin.tp_row = vt_logo_sprite_height;
685 		vw->vw_draw_area.tr_end.tp_col = vd->vd_width;
686 		vw->vw_draw_area.tr_end.tp_row = vd->vd_height;
687 		return;
688 	}
689 
690 	vf = vw->vw_font;
691 
692 	/*
693 	 * Compute the drawable area, so that the text is centered on
694 	 * the screen.
695 	 */
696 
697 	height = vd->vd_height;
698 	if (vt_draw_logo_cpus)
699 		height -= vt_logo_sprite_height;
700 	vw->vw_draw_area.tr_begin.tp_col = (vd->vd_width % vf->vf_width) / 2;
701 	vw->vw_draw_area.tr_begin.tp_row = (height % vf->vf_height) / 2;
702 	if (vt_draw_logo_cpus)
703 		vw->vw_draw_area.tr_begin.tp_row += vt_logo_sprite_height;
704 	vw->vw_draw_area.tr_end.tp_col = vw->vw_draw_area.tr_begin.tp_col +
705 	    rounddown(vd->vd_width, vf->vf_width);
706 	vw->vw_draw_area.tr_end.tp_row = vw->vw_draw_area.tr_begin.tp_row +
707 	    rounddown(height, vf->vf_height);
708 }
709 
710 static void
711 vt_scroll(struct vt_window *vw, int offset, int whence)
712 {
713 	int diff;
714 	term_pos_t size;
715 
716 	if ((vw->vw_flags & VWF_SCROLL) == 0)
717 		return;
718 
719 	vt_termsize(vw->vw_device, vw->vw_font, &size);
720 
721 	diff = vthistory_seek(&vw->vw_buf, offset, whence);
722 	if (diff)
723 		vw->vw_device->vd_flags |= VDF_INVALID;
724 	vt_resume_flush_timer(vw, 0);
725 }
726 
727 static int
728 vt_machine_kbdevent(int c)
729 {
730 
731 	switch (c) {
732 	case SPCLKEY | DBG: /* kbdmap(5) keyword `debug`. */
733 		if (vt_kbd_debug)
734 			kdb_enter(KDB_WHY_BREAK, "manual escape to debugger");
735 		return (1);
736 	case SPCLKEY | HALT: /* kbdmap(5) keyword `halt`. */
737 		if (vt_kbd_halt)
738 			shutdown_nice(RB_HALT);
739 		return (1);
740 	case SPCLKEY | PASTE: /* kbdmap(5) keyword `paste`. */
741 #ifndef SC_NO_CUTPASTE
742 		/* Insert text from cut-paste buffer. */
743 		vt_mouse_paste();
744 #endif
745 		break;
746 	case SPCLKEY | PDWN: /* kbdmap(5) keyword `pdwn`. */
747 		if (vt_kbd_poweroff)
748 			shutdown_nice(RB_HALT|RB_POWEROFF);
749 		return (1);
750 	case SPCLKEY | PNC: /* kbdmap(5) keyword `panic`. */
751 		/*
752 		 * Request to immediate panic if sysctl
753 		 * kern.vt.enable_panic_key allow it.
754 		 */
755 		if (vt_kbd_panic)
756 			panic("Forced by the panic key");
757 		return (1);
758 	case SPCLKEY | RBT: /* kbdmap(5) keyword `boot`. */
759 		if (vt_kbd_reboot)
760 			shutdown_nice(RB_AUTOBOOT);
761 		return (1);
762 	case SPCLKEY | SPSC: /* kbdmap(5) keyword `spsc`. */
763 		/* Force activatation/deactivation of the screen saver. */
764 		/* TODO */
765 		return (1);
766 	case SPCLKEY | STBY: /* XXX Not present in kbdcontrol parser. */
767 		/* Put machine into Stand-By mode. */
768 		power_pm_suspend(POWER_SLEEP_STATE_STANDBY);
769 		return (1);
770 	case SPCLKEY | SUSP: /* kbdmap(5) keyword `susp`. */
771 		/* Suspend machine. */
772 		power_pm_suspend(POWER_SLEEP_STATE_SUSPEND);
773 		return (1);
774 	}
775 
776 	return (0);
777 }
778 
779 static void
780 vt_scrollmode_kbdevent(struct vt_window *vw, int c, int console)
781 {
782 	struct vt_device *vd;
783 	term_pos_t size;
784 
785 	vd = vw->vw_device;
786 	/* Only special keys handled in ScrollLock mode */
787 	if ((c & SPCLKEY) == 0)
788 		return;
789 
790 	c &= ~SPCLKEY;
791 
792 	if (console == 0) {
793 		if (c >= F_SCR && c <= MIN(L_SCR, F_SCR + VT_MAXWINDOWS - 1)) {
794 			vw = vd->vd_windows[c - F_SCR];
795 			vt_proc_window_switch(vw);
796 			return;
797 		}
798 		VT_LOCK(vd);
799 	}
800 
801 	switch (c) {
802 	case SLK: {
803 		/* Turn scrolling off. */
804 		vt_scroll(vw, 0, VHS_END);
805 		VTBUF_SLCK_DISABLE(&vw->vw_buf);
806 		vw->vw_flags &= ~VWF_SCROLL;
807 		break;
808 	}
809 	case FKEY | F(49): /* Home key. */
810 		vt_scroll(vw, 0, VHS_SET);
811 		break;
812 	case FKEY | F(50): /* Arrow up. */
813 		vt_scroll(vw, -1, VHS_CUR);
814 		break;
815 	case FKEY | F(51): /* Page up. */
816 		vt_termsize(vd, vw->vw_font, &size);
817 		vt_scroll(vw, -size.tp_row, VHS_CUR);
818 		break;
819 	case FKEY | F(57): /* End key. */
820 		vt_scroll(vw, 0, VHS_END);
821 		break;
822 	case FKEY | F(58): /* Arrow down. */
823 		vt_scroll(vw, 1, VHS_CUR);
824 		break;
825 	case FKEY | F(59): /* Page down. */
826 		vt_termsize(vd, vw->vw_font, &size);
827 		vt_scroll(vw, size.tp_row, VHS_CUR);
828 		break;
829 	}
830 
831 	if (console == 0)
832 		VT_UNLOCK(vd);
833 }
834 
835 static int
836 vt_processkey(keyboard_t *kbd, struct vt_device *vd, int c)
837 {
838 	struct vt_window *vw = vd->vd_curwindow;
839 
840 	random_harvest_queue(&c, sizeof(c), RANDOM_KEYBOARD);
841 #if VT_ALT_TO_ESC_HACK
842 	if (c & RELKEY) {
843 		switch (c & ~RELKEY) {
844 		case (SPCLKEY | RALT):
845 			if (vt_enable_altgr != 0)
846 				break;
847 		case (SPCLKEY | LALT):
848 			vd->vd_kbstate &= ~ALKED;
849 		}
850 		/* Other keys ignored for RELKEY event. */
851 		return (0);
852 	} else {
853 		switch (c & ~RELKEY) {
854 		case (SPCLKEY | RALT):
855 			if (vt_enable_altgr != 0)
856 				break;
857 		case (SPCLKEY | LALT):
858 			vd->vd_kbstate |= ALKED;
859 		}
860 	}
861 #else
862 	if (c & RELKEY)
863 		/* Other keys ignored for RELKEY event. */
864 		return (0);
865 #endif
866 
867 	if (vt_machine_kbdevent(c))
868 		return (0);
869 
870 	if (vw->vw_flags & VWF_SCROLL) {
871 		vt_scrollmode_kbdevent(vw, c, 0/* Not a console */);
872 		/* Scroll mode keys handled, nothing to do more. */
873 		return (0);
874 	}
875 
876 	if (c & SPCLKEY) {
877 		c &= ~SPCLKEY;
878 
879 		if (c >= F_SCR && c <= MIN(L_SCR, F_SCR + VT_MAXWINDOWS - 1)) {
880 			vw = vd->vd_windows[c - F_SCR];
881 			vt_proc_window_switch(vw);
882 			return (0);
883 		}
884 
885 		switch (c) {
886 		case NEXT:
887 			/* Switch to next VT. */
888 			c = (vw->vw_number + 1) % VT_MAXWINDOWS;
889 			vw = vd->vd_windows[c];
890 			vt_proc_window_switch(vw);
891 			return (0);
892 		case PREV:
893 			/* Switch to previous VT. */
894 			c = (vw->vw_number + VT_MAXWINDOWS - 1) % VT_MAXWINDOWS;
895 			vw = vd->vd_windows[c];
896 			vt_proc_window_switch(vw);
897 			return (0);
898 		case SLK: {
899 			vt_save_kbd_state(vw, kbd);
900 			VT_LOCK(vd);
901 			if (vw->vw_kbdstate & SLKED) {
902 				/* Turn scrolling on. */
903 				vw->vw_flags |= VWF_SCROLL;
904 				VTBUF_SLCK_ENABLE(&vw->vw_buf);
905 			} else {
906 				/* Turn scrolling off. */
907 				vw->vw_flags &= ~VWF_SCROLL;
908 				VTBUF_SLCK_DISABLE(&vw->vw_buf);
909 				vt_scroll(vw, 0, VHS_END);
910 			}
911 			VT_UNLOCK(vd);
912 			break;
913 		}
914 		case FKEY | F(1):  case FKEY | F(2):  case FKEY | F(3):
915 		case FKEY | F(4):  case FKEY | F(5):  case FKEY | F(6):
916 		case FKEY | F(7):  case FKEY | F(8):  case FKEY | F(9):
917 		case FKEY | F(10): case FKEY | F(11): case FKEY | F(12):
918 			/* F1 through F12 keys. */
919 			terminal_input_special(vw->vw_terminal,
920 			    TKEY_F1 + c - (FKEY | F(1)));
921 			break;
922 		case FKEY | F(49): /* Home key. */
923 			terminal_input_special(vw->vw_terminal, TKEY_HOME);
924 			break;
925 		case FKEY | F(50): /* Arrow up. */
926 			terminal_input_special(vw->vw_terminal, TKEY_UP);
927 			break;
928 		case FKEY | F(51): /* Page up. */
929 			terminal_input_special(vw->vw_terminal, TKEY_PAGE_UP);
930 			break;
931 		case FKEY | F(53): /* Arrow left. */
932 			terminal_input_special(vw->vw_terminal, TKEY_LEFT);
933 			break;
934 		case FKEY | F(55): /* Arrow right. */
935 			terminal_input_special(vw->vw_terminal, TKEY_RIGHT);
936 			break;
937 		case FKEY | F(57): /* End key. */
938 			terminal_input_special(vw->vw_terminal, TKEY_END);
939 			break;
940 		case FKEY | F(58): /* Arrow down. */
941 			terminal_input_special(vw->vw_terminal, TKEY_DOWN);
942 			break;
943 		case FKEY | F(59): /* Page down. */
944 			terminal_input_special(vw->vw_terminal, TKEY_PAGE_DOWN);
945 			break;
946 		case FKEY | F(60): /* Insert key. */
947 			terminal_input_special(vw->vw_terminal, TKEY_INSERT);
948 			break;
949 		case FKEY | F(61): /* Delete key. */
950 			terminal_input_special(vw->vw_terminal, TKEY_DELETE);
951 			break;
952 		}
953 	} else if (KEYFLAGS(c) == 0) {
954 		/* Don't do UTF-8 conversion when doing raw mode. */
955 		if (vw->vw_kbdmode == K_XLATE) {
956 #if VT_ALT_TO_ESC_HACK
957 			if (vd->vd_kbstate & ALKED) {
958 				/*
959 				 * Prepend ESC sequence if one of ALT keys down.
960 				 */
961 				terminal_input_char(vw->vw_terminal, 0x1b);
962 			}
963 #endif
964 #if defined(KDB)
965 			kdb_alt_break(c, &vd->vd_altbrk);
966 #endif
967 			terminal_input_char(vw->vw_terminal, KEYCHAR(c));
968 		} else
969 			terminal_input_raw(vw->vw_terminal, c);
970 	}
971 	return (0);
972 }
973 
974 static int
975 vt_kbdevent(keyboard_t *kbd, int event, void *arg)
976 {
977 	struct vt_device *vd = arg;
978 	int c;
979 
980 	switch (event) {
981 	case KBDIO_KEYINPUT:
982 		break;
983 	case KBDIO_UNLOADING:
984 		mtx_lock(&Giant);
985 		vd->vd_keyboard = NULL;
986 		kbd_release(kbd, (void *)vd);
987 		mtx_unlock(&Giant);
988 		return (0);
989 	default:
990 		return (EINVAL);
991 	}
992 
993 	while ((c = kbdd_read_char(kbd, 0)) != NOKEY)
994 		vt_processkey(kbd, vd, c);
995 
996 	return (0);
997 }
998 
999 static int
1000 vt_allocate_keyboard(struct vt_device *vd)
1001 {
1002 	int		 grabbed, i, idx0, idx;
1003 	keyboard_t	*k0, *k;
1004 	keyboard_info_t	 ki;
1005 
1006 	/*
1007 	 * If vt_upgrade() happens while the console is grabbed, we are
1008 	 * potentially going to switch keyboard devices while the keyboard is in
1009 	 * use. Unwind the grabbing of the current keyboard first, then we will
1010 	 * re-grab the new keyboard below, before we return.
1011 	 */
1012 	if (vd->vd_curwindow == &vt_conswindow) {
1013 		grabbed = vd->vd_curwindow->vw_grabbed;
1014 		for (i = 0; i < grabbed; ++i)
1015 			vtterm_cnungrab(vd->vd_curwindow->vw_terminal);
1016 	}
1017 
1018 	idx0 = kbd_allocate("kbdmux", -1, vd, vt_kbdevent, vd);
1019 	if (idx0 >= 0) {
1020 		DPRINTF(20, "%s: kbdmux allocated, idx = %d\n", __func__, idx0);
1021 		k0 = kbd_get_keyboard(idx0);
1022 
1023 		for (idx = kbd_find_keyboard2("*", -1, 0);
1024 		     idx != -1;
1025 		     idx = kbd_find_keyboard2("*", -1, idx + 1)) {
1026 			k = kbd_get_keyboard(idx);
1027 
1028 			if (idx == idx0 || KBD_IS_BUSY(k))
1029 				continue;
1030 
1031 			bzero(&ki, sizeof(ki));
1032 			strncpy(ki.kb_name, k->kb_name, sizeof(ki.kb_name));
1033 			ki.kb_name[sizeof(ki.kb_name) - 1] = '\0';
1034 			ki.kb_unit = k->kb_unit;
1035 
1036 			kbdd_ioctl(k0, KBADDKBD, (caddr_t) &ki);
1037 		}
1038 	} else {
1039 		DPRINTF(20, "%s: no kbdmux allocated\n", __func__);
1040 		idx0 = kbd_allocate("*", -1, vd, vt_kbdevent, vd);
1041 		if (idx0 < 0) {
1042 			DPRINTF(10, "%s: No keyboard found.\n", __func__);
1043 			return (-1);
1044 		}
1045 		k0 = kbd_get_keyboard(idx0);
1046 	}
1047 	vd->vd_keyboard = k0;
1048 	DPRINTF(20, "%s: vd_keyboard = %d\n", __func__,
1049 	    vd->vd_keyboard->kb_index);
1050 
1051 	if (vd->vd_curwindow == &vt_conswindow) {
1052 		for (i = 0; i < grabbed; ++i)
1053 			vtterm_cngrab(vd->vd_curwindow->vw_terminal);
1054 	}
1055 
1056 	return (idx0);
1057 }
1058 
1059 static void
1060 vtterm_bell(struct terminal *tm)
1061 {
1062 	struct vt_window *vw = tm->tm_softc;
1063 	struct vt_device *vd = vw->vw_device;
1064 
1065 	if (!vt_enable_bell)
1066 		return;
1067 
1068 	if (vd->vd_flags & VDF_QUIET_BELL)
1069 		return;
1070 
1071 	sysbeep(1193182 / VT_BELLPITCH, VT_BELLDURATION);
1072 }
1073 
1074 static void
1075 vtterm_beep(struct terminal *tm, u_int param)
1076 {
1077 	u_int freq, period;
1078 
1079 	if (!vt_enable_bell)
1080 		return;
1081 
1082 	if ((param == 0) || ((param & 0xffff) == 0)) {
1083 		vtterm_bell(tm);
1084 		return;
1085 	}
1086 
1087 	period = ((param >> 16) & 0xffff) * hz / 1000;
1088 	freq = 1193182 / (param & 0xffff);
1089 
1090 	sysbeep(freq, period);
1091 }
1092 
1093 static void
1094 vtterm_cursor(struct terminal *tm, const term_pos_t *p)
1095 {
1096 	struct vt_window *vw = tm->tm_softc;
1097 
1098 	vtbuf_cursor_position(&vw->vw_buf, p);
1099 }
1100 
1101 static void
1102 vtterm_putchar(struct terminal *tm, const term_pos_t *p, term_char_t c)
1103 {
1104 	struct vt_window *vw = tm->tm_softc;
1105 
1106 	vtbuf_putchar(&vw->vw_buf, p, c);
1107 }
1108 
1109 static void
1110 vtterm_fill(struct terminal *tm, const term_rect_t *r, term_char_t c)
1111 {
1112 	struct vt_window *vw = tm->tm_softc;
1113 
1114 	vtbuf_fill(&vw->vw_buf, r, c);
1115 }
1116 
1117 static void
1118 vtterm_copy(struct terminal *tm, const term_rect_t *r,
1119     const term_pos_t *p)
1120 {
1121 	struct vt_window *vw = tm->tm_softc;
1122 
1123 	vtbuf_copy(&vw->vw_buf, r, p);
1124 }
1125 
1126 static void
1127 vtterm_param(struct terminal *tm, int cmd, unsigned int arg)
1128 {
1129 	struct vt_window *vw = tm->tm_softc;
1130 
1131 	switch (cmd) {
1132 	case TP_SETLOCALCURSOR:
1133 		/*
1134 		 * 0 means normal (usually block), 1 means hidden, and
1135 		 * 2 means blinking (always block) for compatibility with
1136 		 * syscons.  We don't support any changes except hiding,
1137 		 * so must map 2 to 0.
1138 		 */
1139 		arg = (arg == 1) ? 0 : 1;
1140 		/* FALLTHROUGH */
1141 	case TP_SHOWCURSOR:
1142 		vtbuf_cursor_visibility(&vw->vw_buf, arg);
1143 		vt_resume_flush_timer(vw, 0);
1144 		break;
1145 	case TP_MOUSE:
1146 		vw->vw_mouse_level = arg;
1147 		break;
1148 	}
1149 }
1150 
1151 void
1152 vt_determine_colors(term_char_t c, int cursor,
1153     term_color_t *fg, term_color_t *bg)
1154 {
1155 	term_color_t tmp;
1156 	int invert;
1157 
1158 	invert = 0;
1159 
1160 	*fg = TCHAR_FGCOLOR(c);
1161 	if (TCHAR_FORMAT(c) & TF_BOLD)
1162 		*fg = TCOLOR_LIGHT(*fg);
1163 	*bg = TCHAR_BGCOLOR(c);
1164 	if (TCHAR_FORMAT(c) & TF_BLINK)
1165 		*bg = TCOLOR_LIGHT(*bg);
1166 
1167 	if (TCHAR_FORMAT(c) & TF_REVERSE)
1168 		invert ^= 1;
1169 	if (cursor)
1170 		invert ^= 1;
1171 
1172 	if (invert) {
1173 		tmp = *fg;
1174 		*fg = *bg;
1175 		*bg = tmp;
1176 	}
1177 }
1178 
1179 #ifndef SC_NO_CUTPASTE
1180 int
1181 vt_is_cursor_in_area(const struct vt_device *vd, const term_rect_t *area)
1182 {
1183 	unsigned int mx, my;
1184 
1185 	/*
1186 	 * We use the cursor position saved during the current refresh,
1187 	 * in case the cursor moved since.
1188 	 */
1189 	mx = vd->vd_mx_drawn + vd->vd_curwindow->vw_draw_area.tr_begin.tp_col;
1190 	my = vd->vd_my_drawn + vd->vd_curwindow->vw_draw_area.tr_begin.tp_row;
1191 
1192 	if (mx >= area->tr_end.tp_col ||
1193 	    mx + vd->vd_mcursor->width <= area->tr_begin.tp_col ||
1194 	    my >= area->tr_end.tp_row ||
1195 	    my + vd->vd_mcursor->height <= area->tr_begin.tp_row)
1196 		return (0);
1197 	return (1);
1198 }
1199 
1200 static void
1201 vt_mark_mouse_position_as_dirty(struct vt_device *vd, int locked)
1202 {
1203 	term_rect_t area;
1204 	struct vt_window *vw;
1205 	struct vt_font *vf;
1206 	int x, y;
1207 
1208 	vw = vd->vd_curwindow;
1209 	vf = vw->vw_font;
1210 
1211 	x = vd->vd_mx_drawn;
1212 	y = vd->vd_my_drawn;
1213 
1214 	if (vf != NULL) {
1215 		area.tr_begin.tp_col = x / vf->vf_width;
1216 		area.tr_begin.tp_row = y / vf->vf_height;
1217 		area.tr_end.tp_col =
1218 		    ((x + vd->vd_mcursor->width) / vf->vf_width) + 1;
1219 		area.tr_end.tp_row =
1220 		    ((y + vd->vd_mcursor->height) / vf->vf_height) + 1;
1221 	} else {
1222 		/*
1223 		 * No font loaded (ie. vt_vga operating in textmode).
1224 		 *
1225 		 * FIXME: This fake area needs to be revisited once the
1226 		 * mouse cursor is supported in vt_vga's textmode.
1227 		 */
1228 		area.tr_begin.tp_col = x;
1229 		area.tr_begin.tp_row = y;
1230 		area.tr_end.tp_col = x + 2;
1231 		area.tr_end.tp_row = y + 2;
1232 	}
1233 
1234 	if (!locked)
1235 		vtbuf_lock(&vw->vw_buf);
1236 	if (vd->vd_driver->vd_invalidate_text)
1237 		vd->vd_driver->vd_invalidate_text(vd, &area);
1238 	vtbuf_dirty(&vw->vw_buf, &area);
1239 	if (!locked)
1240 		vtbuf_unlock(&vw->vw_buf);
1241 }
1242 #endif
1243 
1244 static void
1245 vt_set_border(struct vt_device *vd, const term_rect_t *area,
1246     term_color_t c)
1247 {
1248 	vd_drawrect_t *drawrect = vd->vd_driver->vd_drawrect;
1249 
1250 	if (drawrect == NULL)
1251 		return;
1252 
1253 	/* Top bar */
1254 	if (area->tr_begin.tp_row > 0)
1255 		drawrect(vd, 0, 0, vd->vd_width - 1,
1256 		    area->tr_begin.tp_row - 1, 1, c);
1257 
1258 	/* Left bar */
1259 	if (area->tr_begin.tp_col > 0)
1260 		drawrect(vd, 0, area->tr_begin.tp_row,
1261 		    area->tr_begin.tp_col - 1, area->tr_end.tp_row - 1, 1, c);
1262 
1263 	/* Right bar */
1264 	if (area->tr_end.tp_col < vd->vd_width)
1265 		drawrect(vd, area->tr_end.tp_col, area->tr_begin.tp_row,
1266 		    vd->vd_width - 1, area->tr_end.tp_row - 1, 1, c);
1267 
1268 	/* Bottom bar */
1269 	if (area->tr_end.tp_row < vd->vd_height)
1270 		drawrect(vd, 0, area->tr_end.tp_row, vd->vd_width - 1,
1271 		    vd->vd_height - 1, 1, c);
1272 }
1273 
1274 static int
1275 vt_flush(struct vt_device *vd)
1276 {
1277 	struct vt_window *vw;
1278 	struct vt_font *vf;
1279 	term_rect_t tarea;
1280 #ifndef SC_NO_CUTPASTE
1281 	int cursor_was_shown, cursor_moved;
1282 #endif
1283 
1284 	vw = vd->vd_curwindow;
1285 	if (vw == NULL)
1286 		return (0);
1287 
1288 	if (vd->vd_flags & VDF_SPLASH || vw->vw_flags & VWF_BUSY)
1289 		return (0);
1290 
1291 	vf = vw->vw_font;
1292 	if (((vd->vd_flags & VDF_TEXTMODE) == 0) && (vf == NULL))
1293 		return (0);
1294 
1295 	vtbuf_lock(&vw->vw_buf);
1296 
1297 #ifndef SC_NO_CUTPASTE
1298 	cursor_was_shown = vd->vd_mshown;
1299 	cursor_moved = (vd->vd_mx != vd->vd_mx_drawn ||
1300 	    vd->vd_my != vd->vd_my_drawn);
1301 
1302 	/* Check if the cursor should be displayed or not. */
1303 	if ((vd->vd_flags & VDF_MOUSECURSOR) && /* Mouse support enabled. */
1304 	    !(vw->vw_flags & VWF_MOUSE_HIDE) && /* Cursor displayed.      */
1305 	    !kdb_active && !KERNEL_PANICKED()) {  /* DDB inactive.          */
1306 		vd->vd_mshown = 1;
1307 	} else {
1308 		vd->vd_mshown = 0;
1309 	}
1310 
1311 	/*
1312 	 * If the cursor changed display state or moved, we must mark
1313 	 * the old position as dirty, so that it's erased.
1314 	 */
1315 	if (cursor_was_shown != vd->vd_mshown ||
1316 	    (vd->vd_mshown && cursor_moved))
1317 		vt_mark_mouse_position_as_dirty(vd, true);
1318 
1319 	/*
1320          * Save position of the mouse cursor. It's used by backends to
1321          * know where to draw the cursor and during the next refresh to
1322          * erase the previous position.
1323 	 */
1324 	vd->vd_mx_drawn = vd->vd_mx;
1325 	vd->vd_my_drawn = vd->vd_my;
1326 
1327 	/*
1328 	 * If the cursor is displayed and has moved since last refresh,
1329 	 * mark the new position as dirty.
1330 	 */
1331 	if (vd->vd_mshown && cursor_moved)
1332 		vt_mark_mouse_position_as_dirty(vd, true);
1333 #endif
1334 
1335 	vtbuf_undirty(&vw->vw_buf, &tarea);
1336 
1337 	/* Force a full redraw when the screen contents might be invalid. */
1338 	if (vd->vd_flags & (VDF_INVALID | VDF_SUSPENDED)) {
1339 		const teken_attr_t *a;
1340 
1341 		vd->vd_flags &= ~VDF_INVALID;
1342 
1343 		a = teken_get_curattr(&vw->vw_terminal->tm_emulator);
1344 		vt_set_border(vd, &vw->vw_draw_area, a->ta_bgcolor);
1345 		vt_termrect(vd, vf, &tarea);
1346 		if (vd->vd_driver->vd_invalidate_text)
1347 			vd->vd_driver->vd_invalidate_text(vd, &tarea);
1348 		if (vt_draw_logo_cpus)
1349 			vtterm_draw_cpu_logos(vd);
1350 	}
1351 
1352 	if (tarea.tr_begin.tp_col < tarea.tr_end.tp_col) {
1353 		vd->vd_driver->vd_bitblt_text(vd, vw, &tarea);
1354 		vtbuf_unlock(&vw->vw_buf);
1355 		return (1);
1356 	}
1357 
1358 	vtbuf_unlock(&vw->vw_buf);
1359 	return (0);
1360 }
1361 
1362 static void
1363 vt_timer(void *arg)
1364 {
1365 	struct vt_device *vd;
1366 	int changed;
1367 
1368 	vd = arg;
1369 	/* Update screen if required. */
1370 	changed = vt_flush(vd);
1371 
1372 	/* Schedule for next update. */
1373 	if (changed)
1374 		vt_schedule_flush(vd, 0);
1375 	else
1376 		vd->vd_timer_armed = 0;
1377 }
1378 
1379 static void
1380 vtterm_pre_input(struct terminal *tm)
1381 {
1382 	struct vt_window *vw = tm->tm_softc;
1383 
1384 	vtbuf_lock(&vw->vw_buf);
1385 }
1386 
1387 static void
1388 vtterm_post_input(struct terminal *tm)
1389 {
1390 	struct vt_window *vw = tm->tm_softc;
1391 
1392 	vtbuf_unlock(&vw->vw_buf);
1393 	vt_resume_flush_timer(vw, 0);
1394 }
1395 
1396 static void
1397 vtterm_done(struct terminal *tm)
1398 {
1399 	struct vt_window *vw = tm->tm_softc;
1400 	struct vt_device *vd = vw->vw_device;
1401 
1402 	if (kdb_active || KERNEL_PANICKED()) {
1403 		/* Switch to the debugger. */
1404 		if (vd->vd_curwindow != vw) {
1405 			vd->vd_curwindow = vw;
1406 			vd->vd_flags |= VDF_INVALID;
1407 			if (vd->vd_driver->vd_postswitch)
1408 				vd->vd_driver->vd_postswitch(vd);
1409 		}
1410 		vd->vd_flags &= ~VDF_SPLASH;
1411 		vt_flush(vd);
1412 	} else if (!(vd->vd_flags & VDF_ASYNC)) {
1413 		vt_flush(vd);
1414 	}
1415 }
1416 
1417 #ifdef DEV_SPLASH
1418 static void
1419 vtterm_splash(struct vt_device *vd)
1420 {
1421 	vt_axis_t top, left;
1422 
1423 	/* Display a nice boot splash. */
1424 	if (!(vd->vd_flags & VDF_TEXTMODE) && (boothowto & RB_MUTE)) {
1425 
1426 		top = (vd->vd_height - vt_logo_height) / 2;
1427 		left = (vd->vd_width - vt_logo_width) / 2;
1428 		switch (vt_logo_depth) {
1429 		case 1:
1430 			/* XXX: Unhardcode colors! */
1431 			vd->vd_driver->vd_bitblt_bmp(vd, vd->vd_curwindow,
1432 			    vt_logo_image, NULL, vt_logo_width, vt_logo_height,
1433 			    left, top, TC_WHITE, TC_BLACK);
1434 		}
1435 		vd->vd_flags |= VDF_SPLASH;
1436 	}
1437 }
1438 #endif
1439 
1440 
1441 static void
1442 vtterm_cnprobe(struct terminal *tm, struct consdev *cp)
1443 {
1444 	struct vt_driver *vtd, **vtdlist, *vtdbest = NULL;
1445 	struct vt_window *vw = tm->tm_softc;
1446 	struct vt_device *vd = vw->vw_device;
1447 	struct winsize wsz;
1448 	const term_attr_t *a;
1449 
1450 	if (!vty_enabled(VTY_VT))
1451 		return;
1452 
1453 	if (vd->vd_flags & VDF_INITIALIZED)
1454 		/* Initialization already done. */
1455 		return;
1456 
1457 	SET_FOREACH(vtdlist, vt_drv_set) {
1458 		vtd = *vtdlist;
1459 		if (vtd->vd_probe == NULL)
1460 			continue;
1461 		if (vtd->vd_probe(vd) == CN_DEAD)
1462 			continue;
1463 		if ((vtdbest == NULL) ||
1464 		    (vtd->vd_priority > vtdbest->vd_priority))
1465 			vtdbest = vtd;
1466 	}
1467 	if (vtdbest == NULL) {
1468 		cp->cn_pri = CN_DEAD;
1469 		vd->vd_flags |= VDF_DEAD;
1470 	} else {
1471 		vd->vd_driver = vtdbest;
1472 		cp->cn_pri = vd->vd_driver->vd_init(vd);
1473 	}
1474 
1475 	/* Check if driver's vt_init return CN_DEAD. */
1476 	if (cp->cn_pri == CN_DEAD) {
1477 		vd->vd_flags |= VDF_DEAD;
1478 	}
1479 
1480 	/* Initialize any early-boot keyboard drivers */
1481 	kbd_configure(KB_CONF_PROBE_ONLY);
1482 
1483 	vd->vd_unit = atomic_fetchadd_int(&vt_unit, 1);
1484 	vd->vd_windows[VT_CONSWINDOW] = vw;
1485 	sprintf(cp->cn_name, "ttyv%r", VT_UNIT(vw));
1486 
1487 	/* Attach default font if not in TEXTMODE. */
1488 	if ((vd->vd_flags & VDF_TEXTMODE) == 0) {
1489 		vw->vw_font = vtfont_ref(&vt_font_default);
1490 		vt_compute_drawable_area(vw);
1491 	}
1492 
1493 	/*
1494 	 * The original screen size was faked (_VTDEFW x _VTDEFH). Now
1495 	 * that we have the real viewable size, fix it in the static
1496 	 * buffer.
1497 	 */
1498 	if (vd->vd_width != 0 && vd->vd_height != 0)
1499 		vt_termsize(vd, vw->vw_font, &vw->vw_buf.vb_scr_size);
1500 
1501 	/* We need to access terminal attributes from vtbuf */
1502 	vw->vw_buf.vb_terminal = tm;
1503 	vtbuf_init_early(&vw->vw_buf);
1504 	vt_winsize(vd, vw->vw_font, &wsz);
1505 	a = teken_get_curattr(&tm->tm_emulator);
1506 	terminal_set_winsize_blank(tm, &wsz, 1, a);
1507 
1508 	if (vtdbest != NULL) {
1509 #ifdef DEV_SPLASH
1510 		if (!vt_splash_cpu)
1511 			vtterm_splash(vd);
1512 #endif
1513 		vd->vd_flags |= VDF_INITIALIZED;
1514 	}
1515 }
1516 
1517 static int
1518 vtterm_cngetc(struct terminal *tm)
1519 {
1520 	struct vt_window *vw = tm->tm_softc;
1521 	struct vt_device *vd = vw->vw_device;
1522 	keyboard_t *kbd;
1523 	u_int c;
1524 
1525 	if (vw->vw_kbdsq && *vw->vw_kbdsq)
1526 		return (*vw->vw_kbdsq++);
1527 
1528 	/* Make sure the splash screen is not there. */
1529 	if (vd->vd_flags & VDF_SPLASH) {
1530 		/* Remove splash */
1531 		vd->vd_flags &= ~VDF_SPLASH;
1532 		/* Mark screen as invalid to force update */
1533 		vd->vd_flags |= VDF_INVALID;
1534 		vt_flush(vd);
1535 	}
1536 
1537 	/* Stripped down keyboard handler. */
1538 	if ((kbd = vd->vd_keyboard) == NULL)
1539 		return (-1);
1540 
1541 	/* Force keyboard input mode to K_XLATE */
1542 	vw->vw_kbdmode = K_XLATE;
1543 	vt_update_kbd_mode(vw, kbd);
1544 
1545 	/* Switch the keyboard to polling to make it work here. */
1546 	kbdd_poll(kbd, TRUE);
1547 	c = kbdd_read_char(kbd, 0);
1548 	kbdd_poll(kbd, FALSE);
1549 	if (c & RELKEY)
1550 		return (-1);
1551 
1552 	if (vw->vw_flags & VWF_SCROLL) {
1553 		vt_scrollmode_kbdevent(vw, c, 1/* Console mode */);
1554 		vt_flush(vd);
1555 		return (-1);
1556 	}
1557 
1558 	/* Stripped down handling of vt_kbdevent(), without locking, etc. */
1559 	if (c & SPCLKEY) {
1560 		switch (c) {
1561 		case SPCLKEY | SLK:
1562 			vt_save_kbd_state(vw, kbd);
1563 			if (vw->vw_kbdstate & SLKED) {
1564 				/* Turn scrolling on. */
1565 				vw->vw_flags |= VWF_SCROLL;
1566 				VTBUF_SLCK_ENABLE(&vw->vw_buf);
1567 			} else {
1568 				/* Turn scrolling off. */
1569 				vt_scroll(vw, 0, VHS_END);
1570 				vw->vw_flags &= ~VWF_SCROLL;
1571 				VTBUF_SLCK_DISABLE(&vw->vw_buf);
1572 			}
1573 			break;
1574 		/* XXX: KDB can handle history. */
1575 		case SPCLKEY | FKEY | F(50): /* Arrow up. */
1576 			vw->vw_kbdsq = "\x1b[A";
1577 			break;
1578 		case SPCLKEY | FKEY | F(58): /* Arrow down. */
1579 			vw->vw_kbdsq = "\x1b[B";
1580 			break;
1581 		case SPCLKEY | FKEY | F(55): /* Arrow right. */
1582 			vw->vw_kbdsq = "\x1b[C";
1583 			break;
1584 		case SPCLKEY | FKEY | F(53): /* Arrow left. */
1585 			vw->vw_kbdsq = "\x1b[D";
1586 			break;
1587 		}
1588 
1589 		/* Force refresh to make scrollback work. */
1590 		vt_flush(vd);
1591 	} else if (KEYFLAGS(c) == 0) {
1592 		return (KEYCHAR(c));
1593 	}
1594 
1595 	if (vw->vw_kbdsq && *vw->vw_kbdsq)
1596 		return (*vw->vw_kbdsq++);
1597 
1598 	return (-1);
1599 }
1600 
1601 static void
1602 vtterm_cngrab(struct terminal *tm)
1603 {
1604 	struct vt_device *vd;
1605 	struct vt_window *vw;
1606 	keyboard_t *kbd;
1607 
1608 	vw = tm->tm_softc;
1609 	vd = vw->vw_device;
1610 
1611 	if (!cold)
1612 		vt_window_switch(vw);
1613 
1614 	if ((kbd = vd->vd_keyboard) == NULL)
1615 		return;
1616 
1617 	if (vw->vw_grabbed++ > 0)
1618 		return;
1619 
1620 	/*
1621 	 * Make sure the keyboard is accessible even when the kbd device
1622 	 * driver is disabled.
1623 	 */
1624 	kbdd_enable(kbd);
1625 
1626 	/* We shall always use the keyboard in the XLATE mode here. */
1627 	vw->vw_prev_kbdmode = vw->vw_kbdmode;
1628 	vw->vw_kbdmode = K_XLATE;
1629 	vt_update_kbd_mode(vw, kbd);
1630 
1631 	kbdd_poll(kbd, TRUE);
1632 }
1633 
1634 static void
1635 vtterm_cnungrab(struct terminal *tm)
1636 {
1637 	struct vt_device *vd;
1638 	struct vt_window *vw;
1639 	keyboard_t *kbd;
1640 
1641 	vw = tm->tm_softc;
1642 	vd = vw->vw_device;
1643 
1644 	if ((kbd = vd->vd_keyboard) == NULL)
1645 		return;
1646 
1647 	if (--vw->vw_grabbed > 0)
1648 		return;
1649 
1650 	kbdd_poll(kbd, FALSE);
1651 
1652 	vw->vw_kbdmode = vw->vw_prev_kbdmode;
1653 	vt_update_kbd_mode(vw, kbd);
1654 	kbdd_disable(kbd);
1655 }
1656 
1657 static void
1658 vtterm_opened(struct terminal *tm, int opened)
1659 {
1660 	struct vt_window *vw = tm->tm_softc;
1661 	struct vt_device *vd = vw->vw_device;
1662 
1663 	VT_LOCK(vd);
1664 	vd->vd_flags &= ~VDF_SPLASH;
1665 	if (opened)
1666 		vw->vw_flags |= VWF_OPENED;
1667 	else {
1668 		vw->vw_flags &= ~VWF_OPENED;
1669 		/* TODO: finish ACQ/REL */
1670 	}
1671 	VT_UNLOCK(vd);
1672 }
1673 
1674 static int
1675 vt_change_font(struct vt_window *vw, struct vt_font *vf)
1676 {
1677 	struct vt_device *vd = vw->vw_device;
1678 	struct terminal *tm = vw->vw_terminal;
1679 	term_pos_t size;
1680 	struct winsize wsz;
1681 
1682 	/*
1683 	 * Changing fonts.
1684 	 *
1685 	 * Changing fonts is a little tricky.  We must prevent
1686 	 * simultaneous access to the device, so we must stop
1687 	 * the display timer and the terminal from accessing.
1688 	 * We need to switch fonts and grow our screen buffer.
1689 	 *
1690 	 * XXX: Right now the code uses terminal_mute() to
1691 	 * prevent data from reaching the console driver while
1692 	 * resizing the screen buffer.  This isn't elegant...
1693 	 */
1694 
1695 	VT_LOCK(vd);
1696 	if (vw->vw_flags & VWF_BUSY) {
1697 		/* Another process is changing the font. */
1698 		VT_UNLOCK(vd);
1699 		return (EBUSY);
1700 	}
1701 	vw->vw_flags |= VWF_BUSY;
1702 	VT_UNLOCK(vd);
1703 
1704 	vt_termsize(vd, vf, &size);
1705 	vt_winsize(vd, vf, &wsz);
1706 
1707 	/* Grow the screen buffer and terminal. */
1708 	terminal_mute(tm, 1);
1709 	vtbuf_grow(&vw->vw_buf, &size, vw->vw_buf.vb_history_size);
1710 	terminal_set_winsize_blank(tm, &wsz, 0, NULL);
1711 	terminal_set_cursor(tm, &vw->vw_buf.vb_cursor);
1712 	terminal_mute(tm, 0);
1713 
1714 	/* Actually apply the font to the current window. */
1715 	VT_LOCK(vd);
1716 	if (vw->vw_font != vf && vw->vw_font != NULL && vf != NULL) {
1717 		/*
1718 		 * In case vt_change_font called to update size we don't need
1719 		 * to update font link.
1720 		 */
1721 		vtfont_unref(vw->vw_font);
1722 		vw->vw_font = vtfont_ref(vf);
1723 	}
1724 
1725 	/*
1726 	 * Compute the drawable area and move the mouse cursor inside
1727 	 * it, in case the new area is smaller than the previous one.
1728 	 */
1729 	vt_compute_drawable_area(vw);
1730 	vd->vd_mx = min(vd->vd_mx,
1731 	    vw->vw_draw_area.tr_end.tp_col -
1732 	    vw->vw_draw_area.tr_begin.tp_col - 1);
1733 	vd->vd_my = min(vd->vd_my,
1734 	    vw->vw_draw_area.tr_end.tp_row -
1735 	    vw->vw_draw_area.tr_begin.tp_row - 1);
1736 
1737 	/* Force a full redraw the next timer tick. */
1738 	if (vd->vd_curwindow == vw) {
1739 		vd->vd_flags |= VDF_INVALID;
1740 		vt_resume_flush_timer(vw, 0);
1741 	}
1742 	vw->vw_flags &= ~VWF_BUSY;
1743 	VT_UNLOCK(vd);
1744 	return (0);
1745 }
1746 
1747 static int
1748 vt_proc_alive(struct vt_window *vw)
1749 {
1750 	struct proc *p;
1751 
1752 	if (vw->vw_smode.mode != VT_PROCESS)
1753 		return (FALSE);
1754 
1755 	if (vw->vw_proc) {
1756 		if ((p = pfind(vw->vw_pid)) != NULL)
1757 			PROC_UNLOCK(p);
1758 		if (vw->vw_proc == p)
1759 			return (TRUE);
1760 		vw->vw_proc = NULL;
1761 		vw->vw_smode.mode = VT_AUTO;
1762 		DPRINTF(1, "vt controlling process %d died\n", vw->vw_pid);
1763 		vw->vw_pid = 0;
1764 	}
1765 	return (FALSE);
1766 }
1767 
1768 static int
1769 signal_vt_rel(struct vt_window *vw)
1770 {
1771 
1772 	if (vw->vw_smode.mode != VT_PROCESS)
1773 		return (FALSE);
1774 	if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1775 		vw->vw_proc = NULL;
1776 		vw->vw_pid = 0;
1777 		return (TRUE);
1778 	}
1779 	vw->vw_flags |= VWF_SWWAIT_REL;
1780 	PROC_LOCK(vw->vw_proc);
1781 	kern_psignal(vw->vw_proc, vw->vw_smode.relsig);
1782 	PROC_UNLOCK(vw->vw_proc);
1783 	DPRINTF(1, "sending relsig to %d\n", vw->vw_pid);
1784 	return (TRUE);
1785 }
1786 
1787 static int
1788 signal_vt_acq(struct vt_window *vw)
1789 {
1790 
1791 	if (vw->vw_smode.mode != VT_PROCESS)
1792 		return (FALSE);
1793 	if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1794 		cnavailable(vw->vw_terminal->consdev, FALSE);
1795 	if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1796 		vw->vw_proc = NULL;
1797 		vw->vw_pid = 0;
1798 		return (TRUE);
1799 	}
1800 	vw->vw_flags |= VWF_SWWAIT_ACQ;
1801 	PROC_LOCK(vw->vw_proc);
1802 	kern_psignal(vw->vw_proc, vw->vw_smode.acqsig);
1803 	PROC_UNLOCK(vw->vw_proc);
1804 	DPRINTF(1, "sending acqsig to %d\n", vw->vw_pid);
1805 	return (TRUE);
1806 }
1807 
1808 static int
1809 finish_vt_rel(struct vt_window *vw, int release, int *s)
1810 {
1811 
1812 	if (vw->vw_flags & VWF_SWWAIT_REL) {
1813 		vw->vw_flags &= ~VWF_SWWAIT_REL;
1814 		if (release) {
1815 			callout_drain(&vw->vw_proc_dead_timer);
1816 			(void)vt_late_window_switch(vw->vw_switch_to);
1817 		}
1818 		return (0);
1819 	}
1820 	return (EINVAL);
1821 }
1822 
1823 static int
1824 finish_vt_acq(struct vt_window *vw)
1825 {
1826 
1827 	if (vw->vw_flags & VWF_SWWAIT_ACQ) {
1828 		vw->vw_flags &= ~VWF_SWWAIT_ACQ;
1829 		return (0);
1830 	}
1831 	return (EINVAL);
1832 }
1833 
1834 #ifndef SC_NO_CUTPASTE
1835 static void
1836 vt_mouse_terminput_button(struct vt_device *vd, int button)
1837 {
1838 	struct vt_window *vw;
1839 	struct vt_font *vf;
1840 	char mouseb[6] = "\x1B[M";
1841 	int i, x, y;
1842 
1843 	vw = vd->vd_curwindow;
1844 	vf = vw->vw_font;
1845 
1846 	/* Translate to char position. */
1847 	x = vd->vd_mx / vf->vf_width;
1848 	y = vd->vd_my / vf->vf_height;
1849 	/* Avoid overflow. */
1850 	x = MIN(x, 255 - '!');
1851 	y = MIN(y, 255 - '!');
1852 
1853 	mouseb[3] = ' ' + button;
1854 	mouseb[4] = '!' + x;
1855 	mouseb[5] = '!' + y;
1856 
1857 	for (i = 0; i < sizeof(mouseb); i++)
1858 		terminal_input_char(vw->vw_terminal, mouseb[i]);
1859 }
1860 
1861 static void
1862 vt_mouse_terminput(struct vt_device *vd, int type, int x, int y, int event,
1863     int cnt)
1864 {
1865 
1866 	switch (type) {
1867 	case MOUSE_BUTTON_EVENT:
1868 		if (cnt > 0) {
1869 			/* Mouse button pressed. */
1870 			if (event & MOUSE_BUTTON1DOWN)
1871 				vt_mouse_terminput_button(vd, 0);
1872 			if (event & MOUSE_BUTTON2DOWN)
1873 				vt_mouse_terminput_button(vd, 1);
1874 			if (event & MOUSE_BUTTON3DOWN)
1875 				vt_mouse_terminput_button(vd, 2);
1876 		} else {
1877 			/* Mouse button released. */
1878 			vt_mouse_terminput_button(vd, 3);
1879 		}
1880 		break;
1881 #ifdef notyet
1882 	case MOUSE_MOTION_EVENT:
1883 		if (mouse->u.data.z < 0) {
1884 			/* Scroll up. */
1885 			sc_mouse_input_button(vd, 64);
1886 		} else if (mouse->u.data.z > 0) {
1887 			/* Scroll down. */
1888 			sc_mouse_input_button(vd, 65);
1889 		}
1890 		break;
1891 #endif
1892 	}
1893 }
1894 
1895 static void
1896 vt_mouse_paste()
1897 {
1898 	term_char_t *buf;
1899 	int i, len;
1900 
1901 	len = VD_PASTEBUFLEN(main_vd);
1902 	buf = VD_PASTEBUF(main_vd);
1903 	len /= sizeof(term_char_t);
1904 	for (i = 0; i < len; i++) {
1905 		if (buf[i] == '\0')
1906 			continue;
1907 		terminal_input_char(main_vd->vd_curwindow->vw_terminal,
1908 		    buf[i]);
1909 	}
1910 }
1911 
1912 void
1913 vt_mouse_event(int type, int x, int y, int event, int cnt, int mlevel)
1914 {
1915 	struct vt_device *vd;
1916 	struct vt_window *vw;
1917 	struct vt_font *vf;
1918 	term_pos_t size;
1919 	int len, mark;
1920 
1921 	vd = main_vd;
1922 	vw = vd->vd_curwindow;
1923 	vf = vw->vw_font;
1924 	mark = 0;
1925 
1926 	if (vw->vw_flags & (VWF_MOUSE_HIDE | VWF_GRAPHICS))
1927 		/*
1928 		 * Either the mouse is disabled, or the window is in
1929 		 * "graphics mode". The graphics mode is usually set by
1930 		 * an X server, using the KDSETMODE ioctl.
1931 		 */
1932 		return;
1933 
1934 	if (vf == NULL)	/* Text mode. */
1935 		return;
1936 
1937 	/*
1938 	 * TODO: add flag about pointer position changed, to not redraw chars
1939 	 * under mouse pointer when nothing changed.
1940 	 */
1941 
1942 	if (vw->vw_mouse_level > 0)
1943 		vt_mouse_terminput(vd, type, x, y, event, cnt);
1944 
1945 	switch (type) {
1946 	case MOUSE_ACTION:
1947 	case MOUSE_MOTION_EVENT:
1948 		/* Movement */
1949 		x += vd->vd_mx;
1950 		y += vd->vd_my;
1951 
1952 		vt_termsize(vd, vf, &size);
1953 
1954 		/* Apply limits. */
1955 		x = MAX(x, 0);
1956 		y = MAX(y, 0);
1957 		x = MIN(x, (size.tp_col * vf->vf_width) - 1);
1958 		y = MIN(y, (size.tp_row * vf->vf_height) - 1);
1959 
1960 		vd->vd_mx = x;
1961 		vd->vd_my = y;
1962 		if (vd->vd_mstate & MOUSE_BUTTON1DOWN)
1963 			vtbuf_set_mark(&vw->vw_buf, VTB_MARK_MOVE,
1964 			    vd->vd_mx / vf->vf_width,
1965 			    vd->vd_my / vf->vf_height);
1966 
1967 		vt_resume_flush_timer(vw, 0);
1968 		return; /* Done */
1969 	case MOUSE_BUTTON_EVENT:
1970 		/* Buttons */
1971 		break;
1972 	default:
1973 		return; /* Done */
1974 	}
1975 
1976 	switch (event) {
1977 	case MOUSE_BUTTON1DOWN:
1978 		switch (cnt % 4) {
1979 		case 0:	/* up */
1980 			mark = VTB_MARK_END;
1981 			break;
1982 		case 1: /* single click: start cut operation */
1983 			mark = VTB_MARK_START;
1984 			break;
1985 		case 2:	/* double click: cut a word */
1986 			mark = VTB_MARK_WORD;
1987 			break;
1988 		case 3:	/* triple click: cut a line */
1989 			mark = VTB_MARK_ROW;
1990 			break;
1991 		}
1992 		break;
1993 	case VT_MOUSE_PASTEBUTTON:
1994 		switch (cnt) {
1995 		case 0:	/* up */
1996 			break;
1997 		default:
1998 			vt_mouse_paste();
1999 			break;
2000 		}
2001 		return; /* Done */
2002 	case VT_MOUSE_EXTENDBUTTON:
2003 		switch (cnt) {
2004 		case 0:	/* up */
2005 			if (!(vd->vd_mstate & MOUSE_BUTTON1DOWN))
2006 				mark = VTB_MARK_EXTEND;
2007 			else
2008 				mark = 0;
2009 			break;
2010 		default:
2011 			mark = VTB_MARK_EXTEND;
2012 			break;
2013 		}
2014 		break;
2015 	default:
2016 		return; /* Done */
2017 	}
2018 
2019 	/* Save buttons state. */
2020 	if (cnt > 0)
2021 		vd->vd_mstate |= event;
2022 	else
2023 		vd->vd_mstate &= ~event;
2024 
2025 	if (vtbuf_set_mark(&vw->vw_buf, mark, vd->vd_mx / vf->vf_width,
2026 	    vd->vd_my / vf->vf_height) == 1) {
2027 		/*
2028 		 * We have something marked to copy, so update pointer to
2029 		 * window with selection.
2030 		 */
2031 		vt_resume_flush_timer(vw, 0);
2032 
2033 		switch (mark) {
2034 		case VTB_MARK_END:
2035 		case VTB_MARK_WORD:
2036 		case VTB_MARK_ROW:
2037 		case VTB_MARK_EXTEND:
2038 			break;
2039 		default:
2040 			/* Other types of mark do not require to copy data. */
2041 			return;
2042 		}
2043 
2044 		/* Get current selection size in bytes. */
2045 		len = vtbuf_get_marked_len(&vw->vw_buf);
2046 		if (len <= 0)
2047 			return;
2048 
2049 		/* Reallocate buffer only if old one is too small. */
2050 		if (len > VD_PASTEBUFSZ(vd)) {
2051 			VD_PASTEBUF(vd) = realloc(VD_PASTEBUF(vd), len, M_VT,
2052 			    M_WAITOK | M_ZERO);
2053 			/* Update buffer size. */
2054 			VD_PASTEBUFSZ(vd) = len;
2055 		}
2056 		/* Request copy/paste buffer data, no more than `len' */
2057 		vtbuf_extract_marked(&vw->vw_buf, VD_PASTEBUF(vd),
2058 		    VD_PASTEBUFSZ(vd));
2059 
2060 		VD_PASTEBUFLEN(vd) = len;
2061 
2062 		/* XXX VD_PASTEBUF(vd) have to be freed on shutdown/unload. */
2063 	}
2064 }
2065 
2066 void
2067 vt_mouse_state(int show)
2068 {
2069 	struct vt_device *vd;
2070 	struct vt_window *vw;
2071 
2072 	vd = main_vd;
2073 	vw = vd->vd_curwindow;
2074 
2075 	switch (show) {
2076 	case VT_MOUSE_HIDE:
2077 		vw->vw_flags |= VWF_MOUSE_HIDE;
2078 		break;
2079 	case VT_MOUSE_SHOW:
2080 		vw->vw_flags &= ~VWF_MOUSE_HIDE;
2081 		break;
2082 	}
2083 
2084 	/* Mark mouse position as dirty. */
2085 	vt_mark_mouse_position_as_dirty(vd, false);
2086 	vt_resume_flush_timer(vw, 0);
2087 }
2088 #endif
2089 
2090 static int
2091 vtterm_mmap(struct terminal *tm, vm_ooffset_t offset, vm_paddr_t * paddr,
2092     int nprot, vm_memattr_t *memattr)
2093 {
2094 	struct vt_window *vw = tm->tm_softc;
2095 	struct vt_device *vd = vw->vw_device;
2096 
2097 	if (vd->vd_driver->vd_fb_mmap)
2098 		return (vd->vd_driver->vd_fb_mmap(vd, offset, paddr, nprot,
2099 		    memattr));
2100 
2101 	return (ENXIO);
2102 }
2103 
2104 static int
2105 vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data,
2106     struct thread *td)
2107 {
2108 	struct vt_window *vw = tm->tm_softc;
2109 	struct vt_device *vd = vw->vw_device;
2110 	keyboard_t *kbd;
2111 	int error, i, s;
2112 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
2113     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
2114 	int ival;
2115 
2116 	switch (cmd) {
2117 	case _IO('v', 4):
2118 		cmd = VT_RELDISP;
2119 		break;
2120 	case _IO('v', 5):
2121 		cmd = VT_ACTIVATE;
2122 		break;
2123 	case _IO('v', 6):
2124 		cmd = VT_WAITACTIVE;
2125 		break;
2126 	case _IO('K', 20):
2127 		cmd = KDSKBSTATE;
2128 		break;
2129 	case _IO('K', 67):
2130 		cmd = KDSETRAD;
2131 		break;
2132 	case _IO('K', 7):
2133 		cmd = KDSKBMODE;
2134 		break;
2135 	case _IO('K', 8):
2136 		cmd = KDMKTONE;
2137 		break;
2138 	case _IO('K', 10):
2139 		cmd = KDSETMODE;
2140 		break;
2141 	case _IO('K', 13):
2142 		cmd = KDSBORDER;
2143 		break;
2144 	case _IO('K', 63):
2145 		cmd = KIOCSOUND;
2146 		break;
2147 	case _IO('K', 66):
2148 		cmd = KDSETLED;
2149 		break;
2150 	case _IO('c', 104):
2151 		cmd = CONS_SETWINORG;
2152 		break;
2153 	case _IO('c', 110):
2154 		cmd = CONS_SETKBD;
2155 		break;
2156 	default:
2157 		goto skip_thunk;
2158 	}
2159 	ival = IOCPARM_IVAL(data);
2160 	data = (caddr_t)&ival;
2161 skip_thunk:
2162 #endif
2163 
2164 	switch (cmd) {
2165 	case KDSETRAD:		/* set keyboard repeat & delay rates (old) */
2166 		if (*(int *)data & ~0x7f)
2167 			return (EINVAL);
2168 		/* FALLTHROUGH */
2169 	case GIO_KEYMAP:
2170 	case PIO_KEYMAP:
2171 	case GIO_DEADKEYMAP:
2172 	case PIO_DEADKEYMAP:
2173 	case GETFKEY:
2174 	case SETFKEY:
2175 	case KDGKBINFO:
2176 	case KDGKBTYPE:
2177 	case KDGETREPEAT:	/* get keyboard repeat & delay rates */
2178 	case KDSETREPEAT:	/* set keyboard repeat & delay rates (new) */
2179 	case KBADDKBD:		/* add/remove keyboard to/from mux */
2180 	case KBRELKBD: {
2181 		error = 0;
2182 
2183 		mtx_lock(&Giant);
2184 		if ((kbd = vd->vd_keyboard) != NULL)
2185 			error = kbdd_ioctl(kbd, cmd, data);
2186 		mtx_unlock(&Giant);
2187 		if (error == ENOIOCTL) {
2188 			if (cmd == KDGKBTYPE) {
2189 				/* always return something? XXX */
2190 				*(int *)data = 0;
2191 			} else {
2192 				return (ENODEV);
2193 			}
2194 		}
2195 		return (error);
2196 	}
2197 	case KDGKBSTATE: {	/* get keyboard state (locks) */
2198 		error = 0;
2199 
2200 		if (vw == vd->vd_curwindow) {
2201 			mtx_lock(&Giant);
2202 			if ((kbd = vd->vd_keyboard) != NULL)
2203 				error = vt_save_kbd_state(vw, kbd);
2204 			mtx_unlock(&Giant);
2205 
2206 			if (error != 0)
2207 				return (error);
2208 		}
2209 
2210 		*(int *)data = vw->vw_kbdstate & LOCK_MASK;
2211 
2212 		return (error);
2213 	}
2214 	case KDSKBSTATE: {	/* set keyboard state (locks) */
2215 		int state;
2216 
2217 		state = *(int *)data;
2218 		if (state & ~LOCK_MASK)
2219 			return (EINVAL);
2220 
2221 		vw->vw_kbdstate &= ~LOCK_MASK;
2222 		vw->vw_kbdstate |= state;
2223 
2224 		error = 0;
2225 		if (vw == vd->vd_curwindow) {
2226 			mtx_lock(&Giant);
2227 			if ((kbd = vd->vd_keyboard) != NULL)
2228 				error = vt_update_kbd_state(vw, kbd);
2229 			mtx_unlock(&Giant);
2230 		}
2231 
2232 		return (error);
2233 	}
2234 	case KDGETLED: {	/* get keyboard LED status */
2235 		error = 0;
2236 
2237 		if (vw == vd->vd_curwindow) {
2238 			mtx_lock(&Giant);
2239 			if ((kbd = vd->vd_keyboard) != NULL)
2240 				error = vt_save_kbd_leds(vw, kbd);
2241 			mtx_unlock(&Giant);
2242 
2243 			if (error != 0)
2244 				return (error);
2245 		}
2246 
2247 		*(int *)data = vw->vw_kbdstate & LED_MASK;
2248 
2249 		return (error);
2250 	}
2251 	case KDSETLED: {	/* set keyboard LED status */
2252 		int leds;
2253 
2254 		leds = *(int *)data;
2255 		if (leds & ~LED_MASK)
2256 			return (EINVAL);
2257 
2258 		vw->vw_kbdstate &= ~LED_MASK;
2259 		vw->vw_kbdstate |= leds;
2260 
2261 		error = 0;
2262 		if (vw == vd->vd_curwindow) {
2263 			mtx_lock(&Giant);
2264 			if ((kbd = vd->vd_keyboard) != NULL)
2265 				error = vt_update_kbd_leds(vw, kbd);
2266 			mtx_unlock(&Giant);
2267 		}
2268 
2269 		return (error);
2270 	}
2271 	case KDGETMODE:
2272 		*(int *)data = (vw->vw_flags & VWF_GRAPHICS) ?
2273 		    KD_GRAPHICS : KD_TEXT;
2274 		return (0);
2275 	case KDGKBMODE: {
2276 		error = 0;
2277 
2278 		if (vw == vd->vd_curwindow) {
2279 			mtx_lock(&Giant);
2280 			if ((kbd = vd->vd_keyboard) != NULL)
2281 				error = vt_save_kbd_mode(vw, kbd);
2282 			mtx_unlock(&Giant);
2283 
2284 			if (error != 0)
2285 				return (error);
2286 		}
2287 
2288 		*(int *)data = vw->vw_kbdmode;
2289 
2290 		return (error);
2291 	}
2292 	case KDSKBMODE: {
2293 		int mode;
2294 
2295 		mode = *(int *)data;
2296 		switch (mode) {
2297 		case K_XLATE:
2298 		case K_RAW:
2299 		case K_CODE:
2300 			vw->vw_kbdmode = mode;
2301 
2302 			error = 0;
2303 			if (vw == vd->vd_curwindow) {
2304 				mtx_lock(&Giant);
2305 				if ((kbd = vd->vd_keyboard) != NULL)
2306 					error = vt_update_kbd_mode(vw, kbd);
2307 				mtx_unlock(&Giant);
2308 			}
2309 
2310 			return (error);
2311 		default:
2312 			return (EINVAL);
2313 		}
2314 	}
2315 	case FBIOGTYPE:
2316 	case FBIO_GETWINORG:	/* get frame buffer window origin */
2317 	case FBIO_GETDISPSTART:	/* get display start address */
2318 	case FBIO_GETLINEWIDTH:	/* get scan line width in bytes */
2319 	case FBIO_BLANK:	/* blank display */
2320 		if (vd->vd_driver->vd_fb_ioctl)
2321 			return (vd->vd_driver->vd_fb_ioctl(vd, cmd, data, td));
2322 		break;
2323 	case CONS_BLANKTIME:
2324 		/* XXX */
2325 		return (0);
2326 	case CONS_HISTORY:
2327 		if (*(int *)data < 0)
2328 			return EINVAL;
2329 		if (*(int *)data != vw->vw_buf.vb_history_size)
2330 			vtbuf_sethistory_size(&vw->vw_buf, *(int *)data);
2331 		return (0);
2332 	case CONS_CLRHIST:
2333 		vtbuf_clearhistory(&vw->vw_buf);
2334 		/*
2335 		 * Invalidate the entire visible window; it is not guaranteed
2336 		 * that this operation will be immediately followed by a scroll
2337 		 * event, so it would otherwise be possible for prior artifacts
2338 		 * to remain visible.
2339 		 */
2340 		VT_LOCK(vd);
2341 		if (vw == vd->vd_curwindow) {
2342 			vd->vd_flags |= VDF_INVALID;
2343 			vt_resume_flush_timer(vw, 0);
2344 		}
2345 		VT_UNLOCK(vd);
2346 		return (0);
2347 	case CONS_GET:
2348 		/* XXX */
2349 		*(int *)data = M_CG640x480;
2350 		return (0);
2351 	case CONS_BELLTYPE:	/* set bell type sound */
2352 		if ((*(int *)data) & CONS_QUIET_BELL)
2353 			vd->vd_flags |= VDF_QUIET_BELL;
2354 		else
2355 			vd->vd_flags &= ~VDF_QUIET_BELL;
2356 		return (0);
2357 	case CONS_GETINFO: {
2358 		vid_info_t *vi = (vid_info_t *)data;
2359 		if (vi->size != sizeof(struct vid_info))
2360 			return (EINVAL);
2361 
2362 		if (vw == vd->vd_curwindow) {
2363 			mtx_lock(&Giant);
2364 			if ((kbd = vd->vd_keyboard) != NULL)
2365 				vt_save_kbd_state(vw, kbd);
2366 			mtx_unlock(&Giant);
2367 		}
2368 
2369 		vi->m_num = vd->vd_curwindow->vw_number + 1;
2370 		vi->mk_keylock = vw->vw_kbdstate & LOCK_MASK;
2371 		/* XXX: other fields! */
2372 		return (0);
2373 	}
2374 	case CONS_GETVERS:
2375 		*(int *)data = 0x200;
2376 		return (0);
2377 	case CONS_MODEINFO:
2378 		/* XXX */
2379 		return (0);
2380 	case CONS_MOUSECTL: {
2381 		mouse_info_t *mouse = (mouse_info_t*)data;
2382 
2383 		/*
2384 		 * All the commands except MOUSE_SHOW nd MOUSE_HIDE
2385 		 * should not be applied to individual TTYs, but only to
2386 		 * consolectl.
2387 		 */
2388 		switch (mouse->operation) {
2389 		case MOUSE_HIDE:
2390 			if (vd->vd_flags & VDF_MOUSECURSOR) {
2391 				vd->vd_flags &= ~VDF_MOUSECURSOR;
2392 #ifndef SC_NO_CUTPASTE
2393 				vt_mouse_state(VT_MOUSE_HIDE);
2394 #endif
2395 			}
2396 			return (0);
2397 		case MOUSE_SHOW:
2398 			if (!(vd->vd_flags & VDF_MOUSECURSOR)) {
2399 				vd->vd_flags |= VDF_MOUSECURSOR;
2400 				vd->vd_mx = vd->vd_width / 2;
2401 				vd->vd_my = vd->vd_height / 2;
2402 #ifndef SC_NO_CUTPASTE
2403 				vt_mouse_state(VT_MOUSE_SHOW);
2404 #endif
2405 			}
2406 			return (0);
2407 		default:
2408 			return (EINVAL);
2409 		}
2410 	}
2411 	case PIO_VFONT: {
2412 		struct vt_font *vf;
2413 
2414 		if (vd->vd_flags & VDF_TEXTMODE)
2415 			return (ENOTSUP);
2416 
2417 		error = vtfont_load((void *)data, &vf);
2418 		if (error != 0)
2419 			return (error);
2420 
2421 		error = vt_change_font(vw, vf);
2422 		vtfont_unref(vf);
2423 		return (error);
2424 	}
2425 	case PIO_VFONT_DEFAULT: {
2426 		/* Reset to default font. */
2427 		error = vt_change_font(vw, &vt_font_default);
2428 		return (error);
2429 	}
2430 	case GIO_SCRNMAP: {
2431 		scrmap_t *sm = (scrmap_t *)data;
2432 
2433 		/* We don't have screen maps, so return a handcrafted one. */
2434 		for (i = 0; i < 256; i++)
2435 			sm->scrmap[i] = i;
2436 		return (0);
2437 	}
2438 	case KDSETMODE:
2439 		/*
2440 		 * FIXME: This implementation is incomplete compared to
2441 		 * syscons.
2442 		 */
2443 		switch (*(int *)data) {
2444 		case KD_TEXT:
2445 		case KD_TEXT1:
2446 		case KD_PIXEL:
2447 			vw->vw_flags &= ~VWF_GRAPHICS;
2448 			break;
2449 		case KD_GRAPHICS:
2450 			vw->vw_flags |= VWF_GRAPHICS;
2451 			break;
2452 		}
2453 		return (0);
2454 	case KDENABIO:		/* allow io operations */
2455 		error = priv_check(td, PRIV_IO);
2456 		if (error != 0)
2457 			return (error);
2458 		error = securelevel_gt(td->td_ucred, 0);
2459 		if (error != 0)
2460 			return (error);
2461 #if defined(__i386__)
2462 		td->td_frame->tf_eflags |= PSL_IOPL;
2463 #elif defined(__amd64__)
2464 		td->td_frame->tf_rflags |= PSL_IOPL;
2465 #endif
2466 		return (0);
2467 	case KDDISABIO:		/* disallow io operations (default) */
2468 #if defined(__i386__)
2469 		td->td_frame->tf_eflags &= ~PSL_IOPL;
2470 #elif defined(__amd64__)
2471 		td->td_frame->tf_rflags &= ~PSL_IOPL;
2472 #endif
2473 		return (0);
2474 	case KDMKTONE:		/* sound the bell */
2475 		vtterm_beep(tm, *(u_int *)data);
2476 		return (0);
2477 	case KIOCSOUND:		/* make tone (*data) hz */
2478 		/* TODO */
2479 		return (0);
2480 	case CONS_SETKBD:	/* set the new keyboard */
2481 		mtx_lock(&Giant);
2482 		error = 0;
2483 		if (vd->vd_keyboard == NULL ||
2484 		    vd->vd_keyboard->kb_index != *(int *)data) {
2485 			kbd = kbd_get_keyboard(*(int *)data);
2486 			if (kbd == NULL) {
2487 				mtx_unlock(&Giant);
2488 				return (EINVAL);
2489 			}
2490 			i = kbd_allocate(kbd->kb_name, kbd->kb_unit,
2491 			    (void *)vd, vt_kbdevent, vd);
2492 			if (i >= 0) {
2493 				if ((kbd = vd->vd_keyboard) != NULL) {
2494 					vt_save_kbd_state(vd->vd_curwindow, kbd);
2495 					kbd_release(kbd, (void *)vd);
2496 				}
2497 				kbd = vd->vd_keyboard = kbd_get_keyboard(i);
2498 
2499 				vt_update_kbd_mode(vd->vd_curwindow, kbd);
2500 				vt_update_kbd_state(vd->vd_curwindow, kbd);
2501 			} else {
2502 				error = EPERM;	/* XXX */
2503 			}
2504 		}
2505 		mtx_unlock(&Giant);
2506 		return (error);
2507 	case CONS_RELKBD:	/* release the current keyboard */
2508 		mtx_lock(&Giant);
2509 		error = 0;
2510 		if ((kbd = vd->vd_keyboard) != NULL) {
2511 			vt_save_kbd_state(vd->vd_curwindow, kbd);
2512 			error = kbd_release(kbd, (void *)vd);
2513 			if (error == 0) {
2514 				vd->vd_keyboard = NULL;
2515 			}
2516 		}
2517 		mtx_unlock(&Giant);
2518 		return (error);
2519 	case VT_ACTIVATE: {
2520 		int win;
2521 		win = *(int *)data - 1;
2522 		DPRINTF(5, "%s%d: VT_ACTIVATE ttyv%d ", SC_DRIVER_NAME,
2523 		    VT_UNIT(vw), win);
2524 		if ((win >= VT_MAXWINDOWS) || (win < 0))
2525 			return (EINVAL);
2526 		return (vt_proc_window_switch(vd->vd_windows[win]));
2527 	}
2528 	case VT_GETACTIVE:
2529 		*(int *)data = vd->vd_curwindow->vw_number + 1;
2530 		return (0);
2531 	case VT_GETINDEX:
2532 		*(int *)data = vw->vw_number + 1;
2533 		return (0);
2534 	case VT_LOCKSWITCH:
2535 		/* TODO: Check current state, switching can be in progress. */
2536 		if ((*(int *)data) == 0x01)
2537 			vw->vw_flags |= VWF_VTYLOCK;
2538 		else if ((*(int *)data) == 0x02)
2539 			vw->vw_flags &= ~VWF_VTYLOCK;
2540 		else
2541 			return (EINVAL);
2542 		return (0);
2543 	case VT_OPENQRY:
2544 		VT_LOCK(vd);
2545 		for (i = 0; i < VT_MAXWINDOWS; i++) {
2546 			vw = vd->vd_windows[i];
2547 			if (vw == NULL)
2548 				continue;
2549 			if (!(vw->vw_flags & VWF_OPENED)) {
2550 				*(int *)data = vw->vw_number + 1;
2551 				VT_UNLOCK(vd);
2552 				return (0);
2553 			}
2554 		}
2555 		VT_UNLOCK(vd);
2556 		return (EINVAL);
2557 	case VT_WAITACTIVE: {
2558 		unsigned int idx;
2559 
2560 		error = 0;
2561 
2562 		idx = *(unsigned int *)data;
2563 		if (idx > VT_MAXWINDOWS)
2564 			return (EINVAL);
2565 		if (idx > 0)
2566 			vw = vd->vd_windows[idx - 1];
2567 
2568 		VT_LOCK(vd);
2569 		while (vd->vd_curwindow != vw && error == 0)
2570 			error = cv_wait_sig(&vd->vd_winswitch, &vd->vd_lock);
2571 		VT_UNLOCK(vd);
2572 		return (error);
2573 	}
2574 	case VT_SETMODE: {	/* set screen switcher mode */
2575 		struct vt_mode *mode;
2576 		struct proc *p1;
2577 
2578 		mode = (struct vt_mode *)data;
2579 		DPRINTF(5, "%s%d: VT_SETMODE ", SC_DRIVER_NAME, VT_UNIT(vw));
2580 		if (vw->vw_smode.mode == VT_PROCESS) {
2581 			p1 = pfind(vw->vw_pid);
2582 			if (vw->vw_proc == p1 && vw->vw_proc != td->td_proc) {
2583 				if (p1)
2584 					PROC_UNLOCK(p1);
2585 				DPRINTF(5, "error EPERM\n");
2586 				return (EPERM);
2587 			}
2588 			if (p1)
2589 				PROC_UNLOCK(p1);
2590 		}
2591 		if (mode->mode == VT_AUTO) {
2592 			vw->vw_smode.mode = VT_AUTO;
2593 			vw->vw_proc = NULL;
2594 			vw->vw_pid = 0;
2595 			DPRINTF(5, "VT_AUTO, ");
2596 			if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
2597 				cnavailable(vw->vw_terminal->consdev, TRUE);
2598 			/* were we in the middle of the vty switching process? */
2599 			if (finish_vt_rel(vw, TRUE, &s) == 0)
2600 				DPRINTF(5, "reset WAIT_REL, ");
2601 			if (finish_vt_acq(vw) == 0)
2602 				DPRINTF(5, "reset WAIT_ACQ, ");
2603 			return (0);
2604 		} else if (mode->mode == VT_PROCESS) {
2605 			if (!ISSIGVALID(mode->relsig) ||
2606 			    !ISSIGVALID(mode->acqsig) ||
2607 			    !ISSIGVALID(mode->frsig)) {
2608 				DPRINTF(5, "error EINVAL\n");
2609 				return (EINVAL);
2610 			}
2611 			DPRINTF(5, "VT_PROCESS %d, ", td->td_proc->p_pid);
2612 			bcopy(data, &vw->vw_smode, sizeof(struct vt_mode));
2613 			vw->vw_proc = td->td_proc;
2614 			vw->vw_pid = vw->vw_proc->p_pid;
2615 			if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
2616 				cnavailable(vw->vw_terminal->consdev, FALSE);
2617 		} else {
2618 			DPRINTF(5, "VT_SETMODE failed, unknown mode %d\n",
2619 			    mode->mode);
2620 			return (EINVAL);
2621 		}
2622 		DPRINTF(5, "\n");
2623 		return (0);
2624 	}
2625 	case VT_GETMODE:	/* get screen switcher mode */
2626 		bcopy(&vw->vw_smode, data, sizeof(struct vt_mode));
2627 		return (0);
2628 
2629 	case VT_RELDISP:	/* screen switcher ioctl */
2630 		/*
2631 		 * This must be the current vty which is in the VT_PROCESS
2632 		 * switching mode...
2633 		 */
2634 		if ((vw != vd->vd_curwindow) || (vw->vw_smode.mode !=
2635 		    VT_PROCESS)) {
2636 			return (EINVAL);
2637 		}
2638 		/* ...and this process is controlling it. */
2639 		if (vw->vw_proc != td->td_proc) {
2640 			return (EPERM);
2641 		}
2642 		error = EINVAL;
2643 		switch(*(int *)data) {
2644 		case VT_FALSE:	/* user refuses to release screen, abort */
2645 			if ((error = finish_vt_rel(vw, FALSE, &s)) == 0)
2646 				DPRINTF(5, "%s%d: VT_RELDISP: VT_FALSE\n",
2647 				    SC_DRIVER_NAME, VT_UNIT(vw));
2648 			break;
2649 		case VT_TRUE:	/* user has released screen, go on */
2650 			/* finish_vt_rel(..., TRUE, ...) should not be locked */
2651 			if (vw->vw_flags & VWF_SWWAIT_REL) {
2652 				if ((error = finish_vt_rel(vw, TRUE, &s)) == 0)
2653 					DPRINTF(5, "%s%d: VT_RELDISP: VT_TRUE\n",
2654 					    SC_DRIVER_NAME, VT_UNIT(vw));
2655 			} else {
2656 				error = EINVAL;
2657 			}
2658 			return (error);
2659 		case VT_ACKACQ:	/* acquire acknowledged, switch completed */
2660 			if ((error = finish_vt_acq(vw)) == 0)
2661 				DPRINTF(5, "%s%d: VT_RELDISP: VT_ACKACQ\n",
2662 				    SC_DRIVER_NAME, VT_UNIT(vw));
2663 			break;
2664 		default:
2665 			break;
2666 		}
2667 		return (error);
2668 	}
2669 
2670 	return (ENOIOCTL);
2671 }
2672 
2673 static struct vt_window *
2674 vt_allocate_window(struct vt_device *vd, unsigned int window)
2675 {
2676 	struct vt_window *vw;
2677 	struct terminal *tm;
2678 	term_pos_t size;
2679 	struct winsize wsz;
2680 
2681 	vw = malloc(sizeof *vw, M_VT, M_WAITOK|M_ZERO);
2682 	vw->vw_device = vd;
2683 	vw->vw_number = window;
2684 	vw->vw_kbdmode = K_XLATE;
2685 
2686 	if ((vd->vd_flags & VDF_TEXTMODE) == 0) {
2687 		vw->vw_font = vtfont_ref(&vt_font_default);
2688 		vt_compute_drawable_area(vw);
2689 	}
2690 
2691 	vt_termsize(vd, vw->vw_font, &size);
2692 	vt_winsize(vd, vw->vw_font, &wsz);
2693 	tm = vw->vw_terminal = terminal_alloc(&vt_termclass, vw);
2694 	vw->vw_buf.vb_terminal = tm;	/* must be set before vtbuf_init() */
2695 	vtbuf_init(&vw->vw_buf, &size);
2696 
2697 	terminal_set_winsize(tm, &wsz);
2698 	vd->vd_windows[window] = vw;
2699 	callout_init(&vw->vw_proc_dead_timer, 0);
2700 
2701 	return (vw);
2702 }
2703 
2704 void
2705 vt_upgrade(struct vt_device *vd)
2706 {
2707 	struct vt_window *vw;
2708 	unsigned int i;
2709 	int register_handlers;
2710 
2711 	if (!vty_enabled(VTY_VT))
2712 		return;
2713 	if (main_vd->vd_driver == NULL)
2714 		return;
2715 
2716 	for (i = 0; i < VT_MAXWINDOWS; i++) {
2717 		vw = vd->vd_windows[i];
2718 		if (vw == NULL) {
2719 			/* New window. */
2720 			vw = vt_allocate_window(vd, i);
2721 		}
2722 		if (!(vw->vw_flags & VWF_READY)) {
2723 			callout_init(&vw->vw_proc_dead_timer, 0);
2724 			terminal_maketty(vw->vw_terminal, "v%r", VT_UNIT(vw));
2725 			vw->vw_flags |= VWF_READY;
2726 			if (vw->vw_flags & VWF_CONSOLE) {
2727 				/* For existing console window. */
2728 				EVENTHANDLER_REGISTER(shutdown_pre_sync,
2729 				    vt_window_switch, vw, SHUTDOWN_PRI_DEFAULT);
2730 			}
2731 		}
2732 
2733 	}
2734 	VT_LOCK(vd);
2735 	if (vd->vd_curwindow == NULL)
2736 		vd->vd_curwindow = vd->vd_windows[VT_CONSWINDOW];
2737 
2738 	register_handlers = 0;
2739 	if (!(vd->vd_flags & VDF_ASYNC)) {
2740 		/* Attach keyboard. */
2741 		vt_allocate_keyboard(vd);
2742 
2743 		/* Init 25 Hz timer. */
2744 		callout_init_mtx(&vd->vd_timer, &vd->vd_lock, 0);
2745 
2746 		/*
2747 		 * Start timer when everything ready.
2748 		 * Note that the operations here are purposefully ordered.
2749 		 * We need to ensure vd_timer_armed is non-zero before we set
2750 		 * the VDF_ASYNC flag. That prevents this function from
2751 		 * racing with vt_resume_flush_timer() to update the
2752 		 * callout structure.
2753 		 */
2754 		atomic_add_acq_int(&vd->vd_timer_armed, 1);
2755 		vd->vd_flags |= VDF_ASYNC;
2756 		callout_reset(&vd->vd_timer, hz / VT_TIMERFREQ, vt_timer, vd);
2757 		register_handlers = 1;
2758 	}
2759 
2760 	VT_UNLOCK(vd);
2761 
2762 	/* Refill settings with new sizes. */
2763 	vt_resize(vd);
2764 
2765 	if (register_handlers) {
2766 		/* Register suspend/resume handlers. */
2767 		EVENTHANDLER_REGISTER(power_suspend_early, vt_suspend_handler,
2768 		    vd, EVENTHANDLER_PRI_ANY);
2769 		EVENTHANDLER_REGISTER(power_resume, vt_resume_handler, vd,
2770 		    EVENTHANDLER_PRI_ANY);
2771 	}
2772 }
2773 
2774 static void
2775 vt_resize(struct vt_device *vd)
2776 {
2777 	struct vt_window *vw;
2778 	int i;
2779 
2780 	for (i = 0; i < VT_MAXWINDOWS; i++) {
2781 		vw = vd->vd_windows[i];
2782 		VT_LOCK(vd);
2783 		/* Assign default font to window, if not textmode. */
2784 		if (!(vd->vd_flags & VDF_TEXTMODE) && vw->vw_font == NULL)
2785 			vw->vw_font = vtfont_ref(&vt_font_default);
2786 		VT_UNLOCK(vd);
2787 
2788 		/* Resize terminal windows */
2789 		while (vt_change_font(vw, vw->vw_font) == EBUSY) {
2790 			DPRINTF(100, "%s: vt_change_font() is busy, "
2791 			    "window %d\n", __func__, i);
2792 		}
2793 	}
2794 }
2795 
2796 static void
2797 vt_replace_backend(const struct vt_driver *drv, void *softc)
2798 {
2799 	struct vt_device *vd;
2800 
2801 	vd = main_vd;
2802 
2803 	if (vd->vd_flags & VDF_ASYNC) {
2804 		/* Stop vt_flush periodic task. */
2805 		VT_LOCK(vd);
2806 		vt_suspend_flush_timer(vd);
2807 		VT_UNLOCK(vd);
2808 		/*
2809 		 * Mute current terminal until we done. vt_change_font (called
2810 		 * from vt_resize) will unmute it.
2811 		 */
2812 		terminal_mute(vd->vd_curwindow->vw_terminal, 1);
2813 	}
2814 
2815 	/*
2816 	 * Reset VDF_TEXTMODE flag, driver who require that flag (vt_vga) will
2817 	 * set it.
2818 	 */
2819 	VT_LOCK(vd);
2820 	vd->vd_flags &= ~VDF_TEXTMODE;
2821 
2822 	if (drv != NULL) {
2823 		/*
2824 		 * We want to upgrade from the current driver to the
2825 		 * given driver.
2826 		 */
2827 
2828 		vd->vd_prev_driver = vd->vd_driver;
2829 		vd->vd_prev_softc = vd->vd_softc;
2830 		vd->vd_driver = drv;
2831 		vd->vd_softc = softc;
2832 
2833 		vd->vd_driver->vd_init(vd);
2834 	} else if (vd->vd_prev_driver != NULL && vd->vd_prev_softc != NULL) {
2835 		/*
2836 		 * No driver given: we want to downgrade to the previous
2837 		 * driver.
2838 		 */
2839 		const struct vt_driver *old_drv;
2840 		void *old_softc;
2841 
2842 		old_drv = vd->vd_driver;
2843 		old_softc = vd->vd_softc;
2844 
2845 		vd->vd_driver = vd->vd_prev_driver;
2846 		vd->vd_softc = vd->vd_prev_softc;
2847 		vd->vd_prev_driver = NULL;
2848 		vd->vd_prev_softc = NULL;
2849 
2850 		vd->vd_flags |= VDF_DOWNGRADE;
2851 
2852 		vd->vd_driver->vd_init(vd);
2853 
2854 		if (old_drv->vd_fini)
2855 			old_drv->vd_fini(vd, old_softc);
2856 
2857 		vd->vd_flags &= ~VDF_DOWNGRADE;
2858 	}
2859 
2860 	VT_UNLOCK(vd);
2861 
2862 	/* Update windows sizes and initialize last items. */
2863 	vt_upgrade(vd);
2864 
2865 #ifdef DEV_SPLASH
2866 	if (vd->vd_flags & VDF_SPLASH)
2867 		vtterm_splash(vd);
2868 #endif
2869 
2870 	if (vd->vd_flags & VDF_ASYNC) {
2871 		/* Allow to put chars now. */
2872 		terminal_mute(vd->vd_curwindow->vw_terminal, 0);
2873 		/* Rerun timer for screen updates. */
2874 		vt_resume_flush_timer(vd->vd_curwindow, 0);
2875 	}
2876 
2877 	/*
2878 	 * Register as console. If it already registered, cnadd() will ignore
2879 	 * it.
2880 	 */
2881 	termcn_cnregister(vd->vd_windows[VT_CONSWINDOW]->vw_terminal);
2882 }
2883 
2884 static void
2885 vt_suspend_handler(void *priv)
2886 {
2887 	struct vt_device *vd;
2888 
2889 	vd = priv;
2890 	vd->vd_flags |= VDF_SUSPENDED;
2891 	if (vd->vd_driver != NULL && vd->vd_driver->vd_suspend != NULL)
2892 		vd->vd_driver->vd_suspend(vd);
2893 }
2894 
2895 static void
2896 vt_resume_handler(void *priv)
2897 {
2898 	struct vt_device *vd;
2899 
2900 	vd = priv;
2901 	if (vd->vd_driver != NULL && vd->vd_driver->vd_resume != NULL)
2902 		vd->vd_driver->vd_resume(vd);
2903 	vd->vd_flags &= ~VDF_SUSPENDED;
2904 }
2905 
2906 void
2907 vt_allocate(const struct vt_driver *drv, void *softc)
2908 {
2909 
2910 	if (!vty_enabled(VTY_VT))
2911 		return;
2912 
2913 	if (main_vd->vd_driver == NULL) {
2914 		main_vd->vd_driver = drv;
2915 		printf("VT: initialize with new VT driver \"%s\".\n",
2916 		    drv->vd_name);
2917 	} else {
2918 		/*
2919 		 * Check if have rights to replace current driver. For example:
2920 		 * it is bad idea to replace KMS driver with generic VGA one.
2921 		 */
2922 		if (drv->vd_priority <= main_vd->vd_driver->vd_priority) {
2923 			printf("VT: Driver priority %d too low. Current %d\n ",
2924 			    drv->vd_priority, main_vd->vd_driver->vd_priority);
2925 			return;
2926 		}
2927 		printf("VT: Replacing driver \"%s\" with new \"%s\".\n",
2928 		    main_vd->vd_driver->vd_name, drv->vd_name);
2929 	}
2930 
2931 	vt_replace_backend(drv, softc);
2932 }
2933 
2934 void
2935 vt_deallocate(const struct vt_driver *drv, void *softc)
2936 {
2937 
2938 	if (!vty_enabled(VTY_VT))
2939 		return;
2940 
2941 	if (main_vd->vd_prev_driver == NULL ||
2942 	    main_vd->vd_driver != drv ||
2943 	    main_vd->vd_softc != softc)
2944 		return;
2945 
2946 	printf("VT: Switching back from \"%s\" to \"%s\".\n",
2947 	    main_vd->vd_driver->vd_name, main_vd->vd_prev_driver->vd_name);
2948 
2949 	vt_replace_backend(NULL, NULL);
2950 }
2951 
2952 void
2953 vt_suspend(struct vt_device *vd)
2954 {
2955 	int error;
2956 
2957 	if (vt_suspendswitch == 0)
2958 		return;
2959 	/* Save current window. */
2960 	vd->vd_savedwindow = vd->vd_curwindow;
2961 	/* Ask holding process to free window and switch to console window */
2962 	vt_proc_window_switch(vd->vd_windows[VT_CONSWINDOW]);
2963 
2964 	/* Wait for the window switch to complete. */
2965 	error = 0;
2966 	VT_LOCK(vd);
2967 	while (vd->vd_curwindow != vd->vd_windows[VT_CONSWINDOW] && error == 0)
2968 		error = cv_wait_sig(&vd->vd_winswitch, &vd->vd_lock);
2969 	VT_UNLOCK(vd);
2970 }
2971 
2972 void
2973 vt_resume(struct vt_device *vd)
2974 {
2975 
2976 	if (vt_suspendswitch == 0)
2977 		return;
2978 	/* Switch back to saved window, if any */
2979 	vt_proc_window_switch(vd->vd_savedwindow);
2980 	vd->vd_savedwindow = NULL;
2981 }
2982