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