1 /* $NetBSD: voodoofb.c,v 1.56 2022/09/25 17:52:25 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 2005, 2006, 2012 Michael Lorenz 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 /* 29 * A console driver for 3Dfx Voodoo3 graphics boards 30 * Thanks to Andreas Drewke (andreas_dr@gmx.de) for his Voodoo3 driver for BeOS 31 * which I used as reference / documentation 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: voodoofb.c,v 1.56 2022/09/25 17:52:25 thorpej Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/kernel.h> 40 #include <sys/device.h> 41 #include <sys/callout.h> 42 #include <sys/kauth.h> 43 44 #include <dev/pci/pcivar.h> 45 #include <dev/pci/pcireg.h> 46 #include <dev/pci/pcidevs.h> 47 #include <dev/pci/pciio.h> 48 #include <dev/pci/voodoofbreg.h> 49 50 #include <dev/wscons/wsdisplayvar.h> 51 #include <dev/wscons/wsconsio.h> 52 #include <dev/wsfont/wsfont.h> 53 #include <dev/rasops/rasops.h> 54 #include <dev/wscons/wsdisplay_vconsvar.h> 55 #include <dev/pci/wsdisplay_pci.h> 56 57 #include <dev/i2c/i2cvar.h> 58 #include <dev/i2c/i2c_bitbang.h> 59 #include <dev/i2c/ddcvar.h> 60 #include <dev/videomode/videomode.h> 61 #include <dev/videomode/edidvar.h> 62 #include <dev/videomode/edidreg.h> 63 64 #include "opt_wsemul.h" 65 66 struct voodoofb_softc { 67 device_t sc_dev; 68 pci_chipset_tag_t sc_pc; 69 pcitag_t sc_pcitag; 70 struct pci_attach_args sc_pa; 71 72 bus_space_tag_t sc_memt; 73 bus_space_tag_t sc_iot; 74 bus_space_handle_t sc_memh; 75 76 bus_space_tag_t sc_regt; 77 bus_space_tag_t sc_ioregt; 78 bus_space_handle_t sc_regh; 79 bus_space_handle_t sc_ioregh; 80 bus_addr_t sc_regs, sc_fb, sc_ioreg; 81 bus_size_t sc_regsize, sc_fbsize, sc_ioregsize; 82 83 void *sc_ih; 84 85 #define MAX_CLOCK_VB 270000 /* Voodoo Banshee */ 86 #define MAX_CLOCK_V3 300000 /* Voodoo3 */ 87 #define MAX_CLOCK_V45 350000 /* Voodoo4/5 (not yet) */ 88 uint32_t sc_max_clock; 89 90 size_t sc_memsize; 91 int sc_memtype; 92 93 int sc_bits_per_pixel; 94 int sc_width, sc_height, sc_linebytes; 95 const struct videomode *sc_videomode; 96 int sc_is_mapped; 97 98 /* glyph cache */ 99 long sc_defattr, sc_kernattr; 100 uint32_t sc_glyphs_defattr[256]; 101 uint32_t sc_glyphs_kernattr[256]; 102 int sc_numglyphs, sc_usedglyphs; 103 uint32_t sc_cache; /* offset where cache starts */ 104 uint32_t sc_fmt; /* *fmt register */ 105 void *sc_font; 106 107 /* i2c stuff */ 108 struct i2c_controller sc_i2c; 109 uint8_t sc_edid_data[128]; 110 struct edid_info sc_edid_info; 111 uint32_t sc_i2creg; 112 113 int sc_mode; 114 uint32_t sc_bg; 115 116 u_char sc_cmap_red[256]; 117 u_char sc_cmap_green[256]; 118 u_char sc_cmap_blue[256]; 119 int sc_dacw; 120 121 struct vcons_data vd; 122 }; 123 124 struct voodoo_regs { 125 uint8_t vr_crtc[31]; 126 uint8_t vr_graph[9]; 127 uint8_t vr_attr[21]; 128 uint8_t vr_seq[5]; 129 }; 130 131 static struct vcons_screen voodoofb_console_screen; 132 133 static int voodoofb_match(device_t, cfdata_t, void *); 134 static void voodoofb_attach(device_t, device_t, void *); 135 136 static int voodoofb_drm_print(void *, const char *); 137 static int voodoofb_drm_unmap(struct voodoofb_softc *); 138 static int voodoofb_drm_map(struct voodoofb_softc *); 139 140 CFATTACH_DECL_NEW(voodoofb, sizeof(struct voodoofb_softc), voodoofb_match, 141 voodoofb_attach, NULL, NULL); 142 143 static bool voodoofb_is_console(struct voodoofb_softc *); 144 static void voodoofb_init(struct voodoofb_softc *); 145 146 static void voodoofb_cursor(void *, int, int, int); 147 static void voodoofb_putchar(void *, int, int, u_int, long); 148 static void voodoofb_putchar_aa(void *, int, int, u_int, long); 149 static void voodoofb_copycols(void *, int, int, int, int); 150 static void voodoofb_erasecols(void *, int, int, int, long); 151 static void voodoofb_copyrows(void *, int, int, int); 152 static void voodoofb_eraserows(void *, int, int, long); 153 154 #if 0 155 static int voodoofb_allocattr(void *, int, int, int, long *); 156 static void voodoofb_scroll(void *, void *, int); 157 static int voodoofb_load_font(void *, void *, struct wsdisplay_font *); 158 #endif 159 160 static int voodoofb_putcmap(struct voodoofb_softc *, 161 struct wsdisplay_cmap *); 162 static int voodoofb_getcmap(struct voodoofb_softc *, 163 struct wsdisplay_cmap *); 164 static int voodoofb_putpalreg(struct voodoofb_softc *, uint8_t, uint8_t, 165 uint8_t, uint8_t); 166 static void voodoofb_bitblt(struct voodoofb_softc *, int, int, int, int, 167 int, int); 168 static void voodoofb_rectfill(struct voodoofb_softc *, int, int, int, int, 169 int); 170 static void voodoofb_rectinvert(struct voodoofb_softc *, int, int, int, 171 int); 172 static void voodoofb_setup_mono(struct voodoofb_softc *, int, int, int, 173 int, uint32_t, uint32_t); 174 static void voodoofb_feed_line(struct voodoofb_softc *, int, uint8_t *); 175 176 static void voodoofb_wait_idle(struct voodoofb_softc *); 177 static void voodoofb_init_glyphcache(struct voodoofb_softc *, 178 struct rasops_info *); 179 180 #ifdef VOODOOFB_ENABLE_INTR 181 static int voodoofb_intr(void *); 182 #endif 183 184 static void voodoofb_set_videomode(struct voodoofb_softc *, 185 const struct videomode *); 186 187 struct wsscreen_descr voodoofb_defaultscreen = { 188 "default", 189 0, 0, 190 NULL, 191 8, 16, 192 WSSCREEN_WSCOLORS | WSSCREEN_HILIT, 193 NULL, 194 }; 195 196 const struct wsscreen_descr *_voodoofb_scrlist[] = { 197 &voodoofb_defaultscreen, 198 /* XXX other formats, graphics screen? */ 199 }; 200 201 struct wsscreen_list voodoofb_screenlist = { 202 sizeof(_voodoofb_scrlist) / sizeof(struct wsscreen_descr *), _voodoofb_scrlist 203 }; 204 205 static int voodoofb_ioctl(void *, void *, u_long, void *, int, 206 struct lwp *); 207 static paddr_t voodoofb_mmap(void *, void *, off_t, int); 208 209 static void voodoofb_clearscreen(struct voodoofb_softc *); 210 static void voodoofb_init_screen(void *, struct vcons_screen *, int, 211 long *); 212 213 214 struct wsdisplay_accessops voodoofb_accessops = { 215 voodoofb_ioctl, 216 voodoofb_mmap, 217 NULL, 218 NULL, 219 NULL, 220 NULL, /* load_font */ 221 NULL, /* polls */ 222 NULL, /* scroll */ 223 }; 224 225 /* I2C glue */ 226 static int voodoofb_i2c_send_start(void *, int); 227 static int voodoofb_i2c_send_stop(void *, int); 228 static int voodoofb_i2c_initiate_xfer(void *, i2c_addr_t, int); 229 static int voodoofb_i2c_read_byte(void *, uint8_t *, int); 230 static int voodoofb_i2c_write_byte(void *, uint8_t, int); 231 232 /* I2C bitbang glue */ 233 static void voodoofb_i2cbb_set_bits(void *, uint32_t); 234 static void voodoofb_i2cbb_set_dir(void *, uint32_t); 235 static uint32_t voodoofb_i2cbb_read(void *); 236 237 static void voodoofb_setup_i2c(struct voodoofb_softc *); 238 239 static const struct i2c_bitbang_ops voodoofb_i2cbb_ops = { 240 voodoofb_i2cbb_set_bits, 241 voodoofb_i2cbb_set_dir, 242 voodoofb_i2cbb_read, 243 { 244 VSP_SDA0_IN, 245 VSP_SCL0_IN, 246 0, 247 0 248 } 249 }; 250 251 extern const u_char rasops_cmap[768]; 252 253 /* 254 * Inline functions for getting access to register aperture. 255 */ 256 static inline void 257 voodoo3_write32(struct voodoofb_softc *sc, uint32_t reg, uint32_t val) 258 { 259 bus_space_write_4(sc->sc_regt, sc->sc_regh, reg, val); 260 } 261 262 static inline void 263 voodoo3_write32s(struct voodoofb_softc *sc, uint32_t reg, uint32_t val) 264 { 265 bus_space_write_stream_4(sc->sc_regt, sc->sc_regh, reg, val); 266 } 267 static inline uint32_t 268 voodoo3_read32(struct voodoofb_softc *sc, uint32_t reg) 269 { 270 return bus_space_read_4(sc->sc_regt, sc->sc_regh, reg); 271 } 272 273 static inline void 274 voodoo3_write_crtc(struct voodoofb_softc *sc, uint8_t reg, uint8_t val) 275 { 276 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, CRTC_INDEX - 0x300, reg); 277 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, CRTC_DATA - 0x300, val); 278 } 279 280 static inline void 281 voodoo3_write_seq(struct voodoofb_softc *sc, uint8_t reg, uint8_t val) 282 { 283 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, SEQ_INDEX - 0x300, reg); 284 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, SEQ_DATA - 0x300, val); 285 } 286 287 static inline void 288 voodoo3_write_gra(struct voodoofb_softc *sc, uint8_t reg, uint8_t val) 289 { 290 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, GRA_INDEX - 0x300, reg); 291 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, GRA_DATA - 0x300, val); 292 } 293 294 static inline void 295 voodoo3_write_attr(struct voodoofb_softc *sc, uint8_t reg, uint8_t val) 296 { 297 uint8_t index; 298 299 (void)bus_space_read_1(sc->sc_ioregt, sc->sc_ioregh, IS1_R - 0x300); 300 index = bus_space_read_1(sc->sc_ioregt, sc->sc_ioregh, ATT_IW - 0x300); 301 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, ATT_IW - 0x300, reg); 302 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, ATT_IW - 0x300, val); 303 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, ATT_IW - 0x300, index); 304 } 305 306 static inline void 307 vga_outb(struct voodoofb_softc *sc, uint32_t reg, uint8_t val) 308 { 309 bus_space_write_1(sc->sc_ioregt, sc->sc_ioregh, reg - 0x300, val); 310 } 311 312 /* wait until there's room for len bytes in the FIFO */ 313 static inline void 314 voodoo3_make_room(struct voodoofb_softc *sc, int len) 315 { 316 while ((voodoo3_read32(sc, STATUS) & 0x1f) < len); 317 } 318 319 static void 320 voodoofb_wait_idle(struct voodoofb_softc *sc) 321 { 322 int i = 0; 323 324 voodoo3_make_room(sc, 1); 325 voodoo3_write32(sc, COMMAND_3D, COMMAND_3D_NOP); 326 327 while (1) { 328 i = (voodoo3_read32(sc, STATUS) & STATUS_BUSY) ? 0 : i + 1; 329 if(i == 3) break; 330 } 331 } 332 333 static int 334 voodoofb_match(device_t parent, cfdata_t match, void *aux) 335 { 336 struct pci_attach_args *pa = (struct pci_attach_args *)aux; 337 338 if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY || 339 PCI_SUBCLASS(pa->pa_class) != PCI_SUBCLASS_DISPLAY_VGA) 340 return 0; 341 if ((PCI_VENDOR(pa->pa_id)==PCI_VENDOR_3DFX) && 342 (PCI_PRODUCT(pa->pa_id)>=PCI_PRODUCT_3DFX_VOODOO3)) 343 return 100; 344 345 if ((PCI_VENDOR(pa->pa_id)==PCI_VENDOR_3DFX) && 346 (PCI_PRODUCT(pa->pa_id)>=PCI_PRODUCT_3DFX_BANSHEE)) 347 return 100; 348 return 0; 349 } 350 351 static void 352 voodoofb_attach(device_t parent, device_t self, void *aux) 353 { 354 struct voodoofb_softc *sc = device_private(self); 355 struct pci_attach_args *pa = aux; 356 struct wsemuldisplaydev_attach_args aa; 357 struct rasops_info *ri; 358 #ifdef VOODOOFB_ENABLE_INTR 359 pci_intr_handle_t ih; 360 const char *intrstr; 361 #endif 362 ulong defattr; 363 int console, width, height, i; 364 prop_dictionary_t dict; 365 int linebytes, depth, flags; 366 uint32_t bg, fg, ul; 367 368 sc->sc_dev = self; 369 370 sc->sc_mode = WSDISPLAYIO_MODE_EMUL; 371 sc->sc_pc = pa->pa_pc; 372 sc->sc_pcitag = pa->pa_tag; 373 sc->sc_dacw = -1; 374 pci_aprint_devinfo(pa, NULL); 375 376 sc->sc_memt = pa->pa_memt; 377 sc->sc_iot = pa->pa_iot; 378 sc->sc_pa = *pa; 379 380 if (PCI_PRODUCT(pa->pa_id)>=PCI_PRODUCT_3DFX_BANSHEE) 381 sc->sc_max_clock = MAX_CLOCK_VB; 382 else 383 sc->sc_max_clock = MAX_CLOCK_V3; 384 385 /* the framebuffer */ 386 if (pci_mapreg_info(sc->sc_pc, sc->sc_pcitag, 0x14, 387 PCI_MAPREG_TYPE_MEM, &sc->sc_fb, &sc->sc_fbsize, &flags)) { 388 aprint_error_dev(self, "failed to map the frame buffer.\n"); 389 } 390 sc->sc_memsize = sc->sc_fbsize >> 1; /* VRAM aperture is 2x VRAM */ 391 392 /* memory-mapped registers */ 393 if (pci_mapreg_map(pa, 0x10, PCI_MAPREG_TYPE_MEM, 0, 394 &sc->sc_regt, &sc->sc_regh, &sc->sc_regs, &sc->sc_regsize)) { 395 aprint_error_dev(self, 396 "failed to map memory-mapped registers.\n"); 397 } 398 399 /* IO-mapped registers */ 400 if (pci_mapreg_map(pa, 0x18, PCI_MAPREG_TYPE_IO, 0, 401 &sc->sc_ioregt, &sc->sc_ioregh, &sc->sc_ioreg, 402 &sc->sc_ioregsize)) { 403 aprint_error_dev(self, "failed to map IO-mapped registers.\n"); 404 } 405 sc->sc_is_mapped = TRUE; 406 voodoofb_init(sc); 407 408 /* we should read these from the chip instead of depending on OF */ 409 width = height = -1; 410 411 dict = device_properties(self); 412 if (!prop_dictionary_get_uint32(dict, "width", &width)) { 413 aprint_error_dev(self, "no width property\n"); 414 return; 415 } 416 if (!prop_dictionary_get_uint32(dict, "height", &height)) { 417 aprint_error_dev(self, "no height property\n"); 418 return; 419 } 420 if (!prop_dictionary_get_uint32(dict, "depth", &depth)) { 421 aprint_error_dev(self, "no depth property\n"); 422 return; 423 } 424 linebytes = width; /* XXX */ 425 426 if (width == -1 || height == -1) 427 return; 428 429 sc->sc_width = width; 430 sc->sc_height = height; 431 sc->sc_bits_per_pixel = depth; 432 sc->sc_linebytes = linebytes; 433 printf("%s: initial resolution %dx%d, %d bit\n", device_xname(self), 434 sc->sc_width, sc->sc_height, sc->sc_bits_per_pixel); 435 436 sc->sc_videomode = NULL; 437 voodoofb_setup_i2c(sc); 438 439 /* XXX this should at least be configurable via kernel config */ 440 if (sc->sc_videomode == NULL) { 441 sc->sc_videomode = pick_mode_by_ref(width, height, 60); 442 } 443 444 voodoofb_set_videomode(sc, sc->sc_videomode); 445 446 sc->sc_font = NULL; 447 448 vcons_init(&sc->vd, sc, &voodoofb_defaultscreen, &voodoofb_accessops); 449 sc->vd.init_screen = voodoofb_init_screen; 450 451 console = voodoofb_is_console(sc); 452 453 ri = &voodoofb_console_screen.scr_ri; 454 if (console) { 455 vcons_init_screen(&sc->vd, &voodoofb_console_screen, 1, 456 &defattr); 457 voodoofb_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; 458 459 voodoofb_defaultscreen.textops = &ri->ri_ops; 460 voodoofb_defaultscreen.capabilities = ri->ri_caps; 461 voodoofb_defaultscreen.nrows = ri->ri_rows; 462 voodoofb_defaultscreen.ncols = ri->ri_cols; 463 wsdisplay_cnattach(&voodoofb_defaultscreen, ri, 0, 0, defattr); 464 } else { 465 if (voodoofb_console_screen.scr_ri.ri_rows == 0) { 466 /* do some minimal setup to avoid weirdnesses later */ 467 vcons_init_screen(&sc->vd, &voodoofb_console_screen, 468 1, &defattr); 469 } else 470 (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr); 471 } 472 473 printf("%s: %d MB aperture at 0x%08x, %d MB registers at 0x%08x\n", 474 device_xname(self), (u_int)(sc->sc_fbsize >> 20), 475 (u_int)sc->sc_fb, (u_int)(sc->sc_regsize >> 20), 476 (u_int)sc->sc_regs); 477 #ifdef VOODOOFB_DEBUG 478 printf("fb: %08lx\n", (ulong)ri->ri_bits); 479 #endif 480 481 if (sc->sc_bits_per_pixel == 8) { 482 uint8_t tmp; 483 for (i = 0; i < 256; i++) { 484 tmp = i & 0xe0; 485 /* 486 * replicate bits so 0xe0 maps to a red value of 0xff 487 * in order to make white look actually white 488 */ 489 tmp |= (tmp >> 3) | (tmp >> 6); 490 sc->sc_cmap_red[i] = tmp; 491 492 tmp = (i & 0x1c) << 3; 493 tmp |= (tmp >> 3) | (tmp >> 6); 494 sc->sc_cmap_green[i] = tmp; 495 496 tmp = (i & 0x03) << 6; 497 tmp |= tmp >> 2; 498 tmp |= tmp >> 4; 499 sc->sc_cmap_blue[i] = tmp; 500 501 voodoofb_putpalreg(sc, i, sc->sc_cmap_red[i], 502 sc->sc_cmap_green[i], sc->sc_cmap_blue[i]); 503 } 504 } else { 505 /* linear ramp */ 506 for (i = 0; i < 256; i++) { 507 sc->sc_cmap_red[i] = i; 508 sc->sc_cmap_green[i] = i; 509 sc->sc_cmap_blue[i] = i; 510 511 voodoofb_putpalreg(sc, i, sc->sc_cmap_red[i], 512 sc->sc_cmap_green[i], sc->sc_cmap_blue[i]); 513 } 514 } 515 516 #ifdef VOODOOFB_ENABLE_INTR 517 char intrbuf[PCI_INTRSTR_LEN]; 518 /* Interrupt. We don't use it for anything yet */ 519 if (pci_intr_map(pa, &ih)) { 520 aprint_error_dev(self, "failed to map interrupt\n"); 521 return; 522 } 523 524 intrstr = pci_intr_string(sc->sc_pc, ih, intrbuf, sizeof(intrbuf)); 525 sc->sc_ih = pci_intr_establish_xname(sc->sc_pc, ih, IPL_NET, 526 voodoofb_intr, sc, device_xname(self)); 527 if (sc->sc_ih == NULL) { 528 aprint_error_dev(self, "failed to establish interrupt"); 529 if (intrstr != NULL) 530 aprint_error(" at %s", intrstr); 531 aprint_error("\n"); 532 return; 533 } 534 aprint_normal_dev(self, "interrupting at %s\n", intrstr); 535 #endif 536 537 rasops_unpack_attr(defattr, &fg, &bg, &ul); 538 sc->sc_bg = ri->ri_devcmap[bg]; 539 voodoofb_clearscreen(sc); 540 541 if (console) 542 vcons_replay_msgbuf(&voodoofb_console_screen); 543 aa.console = console; 544 aa.scrdata = &voodoofb_screenlist; 545 aa.accessops = &voodoofb_accessops; 546 aa.accesscookie = &sc->vd; 547 548 config_found(self, &aa, wsemuldisplaydevprint, 549 CFARGS(.iattr = "wsemuldisplaydev")); 550 config_found(self, aux, voodoofb_drm_print, 551 CFARGS(.iattr = "drm")); 552 } 553 554 static int 555 voodoofb_drm_print(void *opaque, const char *pnp) 556 { 557 if (pnp) 558 aprint_normal("drm at %s", pnp); 559 560 return UNCONF; 561 } 562 563 static int 564 voodoofb_drm_unmap(struct voodoofb_softc *sc) 565 { 566 567 if (!sc->sc_is_mapped) 568 return 0; 569 570 printf("%s: releasing bus resources\n", device_xname(sc->sc_dev)); 571 572 bus_space_unmap(sc->sc_ioregt, sc->sc_ioregh, sc->sc_ioregsize); 573 bus_space_unmap(sc->sc_regt, sc->sc_regh, sc->sc_regsize); 574 575 sc->sc_is_mapped = FALSE; 576 577 return 0; 578 } 579 580 static int 581 voodoofb_drm_map(struct voodoofb_softc *sc) 582 { 583 584 if (sc->sc_is_mapped) 585 return 0; 586 587 /* memory-mapped registers */ 588 if (pci_mapreg_map(&sc->sc_pa, 0x10, PCI_MAPREG_TYPE_MEM, 0, 589 &sc->sc_regt, &sc->sc_regh, &sc->sc_regs, &sc->sc_regsize)) { 590 aprint_error_dev(sc->sc_dev, 591 "failed to map memory-mapped registers.\n"); 592 } 593 594 /* IO-mapped registers */ 595 if (pci_mapreg_map(&sc->sc_pa, 0x18, PCI_MAPREG_TYPE_IO, 0, 596 &sc->sc_ioregt, &sc->sc_ioregh, &sc->sc_ioreg, 597 &sc->sc_ioregsize)) { 598 aprint_error_dev(sc->sc_dev, 599 "failed to map IO-mapped registers.\n"); 600 } 601 602 sc->sc_is_mapped = TRUE; 603 604 voodoofb_init(sc); 605 /* XXX this should at least be configurable via kernel config */ 606 voodoofb_set_videomode(sc, sc->sc_videomode); 607 608 return 0; 609 } 610 611 static int 612 voodoofb_putpalreg(struct voodoofb_softc *sc, uint8_t index, uint8_t r, 613 uint8_t g, uint8_t b) 614 { 615 uint32_t color; 616 617 sc->sc_cmap_red[index] = r; 618 sc->sc_cmap_green[index] = g; 619 sc->sc_cmap_blue[index] = b; 620 621 color = (r << 16) | (g << 8) | b; 622 voodoo3_make_room(sc, 2); 623 voodoo3_write32(sc, DACADDR, index); 624 voodoo3_write32(sc, DACDATA, color); 625 626 return 0; 627 } 628 629 static int 630 voodoofb_putcmap(struct voodoofb_softc *sc, struct wsdisplay_cmap *cm) 631 { 632 u_char *r, *g, *b; 633 u_int index = cm->index; 634 u_int count = cm->count; 635 int i, error; 636 u_char rbuf[256], gbuf[256], bbuf[256]; 637 638 #ifdef VOODOOFB_DEBUG 639 printf("putcmap: %d %d\n",index, count); 640 #endif 641 if (cm->index >= 256 || cm->count > 256 || 642 (cm->index + cm->count) > 256) 643 return EINVAL; 644 error = copyin(cm->red, &rbuf[index], count); 645 if (error) 646 return error; 647 error = copyin(cm->green, &gbuf[index], count); 648 if (error) 649 return error; 650 error = copyin(cm->blue, &bbuf[index], count); 651 if (error) 652 return error; 653 654 memcpy(&sc->sc_cmap_red[index], &rbuf[index], count); 655 memcpy(&sc->sc_cmap_green[index], &gbuf[index], count); 656 memcpy(&sc->sc_cmap_blue[index], &bbuf[index], count); 657 658 r = &sc->sc_cmap_red[index]; 659 g = &sc->sc_cmap_green[index]; 660 b = &sc->sc_cmap_blue[index]; 661 662 for (i = 0; i < count; i++) { 663 voodoofb_putpalreg(sc, index, *r, *g, *b); 664 index++; 665 r++, g++, b++; 666 } 667 return 0; 668 } 669 670 static int 671 voodoofb_getcmap(struct voodoofb_softc *sc, struct wsdisplay_cmap *cm) 672 { 673 u_int index = cm->index; 674 u_int count = cm->count; 675 int error; 676 677 if (index >= 255 || count > 256 || index + count > 256) 678 return EINVAL; 679 680 error = copyout(&sc->sc_cmap_red[index], cm->red, count); 681 if (error) 682 return error; 683 error = copyout(&sc->sc_cmap_green[index], cm->green, count); 684 if (error) 685 return error; 686 error = copyout(&sc->sc_cmap_blue[index], cm->blue, count); 687 if (error) 688 return error; 689 690 return 0; 691 } 692 693 static bool 694 voodoofb_is_console(struct voodoofb_softc *sc) 695 { 696 prop_dictionary_t dict; 697 bool console = FALSE; 698 699 dict = device_properties(sc->sc_dev); 700 prop_dictionary_get_bool(dict, "is_console", &console); 701 return console; 702 } 703 704 static void 705 voodoofb_clearscreen(struct voodoofb_softc *sc) 706 { 707 voodoofb_rectfill(sc, 0, 0, sc->sc_width, sc->sc_height, sc->sc_bg); 708 } 709 710 /* 711 * wsdisplay_emulops 712 */ 713 714 static void 715 voodoofb_cursor(void *cookie, int on, int row, int col) 716 { 717 struct rasops_info *ri = cookie; 718 struct vcons_screen *scr = ri->ri_hw; 719 struct voodoofb_softc *sc = scr->scr_cookie; 720 int x, y, wi, he; 721 722 wi = ri->ri_font->fontwidth; 723 he = ri->ri_font->fontheight; 724 725 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 726 x = ri->ri_ccol * wi + ri->ri_xorigin; 727 y = ri->ri_crow * he + ri->ri_yorigin; 728 if (ri->ri_flg & RI_CURSOR) { 729 voodoofb_rectinvert(sc, x, y, wi, he); 730 ri->ri_flg &= ~RI_CURSOR; 731 } 732 ri->ri_crow = row; 733 ri->ri_ccol = col; 734 if (on) 735 { 736 x = ri->ri_ccol * wi + ri->ri_xorigin; 737 y = ri->ri_crow * he + ri->ri_yorigin; 738 voodoofb_rectinvert(sc, x, y, wi, he); 739 ri->ri_flg |= RI_CURSOR; 740 } 741 } else { 742 ri->ri_flg &= ~RI_CURSOR; 743 ri->ri_crow = row; 744 ri->ri_ccol = col; 745 } 746 } 747 748 #if 0 749 int 750 voodoofb_mapchar(void *cookie, int uni, u_int *index) 751 { 752 return 0; 753 } 754 #endif 755 756 static void 757 voodoofb_putchar(void *cookie, int row, int col, u_int c, long attr) 758 { 759 struct rasops_info *ri = cookie; 760 struct wsdisplay_font *font = PICK_FONT(ri, c); 761 struct vcons_screen *scr = ri->ri_hw; 762 struct voodoofb_softc *sc = scr->scr_cookie; 763 764 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 765 uint8_t *data; 766 int fg, bg, uc, i; 767 int x, y, wi, he; 768 769 wi = font->fontwidth; 770 he = font->fontheight; 771 772 if (!CHAR_IN_FONT(c, font)) 773 return; 774 bg = (u_char)ri->ri_devcmap[(attr >> 16) & 0xf]; 775 fg = (u_char)ri->ri_devcmap[(attr >> 24) & 0xf]; 776 x = ri->ri_xorigin + col * wi; 777 y = ri->ri_yorigin + row * he; 778 if (c == 0x20) { 779 voodoofb_rectfill(sc, x, y, wi, he, bg); 780 } else { 781 uc = c - font->firstchar; 782 data = (uint8_t *)font->data + uc * 783 ri->ri_fontscale; 784 voodoofb_setup_mono(sc, x, y, wi, he, fg, bg); 785 for (i = 0; i < he; i++) { 786 voodoofb_feed_line(sc, font->stride, data); 787 data += font->stride; 788 } 789 } 790 } 791 } 792 793 static void 794 voodoofb_putchar_aa(void *cookie, int row, int col, u_int c, long attr) 795 { 796 struct rasops_info *ri = cookie; 797 struct wsdisplay_font *font = PICK_FONT(ri, c); 798 struct vcons_screen *scr = ri->ri_hw; 799 struct voodoofb_softc *sc = scr->scr_cookie; 800 uint8_t *data; 801 uint32_t bg, latch = 0, bg8, fg8, pixel, save_offset = 0; 802 int i, x, y, wi, he, r, g, b, aval; 803 int r1, g1, b1, r0, g0, b0, fgo, bgo, j; 804 805 if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL) 806 return; 807 808 if (!CHAR_IN_FONT(c, font)) 809 return; 810 811 wi = font->fontwidth; 812 he = font->fontheight; 813 814 bg = ri->ri_devcmap[(attr >> 16) & 0xf]; 815 x = ri->ri_xorigin + col * wi; 816 y = ri->ri_yorigin + row * he; 817 if (c == 0x20) { 818 voodoofb_rectfill(sc, x, y, wi, he, bg); 819 return; 820 } 821 822 /* first, see if it's in the cache */ 823 if ((attr == sc->sc_defattr) && (c < 256)) { 824 uint32_t offset = sc->sc_glyphs_defattr[c]; 825 if (offset != 0) { 826 voodoo3_make_room(sc, 8); 827 voodoo3_write32(sc, SRCBASE, offset); 828 voodoo3_write32(sc, DSTBASE, 0); 829 voodoo3_write32(sc, SRCFORMAT, sc->sc_fmt); 830 voodoo3_write32(sc, DSTFORMAT, 831 sc->sc_linebytes | FMT_8BIT); 832 voodoo3_write32(sc, DSTSIZE, wi | (he << 16)); 833 voodoo3_write32(sc, DSTXY, x | (y << 16)); 834 voodoo3_write32(sc, SRCXY, 0); 835 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_S2S_BITBLT 836 | (ROP_COPY << 24) | SST_2D_GO); 837 return; 838 } else { 839 int slot = sc->sc_usedglyphs; 840 sc->sc_usedglyphs++; 841 save_offset = sc->sc_cache + (slot * ri->ri_fontscale); 842 sc->sc_glyphs_defattr[c] = save_offset; 843 } 844 } 845 data = WSFONT_GLYPH(c, font); 846 847 voodoo3_make_room(sc, 7); 848 voodoo3_write32(sc, DSTBASE, 0); 849 voodoo3_write32(sc, SRCFORMAT, FMT_8BIT | FMT_PAD_BYTE); 850 voodoo3_write32(sc, DSTFORMAT, sc->sc_linebytes | FMT_8BIT); 851 voodoo3_write32(sc, DSTSIZE, wi | (he << 16)); 852 voodoo3_write32(sc, DSTXY, x | (y << 16)); 853 voodoo3_write32(sc, SRCXY, 0); 854 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_H2S_BITBLT | 855 (ROP_COPY << 24) | SST_2D_GO); 856 857 /* 858 * we need the RGB colours here, so get offsets into rasops_cmap 859 */ 860 fgo = ((attr >> 24) & 0xf) * 3; 861 bgo = ((attr >> 16) & 0xf) * 3; 862 863 r0 = rasops_cmap[bgo]; 864 r1 = rasops_cmap[fgo]; 865 g0 = rasops_cmap[bgo + 1]; 866 g1 = rasops_cmap[fgo + 1]; 867 b0 = rasops_cmap[bgo + 2]; 868 b1 = rasops_cmap[fgo + 2]; 869 #define R3G3B2(r, g, b) ((r & 0xe0) | ((g >> 3) & 0x1c) | (b >> 6)) 870 bg8 = R3G3B2(r0, g0, b0); 871 fg8 = R3G3B2(r1, g1, b1); 872 voodoo3_make_room(sc, 15); 873 j = 15; 874 for (i = 0; i < ri->ri_fontscale; i++) { 875 aval = *data; 876 if (aval == 0) { 877 pixel = bg8; 878 } else if (aval == 255) { 879 pixel = fg8; 880 } else { 881 r = aval * r1 + (255 - aval) * r0; 882 g = aval * g1 + (255 - aval) * g0; 883 b = aval * b1 + (255 - aval) * b0; 884 pixel = ((r & 0xe000) >> 8) | 885 ((g & 0xe000) >> 11) | 886 ((b & 0xc000) >> 14); 887 } 888 latch = (latch << 8) | pixel; 889 /* write in 32bit chunks */ 890 if ((i & 3) == 3) { 891 voodoo3_write32s(sc, LAUNCH_2D, latch); 892 /* 893 * not strictly necessary, old data should be shifted 894 * out 895 */ 896 latch = 0; 897 /* 898 * check for pipeline space every now and then 899 * I don't think we can feed a Voodoo3 faster than it 900 * can process simple pixel data but I have been wrong 901 * about that before 902 */ 903 j--; 904 if (j == 0) { 905 voodoo3_make_room(sc, 15); 906 j = 15; 907 } 908 } 909 data++; 910 } 911 /* if we have pixels left in latch write them out */ 912 if ((i & 3) != 0) { 913 latch = latch << ((4 - (i & 3)) << 3); 914 voodoo3_write32s(sc, LAUNCH_2D, latch); 915 } 916 if (save_offset != 0) { 917 /* save the glyph we just drew */ 918 voodoo3_make_room(sc, 8); 919 voodoo3_write32(sc, SRCBASE, 0); 920 voodoo3_write32(sc, DSTBASE, save_offset); 921 voodoo3_write32(sc, SRCFORMAT, sc->sc_linebytes | FMT_8BIT); 922 voodoo3_write32(sc, DSTFORMAT, sc->sc_fmt); 923 voodoo3_write32(sc, DSTSIZE, wi | (he << 16)); 924 voodoo3_write32(sc, DSTXY, 0); 925 voodoo3_write32(sc, SRCXY, x | (y << 16)); 926 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_S2S_BITBLT | 927 (ROP_COPY << 24) | SST_2D_GO); 928 } 929 } 930 931 static void 932 voodoofb_copycols(void *cookie, int row, int srccol, int dstcol, int ncols) 933 { 934 struct rasops_info *ri = cookie; 935 struct vcons_screen *scr = ri->ri_hw; 936 struct voodoofb_softc *sc = scr->scr_cookie; 937 int32_t xs, xd, y, width, height; 938 939 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 940 xs = ri->ri_xorigin + ri->ri_font->fontwidth * srccol; 941 xd = ri->ri_xorigin + ri->ri_font->fontwidth * dstcol; 942 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 943 width = ri->ri_font->fontwidth * ncols; 944 height = ri->ri_font->fontheight; 945 voodoofb_bitblt(sc, xs, y, xd, y, width, height); 946 } 947 } 948 949 static void 950 voodoofb_erasecols(void *cookie, int row, int startcol, int ncols, 951 long fillattr) 952 { 953 struct rasops_info *ri = cookie; 954 struct vcons_screen *scr = ri->ri_hw; 955 struct voodoofb_softc *sc = scr->scr_cookie; 956 int32_t x, y, width, height, fg, bg, ul; 957 958 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 959 x = ri->ri_xorigin + ri->ri_font->fontwidth * startcol; 960 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 961 width = ri->ri_font->fontwidth * ncols; 962 height = ri->ri_font->fontheight; 963 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 964 965 voodoofb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]); 966 } 967 } 968 969 static void 970 voodoofb_copyrows(void *cookie, int srcrow, int dstrow, int nrows) 971 { 972 struct rasops_info *ri = cookie; 973 struct vcons_screen *scr = ri->ri_hw; 974 struct voodoofb_softc *sc = scr->scr_cookie; 975 int32_t x, ys, yd, width, height; 976 977 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 978 x = ri->ri_xorigin; 979 ys = ri->ri_yorigin + ri->ri_font->fontheight * srcrow; 980 yd = ri->ri_yorigin + ri->ri_font->fontheight * dstrow; 981 width = ri->ri_emuwidth; 982 height = ri->ri_font->fontheight * nrows; 983 voodoofb_bitblt(sc, x, ys, x, yd, width, height); 984 } 985 } 986 987 static void 988 voodoofb_eraserows(void *cookie, int row, int nrows, long fillattr) 989 { 990 struct rasops_info *ri = cookie; 991 struct vcons_screen *scr = ri->ri_hw; 992 struct voodoofb_softc *sc = scr->scr_cookie; 993 int32_t x, y, width, height, fg, bg, ul; 994 995 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 996 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 997 if ((row == 0) && (nrows == ri->ri_rows)) { 998 /* clear the whole screen */ 999 voodoofb_rectfill(sc, 0, 0, ri->ri_width, 1000 ri->ri_height, ri->ri_devcmap[bg]); 1001 } else { 1002 x = ri->ri_xorigin; 1003 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1004 width = ri->ri_emuwidth; 1005 height = ri->ri_font->fontheight * nrows; 1006 voodoofb_rectfill(sc, x, y, width, height, 1007 ri->ri_devcmap[bg]); 1008 } 1009 } 1010 } 1011 1012 static void 1013 voodoofb_bitblt(struct voodoofb_softc *sc, int xs, int ys, int xd, int yd, 1014 int width, int height) 1015 { 1016 uint32_t fmt, blitcmd; 1017 1018 fmt = sc->sc_linebytes | ((sc->sc_bits_per_pixel + 1019 ((sc->sc_bits_per_pixel == 8) ? 0 : 8)) << 13); 1020 blitcmd = COMMAND_2D_S2S_BITBLT | (ROP_COPY << 24); 1021 1022 if (xs <= xd) { 1023 blitcmd |= BIT(14); 1024 xs += (width - 1); 1025 xd += (width - 1); 1026 } 1027 if (ys <= yd) { 1028 blitcmd |= BIT(15); 1029 ys += (height - 1); 1030 yd += (height - 1); 1031 } 1032 voodoo3_make_room(sc, 8); 1033 1034 voodoo3_write32(sc, SRCBASE, 0); 1035 voodoo3_write32(sc, DSTBASE, 0); 1036 voodoo3_write32(sc, SRCFORMAT, fmt); 1037 voodoo3_write32(sc, DSTFORMAT, fmt); 1038 voodoo3_write32(sc, DSTSIZE, width | (height << 16)); 1039 voodoo3_write32(sc, DSTXY, xd | (yd << 16)); 1040 voodoo3_write32(sc, SRCXY, xs | (ys << 16)); 1041 voodoo3_write32(sc, COMMAND_2D, blitcmd | SST_2D_GO); 1042 } 1043 1044 static void 1045 voodoofb_rectfill(struct voodoofb_softc *sc, int x, int y, int width, 1046 int height, int colour) 1047 { 1048 uint32_t fmt; 1049 1050 fmt = sc->sc_linebytes | ((sc->sc_bits_per_pixel + 1051 ((sc->sc_bits_per_pixel == 8) ? 0 : 8)) << 13); 1052 1053 voodoo3_make_room(sc, 7); 1054 voodoo3_write32(sc, DSTFORMAT, fmt); 1055 voodoo3_write32(sc, DSTBASE, 0); 1056 voodoo3_write32(sc, COLORFORE, colour); 1057 voodoo3_write32(sc, COLORBACK, colour); 1058 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_FILLRECT | (ROP_COPY << 24)); 1059 voodoo3_write32(sc, DSTSIZE, width | (height << 16)); 1060 voodoo3_write32(sc, LAUNCH_2D, x | (y << 16)); 1061 } 1062 1063 static void 1064 voodoofb_rectinvert(struct voodoofb_softc *sc, int x, int y, int width, 1065 int height) 1066 { 1067 uint32_t fmt; 1068 1069 fmt = sc->sc_linebytes | ((sc->sc_bits_per_pixel + 1070 ((sc->sc_bits_per_pixel == 8) ? 0 : 8)) << 13); 1071 1072 voodoo3_make_room(sc, 8); 1073 voodoo3_write32(sc, SRCBASE, 0); 1074 voodoo3_write32(sc, DSTBASE, 0); 1075 voodoo3_write32(sc, DSTFORMAT, fmt); 1076 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_FILLRECT | 1077 (ROP_INVERT << 24)); 1078 voodoo3_write32(sc, DSTSIZE, width | (height << 16)); 1079 voodoo3_write32(sc, DSTXY, x | (y << 16)); 1080 voodoo3_write32(sc, LAUNCH_2D, x | (y << 16)); 1081 } 1082 1083 static void 1084 voodoofb_setup_mono(struct voodoofb_softc *sc, int xd, int yd, int width, 1085 int height, uint32_t fg, uint32_t bg) 1086 { 1087 uint32_t dfmt, sfmt = sc->sc_linebytes; 1088 1089 dfmt = sc->sc_linebytes | ((sc->sc_bits_per_pixel + 1090 ((sc->sc_bits_per_pixel == 8) ? 0 : 8)) << 13); 1091 1092 voodoo3_make_room(sc, 10); 1093 voodoo3_write32(sc, SRCFORMAT, sfmt); 1094 voodoo3_write32(sc, DSTFORMAT, dfmt); 1095 voodoo3_write32(sc, DSTBASE, 0); 1096 voodoo3_write32(sc, COLORFORE, fg); 1097 voodoo3_write32(sc, COLORBACK, bg); 1098 voodoo3_write32(sc, DSTSIZE, width | (height << 16)); 1099 voodoo3_write32(sc, DSTXY, xd | (yd << 16)); 1100 voodoo3_write32(sc, SRCXY, 0); 1101 voodoo3_write32(sc, COMMAND_2D, COMMAND_2D_H2S_BITBLT | 1102 (ROP_COPY << 24) | SST_2D_GO); 1103 1104 /* now feed the data into the chip */ 1105 } 1106 1107 static void 1108 voodoofb_feed_line(struct voodoofb_softc *sc, int count, uint8_t *data) 1109 { 1110 int i; 1111 uint32_t latch = 0, bork; 1112 int shift = 0; 1113 1114 voodoo3_make_room(sc, count); 1115 for (i = 0; i < count; i++) { 1116 bork = data[i]; 1117 latch |= (bork << shift); 1118 if (shift == 24) { 1119 voodoo3_write32(sc, LAUNCH_2D, latch); 1120 latch = 0; 1121 shift = 0; 1122 } else 1123 shift += 8; 1124 } 1125 if (shift != 24) 1126 voodoo3_write32(sc, LAUNCH_2D, latch); 1127 } 1128 1129 #if 0 1130 static int 1131 voodoofb_allocattr(void *cookie, int fg, int bg, int flags, long *attrp) 1132 { 1133 1134 return 0; 1135 } 1136 #endif 1137 1138 /* 1139 * wsdisplay_accessops 1140 */ 1141 1142 static int 1143 voodoofb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 1144 struct lwp *l) 1145 { 1146 struct vcons_data *vd = v; 1147 struct voodoofb_softc *sc = vd->cookie; 1148 struct wsdisplay_fbinfo *wdf; 1149 struct vcons_screen *ms = vd->active; 1150 1151 switch (cmd) { 1152 case WSDISPLAYIO_GTYPE: 1153 *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; 1154 return 0; 1155 1156 case WSDISPLAYIO_GINFO: 1157 wdf = (void *)data; 1158 wdf->height = ms->scr_ri.ri_height; 1159 wdf->width = ms->scr_ri.ri_width; 1160 wdf->depth = ms->scr_ri.ri_depth; 1161 wdf->cmsize = 256; 1162 return 0; 1163 1164 case WSDISPLAYIO_GETCMAP: 1165 return voodoofb_getcmap(sc, 1166 (struct wsdisplay_cmap *)data); 1167 1168 case WSDISPLAYIO_PUTCMAP: 1169 return voodoofb_putcmap(sc, 1170 (struct wsdisplay_cmap *)data); 1171 1172 /* PCI config read/write passthrough. */ 1173 case PCI_IOC_CFGREAD: 1174 case PCI_IOC_CFGWRITE: 1175 return pci_devioctl(sc->sc_pc, sc->sc_pcitag, 1176 cmd, data, flag, l); 1177 1178 case WSDISPLAYIO_GET_BUSID: 1179 return wsdisplayio_busid_pci(sc->sc_dev, sc->sc_pc, 1180 sc->sc_pcitag, data); 1181 1182 case WSDISPLAYIO_SMODE: { 1183 int new_mode = *(int*)data; 1184 if (new_mode != sc->sc_mode) { 1185 sc->sc_mode = new_mode; 1186 if (new_mode == WSDISPLAYIO_MODE_EMUL) { 1187 voodoofb_drm_map(sc); 1188 int i; 1189 1190 /* restore the palette */ 1191 for (i = 0; i < 256; i++) { 1192 voodoofb_putpalreg(sc, 1193 i, 1194 sc->sc_cmap_red[i], 1195 sc->sc_cmap_green[i], 1196 sc->sc_cmap_blue[i]); 1197 } 1198 1199 /* zap the glyph cache */ 1200 for (i = 0; i < 256; i++) { 1201 sc->sc_glyphs_defattr[i] = 0; 1202 sc->sc_glyphs_kernattr[i] = 0; 1203 } 1204 sc->sc_usedglyphs = 0; 1205 1206 voodoofb_clearscreen(sc); 1207 vcons_redraw_screen(ms); 1208 } else { 1209 voodoofb_drm_unmap(sc); 1210 } 1211 } 1212 } 1213 return 0; 1214 /* XXX WSDISPLAYIO_GET_EDID */ 1215 1216 case WSDISPLAYIO_GET_FBINFO: { 1217 struct wsdisplayio_fbinfo *fbi = data; 1218 return wsdisplayio_get_fbinfo(&ms->scr_ri, fbi); 1219 } 1220 } 1221 return EPASSTHROUGH; 1222 } 1223 1224 static paddr_t 1225 voodoofb_mmap(void *v, void *vs, off_t offset, int prot) 1226 { 1227 struct vcons_data *vd = v; 1228 struct voodoofb_softc *sc = vd->cookie; 1229 paddr_t pa; 1230 1231 /* 'regular' framebuffer mmap()ing */ 1232 if (sc->sc_mode == WSDISPLAYIO_MODE_DUMBFB) { 1233 if (offset < sc->sc_fbsize) { 1234 pa = bus_space_mmap(sc->sc_memt, sc->sc_fb, offset, 1235 prot, 1236 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE); 1237 return pa; 1238 } 1239 } else if (sc->sc_mode == WSDISPLAYIO_MODE_MAPPED) { 1240 1241 if (kauth_authorize_machdep(kauth_cred_get(), 1242 KAUTH_MACHDEP_UNMANAGEDMEM, NULL, NULL, NULL, NULL) != 0) { 1243 aprint_error_dev(sc->sc_dev, "mmap() rejected.\n"); 1244 return -1; 1245 } 1246 1247 if ((offset >= 0xa0000) && 1248 (offset < 0xb0000)) { 1249 pa = bus_space_mmap(sc->sc_memt, 1250 sc->sc_fb, offset - 0xa0000, 1251 prot, BUS_SPACE_MAP_LINEAR); 1252 return pa; 1253 } 1254 1255 if ((offset >= sc->sc_fb) && 1256 (offset < (sc->sc_fb + sc->sc_fbsize))) { 1257 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot, 1258 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE); 1259 return pa; 1260 } 1261 1262 if ((offset >= sc->sc_regs) && (offset < (sc->sc_regs + 1263 sc->sc_regsize))) { 1264 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot, 1265 BUS_SPACE_MAP_LINEAR); 1266 return pa; 1267 } 1268 1269 #ifdef PCI_MAGIC_IO_RANGE 1270 /* allow mapping of IO space */ 1271 if ((offset >= PCI_MAGIC_IO_RANGE) && 1272 (offset < PCI_MAGIC_IO_RANGE + 0x10000)) { 1273 pa = bus_space_mmap(sc->sc_iot, 1274 offset - PCI_MAGIC_IO_RANGE, 0, prot, 0); 1275 return pa; 1276 } 1277 #endif 1278 1279 #ifdef OFB_ALLOW_OTHERS 1280 if (offset >= 0x80000000) { 1281 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot, 1282 BUS_SPACE_MAP_LINEAR); 1283 return pa; 1284 } 1285 #endif 1286 } 1287 return -1; 1288 } 1289 1290 static void 1291 voodoofb_init_screen(void *cookie, struct vcons_screen *scr, 1292 int existing, long *defattr) 1293 { 1294 struct voodoofb_softc *sc = cookie; 1295 struct rasops_info *ri = &scr->scr_ri; 1296 1297 ri->ri_depth = sc->sc_bits_per_pixel; 1298 ri->ri_width = sc->sc_width; 1299 ri->ri_height = sc->sc_height; 1300 ri->ri_stride = sc->sc_linebytes; 1301 ri->ri_flg = RI_CENTER | RI_8BIT_IS_RGB | RI_ENABLE_ALPHA; 1302 1303 rasops_init(ri, 0, 0); 1304 ri->ri_caps = WSSCREEN_WSCOLORS; 1305 1306 rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight, 1307 sc->sc_width / ri->ri_font->fontwidth); 1308 1309 ri->ri_hw = scr; 1310 ri->ri_ops.copyrows = voodoofb_copyrows; 1311 ri->ri_ops.copycols = voodoofb_copycols; 1312 ri->ri_ops.eraserows = voodoofb_eraserows; 1313 ri->ri_ops.erasecols = voodoofb_erasecols; 1314 ri->ri_ops.cursor = voodoofb_cursor; 1315 if (FONT_IS_ALPHA(ri->ri_font)) { 1316 ri->ri_ops.putchar = voodoofb_putchar_aa; 1317 ri->ri_ops.allocattr(ri, WS_DEFAULT_FG, WS_DEFAULT_BG, 1318 0, &sc->sc_defattr); 1319 sc->sc_kernattr = (WS_KERNEL_FG << 24) | (WS_KERNEL_BG << 16); 1320 voodoofb_init_glyphcache(sc, ri); 1321 } else { 1322 ri->ri_ops.putchar = voodoofb_putchar; 1323 } 1324 } 1325 1326 #if 0 1327 int 1328 voodoofb_load_font(void *v, void *cookie, struct wsdisplay_font *data) 1329 { 1330 1331 return 0; 1332 } 1333 #endif 1334 1335 #ifdef VOODOOFB_ENABLE_INTR 1336 static int 1337 voodoofb_intr(void *arg) 1338 { 1339 struct voodoofb_softc *sc = arg; 1340 1341 voodoo3_write32(sc, V3_STATUS, 0); /* clear interrupts */ 1342 return 1; 1343 } 1344 #endif 1345 1346 /* video mode stuff */ 1347 1348 #define REFFREQ 14318 /* .18 */ 1349 1350 #define ABS(a) ((a < 0) ? -a : a) 1351 1352 static int 1353 voodoofb_calc_pll(int freq, int *f_out, int isBanshee) 1354 { 1355 int m, n, k, best_m, best_n, best_k, f_cur, best_error; 1356 int minm, maxm; 1357 1358 best_error = freq; 1359 best_n = best_m = best_k = 0; 1360 1361 if (isBanshee) { 1362 minm = 24; 1363 maxm = 24; 1364 } else { 1365 minm = 1; 1366 maxm = 57; 1367 /* This used to be 64, alas it seems the last 8 (funny that ?) 1368 * values cause jittering at lower resolutions. I've not done 1369 * any calculations to what the adjustment affects clock ranges, 1370 * but I can still run at 1600x1200@75Hz */ 1371 } 1372 for (n = 1; n < 256; n++) { 1373 f_cur = REFFREQ * (n + 2); 1374 if (f_cur < freq) { 1375 f_cur = f_cur / 3; 1376 if (freq - f_cur < best_error) { 1377 best_error = freq - f_cur; 1378 best_n = n; 1379 best_m = 1; 1380 best_k = 0; 1381 continue; 1382 } 1383 } 1384 for (m = minm; m < maxm; m++) { 1385 for (k = 0; k < 4; k++) { 1386 f_cur = REFFREQ * (n + 2) / (m + 2) / (1 << k); 1387 if (ABS(f_cur - freq) < best_error) { 1388 best_error = ABS(f_cur - freq); 1389 best_n = n; 1390 best_m = m; 1391 best_k = k; 1392 } 1393 } 1394 } 1395 } 1396 n = best_n; 1397 m = best_m; 1398 k = best_k; 1399 *f_out = REFFREQ * (n + 2) / (m + 2) / (1 << k); 1400 return ( n << 8) | (m << 2) | k; 1401 } 1402 1403 static void 1404 voodoofb_setup_monitor(struct voodoofb_softc *sc, const struct videomode *vm) 1405 { 1406 struct voodoo_regs mod; 1407 struct voodoo_regs *mode; 1408 uint32_t horizontal_display_end, horizontal_sync_start, 1409 horizontal_sync_end, horizontal_total, 1410 horizontal_blanking_start, horizontal_blanking_end; 1411 1412 uint32_t vertical_display_enable_end, vertical_sync_start, 1413 vertical_sync_end, vertical_total, vertical_blanking_start, 1414 vertical_blanking_end; 1415 1416 uint32_t wd; // CRTC offset 1417 1418 int i; 1419 1420 uint8_t misc; 1421 1422 memset(&mod, 0, sizeof(mod)); 1423 1424 mode = &mod; 1425 1426 wd = (vm->hdisplay >> 3) - 1; 1427 horizontal_display_end = (vm->hdisplay >> 3) - 1; 1428 horizontal_sync_start = (vm->hsync_start >> 3) - 1; 1429 horizontal_sync_end = (vm->hsync_end >> 3) - 1; 1430 horizontal_total = (vm->htotal >> 3) - 1; 1431 horizontal_blanking_start = horizontal_display_end; 1432 horizontal_blanking_end = horizontal_total; 1433 1434 vertical_display_enable_end = vm->vdisplay - 1; 1435 vertical_sync_start = vm->vsync_start; // - 1; 1436 vertical_sync_end = vm->vsync_end; // - 1; 1437 vertical_total = vm->vtotal - 2; 1438 vertical_blanking_start = vertical_display_enable_end; 1439 vertical_blanking_end = vertical_total; 1440 1441 #if 0 1442 misc = 0x0f | 1443 (vm->hdisplay < 400 ? 0xa0 : 1444 vm->hdisplay < 480 ? 0x60 : 1445 vm->hdisplay < 768 ? 0xe0 : 0x20); 1446 #else 1447 misc = 0x2f; 1448 if (vm->flags & VID_NHSYNC) 1449 misc |= HSYNC_NEG; 1450 if (vm->flags & VID_NVSYNC) 1451 misc |= VSYNC_NEG; 1452 #ifdef VOODOOFB_DEBUG 1453 printf("misc: %02x\n", misc); 1454 #endif 1455 #endif 1456 mode->vr_seq[0] = 3; 1457 mode->vr_seq[1] = 1; 1458 mode->vr_seq[2] = 8; 1459 mode->vr_seq[3] = 0; 1460 mode->vr_seq[4] = 6; 1461 1462 /* crtc regs start */ 1463 mode->vr_crtc[0] = horizontal_total - 4; 1464 mode->vr_crtc[1] = horizontal_display_end; 1465 mode->vr_crtc[2] = horizontal_blanking_start; 1466 mode->vr_crtc[3] = 0x80 | (horizontal_blanking_end & 0x1f); 1467 mode->vr_crtc[4] = horizontal_sync_start; 1468 1469 mode->vr_crtc[5] = ((horizontal_blanking_end & 0x20) << 2) | 1470 (horizontal_sync_end & 0x1f); 1471 mode->vr_crtc[6] = vertical_total; 1472 mode->vr_crtc[7] = ((vertical_sync_start & 0x200) >> 2) | 1473 ((vertical_display_enable_end & 0x200) >> 3) | 1474 ((vertical_total & 0x200) >> 4) | 1475 0x10 | 1476 ((vertical_blanking_start & 0x100) >> 5) | 1477 ((vertical_sync_start & 0x100) >> 6) | 1478 ((vertical_display_enable_end & 0x100) >> 7) | 1479 ((vertical_total & 0x100) >> 8); 1480 1481 mode->vr_crtc[8] = 0; 1482 mode->vr_crtc[9] = 0x40 | 1483 ((vertical_blanking_start & 0x200) >> 4); 1484 1485 mode->vr_crtc[10] = 0; 1486 mode->vr_crtc[11] = 0; 1487 mode->vr_crtc[12] = 0; 1488 mode->vr_crtc[13] = 0; 1489 mode->vr_crtc[14] = 0; 1490 mode->vr_crtc[15] = 0; 1491 1492 mode->vr_crtc[16] = vertical_sync_start; 1493 mode->vr_crtc[17] = (vertical_sync_end & 0x0f) | 0x20; 1494 mode->vr_crtc[18] = vertical_display_enable_end; 1495 mode->vr_crtc[19] = wd; // CRTC offset 1496 mode->vr_crtc[20] = 0; 1497 mode->vr_crtc[21] = vertical_blanking_start; 1498 mode->vr_crtc[22] = vertical_blanking_end + 1; 1499 mode->vr_crtc[23] = 128; 1500 mode->vr_crtc[24] = 255; 1501 1502 /* overflow registers */ 1503 mode->vr_crtc[CRTC_HDISP_EXT] = 1504 (horizontal_total&0x100) >> 8 | 1505 (horizontal_display_end & 0x100) >> 6 | 1506 (horizontal_blanking_start & 0x100) >> 4 | 1507 (horizontal_blanking_end & 0x40) >> 1 | 1508 (horizontal_sync_start & 0x100) >> 2 | 1509 (horizontal_sync_end & 0x20) << 2; 1510 1511 mode->vr_crtc[CRTC_VDISP_EXT] = 1512 (vertical_total & 0x400) >> 10 | 1513 (vertical_display_enable_end & 0x400) >> 8 | /* the manual is contradictory here */ 1514 (vertical_blanking_start & 0x400) >> 6 | 1515 (vertical_blanking_end & 0x400) >> 4; 1516 1517 /* attr regs start */ 1518 mode->vr_attr[0] = 0; 1519 mode->vr_attr[1] = 0; 1520 mode->vr_attr[2] = 0; 1521 mode->vr_attr[3] = 0; 1522 mode->vr_attr[4] = 0; 1523 mode->vr_attr[5] = 0; 1524 mode->vr_attr[6] = 0; 1525 mode->vr_attr[7] = 0; 1526 mode->vr_attr[8] = 0; 1527 mode->vr_attr[9] = 0; 1528 mode->vr_attr[10] = 0; 1529 mode->vr_attr[11] = 0; 1530 mode->vr_attr[12] = 0; 1531 mode->vr_attr[13] = 0; 1532 mode->vr_attr[14] = 0; 1533 mode->vr_attr[15] = 0; 1534 mode->vr_attr[16] = 1; 1535 mode->vr_attr[17] = 0; 1536 mode->vr_attr[18] = 15; 1537 mode->vr_attr[19] = 0; 1538 /* attr regs end */ 1539 1540 /* graph regs start */ 1541 mode->vr_graph[0] = 159; 1542 mode->vr_graph[1] = 127; 1543 mode->vr_graph[2] = 127; 1544 mode->vr_graph[3] = 131; 1545 mode->vr_graph[4] = 130; 1546 mode->vr_graph[5] = 142; 1547 mode->vr_graph[6] = 30; 1548 mode->vr_graph[7] = 245; 1549 mode->vr_graph[8] = 0; 1550 1551 vga_outb(sc, MISC_W, misc | 0x01); 1552 1553 for(i = 0; i < 5; i++) 1554 voodoo3_write_seq(sc, i, mode->vr_seq[i]); 1555 for (i = 0; i < CRTC_PCI_READBACK; i ++) 1556 voodoo3_write_crtc(sc, i, mode->vr_crtc[i]); 1557 for (i = 0; i < 0x14; i ++) 1558 voodoo3_write_attr(sc, i, mode->vr_attr[i]); 1559 for (i = 0; i < 0x09; i ++) 1560 voodoo3_write_gra(sc, i, mode->vr_graph[i]); 1561 } 1562 1563 static void 1564 voodoofb_set_videomode(struct voodoofb_softc *sc, 1565 const struct videomode *vm) 1566 { 1567 uint32_t miscinit0 = 0; 1568 int vidpll, fout; 1569 uint32_t vidproc = VIDPROCDEFAULT; 1570 uint32_t bpp = 1; /* for now */ 1571 uint32_t bytes_per_row = vm->hdisplay * bpp; 1572 1573 sc->sc_bits_per_pixel = bpp << 3; 1574 sc->sc_width = vm->hdisplay; 1575 sc->sc_height = vm->vdisplay; 1576 sc->sc_linebytes = bytes_per_row; 1577 1578 voodoofb_setup_monitor(sc, vm); 1579 1580 vidproc &= ~(0x1c0000); /* clear bits 18 to 20, bpp in vidproccfg */ 1581 /* enable bits 18 to 20 to the required bpp */ 1582 vidproc |= ((bpp - 1) << VIDCFG_PIXFMT_SHIFT); 1583 1584 vidpll = voodoofb_calc_pll(vm->dot_clock, &fout, 0); 1585 1586 #ifdef VOODOOFB_DEBUG 1587 uint32_t vp; 1588 vp = voodoo3_read32(sc, VIDPROCCFG); 1589 printf("old vidproc: %08x\n", vp); 1590 printf("pll: %08x %d\n", vidpll, fout); 1591 #endif 1592 /* bit 10 of vidproccfg, is enabled or disabled as needed */ 1593 switch (bpp) { 1594 case 1: 1595 /* 1596 * bit 10 off for palettized modes only, off means 1597 * palette is used 1598 */ 1599 vidproc &= ~(1 << 10); 1600 break; 1601 #if 0 1602 case 2: 1603 #if __POWERPC__ 1604 miscinit0 = 0xc0000000; 1605 #endif 1606 /* bypass palette for 16bit modes */ 1607 vidproc |= (1 << 10); 1608 break; 1609 case 4: 1610 #if __POWERPC__ 1611 miscinit0 = 0x40000000; 1612 #endif 1613 vidproc |= (1 << 10); /* Same for 32bit modes */ 1614 break; 1615 #endif 1616 default: 1617 printf("We support only 8 bit for now\n"); 1618 return; 1619 } 1620 1621 voodoofb_wait_idle(sc); 1622 1623 voodoo3_write32(sc, MISCINIT1, voodoo3_read32(sc, MISCINIT1) | 0x01); 1624 1625 voodoo3_make_room(sc, 4); 1626 voodoo3_write32(sc, VGAINIT0, 4928); 1627 voodoo3_write32(sc, DACMODE, 0); 1628 voodoo3_write32(sc, VIDDESKSTRIDE, bytes_per_row); 1629 voodoo3_write32(sc, PLLCTRL0, vidpll); 1630 1631 voodoo3_make_room(sc, 5); 1632 voodoo3_write32(sc, VIDSCREENSIZE, sc->sc_width | 1633 (sc->sc_height << 12)); 1634 voodoo3_write32(sc, VIDDESKSTART, 0); 1635 1636 vidproc &= ~VIDCFG_HWCURSOR_ENABLE; 1637 voodoo3_write32(sc, VIDPROCCFG, vidproc); 1638 1639 voodoo3_write32(sc, VGAINIT1, 0); 1640 voodoo3_write32(sc, MISCINIT0, miscinit0); 1641 #ifdef VOODOOFB_DEBUG 1642 printf("vidproc: %08x\n", vidproc); 1643 #endif 1644 voodoo3_make_room(sc, 8); 1645 voodoo3_write32(sc, SRCBASE, 0); 1646 voodoo3_write32(sc, DSTBASE, 0); 1647 voodoo3_write32(sc, COMMANDEXTRA_2D, 0); 1648 voodoo3_write32(sc, CLIP0MIN, 0); 1649 voodoo3_write32(sc, CLIP0MAX, 0x0fff0fff); 1650 voodoo3_write32(sc, CLIP1MIN, 0); 1651 voodoo3_write32(sc, CLIP1MAX, 0x0fff0fff); 1652 voodoo3_write32(sc, SRCXY, 0); 1653 voodoofb_wait_idle(sc); 1654 printf("%s: switched to %dx%d, %d bit\n", device_xname(sc->sc_dev), 1655 sc->sc_width, sc->sc_height, sc->sc_bits_per_pixel); 1656 sc->sc_numglyphs = 0; /* invalidate the glyph cache */ 1657 } 1658 1659 static void 1660 voodoofb_init(struct voodoofb_softc *sc) 1661 { 1662 /* XXX */ 1663 uint32_t vgainit0 = 0; 1664 uint32_t vidcfg = 0; 1665 1666 #ifdef VOODOOFB_DEBUG 1667 printf("initializing engine..."); 1668 #endif 1669 vgainit0 = voodoo3_read32(sc, VGAINIT0); 1670 #ifdef VOODOOFB_DEBUG 1671 printf("vga: %08x", vgainit0); 1672 #endif 1673 vgainit0 |= 1674 VGAINIT0_8BIT_DAC | 1675 VGAINIT0_EXT_ENABLE | 1676 VGAINIT0_WAKEUP_3C3 | 1677 VGAINIT0_ALT_READBACK | 1678 VGAINIT0_EXTSHIFTOUT; 1679 1680 vidcfg = voodoo3_read32(sc, VIDPROCCFG); 1681 #ifdef VOODOOFB_DEBUG 1682 printf(" vidcfg: %08x\n", vidcfg); 1683 #endif 1684 vidcfg |= 1685 VIDCFG_VIDPROC_ENABLE | 1686 VIDCFG_DESK_ENABLE; 1687 vidcfg &= ~VIDCFG_HWCURSOR_ENABLE; 1688 1689 voodoo3_make_room(sc, 2); 1690 1691 voodoo3_write32(sc, VGAINIT0, vgainit0); 1692 voodoo3_write32(sc, VIDPROCCFG, vidcfg); 1693 1694 voodoo3_make_room(sc, 8); 1695 voodoo3_write32(sc, SRCBASE, 0); 1696 voodoo3_write32(sc, DSTBASE, 0); 1697 voodoo3_write32(sc, COMMANDEXTRA_2D, 0); 1698 voodoo3_write32(sc, CLIP0MIN, 0); 1699 voodoo3_write32(sc, CLIP0MAX, 0x1fff1fff); 1700 voodoo3_write32(sc, CLIP1MIN, 0); 1701 voodoo3_write32(sc, CLIP1MAX, 0x1fff1fff); 1702 voodoo3_write32(sc, SRCXY, 0); 1703 1704 voodoofb_wait_idle(sc); 1705 } 1706 1707 #define MAX_HRES 1700 /* 1708 * XXX in theory we can go higher but I 1709 * couldn't get anything above 1680 x 1200 1710 * to work, so until I find out why, it's 1711 * disabled so people won't end up with a 1712 * blank screen 1713 */ 1714 #define MODE_IS_VALID(m, mclk) (((m)->dot_clock <= (mclk)) && \ 1715 ((m)->hdisplay < MAX_HRES)) 1716 static void 1717 voodoofb_setup_i2c(struct voodoofb_softc *sc) 1718 { 1719 int i; 1720 1721 /* Fill in the i2c tag */ 1722 iic_tag_init(&sc->sc_i2c); 1723 sc->sc_i2c.ic_cookie = sc; 1724 sc->sc_i2c.ic_send_start = voodoofb_i2c_send_start; 1725 sc->sc_i2c.ic_send_stop = voodoofb_i2c_send_stop; 1726 sc->sc_i2c.ic_initiate_xfer = voodoofb_i2c_initiate_xfer; 1727 sc->sc_i2c.ic_read_byte = voodoofb_i2c_read_byte; 1728 sc->sc_i2c.ic_write_byte = voodoofb_i2c_write_byte; 1729 1730 sc->sc_i2creg = voodoo3_read32(sc, VIDSERPARPORT); 1731 #ifdef VOODOOFB_DEBUG 1732 printf("data: %08x\n", sc->sc_i2creg); 1733 #endif 1734 sc->sc_i2creg |= VSP_ENABLE_IIC0; 1735 sc->sc_i2creg &= ~(VSP_SDA0_OUT | VSP_SCL0_OUT); 1736 voodoo3_write32(sc, VIDSERPARPORT, sc->sc_i2creg); 1737 1738 /* zero out the EDID buffer */ 1739 memset(sc->sc_edid_data, 0, 128); 1740 1741 /* Some monitors don't respond first time */ 1742 i = 0; 1743 while (sc->sc_edid_data[1] == 0 && i++ < 3) 1744 ddc_read_edid(&sc->sc_i2c, sc->sc_edid_data, 128); 1745 if (i < 3) { 1746 if (edid_parse(sc->sc_edid_data, &sc->sc_edid_info) != -1) { 1747 #ifdef VOODOOFB_DEBUG 1748 edid_print(&sc->sc_edid_info); 1749 #endif 1750 /* 1751 * Now pick a mode. 1752 * How do we know our max. pixel clock? 1753 * All Voodoo3 should support at least 250MHz. 1754 * All Voodoo3 I've seen so far have at least 8MB 1755 * which we're not going to exhaust either in 8bit. 1756 */ 1757 if ((sc->sc_edid_info.edid_preferred_mode != NULL)) { 1758 struct videomode *m = 1759 sc->sc_edid_info.edid_preferred_mode; 1760 if (MODE_IS_VALID(m, sc->sc_max_clock)) { 1761 sc->sc_videomode = m; 1762 } else { 1763 aprint_error_dev(sc->sc_dev, 1764 "unable to use preferred mode\n"); 1765 } 1766 } 1767 /* 1768 * if we can't use the preferred mode go look for the 1769 * best one we can support 1770 */ 1771 if (sc->sc_videomode == NULL) { 1772 int n = 0; 1773 struct videomode *m = 1774 sc->sc_edid_info.edid_modes; 1775 1776 sort_modes(sc->sc_edid_info.edid_modes, 1777 &sc->sc_edid_info.edid_preferred_mode, 1778 sc->sc_edid_info.edid_nmodes); 1779 while ((sc->sc_videomode == NULL) && 1780 (n < sc->sc_edid_info.edid_nmodes)) { 1781 if (MODE_IS_VALID(&m[n], 1782 sc->sc_max_clock)) { 1783 sc->sc_videomode = &m[n]; 1784 } 1785 n++; 1786 } 1787 } 1788 } 1789 } 1790 } 1791 1792 /* I2C bitbanging */ 1793 static void voodoofb_i2cbb_set_bits(void *cookie, uint32_t bits) 1794 { 1795 struct voodoofb_softc *sc = cookie; 1796 uint32_t out; 1797 1798 out = bits >> 2; /* bitmasks match the IN bits */ 1799 1800 voodoo3_write32(sc, VIDSERPARPORT, sc->sc_i2creg | out); 1801 } 1802 1803 static void voodoofb_i2cbb_set_dir(void *cookie, uint32_t dir) 1804 { 1805 /* Nothing to do */ 1806 } 1807 1808 static uint32_t voodoofb_i2cbb_read(void *cookie) 1809 { 1810 struct voodoofb_softc *sc = cookie; 1811 uint32_t bits; 1812 1813 bits = voodoo3_read32(sc, VIDSERPARPORT); 1814 1815 return bits; 1816 } 1817 1818 /* higher level I2C stuff */ 1819 static int 1820 voodoofb_i2c_send_start(void *cookie, int flags) 1821 { 1822 return (i2c_bitbang_send_start(cookie, flags, &voodoofb_i2cbb_ops)); 1823 } 1824 1825 static int 1826 voodoofb_i2c_send_stop(void *cookie, int flags) 1827 { 1828 1829 return (i2c_bitbang_send_stop(cookie, flags, &voodoofb_i2cbb_ops)); 1830 } 1831 1832 static int 1833 voodoofb_i2c_initiate_xfer(void *cookie, i2c_addr_t addr, int flags) 1834 { 1835 1836 return (i2c_bitbang_initiate_xfer(cookie, addr, flags, 1837 &voodoofb_i2cbb_ops)); 1838 } 1839 1840 static int 1841 voodoofb_i2c_read_byte(void *cookie, uint8_t *valp, int flags) 1842 { 1843 return (i2c_bitbang_read_byte(cookie, valp, flags, &voodoofb_i2cbb_ops)); 1844 } 1845 1846 static int 1847 voodoofb_i2c_write_byte(void *cookie, uint8_t val, int flags) 1848 { 1849 return (i2c_bitbang_write_byte(cookie, val, flags, &voodoofb_i2cbb_ops)); 1850 } 1851 1852 /* glyph cache */ 1853 static void 1854 voodoofb_init_glyphcache(struct voodoofb_softc *sc, struct rasops_info *ri) 1855 { 1856 int bufsize, i; 1857 1858 if (sc->sc_numglyphs != 0) { 1859 /* re-initialize */ 1860 if (ri->ri_font == sc->sc_font) { 1861 /* nothing to do, keep using the same cache */ 1862 return; 1863 } 1864 } 1865 sc->sc_cache = (ri->ri_width * ri->ri_stride + 3) & 0xfffffffc; 1866 bufsize = sc->sc_memsize - sc->sc_cache; 1867 sc->sc_numglyphs = bufsize / ri->ri_fontscale; 1868 sc->sc_usedglyphs = 0; 1869 for (i = 0; i < 256; i++) { 1870 sc->sc_glyphs_kernattr[i] = 0; 1871 sc->sc_glyphs_defattr[i] = 0; 1872 } 1873 sc->sc_fmt = ri->ri_font->fontwidth | FMT_8BIT; 1874 } 1875