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 39 #include <sys/ddi.h> 40 #include <sys/stat.h> 41 #include <sys/sunddi.h> 42 #include <sys/file.h> 43 #include <sys/open.h> 44 #include <sys/modctl.h> 45 #include <sys/vgareg.h> 46 #include <sys/vgasubr.h> 47 #include <sys/pci.h> 48 #include <sys/kd.h> 49 #include <sys/ddi_impldefs.h> 50 #include <sys/sunldi.h> 51 52 #define MYNAME "vgatext" 53 54 /* 55 * Each instance of this driver has 2 minor nodes: 56 * 0: for common graphics operations 57 * 1: for agpmaster operations 58 */ 59 #define GFX_MINOR 0 60 #define AGPMASTER_MINOR 1 61 62 #define MY_NBITSMINOR 1 63 #define DEV2INST(dev) (getminor(dev) >> MY_NBITSMINOR) 64 #define DEV2MINOR(dev) (getminor(dev) & ((1 << MY_NBITSMINOR) - 1)) 65 #define INST2NODE1(inst) ((inst) << MY_NBITSMINOR + GFX_MINOR) 66 #define INST2NODE2(inst) (((inst) << MY_NBITSMINOR) + AGPMASTER_MINOR) 67 68 /* I don't know exactly where these should be defined, but this is a */ 69 /* heck of a lot better than constants in the code. */ 70 #define TEXT_ROWS 25 71 #define TEXT_COLS 80 72 73 #define VGA_BRIGHT_WHITE 0x0f 74 #define VGA_BLACK 0x00 75 76 #define VGA_REG_ADDR 0x3c0 77 #define VGA_REG_SIZE 0x20 78 79 #define VGA_MEM_ADDR 0xa0000 80 #define VGA_MEM_SIZE 0x20000 81 82 #define VGA_MMAP_FB_BASE VGA_MEM_ADDR 83 84 /* 85 * This variable allows for this driver to suspend even if it 86 * shouldn't. Note that by setting it, the framebuffer will probably 87 * not come back. So use it with a serial console, or with serial 88 * line debugging (say, for example, if this driver is being modified 89 * to support _some_ hardware doing suspend and resume). 90 */ 91 int vgatext_force_suspend = 0; 92 93 static int vgatext_open(dev_t *, int, int, cred_t *); 94 static int vgatext_close(dev_t, int, int, cred_t *); 95 static int vgatext_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 96 static int vgatext_devmap(dev_t, devmap_cookie_t, offset_t, size_t, 97 size_t *, uint_t); 98 99 static struct cb_ops cb_vgatext_ops = { 100 vgatext_open, /* cb_open */ 101 vgatext_close, /* cb_close */ 102 nodev, /* cb_strategy */ 103 nodev, /* cb_print */ 104 nodev, /* cb_dump */ 105 nodev, /* cb_read */ 106 nodev, /* cb_write */ 107 vgatext_ioctl, /* cb_ioctl */ 108 vgatext_devmap, /* cb_devmap */ 109 nodev, /* cb_mmap */ 110 ddi_devmap_segmap, /* cb_segmap */ 111 nochpoll, /* cb_chpoll */ 112 ddi_prop_op, /* cb_prop_op */ 113 0, /* cb_stream */ 114 D_NEW | D_MTSAFE /* cb_flag */ 115 }; 116 117 static int vgatext_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 118 void **result); 119 static int vgatext_attach(dev_info_t *, ddi_attach_cmd_t); 120 static int vgatext_detach(dev_info_t *, ddi_detach_cmd_t); 121 122 static struct vis_identifier text_ident = { "SUNWtext" }; 123 124 static struct dev_ops vgatext_ops = { 125 DEVO_REV, /* devo_rev */ 126 0, /* devo_refcnt */ 127 vgatext_info, /* devo_getinfo */ 128 nulldev, /* devo_identify */ 129 nulldev, /* devo_probe */ 130 vgatext_attach, /* devo_attach */ 131 vgatext_detach, /* devo_detach */ 132 nodev, /* devo_reset */ 133 &cb_vgatext_ops, /* devo_cb_ops */ 134 (struct bus_ops *)NULL, /* devo_bus_ops */ 135 NULL, /* power */ 136 ddi_quiesce_not_needed, /* quiesce */ 137 }; 138 139 struct vgatext_softc { 140 struct vgaregmap regs; 141 struct vgaregmap fb; 142 off_t fb_size; 143 int fb_regno; 144 dev_info_t *devi; 145 int mode; /* KD_TEXT or KD_GRAPHICS */ 146 caddr_t text_base; /* hardware text base */ 147 char shadow[TEXT_ROWS*TEXT_COLS*2]; 148 caddr_t current_base; /* hardware or shadow */ 149 struct { 150 boolean_t visible; 151 int row; 152 int col; 153 } cursor; 154 struct vis_polledio polledio; 155 struct { 156 unsigned char red; 157 unsigned char green; 158 unsigned char blue; 159 } colormap[VGA8_CMAP_ENTRIES]; 160 unsigned char attrib_palette[VGA_ATR_NUM_PLT]; 161 unsigned int flags; 162 kmutex_t lock; 163 }; 164 165 #define VGATEXT_FLAG_CONSOLE 0x00000001 166 #define VGATEXT_IS_CONSOLE(softc) ((softc)->flags & VGATEXT_FLAG_CONSOLE) 167 168 static int vgatext_devinit(struct vgatext_softc *, struct vis_devinit *data); 169 static void vgatext_cons_copy(struct vgatext_softc *, 170 struct vis_conscopy *); 171 static void vgatext_cons_display(struct vgatext_softc *, 172 struct vis_consdisplay *); 173 static void vgatext_cons_cursor(struct vgatext_softc *, 174 struct vis_conscursor *); 175 static void vgatext_polled_copy(struct vis_polledio_arg *, 176 struct vis_conscopy *); 177 static void vgatext_polled_display(struct vis_polledio_arg *, 178 struct vis_consdisplay *); 179 static void vgatext_polled_cursor(struct vis_polledio_arg *, 180 struct vis_conscursor *); 181 static void vgatext_init(struct vgatext_softc *); 182 static void vgatext_set_text(struct vgatext_softc *); 183 #if defined(USE_BORDERS) 184 static void vgatext_init_graphics(struct vgatext_softc *); 185 #endif 186 static int vgatext_kdsetmode(struct vgatext_softc *softc, int mode); 187 static void vgatext_setfont(struct vgatext_softc *softc); 188 static void vgatext_get_cursor(struct vgatext_softc *softc, 189 screen_pos_t *row, screen_pos_t *col); 190 static void vgatext_set_cursor(struct vgatext_softc *softc, int row, int col); 191 static void vgatext_hide_cursor(struct vgatext_softc *softc); 192 static void vgatext_save_colormap(struct vgatext_softc *softc); 193 static void vgatext_restore_colormap(struct vgatext_softc *softc); 194 static int vgatext_get_pci_reg_index(dev_info_t *const devi, 195 unsigned long himask, unsigned long hival, unsigned long addr, 196 off_t *offset); 197 static int vgatext_get_isa_reg_index(dev_info_t *const devi, 198 unsigned long hival, unsigned long addr, off_t *offset); 199 static void *vgatext_softc_head; 200 static char vgatext_silent; 201 static char happyface_boot; 202 203 /* Loadable Driver stuff */ 204 205 static struct modldrv modldrv = { 206 &mod_driverops, /* Type of module. This one is a driver */ 207 "VGA text driver", /* Name of the module. */ 208 &vgatext_ops, /* driver ops */ 209 }; 210 211 static struct modlinkage modlinkage = { 212 MODREV_1, (void *) &modldrv, NULL 213 }; 214 215 typedef enum pc_colors { 216 pc_black = 0, 217 pc_blue = 1, 218 pc_green = 2, 219 pc_cyan = 3, 220 pc_red = 4, 221 pc_magenta = 5, 222 pc_brown = 6, 223 pc_white = 7, 224 pc_grey = 8, 225 pc_brt_blue = 9, 226 pc_brt_green = 10, 227 pc_brt_cyan = 11, 228 pc_brt_red = 12, 229 pc_brt_magenta = 13, 230 pc_yellow = 14, 231 pc_brt_white = 15 232 } pc_colors_t; 233 234 static const unsigned char solaris_color_to_pc_color[16] = { 235 pc_brt_white, /* 0 - brt_white */ 236 pc_black, /* 1 - black */ 237 pc_blue, /* 2 - blue */ 238 pc_green, /* 3 - green */ 239 pc_cyan, /* 4 - cyan */ 240 pc_red, /* 5 - red */ 241 pc_magenta, /* 6 - magenta */ 242 pc_brown, /* 7 - brown */ 243 pc_white, /* 8 - white */ 244 pc_grey, /* 9 - gery */ 245 pc_brt_blue, /* 10 - brt_blue */ 246 pc_brt_green, /* 11 - brt_green */ 247 pc_brt_cyan, /* 12 - brt_cyan */ 248 pc_brt_red, /* 13 - brt_red */ 249 pc_brt_magenta, /* 14 - brt_magenta */ 250 pc_yellow /* 15 - yellow */ 251 }; 252 253 static ddi_device_acc_attr_t i8xx_dev_access = { 254 DDI_DEVICE_ATTR_V0, 255 DDI_NEVERSWAP_ACC, 256 DDI_STRICTORDER_ACC 257 }; 258 259 static ddi_device_acc_attr_t dev_attr = { 260 DDI_DEVICE_ATTR_V0, 261 DDI_NEVERSWAP_ACC, 262 DDI_STRICTORDER_ACC, 263 }; 264 265 int 266 _init(void) 267 { 268 int e; 269 270 if ((e = ddi_soft_state_init(&vgatext_softc_head, 271 sizeof (struct vgatext_softc), 1)) != 0) { 272 return (e); 273 } 274 275 e = mod_install(&modlinkage); 276 277 if (e) { 278 ddi_soft_state_fini(&vgatext_softc_head); 279 } 280 return (e); 281 } 282 283 int 284 _fini(void) 285 { 286 int e; 287 288 if ((e = mod_remove(&modlinkage)) != 0) 289 return (e); 290 291 ddi_soft_state_fini(&vgatext_softc_head); 292 293 return (0); 294 } 295 296 int 297 _info(struct modinfo *modinfop) 298 { 299 return (mod_info(&modlinkage, modinfop)); 300 } 301 302 /* default structure for FBIOGATTR ioctl */ 303 static struct fbgattr vgatext_attr = { 304 /* real_type owner */ 305 FBTYPE_SUNFAST_COLOR, 0, 306 /* fbtype: type h w depth cms size */ 307 { FBTYPE_SUNFAST_COLOR, TEXT_ROWS, TEXT_COLS, 1, 256, 0 }, 308 /* fbsattr: flags emu_type dev_specific */ 309 { 0, FBTYPE_SUN4COLOR, { 0 } }, 310 /* emu_types */ 311 { -1 } 312 }; 313 314 /* 315 * handy macros 316 */ 317 318 #define getsoftc(instance) ((struct vgatext_softc *) \ 319 ddi_get_soft_state(vgatext_softc_head, (instance))) 320 321 #define STREQ(a, b) (strcmp((a), (b)) == 0) 322 323 /* 324 * NOTE: this function is duplicated here and in gfx_private/vgatext while 325 * we work on a set of commitable interfaces to sunpci.c. 326 * 327 * Use the class code to determine if the device is a PCI-to-PCI bridge. 328 * Returns: B_TRUE if the device is a bridge. 329 * B_FALSE if the device is not a bridge or the property cannot be 330 * retrieved. 331 */ 332 static boolean_t 333 is_pci_bridge(dev_info_t *dip) 334 { 335 uint32_t class_code; 336 337 class_code = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, dip, 338 DDI_PROP_DONTPASS, "class-code", 0xffffffff); 339 340 if (class_code == 0xffffffff || class_code == DDI_PROP_NOT_FOUND) 341 return (B_FALSE); 342 343 class_code &= 0x00ffff00; 344 if (class_code == ((PCI_CLASS_BRIDGE << 16) | (PCI_BRIDGE_PCI << 8))) 345 return (B_TRUE); 346 347 return (B_FALSE); 348 } 349 350 static void 351 vgatext_check_for_console(dev_info_t *devi, struct vgatext_softc *softc, 352 int pci_pcie_bus) 353 { 354 ddi_acc_handle_t pci_conf; 355 dev_info_t *pdevi; 356 uint16_t data16; 357 358 /* 359 * Based on Section 11.3, "PCI Display Subsystem Initialization", 360 * of the 1.1 PCI-to-PCI Bridge Architecture Specification 361 * determine if this is the boot console device. First, see 362 * if the SBIOS has turned on PCI I/O for this device. Then if 363 * this is PCI/PCI-E, verify the parent bridge has VGAEnable set. 364 */ 365 366 if (pci_config_setup(devi, &pci_conf) != DDI_SUCCESS) { 367 cmn_err(CE_WARN, 368 MYNAME ": can't get PCI conf handle"); 369 return; 370 } 371 372 data16 = pci_config_get16(pci_conf, PCI_CONF_COMM); 373 if (data16 & PCI_COMM_IO) 374 softc->flags |= VGATEXT_FLAG_CONSOLE; 375 376 pci_config_teardown(&pci_conf); 377 378 /* If IO not enabled or ISA/EISA, just return */ 379 if (!(softc->flags & VGATEXT_FLAG_CONSOLE) || !pci_pcie_bus) 380 return; 381 382 /* 383 * Check for VGA Enable in the Bridge Control register for all 384 * PCI/PCIEX parents. If not set all the way up the chain, 385 * this cannot be the boot console. 386 */ 387 388 pdevi = devi; 389 while (pdevi = ddi_get_parent(pdevi)) { 390 int error; 391 ddi_acc_handle_t ppci_conf; 392 char *parent_type = NULL; 393 394 error = ddi_prop_lookup_string(DDI_DEV_T_ANY, pdevi, 395 DDI_PROP_DONTPASS, "device_type", &parent_type); 396 if (error != DDI_SUCCESS) { 397 return; 398 } 399 400 /* Verify still on the PCI/PCIEX parent tree */ 401 if (!STREQ(parent_type, "pci") && 402 !STREQ(parent_type, "pciex")) { 403 ddi_prop_free(parent_type); 404 return; 405 } 406 407 ddi_prop_free(parent_type); 408 parent_type = NULL; 409 410 /* VGAEnable is set only for PCI-to-PCI bridges. */ 411 if (is_pci_bridge(pdevi) == B_FALSE) 412 continue; 413 414 if (pci_config_setup(pdevi, &ppci_conf) != DDI_SUCCESS) 415 continue; 416 417 data16 = pci_config_get16(ppci_conf, PCI_BCNF_BCNTRL); 418 pci_config_teardown(&ppci_conf); 419 420 if (!(data16 & PCI_BCNF_BCNTRL_VGA_ENABLE)) { 421 softc->flags &= ~VGATEXT_FLAG_CONSOLE; 422 return; 423 } 424 } 425 } 426 427 static int 428 vgatext_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 429 { 430 struct vgatext_softc *softc; 431 int unit = ddi_get_instance(devi); 432 int error; 433 char *parent_type = NULL; 434 int reg_rnumber; 435 off_t reg_offset; 436 off_t mem_offset; 437 char buf[80], *cons; 438 int pci_pcie_bus = 0; 439 440 441 switch (cmd) { 442 case DDI_ATTACH: 443 break; 444 445 case DDI_RESUME: 446 /* 447 * Though vgatext doesn't really know how to resume 448 * on a generic framebuffer, we should succeed, as 449 * it is far better to have no console, than potentiall 450 * have no machine. 451 */ 452 return (DDI_SUCCESS); 453 default: 454 return (DDI_FAILURE); 455 } 456 457 /* DDI_ATTACH */ 458 459 /* Allocate softc struct */ 460 if (ddi_soft_state_zalloc(vgatext_softc_head, unit) != DDI_SUCCESS) { 461 return (DDI_FAILURE); 462 } 463 softc = getsoftc(unit); 464 465 /* link it in */ 466 softc->devi = devi; 467 ddi_set_driver_private(devi, softc); 468 469 softc->polledio.arg = (struct vis_polledio_arg *)softc; 470 softc->polledio.display = vgatext_polled_display; 471 softc->polledio.copy = vgatext_polled_copy; 472 softc->polledio.cursor = vgatext_polled_cursor; 473 474 mutex_init(&(softc->lock), NULL, MUTEX_DRIVER, NULL); 475 476 error = ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_get_parent(devi), 477 DDI_PROP_DONTPASS, "device_type", &parent_type); 478 if (error != DDI_SUCCESS) { 479 cmn_err(CE_WARN, MYNAME ": can't determine parent type."); 480 goto fail; 481 } 482 483 if (STREQ(parent_type, "isa") || STREQ(parent_type, "eisa")) { 484 reg_rnumber = vgatext_get_isa_reg_index(devi, 1, VGA_REG_ADDR, 485 ®_offset); 486 if (reg_rnumber < 0) { 487 cmn_err(CE_WARN, 488 MYNAME ": can't find reg entry for registers"); 489 error = DDI_FAILURE; 490 goto fail; 491 } 492 softc->fb_regno = vgatext_get_isa_reg_index(devi, 0, 493 VGA_MEM_ADDR, &mem_offset); 494 if (softc->fb_regno < 0) { 495 cmn_err(CE_WARN, 496 MYNAME ": can't find reg entry for memory"); 497 error = DDI_FAILURE; 498 goto fail; 499 } 500 } else if (STREQ(parent_type, "pci") || STREQ(parent_type, "pciex")) { 501 pci_pcie_bus = 1; 502 reg_rnumber = vgatext_get_pci_reg_index(devi, 503 PCI_REG_ADDR_M|PCI_REG_REL_M, 504 PCI_ADDR_IO|PCI_RELOCAT_B, VGA_REG_ADDR, 505 ®_offset); 506 if (reg_rnumber < 0) { 507 cmn_err(CE_WARN, 508 MYNAME ": can't find reg entry for registers"); 509 error = DDI_FAILURE; 510 goto fail; 511 } 512 softc->fb_regno = vgatext_get_pci_reg_index(devi, 513 PCI_REG_ADDR_M|PCI_REG_REL_M, 514 PCI_ADDR_MEM32|PCI_RELOCAT_B, VGA_MEM_ADDR, 515 &mem_offset); 516 if (softc->fb_regno < 0) { 517 cmn_err(CE_WARN, 518 MYNAME ": can't find reg entry for memory"); 519 error = DDI_FAILURE; 520 goto fail; 521 } 522 } else { 523 cmn_err(CE_WARN, MYNAME ": unknown parent type \"%s\".", 524 parent_type); 525 error = DDI_FAILURE; 526 goto fail; 527 } 528 ddi_prop_free(parent_type); 529 parent_type = NULL; 530 531 error = ddi_regs_map_setup(devi, reg_rnumber, 532 (caddr_t *)&softc->regs.addr, reg_offset, VGA_REG_SIZE, 533 &dev_attr, &softc->regs.handle); 534 if (error != DDI_SUCCESS) 535 goto fail; 536 softc->regs.mapped = B_TRUE; 537 538 softc->fb_size = VGA_MEM_SIZE; 539 540 error = ddi_regs_map_setup(devi, softc->fb_regno, 541 (caddr_t *)&softc->fb.addr, 542 mem_offset, softc->fb_size, 543 &dev_attr, &softc->fb.handle); 544 if (error != DDI_SUCCESS) 545 goto fail; 546 softc->fb.mapped = B_TRUE; 547 548 if (ddi_get8(softc->regs.handle, 549 softc->regs.addr + VGA_MISC_R) & VGA_MISC_IOA_SEL) 550 softc->text_base = (caddr_t)softc->fb.addr + VGA_COLOR_BASE; 551 else 552 softc->text_base = (caddr_t)softc->fb.addr + VGA_MONO_BASE; 553 554 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 555 DDI_PROP_DONTPASS, "console", &cons) == DDI_SUCCESS) { 556 if (strcmp(cons, "graphics") == 0) { 557 happyface_boot = 1; 558 vgatext_silent = 1; 559 softc->current_base = softc->shadow; 560 } else { 561 softc->current_base = softc->text_base; 562 } 563 ddi_prop_free(cons); 564 } else { 565 softc->current_base = softc->text_base; 566 } 567 568 (void) sprintf(buf, "text-%d", unit); 569 error = ddi_create_minor_node(devi, buf, S_IFCHR, 570 INST2NODE1(unit), DDI_NT_DISPLAY, NULL); 571 if (error != DDI_SUCCESS) 572 goto fail; 573 574 error = ddi_prop_create(makedevice(DDI_MAJOR_T_UNKNOWN, unit), 575 devi, DDI_PROP_CANSLEEP, DDI_KERNEL_IOCTL, NULL, 0); 576 if (error != DDI_SUCCESS) 577 goto fail; 578 579 vgatext_check_for_console(devi, softc, pci_pcie_bus); 580 581 /* only do this if not in graphics mode */ 582 if ((vgatext_silent == 0) && (VGATEXT_IS_CONSOLE(softc))) { 583 vgatext_init(softc); 584 vgatext_save_colormap(softc); 585 } 586 587 return (DDI_SUCCESS); 588 589 fail: 590 if (parent_type != NULL) 591 ddi_prop_free(parent_type); 592 (void) vgatext_detach(devi, DDI_DETACH); 593 return (error); 594 } 595 596 static int 597 vgatext_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 598 { 599 int instance = ddi_get_instance(devi); 600 struct vgatext_softc *softc = getsoftc(instance); 601 602 603 switch (cmd) { 604 case DDI_DETACH: 605 if (softc->fb.mapped) 606 ddi_regs_map_free(&softc->fb.handle); 607 if (softc->regs.mapped) 608 ddi_regs_map_free(&softc->regs.handle); 609 mutex_destroy(&(softc->lock)); 610 ddi_remove_minor_node(devi, NULL); 611 (void) ddi_soft_state_free(vgatext_softc_head, instance); 612 return (DDI_SUCCESS); 613 614 case DDI_SUSPEND: 615 /* 616 * This is a generic VGA file, and therefore, cannot 617 * understand how to deal with suspend and resume on 618 * a generic interface. So we fail any attempt to 619 * suspend. At some point in the future, we might use 620 * this as an entrypoint for display drivers and this 621 * assumption may change. 622 * 623 * However, from a platform development perspective, 624 * it is important that this driver suspend if a 625 * developer is using a serial console and/or working 626 * on a framebuffer driver that will support suspend 627 * and resume. Therefore, we have this module tunable 628 * (purposely using a long name) that will allow for 629 * suspend it it is set. Otherwise we fail. 630 */ 631 if (vgatext_force_suspend != 0) 632 return (DDI_SUCCESS); 633 else 634 return (DDI_FAILURE); 635 636 default: 637 cmn_err(CE_WARN, "vgatext_detach: unknown cmd 0x%x\n", cmd); 638 return (DDI_FAILURE); 639 } 640 } 641 642 /*ARGSUSED*/ 643 static int 644 vgatext_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 645 { 646 dev_t dev; 647 int error; 648 int instance; 649 struct vgatext_softc *softc; 650 651 error = DDI_SUCCESS; 652 653 dev = (dev_t)arg; 654 instance = DEV2INST(dev); 655 softc = getsoftc(instance); 656 657 switch (infocmd) { 658 case DDI_INFO_DEVT2DEVINFO: 659 if (softc == NULL || softc->devi == NULL) { 660 error = DDI_FAILURE; 661 } else { 662 *result = (void *) softc->devi; 663 error = DDI_SUCCESS; 664 } 665 break; 666 case DDI_INFO_DEVT2INSTANCE: 667 *result = (void *)(uintptr_t)instance; 668 error = DDI_SUCCESS; 669 break; 670 default: 671 error = DDI_FAILURE; 672 break; 673 } 674 return (error); 675 } 676 677 678 /*ARGSUSED*/ 679 static int 680 vgatext_open(dev_t *devp, int flag, int otyp, cred_t *cred) 681 { 682 struct vgatext_softc *softc = getsoftc(DEV2INST(*devp)); 683 684 if (softc == NULL || otyp == OTYP_BLK) 685 return (ENXIO); 686 687 return (0); 688 } 689 690 /*ARGSUSED*/ 691 static int 692 vgatext_close(dev_t devp, int flag, int otyp, cred_t *cred) 693 { 694 return (0); 695 } 696 697 static int 698 do_gfx_ioctl(int cmd, intptr_t data, int mode, struct vgatext_softc *softc) 699 { 700 static char kernel_only[] = 701 "do_gfx_ioctl: %s is a kernel only ioctl"; 702 int err; 703 int kd_mode; 704 705 switch (cmd) { 706 case KDSETMODE: 707 return (vgatext_kdsetmode(softc, (int)data)); 708 709 case KDGETMODE: 710 kd_mode = softc->mode; 711 if (ddi_copyout(&kd_mode, (void *)data, sizeof (int), mode)) 712 return (EFAULT); 713 break; 714 715 case VIS_GETIDENTIFIER: 716 if (ddi_copyout(&text_ident, (void *)data, 717 sizeof (struct vis_identifier), mode)) 718 return (EFAULT); 719 break; 720 721 case VIS_DEVINIT: 722 723 if (!(mode & FKIOCTL)) { 724 cmn_err(CE_CONT, kernel_only, "VIS_DEVINIT"); 725 return (ENXIO); 726 } 727 728 err = vgatext_devinit(softc, (struct vis_devinit *)data); 729 if (err != 0) { 730 cmn_err(CE_WARN, 731 "vgatext_ioctl: could not initialize console"); 732 return (err); 733 } 734 break; 735 736 case VIS_CONSCOPY: /* move */ 737 { 738 struct vis_conscopy pma; 739 740 if (ddi_copyin((void *)data, &pma, 741 sizeof (struct vis_conscopy), mode)) 742 return (EFAULT); 743 744 vgatext_cons_copy(softc, &pma); 745 break; 746 } 747 748 case VIS_CONSDISPLAY: /* display */ 749 { 750 struct vis_consdisplay display_request; 751 752 if (ddi_copyin((void *)data, &display_request, 753 sizeof (display_request), mode)) 754 return (EFAULT); 755 756 vgatext_cons_display(softc, &display_request); 757 break; 758 } 759 760 case VIS_CONSCURSOR: 761 { 762 struct vis_conscursor cursor_request; 763 764 if (ddi_copyin((void *)data, &cursor_request, 765 sizeof (cursor_request), mode)) 766 return (EFAULT); 767 768 vgatext_cons_cursor(softc, &cursor_request); 769 770 if (cursor_request.action == VIS_GET_CURSOR && 771 ddi_copyout(&cursor_request, (void *)data, 772 sizeof (cursor_request), mode)) 773 return (EFAULT); 774 break; 775 } 776 777 case VIS_GETCMAP: 778 case VIS_PUTCMAP: 779 case FBIOPUTCMAP: 780 case FBIOGETCMAP: 781 /* 782 * At the moment, text mode is not considered to have 783 * a color map. 784 */ 785 return (EINVAL); 786 787 case FBIOGATTR: 788 if (copyout(&vgatext_attr, (void *)data, 789 sizeof (struct fbgattr))) 790 return (EFAULT); 791 break; 792 793 case FBIOGTYPE: 794 if (copyout(&vgatext_attr.fbtype, (void *)data, 795 sizeof (struct fbtype))) 796 return (EFAULT); 797 break; 798 799 default: 800 return (ENXIO); 801 } 802 return (0); 803 } 804 805 806 /*ARGSUSED*/ 807 static int 808 vgatext_ioctl( 809 dev_t dev, 810 int cmd, 811 intptr_t data, 812 int mode, 813 cred_t *cred, 814 int *rval) 815 { 816 struct vgatext_softc *softc = getsoftc(DEV2INST(dev)); 817 int err; 818 819 switch (DEV2MINOR(dev)) { 820 case GFX_MINOR: 821 mutex_enter(&(softc->lock)); 822 err = do_gfx_ioctl(cmd, data, mode, softc); 823 mutex_exit(&(softc->lock)); 824 break; 825 826 case AGPMASTER_MINOR: 827 /* 828 * This is apparently not used anymore. Let's log a 829 * message so we'll know if some consumer shows up. 830 * If it turns out that we actually do need to keep 831 * support for this pass-through to agpmaster, it 832 * would probably be better to use "layered" access 833 * to the AGP device (ldi_open, ldi_ioctl, ldi_close) 834 */ 835 cmn_err(CE_NOTE, "!vgatext wants agpmaster"); 836 return (EBADF); 837 838 default: 839 /* not a valid minor node */ 840 return (EBADF); 841 } 842 return (err); 843 } 844 845 static void 846 vgatext_save_text(struct vgatext_softc *softc) 847 { 848 unsigned i; 849 850 for (i = 0; i < sizeof (softc->shadow); i++) 851 softc->shadow[i] = softc->current_base[i]; 852 } 853 854 static void 855 vgatext_progressbar_stop() 856 { 857 extern void progressbar_stop(void); 858 859 if (vgatext_silent == 1) { 860 vgatext_silent = 0; 861 progressbar_stop(); 862 } 863 } 864 865 static void 866 vgatext_kdsettext(struct vgatext_softc *softc) 867 { 868 int i; 869 870 vgatext_init(softc); 871 for (i = 0; i < sizeof (softc->shadow); i++) { 872 softc->text_base[i] = softc->shadow[i]; 873 } 874 softc->current_base = softc->text_base; 875 if (softc->cursor.visible) { 876 vgatext_set_cursor(softc, 877 softc->cursor.row, softc->cursor.col); 878 } 879 vgatext_restore_colormap(softc); 880 } 881 882 static void 883 vgatext_kdsetgraphics(struct vgatext_softc *softc) 884 { 885 vgatext_progressbar_stop(); 886 vgatext_save_text(softc); 887 softc->current_base = softc->shadow; 888 #if defined(USE_BORDERS) 889 vgatext_init_graphics(softc); 890 #endif 891 } 892 893 static int 894 vgatext_kdsetmode(struct vgatext_softc *softc, int mode) 895 { 896 if ((mode == softc->mode) || (!VGATEXT_IS_CONSOLE(softc))) 897 return (0); 898 899 switch (mode) { 900 case KD_TEXT: 901 vgatext_kdsettext(softc); 902 break; 903 904 case KD_GRAPHICS: 905 vgatext_kdsetgraphics(softc); 906 break; 907 908 case KD_RESETTEXT: 909 /* 910 * In order to avoid racing with a starting X server, 911 * this needs to be a test and set that is performed in 912 * a single (softc->lock protected) ioctl into this driver. 913 */ 914 if (softc->mode == KD_TEXT && vgatext_silent == 1) { 915 vgatext_progressbar_stop(); 916 vgatext_kdsettext(softc); 917 } 918 break; 919 920 default: 921 return (EINVAL); 922 } 923 softc->mode = mode; 924 return (0); 925 } 926 927 /*ARGSUSED*/ 928 static int 929 vgatext_devmap(dev_t dev, devmap_cookie_t dhp, offset_t off, size_t len, 930 size_t *maplen, uint_t model) 931 { 932 struct vgatext_softc *softc; 933 int err; 934 size_t length; 935 936 937 softc = getsoftc(DEV2INST(dev)); 938 if (softc == NULL) { 939 cmn_err(CE_WARN, "vgatext: Can't find softstate"); 940 return (-1); 941 } 942 943 if (!(off >= VGA_MMAP_FB_BASE && 944 off < VGA_MMAP_FB_BASE + softc->fb_size)) { 945 cmn_err(CE_WARN, "vgatext: Can't map offset 0x%llx", off); 946 return (-1); 947 } 948 949 if (off + len > VGA_MMAP_FB_BASE + softc->fb_size) 950 length = VGA_MMAP_FB_BASE + softc->fb_size - off; 951 else 952 length = len; 953 954 if ((err = devmap_devmem_setup(dhp, softc->devi, NULL, softc->fb_regno, 955 off - VGA_MMAP_FB_BASE, 956 length, PROT_ALL, 0, &dev_attr)) < 0) { 957 return (err); 958 } 959 960 961 *maplen = length; 962 return (0); 963 } 964 965 966 static int 967 vgatext_devinit(struct vgatext_softc *softc, struct vis_devinit *data) 968 { 969 /* initialize console instance */ 970 data->version = VIS_CONS_REV; 971 data->width = TEXT_COLS; 972 data->height = TEXT_ROWS; 973 data->linebytes = TEXT_COLS; 974 data->depth = 4; 975 data->mode = VIS_TEXT; 976 data->polledio = &softc->polledio; 977 978 return (0); 979 } 980 981 /* 982 * display a string on the screen at (row, col) 983 * assume it has been cropped to fit. 984 */ 985 986 static void 987 vgatext_cons_display(struct vgatext_softc *softc, struct vis_consdisplay *da) 988 { 989 unsigned char *string; 990 int i; 991 unsigned char attr; 992 struct cgatext { 993 unsigned char ch; 994 unsigned char attr; 995 }; 996 struct cgatext *addr; 997 998 /* 999 * Sanity checks. This is a last-ditch effort to avoid damage 1000 * from brokenness or maliciousness above. 1001 */ 1002 if (da->row < 0 || da->row >= TEXT_ROWS || 1003 da->col < 0 || da->col >= TEXT_COLS || 1004 da->col + da->width > TEXT_COLS) 1005 return; 1006 1007 /* 1008 * To be fully general, we should copyin the data. This is not 1009 * really relevant for this text-only driver, but a graphical driver 1010 * should support these ioctls from userland to enable simple 1011 * system startup graphics. 1012 */ 1013 attr = (solaris_color_to_pc_color[da->bg_color & 0xf] << 4) 1014 | solaris_color_to_pc_color[da->fg_color & 0xf]; 1015 string = da->data; 1016 addr = (struct cgatext *)softc->current_base 1017 + (da->row * TEXT_COLS + da->col); 1018 for (i = 0; i < da->width; i++) { 1019 addr->ch = string[i]; 1020 addr->attr = attr; 1021 addr++; 1022 } 1023 } 1024 1025 static void 1026 vgatext_polled_display( 1027 struct vis_polledio_arg *arg, 1028 struct vis_consdisplay *da) 1029 { 1030 vgatext_cons_display((struct vgatext_softc *)arg, da); 1031 } 1032 1033 /* 1034 * screen-to-screen copy 1035 */ 1036 1037 static void 1038 vgatext_cons_copy(struct vgatext_softc *softc, struct vis_conscopy *ma) 1039 { 1040 unsigned short *from; 1041 unsigned short *to; 1042 int cnt; 1043 screen_size_t chars_per_row; 1044 unsigned short *to_row_start; 1045 unsigned short *from_row_start; 1046 screen_size_t rows_to_move; 1047 unsigned short *base; 1048 1049 /* 1050 * Sanity checks. Note that this is a last-ditch effort to avoid 1051 * damage caused by broken-ness or maliciousness above. 1052 */ 1053 if (ma->s_col < 0 || ma->s_col >= TEXT_COLS || 1054 ma->s_row < 0 || ma->s_row >= TEXT_ROWS || 1055 ma->e_col < 0 || ma->e_col >= TEXT_COLS || 1056 ma->e_row < 0 || ma->e_row >= TEXT_ROWS || 1057 ma->t_col < 0 || ma->t_col >= TEXT_COLS || 1058 ma->t_row < 0 || ma->t_row >= TEXT_ROWS || 1059 ma->s_col > ma->e_col || 1060 ma->s_row > ma->e_row) 1061 return; 1062 1063 /* 1064 * Remember we're going to copy shorts because each 1065 * character/attribute pair is 16 bits. 1066 */ 1067 chars_per_row = ma->e_col - ma->s_col + 1; 1068 rows_to_move = ma->e_row - ma->s_row + 1; 1069 1070 /* More sanity checks. */ 1071 if (ma->t_row + rows_to_move > TEXT_ROWS || 1072 ma->t_col + chars_per_row > TEXT_COLS) 1073 return; 1074 1075 base = (unsigned short *)softc->current_base; 1076 1077 to_row_start = base + ((ma->t_row * TEXT_COLS) + ma->t_col); 1078 from_row_start = base + ((ma->s_row * TEXT_COLS) + ma->s_col); 1079 1080 if (to_row_start < from_row_start) { 1081 while (rows_to_move-- > 0) { 1082 to = to_row_start; 1083 from = from_row_start; 1084 to_row_start += TEXT_COLS; 1085 from_row_start += TEXT_COLS; 1086 for (cnt = chars_per_row; cnt-- > 0; ) 1087 *to++ = *from++; 1088 } 1089 } else { 1090 /* 1091 * Offset to the end of the region and copy backwards. 1092 */ 1093 cnt = rows_to_move * TEXT_COLS + chars_per_row; 1094 to_row_start += cnt; 1095 from_row_start += cnt; 1096 1097 while (rows_to_move-- > 0) { 1098 to_row_start -= TEXT_COLS; 1099 from_row_start -= TEXT_COLS; 1100 to = to_row_start; 1101 from = from_row_start; 1102 for (cnt = chars_per_row; cnt-- > 0; ) 1103 *--to = *--from; 1104 } 1105 } 1106 } 1107 1108 static void 1109 vgatext_polled_copy( 1110 struct vis_polledio_arg *arg, 1111 struct vis_conscopy *ca) 1112 { 1113 vgatext_cons_copy((struct vgatext_softc *)arg, ca); 1114 } 1115 1116 1117 static void 1118 vgatext_cons_cursor(struct vgatext_softc *softc, struct vis_conscursor *ca) 1119 { 1120 if (vgatext_silent) 1121 return; 1122 1123 switch (ca->action) { 1124 case VIS_HIDE_CURSOR: 1125 softc->cursor.visible = B_FALSE; 1126 if (softc->current_base == softc->text_base) 1127 vgatext_hide_cursor(softc); 1128 break; 1129 case VIS_DISPLAY_CURSOR: 1130 /* 1131 * Sanity check. This is a last-ditch effort to avoid 1132 * damage from brokenness or maliciousness above. 1133 */ 1134 if (ca->col < 0 || ca->col >= TEXT_COLS || 1135 ca->row < 0 || ca->row >= TEXT_ROWS) 1136 return; 1137 1138 softc->cursor.visible = B_TRUE; 1139 softc->cursor.col = ca->col; 1140 softc->cursor.row = ca->row; 1141 if (softc->current_base == softc->text_base) 1142 vgatext_set_cursor(softc, ca->row, ca->col); 1143 break; 1144 case VIS_GET_CURSOR: 1145 if (softc->current_base == softc->text_base) { 1146 vgatext_get_cursor(softc, &ca->row, &ca->col); 1147 } 1148 break; 1149 } 1150 } 1151 1152 static void 1153 vgatext_polled_cursor( 1154 struct vis_polledio_arg *arg, 1155 struct vis_conscursor *ca) 1156 { 1157 vgatext_cons_cursor((struct vgatext_softc *)arg, ca); 1158 } 1159 1160 1161 1162 /*ARGSUSED*/ 1163 static void 1164 vgatext_hide_cursor(struct vgatext_softc *softc) 1165 { 1166 /* Nothing at present */ 1167 } 1168 1169 static void 1170 vgatext_set_cursor(struct vgatext_softc *softc, int row, int col) 1171 { 1172 short addr; 1173 1174 if (vgatext_silent) 1175 return; 1176 1177 addr = row * TEXT_COLS + col; 1178 1179 vga_set_crtc(&softc->regs, VGA_CRTC_CLAH, addr >> 8); 1180 vga_set_crtc(&softc->regs, VGA_CRTC_CLAL, addr & 0xff); 1181 } 1182 1183 static int vga_row, vga_col; 1184 1185 static void 1186 vgatext_get_cursor(struct vgatext_softc *softc, 1187 screen_pos_t *row, screen_pos_t *col) 1188 { 1189 short addr; 1190 1191 addr = (vga_get_crtc(&softc->regs, VGA_CRTC_CLAH) << 8) + 1192 vga_get_crtc(&softc->regs, VGA_CRTC_CLAL); 1193 1194 vga_row = *row = addr / TEXT_COLS; 1195 vga_col = *col = addr % TEXT_COLS; 1196 } 1197 1198 /* 1199 * This code is experimental. It's only enabled if console is 1200 * set to graphics, a preliminary implementation of happyface boot. 1201 */ 1202 static void 1203 vgatext_set_text(struct vgatext_softc *softc) 1204 { 1205 int i; 1206 1207 if (happyface_boot == 0) 1208 return; 1209 1210 /* we are in graphics mode, set to text 80X25 mode */ 1211 1212 /* set misc registers */ 1213 vga_set_reg(&softc->regs, VGA_MISC_W, VGA_MISC_TEXT); 1214 1215 /* set sequencer registers */ 1216 vga_set_seq(&softc->regs, VGA_SEQ_RST_SYN, 1217 (vga_get_seq(&softc->regs, VGA_SEQ_RST_SYN) & 1218 ~VGA_SEQ_RST_SYN_NO_SYNC_RESET)); 1219 for (i = 1; i < NUM_SEQ_REG; i++) { 1220 vga_set_seq(&softc->regs, i, VGA_SEQ_TEXT[i]); 1221 } 1222 vga_set_seq(&softc->regs, VGA_SEQ_RST_SYN, 1223 (vga_get_seq(&softc->regs, VGA_SEQ_RST_SYN) | 1224 VGA_SEQ_RST_SYN_NO_ASYNC_RESET | 1225 VGA_SEQ_RST_SYN_NO_SYNC_RESET)); 1226 1227 /* set crt controller registers */ 1228 vga_set_crtc(&softc->regs, VGA_CRTC_VRE, 1229 (vga_get_crtc(&softc->regs, VGA_CRTC_VRE) & 1230 ~VGA_CRTC_VRE_LOCK)); 1231 for (i = 0; i < NUM_CRTC_REG; i++) { 1232 vga_set_crtc(&softc->regs, i, VGA_CRTC_TEXT[i]); 1233 } 1234 1235 /* set graphics controller registers */ 1236 for (i = 0; i < NUM_GRC_REG; i++) { 1237 vga_set_grc(&softc->regs, i, VGA_GRC_TEXT[i]); 1238 } 1239 1240 /* set attribute registers */ 1241 for (i = 0; i < NUM_ATR_REG; i++) { 1242 vga_set_atr(&softc->regs, i, VGA_ATR_TEXT[i]); 1243 } 1244 1245 /* set palette */ 1246 for (i = 0; i < VGA_TEXT_CMAP_ENTRIES; i++) { 1247 vga_put_cmap(&softc->regs, i, VGA_TEXT_PALETTES[i][0] << 2, 1248 VGA_TEXT_PALETTES[i][1] << 2, 1249 VGA_TEXT_PALETTES[i][2] << 2); 1250 } 1251 for (i = VGA_TEXT_CMAP_ENTRIES; i < VGA8_CMAP_ENTRIES; i++) { 1252 vga_put_cmap(&softc->regs, i, 0, 0, 0); 1253 } 1254 1255 vgatext_save_colormap(softc); 1256 } 1257 1258 static void 1259 vgatext_init(struct vgatext_softc *softc) 1260 { 1261 unsigned char atr_mode; 1262 1263 atr_mode = vga_get_atr(&softc->regs, VGA_ATR_MODE); 1264 if (atr_mode & VGA_ATR_MODE_GRAPH) 1265 vgatext_set_text(softc); 1266 atr_mode = vga_get_atr(&softc->regs, VGA_ATR_MODE); 1267 atr_mode &= ~VGA_ATR_MODE_BLINK; 1268 atr_mode &= ~VGA_ATR_MODE_9WIDE; 1269 vga_set_atr(&softc->regs, VGA_ATR_MODE, atr_mode); 1270 #if defined(USE_BORDERS) 1271 vga_set_atr(&softc->regs, VGA_ATR_BDR_CLR, 1272 vga_get_atr(&softc->regs, VGA_BRIGHT_WHITE)); 1273 #else 1274 vga_set_atr(&softc->regs, VGA_ATR_BDR_CLR, 1275 vga_get_atr(&softc->regs, VGA_BLACK)); 1276 #endif 1277 vgatext_setfont(softc); /* need selectable font? */ 1278 } 1279 1280 #if defined(USE_BORDERS) 1281 static void 1282 vgatext_init_graphics(struct vgatext_softc *softc) 1283 { 1284 vga_set_atr(&softc->regs, VGA_ATR_BDR_CLR, 1285 vga_get_atr(&softc->regs, VGA_BLACK)); 1286 } 1287 #endif 1288 1289 static char vga_fontslot = 0; 1290 1291 static void 1292 vgatext_setfont(struct vgatext_softc *softc) 1293 { 1294 static uchar_t fsreg[8] = {0x0, 0x30, 0x5, 0x35, 0xa, 0x3a, 0xf, 0x3f}; 1295 1296 uchar_t *from; 1297 uchar_t volatile *to; 1298 int i, j, s; 1299 int bpc, f_offset; 1300 1301 /* Sync-reset the sequencer registers */ 1302 vga_set_seq(&softc->regs, 0x00, 0x01); 1303 /* 1304 * enable write to plane2, since fonts 1305 * could only be loaded into plane2 1306 */ 1307 vga_set_seq(&softc->regs, 0x02, 0x04); 1308 /* 1309 * sequentially access data in the bit map being 1310 * selected by MapMask register (index 0x02) 1311 */ 1312 vga_set_seq(&softc->regs, 0x04, 0x07); 1313 /* Sync-reset ended, and allow the sequencer to operate */ 1314 vga_set_seq(&softc->regs, 0x00, 0x03); 1315 1316 /* 1317 * select plane 2 on Read Mode 0 1318 */ 1319 vga_set_grc(&softc->regs, 0x04, 0x02); 1320 /* 1321 * system addresses sequentially access data, follow 1322 * Memory Mode register bit 2 in the sequencer 1323 */ 1324 vga_set_grc(&softc->regs, 0x05, 0x00); 1325 /* 1326 * set range of host memory addresses decoded by VGA 1327 * hardware -- A0000h-BFFFFh (128K region) 1328 */ 1329 vga_set_grc(&softc->regs, 0x06, 0x00); 1330 1331 /* 1332 * This assumes 8x16 characters, which yield the traditional 80x25 1333 * screen. It really should support other character heights. 1334 */ 1335 bpc = 16; 1336 s = vga_fontslot; 1337 f_offset = s * 8 * 1024; 1338 for (i = 0; i < 256; i++) { 1339 from = font_data_8x16.encoding[i]; 1340 to = (unsigned char *)softc->fb.addr + f_offset + i * 0x20; 1341 for (j = 0; j < bpc; j++) 1342 *to++ = *from++; 1343 } 1344 1345 /* Sync-reset the sequencer registers */ 1346 vga_set_seq(&softc->regs, 0x00, 0x01); 1347 /* enable write to plane 0 and 1 */ 1348 vga_set_seq(&softc->regs, 0x02, 0x03); 1349 /* 1350 * enable character map selection 1351 * and odd/even addressing 1352 */ 1353 vga_set_seq(&softc->regs, 0x04, 0x03); 1354 /* 1355 * select font map 1356 */ 1357 vga_set_seq(&softc->regs, 0x03, fsreg[s]); 1358 /* Sync-reset ended, and allow the sequencer to operate */ 1359 vga_set_seq(&softc->regs, 0x00, 0x03); 1360 1361 /* restore graphic registers */ 1362 1363 /* select plane 0 */ 1364 vga_set_grc(&softc->regs, 0x04, 0x00); 1365 /* enable odd/even addressing mode */ 1366 vga_set_grc(&softc->regs, 0x05, 0x10); 1367 /* 1368 * range of host memory addresses decoded by VGA 1369 * hardware -- B8000h-BFFFFh (32K region) 1370 */ 1371 vga_set_grc(&softc->regs, 0x06, 0x0e); 1372 /* enable all color plane */ 1373 vga_set_atr(&softc->regs, 0x12, 0x0f); 1374 1375 } 1376 1377 static void 1378 vgatext_save_colormap(struct vgatext_softc *softc) 1379 { 1380 int i; 1381 1382 for (i = 0; i < VGA_ATR_NUM_PLT; i++) { 1383 softc->attrib_palette[i] = vga_get_atr(&softc->regs, i); 1384 } 1385 for (i = 0; i < VGA8_CMAP_ENTRIES; i++) { 1386 vga_get_cmap(&softc->regs, i, 1387 &softc->colormap[i].red, 1388 &softc->colormap[i].green, 1389 &softc->colormap[i].blue); 1390 } 1391 } 1392 1393 static void 1394 vgatext_restore_colormap(struct vgatext_softc *softc) 1395 { 1396 int i; 1397 1398 for (i = 0; i < VGA_ATR_NUM_PLT; i++) { 1399 vga_set_atr(&softc->regs, i, softc->attrib_palette[i]); 1400 } 1401 for (i = 0; i < VGA8_CMAP_ENTRIES; i++) { 1402 vga_put_cmap(&softc->regs, i, 1403 softc->colormap[i].red, 1404 softc->colormap[i].green, 1405 softc->colormap[i].blue); 1406 } 1407 } 1408 1409 /* 1410 * search the entries of the "reg" property for one which has the desired 1411 * combination of phys_hi bits and contains the desired address. 1412 * 1413 * This version searches a PCI-style "reg" property. It was prompted by 1414 * issues surrounding the presence or absence of an entry for the ROM: 1415 * (a) a transition problem with PowerPC Virtual Open Firmware 1416 * (b) uncertainty as to whether an entry will be included on a device 1417 * with ROM support (and so an "active" ROM base address register), 1418 * but no ROM actually installed. 1419 * 1420 * See the note below on vgatext_get_isa_reg_index for the reasons for 1421 * returning the offset. 1422 * 1423 * Note that this routine may not be fully general; it is intended for the 1424 * specific purpose of finding a couple of particular VGA reg entries and 1425 * may not be suitable for all reg-searching purposes. 1426 */ 1427 static int 1428 vgatext_get_pci_reg_index( 1429 dev_info_t *const devi, 1430 unsigned long himask, 1431 unsigned long hival, 1432 unsigned long addr, 1433 off_t *offset) 1434 { 1435 1436 int length, index; 1437 pci_regspec_t *reg; 1438 1439 if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1440 "reg", (caddr_t)®, &length) != DDI_PROP_SUCCESS) { 1441 return (-1); 1442 } 1443 1444 for (index = 0; index < length / sizeof (pci_regspec_t); index++) { 1445 if ((reg[index].pci_phys_hi & himask) != hival) 1446 continue; 1447 if (reg[index].pci_size_hi != 0) 1448 continue; 1449 if (reg[index].pci_phys_mid != 0) 1450 continue; 1451 if (reg[index].pci_phys_low > addr) 1452 continue; 1453 if (reg[index].pci_phys_low + reg[index].pci_size_low <= addr) 1454 continue; 1455 1456 *offset = addr - reg[index].pci_phys_low; 1457 kmem_free(reg, (size_t)length); 1458 return (index); 1459 } 1460 kmem_free(reg, (size_t)length); 1461 1462 return (-1); 1463 } 1464 1465 /* 1466 * search the entries of the "reg" property for one which has the desired 1467 * combination of phys_hi bits and contains the desired address. 1468 * 1469 * This version searches a ISA-style "reg" property. It was prompted by 1470 * issues surrounding 8514/A support. By IEEE 1275 compatibility conventions, 1471 * 8514/A registers should have been added after all standard VGA registers. 1472 * Unfortunately, the Solaris/Intel device configuration framework 1473 * (a) lists the 8514/A registers before the video memory, and then 1474 * (b) also sorts the entries so that I/O entries come before memory 1475 * entries. 1476 * 1477 * It returns the "reg" index and offset into that register set. 1478 * The offset is needed because there exist (broken?) BIOSes that 1479 * report larger ranges enclosing the standard ranges. One reports 1480 * 0x3bf for 0x21 instead of 0x3c0 for 0x20, for instance. Using the 1481 * offset adjusts for this difference in the base of the register set. 1482 * 1483 * Note that this routine may not be fully general; it is intended for the 1484 * specific purpose of finding a couple of particular VGA reg entries and 1485 * may not be suitable for all reg-searching purposes. 1486 */ 1487 static int 1488 vgatext_get_isa_reg_index( 1489 dev_info_t *const devi, 1490 unsigned long hival, 1491 unsigned long addr, 1492 off_t *offset) 1493 { 1494 1495 int length, index; 1496 struct regspec *reg; 1497 1498 if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1499 "reg", (caddr_t)®, &length) != DDI_PROP_SUCCESS) { 1500 return (-1); 1501 } 1502 1503 for (index = 0; index < length / sizeof (struct regspec); index++) { 1504 if (reg[index].regspec_bustype != hival) 1505 continue; 1506 if (reg[index].regspec_addr > addr) 1507 continue; 1508 if (reg[index].regspec_addr + reg[index].regspec_size <= addr) 1509 continue; 1510 1511 *offset = addr - reg[index].regspec_addr; 1512 kmem_free(reg, (size_t)length); 1513 return (index); 1514 } 1515 kmem_free(reg, (size_t)length); 1516 1517 return (-1); 1518 } 1519