gftfb.c revision 1.20
1 /* $NetBSD: gftfb.c,v 1.20 2024/09/10 08:49:33 macallan Exp $ */ 2 3 /* $OpenBSD: sti_pci.c,v 1.7 2009/02/06 22:51:04 miod Exp $ */ 4 5 /* 6 * Copyright (c) 2006, 2007 Miodrag Vallat. 7 ^ 2024 Michael Lorenz 8 * 9 * Permission to use, copy, modify, and distribute this software for any 10 * purpose with or without fee is hereby granted, provided that the above 11 * copyright notice, this permission notice, and the disclaimer below 12 * appear in all copies. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 15 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 16 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 17 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 19 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 20 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 21 */ 22 23 /* 24 * a native driver for HP Visualize EG PCI graphics cards 25 * STI portions are from Miodrag Vallat's sti_pci.c 26 */ 27 28 #include <sys/param.h> 29 #include <sys/systm.h> 30 #include <sys/kmem.h> 31 #include <sys/device.h> 32 #include <sys/mutex.h> 33 34 #include <dev/pci/pcivar.h> 35 #include <dev/pci/pcireg.h> 36 #include <dev/pci/pcidevs.h> 37 #include <dev/pci/pciio.h> 38 39 #include <dev/wscons/wsdisplayvar.h> 40 #include <dev/wscons/wsconsio.h> 41 #include <dev/wsfont/wsfont.h> 42 #include <dev/rasops/rasops.h> 43 #include <dev/wscons/wsdisplay_vconsvar.h> 44 #include <dev/pci/wsdisplay_pci.h> 45 #include <dev/wscons/wsdisplay_glyphcachevar.h> 46 47 #include <dev/ic/stireg.h> 48 #include <dev/ic/stivar.h> 49 50 #include "opt_gftfb.h" 51 52 #ifdef GFTFB_DEBUG 53 #define DPRINTF(s) printf(s) 54 #else 55 #define DPRINTF(s) /* */ 56 #endif 57 58 int gftfb_match(device_t, cfdata_t, void *); 59 void gftfb_attach(device_t, device_t, void *); 60 61 struct gftfb_softc { 62 device_t sc_dev; 63 pci_chipset_tag_t sc_pc; 64 pcitag_t sc_tag; 65 66 /* stuff we need in order to use the STI ROM */ 67 struct sti_softc sc_base; 68 struct sti_screen sc_scr; 69 bus_space_handle_t sc_romh; 70 71 int sc_width, sc_height; 72 int sc_locked; 73 struct vcons_screen sc_console_screen; 74 struct wsscreen_descr sc_defaultscreen_descr; 75 const struct wsscreen_descr *sc_screens[1]; 76 struct wsscreen_list sc_screenlist; 77 struct vcons_data vd; 78 int sc_mode; 79 void (*sc_putchar)(void *, int, int, u_int, long); 80 u_char sc_cmap_red[256]; 81 u_char sc_cmap_green[256]; 82 u_char sc_cmap_blue[256]; 83 kmutex_t sc_hwlock; 84 uint32_t sc_hwmode; 85 #define HW_FB 0 86 #define HW_FILL 1 87 #define HW_BLIT 2 88 /* cursor stuff */ 89 int sc_cursor_x, sc_cursor_y; 90 int sc_hot_x, sc_hot_y, sc_enabled; 91 int sc_video_on; 92 glyphcache sc_gc; 93 }; 94 95 CFATTACH_DECL_NEW(gftfb, sizeof(struct gftfb_softc), 96 gftfb_match, gftfb_attach, NULL, NULL); 97 98 int gftfb_readbar(struct sti_softc *, struct pci_attach_args *, u_int, int); 99 int gftfb_check_rom(struct gftfb_softc *, struct pci_attach_args *); 100 void gftfb_enable_rom(struct sti_softc *); 101 void gftfb_disable_rom(struct sti_softc *); 102 void gftfb_enable_rom_internal(struct gftfb_softc *); 103 void gftfb_disable_rom_internal(struct gftfb_softc *); 104 105 void gftfb_setup(struct gftfb_softc *); 106 107 #define ngle_bt458_write(memt, memh, r, v) \ 108 bus_space_write_stream_4(memt, memh, NGLE_REG_RAMDAC + ((r) << 2), (v) << 24) 109 110 111 /* XXX these really need to go into their own header */ 112 int sti_pci_is_console(struct pci_attach_args *, bus_addr_t *); 113 int sti_rom_setup(struct sti_rom *, bus_space_tag_t, bus_space_tag_t, 114 bus_space_handle_t, bus_addr_t *, u_int); 115 int sti_screen_setup(struct sti_screen *, int); 116 void sti_describe_screen(struct sti_softc *, struct sti_screen *); 117 118 #define PCI_ROM_SIZE(mr) \ 119 (PCI_MAPREG_ROM_ADDR(mr) & -PCI_MAPREG_ROM_ADDR(mr)) 120 121 /* wsdisplay stuff */ 122 static int gftfb_ioctl(void *, void *, u_long, void *, int, 123 struct lwp *); 124 static paddr_t gftfb_mmap(void *, void *, off_t, int); 125 static void gftfb_init_screen(void *, struct vcons_screen *, int, long *); 126 127 static int gftfb_putcmap(struct gftfb_softc *, struct wsdisplay_cmap *); 128 static int gftfb_getcmap(struct gftfb_softc *, struct wsdisplay_cmap *); 129 static void gftfb_restore_palette(struct gftfb_softc *); 130 static int gftfb_putpalreg(struct gftfb_softc *, uint8_t, uint8_t, 131 uint8_t, uint8_t); 132 133 static void gftfb_rectfill(struct gftfb_softc *, int, int, int, int, 134 uint32_t); 135 static void gftfb_bitblt(void *, int, int, int, int, int, 136 int, int); 137 138 static void gftfb_cursor(void *, int, int, int); 139 static void gftfb_putchar(void *, int, int, u_int, long); 140 static void gftfb_copycols(void *, int, int, int, int); 141 static void gftfb_erasecols(void *, int, int, int, long); 142 static void gftfb_copyrows(void *, int, int, int); 143 static void gftfb_eraserows(void *, int, int, long); 144 145 static void gftfb_move_cursor(struct gftfb_softc *, int, int); 146 static int gftfb_do_cursor(struct gftfb_softc *, struct wsdisplay_cursor *); 147 148 static void gftfb_set_video(struct gftfb_softc *, int); 149 150 struct wsdisplay_accessops gftfb_accessops = { 151 gftfb_ioctl, 152 gftfb_mmap, 153 NULL, /* alloc_screen */ 154 NULL, /* free_screen */ 155 NULL, /* show_screen */ 156 NULL, /* load_font */ 157 NULL, /* pollc */ 158 NULL /* scroll */ 159 }; 160 161 static inline void gftfb_wait_fifo(struct gftfb_softc *, uint32_t); 162 163 int 164 gftfb_match(device_t parent, cfdata_t cf, void *aux) 165 { 166 struct pci_attach_args *paa = aux; 167 168 if (PCI_VENDOR(paa->pa_id) != PCI_VENDOR_HP) 169 return 0; 170 171 if (PCI_PRODUCT(paa->pa_id) == PCI_PRODUCT_HP_VISUALIZE_EG) 172 return 10; /* beat out sti at pci */ 173 174 return 0; 175 } 176 177 void 178 gftfb_attach(device_t parent, device_t self, void *aux) 179 { 180 struct gftfb_softc *sc = device_private(self); 181 struct pci_attach_args *paa = aux; 182 struct sti_rom *rom; 183 struct rasops_info *ri; 184 struct wsemuldisplaydev_attach_args aa; 185 unsigned long defattr = 0; 186 int ret, is_console = 0; 187 188 sc->sc_dev = self; 189 190 sc->sc_pc = paa->pa_pc; 191 sc->sc_tag = paa->pa_tag; 192 sc->sc_base.sc_dev = self; 193 sc->sc_base.sc_enable_rom = gftfb_enable_rom; 194 sc->sc_base.sc_disable_rom = gftfb_disable_rom; 195 196 /* we can *not* be interrupted when doing colour map accesses */ 197 mutex_init(&sc->sc_hwlock, MUTEX_DEFAULT, IPL_HIGH); 198 199 aprint_normal("\n"); 200 201 if (gftfb_check_rom(sc, paa) != 0) 202 return; 203 204 ret = sti_pci_is_console(paa, sc->sc_base. bases); 205 if (ret != 0) { 206 sc->sc_base.sc_flags |= STI_CONSOLE; 207 is_console = 1; 208 } 209 rom = (struct sti_rom *)kmem_zalloc(sizeof(*rom), KM_SLEEP); 210 rom->rom_softc = &sc->sc_base; 211 ret = sti_rom_setup(rom, paa->pa_iot, paa->pa_memt, sc->sc_romh, 212 sc->sc_base.bases, STI_CODEBASE_MAIN); 213 if (ret != 0) { 214 kmem_free(rom, sizeof(*rom)); 215 return; 216 } 217 218 sc->sc_base.sc_rom = rom; 219 220 sc->sc_scr.scr_rom = sc->sc_base.sc_rom; 221 ret = sti_screen_setup(&sc->sc_scr, STI_FBMODE); 222 223 sc->sc_width = sc->sc_scr.scr_cfg.scr_width; 224 sc->sc_height = sc->sc_scr.scr_cfg.scr_height; 225 226 aprint_normal_dev(sc->sc_dev, "%s at %dx%d\n", sc->sc_scr.name, 227 sc->sc_width, sc->sc_height); 228 gftfb_setup(sc); 229 230 sc->sc_defaultscreen_descr = (struct wsscreen_descr){ 231 "default", 232 0, 0, 233 NULL, 234 8, 16, 235 WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE | 236 WSSCREEN_RESIZE, 237 NULL 238 }; 239 240 sc->sc_screens[0] = &sc->sc_defaultscreen_descr; 241 sc->sc_screenlist = (struct wsscreen_list){1, sc->sc_screens}; 242 sc->sc_mode = WSDISPLAYIO_MODE_EMUL; 243 sc->sc_locked = 0; 244 245 vcons_init(&sc->vd, sc, &sc->sc_defaultscreen_descr, 246 &gftfb_accessops); 247 sc->vd.init_screen = gftfb_init_screen; 248 sc->vd.show_screen_cookie = &sc->sc_gc; 249 sc->vd.show_screen_cb = glyphcache_adapt; 250 251 ri = &sc->sc_console_screen.scr_ri; 252 253 sc->sc_gc.gc_bitblt = gftfb_bitblt; 254 sc->sc_gc.gc_blitcookie = sc; 255 sc->sc_gc.gc_rop = RopSrc; 256 257 if (is_console) { 258 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, 259 &defattr); 260 sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; 261 262 sc->sc_defaultscreen_descr.textops = &ri->ri_ops; 263 sc->sc_defaultscreen_descr.capabilities = ri->ri_caps; 264 sc->sc_defaultscreen_descr.nrows = ri->ri_rows; 265 sc->sc_defaultscreen_descr.ncols = ri->ri_cols; 266 267 glyphcache_init(&sc->sc_gc, sc->sc_height + 5, 268 sc->sc_scr.fbheight - sc->sc_height - 5, 269 sc->sc_scr.fbwidth, 270 ri->ri_font->fontwidth, 271 ri->ri_font->fontheight, 272 defattr); 273 274 wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, 0, 275 defattr); 276 277 gftfb_rectfill(sc, 0, 0, sc->sc_width, sc->sc_height, 278 ri->ri_devcmap[(defattr >> 16) & 0xff]); 279 280 vcons_replay_msgbuf(&sc->sc_console_screen); 281 } else { 282 /* 283 * since we're not the console we can postpone the rest 284 * until someone actually allocates a screen for us 285 */ 286 if (sc->sc_console_screen.scr_ri.ri_rows == 0) { 287 /* do some minimal setup to avoid weirdnesses later */ 288 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, 289 &defattr); 290 } else 291 (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr); 292 293 glyphcache_init(&sc->sc_gc, sc->sc_height + 5, 294 sc->sc_scr.fbheight - sc->sc_height - 5, 295 sc->sc_scr.fbwidth, 296 ri->ri_font->fontwidth, 297 ri->ri_font->fontheight, 298 defattr); 299 } 300 301 gftfb_restore_palette(sc); 302 303 /* no suspend/resume support yet */ 304 if (!pmf_device_register(sc->sc_dev, NULL, NULL)) 305 aprint_error_dev(sc->sc_dev, 306 "couldn't establish power handler\n"); 307 308 aa.console = is_console; 309 aa.scrdata = &sc->sc_screenlist; 310 aa.accessops = &gftfb_accessops; 311 aa.accesscookie = &sc->vd; 312 313 config_found(sc->sc_dev, &aa, wsemuldisplaydevprint, CFARGS_NONE); 314 } 315 316 /* 317 * Grovel the STI ROM image. 318 */ 319 int 320 gftfb_check_rom(struct gftfb_softc *spc, struct pci_attach_args *pa) 321 { 322 struct sti_softc *sc = &spc->sc_base; 323 pcireg_t address, mask; 324 bus_space_handle_t romh; 325 bus_size_t romsize, subsize, stiromsize; 326 bus_addr_t selected, offs, suboffs; 327 uint32_t tmp; 328 int i; 329 int rc; 330 331 /* sort of inline sti_pci_enable_rom(sc) */ 332 address = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_MAPREG_ROM); 333 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_MAPREG_ROM, 334 ~PCI_MAPREG_ROM_ENABLE); 335 mask = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_MAPREG_ROM); 336 address |= PCI_MAPREG_ROM_ENABLE; 337 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_MAPREG_ROM, address); 338 sc->sc_flags |= STI_ROM_ENABLED; 339 /* 340 * Map the complete ROM for now. 341 */ 342 343 romsize = PCI_ROM_SIZE(mask); 344 DPRINTF(("%s: mapping rom @ %lx for %lx\n", __func__, 345 (long)PCI_MAPREG_ROM_ADDR(address), (long)romsize)); 346 347 rc = bus_space_map(pa->pa_memt, PCI_MAPREG_ROM_ADDR(address), romsize, 348 0, &romh); 349 if (rc != 0) { 350 aprint_error_dev(sc->sc_dev, "can't map PCI ROM (%d)\n", rc); 351 goto fail2; 352 } 353 354 gftfb_disable_rom_internal(spc); 355 /* 356 * Iterate over the ROM images, pick the best candidate. 357 */ 358 359 selected = (bus_addr_t)-1; 360 for (offs = 0; offs < romsize; offs += subsize) { 361 gftfb_enable_rom_internal(spc); 362 /* 363 * Check for a valid ROM header. 364 */ 365 tmp = bus_space_read_4(pa->pa_memt, romh, offs + 0); 366 tmp = le32toh(tmp); 367 if (tmp != 0x55aa0000) { 368 gftfb_disable_rom_internal(spc); 369 if (offs == 0) { 370 aprint_error_dev(sc->sc_dev, 371 "invalid PCI ROM header signature (%08x)\n", 372 tmp); 373 rc = EINVAL; 374 } 375 break; 376 } 377 378 /* 379 * Check ROM type. 380 */ 381 tmp = bus_space_read_4(pa->pa_memt, romh, offs + 4); 382 tmp = le32toh(tmp); 383 if (tmp != 0x00000001) { /* 1 == STI ROM */ 384 gftfb_disable_rom_internal(spc); 385 if (offs == 0) { 386 aprint_error_dev(sc->sc_dev, 387 "invalid PCI ROM type (%08x)\n", tmp); 388 rc = EINVAL; 389 } 390 break; 391 } 392 393 subsize = (bus_addr_t)bus_space_read_2(pa->pa_memt, romh, 394 offs + 0x0c); 395 subsize <<= 9; 396 397 #ifdef GFTFB_DEBUG 398 gftfb_disable_rom_internal(spc); 399 DPRINTF(("ROM offset %08x size %08x type %08x", 400 (u_int)offs, (u_int)subsize, tmp)); 401 gftfb_enable_rom_internal(spc); 402 #endif 403 404 /* 405 * Check for a valid ROM data structure. 406 * We do not need it except to know what architecture the ROM 407 * code is for. 408 */ 409 410 suboffs = offs +(bus_addr_t)bus_space_read_2(pa->pa_memt, romh, 411 offs + 0x18); 412 tmp = bus_space_read_4(pa->pa_memt, romh, suboffs + 0); 413 tmp = le32toh(tmp); 414 if (tmp != 0x50434952) { /* PCIR */ 415 gftfb_disable_rom_internal(spc); 416 if (offs == 0) { 417 aprint_error_dev(sc->sc_dev, "invalid PCI data" 418 " signature (%08x)\n", tmp); 419 rc = EINVAL; 420 } else { 421 DPRINTF((" invalid PCI data signature %08x\n", 422 tmp)); 423 continue; 424 } 425 } 426 427 tmp = bus_space_read_1(pa->pa_memt, romh, suboffs + 0x14); 428 gftfb_disable_rom_internal(spc); 429 DPRINTF((" code %02x", tmp)); 430 431 switch (tmp) { 432 #ifdef __hppa__ 433 case 0x10: 434 if (selected == (bus_addr_t)-1) 435 selected = offs; 436 break; 437 #endif 438 #ifdef __i386__ 439 case 0x00: 440 if (selected == (bus_addr_t)-1) 441 selected = offs; 442 break; 443 #endif 444 default: 445 #ifdef GFTFB_DEBUG 446 DPRINTF((" (wrong architecture)")); 447 #endif 448 break; 449 } 450 DPRINTF(("%s\n", selected == offs ? " -> SELECTED" : "")); 451 } 452 453 if (selected == (bus_addr_t)-1) { 454 if (rc == 0) { 455 aprint_error_dev(sc->sc_dev, "found no ROM with " 456 "correct microcode architecture\n"); 457 rc = ENOEXEC; 458 } 459 goto fail; 460 } 461 462 /* 463 * Read the STI region BAR assignments. 464 */ 465 466 gftfb_enable_rom_internal(spc); 467 offs = selected + 468 (bus_addr_t)bus_space_read_2(pa->pa_memt, romh, selected + 0x0e); 469 for (i = 0; i < STI_REGION_MAX; i++) { 470 rc = gftfb_readbar(sc, pa, i, 471 bus_space_read_1(pa->pa_memt, romh, offs + i)); 472 if (rc != 0) 473 goto fail; 474 } 475 476 /* 477 * Find out where the STI ROM itself lies, and its size. 478 */ 479 480 offs = selected + 481 (bus_addr_t)bus_space_read_4(pa->pa_memt, romh, selected + 0x08); 482 stiromsize = (bus_addr_t)bus_space_read_4(pa->pa_memt, romh, 483 offs + 0x18); 484 stiromsize = le32toh(stiromsize); 485 gftfb_disable_rom_internal(spc); 486 487 /* 488 * Replace our mapping with a smaller mapping of only the area 489 * we are interested in. 490 */ 491 492 DPRINTF(("remapping rom @ %lx for %lx\n", 493 (long)(PCI_MAPREG_ROM_ADDR(address) + offs), (long)stiromsize)); 494 bus_space_unmap(pa->pa_memt, romh, romsize); 495 rc = bus_space_map(pa->pa_memt, PCI_MAPREG_ROM_ADDR(address) + offs, 496 stiromsize, 0, &spc->sc_romh); 497 if (rc != 0) { 498 aprint_error_dev(sc->sc_dev, "can't map STI ROM (%d)\n", 499 rc); 500 goto fail2; 501 } 502 gftfb_disable_rom_internal(spc); 503 sc->sc_flags &= ~STI_ROM_ENABLED; 504 505 return 0; 506 507 fail: 508 bus_space_unmap(pa->pa_memt, romh, romsize); 509 fail2: 510 gftfb_disable_rom_internal(spc); 511 512 return rc; 513 } 514 515 /* 516 * Decode a BAR register. 517 */ 518 int 519 gftfb_readbar(struct sti_softc *sc, struct pci_attach_args *pa, u_int region, 520 int bar) 521 { 522 bus_addr_t addr; 523 bus_size_t size; 524 uint32_t cf; 525 int rc; 526 527 if (bar == 0) { 528 sc->bases[region] = 0; 529 return (0); 530 } 531 532 #ifdef DIAGNOSTIC 533 if (bar < PCI_MAPREG_START || bar > PCI_MAPREG_PPB_END) { 534 gftfb_disable_rom(sc); 535 printf("%s: unexpected bar %02x for region %d\n", 536 device_xname(sc->sc_dev), bar, region); 537 gftfb_enable_rom(sc); 538 } 539 #endif 540 541 cf = pci_conf_read(pa->pa_pc, pa->pa_tag, bar); 542 543 rc = pci_mapreg_info(pa->pa_pc, pa->pa_tag, bar, PCI_MAPREG_TYPE(cf), 544 &addr, &size, NULL); 545 546 if (rc != 0) { 547 gftfb_disable_rom(sc); 548 aprint_error_dev(sc->sc_dev, "invalid bar %02x for region %d\n", 549 bar, region); 550 gftfb_enable_rom(sc); 551 return (rc); 552 } 553 554 sc->bases[region] = addr; 555 return (0); 556 } 557 558 /* 559 * Enable PCI ROM. 560 */ 561 void 562 gftfb_enable_rom_internal(struct gftfb_softc *spc) 563 { 564 pcireg_t address; 565 566 KASSERT(spc != NULL); 567 568 address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM); 569 address |= PCI_MAPREG_ROM_ENABLE; 570 pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address); 571 } 572 573 void 574 gftfb_enable_rom(struct sti_softc *sc) 575 { 576 struct gftfb_softc *spc = device_private(sc->sc_dev); 577 578 if (!ISSET(sc->sc_flags, STI_ROM_ENABLED)) { 579 gftfb_enable_rom_internal(spc); 580 } 581 SET(sc->sc_flags, STI_ROM_ENABLED); 582 } 583 584 /* 585 * Disable PCI ROM. 586 */ 587 void 588 gftfb_disable_rom_internal(struct gftfb_softc *spc) 589 { 590 pcireg_t address; 591 592 KASSERT(spc != NULL); 593 594 address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM); 595 address &= ~PCI_MAPREG_ROM_ENABLE; 596 pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address); 597 } 598 599 void 600 gftfb_disable_rom(struct sti_softc *sc) 601 { 602 struct gftfb_softc *spc = device_private(sc->sc_dev); 603 604 if (ISSET(sc->sc_flags, STI_ROM_ENABLED)) { 605 gftfb_disable_rom_internal(spc); 606 } 607 CLR(sc->sc_flags, STI_ROM_ENABLED); 608 } 609 610 static inline void 611 gftfb_wait(struct gftfb_softc *sc) 612 { 613 struct sti_rom *rom = sc->sc_base.sc_rom; 614 bus_space_tag_t memt = rom->memt; 615 bus_space_handle_t memh = rom->regh[2]; 616 uint8_t stat; 617 618 do { 619 stat = bus_space_read_1(memt, memh, NGLE_REG_15b0); 620 if (stat == 0) 621 stat = bus_space_read_1(memt, memh, NGLE_REG_15b0); 622 } while (stat != 0); 623 } 624 625 static inline void 626 gftfb_setup_fb(struct gftfb_softc *sc) 627 { 628 struct sti_rom *rom = sc->sc_base.sc_rom; 629 bus_space_tag_t memt = rom->memt; 630 bus_space_handle_t memh = rom->regh[2]; 631 632 gftfb_wait(sc); 633 bus_space_write_stream_4(memt, memh, NGLE_REG_10, 0x13601000); 634 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x83000300); 635 gftfb_wait(sc); 636 bus_space_write_1(memt, memh, NGLE_REG_16b1, 1); 637 sc->sc_hwmode = HW_FB; 638 } 639 640 void 641 gftfb_setup(struct gftfb_softc *sc) 642 { 643 struct sti_rom *rom = sc->sc_base.sc_rom; 644 bus_space_tag_t memt = rom->memt; 645 bus_space_handle_t memh = rom->regh[2]; 646 int i; 647 648 sc->sc_hwmode = HW_FB; 649 sc->sc_hot_x = 0; 650 sc->sc_hot_y = 0; 651 sc->sc_enabled = 0; 652 sc->sc_video_on = 1; 653 654 655 /* set Bt458 read mask register to all planes */ 656 gftfb_wait(sc); 657 ngle_bt458_write(memt, memh, 0x08, 0x04); 658 ngle_bt458_write(memt, memh, 0x0a, 0xff); 659 660 gftfb_setup_fb(sc); 661 662 /* attr. planes */ 663 gftfb_wait(sc); 664 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 0x2ea0d000); 665 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x23000302); 666 bus_space_write_stream_4(memt, memh, NGLE_REG_12, NGLE_ARTIST_CMAP0); 667 bus_space_write_stream_4(memt, memh, NGLE_REG_8, 0xffffffff); 668 669 gftfb_wait(sc); 670 bus_space_write_stream_4(memt, memh, NGLE_REG_6, 0x00000000); 671 bus_space_write_stream_4(memt, memh, NGLE_REG_9, 672 (sc->sc_scr.scr_cfg.scr_width << 16) | sc->sc_scr.scr_cfg.scr_height); 673 /* 674 * blit into offscreen memory to force flush previous - apparently 675 * some chips have a bug this works around 676 */ 677 bus_space_write_stream_4(memt, memh, NGLE_REG_6, 0x05000000); 678 bus_space_write_stream_4(memt, memh, NGLE_REG_9, 0x00040001); 679 680 gftfb_wait(sc); 681 bus_space_write_stream_4(memt, memh, NGLE_REG_12, 0x00000000); 682 683 gftfb_setup_fb(sc); 684 685 /* make sure video output is enabled */ 686 gftfb_wait(sc); 687 bus_space_write_stream_4(memt, memh, NGLE_REG_21, 688 bus_space_read_stream_4(memt, memh, NGLE_REG_21) | 0x0a000000); 689 bus_space_write_stream_4(memt, memh, NGLE_REG_27, 690 bus_space_read_stream_4(memt, memh, NGLE_REG_27) | 0x00800000); 691 692 /* initialize cursor sprite */ 693 gftfb_wait(sc); 694 695 /* cursor mask */ 696 gftfb_wait(sc); 697 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x300); 698 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 699 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 0x28A07000); 700 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 701 for (i = 0; i < 64; i++) { 702 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0xffffffff); 703 bus_space_write_stream_4(memt, memh, NGLE_REG_5, 0xffffffff); 704 } 705 706 /* cursor image */ 707 gftfb_wait(sc); 708 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x300); 709 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 710 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 0x28A06000); 711 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 712 for (i = 0; i < 64; i++) { 713 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0xff00ff00); 714 bus_space_write_stream_4(memt, memh, NGLE_REG_5, 0xff00ff00); 715 } 716 717 /* colour map */ 718 gftfb_wait(sc); 719 bus_space_write_stream_4(memt, memh, NGLE_REG_10, 0xBBE0F000); 720 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x03000300); 721 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 722 gftfb_wait(sc); 723 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 724 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0); 725 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0); 726 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0x000000ff); /* BG */ 727 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0x00ff0000); /* FG */ 728 gftfb_wait(sc); 729 bus_space_write_stream_4(memt, memh, NGLE_REG_2, 0); 730 bus_space_write_stream_4(memt, memh, NGLE_REG_26, 0x80008004); 731 gftfb_setup_fb(sc); 732 733 gftfb_move_cursor(sc, 100, 100); 734 735 } 736 737 static int 738 gftfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 739 struct lwp *l) 740 { 741 struct vcons_data *vd = v; 742 struct gftfb_softc *sc = vd->cookie; 743 struct wsdisplay_fbinfo *wdf; 744 struct vcons_screen *ms = vd->active; 745 746 switch (cmd) { 747 case WSDISPLAYIO_GTYPE: 748 *(u_int *)data = WSDISPLAY_TYPE_STI; 749 return 0; 750 751 case GCID: 752 *(u_int *)data = STI_DD_EG; 753 return 0; 754 755 /* PCI config read/write passthrough. */ 756 case PCI_IOC_CFGREAD: 757 case PCI_IOC_CFGWRITE: 758 return pci_devioctl(sc->sc_pc, sc->sc_tag, 759 cmd, data, flag, l); 760 761 case WSDISPLAYIO_GET_BUSID: 762 return wsdisplayio_busid_pci(sc->sc_dev, sc->sc_pc, 763 sc->sc_tag, data); 764 765 case WSDISPLAYIO_GINFO: 766 if (ms == NULL) 767 return ENODEV; 768 wdf = (void *)data; 769 wdf->height = ms->scr_ri.ri_height; 770 wdf->width = ms->scr_ri.ri_width; 771 wdf->depth = ms->scr_ri.ri_depth; 772 wdf->cmsize = 256; 773 return 0; 774 775 case WSDISPLAYIO_GETCMAP: 776 return gftfb_getcmap(sc, 777 (struct wsdisplay_cmap *)data); 778 779 case WSDISPLAYIO_PUTCMAP: 780 return gftfb_putcmap(sc, 781 (struct wsdisplay_cmap *)data); 782 783 case WSDISPLAYIO_LINEBYTES: 784 *(u_int *)data = 2048; 785 return 0; 786 787 case WSDISPLAYIO_SMODE: { 788 int new_mode = *(int*)data; 789 if (new_mode != sc->sc_mode) { 790 sc->sc_mode = new_mode; 791 if(new_mode == WSDISPLAYIO_MODE_EMUL) { 792 gftfb_setup(sc); 793 gftfb_restore_palette(sc); 794 glyphcache_wipe(&sc->sc_gc); 795 gftfb_rectfill(sc, 0, 0, sc->sc_width, 796 sc->sc_height, ms->scr_ri.ri_devcmap[ 797 (ms->scr_defattr >> 16) & 0xff]); 798 vcons_redraw_screen(ms); 799 gftfb_set_video(sc, 1); 800 } 801 } 802 } 803 return 0; 804 805 case WSDISPLAYIO_GET_FBINFO: 806 { 807 struct wsdisplayio_fbinfo *fbi = data; 808 int ret; 809 810 ret = wsdisplayio_get_fbinfo(&ms->scr_ri, fbi); 811 fbi->fbi_fbsize = sc->sc_scr.fbheight * 2048; 812 return ret; 813 } 814 815 case WSDISPLAYIO_GCURPOS: 816 { 817 struct wsdisplay_curpos *cp = (void *)data; 818 819 cp->x = sc->sc_cursor_x; 820 cp->y = sc->sc_cursor_y; 821 } 822 return 0; 823 824 case WSDISPLAYIO_SCURPOS: 825 { 826 struct wsdisplay_curpos *cp = (void *)data; 827 828 gftfb_move_cursor(sc, cp->x, cp->y); 829 } 830 return 0; 831 832 case WSDISPLAYIO_GCURMAX: 833 { 834 struct wsdisplay_curpos *cp = (void *)data; 835 836 cp->x = 64; 837 cp->y = 64; 838 } 839 return 0; 840 841 case WSDISPLAYIO_SCURSOR: 842 { 843 struct wsdisplay_cursor *cursor = (void *)data; 844 845 return gftfb_do_cursor(sc, cursor); 846 } 847 848 case WSDISPLAYIO_SVIDEO: 849 gftfb_set_video(sc, *(int *)data); 850 return 0; 851 case WSDISPLAYIO_GVIDEO: 852 *(u_int *)data = sc->sc_video_on ? 853 WSDISPLAYIO_VIDEO_ON : WSDISPLAYIO_VIDEO_OFF; 854 return 0; 855 } 856 return EPASSTHROUGH; 857 } 858 859 static paddr_t 860 gftfb_mmap(void *v, void *vs, off_t offset, int prot) 861 { 862 struct vcons_data *vd = v; 863 struct gftfb_softc *sc = vd->cookie; 864 struct sti_rom *rom = sc->sc_base.sc_rom; 865 paddr_t pa = -1; 866 867 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) 868 return -1; 869 870 if (offset >= 0 && offset < sc->sc_scr.fblen) { 871 /* framebuffer */ 872 pa = bus_space_mmap(rom->memt, sc->sc_scr.fbaddr, offset, 873 prot, BUS_SPACE_MAP_LINEAR); 874 } else if (offset >= 0x80000000 && offset < 0x8040000) { 875 /* blitter registers etc. */ 876 pa = bus_space_mmap(rom->memt, rom->regh[2], 877 offset - 0x80000000, prot, BUS_SPACE_MAP_LINEAR); 878 } 879 880 return pa; 881 } 882 883 static void 884 gftfb_init_screen(void *cookie, struct vcons_screen *scr, 885 int existing, long *defattr) 886 { 887 struct gftfb_softc *sc = cookie; 888 struct rasops_info *ri = &scr->scr_ri; 889 890 ri->ri_depth = 8; 891 ri->ri_width = sc->sc_width; 892 ri->ri_height = sc->sc_height; 893 ri->ri_stride = 2048; 894 ri->ri_flg = RI_CENTER | RI_8BIT_IS_RGB | 895 RI_ENABLE_ALPHA | RI_PREFER_ALPHA; 896 897 ri->ri_bits = (void *)sc->sc_scr.fbaddr; 898 rasops_init(ri, 0, 0); 899 ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE | 900 WSSCREEN_RESIZE; 901 scr->scr_flags |= VCONS_LOADFONT; 902 903 rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight, 904 sc->sc_width / ri->ri_font->fontwidth); 905 906 ri->ri_hw = scr; 907 sc->sc_putchar = ri->ri_ops.putchar; 908 ri->ri_ops.copyrows = gftfb_copyrows; 909 ri->ri_ops.copycols = gftfb_copycols; 910 ri->ri_ops.eraserows = gftfb_eraserows; 911 ri->ri_ops.erasecols = gftfb_erasecols; 912 ri->ri_ops.cursor = gftfb_cursor; 913 ri->ri_ops.putchar = gftfb_putchar; 914 } 915 916 static int 917 gftfb_putcmap(struct gftfb_softc *sc, struct wsdisplay_cmap *cm) 918 { 919 u_char *r, *g, *b; 920 u_int index = cm->index; 921 u_int count = cm->count; 922 int i, error; 923 u_char rbuf[256], gbuf[256], bbuf[256]; 924 925 if (cm->index >= 256 || cm->count > 256 || 926 (cm->index + cm->count) > 256) 927 return EINVAL; 928 error = copyin(cm->red, &rbuf[index], count); 929 if (error) 930 return error; 931 error = copyin(cm->green, &gbuf[index], count); 932 if (error) 933 return error; 934 error = copyin(cm->blue, &bbuf[index], count); 935 if (error) 936 return error; 937 938 memcpy(&sc->sc_cmap_red[index], &rbuf[index], count); 939 memcpy(&sc->sc_cmap_green[index], &gbuf[index], count); 940 memcpy(&sc->sc_cmap_blue[index], &bbuf[index], count); 941 942 r = &sc->sc_cmap_red[index]; 943 g = &sc->sc_cmap_green[index]; 944 b = &sc->sc_cmap_blue[index]; 945 946 for (i = 0; i < count; i++) { 947 gftfb_putpalreg(sc, index, *r, *g, *b); 948 index++; 949 r++, g++, b++; 950 } 951 return 0; 952 } 953 954 static int 955 gftfb_getcmap(struct gftfb_softc *sc, struct wsdisplay_cmap *cm) 956 { 957 u_int index = cm->index; 958 u_int count = cm->count; 959 int error; 960 961 if (index >= 255 || count > 256 || index + count > 256) 962 return EINVAL; 963 964 error = copyout(&sc->sc_cmap_red[index], cm->red, count); 965 if (error) 966 return error; 967 error = copyout(&sc->sc_cmap_green[index], cm->green, count); 968 if (error) 969 return error; 970 error = copyout(&sc->sc_cmap_blue[index], cm->blue, count); 971 if (error) 972 return error; 973 974 return 0; 975 } 976 977 static void 978 gftfb_restore_palette(struct gftfb_softc *sc) 979 { 980 uint8_t cmap[768]; 981 int i, j; 982 983 j = 0; 984 rasops_get_cmap(&sc->sc_console_screen.scr_ri, cmap, sizeof(cmap)); 985 for (i = 0; i < 256; i++) { 986 sc->sc_cmap_red[i] = cmap[j]; 987 sc->sc_cmap_green[i] = cmap[j + 1]; 988 sc->sc_cmap_blue[i] = cmap[j + 2]; 989 gftfb_putpalreg(sc, i, cmap[j], cmap[j + 1], cmap[j + 2]); 990 j += 3; 991 } 992 } 993 994 static int 995 gftfb_putpalreg(struct gftfb_softc *sc, uint8_t idx, uint8_t r, uint8_t g, 996 uint8_t b) 997 { 998 struct sti_rom *rom = sc->sc_base.sc_rom; 999 bus_space_tag_t memt = rom->memt; 1000 bus_space_handle_t memh = rom->regh[2]; 1001 1002 mutex_enter(&sc->sc_hwlock); 1003 gftfb_wait(sc); 1004 bus_space_write_stream_4(memt, memh, NGLE_REG_10, 0xbbe0f000); 1005 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x03000300); 1006 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 1007 1008 gftfb_wait(sc); 1009 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 1010 0x400 | (idx << 2)); 1011 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 1012 (r << 16) | (g << 8) | b); 1013 1014 bus_space_write_stream_4(memt, memh, NGLE_REG_2, 0x400); 1015 bus_space_write_stream_4(memt, memh, NGLE_REG_26, 0x80000100); 1016 gftfb_setup_fb(sc); 1017 mutex_exit(&sc->sc_hwlock); 1018 return 0; 1019 } 1020 1021 static inline void 1022 gftfb_wait_fifo(struct gftfb_softc *sc, uint32_t slots) 1023 { 1024 struct sti_rom *rom = sc->sc_base.sc_rom; 1025 bus_space_tag_t memt = rom->memt; 1026 bus_space_handle_t memh = rom->regh[2]; 1027 uint32_t reg; 1028 1029 do { 1030 reg = bus_space_read_stream_4(memt, memh, NGLE_REG_34); 1031 } while (reg < slots); 1032 } 1033 1034 static void 1035 gftfb_rectfill(struct gftfb_softc *sc, int x, int y, int wi, int he, 1036 uint32_t bg) 1037 { 1038 struct sti_rom *rom = sc->sc_base.sc_rom; 1039 bus_space_tag_t memt = rom->memt; 1040 bus_space_handle_t memh = rom->regh[2]; 1041 uint32_t mask = 0xffffffff; 1042 1043 if (sc->sc_hwmode != HW_FILL) { 1044 gftfb_wait_fifo(sc, 3); 1045 /* plane mask */ 1046 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xff); 1047 /* bitmap op */ 1048 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 1049 IBOvals(RopSrc, 0, BitmapExtent08, 0, DataDynamic, MaskOtc, 1, 0)); 1050 /* dst bitmap access */ 1051 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 1052 BA(IndexedDcd, Otc32, OtsIndirect, AddrLong, 0, BINapp0I, 0)); 1053 sc->sc_hwmode = HW_FILL; 1054 } 1055 gftfb_wait_fifo(sc, 4); 1056 1057 if (wi < 32) 1058 mask = 0xffffffff << (32 - wi); 1059 /* transfer data */ 1060 bus_space_write_stream_4(memt, memh, NGLE_REG_8, mask); 1061 bus_space_write_stream_4(memt, memh, NGLE_REG_35, bg); 1062 /* dst XY */ 1063 bus_space_write_stream_4(memt, memh, NGLE_REG_6, (x << 16) | y); 1064 /* len XY start */ 1065 bus_space_write_stream_4(memt, memh, NGLE_REG_9, (wi << 16) | he); 1066 1067 } 1068 1069 static void 1070 gftfb_bitblt(void *cookie, int xs, int ys, int xd, int yd, int wi, 1071 int he, int rop) 1072 { 1073 struct gftfb_softc *sc = cookie; 1074 struct sti_rom *rom = sc->sc_base.sc_rom; 1075 bus_space_tag_t memt = rom->memt; 1076 bus_space_handle_t memh = rom->regh[2]; 1077 1078 if (sc->sc_hwmode != HW_BLIT) { 1079 gftfb_wait(sc); 1080 bus_space_write_stream_4(memt, memh, NGLE_REG_10, 0x13a01000); 1081 sc->sc_hwmode = HW_BLIT; 1082 } 1083 gftfb_wait_fifo(sc, 5); 1084 bus_space_write_stream_4(memt, memh, NGLE_REG_14, ((rop << 8) & 0xf00) | 0x23000000); 1085 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xff); 1086 bus_space_write_stream_4(memt, memh, NGLE_REG_24, (xs << 16) | ys); 1087 bus_space_write_stream_4(memt, memh, NGLE_REG_7, (wi << 16) | he); 1088 bus_space_write_stream_4(memt, memh, NGLE_REG_25, (xd << 16) | yd); 1089 } 1090 1091 static void 1092 gftfb_nuke_cursor(struct rasops_info *ri) 1093 { 1094 struct vcons_screen *scr = ri->ri_hw; 1095 struct gftfb_softc *sc = scr->scr_cookie; 1096 int wi, he, x, y; 1097 1098 if (ri->ri_flg & RI_CURSOR) { 1099 wi = ri->ri_font->fontwidth; 1100 he = ri->ri_font->fontheight; 1101 x = ri->ri_ccol * wi + ri->ri_xorigin; 1102 y = ri->ri_crow * he + ri->ri_yorigin; 1103 gftfb_bitblt(sc, x, y, x, y, wi, he, RopInv); 1104 ri->ri_flg &= ~RI_CURSOR; 1105 } 1106 } 1107 1108 static void 1109 gftfb_cursor(void *cookie, int on, int row, int col) 1110 { 1111 struct rasops_info *ri = cookie; 1112 struct vcons_screen *scr = ri->ri_hw; 1113 struct gftfb_softc *sc = scr->scr_cookie; 1114 int x, y, wi, he; 1115 1116 wi = ri->ri_font->fontwidth; 1117 he = ri->ri_font->fontheight; 1118 1119 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 1120 if (on) { 1121 if (ri->ri_flg & RI_CURSOR) { 1122 gftfb_nuke_cursor(ri); 1123 } 1124 x = col * wi + ri->ri_xorigin; 1125 y = row * he + ri->ri_yorigin; 1126 gftfb_bitblt(sc, x, y, x, y, wi, he, RopInv); 1127 ri->ri_flg |= RI_CURSOR; 1128 } 1129 ri->ri_crow = row; 1130 ri->ri_ccol = col; 1131 } else 1132 { 1133 ri->ri_crow = row; 1134 ri->ri_ccol = col; 1135 ri->ri_flg &= ~RI_CURSOR; 1136 } 1137 1138 } 1139 1140 static void 1141 gftfb_putchar(void *cookie, int row, int col, u_int c, long attr) 1142 { 1143 struct rasops_info *ri = cookie; 1144 struct wsdisplay_font *font = PICK_FONT(ri, c); 1145 struct vcons_screen *scr = ri->ri_hw; 1146 struct gftfb_softc *sc = scr->scr_cookie; 1147 int x, y, wi, he, rv = GC_NOPE; 1148 uint32_t bg; 1149 1150 if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL) 1151 return; 1152 1153 if (!CHAR_IN_FONT(c, font)) 1154 return; 1155 1156 if (row == ri->ri_crow && col == ri->ri_ccol) { 1157 ri->ri_flg &= ~RI_CURSOR; 1158 } 1159 1160 wi = font->fontwidth; 1161 he = font->fontheight; 1162 1163 x = ri->ri_xorigin + col * wi; 1164 y = ri->ri_yorigin + row * he; 1165 1166 bg = ri->ri_devcmap[(attr >> 16) & 0xf]; 1167 1168 if (c == 0x20) { 1169 gftfb_rectfill(sc, x, y, wi, he, bg); 1170 return; 1171 } 1172 1173 rv = glyphcache_try(&sc->sc_gc, c, x, y, attr); 1174 if (rv == GC_OK) 1175 return; 1176 1177 if (sc->sc_hwmode != HW_FB) gftfb_setup_fb(sc); 1178 sc->sc_putchar(cookie, row, col, c, attr); 1179 1180 if (rv == GC_ADD) 1181 glyphcache_add(&sc->sc_gc, c, x, y); 1182 } 1183 1184 static void 1185 gftfb_copycols(void *cookie, int row, int srccol, int dstcol, int ncols) 1186 { 1187 struct rasops_info *ri = cookie; 1188 struct vcons_screen *scr = ri->ri_hw; 1189 struct gftfb_softc *sc = scr->scr_cookie; 1190 int32_t xs, xd, y, width, height; 1191 1192 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1193 if (ri->ri_crow == row && 1194 (ri->ri_ccol >= srccol && ri->ri_ccol < (srccol + ncols)) && 1195 (ri->ri_flg & RI_CURSOR)) { 1196 gftfb_nuke_cursor(ri); 1197 } 1198 1199 xs = ri->ri_xorigin + ri->ri_font->fontwidth * srccol; 1200 xd = ri->ri_xorigin + ri->ri_font->fontwidth * dstcol; 1201 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1202 width = ri->ri_font->fontwidth * ncols; 1203 height = ri->ri_font->fontheight; 1204 gftfb_bitblt(sc, xs, y, xd, y, width, height, RopSrc); 1205 if (ri->ri_crow == row && 1206 (ri->ri_ccol >= dstcol && ri->ri_ccol < (dstcol + ncols))) 1207 ri->ri_flg &= ~RI_CURSOR; 1208 } 1209 } 1210 1211 static void 1212 gftfb_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr) 1213 { 1214 struct rasops_info *ri = cookie; 1215 struct vcons_screen *scr = ri->ri_hw; 1216 struct gftfb_softc *sc = scr->scr_cookie; 1217 int32_t x, y, width, height, fg, bg, ul; 1218 1219 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1220 x = ri->ri_xorigin + ri->ri_font->fontwidth * startcol; 1221 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1222 width = ri->ri_font->fontwidth * ncols; 1223 height = ri->ri_font->fontheight; 1224 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 1225 1226 gftfb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]); 1227 if (ri->ri_crow == row && 1228 (ri->ri_ccol >= startcol && ri->ri_ccol < (startcol + ncols))) 1229 ri->ri_flg &= ~RI_CURSOR; 1230 } 1231 } 1232 1233 static void 1234 gftfb_copyrows(void *cookie, int srcrow, int dstrow, int nrows) 1235 { 1236 struct rasops_info *ri = cookie; 1237 struct vcons_screen *scr = ri->ri_hw; 1238 struct gftfb_softc *sc = scr->scr_cookie; 1239 int32_t x, ys, yd, width, height; 1240 1241 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1242 if ((ri->ri_crow >= srcrow && ri->ri_crow < (srcrow + nrows)) && 1243 (ri->ri_flg & RI_CURSOR)) { 1244 gftfb_nuke_cursor(ri); 1245 } 1246 x = ri->ri_xorigin; 1247 ys = ri->ri_yorigin + ri->ri_font->fontheight * srcrow; 1248 yd = ri->ri_yorigin + ri->ri_font->fontheight * dstrow; 1249 width = ri->ri_emuwidth; 1250 height = ri->ri_font->fontheight * nrows; 1251 gftfb_bitblt(sc, x, ys, x, yd, width, height, RopSrc); 1252 if (ri->ri_crow >= dstrow && ri->ri_crow < (dstrow + nrows)) 1253 ri->ri_flg &= ~RI_CURSOR; 1254 } 1255 } 1256 1257 static void 1258 gftfb_eraserows(void *cookie, int row, int nrows, long fillattr) 1259 { 1260 struct rasops_info *ri = cookie; 1261 struct vcons_screen *scr = ri->ri_hw; 1262 struct gftfb_softc *sc = scr->scr_cookie; 1263 int32_t x, y, width, height, fg, bg, ul; 1264 1265 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1266 x = ri->ri_xorigin; 1267 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1268 width = ri->ri_emuwidth; 1269 height = ri->ri_font->fontheight * nrows; 1270 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 1271 1272 gftfb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]); 1273 1274 if (ri->ri_crow >= row && ri->ri_crow < (row + nrows)) 1275 ri->ri_flg &= ~RI_CURSOR; 1276 } 1277 } 1278 1279 /* 1280 * cursor sprite handling 1281 * like most hw info, xf86 3.3 -> nglehdw.h was used as documentation 1282 * problem is, the PCI EG doesn't quite behave like an S9000_ID_ARTIST 1283 * the cursor position register bahaves like the one on HCRX while using 1284 * the same address as Artist, incuding the enable bit and weird handling 1285 * of negative coordinates. The rest of it, colour map, sprite image etc., 1286 * behave like Artist. 1287 */ 1288 1289 static void 1290 gftfb_move_cursor(struct gftfb_softc *sc, int x, int y) 1291 { 1292 struct sti_rom *rom = sc->sc_base.sc_rom; 1293 bus_space_tag_t memt = rom->memt; 1294 bus_space_handle_t memh = rom->regh[2]; 1295 uint32_t pos; 1296 1297 sc->sc_cursor_x = x; 1298 x -= sc->sc_hot_x; 1299 sc->sc_cursor_y = y; 1300 y -= sc->sc_hot_y; 1301 1302 if (x < 0) x = 0x1000 - x; 1303 if (y < 0) y = 0x1000 - y; 1304 pos = (x << 16) | y; 1305 if (sc->sc_enabled) pos |= 0x80000000; 1306 gftfb_wait(sc); 1307 bus_space_write_stream_4(memt, memh, NGLE_REG_17, pos); 1308 bus_space_write_stream_4(memt, memh, NGLE_REG_18, 0x80); 1309 } 1310 1311 static int 1312 gftfb_do_cursor(struct gftfb_softc *sc, struct wsdisplay_cursor *cur) 1313 { 1314 struct sti_rom *rom = sc->sc_base.sc_rom; 1315 bus_space_tag_t memt = rom->memt; 1316 bus_space_handle_t memh = rom->regh[2]; 1317 1318 if (cur->which & WSDISPLAY_CURSOR_DOCUR) { 1319 1320 sc->sc_enabled = cur->enable; 1321 cur->which |= WSDISPLAY_CURSOR_DOPOS; 1322 } 1323 if (cur->which & WSDISPLAY_CURSOR_DOHOT) { 1324 1325 sc->sc_hot_x = cur->hot.x; 1326 sc->sc_hot_y = cur->hot.y; 1327 cur->which |= WSDISPLAY_CURSOR_DOPOS; 1328 } 1329 if (cur->which & WSDISPLAY_CURSOR_DOPOS) { 1330 1331 gftfb_move_cursor(sc, cur->pos.x, cur->pos.y); 1332 } 1333 if (cur->which & WSDISPLAY_CURSOR_DOCMAP) { 1334 uint32_t rgb; 1335 uint8_t r[2], g[2], b[2]; 1336 1337 copyin(cur->cmap.blue, b, 2); 1338 copyin(cur->cmap.green, g, 2); 1339 copyin(cur->cmap.red, r, 2); 1340 mutex_enter(&sc->sc_hwlock); 1341 gftfb_wait(sc); 1342 bus_space_write_stream_4(memt, memh, NGLE_REG_10, 0xBBE0F000); 1343 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x03000300); 1344 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 1345 gftfb_wait(sc); 1346 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 1347 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0); 1348 bus_space_write_stream_4(memt, memh, NGLE_REG_4, 0); 1349 rgb = (r[0] << 16) | (g[0] << 8) | b[0]; 1350 bus_space_write_stream_4(memt, memh, NGLE_REG_4, rgb); /* BG */ 1351 rgb = (r[1] << 16) | (g[1] << 8) | b[1]; 1352 bus_space_write_stream_4(memt, memh, NGLE_REG_4, rgb); /* FG */ 1353 bus_space_write_stream_4(memt, memh, NGLE_REG_2, 0); 1354 bus_space_write_stream_4(memt, memh, NGLE_REG_26, 0x80008004); 1355 gftfb_setup_fb(sc); 1356 mutex_exit(&sc->sc_hwlock); 1357 1358 } 1359 if (cur->which & WSDISPLAY_CURSOR_DOSHAPE) { 1360 uint32_t buffer[128], latch, tmp; 1361 int i; 1362 1363 copyin(cur->mask, buffer, 512); 1364 gftfb_wait(sc); 1365 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x300); 1366 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 1367 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 0x28A07000); 1368 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 1369 for (i = 0; i < 128; i += 2) { 1370 latch = 0; 1371 tmp = buffer[i] & 0x80808080; 1372 latch |= tmp >> 7; 1373 tmp = buffer[i] & 0x40404040; 1374 latch |= tmp >> 5; 1375 tmp = buffer[i] & 0x20202020; 1376 latch |= tmp >> 3; 1377 tmp = buffer[i] & 0x10101010; 1378 latch |= tmp >> 1; 1379 tmp = buffer[i] & 0x08080808; 1380 latch |= tmp << 1; 1381 tmp = buffer[i] & 0x04040404; 1382 latch |= tmp << 3; 1383 tmp = buffer[i] & 0x02020202; 1384 latch |= tmp << 5; 1385 tmp = buffer[i] & 0x01010101; 1386 latch |= tmp << 7; 1387 bus_space_write_stream_4(memt, memh, NGLE_REG_4, latch); 1388 latch = 0; 1389 tmp = buffer[i + 1] & 0x80808080; 1390 latch |= tmp >> 7; 1391 tmp = buffer[i + 1] & 0x40404040; 1392 latch |= tmp >> 5; 1393 tmp = buffer[i + 1] & 0x20202020; 1394 latch |= tmp >> 3; 1395 tmp = buffer[i + 1] & 0x10101010; 1396 latch |= tmp >> 1; 1397 tmp = buffer[i + 1] & 0x08080808; 1398 latch |= tmp << 1; 1399 tmp = buffer[i + 1] & 0x04040404; 1400 latch |= tmp << 3; 1401 tmp = buffer[i + 1] & 0x02020202; 1402 latch |= tmp << 5; 1403 tmp = buffer[i + 1] & 0x01010101; 1404 latch |= tmp << 7; 1405 bus_space_write_stream_4(memt, memh, NGLE_REG_5, latch); 1406 } 1407 1408 copyin(cur->image, buffer, 512); 1409 gftfb_wait(sc); 1410 bus_space_write_stream_4(memt, memh, NGLE_REG_14, 0x300); 1411 bus_space_write_stream_4(memt, memh, NGLE_REG_13, 0xffffffff); 1412 bus_space_write_stream_4(memt, memh, NGLE_REG_11, 0x28A06000); 1413 bus_space_write_stream_4(memt, memh, NGLE_REG_3, 0); 1414 for (i = 0; i < 128; i += 2) { 1415 latch = 0; 1416 tmp = buffer[i] & 0x80808080; 1417 latch |= tmp >> 7; 1418 tmp = buffer[i] & 0x40404040; 1419 latch |= tmp >> 5; 1420 tmp = buffer[i] & 0x20202020; 1421 latch |= tmp >> 3; 1422 tmp = buffer[i] & 0x10101010; 1423 latch |= tmp >> 1; 1424 tmp = buffer[i] & 0x08080808; 1425 latch |= tmp << 1; 1426 tmp = buffer[i] & 0x04040404; 1427 latch |= tmp << 3; 1428 tmp = buffer[i] & 0x02020202; 1429 latch |= tmp << 5; 1430 tmp = buffer[i] & 0x01010101; 1431 latch |= tmp << 7; 1432 bus_space_write_stream_4(memt, memh, NGLE_REG_4, latch); 1433 latch = 0; 1434 tmp = buffer[i + 1] & 0x80808080; 1435 latch |= tmp >> 7; 1436 tmp = buffer[i + 1] & 0x40404040; 1437 latch |= tmp >> 5; 1438 tmp = buffer[i + 1] & 0x20202020; 1439 latch |= tmp >> 3; 1440 tmp = buffer[i + 1] & 0x10101010; 1441 latch |= tmp >> 1; 1442 tmp = buffer[i + 1] & 0x08080808; 1443 latch |= tmp << 1; 1444 tmp = buffer[i + 1] & 0x04040404; 1445 latch |= tmp << 3; 1446 tmp = buffer[i + 1] & 0x02020202; 1447 latch |= tmp << 5; 1448 tmp = buffer[i + 1] & 0x01010101; 1449 latch |= tmp << 7; 1450 bus_space_write_stream_4(memt, memh, NGLE_REG_5, latch); 1451 } 1452 gftfb_setup_fb(sc); 1453 } 1454 1455 return 0; 1456 } 1457 1458 static void 1459 gftfb_set_video(struct gftfb_softc *sc, int on) 1460 { 1461 struct sti_rom *rom = sc->sc_base.sc_rom; 1462 bus_space_tag_t memt = rom->memt; 1463 bus_space_handle_t memh = rom->regh[2]; 1464 1465 if (sc->sc_video_on == on) 1466 return; 1467 1468 sc->sc_video_on = on; 1469 1470 gftfb_wait(sc); 1471 if (on) { 1472 bus_space_write_stream_4(memt, memh, NGLE_REG_21, 1473 bus_space_read_stream_4(memt, memh, NGLE_REG_21) | 0x0a000000); 1474 bus_space_write_stream_4(memt, memh, NGLE_REG_27, 1475 bus_space_read_stream_4(memt, memh, NGLE_REG_27) | 0x00800000); 1476 } else { 1477 bus_space_write_stream_4(memt, memh, NGLE_REG_21, 1478 bus_space_read_stream_4(memt, memh, NGLE_REG_21) & ~0x0a000000); 1479 bus_space_write_stream_4(memt, memh, NGLE_REG_27, 1480 bus_space_read_stream_4(memt, memh, NGLE_REG_27) & ~0x00800000); 1481 } 1482 } 1483
Indexes created Thu Sep 25 16:09:42 GMT 2025