sys/dev/vt/vt_core.c

   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
 656         *fg = TCHAR_FGCOLOR(c);
 657         if (TCHAR_FORMAT(c) & TF_BOLD)
 658                 *fg = TCOLOR_LIGHT(*fg);
 659         *bg = TCHAR_BGCOLOR(c);
 660
 661         if (TCHAR_FORMAT(c) & TF_REVERSE) {
 662                 term_color_t tmp;
 663
 664                 tmp = *fg;
 665                 *fg = *bg;
 666                 *bg = tmp;
 667         }
 668
 669         if (cursor) {
 670                 *fg = *bg;
 671                 *bg = TC_WHITE;
 672         }
 673 }
 674
 675 static void
 676 vt_bitblt_char(struct vt_device *vd, struct vt_font *vf, term_char_t c,
 677     int iscursor, unsigned int row, unsigned int col)
 678 {
 679         term_color_t fg, bg;
 680
 681         vt_determine_colors(c, iscursor, &fg, &bg);
 682
 683         if (vf != NULL) {
 684                 const uint8_t *src;
 685                 vt_axis_t top, left;
 686
 687                 src = vtfont_lookup(vf, c);
 688
 689                 /*
 690                  * Align the terminal to the centre of the screen.
 691                  * Fonts may not always be able to fill the entire
 692                  * screen.
 693                  */
 694                 top = row * vf->vf_height + vd->vd_offset.tp_row;
 695                 left = col * vf->vf_width + vd->vd_offset.tp_col;
 696
 697                 vd->vd_driver->vd_bitbltchr(vd, src, NULL, 0, top, left,
 698                     vf->vf_width, vf->vf_height, fg, bg);
 699         } else {
 700                 vd->vd_driver->vd_putchar(vd, TCHAR_CHARACTER(c),
 701                     row, col, fg, bg);
 702         }
 703 }
 704
 705 static void
 706 vt_flush(struct vt_device *vd)
 707 {
 708         struct vt_window *vw = vd->vd_curwindow;
 709         struct vt_font *vf = vw->vw_font;
 710         struct vt_bufmask tmask;
 711         unsigned int row, col;
 712         term_rect_t tarea;
 713         term_pos_t size;
 714         term_char_t *r;
 715 #ifndef SC_NO_CUTPASTE
 716         struct mouse_cursor *m;
 717         int bpl, h, w;
 718 #endif
 719
 720         if (vd->vd_flags & VDF_SPLASH || vw->vw_flags & VWF_BUSY)
 721                 return;
 722
 723         vtbuf_undirty(&vw->vw_buf, &tarea, &tmask);
 724         vt_termsize(vd, vf, &size);
 725
 726         /* Force a full redraw when the screen contents are invalid. */
 727         if (vd->vd_flags & VDF_INVALID) {
 728                 tarea.tr_begin.tp_row = tarea.tr_begin.tp_col = 0;
 729                 tarea.tr_end = size;
 730                 tmask.vbm_row = tmask.vbm_col = VBM_DIRTY;
 731
 732                 vd->vd_flags &= ~VDF_INVALID;
 733         }
 734
 735 #ifndef SC_NO_CUTPASTE
 736         if ((vw->vw_flags & VWF_MOUSE_HIDE) == 0) {
 737                 /* Mark last mouse position as dirty to erase. */
 738                 vtbuf_mouse_cursor_position(&vw->vw_buf, vd->vd_mdirtyx,
 739                     vd->vd_mdirtyy);
 740         }
 741 #endif
 742
 743         for (row = tarea.tr_begin.tp_row; row < tarea.tr_end.tp_row; row++) {
 744                 if (!VTBUF_DIRTYROW(&tmask, row))
 745                         continue;
 746                 r = VTBUF_GET_ROW(&vw->vw_buf, row);
 747                 for (col = tarea.tr_begin.tp_col;
 748                     col < tarea.tr_end.tp_col; col++) {
 749                         if (!VTBUF_DIRTYCOL(&tmask, col))
 750                                 continue;
 751
 752                         vt_bitblt_char(vd, vf, r[col],
 753                             VTBUF_ISCURSOR(&vw->vw_buf, row, col), row, col);
 754                 }
 755         }
 756
 757 #ifndef SC_NO_CUTPASTE
 758         /* Mouse disabled. */
 759         if (vw->vw_flags & VWF_MOUSE_HIDE)
 760                 return;
 761
 762         /* No mouse for DDB. */
 763         if (kdb_active || panicstr != NULL)
 764                 return;
 765
 766         if ((vd->vd_flags & (VDF_MOUSECURSOR|VDF_TEXTMODE)) ==
 767             VDF_MOUSECURSOR) {
 768                 m = &vt_default_mouse_pointer;
 769                 bpl = (m->w + 7) >> 3; /* Bytes per sorce line. */
 770                 w = m->w;
 771                 h = m->h;
 772
 773                 if ((vd->vd_mx + m->w) > (size.tp_col * vf->vf_width))
 774                         w = (size.tp_col * vf->vf_width) - vd->vd_mx - 1;
 775                 if ((vd->vd_my + m->h) > (size.tp_row * vf->vf_height))
 776                         h = (size.tp_row * vf->vf_height) - vd->vd_my - 1;
 777
 778                 vd->vd_driver->vd_bitbltchr(vd, m->map, m->mask, bpl,
 779                     vd->vd_offset.tp_row + vd->vd_my,
 780                     vd->vd_offset.tp_col + vd->vd_mx,
 781                     w, h, TC_WHITE, TC_BLACK);
 782                 /* Save point of last mouse cursor to erase it later. */
 783                 vd->vd_mdirtyx = vd->vd_mx / vf->vf_width;
 784                 vd->vd_mdirtyy = vd->vd_my / vf->vf_height;
 785         }
 786 #endif
 787 }
 788
 789 static void
 790 vt_timer(void *arg)
 791 {
 792         struct vt_device *vd;
 793
 794         vd = arg;
 795         /* Update screen if required. */
 796         vt_flush(vd);
 797         /* Schedule for next update. */
 798         callout_schedule(&vd->vd_timer, hz / VT_TIMERFREQ);
 799 }
 800
 801 static void
 802 vtterm_done(struct terminal *tm)
 803 {
 804         struct vt_window *vw = tm->tm_softc;
 805         struct vt_device *vd = vw->vw_device;
 806
 807         if (kdb_active || panicstr != NULL) {
 808                 /* Switch to the debugger. */
 809                 if (vd->vd_curwindow != vw) {
 810                         vd->vd_curwindow = vw;
 811                         vd->vd_flags |= VDF_INVALID;
 812                         if (vd->vd_driver->vd_postswitch)
 813                                 vd->vd_driver->vd_postswitch(vd);
 814                 }
 815                 vd->vd_flags &= ~VDF_SPLASH;
 816                 vt_flush(vd);
 817         } else if (!(vd->vd_flags & VDF_ASYNC)) {
 818                 vt_flush(vd);
 819         }
 820 }
 821
 822 #ifdef DEV_SPLASH
 823 static void
 824 vtterm_splash(struct vt_device *vd)
 825 {
 826         vt_axis_t top, left;
 827
 828         /* Display a nice boot splash. */
 829         if (!(vd->vd_flags & VDF_TEXTMODE) && (boothowto & RB_MUTE)) {
 830
 831                 top = (vd->vd_height - vt_logo_height) / 2;
 832                 left = (vd->vd_width - vt_logo_width) / 2;
 833                 switch (vt_logo_depth) {
 834                 case 1:
 835                         /* XXX: Unhardcode colors! */
 836                         vd->vd_driver->vd_bitbltchr(vd, vt_logo_image, NULL, 0,
 837                             top, left, vt_logo_width, vt_logo_height, 0xf, 0x0);
 838                 }
 839                 vd->vd_flags |= VDF_SPLASH;
 840         }
 841 }
 842 #endif
 843
 844 static void
 845 vtterm_cnprobe(struct terminal *tm, struct consdev *cp)
 846 {
 847         struct vt_window *vw = tm->tm_softc;
 848         struct vt_device *vd = vw->vw_device;
 849         struct winsize wsz;
 850
 851         if (vd->vd_flags & VDF_INITIALIZED)
 852                 /* Initialization already done. */
 853                 return;
 854
 855         cp->cn_pri = vd->vd_driver->vd_init(vd);
 856         if (cp->cn_pri == CN_DEAD) {
 857                 vd->vd_flags |= VDF_DEAD;
 858                 return;
 859         }
 860
 861         /* Initialize any early-boot keyboard drivers */
 862         kbd_configure(KB_CONF_PROBE_ONLY);
 863
 864         vd->vd_unit = atomic_fetchadd_int(&vt_unit, 1);
 865         vd->vd_windows[VT_CONSWINDOW] = vw;
 866         sprintf(cp->cn_name, "ttyv%r", VT_UNIT(vw));
 867
 868         if (!(vd->vd_flags & VDF_TEXTMODE))
 869                 vw->vw_font = vtfont_ref(&vt_font_default);
 870
 871         vtbuf_init_early(&vw->vw_buf);
 872         vt_winsize(vd, vw->vw_font, &wsz);
 873         terminal_set_winsize(tm, &wsz);
 874
 875 #ifdef DEV_SPLASH
 876         vtterm_splash(vd);
 877 #endif
 878
 879         vd->vd_flags |= VDF_INITIALIZED;
 880         main_vd = vd;
 881 }
 882
 883 static int
 884 vtterm_cngetc(struct terminal *tm)
 885 {
 886         struct vt_window *vw = tm->tm_softc;
 887         struct vt_device *vd = vw->vw_device;
 888         keyboard_t *kbd;
 889         int state;
 890         u_int c;
 891
 892         if (vw->vw_kbdsq && *vw->vw_kbdsq)
 893                 return (*vw->vw_kbdsq++);
 894
 895         state = 0;
 896         /* Make sure the splash screen is not there. */
 897         if (vd->vd_flags & VDF_SPLASH) {
 898                 /* Remove splash */
 899                 vd->vd_flags &= ~VDF_SPLASH;
 900                 /* Mark screen as invalid to force update */
 901                 vd->vd_flags |= VDF_INVALID;
 902                 vt_flush(vd);
 903         }
 904
 905         /* Stripped down keyboard handler. */
 906         kbd = kbd_get_keyboard(vd->vd_keyboard);
 907         if (kbd == NULL)
 908                 return (-1);
 909
 910         /* Force keyboard input mode to K_XLATE */
 911         c = K_XLATE;
 912         kbdd_ioctl(kbd, KDSKBMODE, (void *)&c);
 913
 914         /* Switch the keyboard to polling to make it work here. */
 915         kbdd_poll(kbd, TRUE);
 916         c = kbdd_read_char(kbd, 0);
 917         kbdd_poll(kbd, FALSE);
 918         if (c & RELKEY)
 919                 return (-1);
 920
 921         if (vw->vw_flags & VWF_SCROLL) {
 922                 vt_scrollmode_kbdevent(vw, c, 1/* Console mode */);
 923                 vt_flush(vd);
 924                 return (-1);
 925         }
 926
 927         /* Stripped down handling of vt_kbdevent(), without locking, etc. */
 928         if (c & SPCLKEY) {
 929                 switch (c) {
 930                 case SPCLKEY | SLK:
 931                         kbdd_ioctl(kbd, KDGKBSTATE, (caddr_t)&state);
 932                         if (state & SLKED) {
 933                                 /* Turn scrolling on. */
 934                                 vw->vw_flags |= VWF_SCROLL;
 935                                 VTBUF_SLCK_ENABLE(&vw->vw_buf);
 936                         } else {
 937                                 /* Turn scrolling off. */
 938                                 vt_scroll(vw, 0, VHS_END);
 939                                 vw->vw_flags &= ~VWF_SCROLL;
 940                                 VTBUF_SLCK_DISABLE(&vw->vw_buf);
 941                         }
 942                         break;
 943                 /* XXX: KDB can handle history. */
 944                 case SPCLKEY | FKEY | F(50): /* Arrow up. */
 945                         vw->vw_kbdsq = "\x1b[A";
 946                         break;
 947                 case SPCLKEY | FKEY | F(58): /* Arrow down. */
 948                         vw->vw_kbdsq = "\x1b[B";
 949                         break;
 950                 case SPCLKEY | FKEY | F(55): /* Arrow right. */
 951                         vw->vw_kbdsq = "\x1b[C";
 952                         break;
 953                 case SPCLKEY | FKEY | F(53): /* Arrow left. */
 954                         vw->vw_kbdsq = "\x1b[D";
 955                         break;
 956                 }
 957
 958                 /* Force refresh to make scrollback work. */
 959                 vt_flush(vd);
 960         } else if (KEYFLAGS(c) == 0) {
 961                 return (KEYCHAR(c));
 962         }
 963
 964         if (vw->vw_kbdsq && *vw->vw_kbdsq)
 965                 return (*vw->vw_kbdsq++);
 966
 967         return (-1);
 968 }
 969
 970 static void
 971 vtterm_opened(struct terminal *tm, int opened)
 972 {
 973         struct vt_window *vw = tm->tm_softc;
 974         struct vt_device *vd = vw->vw_device;
 975
 976         VT_LOCK(vd);
 977         vd->vd_flags &= ~VDF_SPLASH;
 978         if (opened)
 979                 vw->vw_flags |= VWF_OPENED;
 980         else {
 981                 vw->vw_flags &= ~VWF_OPENED;
 982                 /* TODO: finish ACQ/REL */
 983         }
 984         VT_UNLOCK(vd);
 985 }
 986
 987 static int
 988 vt_change_font(struct vt_window *vw, struct vt_font *vf)
 989 {
 990         struct vt_device *vd = vw->vw_device;
 991         struct terminal *tm = vw->vw_terminal;
 992         term_pos_t size;
 993         struct winsize wsz;
 994
 995         /*
 996          * Changing fonts.
 997          *
 998          * Changing fonts is a little tricky.  We must prevent
 999          * simultaneous access to the device, so we must stop
1000          * the display timer and the terminal from accessing.
1001          * We need to switch fonts and grow our screen buffer.
1002          *
1003          * XXX: Right now the code uses terminal_mute() to
1004          * prevent data from reaching the console driver while
1005          * resizing the screen buffer.  This isn't elegant...
1006          */
1007
1008         VT_LOCK(vd);
1009         if (vw->vw_flags & VWF_BUSY) {
1010                 /* Another process is changing the font. */
1011                 VT_UNLOCK(vd);
1012                 return (EBUSY);
1013         }
1014         if (vw->vw_font == NULL) {
1015                 /* Our device doesn't need fonts. */
1016                 VT_UNLOCK(vd);
1017                 return (ENOTTY);
1018         }
1019         vw->vw_flags |= VWF_BUSY;
1020         VT_UNLOCK(vd);
1021
1022         vt_termsize(vd, vf, &size);
1023         vt_winsize(vd, vf, &wsz);
1024         /* Save offset to font aligned area. */
1025         vd->vd_offset.tp_col = (vd->vd_width % vf->vf_width) / 2;
1026         vd->vd_offset.tp_row = (vd->vd_height % vf->vf_height) / 2;
1027
1028         /* Grow the screen buffer and terminal. */
1029         terminal_mute(tm, 1);
1030         vtbuf_grow(&vw->vw_buf, &size, vw->vw_buf.vb_history_size);
1031         terminal_set_winsize_blank(tm, &wsz, 0);
1032         terminal_mute(tm, 0);
1033
1034         /* Actually apply the font to the current window. */
1035         VT_LOCK(vd);
1036         vtfont_unref(vw->vw_font);
1037         vw->vw_font = vtfont_ref(vf);
1038
1039         /* Force a full redraw the next timer tick. */
1040         if (vd->vd_curwindow == vw)
1041                 vd->vd_flags |= VDF_INVALID;
1042         vw->vw_flags &= ~VWF_BUSY;
1043         VT_UNLOCK(vd);
1044         return (0);
1045 }
1046
1047 static int
1048 vt_set_border(struct vt_window *vw, struct vt_font *vf, term_color_t c)
1049 {
1050         struct vt_device *vd = vw->vw_device;
1051         int l, r, t, b, w, h;
1052
1053         if (vd->vd_driver->vd_drawrect == NULL)
1054                 return (ENOTSUP);
1055
1056         w = vd->vd_width - 1;
1057         h = vd->vd_height - 1;
1058         l = vd->vd_offset.tp_col - 1;
1059         r = w - l;
1060         t = vd->vd_offset.tp_row - 1;
1061         b = h - t;
1062
1063         vd->vd_driver->vd_drawrect(vd, 0, 0, w, t, 1, c); /* Top bar. */
1064         vd->vd_driver->vd_drawrect(vd, 0, t, l, b, 1, c); /* Left bar. */
1065         vd->vd_driver->vd_drawrect(vd, r, t, w, b, 1, c); /* Right bar. */
1066         vd->vd_driver->vd_drawrect(vd, 0, b, w, h, 1, c); /* Bottom bar. */
1067
1068         return (0);
1069 }
1070
1071 static int
1072 vt_proc_alive(struct vt_window *vw)
1073 {
1074         struct proc *p;
1075
1076         if (vw->vw_smode.mode != VT_PROCESS)
1077                 return (FALSE);
1078
1079         if (vw->vw_proc) {
1080                 if ((p = pfind(vw->vw_pid)) != NULL)
1081                         PROC_UNLOCK(p);
1082                 if (vw->vw_proc == p)
1083                         return (TRUE);
1084                 vw->vw_proc = NULL;
1085                 vw->vw_smode.mode = VT_AUTO;
1086                 DPRINTF(1, "vt controlling process %d died\n", vw->vw_pid);
1087                 vw->vw_pid = 0;
1088         }
1089         return (FALSE);
1090 }
1091
1092 static int
1093 signal_vt_rel(struct vt_window *vw)
1094 {
1095
1096         if (vw->vw_smode.mode != VT_PROCESS)
1097                 return (FALSE);
1098         if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1099                 vw->vw_proc = NULL;
1100                 vw->vw_pid = 0;
1101                 return (TRUE);
1102         }
1103         vw->vw_flags |= VWF_SWWAIT_REL;
1104         PROC_LOCK(vw->vw_proc);
1105         kern_psignal(vw->vw_proc, vw->vw_smode.relsig);
1106         PROC_UNLOCK(vw->vw_proc);
1107         DPRINTF(1, "sending relsig to %d\n", vw->vw_pid);
1108         return (TRUE);
1109 }
1110
1111 static int
1112 signal_vt_acq(struct vt_window *vw)
1113 {
1114
1115         if (vw->vw_smode.mode != VT_PROCESS)
1116                 return (FALSE);
1117         if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1118                 cnavailable(vw->vw_terminal->consdev, FALSE);
1119         if (vw->vw_proc == NULL || vt_proc_alive(vw) == FALSE) {
1120                 vw->vw_proc = NULL;
1121                 vw->vw_pid = 0;
1122                 return (TRUE);
1123         }
1124         vw->vw_flags |= VWF_SWWAIT_ACQ;
1125         PROC_LOCK(vw->vw_proc);
1126         kern_psignal(vw->vw_proc, vw->vw_smode.acqsig);
1127         PROC_UNLOCK(vw->vw_proc);
1128         DPRINTF(1, "sending acqsig to %d\n", vw->vw_pid);
1129         return (TRUE);
1130 }
1131
1132 static int
1133 finish_vt_rel(struct vt_window *vw, int release, int *s)
1134 {
1135
1136         if (vw->vw_flags & VWF_SWWAIT_REL) {
1137                 vw->vw_flags &= ~VWF_SWWAIT_REL;
1138                 if (release) {
1139                         callout_drain(&vw->vw_proc_dead_timer);
1140                         vt_late_window_switch(vw->vw_switch_to);
1141                 }
1142                 return (0);
1143         }
1144         return (EINVAL);
1145 }
1146
1147 static int
1148 finish_vt_acq(struct vt_window *vw)
1149 {
1150
1151         if (vw->vw_flags & VWF_SWWAIT_ACQ) {
1152                 vw->vw_flags &= ~VWF_SWWAIT_ACQ;
1153                 return (0);
1154         }
1155         return (EINVAL);
1156 }
1157
1158 #ifndef SC_NO_CUTPASTE
1159 static void
1160 vt_mouse_terminput_button(struct vt_device *vd, int button)
1161 {
1162         struct vt_window *vw;
1163         struct vt_font *vf;
1164         char mouseb[6] = "\x1B[M";
1165         int i, x, y;
1166
1167         vw = vd->vd_curwindow;
1168         vf = vw->vw_font;
1169
1170         /* Translate to char position. */
1171         x = vd->vd_mx / vf->vf_width;
1172         y = vd->vd_my / vf->vf_height;
1173         /* Avoid overflow. */
1174         x = MIN(x, 255 - '!');
1175         y = MIN(y, 255 - '!');
1176
1177         mouseb[3] = ' ' + button;
1178         mouseb[4] = '!' + x;
1179         mouseb[5] = '!' + y;
1180
1181         for (i = 0; i < sizeof(mouseb); i++ )
1182                 terminal_input_char(vw->vw_terminal, mouseb[i]);
1183 }
1184
1185 static void
1186 vt_mouse_terminput(struct vt_device *vd, int type, int x, int y, int event,
1187     int cnt)
1188 {
1189
1190         switch (type) {
1191         case MOUSE_BUTTON_EVENT:
1192                 if (cnt > 0) {
1193                         /* Mouse button pressed. */
1194                         if (event & MOUSE_BUTTON1DOWN)
1195                                 vt_mouse_terminput_button(vd, 0);
1196                         if (event & MOUSE_BUTTON2DOWN)
1197                                 vt_mouse_terminput_button(vd, 1);
1198                         if (event & MOUSE_BUTTON3DOWN)
1199                                 vt_mouse_terminput_button(vd, 2);
1200                 } else {
1201                         /* Mouse button released. */
1202                         vt_mouse_terminput_button(vd, 3);
1203                 }
1204                 break;
1205 #ifdef notyet
1206         case MOUSE_MOTION_EVENT:
1207                 if (mouse->u.data.z < 0) {
1208                         /* Scroll up. */
1209                         sc_mouse_input_button(vd, 64);
1210                 } else if (mouse->u.data.z > 0) {
1211                         /* Scroll down. */
1212                         sc_mouse_input_button(vd, 65);
1213                 }
1214                 break;
1215 #endif
1216         }
1217 }
1218
1219 void
1220 vt_mouse_event(int type, int x, int y, int event, int cnt, int mlevel)
1221 {
1222         struct vt_device *vd;
1223         struct vt_window *vw;
1224         struct vt_font *vf;
1225         term_pos_t size;
1226         term_char_t *buf;
1227         int i, len, mark;
1228
1229         vd = main_vd;
1230         vw = vd->vd_curwindow;
1231         vf = vw->vw_font;
1232         mark = 0;
1233
1234         if (vw->vw_flags & VWF_MOUSE_HIDE)
1235                 return; /* Mouse disabled. */
1236
1237         if (vf == NULL) /* Text mode. */
1238                 return;
1239
1240         /*
1241          * TODO: add flag about pointer position changed, to not redraw chars
1242          * under mouse pointer when nothing changed.
1243          */
1244
1245         if (vw->vw_mouse_level > 0)
1246                 vt_mouse_terminput(vd, type, x, y, event, cnt);
1247
1248         switch (type) {
1249         case MOUSE_ACTION:
1250         case MOUSE_MOTION_EVENT:
1251                 /* Movement */
1252                 x += vd->vd_mx;
1253                 y += vd->vd_my;
1254
1255                 vt_termsize(vd, vf, &size);
1256
1257                 /* Apply limits. */
1258                 x = MAX(x, 0);
1259                 y = MAX(y, 0);
1260                 x = MIN(x, (size.tp_col * vf->vf_width) - 1);
1261                 y = MIN(y, (size.tp_row * vf->vf_height) - 1);
1262
1263                 vd->vd_mx = x;
1264                 vd->vd_my = y;
1265                 if ((vd->vd_mstate & MOUSE_BUTTON1DOWN) &&
1266                     (vtbuf_set_mark(&vw->vw_buf, VTB_MARK_MOVE,
1267                         vd->vd_mx / vf->vf_width,
1268                         vd->vd_my / vf->vf_height) == 1)) {
1269
1270                         /*
1271                          * We have something marked to copy, so update pointer
1272                          * to window with selection.
1273                          */
1274                         vd->vd_markedwin = vw;
1275                 }
1276                 return; /* Done */
1277         case MOUSE_BUTTON_EVENT:
1278                 /* Buttons */
1279                 break;
1280         default:
1281                 return; /* Done */
1282         }
1283
1284         switch (event) {
1285         case MOUSE_BUTTON1DOWN:
1286                 switch (cnt % 4) {
1287                 case 0: /* up */
1288                         mark = VTB_MARK_END;
1289                         break;
1290                 case 1: /* single click: start cut operation */
1291                         mark = VTB_MARK_START;
1292                         break;
1293                 case 2: /* double click: cut a word */
1294                         mark = VTB_MARK_WORD;
1295                         break;
1296                 case 3: /* triple click: cut a line */
1297                         mark = VTB_MARK_ROW;
1298                         break;
1299                 }
1300                 break;
1301         case VT_MOUSE_PASTEBUTTON:
1302                 switch (cnt) {
1303                 case 0: /* up */
1304                         break;
1305                 default:
1306                         if (vd->vd_markedwin == NULL)
1307                                 return;
1308                         /* Get current selecton size in bytes. */
1309                         len = vtbuf_get_marked_len(&vd->vd_markedwin->vw_buf);
1310                         if (len <= 0)
1311                                 return;
1312
1313                         buf = malloc(len, M_VT, M_WAITOK | M_ZERO);
1314                         /* Request cupy/paste buffer data, no more than `len' */
1315                         vtbuf_extract_marked(&vd->vd_markedwin->vw_buf, buf,
1316                             len);
1317
1318                         len /= sizeof(term_char_t);
1319                         for (i = 0; i < len; i++ ) {
1320                                 if (buf[i] == '\0')
1321                                         continue;
1322                                 terminal_input_char(vw->vw_terminal, buf[i]);
1323                         }
1324
1325                         /* Done, so cleanup. */
1326                         free(buf, M_VT);
1327                         break;
1328                 }
1329                 return; /* Done */
1330         case VT_MOUSE_EXTENDBUTTON:
1331                 switch (cnt) {
1332                 case 0: /* up */
1333                         if (!(vd->vd_mstate & MOUSE_BUTTON1DOWN))
1334                                 mark = VTB_MARK_EXTEND;
1335                         else
1336                                 mark = 0;
1337                         break;
1338                 default:
1339                         mark = VTB_MARK_EXTEND;
1340                         break;
1341                 }
1342                 break;
1343         default:
1344                 return; /* Done */
1345         }
1346
1347         /* Save buttons state. */
1348         if (cnt > 0)
1349                 vd->vd_mstate |= event;
1350         else
1351                 vd->vd_mstate &= ~event;
1352
1353         if (vtbuf_set_mark(&vw->vw_buf, mark, vd->vd_mx / vf->vf_width,
1354             vd->vd_my / vf->vf_height) == 1) {
1355                 /*
1356                  * We have something marked to copy, so update pointer to
1357                  * window with selection.
1358                  */
1359                 vd->vd_markedwin = vw;
1360         }
1361 }
1362
1363 void
1364 vt_mouse_state(int show)
1365 {
1366         struct vt_device *vd;
1367         struct vt_window *vw;
1368
1369         vd = main_vd;
1370         vw = vd->vd_curwindow;
1371
1372         switch (show) {
1373         case VT_MOUSE_HIDE:
1374                 vw->vw_flags |= VWF_MOUSE_HIDE;
1375                 break;
1376         case VT_MOUSE_SHOW:
1377                 vw->vw_flags &= ~VWF_MOUSE_HIDE;
1378                 break;
1379         }
1380 }
1381 #endif
1382
1383 static int
1384 vtterm_mmap(struct terminal *tm, vm_ooffset_t offset, vm_paddr_t * paddr,
1385     int nprot, vm_memattr_t *memattr)
1386 {
1387         struct vt_window *vw = tm->tm_softc;
1388         struct vt_device *vd = vw->vw_device;
1389
1390         if (vd->vd_driver->vd_fb_mmap)
1391                 return (vd->vd_driver->vd_fb_mmap(vd, offset, paddr, nprot,
1392                     memattr));
1393
1394         return (ENXIO);
1395 }
1396
1397 static int
1398 vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data,
1399     struct thread *td)
1400 {
1401         struct vt_window *vw = tm->tm_softc;
1402         struct vt_device *vd = vw->vw_device;
1403         keyboard_t *kbd;
1404         int error, i, s;
1405 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
1406     defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
1407         int ival;
1408
1409         switch (cmd) {
1410         case _IO('v', 4):
1411                 cmd = VT_RELDISP;
1412                 break;
1413         case _IO('v', 5):
1414                 cmd = VT_ACTIVATE;
1415                 break;
1416         case _IO('v', 6):
1417                 cmd = VT_WAITACTIVE;
1418                 break;
1419         case _IO('K', 20):
1420                 cmd = KDSKBSTATE;
1421                 break;
1422         case _IO('K', 67):
1423                 cmd = KDSETRAD;
1424                 break;
1425         case _IO('K', 7):
1426                 cmd = KDSKBMODE;
1427                 break;
1428         case _IO('K', 8):
1429                 cmd = KDMKTONE;
1430                 break;
1431         case _IO('K', 63):
1432                 cmd = KIOCSOUND;
1433                 break;
1434         case _IO('K', 66):
1435                 cmd = KDSETLED;
1436                 break;
1437         case _IO('c', 110):
1438                 cmd = CONS_SETKBD;
1439                 break;
1440         default:
1441                 goto skip_thunk;
1442         }
1443         ival = IOCPARM_IVAL(data);
1444         data = (caddr_t)&ival;
1445 skip_thunk:
1446 #endif
1447
1448         switch (cmd) {
1449         case KDSETRAD:          /* set keyboard repeat & delay rates (old) */
1450                 if (*(int *)data & ~0x7f)
1451                         return (EINVAL);
1452         case GIO_KEYMAP:
1453         case PIO_KEYMAP:
1454         case GIO_DEADKEYMAP:
1455         case PIO_DEADKEYMAP:
1456         case GETFKEY:
1457         case SETFKEY:
1458         case KDGKBINFO:
1459         case KDGKBTYPE:
1460         case KDSKBSTATE:        /* set keyboard state (locks) */
1461         case KDGKBSTATE:        /* get keyboard state (locks) */
1462         case KDGETREPEAT:       /* get keyboard repeat & delay rates */
1463         case KDSETREPEAT:       /* set keyboard repeat & delay rates (new) */
1464         case KDSETLED:          /* set keyboard LED status */
1465         case KDGETLED:          /* get keyboard LED status */
1466         case KBADDKBD:          /* add/remove keyboard to/from mux */
1467         case KBRELKBD: {
1468                 error = 0;
1469
1470                 mtx_lock(&Giant);
1471                 kbd = kbd_get_keyboard(vd->vd_keyboard);
1472                 if (kbd != NULL)
1473                         error = kbdd_ioctl(kbd, cmd, data);
1474                 mtx_unlock(&Giant);
1475                 if (error == ENOIOCTL) {
1476                         if (cmd == KDGKBTYPE) {
1477                                 /* always return something? XXX */
1478                                 *(int *)data = 0;
1479                         } else {
1480                                 return (ENODEV);
1481                         }
1482                 }
1483                 return (error);
1484         }
1485         case KDGKBMODE: {
1486                 int mode = -1;
1487
1488                 mtx_lock(&Giant);
1489                 kbd = kbd_get_keyboard(vd->vd_keyboard);
1490                 if (kbd != NULL) {
1491                         kbdd_ioctl(kbd, KDGKBMODE, (void *)&mode);
1492                 }
1493                 mtx_unlock(&Giant);
1494                 DPRINTF(20, "mode %d, vw_kbdmode %d\n", mode, vw->vw_kbdmode);
1495                 *(int *)data = mode;
1496                 return (0);
1497         }
1498         case KDSKBMODE: {
1499                 int mode;
1500
1501                 mode = *(int *)data;
1502                 switch (mode) {
1503                 case K_XLATE:
1504                 case K_RAW:
1505                 case K_CODE:
1506                         vw->vw_kbdmode = mode;
1507                         if (vw == vd->vd_curwindow) {
1508                                 keyboard_t *kbd;
1509                                 error = 0;
1510
1511                                 mtx_lock(&Giant);
1512                                 kbd = kbd_get_keyboard(vd->vd_keyboard);
1513                                 if (kbd != NULL) {
1514                                         error = kbdd_ioctl(kbd, KDSKBMODE,
1515                                             (void *)&mode);
1516                                 }
1517                                 mtx_unlock(&Giant);
1518                         }
1519                         return (0);
1520                 default:
1521                         return (EINVAL);
1522                 }
1523         }
1524         case FBIOGTYPE:
1525         case FBIO_GETWINORG:    /* get frame buffer window origin */
1526         case FBIO_GETDISPSTART: /* get display start address */
1527         case FBIO_GETLINEWIDTH: /* get scan line width in bytes */
1528         case FBIO_BLANK:        /* blank display */
1529                 if (vd->vd_driver->vd_fb_ioctl)
1530                         return (vd->vd_driver->vd_fb_ioctl(vd, cmd, data, td));
1531                 break;
1532         case CONS_BLANKTIME:
1533                 /* XXX */
1534                 return (0);
1535         case CONS_GET:
1536                 /* XXX */
1537                 *(int *)data = M_CG640x480;
1538                 return (0);
1539         case CONS_BELLTYPE:     /* set bell type sound */
1540                 if ((*(int *)data) & CONS_QUIET_BELL)
1541                         vd->vd_flags |= VDF_QUIET_BELL;
1542                 else
1543                         vd->vd_flags &= ~VDF_QUIET_BELL;
1544                 return (0);
1545         case CONS_GETINFO: {
1546                 vid_info_t *vi = (vid_info_t *)data;
1547
1548                 vi->m_num = vd->vd_curwindow->vw_number + 1;
1549                 /* XXX: other fields! */
1550                 return (0);
1551         }
1552         case CONS_GETVERS:
1553                 *(int *)data = 0x200;
1554                 return (0);
1555         case CONS_MODEINFO:
1556                 /* XXX */
1557                 return (0);
1558         case CONS_MOUSECTL: {
1559                 mouse_info_t *mouse = (mouse_info_t*)data;
1560
1561                 /*
1562                  * This has no effect on vt(4).  We don't draw any mouse
1563                  * cursor.  Just ignore MOUSE_HIDE and MOUSE_SHOW to
1564                  * prevent excessive errors.  All the other commands
1565                  * should not be applied to individual TTYs, but only to
1566                  * consolectl.
1567                  */
1568                 switch (mouse->operation) {
1569                 case MOUSE_HIDE:
1570                         vd->vd_flags &= ~VDF_MOUSECURSOR;
1571                         return (0);
1572                 case MOUSE_SHOW:
1573                         vd->vd_mx = vd->vd_width / 2;
1574                         vd->vd_my = vd->vd_height / 2;
1575                         vd->vd_flags |= VDF_MOUSECURSOR;
1576                         return (0);
1577                 default:
1578                         return (EINVAL);
1579                 }
1580         }
1581         case PIO_VFONT: {
1582                 struct vt_font *vf;
1583
1584                 error = vtfont_load((void *)data, &vf);
1585                 if (error != 0)
1586                         return (error);
1587
1588                 error = vt_change_font(vw, vf);
1589                 if (error == 0) {
1590                         /* XXX: replace 0 with current bg color. */
1591                         vt_set_border(vw, vf, 0);
1592                 }
1593                 vtfont_unref(vf);
1594                 return (error);
1595         }
1596         case GIO_SCRNMAP: {
1597                 scrmap_t *sm = (scrmap_t *)data;
1598                 int i;
1599
1600                 /* We don't have screen maps, so return a handcrafted one. */
1601                 for (i = 0; i < 256; i++)
1602                         sm->scrmap[i] = i;
1603                 return (0);
1604         }
1605         case KDSETMODE:
1606                 /* XXX */
1607                 return (0);
1608         case KDENABIO:          /* allow io operations */
1609                 error = priv_check(td, PRIV_IO);
1610                 if (error != 0)
1611                         return (error);
1612                 error = securelevel_gt(td->td_ucred, 0);
1613                 if (error != 0)
1614                         return (error);
1615 #if defined(__i386__)
1616                 td->td_frame->tf_eflags |= PSL_IOPL;
1617 #elif defined(__amd64__)
1618                 td->td_frame->tf_rflags |= PSL_IOPL;
1619 #endif
1620                 return (0);
1621         case KDDISABIO:         /* disallow io operations (default) */
1622 #if defined(__i386__)
1623                 td->td_frame->tf_eflags &= ~PSL_IOPL;
1624 #elif defined(__amd64__)
1625                 td->td_frame->tf_rflags &= ~PSL_IOPL;
1626 #endif
1627                 return (0);
1628         case KDMKTONE:          /* sound the bell */
1629                 /* TODO */
1630                 return (0);
1631         case KIOCSOUND:         /* make tone (*data) hz */
1632                 /* TODO */
1633                 return (0);
1634         case CONS_SETKBD:               /* set the new keyboard */
1635                 mtx_lock(&Giant);
1636                 error = 0;
1637                 if (vd->vd_keyboard != *(int *)data) {
1638                         kbd = kbd_get_keyboard(*(int *)data);
1639                         if (kbd == NULL) {
1640                                 mtx_unlock(&Giant);
1641                                 return (EINVAL);
1642                         }
1643                         i = kbd_allocate(kbd->kb_name, kbd->kb_unit,
1644                             (void *)&vd->vd_keyboard, vt_kbdevent, vd);
1645                         if (i >= 0) {
1646                                 if (vd->vd_keyboard != -1) {
1647                                         kbd_release(kbd,
1648                                             (void *)&vd->vd_keyboard);
1649                                 }
1650                                 kbd = kbd_get_keyboard(i);
1651                                 vd->vd_keyboard = i;
1652
1653                                 (void)kbdd_ioctl(kbd, KDSKBMODE,
1654                                     (caddr_t)&vd->vd_curwindow->vw_kbdmode);
1655                         } else {
1656                                 error = EPERM;  /* XXX */
1657                         }
1658                 }
1659                 mtx_unlock(&Giant);
1660                 return (error);
1661         case CONS_RELKBD:               /* release the current keyboard */
1662                 mtx_lock(&Giant);
1663                 error = 0;
1664                 if (vd->vd_keyboard != -1) {
1665                         kbd = kbd_get_keyboard(vd->vd_keyboard);
1666                         if (kbd == NULL) {
1667                                 mtx_unlock(&Giant);
1668                                 return (EINVAL);
1669                         }
1670                         error = kbd_release(kbd, (void *)&vd->vd_keyboard);
1671                         if (error == 0) {
1672                                 vd->vd_keyboard = -1;
1673                         }
1674                 }
1675                 mtx_unlock(&Giant);
1676                 return (error);
1677         case VT_ACTIVATE: {
1678                 int win;
1679                 win = *(int *)data - 1;
1680                 DPRINTF(5, "%s%d: VT_ACTIVATE ttyv%d ", SC_DRIVER_NAME,
1681                     VT_UNIT(vw), win);
1682                 if ((win > VT_MAXWINDOWS) || (win < 0))
1683                         return (EINVAL);
1684                 return (vt_proc_window_switch(vd->vd_windows[win]));
1685         }
1686         case VT_GETACTIVE:
1687                 *(int *)data = vd->vd_curwindow->vw_number + 1;
1688                 return (0);
1689         case VT_GETINDEX:
1690                 *(int *)data = vw->vw_number + 1;
1691                 return (0);
1692         case VT_LOCKSWITCH:
1693                 /* TODO: Check current state, switching can be in progress. */
1694                 if ((*(int *)data) & 0x01)
1695                         vw->vw_flags |= VWF_VTYLOCK;
1696                 else
1697                         vw->vw_flags &= ~VWF_VTYLOCK;
1698         case VT_OPENQRY:
1699                 VT_LOCK(vd);
1700                 for (i = 0; i < VT_MAXWINDOWS; i++) {
1701                         vw = vd->vd_windows[i];
1702                         if (vw == NULL)
1703                                 continue;
1704                         if (!(vw->vw_flags & VWF_OPENED)) {
1705                                 *(int *)data = vw->vw_number + 1;
1706                                 VT_UNLOCK(vd);
1707                                 return (0);
1708                         }
1709                 }
1710                 VT_UNLOCK(vd);
1711                 return (EINVAL);
1712         case VT_WAITACTIVE:
1713                 error = 0;
1714
1715                 i = *(unsigned int *)data;
1716                 if (i > VT_MAXWINDOWS)
1717                         return (EINVAL);
1718                 if (i != 0)
1719                         vw = vd->vd_windows[i - 1];
1720
1721                 VT_LOCK(vd);
1722                 while (vd->vd_curwindow != vw && error == 0)
1723                         error = cv_wait_sig(&vd->vd_winswitch, &vd->vd_lock);
1724                 VT_UNLOCK(vd);
1725                 return (error);
1726         case VT_SETMODE: {      /* set screen switcher mode */
1727                 struct vt_mode *mode;
1728                 struct proc *p1;
1729
1730                 mode = (struct vt_mode *)data;
1731                 DPRINTF(5, "%s%d: VT_SETMODE ", SC_DRIVER_NAME, VT_UNIT(vw));
1732                 if (vw->vw_smode.mode == VT_PROCESS) {
1733                         p1 = pfind(vw->vw_pid);
1734                         if (vw->vw_proc == p1 && vw->vw_proc != td->td_proc) {
1735                                 if (p1)
1736                                         PROC_UNLOCK(p1);
1737                                 DPRINTF(5, "error EPERM\n");
1738                                 return (EPERM);
1739                         }
1740                         if (p1)
1741                                 PROC_UNLOCK(p1);
1742                 }
1743                 if (mode->mode == VT_AUTO) {
1744                         vw->vw_smode.mode = VT_AUTO;
1745                         vw->vw_proc = NULL;
1746                         vw->vw_pid = 0;
1747                         DPRINTF(5, "VT_AUTO, ");
1748                         if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1749                                 cnavailable(vw->vw_terminal->consdev, TRUE);
1750                         /* were we in the middle of the vty switching process? */
1751                         if (finish_vt_rel(vw, TRUE, &s) == 0)
1752                                 DPRINTF(5, "reset WAIT_REL, ");
1753                         if (finish_vt_acq(vw) == 0)
1754                                 DPRINTF(5, "reset WAIT_ACQ, ");
1755                         return (0);
1756                 } else if (mode->mode == VT_PROCESS) {
1757                         if (!ISSIGVALID(mode->relsig) ||
1758                             !ISSIGVALID(mode->acqsig) ||
1759                             !ISSIGVALID(mode->frsig)) {
1760                                 DPRINTF(5, "error EINVAL\n");
1761                                 return (EINVAL);
1762                         }
1763                         DPRINTF(5, "VT_PROCESS %d, ", td->td_proc->p_pid);
1764                         bcopy(data, &vw->vw_smode, sizeof(struct vt_mode));
1765                         vw->vw_proc = td->td_proc;
1766                         vw->vw_pid = vw->vw_proc->p_pid;
1767                         if (vw == vw->vw_device->vd_windows[VT_CONSWINDOW])
1768                                 cnavailable(vw->vw_terminal->consdev, FALSE);
1769                 } else {
1770                         DPRINTF(5, "VT_SETMODE failed, unknown mode %d\n",
1771                             mode->mode);
1772                         return (EINVAL);
1773                 }
1774                 DPRINTF(5, "\n");
1775                 return (0);
1776         }
1777         case VT_GETMODE:        /* get screen switcher mode */
1778                 bcopy(&vw->vw_smode, data, sizeof(struct vt_mode));
1779                 return (0);
1780
1781         case VT_RELDISP:        /* screen switcher ioctl */
1782                 /*
1783                  * This must be the current vty which is in the VT_PROCESS
1784                  * switching mode...
1785                  */
1786                 if ((vw != vd->vd_curwindow) || (vw->vw_smode.mode !=
1787                     VT_PROCESS)) {
1788                         return (EINVAL);
1789                 }
1790                 /* ...and this process is controlling it. */
1791                 if (vw->vw_proc != td->td_proc) {
1792                         return (EPERM);
1793                 }
1794                 error = EINVAL;
1795                 switch(*(int *)data) {
1796                 case VT_FALSE:  /* user refuses to release screen, abort */
1797                         if ((error = finish_vt_rel(vw, FALSE, &s)) == 0)
1798                                 DPRINTF(5, "%s%d: VT_RELDISP: VT_FALSE\n",
1799                                     SC_DRIVER_NAME, VT_UNIT(vw));
1800                         break;
1801                 case VT_TRUE:   /* user has released screen, go on */
1802                         /* finish_vt_rel(..., TRUE, ...) should not be locked */
1803                         if (vw->vw_flags & VWF_SWWAIT_REL) {
1804                                 if ((error = finish_vt_rel(vw, TRUE, &s)) == 0)
1805                                         DPRINTF(5, "%s%d: VT_RELDISP: VT_TRUE\n",
1806                                             SC_DRIVER_NAME, VT_UNIT(vw));
1807                         } else {
1808                                 error = EINVAL;
1809                         }
1810                         return (error);
1811                 case VT_ACKACQ: /* acquire acknowledged, switch completed */
1812                         if ((error = finish_vt_acq(vw)) == 0)
1813                                 DPRINTF(5, "%s%d: VT_RELDISP: VT_ACKACQ\n",
1814                                     SC_DRIVER_NAME, VT_UNIT(vw));
1815                         break;
1816                 default:
1817                         break;
1818                 }
1819                 return (error);
1820         }
1821
1822         return (ENOIOCTL);
1823 }
1824
1825 static struct vt_window *
1826 vt_allocate_window(struct vt_device *vd, unsigned int window)
1827 {
1828         struct vt_window *vw;
1829         struct terminal *tm;
1830         term_pos_t size;
1831         struct winsize wsz;
1832
1833         vw = malloc(sizeof *vw, M_VT, M_WAITOK|M_ZERO);
1834         vw->vw_device = vd;
1835         vw->vw_number = window;
1836         vw->vw_kbdmode = K_XLATE;
1837
1838         if (!(vd->vd_flags & VDF_TEXTMODE))
1839                 vw->vw_font = vtfont_ref(&vt_font_default);
1840
1841         vt_termsize(vd, vw->vw_font, &size);
1842         vt_winsize(vd, vw->vw_font, &wsz);
1843         vtbuf_init(&vw->vw_buf, &size);
1844
1845         tm = vw->vw_terminal = terminal_alloc(&vt_termclass, vw);
1846         terminal_set_winsize(tm, &wsz);
1847         vd->vd_windows[window] = vw;
1848         callout_init(&vw->vw_proc_dead_timer, 0);
1849
1850         return (vw);
1851 }
1852
1853 void
1854 vt_upgrade(struct vt_device *vd)
1855 {
1856         struct vt_window *vw;
1857         unsigned int i;
1858
1859         /* Device didn't pass vd_init() or already upgraded. */
1860         if (vd->vd_flags & (VDF_ASYNC|VDF_DEAD))
1861                 return;
1862         vd->vd_flags |= VDF_ASYNC;
1863
1864         mtx_init(&vd->vd_lock, "vtdev", NULL, MTX_DEF);
1865         cv_init(&vd->vd_winswitch, "vtwswt");
1866
1867         /* Init 25 Hz timer. */
1868         callout_init_mtx(&vd->vd_timer, &vd->vd_lock, 0);
1869
1870         for (i = 0; i < VT_MAXWINDOWS; i++) {
1871                 vw = vd->vd_windows[i];
1872                 if (vw == NULL) {
1873                         /* New window. */
1874                         vw = vt_allocate_window(vd, i);
1875                 }
1876                 if (i == VT_CONSWINDOW) {
1877                         /* Console window. */
1878                         EVENTHANDLER_REGISTER(shutdown_pre_sync,
1879                             vt_window_switch, vw, SHUTDOWN_PRI_DEFAULT);
1880                 }
1881                 terminal_maketty(vw->vw_terminal, "v%r", VT_UNIT(vw));
1882         }
1883         if (vd->vd_curwindow == NULL)
1884                 vd->vd_curwindow = vd->vd_windows[VT_CONSWINDOW];
1885
1886         /* Attach keyboard. */
1887         vt_allocate_keyboard(vd);
1888         DPRINTF(20, "%s: vd_keyboard = %d\n", __func__, vd->vd_keyboard);
1889
1890         /* Start timer when everything ready. */
1891         callout_reset(&vd->vd_timer, hz / VT_TIMERFREQ, vt_timer, vd);
1892 }
1893
1894 static void
1895 vt_resize(struct vt_device *vd)
1896 {
1897         struct vt_window *vw;
1898         int i;
1899
1900         for (i = 0; i < VT_MAXWINDOWS; i++) {
1901                 vw = vd->vd_windows[i];
1902                 /* Resize terminal windows */
1903                 vt_change_font(vw, vw->vw_font);
1904         }
1905 }
1906
1907 void
1908 vt_allocate(struct vt_driver *drv, void *softc)
1909 {
1910         struct vt_device *vd;
1911         struct winsize wsz;
1912
1913         if (main_vd == NULL) {
1914                 main_vd = malloc(sizeof *vd, M_VT, M_WAITOK|M_ZERO);
1915                 printf("%s: VT initialize with new VT driver.\n", __func__);
1916         } else {
1917                 /*
1918                  * Check if have rights to replace current driver. For example:
1919                  * it is bad idea to replace KMS driver with generic VGA one.
1920                  */
1921                 if (drv->vd_priority <= main_vd->vd_driver->vd_priority) {
1922                         printf("%s: Driver priority %d too low. Current %d\n ",
1923                             __func__, drv->vd_priority,
1924                             main_vd->vd_driver->vd_priority);
1925                         return;
1926                 }
1927                 printf("%s: Replace existing VT driver.\n", __func__);
1928         }
1929         vd = main_vd;
1930
1931         /* Stop vt_flush periodic task. */
1932         if (vd->vd_curwindow != NULL)
1933                 callout_drain(&vd->vd_timer);
1934
1935         vd->vd_driver = drv;
1936         vd->vd_softc = softc;
1937         vd->vd_driver->vd_init(vd);
1938
1939         vt_upgrade(vd);
1940
1941         /* Refill settings with new sizes. */
1942         vt_resize(vd);
1943
1944 #ifdef DEV_SPLASH
1945         if (vd->vd_flags & VDF_SPLASH)
1946                 vtterm_splash(vd);
1947 #endif
1948
1949         if (vd->vd_curwindow != NULL)
1950                 callout_schedule(&vd->vd_timer, hz / VT_TIMERFREQ);
1951
1952         termcn_cnregister(vd->vd_windows[VT_CONSWINDOW]->vw_terminal);
1953
1954         /* Update console window sizes to actual. */
1955         vt_winsize(vd, vd->vd_windows[VT_CONSWINDOW]->vw_font, &wsz);
1956         terminal_set_winsize(vd->vd_windows[VT_CONSWINDOW]->vw_terminal, &wsz);
1957 }
1958
1959 void
1960 vt_suspend()
1961 {
1962
1963         if (vt_suspendswitch == 0)
1964                 return;
1965         /* Save current window. */
1966         main_vd->vd_savedwindow = main_vd->vd_curwindow;
1967         /* Ask holding process to free window and switch to console window */
1968         vt_proc_window_switch(main_vd->vd_windows[VT_CONSWINDOW]);
1969 }
1970
1971 void
1972 vt_resume()
1973 {
1974
1975         if (vt_suspendswitch == 0)
1976                 return;
1977         /* Switch back to saved window */
1978         if (main_vd->vd_savedwindow != NULL)
1979                 vt_proc_window_switch(main_vd->vd_savedwindow);
1980         main_vd->vd_savedwindow = NULL;
1981 }