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