stand/i386/libi386/vidconsole.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith (msmith@freebsd.org)
   3  * Copyright (c) 1997 Kazutaka YOKOTA (yokota@zodiac.mech.utsunomiya-u.ac.jp)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  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  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      Id: probe_keyboard.c,v 1.13 1997/06/09 05:10:55 bde Exp
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <stand.h>
  34 #include <sys/param.h>
  35 #include <bootstrap.h>
  36 #include <btxv86.h>
  37 #include <gfx_fb.h>
  38 #include <teken.h>
  39 #include <stdbool.h>
  40 #include "vbe.h"
  41
  42 #include <dev/vt/hw/vga/vt_vga_reg.h>
  43
  44 #include "libi386.h"
  45
  46 #if KEYBOARD_PROBE
  47 static int      probe_keyboard(void);
  48 #endif
  49 static void     vidc_probe(struct console *cp);
  50 static int      vidc_init(int arg);
  51 static void     vidc_putchar(int c);
  52 static int      vidc_getchar(void);
  53 static int      vidc_ischar(void);
  54 static void     cons_draw_frame(teken_attr_t *);
  55
  56 static bool     vidc_started;
  57 static uint16_t *vgatext;
  58
  59 static tf_bell_t        vidc_cons_bell;
  60 static tf_cursor_t      vidc_text_cursor;
  61 static tf_putchar_t     vidc_text_putchar;
  62 static tf_fill_t        vidc_text_fill;
  63 static tf_copy_t        vidc_text_copy;
  64 static tf_param_t       vidc_text_param;
  65 static tf_respond_t     vidc_cons_respond;
  66
  67 static teken_funcs_t tf = {
  68         .tf_bell        = vidc_cons_bell,
  69         .tf_cursor      = vidc_text_cursor,
  70         .tf_putchar     = vidc_text_putchar,
  71         .tf_fill        = vidc_text_fill,
  72         .tf_copy        = vidc_text_copy,
  73         .tf_param       = vidc_text_param,
  74         .tf_respond     = vidc_cons_respond,
  75 };
  76
  77 static teken_funcs_t tfx = {
  78         .tf_bell        = vidc_cons_bell,
  79         .tf_cursor      = gfx_fb_cursor,
  80         .tf_putchar     = gfx_fb_putchar,
  81         .tf_fill        = gfx_fb_fill,
  82         .tf_copy        = gfx_fb_copy,
  83         .tf_param       = gfx_fb_param,
  84         .tf_respond     = vidc_cons_respond,
  85 };
  86
  87 #define KEYBUFSZ        10
  88
  89 static uint8_t  keybuf[KEYBUFSZ];       /* keybuf for extended codes */
  90
  91 struct console vidconsole = {
  92         .c_name = "vidconsole",
  93         .c_desc = "internal video/keyboard",
  94         .c_flags = 0,
  95         .c_probe = vidc_probe,
  96         .c_init = vidc_init,
  97         .c_out = vidc_putchar,
  98         .c_in = vidc_getchar,
  99         .c_ready = vidc_ischar
 100 };
 101
 102 /*
 103  * This function is used to mark a rectangular image area so the scrolling
 104  * will know we need to copy the data from there.
 105  */
 106 void
 107 term_image_display(teken_gfx_t *state, const teken_rect_t *r)
 108 {
 109         teken_pos_t p;
 110         int idx;
 111
 112         if (screen_buffer == NULL)
 113                 return;
 114
 115         for (p.tp_row = r->tr_begin.tp_row;
 116             p.tp_row < r->tr_end.tp_row; p.tp_row++) {
 117                 for (p.tp_col = r->tr_begin.tp_col;
 118                     p.tp_col < r->tr_end.tp_col; p.tp_col++) {
 119                         idx = p.tp_col + p.tp_row * state->tg_tp.tp_col;
 120                         if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row)
 121                                 return;
 122                         screen_buffer[idx].a.ta_format |= TF_IMAGE;
 123                 }
 124         }
 125 }
 126
 127 static void
 128 vidc_text_set_cursor(teken_unit_t row, teken_unit_t col, bool visible)
 129 {
 130         uint16_t addr;
 131         uint8_t msl, s, e;
 132
 133         msl = vga_get_crtc(VGA_REG_BASE, VGA_CRTC_MAX_SCAN_LINE) & 0x1f;
 134         s = vga_get_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_START) & 0xC0;
 135         e = vga_get_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_END);
 136
 137         if (visible == true) {
 138                 addr = row * TEXT_COLS + col;
 139                 vga_set_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_LOC_HIGH, addr >> 8);
 140                 vga_set_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_LOC_LOW,
 141                     addr & 0xff);
 142                 e = msl;
 143         } else {
 144                 s |= (1<<5);
 145         }
 146         vga_set_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_START, s);
 147         vga_set_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_END, e);
 148 }
 149
 150 static void
 151 vidc_text_get_cursor(teken_unit_t *row, teken_unit_t *col)
 152 {
 153         uint16_t addr;
 154
 155         addr = (vga_get_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_LOC_HIGH) << 8) +
 156             vga_get_crtc(VGA_REG_BASE, VGA_CRTC_CURSOR_LOC_LOW);
 157
 158         *row = addr / TEXT_COLS;
 159         *col = addr % TEXT_COLS;
 160 }
 161
 162 /*
 163  * Not implemented.
 164  */
 165 static void
 166 vidc_cons_bell(void *s __unused)
 167 {
 168 }
 169
 170 static void
 171 vidc_text_cursor(void *s __unused, const teken_pos_t *p)
 172 {
 173         teken_unit_t row, col;
 174
 175         if (p->tp_col == TEXT_COLS)
 176                 col = p->tp_col - 1;
 177         else
 178                 col = p->tp_col;
 179
 180         if (p->tp_row == TEXT_ROWS)
 181                 row = p->tp_row - 1;
 182         else
 183                 row = p->tp_row;
 184
 185         vidc_text_set_cursor(row, col, true);
 186 }
 187
 188 /*
 189  * Binary searchable table for Unicode to CP437 conversion.
 190  */
 191 struct unicp437 {
 192         uint16_t        unicode_base;
 193         uint8_t         cp437_base;
 194         uint8_t         length;
 195 };
 196
 197 static const struct unicp437 cp437table[] = {
 198         { 0x0020, 0x20, 0x5e }, { 0x00a0, 0x20, 0x00 },
 199         { 0x00a1, 0xad, 0x00 }, { 0x00a2, 0x9b, 0x00 },
 200         { 0x00a3, 0x9c, 0x00 }, { 0x00a5, 0x9d, 0x00 },
 201         { 0x00a7, 0x15, 0x00 }, { 0x00aa, 0xa6, 0x00 },
 202         { 0x00ab, 0xae, 0x00 }, { 0x00ac, 0xaa, 0x00 },
 203         { 0x00b0, 0xf8, 0x00 }, { 0x00b1, 0xf1, 0x00 },
 204         { 0x00b2, 0xfd, 0x00 }, { 0x00b5, 0xe6, 0x00 },
 205         { 0x00b6, 0x14, 0x00 }, { 0x00b7, 0xfa, 0x00 },
 206         { 0x00ba, 0xa7, 0x00 }, { 0x00bb, 0xaf, 0x00 },
 207         { 0x00bc, 0xac, 0x00 }, { 0x00bd, 0xab, 0x00 },
 208         { 0x00bf, 0xa8, 0x00 }, { 0x00c4, 0x8e, 0x01 },
 209         { 0x00c6, 0x92, 0x00 }, { 0x00c7, 0x80, 0x00 },
 210         { 0x00c9, 0x90, 0x00 }, { 0x00d1, 0xa5, 0x00 },
 211         { 0x00d6, 0x99, 0x00 }, { 0x00dc, 0x9a, 0x00 },
 212         { 0x00df, 0xe1, 0x00 }, { 0x00e0, 0x85, 0x00 },
 213         { 0x00e1, 0xa0, 0x00 }, { 0x00e2, 0x83, 0x00 },
 214         { 0x00e4, 0x84, 0x00 }, { 0x00e5, 0x86, 0x00 },
 215         { 0x00e6, 0x91, 0x00 }, { 0x00e7, 0x87, 0x00 },
 216         { 0x00e8, 0x8a, 0x00 }, { 0x00e9, 0x82, 0x00 },
 217         { 0x00ea, 0x88, 0x01 }, { 0x00ec, 0x8d, 0x00 },
 218         { 0x00ed, 0xa1, 0x00 }, { 0x00ee, 0x8c, 0x00 },
 219         { 0x00ef, 0x8b, 0x00 }, { 0x00f0, 0xeb, 0x00 },
 220         { 0x00f1, 0xa4, 0x00 }, { 0x00f2, 0x95, 0x00 },
 221         { 0x00f3, 0xa2, 0x00 }, { 0x00f4, 0x93, 0x00 },
 222         { 0x00f6, 0x94, 0x00 }, { 0x00f7, 0xf6, 0x00 },
 223         { 0x00f8, 0xed, 0x00 }, { 0x00f9, 0x97, 0x00 },
 224         { 0x00fa, 0xa3, 0x00 }, { 0x00fb, 0x96, 0x00 },
 225         { 0x00fc, 0x81, 0x00 }, { 0x00ff, 0x98, 0x00 },
 226         { 0x0192, 0x9f, 0x00 }, { 0x0393, 0xe2, 0x00 },
 227         { 0x0398, 0xe9, 0x00 }, { 0x03a3, 0xe4, 0x00 },
 228         { 0x03a6, 0xe8, 0x00 }, { 0x03a9, 0xea, 0x00 },
 229         { 0x03b1, 0xe0, 0x01 }, { 0x03b4, 0xeb, 0x00 },
 230         { 0x03b5, 0xee, 0x00 }, { 0x03bc, 0xe6, 0x00 },
 231         { 0x03c0, 0xe3, 0x00 }, { 0x03c3, 0xe5, 0x00 },
 232         { 0x03c4, 0xe7, 0x00 }, { 0x03c6, 0xed, 0x00 },
 233         { 0x03d5, 0xed, 0x00 }, { 0x2010, 0x2d, 0x00 },
 234         { 0x2014, 0x2d, 0x00 }, { 0x2018, 0x60, 0x00 },
 235         { 0x2019, 0x27, 0x00 }, { 0x201c, 0x22, 0x00 },
 236         { 0x201d, 0x22, 0x00 }, { 0x2022, 0x07, 0x00 },
 237         { 0x203c, 0x13, 0x00 }, { 0x207f, 0xfc, 0x00 },
 238         { 0x20a7, 0x9e, 0x00 }, { 0x20ac, 0xee, 0x00 },
 239         { 0x2126, 0xea, 0x00 }, { 0x2190, 0x1b, 0x00 },
 240         { 0x2191, 0x18, 0x00 }, { 0x2192, 0x1a, 0x00 },
 241         { 0x2193, 0x19, 0x00 }, { 0x2194, 0x1d, 0x00 },
 242         { 0x2195, 0x12, 0x00 }, { 0x21a8, 0x17, 0x00 },
 243         { 0x2202, 0xeb, 0x00 }, { 0x2208, 0xee, 0x00 },
 244         { 0x2211, 0xe4, 0x00 }, { 0x2212, 0x2d, 0x00 },
 245         { 0x2219, 0xf9, 0x00 }, { 0x221a, 0xfb, 0x00 },
 246         { 0x221e, 0xec, 0x00 }, { 0x221f, 0x1c, 0x00 },
 247         { 0x2229, 0xef, 0x00 }, { 0x2248, 0xf7, 0x00 },
 248         { 0x2261, 0xf0, 0x00 }, { 0x2264, 0xf3, 0x00 },
 249         { 0x2265, 0xf2, 0x00 }, { 0x2302, 0x7f, 0x00 },
 250         { 0x2310, 0xa9, 0x00 }, { 0x2320, 0xf4, 0x00 },
 251         { 0x2321, 0xf5, 0x00 }, { 0x2500, 0xc4, 0x00 },
 252         { 0x2502, 0xb3, 0x00 }, { 0x250c, 0xda, 0x00 },
 253         { 0x2510, 0xbf, 0x00 }, { 0x2514, 0xc0, 0x00 },
 254         { 0x2518, 0xd9, 0x00 }, { 0x251c, 0xc3, 0x00 },
 255         { 0x2524, 0xb4, 0x00 }, { 0x252c, 0xc2, 0x00 },
 256         { 0x2534, 0xc1, 0x00 }, { 0x253c, 0xc5, 0x00 },
 257         { 0x2550, 0xcd, 0x00 }, { 0x2551, 0xba, 0x00 },
 258         { 0x2552, 0xd5, 0x00 }, { 0x2553, 0xd6, 0x00 },
 259         { 0x2554, 0xc9, 0x00 }, { 0x2555, 0xb8, 0x00 },
 260         { 0x2556, 0xb7, 0x00 }, { 0x2557, 0xbb, 0x00 },
 261         { 0x2558, 0xd4, 0x00 }, { 0x2559, 0xd3, 0x00 },
 262         { 0x255a, 0xc8, 0x00 }, { 0x255b, 0xbe, 0x00 },
 263         { 0x255c, 0xbd, 0x00 }, { 0x255d, 0xbc, 0x00 },
 264         { 0x255e, 0xc6, 0x01 }, { 0x2560, 0xcc, 0x00 },
 265         { 0x2561, 0xb5, 0x00 }, { 0x2562, 0xb6, 0x00 },
 266         { 0x2563, 0xb9, 0x00 }, { 0x2564, 0xd1, 0x01 },
 267         { 0x2566, 0xcb, 0x00 }, { 0x2567, 0xcf, 0x00 },
 268         { 0x2568, 0xd0, 0x00 }, { 0x2569, 0xca, 0x00 },
 269         { 0x256a, 0xd8, 0x00 }, { 0x256b, 0xd7, 0x00 },
 270         { 0x256c, 0xce, 0x00 }, { 0x2580, 0xdf, 0x00 },
 271         { 0x2584, 0xdc, 0x00 }, { 0x2588, 0xdb, 0x00 },
 272         { 0x258c, 0xdd, 0x00 }, { 0x2590, 0xde, 0x00 },
 273         { 0x2591, 0xb0, 0x02 }, { 0x25a0, 0xfe, 0x00 },
 274         { 0x25ac, 0x16, 0x00 }, { 0x25b2, 0x1e, 0x00 },
 275         { 0x25ba, 0x10, 0x00 }, { 0x25bc, 0x1f, 0x00 },
 276         { 0x25c4, 0x11, 0x00 }, { 0x25cb, 0x09, 0x00 },
 277         { 0x25d8, 0x08, 0x00 }, { 0x25d9, 0x0a, 0x00 },
 278         { 0x263a, 0x01, 0x01 }, { 0x263c, 0x0f, 0x00 },
 279         { 0x2640, 0x0c, 0x00 }, { 0x2642, 0x0b, 0x00 },
 280         { 0x2660, 0x06, 0x00 }, { 0x2663, 0x05, 0x00 },
 281         { 0x2665, 0x03, 0x01 }, { 0x266a, 0x0d, 0x00 },
 282         { 0x266c, 0x0e, 0x00 }
 283 };
 284
 285 static uint8_t
 286 vga_get_cp437(teken_char_t c)
 287 {
 288         int min, mid, max;
 289
 290         min = 0;
 291         max = (sizeof(cp437table) / sizeof(struct unicp437)) - 1;
 292
 293         if (c < cp437table[0].unicode_base ||
 294             c > cp437table[max].unicode_base + cp437table[max].length)
 295                 return ('?');
 296
 297         while (max >= min) {
 298                 mid = (min + max) / 2;
 299                 if (c < cp437table[mid].unicode_base)
 300                         max = mid - 1;
 301                 else if (c > cp437table[mid].unicode_base +
 302                     cp437table[mid].length)
 303                         min = mid + 1;
 304                 else
 305                         return (c - cp437table[mid].unicode_base +
 306                             cp437table[mid].cp437_base);
 307         }
 308
 309         return ('?');
 310 }
 311
 312 static void
 313 vidc_text_printchar(teken_gfx_t *state, const teken_pos_t *p)
 314 {
 315         int idx;
 316         uint8_t attr;
 317         struct text_pixel *px;
 318         teken_color_t fg, bg, tmp;
 319         struct cgatext {
 320                 uint8_t ch;
 321                 uint8_t attr;
 322         } *addr;
 323
 324         idx = p->tp_col + p->tp_row * state->tg_tp.tp_col;
 325         px = &screen_buffer[idx];
 326         fg = teken_256to16(px->a.ta_fgcolor);
 327         bg = teken_256to16(px->a.ta_bgcolor);
 328         if (px->a.ta_format & TF_BOLD)
 329                 fg |= TC_LIGHT;
 330         if (px->a.ta_format & TF_BLINK)
 331                 bg |= TC_LIGHT;
 332
 333         if (px->a.ta_format & TF_REVERSE) {
 334                 tmp = fg;
 335                 fg = bg;
 336                 bg = tmp;
 337         }
 338
 339         attr = (cmap[bg & 0xf] << 4) | cmap[fg & 0xf];
 340         addr = (struct cgatext *)vgatext;
 341         addr[idx].ch = vga_get_cp437(px->c);
 342         addr[idx].attr = attr;
 343 }
 344
 345 static void
 346 vidc_text_putchar(void *s, const teken_pos_t *p, teken_char_t c,
 347     const teken_attr_t *a)
 348 {
 349         teken_gfx_t *state = s;
 350         int attr, idx;
 351
 352         idx = p->tp_col + p->tp_row * state->tg_tp.tp_col;
 353         if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row)
 354                 return;
 355
 356         screen_buffer[idx].c = c;
 357         screen_buffer[idx].a = *a;
 358
 359         vidc_text_printchar(state, p);
 360 }
 361
 362 static void
 363 vidc_text_fill(void *arg, const teken_rect_t *r, teken_char_t c,
 364     const teken_attr_t *a)
 365 {
 366         teken_gfx_t *state = arg;
 367         teken_pos_t p;
 368         teken_unit_t row, col;
 369
 370         vidc_text_get_cursor(&row, &col);
 371         vidc_text_set_cursor(row, col, false);
 372         for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row;
 373             p.tp_row++)
 374                 for (p.tp_col = r->tr_begin.tp_col;
 375                     p.tp_col < r->tr_end.tp_col; p.tp_col++)
 376                         vidc_text_putchar(state, &p, c, a);
 377         vidc_text_set_cursor(row, col, true);
 378 }
 379
 380 static void
 381 vidc_text_copy(void *ptr, const teken_rect_t *r, const teken_pos_t *p)
 382 {
 383         teken_gfx_t *state = ptr;
 384         int srow, drow;
 385         int nrow, ncol, x, y; /* Has to be signed - >= 0 comparison */
 386         teken_pos_t d, s;
 387         teken_unit_t row, col;
 388
 389         /*
 390          * Copying is a little tricky. We must make sure we do it in
 391          * correct order, to make sure we don't overwrite our own data.
 392          */
 393
 394         nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
 395         ncol = r->tr_end.tp_col - r->tr_begin.tp_col;
 396
 397         vidc_text_get_cursor(&row, &col);
 398         vidc_text_set_cursor(row, col, false);
 399         if (p->tp_row < r->tr_begin.tp_row) {
 400                 /* Copy from bottom to top. */
 401                 for (y = 0; y < nrow; y++) {
 402                         d.tp_row = p->tp_row + y;
 403                         s.tp_row = r->tr_begin.tp_row + y;
 404                         drow = d.tp_row * state->tg_tp.tp_col;
 405                         srow = s.tp_row * state->tg_tp.tp_col;
 406                         for (x = 0; x < ncol; x++) {
 407                                 d.tp_col = p->tp_col + x;
 408                                 s.tp_col = r->tr_begin.tp_col + x;
 409
 410                                 if (!is_same_pixel(
 411                                     &screen_buffer[d.tp_col + drow],
 412                                     &screen_buffer[s.tp_col + srow])) {
 413                                         screen_buffer[d.tp_col + drow] =
 414                                             screen_buffer[s.tp_col + srow];
 415                                         vidc_text_printchar(state, &d);
 416                                 }
 417                         }
 418                 }
 419         } else {
 420                 /* Copy from top to bottom. */
 421                 if (p->tp_col < r->tr_begin.tp_col) {
 422                         /* Copy from right to left. */
 423                         for (y = nrow - 1; y >= 0; y--) {
 424                                 d.tp_row = p->tp_row + y;
 425                                 s.tp_row = r->tr_begin.tp_row + y;
 426                                 drow = d.tp_row * state->tg_tp.tp_col;
 427                                 srow = s.tp_row * state->tg_tp.tp_col;
 428                                 for (x = 0; x < ncol; x++) {
 429                                         d.tp_col = p->tp_col + x;
 430                                         s.tp_col = r->tr_begin.tp_col + x;
 431
 432                                         if (!is_same_pixel(
 433                                             &screen_buffer[d.tp_col + drow],
 434                                             &screen_buffer[s.tp_col + srow])) {
 435                                                 screen_buffer[d.tp_col + drow] =
 436                                                     screen_buffer[s.tp_col + srow];
 437                                                 vidc_text_printchar(state, &d);
 438                                         }
 439                                 }
 440                         }
 441                 } else {
 442                         /* Copy from left to right. */
 443                         for (y = nrow - 1; y >= 0; y--) {
 444                                 d.tp_row = p->tp_row + y;
 445                                 s.tp_row = r->tr_begin.tp_row + y;
 446                                 drow = d.tp_row * state->tg_tp.tp_col;
 447                                 srow = s.tp_row * state->tg_tp.tp_col;
 448                                 for (x = ncol - 1; x >= 0; x--) {
 449                                         d.tp_col = p->tp_col + x;
 450                                         s.tp_col = r->tr_begin.tp_col + x;
 451
 452                                         if (!is_same_pixel(
 453                                             &screen_buffer[d.tp_col + drow],
 454                                             &screen_buffer[s.tp_col + srow])) {
 455                                                 screen_buffer[d.tp_col + drow] =
 456                                                     screen_buffer[s.tp_col + srow];
 457                                                 vidc_text_printchar(state, &d);
 458                                         }
 459                                 }
 460                         }
 461                 }
 462         }
 463         vidc_text_set_cursor(row, col, true);
 464 }
 465
 466 static void
 467 vidc_text_param(void *arg, int cmd, unsigned int value)
 468 {
 469         teken_gfx_t *state = arg;
 470         teken_unit_t row, col;
 471
 472         switch (cmd) {
 473         case TP_SETLOCALCURSOR:
 474                 /*
 475                  * 0 means normal (usually block), 1 means hidden, and
 476                  * 2 means blinking (always block) for compatibility with
 477                  * syscons.  We don't support any changes except hiding,
 478                  * so must map 2 to 0.
 479                  */
 480                 value = (value == 1) ? 0 : 1;
 481                 /* FALLTHROUGH */
 482         case TP_SHOWCURSOR:
 483                 vidc_text_get_cursor(&row, &col);
 484                 if (value != 0) {
 485                         vidc_text_set_cursor(row, col, true);
 486                         state->tg_cursor_visible = true;
 487                 } else {
 488                         vidc_text_set_cursor(row, col, false);
 489                         state->tg_cursor_visible = false;
 490                 }
 491                 break;
 492         default:
 493                 /* Not yet implemented */
 494                 break;
 495         }
 496 }
 497
 498 /*
 499  * Not implemented.
 500  */
 501 static void
 502 vidc_cons_respond(void *s __unused, const void *buf __unused,
 503     size_t len __unused)
 504 {
 505 }
 506
 507 static void
 508 vidc_probe(struct console *cp)
 509 {
 510
 511     /* look for a keyboard */
 512 #if KEYBOARD_PROBE
 513     if (probe_keyboard())
 514 #endif
 515     {
 516
 517         cp->c_flags |= C_PRESENTIN;
 518     }
 519
 520     /* XXX for now, always assume we can do BIOS screen output */
 521     cp->c_flags |= C_PRESENTOUT;
 522 }
 523
 524 static bool
 525 color_name_to_teken(const char *name, int *val)
 526 {
 527         int light = 0;
 528         if (strncasecmp(name, "light", 5) == 0) {
 529                 name += 5;
 530                 light = TC_LIGHT;
 531         } else if (strncasecmp(name, "bright", 6) == 0) {
 532                 name += 6;
 533                 light = TC_LIGHT;
 534         }
 535         if (strcasecmp(name, "black") == 0) {
 536                 *val = TC_BLACK | light;
 537                 return (true);
 538         }
 539         if (strcasecmp(name, "red") == 0) {
 540                 *val = TC_RED | light;
 541                 return (true);
 542         }
 543         if (strcasecmp(name, "green") == 0) {
 544                 *val = TC_GREEN | light;
 545                 return (true);
 546         }
 547         if (strcasecmp(name, "yellow") == 0 || strcasecmp(name, "brown") == 0) {
 548                 *val = TC_YELLOW | light;
 549                 return (true);
 550         }
 551         if (strcasecmp(name, "blue") == 0) {
 552                 *val = TC_BLUE | light;
 553                 return (true);
 554         }
 555         if (strcasecmp(name, "magenta") == 0) {
 556                 *val = TC_MAGENTA | light;
 557                 return (true);
 558         }
 559         if (strcasecmp(name, "cyan") == 0) {
 560                 *val = TC_CYAN | light;
 561                 return (true);
 562         }
 563         if (strcasecmp(name, "white") == 0) {
 564                 *val = TC_WHITE | light;
 565                 return (true);
 566         }
 567         return (false);
 568 }
 569
 570 static int
 571 vidc_set_colors(struct env_var *ev, int flags, const void *value)
 572 {
 573         int val = 0;
 574         char buf[3];
 575         const void *evalue;
 576         const teken_attr_t *ap;
 577         teken_attr_t a;
 578
 579         if (value == NULL)
 580                 return (CMD_OK);
 581
 582         if (color_name_to_teken(value, &val)) {
 583                 snprintf(buf, sizeof (buf), "%d", val);
 584                 evalue = buf;
 585         } else {
 586                 char *end;
 587                 long lval;
 588
 589                 errno = 0;
 590                 lval = strtol(value, &end, 0);
 591                 if (errno != 0 || *end != '\0' || lval < 0 || lval > 15) {
 592                         printf("Allowed values are either ansi color name or "
 593                             "number from range [0-15].\n");
 594                         return (CMD_OK);
 595                 }
 596                 val = (int)lval;
 597                 evalue = value;
 598         }
 599
 600         ap = teken_get_defattr(&gfx_state.tg_teken);
 601         a = *ap;
 602         if (strcmp(ev->ev_name, "teken.fg_color") == 0) {
 603                 /* is it already set? */
 604                 if (ap->ta_fgcolor == val)
 605                         return (CMD_OK);
 606                 a.ta_fgcolor = val;
 607         }
 608         if (strcmp(ev->ev_name, "teken.bg_color") == 0) {
 609                 /* is it already set? */
 610                 if (ap->ta_bgcolor == val)
 611                         return (CMD_OK);
 612                 a.ta_bgcolor = val;
 613         }
 614
 615         /* Improve visibility */
 616         if (a.ta_bgcolor == TC_WHITE)
 617                 a.ta_bgcolor |= TC_LIGHT;
 618
 619         teken_set_defattr(&gfx_state.tg_teken, &a);
 620         cons_draw_frame(&a);
 621         env_setenv(ev->ev_name, flags | EV_NOHOOK, evalue, NULL, NULL);
 622         teken_input(&gfx_state.tg_teken, "\e[2J", 4);
 623
 624         return (CMD_OK);
 625 }
 626
 627 static int
 628 env_screen_nounset(struct env_var *ev __unused)
 629 {
 630         if (gfx_state.tg_fb_type == FB_TEXT)
 631                 return (0);
 632         return (EPERM);
 633 }
 634
 635 static int
 636 vidc_load_palette(void)
 637 {
 638         int i, roff, goff, boff, rc;
 639
 640         if (pe8 == NULL)
 641                 pe8 = calloc(sizeof(*pe8), NCMAP);
 642         if (pe8 == NULL)
 643                 return (ENOMEM);
 644
 645         /* Generate VGA colors */
 646         roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
 647         goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
 648         boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
 649         rc = generate_cons_palette((uint32_t *)pe8, COLOR_FORMAT_RGB,
 650             gfx_state.tg_fb.fb_mask_red >> roff, roff,
 651             gfx_state.tg_fb.fb_mask_green >> goff, goff,
 652             gfx_state.tg_fb.fb_mask_blue >> boff, boff);
 653
 654         if (rc == 0) {
 655                 for (i = 0; i < NCMAP; i++) {
 656                         int idx;
 657
 658                         if (i < NCOLORS)
 659                                 idx = cons_to_vga_colors[i];
 660                         else
 661                                 idx = i;
 662
 663                         rc = vbe_set_palette(&pe8[i], idx);
 664                         if (rc != 0)
 665                                 break;
 666                 }
 667         }
 668         return (rc);
 669 }
 670
 671 static void
 672 cons_draw_frame(teken_attr_t *a)
 673 {
 674         teken_attr_t attr = *a;
 675         teken_color_t fg = a->ta_fgcolor;
 676
 677         attr.ta_fgcolor = attr.ta_bgcolor;
 678         teken_set_defattr(&gfx_state.tg_teken, &attr);
 679
 680         gfx_fb_drawrect(0, 0, gfx_state.tg_fb.fb_width,
 681             gfx_state.tg_origin.tp_row, 1);
 682         gfx_fb_drawrect(0,
 683             gfx_state.tg_fb.fb_height - gfx_state.tg_origin.tp_row - 1,
 684             gfx_state.tg_fb.fb_width, gfx_state.tg_fb.fb_height, 1);
 685         gfx_fb_drawrect(0, gfx_state.tg_origin.tp_row,
 686             gfx_state.tg_origin.tp_col,
 687             gfx_state.tg_fb.fb_height - gfx_state.tg_origin.tp_row - 1, 1);
 688         gfx_fb_drawrect(
 689             gfx_state.tg_fb.fb_width - gfx_state.tg_origin.tp_col - 1,
 690             gfx_state.tg_origin.tp_row, gfx_state.tg_fb.fb_width,
 691             gfx_state.tg_fb.fb_height, 1);
 692
 693         attr.ta_fgcolor = fg;
 694         teken_set_defattr(&gfx_state.tg_teken, &attr);
 695 }
 696
 697 /*
 698  * Binary searchable table for CP437 to Unicode conversion.
 699  */
 700 struct cp437uni {
 701         uint8_t         cp437_base;
 702         uint16_t        unicode_base;
 703         uint8_t         length;
 704 };
 705
 706 static const struct cp437uni cp437unitable[] = {
 707         {   0, 0x0000, 0 }, {   1, 0x263A, 1 }, {   3, 0x2665, 1 },
 708         {   5, 0x2663, 0 }, {   6, 0x2660, 0 }, {   7, 0x2022, 0 },
 709         {   8, 0x25D8, 0 }, {   9, 0x25CB, 0 }, {  10, 0x25D9, 0 },
 710         {  11, 0x2642, 0 }, {  12, 0x2640, 0 }, {  13, 0x266A, 1 },
 711         {  15, 0x263C, 0 }, {  16, 0x25BA, 0 }, {  17, 0x25C4, 0 },
 712         {  18, 0x2195, 0 }, {  19, 0x203C, 0 }, {  20, 0x00B6, 0 },
 713         {  21, 0x00A7, 0 }, {  22, 0x25AC, 0 }, {  23, 0x21A8, 0 },
 714         {  24, 0x2191, 0 }, {  25, 0x2193, 0 }, {  26, 0x2192, 0 },
 715         {  27, 0x2190, 0 }, {  28, 0x221F, 0 }, {  29, 0x2194, 0 },
 716         {  30, 0x25B2, 0 }, {  31, 0x25BC, 0 }, {  32, 0x0020, 0x5e },
 717         { 127, 0x2302, 0 }, { 128, 0x00C7, 0 }, { 129, 0x00FC, 0 },
 718         { 130, 0x00E9, 0 }, { 131, 0x00E2, 0 }, { 132, 0x00E4, 0 },
 719         { 133, 0x00E0, 0 }, { 134, 0x00E5, 0 }, { 135, 0x00E7, 0 },
 720         { 136, 0x00EA, 1 }, { 138, 0x00E8, 0 }, { 139, 0x00EF, 0 },
 721         { 140, 0x00EE, 0 }, { 141, 0x00EC, 0 }, { 142, 0x00C4, 1 },
 722         { 144, 0x00C9, 0 }, { 145, 0x00E6, 0 }, { 146, 0x00C6, 0 },
 723         { 147, 0x00F4, 0 }, { 148, 0x00F6, 0 }, { 149, 0x00F2, 0 },
 724         { 150, 0x00FB, 0 }, { 151, 0x00F9, 0 }, { 152, 0x00FF, 0 },
 725         { 153, 0x00D6, 0 }, { 154, 0x00DC, 0 }, { 155, 0x00A2, 1 },
 726         { 157, 0x00A5, 0 }, { 158, 0x20A7, 0 }, { 159, 0x0192, 0 },
 727         { 160, 0x00E1, 0 }, { 161, 0x00ED, 0 }, { 162, 0x00F3, 0 },
 728         { 163, 0x00FA, 0 }, { 164, 0x00F1, 0 }, { 165, 0x00D1, 0 },
 729         { 166, 0x00AA, 0 }, { 167, 0x00BA, 0 }, { 168, 0x00BF, 0 },
 730         { 169, 0x2310, 0 }, { 170, 0x00AC, 0 }, { 171, 0x00BD, 0 },
 731         { 172, 0x00BC, 0 }, { 173, 0x00A1, 0 }, { 174, 0x00AB, 0 },
 732         { 175, 0x00BB, 0 }, { 176, 0x2591, 2 }, { 179, 0x2502, 0 },
 733         { 180, 0x2524, 0 }, { 181, 0x2561, 1 }, { 183, 0x2556, 0 },
 734         { 184, 0x2555, 0 }, { 185, 0x2563, 0 }, { 186, 0x2551, 0 },
 735         { 187, 0x2557, 0 }, { 188, 0x255D, 0 }, { 189, 0x255C, 0 },
 736         { 190, 0x255B, 0 }, { 191, 0x2510, 0 }, { 192, 0x2514, 0 },
 737         { 193, 0x2534, 0 }, { 194, 0x252C, 0 }, { 195, 0x251C, 0 },
 738         { 196, 0x2500, 0 }, { 197, 0x253C, 0 }, { 198, 0x255E, 1 },
 739         { 200, 0x255A, 0 }, { 201, 0x2554, 0 }, { 202, 0x2569, 0 },
 740         { 203, 0x2566, 0 }, { 204, 0x2560, 0 }, { 205, 0x2550, 0 },
 741         { 206, 0x256C, 0 }, { 207, 0x2567, 1 }, { 209, 0x2564, 1 },
 742         { 211, 0x2559, 0 }, { 212, 0x2558, 0 }, { 213, 0x2552, 1 },
 743         { 215, 0x256B, 0 }, { 216, 0x256A, 0 }, { 217, 0x2518, 0 },
 744         { 218, 0x250C, 0 }, { 219, 0x2588, 0 }, { 220, 0x2584, 0 },
 745         { 221, 0x258C, 0 }, { 222, 0x2590, 0 }, { 223, 0x2580, 0 },
 746         { 224, 0x03B1, 0 }, { 225, 0x00DF, 0 }, { 226, 0x0393, 0 },
 747         { 227, 0x03C0, 0 }, { 228, 0x03A3, 0 }, { 229, 0x03C3, 0 },
 748         { 230, 0x00B5, 0 }, { 231, 0x03C4, 0 }, { 232, 0x03A6, 0 },
 749         { 233, 0x0398, 0 }, { 234, 0x03A9, 0 }, { 235, 0x03B4, 0 },
 750         { 236, 0x221E, 0 }, { 237, 0x03C6, 0 }, { 238, 0x03B5, 0 },
 751         { 239, 0x2229, 0 }, { 240, 0x2261, 0 }, { 241, 0x00B1, 0 },
 752         { 242, 0x2265, 0 }, { 243, 0x2264, 0 }, { 244, 0x2320, 1 },
 753         { 246, 0x00F7, 0 }, { 247, 0x2248, 0 }, { 248, 0x00B0, 0 },
 754         { 249, 0x2219, 0 }, { 250, 0x00B7, 0 }, { 251, 0x221A, 0 },
 755         { 252, 0x207F, 0 }, { 253, 0x00B2, 0 }, { 254, 0x25A0, 0 },
 756         { 255, 0x00A0, 0 }
 757 };
 758
 759 static uint16_t
 760 vga_cp437_to_uni(uint8_t c)
 761 {
 762         int min, mid, max;
 763
 764         min = 0;
 765         max = (sizeof(cp437unitable) / sizeof(struct cp437uni)) - 1;
 766
 767         while (max >= min) {
 768                 mid = (min + max) / 2;
 769                 if (c < cp437unitable[mid].cp437_base)
 770                         max = mid - 1;
 771                 else if (c > cp437unitable[mid].cp437_base +
 772                     cp437unitable[mid].length)
 773                         min = mid + 1;
 774                 else
 775                         return (c - cp437unitable[mid].cp437_base +
 776                             cp437unitable[mid].unicode_base);
 777         }
 778
 779         return ('?');
 780 }
 781
 782 /*
 783  * install font for text mode
 784  */
 785 static void
 786 vidc_install_font(void)
 787 {
 788         uint8_t reg[7];
 789         const uint8_t *from;
 790         uint8_t volatile *to;
 791         uint16_t c;
 792         int i, j, s;
 793         int bpc, f_offset;
 794         teken_attr_t a = { 0 };
 795
 796         /* We can only program VGA registers. */
 797         if (!vbe_is_vga())
 798                 return;
 799
 800         if (gfx_state.tg_fb_type != FB_TEXT)
 801                 return;
 802
 803         /* Sync-reset the sequencer registers */
 804         vga_set_seq(VGA_REG_BASE, VGA_SEQ_RESET, VGA_SEQ_RST_NAR);
 805
 806         reg[0] = vga_get_seq(VGA_REG_BASE, VGA_SEQ_MAP_MASK);
 807         reg[1] = vga_get_seq(VGA_REG_BASE, VGA_SEQ_CLOCKING_MODE);
 808         reg[2] = vga_get_seq(VGA_REG_BASE, VGA_SEQ_MEMORY_MODE);
 809         reg[3] = vga_get_grc(VGA_REG_BASE, VGA_GC_READ_MAP_SELECT);
 810         reg[4] = vga_get_grc(VGA_REG_BASE, VGA_GC_MODE);
 811         reg[5] = vga_get_grc(VGA_REG_BASE, VGA_GC_MISCELLANEOUS);
 812         reg[6] = vga_get_atr(VGA_REG_BASE, VGA_AC_MODE_CONTROL);
 813
 814         /* Screen off */
 815         vga_set_seq(VGA_REG_BASE, VGA_SEQ_CLOCKING_MODE,
 816             reg[1] | VGA_SEQ_CM_SO);
 817
 818         /*
 819          * enable write to plane2, since fonts
 820          * could only be loaded into plane2
 821          */
 822         vga_set_seq(VGA_REG_BASE, VGA_SEQ_MAP_MASK, VGA_SEQ_MM_EM2);
 823         /*
 824          * sequentially access data in the bit map being
 825          * selected by MapMask register (index 0x02)
 826          */
 827         vga_set_seq(VGA_REG_BASE, VGA_SEQ_MEMORY_MODE, 0x07);
 828         /* Sync-reset ended, and allow the sequencer to operate */
 829         vga_set_seq(VGA_REG_BASE, VGA_SEQ_RESET,
 830             VGA_SEQ_RST_SR | VGA_SEQ_RST_NAR);
 831
 832         /*
 833          * select plane 2 on Read Mode 0
 834          */
 835         vga_set_grc(VGA_REG_BASE, VGA_GC_READ_MAP_SELECT, 0x02);
 836         /*
 837          * system addresses sequentially access data, follow
 838          * Memory Mode register bit 2 in the sequencer
 839          */
 840         vga_set_grc(VGA_REG_BASE, VGA_GC_MODE, 0x00);
 841         /*
 842          * set range of host memory addresses decoded by VGA
 843          * hardware -- A0000h-BFFFFh (128K region)
 844          */
 845         vga_set_grc(VGA_REG_BASE, VGA_GC_MISCELLANEOUS, 0x00);
 846
 847         /*
 848          * This assumes 8x16 characters, which yield the traditional 80x25
 849          * screen.
 850          */
 851         bpc = 16;
 852         s = 0;  /* font slot, maybe should use tunable there. */
 853         f_offset = s * 8 * 1024;
 854         for (i = 0; i < 256; i++) {
 855                 c = vga_cp437_to_uni(i);
 856                 from = font_lookup(&gfx_state.tg_font, c, &a);
 857                 to = (unsigned char *)ptov(VGA_MEM_BASE) + f_offset +
 858                     i * 0x20;
 859                 for (j = 0; j < bpc; j++)
 860                         *to++ = *from++;
 861         }
 862
 863         vga_set_atr(VGA_REG_BASE, VGA_AC_MODE_CONTROL, reg[6]);
 864
 865         /* Sync-reset the sequencer registers */
 866         vga_set_seq(VGA_REG_BASE, VGA_SEQ_RESET, VGA_SEQ_RST_NAR);
 867         vga_set_seq(VGA_REG_BASE, VGA_SEQ_MAP_MASK, reg[0]);
 868         vga_set_seq(VGA_REG_BASE, VGA_SEQ_MEMORY_MODE, reg[2]);
 869         /* Sync-reset ended, and allow the sequencer to operate */
 870         vga_set_seq(VGA_REG_BASE, VGA_SEQ_RESET,
 871             VGA_SEQ_RST_SR | VGA_SEQ_RST_NAR);
 872
 873         /* restore graphic registers */
 874         vga_set_grc(VGA_REG_BASE, VGA_GC_READ_MAP_SELECT, reg[3]);
 875         vga_set_grc(VGA_REG_BASE, VGA_GC_MODE, reg[4]);
 876         vga_set_grc(VGA_REG_BASE, VGA_GC_MISCELLANEOUS, (reg[5] & 0x03) | 0x0c);
 877
 878         /* Screen on */
 879         vga_set_seq(VGA_REG_BASE, VGA_SEQ_CLOCKING_MODE, reg[1] & 0xdf);
 880 }
 881
 882 bool
 883 cons_update_mode(bool use_gfx_mode)
 884 {
 885         const teken_attr_t *a;
 886         teken_attr_t attr;
 887         char env[10], *ptr;
 888         int format, roff, goff, boff;
 889
 890         /* vidc_init() is not called yet. */
 891         if (!vidc_started)
 892                 return (false);
 893
 894         gfx_state.tg_tp.tp_row = TEXT_ROWS;
 895         gfx_state.tg_tp.tp_col = TEXT_COLS;
 896
 897         if (use_gfx_mode) {
 898                 setup_font(&gfx_state, gfx_state.tg_fb.fb_height,
 899                     gfx_state.tg_fb.fb_width);
 900                 /* Point of origin in pixels. */
 901                 gfx_state.tg_origin.tp_row = (gfx_state.tg_fb.fb_height -
 902                     (gfx_state.tg_tp.tp_row * gfx_state.tg_font.vf_height)) / 2;
 903                 gfx_state.tg_origin.tp_col = (gfx_state.tg_fb.fb_width -
 904                     (gfx_state.tg_tp.tp_col * gfx_state.tg_font.vf_width)) / 2;
 905
 906                 gfx_state.tg_glyph_size = gfx_state.tg_font.vf_height *
 907                     gfx_state.tg_font.vf_width * 4;
 908                 free(gfx_state.tg_glyph);
 909                 gfx_state.tg_glyph = malloc(gfx_state.tg_glyph_size);
 910                 if (gfx_state.tg_glyph == NULL)
 911                         return (false);
 912                 gfx_state.tg_functions = &tfx;
 913                 snprintf(env, sizeof (env), "%d", gfx_state.tg_fb.fb_height);
 914                 env_setenv("screen.height", EV_VOLATILE | EV_NOHOOK, env,
 915                     env_noset, env_screen_nounset);
 916                 snprintf(env, sizeof (env), "%d", gfx_state.tg_fb.fb_width);
 917                 env_setenv("screen.width", EV_VOLATILE | EV_NOHOOK, env,
 918                     env_noset, env_screen_nounset);
 919                 snprintf(env, sizeof (env), "%d", gfx_state.tg_fb.fb_bpp);
 920                 env_setenv("screen.depth", EV_VOLATILE | EV_NOHOOK, env,
 921                     env_noset, env_screen_nounset);
 922         } else {
 923                 /* Trigger loading of 8x16 font. */
 924                 setup_font(&gfx_state,
 925                     16 * gfx_state.tg_fb.fb_height,
 926                     8 * gfx_state.tg_fb.fb_width);
 927                 gfx_state.tg_functions = &tf;
 928                 /* ensure the following are not set for text mode */
 929                 unsetenv("screen.height");
 930                 unsetenv("screen.width");
 931                 unsetenv("screen.depth");
 932                 vidc_install_font();
 933         }
 934
 935         free(screen_buffer);
 936         screen_buffer = malloc(gfx_state.tg_tp.tp_row * gfx_state.tg_tp.tp_col *
 937             sizeof(*screen_buffer));
 938         if (screen_buffer == NULL)
 939                 return (false);
 940
 941         teken_init(&gfx_state.tg_teken, gfx_state.tg_functions, &gfx_state);
 942
 943         if (gfx_state.tg_ctype == CT_INDEXED)
 944                 format = COLOR_FORMAT_VGA;
 945         else
 946                 format = COLOR_FORMAT_RGB;
 947
 948         roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
 949         goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
 950         boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
 951         (void) generate_cons_palette(cmap, format,
 952             gfx_state.tg_fb.fb_mask_red >> roff, roff,
 953             gfx_state.tg_fb.fb_mask_green >> goff, goff,
 954             gfx_state.tg_fb.fb_mask_blue >> boff, boff);
 955
 956         if (gfx_state.tg_ctype == CT_INDEXED && use_gfx_mode)
 957                 vidc_load_palette();
 958
 959         teken_set_winsize(&gfx_state.tg_teken, &gfx_state.tg_tp);
 960         a = teken_get_defattr(&gfx_state.tg_teken);
 961         attr = *a;
 962
 963         /*
 964          * On first run, we set up the vidc_set_colors()
 965          * callback. If the env is already set, we
 966          * pick up fg and bg color values from the environment.
 967          */
 968         ptr = getenv("teken.fg_color");
 969         if (ptr != NULL) {
 970                 attr.ta_fgcolor = strtol(ptr, NULL, 10);
 971                 ptr = getenv("teken.bg_color");
 972                 attr.ta_bgcolor = strtol(ptr, NULL, 10);
 973
 974                 teken_set_defattr(&gfx_state.tg_teken, &attr);
 975         } else {
 976                 snprintf(env, sizeof(env), "%d", attr.ta_fgcolor);
 977                 env_setenv("teken.fg_color", EV_VOLATILE, env,
 978                     vidc_set_colors, env_nounset);
 979                 snprintf(env, sizeof(env), "%d", attr.ta_bgcolor);
 980                 env_setenv("teken.bg_color", EV_VOLATILE, env,
 981                     vidc_set_colors, env_nounset);
 982         }
 983
 984         /* Improve visibility */
 985         if (attr.ta_bgcolor == TC_WHITE)
 986                 attr.ta_bgcolor |= TC_LIGHT;
 987         teken_set_defattr(&gfx_state.tg_teken, &attr);
 988
 989         snprintf(env, sizeof (env), "%u", (unsigned)gfx_state.tg_tp.tp_row);
 990         setenv("LINES", env, 1);
 991         snprintf(env, sizeof (env), "%u", (unsigned)gfx_state.tg_tp.tp_col);
 992         setenv("COLUMNS", env, 1);
 993
 994         /* Draw frame around terminal area. */
 995         cons_draw_frame(&attr);
 996         /* Erase display, this will also fill our screen buffer. */
 997         teken_input(&gfx_state.tg_teken, "\e[2J", 4);
 998         gfx_state.tg_functions->tf_param(&gfx_state, TP_SHOWCURSOR, 1);
 999
1000         return (true);
1001 }
1002
1003 static int
1004 vidc_init(int arg)
1005 {
1006         const teken_attr_t *a;
1007         int val;
1008         char env[8];
1009
1010         if (vidc_started && arg == 0)
1011                 return (0);
1012
1013         vidc_started = true;
1014         vbe_init();
1015
1016         /*
1017          * Check Miscellaneous Output Register (Read at 3CCh, Write at 3C2h)
1018          * for bit 1 (Input/Output Address Select), which means
1019          * color/graphics adapter.
1020          */
1021         if (vga_get_reg(VGA_REG_BASE, VGA_GEN_MISC_OUTPUT_R) & VGA_GEN_MO_IOA)
1022                 vgatext = (uint16_t *)PTOV(VGA_TXT_BASE);
1023         else
1024                 vgatext = (uint16_t *)PTOV(VGA_MEM_BASE + VGA_MEM_SIZE);
1025
1026         /* set 16bit colors */
1027         val = vga_get_atr(VGA_REG_BASE, VGA_AC_MODE_CONTROL);
1028         val &= ~VGA_AC_MC_BI;
1029         val &= ~VGA_AC_MC_ELG;
1030         vga_set_atr(VGA_REG_BASE, VGA_AC_MODE_CONTROL, val);
1031
1032 #if defined(FRAMEBUFFER_MODE)
1033         val = vbe_default_mode();
1034         /* if val is not legal VBE mode, use text mode */
1035         if (VBE_VALID_MODE(val)) {
1036                 if (vbe_set_mode(val) != 0)
1037                         bios_set_text_mode(VGA_TEXT_MODE);
1038         }
1039 #endif
1040
1041         gfx_framework_init();
1042
1043         if (!cons_update_mode(VBE_VALID_MODE(vbe_get_mode())))
1044                 return (1);
1045
1046         for (int i = 0; i < 10 && vidc_ischar(); i++)
1047                 (void) vidc_getchar();
1048
1049         return (0);     /* XXX reinit? */
1050 }
1051
1052 void
1053 vidc_biosputchar(int c)
1054 {
1055
1056     v86.ctl = 0;
1057     v86.addr = 0x10;
1058     v86.eax = 0xe00 | (c & 0xff);
1059     v86.ebx = 0x7;
1060     v86int();
1061 }
1062
1063 static void
1064 vidc_putchar(int c)
1065 {
1066         unsigned char ch = c;
1067
1068         if (screen_buffer != NULL)
1069                 teken_input(&gfx_state.tg_teken, &ch, sizeof (ch));
1070         else
1071                 vidc_biosputchar(c);
1072 }
1073
1074 static int
1075 vidc_getchar(void)
1076 {
1077         int i, c;
1078
1079         for (i = 0; i < KEYBUFSZ; i++) {
1080                 if (keybuf[i] != 0) {
1081                         c = keybuf[i];
1082                         keybuf[i] = 0;
1083                         return (c);
1084                 }
1085         }
1086
1087         if (vidc_ischar()) {
1088                 v86.ctl = 0;
1089                 v86.addr = 0x16;
1090                 v86.eax = 0x0;
1091                 v86int();
1092                 if ((v86.eax & 0xff) != 0) {
1093                         return (v86.eax & 0xff);
1094                 }
1095
1096                 /* extended keys */
1097                 switch (v86.eax & 0xff00) {
1098                 case 0x4800:    /* up */
1099                         keybuf[0] = '[';
1100                         keybuf[1] = 'A';
1101                         return (0x1b);  /* esc */
1102                 case 0x4b00:    /* left */
1103                         keybuf[0] = '[';
1104                         keybuf[1] = 'D';
1105                         return (0x1b);  /* esc */
1106                 case 0x4d00:    /* right */
1107                         keybuf[0] = '[';
1108                         keybuf[1] = 'C';
1109                         return (0x1b);  /* esc */
1110                 case 0x5000:    /* down */
1111                         keybuf[0] = '[';
1112                         keybuf[1] = 'B';
1113                         return (0x1b);  /* esc */
1114                 default:
1115                         return (-1);
1116                 }
1117         } else {
1118                 return (-1);
1119         }
1120 }
1121
1122 static int
1123 vidc_ischar(void)
1124 {
1125         int i;
1126
1127         for (i = 0; i < KEYBUFSZ; i++) {
1128                 if (keybuf[i] != 0) {
1129                         return (1);
1130                 }
1131         }
1132
1133         v86.ctl = V86_FLAGS;
1134         v86.addr = 0x16;
1135         v86.eax = 0x100;
1136         v86int();
1137         return (!V86_ZR(v86.efl));
1138 }
1139
1140 #if KEYBOARD_PROBE
1141
1142 #define PROBE_MAXRETRY  5
1143 #define PROBE_MAXWAIT   400
1144 #define IO_DUMMY        0x84
1145 #define IO_KBD          0x060           /* 8042 Keyboard */
1146
1147 /* selected defines from kbdio.h */
1148 #define KBD_STATUS_PORT         4       /* status port, read */
1149 #define KBD_DATA_PORT           0       /* data port, read/write
1150                                          * also used as keyboard command
1151                                          * and mouse command port
1152                                          */
1153 #define KBDC_ECHO               0x00ee
1154 #define KBDS_ANY_BUFFER_FULL    0x0001
1155 #define KBDS_INPUT_BUFFER_FULL  0x0002
1156 #define KBD_ECHO                0x00ee
1157
1158 /* 7 microsec delay necessary for some keyboard controllers */
1159 static void
1160 delay7(void)
1161 {
1162         /*
1163          * I know this is broken, but no timer is available yet at this stage...
1164          * See also comments in `delay1ms()'.
1165          */
1166         inb(IO_DUMMY); inb(IO_DUMMY);
1167         inb(IO_DUMMY); inb(IO_DUMMY);
1168         inb(IO_DUMMY); inb(IO_DUMMY);
1169 }
1170
1171 /*
1172  * This routine uses an inb to an unused port, the time to execute that
1173  * inb is approximately 1.25uS.  This value is pretty constant across
1174  * all CPU's and all buses, with the exception of some PCI implentations
1175  * that do not forward this I/O address to the ISA bus as they know it
1176  * is not a valid ISA bus address, those machines execute this inb in
1177  * 60 nS :-(.
1178  *
1179  */
1180 static void
1181 delay1ms(void)
1182 {
1183         int i = 800;
1184         while (--i >= 0)
1185                 (void) inb(0x84);
1186 }
1187
1188 /*
1189  * We use the presence/absence of a keyboard to determine whether the internal
1190  * console can be used for input.
1191  *
1192  * Perform a simple test on the keyboard; issue the ECHO command and see
1193  * if the right answer is returned. We don't do anything as drastic as
1194  * full keyboard reset; it will be too troublesome and take too much time.
1195  */
1196 static int
1197 probe_keyboard(void)
1198 {
1199         int retry = PROBE_MAXRETRY;
1200         int wait;
1201         int i;
1202
1203         while (--retry >= 0) {
1204                 /* flush any noise */
1205                 while (inb(IO_KBD + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) {
1206                         delay7();
1207                         inb(IO_KBD + KBD_DATA_PORT);
1208                         delay1ms();
1209                 }
1210
1211                 /* wait until the controller can accept a command */
1212                 for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
1213                         if (((i = inb(IO_KBD + KBD_STATUS_PORT))
1214                             & (KBDS_INPUT_BUFFER_FULL | KBDS_ANY_BUFFER_FULL))
1215                             == 0)
1216                                 break;
1217                         if (i & KBDS_ANY_BUFFER_FULL) {
1218                                 delay7();
1219                                 inb(IO_KBD + KBD_DATA_PORT);
1220                         }
1221                         delay1ms();
1222                 }
1223                 if (wait <= 0)
1224                         continue;
1225
1226                 /* send the ECHO command */
1227                 outb(IO_KBD + KBD_DATA_PORT, KBDC_ECHO);
1228
1229                 /* wait for a response */
1230                 for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
1231                         if (inb(IO_KBD + KBD_STATUS_PORT) &
1232                             KBDS_ANY_BUFFER_FULL)
1233                                 break;
1234                         delay1ms();
1235                 }
1236                 if (wait <= 0)
1237                         continue;
1238
1239                 delay7();
1240                 i = inb(IO_KBD + KBD_DATA_PORT);
1241 #ifdef PROBE_KBD_BEBUG
1242                 printf("probe_keyboard: got 0x%x.\n", i);
1243 #endif
1244                 if (i == KBD_ECHO) {
1245                         /* got the right answer */
1246                         return (1);
1247                 }
1248         }
1249
1250         return (0);
1251 }
1252 #endif /* KEYBOARD_PROBE */