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