sys/dev/misc/syscons/syscons.c

   1 /*-
   2  * Copyright (c) 1992-1998 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/dev/syscons/syscons.c,v 1.336.2.15 2002/10/24 00:35:31 kbyanc Exp $
  29  * $DragonFly: src/sys/dev/misc/syscons/syscons.c,v 1.2 2003/06/17 04:28:32 dillon Exp $
  30  */
  31
  32 #include "splash.h"
  33 #include "opt_syscons.h"
  34 #include "opt_ddb.h"
  35 #ifdef __i386__
  36 #include "apm.h"
  37 #endif
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/eventhandler.h>
  42 #include <sys/reboot.h>
  43 #include <sys/conf.h>
  44 #include <sys/proc.h>
  45 #include <sys/signalvar.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/tty.h>
  48 #include <sys/kernel.h>
  49 #include <sys/malloc.h>
  50 #include <sys/cons.h>
  51 #include <sys/random.h>
  52
  53 #include <machine/clock.h>
  54 #include <machine/console.h>
  55 #include <machine/psl.h>
  56 #include <machine/pc/display.h>
  57 #ifdef __i386__
  58 #include <machine/apm_bios.h>
  59 #include <machine/frame.h>
  60 #endif
  61
  62 #include <dev/kbd/kbdreg.h>
  63 #include <dev/fb/fbreg.h>
  64 #include <dev/fb/splashreg.h>
  65 #include <dev/syscons/syscons.h>
  66
  67 #define COLD 0
  68 #define WARM 1
  69
  70 #define DEFAULT_BLANKTIME       (5*60)          /* 5 minutes */
  71 #define MAX_BLANKTIME           (7*24*60*60)    /* 7 days!? */
  72
  73 #define KEYCODE_BS              0x0e            /* "<-- Backspace" key, XXX */
  74
  75 typedef struct default_attr {
  76         int             std_color;              /* normal hardware color */
  77         int             rev_color;              /* reverse hardware color */
  78 } default_attr;
  79
  80 static default_attr user_default = {
  81     SC_NORM_ATTR,
  82     SC_NORM_REV_ATTR,
  83 };
  84
  85 static default_attr kernel_default = {
  86     SC_KERNEL_CONS_ATTR,
  87     SC_KERNEL_CONS_REV_ATTR,
  88 };
  89
  90 static  int             sc_console_unit = -1;
  91 static  scr_stat        *sc_console;
  92 static  struct tty      *sc_console_tty;
  93 static  void            *kernel_console_ts;
  94
  95 static  char            init_done = COLD;
  96 static  char            shutdown_in_progress = FALSE;
  97 static  char            sc_malloc = FALSE;
  98
  99 static  int             saver_mode = CONS_NO_SAVER; /* LKM/user saver */
 100 static  int             run_scrn_saver = FALSE; /* should run the saver? */
 101 static  long            scrn_blank_time = 0;    /* screen saver timeout value */
 102 #if NSPLASH > 0
 103 static  int             scrn_blanked;           /* # of blanked screen */
 104 static  int             sticky_splash = FALSE;
 105
 106 static  void            none_saver(sc_softc_t *sc, int blank) { }
 107 static  void            (*current_saver)(sc_softc_t *, int) = none_saver;
 108 #endif
 109
 110 #if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT)
 111 #include "font.h"
 112 #endif
 113
 114         d_ioctl_t       *sc_user_ioctl;
 115
 116 static  bios_values_t   bios_value;
 117
 118 static  int             enable_panic_key;
 119 SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key,
 120            0, "");
 121
 122 #define SC_CONSOLECTL   255
 123
 124 #define VIRTUAL_TTY(sc, x) (SC_DEV((sc), (x)) != NULL ? \
 125         SC_DEV((sc), (x))->si_tty : NULL)
 126 #define ISTTYOPEN(tp)   ((tp) && ((tp)->t_state & TS_ISOPEN))
 127
 128 static  int             debugger;
 129
 130 /* prototypes */
 131 static int scvidprobe(int unit, int flags, int cons);
 132 static int sckbdprobe(int unit, int flags, int cons);
 133 static void scmeminit(void *arg);
 134 static int scdevtounit(dev_t dev);
 135 static kbd_callback_func_t sckbdevent;
 136 static int scparam(struct tty *tp, struct termios *t);
 137 static void scstart(struct tty *tp);
 138 static void scinit(int unit, int flags);
 139 #if __i386__
 140 static void scterm(int unit, int flags);
 141 #endif
 142 static void scshutdown(void *arg, int howto);
 143 static u_int scgetc(sc_softc_t *sc, u_int flags);
 144 #define SCGETC_CN       1
 145 #define SCGETC_NONBLOCK 2
 146 static int sccngetch(int flags);
 147 static void sccnupdate(scr_stat *scp);
 148 static scr_stat *alloc_scp(sc_softc_t *sc, int vty);
 149 static void init_scp(sc_softc_t *sc, int vty, scr_stat *scp);
 150 static timeout_t scrn_timer;
 151 static int and_region(int *s1, int *e1, int s2, int e2);
 152 static void scrn_update(scr_stat *scp, int show_cursor);
 153
 154 #if NSPLASH > 0
 155 static int scsplash_callback(int event, void *arg);
 156 static void scsplash_saver(sc_softc_t *sc, int show);
 157 static int add_scrn_saver(void (*this_saver)(sc_softc_t *, int));
 158 static int remove_scrn_saver(void (*this_saver)(sc_softc_t *, int));
 159 static int set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border);
 160 static int restore_scrn_saver_mode(scr_stat *scp, int changemode);
 161 static void stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int));
 162 static int wait_scrn_saver_stop(sc_softc_t *sc);
 163 #define scsplash_stick(stick)           (sticky_splash = (stick))
 164 #else /* !NSPLASH */
 165 #define scsplash_stick(stick)
 166 #endif /* NSPLASH */
 167
 168 static int do_switch_scr(sc_softc_t *sc, int s);
 169 static int vt_proc_alive(scr_stat *scp);
 170 static int signal_vt_rel(scr_stat *scp);
 171 static int signal_vt_acq(scr_stat *scp);
 172 static int finish_vt_rel(scr_stat *scp, int release, int *s);
 173 static int finish_vt_acq(scr_stat *scp);
 174 static void exchange_scr(sc_softc_t *sc);
 175 static void update_cursor_image(scr_stat *scp);
 176 static int save_kbd_state(scr_stat *scp);
 177 static int update_kbd_state(scr_stat *scp, int state, int mask);
 178 static int update_kbd_leds(scr_stat *scp, int which);
 179 static timeout_t blink_screen;
 180
 181 #define CDEV_MAJOR      12
 182
 183 static cn_probe_t       sccnprobe;
 184 static cn_init_t        sccninit;
 185 static cn_getc_t        sccngetc;
 186 static cn_checkc_t      sccncheckc;
 187 static cn_putc_t        sccnputc;
 188 static cn_dbctl_t       sccndbctl;
 189 static cn_term_t        sccnterm;
 190
 191 #if __alpha__
 192 void sccnattach(void);
 193 #endif
 194
 195 CONS_DRIVER(sc, sccnprobe, sccninit, sccnterm, sccngetc, sccncheckc, sccnputc,
 196             sccndbctl);
 197
 198 static  d_open_t        scopen;
 199 static  d_close_t       scclose;
 200 static  d_read_t        scread;
 201 static  d_ioctl_t       scioctl;
 202 static  d_mmap_t        scmmap;
 203
 204 static struct cdevsw sc_cdevsw = {
 205         /* open */      scopen,
 206         /* close */     scclose,
 207         /* read */      scread,
 208         /* write */     ttywrite,
 209         /* ioctl */     scioctl,
 210         /* poll */      ttypoll,
 211         /* mmap */      scmmap,
 212         /* strategy */  nostrategy,
 213         /* name */      "sc",
 214         /* maj */       CDEV_MAJOR,
 215         /* dump */      nodump,
 216         /* psize */     nopsize,
 217         /* flags */     D_TTY | D_KQFILTER,
 218         /* bmaj */      -1,
 219         /* kqfilter */  ttykqfilter
 220 };
 221
 222 int
 223 sc_probe_unit(int unit, int flags)
 224 {
 225     if (!scvidprobe(unit, flags, FALSE)) {
 226         if (bootverbose)
 227             printf("sc%d: no video adapter found.\n", unit);
 228         return ENXIO;
 229     }
 230
 231     /* syscons will be attached even when there is no keyboard */
 232     sckbdprobe(unit, flags, FALSE);
 233
 234     return 0;
 235 }
 236
 237 /* probe video adapters, return TRUE if found */
 238 static int
 239 scvidprobe(int unit, int flags, int cons)
 240 {
 241     /*
 242      * Access the video adapter driver through the back door!
 243      * Video adapter drivers need to be configured before syscons.
 244      * However, when syscons is being probed as the low-level console,
 245      * they have not been initialized yet.  We force them to initialize
 246      * themselves here. XXX
 247      */
 248     vid_configure(cons ? VIO_PROBE_ONLY : 0);
 249
 250     return (vid_find_adapter("*", unit) >= 0);
 251 }
 252
 253 /* probe the keyboard, return TRUE if found */
 254 static int
 255 sckbdprobe(int unit, int flags, int cons)
 256 {
 257     /* access the keyboard driver through the backdoor! */
 258     kbd_configure(cons ? KB_CONF_PROBE_ONLY : 0);
 259
 260     return (kbd_find_keyboard("*", unit) >= 0);
 261 }
 262
 263 static char
 264 *adapter_name(video_adapter_t *adp)
 265 {
 266     static struct {
 267         int type;
 268         char *name[2];
 269     } names[] = {
 270         { KD_MONO,      { "MDA",        "MDA" } },
 271         { KD_HERCULES,  { "Hercules",   "Hercules" } },
 272         { KD_CGA,       { "CGA",        "CGA" } },
 273         { KD_EGA,       { "EGA",        "EGA (mono)" } },
 274         { KD_VGA,       { "VGA",        "VGA (mono)" } },
 275         { KD_PC98,      { "PC-98x1",    "PC-98x1" } },
 276         { KD_TGA,       { "TGA",        "TGA" } },
 277         { -1,           { "Unknown",    "Unknown" } },
 278     };
 279     int i;
 280
 281     for (i = 0; names[i].type != -1; ++i)
 282         if (names[i].type == adp->va_type)
 283             break;
 284     return names[i].name[(adp->va_flags & V_ADP_COLOR) ? 0 : 1];
 285 }
 286
 287 int
 288 sc_attach_unit(int unit, int flags)
 289 {
 290     sc_softc_t *sc;
 291     scr_stat *scp;
 292 #ifdef SC_PIXEL_MODE
 293     video_info_t info;
 294 #endif
 295     int vc;
 296     dev_t dev;
 297
 298     flags &= ~SC_KERNEL_CONSOLE;
 299
 300     if (sc_console_unit == unit) {
 301         /*
 302          * If this unit is being used as the system console, we need to
 303          * adjust some variables and buffers before and after scinit().
 304          */
 305         /* assert(sc_console != NULL) */
 306         flags |= SC_KERNEL_CONSOLE;
 307         scmeminit(NULL);
 308
 309         scinit(unit, flags);
 310
 311         if (sc_console->tsw->te_size > 0) {
 312             /* assert(sc_console->ts != NULL); */
 313             kernel_console_ts = sc_console->ts;
 314             sc_console->ts = malloc(sc_console->tsw->te_size,
 315                                     M_DEVBUF, M_WAITOK);
 316             bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size);
 317             (*sc_console->tsw->te_default_attr)(sc_console,
 318                                                 user_default.std_color,
 319                                                 user_default.rev_color);
 320         }
 321     } else {
 322         scinit(unit, flags);
 323     }
 324
 325     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
 326     sc->config = flags;
 327     scp = SC_STAT(sc->dev[0]);
 328     if (sc_console == NULL)     /* sc_console_unit < 0 */
 329         sc_console = scp;
 330
 331 #ifdef SC_PIXEL_MODE
 332     if ((sc->config & SC_VESA800X600)
 333         && ((*vidsw[sc->adapter]->get_info)(sc->adp, M_VESA_800x600, &info) == 0)) {
 334 #if NSPLASH > 0
 335         if (sc->flags & SC_SPLASH_SCRN)
 336             splash_term(sc->adp);
 337 #endif
 338         sc_set_graphics_mode(scp, NULL, M_VESA_800x600);
 339         sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
 340         sc->initial_mode = M_VESA_800x600;
 341 #if NSPLASH > 0
 342         /* put up the splash again! */
 343         if (sc->flags & SC_SPLASH_SCRN)
 344             splash_init(sc->adp, scsplash_callback, sc);
 345 #endif
 346     }
 347 #endif /* SC_PIXEL_MODE */
 348
 349     /* initialize cursor */
 350     if (!ISGRAPHSC(scp))
 351         update_cursor_image(scp);
 352
 353     /* get screen update going */
 354     scrn_timer(sc);
 355
 356     /* set up the keyboard */
 357     kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
 358     update_kbd_state(scp, scp->status, LOCK_MASK);
 359
 360     printf("sc%d: %s <%d virtual consoles, flags=0x%x>\n",
 361            unit, adapter_name(sc->adp), sc->vtys, sc->config);
 362     if (bootverbose) {
 363         printf("sc%d:", unit);
 364         if (sc->adapter >= 0)
 365             printf(" fb%d", sc->adapter);
 366         if (sc->keyboard >= 0)
 367             printf(", kbd%d", sc->keyboard);
 368         if (scp->tsw)
 369             printf(", terminal emulator: %s (%s)",
 370                    scp->tsw->te_name, scp->tsw->te_desc);
 371         printf("\n");
 372     }
 373
 374     /* register a shutdown callback for the kernel console */
 375     if (sc_console_unit == unit)
 376         EVENTHANDLER_REGISTER(shutdown_pre_sync, scshutdown,
 377                               (void *)(uintptr_t)unit, SHUTDOWN_PRI_DEFAULT);
 378
 379     for (vc = 0; vc < sc->vtys; vc++) {
 380         dev = make_dev(&sc_cdevsw, vc + unit * MAXCONS,
 381             UID_ROOT, GID_WHEEL, 0600, "ttyv%r", vc + unit * MAXCONS);
 382         sc->dev[vc] = dev;
 383         /*
 384          * The first vty already has struct tty and scr_stat initialized
 385          * in scinit().  The other vtys will have these structs when
 386          * first opened.
 387          */
 388     }
 389
 390     dev = make_dev(&sc_cdevsw, SC_CONSOLECTL,
 391                    UID_ROOT, GID_WHEEL, 0600, "consolectl");
 392     dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty);
 393     SC_STAT(dev) = sc_console;
 394
 395     return 0;
 396 }
 397
 398 static void
 399 scmeminit(void *arg)
 400 {
 401     if (sc_malloc)
 402         return;
 403     sc_malloc = TRUE;
 404
 405     /*
 406      * As soon as malloc() becomes functional, we had better allocate
 407      * various buffers for the kernel console.
 408      */
 409
 410     if (sc_console_unit < 0)    /* sc_console == NULL */
 411         return;
 412
 413     /* copy the temporary buffer to the final buffer */
 414     sc_alloc_scr_buffer(sc_console, FALSE, FALSE);
 415
 416 #ifndef SC_NO_CUTPASTE
 417     sc_alloc_cut_buffer(sc_console, FALSE);
 418 #endif
 419
 420 #ifndef SC_NO_HISTORY
 421     /* initialize history buffer & pointers */
 422     sc_alloc_history_buffer(sc_console, 0, 0, FALSE);
 423 #endif
 424 }
 425
 426 /* XXX */
 427 SYSINIT(sc_mem, SI_SUB_KMEM, SI_ORDER_ANY, scmeminit, NULL);
 428
 429 static int
 430 scdevtounit(dev_t dev)
 431 {
 432     int vty = SC_VTY(dev);
 433
 434     if (vty == SC_CONSOLECTL)
 435         return ((sc_console != NULL) ? sc_console->sc->unit : -1);
 436     else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit()))
 437         return -1;
 438     else
 439         return vty/MAXCONS;
 440 }
 441
 442 int
 443 scopen(dev_t dev, int flag, int mode, struct proc *p)
 444 {
 445     int unit = scdevtounit(dev);
 446     sc_softc_t *sc;
 447     struct tty *tp;
 448     scr_stat *scp;
 449     keyarg_t key;
 450     int error;
 451
 452     DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n",
 453                 major(dev), minor(dev), unit, SC_VTY(dev)));
 454
 455     sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0);
 456     if (sc == NULL)
 457         return ENXIO;
 458
 459     tp = dev->si_tty = ttymalloc(dev->si_tty);
 460     tp->t_oproc = scstart;
 461     tp->t_param = scparam;
 462     tp->t_stop = nottystop;
 463     tp->t_dev = dev;
 464     if (!ISTTYOPEN(tp)) {
 465         ttychars(tp);
 466         /* Use the current setting of the <-- key as default VERASE. */
 467         /* If the Delete key is preferable, an stty is necessary     */
 468         if (sc->kbd != NULL) {
 469             key.keynum = KEYCODE_BS;
 470             kbd_ioctl(sc->kbd, GIO_KEYMAPENT, (caddr_t)&key);
 471             tp->t_cc[VERASE] = key.key.map[0];
 472         }
 473         tp->t_iflag = TTYDEF_IFLAG;
 474         tp->t_oflag = TTYDEF_OFLAG;
 475         tp->t_cflag = TTYDEF_CFLAG;
 476         tp->t_lflag = TTYDEF_LFLAG;
 477         tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
 478         scparam(tp, &tp->t_termios);
 479         (*linesw[tp->t_line].l_modem)(tp, 1);
 480     }
 481     else
 482         if (tp->t_state & TS_XCLUDE && suser(p))
 483             return(EBUSY);
 484
 485     error = (*linesw[tp->t_line].l_open)(dev, tp);
 486
 487     scp = SC_STAT(dev);
 488     if (scp == NULL) {
 489         scp = SC_STAT(dev) = alloc_scp(sc, SC_VTY(dev));
 490         if (ISGRAPHSC(scp))
 491             sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
 492     }
 493     if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) {
 494         tp->t_winsize.ws_col = scp->xsize;
 495         tp->t_winsize.ws_row = scp->ysize;
 496     }
 497
 498     return error;
 499 }
 500
 501 int
 502 scclose(dev_t dev, int flag, int mode, struct proc *p)
 503 {
 504     struct tty *tp = dev->si_tty;
 505     scr_stat *scp;
 506     int s;
 507
 508     if (SC_VTY(dev) != SC_CONSOLECTL) {
 509         scp = SC_STAT(tp->t_dev);
 510         /* were we in the middle of the VT switching process? */
 511         DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit));
 512         s = spltty();
 513         if ((scp == scp->sc->cur_scp) && (scp->sc->unit == sc_console_unit))
 514             cons_unavail = FALSE;
 515         if (finish_vt_rel(scp, TRUE, &s) == 0)  /* force release */
 516             DPRINTF(5, ("reset WAIT_REL, "));
 517         if (finish_vt_acq(scp) == 0)            /* force acknowledge */
 518             DPRINTF(5, ("reset WAIT_ACQ, "));
 519 #if not_yet_done
 520         if (scp == &main_console) {
 521             scp->pid = 0;
 522             scp->proc = NULL;
 523             scp->smode.mode = VT_AUTO;
 524         }
 525         else {
 526             sc_vtb_destroy(&scp->vtb);
 527             sc_vtb_destroy(&scp->scr);
 528             sc_free_history_buffer(scp, scp->ysize);
 529             SC_STAT(dev) = NULL;
 530             free(scp, M_DEVBUF);
 531         }
 532 #else
 533         scp->pid = 0;
 534         scp->proc = NULL;
 535         scp->smode.mode = VT_AUTO;
 536 #endif
 537         scp->kbd_mode = K_XLATE;
 538         if (scp == scp->sc->cur_scp)
 539             kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
 540         DPRINTF(5, ("done.\n"));
 541     }
 542     spltty();
 543     (*linesw[tp->t_line].l_close)(tp, flag);
 544     ttyclose(tp);
 545     spl0();
 546     return(0);
 547 }
 548
 549 int
 550 scread(dev_t dev, struct uio *uio, int flag)
 551 {
 552     sc_touch_scrn_saver();
 553     return ttyread(dev, uio, flag);
 554 }
 555
 556 static int
 557 sckbdevent(keyboard_t *thiskbd, int event, void *arg)
 558 {
 559     sc_softc_t *sc;
 560     struct tty *cur_tty;
 561     int c;
 562     size_t len;
 563     u_char *cp;
 564
 565     sc = (sc_softc_t *)arg;
 566     /* assert(thiskbd == sc->kbd) */
 567
 568     switch (event) {
 569     case KBDIO_KEYINPUT:
 570         break;
 571     case KBDIO_UNLOADING:
 572         sc->kbd = NULL;
 573         sc->keyboard = -1;
 574         kbd_release(thiskbd, (void *)&sc->keyboard);
 575         return 0;
 576     default:
 577         return EINVAL;
 578     }
 579
 580     /*
 581      * Loop while there is still input to get from the keyboard.
 582      * I don't think this is nessesary, and it doesn't fix
 583      * the Xaccel-2.1 keyboard hang, but it can't hurt.         XXX
 584      */
 585     while ((c = scgetc(sc, SCGETC_NONBLOCK)) != NOKEY) {
 586
 587         cur_tty = VIRTUAL_TTY(sc, sc->cur_scp->index);
 588         if (!ISTTYOPEN(cur_tty)) {
 589             cur_tty = sc_console_tty;
 590             if (!ISTTYOPEN(cur_tty))
 591                 continue;
 592         }
 593
 594         if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty))
 595             continue;
 596
 597         switch (KEYFLAGS(c)) {
 598         case 0x0000: /* normal key */
 599             (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
 600             break;
 601         case FKEY:  /* function key, return string */
 602             cp = kbd_get_fkeystr(thiskbd, KEYCHAR(c), &len);
 603             if (cp != NULL) {
 604                 while (len-- >  0)
 605                     (*linesw[cur_tty->t_line].l_rint)(*cp++, cur_tty);
 606             }
 607             break;
 608         case MKEY:  /* meta is active, prepend ESC */
 609             (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
 610             (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
 611             break;
 612         case BKEY:  /* backtab fixed sequence (esc [ Z) */
 613             (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
 614             (*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
 615             (*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
 616             break;
 617         }
 618     }
 619
 620     sc->cur_scp->status |= MOUSE_HIDDEN;
 621
 622     return 0;
 623 }
 624
 625 static int
 626 scparam(struct tty *tp, struct termios *t)
 627 {
 628     tp->t_ispeed = t->c_ispeed;
 629     tp->t_ospeed = t->c_ospeed;
 630     tp->t_cflag = t->c_cflag;
 631     return 0;
 632 }
 633
 634 int
 635 scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 636 {
 637     int error;
 638     int i;
 639     struct tty *tp;
 640     sc_softc_t *sc;
 641     scr_stat *scp;
 642     int s;
 643
 644     tp = dev->si_tty;
 645
 646     /* If there is a user_ioctl function call that first */
 647     if (sc_user_ioctl) {
 648         error = (*sc_user_ioctl)(dev, cmd, data, flag, p);
 649         if (error != ENOIOCTL)
 650             return error;
 651     }
 652
 653     error = sc_vid_ioctl(tp, cmd, data, flag, p);
 654     if (error != ENOIOCTL)
 655         return error;
 656
 657 #ifndef SC_NO_HISTORY
 658     error = sc_hist_ioctl(tp, cmd, data, flag, p);
 659     if (error != ENOIOCTL)
 660         return error;
 661 #endif
 662
 663 #ifndef SC_NO_SYSMOUSE
 664     error = sc_mouse_ioctl(tp, cmd, data, flag, p);
 665     if (error != ENOIOCTL)
 666         return error;
 667 #endif
 668
 669     scp = SC_STAT(tp->t_dev);
 670     /* assert(scp != NULL) */
 671     /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */
 672     sc = scp->sc;
 673
 674     if (scp->tsw) {
 675         error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, p);
 676         if (error != ENOIOCTL)
 677             return error;
 678     }
 679
 680     switch (cmd) {              /* process console hardware related ioctl's */
 681
 682     case GIO_ATTR:              /* get current attributes */
 683         /* this ioctl is not processed here, but in the terminal emulator */
 684         return ENOTTY;
 685
 686     case GIO_COLOR:             /* is this a color console ? */
 687         *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0;
 688         return 0;
 689
 690     case CONS_BLANKTIME:        /* set screen saver timeout (0 = no saver) */
 691         if (*(int *)data < 0 || *(int *)data > MAX_BLANKTIME)
 692             return EINVAL;
 693         s = spltty();
 694         scrn_blank_time = *(int *)data;
 695         run_scrn_saver = (scrn_blank_time != 0);
 696         splx(s);
 697         return 0;
 698
 699     case CONS_CURSORTYPE:       /* set cursor type blink/noblink */
 700         s = spltty();
 701         if (!ISGRAPHSC(sc->cur_scp))
 702             sc_remove_cursor_image(sc->cur_scp);
 703         if ((*(int*)data) & 0x01)
 704             sc->flags |= SC_BLINK_CURSOR;
 705         else
 706             sc->flags &= ~SC_BLINK_CURSOR;
 707         if ((*(int*)data) & 0x02) {
 708             sc->flags |= SC_CHAR_CURSOR;
 709         } else
 710             sc->flags &= ~SC_CHAR_CURSOR;
 711         /*
 712          * The cursor shape is global property; all virtual consoles
 713          * are affected. Update the cursor in the current console...
 714          */
 715         if (!ISGRAPHSC(sc->cur_scp)) {
 716             sc_set_cursor_image(sc->cur_scp);
 717             sc_draw_cursor_image(sc->cur_scp);
 718         }
 719         splx(s);
 720         return 0;
 721
 722     case CONS_BELLTYPE:         /* set bell type sound/visual */
 723         if ((*(int *)data) & 0x01)
 724             sc->flags |= SC_VISUAL_BELL;
 725         else
 726             sc->flags &= ~SC_VISUAL_BELL;
 727         if ((*(int *)data) & 0x02)
 728             sc->flags |= SC_QUIET_BELL;
 729         else
 730             sc->flags &= ~SC_QUIET_BELL;
 731         return 0;
 732
 733     case CONS_GETINFO:          /* get current (virtual) console info */
 734     {
 735         vid_info_t *ptr = (vid_info_t*)data;
 736         if (ptr->size == sizeof(struct vid_info)) {
 737             ptr->m_num = sc->cur_scp->index;
 738             ptr->font_size = scp->font_size;
 739             ptr->mv_col = scp->xpos;
 740             ptr->mv_row = scp->ypos;
 741             ptr->mv_csz = scp->xsize;
 742             ptr->mv_rsz = scp->ysize;
 743             /*
 744              * The following fields are filled by the terminal emulator. XXX
 745              *
 746              * ptr->mv_norm.fore
 747              * ptr->mv_norm.back
 748              * ptr->mv_rev.fore
 749              * ptr->mv_rev.back
 750              */
 751             ptr->mv_grfc.fore = 0;      /* not supported */
 752             ptr->mv_grfc.back = 0;      /* not supported */
 753             ptr->mv_ovscan = scp->border;
 754             if (scp == sc->cur_scp)
 755                 save_kbd_state(scp);
 756             ptr->mk_keylock = scp->status & LOCK_MASK;
 757             return 0;
 758         }
 759         return EINVAL;
 760     }
 761
 762     case CONS_GETVERS:          /* get version number */
 763         *(int*)data = 0x200;    /* version 2.0 */
 764         return 0;
 765
 766     case CONS_IDLE:             /* see if the screen has been idle */
 767         /*
 768          * When the screen is in the GRAPHICS_MODE or UNKNOWN_MODE,
 769          * the user process may have been writing something on the
 770          * screen and syscons is not aware of it. Declare the screen
 771          * is NOT idle if it is in one of these modes. But there is
 772          * an exception to it; if a screen saver is running in the
 773          * graphics mode in the current screen, we should say that the
 774          * screen has been idle.
 775          */
 776         *(int *)data = (sc->flags & SC_SCRN_IDLE)
 777                        && (!ISGRAPHSC(sc->cur_scp)
 778                            || (sc->cur_scp->status & SAVER_RUNNING));
 779         return 0;
 780
 781     case CONS_SAVERMODE:        /* set saver mode */
 782         switch(*(int *)data) {
 783         case CONS_NO_SAVER:
 784         case CONS_USR_SAVER:
 785             /* if a LKM screen saver is running, stop it first. */
 786             scsplash_stick(FALSE);
 787             saver_mode = *(int *)data;
 788             s = spltty();
 789 #if NSPLASH > 0
 790             if ((error = wait_scrn_saver_stop(NULL))) {
 791                 splx(s);
 792                 return error;
 793             }
 794 #endif /* NSPLASH */
 795             run_scrn_saver = TRUE;
 796             if (saver_mode == CONS_USR_SAVER)
 797                 scp->status |= SAVER_RUNNING;
 798             else
 799                 scp->status &= ~SAVER_RUNNING;
 800             scsplash_stick(TRUE);
 801             splx(s);
 802             break;
 803         case CONS_LKM_SAVER:
 804             s = spltty();
 805             if ((saver_mode == CONS_USR_SAVER) && (scp->status & SAVER_RUNNING))
 806                 scp->status &= ~SAVER_RUNNING;
 807             saver_mode = *(int *)data;
 808             splx(s);
 809             break;
 810         default:
 811             return EINVAL;
 812         }
 813         return 0;
 814
 815     case CONS_SAVERSTART:       /* immediately start/stop the screen saver */
 816         /*
 817          * Note that this ioctl does not guarantee the screen saver
 818          * actually starts or stops. It merely attempts to do so...
 819          */
 820         s = spltty();
 821         run_scrn_saver = (*(int *)data != 0);
 822         if (run_scrn_saver)
 823             sc->scrn_time_stamp -= scrn_blank_time;
 824         splx(s);
 825         return 0;
 826
 827     case CONS_SCRSHOT:          /* get a screen shot */
 828     {
 829         scrshot_t *ptr = (scrshot_t*)data;
 830         s = spltty();
 831         if (ISGRAPHSC(scp)) {
 832             splx(s);
 833             return EOPNOTSUPP;
 834         }
 835         if (scp->xsize != ptr->xsize || scp->ysize != ptr->ysize) {
 836             splx(s);
 837             return EINVAL;
 838         }
 839         copyout ((void*)scp->vtb.vtb_buffer, ptr->buf,
 840                  ptr->xsize * ptr->ysize * sizeof(u_int16_t));
 841         splx(s);
 842         return 0;
 843     }
 844
 845     case VT_SETMODE:            /* set screen switcher mode */
 846     {
 847         struct vt_mode *mode;
 848
 849         mode = (struct vt_mode *)data;
 850         DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit));
 851         if (scp->smode.mode == VT_PROCESS) {
 852             if (scp->proc == pfind(scp->pid) && scp->proc != p) {
 853                 DPRINTF(5, ("error EPERM\n"));
 854                 return EPERM;
 855             }
 856         }
 857         s = spltty();
 858         if (mode->mode == VT_AUTO) {
 859             scp->smode.mode = VT_AUTO;
 860             scp->proc = NULL;
 861             scp->pid = 0;
 862             DPRINTF(5, ("VT_AUTO, "));
 863             if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
 864                 cons_unavail = FALSE;
 865             /* were we in the middle of the vty switching process? */
 866             if (finish_vt_rel(scp, TRUE, &s) == 0)
 867                 DPRINTF(5, ("reset WAIT_REL, "));
 868             if (finish_vt_acq(scp) == 0)
 869                 DPRINTF(5, ("reset WAIT_ACQ, "));
 870         } else {
 871             if (!ISSIGVALID(mode->relsig) || !ISSIGVALID(mode->acqsig)
 872                 || !ISSIGVALID(mode->frsig)) {
 873                 splx(s);
 874                 DPRINTF(5, ("error EINVAL\n"));
 875                 return EINVAL;
 876             }
 877             DPRINTF(5, ("VT_PROCESS %d, ", p->p_pid));
 878             bcopy(data, &scp->smode, sizeof(struct vt_mode));
 879             scp->proc = p;
 880             scp->pid = scp->proc->p_pid;
 881             if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
 882                 cons_unavail = TRUE;
 883         }
 884         splx(s);
 885         DPRINTF(5, ("\n"));
 886         return 0;
 887     }
 888
 889     case VT_GETMODE:            /* get screen switcher mode */
 890         bcopy(&scp->smode, data, sizeof(struct vt_mode));
 891         return 0;
 892
 893     case VT_RELDISP:            /* screen switcher ioctl */
 894         s = spltty();
 895         /*
 896          * This must be the current vty which is in the VT_PROCESS
 897          * switching mode...
 898          */
 899         if ((scp != sc->cur_scp) || (scp->smode.mode != VT_PROCESS)) {
 900             splx(s);
 901             return EINVAL;
 902         }
 903         /* ...and this process is controlling it. */
 904         if (scp->proc != p) {
 905             splx(s);
 906             return EPERM;
 907         }
 908         error = EINVAL;
 909         switch(*(int *)data) {
 910         case VT_FALSE:          /* user refuses to release screen, abort */
 911             if ((error = finish_vt_rel(scp, FALSE, &s)) == 0)
 912                 DPRINTF(5, ("sc%d: VT_FALSE\n", sc->unit));
 913             break;
 914         case VT_TRUE:           /* user has released screen, go on */
 915             if ((error = finish_vt_rel(scp, TRUE, &s)) == 0)
 916                 DPRINTF(5, ("sc%d: VT_TRUE\n", sc->unit));
 917             break;
 918         case VT_ACKACQ:         /* acquire acknowledged, switch completed */
 919             if ((error = finish_vt_acq(scp)) == 0)
 920                 DPRINTF(5, ("sc%d: VT_ACKACQ\n", sc->unit));
 921             break;
 922         default:
 923             break;
 924         }
 925         splx(s);
 926         return error;
 927
 928     case VT_OPENQRY:            /* return free virtual console */
 929         for (i = sc->first_vty; i < sc->first_vty + sc->vtys; i++) {
 930             tp = VIRTUAL_TTY(sc, i);
 931             if (!ISTTYOPEN(tp)) {
 932                 *(int *)data = i + 1;
 933                 return 0;
 934             }
 935         }
 936         return EINVAL;
 937
 938     case VT_ACTIVATE:           /* switch to screen *data */
 939         i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
 940         s = spltty();
 941         sc_clean_up(sc->cur_scp);
 942         splx(s);
 943         return sc_switch_scr(sc, i);
 944
 945     case VT_WAITACTIVE:         /* wait for switch to occur */
 946         i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
 947         if ((i < sc->first_vty) || (i >= sc->first_vty + sc->vtys))
 948             return EINVAL;
 949         s = spltty();
 950         error = sc_clean_up(sc->cur_scp);
 951         splx(s);
 952         if (error)
 953             return error;
 954         scp = SC_STAT(SC_DEV(sc, i));
 955         if (scp == scp->sc->cur_scp)
 956             return 0;
 957         while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH,
 958                              "waitvt", 0)) == ERESTART) ;
 959         return error;
 960
 961     case VT_GETACTIVE:          /* get active vty # */
 962         *(int *)data = sc->cur_scp->index + 1;
 963         return 0;
 964
 965     case VT_GETINDEX:           /* get this vty # */
 966         *(int *)data = scp->index + 1;
 967         return 0;
 968
 969     case VT_LOCKSWITCH:         /* prevent vty switching */
 970         if ((*(int *)data) & 0x01)
 971             sc->flags |= SC_SCRN_VTYLOCK;
 972         else
 973             sc->flags &= ~SC_SCRN_VTYLOCK;
 974         return 0;
 975
 976     case KDENABIO:              /* allow io operations */
 977         error = suser(p);
 978         if (error != 0)
 979             return error;
 980         if (securelevel > 0)
 981             return EPERM;
 982 #ifdef __i386__
 983         p->p_md.md_regs->tf_eflags |= PSL_IOPL;
 984 #endif
 985         return 0;
 986
 987     case KDDISABIO:             /* disallow io operations (default) */
 988 #ifdef __i386__
 989         p->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
 990 #endif
 991         return 0;
 992
 993     case KDSKBSTATE:            /* set keyboard state (locks) */
 994         if (*(int *)data & ~LOCK_MASK)
 995             return EINVAL;
 996         scp->status &= ~LOCK_MASK;
 997         scp->status |= *(int *)data;
 998         if (scp == sc->cur_scp)
 999             update_kbd_state(scp, scp->status, LOCK_MASK);
