tfb.c revision 1.18.2.1
1 /* $NetBSD: tfb.c,v 1.18.2.1 1999/10/20 22:55:00 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 1999 Tohru Nishimura. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Tohru Nishimura 17 * for the NetBSD Project. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */ 34 35 __KERNEL_RCSID(0, "$NetBSD: tfb.c,v 1.18.2.1 1999/10/20 22:55:00 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/malloc.h> 42 #include <sys/buf.h> 43 #include <sys/ioctl.h> 44 #include <vm/vm.h> 45 46 #include <machine/bus.h> 47 #include <machine/intr.h> 48 49 #include <dev/rcons/raster.h> 50 #include <dev/wscons/wsconsio.h> 51 #include <dev/wscons/wscons_raster.h> 52 #include <dev/wscons/wsdisplayvar.h> 53 54 #include <dev/tc/tcvar.h> 55 #include <dev/ic/bt463reg.h> 56 #include <dev/ic/bt431reg.h> 57 58 #include <uvm/uvm_extern.h> 59 60 #if defined(pmax) 61 #define machine_btop(x) mips_btop(x) 62 #define MACHINE_KSEG0_TO_PHYS(x) MIPS_KSEG0_TO_PHYS(x) 63 64 /* 65 * struct bt463reg { 66 * u_int8_t bt_lo; 67 * unsigned : 24; 68 * u_int8_t bt_hi; 69 * unsigned : 24; 70 * u_int8_t bt_reg; 71 * unsigned : 24; 72 * u_int8_t bt_cmap; 73 * }; 74 * 75 * N.B. a pair of Bt431s are located adjascently. 76 * struct bt431twin { 77 * struct { 78 * u_int8_t u0; for sprite mask 79 * u_int8_t u1; for sprite image 80 * unsigned :16; 81 * } bt_lo; 82 * ... 83 * 84 * struct bt431reg { 85 * u_int16_t bt_lo; 86 * unsigned : 16; 87 * u_int16_t bt_hi; 88 * unsigned : 16; 89 * u_int16_t bt_ram; 90 * unsigned : 16; 91 * u_int16_t bt_ctl; 92 * }; 93 */ 94 95 #define BYTE(base, index) *((u_int8_t *)(base) + ((index)<<2)) 96 #define HALF(base, index) *((u_int16_t *)(base) + ((index)<<1)) 97 98 #endif 99 100 #if defined(__alpha__) || defined(alpha) 101 #define machine_btop(x) alpha_btop(x) 102 #define MACHINE_KSEG0_TO_PHYS(x) ALPHA_K0SEG_TO_PHYS(x) 103 104 /* 105 * struct bt463reg { 106 * u_int32_t bt_lo; 107 * u_int32_t bt_hi; 108 * u_int32_t bt_reg; 109 * u_int32_t bt_cmap; 110 * }; 111 * 112 * struct bt431reg { 113 * u_int32_t bt_lo; 114 * u_int32_t bt_hi; 115 * u_int32_t bt_ram; 116 * u_int32_t bt_ctl; 117 * }; 118 */ 119 120 #define BYTE(base, index) *((u_int32_t *)(base) + (index)) 121 #define HALF(base, index) *((u_int32_t *)(base) + (index)) 122 123 #endif 124 125 /* Bt463 hardware registers */ 126 #define bt_lo 0 127 #define bt_hi 1 128 #define bt_reg 2 129 #define bt_cmap 3 130 131 /* Bt431 hardware registers */ 132 #define bt_ram 2 133 #define bt_ctl 3 134 135 #define SELECT463(vdac, regno) do { \ 136 BYTE(vdac, bt_lo) = (regno) & 0x00ff; \ 137 BYTE(vdac, bt_hi) = ((regno)& 0xff00) >> 8; \ 138 tc_wmb(); \ 139 } while (0) 140 141 #define TWIN(x) ((x) | ((x) << 8)) 142 #define TWIN_LO(x) (twin = (x) & 0x00ff, (twin << 8) | twin) 143 #define TWIN_HI(x) (twin = (x) & 0xff00, twin | (twin >> 8)) 144 145 #define SELECT431(curs, regno) do { \ 146 HALF(curs, bt_lo) = TWIN(regno);\ 147 HALF(curs, bt_hi) = 0; \ 148 tc_wmb(); \ 149 } while (0) 150 151 struct fb_devconfig { 152 vaddr_t dc_vaddr; /* memory space virtual base address */ 153 paddr_t dc_paddr; /* memory space physical base address */ 154 vsize_t dc_size; /* size of slot memory */ 155 int dc_wid; /* width of frame buffer */ 156 int dc_ht; /* height of frame buffer */ 157 int dc_depth; /* depth, bits per pixel */ 158 int dc_rowbytes; /* bytes in a FB scan line */ 159 vaddr_t dc_videobase; /* base of flat frame buffer */ 160 struct raster dc_raster; /* raster description */ 161 struct rcons dc_rcons; /* raster blitter control info */ 162 int dc_blanked; /* currently has video disabled */ 163 }; 164 165 struct hwcmap256 { 166 #define CMAP_SIZE 256 /* R/G/B entries */ 167 u_int8_t r[CMAP_SIZE]; 168 u_int8_t g[CMAP_SIZE]; 169 u_int8_t b[CMAP_SIZE]; 170 }; 171 172 struct hwcursor64 { 173 struct wsdisplay_curpos cc_pos; 174 struct wsdisplay_curpos cc_hot; 175 struct wsdisplay_curpos cc_size; 176 struct wsdisplay_curpos cc_magic; 177 #define CURSOR_MAX_SIZE 64 178 u_int8_t cc_color[6]; 179 u_int64_t cc_image[64 + 64]; 180 }; 181 182 struct tfb_softc { 183 struct device sc_dev; 184 struct fb_devconfig *sc_dc; /* device configuration */ 185 struct hwcmap256 sc_cmap; /* software copy of colormap */ 186 struct hwcursor64 sc_cursor; /* software copy of cursor */ 187 int sc_curenb; /* cursor sprite enabled */ 188 int sc_changed; /* need update of colormap */ 189 #define DATA_ENB_CHANGED 0x01 /* cursor enable changed */ 190 #define DATA_CURCMAP_CHANGED 0x02 /* cursor colormap changed */ 191 #define DATA_CURSHAPE_CHANGED 0x04 /* cursor size, image, mask changed */ 192 #define DATA_CMAP_CHANGED 0x08 /* colormap changed */ 193 #define DATA_ALL_CHANGED 0x0f 194 int nscreens; 195 }; 196 197 #define TX_MAGIC_X 360 198 #define TX_MAGIC_Y 36 199 200 #define TX_BT463_OFFSET 0x040000 201 #define TX_BT431_OFFSET 0x040010 202 #define TX_CONTROL 0x040030 203 #define TX_MAP_REGISTER 0x040030 204 #define TX_PIP_OFFSET 0x0800c0 205 #define TX_SELECTION 0x100000 206 #define TX_8BPP_OFFSET 0x200000 207 #define TX_8BPP_SIZE 0x200000 208 #define TX_24BPP_OFFSET 0x400000 209 #define TX_24BPP_SIZE 0x600000 210 #define TX_VIDEO_ENABLE 0xa00000 211 212 #define TX_CTL_VIDEO_ON 0x80 213 #define TX_CTL_INT_ENA 0x40 214 #define TX_CTL_INT_PEND 0x20 215 #define TX_CTL_SEG_ENA 0x10 216 #define TX_CTL_SEG 0x0f 217 218 int tfbmatch __P((struct device *, struct cfdata *, void *)); 219 void tfbattach __P((struct device *, struct device *, void *)); 220 221 struct cfattach tfb_ca = { 222 sizeof(struct tfb_softc), tfbmatch, tfbattach, 223 }; 224 225 void tfb_getdevconfig __P((tc_addr_t, struct fb_devconfig *)); 226 struct fb_devconfig tfb_console_dc; 227 tc_addr_t tfb_consaddr; 228 229 struct wsdisplay_emulops tfb_emulops = { 230 rcons_cursor, /* could use hardware cursor; punt */ 231 rcons_mapchar, 232 rcons_putchar, 233 rcons_copycols, 234 rcons_erasecols, 235 rcons_copyrows, 236 rcons_eraserows, 237 rcons_alloc_attr 238 }; 239 240 struct wsscreen_descr tfb_stdscreen = { 241 "std", 0, 0, 242 &tfb_emulops, 243 0, 0, 244 WSSCREEN_REVERSE 245 }; 246 247 const struct wsscreen_descr *_tfb_scrlist[] = { 248 &tfb_stdscreen, 249 }; 250 251 struct wsscreen_list tfb_screenlist = { 252 sizeof(_tfb_scrlist) / sizeof(struct wsscreen_descr *), _tfb_scrlist 253 }; 254 255 int tfbioctl __P((void *, u_long, caddr_t, int, struct proc *)); 256 int tfbmmap __P((void *, off_t, int)); 257 258 int tfb_alloc_screen __P((void *, const struct wsscreen_descr *, 259 void **, int *, int *, long *)); 260 void tfb_free_screen __P((void *, void *)); 261 void tfb_show_screen __P((void *, void *)); 262 263 struct wsdisplay_accessops tfb_accessops = { 264 tfbioctl, 265 tfbmmap, 266 tfb_alloc_screen, 267 tfb_free_screen, 268 tfb_show_screen, 269 0 /* load_font */ 270 }; 271 272 int tfb_cnattach __P((tc_addr_t)); 273 int tfbintr __P((void *)); 274 void tfbinit __P((struct fb_devconfig *)); 275 276 static int get_cmap __P((struct tfb_softc *, struct wsdisplay_cmap *)); 277 static int set_cmap __P((struct tfb_softc *, struct wsdisplay_cmap *)); 278 static int set_cursor __P((struct tfb_softc *, struct wsdisplay_cursor *)); 279 static int get_cursor __P((struct tfb_softc *, struct wsdisplay_cursor *)); 280 static void set_curpos __P((struct tfb_softc *, struct wsdisplay_curpos *)); 281 static void bt431_set_curpos __P((struct tfb_softc *)); 282 283 /* bit order reverse */ 284 const static u_int8_t flip[256] = { 285 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 286 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 287 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 288 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 289 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 290 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 291 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 292 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 293 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 294 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 295 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 296 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 297 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 298 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 299 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 300 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 301 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 302 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 303 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 304 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 305 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 306 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 307 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 308 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 309 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 310 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 311 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 312 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 313 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 314 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 315 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 316 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, 317 }; 318 319 int 320 tfbmatch(parent, match, aux) 321 struct device *parent; 322 struct cfdata *match; 323 void *aux; 324 { 325 struct tc_attach_args *ta = aux; 326 327 if (strncmp("PMAG-RO ", ta->ta_modname, TC_ROM_LLEN) != 0 328 && strncmp("PMAG-JA ", ta->ta_modname, TC_ROM_LLEN) != 0) 329 return (0); 330 331 return (1); 332 } 333 334 void 335 tfb_getdevconfig(dense_addr, dc) 336 tc_addr_t dense_addr; 337 struct fb_devconfig *dc; 338 { 339 struct raster *rap; 340 struct rcons *rcp; 341 int i; 342 343 dc->dc_vaddr = dense_addr; 344 dc->dc_paddr = MACHINE_KSEG0_TO_PHYS(dc->dc_vaddr); 345 346 dc->dc_wid = 1280; 347 dc->dc_ht = 1024; 348 dc->dc_depth = 8; 349 dc->dc_rowbytes = 1280; 350 dc->dc_videobase = dc->dc_vaddr + TX_8BPP_OFFSET; 351 dc->dc_blanked = 0; 352 353 /* initialize colormap and cursor resource */ 354 tfbinit(dc); 355 356 /* clear the screen */ 357 for (i = 0; i < dc->dc_ht * dc->dc_rowbytes; i += sizeof(u_int32_t)) 358 *(u_int32_t *)(dc->dc_videobase + i) = 0x0; 359 360 /* initialize the raster */ 361 rap = &dc->dc_raster; 362 rap->width = dc->dc_wid; 363 rap->height = dc->dc_ht; 364 rap->depth = dc->dc_depth; 365 rap->linelongs = dc->dc_rowbytes / sizeof(u_int32_t); 366 rap->pixels = (u_int32_t *)dc->dc_videobase; 367 368 /* initialize the raster console blitter */ 369 rcp = &dc->dc_rcons; 370 rcp->rc_sp = rap; 371 rcp->rc_crow = rcp->rc_ccol = -1; 372 rcp->rc_crowp = &rcp->rc_crow; 373 rcp->rc_ccolp = &rcp->rc_ccol; 374 rcons_init(rcp, 34, 80); 375 376 tfb_stdscreen.nrows = dc->dc_rcons.rc_maxrow; 377 tfb_stdscreen.ncols = dc->dc_rcons.rc_maxcol; 378 } 379 380 void 381 tfbattach(parent, self, aux) 382 struct device *parent, *self; 383 void *aux; 384 { 385 struct tfb_softc *sc = (struct tfb_softc *)self; 386 struct tc_attach_args *ta = aux; 387 struct wsemuldisplaydev_attach_args waa; 388 struct hwcmap256 *cm; 389 int console; 390 391 console = (ta->ta_addr == tfb_consaddr); 392 if (console) { 393 sc->sc_dc = &tfb_console_dc; 394 sc->nscreens = 1; 395 } 396 else { 397 sc->sc_dc = (struct fb_devconfig *) 398 malloc(sizeof(struct fb_devconfig), M_DEVBUF, M_WAITOK); 399 tfb_getdevconfig(ta->ta_addr, sc->sc_dc); 400 } 401 printf(": %d x %d, 8,24bpp\n", sc->sc_dc->dc_wid, sc->sc_dc->dc_ht); 402 403 cm = &sc->sc_cmap; 404 memset(cm, 255, sizeof(struct hwcmap256)); /* XXX */ 405 cm->r[0] = cm->g[0] = cm->b[0] = 0; /* XXX */ 406 407 sc->sc_cursor.cc_magic.x = TX_MAGIC_X; 408 sc->sc_cursor.cc_magic.y = TX_MAGIC_Y; 409 410 tc_intr_establish(parent, ta->ta_cookie, TC_IPL_TTY, tfbintr, sc); 411 412 *(u_int8_t *)(sc->sc_dc->dc_vaddr + TX_CONTROL) &= ~0x40; 413 *(u_int8_t *)(sc->sc_dc->dc_vaddr + TX_CONTROL) |= 0x40; 414 415 waa.console = console; 416 waa.scrdata = &tfb_screenlist; 417 waa.accessops = &tfb_accessops; 418 waa.accesscookie = sc; 419 420 config_found(self, &waa, wsemuldisplaydevprint); 421 } 422 423 int 424 tfbioctl(v, cmd, data, flag, p) 425 void *v; 426 u_long cmd; 427 caddr_t data; 428 int flag; 429 struct proc *p; 430 { 431 struct tfb_softc *sc = v; 432 struct fb_devconfig *dc = sc->sc_dc; 433 int turnoff; 434 435 switch (cmd) { 436 case WSDISPLAYIO_GTYPE: 437 *(u_int *)data = WSDISPLAY_TYPE_TX; 438 return (0); 439 440 case WSDISPLAYIO_GINFO: 441 #define wsd_fbip ((struct wsdisplay_fbinfo *)data) 442 wsd_fbip->height = sc->sc_dc->dc_ht; 443 wsd_fbip->width = sc->sc_dc->dc_wid; 444 wsd_fbip->depth = sc->sc_dc->dc_depth; 445 wsd_fbip->cmsize = CMAP_SIZE; 446 #undef fbt 447 return (0); 448 449 case WSDISPLAYIO_GETCMAP: 450 return get_cmap(sc, (struct wsdisplay_cmap *)data); 451 452 case WSDISPLAYIO_PUTCMAP: 453 return set_cmap(sc, (struct wsdisplay_cmap *)data); 454 455 case WSDISPLAYIO_SVIDEO: 456 turnoff = *(int *)data == WSDISPLAYIO_VIDEO_OFF; 457 if ((dc->dc_blanked == 0) ^ turnoff) { 458 dc->dc_blanked = turnoff; 459 #if 0 /* XXX later XXX */ 460 To turn off; 461 - clear the MSB of TX control register; &= ~0x80, 462 - assign Bt431 register #0 with value 0x4 to hide sprite cursor. 463 #endif /* XXX XXX XXX */ 464 } 465 return (0); 466 467 case WSDISPLAYIO_GVIDEO: 468 *(u_int *)data = dc->dc_blanked ? 469 WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON; 470 return (0); 471 472 case WSDISPLAYIO_GCURPOS: 473 *(struct wsdisplay_curpos *)data = sc->sc_cursor.cc_pos; 474 return (0); 475 476 case WSDISPLAYIO_SCURPOS: 477 set_curpos(sc, (struct wsdisplay_curpos *)data); 478 bt431_set_curpos(sc); 479 return (0); 480 481 case WSDISPLAYIO_GCURMAX: 482 ((struct wsdisplay_curpos *)data)->x = 483 ((struct wsdisplay_curpos *)data)->y = CURSOR_MAX_SIZE; 484 return (0); 485 486 case WSDISPLAYIO_GCURSOR: 487 return get_cursor(sc, (struct wsdisplay_cursor *)data); 488 489 case WSDISPLAYIO_SCURSOR: 490 return set_cursor(sc, (struct wsdisplay_cursor *)data); 491 } 492 return (ENOTTY); 493 } 494 495 int 496 tfbmmap(v, offset, prot) 497 void *v; 498 off_t offset; 499 int prot; 500 { 501 struct tfb_softc *sc = v; 502 503 if (offset >= TX_8BPP_SIZE || offset < 0) 504 return (-1); 505 return machine_btop(sc->sc_dc->dc_paddr + TX_8BPP_OFFSET + offset); 506 } 507 508 int 509 tfb_alloc_screen(v, type, cookiep, curxp, curyp, attrp) 510 void *v; 511 const struct wsscreen_descr *type; 512 void **cookiep; 513 int *curxp, *curyp; 514 long *attrp; 515 { 516 struct tfb_softc *sc = v; 517 long defattr; 518 519 if (sc->nscreens > 0) 520 return (ENOMEM); 521 522 *cookiep = &sc->sc_dc->dc_rcons; /* one and only for now */ 523 *curxp = 0; 524 *curyp = 0; 525 rcons_alloc_attr(&sc->sc_dc->dc_rcons, 0, 0, 0, &defattr); 526 *attrp = defattr; 527 sc->nscreens++; 528 return (0); 529 } 530 531 void 532 tfb_free_screen(v, cookie) 533 void *v; 534 void *cookie; 535 { 536 struct tfb_softc *sc = v; 537 538 if (sc->sc_dc == &tfb_console_dc) 539 panic("tfb_free_screen: console"); 540 541 sc->nscreens--; 542 } 543 544 void 545 tfb_show_screen(v, cookie) 546 void *v; 547 void *cookie; 548 { 549 } 550 551 int 552 tfb_cnattach(addr) 553 tc_addr_t addr; 554 { 555 struct fb_devconfig *dcp = &tfb_console_dc; 556 long defattr; 557 558 tfb_getdevconfig(addr, dcp); 559 560 rcons_alloc_attr(&dcp->dc_rcons, 0, 0, 0, &defattr); 561 562 wsdisplay_cnattach(&tfb_stdscreen, &dcp->dc_rcons, 563 0, 0, defattr); 564 tfb_consaddr = addr; 565 return(0); 566 } 567 568 int 569 tfbintr(arg) 570 void *arg; 571 { 572 struct tfb_softc *sc = arg; 573 caddr_t tfbbase = (caddr_t)sc->sc_dc->dc_vaddr; 574 void *vdac, *curs; 575 int v; 576 577 *(u_int8_t *)(tfbbase + TX_CONTROL) &= ~0x40; 578 if (sc->sc_changed == 0) 579 goto done; 580 581 vdac = (void *)(tfbbase + TX_BT463_OFFSET); 582 curs = (void *)(tfbbase + TX_BT431_OFFSET); 583 v = sc->sc_changed; 584 sc->sc_changed = 0; 585 if (v & DATA_ENB_CHANGED) { 586 SELECT431(curs, BT431_REG_COMMAND); 587 HALF(curs, bt_ctl) = (sc->sc_curenb) ? 0x4444 : 0x0404; 588 } 589 if (v & DATA_CURCMAP_CHANGED) { 590 u_int8_t *cp = sc->sc_cursor.cc_color; 591 592 SELECT463(vdac, BT463_IREG_CURSOR_COLOR_0); 593 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 594 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 595 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 596 597 BYTE(vdac, bt_reg) = cp[0]; tc_wmb(); 598 BYTE(vdac, bt_reg) = cp[2]; tc_wmb(); 599 BYTE(vdac, bt_reg) = cp[4]; tc_wmb(); 600 601 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 602 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 603 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 604 605 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 606 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 607 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 608 } 609 if (v & DATA_CURSHAPE_CHANGED) { 610 u_int8_t *ip, *mp, img, msk; 611 int bcnt; 612 613 ip = (u_int8_t *)sc->sc_cursor.cc_image; 614 mp = (u_int8_t *)(sc->sc_cursor.cc_image + CURSOR_MAX_SIZE); 615 bcnt = 0; 616 SELECT431(curs, BT431_REG_CRAM_BASE); 617 618 /* 64 pixel scan line is consisted with 16 byte cursor ram */ 619 while (bcnt < sc->sc_cursor.cc_size.y * 16) { 620 /* pad right half 32 pixel when smaller than 33 */ 621 if ((bcnt & 0x8) && sc->sc_cursor.cc_size.x < 33) { 622 HALF(curs, bt_ram) = 0; 623 tc_wmb(); 624 } 625 else { 626 img = *ip++; 627 msk = *mp++; 628 img &= msk; /* cookie off image */ 629 HALF(curs, bt_ram) 630 = (flip[img] << 8) | flip[msk]; 631 tc_wmb(); 632 } 633 bcnt += 2; 634 } 635 /* pad unoccupied scan lines */ 636 while (bcnt < CURSOR_MAX_SIZE * 16) { 637 HALF(curs, bt_ram) = 0; 638 tc_wmb(); 639 bcnt += 2; 640 } 641 } 642 if (v & DATA_CMAP_CHANGED) { 643 struct hwcmap256 *cm = &sc->sc_cmap; 644 int index; 645 646 SELECT463(vdac, BT463_IREG_CPALETTE_RAM); 647 for (index = 0; index < CMAP_SIZE; index++) { 648 BYTE(vdac, bt_cmap) = cm->r[index]; 649 BYTE(vdac, bt_cmap) = cm->g[index]; 650 BYTE(vdac, bt_cmap) = cm->b[index]; 651 } 652 } 653 done: 654 *(u_int8_t *)(tfbbase + TX_CONTROL) &= ~0x40; /* !? Eeeh !? */ 655 *(u_int8_t *)(tfbbase + TX_CONTROL) |= 0x40; 656 return (1); 657 } 658 659 void 660 tfbinit(dc) 661 struct fb_devconfig *dc; 662 { 663 caddr_t tfbbase = (caddr_t)dc->dc_vaddr; 664 void *vdac = (void *)(tfbbase + TX_BT463_OFFSET); 665 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 666 int i; 667 668 SELECT463(vdac, BT463_IREG_COMMAND_0); 669 BYTE(vdac, bt_reg) = 0x40; tc_wmb(); /* CMD 0 */ 670 BYTE(vdac, bt_reg) = 0x46; tc_wmb(); /* CMD 1 */ 671 BYTE(vdac, bt_reg) = 0xc0; tc_wmb(); /* CMD 2 */ 672 BYTE(vdac, bt_reg) = 0; tc_wmb(); /* !? 204 !? */ 673 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 0:7 */ 674 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 8:15 */ 675 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 16:23 */ 676 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 24:27 */ 677 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 0:7 */ 678 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 8:15 */ 679 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 16:23 */ 680 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 24:27 */ 681 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); 682 683 #if 0 /* XXX ULTRIX does initialize 16 entry window type here XXX */ 684 { 685 static u_int32_t windowtype[BT463_IREG_WINDOW_TYPE_TABLE] = { 686 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 687 }; 688 689 SELECT463(vdac, BT463_IREG_WINDOW_TYPE_TABLE); 690 for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) { 691 BYTE(vdac, bt_reg) = windowtype[i]; /* 0:7 */ 692 BYTE(vdac, bt_reg) = windowtype[i] >> 8; /* 8:15 */ 693 BYTE(vdac, bt_reg) = windowtype[i] >> 16; /* 16:23 */ 694 } 695 } 696 #endif 697 698 SELECT463(vdac, BT463_IREG_CPALETTE_RAM); 699 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 700 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 701 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 702 for (i = 1; i < 256; i++) { 703 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 704 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 705 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 706 } 707 708 /* !? Eeeh !? */ 709 SELECT463(vdac, 0x0100 /* BT463_IREG_CURSOR_COLOR_0 */); 710 for (i = 0; i < 256; i++) { 711 BYTE(vdac, bt_cmap) = i; tc_wmb(); 712 BYTE(vdac, bt_cmap) = i; tc_wmb(); 713 BYTE(vdac, bt_cmap) = i; tc_wmb(); 714 } 715 716 SELECT431(curs, BT431_REG_COMMAND); 717 HALF(curs, bt_ctl) = 0x0404; tc_wmb(); 718 HALF(curs, bt_ctl) = 0; /* XLO */ tc_wmb(); 719 HALF(curs, bt_ctl) = 0; /* XHI */ tc_wmb(); 720 HALF(curs, bt_ctl) = 0; /* YLO */ tc_wmb(); 721 HALF(curs, bt_ctl) = 0; /* YHI */ tc_wmb(); 722 HALF(curs, bt_ctl) = 0; /* XWLO */ tc_wmb(); 723 HALF(curs, bt_ctl) = 0; /* XWHI */ tc_wmb(); 724 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 725 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 726 HALF(curs, bt_ctl) = 0; /* WWLO */ tc_wmb(); 727 HALF(curs, bt_ctl) = 0; /* WWHI */ tc_wmb(); 728 HALF(curs, bt_ctl) = 0; /* WHLO */ tc_wmb(); 729 HALF(curs, bt_ctl) = 0; /* WHHI */ tc_wmb(); 730 731 SELECT431(curs, BT431_REG_CRAM_BASE); 732 for (i = 0; i < 512; i++) { 733 HALF(curs, bt_ram) = 0; tc_wmb(); 734 } 735 } 736 737 static int 738 get_cmap(sc, p) 739 struct tfb_softc *sc; 740 struct wsdisplay_cmap *p; 741 { 742 u_int index = p->index, count = p->count; 743 744 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 745 return (EINVAL); 746 747 if (!uvm_useracc(p->red, count, B_WRITE) || 748 !uvm_useracc(p->green, count, B_WRITE) || 749 !uvm_useracc(p->blue, count, B_WRITE)) 750 return (EFAULT); 751 752 copyout(&sc->sc_cmap.r[index], p->red, count); 753 copyout(&sc->sc_cmap.g[index], p->green, count); 754 copyout(&sc->sc_cmap.b[index], p->blue, count); 755 756 return (0); 757 } 758 759 static int 760 set_cmap(sc, p) 761 struct tfb_softc *sc; 762 struct wsdisplay_cmap *p; 763 { 764 u_int index = p->index, count = p->count; 765 766 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 767 return (EINVAL); 768 769 if (!uvm_useracc(p->red, count, B_READ) || 770 !uvm_useracc(p->green, count, B_READ) || 771 !uvm_useracc(p->blue, count, B_READ)) 772 return (EFAULT); 773 774 copyin(p->red, &sc->sc_cmap.r[index], count); 775 copyin(p->green, &sc->sc_cmap.g[index], count); 776 copyin(p->blue, &sc->sc_cmap.b[index], count); 777 778 sc->sc_changed |= DATA_CMAP_CHANGED; 779 780 return (0); 781 } 782 783 static int 784 set_cursor(sc, p) 785 struct tfb_softc *sc; 786 struct wsdisplay_cursor *p; 787 { 788 #define cc (&sc->sc_cursor) 789 int v, index, count, icount; 790 791 v = p->which; 792 if (v & WSDISPLAY_CURSOR_DOCMAP) { 793 index = p->cmap.index; 794 count = p->cmap.count; 795 if (index >= 2 || (index + count) > 2) 796 return (EINVAL); 797 if (!uvm_useracc(p->cmap.red, count, B_READ) || 798 !uvm_useracc(p->cmap.green, count, B_READ) || 799 !uvm_useracc(p->cmap.blue, count, B_READ)) 800 return (EFAULT); 801 } 802 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 803 if (p->size.x > CURSOR_MAX_SIZE || p->size.y > CURSOR_MAX_SIZE) 804 return (EINVAL); 805 icount = ((p->size.x < 33) ? 4 : 8) * p->size.y; 806 if (!uvm_useracc(p->image, icount, B_READ) || 807 !uvm_useracc(p->mask, icount, B_READ)) 808 return (EFAULT); 809 } 810 if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) { 811 if (v & WSDISPLAY_CURSOR_DOCUR) 812 cc->cc_hot = p->hot; 813 if (v & WSDISPLAY_CURSOR_DOPOS) 814 set_curpos(sc, &p->pos); 815 bt431_set_curpos(sc); 816 } 817 818 sc->sc_changed = 0; 819 if (v & WSDISPLAY_CURSOR_DOCUR) { 820 sc->sc_curenb = p->enable; 821 sc->sc_changed |= DATA_ENB_CHANGED; 822 } 823 if (v & WSDISPLAY_CURSOR_DOCMAP) { 824 copyin(p->cmap.red, &cc->cc_color[index], count); 825 copyin(p->cmap.green, &cc->cc_color[index + 2], count); 826 copyin(p->cmap.blue, &cc->cc_color[index + 4], count); 827 sc->sc_changed |= DATA_CURCMAP_CHANGED; 828 } 829 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 830 cc->cc_size = p->size; 831 memset(cc->cc_image, 0, sizeof cc->cc_image); 832 copyin(p->image, cc->cc_image, icount); 833 copyin(p->mask, cc->cc_image+CURSOR_MAX_SIZE, icount); 834 sc->sc_changed |= DATA_CURSHAPE_CHANGED; 835 } 836 837 return (0); 838 #undef cc 839 } 840 841 static int 842 get_cursor(sc, p) 843 struct tfb_softc *sc; 844 struct wsdisplay_cursor *p; 845 { 846 return (ENOTTY); /* XXX */ 847 } 848 849 static void 850 set_curpos(sc, curpos) 851 struct tfb_softc *sc; 852 struct wsdisplay_curpos *curpos; 853 { 854 struct fb_devconfig *dc = sc->sc_dc; 855 int x = curpos->x, y = curpos->y; 856 857 if (y < 0) 858 y = 0; 859 else if (y > dc->dc_ht) 860 y = dc->dc_ht; 861 if (x < 0) 862 x = 0; 863 else if (x > dc->dc_wid) 864 x = dc->dc_wid; 865 sc->sc_cursor.cc_pos.x = x; 866 sc->sc_cursor.cc_pos.y = y; 867 } 868 869 void 870 bt431_set_curpos(sc) 871 struct tfb_softc *sc; 872 { 873 caddr_t tfbbase = (caddr_t)sc->sc_dc->dc_vaddr; 874 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 875 u_int16_t twin; 876 int x, y, s; 877 878 x = sc->sc_cursor.cc_pos.x - sc->sc_cursor.cc_hot.x; 879 y = sc->sc_cursor.cc_pos.y - sc->sc_cursor.cc_hot.y; 880 881 x += sc->sc_cursor.cc_magic.x; 882 y += sc->sc_cursor.cc_magic.y; 883 884 s = spltty(); 885 886 SELECT431(curs, BT431_REG_CURSOR_X_LOW); 887 HALF(curs, bt_ctl) = TWIN_LO(x); tc_wmb(); 888 HALF(curs, bt_ctl) = TWIN_HI(x); tc_wmb(); 889 HALF(curs, bt_ctl) = TWIN_LO(y); tc_wmb(); 890 HALF(curs, bt_ctl) = TWIN_HI(y); tc_wmb(); 891 892 splx(s); 893 } 894
Indexes created Mon Oct 13 04:09:54 GMT 2025