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