xref: /freebsd/sys/dev/vt/vt_core.c (revision 9ecd54f24fe9fa373e07c9fd7c052deb2188f545)
1 /*-
2  * Copyright (c) 2009, 2013 The FreeBSD Foundation
3  * All rights reserved.
4  *
5  * This software was developed by Ed Schouten under sponsorship from the
6  * FreeBSD Foundation.
7  *
8  * Portions of this software were developed by Oleksandr Rybalko
9  * under sponsorship from the FreeBSD Foundation.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include "opt_compat.h"
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/priv.h>
49 #include <sys/proc.h>
50 #include <sys/reboot.h>
51 #include <sys/systm.h>
52 #include <sys/terminal.h>
53 
54 #include <dev/kbd/kbdreg.h>
55 #include <dev/vt/vt.h>
56 
57 #if defined(__i386__) || defined(__amd64__)
58 #include <machine/psl.h>
59 #include <machine/frame.h>
60 #endif
61 
62 static tc_bell_t	vtterm_bell;
63 static tc_cursor_t	vtterm_cursor;
64 static tc_putchar_t	vtterm_putchar;
65 static tc_fill_t	vtterm_fill;
66 static tc_copy_t	vtterm_copy;
67 static tc_param_t	vtterm_param;
68 static tc_done_t	vtterm_done;
69 
70 static tc_cnprobe_t	vtterm_cnprobe;
71 static tc_cngetc_t	vtterm_cngetc;
72 
73 static tc_opened_t	vtterm_opened;
74 static tc_ioctl_t	vtterm_ioctl;
75 static tc_mmap_t	vtterm_mmap;
76 
77 const struct terminal_class vt_termclass = {
78 	.tc_bell	= vtterm_bell,
79 	.tc_cursor	= vtterm_cursor,
80 	.tc_putchar	= vtterm_putchar,
81 	.tc_fill	= vtterm_fill,
82 	.tc_copy	= vtterm_copy,
83 	.tc_param	= vtterm_param,
84 	.tc_done	= vtterm_done,
85 
86 	.tc_cnprobe	= vtterm_cnprobe,
87 	.tc_cngetc	= vtterm_cngetc,
88 
89 	.tc_opened	= vtterm_opened,
90 	.tc_ioctl	= vtterm_ioctl,
91 	.tc_mmap	= vtterm_mmap,
92 };
93 
94 /*
95  * Use a constant timer of 25 Hz to redraw the screen.
96  *
97  * XXX: In theory we should only fire up the timer when there is really
98  * activity. Unfortunately we cannot always start timers. We really
99  * don't want to process kernel messages synchronously, because it
100  * really slows down the system.
101  */
102 #define	VT_TIMERFREQ	25
103 
104 /* Bell pitch/duration. */
105 #define VT_BELLDURATION	((5 * hz + 99) / 100)
106 #define VT_BELLPITCH	800
107 
108 #define	VT_LOCK(vd)	mtx_lock(&(vd)->vd_lock)
109 #define	VT_UNLOCK(vd)	mtx_unlock(&(vd)->vd_lock)
110 
111 #define	VT_UNIT(vw)	((vw)->vw_device->vd_unit * VT_MAXWINDOWS + \
112 			(vw)->vw_number)
113 
114 /* XXX while syscons is here. */
115 int sc_txtmouse_no_retrace_wait;
116 
117 static SYSCTL_NODE(_kern, OID_AUTO, vt, CTLFLAG_RD, 0, "vt(9) parameters");
118 VT_SYSCTL_INT(enable_altgr, 1, "Enable AltGr key (Do not assume R.Alt as Alt)");
119 VT_SYSCTL_INT(debug, 0, "vt(9) debug level");
120 VT_SYSCTL_INT(deadtimer, 15, "Time to wait busy process in VT_PROCESS mode");
121 VT_SYSCTL_INT(suspendswitch, 1, "Switch to VT0 before suspend");
122 
123 static unsigned int vt_unit = 0;
124 static MALLOC_DEFINE(M_VT, "vt", "vt device");
125 struct vt_device *main_vd = NULL;
126 
127 /* Boot logo. */
128 extern unsigned int vt_logo_width;
129 extern unsigned int vt_logo_height;
130 extern unsigned int vt_logo_depth;
131 extern unsigned char vt_logo_image[];
132 
133 /* Font. */
134 extern struct vt_font vt_font_default;
135 #ifndef SC_NO_CUTPASTE
136 extern struct mouse_cursor vt_default_mouse_pointer;
137 #endif
138 
139 static int signal_vt_rel(struct vt_window *);
140 static int signal_vt_acq(struct vt_window *);
141 static int finish_vt_rel(struct vt_window *, int, int *);
142 static int finish_vt_acq(struct vt_window *);
143 static int vt_window_switch(struct vt_window *);
144 static int vt_late_window_switch(struct vt_window *);
145 static int vt_proc_alive(struct vt_window *);
146 static void vt_resize(struct vt_device *);
147 
148 static void
149 vt_switch_timer(void *arg)
150 {
151 
152 	vt_late_window_switch((struct vt_window *)arg);
153 }
154 
155 static int
156 vt_window_preswitch(struct vt_window *vw, struct vt_window *curvw)
157 {
158 
159 	DPRINTF(40, "%s\n", __func__);
160 	curvw->vw_switch_to = vw;
161 	/* Set timer to allow switch in case when process hang. */
162 	callout_reset(&vw->vw_proc_dead_timer, hz * vt_deadtimer,
163 	    vt_switch_timer, (void *)vw);
164 	/* Notify process about vt switch attempt. */
165 	DPRINTF(30, "%s: Notify process.\n", __func__);
166 	signal_vt_rel(curvw);
167 
168 	return (0);
169 }
170 
171 static int
172 vt_window_postswitch(struct vt_window *vw)
173 {
174 
175 	signal_vt_acq(vw);
176 	return (0);
177 }
178 
179 /* vt_late_window_switch will done VT switching for regular case. */
180 static int
181 vt_late_window_switch(struct vt_window *vw)
182 {
183 	int ret;
184 
185 	callout_stop(&vw->vw_proc_dead_timer);
186 
187 	ret = vt_window_switch(vw);
188 	if (ret)
189 		return (ret);
190 
191 	/* Notify owner process about terminal availability. */
192 	if (vw->vw_smode.mode == VT_PROCESS) {
193 		ret = vt_window_postswitch(vw);
194 	}
195 	return (ret);
196 }
197 
198 /* Switch window. */
199 static int
200 vt_proc_window_switch(struct vt_window *vw)
201 {
202 	struct vt_window *curvw;
203 	struct vt_device *vd;
204 	int ret;
205 
206 	if (vw->vw_flags & VWF_VTYLOCK)
207 		return (EBUSY);
208 
209 	vd = vw->vw_device;
210 	curvw = vd->vd_curwindow;
211 
212 	/* Ask current process permitions to switch away. */
213 	if (curvw->vw_smode.mode == VT_PROCESS) {
214 		DPRINTF(30, "%s: VT_PROCESS ", __func__);
215 		if (vt_proc_alive(curvw) == FALSE) {
216 			DPRINTF(30, "Dead. Cleaning.");
217 			/* Dead */
218 		} else {
219 			DPRINTF(30, "%s: Signaling process.\n", __func__);
220 			/* Alive, try to ask him. */
221 			ret = vt_window_preswitch(vw, curvw);
222 			/* Wait for process answer or timeout. */
223 			return (ret);
224 		}
225 		DPRINTF(30, "\n");
226 	}
227 
228 	ret = vt_late_window_switch(vw);
229 	return (ret);
230 }
231 
232 /* Switch window ignoring process locking. */
233 static int
234 vt_window_switch(struct vt_window *vw)
235 {
236 	struct vt_device *vd = vw->vw_device;
237 	struct vt_window *curvw = vd->vd_curwindow;
238 	keyboard_t *kbd;
239 
240 	VT_LOCK(vd);
241 	if (curvw == vw) {
242 		/* Nothing to do. */
243 		VT_UNLOCK(vd);
244 		return (0);
245 	}
246 	if (!(vw->vw_flags & (VWF_OPENED|VWF_CONSOLE))) {
247 		VT_UNLOCK(vd);
248 		return (EINVAL);
249 	}
250 
251 	vd->vd_curwindow = vw;
252 	vd->vd_flags |= VDF_INVALID;
253 	cv_broadcast(&vd->vd_winswitch);
254 	VT_UNLOCK(vd);
255 
256 	if (vd->vd_driver->vd_postswitch)
257 		vd->vd_driver->vd_postswitch(vd);
258 
259 	/* Restore per-window keyboard mode. */
260 	mtx_lock(&Giant);
261 	kbd = kbd_get_keyboard(vd->vd_keyboard);
262 	if (kbd != NULL) {
263 		kbdd_ioctl(kbd, KDSKBMODE, (void *)&vw->vw_kbdmode);
264 	}
265 	mtx_unlock(&Giant);
266 	DPRINTF(10, "%s(ttyv%d) done\n", __func__, vw->vw_number);
267 
268 	return (0);
269 }
270 
271 static inline void
272 vt_termsize(struct vt_device *vd, struct vt_font *vf, term_pos_t *size)
273 {
274 
275 	size->tp_row = vd->vd_height;
276 	size->tp_col = vd->vd_width;
277 	if (vf != NULL) {
278 		size->tp_row /= vf->vf_height;
279 		size->tp_col /= vf->vf_width;
280 	}
281 }
282 
283 static inline void
284 vt_winsize(struct vt_device *vd, struct vt_font *vf, struct winsize *size)
285 {
286 
287 	size->ws_row = size->ws_ypixel = vd->vd_height;
288 	size->ws_col = size->ws_xpixel = vd->vd_width;
289 	if (vf != NULL) {
290 		size->ws_row /= vf->vf_height;
291 		size->ws_col /= vf->vf_width;
292 	}
293 }
294 
295 static void
296 vt_scroll(struct vt_window *vw, int offset, int whence)
297 {
298 	int diff;
299 	term_pos_t size;
300 
301 	if ((vw->vw_flags & VWF_SCROLL) == 0)
302 		return;
303 
304 	vt_termsize(vw->vw_device, vw->vw_font, &size);
305 
306 	diff = vthistory_seek(&vw->vw_buf, offset, whence);
307 	/*
308 	 * Offset changed, please update Nth lines on sceen.
309 	 * +N - Nth lines at top;
310 	 * -N - Nth lines at bottom.
311 	 */
312 
313 	if (diff < -size.tp_row || diff > size.tp_row) {
314 		vw->vw_device->vd_flags |= VDF_INVALID;
315 		return;
316 	}
317 	vw->vw_device->vd_flags |= VDF_INVALID; /*XXX*/
318 }
319 
320 static int
321 vt_machine_kbdevent(int c)
322 {
323 
324 	switch (c) {
325 	case SPCLKEY | DBG:
326 		kdb_enter(KDB_WHY_BREAK, "manual escape to debugger");
327 		return (1);
328 	case SPCLKEY | RBT:
329 		/* XXX: Make this configurable! */
330 		shutdown_nice(0);
331 		return (1);
332 	case SPCLKEY | HALT:
333 		shutdown_nice(RB_HALT);
334 		return (1);
335 	case SPCLKEY | PDWN:
336 		shutdown_nice(RB_HALT|RB_POWEROFF);
337 		return (1);
338 	};
339 
340 	return (0);
341 }
342 
343 static void
344 vt_scrollmode_kbdevent(struct vt_window *vw, int c, int console)
345 {
346 	struct vt_device *vd;
347 	term_pos_t size;
348 
349 	vd = vw->vw_device;
350 	/* Only special keys handled in ScrollLock mode */
351 	if ((c & SPCLKEY) == 0)
352 		return;
353 
354 	c &= ~SPCLKEY;
355 
356 	if (console == 0) {
357 		if (c >= F_SCR && c <= MIN(L_SCR, F_SCR + VT_MAXWINDOWS - 1)) {
358 			vw = vd->vd_windows[c - F_SCR];
359 			if (vw != NULL)
360 				vt_proc_window_switch(vw);
361 			return;
362 		}
363 		VT_LOCK(vd);
364 	}
365 
366 	switch (c) {
367 	case SLK: {
368 		/* Turn scrolling off. */
369 		vt_scroll(vw, 0, VHS_END);
370 		VTBUF_SLCK_DISABLE(&vw->vw_buf);
371 		vw->vw_flags &= ~VWF_SCROLL;
372 		break;
373 	}
374 	case FKEY | F(49): /* Home key. */
375 		vt_scroll(vw, 0, VHS_SET);
376 		break;
377 	case FKEY | F(50): /* Arrow up. */
378 		vt_scroll(vw, -1, VHS_CUR);
379 		break;
380 	case FKEY | F(51): /* Page up. */
381 		vt_termsize(vd, vw->vw_font, &size);
382 		vt_scroll(vw, -size.tp_row, VHS_CUR);
383 		break;
384 	case FKEY | F(57): /* End key. */
385 		vt_scroll(vw, 0, VHS_END);
386 		break;
387 	case FKEY | F(58): /* Arrow down. */
388 		vt_scroll(vw, 1, VHS_CUR);
389 		break;
390 	case FKEY | F(59): /* Page down. */
391 		vt_termsize(vd, vw->vw_font, &size);
392 		vt_scroll(vw, size.tp_row, VHS_CUR);
393 		break;
394 	}
395 
396 	if (console == 0)
397 		VT_UNLOCK(vd);
398 }
399 
400 static int
401 vt_processkey(keyboard_t *kbd, struct vt_device *vd, int c)
402 {
403 	struct vt_window *vw = vd->vd_curwindow;
404 	int state = 0;
405 
406 #if VT_ALT_TO_ESC_HACK
407 	if (c & RELKEY) {
408 		switch (c & ~RELKEY) {
409 		case (SPCLKEY | RALT):
410 			if (vt_enable_altgr != 0)
411 				break;
412 		case (SPCLKEY | LALT):
413 			vd->vd_kbstate &= ~ALKED;
414 		}
415 		/* Other keys ignored for RELKEY event. */
416 		return (0);
417 	} else {
418 		switch (c & ~RELKEY) {
419 		case (SPCLKEY | RALT):
420 			if (vt_enable_altgr != 0)
421 				break;
422 		case (SPCLKEY | LALT):
423 			vd->vd_kbstate |= ALKED;
424 		}
425 	}
426 #else
427 	if (c & RELKEY)
428 		/* Other keys ignored for RELKEY event. */
429 		return (0);
430 #endif
431 
432 	if (vt_machine_kbdevent(c))
433 		return (0);
434 
435 	if (vw->vw_flags & VWF_SCROLL) {
436 		vt_scrollmode_kbdevent(vw, c, 0/* Not a console */);
437 		/* Scroll mode keys handled, nothing to do more. */
438 		return (0);
439 	}
440 
441 	if (c & SPCLKEY) {
442 		c &= ~SPCLKEY;
443 
444 		if (c >= F_SCR && c <= MIN(L_SCR, F_SCR + VT_MAXWINDOWS - 1)) {
445 			vw = vd->vd_windows[c - F_SCR];
446 			if (vw != NULL)
447 				vt_proc_window_switch(vw);
448 			return (0);
449 		}
450 
451 		switch (c) {
452 		case SLK: {
453 
454 			kbdd_ioctl(kbd, KDGKBSTATE, (caddr_t)&state);
455 			VT_LOCK(vd);
456 			if (state & SLKED) {
457 				/* Turn scrolling on. */
458 				vw->vw_flags |= VWF_SCROLL;
459 				VTBUF_SLCK_ENABLE(&vw->vw_buf);
460 			} else {
461 				/* Turn scrolling off. */
462 				vw->vw_flags &= ~VWF_SCROLL;
463 				VTBUF_SLCK_DISABLE(&vw->vw_buf);
464 				vt_scroll(vw, 0, VHS_END);
465 			}
466 			VT_UNLOCK(vd);
467 			break;
468 		}
469 		case FKEY | F(1):  case FKEY | F(2):  case FKEY | F(3):
470 		case FKEY | F(4):  case FKEY | F(5):  case FKEY | F(6):
471 		case FKEY | F(7):  case FKEY | F(8):  case FKEY | F(9):
472 		case FKEY | F(10): case FKEY | F(11): case FKEY | F(12):
473 			/* F1 through F12 keys. */
474 			terminal_input_special(vw->vw_terminal,
475 			    TKEY_F1 + c - (FKEY | F(1)));
476 			break;
477 		case FKEY | F(49): /* Home key. */
478 			terminal_input_special(vw->vw_terminal, TKEY_HOME);
479 			break;
480 		case FKEY | F(50): /* Arrow up. */
481 			terminal_input_special(vw->vw_terminal, TKEY_UP);
482 			break;
483 		case FKEY | F(51): /* Page up. */
484 			terminal_input_special(vw->vw_terminal, TKEY_PAGE_UP);
485 			break;
486 		case FKEY | F(53): /* Arrow left. */
487 			terminal_input_special(vw->vw_terminal, TKEY_LEFT);
488 			break;
489 		case FKEY | F(55): /* Arrow right. */
490 			terminal_input_special(vw->vw_terminal, TKEY_RIGHT);
491 			break;
492 		case FKEY | F(57): /* End key. */
493 			terminal_input_special(vw->vw_terminal, TKEY_END);
494 			break;
495 		case FKEY | F(58): /* Arrow down. */
496 			terminal_input_special(vw->vw_terminal, TKEY_DOWN);
497 			break;
498 		case FKEY | F(59): /* Page down. */
499 			terminal_input_special(vw->vw_terminal, TKEY_PAGE_DOWN);
500 			break;
501 		case FKEY | F(60): /* Insert key. */
502 			terminal_input_special(vw->vw_terminal, TKEY_INSERT);
503 			break;
504 		case FKEY | F(61): /* Delete key. */
505 			terminal_input_special(vw->vw_terminal, TKEY_DELETE);
506 			break;
507 		}
508 	} else if (KEYFLAGS(c) == 0) {
509 		/* Don't do UTF-8 conversion when doing raw mode. */
510 		if (vw->vw_kbdmode == K_XLATE) {
511 #if VT_ALT_TO_ESC_HACK
512 			if (vd->vd_kbstate & ALKED) {
513 				/*
514 				 * Prepend ESC sequence if one of ALT keys down.
515 				 */
516 				terminal_input_char(vw->vw_terminal, 0x1b);
517 			}
518 #endif
519 
520 			terminal_input_char(vw->vw_terminal, KEYCHAR(c));
521 		} else
522 			terminal_input_raw(vw->vw_terminal, c);
523 	}
524 	return (0);
525 }
526 
527 static int
528 vt_kbdevent(keyboard_t *kbd, int event, void *arg)
529 {
530 	struct vt_device *vd = arg;
531 	int c;
532 
533 	switch (event) {
534 	case KBDIO_KEYINPUT:
535 		break;
536 	case KBDIO_UNLOADING:
537 		mtx_lock(&Giant);
538 		vd->vd_keyboard = -1;
539 		kbd_release(kbd, (void *)&vd->vd_keyboard);
540 		mtx_unlock(&Giant);
541 		return (0);
542 	default:
543 		return (EINVAL);
544 	}
545 
546 	while ((c = kbdd_read_char(kbd, 0)) != NOKEY)
547 		vt_processkey(kbd, vd, c);
548 
549 	return (0);
550 }
551 
552 static int
553 vt_allocate_keyboard(struct vt_device *vd)
554 {
555 	int		 idx0, idx;
556 	keyboard_t	*k0, *k;
557 	keyboard_info_t	 ki;
558 
559 	idx0 = kbd_allocate("kbdmux", -1, (void *)&vd->vd_keyboard,
560 	    vt_kbdevent, vd);
561 	/* XXX: kb_token lost */
562 	vd->vd_keyboard = idx0;
563 	if (idx0 != -1) {
564 		DPRINTF(20, "%s: kbdmux allocated, idx = %d\n", __func__, idx0);
565 		k0 = kbd_get_keyboard(idx0);
566 
567 		for (idx = kbd_find_keyboard2("*", -1, 0);
568 		     idx != -1;
569 		     idx = kbd_find_keyboard2("*", -1, idx + 1)) {
570 			k = kbd_get_keyboard(idx);
571 
572 			if (idx == idx0 || KBD_IS_BUSY(k))
573 				continue;
574 
575 			bzero(&ki, sizeof(ki));
576 			strcpy(ki.kb_name, k->kb_name);
577 			ki.kb_unit = k->kb_unit;
578 
579 			kbdd_ioctl(k0, KBADDKBD, (caddr_t) &ki);
580 		}
581 	} else {
582 		DPRINTF(20, "%s: no kbdmux allocated\n", __func__);
583 		idx0 = kbd_allocate("*", -1, (void *)&vd->vd_keyboard,
584 		    vt_kbdevent, vd);
585 	}
586 	DPRINTF(20, "%s: vd_keyboard = %d\n", __func__, vd->vd_keyboard);
587 
588 	return (idx0);
589 }
590 
591 static void
592 vtterm_bell(struct terminal *tm)
593 {
594 	struct vt_window *vw = tm->tm_softc;
595 	struct vt_device *vd = vw->vw_device;
596 
597 	if (vd->vd_flags & VDF_QUIET_BELL)
598 		return;
599 
600 	sysbeep(1193182 / VT_BELLPITCH, VT_BELLDURATION);
601 }
602 
603 static void
604 vtterm_cursor(struct terminal *tm, const term_pos_t *p)
605 {
606 	struct vt_window *vw = tm->tm_softc;
607 
608 	vtbuf_cursor_position(&vw->vw_buf, p);
609 }
610 
611 static void
612 vtterm_putchar(struct terminal *tm, const term_pos_t *p, term_char_t c)
613 {
614 	struct vt_window *vw = tm->tm_softc;
615 
616 	vtbuf_putchar(&vw->vw_buf, p, c);
617 }
618 
619 static void
620 vtterm_fill(struct terminal *tm, const term_rect_t *r, term_char_t c)
621 {
622 	struct vt_window *vw = tm->tm_softc;
623 
624 	vtbuf_fill_locked(&vw->vw_buf, r, c);
625 }
626 
627 static void
628 vtterm_copy(struct terminal *tm, const term_rect_t *r,
629     const term_pos_t *p)
630 {
631 	struct vt_window *vw = tm->tm_softc;
632 
633 	vtbuf_copy(&vw->vw_buf, r, p);
634 }
635 
636 static void
637 vtterm_param(struct terminal *tm, int cmd, unsigned int arg)
638 {
639 	struct vt_window *vw = tm->tm_softc;
640 
641 	switch (cmd) {
642 	case TP_SHOWCURSOR:
643 		vtbuf_cursor_visibility(&vw->vw_buf, arg);
644 		break;
645 	case TP_MOUSE:
646 		vw->vw_mouse_level = arg;
647 		break;
648 	}
649 }
650 
651 static inline void
652 vt_determine_colors(term_char_t c, int cursor,
653     term_color_t *fg, term_color_t *bg)
654 {
655 	term_color_t tmp;
656 	int invert;
657 
658 	invert = 0;
659 
660 	*fg = TCHAR_FGCOLOR(c);
661 	if (TCHAR_FORMAT(c) & TF_BOLD)
662 		*fg = TCOLOR_LIGHT(*fg);
663 	*bg = TCHAR_BGCOLOR(c);
664 
665 	if (TCHAR_FORMAT(c) & TF_REVERSE)
666 		invert ^= 1;
667 	if (cursor)
668 		invert ^= 1;
669 
670 	if (invert) {
671 		tmp = *fg;
672 		*fg = *bg;
673 		*bg = tmp;
674 	}
675 }
676 
677 static void
678 vt_bitblt_char(struct vt_device *vd, struct vt_font *vf, term_char_t c,
679     int iscursor, unsigned int row, unsigned int col)
680 {
681 	term_color_t fg, bg;
682 
683 	vt_determine_colors(c, iscursor, &fg, &bg);
684 
685 	if (vf != NULL) {
686 		const uint8_t *src;
687 		vt_axis_t top, left;
688 
689 		src = vtfont_lookup(vf, c);
690 
691 		/*
692 		 * Align the terminal to the centre of the screen.
693 		 * Fonts may not always be able to fill the entire
694 		 * screen.
695 		 */
696 		top = row * vf->vf_height + vd->vd_offset.tp_row;
697 		left = col * vf->vf_width + vd->vd_offset.tp_col;
698 
699 		vd->vd_driver->vd_bitbltchr(vd, src, NULL, 0, top, left,
700 		    vf->vf_width, vf->vf_height, fg, bg);
701 	} else {
702 		vd->vd_driver->vd_putchar(vd, TCHAR_CHARACTER(c),
703 		    row, col, fg, bg);
704 	}
705 }
706 
707 static void
708 vt_flush(struct vt_device *vd)
709 {
710 	struct vt_window *vw;
711 	struct vt_font *vf;
712 	struct vt_bufmask tmask;
713 	unsigned int row, col;
714 	term_rect_t tarea;
715 	term_pos_t size;
716 	term_char_t *r;
717 #ifndef SC_NO_CUTPASTE
718 	struct mouse_cursor *m;
719 	int bpl, h, w;
720 #endif
721 
722 	vw = vd->vd_curwindow;
723 	if (vw == NULL)
724 		return;
725 	vf = vw->vw_font;
726 	if (((vd->vd_flags & VDF_TEXTMODE) == 0) && (vf == NULL))
727 		return;
728 
729 	if (vd->vd_flags & VDF_SPLASH || vw->vw_flags & VWF_BUSY)
730 		return;
731 
732 	vtbuf_undirty(&vw->vw_buf, &tarea, &tmask);
733 	vt_termsize(vd, vf, &size);
734 
735 	/* Force a full redraw when the screen contents are invalid. */
736 	if (vd->vd_flags & VDF_INVALID) {
737 		tarea.tr_begin.tp_row = tarea.tr_begin.tp_col = 0;
738 		tarea.tr_end = size;
739 		tmask.vbm_row = tmask.vbm_col = VBM_DIRTY;
740 
741 		vd->vd_flags &= ~VDF_INVALID;
742 	}
743 
744 #ifndef SC_NO_CUTPASTE
745 	if ((vw->vw_flags & VWF_MOUSE_HIDE) == 0) {
746 		/* Mark last mouse position as dirty to erase. */
747 		vtbuf_mouse_cursor_position(&vw->vw_buf, vd->vd_mdirtyx,
748 		    vd->vd_mdirtyy);
749 	}
750 #endif
751 
752 	for (row = tarea.tr_begin.tp_row; row < tarea.tr_end.tp_row; row++) {
753 		if (!VTBUF_DIRTYROW(&tmask, row))
754 			continue;
755 		r = VTBUF_GET_ROW(&vw->vw_buf, row);
756 		for (col = tarea.tr_begin.tp_col;
757 		    col < tarea.tr_end.tp_col; col++) {
758 			if (!VTBUF_DIRTYCOL(&tmask, col))
759 				continue;
760 
761 			vt_bitblt_char(vd, vf, r[col],
762 			    VTBUF_ISCURSOR(&vw->vw_buf, row, col), row, col);
763 		}
764 	}
765 
766 #ifndef SC_NO_CUTPASTE
767 	/* Mouse disabled. */
768 	if (vw->vw_flags & VWF_MOUSE_HIDE)
769 		return;
770 
771 	/* No mouse for DDB. */
772 	if (kdb_active || panicstr != NULL)
773 		return;
774 
775 	if ((vd->vd_flags & (VDF_MOUSECURSOR|VDF_TEXTMODE)) ==
776 	    VDF_MOUSECURSOR) {
777 		m = &vt_default_mouse_pointer;
778 		bpl = (m->w + 7) >> 3; /* Bytes per sorce line. */
779 		w = m->w;
780 		h = m->h;
781 
782 		if ((vd->vd_mx + m->w) > (size.tp_col * vf->vf_width))
783 			w = (size.tp_col * vf->vf_width) - vd->vd_mx - 1;
784 		if ((vd->vd_my + m->h) > (size.tp_row * vf->vf_height))
785 			h = (size.tp_row * vf->vf_height) - vd->vd_my - 1;
786 
787 		vd->vd_driver->vd_maskbitbltchr(vd, m->map, m->mask, bpl,
788 		    vd->vd_offset.tp_row + vd->vd_my,
789 		    vd->vd_offset.tp_col + vd->vd_mx,
790 		    w, h, TC_WHITE, TC_BLACK);
791 		/* Save point of last mouse cursor to erase it later. */
792 		vd->vd_mdirtyx = vd->vd_mx / vf->vf_width;
793 		vd->vd_mdirtyy = vd->vd_my / vf->vf_height;
794 	}
795 #endif
796 }
797 
798 static void
799 vt_timer(void *arg)
800 {
801 	struct vt_device *vd;
802 
803 	vd = arg;
804 	/* Update screen if required. */
805 	vt_flush(vd);
806 
807 	/* Schedule for next update. */
808 	callout_schedule(&vd->vd_timer, hz / VT_TIMERFREQ);
809 }
810 
811 static void
812 vtterm_done(struct terminal *tm)
813 {
814 	struct vt_window *vw = tm->tm_softc;
815 	struct vt_device *vd = vw->vw_device;
816 
817 	if (kdb_active || panicstr != NULL) {
818 		/* Switch to the debugger. */
819 		if (vd->vd_curwindow != vw) {
820 			vd->vd_curwindow = vw;
821 			vd->vd_flags |= VDF_INVALID;
822 			if (vd->vd_driver->vd_postswitch)
823 				vd->vd_driver->vd_postswitch(vd);
824 		}
825 		vd->vd_flags &= ~VDF_SPLASH;
826 		vt_flush(vd);
827 	} else if (!(vd->vd_flags & VDF_ASYNC)) {
828 		vt_flush(vd);
829 	}
830 }
831 
832 #ifdef DEV_SPLASH
833 static void
834 vtterm_splash(struct vt_device *vd)
835 {
836 	vt_axis_t top, left;
837 
838 	/* Display a nice boot splash. */
839 	if (!(vd->vd_flags & VDF_TEXTMODE) && (boothowto & RB_MUTE)) {
840 
841 		top = (vd->vd_height - vt_logo_height) / 2;
842 		left = (vd->vd_width - vt_logo_width) / 2;
843 		switch (vt_logo_depth) {
844 		case 1:
845 			/* XXX: Unhardcode colors! */
846 			vd->vd_driver->vd_bitbltchr(vd, vt_logo_image, NULL, 0,
847 			    top, left, vt_logo_width, vt_logo_height, 0xf, 0x0);
848 		}
849 		vd->vd_flags |= VDF_SPLASH;
850 	}
851 }
852 #endif
853 
854 static void
855 vtterm_cnprobe(struct terminal *tm, struct consdev *cp)
856 {
857 	struct vt_window *vw = tm->tm_softc;
858 	struct vt_device *vd = vw->vw_device;
859 	struct winsize wsz;
860 
861 	if (vd->vd_flags & VDF_INITIALIZED)
862 		/* Initialization already done. */
863 		return;
864 
865 	cp->cn_pri = vd->vd_driver->vd_init(vd);
866 	if (cp->cn_pri == CN_DEAD) {
867 		vd->vd_flags |= VDF_DEAD;
868 		return;
869 	}
870 
871 	/* Initialize any early-boot keyboard drivers */
872 	kbd_configure(KB_CONF_PROBE_ONLY);
873 
874 	vd->vd_unit = atomic_fetchadd_int(&vt_unit, 1);
875 	vd->vd_windows[VT_CONSWINDOW] = vw;
876 	sprintf(cp->cn_name, "ttyv%r", VT_UNIT(vw));
877 
878 	if (!(vd->vd_flags & VDF_TEXTMODE))
879 		vw->vw_font = vtfont_ref(&vt_font_default);
880 
881 	vtbuf_init_early(&vw->vw_buf);
882 	vt_winsize(vd, vw->vw_font, &wsz);
883 	terminal_set_winsize(tm, &wsz);
884 
885 #ifdef DEV_SPLASH
886 	vtterm_splash(vd);
887 #endif
888 
889 	vd->vd_flags |= VDF_INITIALIZED;
890 	main_vd = vd;
891 }
892 
893 static int
894 vtterm_cngetc(struct terminal *tm)
895 {
896 	struct vt_window *vw = tm->tm_softc;
897 	struct vt_device *vd = vw->vw_device;
898 	keyboard_t *kbd;
899 	int state;
900 	u_int c;
901 
902 	if (vw->vw_kbdsq && *vw->vw_kbdsq)
903 		return (*vw->vw_kbdsq++);
904 
905 	state = 0;
906 	/* Make sure the splash screen is not there. */
907 	if (vd->vd_flags & VDF_SPLASH) {
908 		/* Remove splash */
909 		vd->vd_flags &= ~VDF_SPLASH;
910 		/* Mark screen as invalid to force update */
911 		vd->vd_flags |= VDF_INVALID;
912 		vt_flush(vd);
913 	}
914 
915 	/* Stripped down keyboard handler. */
916 	kbd = kbd_get_keyboard(vd->vd_keyboard);
917 	if (kbd == NULL)
918 		return (-1);
919 
920 	/* Force keyboard input mode to K_XLATE */
921 	c = K_XLATE;
922 	kbdd_ioctl(kbd, KDSKBMODE, (void *)&c);
923 
924 	/* Switch the keyboard to polling to make it work here. */
925 	kbdd_poll(kbd, TRUE);
926 	c = kbdd_read_char(kbd, 0);
927 	kbdd_poll(kbd, FALSE);
928 	if (c & RELKEY)
929 		return (-1);
930 
931 	if (vw->vw_flags & VWF_SCROLL) {
932 		vt_scrollmode_kbdevent(vw, c, 1/* Console mode */);
933 		vt_flush(vd);
934 		return (-1);
935 	}
936 
937 	/* Stripped down handling of vt_kbdevent(), without locking, etc. */
938 	if (c & SPCLKEY) {
939 		switch (c) {
940 		case SPCLKEY | SLK:
941 			kbdd_ioctl(kbd, KDGKBSTATE, (caddr_t)&state);
942 			if (state & SLKED) {
943 				/* Turn scrolling on. */
944 				vw->vw_flags |= VWF_SCROLL;
945 				VTBUF_SLCK_ENABLE(&vw->vw_buf);
946 			} else {
947 				/* Turn scrolling off. */
948 				vt_scroll(vw, 0, VHS_END);
949 				vw->vw_flags &= ~VWF_SCROLL;
950 				VTBUF_SLCK_DISABLE(&vw->vw_buf);
951 			}
952 			break;
953 		/* XXX: KDB can handle history. */
954 		case SPCLKEY | FKEY | F(50): /* Arrow up. */
955 			vw->vw_kbdsq = "\x1b[A";
956 			break;
957 		case SPCLKEY | FKEY | F(58): /* Arrow down. */
958 			vw->vw_kbdsq = "\x1b[B";
959 			break;
960 		case SPCLKEY | FKEY | F(55): /* Arrow right. */
961 			vw->vw_kbdsq = "\x1b[C";
962 			break;
963 		case SPCLKEY | FKEY | F(53): /* Arrow left. */
964 			vw->vw_kbdsq = "\x1b[D";
965 			break;
966 		}
967 
968 		/* Force refresh to make scrollback work. */
969 		vt_flush(vd);
970 	} else if (KEYFLAGS(c) == 0) {
971 		return (KEYCHAR(c));
972 	}
973 
974 	if (vw->vw_kbdsq && *vw->vw_kbdsq)
975 		return (*vw->vw_kbdsq++);
976 
977 	return (-1);
978 }
979 
980 static void
981 vtterm_opened(struct terminal *tm, int opened)
982 {
983 	struct vt_window *vw = tm->tm_softc;
984 	struct vt_device *vd = vw->vw_device;
985 
986 	VT_LOCK(vd);
987 	vd->vd_flags &= ~VDF_SPLASH;
988 	if (opened)
989 		vw->vw_flags |= VWF_OPENED;
990 	else {
991 		vw->vw_flags &= ~VWF_OPENED;
992 		/* TODO: finish ACQ/REL */
993 	}
994 	VT_UNLOCK(vd);
995 }
996 
997 static int
998 vt_change_font(struct vt_window *vw, struct vt_font *vf)
999 {
1000 	struct vt_device *vd = vw->vw_device;
1001 	struct terminal *tm = vw->vw_terminal;
1002 	term_pos_t size;
1003 	struct winsize wsz;
1004 
1005 	/*
1006 	 * Changing fonts.
1007 	 *
1008 	 * Changing fonts is a little tricky.  We must prevent
1009 	 * simultaneous access to the device, so we must stop
1010 	 * the display timer and the terminal from accessing.
1011 	 * We need to switch fonts and grow our screen buffer.
1012 	 *
1013 	 * XXX: Right now the code uses terminal_mute() to
1014 	 * prevent data from reaching the console driver while
1015 	 * resizing the screen buffer.  This isn't elegant...
1016 	 */
1017 
1018 	VT_LOCK(vd);
1019 	if (vw->vw_flags & VWF_BUSY) {
1020 		/* Another process is changing the font. */
1021 		VT_UNLOCK(vd);
1022 		return (EBUSY);
1023 	}
1024 	if (vw->vw_font == NULL) {
1025 		/* Our device doesn't need fonts. */
1026 		VT_UNLOCK(vd);
1027 		return (ENOTTY);
1028 	}
1029 	vw->vw_flags |= VWF_BUSY;
1030 	VT_UNLOCK(vd);
1031 
1032 	vt_termsize(vd, vf, &size);
1033 	vt_winsize(vd, vf, &wsz);
1034 	/* Save offset to font aligned area. */
1035 	vd->vd_offset.tp_col = (vd->vd_width % vf->vf_width) / 2;
1036 	vd->vd_offset.tp_row = (vd->vd_height % vf->vf_height) / 2;
1037 
1038 	/* Grow the screen buffer and terminal. */
1039 	terminal_mute(tm, 1);
1040 	vtbuf_grow(&vw->vw_buf, &size, vw->vw_buf.vb_history_size);
1041 	terminal_set_winsize_blank(tm, &wsz, 0);
1042 	terminal_mute(tm, 0);
1043 
1044 	/* Actually apply the font to the current window. */
1045 	VT_LOCK(vd);
1046 	vtfont_unref(vw->vw_font);
1047 	vw->vw_font = vtfont_ref(vf);
1048 
1049 	/* Force a full redraw the next timer tick. */
1050 	if (vd->vd_curwindow == vw)
1051 		vd->vd_flags |= VDF_INVALID;
1052 	vw->vw_flags &= ~VWF_BUSY;
1053 	VT_UNLOCK(vd);
1054 	return (0);
1055 }
1056 
1057 static int
1058 vt_set_border(struct vt_window *vw, struct vt_font *vf, term_color_t c)
1059 {
1060 	struct vt_device *vd = vw->vw_device;
1061 	int l, r, t, b, w, h;
1062 
1063 	if (vd->vd_driver->vd_drawrect == NULL)
1064 		return (ENOTSUP);
1065 
1066 	w = vd->vd_width - 1;
1067 	h = vd->vd_height - 1;
1068 	l = vd->vd_offset.tp_col - 1;
1069 	r = w - l;
1070 	t = vd->vd_offset.tp_row - 1;
1071 	b = h - t;
1072 
1073 	vd->vd_driver->vd_drawrect(vd, 0, 0, w, t, 1, c); /* Top bar. */
1074 	vd->vd_driver->vd_drawrect(vd, 0, t, l, b, 1, c); /* Left bar. */
1075 	vd->vd_driver->vd_drawrect(vd, r, t, w, b, 1, c); /* Right bar. */
1076 	vd->vd_driver->vd_drawrect(vd, 0, b, w, h, 1, c); /* Bottom bar. */
1077 
1078 	return (0);
1079 }
1080 
1081 static int
1082 vt_proc_alive(struct vt_window *vw)
1083 {
1084 	struct proc *p;
1085 
1086 	if (vw->vw_smode.mode != VT_PROCESS)
1087 		return (FALSE);
1088 
1089 	if (vw->vw_proc) {
1090 		if ((p = pfind(vw->vw_pid)) != NULL)
1091 			PROC_UNLOCK(p);
1092 		if (vw->vw_proc == p)
1093 			return (TRUE);
1094 		vw->vw_proc = NULL;
1095 		vw->vw_smode.mode = VT_AUTO;
1096 		DPRINTF(1, "vt controlling process %d died\n", vw->vw_pid);
1097 		vw->vw_pid = 0;
1098 	}
1099 	return (FALSE);
1100 }
1101 
1102 static int
1103 signal_vt_rel(struct vt_window *vw)
1104 {
1105 
1106 	if (vw->vw_smode.mode != VT_PROCESS)
1107 		return (FALSE);
1108 	if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1109 		vw->vw_proc = NULL;
1110 		vw->vw_pid = 0;
1111 		return (TRUE);
1112 	}
1113 	vw->vw_flags |= VWF_SWWAIT_REL;
1114 	PROC_LOCK(vw->vw_proc);
1115 	kern_psignal(vw->vw_proc, vw->vw_smode.relsig);
1116 	PROC_UNLOCK(vw->vw_proc);
1117 	DPRINTF(1, "sending relsig to %d\n", vw->vw_pid);
1118 	return (TRUE);
1119 }
1120 
1121 static int
1122 signal_vt_acq(struct vt_window *vw)
1123 {
1124 
1125 	if (vw->vw_smode.mode != VT_PROCESS)
1126 		return (FALSE);
1127 	if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1128 		cnavailable(vw->vw_terminal->consdev, FALSE);
1129 	if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1130 		vw->vw_proc = NULL;
1131 		vw->vw_pid = 0;
1132 		return (TRUE);
1133 	}
1134 	vw->vw_flags |= VWF_SWWAIT_ACQ;
1135 	PROC_LOCK(vw->vw_proc);
1136 	kern_psignal(vw->vw_proc, vw->vw_smode.acqsig);
1137 	PROC_UNLOCK(vw->vw_proc);
1138 	DPRINTF(1, "sending acqsig to %d\n", vw->vw_pid);
1139 	return (TRUE);
1140 }
1141 
1142 static int
1143 finish_vt_rel(struct vt_window *vw, int release, int *s)
1144 {
1145 
1146 	if (vw->vw_flags & VWF_SWWAIT_REL) {
1147 		vw->vw_flags &= ~VWF_SWWAIT_REL;
1148 		if (release) {
1149 			callout_drain(&vw->vw_proc_dead_timer);
1150 			vt_late_window_switch(vw->vw_switch_to);
1151 		}
1152 		return (0);
1153 	}
1154 	return (EINVAL);
1155 }
1156 
1157 static int
1158 finish_vt_acq(struct vt_window *vw)
1159 {
1160 
1161 	if (vw->vw_flags & VWF_SWWAIT_ACQ) {
1162 		vw->vw_flags &= ~VWF_SWWAIT_ACQ;
1163 		return (0);
1164 	}
1165 	return (EINVAL);
1166 }
1167 
1168 #ifndef SC_NO_CUTPASTE
1169 static void
1170 vt_mouse_terminput_button(struct vt_device *vd, int button)
1171 {
1172 	struct vt_window *vw;
1173 	struct vt_font *vf;
1174 	char mouseb[6] = "\x1B[M";
1175 	int i, x, y;
1176 
1177 	vw = vd->vd_curwindow;
1178 	vf = vw->vw_font;
1179 
1180 	/* Translate to char position. */
1181 	x = vd->vd_mx / vf->vf_width;
1182 	y = vd->vd_my / vf->vf_height;
1183 	/* Avoid overflow. */
1184 	x = MIN(x, 255 - '!');
1185 	y = MIN(y, 255 - '!');
1186 
1187 	mouseb[3] = ' ' + button;
1188 	mouseb[4] = '!' + x;
1189 	mouseb[5] = '!' + y;
1190 
1191 	for (i = 0; i < sizeof(mouseb); i++ )
1192 		terminal_input_char(vw->vw_terminal, mouseb[i]);
1193 }
1194 
1195 static void
1196 vt_mouse_terminput(struct vt_device *vd, int type, int x, int y, int event,
1197     int cnt)
1198 {
1199 
1200 	switch (type) {
1201 	case MOUSE_BUTTON_EVENT:
1202 		if (cnt > 0) {
1203 			/* Mouse button pressed. */
1204 			if (event & MOUSE_BUTTON1DOWN)
1205 				vt_mouse_terminput_button(vd, 0);
1206 			if (event & MOUSE_BUTTON2DOWN)
1207 				vt_mouse_terminput_button(vd, 1);
1208 			if (event & MOUSE_BUTTON3DOWN)
1209 				vt_mouse_terminput_button(vd, 2);
1210 		} else {
1211 			/* Mouse button released. */
1212 			vt_mouse_terminput_button(vd, 3);
1213 		}
1214 		break;
1215 #ifdef notyet
1216 	case MOUSE_MOTION_EVENT:
1217 		if (mouse->u.data.z < 0) {
1218 			/* Scroll up. */
1219 			sc_mouse_input_button(vd, 64);
1220 		} else if (mouse->u.data.z > 0) {
1221 			/* Scroll down. */
1222 			sc_mouse_input_button(vd, 65);
1223 		}
1224 		break;
1225 #endif
1226 	}
1227 }
1228 
1229 void
1230 vt_mouse_event(int type, int x, int y, int event, int cnt, int mlevel)
1231 {
1232 	struct vt_device *vd;
1233 	struct vt_window *vw;
1234 	struct vt_font *vf;
1235 	term_pos_t size;
1236 	term_char_t *buf;
1237 	int i, len, mark;
1238 
1239 	vd = main_vd;
1240 	vw = vd->vd_curwindow;
1241 	vf = vw->vw_font;
1242 	mark = 0;
1243 
1244 	if (vw->vw_flags & VWF_MOUSE_HIDE)
1245 		return; /* Mouse disabled. */
1246 
1247 	if (vf == NULL)	/* Text mode. */
1248 		return;
1249 
1250 	/*
1251 	 * TODO: add flag about pointer position changed, to not redraw chars
1252 	 * under mouse pointer when nothing changed.
1253 	 */
1254 
1255 	if (vw->vw_mouse_level > 0)
1256 		vt_mouse_terminput(vd, type, x, y, event, cnt);
1257 
1258 	switch (type) {
1259 	case MOUSE_ACTION:
1260 	case MOUSE_MOTION_EVENT:
1261 		/* Movement */
1262 		x += vd->vd_mx;
1263 		y += vd->vd_my;
1264 
1265 		vt_termsize(vd, vf, &size);
1266 
1267 		/* Apply limits. */
1268 		x = MAX(x, 0);
1269 		y = MAX(y, 0);
1270 		x = MIN(x, (size.tp_col * vf->vf_width) - 1);
1271 		y = MIN(y, (size.tp_row * vf->vf_height) - 1);
1272 
1273 		vd->vd_mx = x;
1274 		vd->vd_my = y;
1275 		if ((vd->vd_mstate & MOUSE_BUTTON1DOWN) &&
1276 		    (vtbuf_set_mark(&vw->vw_buf, VTB_MARK_MOVE,
1277 			vd->vd_mx / vf->vf_width,
1278 			vd->vd_my / vf->vf_height) == 1)) {
1279 
1280 			/*
1281 			 * We have something marked to copy, so update pointer
1282 			 * to window with selection.
1283 			 */
1284 			vd->vd_markedwin = vw;
1285 		}
1286 		return; /* Done */
1287 	case MOUSE_BUTTON_EVENT:
1288 		/* Buttons */
1289 		break;
1290 	default:
1291 		return; /* Done */
1292 	}
1293 
1294 	switch (event) {
1295 	case MOUSE_BUTTON1DOWN:
1296 		switch (cnt % 4) {
1297 		case 0:	/* up */
1298 			mark = VTB_MARK_END;
1299 			break;
1300 		case 1: /* single click: start cut operation */
1301 			mark = VTB_MARK_START;
1302 			break;
1303 		case 2:	/* double click: cut a word */
1304 			mark = VTB_MARK_WORD;
1305 			break;
1306 		case 3:	/* triple click: cut a line */
1307 			mark = VTB_MARK_ROW;
1308 			break;
1309 		}
1310 		break;
1311 	case VT_MOUSE_PASTEBUTTON:
1312 		switch (cnt) {
1313 		case 0:	/* up */
1314 			break;
1315 		default:
1316 			if (vd->vd_markedwin == NULL)
1317 				return;
1318 			/* Get current selecton size in bytes. */
1319 			len = vtbuf_get_marked_len(&vd->vd_markedwin->vw_buf);
1320 			if (len <= 0)
1321 				return;
1322 
1323 			buf = malloc(len, M_VT, M_WAITOK | M_ZERO);
1324 			/* Request cupy/paste buffer data, no more than `len' */
1325 			vtbuf_extract_marked(&vd->vd_markedwin->vw_buf, buf,
1326 			    len);
1327 
1328 			len /= sizeof(term_char_t);
1329 			for (i = 0; i < len; i++ ) {
1330 				if (buf[i] == '\0')
1331 					continue;
1332 				terminal_input_char(vw->vw_terminal, buf[i]);
1333 			}
1334 
1335 			/* Done, so cleanup. */
1336 			free(buf, M_VT);
1337 			break;
1338 		}
1339 		return; /* Done */
1340 	case VT_MOUSE_EXTENDBUTTON:
1341 		switch (cnt) {
1342 		case 0:	/* up */
1343 			if (!(vd->vd_mstate & MOUSE_BUTTON1DOWN))
1344 				mark = VTB_MARK_EXTEND;
1345 			else
1346 				mark = 0;
1347 			break;
1348 		default:
1349 			mark = VTB_MARK_EXTEND;
1350 			break;
1351 		}
1352 		break;
1353 	default:
1354 		return; /* Done */
1355 	}
1356 
1357 	/* Save buttons state. */
1358 	if (cnt > 0)
1359 		vd->vd_mstate |= event;
1360 	else
1361 		vd->vd_mstate &= ~event;
1362 
1363 	if (vtbuf_set_mark(&vw->vw_buf, mark, vd->vd_mx / vf->vf_width,
1364 	    vd->vd_my / vf->vf_height) == 1) {
1365 		/*
1366 		 * We have something marked to copy, so update pointer to
1367 		 * window with selection.
1368 		 */
1369 		vd->vd_markedwin = vw;
1370 	}
1371 }
1372 
1373 void
1374 vt_mouse_state(int show)
1375 {
1376 	struct vt_device *vd;
1377 	struct vt_window *vw;
1378 
1379 	vd = main_vd;
1380 	vw = vd->vd_curwindow;
1381 
1382 	switch (show) {
1383 	case VT_MOUSE_HIDE:
1384 		vw->vw_flags |= VWF_MOUSE_HIDE;
1385 		break;
1386 	case VT_MOUSE_SHOW:
1387 		vw->vw_flags &= ~VWF_MOUSE_HIDE;
1388 		break;
1389 	}
1390 }
1391 #endif
1392 
1393 static int
1394 vtterm_mmap(struct terminal *tm, vm_ooffset_t offset, vm_paddr_t * paddr,
1395     int nprot, vm_memattr_t *memattr)
1396 {
1397 	struct vt_window *vw = tm->tm_softc;
1398 	struct vt_device *vd = vw->vw_device;
1399 
1400 	if (vd->vd_driver->vd_fb_mmap)
1401 		return (vd->vd_driver->vd_fb_mmap(vd, offset, paddr, nprot,
1402 		    memattr));
1403 
1404 	return (ENXIO);
1405 }
1406 
1407 static int
1408 vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data,
1409     struct thread *td)
1410 {
1411 	struct vt_window *vw = tm->tm_softc;
1412 	struct vt_device *vd = vw->vw_device;
1413 	keyboard_t *kbd;
1414 	int error, i, s;
1415 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1416     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1417 	int ival;
1418 
1419 	switch (cmd) {
1420 	case _IO('v', 4):
1421 		cmd = VT_RELDISP;
1422 		break;
1423 	case _IO('v', 5):
1424 		cmd = VT_ACTIVATE;
1425 		break;
1426 	case _IO('v', 6):
1427 		cmd = VT_WAITACTIVE;
1428 		break;
1429 	case _IO('K', 20):
1430 		cmd = KDSKBSTATE;
1431 		break;
1432 	case _IO('K', 67):
1433 		cmd = KDSETRAD;
1434 		break;
1435 	case _IO('K', 7):
1436 		cmd = KDSKBMODE;
1437 		break;
1438 	case _IO('K', 8):
1439 		cmd = KDMKTONE;
1440 		break;
1441 	case _IO('K', 63):
1442 		cmd = KIOCSOUND;
1443 		break;
1444 	case _IO('K', 66):
1445 		cmd = KDSETLED;
1446 		break;
1447 	case _IO('c', 110):
1448 		cmd = CONS_SETKBD;
1449 		break;
1450 	default:
1451 		goto skip_thunk;
1452 	}
1453 	ival = IOCPARM_IVAL(data);
1454 	data = (caddr_t)&ival;
1455 skip_thunk:
1456 #endif
1457 
1458 	switch (cmd) {
1459 	case KDSETRAD:		/* set keyboard repeat & delay rates (old) */
1460 		if (*(int *)data & ~0x7f)
1461 			return (EINVAL);
1462 	case GIO_KEYMAP:
1463 	case PIO_KEYMAP:
1464 	case GIO_DEADKEYMAP:
1465 	case PIO_DEADKEYMAP:
1466 	case GETFKEY:
1467 	case SETFKEY:
1468 	case KDGKBINFO:
1469 	case KDGKBTYPE:
1470 	case KDSKBSTATE:	/* set keyboard state (locks) */
1471 	case KDGKBSTATE:	/* get keyboard state (locks) */
1472 	case KDGETREPEAT:	/* get keyboard repeat & delay rates */
1473 	case KDSETREPEAT:	/* set keyboard repeat & delay rates (new) */
1474 	case KDSETLED:		/* set keyboard LED status */
1475 	case KDGETLED:		/* get keyboard LED status */
1476 	case KBADDKBD:		/* add/remove keyboard to/from mux */
1477 	case KBRELKBD: {
1478 		error = 0;
1479 
1480 		mtx_lock(&Giant);
1481 		kbd = kbd_get_keyboard(vd->vd_keyboard);
1482 		if (kbd != NULL)
1483 			error = kbdd_ioctl(kbd, cmd, data);
1484 		mtx_unlock(&Giant);
1485 		if (error == ENOIOCTL) {
1486 			if (cmd == KDGKBTYPE) {
1487 				/* always return something? XXX */
1488 				*(int *)data = 0;
1489 			} else {
1490 				return (ENODEV);
1491 			}
1492 		}
1493 		return (error);
1494 	}
1495 	case KDGKBMODE: {
1496 		int mode = -1;
1497 
1498 		mtx_lock(&Giant);
1499 		kbd = kbd_get_keyboard(vd->vd_keyboard);
1500 		if (kbd != NULL) {
1501 			kbdd_ioctl(kbd, KDGKBMODE, (void *)&mode);
1502 		}
1503 		mtx_unlock(&Giant);
1504 		DPRINTF(20, "mode %d, vw_kbdmode %d\n", mode, vw->vw_kbdmode);
1505 		*(int *)data = mode;
1506 		return (0);
1507 	}
1508 	case KDSKBMODE: {
1509 		int mode;
1510 
1511 		mode = *(int *)data;
1512 		switch (mode) {
1513 		case K_XLATE:
1514 		case K_RAW:
1515 		case K_CODE:
1516 			vw->vw_kbdmode = mode;
1517 			if (vw == vd->vd_curwindow) {
1518 				keyboard_t *kbd;
1519 				error = 0;
1520 
1521 				mtx_lock(&Giant);
1522 				kbd = kbd_get_keyboard(vd->vd_keyboard);
1523 				if (kbd != NULL) {
1524 					error = kbdd_ioctl(kbd, KDSKBMODE,
1525 					    (void *)&mode);
1526 				}
1527 				mtx_unlock(&Giant);
1528 			}
1529 			return (0);
1530 		default:
1531 			return (EINVAL);
1532 		}
1533 	}
1534 	case FBIOGTYPE:
1535 	case FBIO_GETWINORG:	/* get frame buffer window origin */
1536 	case FBIO_GETDISPSTART:	/* get display start address */
1537 	case FBIO_GETLINEWIDTH:	/* get scan line width in bytes */
1538 	case FBIO_BLANK:	/* blank display */
1539 		if (vd->vd_driver->vd_fb_ioctl)
1540 			return (vd->vd_driver->vd_fb_ioctl(vd, cmd, data, td));
1541 		break;
1542 	case CONS_BLANKTIME:
1543 		/* XXX */
1544 		return (0);
1545 	case CONS_GET:
1546 		/* XXX */
1547 		*(int *)data = M_CG640x480;
1548 		return (0);
1549 	case CONS_BELLTYPE: 	/* set bell type sound */
1550 		if ((*(int *)data) & CONS_QUIET_BELL)
1551 			vd->vd_flags |= VDF_QUIET_BELL;
1552 		else
1553 			vd->vd_flags &= ~VDF_QUIET_BELL;
1554 		return (0);
1555 	case CONS_GETINFO: {
1556 		vid_info_t *vi = (vid_info_t *)data;
1557 
1558 		vi->m_num = vd->vd_curwindow->vw_number + 1;
1559 		/* XXX: other fields! */
1560 		return (0);
1561 	}
1562 	case CONS_GETVERS:
1563 		*(int *)data = 0x200;
1564 		return (0);
1565 	case CONS_MODEINFO:
1566 		/* XXX */
1567 		return (0);
1568 	case CONS_MOUSECTL: {
1569 		mouse_info_t *mouse = (mouse_info_t*)data;
1570 
1571 		/*
1572 		 * This has no effect on vt(4).  We don't draw any mouse
1573 		 * cursor.  Just ignore MOUSE_HIDE and MOUSE_SHOW to
1574 		 * prevent excessive errors.  All the other commands
1575 		 * should not be applied to individual TTYs, but only to
1576 		 * consolectl.
1577 		 */
1578 		switch (mouse->operation) {
1579 		case MOUSE_HIDE:
1580 			vd->vd_flags &= ~VDF_MOUSECURSOR;
1581 			return (0);
1582 		case MOUSE_SHOW:
1583 			vd->vd_mx = vd->vd_width / 2;
1584 			vd->vd_my = vd->vd_height / 2;
1585 			vd->vd_flags |= VDF_MOUSECURSOR;
1586 			return (0);
1587 		default:
1588 			return (EINVAL);
1589 		}
1590 	}
1591 	case PIO_VFONT: {
1592 		struct vt_font *vf;
1593 
1594 		error = vtfont_load((void *)data, &vf);
1595 		if (error != 0)
1596 			return (error);
1597 
1598 		error = vt_change_font(vw, vf);
1599 		if (error == 0) {
1600 			/* XXX: replace 0 with current bg color. */
1601 			vt_set_border(vw, vf, 0);
1602 		}
1603 		vtfont_unref(vf);
1604 		return (error);
1605 	}
1606 	case GIO_SCRNMAP: {
1607 		scrmap_t *sm = (scrmap_t *)data;
1608 		int i;
1609 
1610 		/* We don't have screen maps, so return a handcrafted one. */
1611 		for (i = 0; i < 256; i++)
1612 			sm->scrmap[i] = i;
1613 		return (0);
1614 	}
1615 	case KDSETMODE:
1616 		/* XXX */
1617 		return (0);
1618 	case KDENABIO:      	/* allow io operations */
1619 		error = priv_check(td, PRIV_IO);
1620 		if (error != 0)
1621 			return (error);
1622 		error = securelevel_gt(td->td_ucred, 0);
1623 		if (error != 0)
1624 			return (error);
1625 #if defined(__i386__)
1626 		td->td_frame->tf_eflags |= PSL_IOPL;
1627 #elif defined(__amd64__)
1628 		td->td_frame->tf_rflags |= PSL_IOPL;
1629 #endif
1630 		return (0);
1631 	case KDDISABIO:     	/* disallow io operations (default) */
1632 #if defined(__i386__)
1633 		td->td_frame->tf_eflags &= ~PSL_IOPL;
1634 #elif defined(__amd64__)
1635 		td->td_frame->tf_rflags &= ~PSL_IOPL;
1636 #endif
1637 		return (0);
1638 	case KDMKTONE:      	/* sound the bell */
1639 		/* TODO */
1640 		return (0);
1641 	case KIOCSOUND:     	/* make tone (*data) hz */
1642 		/* TODO */
1643 		return (0);
1644 	case CONS_SETKBD: 		/* set the new keyboard */
1645 		mtx_lock(&Giant);
1646 		error = 0;
1647 		if (vd->vd_keyboard != *(int *)data) {
1648 			kbd = kbd_get_keyboard(*(int *)data);
1649 			if (kbd == NULL) {
1650 				mtx_unlock(&Giant);
1651 				return (EINVAL);
1652 			}
1653 			i = kbd_allocate(kbd->kb_name, kbd->kb_unit,
1654 			    (void *)&vd->vd_keyboard, vt_kbdevent, vd);
1655 			if (i >= 0) {
1656 				if (vd->vd_keyboard != -1) {
1657 					kbd_release(kbd,
1658 					    (void *)&vd->vd_keyboard);
1659 				}
1660 				kbd = kbd_get_keyboard(i);
1661 				vd->vd_keyboard = i;
1662 
1663 				(void)kbdd_ioctl(kbd, KDSKBMODE,
1664 				    (caddr_t)&vd->vd_curwindow->vw_kbdmode);
1665 			} else {
1666 				error = EPERM;	/* XXX */
1667 			}
1668 		}
1669 		mtx_unlock(&Giant);
1670 		return (error);
1671 	case CONS_RELKBD: 		/* release the current keyboard */
1672 		mtx_lock(&Giant);
1673 		error = 0;
1674 		if (vd->vd_keyboard != -1) {
1675 			kbd = kbd_get_keyboard(vd->vd_keyboard);
1676 			if (kbd == NULL) {
1677 				mtx_unlock(&Giant);
1678 				return (EINVAL);
1679 			}
1680 			error = kbd_release(kbd, (void *)&vd->vd_keyboard);
1681 			if (error == 0) {
1682 				vd->vd_keyboard = -1;
1683 			}
1684 		}
1685 		mtx_unlock(&Giant);
1686 		return (error);
1687 	case VT_ACTIVATE: {
1688 		int win;
1689 		win = *(int *)data - 1;
1690 		DPRINTF(5, "%s%d: VT_ACTIVATE ttyv%d ", SC_DRIVER_NAME,
1691 		    VT_UNIT(vw), win);
1692 		if ((win > VT_MAXWINDOWS) || (win < 0))
1693 			return (EINVAL);
1694 		return (vt_proc_window_switch(vd->vd_windows[win]));
1695 	}
1696 	case VT_GETACTIVE:
1697 		*(int *)data = vd->vd_curwindow->vw_number + 1;
1698 		return (0);
1699 	case VT_GETINDEX:
1700 		*(int *)data = vw->vw_number + 1;
1701 		return (0);
1702 	case VT_LOCKSWITCH:
1703 		/* TODO: Check current state, switching can be in progress. */
1704 		if ((*(int *)data) & 0x01)
1705 			vw->vw_flags |= VWF_VTYLOCK;
1706 		else
1707 			vw->vw_flags &= ~VWF_VTYLOCK;
1708 	case VT_OPENQRY:
1709 		VT_LOCK(vd);
1710 		for (i = 0; i < VT_MAXWINDOWS; i++) {
1711 			vw = vd->vd_windows[i];
1712 			if (vw == NULL)
1713 				continue;
1714 			if (!(vw->vw_flags & VWF_OPENED)) {
1715 				*(int *)data = vw->vw_number + 1;
1716 				VT_UNLOCK(vd);
1717 				return (0);
1718 			}
1719 		}
1720 		VT_UNLOCK(vd);
1721 		return (EINVAL);
1722 	case VT_WAITACTIVE:
1723 		error = 0;
1724 
1725 		i = *(unsigned int *)data;
1726 		if (i > VT_MAXWINDOWS)
1727 			return (EINVAL);
1728 		if (i != 0)
1729 			vw = vd->vd_windows[i - 1];
1730 
1731 		VT_LOCK(vd);
1732 		while (vd->vd_curwindow != vw && error == 0)
1733 			error = cv_wait_sig(&vd->vd_winswitch, &vd->vd_lock);
1734 		VT_UNLOCK(vd);
1735 		return (error);
1736 	case VT_SETMODE: {    	/* set screen switcher mode */
1737 		struct vt_mode *mode;
1738 		struct proc *p1;
1739 
1740 		mode = (struct vt_mode *)data;
1741 		DPRINTF(5, "%s%d: VT_SETMODE ", SC_DRIVER_NAME, VT_UNIT(vw));
1742 		if (vw->vw_smode.mode == VT_PROCESS) {
1743 			p1 = pfind(vw->vw_pid);
1744 			if (vw->vw_proc == p1 && vw->vw_proc != td->td_proc) {
1745 				if (p1)
1746 					PROC_UNLOCK(p1);
1747 				DPRINTF(5, "error EPERM\n");
1748 				return (EPERM);
1749 			}
1750 			if (p1)
1751 				PROC_UNLOCK(p1);
1752 		}
1753 		if (mode->mode == VT_AUTO) {
1754 			vw->vw_smode.mode = VT_AUTO;
1755 			vw->vw_proc = NULL;
1756 			vw->vw_pid = 0;
1757 			DPRINTF(5, "VT_AUTO, ");
1758 			if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1759 				cnavailable(vw->vw_terminal->consdev, TRUE);
1760 			/* were we in the middle of the vty switching process? */
1761 			if (finish_vt_rel(vw, TRUE, &s) == 0)
1762 				DPRINTF(5, "reset WAIT_REL, ");
1763 			if (finish_vt_acq(vw) == 0)
1764 				DPRINTF(5, "reset WAIT_ACQ, ");
1765 			return (0);
1766 		} else if (mode->mode == VT_PROCESS) {
1767 			if (!ISSIGVALID(mode->relsig) ||
1768 			    !ISSIGVALID(mode->acqsig) ||
1769 			    !ISSIGVALID(mode->frsig)) {
1770 				DPRINTF(5, "error EINVAL\n");
1771 				return (EINVAL);
1772 			}
1773 			DPRINTF(5, "VT_PROCESS %d, ", td->td_proc->p_pid);
1774 			bcopy(data, &vw->vw_smode, sizeof(struct vt_mode));
1775 			vw->vw_proc = td->td_proc;
1776 			vw->vw_pid = vw->vw_proc->p_pid;
1777 			if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1778 				cnavailable(vw->vw_terminal->consdev, FALSE);
1779 		} else {
1780 			DPRINTF(5, "VT_SETMODE failed, unknown mode %d\n",
1781 			    mode->mode);
1782 			return (EINVAL);
1783 		}
1784 		DPRINTF(5, "\n");
1785 		return (0);
1786 	}
1787 	case VT_GETMODE:	/* get screen switcher mode */
1788 		bcopy(&vw->vw_smode, data, sizeof(struct vt_mode));
1789 		return (0);
1790 
1791 	case VT_RELDISP:	/* screen switcher ioctl */
1792 		/*
1793 		 * This must be the current vty which is in the VT_PROCESS
1794 		 * switching mode...
1795 		 */
1796 		if ((vw != vd->vd_curwindow) || (vw->vw_smode.mode !=
1797 		    VT_PROCESS)) {
1798 			return (EINVAL);
1799 		}
1800 		/* ...and this process is controlling it. */
1801 		if (vw->vw_proc != td->td_proc) {
1802 			return (EPERM);
1803 		}
1804 		error = EINVAL;
1805 		switch(*(int *)data) {
1806 		case VT_FALSE:	/* user refuses to release screen, abort */
1807 			if ((error = finish_vt_rel(vw, FALSE, &s)) == 0)
1808 				DPRINTF(5, "%s%d: VT_RELDISP: VT_FALSE\n",
1809 				    SC_DRIVER_NAME, VT_UNIT(vw));
1810 			break;
1811 		case VT_TRUE:	/* user has released screen, go on */
1812 			/* finish_vt_rel(..., TRUE, ...) should not be locked */
1813 			if (vw->vw_flags & VWF_SWWAIT_REL) {
1814 				if ((error = finish_vt_rel(vw, TRUE, &s)) == 0)
1815 					DPRINTF(5, "%s%d: VT_RELDISP: VT_TRUE\n",
1816 					    SC_DRIVER_NAME, VT_UNIT(vw));
1817 			} else {
1818 				error = EINVAL;
1819 			}
1820 			return (error);
1821 		case VT_ACKACQ:	/* acquire acknowledged, switch completed */
1822 			if ((error = finish_vt_acq(vw)) == 0)
1823 				DPRINTF(5, "%s%d: VT_RELDISP: VT_ACKACQ\n",
1824 				    SC_DRIVER_NAME, VT_UNIT(vw));
1825 			break;
1826 		default:
1827 			break;
1828 		}
1829 		return (error);
1830 	}
1831 
1832 	return (ENOIOCTL);
1833 }
1834 
1835 static struct vt_window *
1836 vt_allocate_window(struct vt_device *vd, unsigned int window)
1837 {
1838 	struct vt_window *vw;
1839 	struct terminal *tm;
1840 	term_pos_t size;
1841 	struct winsize wsz;
1842 
1843 	vw = malloc(sizeof *vw, M_VT, M_WAITOK|M_ZERO);
1844 	vw->vw_device = vd;
1845 	vw->vw_number = window;
1846 	vw->vw_kbdmode = K_XLATE;
1847 
1848 	if (!(vd->vd_flags & VDF_TEXTMODE))
1849 		vw->vw_font = vtfont_ref(&vt_font_default);
1850 
1851 	vt_termsize(vd, vw->vw_font, &size);
1852 	vt_winsize(vd, vw->vw_font, &wsz);
1853 	vtbuf_init(&vw->vw_buf, &size);
1854 
1855 	tm = vw->vw_terminal = terminal_alloc(&vt_termclass, vw);
1856 	terminal_set_winsize(tm, &wsz);
1857 	vd->vd_windows[window] = vw;
1858 	callout_init(&vw->vw_proc_dead_timer, 0);
1859 
1860 	return (vw);
1861 }
1862 
1863 void
1864 vt_upgrade(struct vt_device *vd)
1865 {
1866 	struct vt_window *vw;
1867 	unsigned int i;
1868 
1869 	/* Device didn't pass vd_init() or already upgraded. */
1870 	if (vd->vd_flags & (VDF_ASYNC|VDF_DEAD))
1871 		return;
1872 	vd->vd_flags |= VDF_ASYNC;
1873 
1874 	mtx_init(&vd->vd_lock, "vtdev", NULL, MTX_DEF);
1875 	cv_init(&vd->vd_winswitch, "vtwswt");
1876 
1877 	/* Init 25 Hz timer. */
1878 	callout_init_mtx(&vd->vd_timer, &vd->vd_lock, 0);
1879 
1880 	for (i = 0; i < VT_MAXWINDOWS; i++) {
1881 		vw = vd->vd_windows[i];
1882 		if (vw == NULL) {
1883 			/* New window. */
1884 			vw = vt_allocate_window(vd, i);
1885 		} else if (vw->vw_flags & VWF_CONSOLE) {
1886 			/* For existing console window. */
1887 			callout_init(&vw->vw_proc_dead_timer, 0);
1888 		}
1889 		if (i == VT_CONSWINDOW) {
1890 			/* Console window. */
1891 			EVENTHANDLER_REGISTER(shutdown_pre_sync,
1892 			    vt_window_switch, vw, SHUTDOWN_PRI_DEFAULT);
1893 		}
1894 		terminal_maketty(vw->vw_terminal, "v%r", VT_UNIT(vw));
1895 
1896 	}
1897 	if (vd->vd_curwindow == NULL)
1898 		vd->vd_curwindow = vd->vd_windows[VT_CONSWINDOW];
1899 
1900 	/* Attach keyboard. */
1901 	vt_allocate_keyboard(vd);
1902 	DPRINTF(20, "%s: vd_keyboard = %d\n", __func__, vd->vd_keyboard);
1903 
1904 	/* Start timer when everything ready. */
1905 	callout_reset(&vd->vd_timer, hz / VT_TIMERFREQ, vt_timer, vd);
1906 }
1907 
1908 static void
1909 vt_resize(struct vt_device *vd)
1910 {
1911 	struct vt_window *vw;
1912 	int i;
1913 
1914 	for (i = 0; i < VT_MAXWINDOWS; i++) {
1915 		vw = vd->vd_windows[i];
1916 		/* Assign default font to window, if not textmode. */
1917 		if (!(vd->vd_flags & VDF_TEXTMODE) && vw->vw_font == NULL)
1918 			vw->vw_font = vtfont_ref(&vt_font_default);
1919 		/* Resize terminal windows */
1920 		vt_change_font(vw, vw->vw_font);
1921 	}
1922 }
1923 
1924 void
1925 vt_allocate(struct vt_driver *drv, void *softc)
1926 {
1927 	struct vt_device *vd;
1928 	struct winsize wsz;
1929 
1930 	if (main_vd == NULL) {
1931 		main_vd = malloc(sizeof *vd, M_VT, M_WAITOK|M_ZERO);
1932 		printf("%s: VT initialize with new VT driver.\n", __func__);
1933 	} else {
1934 		/*
1935 		 * Check if have rights to replace current driver. For example:
1936 		 * it is bad idea to replace KMS driver with generic VGA one.
1937 		 */
1938 		if (drv->vd_priority <= main_vd->vd_driver->vd_priority) {
1939 			printf("%s: Driver priority %d too low. Current %d\n ",
1940 			    __func__, drv->vd_priority,
1941 			    main_vd->vd_driver->vd_priority);
1942 			return;
1943 		}
1944 		printf("%s: Replace existing VT driver.\n", __func__);
1945 	}
1946 	vd = main_vd;
1947 	if (drv->vd_maskbitbltchr == NULL)
1948 		drv->vd_maskbitbltchr = drv->vd_bitbltchr;
1949 
1950 	if (vd->vd_flags & VDF_ASYNC) {
1951 		/* Stop vt_flush periodic task. */
1952 		callout_drain(&vd->vd_timer);
1953 		/*
1954 		 * Mute current terminal until we done. vt_change_font (called
1955 		 * from vt_resize) will unmute it.
1956 		 */
1957 		terminal_mute(vd->vd_curwindow->vw_terminal, 1);
1958 	}
1959 
1960 	/*
1961 	 * Reset VDF_TEXTMODE flag, driver who require that flag (vt_vga) will
1962 	 * set it.
1963 	 */
1964 	vd->vd_flags &= ~VDF_TEXTMODE;
1965 
1966 	vd->vd_driver = drv;
1967 	vd->vd_softc = softc;
1968 	vd->vd_driver->vd_init(vd);
1969 
1970 	vt_upgrade(vd);
1971 
1972 	/* Refill settings with new sizes. */
1973 	vt_resize(vd);
1974 
1975 #ifdef DEV_SPLASH
1976 	if (vd->vd_flags & VDF_SPLASH)
1977 		vtterm_splash(vd);
1978 #endif
1979 
1980 	if (vd->vd_flags & VDF_ASYNC) {
1981 		terminal_mute(vd->vd_curwindow->vw_terminal, 0);
1982 		callout_schedule(&vd->vd_timer, hz / VT_TIMERFREQ);
1983 	}
1984 
1985 	termcn_cnregister(vd->vd_windows[VT_CONSWINDOW]->vw_terminal);
1986 
1987 	/* Update console window sizes to actual. */
1988 	vt_winsize(vd, vd->vd_windows[VT_CONSWINDOW]->vw_font, &wsz);
1989 	terminal_set_winsize(vd->vd_windows[VT_CONSWINDOW]->vw_terminal, &wsz);
1990 }
1991 
1992 void
1993 vt_suspend()
1994 {
1995 
1996 	if (vt_suspendswitch == 0)
1997 		return;
1998 	/* Save current window. */
1999 	main_vd->vd_savedwindow = main_vd->vd_curwindow;
2000 	/* Ask holding process to free window and switch to console window */
2001 	vt_proc_window_switch(main_vd->vd_windows[VT_CONSWINDOW]);
2002 }
2003 
2004 void
2005 vt_resume()
2006 {
2007 
2008 	if (vt_suspendswitch == 0)
2009 		return;
2010 	/* Switch back to saved window */
2011 	if (main_vd->vd_savedwindow != NULL)
2012 		vt_proc_window_switch(main_vd->vd_savedwindow);
2013 	main_vd->vd_savedwindow = NULL;
2014 }
2015