1000         return 0;
1001
1002     case KDGKBSTATE:            /* get keyboard state (locks) */
1003         if (scp == sc->cur_scp)
1004             save_kbd_state(scp);
1005         *(int *)data = scp->status & LOCK_MASK;
1006         return 0;
1007
1008     case KDGETREPEAT:           /* get keyboard repeat & delay rates */
1009     case KDSETREPEAT:           /* set keyboard repeat & delay rates (new) */
1010         error = kbd_ioctl(sc->kbd, cmd, data);
1011         if (error == ENOIOCTL)
1012             error = ENODEV;
1013         return error;
1014
1015     case KDSETRAD:              /* set keyboard repeat & delay rates (old) */
1016         if (*(int *)data & ~0x7f)
1017             return EINVAL;
1018         error = kbd_ioctl(sc->kbd, cmd, data);
1019         if (error == ENOIOCTL)
1020             error = ENODEV;
1021         return error;
1022
1023     case KDSKBMODE:             /* set keyboard mode */
1024         switch (*(int *)data) {
1025         case K_XLATE:           /* switch to XLT ascii mode */
1026         case K_RAW:             /* switch to RAW scancode mode */
1027         case K_CODE:            /* switch to CODE mode */
1028             scp->kbd_mode = *(int *)data;
1029             if (scp == sc->cur_scp)
1030                 kbd_ioctl(sc->kbd, cmd, data);
1031             return 0;
1032         default:
1033             return EINVAL;
1034         }
1035         /* NOT REACHED */
1036
1037     case KDGKBMODE:             /* get keyboard mode */
1038         *(int *)data = scp->kbd_mode;
1039         return 0;
1040
1041     case KDGKBINFO:
1042         error = kbd_ioctl(sc->kbd, cmd, data);
1043         if (error == ENOIOCTL)
1044             error = ENODEV;
1045         return error;
1046
1047     case KDMKTONE:              /* sound the bell */
1048         if (*(int*)data)
1049             sc_bell(scp, (*(int*)data)&0xffff,
1050                     (((*(int*)data)>>16)&0xffff)*hz/1000);
1051         else
1052             sc_bell(scp, scp->bell_pitch, scp->bell_duration);
1053         return 0;
1054
1055     case KIOCSOUND:             /* make tone (*data) hz */
1056         if (scp == sc->cur_scp) {
1057             if (*(int *)data)
1058                 return sc_tone(*(int *)data);
1059             else
1060                 return sc_tone(0);
1061         }
1062         return 0;
1063
1064     case KDGKBTYPE:             /* get keyboard type */
1065         error = kbd_ioctl(sc->kbd, cmd, data);
1066         if (error == ENOIOCTL) {
1067             /* always return something? XXX */
1068             *(int *)data = 0;
1069         }
1070         return 0;
1071
1072     case KDSETLED:              /* set keyboard LED status */
1073         if (*(int *)data & ~LED_MASK)   /* FIXME: LOCK_MASK? */
1074             return EINVAL;
1075         scp->status &= ~LED_MASK;
1076         scp->status |= *(int *)data;
1077         if (scp == sc->cur_scp)
1078             update_kbd_leds(scp, scp->status);
1079         return 0;
1080
1081     case KDGETLED:              /* get keyboard LED status */
1082         if (scp == sc->cur_scp)
1083             save_kbd_state(scp);
1084         *(int *)data = scp->status & LED_MASK;
1085         return 0;
1086
1087     case CONS_SETKBD:           /* set the new keyboard */
1088         {
1089             keyboard_t *newkbd;
1090
1091             s = spltty();
1092             newkbd = kbd_get_keyboard(*(int *)data);
1093             if (newkbd == NULL) {
1094                 splx(s);
1095                 return EINVAL;
1096             }
1097             error = 0;
1098             if (sc->kbd != newkbd) {
1099                 i = kbd_allocate(newkbd->kb_name, newkbd->kb_unit,
1100                                  (void *)&sc->keyboard, sckbdevent, sc);
1101                 /* i == newkbd->kb_index */
1102                 if (i >= 0) {
1103                     if (sc->kbd != NULL) {
1104                         save_kbd_state(sc->cur_scp);
1105                         kbd_release(sc->kbd, (void *)&sc->keyboard);
1106                     }
1107                     sc->kbd = kbd_get_keyboard(i); /* sc->kbd == newkbd */
1108                     sc->keyboard = i;
1109                     kbd_ioctl(sc->kbd, KDSKBMODE,
1110                               (caddr_t)&sc->cur_scp->kbd_mode);
1111                     update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1112                                      LOCK_MASK);
1113                 } else {
1114                     error = EPERM;      /* XXX */
1115                 }
1116             }
1117             splx(s);
1118             return error;
1119         }
1120
1121     case CONS_RELKBD:           /* release the current keyboard */
1122         s = spltty();
1123         error = 0;
1124         if (sc->kbd != NULL) {
1125             save_kbd_state(sc->cur_scp);
1126             error = kbd_release(sc->kbd, (void *)&sc->keyboard);
1127             if (error == 0) {
1128                 sc->kbd = NULL;
1129                 sc->keyboard = -1;
1130             }
1131         }
1132         splx(s);
1133         return error;
1134
1135     case CONS_GETTERM:          /* get the current terminal emulator info */
1136         {
1137             sc_term_sw_t *sw;
1138
1139             if (((term_info_t *)data)->ti_index == 0) {
1140                 sw = scp->tsw;
1141             } else {
1142                 sw = sc_term_match_by_number(((term_info_t *)data)->ti_index);
1143             }
1144             if (sw != NULL) {
1145                 strncpy(((term_info_t *)data)->ti_name, sw->te_name,
1146                         sizeof(((term_info_t *)data)->ti_name));
1147                 strncpy(((term_info_t *)data)->ti_desc, sw->te_desc,
1148                         sizeof(((term_info_t *)data)->ti_desc));
1149                 ((term_info_t *)data)->ti_flags = 0;
1150                 return 0;
1151             } else {
1152                 ((term_info_t *)data)->ti_name[0] = '\0';
1153                 ((term_info_t *)data)->ti_desc[0] = '\0';
1154                 ((term_info_t *)data)->ti_flags = 0;
1155                 return EINVAL;
1156             }
1157         }
1158
1159     case CONS_SETTERM:          /* set the current terminal emulator */
1160         s = spltty();
1161         error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name);
1162         /* FIXME: what if scp == sc_console! XXX */
1163         splx(s);
1164         return error;
1165
1166     case GIO_SCRNMAP:           /* get output translation table */
1167         bcopy(&sc->scr_map, data, sizeof(sc->scr_map));
1168         return 0;
1169
1170     case PIO_SCRNMAP:           /* set output translation table */
1171         bcopy(data, &sc->scr_map, sizeof(sc->scr_map));
1172         for (i=0; i<sizeof(sc->scr_map); i++) {
1173             sc->scr_rmap[sc->scr_map[i]] = i;
1174         }
1175         return 0;
1176
1177     case GIO_KEYMAP:            /* get keyboard translation table */
1178     case PIO_KEYMAP:            /* set keyboard translation table */
1179     case GIO_DEADKEYMAP:        /* get accent key translation table */
1180     case PIO_DEADKEYMAP:        /* set accent key translation table */
1181     case GETFKEY:               /* get function key string */
1182     case SETFKEY:               /* set function key string */
1183         error = kbd_ioctl(sc->kbd, cmd, data);
1184         if (error == ENOIOCTL)
1185             error = ENODEV;
1186         return error;
1187
1188 #ifndef SC_NO_FONT_LOADING
1189
1190     case PIO_FONT8x8:           /* set 8x8 dot font */
1191         if (!ISFONTAVAIL(sc->adp->va_flags))
1192             return ENXIO;
1193         bcopy(data, sc->font_8, 8*256);
1194         sc->fonts_loaded |= FONT_8;
1195         /*
1196          * FONT KLUDGE
1197          * Always use the font page #0. XXX
1198          * Don't load if the current font size is not 8x8.
1199          */
1200         if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size < 14))
1201             sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256);
1202         return 0;
1203
1204     case GIO_FONT8x8:           /* get 8x8 dot font */
1205         if (!ISFONTAVAIL(sc->adp->va_flags))
1206             return ENXIO;
1207         if (sc->fonts_loaded & FONT_8) {
1208             bcopy(sc->font_8, data, 8*256);
1209             return 0;
1210         }
1211         else
1212             return ENXIO;
1213
1214     case PIO_FONT8x14:          /* set 8x14 dot font */
1215         if (!ISFONTAVAIL(sc->adp->va_flags))
1216             return ENXIO;
1217         bcopy(data, sc->font_14, 14*256);
1218         sc->fonts_loaded |= FONT_14;
1219         /*
1220          * FONT KLUDGE
1221          * Always use the font page #0. XXX
1222          * Don't load if the current font size is not 8x14.
1223          */
1224         if (ISTEXTSC(sc->cur_scp)
1225             && (sc->cur_scp->font_size >= 14)
1226             && (sc->cur_scp->font_size < 16))
1227             sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256);
1228         return 0;
1229
1230     case GIO_FONT8x14:          /* get 8x14 dot font */
1231         if (!ISFONTAVAIL(sc->adp->va_flags))
1232             return ENXIO;
1233         if (sc->fonts_loaded & FONT_14) {
1234             bcopy(sc->font_14, data, 14*256);
1235             return 0;
1236         }
1237         else
1238             return ENXIO;
1239
1240     case PIO_FONT8x16:          /* set 8x16 dot font */
1241         if (!ISFONTAVAIL(sc->adp->va_flags))
1242             return ENXIO;
1243         bcopy(data, sc->font_16, 16*256);
1244         sc->fonts_loaded |= FONT_16;
1245         /*
1246          * FONT KLUDGE
1247          * Always use the font page #0. XXX
1248          * Don't load if the current font size is not 8x16.
1249          */
1250         if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size >= 16))
1251             sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256);
1252         return 0;
1253
1254     case GIO_FONT8x16:          /* get 8x16 dot font */
1255         if (!ISFONTAVAIL(sc->adp->va_flags))
1256             return ENXIO;
1257         if (sc->fonts_loaded & FONT_16) {
1258             bcopy(sc->font_16, data, 16*256);
1259             return 0;
1260         }
1261         else
1262             return ENXIO;
1263
1264 #endif /* SC_NO_FONT_LOADING */
1265
1266     default:
1267         break;
1268     }
1269
1270     error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
1271     if (error != ENOIOCTL)
1272         return(error);
1273     error = ttioctl(tp, cmd, data, flag);
1274     if (error != ENOIOCTL)
1275         return(error);
1276     return(ENOTTY);
1277 }
1278
1279 static void
1280 scstart(struct tty *tp)
1281 {
1282     struct clist *rbp;
1283     int s, len;
1284     u_char buf[PCBURST];
1285     scr_stat *scp = SC_STAT(tp->t_dev);
1286
1287     if (scp->status & SLKED || scp->sc->blink_in_progress)
1288         return;
1289     s = spltty();
1290     if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) {
1291         tp->t_state |= TS_BUSY;
1292         rbp = &tp->t_outq;
1293         while (rbp->c_cc) {
1294             len = q_to_b(rbp, buf, PCBURST);
1295             splx(s);
1296             sc_puts(scp, buf, len);
1297             s = spltty();
1298         }
1299         tp->t_state &= ~TS_BUSY;
1300         ttwwakeup(tp);
1301     }
1302     splx(s);
1303 }
1304
1305 static void
1306 sccnprobe(struct consdev *cp)
1307 {
1308 #if __i386__
1309     int unit;
1310     int flags;
1311
1312     cp->cn_pri = sc_get_cons_priority(&unit, &flags);
1313
1314     /* a video card is always required */
1315     if (!scvidprobe(unit, flags, TRUE))
1316         cp->cn_pri = CN_DEAD;
1317
1318     /* syscons will become console even when there is no keyboard */
1319     sckbdprobe(unit, flags, TRUE);
1320
1321     if (cp->cn_pri == CN_DEAD)
1322         return;
1323
1324     /* initialize required fields */
1325     cp->cn_dev = makedev(CDEV_MAJOR, SC_CONSOLECTL);
1326 #endif /* __i386__ */
1327
1328 #if __alpha__
1329     /*
1330      * alpha use sccnattach() rather than cnprobe()/cninit()/cnterm()
1331      * interface to install the console.  Always return CN_DEAD from
1332      * here.
1333      */
1334     cp->cn_pri = CN_DEAD;
1335 #endif /* __alpha__ */
1336 }
1337
1338 static void
1339 sccninit(struct consdev *cp)
1340 {
1341 #if __i386__
1342     int unit;
1343     int flags;
1344
1345     sc_get_cons_priority(&unit, &flags);
1346     scinit(unit, flags | SC_KERNEL_CONSOLE);
1347     sc_console_unit = unit;
1348     sc_console = SC_STAT(sc_get_softc(unit, SC_KERNEL_CONSOLE)->dev[0]);
1349 #endif /* __i386__ */
1350
1351 #if __alpha__
1352     /* SHOULDN'T REACH HERE */
1353 #endif /* __alpha__ */
1354 }
1355
1356 static void
1357 sccnterm(struct consdev *cp)
1358 {
1359     /* we are not the kernel console any more, release everything */
1360
1361     if (sc_console_unit < 0)
1362         return;                 /* shouldn't happen */
1363
1364 #if __i386__
1365 #if 0 /* XXX */
1366     sc_clear_screen(sc_console);
1367     sccnupdate(sc_console);
1368 #endif
1369     scterm(sc_console_unit, SC_KERNEL_CONSOLE);
1370     sc_console_unit = -1;
1371     sc_console = NULL;
1372 #endif /* __i386__ */
1373
1374 #if __alpha__
1375     /* do nothing XXX */
1376 #endif /* __alpha__ */
1377 }
1378
1379 #ifdef __alpha__
1380
1381 void
1382 sccnattach(void)
1383 {
1384     static struct consdev consdev;
1385     int unit;
1386     int flags;
1387
1388     bcopy(&sc_consdev, &consdev, sizeof(sc_consdev));
1389     consdev.cn_pri = sc_get_cons_priority(&unit, &flags);
1390
1391     /* a video card is always required */
1392     if (!scvidprobe(unit, flags, TRUE))
1393         consdev.cn_pri = CN_DEAD;
1394
1395     /* alpha doesn't allow the console being without a keyboard... Why? */
1396     if (!sckbdprobe(unit, flags, TRUE))
1397         consdev.cn_pri = CN_DEAD;
1398
1399     if (consdev.cn_pri == CN_DEAD)
1400         return;
1401
1402     scinit(unit, flags | SC_KERNEL_CONSOLE);
1403     sc_console_unit = unit;
1404     sc_console = SC_STAT(sc_get_softc(unit, SC_KERNEL_CONSOLE)->dev[0]);
1405     consdev.cn_dev = makedev(CDEV_MAJOR, 0);
1406     cn_tab = &consdev;
1407 }
1408
1409 #endif /* __alpha__ */
1410
1411 static void
1412 sccnputc(dev_t dev, int c)
1413 {
1414     u_char buf[1];
1415     scr_stat *scp = sc_console;
1416     void *save;
1417 #ifndef SC_NO_HISTORY
1418     struct tty *tp;
1419 #endif /* !SC_NO_HISTORY */
1420     int s;
1421
1422     /* assert(sc_console != NULL) */
1423
1424 #ifndef SC_NO_HISTORY
1425     if (scp == scp->sc->cur_scp && scp->status & SLKED) {
1426         scp->status &= ~SLKED;
1427         update_kbd_state(scp, scp->status, SLKED);
1428         if (scp->status & BUFFER_SAVED) {
1429             if (!sc_hist_restore(scp))
1430                 sc_remove_cutmarking(scp);
1431             scp->status &= ~BUFFER_SAVED;
1432             scp->status |= CURSOR_ENABLED;
1433             sc_draw_cursor_image(scp);
1434         }
1435         tp = VIRTUAL_TTY(scp->sc, scp->index);
1436         if (ISTTYOPEN(tp))
1437             scstart(tp);
1438     }
1439 #endif /* !SC_NO_HISTORY */
1440
1441     save = scp->ts;
1442     if (kernel_console_ts != NULL)
1443         scp->ts = kernel_console_ts;
1444     buf[0] = c;
1445     sc_puts(scp, buf, 1);
1446     scp->ts = save;
1447
1448     s = spltty();       /* block sckbdevent and scrn_timer */
1449     sccnupdate(scp);
1450     splx(s);
1451 }
1452
1453 static int
1454 sccngetc(dev_t dev)
1455 {
1456     return sccngetch(0);
1457 }
1458
1459 static int
1460 sccncheckc(dev_t dev)
1461 {
1462     return sccngetch(SCGETC_NONBLOCK);
1463 }
1464
1465 static void
1466 sccndbctl(dev_t dev, int on)
1467 {
1468     /* assert(sc_console_unit >= 0) */
1469     /* try to switch to the kernel console screen */
1470     if (on && debugger == 0) {
1471         /*
1472          * TRY to make sure the screen saver is stopped,
1473          * and the screen is updated before switching to
1474          * the vty0.
1475          */
1476         scrn_timer(NULL);
1477         if (!cold
1478             && sc_console->sc->cur_scp->smode.mode == VT_AUTO
1479             && sc_console->smode.mode == VT_AUTO) {
1480             sc_console->sc->cur_scp->status |= MOUSE_HIDDEN;
1481             sc_switch_scr(sc_console->sc, sc_console->index);
1482         }
1483     }
1484     if (on)
1485         ++debugger;
1486     else
1487         --debugger;
1488 }
1489
1490 static int
1491 sccngetch(int flags)
1492 {
1493     static struct fkeytab fkey;
1494     static int fkeycp;
1495     scr_stat *scp;
1496     u_char *p;
1497     int cur_mode;
1498     int s = spltty();   /* block sckbdevent and scrn_timer while we poll */
1499     int c;
1500
1501     /* assert(sc_console != NULL) */
1502
1503     /*
1504      * Stop the screen saver and update the screen if necessary.
1505      * What if we have been running in the screen saver code... XXX
1506      */
1507     sc_touch_scrn_saver();
1508     scp = sc_console->sc->cur_scp;      /* XXX */
1509     sccnupdate(scp);
1510
1511     if (fkeycp < fkey.len) {
1512         splx(s);
1513         return fkey.str[fkeycp++];
1514     }
1515
1516     if (scp->sc->kbd == NULL) {
1517         splx(s);
1518         return -1;
1519     }
1520
1521     /*
1522      * Make sure the keyboard is accessible even when the kbd device
1523      * driver is disabled.
1524      */
1525     kbd_enable(scp->sc->kbd);
1526
1527     /* we shall always use the keyboard in the XLATE mode here */
1528     cur_mode = scp->kbd_mode;
1529     scp->kbd_mode = K_XLATE;
1530     kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1531
1532     kbd_poll(scp->sc->kbd, TRUE);
1533     c = scgetc(scp->sc, SCGETC_CN | flags);
1534     kbd_poll(scp->sc->kbd, FALSE);
1535
1536     scp->kbd_mode = cur_mode;
1537     kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1538     kbd_disable(scp->sc->kbd);
1539     splx(s);
1540
1541     switch (KEYFLAGS(c)) {
1542     case 0:     /* normal char */
1543         return KEYCHAR(c);
1544     case FKEY:  /* function key */
1545         p = kbd_get_fkeystr(scp->sc->kbd, KEYCHAR(c), (size_t *)&fkeycp);
1546         fkey.len = fkeycp;
1547         if ((p != NULL) && (fkey.len > 0)) {
1548             bcopy(p, fkey.str, fkey.len);
1549             fkeycp = 1;
1550             return fkey.str[0];
1551         }
1552         return c;       /* XXX */
1553     case NOKEY:
1554     case ERRKEY:
1555     default:
1556         return -1;
1557     }
1558     /* NOT REACHED */
1559 }
1560
1561 static void
1562 sccnupdate(scr_stat *scp)
1563 {
1564     /* this is a cut-down version of scrn_timer()... */
1565
1566     if (scp->sc->font_loading_in_progress || scp->sc->videoio_in_progress)
1567         return;
1568
1569     if (debugger > 0 || panicstr || shutdown_in_progress) {
1570         sc_touch_scrn_saver();
1571     } else if (scp != scp->sc->cur_scp) {
1572         return;
1573     }
1574
1575     if (!run_scrn_saver)
1576         scp->sc->flags &= ~SC_SCRN_IDLE;
1577 #if NSPLASH > 0
1578     if ((saver_mode != CONS_LKM_SAVER) || !(scp->sc->flags & SC_SCRN_IDLE))
1579         if (scp->sc->flags & SC_SCRN_BLANKED)
1580             stop_scrn_saver(scp->sc, current_saver);
1581 #endif /* NSPLASH */
1582
1583     if (scp != scp->sc->cur_scp || scp->sc->blink_in_progress
1584         || scp->sc->switch_in_progress)
1585         return;
1586     /*
1587      * FIXME: unlike scrn_timer(), we call scrn_update() from here even
1588      * when write_in_progress is non-zero.  XXX
1589      */
1590
1591     if (!ISGRAPHSC(scp) && !(scp->sc->flags & SC_SCRN_BLANKED))
1592         scrn_update(scp, TRUE);
1593 }
1594
1595 static void
1596 scrn_timer(void *arg)
1597 {
1598     static int kbd_interval = 0;
1599     struct timeval tv;
1600     sc_softc_t *sc;
1601     scr_stat *scp;
1602     int again;
1603     int s;
1604
1605     again = (arg != NULL);
1606     if (arg != NULL)
1607         sc = (sc_softc_t *)arg;
1608     else if (sc_console != NULL)
1609         sc = sc_console->sc;
1610     else
1611         return;
1612
1613     /* don't do anything when we are performing some I/O operations */
1614     if (sc->font_loading_in_progress || sc->videoio_in_progress) {
1615         if (again)
1616             timeout(scrn_timer, sc, hz / 10);
1617         return;
1618     }
1619     s = spltty();
1620
1621     if ((sc->kbd == NULL) && (sc->config & SC_AUTODETECT_KBD)) {
1622         /* try to allocate a keyboard automatically */
1623         if (++kbd_interval >= 25) {
1624             sc->keyboard = kbd_allocate("*", -1, (void *)&sc->keyboard,
1625                                         sckbdevent, sc);
1626             if (sc->keyboard >= 0) {
1627                 sc->kbd = kbd_get_keyboard(sc->keyboard);
1628                 kbd_ioctl(sc->kbd, KDSKBMODE,
1629                           (caddr_t)&sc->cur_scp->kbd_mode);
1630                 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1631                                  LOCK_MASK);
1632             }
1633             kbd_interval = 0;
1634         }
1635     }
1636
1637     /* find the vty to update */
1638     scp = sc->cur_scp;
1639
1640     /* should we stop the screen saver? */
1641     getmicrouptime(&tv);
1642     if (debugger > 0 || panicstr || shutdown_in_progress)
1643         sc_touch_scrn_saver();
1644     if (run_scrn_saver) {
1645         if (tv.tv_sec > sc->scrn_time_stamp + scrn_blank_time)
1646             sc->flags |= SC_SCRN_IDLE;
1647         else
1648             sc->flags &= ~SC_SCRN_IDLE;
1649     } else {
1650         sc->scrn_time_stamp = tv.tv_sec;
1651         sc->flags &= ~SC_SCRN_IDLE;
1652         if (scrn_blank_time > 0)
1653             run_scrn_saver = TRUE;
1654     }
1655 #if NSPLASH > 0
1656     if ((saver_mode != CONS_LKM_SAVER) || !(sc->flags & SC_SCRN_IDLE))
1657         if (sc->flags & SC_SCRN_BLANKED)
1658             stop_scrn_saver(sc, current_saver);
1659 #endif /* NSPLASH */
1660
1661     /* should we just return ? */
1662     if (sc->blink_in_progress || sc->switch_in_progress
1663         || sc->write_in_progress) {
1664         if (again)
1665             timeout(scrn_timer, sc, hz / 10);
1666         splx(s);
1667         return;
1668     }
1669
1670     /* Update the screen */
1671     scp = sc->cur_scp;          /* cur_scp may have changed... */
1672     if (!ISGRAPHSC(scp) && !(sc->flags & SC_SCRN_BLANKED))
1673         scrn_update(scp, TRUE);
1674
1675 #if NSPLASH > 0
1676     /* should we activate the screen saver? */
1677     if ((saver_mode == CONS_LKM_SAVER) && (sc->flags & SC_SCRN_IDLE))
1678         if (!ISGRAPHSC(scp) || (sc->flags & SC_SCRN_BLANKED))
1679             (*current_saver)(sc, TRUE);
1680 #endif /* NSPLASH */
1681
1682     if (again)
1683         timeout(scrn_timer, sc, hz / 25);
1684     splx(s);
1685 }
1686
1687 static int
1688 and_region(int *s1, int *e1, int s2, int e2)
1689 {
1690     if (*e1 < s2 || e2 < *s1)
1691         return FALSE;
1692     *s1 = imax(*s1, s2);
1693     *e1 = imin(*e1, e2);
1694     return TRUE;
1695 }
1696
1697 static void
1698 scrn_update(scr_stat *scp, int show_cursor)
1699 {
1700     int start;
1701     int end;
1702     int s;
1703     int e;
1704
1705     /* assert(scp == scp->sc->cur_scp) */
1706
1707     ++scp->sc->videoio_in_progress;
1708
1709 #ifndef SC_NO_CUTPASTE
1710     /* remove the previous mouse pointer image if necessary */
1711     if (scp->status & MOUSE_VISIBLE) {
1712         s = scp->mouse_pos;
1713         e = scp->mouse_pos + scp->xsize + 1;
1714         if ((scp->status & (MOUSE_MOVED | MOUSE_HIDDEN))
1715             || and_region(&s, &e, scp->start, scp->end)
1716             || ((scp->status & CURSOR_ENABLED) &&
1717                 (scp->cursor_pos != scp->cursor_oldpos) &&
1718                 (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos)
1719                  || and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos)))) {
1720             sc_remove_mouse_image(scp);
1721             if (scp->end >= scp->xsize*scp->ysize)
1722                 scp->end = scp->xsize*scp->ysize - 1;
1723         }
1724     }
1725 #endif /* !SC_NO_CUTPASTE */
1726
1727 #if 1
1728     /* debug: XXX */
1729     if (scp->end >= scp->xsize*scp->ysize) {
1730         printf("scrn_update(): scp->end %d > size_of_screen!!\n", scp->end);
1731         scp->end = scp->xsize*scp->ysize - 1;
1732     }
1733     if (scp->start < 0) {
1734         printf("scrn_update(): scp->start %d < 0\n", scp->start);
1735         scp->start = 0;
1736     }
1737 #endif
1738
1739     /* update screen image */
1740     if (scp->start <= scp->end)  {
1741         if (scp->mouse_cut_end >= 0) {
1742             /* there is a marked region for cut & paste */
1743             if (scp->mouse_cut_start <= scp->mouse_cut_end) {
1744                 start = scp->mouse_cut_start;
1745                 end = scp->mouse_cut_end;
1746             } else {
1747                 start = scp->mouse_cut_end;
1748                 end = scp->mouse_cut_start - 1;
1749             }
1750             s = start;
1751             e = end;
1752             /* does the cut-mark region overlap with the update region? */
1753             if (and_region(&s, &e, scp->start, scp->end)) {
1754                 (*scp->rndr->draw)(scp, s, e - s + 1, TRUE);
1755                 s = 0;
1756                 e = start - 1;
1757                 if (and_region(&s, &e, scp->start, scp->end))
1758                     (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1759                 s = end + 1;
1760                 e = scp->xsize*scp->ysize - 1;
1761                 if (and_region(&s, &e, scp->start, scp->end))
1762                     (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1763             } else {
1764                 (*scp->rndr->draw)(scp, scp->start,
1765                                    scp->end - scp->start + 1, FALSE);
1766             }
1767         } else {
1768             (*scp->rndr->draw)(scp, scp->start,
1769                                scp->end - scp->start + 1, FALSE);
1770         }
1771     }
1772
1773     /* we are not to show the cursor and the mouse pointer... */
1774     if (!show_cursor) {
1775         scp->end = 0;
1776         scp->start = scp->xsize*scp->ysize - 1;
1777         --scp->sc->videoio_in_progress;
1778         return;
1779     }
1780
1781     /* update cursor image */
1782     if (scp->status & CURSOR_ENABLED) {
1783         s = scp->start;
1784         e = scp->end;
1785         /* did cursor move since last time ? */
1786         if (scp->cursor_pos != scp->cursor_oldpos) {
1787             /* do we need to remove old cursor image ? */
1788             if (!and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos))
1789                 sc_remove_cursor_image(scp);
1790             sc_draw_cursor_image(scp);
1791         } else {
1792             if (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos))
1793                 /* cursor didn't move, but has been overwritten */
1794                 sc_draw_cursor_image(scp);
1795             else if (scp->sc->flags & SC_BLINK_CURSOR)
1796                 /* if it's a blinking cursor, update it */
1797                 (*scp->rndr->blink_cursor)(scp, scp->cursor_pos,
1798                                            sc_inside_cutmark(scp,
1799                                                scp->cursor_pos));
1800         }
1801     }
1802
1803 #ifndef SC_NO_CUTPASTE
1804     /* update "pseudo" mouse pointer image */
1805     if (scp->sc->flags & SC_MOUSE_ENABLED) {
1806         if (!(scp->status & (MOUSE_VISIBLE | MOUSE_HIDDEN))) {
1807             scp->status &= ~MOUSE_MOVED;
1808             sc_draw_mouse_image(scp);
1809         }
1810     }
1811 #endif /* SC_NO_CUTPASTE */
1812
1813     scp->end = 0;
1814     scp->start = scp->xsize*scp->ysize - 1;
1815
1816     --scp->sc->videoio_in_progress;
1817 }
1818
1819 #if NSPLASH > 0
1820 static int
1821 scsplash_callback(int event, void *arg)
1822 {
1823     sc_softc_t *sc;
1824     int error;
1825
1826     sc = (sc_softc_t *)arg;
1827
1828     switch (event) {
1829     case SPLASH_INIT:
1830         if (add_scrn_saver(scsplash_saver) == 0) {
1831             sc->flags &= ~SC_SAVER_FAILED;
1832             run_scrn_saver = TRUE;
1833             if (cold && !(boothowto & (RB_VERBOSE | RB_CONFIG))) {
1834                 scsplash_stick(TRUE);
1835                 (*current_saver)(sc, TRUE);
1836             }
1837         }
1838         return 0;
1839
1840     case SPLASH_TERM:
1841         if (current_saver == scsplash_saver) {
1842             scsplash_stick(FALSE);
1843             error = remove_scrn_saver(scsplash_saver);
1844             if (error)
1845                 return error;
1846         }
1847         return 0;
1848
1849     default:
1850         return EINVAL;
1851     }
1852 }
1853
1854 static void
1855 scsplash_saver(sc_softc_t *sc, int show)
1856 {
1857     static int busy = FALSE;
1858     scr_stat *scp;
1859
1860     if (busy)
1861         return;
1862     busy = TRUE;
1863
1864     scp = sc->cur_scp;
1865     if (show) {
1866         if (!(sc->flags & SC_SAVER_FAILED)) {
1867             if (!(sc->flags & SC_SCRN_BLANKED))
1868                 set_scrn_saver_mode(scp, -1, NULL, 0);
1869             switch (splash(sc->adp, TRUE)) {
1870             case 0:             /* succeeded */
1871                 break;
1872             case EAGAIN:        /* try later */
1873                 restore_scrn_saver_mode(scp, FALSE);
1874                 sc_touch_scrn_saver();          /* XXX */
1875                 break;
1876             default:
1877                 sc->flags |= SC_SAVER_FAILED;
1878                 scsplash_stick(FALSE);
1879                 restore_scrn_saver_mode(scp, TRUE);
1880                 printf("scsplash_saver(): failed to put up the image\n");
1881                 break;
1882             }
1883         }
1884     } else if (!sticky_splash) {
1885         if ((sc->flags & SC_SCRN_BLANKED) && (splash(sc->adp, FALSE) == 0))
1886             restore_scrn_saver_mode(scp, TRUE);
1887     }
1888     busy = FALSE;
1889 }
1890
1891 static int
1892 add_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1893 {
1894 #if 0
1895     int error;
1896
1897     if (current_saver != none_saver) {
1898         error = remove_scrn_saver(current_saver);
1899         if (error)
1900             return error;
1901     }
1902 #endif
1903     if (current_saver != none_saver)
1904         return EBUSY;
1905
1906     run_scrn_saver = FALSE;
1907     saver_mode = CONS_LKM_SAVER;
1908     current_saver = this_saver;
1909     return 0;
1910 }
1911
1912 static int
1913 remove_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1914 {
1915     if (current_saver != this_saver)
1916         return EINVAL;
1917
1918 #if 0
1919     /*
1920      * In order to prevent `current_saver' from being called by
1921      * the timeout routine `scrn_timer()' while we manipulate
1922      * the saver list, we shall set `current_saver' to `none_saver'
1923      * before stopping the current saver, rather than blocking by `splXX()'.
1924      */
1925     current_saver = none_saver;
1926     if (scrn_blanked)
1927         stop_scrn_saver(this_saver);
1928 #endif
1929
1930     /* unblank all blanked screens */
1931     wait_scrn_saver_stop(NULL);
1932     if (scrn_blanked)
1933         return EBUSY;
1934
1935     current_saver = none_saver;
1936     return 0;
1937 }
1938
1939 static int
1940 set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border)
1941 {
1942     int s;
1943
1944     /* assert(scp == scp->sc->cur_scp) */
1945     s = spltty();
1946     if (!ISGRAPHSC(scp))
1947         sc_remove_cursor_image(scp);
1948     scp->splash_save_mode = scp->mode;
1949     scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE);
1950     scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE);
1951     scp->status |= (UNKNOWN_MODE | SAVER_RUNNING);
1952     scp->sc->flags |= SC_SCRN_BLANKED;
1953     ++scrn_blanked;
1954     splx(s);
1955     if (mode < 0)
1956         return 0;
1957     scp->mode = mode;
1958     if (set_mode(scp) == 0) {
1959         if (scp->sc->adp->va_info.vi_flags & V_INFO_GRAPHICS)
1960             scp->status |= GRAPHICS_MODE;
1961 #ifndef SC_NO_PALETTE_LOADING
1962         if (pal != NULL)
1963             load_palette(scp->sc->adp, pal);
1964 #endif
1965         sc_set_border(scp, border);
1966         return 0;
1967     } else {
1968         s = spltty();
1969         scp->mode = scp->splash_save_mode;
1970         scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
1971         scp->status |= scp->splash_save_status;
1972         splx(s);
1973         return 1;
1974     }
1975 }
1976
1977 static int
1978 restore_scrn_saver_mode(scr_stat *scp, int changemode)
1979 {
1980     int mode;
1981     int status;
1982     int s;
1983
1984     /* assert(scp == scp->sc->cur_scp) */
1985     s = spltty();
1986     mode = scp->mode;
1987     status = scp->status;
1988     scp->mode = scp->splash_save_mode;
1989     scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
1990     scp->status |= scp->splash_save_status;
1991     scp->sc->flags &= ~SC_SCRN_BLANKED;
1992     if (!changemode) {
1993         if (!ISGRAPHSC(scp))
1994             sc_draw_cursor_image(scp);
1995         --scrn_blanked;
1996         splx(s);
1997         return 0;
1998     }
1999     if (set_mode(scp) == 0) {
2000 #ifndef SC_NO_PALETTE_LOADING
2001         load_palette(scp->sc->adp, scp->sc->palette);
2002 #endif
2003         --scrn_blanked;
2004         splx(s);
2005         return 0;
2006     } else {
2007         scp->mode = mode;
2008         scp->status = status;
2009         splx(s);
2010         return 1;
2011     }
2012 }
2013
2014 static void
2015 stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
2016 {
2017     (*saver)(sc, FALSE);
2018     run_scrn_saver = FALSE;
2019     /* the screen saver may have chosen not to stop after all... */
2020     if (sc->flags & SC_SCRN_BLANKED)
2021         return;
2022
2023     mark_all(sc->cur_scp);
2024     if (sc->delayed_next_scr)
2025         sc_switch_scr(sc, sc->delayed_next_scr - 1);
2026     wakeup((caddr_t)&scrn_blanked);
2027 }
2028
2029 static int
2030 wait_scrn_saver_stop(sc_softc_t *sc)
2031 {
2032     int error = 0;
2033
2034     while (scrn_blanked > 0) {
2035         run_scrn_saver = FALSE;
2036         if (sc && !(sc->flags & SC_SCRN_BLANKED)) {
2037             error = 0;
2038             break;
2039         }
2040         error = tsleep((caddr_t)&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
2041         if ((error != 0) && (error != ERESTART))
2042             break;
2043     }
2044     run_scrn_saver = FALSE;
2045     return error;
2046 }
2047 #endif /* NSPLASH */
2048
2049 void
2050 sc_touch_scrn_saver(void)
2051 {
2052     scsplash_stick(FALSE);
2053     run_scrn_saver = FALSE;
2054 }
2055
2056 int
2057 sc_switch_scr(sc_softc_t *sc, u_int next_scr)
2058 {
2059     scr_stat *cur_scp;
2060     struct tty *tp;
2061     int s;
2062
2063     DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1));
2064
2065     /* prevent switch if previously requested */
2066     if (sc->flags & SC_SCRN_VTYLOCK) {
2067             sc_bell(sc->cur_scp, sc->cur_scp->bell_pitch,
2068                 sc->cur_scp->bell_duration);
2069             return EPERM;
2070     }
2071
2072     /* delay switch if the screen is blanked or being updated */
2073     if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress
2074         || sc->blink_in_progress || sc->videoio_in_progress) {
2075         sc->delayed_next_scr = next_scr + 1;
2076         sc_touch_scrn_saver();
2077         DPRINTF(5, ("switch delayed\n"));
2078         return 0;
2079     }
2080
2081     s = spltty();
2082     cur_scp = sc->cur_scp;
2083
2084     /* we are in the middle of the vty switching process... */
2085     if (sc->switch_in_progress
2086         && (cur_scp->smode.mode == VT_PROCESS)
2087         && cur_scp->proc) {
2088         if (cur_scp->proc != pfind(cur_scp->pid)) {
2089             /*
2090              * The controlling process has died!!.  Do some clean up.
2091              * NOTE:`cur_scp->proc' and `cur_scp->smode.mode'
2092              * are not reset here yet; they will be cleared later.
2093              */
2094             DPRINTF(5, ("cur_scp controlling process %d died, ",
2095                cur_scp->pid));
2096             if (cur_scp->status & SWITCH_WAIT_REL) {
2097                 /*
2098                  * Force the previous switch to finish, but return now
2099                  * with error.
2100                  */
2101                 DPRINTF(5, ("reset WAIT_REL, "));
2102                 finish_vt_rel(cur_scp, TRUE, &s);
2103                 splx(s);
2104                 DPRINTF(5, ("finishing previous switch\n"));
2105                 return EINVAL;
2106             } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2107                 /* let's assume screen switch has been completed. */
2108                 DPRINTF(5, ("reset WAIT_ACQ, "));
2109                 finish_vt_acq(cur_scp);
2110             } else {
2111                 /*
2112                  * We are in between screen release and acquisition, and
2113                  * reached here via scgetc() or scrn_timer() which has
2114                  * interrupted exchange_scr(). Don't do anything stupid.
2115                  */
2116                 DPRINTF(5, ("waiting nothing, "));
2117             }
2118         } else {
2119             /*
2120              * The controlling process is alive, but not responding...
2121              * It is either buggy or it may be just taking time.
2122              * The following code is a gross kludge to cope with this
2123              * problem for which there is no clean solution. XXX
2124              */
2125             if (cur_scp->status & SWITCH_WAIT_REL) {
2126                 switch (sc->switch_in_progress++) {
2127                 case 1:
2128                     break;
2129                 case 2:
2130                     DPRINTF(5, ("sending relsig again, "));
2131                     signal_vt_rel(cur_scp);
2132                     break;
2133                 case 3:
2134                     break;
2135                 case 4:
2136                 default:
2137                     /*
2138                      * Act as if the controlling program returned
2139                      * VT_FALSE.
2140                      */
2141                     DPRINTF(5, ("force reset WAIT_REL, "));
2142                     finish_vt_rel(cur_scp, FALSE, &s);
2143                     splx(s);
2144                     DPRINTF(5, ("act as if VT_FALSE was seen\n"));
2145                     return EINVAL;
2146                 }
2147             } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2148                 switch (sc->switch_in_progress++) {
2149                 case 1:
2150                     break;
2151                 case 2:
2152                     DPRINTF(5, ("sending acqsig again, "));
2153                     signal_vt_acq(cur_scp);
2154                     break;
2155                 case 3:
2156                     break;
2157                 case 4:
2158                 default:
2159                      /* clear the flag and finish the previous switch */
2160                     DPRINTF(5, ("force reset WAIT_ACQ, "));
2161                     finish_vt_acq(cur_scp);
2162                     break;
2163                 }
2164             }
2165         }
2166     }
2167
2168     /*
2169      * Return error if an invalid argument is given, or vty switch
2170      * is still in progress.
2171      */
2172     if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys)
2173         || sc->switch_in_progress) {
2174         splx(s);
2175         sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2176         DPRINTF(5, ("error 1\n"));
2177         return EINVAL;
2178     }
2179
2180     /*
2181      * Don't allow switching away from the graphics mode vty
2182      * if the switch mode is VT_AUTO, unless the next vty is the same
2183      * as the current or the current vty has been closed (but showing).
2184      */
2185     tp = VIRTUAL_TTY(sc, cur_scp->index);
2186     if ((cur_scp->index != next_scr)
2187         && ISTTYOPEN(tp)
2188         && (cur_scp->smode.mode == VT_AUTO)
2189         && ISGRAPHSC(cur_scp)) {
2190         splx(s);
2191         sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2192         DPRINTF(5, ("error, graphics mode\n"));
2193         return EINVAL;
2194     }
2195
2196     /*
2197      * Is the wanted vty open? Don't allow switching to a closed vty.
2198      * If we are in DDB, don't switch to a vty in the VT_PROCESS mode.
2199      * Note that we always allow the user to switch to the kernel
2200      * console even if it is closed.
2201      */
2202     if ((sc_console == NULL) || (next_scr != sc_console->index)) {
2203         tp = VIRTUAL_TTY(sc, next_scr);
2204         if (!ISTTYOPEN(tp)) {
2205             splx(s);
2206             sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2207             DPRINTF(5, ("error 2, requested vty isn't open!\n"));
2208             return EINVAL;
2209         }
2210         if ((debugger > 0) && (SC_STAT(tp->t_dev)->smode.mode == VT_PROCESS)) {
2211             splx(s);
2212             DPRINTF(5, ("error 3, requested vty is in the VT_PROCESS mode\n"));
2213             return EINVAL;
2214         }
2215     }
2216
2217     /* this is the start of vty switching process... */
2218     ++sc->switch_in_progress;
2219     sc->delayed_next_scr = 0;
2220     sc->old_scp = cur_scp;
2221     sc->new_scp = SC_STAT(SC_DEV(sc, next_scr));
2222     if (sc->new_scp == sc->old_scp) {
2223         sc->switch_in_progress = 0;
2224         wakeup((caddr_t)&sc->new_scp->smode);
2225         splx(s);
2226         DPRINTF(5, ("switch done (new == old)\n"));
2227         return 0;
2228     }
2229
2230     /* has controlling process died? */
2231     vt_proc_alive(sc->old_scp);
2232     vt_proc_alive(sc->new_scp);
2233
2234     /* wait for the controlling process to release the screen, if necessary */
2235     if (signal_vt_rel(sc->old_scp)) {
2236         splx(s);
2237         return 0;
2238     }
2239
2240     /* go set up the new vty screen */
2241     splx(s);
2242     exchange_scr(sc);
2243     s = spltty();
2244
2245     /* wake up processes waiting for this vty */
2246     wakeup((caddr_t)&sc->cur_scp->smode);
2247
2248     /* wait for the controlling process to acknowledge, if necessary */
2249     if (signal_vt_acq(sc->cur_scp)) {
2250         splx(s);
2251         return 0;
2252     }
2253
2254     sc->switch_in_progress = 0;
2255     if (sc->unit == sc_console_unit)
2256         cons_unavail = FALSE;
2257     splx(s);
2258     DPRINTF(5, ("switch done\n"));
2259
2260     return 0;
2261 }
2262
2263 static int
2264 do_switch_scr(sc_softc_t *sc, int s)
2265 {
2266     vt_proc_alive(sc->new_scp);
2267
2268     splx(s);
2269     exchange_scr(sc);
2270     s = spltty();
2271     /* sc->cur_scp == sc->new_scp */
2272     wakeup((caddr_t)&sc->cur_scp->smode);
2273
2274     /* wait for the controlling process to acknowledge, if necessary */
2275     if (!signal_vt_acq(sc->cur_scp)) {
2276         sc->switch_in_progress = 0;
2277         if (sc->unit == sc_console_unit)
2278             cons_unavail = FALSE;
2279     }
2280
2281     return s;
2282 }
2283
2284 static int
2285 vt_proc_alive(scr_stat *scp)
2286 {
2287     if (scp->proc) {
2288         if (scp->proc == pfind(scp->pid))
2289             return TRUE;
2290         scp->proc = NULL;
2291         scp->smode.mode = VT_AUTO;
2292         DPRINTF(5, ("vt controlling process %d died\n", scp->pid));
2293     }
2294     return FALSE;
2295 }
2296
2297 static int
2298 signal_vt_rel(scr_stat *scp)
2299 {
2300     if (scp->smode.mode != VT_PROCESS)
2301         return FALSE;
2302     scp->status |= SWITCH_WAIT_REL;
2303     psignal(scp->proc, scp->smode.relsig);
2304     DPRINTF(5, ("sending relsig to %d\n", scp->pid));
2305     return TRUE;
2306 }
2307
2308 static int
2309 signal_vt_acq(scr_stat *scp)
2310 {
2311     if (scp->smode.mode != VT_PROCESS)
2312         return FALSE;
2313     if (scp->sc->unit == sc_console_unit)
2314         cons_unavail = TRUE;
2315     scp->status |= SWITCH_WAIT_ACQ;
2316     psignal(scp->proc, scp->smode.acqsig);
2317     DPRINTF(5, ("sending acqsig to %d\n", scp->pid));
2318     return TRUE;
2319 }
2320
2321 static int
2322 finish_vt_rel(scr_stat *scp, int release, int *s)
2323 {
2324     if (scp == scp->sc->old_scp && scp->status & SWITCH_WAIT_REL) {
2325         scp->status &= ~SWITCH_WAIT_REL;
2326         if (release)
2327             *s = do_switch_scr(scp->sc, *s);
2328         else
2329             scp->sc->switch_in_progress = 0;
2330         return 0;
2331     }
2332     return EINVAL;
2333 }
2334
2335 static int
2336 finish_vt_acq(scr_stat *scp)
2337 {
2338     if (scp == scp->sc->new_scp && scp->status & SWITCH_WAIT_ACQ) {
2339         scp->status &= ~SWITCH_WAIT_ACQ;
2340         scp->sc->switch_in_progress = 0;
2341         return 0;
2342     }
2343     return EINVAL;
2344 }
2345
2346 static void
2347 exchange_scr(sc_softc_t *sc)
2348 {
2349     scr_stat *scp;
2350
2351     /* save the current state of video and keyboard */
2352     sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos);
2353     if (!ISGRAPHSC(sc->old_scp))
2354         sc_remove_cursor_image(sc->old_scp);
2355     if (sc->old_scp->kbd_mode == K_XLATE)
2356         save_kbd_state(sc->old_scp);
2357
2358     /* set up the video for the new screen */
2359     scp = sc->cur_scp = sc->new_scp;
2360     if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp))
2361         set_mode(scp);
2362     else
2363         sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2364                     (void *)sc->adp->va_window, FALSE);
2365     scp->status |= MOUSE_HIDDEN;
2366     sc_move_cursor(scp, scp->xpos, scp->ypos);
2367     if (!ISGRAPHSC(scp))
2368         sc_set_cursor_image(scp);
2369 #ifndef SC_NO_PALETTE_LOADING
2370     if (ISGRAPHSC(sc->old_scp))
2371         load_palette(sc->adp, sc->palette);
2372 #endif
2373     sc_set_border(scp, scp->border);
2374
2375     /* set up the keyboard for the new screen */
2376     if (sc->old_scp->kbd_mode != scp->kbd_mode)
2377         kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
2378     update_kbd_state(scp, scp->status, LOCK_MASK);
2379
2380     mark_all(scp);
2381 }
2382
2383 void
2384 sc_puts(scr_stat *scp, u_char *buf, int len)
2385 {
2386 #if NSPLASH > 0
2387     /* make screensaver happy */
2388     if (!sticky_splash && scp == scp->sc->cur_scp)
2389         run_scrn_saver = FALSE;
2390 #endif
2391
2392     if (scp->tsw)
2393         (*scp->tsw->te_puts)(scp, buf, len);
2394
2395     if (scp->sc->delayed_next_scr)
2396         sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
2397 }
2398
2399 void
2400 sc_draw_cursor_image(scr_stat *scp)
2401 {
2402     /* assert(scp == scp->sc->cur_scp); */
2403     ++scp->sc->videoio_in_progress;
2404     (*scp->rndr->draw_cursor)(scp, scp->cursor_pos,
2405                               scp->sc->flags & SC_BLINK_CURSOR, TRUE,
2406                               sc_inside_cutmark(scp, scp->cursor_pos));
2407     scp->cursor_oldpos = scp->cursor_pos;
2408     --scp->sc->videoio_in_progress;
2409 }
2410
2411 void
2412 sc_remove_cursor_image(scr_stat *scp)
2413 {
2414     /* assert(scp == scp->sc->cur_scp); */
2415     ++scp->sc->videoio_in_progress;
2416     (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos,
2417                               scp->sc->flags & SC_BLINK_CURSOR, FALSE,
2418                               sc_inside_cutmark(scp, scp->cursor_oldpos));
2419     --scp->sc->videoio_in_progress;
2420 }
2421
2422 static void
2423 update_cursor_image(scr_stat *scp)
2424 {
2425     int blink;
2426
2427     if (scp->sc->flags & SC_CHAR_CURSOR) {
2428         scp->cursor_base = imax(0, scp->sc->cursor_base);
2429         scp->cursor_height = imin(scp->sc->cursor_height, scp->font_size);
2430     } else {
2431         scp->cursor_base = 0;
2432         scp->cursor_height = scp->font_size;
2433     }
2434     blink = scp->sc->flags & SC_BLINK_CURSOR;
2435
2436     /* assert(scp == scp->sc->cur_scp); */
2437     ++scp->sc->videoio_in_progress;
2438     (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos, blink, FALSE,
2439                               sc_inside_cutmark(scp, scp->cursor_pos));
2440     (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height, blink);
2441     (*scp->rndr->draw_cursor)(scp, scp->cursor_pos, blink, TRUE,
2442                               sc_inside_cutmark(scp, scp->cursor_pos));
2443     --scp->sc->videoio_in_progress;
2444 }
2445
2446 void
2447 sc_set_cursor_image(scr_stat *scp)
2448 {
2449     if (scp->sc->flags & SC_CHAR_CURSOR) {
2450         scp->cursor_base = imax(0, scp->sc->cursor_base);
2451         scp->cursor_height = imin(scp->sc->cursor_height, scp->font_size);
2452     } else {
2453         scp->cursor_base = 0;
2454         scp->cursor_height = scp->font_size;
2455     }
2456
2457     /* assert(scp == scp->sc->cur_scp); */
2458     ++scp->sc->videoio_in_progress;
2459     (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height,
2460                              scp->sc->flags & SC_BLINK_CURSOR);
2461     --scp->sc->videoio_in_progress;
2462 }
2463
2464 static void
2465 scinit(int unit, int flags)
2466 {
2467     /*
2468      * When syscons is being initialized as the kernel console, malloc()
2469      * is not yet functional, because various kernel structures has not been
2470      * fully initialized yet.  Therefore, we need to declare the following
2471      * static buffers for the console.  This is less than ideal,
2472      * but is necessry evil for the time being.  XXX
2473      */
2474     static scr_stat main_console;
2475     static dev_t main_devs[MAXCONS];
2476     static struct tty main_tty;
2477     static u_short sc_buffer[ROW*COL];  /* XXX */
2478 #ifndef SC_NO_FONT_LOADING
2479     static u_char font_8[256*8];
2480     static u_char font_14[256*14];
2481     static u_char font_16[256*16];
2482 #endif
2483
2484     sc_softc_t *sc;
2485     scr_stat *scp;
2486     video_adapter_t *adp;
2487     int col;
2488     int row;
2489     int i;
2490
2491     /* one time initialization */
2492     if (init_done == COLD)
2493         sc_get_bios_values(&bios_value);
2494     init_done = WARM;
2495
2496     /*
2497      * Allocate resources.  Even if we are being called for the second
2498      * time, we must allocate them again, because they might have
2499      * disappeared...
2500      */
2501     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2502     adp = NULL;
2503     if (sc->adapter >= 0) {
2504         vid_release(sc->adp, (void *)&sc->adapter);
2505         adp = sc->adp;
2506         sc->adp = NULL;
2507     }
2508     if (sc->keyboard >= 0) {
2509         DPRINTF(5, ("sc%d: releasing kbd%d\n", unit, sc->keyboard));
2510         i = kbd_release(sc->kbd, (void *)&sc->keyboard);
2511         DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i));
2512         if (sc->kbd != NULL) {
2513             DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n",
2514                 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2515         }
2516         sc->kbd = NULL;
2517     }
2518     sc->adapter = vid_allocate("*", unit, (void *)&sc->adapter);
2519     sc->adp = vid_get_adapter(sc->adapter);
2520     /* assert((sc->adapter >= 0) && (sc->adp != NULL)) */
2521     sc->keyboard = kbd_allocate("*", unit, (void *)&sc->keyboard,
2522                                 sckbdevent, sc);
2523     DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard));
2524     sc->kbd = kbd_get_keyboard(sc->keyboard);
2525     if (sc->kbd != NULL) {
2526         DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n",
2527                 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2528     }
2529
2530     if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) {
2531
2532         sc->initial_mode = sc->adp->va_initial_mode;
2533
2534 #ifndef SC_NO_FONT_LOADING
2535         if (flags & SC_KERNEL_CONSOLE) {
2536             sc->font_8 = font_8;
2537             sc->font_14 = font_14;
2538             sc->font_16 = font_16;
2539         } else if (sc->font_8 == NULL) {
2540             /* assert(sc_malloc) */
2541             sc->font_8 = malloc(sizeof(font_8), M_DEVBUF, M_WAITOK);
2542             sc->font_14 = malloc(sizeof(font_14), M_DEVBUF, M_WAITOK);
2543             sc->font_16 = malloc(sizeof(font_16), M_DEVBUF, M_WAITOK);
2544         }
2545 #endif
2546
2547         /* extract the hardware cursor location and hide the cursor for now */
2548         (*vidsw[sc->adapter]->read_hw_cursor)(sc->adp, &col, &row);
2549         (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, -1, -1);
2550
2551         /* set up the first console */
2552         sc->first_vty = unit*MAXCONS;
2553         sc->vtys = MAXCONS;             /* XXX: should be configurable */
2554         if (flags & SC_KERNEL_CONSOLE) {
2555             sc->dev = main_devs;
2556             sc->dev[0] = makedev(CDEV_MAJOR, unit*MAXCONS);
2557             sc->dev[0]->si_tty = &main_tty;
2558             ttyregister(&main_tty);
2559             scp = &main_console;
2560             init_scp(sc, sc->first_vty, scp);
2561             sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
2562                         (void *)sc_buffer, FALSE);
2563             if (sc_init_emulator(scp, SC_DFLT_TERM))
2564                 sc_init_emulator(scp, "*");
2565             (*scp->tsw->te_default_attr)(scp,
2566                                          kernel_default.std_color,
2567                                          kernel_default.rev_color);
2568         } else {
2569             /* assert(sc_malloc) */
2570             sc->dev = malloc(sizeof(dev_t)*sc->vtys, M_DEVBUF, M_WAITOK);
2571             bzero(sc->dev, sizeof(dev_t)*sc->vtys);
2572             sc->dev[0] = makedev(CDEV_MAJOR, unit*MAXCONS);
2573             sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
2574             scp = alloc_scp(sc, sc->first_vty);
2575         }
2576         SC_STAT(sc->dev[0]) = scp;
2577         sc->cur_scp = scp;
2578
2579         /* copy screen to temporary buffer */
2580         sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2581                     (void *)scp->sc->adp->va_window, FALSE);
2582         if (ISTEXTSC(scp))
2583             sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
2584
2585         /* move cursors to the initial positions */
2586         if (col >= scp->xsize)
2587             col = 0;
2588         if (row >= scp->ysize)
2589             row = scp->ysize - 1;
2590         scp->xpos = col;
2591         scp->ypos = row;
2592         scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
2593         if (bios_value.cursor_end < scp->font_size)
2594             sc->cursor_base = scp->font_size - bios_value.cursor_end - 1;
2595         else
2596             sc->cursor_base = 0;
2597         i = bios_value.cursor_end - bios_value.cursor_start + 1;
2598         sc->cursor_height = imin(i, scp->font_size);
2599 #ifndef SC_NO_SYSMOUSE
2600         sc_mouse_move(scp, scp->xpixel/2, scp->ypixel/2);
2601 #endif
2602         if (!ISGRAPHSC(scp)) {
2603             sc_set_cursor_image(scp);
2604             sc_draw_cursor_image(scp);
2605         }
2606
2607         /* save font and palette */
2608 #ifndef SC_NO_FONT_LOADING
2609         sc->fonts_loaded = 0;
2610         if (ISFONTAVAIL(sc->adp->va_flags)) {
2611 #ifdef SC_DFLT_FONT
2612             bcopy(dflt_font_8, sc->font_8, sizeof(dflt_font_8));
2613             bcopy(dflt_font_14, sc->font_14, sizeof(dflt_font_14));
2614             bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16));
2615             sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8;
2616             if (scp->font_size < 14) {
2617                 sc_load_font(scp, 0, 8, sc->font_8, 0, 256);
2618             } else if (scp->font_size >= 16) {
2619                 sc_load_font(scp, 0, 16, sc->font_16, 0, 256);
2620             } else {
2621                 sc_load_font(scp, 0, 14, sc->font_14, 0, 256);
2622             }
2623 #else /* !SC_DFLT_FONT */
2624             if (scp->font_size < 14) {
2625                 sc_save_font(scp, 0, 8, sc->font_8, 0, 256);
2626                 sc->fonts_loaded = FONT_8;
2627             } else if (scp->font_size >= 16) {
2628                 sc_save_font(scp, 0, 16, sc->font_16, 0, 256);
2629                 sc->fonts_loaded = FONT_16;
2630             } else {
2631                 sc_save_font(scp, 0, 14, sc->font_14, 0, 256);
2632                 sc->fonts_loaded = FONT_14;
2633             }
2634 #endif /* SC_DFLT_FONT */
2635             /* FONT KLUDGE: always use the font page #0. XXX */
2636             sc_show_font(scp, 0);
2637         }
2638 #endif /* !SC_NO_FONT_LOADING */
2639
2640 #ifndef SC_NO_PALETTE_LOADING
2641         save_palette(sc->adp, sc->palette);
2642 #endif
2643
2644 #if NSPLASH > 0
2645         if (!(sc->flags & SC_SPLASH_SCRN) && (flags & SC_KERNEL_CONSOLE)) {
2646             /* we are ready to put up the splash image! */
2647             splash_init(sc->adp, scsplash_callback, sc);
2648             sc->flags |= SC_SPLASH_SCRN;
2649         }
2650 #endif /* NSPLASH */
2651     }
2652
2653     /* the rest is not necessary, if we have done it once */
2654     if (sc->flags & SC_INIT_DONE)
2655         return;
2656
2657     /* initialize mapscrn arrays to a one to one map */
2658     for (i = 0; i < sizeof(sc->scr_map); i++)
2659         sc->scr_map[i] = sc->scr_rmap[i] = i;
2660
2661     sc->flags |= SC_INIT_DONE;
2662 }
2663
2664 #if __i386__
2665 static void
2666 scterm(int unit, int flags)
2667 {
2668     sc_softc_t *sc;
2669     scr_stat *scp;
2670
2671     sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2672     if (sc == NULL)
2673         return;                 /* shouldn't happen */
2674
2675 #if NSPLASH > 0
2676     /* this console is no longer available for the splash screen */
2677     if (sc->flags & SC_SPLASH_SCRN) {
2678         splash_term(sc->adp);
2679         sc->flags &= ~SC_SPLASH_SCRN;
2680     }
2681 #endif /* NSPLASH */
2682
2683 #if 0 /* XXX */
2684     /* move the hardware cursor to the upper-left corner */
2685     (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, 0, 0);
2686 #endif
2687
2688     /* release the keyboard and the video card */
2689     if (sc->keyboard >= 0)
2690         kbd_release(sc->kbd, &sc->keyboard);
2691     if (sc->adapter >= 0)
2692         vid_release(sc->adp, &sc->adapter);
2693
2694     /* stop the terminal emulator, if any */
2695     scp = SC_STAT(sc->dev[0]);
2696     if (scp->tsw)
2697         (*scp->tsw->te_term)(scp, &scp->ts);
2698     if (scp->ts != NULL)
2699         free(scp->ts, M_DEVBUF);
2700
2701     /* clear the structure */
2702     if (!(flags & SC_KERNEL_CONSOLE)) {
2703         /* XXX: We need delete_dev() for this */
2704         free(sc->dev, M_DEVBUF);
2705 #if 0
2706         /* XXX: We need a ttyunregister for this */
2707         free(sc->tty, M_DEVBUF);
2708 #endif
2709 #ifndef SC_NO_FONT_LOADING
2710         free(sc->font_8, M_DEVBUF);
2711         free(sc->font_14, M_DEVBUF);
2712         free(sc->font_16, M_DEVBUF);
2713 #endif
2714         /* XXX vtb, history */
2715     }
2716     bzero(sc, sizeof(*sc));
2717     sc->keyboard = -1;
2718     sc->adapter = -1;
2719 }
2720 #endif
2721
2722 static void
2723 scshutdown(void *arg, int howto)
2724 {
2725     /* assert(sc_console != NULL) */
2726
2727     sc_touch_scrn_saver();
2728     if (!cold && sc_console
2729         && sc_console->sc->cur_scp->smode.mode == VT_AUTO
2730         && sc_console->smode.mode == VT_AUTO)
2731         sc_switch_scr(sc_console->sc, sc_console->index);
2732     shutdown_in_progress = TRUE;
2733 }
2734
2735 int
2736 sc_clean_up(scr_stat *scp)
2737 {
2738 #if NSPLASH > 0
2739     int error;
2740 #endif /* NSPLASH */
2741
2742     if (scp->sc->flags & SC_SCRN_BLANKED) {
2743         sc_touch_scrn_saver();
2744 #if NSPLASH > 0
2745         if ((error = wait_scrn_saver_stop(scp->sc)))
2746             return error;
2747 #endif /* NSPLASH */
2748     }
2749     scp->status |= MOUSE_HIDDEN;
2750     sc_remove_mouse_image(scp);
2751     sc_remove_cutmarking(scp);
2752     return 0;
2753 }
2754
2755 void
2756 sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard)
2757 {
2758     sc_vtb_t new;
2759     sc_vtb_t old;
2760
2761     old = scp->vtb;
2762     sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait);
2763     if (!discard && (old.vtb_flags & VTB_VALID)) {
2764         /* retain the current cursor position and buffer contants */
2765         scp->cursor_oldpos = scp->cursor_pos;
2766         /*
2767          * This works only if the old buffer has the same size as or larger
2768          * than the new one. XXX
2769          */
2770         sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize);
2771         scp->vtb = new;
2772     } else {
2773         scp->vtb = new;
2774         sc_vtb_destroy(&old);
2775     }
2776
2777 #ifndef SC_NO_SYSMOUSE
2778     /* move the mouse cursor at the center of the screen */
2779     sc_mouse_move(scp, scp->xpixel / 2, scp->ypixel / 2);
2780 #endif
2781 }
2782
2783 static scr_stat
2784 *alloc_scp(sc_softc_t *sc, int vty)
2785 {
2786     scr_stat *scp;
2787
2788     /* assert(sc_malloc) */
2789
2790     scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_WAITOK);
2791     init_scp(sc, vty, scp);
2792
2793     sc_alloc_scr_buffer(scp, TRUE, TRUE);
2794     if (sc_init_emulator(scp, SC_DFLT_TERM))
2795         sc_init_emulator(scp, "*");
2796
2797 #ifndef SC_NO_CUTPASTE
2798     sc_alloc_cut_buffer(scp, TRUE);
2799 #endif
2800
2801 #ifndef SC_NO_HISTORY
2802     sc_alloc_history_buffer(scp, 0, 0, TRUE);
2803 #endif
2804
2805     return scp;
2806 }
2807
2808 static void
2809 init_scp(sc_softc_t *sc, int vty, scr_stat *scp)
2810 {
2811     video_info_t info;
2812
2813     bzero(scp, sizeof(*scp));
2814
2815     scp->index = vty;
2816     scp->sc = sc;
2817     scp->status = 0;
2818     scp->mode = sc->initial_mode;
2819     (*vidsw[sc->adapter]->get_info)(sc->adp, scp->mode, &info);
2820     if (info.vi_flags & V_INFO_GRAPHICS) {
2821         scp->status |= GRAPHICS_MODE;
2822         scp->xpixel = info.vi_width;
2823         scp->ypixel = info.vi_height;
2824         scp->xsize = info.vi_width/8;
2825         scp->ysize = info.vi_height/info.vi_cheight;
2826         scp->font_size = 0;
2827         scp->font = NULL;
2828     } else {
2829         scp->xsize = info.vi_width;
2830         scp->ysize = info.vi_height;
2831         scp->xpixel = scp->xsize*8;
2832         scp->ypixel = scp->ysize*info.vi_cheight;
2833         if (info.vi_cheight < 14) {
2834             scp->font_size = 8;
2835 #ifndef SC_NO_FONT_LOADING
2836             scp->font = sc->font_8;
2837 #else
2838             scp->font = NULL;
2839 #endif
2840         } else if (info.vi_cheight >= 16) {
2841             scp->font_size = 16;
2842 #ifndef SC_NO_FONT_LOADING
2843             scp->font = sc->font_16;
2844 #else
2845             scp->font = NULL;
2846 #endif
2847         } else {
2848             scp->font_size = 14;
2849 #ifndef SC_NO_FONT_LOADING
2850             scp->font = sc->font_14;
2851 #else
2852             scp->font = NULL;
2853 #endif
2854         }
2855     }
2856     sc_vtb_init(&scp->vtb, VTB_MEMORY, 0, 0, NULL, FALSE);
2857     sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE);
2858     scp->xoff = scp->yoff = 0;
2859     scp->xpos = scp->ypos = 0;
2860     scp->start = scp->xsize * scp->ysize - 1;
2861     scp->end = 0;
2862     scp->tsw = NULL;
2863     scp->ts = NULL;
2864     scp->rndr = NULL;
2865     scp->border = BG_BLACK;
2866     scp->cursor_base = sc->cursor_base;
2867     scp->cursor_height = imin(sc->cursor_height, scp->font_size);
2868     scp->mouse_cut_start = scp->xsize*scp->ysize;
2869     scp->mouse_cut_end = -1;
2870     scp->mouse_signal = 0;
2871     scp->mouse_pid = 0;
2872     scp->mouse_proc = NULL;
2873     scp->kbd_mode = K_XLATE;
2874     scp->bell_pitch = bios_value.bell_pitch;
2875     scp->bell_duration = BELL_DURATION;
2876     scp->status |= (bios_value.shift_state & NLKED);
2877     scp->status |= CURSOR_ENABLED | MOUSE_HIDDEN;
2878     scp->pid = 0;
2879     scp->proc = NULL;
2880     scp->smode.mode = VT_AUTO;
2881     scp->history = NULL;
2882     scp->history_pos = 0;
2883     scp->history_size = 0;
2884 }
2885
2886 int
2887 sc_init_emulator(scr_stat *scp, char *name)
2888 {
2889     sc_term_sw_t *sw;
2890     sc_rndr_sw_t *rndr;
2891     void *p;
2892     int error;
2893
2894     if (name == NULL)   /* if no name is given, use the current emulator */
2895         sw = scp->tsw;
2896     else                /* ...otherwise find the named emulator */
2897         sw = sc_term_match(name);
2898     if (sw == NULL)
2899         return EINVAL;
2900
2901     rndr = NULL;
2902     if (strcmp(sw->te_renderer, "*") != 0) {
2903         rndr = sc_render_match(scp, sw->te_renderer,
2904                                scp->status & (GRAPHICS_MODE | PIXEL_MODE));
2905     }
2906     if (rndr == NULL) {
2907         rndr = sc_render_match(scp, scp->sc->adp->va_name,
2908                                scp->status & (GRAPHICS_MODE | PIXEL_MODE));
2909         if (rndr == NULL)
2910             return ENODEV;
2911     }
2912
2913     if (sw == scp->tsw) {
2914         error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT);
2915         scp->rndr = rndr;
2916         sc_clear_screen(scp);
2917         /* assert(error == 0); */
2918         return error;
2919     }
2920
2921     if (sc_malloc && (sw->te_size > 0))
2922         p = malloc(sw->te_size, M_DEVBUF, M_NOWAIT);
2923     else
2924         p = NULL;
2925     error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT);
2926     if (error)
2927         return error;
2928
2929     if (scp->tsw)
2930         (*scp->tsw->te_term)(scp, &scp->ts);
2931     if (scp->ts != NULL)
2932         free(scp->ts, M_DEVBUF);
2933     scp->tsw = sw;
2934     scp->ts = p;
2935     scp->rndr = rndr;
2936
2937     /* XXX */
2938     (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color);
2939     sc_clear_screen(scp);
2940
2941     return 0;
2942 }
2943
2944 /*
2945  * scgetc(flags) - get character from keyboard.
2946  * If flags & SCGETC_CN, then avoid harmful side effects.
2947  * If flags & SCGETC_NONBLOCK, then wait until a key is pressed, else
2948  * return NOKEY if there is nothing there.
2949  */
2950 static u_int
2951 scgetc(sc_softc_t *sc, u_int flags)
2952 {
2953     scr_stat *scp;
2954 #ifndef SC_NO_HISTORY
2955     struct tty *tp;
2956 #endif
2957     u_int c;
2958     int this_scr;
2959     int f;
2960     int i;
2961
2962     if (sc->kbd == NULL)
2963         return NOKEY;
2964
2965 next_code:
2966 #if 1
2967     /* I don't like this, but... XXX */
2968     if (flags & SCGETC_CN)
2969         sccnupdate(sc->cur_scp);
2970 #endif
2971     scp = sc->cur_scp;
2972     /* first see if there is something in the keyboard port */
2973     for (;;) {
2974         c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK));
2975         if (c == ERRKEY) {
2976             if (!(flags & SCGETC_CN))
2977                 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
2978         } else if (c == NOKEY)
2979             return c;
2980         else
2981             break;
2982     }
2983
2984     /* make screensaver happy */
2985     if (!(c & RELKEY))
2986         sc_touch_scrn_saver();
2987
2988 #ifdef __i386__
2989     if (!(flags & SCGETC_CN))
2990         /* do the /dev/random device a favour */
2991         add_keyboard_randomness(c);
2992 #endif
2993
2994     if (scp->kbd_mode != K_XLATE)
2995         return KEYCHAR(c);
2996
2997     /* if scroll-lock pressed allow history browsing */
2998     if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) {
2999
3000         scp->status &= ~CURSOR_ENABLED;
3001         sc_remove_cursor_image(scp);
3002
3003 #ifndef SC_NO_HISTORY
3004         if (!(scp->status & BUFFER_SAVED)) {
3005             scp->status |= BUFFER_SAVED;
3006             sc_hist_save(scp);
3007         }
3008         switch (c) {
3009         /* FIXME: key codes */
3010         case SPCLKEY | FKEY | F(49):  /* home key */
3011             sc_remove_cutmarking(scp);
3012             sc_hist_home(scp);
3013             goto next_code;
3014
3015         case SPCLKEY | FKEY | F(57):  /* end key */
3016             sc_remove_cutmarking(scp);
3017             sc_hist_end(scp);
3018             goto next_code;
3019
3020         case SPCLKEY | FKEY | F(50):  /* up arrow key */
3021             sc_remove_cutmarking(scp);
3022             if (sc_hist_up_line(scp))
3023                 if (!(flags & SCGETC_CN))
3024                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3025             goto next_code;
3026
3027         case SPCLKEY | FKEY | F(58):  /* down arrow key */
3028             sc_remove_cutmarking(scp);
3029             if (sc_hist_down_line(scp))
3030                 if (!(flags & SCGETC_CN))
3031                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3032             goto next_code;
3033
3034         case SPCLKEY | FKEY | F(51):  /* page up key */
3035             sc_remove_cutmarking(scp);
3036             for (i=0; i<scp->ysize; i++)
3037             if (sc_hist_up_line(scp)) {
3038                 if (!(flags & SCGETC_CN))
3039                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3040                 break;
3041             }
3042             goto next_code;
3043
3044         case SPCLKEY | FKEY | F(59):  /* page down key */
3045             sc_remove_cutmarking(scp);
3046             for (i=0; i<scp->ysize; i++)
3047             if (sc_hist_down_line(scp)) {
3048                 if (!(flags & SCGETC_CN))
3049                     sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3050                 break;
3051             }
3052             goto next_code;
3053         }
3054 #endif /* SC_NO_HISTORY */
3055     }
3056
3057     /*
3058      * Process and consume special keys here.  Return a plain char code
3059      * or a char code with the META flag or a function key code.
3060      */
3061     if (c & RELKEY) {
3062         /* key released */
3063         /* goto next_code */
3064     } else {
3065         /* key pressed */
3066         if (c & SPCLKEY) {
3067             c &= ~SPCLKEY;
3068             switch (KEYCHAR(c)) {
3069             /* LOCKING KEYS */
3070             case NLK: case CLK: case ALK:
3071                 break;
3072             case SLK:
3073                 kbd_ioctl(sc->kbd, KDGKBSTATE, (caddr_t)&f);
3074                 if (f & SLKED) {
3075                     scp->status |= SLKED;
3076                 } else {
3077                     if (scp->status & SLKED) {
3078                         scp->status &= ~SLKED;
3079 #ifndef SC_NO_HISTORY
3080                         if (scp->status & BUFFER_SAVED) {
3081                             if (!sc_hist_restore(scp))
3082                                 sc_remove_cutmarking(scp);
3083                             scp->status &= ~BUFFER_SAVED;
3084                             scp->status |= CURSOR_ENABLED;
3085                             sc_draw_cursor_image(scp);
3086                         }
3087                         tp = VIRTUAL_TTY(sc, scp->index);
3088                         if (ISTTYOPEN(tp))
3089                             scstart(tp);
3090 #endif
3091                     }
3092                 }
3093                 break;
3094
3095             /* NON-LOCKING KEYS */
3096             case NOP:
3097             case LSH:  case RSH:  case LCTR: case RCTR:
3098             case LALT: case RALT: case ASH:  case META:
3099                 break;
3100
3101             case BTAB:
3102                 if (!(sc->flags & SC_SCRN_BLANKED))
3103                     return c;
3104                 break;
3105
3106             case SPSC:
3107 #if NSPLASH > 0
3108                 /* force activatation/deactivation of the screen saver */
3109                 if (!(sc->flags & SC_SCRN_BLANKED)) {
3110                     run_scrn_saver = TRUE;
3111                     sc->scrn_time_stamp -= scrn_blank_time;
3112                 }
3113                 if (cold) {
3114                     /*
3115                      * While devices are being probed, the screen saver need
3116                      * to be invoked explictly. XXX
3117                      */
3118                     if (sc->flags & SC_SCRN_BLANKED) {
3119                         scsplash_stick(FALSE);
3120                         stop_scrn_saver(sc, current_saver);
3121                     } else {
3122                         if (!ISGRAPHSC(scp)) {
3123                             scsplash_stick(TRUE);
3124                             (*current_saver)(sc, TRUE);
3125                         }
3126                     }
3127                 }
3128 #endif /* NSPLASH */
3129                 break;
3130
3131             case RBT:
3132 #ifndef SC_DISABLE_REBOOT
3133                 shutdown_nice(0);
3134 #endif
3135                 break;
3136
3137             case HALT:
3138 #ifndef SC_DISABLE_REBOOT
3139                 shutdown_nice(RB_HALT);
3140 #endif
3141                 break;
3142
3143             case PDWN:
3144 #ifndef SC_DISABLE_REBOOT
3145                 shutdown_nice(RB_HALT|RB_POWEROFF);
3146 #endif
3147                 break;
3148
3149 #if NAPM > 0
3150             case SUSP:
3151                 apm_suspend(PMST_SUSPEND);
3152                 break;
3153             case STBY:
3154                 apm_suspend(PMST_STANDBY);
3155                 break;
3156 #else
3157             case SUSP:
3158             case STBY:
3159                 break;
3160 #endif
3161
3162             case DBG:
3163 #ifndef SC_DISABLE_DDBKEY
3164 #ifdef DDB
3165                 Debugger("manual escape to debugger");
3166 #else
3167                 printf("No debugger in kernel\n");
3168 #endif
3169 #else /* SC_DISABLE_DDBKEY */
3170                 /* do nothing */
3171 #endif /* SC_DISABLE_DDBKEY */
3172                 break;
3173
3174             case PNC:
3175                 if (enable_panic_key)
3176                         panic("Forced by the panic key");
3177                 break;
3178
3179             case NEXT:
3180                 this_scr = scp->index;
3181                 for (i = (this_scr - sc->first_vty + 1)%sc->vtys;
3182                         sc->first_vty + i != this_scr;
3183                         i = (i + 1)%sc->vtys) {
3184                     struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3185                     if (ISTTYOPEN(tp)) {
3186                         sc_switch_scr(scp->sc, sc->first_vty + i);
3187                         break;
3188                     }
3189                 }
3190                 break;
3191
3192             case PREV:
3193                 this_scr = scp->index;
3194                 for (i = (this_scr - sc->first_vty + sc->vtys - 1)%sc->vtys;
3195                         sc->first_vty + i != this_scr;
3196                         i = (i + sc->vtys - 1)%sc->vtys) {
3197                     struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3198                     if (ISTTYOPEN(tp)) {
3199                         sc_switch_scr(scp->sc, sc->first_vty + i);
3200                         break;
3201                     }
3202                 }
3203                 break;
3204
3205             default:
3206                 if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) {
3207                     sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR);
3208                     break;
3209                 }
3210                 /* assert(c & FKEY) */
3211                 if (!(sc->flags & SC_SCRN_BLANKED))
3212                     return c;
3213                 break;
3214             }
3215             /* goto next_code */
3216         } else {
3217             /* regular keys (maybe MKEY is set) */
3218             if (!(sc->flags & SC_SCRN_BLANKED))
3219                 return c;
3220         }
3221     }
3222
3223     goto next_code;
3224 }
3225
3226 int
3227 scmmap(dev_t dev, vm_offset_t offset, int nprot)
3228 {
3229     scr_stat *scp;
3230
3231     scp = SC_STAT(dev);
3232     if (scp != scp->sc->cur_scp)
3233         return -1;
3234     return (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp, offset, nprot);
3235 }
3236
3237 static int
3238 save_kbd_state(scr_stat *scp)
3239 {
3240     int state;
3241     int error;
3242
3243     error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3244     if (error == ENOIOCTL)
3245         error = ENODEV;
3246     if (error == 0) {
3247         scp->status &= ~LOCK_MASK;
3248         scp->status |= state;
3249     }
3250     return error;
3251 }
3252
3253 static int
3254 update_kbd_state(scr_stat *scp, int new_bits, int mask)
3255 {
3256     int state;
3257     int error;
3258
3259     if (mask != LOCK_MASK) {
3260         error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3261         if (error == ENOIOCTL)
3262             error = ENODEV;
3263         if (error)
3264             return error;
3265         state &= ~mask;
3266         state |= new_bits & mask;
3267     } else {
3268         state = new_bits & LOCK_MASK;
3269     }
3270     error = kbd_ioctl(scp->sc->kbd, KDSKBSTATE, (caddr_t)&state);
3271     if (error == ENOIOCTL)
3272         error = ENODEV;
3273     return error;
3274 }
3275
3276 static int
3277 update_kbd_leds(scr_stat *scp, int which)
3278 {
3279     int error;
3280
3281     which &= LOCK_MASK;
3282     error = kbd_ioctl(scp->sc->kbd, KDSETLED, (caddr_t)&which);
3283     if (error == ENOIOCTL)
3284         error = ENODEV;
3285     return error;
3286 }
3287
3288 int
3289 set_mode(scr_stat *scp)
3290 {
3291     video_info_t info;
3292
3293     /* reject unsupported mode */
3294     if ((*vidsw[scp->sc->adapter]->get_info)(scp->sc->adp, scp->mode, &info))
3295         return 1;
3296
3297     /* if this vty is not currently showing, do nothing */
3298     if (scp != scp->sc->cur_scp)
3299         return 0;
3300
3301     /* setup video hardware for the given mode */
3302     (*vidsw[scp->sc->adapter]->set_mode)(scp->sc->adp, scp->mode);
3303     sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3304                 (void *)scp->sc->adp->va_window, FALSE);
3305
3306 #ifndef SC_NO_FONT_LOADING
3307     /* load appropriate font */
3308     if (!(scp->status & GRAPHICS_MODE)) {
3309         if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) {
3310             if (scp->font_size < 14) {
3311                 if (scp->sc->fonts_loaded & FONT_8)
3312                     sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256);
3313             } else if (scp->font_size >= 16) {
3314                 if (scp->sc->fonts_loaded & FONT_16)
3315                     sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256);
3316             } else {
3317                 if (scp->sc->fonts_loaded & FONT_14)
3318                     sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256);
3319             }
3320             /*
3321              * FONT KLUDGE:
3322              * This is an interim kludge to display correct font.
3323              * Always use the font page #0 on the video plane 2.
3324              * Somehow we cannot show the font in other font pages on
3325              * some video cards... XXX
3326              */
3327             sc_show_font(scp, 0);
3328         }
3329         mark_all(scp);
3330     }
3331 #endif /* !SC_NO_FONT_LOADING */
3332
3333     sc_set_border(scp, scp->border);
3334     sc_set_cursor_image(scp);
3335
3336     return 0;
3337 }
3338
3339 void
3340 sc_set_border(scr_stat *scp, int color)
3341 {
3342     ++scp->sc->videoio_in_progress;
3343     (*scp->rndr->draw_border)(scp, color);
3344     --scp->sc->videoio_in_progress;
3345 }
3346
3347 #ifndef SC_NO_FONT_LOADING
3348 void
3349 sc_load_font(scr_stat *scp, int page, int size, u_char *buf,
3350              int base, int count)
3351 {
3352     sc_softc_t *sc;
3353
3354     sc = scp->sc;
3355     sc->font_loading_in_progress = TRUE;
3356     (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count);
3357     sc->font_loading_in_progress = FALSE;
3358 }
3359
3360 void
3361 sc_save_font(scr_stat *scp, int page, int size, u_char *buf,
3362              int base, int count)
3363 {
3364     sc_softc_t *sc;
3365
3366     sc = scp->sc;
3367     sc->font_loading_in_progress = TRUE;
3368     (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count);
3369     sc->font_loading_in_progress = FALSE;
3370 }
3371
3372 void
3373 sc_show_font(scr_stat *scp, int page)
3374 {
3375     (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page);
3376 }
3377 #endif /* !SC_NO_FONT_LOADING */
3378
3379 void
3380 sc_paste(scr_stat *scp, u_char *p, int count)
3381 {
3382     struct tty *tp;
3383     u_char *rmap;
3384
3385     if (scp->status & MOUSE_VISIBLE) {
3386         tp = VIRTUAL_TTY(scp->sc, scp->sc->cur_scp->index);
3387         if (!ISTTYOPEN(tp))
3388             return;
3389         rmap = scp->sc->scr_rmap;
3390         for (; count > 0; --count)
3391             (*linesw[tp->t_line].l_rint)(rmap[*p++], tp);
3392     }
3393 }
3394
3395 void
3396 sc_bell(scr_stat *scp, int pitch, int duration)
3397 {
3398     if (cold || shutdown_in_progress)
3399         return;
3400
3401     if (scp != scp->sc->cur_scp && (scp->sc->flags & SC_QUIET_BELL))
3402         return;
3403
3404     if (scp->sc->flags & SC_VISUAL_BELL) {
3405         if (scp->sc->blink_in_progress)
3406             return;
3407         scp->sc->blink_in_progress = 3;
3408         if (scp != scp->sc->cur_scp)
3409             scp->sc->blink_in_progress += 2;
3410         blink_screen(scp->sc->cur_scp);
3411     } else {
3412         if (scp != scp->sc->cur_scp)
3413             pitch *= 2;
3414         sysbeep(pitch, duration);
3415     }
3416 }
3417
3418 static void
3419 blink_screen(void *arg)
3420 {
3421     scr_stat *scp = arg;
3422     struct tty *tp;
3423
3424     if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
3425         scp->sc->blink_in_progress = 0;
3426         mark_all(scp);
3427         tp = VIRTUAL_TTY(scp->sc, scp->index);
3428         if (ISTTYOPEN(tp))
3429             scstart(tp);
3430         if (scp->sc->delayed_next_scr)
3431             sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
3432     }
3433     else {
3434         (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
3435                            scp->sc->blink_in_progress & 1);
3436         scp->sc->blink_in_progress--;
3437         timeout(blink_screen, scp, hz / 10);
3438     }
3439 }