pm2fb.c revision 1.27
1 /* $NetBSD: pm2fb.c,v 1.27 2014/12/17 16:50:08 macallan Exp $ */ 2 3 /* 4 * Copyright (c) 2009, 2012 Michael Lorenz 5 * 2014 Naruaki Etomi 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * A console driver for Permedia 2 graphics controllers 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: pm2fb.c,v 1.27 2014/12/17 16:50:08 macallan Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/device.h> 40 #include <sys/malloc.h> 41 #include <sys/lwp.h> 42 #include <sys/kauth.h> 43 #include <sys/atomic.h> 44 45 #include <dev/videomode/videomode.h> 46 47 #include <dev/pci/pcivar.h> 48 #include <dev/pci/pcireg.h> 49 #include <dev/pci/pcidevs.h> 50 #include <dev/pci/pciio.h> 51 #include <dev/pci/pm2reg.h> 52 53 #include <dev/wscons/wsdisplayvar.h> 54 #include <dev/wscons/wsconsio.h> 55 #include <dev/wsfont/wsfont.h> 56 #include <dev/rasops/rasops.h> 57 #include <dev/wscons/wsdisplay_vconsvar.h> 58 #include <dev/wscons/wsdisplay_glyphcachevar.h> 59 #include <dev/pci/wsdisplay_pci.h> 60 61 #include <dev/i2c/i2cvar.h> 62 #include <dev/i2c/i2c_bitbang.h> 63 #include <dev/i2c/ddcvar.h> 64 #include <dev/videomode/videomode.h> 65 #include <dev/videomode/edidvar.h> 66 #include <dev/videomode/edidreg.h> 67 68 #include "opt_pm2fb.h" 69 70 #ifdef PM2FB_DEBUG 71 #define DPRINTF aprint_error 72 #else 73 #define DPRINTF while (0) printf 74 #endif 75 76 #if BYTE_ORDER == LITTLE_ENDIAN 77 /* 78 * XXX 79 * A temporary workaround for unaligned blits on little endian hardware. 80 * This makes pm2fb_bitblt() work well on little endian hardware to get 81 * scrolling right, but not much more. Unaligned blits ( as in, where the lower 82 * 2 bits of the source and destination X coordinates don't match ) are still 83 * wrong so the glyph cache is also disabled. 84 */ 85 #define BITBLT_LE_WORKAROUND 86 #endif 87 88 struct pm2fb_softc { 89 device_t sc_dev; 90 91 pci_chipset_tag_t sc_pc; 92 pcitag_t sc_pcitag; 93 94 bus_space_tag_t sc_memt; 95 bus_space_tag_t sc_iot; 96 97 bus_space_handle_t sc_regh; 98 bus_addr_t sc_fb, sc_reg; 99 bus_size_t sc_fbsize, sc_regsize; 100 101 int sc_width, sc_height, sc_depth, sc_stride; 102 int sc_locked; 103 struct vcons_screen sc_console_screen; 104 struct wsscreen_descr sc_defaultscreen_descr; 105 const struct wsscreen_descr *sc_screens[1]; 106 struct wsscreen_list sc_screenlist; 107 struct vcons_data vd; 108 int sc_mode; 109 u_char sc_cmap_red[256]; 110 u_char sc_cmap_green[256]; 111 u_char sc_cmap_blue[256]; 112 /* engine stuff */ 113 uint32_t sc_pprod; 114 int sc_is_pm2; 115 /* i2c stuff */ 116 struct i2c_controller sc_i2c; 117 uint8_t sc_edid_data[128]; 118 struct edid_info sc_ei; 119 const struct videomode *sc_videomode; 120 glyphcache sc_gc; 121 }; 122 123 static int pm2fb_match(device_t, cfdata_t, void *); 124 static void pm2fb_attach(device_t, device_t, void *); 125 126 CFATTACH_DECL_NEW(pm2fb, sizeof(struct pm2fb_softc), 127 pm2fb_match, pm2fb_attach, NULL, NULL); 128 129 extern const u_char rasops_cmap[768]; 130 131 static int pm2fb_ioctl(void *, void *, u_long, void *, int, 132 struct lwp *); 133 static paddr_t pm2fb_mmap(void *, void *, off_t, int); 134 static void pm2fb_init_screen(void *, struct vcons_screen *, int, long *); 135 136 static int pm2fb_putcmap(struct pm2fb_softc *, struct wsdisplay_cmap *); 137 static int pm2fb_getcmap(struct pm2fb_softc *, struct wsdisplay_cmap *); 138 static void pm2fb_init_palette(struct pm2fb_softc *); 139 static int pm2fb_putpalreg(struct pm2fb_softc *, uint8_t, uint8_t, 140 uint8_t, uint8_t); 141 142 static void pm2fb_init(struct pm2fb_softc *); 143 static inline void pm2fb_wait(struct pm2fb_softc *, int); 144 static void pm2fb_flush_engine(struct pm2fb_softc *); 145 static void pm2fb_rectfill(struct pm2fb_softc *, int, int, int, int, 146 uint32_t); 147 static void pm2fb_rectfill_a(void *, int, int, int, int, long); 148 static void pm2fb_bitblt(void *, int, int, int, int, int, int, int); 149 150 static void pm2fb_cursor(void *, int, int, int); 151 static void pm2fb_putchar(void *, int, int, u_int, long); 152 static void pm2fb_putchar_aa(void *, int, int, u_int, long); 153 static void pm2fb_copycols(void *, int, int, int, int); 154 static void pm2fb_erasecols(void *, int, int, int, long); 155 static void pm2fb_copyrows(void *, int, int, int); 156 static void pm2fb_eraserows(void *, int, int, long); 157 158 struct wsdisplay_accessops pm2fb_accessops = { 159 pm2fb_ioctl, 160 pm2fb_mmap, 161 NULL, /* alloc_screen */ 162 NULL, /* free_screen */ 163 NULL, /* show_screen */ 164 NULL, /* load_font */ 165 NULL, /* pollc */ 166 NULL /* scroll */ 167 }; 168 169 /* I2C glue */ 170 static int pm2fb_i2c_acquire_bus(void *, int); 171 static void pm2fb_i2c_release_bus(void *, int); 172 static int pm2fb_i2c_send_start(void *, int); 173 static int pm2fb_i2c_send_stop(void *, int); 174 static int pm2fb_i2c_initiate_xfer(void *, i2c_addr_t, int); 175 static int pm2fb_i2c_read_byte(void *, uint8_t *, int); 176 static int pm2fb_i2c_write_byte(void *, uint8_t, int); 177 178 /* I2C bitbang glue */ 179 static void pm2fb_i2cbb_set_bits(void *, uint32_t); 180 static void pm2fb_i2cbb_set_dir(void *, uint32_t); 181 static uint32_t pm2fb_i2cbb_read(void *); 182 183 static void pm2_setup_i2c(struct pm2fb_softc *); 184 185 static const struct i2c_bitbang_ops pm2fb_i2cbb_ops = { 186 pm2fb_i2cbb_set_bits, 187 pm2fb_i2cbb_set_dir, 188 pm2fb_i2cbb_read, 189 { 190 PM2_DD_SDA_IN, 191 PM2_DD_SCL_IN, 192 0, 193 0 194 } 195 }; 196 197 /* mode setting stuff */ 198 static int pm2fb_set_pll(struct pm2fb_softc *, int); 199 static int pm2vfb_set_pll(struct pm2fb_softc *, int); 200 static uint8_t pm2fb_read_dac(struct pm2fb_softc *, int); 201 static void pm2fb_write_dac(struct pm2fb_softc *, int, uint8_t); 202 static void pm2fb_set_mode(struct pm2fb_softc *, const struct videomode *); 203 204 const struct { 205 int vendor; 206 int product; 207 int flags; 208 } pm2fb_pci_devices[] = { 209 { 210 PCI_VENDOR_3DLABS, 211 PCI_PRODUCT_3DLABS_PERMEDIA2V, 212 0 213 }, 214 { 215 PCI_VENDOR_TI, 216 PCI_PRODUCT_TI_TVP4020, 217 1 218 }, 219 { 220 0, 221 0, 222 0 223 } 224 }; 225 226 /* this table is from xf86-video-glint */ 227 #define PARTPROD(a,b,c) (((a)<<6) | ((b)<<3) | (c)) 228 int partprodPermedia[] = { 229 -1, 230 PARTPROD(0,0,1), PARTPROD(0,1,1), PARTPROD(1,1,1), PARTPROD(1,1,2), 231 PARTPROD(1,2,2), PARTPROD(2,2,2), PARTPROD(1,2,3), PARTPROD(2,2,3), 232 PARTPROD(1,3,3), PARTPROD(2,3,3), PARTPROD(1,2,4), PARTPROD(3,3,3), 233 PARTPROD(1,3,4), PARTPROD(2,3,4), -1, PARTPROD(3,3,4), 234 PARTPROD(1,4,4), PARTPROD(2,4,4), -1, PARTPROD(3,4,4), 235 -1, PARTPROD(2,3,5), -1, PARTPROD(4,4,4), 236 PARTPROD(1,4,5), PARTPROD(2,4,5), PARTPROD(3,4,5), -1, 237 -1, -1, -1, PARTPROD(4,4,5), 238 PARTPROD(1,5,5), PARTPROD(2,5,5), -1, PARTPROD(3,5,5), 239 -1, -1, -1, PARTPROD(4,5,5), 240 -1, -1, -1, PARTPROD(3,4,6), 241 -1, -1, -1, PARTPROD(5,5,5), 242 PARTPROD(1,5,6), PARTPROD(2,5,6), -1, PARTPROD(3,5,6), 243 -1, -1, -1, PARTPROD(4,5,6), 244 -1, -1, -1, -1, 245 -1, -1, -1, PARTPROD(5,5,6), 246 -1, -1, -1, -1, 247 -1, -1, -1, -1, 248 -1, -1, -1, -1, 249 -1, -1, -1, -1, 250 -1, -1, -1, -1, 251 -1, -1, -1, -1, 252 -1, -1, -1, -1, 253 -1, -1, -1, -1, 254 -1, -1, -1, -1, 255 -1, -1, -1, -1, 256 -1, -1, -1, -1, 257 -1, -1, -1, -1, 258 -1, -1, -1, -1, 259 -1, -1, -1, -1, 260 -1, -1, -1, -1, 261 -1, -1, -1, -1, 262 0}; 263 264 static inline void 265 pm2fb_wait(struct pm2fb_softc *sc, int slots) 266 { 267 uint32_t reg; 268 269 do { 270 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, 271 PM2_INPUT_FIFO_SPACE); 272 } while (reg <= slots); 273 } 274 275 static void 276 pm2fb_flush_engine(struct pm2fb_softc *sc) 277 { 278 279 pm2fb_wait(sc, 2); 280 281 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_FILTER_MODE, 282 PM2FLT_PASS_SYNC); 283 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SYNC, 0); 284 do { 285 while (bus_space_read_4(sc->sc_memt, sc->sc_regh, 286 PM2_OUTPUT_FIFO_WORDS) == 0); 287 } while (bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_OUTPUT_FIFO) != 288 PM2_SYNC_TAG); 289 } 290 291 static int 292 pm2fb_match(device_t parent, cfdata_t match, void *aux) 293 { 294 struct pci_attach_args *pa = (struct pci_attach_args *)aux; 295 int i; 296 297 if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY) 298 return 0; 299 300 for (i = 0; pm2fb_pci_devices[i].vendor; i++) { 301 if ((PCI_VENDOR(pa->pa_id) == pm2fb_pci_devices[i].vendor && 302 PCI_PRODUCT(pa->pa_id) == pm2fb_pci_devices[i].product)) 303 return 100; 304 } 305 306 return (0); 307 } 308 309 static void 310 pm2fb_attach(device_t parent, device_t self, void *aux) 311 { 312 struct pm2fb_softc *sc = device_private(self); 313 struct pci_attach_args *pa = aux; 314 struct rasops_info *ri; 315 struct wsemuldisplaydev_attach_args aa; 316 prop_dictionary_t dict; 317 unsigned long defattr; 318 bool is_console; 319 uint32_t flags; 320 int i; 321 322 sc->sc_pc = pa->pa_pc; 323 sc->sc_pcitag = pa->pa_tag; 324 sc->sc_memt = pa->pa_memt; 325 sc->sc_iot = pa->pa_iot; 326 sc->sc_dev = self; 327 328 for (i = 0; pm2fb_pci_devices[i].vendor; i++) { 329 if (PCI_PRODUCT(pa->pa_id) == pm2fb_pci_devices[i].product) { 330 sc->sc_is_pm2 = pm2fb_pci_devices[i].flags ; 331 break; 332 } 333 } 334 335 pci_aprint_devinfo(pa, NULL); 336 337 /* 338 * fill in parameters from properties 339 * if we can't get a usable mode via DDC2 we'll use this to pick one, 340 * which is why we fill them in with some conservative values that 341 * hopefully work as a last resort 342 */ 343 dict = device_properties(self); 344 if (!prop_dictionary_get_uint32(dict, "width", &sc->sc_width)) { 345 aprint_error("%s: no width property\n", device_xname(self)); 346 sc->sc_width = 1024; 347 } 348 if (!prop_dictionary_get_uint32(dict, "height", &sc->sc_height)) { 349 aprint_error("%s: no height property\n", device_xname(self)); 350 sc->sc_height = 768; 351 } 352 if (!prop_dictionary_get_uint32(dict, "depth", &sc->sc_depth)) { 353 aprint_error("%s: no depth property\n", device_xname(self)); 354 sc->sc_depth = 8; 355 } 356 357 /* 358 * don't look at the linebytes property - The Raptor firmware lies 359 * about it. Get it from width * depth >> 3 instead. 360 */ 361 362 sc->sc_stride = sc->sc_width * (sc->sc_depth >> 3); 363 364 prop_dictionary_get_bool(dict, "is_console", &is_console); 365 366 pci_mapreg_info(pa->pa_pc, pa->pa_tag, 0x14, PCI_MAPREG_TYPE_MEM, 367 &sc->sc_fb, &sc->sc_fbsize, &flags); 368 369 if (pci_mapreg_map(pa, 0x10, PCI_MAPREG_TYPE_MEM, 0, 370 &sc->sc_memt, &sc->sc_regh, &sc->sc_reg, &sc->sc_regsize)) { 371 aprint_error("%s: failed to map registers.\n", 372 device_xname(sc->sc_dev)); 373 } 374 375 /* 376 * XXX yeah, casting the fb address to uint32_t is formally wrong 377 * but as far as I know there are no PM2 with 64bit BARs 378 */ 379 aprint_normal("%s: %d MB aperture at 0x%08x\n", device_xname(self), 380 (int)(sc->sc_fbsize >> 20), (uint32_t)sc->sc_fb); 381 382 sc->sc_defaultscreen_descr = (struct wsscreen_descr){ 383 "default", 384 0, 0, 385 NULL, 386 8, 16, 387 WSSCREEN_WSCOLORS | WSSCREEN_HILIT, 388 NULL 389 }; 390 sc->sc_screens[0] = &sc->sc_defaultscreen_descr; 391 sc->sc_screenlist = (struct wsscreen_list){1, sc->sc_screens}; 392 sc->sc_mode = WSDISPLAYIO_MODE_EMUL; 393 sc->sc_locked = 0; 394 395 pm2_setup_i2c(sc); 396 397 vcons_init(&sc->vd, sc, &sc->sc_defaultscreen_descr, 398 &pm2fb_accessops); 399 sc->vd.init_screen = pm2fb_init_screen; 400 401 /* init engine here */ 402 pm2fb_init(sc); 403 404 ri = &sc->sc_console_screen.scr_ri; 405 406 sc->sc_gc.gc_bitblt = pm2fb_bitblt; 407 sc->sc_gc.gc_rectfill = pm2fb_rectfill_a; 408 sc->sc_gc.gc_blitcookie = sc; 409 sc->sc_gc.gc_rop = 3; 410 411 #ifdef PM2FB_DEBUG 412 /* 413 * leave some room at the bottom of the screen for various blitter 414 * tests and in order to make the glyph cache visible 415 */ 416 sc->sc_height -= 200; 417 #endif 418 419 if (is_console) { 420 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, 421 &defattr); 422 sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; 423 424 pm2fb_rectfill(sc, 0, 0, sc->sc_width, sc->sc_height, 425 ri->ri_devcmap[(defattr >> 16) & 0xff]); 426 sc->sc_defaultscreen_descr.textops = &ri->ri_ops; 427 sc->sc_defaultscreen_descr.capabilities = ri->ri_caps; 428 sc->sc_defaultscreen_descr.nrows = ri->ri_rows; 429 sc->sc_defaultscreen_descr.ncols = ri->ri_cols; 430 431 glyphcache_init(&sc->sc_gc, sc->sc_height + 5, 432 min(2047, (sc->sc_fbsize / sc->sc_stride)) 433 - sc->sc_height - 5, 434 sc->sc_width, 435 ri->ri_font->fontwidth, 436 ri->ri_font->fontheight, 437 defattr); 438 wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, 0, 439 defattr); 440 vcons_replay_msgbuf(&sc->sc_console_screen); 441 } else { 442 if (sc->sc_console_screen.scr_ri.ri_rows == 0) { 443 /* do some minimal setup to avoid weirdnesses later */ 444 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1, 445 &defattr); 446 } else 447 (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr); 448 glyphcache_init(&sc->sc_gc, sc->sc_height + 5, 449 min(2047, (sc->sc_fbsize / sc->sc_stride)) 450 - sc->sc_height - 5, 451 sc->sc_width, 452 ri->ri_font->fontwidth, 453 ri->ri_font->fontheight, 454 defattr); 455 } 456 457 pm2fb_init_palette(sc); 458 459 aa.console = is_console; 460 aa.scrdata = &sc->sc_screenlist; 461 aa.accessops = &pm2fb_accessops; 462 aa.accesscookie = &sc->vd; 463 464 config_found(sc->sc_dev, &aa, wsemuldisplaydevprint); 465 466 #ifdef PM2FB_DEBUG 467 /* 468 * draw a pattern to check if pm2fb_bitblt() gets the alignment stuff 469 * right 470 */ 471 pm2fb_rectfill(sc, 0, sc->sc_height, sc->sc_width, 200, 0xffffffff); 472 pm2fb_rectfill(sc, 0, sc->sc_height, 300, 10, 0); 473 pm2fb_rectfill(sc, 10, sc->sc_height, 200, 10, 0xe0e0e0e0); 474 for (i = 1; i < 20; i++) { 475 pm2fb_bitblt(sc, 0, sc->sc_height, 476 i, sc->sc_height + 10 * i, 477 300, 10, 3); 478 pm2fb_bitblt(sc, i, sc->sc_height, 479 400, sc->sc_height + 10 * i, 480 300, 10, 3); 481 } 482 #endif 483 } 484 485 static int 486 pm2fb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 487 struct lwp *l) 488 { 489 struct vcons_data *vd = v; 490 struct pm2fb_softc *sc = vd->cookie; 491 struct wsdisplay_fbinfo *wdf; 492 struct vcons_screen *ms = vd->active; 493 494 switch (cmd) { 495 case WSDISPLAYIO_GTYPE: 496 *(u_int *)data = WSDISPLAY_TYPE_PCIMISC; 497 return 0; 498 499 /* PCI config read/write passthrough. */ 500 case PCI_IOC_CFGREAD: 501 case PCI_IOC_CFGWRITE: 502 return pci_devioctl(sc->sc_pc, sc->sc_pcitag, 503 cmd, data, flag, l); 504 505 case WSDISPLAYIO_GET_BUSID: 506 return wsdisplayio_busid_pci(sc->sc_dev, sc->sc_pc, 507 sc->sc_pcitag, data); 508 509 case WSDISPLAYIO_GINFO: 510 if (ms == NULL) 511 return ENODEV; 512 wdf = (void *)data; 513 wdf->height = ms->scr_ri.ri_height; 514 wdf->width = ms->scr_ri.ri_width; 515 wdf->depth = ms->scr_ri.ri_depth; 516 wdf->cmsize = 256; 517 return 0; 518 519 case WSDISPLAYIO_GETCMAP: 520 return pm2fb_getcmap(sc, 521 (struct wsdisplay_cmap *)data); 522 523 case WSDISPLAYIO_PUTCMAP: 524 return pm2fb_putcmap(sc, 525 (struct wsdisplay_cmap *)data); 526 527 case WSDISPLAYIO_LINEBYTES: 528 *(u_int *)data = sc->sc_stride; 529 return 0; 530 531 case WSDISPLAYIO_SMODE: { 532 int new_mode = *(int*)data; 533 if (new_mode != sc->sc_mode) { 534 sc->sc_mode = new_mode; 535 if(new_mode == WSDISPLAYIO_MODE_EMUL) { 536 /* first set the video mode */ 537 if (sc->sc_videomode != NULL) { 538 pm2fb_set_mode(sc, sc->sc_videomode); 539 } 540 /* then initialize the drawing engine */ 541 pm2fb_init(sc); 542 pm2fb_init_palette(sc); 543 /* clean out the glyph cache */ 544 glyphcache_wipe(&sc->sc_gc); 545 /* and redraw everything */ 546 vcons_redraw_screen(ms); 547 } else 548 pm2fb_flush_engine(sc); 549 } 550 } 551 return 0; 552 case WSDISPLAYIO_GET_EDID: { 553 struct wsdisplayio_edid_info *d = data; 554 d->data_size = 128; 555 if (d->buffer_size < 128) 556 return EAGAIN; 557 return copyout(sc->sc_edid_data, d->edid_data, 128); 558 } 559 560 case WSDISPLAYIO_GET_FBINFO: { 561 struct wsdisplayio_fbinfo *fbi = data; 562 return wsdisplayio_get_fbinfo(&ms->scr_ri, fbi); 563 } 564 } 565 return EPASSTHROUGH; 566 } 567 568 static paddr_t 569 pm2fb_mmap(void *v, void *vs, off_t offset, int prot) 570 { 571 struct vcons_data *vd = v; 572 struct pm2fb_softc *sc = vd->cookie; 573 paddr_t pa; 574 575 /* 'regular' framebuffer mmap()ing */ 576 if (offset < sc->sc_fbsize) { 577 pa = bus_space_mmap(sc->sc_memt, sc->sc_fb + offset, 0, prot, 578 BUS_SPACE_MAP_LINEAR); 579 return pa; 580 } 581 582 /* 583 * restrict all other mappings to processes with superuser privileges 584 * or the kernel itself 585 */ 586 if (kauth_authorize_machdep(kauth_cred_get(), 587 KAUTH_MACHDEP_UNMANAGEDMEM, 588 NULL, NULL, NULL, NULL) != 0) { 589 aprint_normal("%s: mmap() rejected.\n", 590 device_xname(sc->sc_dev)); 591 return -1; 592 } 593 594 if ((offset >= sc->sc_fb) && (offset < (sc->sc_fb + sc->sc_fbsize))) { 595 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot, 596 BUS_SPACE_MAP_LINEAR); 597 return pa; 598 } 599 600 if ((offset >= sc->sc_reg) && 601 (offset < (sc->sc_reg + sc->sc_regsize))) { 602 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot, 603 BUS_SPACE_MAP_LINEAR); 604 return pa; 605 } 606 607 #ifdef PCI_MAGIC_IO_RANGE 608 /* allow mapping of IO space */ 609 if ((offset >= PCI_MAGIC_IO_RANGE) && 610 (offset < PCI_MAGIC_IO_RANGE + 0x10000)) { 611 pa = bus_space_mmap(sc->sc_iot, offset - PCI_MAGIC_IO_RANGE, 612 0, prot, BUS_SPACE_MAP_LINEAR); 613 return pa; 614 } 615 #endif 616 617 return -1; 618 } 619 620 static void 621 pm2fb_init_screen(void *cookie, struct vcons_screen *scr, 622 int existing, long *defattr) 623 { 624 struct pm2fb_softc *sc = cookie; 625 struct rasops_info *ri = &scr->scr_ri; 626 627 ri->ri_depth = sc->sc_depth; 628 ri->ri_width = sc->sc_width; 629 ri->ri_height = sc->sc_height; 630 ri->ri_stride = sc->sc_stride; 631 ri->ri_flg = RI_CENTER; 632 if (sc->sc_depth == 8) 633 ri->ri_flg |= RI_8BIT_IS_RGB | RI_ENABLE_ALPHA; 634 635 rasops_init(ri, 0, 0); 636 ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_UNDERLINE; 637 638 rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight, 639 sc->sc_width / ri->ri_font->fontwidth); 640 641 ri->ri_hw = scr; 642 ri->ri_ops.copyrows = pm2fb_copyrows; 643 ri->ri_ops.copycols = pm2fb_copycols; 644 ri->ri_ops.cursor = pm2fb_cursor; 645 ri->ri_ops.eraserows = pm2fb_eraserows; 646 ri->ri_ops.erasecols = pm2fb_erasecols; 647 if (FONT_IS_ALPHA(ri->ri_font)) { 648 ri->ri_ops.putchar = pm2fb_putchar_aa; 649 } else 650 ri->ri_ops.putchar = pm2fb_putchar; 651 } 652 653 static int 654 pm2fb_putcmap(struct pm2fb_softc *sc, struct wsdisplay_cmap *cm) 655 { 656 u_char *r, *g, *b; 657 u_int index = cm->index; 658 u_int count = cm->count; 659 int i, error; 660 u_char rbuf[256], gbuf[256], bbuf[256]; 661 662 #ifdef PM2FB_DEBUG 663 aprint_debug("putcmap: %d %d\n",index, count); 664 #endif 665 if (cm->index >= 256 || cm->count > 256 || 666 (cm->index + cm->count) > 256) 667 return EINVAL; 668 error = copyin(cm->red, &rbuf[index], count); 669 if (error) 670 return error; 671 error = copyin(cm->green, &gbuf[index], count); 672 if (error) 673 return error; 674 error = copyin(cm->blue, &bbuf[index], count); 675 if (error) 676 return error; 677 678 memcpy(&sc->sc_cmap_red[index], &rbuf[index], count); 679 memcpy(&sc->sc_cmap_green[index], &gbuf[index], count); 680 memcpy(&sc->sc_cmap_blue[index], &bbuf[index], count); 681 682 r = &sc->sc_cmap_red[index]; 683 g = &sc->sc_cmap_green[index]; 684 b = &sc->sc_cmap_blue[index]; 685 686 for (i = 0; i < count; i++) { 687 pm2fb_putpalreg(sc, index, *r, *g, *b); 688 index++; 689 r++, g++, b++; 690 } 691 return 0; 692 } 693 694 static int 695 pm2fb_getcmap(struct pm2fb_softc *sc, struct wsdisplay_cmap *cm) 696 { 697 u_int index = cm->index; 698 u_int count = cm->count; 699 int error; 700 701 if (index >= 255 || count > 256 || index + count > 256) 702 return EINVAL; 703 704 error = copyout(&sc->sc_cmap_red[index], cm->red, count); 705 if (error) 706 return error; 707 error = copyout(&sc->sc_cmap_green[index], cm->green, count); 708 if (error) 709 return error; 710 error = copyout(&sc->sc_cmap_blue[index], cm->blue, count); 711 if (error) 712 return error; 713 714 return 0; 715 } 716 717 static void 718 pm2fb_init_palette(struct pm2fb_softc *sc) 719 { 720 struct rasops_info *ri = &sc->sc_console_screen.scr_ri; 721 int i, j = 0; 722 uint8_t cmap[768]; 723 724 rasops_get_cmap(ri, cmap, sizeof(cmap)); 725 for (i = 0; i < 256; i++) { 726 sc->sc_cmap_red[i] = cmap[j]; 727 sc->sc_cmap_green[i] = cmap[j + 1]; 728 sc->sc_cmap_blue[i] = cmap[j + 2]; 729 pm2fb_putpalreg(sc, i, cmap[j], cmap[j + 1], cmap[j + 2]); 730 j += 3; 731 } 732 } 733 734 static int 735 pm2fb_putpalreg(struct pm2fb_softc *sc, uint8_t idx, uint8_t r, uint8_t g, 736 uint8_t b) 737 { 738 bus_space_write_1(sc->sc_memt, sc->sc_regh, PM2_DAC_PAL_WRITE_IDX, idx); 739 bus_space_write_1(sc->sc_memt, sc->sc_regh, PM2_DAC_DATA, r); 740 bus_space_write_1(sc->sc_memt, sc->sc_regh, PM2_DAC_DATA, g); 741 bus_space_write_1(sc->sc_memt, sc->sc_regh, PM2_DAC_DATA, b); 742 return 0; 743 } 744 745 static uint8_t 746 pm2fb_read_dac(struct pm2fb_softc *sc, int reg) 747 { 748 if (sc->sc_is_pm2) { 749 bus_space_write_1(sc->sc_memt, sc->sc_regh, 750 PM2_DAC_PAL_WRITE_IDX, reg); 751 return bus_space_read_1(sc->sc_memt, sc->sc_regh, 752 PM2_DAC_INDEX_DATA); 753 } else { 754 bus_space_write_1(sc->sc_memt, sc->sc_regh, 755 PM2V_DAC_INDEX_LOW, reg & 0xff); 756 bus_space_write_1(sc->sc_memt, sc->sc_regh, 757 PM2V_DAC_INDEX_HIGH, (reg >> 8) & 0xff); 758 return bus_space_read_1(sc->sc_memt, sc->sc_regh, 759 PM2V_DAC_INDEX_DATA); 760 } 761 } 762 763 static void 764 pm2fb_write_dac(struct pm2fb_softc *sc, int reg, uint8_t data) 765 { 766 pm2fb_wait(sc, 3); 767 if (sc->sc_is_pm2) { 768 pm2fb_wait(sc, 2); 769 bus_space_write_1(sc->sc_memt, sc->sc_regh, 770 PM2_DAC_PAL_WRITE_IDX, reg); 771 bus_space_write_1(sc->sc_memt, sc->sc_regh, 772 PM2_DAC_INDEX_DATA, data); 773 } else { 774 pm2fb_wait(sc, 3); 775 bus_space_write_1(sc->sc_memt, sc->sc_regh, 776 PM2V_DAC_INDEX_LOW, reg & 0xff); 777 bus_space_write_1(sc->sc_memt, sc->sc_regh, 778 PM2V_DAC_INDEX_HIGH, (reg >> 8) & 0xff); 779 bus_space_write_1(sc->sc_memt, sc->sc_regh, 780 PM2V_DAC_INDEX_DATA, data); 781 } 782 } 783 784 static void 785 pm2fb_init(struct pm2fb_softc *sc) 786 { 787 pm2fb_flush_engine(sc); 788 789 pm2fb_wait(sc, 9); 790 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_SCREEN_BASE, 0); 791 /* set aperture endianness */ 792 #if BYTE_ORDER == BIG_ENDIAN 793 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_APERTURE1_CONTROL, 794 PM2_AP_BYTESWAP | PM2_AP_HALFWORDSWAP); 795 #else 796 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_APERTURE1_CONTROL, 0); 797 #endif 798 #if 0 799 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_BYPASS_MASK, 800 0xffffffff); 801 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_FB_WRITE_MASK, 802 0xffffffff); 803 #endif 804 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HW_WRITEMASK, 805 0xffffffff); 806 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_SW_WRITEMASK, 807 0xffffffff); 808 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_WRITE_MODE, 809 PM2WM_WRITE_EN); 810 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SCREENSIZE, 811 (sc->sc_height << 16) | sc->sc_width); 812 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SCISSOR_MODE, 813 PM2SC_SCREEN_EN); 814 pm2fb_wait(sc, 8); 815 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DITHER_MODE, 0); 816 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_ALPHA_MODE, 0); 817 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DDA_MODE, 0); 818 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_TEX_COLOUR_MODE, 0); 819 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_TEX_ADDRESS_MODE, 0); 820 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_TEX_READ_MODE, 0); 821 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_TEX_LUT_MODE, 0); 822 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_YUV_MODE, 0); 823 pm2fb_wait(sc, 8); 824 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DEPTH_MODE, 0); 825 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DEPTH, 0); 826 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_STENCIL_MODE, 0); 827 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_STIPPLE_MODE, 0); 828 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_ROP_MODE, 0); 829 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_WINDOW_ORIGIN, 0); 830 #if 0 831 sc->sc_pprod = bus_space_read_4(sc->sc_memt, sc->sc_regh, 832 PM2_FB_READMODE) & 833 (PM2FB_PP0_MASK | PM2FB_PP1_MASK | PM2FB_PP2_MASK); 834 #endif 835 sc->sc_pprod = partprodPermedia[sc->sc_stride >> 5]; 836 837 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_FB_READMODE, 838 sc->sc_pprod); 839 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_TEXMAP_FORMAT, 840 sc->sc_pprod); 841 pm2fb_wait(sc, 9); 842 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DY, 1 << 16); 843 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DXDOM, 0); 844 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_STARTXDOM, 0); 845 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_STARTXSUB, 0); 846 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_STARTY, 0); 847 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_COUNT, 0); 848 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SCISSOR_MINYX, 0); 849 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SCISSOR_MAXYX, 850 0x0fff0fff); 851 /* 852 * another scissor we need to disable in order to blit into off-screen 853 * memory 854 */ 855 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SCREENSIZE, 856 0x0fff0fff); 857 858 switch(sc->sc_depth) { 859 case 8: 860 bus_space_write_4(sc->sc_memt, sc->sc_regh, 861 PM2_RE_PIXEL_SIZE, PM2PS_8BIT); 862 break; 863 case 16: 864 bus_space_write_4(sc->sc_memt, sc->sc_regh, 865 PM2_RE_PIXEL_SIZE, PM2PS_16BIT); 866 break; 867 case 32: 868 bus_space_write_4(sc->sc_memt, sc->sc_regh, 869 PM2_RE_PIXEL_SIZE, PM2PS_32BIT); 870 break; 871 } 872 pm2fb_flush_engine(sc); 873 DPRINTF("pixel size: %08x\n", 874 bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_RE_PIXEL_SIZE)); 875 } 876 877 static void 878 pm2fb_rectfill(struct pm2fb_softc *sc, int x, int y, int wi, int he, 879 uint32_t colour) 880 { 881 882 pm2fb_wait(sc, 7); 883 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DDA_MODE, 0); 884 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_MODE, 0); 885 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_CONFIG, 886 PM2RECFG_WRITE_EN); 887 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_BLOCK_COLOUR, 888 colour); 889 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RECT_START, 890 (y << 16) | x); 891 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RECT_SIZE, 892 (he << 16) | wi); 893 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RENDER, 894 PM2RE_RECTANGLE | PM2RE_INC_X | PM2RE_INC_Y | PM2RE_FASTFILL); 895 } 896 897 static void 898 pm2fb_rectfill_a(void *cookie, int x, int y, int wi, int he, long attr) 899 { 900 struct pm2fb_softc *sc = cookie; 901 902 pm2fb_rectfill(sc, x, y, wi, he, 903 sc->vd.active->scr_ri.ri_devcmap[(attr >> 24 & 0xf)]); 904 } 905 906 static void 907 pm2fb_bitblt(void *cookie, int xs, int ys, int xd, int yd, 908 int wi, int he, int rop) 909 { 910 struct pm2fb_softc *sc = cookie; 911 uint32_t dir = 0; 912 int rxd, rwi, rxdelta; 913 914 if (yd <= ys) { 915 dir |= PM2RE_INC_Y; 916 } 917 if (xd <= xs) { 918 dir |= PM2RE_INC_X; 919 } 920 pm2fb_wait(sc, 8); 921 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_DDA_MODE, 0); 922 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_MODE, 0); 923 if (sc->sc_depth == 8) { 924 int adjust; 925 /* 926 * use packed mode for some extra speed 927 * this copies 32bit quantities even in 8 bit mode, so we need 928 * to adjust for cases where the lower two bits in source and 929 * destination X don't align, and/or where the width isn't a 930 * multiple of 4 931 */ 932 if (rop == 3) { 933 bus_space_write_4(sc->sc_memt, sc->sc_regh, 934 PM2_RE_CONFIG, 935 PM2RECFG_READ_SRC | PM2RECFG_WRITE_EN | 936 PM2RECFG_ROP_EN | PM2RECFG_PACKED | (rop << 6)); 937 } else { 938 bus_space_write_4(sc->sc_memt, sc->sc_regh, 939 PM2_RE_CONFIG, 940 PM2RECFG_READ_SRC | PM2RECFG_READ_DST | 941 PM2RECFG_WRITE_EN | PM2RECFG_PACKED | 942 PM2RECFG_ROP_EN | (rop << 6)); 943 } 944 rxd = xd >> 2; 945 rwi = (wi + 7) >> 2; 946 rxdelta = (xs & 0xffc) - (xd & 0xffc); 947 /* adjust for non-aligned x */ 948 #ifdef BITBLT_LE_WORKAROUND 949 /* I have no idea why this seems to work */ 950 adjust = 1; 951 #else 952 adjust = ((xd & 3) - (xs & 3)); 953 #endif 954 bus_space_write_4(sc->sc_memt, sc->sc_regh, 955 PM2_RE_PACKEDDATA_LIMIT, 956 (xd << 16) | (xd + wi) | (adjust << 29)); 957 958 } else { 959 /* we're in 16 or 32bit mode */ 960 if (rop == 3) { 961 bus_space_write_4(sc->sc_memt, sc->sc_regh, 962 PM2_RE_CONFIG, 963 PM2RECFG_READ_SRC | PM2RECFG_WRITE_EN | 964 PM2RECFG_ROP_EN | PM2RECFG_PACKED | (rop << 6)); 965 } else { 966 bus_space_write_4(sc->sc_memt, sc->sc_regh, 967 PM2_RE_CONFIG, 968 PM2RECFG_READ_SRC | PM2RECFG_READ_DST | 969 PM2RECFG_WRITE_EN | PM2RECFG_PACKED | 970 PM2RECFG_ROP_EN | (rop << 6)); 971 } 972 rxd = xd; 973 rwi = wi; 974 rxdelta = xs - xd; 975 } 976 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RECT_START, 977 (yd << 16) | rxd); 978 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RECT_SIZE, 979 (he << 16) | rwi); 980 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_SOURCE_DELTA, 981 (((ys - yd) & 0xfff) << 16) | (rxdelta & 0xfff)); 982 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_RENDER, 983 PM2RE_RECTANGLE | dir); 984 } 985 986 static void 987 pm2fb_cursor(void *cookie, int on, int row, int col) 988 { 989 struct rasops_info *ri = cookie; 990 struct vcons_screen *scr = ri->ri_hw; 991 struct pm2fb_softc *sc = scr->scr_cookie; 992 int x, y, wi, he; 993 994 wi = ri->ri_font->fontwidth; 995 he = ri->ri_font->fontheight; 996 997 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 998 x = ri->ri_ccol * wi + ri->ri_xorigin; 999 y = ri->ri_crow * he + ri->ri_yorigin; 1000 if (ri->ri_flg & RI_CURSOR) { 1001 pm2fb_bitblt(sc, x, y, x, y, wi, he, 12); 1002 ri->ri_flg &= ~RI_CURSOR; 1003 } 1004 ri->ri_crow = row; 1005 ri->ri_ccol = col; 1006 if (on) { 1007 x = ri->ri_ccol * wi + ri->ri_xorigin; 1008 y = ri->ri_crow * he + ri->ri_yorigin; 1009 pm2fb_bitblt(sc, x, y, x, y, wi, he, 12); 1010 ri->ri_flg |= RI_CURSOR; 1011 } 1012 } else { 1013 scr->scr_ri.ri_crow = row; 1014 scr->scr_ri.ri_ccol = col; 1015 scr->scr_ri.ri_flg &= ~RI_CURSOR; 1016 } 1017 1018 } 1019 1020 static void 1021 pm2fb_putchar(void *cookie, int row, int col, u_int c, long attr) 1022 { 1023 struct rasops_info *ri = cookie; 1024 struct wsdisplay_font *font = PICK_FONT(ri, c); 1025 struct vcons_screen *scr = ri->ri_hw; 1026 struct pm2fb_softc *sc = scr->scr_cookie; 1027 uint32_t mode; 1028 1029 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) { 1030 void *data; 1031 uint32_t fg, bg; 1032 int uc, i; 1033 int x, y, wi, he; 1034 1035 wi = font->fontwidth; 1036 he = font->fontheight; 1037 1038 if (!CHAR_IN_FONT(c, font)) 1039 return; 1040 bg = ri->ri_devcmap[(attr >> 16) & 0xf]; 1041 fg = ri->ri_devcmap[(attr >> 24) & 0xf]; 1042 x = ri->ri_xorigin + col * wi; 1043 y = ri->ri_yorigin + row * he; 1044 if (c == 0x20) { 1045 pm2fb_rectfill(sc, x, y, wi, he, bg); 1046 } else { 1047 uc = c - font->firstchar; 1048 data = (uint8_t *)font->data + uc * ri->ri_fontscale; 1049 1050 mode = PM2RM_MASK_MIRROR; 1051 #if BYTE_ORDER == LITTLE_ENDIAN 1052 switch (ri->ri_font->stride) { 1053 case 1: 1054 mode |= 4 << 7; 1055 break; 1056 case 2: 1057 mode |= 3 << 7; 1058 break; 1059 } 1060 #else 1061 switch (ri->ri_font->stride) { 1062 case 1: 1063 mode |= 3 << 7; 1064 break; 1065 case 2: 1066 mode |= 2 << 7; 1067 break; 1068 } 1069 #endif 1070 pm2fb_wait(sc, 8); 1071 1072 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1073 PM2_RE_MODE, mode); 1074 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1075 PM2_RE_CONFIG, PM2RECFG_WRITE_EN); 1076 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1077 PM2_RE_BLOCK_COLOUR, bg); 1078 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1079 PM2_RE_RECT_START, (y << 16) | x); 1080 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1081 PM2_RE_RECT_SIZE, (he << 16) | wi); 1082 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1083 PM2_RE_RENDER, 1084 PM2RE_RECTANGLE | 1085 PM2RE_INC_X | PM2RE_INC_Y | PM2RE_FASTFILL); 1086 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1087 PM2_RE_BLOCK_COLOUR, fg); 1088 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1089 PM2_RE_RENDER, 1090 PM2RE_RECTANGLE | PM2RE_SYNC_ON_MASK | 1091 PM2RE_INC_X | PM2RE_INC_Y | PM2RE_FASTFILL); 1092 1093 pm2fb_wait(sc, he); 1094 switch (ri->ri_font->stride) { 1095 case 1: { 1096 uint8_t *data8 = data; 1097 uint32_t reg; 1098 for (i = 0; i < he; i++) { 1099 reg = *data8; 1100 bus_space_write_4(sc->sc_memt, 1101 sc->sc_regh, 1102 PM2_RE_BITMASK, reg); 1103 data8++; 1104 } 1105 break; 1106 } 1107 case 2: { 1108 uint16_t *data16 = data; 1109 uint32_t reg; 1110 for (i = 0; i < he; i++) { 1111 reg = *data16; 1112 bus_space_write_4(sc->sc_memt, 1113 sc->sc_regh, 1114 PM2_RE_BITMASK, reg); 1115 data16++; 1116 } 1117 break; 1118 } 1119 } 1120 } 1121 if (attr & 1) 1122 pm2fb_rectfill(sc, x, y + he - 2, wi, 1, fg); 1123 } 1124 } 1125 1126 static void 1127 pm2fb_putchar_aa(void *cookie, int row, int col, u_int c, long attr) 1128 { 1129 struct rasops_info *ri = cookie; 1130 struct wsdisplay_font *font = PICK_FONT(ri, c); 1131 struct vcons_screen *scr = ri->ri_hw; 1132 struct pm2fb_softc *sc = scr->scr_cookie; 1133 uint32_t bg, fg, /*latch = 0,*/ bg8, fg8, pixel; 1134 int i, x, y, wi, he, r, g, b, aval; 1135 int r1, g1, b1, r0, g0, b0, fgo, bgo; 1136 uint8_t *data8; 1137 int rv = GC_NOPE, cnt = 0; 1138 1139 if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL) 1140 return; 1141 1142 if (!CHAR_IN_FONT(c, font)) 1143 return; 1144 1145 wi = font->fontwidth; 1146 he = font->fontheight; 1147 1148 bg = ri->ri_devcmap[(attr >> 16) & 0xf]; 1149 fg = ri->ri_devcmap[(attr >> 24) & 0xf]; 1150 x = ri->ri_xorigin + col * wi; 1151 y = ri->ri_yorigin + row * he; 1152 if (c == 0x20) { 1153 pm2fb_rectfill(sc, x, y, wi, he, bg); 1154 if (attr & 1) 1155 pm2fb_rectfill(sc, x, y + he - 2, wi, 1, fg); 1156 return; 1157 } 1158 1159 #ifdef BITBLT_LE_WORKAROUND 1160 rv = GC_NOPE; 1161 #else 1162 rv = glyphcache_try(&sc->sc_gc, c, x, y, attr); 1163 if (rv == GC_OK) 1164 return; 1165 #endif 1166 1167 data8 = WSFONT_GLYPH(c, font); 1168 1169 pm2fb_wait(sc, 5); 1170 #if 0 1171 /* 1172 * TODO: 1173 * - use packed mode here as well, instead of writing each pixel separately 1174 * - see if we can trick the chip into doing the alpha blending for us 1175 */ 1176 x = x >> 2; 1177 wi = (wi + 3) >> 2; 1178 #endif 1179 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_MODE, 0); 1180 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_RE_CONFIG, 1181 PM2RECFG_WRITE_EN /*| PM2RECFG_PACKED*/); 1182 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1183 PM2_RE_RECT_START, (y << 16) | x); 1184 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1185 PM2_RE_RECT_SIZE, (he << 16) | wi); 1186 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1187 PM2_RE_RENDER, 1188 PM2RE_RECTANGLE | PM2RE_SYNC_ON_HOST | 1189 PM2RE_INC_X | PM2RE_INC_Y); 1190 /* 1191 * we need the RGB colours here, so get offsets into rasops_cmap 1192 */ 1193 fgo = ((attr >> 24) & 0xf) * 3; 1194 bgo = ((attr >> 16) & 0xf) * 3; 1195 1196 r0 = rasops_cmap[bgo]; 1197 r1 = rasops_cmap[fgo]; 1198 g0 = rasops_cmap[bgo + 1]; 1199 g1 = rasops_cmap[fgo + 1]; 1200 b0 = rasops_cmap[bgo + 2]; 1201 b1 = rasops_cmap[fgo + 2]; 1202 #define R3G3B2(r, g, b) ((r & 0xe0) | ((g >> 3) & 0x1c) | (b >> 6)) 1203 bg8 = R3G3B2(r0, g0, b0); 1204 fg8 = R3G3B2(r1, g1, b1); 1205 1206 pm2fb_wait(sc, 200); 1207 1208 for (i = 0; i < ri->ri_fontscale; i++) { 1209 aval = *data8; 1210 if (aval == 0) { 1211 pixel = bg8; 1212 } else if (aval == 255) { 1213 pixel = fg8; 1214 } else { 1215 r = aval * r1 + (255 - aval) * r0; 1216 g = aval * g1 + (255 - aval) * g0; 1217 b = aval * b1 + (255 - aval) * b0; 1218 pixel = ((r & 0xe000) >> 8) | 1219 ((g & 0xe000) >> 11) | 1220 ((b & 0xc000) >> 14); 1221 } 1222 #if 0 1223 latch = (latch << 8) | pixel; 1224 /* write in 32bit chunks */ 1225 if ((i & 3) == 3) { 1226 bus_space_write_stream_4(sc->sc_memt, sc->sc_regh, 1227 PM2_RE_DATA, latch); 1228 /* 1229 * not strictly necessary, old data should be shifted 1230 * out 1231 */ 1232 latch = 0; 1233 cnt++; 1234 if (cnt > 190) { 1235 pm2fb_wait(sc, 200); 1236 cnt = 0; 1237 } 1238 } 1239 #else 1240 bus_space_write_4(sc->sc_memt, sc->sc_regh, 1241 PM2_RE_COLOUR, pixel); 1242 1243 if (cnt > 190) { 1244 pm2fb_wait(sc, 200); 1245 cnt = 0; 1246 } 1247 #endif 1248 data8++; 1249 } 1250 #if 0 1251 /* if we have pixels left in latch write them out */ 1252 if ((i & 3) != 0) { 1253 latch = latch << ((4 - (i & 3)) << 3); 1254 bus_space_write_stream_4(sc->sc_memt, sc->sc_regh, 1255 PM2_RE_DATA, latch); 1256 } 1257 #endif 1258 /* 1259 * XXX 1260 * occasionally characters end up in the cache only partially drawn 1261 * apparently the blitter might end up grabbing them before they're 1262 * completely flushed out into video memory 1263 * so we let the pipeline drain a little bit before continuing 1264 */ 1265 pm2fb_wait(sc, 20); 1266 1267 if (rv == GC_ADD) { 1268 glyphcache_add(&sc->sc_gc, c, x, y); 1269 } else if (attr & 1) 1270 pm2fb_rectfill(sc, x, y + he - 2, wi, 1, fg); 1271 } 1272 1273 static void 1274 pm2fb_copycols(void *cookie, int row, int srccol, int dstcol, int ncols) 1275 { 1276 struct rasops_info *ri = cookie; 1277 struct vcons_screen *scr = ri->ri_hw; 1278 struct pm2fb_softc *sc = scr->scr_cookie; 1279 int32_t xs, xd, y, width, height; 1280 1281 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1282 xs = ri->ri_xorigin + ri->ri_font->fontwidth * srccol; 1283 xd = ri->ri_xorigin + ri->ri_font->fontwidth * dstcol; 1284 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1285 width = ri->ri_font->fontwidth * ncols; 1286 height = ri->ri_font->fontheight; 1287 pm2fb_bitblt(sc, xs, y, xd, y, width, height, 3); 1288 } 1289 } 1290 1291 static void 1292 pm2fb_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr) 1293 { 1294 struct rasops_info *ri = cookie; 1295 struct vcons_screen *scr = ri->ri_hw; 1296 struct pm2fb_softc *sc = scr->scr_cookie; 1297 int32_t x, y, width, height, fg, bg, ul; 1298 1299 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1300 x = ri->ri_xorigin + ri->ri_font->fontwidth * startcol; 1301 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1302 width = ri->ri_font->fontwidth * ncols; 1303 height = ri->ri_font->fontheight; 1304 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 1305 1306 pm2fb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]); 1307 } 1308 } 1309 1310 static void 1311 pm2fb_copyrows(void *cookie, int srcrow, int dstrow, int nrows) 1312 { 1313 struct rasops_info *ri = cookie; 1314 struct vcons_screen *scr = ri->ri_hw; 1315 struct pm2fb_softc *sc = scr->scr_cookie; 1316 int32_t x, ys, yd, width, height; 1317 1318 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1319 x = ri->ri_xorigin; 1320 ys = ri->ri_yorigin + ri->ri_font->fontheight * srcrow; 1321 yd = ri->ri_yorigin + ri->ri_font->fontheight * dstrow; 1322 width = ri->ri_emuwidth; 1323 height = ri->ri_font->fontheight*nrows; 1324 pm2fb_bitblt(sc, x, ys, x, yd, width, height, 3); 1325 } 1326 } 1327 1328 static void 1329 pm2fb_eraserows(void *cookie, int row, int nrows, long fillattr) 1330 { 1331 struct rasops_info *ri = cookie; 1332 struct vcons_screen *scr = ri->ri_hw; 1333 struct pm2fb_softc *sc = scr->scr_cookie; 1334 int32_t x, y, width, height, fg, bg, ul; 1335 1336 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) { 1337 x = ri->ri_xorigin; 1338 y = ri->ri_yorigin + ri->ri_font->fontheight * row; 1339 width = ri->ri_emuwidth; 1340 height = ri->ri_font->fontheight * nrows; 1341 rasops_unpack_attr(fillattr, &fg, &bg, &ul); 1342 1343 pm2fb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]); 1344 } 1345 } 1346 1347 /* 1348 * Permedia2 can't blit outside of 2048x2048, so reject anything higher 1349 * max. dot clock is probably too high 1350 */ 1351 1352 #define MODE_IS_VALID(m) (((m)->hdisplay < 2048) && \ 1353 ((m)->dot_clock < 230000)) 1354 1355 static void 1356 pm2_setup_i2c(struct pm2fb_softc *sc) 1357 { 1358 int i; 1359 #ifdef PM2FB_DEBUG 1360 int j; 1361 #endif 1362 1363 /* Fill in the i2c tag */ 1364 sc->sc_i2c.ic_cookie = sc; 1365 sc->sc_i2c.ic_acquire_bus = pm2fb_i2c_acquire_bus; 1366 sc->sc_i2c.ic_release_bus = pm2fb_i2c_release_bus; 1367 sc->sc_i2c.ic_send_start = pm2fb_i2c_send_start; 1368 sc->sc_i2c.ic_send_stop = pm2fb_i2c_send_stop; 1369 sc->sc_i2c.ic_initiate_xfer = pm2fb_i2c_initiate_xfer; 1370 sc->sc_i2c.ic_read_byte = pm2fb_i2c_read_byte; 1371 sc->sc_i2c.ic_write_byte = pm2fb_i2c_write_byte; 1372 sc->sc_i2c.ic_exec = NULL; 1373 1374 DPRINTF("data: %08x\n", bus_space_read_4(sc->sc_memt, sc->sc_regh, 1375 PM2_DISPLAY_DATA)); 1376 1377 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_DISPLAY_DATA, 0); 1378 1379 /* zero out the EDID buffer */ 1380 memset(sc->sc_edid_data, 0, 128); 1381 1382 /* Some monitors don't respond first time */ 1383 i = 0; 1384 while (sc->sc_edid_data[1] == 0 && i < 10) { 1385 ddc_read_edid(&sc->sc_i2c, sc->sc_edid_data, 128); 1386 i++; 1387 } 1388 #ifdef PM2FB_DEBUG 1389 printf("i = %d\n", i); 1390 for (i = 0; i < 128; i += 16) { 1391 printf("%02x:", i); 1392 for (j = 0; j < 16; j++) 1393 printf(" %02x", sc->sc_edid_data[i + j]); 1394 printf("\n"); 1395 } 1396 #endif 1397 1398 if (edid_parse(&sc->sc_edid_data[0], &sc->sc_ei) != -1) { 1399 #ifdef PM2FB_DEBUG 1400 edid_print(&sc->sc_ei); 1401 #endif 1402 1403 /* 1404 * Now pick a mode. 1405 */ 1406 if ((sc->sc_ei.edid_preferred_mode != NULL)) { 1407 struct videomode *m = sc->sc_ei.edid_preferred_mode; 1408 if (MODE_IS_VALID(m)) { 1409 sc->sc_videomode = m; 1410 } else { 1411 aprint_error_dev(sc->sc_dev, 1412 "unable to use preferred mode\n"); 1413 } 1414 } 1415 /* 1416 * if we can't use the preferred mode go look for the 1417 * best one we can support 1418 */ 1419 if (sc->sc_videomode == NULL) { 1420 struct videomode *m = sc->sc_ei.edid_modes; 1421 1422 sort_modes(sc->sc_ei.edid_modes, 1423 &sc->sc_ei.edid_preferred_mode, 1424 sc->sc_ei.edid_nmodes); 1425 if (sc->sc_videomode == NULL) 1426 for (int n = 0; n < sc->sc_ei.edid_nmodes; n++) 1427 if (MODE_IS_VALID(&m[n])) { 1428 sc->sc_videomode = &m[n]; 1429 break; 1430 } 1431 } 1432 } 1433 if (sc->sc_videomode == NULL) { 1434 /* no EDID data? */ 1435 sc->sc_videomode = pick_mode_by_ref(sc->sc_width, 1436 sc->sc_height, 60); 1437 } 1438 if (sc->sc_videomode != NULL) { 1439 pm2fb_set_mode(sc, sc->sc_videomode); 1440 } 1441 } 1442 1443 /* I2C bitbanging */ 1444 static void pm2fb_i2cbb_set_bits(void *cookie, uint32_t bits) 1445 { 1446 struct pm2fb_softc *sc = cookie; 1447 uint32_t out; 1448 1449 out = bits << 2; /* bitmasks match the IN bits */ 1450 1451 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_DISPLAY_DATA, out); 1452 delay(100); 1453 } 1454 1455 static void pm2fb_i2cbb_set_dir(void *cookie, uint32_t dir) 1456 { 1457 /* Nothing to do */ 1458 } 1459 1460 static uint32_t pm2fb_i2cbb_read(void *cookie) 1461 { 1462 struct pm2fb_softc *sc = cookie; 1463 uint32_t bits; 1464 1465 bits = bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_DISPLAY_DATA); 1466 return bits; 1467 } 1468 1469 /* higher level I2C stuff */ 1470 static int 1471 pm2fb_i2c_acquire_bus(void *cookie, int flags) 1472 { 1473 /* private bus */ 1474 return (0); 1475 } 1476 1477 static void 1478 pm2fb_i2c_release_bus(void *cookie, int flags) 1479 { 1480 /* private bus */ 1481 } 1482 1483 static int 1484 pm2fb_i2c_send_start(void *cookie, int flags) 1485 { 1486 return (i2c_bitbang_send_start(cookie, flags, &pm2fb_i2cbb_ops)); 1487 } 1488 1489 static int 1490 pm2fb_i2c_send_stop(void *cookie, int flags) 1491 { 1492 1493 return (i2c_bitbang_send_stop(cookie, flags, &pm2fb_i2cbb_ops)); 1494 } 1495 1496 static int 1497 pm2fb_i2c_initiate_xfer(void *cookie, i2c_addr_t addr, int flags) 1498 { 1499 1500 return (i2c_bitbang_initiate_xfer(cookie, addr, flags, 1501 &pm2fb_i2cbb_ops)); 1502 } 1503 1504 static int 1505 pm2fb_i2c_read_byte(void *cookie, uint8_t *valp, int flags) 1506 { 1507 return (i2c_bitbang_read_byte(cookie, valp, flags, &pm2fb_i2cbb_ops)); 1508 } 1509 1510 static int 1511 pm2fb_i2c_write_byte(void *cookie, uint8_t val, int flags) 1512 { 1513 return (i2c_bitbang_write_byte(cookie, val, flags, &pm2fb_i2cbb_ops)); 1514 } 1515 1516 static int 1517 pm2vfb_set_pll(struct pm2fb_softc *sc, int freq) 1518 { 1519 int m, n, p, diff, out_freq, bm = 1, bn = 3, bp = 0, 1520 bdiff = 1000000 /* , bfreq */; 1521 int fi; 1522 uint8_t temp; 1523 1524 for (m = 1; m < 128; m++) { 1525 for (n = 2 * m + 1; n < 256; n++) { 1526 fi = PM2_EXT_CLOCK_FREQ * n / m; 1527 for (p = 0; p < 2; p++) { 1528 out_freq = fi >> (p + 1); 1529 diff = abs(out_freq - freq); 1530 if (diff < bdiff) { 1531 bdiff = diff; 1532 /* bfreq = out_freq; */ 1533 bm = m; 1534 bn = n; 1535 bp = p; 1536 } 1537 } 1538 } 1539 } 1540 #if 0 1541 /* 1542 * XXX 1543 * output between switching modes and attaching a wsdisplay will 1544 * go through firmware calls on sparc64 and potentially mess up 1545 * our drawing engine state 1546 */ 1547 DPRINTF("best: %d kHz ( %d off ), %d %d %d\n", bfreq, bdiff, bm, bn, bp); 1548 #endif 1549 temp = pm2fb_read_dac(sc, PM2V_DAC_CLOCK_CONTROL) & 0xfc; 1550 pm2fb_write_dac(sc, PM2V_DAC_CONTROL, 0); 1551 pm2fb_write_dac(sc, PM2V_DAC_CLOCK_A_M, bm); 1552 pm2fb_write_dac(sc, PM2V_DAC_CLOCK_A_N, bn); 1553 pm2fb_write_dac(sc, PM2V_DAC_CLOCK_A_P, bp); 1554 pm2fb_write_dac(sc, PM2V_DAC_CLOCK_CONTROL, temp | 3); 1555 return 0; 1556 } 1557 1558 static int 1559 pm2fb_set_pll(struct pm2fb_softc *sc, int freq) 1560 { 1561 uint8_t reg, bm = 0, bn = 0, bp = 0; 1562 unsigned int m, n, p, fi, diff, out_freq, bdiff = 1000000; 1563 1564 for (n = 2; n < 15; n++) { 1565 for (m = 2 ; m < 256; m++) { 1566 fi = PM2_EXT_CLOCK_FREQ * m / n; 1567 if (fi >= PM2_PLL_FREQ_MIN && fi <= PM2_PLL_FREQ_MAX) { 1568 for (p = 0; p < 5; p++) { 1569 out_freq = fi >> p; 1570 diff = abs(out_freq - freq); 1571 if (diff < bdiff) { 1572 bm = m; 1573 bn = n; 1574 bp = p; 1575 bdiff = diff; 1576 } 1577 } 1578 } 1579 } 1580 } 1581 1582 pm2fb_write_dac(sc, PM2_DAC_PIXELCLKA_M, bm); 1583 pm2fb_write_dac(sc, PM2_DAC_PIXELCLKA_N, bn); 1584 pm2fb_write_dac(sc, PM2_DAC_PIXELCLKA_P, (bp | 0x08)); 1585 1586 do { 1587 reg = bus_space_read_1(sc->sc_memt, sc->sc_regh, 1588 PM2_DAC_INDEX_DATA); 1589 } while (reg == PCLK_LOCKED); 1590 1591 return 0; 1592 } 1593 1594 /* 1595 * most of the following was adapted from the xf86-video-glint driver's 1596 * pm2_dac.c (8bpp only) 1597 */ 1598 static void 1599 pm2fb_set_dac(struct pm2fb_softc *sc, const struct videomode *mode) 1600 { 1601 int t1, t2, t3, t4, stride; 1602 uint32_t vclk, tmp; 1603 uint8_t sync = 0; 1604 1605 t1 = mode->hsync_start - mode->hdisplay; 1606 t2 = mode->vsync_start - mode->vdisplay; 1607 t3 = mode->hsync_end - mode->hsync_start; 1608 t4 = mode->vsync_end - mode->vsync_start; 1609 1610 /* first round up to the next multiple of 32 */ 1611 stride = (mode->hdisplay + 31) & ~31; 1612 /* then find the next bigger one that we have partial products for */ 1613 while ((partprodPermedia[stride >> 5] == -1) && (stride < 2048)) { 1614 stride += 32; 1615 } 1616 1617 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HTOTAL, 1618 ((mode->htotal) >> 2) - 1); 1619 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HSYNC_END, 1620 (t1 + t3) >> 2); 1621 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HSYNC_START, 1622 (t1 >> 2)); 1623 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HBLANK_END, 1624 (mode->htotal - mode->hdisplay) >> 2); 1625 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HGATE_END, 1626 (mode->htotal - mode->hdisplay) >> 2); 1627 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_SCREEN_STRIDE, 1628 stride >> 3); 1629 1630 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VTOTAL, 1631 mode->vtotal - 2); 1632 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VSYNC_END, 1633 t2 + t4 - 1); 1634 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VSYNC_START, 1635 t2 - 1); 1636 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VBLANK_END, 1637 mode->vtotal - mode->vdisplay); 1638 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VIDEO_CONTROL, 1639 PM2_VC_VIDEO_ENABLE | 1640 PM2_VC_HSYNC_ACT_HIGH | PM2_VC_VSYNC_ACT_HIGH); 1641 1642 vclk = bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_VCLKCTL); 1643 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VCLKCTL, 1644 vclk & 0xfffffffc); 1645 1646 tmp = bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_CHIP_CONFIG); 1647 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_CHIP_CONFIG, 1648 tmp & 0xffffffdd); 1649 1650 pm2fb_write_dac(sc, PM2_DAC_MODE_CONTROL, MOC_BUFFERFRONT); 1651 pm2fb_set_pll(sc, mode->dot_clock); 1652 1653 sync = MC_PALETTE_8BIT; 1654 1655 if (!(mode->flags & VID_PHSYNC)) 1656 sync |= MC_HSYNC_INV; 1657 if (!(mode->flags & VID_PVSYNC)) 1658 sync |= MC_VSYNC_INV; 1659 1660 pm2fb_write_dac(sc, PM2_DAC_MISC_CONTROL, sync); 1661 pm2fb_write_dac(sc, PM2_DAC_COLOR_MODE, 1662 CM_PALETTE | CM_GUI_ENABLE | CM_RGB); 1663 1664 sc->sc_width = mode->hdisplay; 1665 sc->sc_height = mode->vdisplay; 1666 sc->sc_depth = 8; 1667 sc->sc_stride = stride; 1668 aprint_normal_dev(sc->sc_dev, "pm2 using %d x %d in 8 bit, stride %d\n", 1669 sc->sc_width, sc->sc_height, stride); 1670 } 1671 1672 /* 1673 * most of the following was adapted from the xf86-video-glint driver's 1674 * pm2v_dac.c 1675 */ 1676 static void 1677 pm2vfb_set_dac(struct pm2fb_softc *sc, const struct videomode *mode) 1678 { 1679 int t1, t2, t3, t4, stride; 1680 uint32_t vclk; 1681 uint8_t sync = 0; 1682 1683 t1 = mode->hsync_start - mode->hdisplay; 1684 t2 = mode->vsync_start - mode->vdisplay; 1685 t3 = mode->hsync_end - mode->hsync_start; 1686 t4 = mode->vsync_end - mode->vsync_start; 1687 1688 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HTOTAL, 1689 ((mode->htotal) >> 3) - 1); 1690 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HSYNC_END, 1691 (t1 + t3) >> 3); 1692 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HSYNC_START, 1693 (t1 >> 3) - 1); 1694 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HBLANK_END, 1695 (mode->htotal - mode->hdisplay) >> 3); 1696 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_HGATE_END, 1697 (mode->htotal - mode->hdisplay) >> 3); 1698 1699 /* first round up to the next multiple of 32 */ 1700 stride = (mode->hdisplay + 31) & ~31; 1701 /* then find the next bigger one that we have partial products for */ 1702 while ((partprodPermedia[stride >> 5] == -1) && (stride < 2048)) { 1703 stride += 32; 1704 } 1705 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_SCREEN_STRIDE, 1706 stride >> 3); 1707 1708 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VTOTAL, 1709 mode->vtotal - 1); 1710 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VSYNC_END, 1711 t2 + t4); 1712 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VSYNC_START, 1713 t2); 1714 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VBLANK_END, 1715 mode->vtotal - mode->vdisplay); 1716 1717 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VIDEO_CONTROL, 1718 PM2_VC_VIDEO_ENABLE | PM2_VC_RAMDAC_64BIT | 1719 PM2_VC_HSYNC_ACT_HIGH | PM2_VC_VSYNC_ACT_HIGH); 1720 1721 vclk = bus_space_read_4(sc->sc_memt, sc->sc_regh, PM2_VCLKCTL); 1722 bus_space_write_4(sc->sc_memt, sc->sc_regh, PM2_VCLKCTL, 1723 vclk & 0xfffffffc); 1724 1725 pm2vfb_set_pll(sc, mode->dot_clock / 2); 1726 pm2fb_write_dac(sc, PM2V_DAC_MISC_CONTROL, PM2V_DAC_8BIT); 1727 1728 if (mode->flags & VID_PHSYNC) 1729 sync |= PM2V_DAC_HSYNC_INV; 1730 if (mode->flags & VID_PVSYNC) 1731 sync |= PM2V_DAC_VSYNC_INV; 1732 pm2fb_write_dac(sc, PM2V_DAC_SYNC_CONTROL, sync); 1733 1734 pm2fb_write_dac(sc, PM2V_DAC_COLOR_FORMAT, PM2V_DAC_PALETTE); 1735 pm2fb_write_dac(sc, PM2V_DAC_PIXEL_SIZE, PM2V_PS_8BIT); 1736 sc->sc_width = mode->hdisplay; 1737 sc->sc_height = mode->vdisplay; 1738 sc->sc_depth = 8; 1739 sc->sc_stride = stride; 1740 aprint_normal_dev(sc->sc_dev, "pm2v using %d x %d in 8 bit, stride %d\n", 1741 sc->sc_width, sc->sc_height, stride); 1742 } 1743 1744 static void 1745 pm2fb_set_mode(struct pm2fb_softc *sc, const struct videomode *mode) 1746 { 1747 if (sc->sc_is_pm2) { 1748 pm2fb_set_dac(sc, mode); 1749 } else { 1750 pm2vfb_set_dac(sc, mode); 1751 } 1752 } 1753
Indexes created Tue Sep 30 06:09:59 GMT 2025