1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */
29 /* All Rights Reserved */
30
31 #include <sys/errno.h>
32 #include <sys/types.h>
33 #include <sys/conf.h>
34 #include <sys/kmem.h>
35 #include <sys/visual_io.h>
36 #include <sys/font.h>
37 #include <sys/fbio.h>
38 #include <sys/ddi.h>
39 #include <sys/stat.h>
40 #include <sys/sunddi.h>
41 #include <sys/open.h>
42 #include <sys/modctl.h>
43 #include <sys/pci.h>
44 #include <sys/kd.h>
45 #include <sys/ddi_impldefs.h>
46 #include <sys/gfx_private.h>
47 #include "gfxp_fb.h"
48
49 #define MYNAME "gfxp_vgatext"
50
51 #define VGA_BRIGHT_WHITE 0x0f
52 #define VGA_BLACK 0x00
53
54 #define VGA_REG_ADDR 0x3c0
55 #define VGA_REG_SIZE 0x20
56
57 #define VGA_MEM_ADDR 0xa0000
58 #define VGA_MEM_SIZE 0x20000
59
60 #define VGA_MMAP_FB_BASE VGA_MEM_ADDR
61
62 typedef enum pc_colors {
63 pc_black = 0,
64 pc_blue = 1,
65 pc_green = 2,
66 pc_cyan = 3,
67 pc_red = 4,
68 pc_magenta = 5,
69 pc_brown = 6,
70 pc_white = 7,
71 pc_grey = 8,
72 pc_brt_blue = 9,
73 pc_brt_green = 10,
74 pc_brt_cyan = 11,
75 pc_brt_red = 12,
76 pc_brt_magenta = 13,
77 pc_yellow = 14,
78 pc_brt_white = 15
79 } pc_colors_t;
80
81 static const unsigned char solaris_color_to_pc_color[16] = {
82 pc_brt_white, /* 0 - brt_white */
83 pc_black, /* 1 - black */
84 pc_blue, /* 2 - blue */
85 pc_green, /* 3 - green */
86 pc_cyan, /* 4 - cyan */
87 pc_red, /* 5 - red */
88 pc_magenta, /* 6 - magenta */
89 pc_brown, /* 7 - brown */
90 pc_white, /* 8 - white */
91 pc_grey, /* 9 - gery */
92 pc_brt_blue, /* 10 - brt_blue */
93 pc_brt_green, /* 11 - brt_green */
94 pc_brt_cyan, /* 12 - brt_cyan */
95 pc_brt_red, /* 13 - brt_red */
96 pc_brt_magenta, /* 14 - brt_magenta */
97 pc_yellow /* 15 - yellow */
98 };
99
100 static ddi_device_acc_attr_t dev_attr = {
101 DDI_DEVICE_ATTR_V0,
102 DDI_NEVERSWAP_ACC,
103 DDI_STRICTORDER_ACC,
104 };
105
106 /* default structure for FBIOGATTR ioctl */
107 static struct fbgattr vgatext_attr = {
108 /* real_type owner */
109 FBTYPE_SUNFAST_COLOR, 0,
110 /* fbtype: type h w depth cms size */
111 { FBTYPE_SUNFAST_COLOR, TEXT_ROWS, TEXT_COLS, 1, 256, 0 },
112 /* fbsattr: flags emu_type dev_specific */
113 { 0, FBTYPE_SUN4COLOR, { 0 } },
114 /* emu_types */
115 { -1 }
116 };
117
118 static struct vis_identifier gfxp_vgatext_ident = { "illumos_text" };
119
120 int gfxp_vga_detach(dev_info_t *, ddi_detach_cmd_t, struct gfxp_fb_softc *);
121 static int vgatext_devinit(struct gfxp_fb_softc *, struct vis_devinit *data);
122 static void vgatext_cons_copy(struct gfxp_fb_softc *,
123 struct vis_conscopy *);
124 static void vgatext_cons_display(struct gfxp_fb_softc *,
125 struct vis_consdisplay *);
126 static int vgatext_cons_clear(struct gfxp_fb_softc *,
127 struct vis_consclear *);
128 static void vgatext_cons_cursor(struct gfxp_fb_softc *,
129 struct vis_conscursor *);
130 static void vgatext_polled_copy(struct vis_polledio_arg *,
131 struct vis_conscopy *);
132 static void vgatext_polled_display(struct vis_polledio_arg *,
133 struct vis_consdisplay *);
134 static void vgatext_polled_cursor(struct vis_polledio_arg *,
135 struct vis_conscursor *);
136 static void vgatext_init(struct gfxp_fb_softc *);
137 static void vgatext_set_text(struct gfxp_fb_softc *);
138
139 static void vgatext_get_text(struct gfxp_fb_softc *softc);
140 static void vgatext_save_text(struct gfxp_fb_softc *softc);
141 static void vgatext_kdsettext(struct gfxp_fb_softc *softc);
142 static int vgatext_suspend(struct gfxp_fb_softc *softc);
143 static void vgatext_resume(struct gfxp_fb_softc *softc);
144 static int vgatext_devmap(dev_t, devmap_cookie_t, offset_t, size_t,
145 size_t *, uint_t, void *);
146
147 #if defined(USE_BORDERS)
148 static void vgatext_init_graphics(struct gfxp_fb_softc *);
149 #endif
150
151 static int vgatext_kdsetmode(struct gfxp_fb_softc *softc, int mode);
152 static void vgatext_setfont(struct gfxp_fb_softc *softc);
153 static void vgatext_get_cursor(struct gfxp_fb_softc *softc,
154 screen_pos_t *row, screen_pos_t *col);
155 static void vgatext_set_cursor(struct gfxp_fb_softc *softc, int row, int col);
156 static void vgatext_hide_cursor(struct gfxp_fb_softc *softc);
157 static void vgatext_save_colormap(struct gfxp_fb_softc *softc);
158 static void vgatext_restore_colormap(struct gfxp_fb_softc *softc);
159 static int vgatext_get_pci_reg_index(dev_info_t *const devi,
160 unsigned long himask, unsigned long hival, unsigned long addr,
161 off_t *offset);
162 static int vgatext_get_isa_reg_index(dev_info_t *const devi,
163 unsigned long hival, unsigned long addr, off_t *offset);
164
165 static struct gfxp_ops gfxp_vgatext_ops = {
166 .ident = &gfxp_vgatext_ident,
167 .kdsetmode = vgatext_kdsetmode,
168 .devinit = vgatext_devinit,
169 .cons_copy = vgatext_cons_copy,
170 .cons_display = vgatext_cons_display,
171 .cons_cursor = vgatext_cons_cursor,
172 .cons_clear = vgatext_cons_clear,
173 .suspend = vgatext_suspend,
174 .resume = vgatext_resume,
175 .devmap = vgatext_devmap
176 };
177
178 #define STREQ(a, b) (strcmp((a), (b)) == 0)
179
180 /*ARGSUSED*/
181 int
182 gfxp_vga_attach(dev_info_t *devi, ddi_attach_cmd_t cmd,
183 struct gfxp_fb_softc *softc)
184 {
185 int unit = ddi_get_instance(devi);
186 int error;
187 char *parent_type = NULL;
188 int reg_rnumber;
189 off_t reg_offset;
190 off_t mem_offset;
191 char *cons;
192 struct gfx_vga *vga;
193
194
195 softc->polledio.display = vgatext_polled_display;
196 softc->polledio.copy = vgatext_polled_copy;
197 softc->polledio.cursor = vgatext_polled_cursor;
198 softc->gfxp_ops = &gfxp_vgatext_ops;
199 softc->fbgattr = &vgatext_attr;
200 vga = kmem_zalloc(sizeof (*vga), KM_SLEEP);
201 softc->console = (union gfx_console *)vga;
202
203 error = ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_get_parent(devi),
204 DDI_PROP_DONTPASS, "device_type", &parent_type);
205 if (error != DDI_SUCCESS) {
206 cmn_err(CE_WARN, MYNAME ": can't determine parent type.");
207 goto fail;
208 }
209
210 /* Not enable AGP and DRM by default */
211 if (STREQ(parent_type, "isa") || STREQ(parent_type, "eisa")) {
212 reg_rnumber = vgatext_get_isa_reg_index(devi, 1, VGA_REG_ADDR,
213 ®_offset);
214 if (reg_rnumber < 0) {
215 cmn_err(CE_WARN,
216 MYNAME
217 ": can't find reg entry for registers");
218 error = DDI_FAILURE;
219 goto fail;
220 }
221 vga->fb_regno = vgatext_get_isa_reg_index(devi, 0,
222 VGA_MEM_ADDR, &mem_offset);
223 if (vga->fb_regno < 0) {
224 cmn_err(CE_WARN,
225 MYNAME ": can't find reg entry for memory");
226 error = DDI_FAILURE;
227 goto fail;
228 }
229 } else if (STREQ(parent_type, "pci") || STREQ(parent_type, "pciex")) {
230 reg_rnumber = vgatext_get_pci_reg_index(devi,
231 PCI_REG_ADDR_M|PCI_REG_REL_M,
232 PCI_ADDR_IO|PCI_RELOCAT_B, VGA_REG_ADDR,
233 ®_offset);
234 if (reg_rnumber < 0) {
235 cmn_err(CE_WARN,
236 MYNAME ": can't find reg entry for registers");
237 error = DDI_FAILURE;
238 goto fail;
239 }
240 vga->fb_regno = vgatext_get_pci_reg_index(devi,
241 PCI_REG_ADDR_M|PCI_REG_REL_M,
242 PCI_ADDR_MEM32|PCI_RELOCAT_B, VGA_MEM_ADDR,
243 &mem_offset);
244 if (vga->fb_regno < 0) {
245 cmn_err(CE_WARN,
246 MYNAME ": can't find reg entry for memory");
247 error = DDI_FAILURE;
248 goto fail;
249 }
250 } else {
251 cmn_err(CE_WARN, MYNAME ": unknown parent type \"%s\".",
252 parent_type);
253 error = DDI_FAILURE;
254 goto fail;
255 }
256 ddi_prop_free(parent_type);
257 parent_type = NULL;
258
259 error = ddi_regs_map_setup(devi, reg_rnumber,
260 (caddr_t *)&vga->regs.addr, reg_offset, VGA_REG_SIZE,
261 &dev_attr, &vga->regs.handle);
262 if (error != DDI_SUCCESS)
263 goto fail;
264 vga->regs.mapped = B_TRUE;
265
266 vga->fb_size = VGA_MEM_SIZE;
267
268 error = ddi_regs_map_setup(devi, vga->fb_regno,
269 (caddr_t *)&vga->fb.addr, mem_offset, vga->fb_size, &dev_attr,
270 &vga->fb.handle);
271 if (error != DDI_SUCCESS)
272 goto fail;
273 vga->fb.mapped = B_TRUE;
274
275 if (ddi_get8(vga->regs.handle,
276 vga->regs.addr + VGA_MISC_R) & VGA_MISC_IOA_SEL)
277 vga->text_base = (caddr_t)vga->fb.addr + VGA_COLOR_BASE;
278 else
279 vga->text_base = (caddr_t)vga->fb.addr + VGA_MONO_BASE;
280
281 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
282 DDI_PROP_DONTPASS, "console", &cons) == DDI_SUCCESS) {
283 if (strcmp(cons, "graphics") == 0) {
284 softc->happyface_boot = 1;
285 softc->silent = 1;
286 vga->current_base = vga->shadow;
287 } else {
288 vga->current_base = vga->text_base;
289 }
290 ddi_prop_free(cons);
291 } else {
292 vga->current_base = vga->text_base;
293 }
294
295 /* Set cursor info. */
296 vga->cursor.visible = fb_info.cursor.visible;
297 vga->cursor.row = fb_info.cursor.pos.y;
298 vga->cursor.col = fb_info.cursor.pos.x;
299
300 error = ddi_prop_create(makedevice(DDI_MAJOR_T_UNKNOWN, unit),
301 devi, DDI_PROP_CANSLEEP, DDI_KERNEL_IOCTL, NULL, 0);
302 if (error != DDI_SUCCESS)
303 goto fail;
304
305 /* only do this if not in graphics mode */
306 if ((softc->silent == 0) && (GFXP_IS_CONSOLE(softc))) {
307 vgatext_init(softc);
308 vgatext_save_colormap(softc);
309 }
310
311 return (DDI_SUCCESS);
312
313 fail:
314 kmem_free(vga, sizeof (*vga));
315 if (parent_type != NULL)
316 ddi_prop_free(parent_type);
317 return (error);
318 }
319
320 /*ARGSUSED*/
321 int
322 gfxp_vga_detach(dev_info_t *devi, ddi_detach_cmd_t cmd,
323 struct gfxp_fb_softc *softc)
324 {
325 if (softc->console->vga.fb.mapped)
326 ddi_regs_map_free(&softc->console->vga.fb.handle);
327 if (softc->console->vga.regs.mapped)
328 ddi_regs_map_free(&softc->console->vga.regs.handle);
329 kmem_free(softc->console, sizeof (struct gfx_vga));
330 return (DDI_SUCCESS);
331 }
332
333 /*
334 * vgatext_save_text
335 * vgatext_suspend
336 * vgatext_resume
337 *
338 * Routines to save and restore contents of the VGA text area
339 * Mostly, this is to support Suspend/Resume operation for graphics
340 * device drivers. Here in the VGAtext common code, we simply squirrel
341 * away the contents of the hardware's text area during Suspend and then
342 * put it back during Resume
343 */
344 static void
345 vgatext_save_text(struct gfxp_fb_softc *softc)
346 {
347 union gfx_console *console = softc->console;
348 unsigned i;
349
350 for (i = 0; i < sizeof (console->vga.shadow); i++)
351 console->vga.shadow[i] = console->vga.current_base[i];
352 }
353
354 static int
355 vgatext_suspend(struct gfxp_fb_softc *softc)
356 {
357 switch (softc->mode) {
358 case KD_TEXT:
359 vgatext_save_text(softc);
360 break;
361
362 case KD_GRAPHICS:
363 break;
364
365 default:
366 cmn_err(CE_WARN, MYNAME ": unknown mode in vgatext_suspend.");
367 return (DDI_FAILURE);
368 }
369 return (DDI_SUCCESS);
370 }
371
372 static void
373 vgatext_resume(struct gfxp_fb_softc *softc)
374 {
375
376 switch (softc->mode) {
377 case KD_TEXT:
378 vgatext_kdsettext(softc);
379 break;
380
381 case KD_GRAPHICS:
382
383 /*
384 * Upon RESUME, the graphics device will always actually
385 * be in TEXT mode even though the Xorg server did not
386 * make that mode change itself (the suspend code did).
387 * We want first, therefore, to restore textmode
388 * operation fully, and then the Xorg server will
389 * do the rest to restore the device to its
390 * (hi resolution) graphics mode
391 */
392 vgatext_kdsettext(softc);
393 #if defined(USE_BORDERS)
394 vgatext_init_graphics(softc);
395 #endif
396 break;
397 default:
398 cmn_err(CE_WARN, MYNAME ": unknown mode in vgatext_resume.");
399 break;
400 }
401 }
402
403 static void
404 vgatext_progressbar_stop(struct gfxp_fb_softc *softc)
405 {
406 extern void progressbar_stop(void);
407
408 if (softc->silent == 1) {
409 softc->silent = 0;
410 progressbar_stop();
411 }
412 }
413
414 static void
415 vgatext_kdsettext(struct gfxp_fb_softc *softc)
416 {
417 union gfx_console *console = softc->console;
418 int i;
419
420 vgatext_init(softc);
421 for (i = 0; i < sizeof (console->vga.shadow); i++) {
422 console->vga.text_base[i] = console->vga.shadow[i];
423 }
424 console->vga.current_base = console->vga.text_base;
425 if (console->vga.cursor.visible) {
426 vgatext_set_cursor(softc,
427 console->vga.cursor.row,
428 console->vga.cursor.col);
429 }
430 vgatext_restore_colormap(softc);
431 }
432
433 static void
434 vgatext_kdsetgraphics(struct gfxp_fb_softc *softc)
435 {
436 vgatext_progressbar_stop(softc);
437 vgatext_save_text(softc);
438 softc->console->vga.current_base = softc->console->vga.shadow;
439 vgatext_get_text(softc);
440 #if defined(USE_BORDERS)
441 vgatext_init_graphics(softc);
442 #endif
443 }
444
445 static int
446 vgatext_kdsetmode(struct gfxp_fb_softc *softc, int mode)
447 {
448 switch (mode) {
449 case KD_TEXT:
450 if (softc->blt_ops.setmode != NULL)
451 softc->blt_ops.setmode(KD_TEXT);
452 vgatext_kdsettext(softc);
453 break;
454
455 case KD_GRAPHICS:
456 vgatext_kdsetgraphics(softc);
457 if (softc->blt_ops.setmode != NULL)
458 softc->blt_ops.setmode(KD_GRAPHICS);
459 break;
460
461 case KD_RESETTEXT:
462 /*
463 * In order to avoid racing with a starting X server,
464 * this needs to be a test and set that is performed in
465 * a single (softc->lock protected) ioctl into this driver.
466 */
467 if (softc->mode == KD_TEXT && softc->silent == 1) {
468 vgatext_progressbar_stop(softc);
469 vgatext_kdsettext(softc);
470 }
471 mode = KD_TEXT;
472 break;
473
474 default:
475 return (EINVAL);
476 }
477
478 softc->mode = mode;
479 return (0);
480 }
481
482 /*ARGSUSED*/
483 static int
484 vgatext_devmap(dev_t dev, devmap_cookie_t dhp, offset_t off, size_t len,
485 size_t *maplen, uint_t model, void *ptr)
486 {
487 struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)ptr;
488 union gfx_console *console;
489 int err;
490 size_t length;
491
492
493 if (softc == NULL) {
494 cmn_err(CE_WARN, "vgatext: Can't find softstate");
495 return (-1);
496 }
497 console = softc->console;
498
499 if (!(off >= VGA_MMAP_FB_BASE &&
500 off < VGA_MMAP_FB_BASE + console->vga.fb_size)) {
501 cmn_err(CE_WARN, "vgatext: Can't map offset 0x%llx", off);
502 return (-1);
503 }
504
505 if (off + len > VGA_MMAP_FB_BASE + console->vga.fb_size)
506 length = VGA_MMAP_FB_BASE + console->vga.fb_size - off;
507 else
508 length = len;
509
510 if ((err = devmap_devmem_setup(dhp, softc->devi,
511 NULL, console->vga.fb_regno, off - VGA_MMAP_FB_BASE,
512 length, PROT_ALL, 0, &dev_attr)) < 0) {
513 return (err);
514 }
515
516
517 *maplen = length;
518 return (0);
519 }
520
521
522 static int
523 vgatext_devinit(struct gfxp_fb_softc *softc, struct vis_devinit *data)
524 {
525 /* initialize console instance */
526 data->version = VIS_CONS_REV;
527 data->width = TEXT_COLS;
528 data->height = TEXT_ROWS;
529 data->linebytes = TEXT_COLS;
530 data->color_map = NULL;
531 data->depth = 4;
532 data->mode = VIS_TEXT;
533 data->polledio = &softc->polledio;
534
535 vgatext_save_text(softc); /* save current console */
536 vgatext_hide_cursor(softc);
537 return (0);
538 }
539
540 /*
541 * Binary searchable table for Unicode to CP437 conversion.
542 */
543 struct unicp437 {
544 uint16_t unicode_base;
545 uint8_t cp437_base;
546 uint8_t length;
547 };
548
549 static const struct unicp437 cp437table[] = {
550 { 0x0020, 0x20, 0x5e }, { 0x00a0, 0x20, 0x00 }, { 0x00a1, 0xad, 0x00 },
551 { 0x00a2, 0x9b, 0x00 }, { 0x00a3, 0x9c, 0x00 }, { 0x00a5, 0x9d, 0x00 },
552 { 0x00a7, 0x15, 0x00 }, { 0x00aa, 0xa6, 0x00 }, { 0x00ab, 0xae, 0x00 },
553 { 0x00ac, 0xaa, 0x00 }, { 0x00b0, 0xf8, 0x00 }, { 0x00b1, 0xf1, 0x00 },
554 { 0x00b2, 0xfd, 0x00 }, { 0x00b5, 0xe6, 0x00 }, { 0x00b6, 0x14, 0x00 },
555 { 0x00b7, 0xfa, 0x00 }, { 0x00ba, 0xa7, 0x00 }, { 0x00bb, 0xaf, 0x00 },
556 { 0x00bc, 0xac, 0x00 }, { 0x00bd, 0xab, 0x00 }, { 0x00bf, 0xa8, 0x00 },
557 { 0x00c4, 0x8e, 0x01 }, { 0x00c6, 0x92, 0x00 }, { 0x00c7, 0x80, 0x00 },
558 { 0x00c9, 0x90, 0x00 }, { 0x00d1, 0xa5, 0x00 }, { 0x00d6, 0x99, 0x00 },
559 { 0x00dc, 0x9a, 0x00 }, { 0x00df, 0xe1, 0x00 }, { 0x00e0, 0x85, 0x00 },
560 { 0x00e1, 0xa0, 0x00 }, { 0x00e2, 0x83, 0x00 }, { 0x00e4, 0x84, 0x00 },
561 { 0x00e5, 0x86, 0x00 }, { 0x00e6, 0x91, 0x00 }, { 0x00e7, 0x87, 0x00 },
562 { 0x00e8, 0x8a, 0x00 }, { 0x00e9, 0x82, 0x00 }, { 0x00ea, 0x88, 0x01 },
563 { 0x00ec, 0x8d, 0x00 }, { 0x00ed, 0xa1, 0x00 }, { 0x00ee, 0x8c, 0x00 },
564 { 0x00ef, 0x8b, 0x00 }, { 0x00f0, 0xeb, 0x00 }, { 0x00f1, 0xa4, 0x00 },
565 { 0x00f2, 0x95, 0x00 }, { 0x00f3, 0xa2, 0x00 }, { 0x00f4, 0x93, 0x00 },
566 { 0x00f6, 0x94, 0x00 }, { 0x00f7, 0xf6, 0x00 }, { 0x00f8, 0xed, 0x00 },
567 { 0x00f9, 0x97, 0x00 }, { 0x00fa, 0xa3, 0x00 }, { 0x00fb, 0x96, 0x00 },
568 { 0x00fc, 0x81, 0x00 }, { 0x00ff, 0x98, 0x00 }, { 0x0192, 0x9f, 0x00 },
569 { 0x0393, 0xe2, 0x00 }, { 0x0398, 0xe9, 0x00 }, { 0x03a3, 0xe4, 0x00 },
570 { 0x03a6, 0xe8, 0x00 }, { 0x03a9, 0xea, 0x00 }, { 0x03b1, 0xe0, 0x01 },
571 { 0x03b4, 0xeb, 0x00 }, { 0x03b5, 0xee, 0x00 }, { 0x03bc, 0xe6, 0x00 },
572 { 0x03c0, 0xe3, 0x00 }, { 0x03c3, 0xe5, 0x00 }, { 0x03c4, 0xe7, 0x00 },
573 { 0x03c6, 0xed, 0x00 }, { 0x03d5, 0xed, 0x00 }, { 0x2010, 0x2d, 0x00 },
574 { 0x2014, 0x2d, 0x00 }, { 0x2018, 0x60, 0x00 }, { 0x2019, 0x27, 0x00 },
575 { 0x201c, 0x22, 0x00 }, { 0x201d, 0x22, 0x00 }, { 0x2022, 0x07, 0x00 },
576 { 0x203c, 0x13, 0x00 }, { 0x207f, 0xfc, 0x00 }, { 0x20a7, 0x9e, 0x00 },
577 { 0x20ac, 0xee, 0x00 }, { 0x2126, 0xea, 0x00 }, { 0x2190, 0x1b, 0x00 },
578 { 0x2191, 0x18, 0x00 }, { 0x2192, 0x1a, 0x00 }, { 0x2193, 0x19, 0x00 },
579 { 0x2194, 0x1d, 0x00 }, { 0x2195, 0x12, 0x00 }, { 0x21a8, 0x17, 0x00 },
580 { 0x2202, 0xeb, 0x00 }, { 0x2208, 0xee, 0x00 }, { 0x2211, 0xe4, 0x00 },
581 { 0x2212, 0x2d, 0x00 }, { 0x2219, 0xf9, 0x00 }, { 0x221a, 0xfb, 0x00 },
582 { 0x221e, 0xec, 0x00 }, { 0x221f, 0x1c, 0x00 }, { 0x2229, 0xef, 0x00 },
583 { 0x2248, 0xf7, 0x00 }, { 0x2261, 0xf0, 0x00 }, { 0x2264, 0xf3, 0x00 },
584 { 0x2265, 0xf2, 0x00 }, { 0x2302, 0x7f, 0x00 }, { 0x2310, 0xa9, 0x00 },
585 { 0x2320, 0xf4, 0x00 }, { 0x2321, 0xf5, 0x00 }, { 0x2500, 0xc4, 0x00 },
586 { 0x2502, 0xb3, 0x00 }, { 0x250c, 0xda, 0x00 }, { 0x2510, 0xbf, 0x00 },
587 { 0x2514, 0xc0, 0x00 }, { 0x2518, 0xd9, 0x00 }, { 0x251c, 0xc3, 0x00 },
588 { 0x2524, 0xb4, 0x00 }, { 0x252c, 0xc2, 0x00 }, { 0x2534, 0xc1, 0x00 },
589 { 0x253c, 0xc5, 0x00 }, { 0x2550, 0xcd, 0x00 }, { 0x2551, 0xba, 0x00 },
590 { 0x2552, 0xd5, 0x00 }, { 0x2553, 0xd6, 0x00 }, { 0x2554, 0xc9, 0x00 },
591 { 0x2555, 0xb8, 0x00 }, { 0x2556, 0xb7, 0x00 }, { 0x2557, 0xbb, 0x00 },
592 { 0x2558, 0xd4, 0x00 }, { 0x2559, 0xd3, 0x00 }, { 0x255a, 0xc8, 0x00 },
593 { 0x255b, 0xbe, 0x00 }, { 0x255c, 0xbd, 0x00 }, { 0x255d, 0xbc, 0x00 },
594 { 0x255e, 0xc6, 0x01 }, { 0x2560, 0xcc, 0x00 }, { 0x2561, 0xb5, 0x00 },
595 { 0x2562, 0xb6, 0x00 }, { 0x2563, 0xb9, 0x00 }, { 0x2564, 0xd1, 0x01 },
596 { 0x2566, 0xcb, 0x00 }, { 0x2567, 0xcf, 0x00 }, { 0x2568, 0xd0, 0x00 },
597 { 0x2569, 0xca, 0x00 }, { 0x256a, 0xd8, 0x00 }, { 0x256b, 0xd7, 0x00 },
598 { 0x256c, 0xce, 0x00 }, { 0x2580, 0xdf, 0x00 }, { 0x2584, 0xdc, 0x00 },
599 { 0x2588, 0xdb, 0x00 }, { 0x258c, 0xdd, 0x00 }, { 0x2590, 0xde, 0x00 },
600 { 0x2591, 0xb0, 0x02 }, { 0x25a0, 0xfe, 0x00 }, { 0x25ac, 0x16, 0x00 },
601 { 0x25b2, 0x1e, 0x00 }, { 0x25ba, 0x10, 0x00 }, { 0x25bc, 0x1f, 0x00 },
602 { 0x25c4, 0x11, 0x00 }, { 0x25cb, 0x09, 0x00 }, { 0x25d8, 0x08, 0x00 },
603 { 0x25d9, 0x0a, 0x00 }, { 0x263a, 0x01, 0x01 }, { 0x263c, 0x0f, 0x00 },
604 { 0x2640, 0x0c, 0x00 }, { 0x2642, 0x0b, 0x00 }, { 0x2660, 0x06, 0x00 },
605 { 0x2663, 0x05, 0x00 }, { 0x2665, 0x03, 0x01 }, { 0x266a, 0x0d, 0x00 },
606 { 0x266c, 0x0e, 0x00 }
607 };
608
609 static uint8_t
610 vga_get_cp437(uint32_t c)
611 {
612 int min, mid, max;
613
614 min = 0;
615 max = (sizeof(cp437table) / sizeof(struct unicp437)) - 1;
616
617 if (c < cp437table[0].unicode_base ||
618 c > cp437table[max].unicode_base + cp437table[max].length)
619 return ('?');
620
621 while (max >= min) {
622 mid = (min + max) / 2;
623 if (c < cp437table[mid].unicode_base)
624 max = mid - 1;
625 else if (c > cp437table[mid].unicode_base +
626 cp437table[mid].length)
627 min = mid + 1;
628 else
629 return (c - cp437table[mid].unicode_base +
630 cp437table[mid].cp437_base);
631 }
632
633 return ('?');
634 }
635
636 /*
637 * display a string on the screen at (row, col)
638 * assume it has been cropped to fit.
639 */
640 static void
641 vgatext_cons_display(struct gfxp_fb_softc *softc, struct vis_consdisplay *da)
642 {
643 uint32_t *string;
644 int i;
645 unsigned char attr;
646 struct cgatext {
647 unsigned char ch;
648 unsigned char attr;
649 };
650 struct cgatext *addr;
651
652 /*
653 * Sanity checks. This is a last-ditch effort to avoid damage
654 * from brokenness or maliciousness above.
655 */
656 if (da->row < 0 || da->row >= TEXT_ROWS ||
657 da->col < 0 || da->col >= TEXT_COLS ||
658 da->col + da->width > TEXT_COLS)
659 return;
660
661 /*
662 * To be fully general, we should copyin the data. This is not
663 * really relevant for this text-only driver, but a graphical driver
664 * should support these ioctls from userland to enable simple
665 * system startup graphics.
666 */
667 attr = (solaris_color_to_pc_color[da->bg_color & 0xf] << 4)
668 | solaris_color_to_pc_color[da->fg_color & 0xf];
669 string = (uint32_t *)da->data;
670 addr = (struct cgatext *)softc->console->vga.current_base
671 + (da->row * TEXT_COLS + da->col);
672 for (i = 0; i < da->width; i++) {
673 addr[i].ch = vga_get_cp437(string[i]);
674 addr[i].attr = attr;
675 }
676 }
677
678 static void
679 vgatext_polled_display(
680 struct vis_polledio_arg *arg,
681 struct vis_consdisplay *da)
682 {
683 vgatext_cons_display((struct gfxp_fb_softc *)arg, da);
684 }
685
686 /*
687 * screen-to-screen copy
688 */
689
690 static void
691 vgatext_cons_copy(struct gfxp_fb_softc *softc, struct vis_conscopy *ma)
692 {
693 unsigned short *from;
694 unsigned short *to;
695 int cnt;
696 screen_size_t chars_per_row;
697 unsigned short *to_row_start;
698 unsigned short *from_row_start;
699 screen_size_t rows_to_move;
700 unsigned short *base;
701
702 /*
703 * Sanity checks. Note that this is a last-ditch effort to avoid
704 * damage caused by broken-ness or maliciousness above.
705 */
706 if (ma->s_col < 0 || ma->s_col >= TEXT_COLS ||
707 ma->s_row < 0 || ma->s_row >= TEXT_ROWS ||
708 ma->e_col < 0 || ma->e_col >= TEXT_COLS ||
709 ma->e_row < 0 || ma->e_row >= TEXT_ROWS ||
710 ma->t_col < 0 || ma->t_col >= TEXT_COLS ||
711 ma->t_row < 0 || ma->t_row >= TEXT_ROWS ||
712 ma->s_col > ma->e_col ||
713 ma->s_row > ma->e_row)
714 return;
715
716 /*
717 * Remember we're going to copy shorts because each
718 * character/attribute pair is 16 bits.
719 */
720 chars_per_row = ma->e_col - ma->s_col + 1;
721 rows_to_move = ma->e_row - ma->s_row + 1;
722
723 /* More sanity checks. */
724 if (ma->t_row + rows_to_move > TEXT_ROWS ||
725 ma->t_col + chars_per_row > TEXT_COLS)
726 return;
727
728 base = (unsigned short *)softc->console->vga.current_base;
729
730 to_row_start = base + ((ma->t_row * TEXT_COLS) + ma->t_col);
731 from_row_start = base + ((ma->s_row * TEXT_COLS) + ma->s_col);
732
733 if (to_row_start < from_row_start) {
734 while (rows_to_move-- > 0) {
735 to = to_row_start;
736 from = from_row_start;
737 to_row_start += TEXT_COLS;
738 from_row_start += TEXT_COLS;
739 for (cnt = chars_per_row; cnt-- > 0; )
740 *to++ = *from++;
741 }
742 } else {
743 /*
744 * Offset to the end of the region and copy backwards.
745 */
746 cnt = rows_to_move * TEXT_COLS + chars_per_row;
747 to_row_start += cnt;
748 from_row_start += cnt;
749
750 while (rows_to_move-- > 0) {
751 to_row_start -= TEXT_COLS;
752 from_row_start -= TEXT_COLS;
753 to = to_row_start;
754 from = from_row_start;
755 for (cnt = chars_per_row; cnt-- > 0; )
756 *--to = *--from;
757 }
758 }
759 }
760
761 static void
762 vgatext_polled_copy(
763 struct vis_polledio_arg *arg,
764 struct vis_conscopy *ca)
765 {
766 vgatext_cons_copy((struct gfxp_fb_softc *)arg, ca);
767 }
768
769 /*ARGSUSED*/
770 static int
771 vgatext_cons_clear(struct gfxp_fb_softc *softc, struct vis_consclear *ca)
772 {
773 uint16_t val, fg, *base;
774 int i;
775
776 if (ca->bg_color == 0) /* bright white */
777 fg = 1; /* black */
778 else
779 fg = 8;
780
781 val = (solaris_color_to_pc_color[ca->bg_color & 0xf] << 4) |
782 solaris_color_to_pc_color[fg];
783 val = (val << 8) | ' ';
784
785 base = (uint16_t *)softc->console->vga.current_base;
786 for (i = 0; i < TEXT_ROWS * TEXT_COLS; i++)
787 base[i] = val;
788
789 return (0);
790 }
791
792 static void
793 vgatext_cons_cursor(struct gfxp_fb_softc *softc, struct vis_conscursor *ca)
794 {
795 if (softc->silent)
796 return;
797
798 switch (ca->action) {
799 case VIS_HIDE_CURSOR:
800 softc->console->vga.cursor.visible = B_FALSE;
801 if (softc->console->vga.current_base ==
802 softc->console->vga.text_base)
803 vgatext_hide_cursor(softc);
804 break;
805 case VIS_DISPLAY_CURSOR:
806 /*
807 * Sanity check. This is a last-ditch effort to avoid
808 * damage from brokenness or maliciousness above.
809 */
810 if (ca->col < 0 || ca->col >= TEXT_COLS ||
811 ca->row < 0 || ca->row >= TEXT_ROWS)
812 return;
813
814 softc->console->vga.cursor.visible = B_TRUE;
815 softc->console->vga.cursor.col = ca->col;
816 softc->console->vga.cursor.row = ca->row;
817 if (softc->console->vga.current_base ==
818 softc->console->vga.text_base)
819 vgatext_set_cursor(softc, ca->row, ca->col);
820 break;
821 case VIS_GET_CURSOR:
822 if (softc->console->vga.current_base ==
823 softc->console->vga.text_base) {
824 vgatext_get_cursor(softc, &ca->row, &ca->col);
825 }
826 break;
827 }
828 }
829
830 static void
831 vgatext_polled_cursor(
832 struct vis_polledio_arg *arg,
833 struct vis_conscursor *ca)
834 {
835 vgatext_cons_cursor((struct gfxp_fb_softc *)arg, ca);
836 }
837
838 static void
839 vgatext_hide_cursor(struct gfxp_fb_softc *softc)
840 {
841 union gfx_console *console = softc->console;
842 uint8_t msl, s;
843
844 if (softc->silent)
845 return;
846
847 msl = vga_get_crtc(&console->vga.regs, VGA_CRTC_MAX_S_LN) & 0x1f;
848 s = vga_get_crtc(&console->vga.regs, VGA_CRTC_CSSL) & 0xc0;
849 s |= (1<<5);
850
851 /* disable cursor */
852 vga_set_crtc(&console->vga.regs, VGA_CRTC_CSSL, s);
853 vga_set_crtc(&console->vga.regs, VGA_CRTC_CESL, msl);
854 }
855
856 static void
857 vgatext_set_cursor(struct gfxp_fb_softc *softc, int row, int col)
858 {
859 union gfx_console *console = softc->console;
860 short addr;
861 uint8_t msl, s;
862
863 if (softc->silent)
864 return;
865
866 msl = vga_get_crtc(&console->vga.regs, VGA_CRTC_MAX_S_LN) & 0x1f;
867 s = vga_get_crtc(&console->vga.regs, VGA_CRTC_CSSL) & 0xc0;
868
869 addr = row * TEXT_COLS + col;
870
871 vga_set_crtc(&console->vga.regs, VGA_CRTC_CLAH, addr >> 8);
872 vga_set_crtc(&console->vga.regs, VGA_CRTC_CLAL, addr & 0xff);
873
874 /* enable cursor */
875 vga_set_crtc(&console->vga.regs, VGA_CRTC_CSSL, s);
876 vga_set_crtc(&console->vga.regs, VGA_CRTC_CESL, msl);
877 }
878
879 static void
880 vgatext_get_cursor(struct gfxp_fb_softc *softc,
881 screen_pos_t *row, screen_pos_t *col)
882 {
883 union gfx_console *console = softc->console;
884 short addr;
885
886 addr = (vga_get_crtc(&console->vga.regs, VGA_CRTC_CLAH) << 8) +
887 vga_get_crtc(&console->vga.regs, VGA_CRTC_CLAL);
888
889 *row = addr / TEXT_COLS;
890 *col = addr % TEXT_COLS;
891 }
892
893 static void
894 vgatext_get_text(struct gfxp_fb_softc *softc)
895 {
896 union gfx_console *console = softc->console;
897 struct vgareg *vga_reg;
898 struct vgaregmap *regs;
899 int i;
900
901 regs = &console->vga.regs;
902 vga_reg = &console->vga.vga_reg;
903
904 vga_reg->vga_misc = vga_get_reg(regs, VGA_MISC_R);
905
906 /* get crt controller registers */
907 for (i = 0; i < NUM_CRTC_REG; i++) {
908 vga_reg->vga_crtc[i] = vga_get_crtc(regs, i);
909 }
910
911 /* get attribute registers */
912 for (i = 0; i < NUM_ATR_REG; i++) {
913 vga_reg->vga_atr[i] = vga_get_atr(regs, i);
914 }
915
916 /* get graphics controller registers */
917 for (i = 0; i < NUM_GRC_REG; i++) {
918 vga_reg->vga_grc[i] = vga_get_grc(regs, i);
919 }
920
921 /* get sequencer registers */
922 for (i = 1; i < NUM_SEQ_REG; i++) {
923 vga_reg->vga_seq[i] = vga_get_seq(regs, i);
924 }
925 }
926
927 /*
928 * This code is experimental. It's only enabled if console is
929 * set to graphics, a preliminary implementation of happyface boot.
930 */
931 static void
932 vgatext_set_text(struct gfxp_fb_softc *softc)
933 {
934 union gfx_console *console = softc->console;
935 struct vgareg *vga_reg;
936 struct vgaregmap *regs;
937 int i;
938
939 regs = &console->vga.regs;
940 vga_reg = &console->vga.vga_reg;
941
942 vgatext_get_text(softc);
943 /*
944 if (softc->happyface_boot == 0)
945 return;
946 */
947
948 /*
949 * Set output register bits for text mode.
950 * Make sure the VGA adapter is not in monochrome emulation mode.
951 */
952 vga_set_reg(regs, VGA_MISC_W, VGA_MISC_HSP | VGA_MISC_PGSL |
953 VGA_MISC_VCLK1 | VGA_MISC_ENB_RAM | VGA_MISC_IOA_SEL);
954
955 #if 0
956 /* set misc registers */
957 vga_set_reg(regs, VGA_MISC_W, vga_reg->vga_misc);
958 #endif
959
960 /* set sequencer registers */
961 vga_set_seq(&console->vga.regs, VGA_SEQ_RST_SYN,
962 (vga_get_seq(&console->vga.regs, VGA_SEQ_RST_SYN) &
963 ~VGA_SEQ_RST_SYN_NO_SYNC_RESET));
964 for (i = 1; i < NUM_SEQ_REG; i++) {
965 /* vga_set_seq(regs, i, vga_reg->vga_seq[i]); */
966 vga_set_seq(regs, i, VGA_SEQ_TEXT[i]);
967 }
968 vga_set_seq(&console->vga.regs, VGA_SEQ_RST_SYN,
969 (vga_get_seq(&console->vga.regs, VGA_SEQ_RST_SYN) |
970 VGA_SEQ_RST_SYN_NO_ASYNC_RESET |
971 VGA_SEQ_RST_SYN_NO_SYNC_RESET));
972
973 /* set crt controller registers */
974 vga_set_crtc(&console->vga.regs, VGA_CRTC_VRE,
975 (vga_reg->vga_crtc[VGA_CRTC_VRE] & ~VGA_CRTC_VRE_LOCK));
976 for (i = 0; i < NUM_CRTC_REG; i++) {
977 /* vga_set_crtc(regs, i, vga_reg->vga_crtc[i]); */
978 vga_set_crtc(regs, i, VGA_CRTC_TEXT[i]);
979 }
980
981 /* set graphics controller registers */
982 for (i = 0; i < NUM_GRC_REG; i++) {
983 /* vga_set_grc(regs, i, vga_reg->vga_grc[i]); */
984 vga_set_grc(regs, i, VGA_GRC_TEXT[i]);
985 }
986
987 /* set attribute registers */
988 for (i = 0; i < NUM_ATR_REG; i++) {
989 /* vga_set_atr(regs, i, vga_reg->vga_seq[i]); */
990 vga_set_atr(regs, i, VGA_ATR_TEXT[i]);
991 }
992
993 /* set palette */
994 for (i = 0; i < VGA_TEXT_CMAP_ENTRIES; i++) {
995 vga_put_cmap(&console->vga.regs, i,
996 VGA_TEXT_PALETTES[i][0] << 2,
997 VGA_TEXT_PALETTES[i][1] << 2,
998 VGA_TEXT_PALETTES[i][2] << 2);
999 }
1000 for (i = VGA_TEXT_CMAP_ENTRIES; i < VGA8_CMAP_ENTRIES; i++) {
1001 vga_put_cmap(&console->vga.regs, i, 0, 0, 0);
1002 }
1003 }
1004
1005 static void
1006 vgatext_init(struct gfxp_fb_softc *softc)
1007 {
1008 union gfx_console *console = softc->console;
1009 unsigned char atr_mode;
1010
1011 atr_mode = vga_get_atr(&console->vga.regs, VGA_ATR_MODE);
1012 if (atr_mode & VGA_ATR_MODE_GRAPH)
1013 vgatext_set_text(softc);
1014 atr_mode = vga_get_atr(&console->vga.regs, VGA_ATR_MODE);
1015 atr_mode &= ~VGA_ATR_MODE_BLINK;
1016 atr_mode &= ~VGA_ATR_MODE_9WIDE;
1017 vga_set_atr(&console->vga.regs, VGA_ATR_MODE, atr_mode);
1018 #if defined(USE_BORDERS)
1019 vga_set_atr(&console->vga.regs, VGA_ATR_BDR_CLR,
1020 vga_get_atr(&console->vga.regs, VGA_BRIGHT_WHITE));
1021 #else
1022 vga_set_atr(&console->vga.regs, VGA_ATR_BDR_CLR,
1023 vga_get_atr(&console->vga.regs, VGA_BLACK));
1024 #endif
1025 vgatext_setfont(softc); /* need selectable font? */
1026 }
1027
1028 #if defined(USE_BORDERS)
1029 static void
1030 vgatext_init_graphics(struct gfxp_fb_softc *softc)
1031 {
1032 vga_set_atr(&softc->console->vga.regs, VGA_ATR_BDR_CLR,
1033 vga_get_atr(&softc->console->vga.regs, VGA_BLACK));
1034 }
1035 #endif
1036
1037 /*
1038 * Binary searchable table for CP437 to Unicode conversion.
1039 */
1040 struct cp437uni {
1041 uint8_t cp437_base;
1042 uint16_t unicode_base;
1043 uint8_t length;
1044 };
1045
1046 static const struct cp437uni cp437unitable[] = {
1047 { 0, 0x0000, 0 }, { 1, 0x263A, 1 }, { 3, 0x2665, 1 },
1048 { 5, 0x2663, 0 }, { 6, 0x2660, 0 }, { 7, 0x2022, 0 },
1049 { 8, 0x25D8, 0 }, { 9, 0x25CB, 0 }, { 10, 0x25D9, 0 },
1050 { 11, 0x2642, 0 }, { 12, 0x2640, 0 }, { 13, 0x266A, 1 },
1051 { 15, 0x263C, 0 }, { 16, 0x25BA, 0 }, { 17, 0x25C4, 0 },
1052 { 18, 0x2195, 0 }, { 19, 0x203C, 0 }, { 20, 0x00B6, 0 },
1053 { 21, 0x00A7, 0 }, { 22, 0x25AC, 0 }, { 23, 0x21A8, 0 },
1054 { 24, 0x2191, 0 }, { 25, 0x2193, 0 }, { 26, 0x2192, 0 },
1055 { 27, 0x2190, 0 }, { 28, 0x221F, 0 }, { 29, 0x2194, 0 },
1056 { 30, 0x25B2, 0 }, { 31, 0x25BC, 0 }, { 32, 0x0020, 0x5e },
1057 { 127, 0x2302, 0 }, { 128, 0x00C7, 0 }, { 129, 0x00FC, 0 },
1058 { 130, 0x00E9, 0 }, { 131, 0x00E2, 0 }, { 132, 0x00E4, 0 },
1059 { 133, 0x00E0, 0 }, { 134, 0x00E5, 0 }, { 135, 0x00E7, 0 },
1060 { 136, 0x00EA, 1 }, { 138, 0x00E8, 0 }, { 139, 0x00EF, 0 },
1061 { 140, 0x00EE, 0 }, { 141, 0x00EC, 0 }, { 142, 0x00C4, 1 },
1062 { 144, 0x00C9, 0 }, { 145, 0x00E6, 0 }, { 146, 0x00C6, 0 },
1063 { 147, 0x00F4, 0 }, { 148, 0x00F6, 0 }, { 149, 0x00F2, 0 },
1064 { 150, 0x00FB, 0 }, { 151, 0x00F9, 0 }, { 152, 0x00FF, 0 },
1065 { 153, 0x00D6, 0 }, { 154, 0x00DC, 0 }, { 155, 0x00A2, 1 },
1066 { 157, 0x00A5, 0 }, { 158, 0x20A7, 0 }, { 159, 0x0192, 0 },
1067 { 160, 0x00E1, 0 }, { 161, 0x00ED, 0 }, { 162, 0x00F3, 0 },
1068 { 163, 0x00FA, 0 }, { 164, 0x00F1, 0 }, { 165, 0x00D1, 0 },
1069 { 166, 0x00AA, 0 }, { 167, 0x00BA, 0 }, { 168, 0x00BF, 0 },
1070 { 169, 0x2310, 0 }, { 170, 0x00AC, 0 }, { 171, 0x00BD, 0 },
1071 { 172, 0x00BC, 0 }, { 173, 0x00A1, 0 }, { 174, 0x00AB, 0 },
1072 { 175, 0x00BB, 0 }, { 176, 0x2591, 2 }, { 179, 0x2502, 0 },
1073 { 180, 0x2524, 0 }, { 181, 0x2561, 1 }, { 183, 0x2556, 0 },
1074 { 184, 0x2555, 0 }, { 185, 0x2563, 0 }, { 186, 0x2551, 0 },
1075 { 187, 0x2557, 0 }, { 188, 0x255D, 0 }, { 189, 0x255C, 0 },
1076 { 190, 0x255B, 0 }, { 191, 0x2510, 0 }, { 192, 0x2514, 0 },
1077 { 193, 0x2534, 0 }, { 194, 0x252C, 0 }, { 195, 0x251C, 0 },
1078 { 196, 0x2500, 0 }, { 197, 0x253C, 0 }, { 198, 0x255E, 1 },
1079 { 200, 0x255A, 0 }, { 201, 0x2554, 0 }, { 202, 0x2569, 0 },
1080 { 203, 0x2566, 0 }, { 204, 0x2560, 0 }, { 205, 0x2550, 0 },
1081 { 206, 0x256C, 0 }, { 207, 0x2567, 1 }, { 209, 0x2564, 1 },
1082 { 211, 0x2559, 0 }, { 212, 0x2558, 0 }, { 213, 0x2552, 1 },
1083 { 215, 0x256B, 0 }, { 216, 0x256A, 0 }, { 217, 0x2518, 0 },
1084 { 218, 0x250C, 0 }, { 219, 0x2588, 0 }, { 220, 0x2584, 0 },
1085 { 221, 0x258C, 0 }, { 222, 0x2590, 0 }, { 223, 0x2580, 0 },
1086 { 224, 0x03B1, 0 }, { 225, 0x00DF, 0 }, { 226, 0x0393, 0 },
1087 { 227, 0x03C0, 0 }, { 228, 0x03A3, 0 }, { 229, 0x03C3, 0 },
1088 { 230, 0x00B5, 0 }, { 231, 0x03C4, 0 }, { 232, 0x03A6, 0 },
1089 { 233, 0x0398, 0 }, { 234, 0x03A9, 0 }, { 235, 0x03B4, 0 },
1090 { 236, 0x221E, 0 }, { 237, 0x03C6, 0 }, { 238, 0x03B5, 0 },
1091 { 239, 0x2229, 0 }, { 240, 0x2261, 0 }, { 241, 0x00B1, 0 },
1092 { 242, 0x2265, 0 }, { 243, 0x2264, 0 }, { 244, 0x2320, 1 },
1093 { 246, 0x00F7, 0 }, { 247, 0x2248, 0 }, { 248, 0x00B0, 0 },
1094 { 249, 0x2219, 0 }, { 250, 0x00B7, 0 }, { 251, 0x221A, 0 },
1095 { 252, 0x207F, 0 }, { 253, 0x00B2, 0 }, { 254, 0x25A0, 0 },
1096 { 255, 0x00A0, 0 }
1097 };
1098
1099 static uint16_t
1100 vga_cp437_to_uni(uint8_t c)
1101 {
1102 int min, mid, max;
1103
1104 min = 0;
1105 max = (sizeof(cp437unitable) / sizeof(struct cp437uni)) - 1;
1106
1107 if (c < cp437unitable[0].cp437_base ||
1108 c > cp437unitable[max].cp437_base + cp437unitable[max].length)
1109 return ('?');
1110
1111 while (max >= min) {
1112 mid = (min + max) / 2;
1113 if (c < cp437unitable[mid].cp437_base)
1114 max = mid - 1;
1115 else if (c > cp437unitable[mid].cp437_base +
1116 cp437unitable[mid].length)
1117 min = mid + 1;
1118 else
1119 return (c - cp437unitable[mid].cp437_base +
1120 cp437unitable[mid].unicode_base);
1121 }
1122
1123 return ('?');
1124 }
1125
1126 static void
1127 vgatext_setfont(struct gfxp_fb_softc *softc)
1128 {
1129 union gfx_console *console = softc->console;
1130 static uchar_t fsreg[8] = {0x0, 0x30, 0x5, 0x35, 0xa, 0x3a, 0xf, 0x3f};
1131
1132 const uchar_t *from;
1133 uchar_t volatile *to;
1134 uint16_t c;
1135 int i, j, s;
1136 int bpc, f_offset;
1137
1138 /* Sync-reset the sequencer registers */
1139 vga_set_seq(&console->vga.regs, 0x00, 0x01);
1140 /*
1141 * enable write to plane2, since fonts
1142 * could only be loaded into plane2
1143 */
1144 vga_set_seq(&console->vga.regs, 0x02, 0x04);
1145 /*
1146 * sequentially access data in the bit map being
1147 * selected by MapMask register (index 0x02)
1148 */
1149 vga_set_seq(&console->vga.regs, 0x04, 0x07);
1150 /* Sync-reset ended, and allow the sequencer to operate */
1151 vga_set_seq(&console->vga.regs, 0x00, 0x03);
1152
1153 /*
1154 * select plane 2 on Read Mode 0
1155 */
1156 vga_set_grc(&console->vga.regs, 0x04, 0x02);
1157 /*
1158 * system addresses sequentially access data, follow
1159 * Memory Mode register bit 2 in the sequencer
1160 */
1161 vga_set_grc(&console->vga.regs, 0x05, 0x00);
1162 /*
1163 * set range of host memory addresses decoded by VGA
1164 * hardware -- A0000h-BFFFFh (128K region)
1165 */
1166 vga_set_grc(&console->vga.regs, 0x06, 0x00);
1167
1168 /*
1169 * This assumes 8x16 characters, which yield the traditional 80x25
1170 * screen. It really should support other character heights.
1171 */
1172 bpc = 16;
1173 s = console->vga.vga_fontslot;
1174 f_offset = s * 8 * 1024;
1175 for (i = 0; i < 256; i++) {
1176 c = vga_cp437_to_uni(i);
1177 from = font_lookup(font_data_8x16.font, c);
1178 to = (unsigned char *)console->vga.fb.addr + f_offset +
1179 i * 0x20;
1180 for (j = 0; j < bpc; j++)
1181 *to++ = *from++;
1182 }
1183
1184 /* Sync-reset the sequencer registers */
1185 vga_set_seq(&console->vga.regs, 0x00, 0x01);
1186 /* enable write to plane 0 and 1 */
1187 vga_set_seq(&console->vga.regs, 0x02, 0x03);
1188 /*
1189 * enable character map selection
1190 * and odd/even addressing
1191 */
1192 vga_set_seq(&console->vga.regs, 0x04, 0x03);
1193 /*
1194 * select font map
1195 */
1196 vga_set_seq(&console->vga.regs, 0x03, fsreg[s]);
1197 /* Sync-reset ended, and allow the sequencer to operate */
1198 vga_set_seq(&console->vga.regs, 0x00, 0x03);
1199
1200 /* restore graphic registers */
1201
1202 /* select plane 0 */
1203 vga_set_grc(&console->vga.regs, 0x04, 0x00);
1204 /* enable odd/even addressing mode */
1205 vga_set_grc(&console->vga.regs, 0x05, 0x10);
1206 /*
1207 * range of host memory addresses decoded by VGA
1208 * hardware -- B8000h-BFFFFh (32K region)
1209 */
1210 vga_set_grc(&console->vga.regs, 0x06, 0x0e);
1211 /* enable all color plane */
1212 vga_set_atr(&console->vga.regs, 0x12, 0x0f);
1213
1214 }
1215
1216 int
1217 /*ARGSUSED*/
1218 gfxp_vga_scrnmap(int cmd, intptr_t data, int mode, struct gfxp_fb_softc *softc)
1219 {
1220 return (ENXIO);
1221 }
1222
1223 static void
1224 vgatext_save_colormap(struct gfxp_fb_softc *softc)
1225 {
1226 union gfx_console *console = softc->console;
1227 int i;
1228
1229 for (i = 0; i < VGA_ATR_NUM_PLT; i++) {
1230 console->vga.attrib_palette[i] =
1231 vga_get_atr(&console->vga.regs, i);
1232 }
1233 for (i = 0; i < VGA8_CMAP_ENTRIES; i++) {
1234 vga_get_cmap(&console->vga.regs, i,
1235 &console->vga.colormap[i].red,
1236 &console->vga.colormap[i].green,
1237 &console->vga.colormap[i].blue);
1238 }
1239 }
1240
1241 static void
1242 vgatext_restore_colormap(struct gfxp_fb_softc *softc)
1243 {
1244 union gfx_console *console = softc->console;
1245 int i;
1246
1247 for (i = 0; i < VGA_ATR_NUM_PLT; i++) {
1248 vga_set_atr(&console->vga.regs, i,
1249 console->vga.attrib_palette[i]);
1250 }
1251 for (i = 0; i < VGA8_CMAP_ENTRIES; i++) {
1252 vga_put_cmap(&console->vga.regs, i,
1253 console->vga.colormap[i].red,
1254 console->vga.colormap[i].green,
1255 console->vga.colormap[i].blue);
1256 }
1257 }
1258
1259 /*
1260 * search the entries of the "reg" property for one which has the desired
1261 * combination of phys_hi bits and contains the desired address.
1262 *
1263 * This version searches a PCI-style "reg" property. It was prompted by
1264 * issues surrounding the presence or absence of an entry for the ROM:
1265 * (a) a transition problem with PowerPC Virtual Open Firmware
1266 * (b) uncertainty as to whether an entry will be included on a device
1267 * with ROM support (and so an "active" ROM base address register),
1268 * but no ROM actually installed.
1269 *
1270 * See the note below on vgatext_get_isa_reg_index for the reasons for
1271 * returning the offset.
1272 *
1273 * Note that this routine may not be fully general; it is intended for the
1274 * specific purpose of finding a couple of particular VGA reg entries and
1275 * may not be suitable for all reg-searching purposes.
1276 */
1277 static int
1278 vgatext_get_pci_reg_index(
1279 dev_info_t *const devi,
1280 unsigned long himask,
1281 unsigned long hival,
1282 unsigned long addr,
1283 off_t *offset)
1284 {
1285
1286 int length, index;
1287 pci_regspec_t *reg;
1288
1289 if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
1290 "reg", (caddr_t)®, &length) != DDI_PROP_SUCCESS) {
1291 return (-1);
1292 }
1293
1294 for (index = 0; index < length / sizeof (pci_regspec_t); index++) {
1295 if ((reg[index].pci_phys_hi & himask) != hival)
1296 continue;
1297 if (reg[index].pci_size_hi != 0)
1298 continue;
1299 if (reg[index].pci_phys_mid != 0)
1300 continue;
1301 if (reg[index].pci_phys_low > addr)
1302 continue;
1303 if (reg[index].pci_phys_low + reg[index].pci_size_low <= addr)
1304 continue;
1305
1306 *offset = addr - reg[index].pci_phys_low;
1307 kmem_free(reg, (size_t)length);
1308 return (index);
1309 }
1310 kmem_free(reg, (size_t)length);
1311
1312 return (-1);
1313 }
1314
1315 /*
1316 * search the entries of the "reg" property for one which has the desired
1317 * combination of phys_hi bits and contains the desired address.
1318 *
1319 * This version searches a ISA-style "reg" property. It was prompted by
1320 * issues surrounding 8514/A support. By IEEE 1275 compatibility conventions,
1321 * 8514/A registers should have been added after all standard VGA registers.
1322 * Unfortunately, the Solaris/Intel device configuration framework
1323 * (a) lists the 8514/A registers before the video memory, and then
1324 * (b) also sorts the entries so that I/O entries come before memory
1325 * entries.
1326 *
1327 * It returns the "reg" index and offset into that register set.
1328 * The offset is needed because there exist (broken?) BIOSes that
1329 * report larger ranges enclosing the standard ranges. One reports
1330 * 0x3bf for 0x21 instead of 0x3c0 for 0x20, for instance. Using the
1331 * offset adjusts for this difference in the base of the register set.
1332 *
1333 * Note that this routine may not be fully general; it is intended for the
1334 * specific purpose of finding a couple of particular VGA reg entries and
1335 * may not be suitable for all reg-searching purposes.
1336 */
1337 static int
1338 vgatext_get_isa_reg_index(
1339 dev_info_t *const devi,
1340 unsigned long hival,
1341 unsigned long addr,
1342 off_t *offset)
1343 {
1344
1345 int length, index;
1346 struct regspec *reg;
1347
1348 if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
1349 "reg", (caddr_t)®, &length) != DDI_PROP_SUCCESS) {
1350 return (-1);
1351 }
1352
1353 for (index = 0; index < length / sizeof (struct regspec); index++) {
1354 if (reg[index].regspec_bustype != hival)
1355 continue;
1356 if (reg[index].regspec_addr > addr)
1357 continue;
1358 if (reg[index].regspec_addr + reg[index].regspec_size <= addr)
1359 continue;
1360
1361 *offset = addr - reg[index].regspec_addr;
1362 kmem_free(reg, (size_t)length);
1363 return (index);
1364 }
1365 kmem_free(reg, (size_t)length);
1366
1367 return (-1);
1368 }
1369
1370 /*
1371 * This vgatext function is used to return the fb, and reg pointers
1372 * and handles for peer graphics drivers.
1373 */
1374
1375 void
1376 vgatext_return_pointers(struct gfxp_fb_softc *softc, struct vgaregmap *fbs,
1377 struct vgaregmap *regss)
1378 {
1379
1380 fbs->addr = softc->console->vga.fb.addr;
1381 fbs->handle = softc->console->vga.fb.handle;
1382 fbs->mapped = softc->console->vga.fb.mapped;
1383 regss->addr = softc->console->vga.regs.addr;
1384 regss->handle = softc->console->vga.regs.handle;
1385 regss->mapped = softc->console->vga.regs.mapped;
1386 }