sys/dev/misc/syscons/syscons.c

   1 /*-
   2  * Copyright (c) 1992-1998 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to The DragonFly Project
   6  * by Sascha Wildner <saw@online.de>
   7  *
   8  * Simple font scaling code by Sascha Wildner and Matthew Dillon
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer,
  15  *    without modification, immediately at the beginning of the file.
  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  * 3. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * $FreeBSD: /usr/local/www/cvsroot/FreeBSD/src/sys/dev/syscons/syscons.c,v 1.336.2.17 2004/03/25 08:41:09 ru Exp $
  34  */
  35
  36 #include "use_splash.h"
  37 #include "opt_syscons.h"
  38 #include "opt_ddb.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/eventhandler.h>
  43 #include <sys/reboot.h>
  44 #include <sys/conf.h>
  45 #include <sys/proc.h>
  46 #include <sys/priv.h>
  47 #include <sys/signalvar.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/taskqueue.h>
  50 #include <sys/tty.h>
  51 #include <sys/kernel.h>
  52 #include <sys/cons.h>
  53 #include <sys/random.h>
  54 #include <ddb/ddb.h>
  55
  56 #include <sys/thread2.h>
  57 #include <sys/mutex2.h>
  58
  59 #include <machine/clock.h>
  60 #include <machine/console.h>
  61 #include <machine/psl.h>
  62 #include <machine/pc/display.h>
  63 #include <machine/frame.h>
  64 #include <machine/framebuffer.h>
  65
  66 #include <dev/misc/kbd/kbdreg.h>
  67 #include <dev/video/fb/fbreg.h>
  68 #include <dev/video/fb/splashreg.h>
  69 #include "syscons.h"
  70
  71 #define COLD 0
  72 #define WARM 1
  73
  74 #define DEFAULT_BLANKTIME       (5*60)          /* 5 minutes */
  75 #define MAX_BLANKTIME           (7*24*60*60)    /* 7 days!? */
  76
  77 #define SCRN_ASYNCOK            0x0001
  78 #define SCRN_BULKUNLOCK         0x0002
  79
  80 #define KEYCODE_BS              0x0e            /* "<-- Backspace" key, XXX */
  81 #define WANT_UNLOCK(m) do {       \
  82         if (m)                    \
  83                 syscons_unlock(); \
  84 } while (0)
  85
  86 #define WANT_LOCK(m) do {         \
  87         if (m)                    \
  88                 syscons_lock();   \
  89 } while(0)
  90
  91
  92 MALLOC_DEFINE(M_SYSCONS, "syscons", "Syscons");
  93
  94 typedef struct default_attr {
  95         int             std_color;              /* normal hardware color */
  96         int             rev_color;              /* reverse hardware color */
  97 } default_attr;
  98
  99 static default_attr user_default = {
 100     SC_NORM_ATTR,
 101     SC_NORM_REV_ATTR,
 102 };
 103
 104 static default_attr kernel_default = {
 105     SC_KERNEL_CONS_ATTR,
 106     SC_KERNEL_CONS_REV_ATTR,
 107 };
 108
 109 static  int             sc_console_unit = -1;
 110 static  scr_stat        *sc_console;
 111 static  struct tty      *sc_console_tty;
 112 static  void            *kernel_console_ts;
 113
 114 static  char            init_done = COLD;
 115 static  char            shutdown_in_progress = FALSE;
 116 static  char            sc_malloc = FALSE;
 117 static  char            sc_filled_border = FALSE; /* filled initial VT border */
 118
 119 static  int             saver_mode = CONS_NO_SAVER; /* LKM/user saver */
 120 static  int             run_scrn_saver = FALSE; /* should run the saver? */
 121 static  long            scrn_blank_time = 0;    /* screen saver timeout value */
 122 #if NSPLASH > 0
 123 static  int             scrn_blanked;           /* # of blanked screen */
 124 static  int             sticky_splash = FALSE;
 125
 126 static  void            none_saver(sc_softc_t *sc, int blank) { }
 127 static  void            (*current_saver)(sc_softc_t *, int) = none_saver;
 128 #endif
 129
 130 /*
 131  * Lock for asynchronous screen update thread, needed to safely modify the
 132  * framebuffer information.
 133  */
 134 static struct lock      sc_asynctd_lk;
 135
 136 #if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT)
 137 #include "font.h"
 138 #endif
 139
 140 static  bios_values_t   bios_value;
 141
 142 static  int             enable_panic_key;
 143 SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key,
 144            0, "Enable the panic key (CTRL-ALT-SHIFT-ESC)");
 145 static  int             syscons_async;
 146 SYSCTL_INT(_kern, OID_AUTO, syscons_async, CTLFLAG_RW, &syscons_async,
 147            0, "Asynchronous bulk syscons fb updates");
 148
 149 static int desired_cols = 0;
 150 TUNABLE_INT("kern.kms_columns", &desired_cols);
 151
 152 #define SC_CONSOLECTL   255
 153
 154 #define VIRTUAL_TTY(sc, x) ((SC_DEV((sc),(x)) != NULL) ?        \
 155         (SC_DEV((sc),(x))->si_tty) : NULL)
 156 #define ISTTYOPEN(tp)   ((tp) && ((tp)->t_state & TS_ISOPEN))
 157
 158 static  int     debugger;
 159 static  cdev_t  cctl_dev;
 160 #if 0
 161 static  timeout_t blink_screen_callout;
 162 #endif
 163 static  void    sc_blink_screen(scr_stat *scp);
 164 static  struct mtx      syscons_mtx = MTX_INITIALIZER("syscons");
 165
 166 /* prototypes */
 167 static int scvidprobe(int unit, int flags, int cons);
 168 static int sckbdprobe(int unit, int flags, int cons);
 169 static void scmeminit(void *arg);
 170 static int scdevtounit(cdev_t dev);
 171 static kbd_callback_func_t sckbdevent;
 172 static int scparam(struct tty *tp, struct termios *t);
 173 static void scstart(struct tty *tp);
 174 static void scinit(int unit, int flags);
 175 static void scterm(int unit, int flags);
 176 static void scshutdown(void *arg, int howto);
 177 static void sc_puts(scr_stat *scp, u_char *buf, int len);
 178 static u_int scgetc(sc_softc_t *sc, u_int flags);
 179 #define SCGETC_CN       1
 180 #define SCGETC_NONBLOCK 2
 181 static int sccngetch(int flags);
 182 static void sccnupdate(scr_stat *scp);
 183 static scr_stat *alloc_scp(sc_softc_t *sc, int vty);
 184 static void init_scp(sc_softc_t *sc, int vty, scr_stat *scp);
 185 static timeout_t scrn_timer;
 186 static int and_region(int *s1, int *e1, int s2, int e2);
 187 static void scrn_update(scr_stat *scp, int show_cursor, int flags);
 188 static void scrn_update_thread(void *arg);
 189
 190 static void sc_fb_set_par(void *context, int pending);
 191 #if NSPLASH > 0
 192 static void sc_fb_blank(void *context, int pending);
 193 #endif /* NSPLASH */
 194
 195 #if NSPLASH > 0
 196 static void scframebuffer_saver(sc_softc_t *sc, int show);
 197 static int scsplash_callback(int event, void *arg);
 198 static void scsplash_saver(sc_softc_t *sc, int show);
 199 static int add_scrn_saver(void (*this_saver)(sc_softc_t *, int));
 200 static int remove_scrn_saver(void (*this_saver)(sc_softc_t *, int));
 201 static int set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border);
 202 static int restore_scrn_saver_mode(scr_stat *scp, int changemode);
 203 static void stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int));
 204 static int wait_scrn_saver_stop(sc_softc_t *sc, int need_unlock);
 205 #define scsplash_stick(stick)           (sticky_splash = (stick))
 206 #else /* !NSPLASH */
 207 #define scsplash_stick(stick)
 208 #endif /* NSPLASH */
 209
 210 static void do_switch_scr(sc_softc_t *sc);
 211 static int vt_proc_alive(scr_stat *scp);
 212 static int signal_vt_rel(scr_stat *scp);
 213 static int signal_vt_acq(scr_stat *scp);
 214 static int finish_vt_rel(scr_stat *scp, int release);
 215 static int finish_vt_acq(scr_stat *scp);
 216 static void exchange_scr(sc_softc_t *sc);
 217 static void update_cursor_image(scr_stat *scp);
 218 static int save_kbd_state(scr_stat *scp, int unlock);
 219 static int update_kbd_state(scr_stat *scp, int state, int mask, int unlock);
 220 static int update_kbd_leds(scr_stat *scp, int which);
 221 static int sc_allocate_keyboard(sc_softc_t *sc, int unit);
 222
 223 /*
 224  * Console locking support functions.
 225  *
 226  * We use mutex spinlocks here in order to allow reentrancy which should
 227  * avoid issues during panics.
 228  *
 229  * A panic can stop a cpu while it is holding the syscons_mtx.  If this
 230  * occurs we try for up to 1/2 a second and then blow the spinlock away.
 231  * The asynchronous update thread makes this happen more often.
 232  */
 233 static void
 234 syscons_lock(void)
 235 {
 236         if (panicstr || shutdown_in_progress) {
 237                 int retries = 500000;
 238                 while (mtx_spinlock_try(&syscons_mtx)) {
 239                         tsc_delay(1000);        /* 1uS */
 240                         if (--retries == 0) {
 241                                 mtx_init(&syscons_mtx, "syscons");
 242                                 retries = 500000;
 243                         }
 244                 }
 245         } else {
 246                 mtx_spinlock(&syscons_mtx);
 247         }
 248 }
 249
 250 /*
 251  * Returns 0 on success, EAGAIN on failure.
 252  */
 253 static int
 254 syscons_lock_nonblock(void)
 255 {
 256         return(mtx_spinlock_try(&syscons_mtx));
 257 }
 258
 259 static void
 260 syscons_unlock(void)
 261 {
 262         mtx_spinunlock(&syscons_mtx);
 263 }
 264
 265 /*
 266  * Console driver
 267  */
 268 static cn_probe_t       sccnprobe;
 269 static cn_init_t        sccninit;
 270 static cn_init_t        sccninit_fini;
 271 static cn_getc_t        sccngetc;
 272 static cn_checkc_t      sccncheckc;
 273 static cn_putc_t        sccnputc;
 274 static cn_dbctl_t       sccndbctl;
 275 static cn_term_t        sccnterm;
 276 static cn_poll_t        sccnpoll;
 277
 278 CONS_DRIVER(sc, sccnprobe, sccninit, sccninit_fini, sccnterm,
 279             sccngetc, sccncheckc, sccnputc, sccndbctl, sccnpoll);
 280
 281 static  d_open_t        scopen;
 282 static  d_close_t       scclose;
 283 static  d_read_t        scread;
 284 static  d_ioctl_t       scioctl;
 285 static  d_mmap_t        scmmap;
 286
 287 static struct dev_ops sc_ops = {
 288         { "sc", 0, D_TTY | D_MPSAFE },
 289         .d_open =       scopen,
 290         .d_close =      scclose,
 291         .d_read =       scread,
 292         .d_write =      ttywrite,
 293         .d_ioctl =      scioctl,
 294         .d_mmap =       scmmap,
 295         .d_kqfilter =   ttykqfilter,
 296         .d_revoke =     ttyrevoke
 297 };
 298
 299 int
 300 sc_probe_unit(int unit, int flags)
 301 {
 302     if ((flags & SC_EFI_FB) && (probe_efi_fb(0) != 0)) {
 303         if (bootverbose)
 304             kprintf("sc%d: no EFI framebuffer found.\n", unit);
 305         flags &= ~SC_EFI_FB;
 306     }
 307
 308     if (!(flags & SC_EFI_FB) && !scvidprobe(unit, flags, FALSE)) {
 309         if (bootverbose)
 310             kprintf("sc%d: no video adapter found.\n", unit);
 311         return ENXIO;
 312     }
 313
 314     /* syscons will be attached even when there is no keyboard */
 315     sckbdprobe(unit, flags, FALSE);
 316
 317     return 0;
 318 }
 319
 320 int
 321 register_framebuffer(struct fb_info *info)
 322 {
 323         sc_softc_t *sc;
 324
 325         /* For now ignore framebuffers, which don't replace the vga display */
 326         if (!info->is_vga_boot_display)
 327                 return 0;
 328
 329         lwkt_gettoken(&tty_token);
 330         sc = sc_get_softc(0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
 331         if (sc == NULL) {
 332                 lwkt_reltoken(&tty_token);
 333                 kprintf("%s: sc_get_softc(%d, %d) returned NULL\n", __func__,
 334                     0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
 335                 return 0;
 336         }
 337
 338         /* Ignore this framebuffer if we already switched to KMS framebuffer */
 339         if (sc->fbi != NULL && sc->fbi != &efi_fb_info &&
 340             sc->fbi != sc->dummy_fb_info) {
 341                 lwkt_reltoken(&tty_token);
 342                 return 0;
 343         }
 344
 345         if (sc->fb_set_par_task == NULL) {
 346                 sc->fb_set_par_task = kmalloc(sizeof(struct task),
 347                     M_SYSCONS, M_WAITOK | M_ZERO);
 348         }
 349         TASK_INIT(sc->fb_set_par_task, 0, sc_fb_set_par, sc);
 350 #if NSPLASH > 0
 351         if (sc->fb_blank_task == NULL) {
 352                 sc->fb_blank_task = kmalloc(sizeof(struct task),
 353                     M_SYSCONS, M_WAITOK | M_ZERO);
 354         }
 355         TASK_INIT(sc->fb_blank_task, 0, sc_fb_blank, sc);
 356 #endif /* NSPLASH */
 357
 358         /*
 359          * Make sure that console messages don't interfere too much with
 360          * modesetting.
 361          */
 362         atomic_add_int(&sc->videoio_in_progress, 1);
 363
 364         /* Lock against synchronous and asynchronous screen updates */
 365         lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
 366         syscons_lock();
 367         sc->fbi = info;
 368         sc->fbi_generation++;
 369         syscons_unlock();
 370
 371         kprintf("kms console: xpixels %d ypixels %d\n",
 372             sc->fbi->width, sc->fbi->height);
 373         sc_update_render(sc->cur_scp);
 374         if (info->fbops.fb_set_par != NULL)
 375                 info->fbops.fb_set_par(info);
 376         atomic_add_int(&sc->videoio_in_progress, -1);
 377
 378         sc->fb_blanked = FALSE;
 379         if (sc->unit == sc_console_unit && sc->cur_scp->smode.mode != VT_AUTO)
 380                 cons_unavail = FALSE;
 381 #if NSPLASH > 0
 382         if (info->fbops.fb_blank != NULL)
 383                 add_scrn_saver(scframebuffer_saver);
 384 #endif /* NSPLASH */
 385
 386         lockmgr(&sc_asynctd_lk, LK_RELEASE);
 387         lwkt_reltoken(&tty_token);
 388         return 0;
 389 }
 390
 391 void
 392 unregister_framebuffer(struct fb_info *info)
 393 {
 394         sc_softc_t *sc;
 395
 396         lwkt_gettoken(&tty_token);
 397         sc = sc_get_softc(0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
 398         if (sc == NULL) {
 399                 lwkt_reltoken(&tty_token);
 400                 kprintf("%s: sc_get_softc(%d, %d) returned NULL\n", __func__,
 401                     0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
 402                 return;
 403         }
 404
 405         if (sc->fbi != info) {
 406                 lwkt_reltoken(&tty_token);
 407                 return;
 408         }
 409
 410 #if NSPLASH > 0
 411         if (info->fbops.fb_blank != NULL)
 412                 remove_scrn_saver(scframebuffer_saver);
 413 #endif /* NSPLASH */
 414
 415         if (sc->fb_set_par_task != NULL &&
 416             taskqueue_cancel(taskqueue_thread[0], sc->fb_set_par_task, NULL)) {
 417                 taskqueue_drain(taskqueue_thread[0], sc->fb_set_par_task);
 418         }
 419 #if NSPLASH > 0
 420         if (sc->fb_blank_task != NULL &&
 421             taskqueue_cancel(taskqueue_thread[0], sc->fb_blank_task, NULL)) {
 422                 taskqueue_drain(taskqueue_thread[0], sc->fb_blank_task);
 423         }
 424 #endif /* NSPLASH */
 425         sc->fb_blanked = TRUE;
 426         if (sc->unit == sc_console_unit)
 427                 cons_unavail = TRUE;
 428
 429         if (sc->dummy_fb_info == NULL) {
 430                 sc->dummy_fb_info = kmalloc(sizeof(struct fb_info),
 431                     M_SYSCONS, M_WAITOK | M_ZERO);
 432         } else {
 433                 memset(sc->dummy_fb_info, 0, sizeof(struct fb_info));
 434         }
 435         *sc->dummy_fb_info = *sc->fbi;
 436         sc->dummy_fb_info->vaddr = 0;
 437         sc->dummy_fb_info->fbops.fb_set_par = NULL;
 438         sc->dummy_fb_info->fbops.fb_blank = NULL;
 439         sc->dummy_fb_info->fbops.fb_debug_enter = NULL;
 440
 441         /* Lock against synchronous and asynchronous screen updates */
 442         lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
 443         syscons_lock();
 444         sc->fbi = sc->dummy_fb_info;
 445         syscons_unlock();
 446         lockmgr(&sc_asynctd_lk, LK_RELEASE);
 447
 448         lwkt_reltoken(&tty_token);
 449 }
 450
 451 void
 452 sc_font_scale(scr_stat *scp, int max_cols, int max_rows)
 453 {
 454         int cols, rows;
 455
 456         /*
 457          * If columns not specified in /boot/loader.conf then
 458          * calculate a non-fractional scaling that yields a
 459          * reasonable number of rows and columns. If it is <0,
 460          * don't scale at all.
 461          */
 462         if (desired_cols == 0) {
 463                 int nomag = 1;
 464                 while (scp->xpixel / (scp->font_width * nomag) >= COL &&
 465                        scp->ypixel / (scp->font_height * nomag) >= ROW) {
 466                         ++nomag;
 467                 }
 468                 if (nomag > 1)
 469                         --nomag;
 470                 cols = scp->xpixel / (scp->font_width * nomag);
 471         } else if (desired_cols < 0) {
 472                 cols = scp->xpixel / scp->font_width;
 473         } else {
 474                 cols = desired_cols;
 475         }
 476         scp->blk_width = scp->xpixel / cols;
 477         scp->blk_height = scp->blk_width * scp->font_height / scp->font_width;
 478         rows = scp->ypixel / scp->blk_height;
 479
 480         /* scp->xsize = scp->xpixel / scp->blk_width; total possible */
 481         scp->xsize = max_cols ? imin(max_cols, cols) : cols;
 482         scp->ysize = max_rows ? imin(max_rows, rows) : rows;
 483 }
 484
 485 /* probe video adapters, return TRUE if found */
 486 static int
 487 scvidprobe(int unit, int flags, int cons)
 488 {
 489     /*
 490      * Access the video adapter driver through the back door!
 491      * Video adapter drivers need to be configured before syscons.
 492      * However, when syscons is being probed as the low-level console,
 493      * they have not been initialized yet.  We force them to initialize
 494      * themselves here. XXX
 495      */
 496     vid_configure(cons ? VIO_PROBE_ONLY : 0);
 497
 498     return (vid_find_adapter("*", unit) >= 0);
 499 }
 500
 501 /* probe the keyboard, return TRUE if found */
 502 static int
 503 sckbdprobe(int unit, int flags, int cons)
 504 {
 505     /* access the keyboard driver through the backdoor! */
 506     kbd_configure(cons ? KB_CONF_PROBE_ONLY : 0);
 507
 508     return (kbd_find_keyboard("*", unit) >= 0);
 509 }
 510
 511 static char *
 512 adapter_name(video_adapter_t *adp)
 513 {
 514     static struct {
 515         int type;
 516         char *name[2];
 517     } names[] = {
 518         { KD_MONO,      { "MDA",        "MDA" } },
 519         { KD_HERCULES,  { "Hercules",   "Hercules" } },
 520         { KD_CGA,       { "CGA",        "CGA" } },
 521         { KD_EGA,       { "EGA",        "EGA (mono)" } },
 522         { KD_VGA,       { "VGA",        "VGA (mono)" } },
 523         { KD_TGA,       { "TGA",        "TGA" } },
 524         { -1,           { "Unknown",    "Unknown" } },
 525     };
 526     int i;
 527
 528     for (i = 0; names[i].type != -1; ++i)
 529         if (names[i].type == adp->va_type)
 530             break;
 531     return names[i].name[(adp->va_flags & V_ADP_COLOR) ? 0 : 1];
 532 }
 533
 534 int
 535 sc_attach_unit(int unit, int flags)
 536 {
 537     sc_softc_t *sc;
 538     scr_stat *scp;
 539     int vc;
 540     cdev_t dev;
 541     flags &= ~SC_KERNEL_CONSOLE;
 542
 543     if ((flags & SC_EFI_FB) && probe_efi_fb(0) != 0)
 544         flags &= ~SC_EFI_FB;
 545
 546     if (sc_console_unit == unit) {
 547         /*
 548          * If this unit is being used as the system console, we need to
 549          * adjust some variables and buffers before and after scinit().
 550          */
 551         /* assert(sc_console != NULL) */
 552         flags |= SC_KERNEL_CONSOLE;
 553         scmeminit(NULL);
 554
 555         scinit(unit, flags);
 556
 557         if (sc_console->tsw->te_size > 0) {
 558             /* assert(sc_console->ts != NULL); */
 559             kernel_console_ts = sc_console->ts;
 560             sc_console->ts = kmalloc(sc_console->tsw->te_size,
 561                                     M_SYSCONS, M_WAITOK);
 562             bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size);
 563             (*sc_console->tsw->te_default_attr)(sc_console,
 564                                                 user_default.std_color,
 565                                                 user_default.rev_color);
 566         }
 567     } else {
 568         scinit(unit, flags);
 569     }
 570
 571     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
 572
 573     /*
 574      * If this is the console we couldn't setup sc->dev before because
 575      * malloc wasn't working.  Set it up now.
 576      */
 577     if (flags & SC_KERNEL_CONSOLE) {
 578         KKASSERT(sc->dev == NULL);
 579         sc->dev = kmalloc(sizeof(cdev_t)*sc->vtys, M_SYSCONS, M_WAITOK|M_ZERO);
 580         sc->dev[0] = make_dev(&sc_ops, sc_console_unit*MAXCONS, UID_ROOT,
 581                               GID_WHEEL, 0600,
 582                               "ttyv%r", sc_console_unit*MAXCONS);
 583         sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
 584         sc->dev[0]->si_drv1 = sc_console;
 585     }
 586
 587     /*
 588      * Finish up the standard attach
 589      */
 590     sc->config = flags;
 591     callout_init_mp(&sc->scrn_timer_ch);
 592     scp = SC_STAT(sc->dev[0]);
 593     if (sc_console == NULL)     /* sc_console_unit < 0 */
 594         sc_console = scp;
 595
 596     /* initialize cursor */
 597     if (!ISGRAPHSC(scp))
 598         update_cursor_image(scp);
 599
 600     /* get screen update going */
 601     scrn_timer(sc);
 602
 603     /* set up the keyboard */
 604     kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
 605     update_kbd_state(scp, scp->status, LOCK_MASK, FALSE);
 606
 607     kprintf("sc%d: %s <%d virtual consoles, flags=0x%x>\n",
 608             unit, (sc->config & SC_EFI_FB) ? "EFI_FB" : adapter_name(sc->adp),
 609             sc->vtys, sc->config);
 610     if (bootverbose) {
 611         kprintf("sc%d:", unit);
 612         if (sc->adapter >= 0)
 613             kprintf(" fb%d", sc->adapter);
 614         if (sc->keyboard >= 0)
 615             kprintf(", kbd%d", sc->keyboard);
 616         if (scp->tsw)
 617             kprintf(", terminal emulator: %s (%s)",
 618                    scp->tsw->te_name, scp->tsw->te_desc);
 619         kprintf("\n");
 620     }
 621
 622     /* register a shutdown callback for the kernel console */
 623     if (sc_console_unit == unit)
 624         EVENTHANDLER_REGISTER(shutdown_pre_sync, scshutdown,
 625                               (void *)(uintptr_t)unit, SHUTDOWN_PRI_DEFAULT);
 626
 627     /*
 628      * create devices.
 629      *
 630      * The first vty already has struct tty and scr_stat initialized
 631      * in scinit().  The other vtys will have these structs when
 632      * first opened.
 633      */
 634     for (vc = 1; vc < sc->vtys; vc++) {
 635         dev = make_dev(&sc_ops, vc + unit * MAXCONS,
 636                         UID_ROOT, GID_WHEEL,
 637                         0600, "ttyv%r", vc + unit * MAXCONS);
 638         sc->dev[vc] = dev;
 639     }
 640     cctl_dev = make_dev(&sc_ops, SC_CONSOLECTL,
 641                         UID_ROOT, GID_WHEEL, 0600, "consolectl");
 642     cctl_dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty);
 643     cctl_dev->si_drv1 = sc_console;
 644     return 0;
 645 }
 646
 647 static void
 648 scmeminit(void *arg)
 649 {
 650     if (sc_malloc)
 651         return;
 652     sc_malloc = TRUE;
 653
 654     /*
 655      * As soon as malloc() becomes functional, we had better allocate
 656      * various buffers for the kernel console.
 657      */
 658
 659     if (sc_console_unit < 0)    /* sc_console == NULL */
 660         return;
 661
 662     /* copy the temporary buffer to the final buffer */
 663     sc_alloc_scr_buffer(sc_console, TRUE, FALSE);
 664
 665 #ifndef SC_NO_CUTPASTE
 666     sc_alloc_cut_buffer(sc_console, TRUE);
 667 #endif
 668
 669 #ifndef SC_NO_HISTORY
 670     /* initialize history buffer & pointers */
 671     sc_alloc_history_buffer(sc_console, 0, 0, TRUE);
 672 #endif
 673
 674     /* Fill initial terminal border, efi_fb_info.vaddr should be non-NULL now */
 675     if (!sc_filled_border) {
 676         sc_filled_border = TRUE;
 677         sc_set_border(sc_console, sc_console->border);
 678     }
 679 }
 680
 681 SYSINIT(sc_mem, SI_BOOT1_POST, SI_ORDER_ANY, scmeminit, NULL);
 682
 683 static int
 684 scdevtounit(cdev_t dev)
 685 {
 686     int vty = SC_VTY(dev);
 687
 688     if (vty == SC_CONSOLECTL)
 689         return ((sc_console != NULL) ? sc_console->sc->unit : -1);
 690     else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit()))
 691         return -1;
 692     else
 693         return vty/MAXCONS;
 694 }
 695
 696 static int
 697 scopen(struct dev_open_args *ap)
 698 {
 699     cdev_t dev = ap->a_head.a_dev;
 700     int unit;
 701     sc_softc_t *sc;
 702     struct tty *tp;
 703     scr_stat *scp;
 704     keyarg_t key;
 705     int error;
 706
 707     lwkt_gettoken(&tty_token);
 708     unit = scdevtounit(dev);
 709     DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n",
 710                 major(dev), minor(dev), unit, SC_VTY(dev)));
 711
 712     sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0);
 713     if (sc == NULL) {
 714         lwkt_reltoken(&tty_token);
 715         return ENXIO;
 716     }
 717
 718     tp = dev->si_tty = ttymalloc(dev->si_tty);
 719     tp->t_oproc = scstart;
 720     tp->t_param = scparam;
 721     tp->t_stop = nottystop;
 722
 723     tp->t_dev = dev;
 724
 725     if (!ISTTYOPEN(tp)) {
 726         ttychars(tp);
 727         /* Use the current setting of the <-- key as default VERASE. */
 728         /* If the Delete key is preferable, an stty is necessary     */
 729         if (sc->kbd != NULL) {
 730             key.keynum = KEYCODE_BS;
 731             kbd_ioctl(sc->kbd, GIO_KEYMAPENT, (caddr_t)&key);
 732             tp->t_cc[VERASE] = key.key.map[0];
 733         }
 734         tp->t_iflag = TTYDEF_IFLAG;
 735         tp->t_oflag = TTYDEF_OFLAG;
 736         tp->t_cflag = TTYDEF_CFLAG;
 737         tp->t_lflag = TTYDEF_LFLAG;
 738         tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
 739         scparam(tp, &tp->t_termios);
 740         (*linesw[tp->t_line].l_modem)(tp, 1);
 741     }
 742     else
 743         if (tp->t_state & TS_XCLUDE && priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) {
 744             lwkt_reltoken(&tty_token);
 745             return(EBUSY);
 746         }
 747
 748     error = (*linesw[tp->t_line].l_open)(dev, tp);
 749
 750     scp = SC_STAT(dev);
 751     if (scp == NULL) {
 752         scp = dev->si_drv1 = alloc_scp(sc, SC_VTY(dev));
 753         syscons_lock();
 754         if (ISGRAPHSC(scp))
 755             sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
 756         syscons_unlock();
 757     }
 758     if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) {
 759         tp->t_winsize.ws_col = scp->xsize;
 760         tp->t_winsize.ws_row = scp->ysize;
 761     }
 762
 763     /*
 764      * Start optional support thread for syscons refreshes.  This thread
 765      * will execute the refresh without the syscons_lock held and will
 766      * allow interrupts while it is doing so.
 767      */
 768     if (scp->asynctd == NULL) {
 769             lwkt_create(scrn_update_thread, scp, &scp->asynctd, NULL, 0, -1,
 770                         "syscons%d", SC_VTY(dev));
 771     }
 772     lwkt_reltoken(&tty_token);
 773     return error;
 774 }
 775
 776 static int
 777 scclose(struct dev_close_args *ap)
 778 {
 779     cdev_t dev = ap->a_head.a_dev;
 780     struct tty *tp = dev->si_tty;
 781     scr_stat *scp;
 782
 783     lwkt_gettoken(&tty_token);
 784     if (SC_VTY(dev) != SC_CONSOLECTL) {
 785         scp = SC_STAT(tp->t_dev);
 786         /* were we in the middle of the VT switching process? */
 787         DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit));
 788         if ((scp == scp->sc->cur_scp) && (scp->sc->unit == sc_console_unit) &&
 789             !scp->sc->fb_blanked) {
 790             cons_unavail = FALSE;
 791         }
 792         if (finish_vt_rel(scp, TRUE) == 0)      /* force release */
 793             DPRINTF(5, ("reset WAIT_REL, "));
 794         if (finish_vt_acq(scp) == 0)            /* force acknowledge */
 795             DPRINTF(5, ("reset WAIT_ACQ, "));
 796         syscons_lock();
 797 #if 0 /* notyet */
 798         if (scp == &main_console) {
 799             scp->pid = 0;
 800             scp->proc = NULL;
 801             scp->smode.mode = VT_AUTO;
 802         }
 803         else {
 804             sc_vtb_destroy(&scp->vtb);
 805             sc_vtb_destroy(&scp->scr);
 806             sc_free_history_buffer(scp, scp->ysize);
 807             SC_STAT(dev) = NULL;
 808             kfree(scp, M_SYSCONS);
 809         }
 810 #else
 811         scp->pid = 0;
 812         scp->proc = NULL;
 813         scp->smode.mode = VT_AUTO;
 814 #endif
 815         scp->kbd_mode = K_XLATE;
 816         syscons_unlock();
 817         if (scp == scp->sc->cur_scp)
 818             kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
 819         DPRINTF(5, ("done.\n"));
 820     }
 821     (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
 822     ttyclose(tp);
 823     lwkt_reltoken(&tty_token);
 824
 825     return(0);
 826 }
 827
 828 static int
 829 scread(struct dev_read_args *ap)
 830 {
 831     int ret;
 832
 833     lwkt_gettoken(&tty_token);
 834     sc_touch_scrn_saver();
 835     ret = ttyread(ap);
 836     lwkt_reltoken(&tty_token);
 837     return ret;
 838 }
 839
 840 static int
 841 sckbdevent(keyboard_t *thiskbd, int event, void *arg)
 842 {
 843     sc_softc_t *sc;
 844     struct tty *cur_tty;
 845     int c;
 846     size_t len;
 847     u_char *cp;
 848
 849     lwkt_gettoken(&tty_token);
 850     /*
 851      * WARNING: In early boot sc->dev may not be setup yet.
 852      */
 853     sc = (sc_softc_t *)arg;
 854     /* assert(thiskbd == sc->kbd) */
 855
 856     switch (event) {
 857     case KBDIO_KEYINPUT:
 858         if (sc->kbd && sc->kbd->kb_flags & KB_POLLED) {
 859                 lwkt_reltoken(&tty_token);
 860                 return 0;
 861         }
 862         break;
 863     case KBDIO_UNLOADING:
 864         syscons_lock();
 865         sc->kbd = NULL;
 866         sc->keyboard = -1;
 867         syscons_unlock();
 868         kbd_release(thiskbd, (void *)&sc->keyboard);
 869         lwkt_reltoken(&tty_token);
 870         return 0;
 871     default:
 872         lwkt_reltoken(&tty_token);
 873         return EINVAL;
 874     }
 875
 876     /*
 877      * Loop while there is still input to get from the keyboard.
 878      * I don't think this is nessesary, and it doesn't fix
 879      * the Xaccel-2.1 keyboard hang, but it can't hurt.         XXX
 880      */
 881     while ((c = scgetc(sc, SCGETC_NONBLOCK)) != NOKEY) {
 882         cur_tty = VIRTUAL_TTY(sc, sc->cur_scp->index);
 883         if (!ISTTYOPEN(cur_tty)) {
 884             cur_tty = sc_console_tty;
 885             if (!ISTTYOPEN(cur_tty))
 886                 continue;
 887         }
 888
 889         syscons_lock();
 890         if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty)) {
 891             syscons_unlock();
 892             continue;
 893         }
 894         syscons_unlock();
 895
 896         switch (KEYFLAGS(c)) {
 897         case 0x0000: /* normal key */
 898             (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
 899             break;
 900         case FKEY:  /* function key, return string */
 901             cp = kbd_get_fkeystr(thiskbd, KEYCHAR(c), &len);
 902             if (cp != NULL) {
 903                 while (len-- >  0)
 904                     (*linesw[cur_tty->t_line].l_rint)(*cp++, cur_tty);
 905             }
 906             break;
 907         case MKEY:  /* meta is active, prepend ESC */
 908             (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
 909             (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
 910             break;
 911         case BKEY:  /* backtab fixed sequence (esc [ Z) */
 912             (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
 913             (*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
 914             (*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
 915             break;
 916         }
 917     }
 918
 919     syscons_lock();
 920     sc->cur_scp->status |= MOUSE_HIDDEN;
 921     syscons_unlock();
 922
 923     lwkt_reltoken(&tty_token);
 924     return 0;
 925 }
 926
 927 static int
 928 scparam(struct tty *tp, struct termios *t)
 929 {
 930     lwkt_gettoken(&tty_token);
 931     tp->t_ispeed = t->c_ispeed;
 932     tp->t_ospeed = t->c_ospeed;
 933     tp->t_cflag = t->c_cflag;
 934     lwkt_reltoken(&tty_token);
 935     return 0;
 936 }
 937
 938 static int
 939 scioctl(struct dev_ioctl_args *ap)
 940 {
 941     cdev_t dev = ap->a_head.a_dev;
 942     u_long cmd = ap->a_cmd;
 943     caddr_t data = ap->a_data;
 944     int flag = ap->a_fflag;
 945     int error;
 946     int i;
 947     struct tty *tp;
 948     sc_softc_t *sc;
 949     scr_stat *scp;
 950
 951     lwkt_gettoken(&tty_token);
 952     tp = dev->si_tty;
 953
 954     error = sc_vid_ioctl(tp, cmd, data, flag);
 955     if (error != ENOIOCTL) {
 956         lwkt_reltoken(&tty_token);
 957         return error;
 958     }
 959
 960 #ifndef SC_NO_HISTORY
 961     error = sc_hist_ioctl(tp, cmd, data, flag);
 962     if (error != ENOIOCTL) {
 963         lwkt_reltoken(&tty_token);
 964         return error;
 965     }
 966 #endif
 967
 968 #ifndef SC_NO_SYSMOUSE
 969     error = sc_mouse_ioctl(tp, cmd, data, flag);
 970     if (error != ENOIOCTL) {
 971         lwkt_reltoken(&tty_token);
 972         return error;
 973     }
 974 #endif
 975
 976     scp = SC_STAT(tp->t_dev);
 977     /* assert(scp != NULL) */
 978     /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */
 979     sc = scp->sc;
 980
 981     if (scp->tsw) {
 982         syscons_lock();
 983         error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag);
 984         syscons_unlock();
 985         if (error != ENOIOCTL) {
 986             lwkt_reltoken(&tty_token);
 987             return error;
 988         }
 989     }
 990
 991     switch (cmd) {              /* process console hardware related ioctl's */
 992
 993     case GIO_ATTR:              /* get current attributes */
 994         /* this ioctl is not processed here, but in the terminal emulator */
 995         lwkt_reltoken(&tty_token);
 996         return ENOTTY;
 997
 998     case GIO_COLOR:             /* is this a color console ? */
 999         if (sc->fbi != NULL)
1000             *(int *)data = 1;
1001         else
1002             *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0;
1003         lwkt_reltoken(&tty_token);
1004         return 0;
1005
1006     case CONS_BLANKTIME:        /* set screen saver timeout (0 = no saver) */
1007         if (*(int *)data < 0 || *(int *)data > MAX_BLANKTIME) {
1008             lwkt_reltoken(&tty_token);
1009             return EINVAL;
1010         }
1011         syscons_lock();
1012         scrn_blank_time = *(int *)data;
1013         run_scrn_saver = (scrn_blank_time != 0);
1014         syscons_unlock();
1015         lwkt_reltoken(&tty_token);
1016         return 0;
1017
1018     case CONS_CURSORTYPE:       /* set cursor type blink/noblink */
1019         syscons_lock();
1020         if (!ISGRAPHSC(sc->cur_scp))
1021             sc_remove_cursor_image(sc->cur_scp);
1022         if ((*(int*)data) & 0x01)
1023             sc->flags |= SC_BLINK_CURSOR;
1024         else
1025             sc->flags &= ~SC_BLINK_CURSOR;
1026         if ((*(int*)data) & 0x02) {
1027             sc->flags |= SC_CHAR_CURSOR;
1028         } else
1029             sc->flags &= ~SC_CHAR_CURSOR;
1030         /*
1031          * The cursor shape is global property; all virtual consoles
1032          * are affected. Update the cursor in the current console...
1033          */
1034         if (!ISGRAPHSC(sc->cur_scp)) {
1035             sc_set_cursor_image(sc->cur_scp);
1036             sc_draw_cursor_image(sc->cur_scp);
1037         }
1038         syscons_unlock();
1039         lwkt_reltoken(&tty_token);
1040         return 0;
1041
1042     case CONS_BELLTYPE:         /* set bell type sound/visual */
1043         syscons_lock();
1044
1045         if ((*(int *)data) & 0x01)
1046             sc->flags |= SC_VISUAL_BELL;
1047         else
1048             sc->flags &= ~SC_VISUAL_BELL;
1049
1050         if ((*(int *)data) & 0x02)
1051             sc->flags |= SC_QUIET_BELL;
1052         else
1053             sc->flags &= ~SC_QUIET_BELL;
1054
1055         syscons_unlock();
1056         lwkt_reltoken(&tty_token);
1057         return 0;
1058
1059     case CONS_GETINFO:          /* get current (virtual) console info */
1060     {
1061         vid_info_t *ptr = (vid_info_t*)data;
1062         if (ptr->size == sizeof(struct vid_info)) {
1063             ptr->m_num = sc->cur_scp->index;
1064             ptr->font_size = scp->font_height;
1065             ptr->mv_col = scp->xpos;
1066             ptr->mv_row = scp->ypos;
1067             ptr->mv_csz = scp->xsize;
1068             ptr->mv_rsz = scp->ysize;
1069             /*
1070              * The following fields are filled by the terminal emulator. XXX
1071              *
1072              * ptr->mv_norm.fore
1073              * ptr->mv_norm.back
1074              * ptr->mv_rev.fore
1075              * ptr->mv_rev.back
1076              */
1077             ptr->mv_grfc.fore = 0;      /* not supported */
1078             ptr->mv_grfc.back = 0;      /* not supported */
1079             ptr->mv_ovscan = scp->border;
1080             if (scp == sc->cur_scp)
1081                 save_kbd_state(scp, FALSE);
1082             ptr->mk_keylock = scp->status & LOCK_MASK;
1083             lwkt_reltoken(&tty_token);
1084             return 0;
1085         }
1086         lwkt_reltoken(&tty_token);
1087         return EINVAL;
1088     }
1089
1090     case CONS_GETVERS:          /* get version number */
1091         *(int*)data = 0x200;    /* version 2.0 */
1092         lwkt_reltoken(&tty_token);
1093         return 0;
1094
1095     case CONS_IDLE:             /* see if the screen has been idle */
1096         /*
1097          * When the screen is in the GRAPHICS_MODE or UNKNOWN_MODE,
1098          * the user process may have been writing something on the
1099          * screen and syscons is not aware of it. Declare the screen
1100          * is NOT idle if it is in one of these modes. But there is
1101          * an exception to it; if a screen saver is running in the
1102          * graphics mode in the current screen, we should say that the
1103          * screen has been idle.
1104          */
1105         *(int *)data = (sc->flags & SC_SCRN_IDLE)
1106                        && (!ISGRAPHSC(sc->cur_scp)
1107                            || (sc->cur_scp->status & SAVER_RUNNING));
1108         lwkt_reltoken(&tty_token);
1109         return 0;
1110
1111     case CONS_SAVERMODE:        /* set saver mode */
1112         switch(*(int *)data) {
1113         case CONS_NO_SAVER:
1114         case CONS_USR_SAVER:
1115             syscons_lock();
1116             /* if a LKM screen saver is running, stop it first. */
1117             scsplash_stick(FALSE);
1118             saver_mode = *(int *)data;
1119 #if NSPLASH > 0
1120             if ((error = wait_scrn_saver_stop(NULL, TRUE))) {
1121                 syscons_unlock();
1122                 lwkt_reltoken(&tty_token);
1123                 return error;
1124             }
1125 #endif /* NSPLASH */
1126             run_scrn_saver = TRUE;
1127             if (saver_mode == CONS_USR_SAVER)
1128                 scp->status |= SAVER_RUNNING;
1129             else
1130                 scp->status &= ~SAVER_RUNNING;
1131             scsplash_stick(TRUE);
1132             syscons_unlock();
1133             break;
1134         case CONS_LKM_SAVER:
1135             syscons_lock();
1136             if ((saver_mode == CONS_USR_SAVER) && (scp->status & SAVER_RUNNING))
1137                 scp->status &= ~SAVER_RUNNING;
1138             saver_mode = *(int *)data;
1139             syscons_unlock();
1140             break;
1141         default:
1142             lwkt_reltoken(&tty_token);
1143             return EINVAL;
1144         }
1145         lwkt_reltoken(&tty_token);
1146         return 0;
1147
1148     case CONS_SAVERSTART:       /* immediately start/stop the screen saver */
1149         /*
1150          * Note that this ioctl does not guarantee the screen saver
1151          * actually starts or stops. It merely attempts to do so...
1152          */
1153         syscons_lock();
1154         run_scrn_saver = (*(int *)data != 0);
1155         if (run_scrn_saver)
1156             sc->scrn_time_stamp -= scrn_blank_time;
1157         syscons_unlock();
1158         lwkt_reltoken(&tty_token);
1159         return 0;
1160
1161     case CONS_SCRSHOT:          /* get a screen shot */
1162     {
1163         scrshot_t *ptr = (scrshot_t*)data;
1164         syscons_lock();
1165         if (ISGRAPHSC(scp)) {
1166             syscons_unlock();
1167             lwkt_reltoken(&tty_token);
1168             return EOPNOTSUPP;
1169         }
1170         if (scp->xsize != ptr->xsize || scp->ysize != ptr->ysize) {
1171             syscons_unlock();
1172             lwkt_reltoken(&tty_token);
1173             return EINVAL;
1174         }
1175         syscons_unlock();
1176         copyout ((void*)scp->vtb.vtb_buffer, ptr->buf,
1177                  ptr->xsize * ptr->ysize * sizeof(uint16_t));
1178         lwkt_reltoken(&tty_token);
1179         return 0;
1180     }
1181
1182     case VT_SETMODE:            /* set screen switcher mode */
1183     {
1184         struct vt_mode *mode;
1185
1186         mode = (struct vt_mode *)data;
1187         DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit));
1188         if (scp->smode.mode == VT_PROCESS) {
1189             if (scp->proc == pfindn(scp->pid) && scp->proc != curproc) {
1190                 DPRINTF(5, ("error EPERM\n"));
1191                 lwkt_reltoken(&tty_token);
1192                 return EPERM;
1193             }
1194         }
1195         syscons_lock();
1196         if (mode->mode == VT_AUTO) {
1197             scp->smode.mode = VT_AUTO;
1198             scp->proc = NULL;
1199             scp->pid = 0;
1200             DPRINTF(5, ("VT_AUTO, "));
1201             if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit) &&
1202                 !sc->fb_blanked) {
1203                 cons_unavail = FALSE;
1204             }
1205             if (finish_vt_rel(scp, TRUE) == 0)
1206                 DPRINTF(5, ("reset WAIT_REL, "));
1207             if (finish_vt_acq(scp) == 0)
1208                 DPRINTF(5, ("reset WAIT_ACQ, "));
1209         } else {
1210             if (!ISSIGVALID(mode->relsig) || !ISSIGVALID(mode->acqsig)
1211                 || !ISSIGVALID(mode->frsig)) {
1212                 syscons_unlock();
1213                 DPRINTF(5, ("error EINVAL\n"));
1214                 lwkt_reltoken(&tty_token);
1215                 return EINVAL;
1216             }
1217             DPRINTF(5, ("VT_PROCESS %d, ", curproc->p_pid));
1218             bcopy(data, &scp->smode, sizeof(struct vt_mode));
1219             scp->proc = curproc;
1220             scp->pid = scp->proc->p_pid;
1221             if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
1222                 cons_unavail = TRUE;
1223         }
1224         syscons_unlock();
1225         DPRINTF(5, ("\n"));
1226         lwkt_reltoken(&tty_token);
1227         return 0;
1228     }
1229
1230     case VT_GETMODE:            /* get screen switcher mode */
1231         bcopy(&scp->smode, data, sizeof(struct vt_mode));
1232         lwkt_reltoken(&tty_token);
1233         return 0;
1234
1235     case VT_RELDISP:            /* screen switcher ioctl */
1236         /*
1237          * This must be the current vty which is in the VT_PROCESS
1238          * switching mode...
1239          */
1240         syscons_lock();
1241         if ((scp != sc->cur_scp) || (scp->smode.mode != VT_PROCESS)) {
1242             syscons_unlock();
1243             lwkt_reltoken(&tty_token);
1244             return EINVAL;
1245         }
1246         /* ...and this process is controlling it. */
1247         if (scp->proc != curproc) {
1248             syscons_unlock();
1249             lwkt_reltoken(&tty_token);
1250             return EPERM;
1251         }
1252         error = EINVAL;
1253         switch(*(int *)data) {
1254         case VT_FALSE:          /* user refuses to release screen, abort */
1255             if ((error = finish_vt_rel(scp, FALSE)) == 0)
1256                 DPRINTF(5, ("sc%d: VT_FALSE\n", sc->unit));
1257             break;
1258         case VT_TRUE:           /* user has released screen, go on */
1259             if ((error = finish_vt_rel(scp, TRUE)) == 0)
1260                 DPRINTF(5, ("sc%d: VT_TRUE\n", sc->unit));
1261             break;
1262         case VT_ACKACQ:         /* acquire acknowledged, switch completed */
1263             if ((error = finish_vt_acq(scp)) == 0)
1264                 DPRINTF(5, ("sc%d: VT_ACKACQ\n", sc->unit));
1265             break;
1266         default:
1267             break;
1268         }
1269         syscons_unlock();
1270         lwkt_reltoken(&tty_token);
1271         return error;
1272
1273     case VT_OPENQRY:            /* return free virtual console */
1274         for (i = sc->first_vty; i < sc->first_vty + sc->vtys; i++) {
1275             tp = VIRTUAL_TTY(sc, i);
1276             if (!ISTTYOPEN(tp)) {
1277                 *(int *)data = i + 1;
1278                 lwkt_reltoken(&tty_token);
1279                 return 0;
1280             }
1281         }
1282         lwkt_reltoken(&tty_token);
1283         return EINVAL;
1284
1285     case VT_ACTIVATE:           /* switch to screen *data */
1286         i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
1287         syscons_lock();
1288         sc_clean_up(sc->cur_scp, TRUE);
1289         error = sc_switch_scr(sc, i);
1290         syscons_unlock();
1291         lwkt_reltoken(&tty_token);
1292         return error;
1293
1294     case VT_WAITACTIVE:         /* wait for switch to occur */
1295         i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
1296         if ((i < sc->first_vty) || (i >= sc->first_vty + sc->vtys)) {
1297             lwkt_reltoken(&tty_token);
1298             return EINVAL;
1299         }
1300         syscons_lock();
1301         error = sc_clean_up(sc->cur_scp, TRUE);
1302         syscons_unlock();
1303         if (error) {
1304             lwkt_reltoken(&tty_token);
1305             return error;
1306         }
1307
1308         /*
1309          * scp might be NULL, we aren't sure why.  Check for NULL.
1310          *
1311          * http://bugs.dragonflybsd.org/issues/2481
1312          */
1313         scp = SC_STAT(SC_DEV(sc, i));
1314         if (scp == NULL || scp == scp->sc->cur_scp) {
1315             lwkt_reltoken(&tty_token);
1316             return 0;
1317         }
1318         error = tsleep((caddr_t)&scp->smode, PCATCH, "waitvt", 0);
1319         /* May return ERESTART */
1320         lwkt_reltoken(&tty_token);
1321         return error;
1322
1323     case VT_GETACTIVE:          /* get active vty # */
1324         *(int *)data = sc->cur_scp->index + 1;
1325         lwkt_reltoken(&tty_token);
1326         return 0;
1327
1328     case VT_GETINDEX:           /* get this vty # */
1329         *(int *)data = scp->index + 1;
1330         lwkt_reltoken(&tty_token);
1331         return 0;
1332
1333     case VT_LOCKSWITCH:         /* prevent vty switching */
1334         syscons_lock();
1335         if ((*(int *)data) & 0x01)
1336             sc->flags |= SC_SCRN_VTYLOCK;
1337         else
1338             sc->flags &= ~SC_SCRN_VTYLOCK;
1339         syscons_unlock();
1340         lwkt_reltoken(&tty_token);
1341         return 0;
1342
1343     case KDENABIO:              /* allow io operations */
1344         error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
1345         if (error != 0) {
1346             lwkt_reltoken(&tty_token);
1347             return error;
1348         }
1349         if (securelevel > 0) {
1350             lwkt_reltoken(&tty_token);
1351             return EPERM;
1352         }
1353 #if defined(__i386__)
1354         curthread->td_lwp->lwp_md.md_regs->tf_eflags |= PSL_IOPL;
1355 #elif defined(__x86_64__)
1356         curthread->td_lwp->lwp_md.md_regs->tf_rflags |= PSL_IOPL;
1357 #endif
1358         lwkt_reltoken(&tty_token);
1359         return 0;
1360
1361     case KDDISABIO:             /* disallow io operations (default) */
1362 #if defined(__i386__)
1363         curthread->td_lwp->lwp_md.md_regs->tf_eflags &= ~PSL_IOPL;
1364 #elif defined(__x86_64__)
1365         curthread->td_lwp->lwp_md.md_regs->tf_rflags &= ~PSL_IOPL;
1366 #endif
1367         lwkt_reltoken(&tty_token);
1368         return 0;
1369
1370     case KDSKBSTATE:            /* set keyboard state (locks) */
1371         if (*(int *)data & ~LOCK_MASK) {
1372             lwkt_reltoken(&tty_token);
1373             return EINVAL;
1374         }
1375         syscons_lock();
1376         scp->status &= ~LOCK_MASK;
1377         scp->status |= *(int *)data;
1378         syscons_unlock();
1379         if (scp == sc->cur_scp)
1380             update_kbd_state(scp, scp->status, LOCK_MASK, FALSE);
1381         lwkt_reltoken(&tty_token);
1382         return 0;
1383
1384     case KDGKBSTATE:            /* get keyboard state (locks) */
1385         if (scp == sc->cur_scp)
1386             save_kbd_state(scp, FALSE);
1387         *(int *)data = scp->status & LOCK_MASK;
1388         lwkt_reltoken(&tty_token);
1389         return 0;
1390
1391     case KDGETREPEAT:           /* get keyboard repeat & delay rates */
1392     case KDSETREPEAT:           /* set keyboard repeat & delay rates (new) */
1393         error = kbd_ioctl(sc->kbd, cmd, data);
1394         if (error == ENOIOCTL)
1395             error = ENODEV;
1396         lwkt_reltoken(&tty_token);
1397         return error;
1398
1399     case KDSKBMODE:             /* set keyboard mode */
1400         switch (*(int *)data) {
1401         case K_XLATE:           /* switch to XLT ascii mode */
1402         case K_RAW:             /* switch to RAW scancode mode */
1403         case K_CODE:            /* switch to CODE mode */
1404             scp->kbd_mode = *(int *)data;
1405             if (scp == sc->cur_scp)
1406                 kbd_ioctl(sc->kbd, cmd, data);
1407             lwkt_reltoken(&tty_token);
1408             return 0;
1409         default:
1410             lwkt_reltoken(&tty_token);
1411             return EINVAL;
1412         }
1413         /* NOT REACHED */
1414
1415     case KDGKBMODE:             /* get keyboard mode */
1416         *(int *)data = scp->kbd_mode;
1417         lwkt_reltoken(&tty_token);
1418         return 0;
1419
1420     case KDGKBINFO:
1421         error = kbd_ioctl(sc->kbd, cmd, data);
1422         if (error == ENOIOCTL)
1423             error = ENODEV;
1424         lwkt_reltoken(&tty_token);
1425         return error;
1426
1427     case KDMKTONE:              /* sound the bell */
1428         syscons_lock();
1429         if (*(int*)data)
1430             sc_bell(scp, (*(int*)data)&0xffff,
1431                     (((*(int*)data)>>16)&0xffff)*hz/1000);
1432         else
1433             sc_bell(scp, scp->bell_pitch, scp->bell_duration);
1434         syscons_unlock();
1435         lwkt_reltoken(&tty_token);
1436         return 0;
1437
1438     case KIOCSOUND:             /* make tone (*data) hz */
1439         syscons_lock();
1440         if (scp == sc->cur_scp) {
1441             if (*(int *)data) {
1442                 error = sc_tone(*(int *)data);
1443             } else {
1444                 error = sc_tone(0);
1445             }
1446         } else {
1447             error = 0;
1448         }
1449         syscons_unlock();
1450         lwkt_reltoken(&tty_token);
1451         return error;
1452
1453     case KDGKBTYPE:             /* get keyboard type */
1454         error = kbd_ioctl(sc->kbd, cmd, data);
1455         if (error == ENOIOCTL) {
1456             /* always return something? XXX */
1457             *(int *)data = 0;
1458         }
1459         lwkt_reltoken(&tty_token);
1460         return 0;
1461
1462     case KDSETLED:              /* set keyboard LED status */
1463         if (*(int *)data & ~LED_MASK) { /* FIXME: LOCK_MASK? */
1464             lwkt_reltoken(&tty_token);
1465             return EINVAL;
1466         }
1467         syscons_lock();
1468         scp->status &= ~LED_MASK;
1469         scp->status |= *(int *)data;
1470         syscons_unlock();
1471         if (scp == sc->cur_scp)
1472             update_kbd_leds(scp, scp->status);
1473         lwkt_reltoken(&tty_token);
1474         return 0;
1475
1476     case KDGETLED:              /* get keyboard LED status */
1477         if (scp == sc->cur_scp)
1478             save_kbd_state(scp, FALSE);
1479         *(int *)data = scp->status & LED_MASK;
1480         lwkt_reltoken(&tty_token);
1481         return 0;
1482
1483         case KBADDKBD:              /* add/remove keyboard to/from mux */
1484         case KBRELKBD:
1485                 error = kbd_ioctl(sc->kbd, cmd, data);
1486                 if (error == ENOIOCTL)
1487                         error = ENODEV;
1488                 lwkt_reltoken(&tty_token);
1489                 return error;
1490
1491     case CONS_SETKBD:           /* set the new keyboard */
1492         {
1493             keyboard_t *newkbd;
1494
1495             newkbd = kbd_get_keyboard(*(int *)data);
1496             if (newkbd == NULL) {
1497                 lwkt_reltoken(&tty_token);
1498                 return EINVAL;
1499             }
1500             error = 0;
1501             if (sc->kbd != newkbd) {
1502                 i = kbd_allocate(newkbd->kb_name, newkbd->kb_unit,
1503                                  (void *)&sc->keyboard, sckbdevent, sc);
1504                 /* i == newkbd->kb_index */
1505                 if (i >= 0) {
1506                     if (sc->kbd != NULL) {
1507                         save_kbd_state(sc->cur_scp, FALSE);
1508                         kbd_release(sc->kbd, (void *)&sc->keyboard);
1509                     }
1510                     syscons_lock();
1511                     sc->kbd = kbd_get_keyboard(i); /* sc->kbd == newkbd */
1512                     sc->keyboard = i;
1513                     syscons_unlock();
1514                     kbd_ioctl(sc->kbd, KDSKBMODE,
1515                               (caddr_t)&sc->cur_scp->kbd_mode);
1516                     update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1517                         LOCK_MASK, FALSE);
1518                 } else {
1519                     error = EPERM;      /* XXX */
1520                 }
1521             }
1522             lwkt_reltoken(&tty_token);
1523             return error;
1524         }
1525
1526     case CONS_RELKBD:           /* release the current keyboard */
1527         error = 0;
1528         if (sc->kbd != NULL) {
1529             save_kbd_state(sc->cur_scp, FALSE);
1530             error = kbd_release(sc->kbd, (void *)&sc->keyboard);
1531             if (error == 0) {
1532                 syscons_lock();
1533                 sc->kbd = NULL;
1534                 sc->keyboard = -1;
1535                 syscons_unlock();
1536             }
1537         }
1538         lwkt_reltoken(&tty_token);
1539         return error;
1540
1541     case CONS_GETTERM:          /* get the current terminal emulator info */
1542         {
1543             sc_term_sw_t *sw;
1544
1545             if (((term_info_t *)data)->ti_index == 0) {
1546                 sw = scp->tsw;
1547             } else {
1548                 sw = sc_term_match_by_number(((term_info_t *)data)->ti_index);
1549             }
1550             if (sw != NULL) {
1551                 strncpy(((term_info_t *)data)->ti_name, sw->te_name,
1552                         sizeof(((term_info_t *)data)->ti_name));
1553                 strncpy(((term_info_t *)data)->ti_desc, sw->te_desc,
1554                         sizeof(((term_info_t *)data)->ti_desc));
1555                 ((term_info_t *)data)->ti_flags = 0;
1556                 lwkt_reltoken(&tty_token);
1557                 return 0;
1558             } else {
1559                 ((term_info_t *)data)->ti_name[0] = '\0';
1560                 ((term_info_t *)data)->ti_desc[0] = '\0';
1561                 ((term_info_t *)data)->ti_flags = 0;
1562                 lwkt_reltoken(&tty_token);
1563                 return EINVAL;
1564             }
1565         }
1566
1567     case CONS_SETTERM:          /* set the current terminal emulator */
1568         syscons_lock();
1569         error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name);
1570         /* FIXME: what if scp == sc_console! XXX */
1571         syscons_unlock();
1572         lwkt_reltoken(&tty_token);
1573         return error;
1574
1575     case GIO_SCRNMAP:           /* get output translation table */
1576         bcopy(&sc->scr_map, data, sizeof(sc->scr_map));
1577         lwkt_reltoken(&tty_token);
1578         return 0;
1579
1580     case PIO_SCRNMAP:           /* set output translation table */
1581         bcopy(data, &sc->scr_map, sizeof(sc->scr_map));
1582         for (i=0; i<sizeof(sc->scr_map); i++) {
1583             sc->scr_rmap[sc->scr_map[i]] = i;
1584         }
1585         lwkt_reltoken(&tty_token);
1586         return 0;
1587
1588     case GIO_KEYMAP:            /* get keyboard translation table */
1589     case PIO_KEYMAP:            /* set keyboard translation table */
1590     case GIO_DEADKEYMAP:        /* get accent key translation table */
1591     case PIO_DEADKEYMAP:        /* set accent key translation table */
1592     case GETFKEY:               /* get function key string */
1593     case SETFKEY:               /* set function key string */
1594         error = kbd_ioctl(sc->kbd, cmd, data);
1595         if (error == ENOIOCTL)
1596             error = ENODEV;
1597         lwkt_reltoken(&tty_token);
1598         return error;
1599
1600 #ifndef SC_NO_FONT_LOADING
1601
1602     case PIO_FONT8x8:           /* set 8x8 dot font */
1603         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1604             lwkt_reltoken(&tty_token);
1605             return ENXIO;
1606         }
1607         syscons_lock();
1608         bcopy(data, sc->font_8, 8*256);
1609         sc->fonts_loaded |= FONT_8;
1610         /*
1611          * FONT KLUDGE
1612          * Always use the font page #0. XXX
1613          * Don't load if the current font size is not 8x8.
1614          */
1615         if (sc->fbi == NULL
1616             && ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_height < 14)) {
1617             sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256);
1618         }
1619         syscons_unlock();
1620         lwkt_reltoken(&tty_token);
1621         return 0;
1622
1623     case GIO_FONT8x8:           /* get 8x8 dot font */
1624         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1625             lwkt_reltoken(&tty_token);
1626             return ENXIO;
1627         }
1628         if (sc->fonts_loaded & FONT_8) {
1629             bcopy(sc->font_8, data, 8*256);
1630             lwkt_reltoken(&tty_token);
1631             return 0;
1632         }
1633         else {
1634             lwkt_reltoken(&tty_token);
1635             return ENXIO;
1636         }
1637
1638     case PIO_FONT8x14:          /* set 8x14 dot font */
1639         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1640             lwkt_reltoken(&tty_token);
1641             return ENXIO;
1642         }
1643         syscons_lock();
1644         bcopy(data, sc->font_14, 14*256);
1645         sc->fonts_loaded |= FONT_14;
1646         /*
1647          * FONT KLUDGE
1648          * Always use the font page #0. XXX
1649          * Don't load if the current font size is not 8x14.
1650          */
1651         if (sc->fbi == NULL
1652             && ISTEXTSC(sc->cur_scp)
1653             && (sc->cur_scp->font_height >= 14)
1654             && (sc->cur_scp->font_height < 16)) {
1655             sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256);
1656         }
1657         syscons_unlock();
1658         lwkt_reltoken(&tty_token);
1659         return 0;
1660
1661     case GIO_FONT8x14:          /* get 8x14 dot font */
1662         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1663             lwkt_reltoken(&tty_token);
1664             return ENXIO;
1665         }
1666         if (sc->fonts_loaded & FONT_14) {
1667             bcopy(sc->font_14, data, 14*256);
1668             lwkt_reltoken(&tty_token);
1669             return 0;
1670         }
1671         else {
1672             lwkt_reltoken(&tty_token);
1673             return ENXIO;
1674         }
1675
1676     case PIO_FONT8x16:          /* set 8x16 dot font */
1677         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1678             lwkt_reltoken(&tty_token);
1679             return ENXIO;
1680         }
1681         syscons_lock();
1682         bcopy(data, sc->font_16, 16*256);
1683         sc->fonts_loaded |= FONT_16;
1684         /*
1685          * FONT KLUDGE
1686          * Always use the font page #0. XXX
1687          * Don't load if the current font size is not 8x16.
1688          */
1689         if (sc->fbi == NULL
1690             && ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_height >= 16))  {
1691             sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256);
1692         }
1693         syscons_unlock();
1694         lwkt_reltoken(&tty_token);
1695         return 0;
1696
1697     case GIO_FONT8x16:          /* get 8x16 dot font */
1698         if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1699             lwkt_reltoken(&tty_token);
1700             return ENXIO;
1701         }
1702         if (sc->fonts_loaded & FONT_16) {
1703             bcopy(sc->font_16, data, 16*256);
1704             lwkt_reltoken(&tty_token);
1705             return 0;
1706         }
1707         else {
1708             lwkt_reltoken(&tty_token);
1709             return ENXIO;
1710         }
1711
1712 #endif /* SC_NO_FONT_LOADING */
1713
1714     default:
1715         break;
1716     }
1717
1718     error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, ap->a_cred);
1719     if (error != ENOIOCTL) {
1720         lwkt_reltoken(&tty_token);
1721         return(error);
1722     }
1723     error = ttioctl(tp, cmd, data, flag);
1724     if (error != ENOIOCTL) {
1725         lwkt_reltoken(&tty_token);
1726         return(error);
1727     }
1728     lwkt_reltoken(&tty_token);
1729     return(ENOTTY);
1730 }
1731
1732 static void
1733 scstart(struct tty *tp)
1734 {
1735     struct clist *rbp;
1736     int len;
1737     u_char buf[PCBURST];
1738     scr_stat *scp = SC_STAT(tp->t_dev);
1739
1740     syscons_lock();
1741     if (scp->status & SLKED ||
1742         (scp == scp->sc->cur_scp && scp->sc->blink_in_progress))
1743     {
1744         syscons_unlock();
1745         return;
1746     }
1747     if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) {
1748         tp->t_state |= TS_BUSY;
1749         rbp = &tp->t_outq;
1750         while (rbp->c_cc) {
1751             len = q_to_b(rbp, buf, PCBURST);
1752             sc_puts(scp, buf, len);
1753         }
1754         tp->t_state &= ~TS_BUSY;
1755         syscons_unlock();
1756         ttwwakeup(tp);
1757     } else {
1758         syscons_unlock();
1759     }
1760 }
1761
1762 static void
1763 sccnprobe(struct consdev *cp)
1764 {
1765     int unit;
1766     int flags;
1767
1768     cp->cn_pri = sc_get_cons_priority(&unit, &flags);
1769
1770     /* a video card is always required */
1771     if (probe_efi_fb(1) != 0 && !scvidprobe(unit, flags, TRUE))
1772         cp->cn_pri = CN_DEAD;
1773
1774     /* syscons will become console even when there is no keyboard */
1775     sckbdprobe(unit, flags, TRUE);
1776
1777     if (cp->cn_pri == CN_DEAD) {
1778         return;
1779     }
1780
1781     /* initialize required fields */
1782     cp->cn_probegood = 1;
1783 }
1784
1785 static void
1786 sccninit(struct consdev *cp)
1787 {
1788     int unit;
1789     int flags;
1790
1791     sc_get_cons_priority(&unit, &flags);
1792     scinit(unit, flags | SC_KERNEL_CONSOLE);
1793     sc_console_unit = unit;
1794     sc_console = sc_get_softc(unit, SC_KERNEL_CONSOLE)->console_scp;
1795 }
1796
1797 static void
1798 sccninit_fini(struct consdev *cp)
1799 {
1800         if (cctl_dev == NULL)
1801                 kprintf("sccninit_fini: WARNING: cctl_dev is NULL!\n");
1802         cp->cn_dev = cctl_dev;
1803 }
1804
1805 static void
1806 sccnterm(struct consdev *cp)
1807 {
1808     /* we are not the kernel console any more, release everything */
1809
1810     if (sc_console_unit < 0)
1811         return;                 /* shouldn't happen */
1812
1813 #if 0 /* XXX */
1814     syscons_lock();
1815     sc_clear_screen(sc_console);
1816     sccnupdate(sc_console);
1817     syscons_unlock();
1818 #endif
1819     scterm(sc_console_unit, SC_KERNEL_CONSOLE);
1820     sc_console_unit = -1;
1821     sc_console = NULL;
1822 }
1823
1824 /*
1825  * Console path - cannot block!
1826  */
1827 static void
1828 sccnputc(void *private, int c)
1829 {
1830     u_char buf[1];
1831     scr_stat *scp = sc_console;
1832     void *save;
1833 #ifndef SC_NO_HISTORY
1834 #if 0
1835     struct tty *tp;
1836 #endif
1837 #endif /* !SC_NO_HISTORY */
1838
1839     /* assert(sc_console != NULL) */
1840
1841     syscons_lock();
1842 #ifndef SC_NO_HISTORY
1843     if (scp == scp->sc->cur_scp && scp->status & SLKED) {
1844         scp->status &= ~SLKED;
1845 #if 0
1846         /* This can block, illegal in the console path */
1847         update_kbd_state(scp, scp->status, SLKED, TRUE);
1848 #endif
1849         if (scp->status & BUFFER_SAVED) {
1850             if (!sc_hist_restore(scp))
1851                 sc_remove_cutmarking(scp);
1852             scp->status &= ~BUFFER_SAVED;
1853             scp->status |= CURSOR_ENABLED;
1854             sc_draw_cursor_image(scp);
1855         }
1856 #if 0
1857         tp = VIRTUAL_TTY(scp->sc, scp->index);
1858         /* This can block, illegal in the console path */
1859         if (ISTTYOPEN(tp)) {
1860             scstart(tp);
1861         }
1862 #endif
1863     }
1864 #endif /* !SC_NO_HISTORY */
1865
1866     save = scp->ts;
1867     if (kernel_console_ts != NULL)
1868         scp->ts = kernel_console_ts;
1869     buf[0] = c;
1870     sc_puts(scp, buf, 1);
1871     scp->ts = save;
1872
1873     sccnupdate(scp);
1874     syscons_unlock();
1875 }
1876
1877 /*
1878  * Console path - cannot block!
1879  */
1880 static int
1881 sccngetc(void *private)
1882 {
1883     return sccngetch(0);
1884 }
1885
1886 /*
1887  * Console path - cannot block!
1888  */
1889 static int
1890 sccncheckc(void *private)
1891 {
1892     return sccngetch(SCGETC_NONBLOCK);
1893 }
1894
1895 /*
1896  * Set polling mode (also disables the tty feed), use when
1897  * polling for console key input.
1898  */
1899 static void
1900 sccnpoll(void *private, int on)
1901 {
1902     scr_stat *scp;
1903
1904     syscons_lock();
1905     sc_touch_scrn_saver();
1906     scp = sc_console->sc->cur_scp;      /* XXX */
1907     syscons_unlock();
1908     if (scp->sc->kbd)
1909             kbd_poll(scp->sc->kbd, on);
1910 }
1911
1912 static void
1913 sccndbctl(void *private, int on)
1914 {
1915     /* assert(sc_console_unit >= 0) */
1916     /* try to switch to the kernel console screen */
1917     if (on && debugger == 0) {
1918         /*
1919          * TRY to make sure the screen saver is stopped,
1920          * and the screen is updated before switching to
1921          * the vty0.
1922          */
1923         scrn_timer(NULL);
1924         if (!cold
1925             && sc_console->sc->cur_scp->smode.mode == VT_AUTO
1926             && sc_console->smode.mode == VT_AUTO) {
1927             sc_console->sc->cur_scp->status |= MOUSE_HIDDEN;
1928             syscons_lock();
1929             sc_switch_scr(sc_console->sc, sc_console->index);
1930             syscons_unlock();
1931         }
1932     }
1933     if (on)
1934         ++debugger;
1935     else
1936         --debugger;
1937 }
1938
1939 /*
1940  * Console path - cannot block!
1941  */
1942 static int
1943 sccngetch(int flags)
1944 {
1945     static struct fkeytab fkey;
1946     static int fkeycp;
1947     scr_stat *scp;
1948     u_char *p;
1949     int cur_mode;
1950     int c;
1951
1952     syscons_lock();
1953     /* assert(sc_console != NULL) */
1954
1955     /*
1956      * Stop the screen saver and update the screen if necessary.
1957      * What if we have been running in the screen saver code... XXX
1958      */
1959     sc_touch_scrn_saver();
1960     scp = sc_console->sc->cur_scp;      /* XXX */
1961     sccnupdate(scp);
1962     syscons_unlock();
1963
1964     if (fkeycp < fkey.len) {
1965         return fkey.str[fkeycp++];
1966     }
1967
1968     if (scp->sc->kbd == NULL) {
1969         return -1;
1970     }
1971
1972     /*
1973      * Make sure the keyboard is accessible even when the kbd device
1974      * driver is disabled.
1975      */
1976     crit_enter();
1977     kbd_enable(scp->sc->kbd);
1978
1979     /* we shall always use the keyboard in the XLATE mode here */
1980     cur_mode = scp->kbd_mode;
1981     scp->kbd_mode = K_XLATE;
1982     kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1983
1984     c = scgetc(scp->sc, SCGETC_CN | flags);
1985
1986     scp->kbd_mode = cur_mode;
1987     kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1988     kbd_disable(scp->sc->kbd);
1989     crit_exit();
1990
1991     switch (KEYFLAGS(c)) {
1992     case 0:     /* normal char */
1993         return KEYCHAR(c);
1994     case FKEY:  /* function key */
1995         p = kbd_get_fkeystr(scp->sc->kbd, KEYCHAR(c), (size_t *)&fkeycp);
1996         fkey.len = fkeycp;
1997         if ((p != NULL) && (fkey.len > 0)) {
1998             bcopy(p, fkey.str, fkey.len);
1999             fkeycp = 1;
2000             return fkey.str[0];
2001         }
2002         return c;       /* XXX */
2003     case NOKEY:
2004         if (flags & SCGETC_NONBLOCK)
2005                 return c;
2006         /* fall through */
2007     case ERRKEY:
2008     default:
2009         return -1;
2010     }
2011     /* NOT REACHED */
2012 }
2013
2014 static void
2015 sccnupdate(scr_stat *scp)
2016 {
2017     int ddb_active;
2018
2019 #ifdef DDB
2020     ddb_active = db_active;
2021 #else
2022     ddb_active = 0;
2023 #endif
2024
2025     /* this is a cut-down version of scrn_timer()... */
2026
2027     /*
2028      * Don't update if videoio is in progress.  However, if we are paniced
2029      * or in the debugger it is possible that the variables might be stuck,
2030      * so ignore it in such cases.
2031      */
2032     if (scp->sc->font_loading_in_progress || scp->sc->videoio_in_progress) {
2033         if (panicstr == NULL && ddb_active == 0 && shutdown_in_progress == 0)
2034                 return;
2035     }
2036
2037     if (debugger > 0 || panicstr || ddb_active || shutdown_in_progress) {
2038         sc_touch_scrn_saver();
2039     } else if (scp != scp->sc->cur_scp) {
2040         return;
2041     }
2042
2043     if (!run_scrn_saver)
2044         scp->sc->flags &= ~SC_SCRN_IDLE;
2045 #if NSPLASH > 0
2046     /*
2047      * This is a hard path, we cannot call stop_scrn_saver() here.
2048      */
2049     if ((saver_mode != CONS_LKM_SAVER) || !(scp->sc->flags & SC_SCRN_IDLE))
2050         if (scp->sc->flags & SC_SCRN_BLANKED) {
2051             sc_touch_scrn_saver();
2052             /*stop_scrn_saver(scp->sc, current_saver);*/
2053         }
2054 #endif /* NSPLASH */
2055
2056     if (scp != scp->sc->cur_scp || scp->sc->blink_in_progress
2057         || scp->sc->switch_in_progress) {
2058         return;
2059     }
2060
2061     /*
2062      * FIXME: unlike scrn_timer(), we call scrn_update() from here even
2063      * when write_in_progress is non-zero.  XXX
2064      */
2065     if (!ISGRAPHSC(scp) && !(scp->sc->flags & SC_SCRN_BLANKED))
2066         scrn_update(scp, TRUE, SCRN_ASYNCOK);
2067 }
2068
2069 static void
2070 scrn_timer(void *arg)
2071 {
2072     static int kbd_interval = 0;
2073     struct timeval tv;
2074     sc_softc_t *sc;
2075     scr_stat *scp;
2076     int again;
2077
2078     /*
2079      * Setup depending on who called us
2080      */
2081     again = (arg != NULL);
2082     if (arg != NULL) {
2083         sc = (sc_softc_t *)arg;
2084     } else if (sc_console != NULL) {
2085         sc = sc_console->sc;
2086     } else {
2087         return;
2088     }
2089
2090     /*
2091      * Don't do anything when we are performing some I/O operations.
2092      * (These are initiated by the frontend?)
2093      */
2094     if (sc->font_loading_in_progress || sc->videoio_in_progress) {
2095         if (again)
2096             callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2097         return;
2098     }
2099
2100     /*
2101      * Try to allocate a keyboard automatically
2102      */
2103     if ((sc->kbd == NULL) && (sc->config & SC_AUTODETECT_KBD)) {
2104         if (++kbd_interval >= 25) {
2105             sc->keyboard = sc_allocate_keyboard(sc, -1);
2106             if (sc->keyboard >= 0) {
2107                 sc->kbd = kbd_get_keyboard(sc->keyboard);
2108                 kbd_ioctl(sc->kbd, KDSKBMODE,
2109                           (caddr_t)&sc->cur_scp->kbd_mode);
2110                 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
2111                     LOCK_MASK, FALSE);
2112             }
2113             kbd_interval = 0;
2114         }
2115     }
2116
2117     /*
2118      * Should we stop the screen saver?  We need the syscons_lock
2119      * for most of this stuff.
2120      */
2121     getmicrouptime(&tv);
2122
2123     if (syscons_lock_nonblock() != 0) {
2124         /* failed to get the lock */
2125         if (again)
2126             callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2127         return;
2128     }
2129     /* successful lock */
2130
2131     if (debugger > 0 || panicstr || shutdown_in_progress)
2132         sc_touch_scrn_saver();
2133     if (run_scrn_saver) {
2134         if (tv.tv_sec > sc->scrn_time_stamp + scrn_blank_time)
2135             sc->flags |= SC_SCRN_IDLE;
2136         else
2137             sc->flags &= ~SC_SCRN_IDLE;
2138     } else {
2139         sc->scrn_time_stamp = tv.tv_sec;
2140         sc->flags &= ~SC_SCRN_IDLE;
2141         if (scrn_blank_time > 0)
2142             run_scrn_saver = TRUE;
2143     }
2144 #if NSPLASH > 0
2145     if ((saver_mode != CONS_LKM_SAVER) || !(sc->flags & SC_SCRN_IDLE)) {
2146         if ((sc->flags & SC_SCRN_BLANKED) && !ISGRAPHSC(sc->cur_scp))
2147             stop_scrn_saver(sc, current_saver);
2148     }
2149 #endif /* NSPLASH */
2150
2151     /* should we just return ? */
2152     if (sc->blink_in_progress || sc->switch_in_progress ||
2153         sc->write_in_progress)
2154     {
2155         syscons_unlock();
2156         if (again)
2157             callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2158         return;
2159     }
2160
2161     /* Update the screen */
2162     scp = sc->cur_scp;          /* cur_scp may have changed... */
2163     if (!ISGRAPHSC(scp) && !(sc->flags & SC_SCRN_BLANKED))
2164         scrn_update(scp, TRUE, SCRN_ASYNCOK);
2165
2166 #if NSPLASH > 0
2167     /* should we activate the screen saver? */
2168     if ((saver_mode == CONS_LKM_SAVER) && (sc->flags & SC_SCRN_IDLE))
2169         if (!ISGRAPHSC(scp) || (sc->flags & SC_SCRN_BLANKED))
2170             (*current_saver)(sc, TRUE);
2171 #endif /* NSPLASH */
2172
2173     syscons_unlock();
2174     if (again)
2175         callout_reset(&sc->scrn_timer_ch, hz / 25, scrn_timer, sc);
2176 }
2177
2178 static int
2179 and_region(int *s1, int *e1, int s2, int e2)
2180 {
2181     if (*e1 < s2 || e2 < *s1)
2182         return FALSE;
2183     *s1 = imax(*s1, s2);
2184     *e1 = imin(*e1, e2);
2185     return TRUE;
2186 }
2187
2188 /*
2189  * Refresh modified frame buffer range.  Also used to
2190  * scroll (entire FB is marked modified).
2191  *
2192  * This function is allowed to run without the syscons_lock,
2193  * so scp fields can change unexpected.  We cache most values
2194  * that we care about and silently discard illegal ranges.
2195  */
2196 static void
2197 scrn_update(scr_stat *scp, int show_cursor, int flags)
2198 {
2199     int start;
2200     int end;
2201     int cpos;
2202     int copos;
2203     int s;
2204     int e;
2205     int ddb_active;
2206
2207 #ifdef DDB
2208     ddb_active = db_active;
2209 #else
2210     ddb_active = 0;
2211 #endif
2212
2213     /*
2214      * Try to run large screen updates as an async operation, which will
2215      * call this function again from a thread with BULKUNLOCK set, allowing
2216      * interrupts during the update which tends to make the system behave
2217      * better (no sound glitches, etc).
2218      */
2219     if ((flags & SCRN_ASYNCOK) && syscons_async && scp->asynctd &&
2220         (scp->end - scp->start) > 16 &&
2221         panicstr == NULL && ddb_active == 0 && shutdown_in_progress == 0) {
2222         scp->show_cursor = show_cursor;
2223         scp->queue_update_td = 1;
2224         wakeup(&scp->asynctd);
2225         return;
2226     }
2227     if (flags & SCRN_BULKUNLOCK)
2228         syscons_lock();
2229
2230     /*
2231      * Synchronous operation or called from
2232      */
2233
2234     /* assert(scp == scp->sc->cur_scp) */
2235     atomic_add_int(&scp->sc->videoio_in_progress, 1);
2236
2237     cpos = scp->cursor_pos;
2238     copos = scp->cursor_oldpos;
2239
2240 #ifndef SC_NO_CUTPASTE
2241     /* remove the previous mouse pointer image if necessary */
2242     if (scp->status & MOUSE_VISIBLE) {
2243         s = scp->mouse_pos;
2244         e = scp->mouse_pos + scp->xsize + 1;
2245         if ((scp->status & (MOUSE_MOVED | MOUSE_HIDDEN))
2246             || and_region(&s, &e, scp->start, scp->end)
2247             || ((scp->status & CURSOR_ENABLED) &&
2248                 (cpos != copos) &&
2249                 (and_region(&s, &e, cpos, cpos)
2250                  || and_region(&s, &e, copos, copos)))) {
2251             sc_remove_mouse_image(scp);
2252             if (scp->end >= scp->xsize*scp->ysize)
2253                 scp->end = scp->xsize*scp->ysize - 1;
2254         }
2255     }
2256 #endif /* !SC_NO_CUTPASTE */
2257
2258     /*
2259      * WARNING: Don't add debugging kprintf()s with syscons locked.
2260      *          Or at all.
2261      */
2262     if (scp->end >= scp->xsize*scp->ysize) {
2263         scp->end = scp->xsize*scp->ysize - 1;
2264     }
2265     if (scp->start < 0) {
2266         scp->start = 0;
2267     }
2268
2269     /*
2270      * Main update, extract update range and reset
2271      * ASAP.
2272      */
2273     start = scp->start;
2274     end = scp->end;
2275     scp->end = 0;
2276     scp->start = scp->xsize * scp->ysize - 1;
2277
2278     if (start <= end)  {
2279         if (flags & SCRN_BULKUNLOCK) {
2280             atomic_add_int(&scp->sc->videoio_in_progress, -1);
2281             syscons_unlock();
2282         }
2283         (*scp->rndr->draw)(scp, start, end - start + 1, FALSE);
2284         if (flags & SCRN_BULKUNLOCK) {
2285             syscons_lock();
2286             atomic_add_int(&scp->sc->videoio_in_progress, 1);
2287         }
2288
2289         /*
2290          * Handle cut sequence
2291          */
2292         s = scp->mouse_cut_start;
2293         e = scp->mouse_cut_end;
2294         cpu_ccfence();          /* allowed to race */
2295
2296         if (e >= 0) {
2297             if (s > e) {
2298                 int r = s;
2299                 s = e;
2300                 e = r;
2301             }
2302             /* does the cut-mark region overlap with the update region? */
2303             if (and_region(&s, &e, start, end)) {
2304                 if (flags & SCRN_BULKUNLOCK) {
2305                     atomic_add_int(&scp->sc->videoio_in_progress, -1);
2306                     syscons_unlock();
2307                 }
2308                 (*scp->rndr->draw)(scp, s, e - s + 1, TRUE);
2309                 if (flags & SCRN_BULKUNLOCK) {
2310                     syscons_lock();
2311                     atomic_add_int(&scp->sc->videoio_in_progress, 1);
2312                 }
2313             }
2314         }
2315     }
2316
2317     /* we are not to show the cursor and the mouse pointer... */
2318     if (!show_cursor)
2319         goto cleanup;
2320
2321     /* update cursor image */
2322     if (scp->status & CURSOR_ENABLED) {
2323         s = start;
2324         e = end;
2325         /* did cursor move since last time ? */
2326         if (cpos != copos) {
2327             /* do we need to remove old cursor image ? */
2328             if (!and_region(&s, &e, copos, copos))
2329                 sc_remove_cursor_image(scp);
2330             sc_draw_cursor_image(scp);
2331         } else {
2332             if (s <= e && and_region(&s, &e, cpos, cpos)) {
2333                 /* cursor didn't move, but has been overwritten */
2334                 sc_draw_cursor_image(scp);
2335             } else if (scp->sc->flags & SC_BLINK_CURSOR) {
2336                 /* if it's a blinking cursor, update it */
2337                 (*scp->rndr->blink_cursor)(scp, cpos,
2338                                            sc_inside_cutmark(scp, cpos));
2339             }
2340         }
2341     }
2342
2343 #ifndef SC_NO_CUTPASTE
2344     /* update "pseudo" mouse pointer image */
2345     if (scp->sc->flags & SC_MOUSE_ENABLED) {
2346         if (!(scp->status & (MOUSE_VISIBLE | MOUSE_HIDDEN))) {
2347             scp->status &= ~MOUSE_MOVED;
2348             sc_draw_mouse_image(scp);
2349         }
2350     }
2351 #endif /* SC_NO_CUTPASTE */
2352
2353     /*
2354      * Cleanup
2355      */
2356 cleanup:
2357     atomic_add_int(&scp->sc->videoio_in_progress, -1);
2358     if (flags & SCRN_BULKUNLOCK)
2359         syscons_unlock();
2360 }
2361
2362 /*
2363  * Thread handles potentially expensive screen updates.   The function is
2364  * expected to operate safely without locks.
2365  */
2366 static void
2367 scrn_update_thread(void *arg)
2368 {
2369         scr_stat *scp = arg;
2370         for (;;) {
2371                 if (scp->queue_update_td == 0) {
2372                         tsleep_interlock(&scp->asynctd, 0);
2373                         if (scp->queue_update_td == 0)
2374                                 tsleep(&scp->asynctd, PINTERLOCKED, "wait", 0);
2375                 }
2376                 scp->queue_update_td = 0;
2377                 lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
2378                 atomic_add_int(&scp->sc->videoio_in_progress, 1);
2379                 scrn_update(scp, scp->show_cursor, SCRN_BULKUNLOCK);
2380                 atomic_add_int(&scp->sc->videoio_in_progress, -1);
2381                 lockmgr(&sc_asynctd_lk, LK_RELEASE);
2382         }
2383 }
2384
2385 static void
2386 sc_fb_set_par(void *context, int pending)
2387 {
2388         sc_softc_t *sc = context;
2389         scr_stat *scp = sc->cur_scp;
2390
2391         lwkt_gettoken(&tty_token);
2392         if (ISTEXTSC(scp) &&
2393             sc->fbi != NULL && sc->fbi->fbops.fb_set_par != NULL) {
2394                 sc->fbi->fbops.fb_set_par(sc->fbi);
2395         }
2396         lwkt_reltoken(&tty_token);
2397 }
2398
2399 #if NSPLASH > 0
2400 static void
2401 sc_fb_blank(void *context, int pending)
2402 {
2403         sc_softc_t *sc = context;
2404
2405         lwkt_gettoken(&tty_token);
2406         if (sc->fbi != NULL && sc->fbi->fbops.fb_blank != NULL) {
2407                 /* 0 == FB_BLANK_UNBLANK and 4 == FB_BLANK_POWERDOWN */
2408                 if (sc->flags & SC_SCRN_BLANKED) {
2409                         sc->fbi->fbops.fb_blank(4, sc->fbi);
2410                         sc->fb_blanked = TRUE;
2411                         if (sc->unit == sc_console_unit)
2412                                 cons_unavail = TRUE;
2413                 } else {
2414                         sc->fbi->fbops.fb_blank(0, sc->fbi);
2415                         sc->fb_blanked = FALSE;
2416                         if (sc->unit == sc_console_unit &&
2417                             sc->cur_scp->smode.mode == VT_AUTO)
2418                                 cons_unavail = FALSE;
2419                 }
2420         }
2421         lwkt_reltoken(&tty_token);
2422 }
2423
2424 static void
2425 scframebuffer_saver(sc_softc_t *sc, int show)
2426 {
2427         scr_stat *scp = sc->cur_scp;
2428
2429         if (panicstr)
2430                 return;
2431
2432         /*
2433          * Gets called on every screen update while screensaver is active,
2434          * so we need to check the SC_SCRN_BLANKED flag ourselves.
2435          */
2436         if ((sc->flags & SC_SCRN_BLANKED) && show)
2437                 return;
2438
2439         taskqueue_cancel(taskqueue_thread[0], sc->fb_blank_task, NULL);
2440         crit_enter();
2441         if (show) {
2442                 scp->status |= SAVER_RUNNING;
2443                 sc->flags |= SC_SCRN_BLANKED;
2444                 ++scrn_blanked;
2445         } else {
2446                 scp->status &= ~SAVER_RUNNING;
2447                 sc->flags &= ~SC_SCRN_BLANKED;
2448                 --scrn_blanked;
2449         }
2450         crit_exit();
2451         taskqueue_enqueue(taskqueue_thread[0], sc->fb_blank_task);
2452 }
2453
2454 static int
2455 scsplash_callback(int event, void *arg)
2456 {
2457     sc_softc_t *sc;
2458     int error;
2459
2460     sc = (sc_softc_t *)arg;
2461
2462     switch (event) {
2463     case SPLASH_INIT:
2464         if (add_scrn_saver(scsplash_saver) == 0) {
2465             sc->flags &= ~SC_SAVER_FAILED;
2466             run_scrn_saver = TRUE;
2467             if (cold) {
2468                 scsplash_stick(TRUE);
2469                 (*current_saver)(sc, TRUE);
2470             }
2471         }
2472         return 0;
2473
2474     case SPLASH_TERM:
2475         if (current_saver == scsplash_saver) {
2476             scsplash_stick(FALSE);
2477             error = remove_scrn_saver(scsplash_saver);
2478             if (error) {
2479                 return error;
2480             }
2481         }
2482         return 0;
2483
2484     default:
2485         return EINVAL;
2486     }
2487 }
2488
2489 static void
2490 scsplash_saver(sc_softc_t *sc, int show)
2491 {
2492     static int busy = FALSE;
2493     scr_stat *scp;
2494
2495     if (busy)
2496         return;
2497     busy = TRUE;
2498
2499     scp = sc->cur_scp;
2500     if (show) {
2501         if (!(sc->flags & SC_SAVER_FAILED)) {
2502             if (!(sc->flags & SC_SCRN_BLANKED))
2503                 set_scrn_saver_mode(scp, -1, NULL, 0);
2504             switch (splash(sc->adp, TRUE)) {
2505             case 0:             /* succeeded */
2506                 break;
2507             case EAGAIN:        /* try later */
2508                 restore_scrn_saver_mode(scp, FALSE);
2509                 sc_touch_scrn_saver();          /* XXX */
2510                 break;
2511             default:
2512                 sc->flags |= SC_SAVER_FAILED;
2513                 scsplash_stick(FALSE);
2514                 restore_scrn_saver_mode(scp, TRUE);
2515                 kprintf("scsplash_saver(): failed to put up the image\n");
2516                 break;
2517             }
2518         }
2519     } else if (!sticky_splash) {
2520         if ((sc->flags & SC_SCRN_BLANKED) && (splash(sc->adp, FALSE) == 0))
2521             restore_scrn_saver_mode(scp, TRUE);
2522     }
2523     busy = FALSE;
2524 }
2525
2526 static int
2527 add_scrn_saver(void (*this_saver)(sc_softc_t *, int))
2528 {
2529 #if 0
2530     int error;
2531
2532     if (current_saver != none_saver) {
2533         error = remove_scrn_saver(current_saver);
2534         if (error)
2535             return error;
2536     }
2537 #endif
2538     if (current_saver != none_saver) {
2539         return EBUSY;
2540     }
2541
2542     run_scrn_saver = FALSE;
2543     saver_mode = CONS_LKM_SAVER;
2544     current_saver = this_saver;
2545     return 0;
2546 }
2547
2548 static int
2549 remove_scrn_saver(void (*this_saver)(sc_softc_t *, int))
2550 {
2551     if (current_saver != this_saver)
2552         return EINVAL;
2553
2554 #if 0
2555     /*
2556      * In order to prevent `current_saver' from being called by
2557      * the timeout routine `scrn_timer()' while we manipulate
2558      * the saver list, we shall set `current_saver' to `none_saver'
2559      * before stopping the current saver, rather than blocking by `splXX()'.
2560      */
2561     current_saver = none_saver;
2562     if (scrn_blanked)
2563         stop_scrn_saver(this_saver);
2564 #endif
2565     /* unblank all blanked screens */
2566     wait_scrn_saver_stop(NULL, FALSE);
2567     if (scrn_blanked) {
2568         return EBUSY;
2569     }
2570
2571     current_saver = none_saver;
2572     return 0;
2573 }
2574
2575 static int
2576 set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border)
2577 {
2578
2579     /* assert(scp == scp->sc->cur_scp) */
2580     crit_enter();
2581     if (!ISGRAPHSC(scp))
2582         sc_remove_cursor_image(scp);
2583     scp->splash_save_mode = scp->mode;
2584     scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE);
2585     scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE);
2586     scp->status |= (UNKNOWN_MODE | SAVER_RUNNING);
2587     scp->sc->flags |= SC_SCRN_BLANKED;
2588     ++scrn_blanked;
2589     crit_exit();
2590     if (mode < 0) {
2591         return 0;
2592     }
2593     scp->mode = mode;
2594     if (set_mode(scp) == 0) {
2595         if (scp->sc->fbi == NULL &&
2596             scp->sc->adp->va_info.vi_flags & V_INFO_GRAPHICS) {
2597             scp->status |= GRAPHICS_MODE;
2598         }
2599 #ifndef SC_NO_PALETTE_LOADING
2600         if (scp->sc->fbi == NULL && pal != NULL)
2601             load_palette(scp->sc->adp, pal);
2602 #endif
2603         sc_set_border(scp, border);
2604         return 0;
2605     } else {
2606         crit_enter();
2607         scp->mode = scp->splash_save_mode;
2608         scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2609         scp->status |= scp->splash_save_status;
2610         crit_exit();
2611         return 1;
2612     }
2613     /* NOTREACHED */
2614 }
2615
2616 static int
2617 restore_scrn_saver_mode(scr_stat *scp, int changemode)
2618 {
2619     int mode;
2620     int status;
2621
2622     /* assert(scp == scp->sc->cur_scp) */
2623     crit_enter();
2624     mode = scp->mode;
2625     status = scp->status;
2626     scp->mode = scp->splash_save_mode;
2627     scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2628     scp->status |= scp->splash_save_status;
2629     scp->sc->flags &= ~SC_SCRN_BLANKED;
2630     if (!changemode) {
2631         if (!ISGRAPHSC(scp))
2632             sc_draw_cursor_image(scp);
2633         --scrn_blanked;
2634         crit_exit();
2635         return 0;
2636     }
2637     if (set_mode(scp) == 0) {
2638 #ifndef SC_NO_PALETTE_LOADING
2639         if (scp->sc->fbi == NULL)
2640             load_palette(scp->sc->adp, scp->sc->palette);
2641 #endif
2642         --scrn_blanked;
2643         crit_exit();
2644         return 0;
2645     } else {
2646         scp->mode = mode;
2647         scp->status = status;
2648         crit_exit();
2649         return 1;
2650     }
2651     /* NOTREACHED */
2652 }
2653
2654 static void
2655 stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
2656 {
2657     (*saver)(sc, FALSE);
2658     run_scrn_saver = FALSE;
2659     /* the screen saver may have chosen not to stop after all... */
2660     if (sc->flags & SC_SCRN_BLANKED) {
2661         return;
2662     }
2663
2664     mark_all(sc->cur_scp);
2665     if (sc->delayed_next_scr)
2666         sc_switch_scr(sc, sc->delayed_next_scr - 1);
2667     wakeup(&scrn_blanked);
2668 }
2669
2670 static int
2671 wait_scrn_saver_stop(sc_softc_t *sc, int need_unlock)
2672 {
2673     int error = 0;
2674
2675     while (scrn_blanked > 0) {
2676         run_scrn_saver = FALSE;
2677         if (sc && !(sc->flags & SC_SCRN_BLANKED)) {
2678             error = 0;
2679             break;
2680         }
2681         if (need_unlock) {
2682             tsleep_interlock(&scrn_blanked, PCATCH);
2683             syscons_unlock();
2684             error = tsleep(&scrn_blanked, PCATCH | PINTERLOCKED, "scrsav", 0);
2685             syscons_lock();
2686         } else {
2687             error = tsleep(&scrn_blanked, PCATCH, "scrsav", 0);
2688         }
2689         /* May return ERESTART */
2690         if (error)
2691                 break;
2692     }
2693     run_scrn_saver = FALSE;
2694     return error;
2695 }
2696 #endif /* NSPLASH */
2697
2698 void
2699 sc_start_scrn_saver(sc_softc_t *sc)
2700 {
2701 #if NSPLASH > 0
2702     (*current_saver)(sc, TRUE);
2703 #endif
2704 }
2705
2706 void
2707 sc_stop_scrn_saver(sc_softc_t *sc)
2708 {
2709 #if NSPLASH > 0
2710     if (sc->flags & SC_SCRN_BLANKED)
2711         stop_scrn_saver(sc, current_saver);
2712 #endif
2713 }
2714
2715 void
2716 sc_touch_scrn_saver(void)
2717 {
2718     scsplash_stick(FALSE);
2719     run_scrn_saver = FALSE;
2720 }
2721
2722 int
2723 sc_switch_scr(sc_softc_t *sc, u_int next_scr)
2724 {
2725     scr_stat *cur_scp;
2726     struct tty *tp;
2727
2728     DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1));
2729
2730     /* prevent switch if previously requested */
2731     if (sc->flags & SC_SCRN_VTYLOCK) {
2732             sc_bell(sc->cur_scp, sc->cur_scp->bell_pitch,
2733                 sc->cur_scp->bell_duration);
2734             return EPERM;
2735     }
2736
2737     /* delay switch if the screen is blanked or being updated */
2738     if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress
2739         || sc->blink_in_progress || sc->videoio_in_progress) {
2740         sc->delayed_next_scr = next_scr + 1;
2741         sc_touch_scrn_saver();
2742         DPRINTF(5, ("switch delayed\n"));
2743         return 0;
2744     }
2745
2746     cur_scp = sc->cur_scp;
2747
2748     /*
2749      * we are in the middle of the vty switching process...
2750      *
2751      * This may be in the console path, be very careful.  pfindn() is
2752      * still going to use a spinlock but it no longer uses tokens so
2753      * we should be ok.
2754      */
2755     if (sc->switch_in_progress &&
2756         (cur_scp->smode.mode == VT_PROCESS) &&
2757         cur_scp->proc) {
2758         if (cur_scp->proc != pfindn(cur_scp->pid)) {
2759             /*
2760              * The controlling process has died!!.  Do some clean up.
2761              * NOTE:`cur_scp->proc' and `cur_scp->smode.mode'
2762              * are not reset here yet; they will be cleared later.
2763              */
2764             DPRINTF(5, ("cur_scp controlling process %d died, ", cur_scp->pid));
2765             if (cur_scp->status & SWITCH_WAIT_REL) {
2766                 /*
2767                  * Force the previous switch to finish, but return now
2768                  * with error.
2769                  *
2770                  */
2771                 DPRINTF(5, ("reset WAIT_REL, "));
2772                 finish_vt_rel(cur_scp, TRUE);
2773                 DPRINTF(5, ("finishing previous switch\n"));
2774                 return EINVAL;
2775             } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2776                 /* let's assume screen switch has been completed. */
2777                 DPRINTF(5, ("reset WAIT_ACQ, "));
2778                 finish_vt_acq(cur_scp);
2779             } else {
2780                 /*
2781                  * We are in between screen release and acquisition, and
2782                  * reached here via scgetc() or scrn_timer() which has
2783                  * interrupted exchange_scr(). Don't do anything stupid.
2784                  */
2785                 DPRINTF(5, ("waiting nothing, "));
2786             }
2787         } else {
2788             /*
2789              * The controlling process is alive, but not responding...
2790              * It is either buggy or it may be just taking time.
2791              * The following code is a gross kludge to cope with this
2792              * problem for which there is no clean solution. XXX
2793              */
2794             if (cur_scp->status & SWITCH_WAIT_REL) {
2795                 switch (sc->switch_in_progress++) {
2796                 case 1:
2797                     break;
2798                 case 2:
2799                     DPRINTF(5, ("sending relsig again, "));
2800                     signal_vt_rel(cur_scp);
2801                     break;
2802                 case 3:
2803                     break;
2804                 case 4:
2805                 default:
2806                     /*
2807                      * Act as if the controlling program returned
2808                      * VT_FALSE.
2809                      *
2810                      */
2811                     DPRINTF(5, ("force reset WAIT_REL, "));
2812                     finish_vt_rel(cur_scp, FALSE);
2813                     DPRINTF(5, ("act as if VT_FALSE was seen\n"));
2814                     return EINVAL;
2815                 }
2816             } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2817                 switch (sc->switch_in_progress++) {
2818                 case 1:
2819                     break;
2820                 case 2:
2821                     DPRINTF(5, ("sending acqsig again, "));
2822                     signal_vt_acq(cur_scp);
2823                     break;
2824                 case 3:
2825                     break;
2826                 case 4:
2827                 default:
2828                      /* clear the flag and finish the previous switch */
2829                     DPRINTF(5, ("force reset WAIT_ACQ, "));
2830                     finish_vt_acq(cur_scp);
2831                     break;
2832                 }
2833             }
2834         }
2835     }
2836
2837     /*
2838      * Return error if an invalid argument is given, or vty switch
2839      * is still in progress.
2840      */
2841     if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys)
2842         || sc->switch_in_progress) {
2843         sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2844         DPRINTF(5, ("error 1\n"));
2845         return EINVAL;
2846     }
2847
2848     /*
2849      * Don't allow switching away from the graphics mode vty
2850      * if the switch mode is VT_AUTO, unless the next vty is the same
2851      * as the current or the current vty has been closed (but showing).
2852      */
2853     tp = VIRTUAL_TTY(sc, cur_scp->index);
2854     if ((cur_scp->index != next_scr)
2855         && ISTTYOPEN(tp)
2856         && (cur_scp->smode.mode == VT_AUTO)
2857         && ISGRAPHSC(cur_scp)) {
2858         sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2859         DPRINTF(5, ("error, graphics mode\n"));
2860         return EINVAL;
2861     }
2862
2863     /*
2864      * Is the wanted vty open? Don't allow switching to a closed vty.
2865      * If we are in DDB, don't switch to a vty in the VT_PROCESS mode.
2866      * Note that we always allow the user to switch to the kernel
2867      * console even if it is closed.
2868      */
2869     if ((sc_console == NULL) || (next_scr != sc_console->index)) {
2870         tp = VIRTUAL_TTY(sc, next_scr);
2871         if (!ISTTYOPEN(tp)) {
2872             sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2873             DPRINTF(5, ("error 2, requested vty isn't open!\n"));
2874             return EINVAL;
2875         }
2876         if ((debugger > 0) && (SC_STAT(tp->t_dev)->smode.mode == VT_PROCESS)) {
2877             DPRINTF(5, ("error 3, requested vty is in the VT_PROCESS mode\n"));
2878             return EINVAL;
2879         }
2880     }
2881
2882     /* this is the start of vty switching process... */
2883     ++sc->switch_in_progress;
2884     sc->delayed_next_scr = 0;
2885     sc->old_scp = cur_scp;
2886     sc->new_scp = SC_STAT(SC_DEV(sc, next_scr));
2887     if (sc->new_scp == sc->old_scp) {
2888         sc->switch_in_progress = 0;
2889         wakeup((caddr_t)&sc->new_scp->smode);
2890         DPRINTF(5, ("switch done (new == old)\n"));
2891         return 0;
2892     }
2893
2894     /* has controlling process died? */
2895     vt_proc_alive(sc->old_scp);
2896     vt_proc_alive(sc->new_scp);
2897
2898     /* wait for the controlling process to release the screen, if necessary */
2899     if (signal_vt_rel(sc->old_scp)) {
2900         return 0;
2901     }
2902
2903     /* go set up the new vty screen */
2904     exchange_scr(sc);
2905
2906     /* wake up processes waiting for this vty */
2907     wakeup((caddr_t)&sc->cur_scp->smode);
2908
2909     /* wait for the controlling process to acknowledge, if necessary */
2910     if (signal_vt_acq(sc->cur_scp)) {
2911         return 0;
2912     }
2913
2914     sc->switch_in_progress = 0;
2915     if (sc->unit == sc_console_unit && !sc->fb_blanked)
2916         cons_unavail = FALSE;
2917     DPRINTF(5, ("switch done\n"));
2918
2919     return 0;
2920 }
2921
2922 static void
2923 do_switch_scr(sc_softc_t *sc)
2924 {
2925     lwkt_gettoken(&tty_token);
2926     vt_proc_alive(sc->new_scp);
2927
2928     exchange_scr(sc);
2929     /* sc->cur_scp == sc->new_scp */
2930     wakeup((caddr_t)&sc->cur_scp->smode);
2931
2932     /* wait for the controlling process to acknowledge, if necessary */
2933     if (!signal_vt_acq(sc->cur_scp)) {
2934         sc->switch_in_progress = 0;
2935         if (sc->unit == sc_console_unit && !sc->fb_blanked)
2936             cons_unavail = FALSE;
2937     }
2938     lwkt_reltoken(&tty_token);
2939 }
2940
2941 static int
2942 vt_proc_alive(scr_stat *scp)
2943 {
2944     lwkt_gettoken(&tty_token);
2945     if (scp->proc) {
2946         if (scp->proc == pfindn(scp->pid)) {
2947             lwkt_reltoken(&tty_token);
2948             return TRUE;
2949         }
2950         scp->proc = NULL;
2951         scp->smode.mode = VT_AUTO;
2952         DPRINTF(5, ("vt controlling process %d died\n", scp->pid));
2953     }
2954     lwkt_reltoken(&tty_token);
2955     return FALSE;
2956 }
2957
2958 static int
2959 signal_vt_rel(scr_stat *scp)
2960 {
2961     struct proc *p;
2962
2963     lwkt_gettoken(&tty_token);
2964     if (scp->smode.mode != VT_PROCESS) {
2965         lwkt_reltoken(&tty_token);
2966         return FALSE;
2967     }
2968     scp->status |= SWITCH_WAIT_REL;
2969     p = scp->proc;
2970     PHOLD(p);
2971     ksignal(p, scp->smode.relsig);
2972     PRELE(p);
2973     DPRINTF(5, ("sending relsig to %d\n", scp->pid));
2974     lwkt_reltoken(&tty_token);
2975
2976     return TRUE;
2977 }
2978
2979 static int
2980 signal_vt_acq(scr_stat *scp)
2981 {
2982     struct proc *p;
2983
2984     lwkt_gettoken(&tty_token);
2985     if (scp->smode.mode != VT_PROCESS) {
2986         lwkt_reltoken(&tty_token);
2987         return FALSE;
2988     }
2989     if (scp->sc->unit == sc_console_unit)
2990         cons_unavail = TRUE;
2991     scp->status |= SWITCH_WAIT_ACQ;
2992     p = scp->proc;
2993     PHOLD(p);
2994     ksignal(p, scp->smode.acqsig);
2995     PRELE(p);
2996     DPRINTF(5, ("sending acqsig to %d\n", scp->pid));
2997     lwkt_reltoken(&tty_token);
2998
2999     return TRUE;
3000 }
3001
3002 static int
3003 finish_vt_rel(scr_stat *scp, int release)
3004 {
3005     lwkt_gettoken(&tty_token);
3006     if (scp == scp->sc->old_scp && scp->status & SWITCH_WAIT_REL) {
3007         scp->status &= ~SWITCH_WAIT_REL;
3008         if (release)
3009             do_switch_scr(scp->sc);
3010         else
3011             scp->sc->switch_in_progress = 0;
3012         lwkt_reltoken(&tty_token);
3013         return 0;
3014     }
3015     lwkt_reltoken(&tty_token);
3016     return EINVAL;
3017 }
3018
3019 static int
3020 finish_vt_acq(scr_stat *scp)
3021 {
3022     lwkt_gettoken(&tty_token);
3023     if (scp == scp->sc->new_scp && scp->status & SWITCH_WAIT_ACQ) {
3024         scp->status &= ~SWITCH_WAIT_ACQ;
3025         scp->sc->switch_in_progress = 0;
3026         lwkt_reltoken(&tty_token);
3027         return 0;
3028     }
3029     lwkt_reltoken(&tty_token);
3030     return EINVAL;
3031 }
3032
3033 static void
3034 exchange_scr(sc_softc_t *sc)
3035 {
3036     scr_stat *scp;
3037
3038     lwkt_gettoken(&tty_token);
3039     /* save the current state of video and keyboard */
3040     sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos);
3041     if (!ISGRAPHSC(sc->old_scp))
3042         sc_remove_cursor_image(sc->old_scp);
3043     if (sc->old_scp->kbd_mode == K_XLATE)
3044         save_kbd_state(sc->old_scp, TRUE);
3045
3046     /* set up the video for the new screen */
3047     scp = sc->cur_scp = sc->new_scp;
3048     if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp))
3049         set_mode(scp);
3050     else if (sc->adp != NULL)
3051         sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3052                     (void *)sc->adp->va_window, FALSE);
3053     scp->status |= MOUSE_HIDDEN;
3054     sc_update_render(scp);     /* Switch to kms renderer if necessary */
3055     sc_move_cursor(scp, scp->xpos, scp->ypos);
3056     if (!ISGRAPHSC(scp))
3057         sc_set_cursor_image(scp);
3058 #ifndef SC_NO_PALETTE_LOADING
3059     if (sc->fbi == NULL && ISGRAPHSC(sc->old_scp))
3060         load_palette(sc->adp, sc->palette);
3061 #endif
3062     if (!ISGRAPHSC(scp) || sc->fbi == NULL)
3063         sc_set_border(scp, scp->border);
3064
3065     /* set up the keyboard for the new screen */
3066     if (sc->old_scp->kbd_mode != scp->kbd_mode)
3067         kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
3068     update_kbd_state(scp, scp->status, LOCK_MASK, TRUE);
3069
3070     mark_all(scp);
3071
3072     /*
3073      * Restore DRM framebuffer console mode if necessary.
3074      * Especially avoid modesetting when switching to a vt which is in
3075      * graphics mode, because the fb_set_par() from the taskqueue thread
3076      * might race with the modesetting ioctl from the userland application.
3077      */
3078     if (ISTEXTSC(scp) && !ISTEXTSC(sc->old_scp) &&
3079         sc->fbi != NULL && sc->fbi->fbops.fb_set_par != NULL &&
3080         sc->fb_set_par_task != NULL) {
3081         taskqueue_enqueue(taskqueue_thread[0], sc->fb_set_par_task);
3082     }
3083
3084     lwkt_reltoken(&tty_token);
3085 }
3086
3087 static void
3088 sc_puts(scr_stat *scp, u_char *buf, int len)
3089 {
3090 #if NSPLASH > 0
3091     /* make screensaver happy */
3092     if (!sticky_splash && scp == scp->sc->cur_scp)
3093         run_scrn_saver = FALSE;
3094 #endif
3095
3096     if (scp->tsw)
3097         (*scp->tsw->te_puts)(scp, buf, len);
3098
3099     if (scp->sc->delayed_next_scr)
3100         sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
3101
3102 }
3103
3104 void
3105 sc_draw_cursor_image(scr_stat *scp)
3106 {
3107     /* assert(scp == scp->sc->cur_scp); */
3108     atomic_add_int(&scp->sc->videoio_in_progress, 1);
3109     (*scp->rndr->draw_cursor)(scp, scp->cursor_pos,
3110                               scp->sc->flags & SC_BLINK_CURSOR, TRUE,
3111                               sc_inside_cutmark(scp, scp->cursor_pos));
3112     scp->cursor_oldpos = scp->cursor_pos;
3113     atomic_add_int(&scp->sc->videoio_in_progress, -1);
3114 }
3115
3116 void
3117 sc_remove_cursor_image(scr_stat *scp)
3118 {
3119     /* assert(scp == scp->sc->cur_scp); */
3120     atomic_add_int(&scp->sc->videoio_in_progress, 1);
3121     (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos,
3122                               scp->sc->flags & SC_BLINK_CURSOR, FALSE,
3123                               sc_inside_cutmark(scp, scp->cursor_oldpos));
3124     atomic_add_int(&scp->sc->videoio_in_progress, -1);
3125 }
3126
3127 static void
3128 update_cursor_image(scr_stat *scp)
3129 {
3130     int blink;
3131
3132     if (scp->sc->flags & SC_CHAR_CURSOR) {
3133         scp->cursor_base = imax(0, scp->sc->cursor_base);
3134         scp->cursor_height = imin(scp->sc->cursor_height, scp->font_height);
3135     } else {
3136         scp->cursor_base = 0;
3137         scp->cursor_height = scp->font_height;
3138     }
3139     blink = scp->sc->flags & SC_BLINK_CURSOR;
3140
3141     /* assert(scp == scp->sc->cur_scp); */
3142     atomic_add_int(&scp->sc->videoio_in_progress, 1);
3143     (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos, blink, FALSE,
3144                               sc_inside_cutmark(scp, scp->cursor_pos));
3145     (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height, blink);
3146     (*scp->rndr->draw_cursor)(scp, scp->cursor_pos, blink, TRUE,
3147                               sc_inside_cutmark(scp, scp->cursor_pos));
3148     atomic_add_int(&scp->sc->videoio_in_progress, -1);
3149 }
3150
3151 void
3152 sc_set_cursor_image(scr_stat *scp)
3153 {
3154     if (scp->sc->flags & SC_CHAR_CURSOR) {
3155         scp->cursor_base = imax(0, scp->sc->cursor_base);
3156         scp->cursor_height = imin(scp->sc->cursor_height, scp->font_height);
3157     } else {
3158         scp->cursor_base = 0;
3159         scp->cursor_height = scp->font_height;
3160     }
3161
3162     /* assert(scp == scp->sc->cur_scp); */
3163     atomic_add_int(&scp->sc->videoio_in_progress, 1);
3164     (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height,
3165                              scp->sc->flags & SC_BLINK_CURSOR);
3166     atomic_add_int(&scp->sc->videoio_in_progress, -1);
3167 }
3168
3169 static void
3170 scinit(int unit, int flags)
3171 {
3172     /*
3173      * When syscons is being initialized as the kernel console, malloc()
3174      * is not yet functional, because various kernel structures has not been
3175      * fully initialized yet.  Therefore, we need to declare the following
3176      * static buffers for the console.  This is less than ideal,
3177      * but is necessry evil for the time being.  XXX
3178      */
3179     static scr_stat main_console;
3180     static u_short sc_buffer[ROW*COL];  /* XXX */
3181 #ifndef SC_NO_FONT_LOADING
3182     static u_char font_8[256*8];
3183     static u_char font_14[256*14];
3184     static u_char font_16[256*16];
3185 #endif
3186
3187     sc_softc_t *sc;
3188     scr_stat *scp;
3189     video_adapter_t *adp;
3190     int col;
3191     int row;
3192     int i;
3193
3194     /* one time initialization */
3195     if (init_done == COLD)
3196         sc_get_bios_values(&bios_value);
3197     init_done = WARM;
3198
3199     /*
3200      * Allocate resources.  Even if we are being called for the second
3201      * time, we must allocate them again, because they might have
3202      * disappeared...
3203      */
3204     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
3205     adp = NULL;
3206     if (flags & SC_EFI_FB) {
3207         /* Don't replace already registered drm framebuffer here */
3208         if (sc->fbi == NULL) {
3209             sc->fbi = &efi_fb_info;
3210             sc->fbi_generation++;
3211         }
3212     } else if (sc->adapter >= 0) {
3213         vid_release(sc->adp, (void *)&sc->adapter);
3214         adp = sc->adp;
3215     }
3216     sc->adp = NULL;
3217     if (sc->keyboard >= 0) {
3218         DPRINTF(5, ("sc%d: releasing kbd%d\n", unit, sc->keyboard));
3219         i = kbd_release(sc->kbd, (void *)&sc->keyboard);
3220         DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i));
3221         if (sc->kbd != NULL) {
3222             DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n",
3223                 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
3224         }
3225         sc->kbd = NULL;
3226     }
3227     if (!(flags & SC_EFI_FB)) {
3228         sc->adapter = vid_allocate("*", unit, (void *)&sc->adapter);
3229         sc->adp = vid_get_adapter(sc->adapter);
3230         /* assert((sc->adapter >= 0) && (sc->adp != NULL)) */
3231     }
3232     sc->keyboard = sc_allocate_keyboard(sc, unit);
3233     DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard));
3234     sc->kbd = kbd_get_keyboard(sc->keyboard);
3235     if (sc->kbd != NULL) {
3236         DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n",
3237                 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
3238     }
3239
3240     if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) {
3241
3242         if (sc->fbi != NULL)
3243                 sc->initial_mode = 0;
3244         else
3245                 sc->initial_mode = sc->adp->va_initial_mode;
3246
3247 #ifndef SC_NO_FONT_LOADING
3248         if (flags & SC_KERNEL_CONSOLE) {
3249             sc->font_8 = font_8;
3250             sc->font_14 = font_14;
3251             sc->font_16 = font_16;
3252         } else if (sc->font_8 == NULL) {
3253             /* assert(sc_malloc) */
3254             sc->font_8 = kmalloc(sizeof(font_8), M_SYSCONS, M_WAITOK);
3255             sc->font_14 = kmalloc(sizeof(font_14), M_SYSCONS, M_WAITOK);
3256             sc->font_16 = kmalloc(sizeof(font_16), M_SYSCONS, M_WAITOK);
3257         }
3258 #endif
3259
3260         if (sc->fbi != NULL) {
3261             col = 0;
3262             row = 0;
3263         } else {
3264             lwkt_gettoken(&tty_token);
3265             /* extract the hw cursor location and hide the cursor for now */
3266             (*vidsw[sc->adapter]->read_hw_cursor)(sc->adp, &col, &row);
3267             (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, -1, -1);
3268             lwkt_reltoken(&tty_token);
3269         }
3270
3271         /* set up the first console */
3272         sc->first_vty = unit*MAXCONS;
3273         sc->vtys = MAXCONS;             /* XXX: should be configurable */
3274         if (flags & SC_KERNEL_CONSOLE) {
3275             scp = &main_console;
3276             sc->console_scp = scp;
3277             init_scp(sc, sc->first_vty, scp);
3278             sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
3279                         (void *)sc_buffer, FALSE);
3280             if (sc_init_emulator(scp, SC_DFLT_TERM))
3281                 sc_init_emulator(scp, "*");
3282             (*scp->tsw->te_default_attr)(scp,
3283                                          kernel_default.std_color,
3284                                          kernel_default.rev_color);
3285         } else {
3286             /* assert(sc_malloc) */
3287             sc->dev = kmalloc(sizeof(cdev_t)*sc->vtys, M_SYSCONS, M_WAITOK | M_ZERO);
3288
3289             sc->dev[0] = make_dev(&sc_ops, unit*MAXCONS, UID_ROOT,
3290                                 GID_WHEEL, 0600, "ttyv%r", unit*MAXCONS);
3291
3292             sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
3293             scp = alloc_scp(sc, sc->first_vty);
3294             sc->dev[0]->si_drv1 = scp;
3295         }
3296         sc->cur_scp = scp;
3297
3298         /* copy screen to temporary buffer */
3299         if (scp->sc->fbi == NULL) {
3300             sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3301                         (void *)scp->sc->adp->va_window, FALSE);
3302             if (ISTEXTSC(scp))
3303                 sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
3304         }
3305
3306         /* move cursors to the initial positions */
3307         if (col >= scp->xsize)
3308             col = 0;
3309         if (row >= scp->ysize)
3310             row = scp->ysize - 1;
3311         scp->xpos = col;
3312         scp->ypos = row;
3313         if (sc->fbi != NULL) {
3314             scp->cursor_pos = 0;
3315             sc->cursor_base = 0;
3316             sc->cursor_height = scp->font_height;
3317         } else {
3318             scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
3319             if (bios_value.cursor_end < scp->font_height)
3320                 sc->cursor_base = scp->font_height - bios_value.cursor_end - 1;
3321             else
3322                 sc->cursor_base = 0;
3323             i = bios_value.cursor_end - bios_value.cursor_start + 1;
3324             sc->cursor_height = imin(i, scp->font_height);
3325         }
3326 #ifndef SC_NO_SYSMOUSE
3327         sc_mouse_move(scp, scp->xpixel/2, scp->ypixel/2);
3328 #endif
3329         if (!ISGRAPHSC(scp)) {
3330             sc_set_cursor_image(scp);
3331             sc_draw_cursor_image(scp);
3332             /* If framebuffer vaddr is still 0, we can't draw the border yet */
3333             if (scp->sc->fbi != NULL && scp->sc->fbi->vaddr != 0) {
3334                 sc_filled_border = TRUE;
3335                 sc_set_border(scp, scp->border);
3336             }
3337         }
3338
3339         /* save font and palette */
3340 #ifndef SC_NO_FONT_LOADING
3341         sc->fonts_loaded = 0;
3342 #ifdef SC_DFLT_FONT
3343         bcopy(dflt_font_8, sc->font_8, sizeof(dflt_font_8));
3344         bcopy(dflt_font_14, sc->font_14, sizeof(dflt_font_14));
3345         bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16));
3346         sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8;
3347 #endif /* SC_DFLT_FONT */
3348         if (sc->adp != NULL && ISFONTAVAIL(sc->adp->va_flags)) {
3349 #ifdef SC_DFLT_FONT
3350             if (scp->font_height < 14) {
3351                 sc_load_font(scp, 0, 8, sc->font_8, 0, 256);
3352             } else if (scp->font_height >= 16) {
3353                 sc_load_font(scp, 0, 16, sc->font_16, 0, 256);
3354             } else {
3355                 sc_load_font(scp, 0, 14, sc->font_14, 0, 256);
3356             }
3357 #else /* !SC_DFLT_FONT */
3358             if (scp->font_height < 14) {
3359                 sc_save_font(scp, 0, 8, sc->font_8, 0, 256);
3360                 sc->fonts_loaded = FONT_8;
3361             } else if (scp->font_height >= 16) {
3362                 sc_save_font(scp, 0, 16, sc->font_16, 0, 256);
3363                 sc->fonts_loaded = FONT_16;
3364             } else {
3365                 sc_save_font(scp, 0, 14, sc->font_14, 0, 256);
3366                 sc->fonts_loaded = FONT_14;
3367             }
3368 #endif /* SC_DFLT_FONT */
3369             /* FONT KLUDGE: always use the font page #0. XXX */
3370             sc_show_font(scp, 0);
3371         }
3372 #endif /* !SC_NO_FONT_LOADING */
3373
3374 #ifndef SC_NO_PALETTE_LOADING
3375         if (!(flags & SC_EFI_FB))
3376             save_palette(sc->adp, sc->palette);
3377 #endif
3378
3379 #if NSPLASH > 0
3380         if (!(sc->flags & SC_SPLASH_SCRN) && (flags & SC_KERNEL_CONSOLE)) {
3381             /* we are ready to put up the splash image! */
3382             splash_init(sc->adp, scsplash_callback, sc);
3383             sc->flags |= SC_SPLASH_SCRN;
3384         }
3385 #endif /* NSPLASH */
3386     }
3387
3388     /* the rest is not necessary, if we have done it once */
3389     if (sc->flags & SC_INIT_DONE) {
3390         return;
3391     }
3392
3393     /* initialize mapscrn arrays to a one to one map */
3394     for (i = 0; i < sizeof(sc->scr_map); i++)
3395         sc->scr_map[i] = sc->scr_rmap[i] = i;
3396
3397     sc->flags |= SC_INIT_DONE;
3398 }
3399
3400 static void
3401 scterm(int unit, int flags)
3402 {
3403     sc_softc_t *sc;
3404     scr_stat *scp;
3405
3406     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
3407     if (sc == NULL)
3408         return;                 /* shouldn't happen */
3409
3410     lwkt_gettoken(&tty_token);
3411 #if NSPLASH > 0
3412     /* this console is no longer available for the splash screen */
3413     if (sc->flags & SC_SPLASH_SCRN) {
3414         splash_term(sc->adp);
3415         sc->flags &= ~SC_SPLASH_SCRN;
3416     }
3417 #endif /* NSPLASH */
3418
3419 #if 0 /* XXX */
3420     /* move the hardware cursor to the upper-left corner */
3421     (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, 0, 0);
3422 #endif
3423
3424     /* release the keyboard and the video card */
3425     if (sc->keyboard >= 0)
3426         kbd_release(sc->kbd, &sc->keyboard);
3427     if (sc->adapter >= 0)
3428         vid_release(sc->adp, &sc->adapter);
3429
3430     /*
3431      * Stop the terminal emulator, if any.  If operating on the
3432      * kernel console sc->dev may not be setup yet.
3433      */
3434     if (flags & SC_KERNEL_CONSOLE)
3435         scp = sc->console_scp;
3436     else
3437         scp = SC_STAT(sc->dev[0]);
3438     if (scp->tsw)
3439         (*scp->tsw->te_term)(scp, &scp->ts);
3440     if (scp->ts != NULL)
3441         kfree(scp->ts, M_SYSCONS);
3442
3443     /* clear the structure */
3444     if (!(flags & SC_KERNEL_CONSOLE)) {
3445         /* XXX: We need delete_dev() for this */
3446         kfree(sc->dev, M_SYSCONS);
3447 #if 0
3448         /* XXX: We need a ttyunregister for this */
3449         kfree(sc->tty, M_SYSCONS);
3450 #endif
3451 #ifndef SC_NO_FONT_LOADING
3452         kfree(sc->font_8, M_SYSCONS);
3453         kfree(sc->font_14, M_SYSCONS);
3454         kfree(sc->font_16, M_SYSCONS);
3455 #endif
3456         /* XXX vtb, history */
3457     }
3458     bzero(sc, sizeof(*sc));
3459     sc->keyboard = -1;
3460     sc->adapter = -1;
3461     lwkt_reltoken(&tty_token);
3462 }
3463
3464 static void
3465 scshutdown(void *arg, int howto)
3466 {
3467     /* assert(sc_console != NULL) */
3468
3469     lwkt_gettoken(&tty_token);
3470     syscons_lock();
3471     sc_touch_scrn_saver();
3472     if (!cold && sc_console
3473         && sc_console->sc->cur_scp->smode.mode == VT_AUTO
3474         && sc_console->smode.mode == VT_AUTO) {
3475         sc_switch_scr(sc_console->sc, sc_console->index);
3476     }
3477     shutdown_in_progress = TRUE;
3478     syscons_unlock();
3479     lwkt_reltoken(&tty_token);
3480 }
3481
3482 int
3483 sc_clean_up(scr_stat *scp, int need_unlock)
3484 {
3485 #if NSPLASH > 0
3486     int error;
3487 #endif /* NSPLASH */
3488
3489     lwkt_gettoken(&tty_token);
3490     if (scp->sc->flags & SC_SCRN_BLANKED) {
3491         sc_touch_scrn_saver();
3492 #if NSPLASH > 0
3493         if ((error = wait_scrn_saver_stop(scp->sc, need_unlock))) {
3494             lwkt_reltoken(&tty_token);
3495             return error;
3496         }
3497 #endif /* NSPLASH */
3498     }
3499     scp->status |= MOUSE_HIDDEN;
3500     sc_remove_mouse_image(scp);
3501     sc_remove_cutmarking(scp);
3502     lwkt_reltoken(&tty_token);
3503     return 0;
3504 }
3505
3506 void
3507 sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard)
3508 {
3509     sc_vtb_t new;
3510     sc_vtb_t old;
3511
3512     lwkt_gettoken(&tty_token);
3513     old = scp->vtb;
3514     sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait);
3515     if (!discard && (old.vtb_flags & VTB_VALID)) {
3516         /* retain the current cursor position and buffer contants */
3517         scp->cursor_oldpos = scp->cursor_pos;
3518         /*
3519          * This works only if the old buffer has the same size as or larger
3520          * than the new one. XXX
3521          */
3522         sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize);
3523         scp->vtb = new;
3524     } else {
3525         scp->vtb = new;
3526         sc_vtb_destroy(&old);
3527     }
3528
3529 #ifndef SC_NO_SYSMOUSE
3530     /* move the mouse cursor at the center of the screen */
3531     sc_mouse_move(scp, scp->xpixel / 2, scp->ypixel / 2);
3532 #endif
3533     lwkt_reltoken(&tty_token);
3534 }
3535
3536 static scr_stat *
3537 alloc_scp(sc_softc_t *sc, int vty)
3538 {
3539     scr_stat *scp;
3540
3541     /* assert(sc_malloc) */
3542
3543     scp = kmalloc(sizeof(scr_stat), M_SYSCONS, M_WAITOK);
3544     init_scp(sc, vty, scp);
3545
3546     sc_alloc_scr_buffer(scp, TRUE, TRUE);
3547     if (sc_init_emulator(scp, SC_DFLT_TERM))
3548         sc_init_emulator(scp, "*");
3549
3550 #ifndef SC_NO_CUTPASTE
3551     sc_alloc_cut_buffer(scp, TRUE);
3552 #endif
3553
3554 #ifndef SC_NO_HISTORY
3555     sc_alloc_history_buffer(scp, 0, 0, TRUE);
3556 #endif
3557     return scp;
3558 }
3559
3560 /*
3561  * NOTE: Must be called with tty_token held.
3562  */
3563 static void
3564 init_scp(sc_softc_t *sc, int vty, scr_stat *scp)
3565 {
3566     video_info_t info;
3567
3568     bzero(scp, sizeof(*scp));
3569
3570     scp->index = vty;
3571     scp->sc = sc;
3572     scp->status = 0;
3573     scp->mode = sc->initial_mode;
3574     scp->fbi_generation = sc->fbi_generation;
3575     callout_init_mp(&scp->blink_screen_ch);
3576     if (scp->sc->fbi == NULL) {
3577         lwkt_gettoken(&tty_token);
3578         (*vidsw[sc->adapter]->get_info)(sc->adp, scp->mode, &info);
3579         lwkt_reltoken(&tty_token);
3580     }
3581     if (scp->sc->fbi != NULL) {
3582         scp->xpixel = sc->fbi->width;
3583         scp->ypixel = sc->fbi->height;
3584         scp->font_width = 8;
3585         scp->font_height = 16;
3586
3587         /* The first vty uses a statically allocated 80x25 buffer */
3588         if (vty == sc->first_vty)
3589                 sc_font_scale(scp, COL, ROW);
3590         else
3591                 sc_font_scale(scp, 0, 0);
3592
3593 #ifndef SC_NO_FONT_LOADING
3594         scp->font = sc->font_16;
3595 #else
3596         scp->font = NULL;
3597 #endif
3598     } else if (info.vi_flags & V_INFO_GRAPHICS) {
3599         scp->status |= GRAPHICS_MODE;
3600         scp->xpixel = info.vi_width;
3601         scp->ypixel = info.vi_height;
3602         scp->xsize = info.vi_width/8;
3603         scp->ysize = info.vi_height/info.vi_cheight;
3604         scp->font_height = 0;
3605         scp->font_width = 0;
3606         scp->font = NULL;
3607     } else {
3608         scp->xsize = info.vi_width;
3609         scp->ysize = info.vi_height;
3610         scp->xpixel = scp->xsize*8;
3611         scp->ypixel = scp->ysize*info.vi_cheight;
3612         scp->font_width = 8;
3613         if (info.vi_cheight < 14) {
3614             scp->font_height = 8;
3615 #ifndef SC_NO_FONT_LOADING
3616             scp->font = sc->font_8;
3617 #else
3618             scp->font = NULL;
3619 #endif
3620         } else if (info.vi_cheight >= 16) {
3621             scp->font_height = 16;
3622 #ifndef SC_NO_FONT_LOADING
3623             scp->font = sc->font_16;
3624 #else
3625             scp->font = NULL;
3626 #endif
3627         } else {
3628             scp->font_height = 14;
3629 #ifndef SC_NO_FONT_LOADING
3630             scp->font = sc->font_14;
3631 #else
3632             scp->font = NULL;
3633 #endif
3634         }
3635     }
3636     scp->xoff = scp->yoff = 0;
3637     scp->xpos = scp->ypos = 0;
3638     sc_vtb_init(&scp->vtb, VTB_MEMORY, 0, 0, NULL, FALSE);
3639     sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE);
3640     scp->start = scp->xsize * scp->ysize - 1;
3641     scp->end = 0;
3642     scp->tsw = NULL;
3643     scp->ts = NULL;
3644     scp->rndr = NULL;
3645     scp->border = SC_BORDER_COLOR;
3646     scp->cursor_base = sc->cursor_base;
3647     scp->cursor_height = imin(sc->cursor_height, scp->font_height);
3648     scp->mouse_cut_start = scp->xsize * scp->ysize;
3649     scp->mouse_cut_end = -1;
3650     scp->mouse_signal = 0;
3651     scp->mouse_pid = 0;
3652     scp->mouse_proc = NULL;
3653     scp->kbd_mode = K_XLATE;
3654     scp->bell_pitch = bios_value.bell_pitch;
3655     scp->bell_duration = BELL_DURATION;
3656     scp->status |= (bios_value.shift_state & NLKED);
3657     scp->status |= CURSOR_ENABLED | MOUSE_HIDDEN;
3658     scp->pid = 0;
3659     scp->proc = NULL;
3660     scp->smode.mode = VT_AUTO;
3661     scp->history = NULL;
3662     scp->history_pos = 0;
3663     scp->history_size = 0;
3664 }
3665
3666 int
3667 sc_init_emulator(scr_stat *scp, char *name)
3668 {
3669     sc_term_sw_t *sw;
3670     sc_rndr_sw_t *rndr;
3671     void *p;
3672     int error;
3673
3674     if (name == NULL)   /* if no name is given, use the current emulator */
3675         sw = scp->tsw;
3676     else                /* ...otherwise find the named emulator */
3677         sw = sc_term_match(name);
3678     if (sw == NULL) {
3679         return EINVAL;
3680     }
3681
3682     rndr = NULL;
3683     if (strcmp(sw->te_renderer, "*") != 0) {
3684         rndr = sc_render_match(scp, sw->te_renderer, scp->model);
3685     }
3686     if (rndr == NULL && scp->sc->fbi != NULL) {
3687         rndr = sc_render_match(scp, "kms", scp->model);
3688     }
3689     if (rndr == NULL) {
3690         rndr = sc_render_match(scp, scp->sc->adp->va_name, scp->model);
3691         if (rndr == NULL) {
3692             return ENODEV;
3693         }
3694     }
3695
3696     if (sw == scp->tsw) {
3697         error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT);
3698         scp->rndr = rndr;
3699         sc_clear_screen(scp);
3700         /* assert(error == 0); */
3701         return error;
3702     }
3703
3704     if (sc_malloc && (sw->te_size > 0))
3705         p = kmalloc(sw->te_size, M_SYSCONS, M_NOWAIT);
3706     else
3707         p = NULL;
3708     error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT);
3709     if (error) {
3710         return error;
3711     }
3712
3713     if (scp->tsw)
3714         (*scp->tsw->te_term)(scp, &scp->ts);
3715     if (scp->ts != NULL)
3716         kfree(scp->ts, M_SYSCONS);
3717     scp->tsw = sw;
3718     scp->ts = p;
3719     scp->rndr = rndr;
3720
3721     /* XXX */
3722     (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color);
3723     sc_clear_screen(scp);
3724
3725     return 0;
3726 }
3727
3728 /*
3729  * scgetc(flags) - get character from keyboard.
3730  * If flags & SCGETC_CN, then avoid harmful side effects.
3731  * If flags & SCGETC_NONBLOCK, then wait until a key is pressed, else
3732  * return NOKEY if there is nothing there.
3733  */
3734 static u_int
3735 scgetc(sc_softc_t *sc, u_int flags)
3736 {
3737     scr_stat *scp;
3738 #ifndef SC_NO_HISTORY
3739     struct tty *tp;
3740 #endif
3741     u_int c;
3742     int this_scr;
3743     int f;
3744     int i;
3745
3746     lwkt_gettoken(&tty_token);
3747     if (sc->kbd == NULL) {
3748         lwkt_reltoken(&tty_token);
3749         return NOKEY;
3750     }
3751
3752 next_code:
3753 #if 1
3754     /* I don't like this, but... XXX */
3755     if (flags & SCGETC_CN) {
3756         syscons_lock();
3757         sccnupdate(sc->cur_scp);
3758         syscons_unlock();
3759     }
3760 #endif
3761     scp = sc->cur_scp;
3762     /* first see if there is something in the keyboard port */
3763     for (;;) {
3764         c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK));
3765         if (c == ERRKEY) {
3766             if (!(flags & SCGETC_CN))
3767                 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3768         } else if (c == NOKEY) {
3769             lwkt_reltoken(&tty_token);
3770             return c;
3771         } else {
3772             break;
3773         }
3774     }
3775
3776     /* make screensaver happy */
3777     if (!(c & RELKEY))
3778         sc_touch_scrn_saver();
3779
3780     if (!(flags & SCGETC_CN))
3781         /* do the /dev/random device a favour */
3782         add_keyboard_randomness(c);
3783
3784     if (scp->kbd_mode != K_XLATE) {
3785         lwkt_reltoken(&tty_token);
3786         return KEYCHAR(c);
3787     }
3788
3789     /* if scroll-lock pressed allow history browsing */
3790     if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) {
3791
3792         scp->status &= ~CURSOR_ENABLED;
3793         sc_remove_cursor_image(scp);
3794
3795 #ifndef SC_NO_HISTORY
3796         if (!(scp->status & BUFFER_SAVED)) {
3797             scp->status |= BUFFER_SAVED;
3798             sc_hist_save(scp);
3799         }
3800         switch (c) {
3801         /* FIXME: key codes */
3802         case SPCLKEY | FKEY | F(49):  /* home key */
3803             sc_remove_cutmarking(scp);
3804             sc_hist_home(scp);
3805             goto next_code;
3806
3807         case SPCLKEY | FKEY | F(57):  /* end key */
3808             sc_remove_cutmarking(scp);
3809             sc_hist_end(scp);
3810             goto next_code;
3811
3812         case SPCLKEY | FKEY | F(50):  /* up arrow key */
3813             sc_remove_cutmarking(scp);
3814             if (sc_hist_up_line(scp))
3815                 if (!(flags & SCGETC_CN))
3816                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3817             goto next_code;
3818
3819         case SPCLKEY | FKEY | F(58):  /* down arrow key */
3820             sc_remove_cutmarking(scp);
3821             if (sc_hist_down_line(scp))
3822                 if (!(flags & SCGETC_CN))
3823                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3824             goto next_code;
3825
3826         case SPCLKEY | FKEY | F(51):  /* page up key */
3827             sc_remove_cutmarking(scp);
3828             for (i=0; i<scp->ysize; i++) {
3829                 if (sc_hist_up_line(scp)) {
3830                     if (!(flags & SCGETC_CN))
3831                         sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3832                     break;
3833                 }
3834             }
3835             goto next_code;
3836
3837         case SPCLKEY | FKEY | F(59):  /* page down key */
3838             sc_remove_cutmarking(scp);
3839             for (i=0; i<scp->ysize; i++) {
3840                 if (sc_hist_down_line(scp)) {
3841                     if (!(flags & SCGETC_CN))
3842                         sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3843                     break;
3844                 }
3845             }
3846             goto next_code;
3847         }
3848 #endif /* SC_NO_HISTORY */
3849     }
3850
3851     /*
3852      * Process and consume special keys here.  Return a plain char code
3853      * or a char code with the META flag or a function key code.
3854      */
3855     if (c & RELKEY) {
3856         /* key released */
3857         /* goto next_code */
3858     } else {
3859         /* key pressed */
3860         if (c & SPCLKEY) {
3861             c &= ~SPCLKEY;
3862             switch (KEYCHAR(c)) {
3863             /* LOCKING KEYS */
3864             case NLK: case CLK: case ALK:
3865                 break;
3866             case SLK:
3867                 kbd_ioctl(sc->kbd, KDGKBSTATE, (caddr_t)&f);
3868                 if (f & SLKED) {
3869                     scp->status |= SLKED;
3870                 } else {
3871                     if (scp->status & SLKED) {
3872                         scp->status &= ~SLKED;
3873 #ifndef SC_NO_HISTORY
3874                         if (scp->status & BUFFER_SAVED) {
3875                             if (!sc_hist_restore(scp))
3876                                 sc_remove_cutmarking(scp);
3877                             scp->status &= ~BUFFER_SAVED;
3878                             scp->status |= CURSOR_ENABLED;
3879                             sc_draw_cursor_image(scp);
3880                         }
3881                         tp = VIRTUAL_TTY(sc, scp->index);
3882                         if (ISTTYOPEN(tp))
3883                             scstart(tp);
3884 #endif
3885                     }
3886                 }
3887                 break;
3888
3889             /* NON-LOCKING KEYS */
3890             case NOP:
3891             case LSH:  case RSH:  case LCTR: case RCTR:
3892             case LALT: case RALT: case ASH:  case META:
3893                 break;
3894
3895             case BTAB:
3896                 if (!(sc->flags & SC_SCRN_BLANKED)) {
3897                     lwkt_reltoken(&tty_token);
3898                     return c;
3899                 }
3900                 break;
3901
3902             case SPSC:
3903 #if NSPLASH > 0
3904                 /* force activatation/deactivation of the screen saver */
3905                 if (!(sc->flags & SC_SCRN_BLANKED)) {
3906                     run_scrn_saver = TRUE;
3907                     sc->scrn_time_stamp -= scrn_blank_time;
3908                 }
3909                 if (cold) {
3910                     /*
3911                      * While devices are being probed, the screen saver need
3912                      * to be invoked explictly. XXX
3913                      */
3914                     if (sc->flags & SC_SCRN_BLANKED) {
3915                         scsplash_stick(FALSE);
3916                         stop_scrn_saver(sc, current_saver);
3917                     } else {
3918                         if (!ISGRAPHSC(scp)) {
3919                             scsplash_stick(TRUE);
3920                             (*current_saver)(sc, TRUE);
3921                         }
3922                     }
3923                 }
3924 #endif /* NSPLASH */
3925                 break;
3926
3927             case RBT:
3928 #ifndef SC_DISABLE_REBOOT
3929                 shutdown_nice(0);
3930 #endif
3931                 break;
3932
3933             case HALT:
3934 #ifndef SC_DISABLE_REBOOT
3935                 shutdown_nice(RB_HALT);
3936 #endif
3937                 break;
3938
3939             case PDWN:
3940 #ifndef SC_DISABLE_REBOOT
3941                 shutdown_nice(RB_HALT|RB_POWEROFF);
3942 #endif
3943                 break;
3944
3945             case SUSP:
3946             case STBY:
3947                 break;
3948
3949             case DBG:
3950 #ifndef SC_DISABLE_DDBKEY
3951 #ifdef DDB
3952                 lwkt_reltoken(&tty_token);
3953                 Debugger("manual escape to debugger");
3954                 lwkt_gettoken(&tty_token);
3955 #else
3956                 kprintf("No debugger in kernel\n");
3957 #endif
3958 #else /* SC_DISABLE_DDBKEY */
3959                 /* do nothing */
3960 #endif /* SC_DISABLE_DDBKEY */
3961                 break;
3962
3963             case PNC:
3964                 if (enable_panic_key)
3965                         panic("Forced by the panic key");
3966                 break;
3967
3968             case NEXT:
3969                 this_scr = scp->index;
3970                 for (i = (this_scr - sc->first_vty + 1)%sc->vtys;
3971                         sc->first_vty + i != this_scr;
3972                         i = (i + 1)%sc->vtys) {
3973                     struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3974                     if (ISTTYOPEN(tp)) {
3975                         syscons_lock();
3976                         sc_switch_scr(scp->sc, sc->first_vty + i);
3977                         syscons_unlock();
3978                         break;
3979                     }
3980                 }
3981                 break;
3982
3983             case PREV:
3984                 this_scr = scp->index;
3985                 for (i = (this_scr - sc->first_vty + sc->vtys - 1)%sc->vtys;
3986                         sc->first_vty + i != this_scr;
3987                         i = (i + sc->vtys - 1)%sc->vtys) {
3988                     struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3989                     if (ISTTYOPEN(tp)) {
3990                         syscons_lock();
3991                         sc_switch_scr(scp->sc, sc->first_vty + i);
3992                         syscons_unlock();
3993                         break;
3994                     }
3995                 }
3996                 break;
3997
3998             default:
3999                 if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) {
4000                     syscons_lock();
4001                     sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR);
4002                     syscons_unlock();
4003                     break;
4004                 }
4005                 /* assert(c & FKEY) */
4006                 if (!(sc->flags & SC_SCRN_BLANKED)) {
4007                     lwkt_reltoken(&tty_token);
4008                     return c;
4009                 }
4010                 break;
4011             }
4012             /* goto next_code */
4013         } else {
4014             /* regular keys (maybe MKEY is set) */
4015             if (!(sc->flags & SC_SCRN_BLANKED)) {
4016                 lwkt_reltoken(&tty_token);
4017                 return c;
4018             }
4019         }
4020     }
4021
4022     goto next_code;
4023 }
4024
4025 static int
4026 scmmap(struct dev_mmap_args *ap)
4027 {
4028     scr_stat *scp;
4029
4030     lwkt_gettoken(&tty_token);
4031     scp = SC_STAT(ap->a_head.a_dev);
4032     if (scp != scp->sc->cur_scp) {
4033         lwkt_reltoken(&tty_token);
4034         return EINVAL;
4035     }
4036     if (scp->sc->fbi != NULL) {
4037         size_t sz =
4038             roundup(scp->sc->fbi->height * scp->sc->fbi->stride, PAGE_SIZE);
4039         if (ap->a_offset > sz - PAGE_SIZE) {
4040             lwkt_reltoken(&tty_token);
4041             return EINVAL;
4042         } else {
4043             ap->a_result = atop(scp->sc->fbi->paddr + ap->a_offset);
4044         }
4045     } else {
4046         ap->a_result = (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp,
4047                                                         ap->a_offset,
4048                                                         ap->a_nprot);
4049     }
4050     lwkt_reltoken(&tty_token);
4051     return(0);
4052 }
4053
4054 static int
4055 save_kbd_state(scr_stat *scp, int unlock)
4056 {
4057     int state;
4058     int error;
4059
4060     WANT_UNLOCK(unlock);
4061     error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
4062     WANT_LOCK(unlock);
4063
4064     if (error == ENOIOCTL)
4065         error = ENODEV;
4066     if (error == 0) {
4067         scp->status &= ~LOCK_MASK;
4068         scp->status |= state;
4069     }
4070     return error;
4071 }
4072
4073 static int
4074 update_kbd_state(scr_stat *scp, int new_bits, int mask, int unlock)
4075 {
4076     int state;
4077     int error;
4078
4079     if (mask != LOCK_MASK) {
4080         WANT_UNLOCK(unlock);
4081         error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
4082         WANT_LOCK(unlock);
4083
4084         if (error == ENOIOCTL)
4085             error = ENODEV;
4086         if (error) {
4087             return error;
4088         }
4089         state &= ~mask;
4090         state |= new_bits & mask;
4091     } else {
4092         state = new_bits & LOCK_MASK;
4093     }
4094     WANT_UNLOCK(unlock);
4095     error = kbd_ioctl(scp->sc->kbd, KDSKBSTATE, (caddr_t)&state);
4096     WANT_LOCK(unlock);
4097     if (error == ENOIOCTL)
4098         error = ENODEV;
4099     return error;
4100 }
4101
4102 static int
4103 update_kbd_leds(scr_stat *scp, int which)
4104 {
4105     int error;
4106
4107     which &= LOCK_MASK;
4108     error = kbd_ioctl(scp->sc->kbd, KDSETLED, (caddr_t)&which);
4109     if (error == ENOIOCTL)
4110         error = ENODEV;
4111     return error;
4112 }
4113
4114 int
4115 set_mode(scr_stat *scp)
4116 {
4117     video_info_t info;
4118
4119     lwkt_gettoken(&tty_token);
4120     /* reject unsupported mode */
4121     if (scp->sc->fbi == NULL && (*vidsw[scp->sc->adapter]->get_info)(scp->sc->adp, scp->mode, &info)) {
4122         lwkt_reltoken(&tty_token);
4123         return 1;
4124     }
4125
4126     /* if this vty is not currently showing, do nothing */
4127     if (scp != scp->sc->cur_scp) {
4128         lwkt_reltoken(&tty_token);
4129         return 0;
4130     }
4131
4132     /* setup video hardware for the given mode */
4133     if (scp->sc->fbi == NULL) {
4134         (*vidsw[scp->sc->adapter]->set_mode)(scp->sc->adp, scp->mode);
4135         sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
4136                     (void *)scp->sc->adp->va_window, FALSE);
4137     } else {
4138         goto done;
4139     }
4140
4141 #ifndef SC_NO_FONT_LOADING
4142     /* load appropriate font */
4143     if (!(scp->status & GRAPHICS_MODE)) {
4144         if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) {
4145             if (scp->font_height < 14) {
4146                 if (scp->sc->fonts_loaded & FONT_8)
4147                     sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256);
4148             } else if (scp->font_height >= 16) {
4149                 if (scp->sc->fonts_loaded & FONT_16)
4150                     sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256);
4151             } else {
4152                 if (scp->sc->fonts_loaded & FONT_14)
4153                     sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256);
4154             }
4155             /*
4156              * FONT KLUDGE:
4157              * This is an interim kludge to display correct font.
4158              * Always use the font page #0 on the video plane 2.
4159              * Somehow we cannot show the font in other font pages on
4160              * some video cards... XXX
4161              */
4162             sc_show_font(scp, 0);
4163         }
4164         mark_all(scp);
4165     }
4166 #endif /* !SC_NO_FONT_LOADING */
4167
4168     sc_set_border(scp, scp->border);
4169     sc_set_cursor_image(scp);
4170
4171 done:
4172     lwkt_reltoken(&tty_token);
4173     return 0;
4174 }
4175
4176 void
4177 refresh_ega_palette(scr_stat *scp)
4178 {
4179     uint32_t r, g, b;
4180     int reg;
4181     int rsize, gsize, bsize;
4182     int rfld, gfld, bfld;
4183     int i;
4184
4185     rsize = scp->sc->adp->va_info.vi_pixel_fsizes[0];
4186     gsize = scp->sc->adp->va_info.vi_pixel_fsizes[1];
4187     bsize = scp->sc->adp->va_info.vi_pixel_fsizes[2];
4188     rfld = scp->sc->adp->va_info.vi_pixel_fields[0];
4189     gfld = scp->sc->adp->va_info.vi_pixel_fields[1];
4190     bfld = scp->sc->adp->va_info.vi_pixel_fields[2];
4191
4192     for (i = 0; i < 16; i++) {
4193         reg = scp->sc->adp->va_palette_regs[i];
4194
4195         r = scp->sc->palette[reg * 3] >> (8 - rsize);
4196         g = scp->sc->palette[reg * 3 + 1] >> (8 - gsize);
4197         b = scp->sc->palette[reg * 3 + 2] >> (8 - bsize);
4198
4199         scp->ega_palette[i] = (r << rfld) + (g << gfld) + (b << bfld);
4200     }
4201 }
4202
4203 void
4204 sc_set_border(scr_stat *scp, int color)
4205 {
4206     atomic_add_int(&scp->sc->videoio_in_progress, 1);
4207     (*scp->rndr->draw_border)(scp, color);
4208     atomic_add_int(&scp->sc->videoio_in_progress, -1);
4209 }
4210
4211 #ifndef SC_NO_FONT_LOADING
4212 void
4213 sc_load_font(scr_stat *scp, int page, int size, u_char *buf,
4214              int base, int count)
4215 {
4216     sc_softc_t *sc;
4217
4218     sc = scp->sc;
4219     sc->font_loading_in_progress = TRUE;
4220     (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count);
4221     sc->font_loading_in_progress = FALSE;
4222 }
4223
4224 void
4225 sc_save_font(scr_stat *scp, int page, int size, u_char *buf,
4226              int base, int count)
4227 {
4228     sc_softc_t *sc;
4229
4230     sc = scp->sc;
4231     sc->font_loading_in_progress = TRUE;
4232     (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count);
4233     sc->font_loading_in_progress = FALSE;
4234 }
4235
4236 void
4237 sc_show_font(scr_stat *scp, int page)
4238 {
4239     (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page);
4240 }
4241 #endif /* !SC_NO_FONT_LOADING */
4242
4243 void
4244 sc_paste(scr_stat *scp, u_char *p, int count)
4245 {
4246     struct tty *tp;
4247     u_char *rmap;
4248
4249     /*
4250      * Holy hell, don't try to inject a paste buffer if the keyboard
4251      * is not in ascii mode!
4252      */
4253     if (scp->kbd_mode != K_XLATE)
4254         return;
4255
4256     lwkt_gettoken(&tty_token);
4257     if (scp->status & MOUSE_VISIBLE) {
4258         tp = VIRTUAL_TTY(scp->sc, scp->sc->cur_scp->index);
4259         if (!ISTTYOPEN(tp)) {
4260             lwkt_reltoken(&tty_token);
4261             return;
4262         }
4263         rmap = scp->sc->scr_rmap;
4264         for (; count > 0; --count)
4265             (*linesw[tp->t_line].l_rint)(rmap[*p++], tp);
4266     }
4267     lwkt_reltoken(&tty_token);
4268 }
4269
4270 void
4271 sc_bell(scr_stat *scp, int pitch, int duration)
4272 {
4273     if (cold || shutdown_in_progress)
4274         return;
4275
4276     if (scp != scp->sc->cur_scp && (scp->sc->flags & SC_QUIET_BELL)) {
4277         return;
4278     }
4279
4280     if (scp->sc->flags & SC_VISUAL_BELL) {
4281         if (scp->sc->blink_in_progress) {
4282             return;
4283         }
4284         scp->sc->blink_in_progress = 3;
4285         if (scp != scp->sc->cur_scp)
4286             scp->sc->blink_in_progress += 2;
4287         sc_blink_screen(scp->sc->cur_scp);
4288     } else if (duration != 0 && pitch != 0) {
4289         if (scp != scp->sc->cur_scp)
4290             pitch *= 2;
4291         sysbeep(pitch, duration);
4292     }
4293 }
4294
4295 /*
4296  * Two versions of blink_screen(), one called from the console path
4297  * with the syscons locked, and one called from a timer callout.
4298  */
4299 static void
4300 sc_blink_screen(scr_stat *scp)
4301 {
4302     if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
4303         scp->sc->blink_in_progress = 0;
4304         mark_all(scp);
4305         if (scp->sc->delayed_next_scr)
4306             sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
4307     } else {
4308         (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
4309                            scp->sc->blink_in_progress & 1);
4310         scp->sc->blink_in_progress--;
4311     }
4312 }
4313
4314 #if 0
4315 static void
4316 blink_screen_callout(void *arg)
4317 {
4318     scr_stat *scp = arg;
4319     struct tty *tp;
4320
4321     if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
4322         syscons_lock();
4323         scp->sc->blink_in_progress = 0;
4324         mark_all(scp);
4325         syscons_unlock();
4326         tp = VIRTUAL_TTY(scp->sc, scp->index);
4327         if (ISTTYOPEN(tp))
4328             scstart(tp);
4329         if (scp->sc->delayed_next_scr) {
4330             syscons_lock();
4331             sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
4332             syscons_unlock();
4333         }
4334     } else {
4335         syscons_lock();
4336         (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
4337                            scp->sc->blink_in_progress & 1);
4338         scp->sc->blink_in_progress--;
4339         syscons_unlock();
4340         callout_reset(&scp->blink_screen_ch, hz / 10,
4341                       blink_screen_callout, scp);
4342     }
4343 }
4344 #endif
4345
4346 /*
4347  * Allocate active keyboard. Try to allocate "kbdmux" keyboard first, and,
4348  * if found, add all non-busy keyboards to "kbdmux". Otherwise look for
4349  * any keyboard.
4350  */
4351
4352 static int
4353 sc_allocate_keyboard(sc_softc_t *sc, int unit)
4354 {
4355         int              idx0, idx;
4356         keyboard_t      *k0, *k;
4357         keyboard_info_t  ki;
4358
4359         idx0 = kbd_allocate("kbdmux", -1, (void *)&sc->keyboard, sckbdevent, sc);
4360         if (idx0 != -1) {
4361                 k0 = kbd_get_keyboard(idx0);
4362
4363                 for (idx = kbd_find_keyboard2("*", -1, 0, 0);
4364                      idx != -1;
4365                      idx = kbd_find_keyboard2("*", -1, idx + 1, 0)) {
4366                         k = kbd_get_keyboard(idx);
4367
4368                         if (idx == idx0 || KBD_IS_BUSY(k))
4369                                 continue;
4370
4371                         bzero(&ki, sizeof(ki));
4372                         strcpy(ki.kb_name, k->kb_name);
4373                         ki.kb_unit = k->kb_unit;
4374
4375                         kbd_ioctl(k0, KBADDKBD, (caddr_t) &ki);
4376                 }
4377         } else
4378                 idx0 = kbd_allocate("*", unit, (void *)&sc->keyboard, sckbdevent, sc);
4379
4380         return (idx0);
4381 }