tfb.c revision 1.13
1 /* $NetBSD: tfb.c,v 1.13 1999/06/25 03:33:21 nisimura 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.13 1999/06/25 03:33:21 nisimura 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 image 79 * u_int8_t u1; for sprite mask 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_ram 2 129 #define bt_ctl 3 130 131 /* Bt431 hardware registers */ 132 #define bt_reg 2 133 #define bt_cmap 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 220 198 #define TX_MAGIC_Y 35 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_8FB_OFFSET 0x200000 207 #define TX_8FB_SIZE 0x100000 208 #define TX_24FB_OFFSET 0x400000 209 #define TX_24FB_SIZE 0x400000 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 0 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_8FB_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, %dbpp\n", sc->sc_dc->dc_wid, sc->sc_dc->dc_ht, 402 sc->sc_dc->dc_depth); 403 404 cm = &sc->sc_cmap; 405 memset(cm, 255, sizeof(struct hwcmap256)); /* XXX */ 406 cm->r[0] = cm->g[0] = cm->b[0] = 0; /* XXX */ 407 408 sc->sc_cursor.cc_magic.x = TX_MAGIC_X; 409 sc->sc_cursor.cc_magic.y = TX_MAGIC_Y; 410 411 tc_intr_establish(parent, ta->ta_cookie, TC_IPL_TTY, tfbintr, sc); 412 413 *(u_int8_t *)(sc->sc_dc->dc_vaddr + TX_CONTROL) &= ~0x40; 414 *(u_int8_t *)(sc->sc_dc->dc_vaddr + TX_CONTROL) |= 0x40; 415 416 waa.console = console; 417 waa.scrdata = &tfb_screenlist; 418 waa.accessops = &tfb_accessops; 419 waa.accesscookie = sc; 420 421 config_found(self, &waa, wsemuldisplaydevprint); 422 } 423 424 int 425 tfbioctl(v, cmd, data, flag, p) 426 void *v; 427 u_long cmd; 428 caddr_t data; 429 int flag; 430 struct proc *p; 431 { 432 struct tfb_softc *sc = v; 433 struct fb_devconfig *dc = sc->sc_dc; 434 int turnoff; 435 436 switch (cmd) { 437 case WSDISPLAYIO_GTYPE: 438 *(u_int *)data = /* WSDISPLAY_TYPE_TX */ 0x19980910; 439 return (0); 440 441 case WSDISPLAYIO_GINFO: 442 #define wsd_fbip ((struct wsdisplay_fbinfo *)data) 443 wsd_fbip->height = sc->sc_dc->dc_ht; 444 wsd_fbip->width = sc->sc_dc->dc_wid; 445 wsd_fbip->depth = sc->sc_dc->dc_depth; 446 wsd_fbip->cmsize = CMAP_SIZE; 447 #undef fbt 448 return (0); 449 450 case WSDISPLAYIO_GETCMAP: 451 return get_cmap(sc, (struct wsdisplay_cmap *)data); 452 453 case WSDISPLAYIO_PUTCMAP: 454 return set_cmap(sc, (struct wsdisplay_cmap *)data); 455 456 case WSDISPLAYIO_SVIDEO: 457 turnoff = *(int *)data == WSDISPLAYIO_VIDEO_OFF; 458 if ((dc->dc_blanked == 0) ^ turnoff) { 459 dc->dc_blanked = turnoff; 460 #if 0 /* XXX later XXX */ 461 To turn off; 462 - clear the MSB of TX control register; &= ~0x80, 463 - assign Bt431 register #0 with value 0x4 to hide sprite cursor. 464 #endif /* XXX XXX XXX */ 465 } 466 return (0); 467 468 case WSDISPLAYIO_GVIDEO: 469 *(u_int *)data = dc->dc_blanked ? 470 WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON; 471 return (0); 472 473 case WSDISPLAYIO_GCURPOS: 474 *(struct wsdisplay_curpos *)data = sc->sc_cursor.cc_pos; 475 return (0); 476 477 case WSDISPLAYIO_SCURPOS: 478 set_curpos(sc, (struct wsdisplay_curpos *)data); 479 bt431_set_curpos(sc); 480 return (0); 481 482 case WSDISPLAYIO_GCURMAX: 483 ((struct wsdisplay_curpos *)data)->x = 484 ((struct wsdisplay_curpos *)data)->y = CURSOR_MAX_SIZE; 485 return (0); 486 487 case WSDISPLAYIO_GCURSOR: 488 return get_cursor(sc, (struct wsdisplay_cursor *)data); 489 490 case WSDISPLAYIO_SCURSOR: 491 return set_cursor(sc, (struct wsdisplay_cursor *)data); 492 } 493 return (ENOTTY); 494 } 495 496 int 497 tfbmmap(v, offset, prot) 498 void *v; 499 off_t offset; 500 int prot; 501 { 502 struct tfb_softc *sc = v; 503 504 if (offset >= TX_8FB_SIZE || offset < 0) 505 return (-1); 506 return machine_btop(sc->sc_dc->dc_paddr + TX_8FB_OFFSET + offset); 507 } 508 509 int 510 tfb_alloc_screen(v, type, cookiep, curxp, curyp, attrp) 511 void *v; 512 const struct wsscreen_descr *type; 513 void **cookiep; 514 int *curxp, *curyp; 515 long *attrp; 516 { 517 struct tfb_softc *sc = v; 518 long defattr; 519 520 if (sc->nscreens > 0) 521 return (ENOMEM); 522 523 *cookiep = &sc->sc_dc->dc_rcons; /* one and only for now */ 524 *curxp = 0; 525 *curyp = 0; 526 rcons_alloc_attr(&sc->sc_dc->dc_rcons, 0, 0, 0, &defattr); 527 *attrp = defattr; 528 sc->nscreens++; 529 return (0); 530 } 531 532 void 533 tfb_free_screen(v, cookie) 534 void *v; 535 void *cookie; 536 { 537 struct tfb_softc *sc = v; 538 539 if (sc->sc_dc == &tfb_console_dc) 540 panic("tfb_free_screen: console"); 541 542 sc->nscreens--; 543 } 544 545 void 546 tfb_show_screen(v, cookie) 547 void *v; 548 void *cookie; 549 { 550 } 551 552 int 553 tfb_cnattach(addr) 554 tc_addr_t addr; 555 { 556 struct fb_devconfig *dcp = &tfb_console_dc; 557 long defattr; 558 559 tfb_getdevconfig(addr, dcp); 560 561 rcons_alloc_attr(&dcp->dc_rcons, 0, 0, 0, &defattr); 562 563 wsdisplay_cnattach(&tfb_stdscreen, &dcp->dc_rcons, 564 0, 0, defattr); 565 tfb_consaddr = addr; 566 return(0); 567 } 568 569 int 570 tfbintr(arg) 571 void *arg; 572 { 573 struct tfb_softc *sc = arg; 574 caddr_t tfbbase; 575 void *vdac, *curs; 576 int v; 577 578 if (sc->sc_changed == 0) 579 return (1); 580 581 tfbbase = (caddr_t)sc->sc_dc->dc_vaddr; 582 vdac = (void *)(tfbbase + TX_BT463_OFFSET); 583 curs = (void *)(tfbbase + TX_BT431_OFFSET); 584 *(u_int8_t *)(tfbbase + TX_CONTROL) &= ~0x40; 585 v = sc->sc_changed; 586 sc->sc_changed = 0; 587 if (v & DATA_ENB_CHANGED) { 588 SELECT431(curs, BT431_REG_COMMAND); 589 HALF(curs, bt_ctl) = (sc->sc_curenb) ? 0x4444 : 0x0404; 590 } 591 if (v & DATA_CURCMAP_CHANGED) { 592 u_int8_t *cp = sc->sc_cursor.cc_color; 593 594 SELECT463(vdac, BT463_IREG_CURSOR_COLOR_0); 595 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 596 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 597 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 598 599 BYTE(vdac, bt_reg) = cp[0]; tc_wmb(); 600 BYTE(vdac, bt_reg) = cp[2]; tc_wmb(); 601 BYTE(vdac, bt_reg) = cp[4]; tc_wmb(); 602 603 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 604 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 605 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 606 607 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 608 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 609 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 610 } 611 if (v & DATA_CURSHAPE_CHANGED) { 612 u_int8_t *ip, *mp, img, msk; 613 int bcnt; 614 615 ip = (u_int8_t *)sc->sc_cursor.cc_image; 616 mp = (u_int8_t *)(sc->sc_cursor.cc_image + CURSOR_MAX_SIZE); 617 618 bcnt = 0; 619 SELECT431(curs, BT431_REG_CRAM_BASE+0); 620 /* 64 pixel scan line is consisted with 16 byte cursor ram */ 621 while (bcnt < sc->sc_cursor.cc_size.y * 16) { 622 /* pad right half 32 pixel when smaller than 33 */ 623 if ((bcnt & 0x8) && sc->sc_cursor.cc_size.x < 33) { 624 HALF(curs, bt_ram) = 0; 625 tc_wmb(); 626 } 627 else { 628 img = *ip++; 629 msk = *mp++; 630 img &= msk; /* cookie off image */ 631 HALF(curs, bt_ram) = (flip[msk] << 8) | flip[img]; 632 tc_wmb(); 633 } 634 bcnt += 2; 635 } 636 /* pad unoccupied scan lines */ 637 while (bcnt < CURSOR_MAX_SIZE * 16) { 638 HALF(curs, bt_ram) = 0; 639 tc_wmb(); 640 bcnt += 2; 641 } 642 } 643 if (v & DATA_CMAP_CHANGED) { 644 struct hwcmap256 *cm = &sc->sc_cmap; 645 int index; 646 647 SELECT463(vdac, BT463_IREG_CPALETTE_RAM); 648 for (index = 0; index < CMAP_SIZE; index++) { 649 BYTE(vdac, bt_cmap) = cm->r[index]; 650 BYTE(vdac, bt_cmap) = cm->g[index]; 651 BYTE(vdac, bt_cmap) = cm->b[index]; 652 } 653 } 654 *(u_int8_t *)(tfbbase + TX_CONTROL) |= 0x40; 655 return (1); 656 } 657 658 void 659 tfbinit(dc) 660 struct fb_devconfig *dc; 661 { 662 caddr_t tfbbase = (caddr_t)dc->dc_vaddr; 663 void *vdac = (void *)(tfbbase + TX_BT463_OFFSET); 664 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 665 int i; 666 667 SELECT463(vdac, BT463_IREG_COMMAND_0); 668 BYTE(vdac, bt_reg) = 0x40; tc_wmb(); 669 BYTE(vdac, bt_reg) = 0x46; tc_wmb(); 670 BYTE(vdac, bt_reg) = 0xc0; tc_wmb(); 671 BYTE(vdac, bt_reg) = 0; tc_wmb(); /* !? 204 !? */ 672 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 0:7 */ 673 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 8:15 */ 674 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 16:23 */ 675 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 24:27 */ 676 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 0:7 */ 677 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 8:15 */ 678 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 16:23 */ 679 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 24:27 */ 680 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); 681 682 #if 0 /* XXX WHAT'S TX REALLY DOING HERE? XXX */ 683 { 684 static struct { 685 u_int8_t x, y, z, u; 686 } windowtype[BT463_IREG_WINDOW_TYPE_TABLE] = { 687 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, 688 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, 689 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, 690 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, 691 }; 692 693 SELECT463(vdac, BT463_IREG_WINDOW_TYPE_TABLE); 694 for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) { 695 BYTE(vdac, bt_reg) = windowtype[i].x; 696 BYTE(vdac, bt_reg) = windowtype[i].y; 697 BYTE(vdac, bt_reg) = windowtype[i].z; 698 } 699 } 700 #endif 701 702 SELECT463(vdac, BT463_IREG_CPALETTE_RAM); 703 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 704 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 705 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 706 for (i = 1; i < 256; i++) { 707 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 708 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 709 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 710 } 711 712 SELECT463(vdac, BT463_IREG_CURSOR_COLOR_0); 713 BYTE(vdac, bt_reg) = 0; tc_wmb(); 714 BYTE(vdac, bt_reg) = 0; tc_wmb(); 715 BYTE(vdac, bt_reg) = 0; tc_wmb(); 716 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); 717 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); 718 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); 719 for (i = 2; i < 256; i++) { 720 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 721 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 722 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 723 } 724 725 SELECT431(curs, BT431_REG_COMMAND); 726 HALF(curs, bt_ctl) = 0x0404; tc_wmb(); 727 HALF(curs, bt_ctl) = 0; /* XLO */ tc_wmb(); 728 HALF(curs, bt_ctl) = 0; /* XHI */ tc_wmb(); 729 HALF(curs, bt_ctl) = 0; /* YLO */ tc_wmb(); 730 HALF(curs, bt_ctl) = 0; /* YHI */ tc_wmb(); 731 HALF(curs, bt_ctl) = 0; /* XWLO */ tc_wmb(); 732 HALF(curs, bt_ctl) = 0; /* XWHI */ tc_wmb(); 733 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 734 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 735 HALF(curs, bt_ctl) = 0; /* WWLO */ tc_wmb(); 736 HALF(curs, bt_ctl) = 0; /* WWHI */ tc_wmb(); 737 HALF(curs, bt_ctl) = 0; /* WHLO */ tc_wmb(); 738 HALF(curs, bt_ctl) = 0; /* WHHI */ tc_wmb(); 739 740 SELECT431(curs, BT431_REG_CRAM_BASE); 741 for (i = 0; i < 512; i++) { 742 HALF(curs, bt_ram) = 0; tc_wmb(); 743 } 744 } 745 746 static int 747 get_cmap(sc, p) 748 struct tfb_softc *sc; 749 struct wsdisplay_cmap *p; 750 { 751 u_int index = p->index, count = p->count; 752 753 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 754 return (EINVAL); 755 756 if (!uvm_useracc(p->red, count, B_WRITE) || 757 !uvm_useracc(p->green, count, B_WRITE) || 758 !uvm_useracc(p->blue, count, B_WRITE)) 759 return (EFAULT); 760 761 copyout(&sc->sc_cmap.r[index], p->red, count); 762 copyout(&sc->sc_cmap.g[index], p->green, count); 763 copyout(&sc->sc_cmap.b[index], p->blue, count); 764 765 return (0); 766 } 767 768 static int 769 set_cmap(sc, p) 770 struct tfb_softc *sc; 771 struct wsdisplay_cmap *p; 772 { 773 u_int index = p->index, count = p->count; 774 775 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 776 return (EINVAL); 777 778 if (!uvm_useracc(p->red, count, B_READ) || 779 !uvm_useracc(p->green, count, B_READ) || 780 !uvm_useracc(p->blue, count, B_READ)) 781 return (EFAULT); 782 783 copyin(p->red, &sc->sc_cmap.r[index], count); 784 copyin(p->green, &sc->sc_cmap.g[index], count); 785 copyin(p->blue, &sc->sc_cmap.b[index], count); 786 787 sc->sc_changed |= DATA_CMAP_CHANGED; 788 789 return (0); 790 } 791 792 static int 793 set_cursor(sc, p) 794 struct tfb_softc *sc; 795 struct wsdisplay_cursor *p; 796 { 797 #define cc (&sc->sc_cursor) 798 int v, index, count, icount; 799 800 v = p->which; 801 if (v & WSDISPLAY_CURSOR_DOCMAP) { 802 index = p->cmap.index; 803 count = p->cmap.count; 804 if (index >= 2 || (index + count) > 2) 805 return (EINVAL); 806 if (!uvm_useracc(p->cmap.red, count, B_READ) || 807 !uvm_useracc(p->cmap.green, count, B_READ) || 808 !uvm_useracc(p->cmap.blue, count, B_READ)) 809 return (EFAULT); 810 } 811 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 812 if (p->size.x > CURSOR_MAX_SIZE || p->size.y > CURSOR_MAX_SIZE) 813 return (EINVAL); 814 icount = ((p->size.x < 33) ? 4 : 8) * p->size.y; 815 if (!uvm_useracc(p->image, icount, B_READ) || 816 !uvm_useracc(p->mask, icount, B_READ)) 817 return (EFAULT); 818 } 819 if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) { 820 if (v & WSDISPLAY_CURSOR_DOCUR) 821 cc->cc_hot = p->hot; 822 if (v & WSDISPLAY_CURSOR_DOPOS) 823 set_curpos(sc, &p->pos); 824 bt431_set_curpos(sc); 825 } 826 827 sc->sc_changed = 0; 828 if (v & WSDISPLAY_CURSOR_DOCUR) { 829 sc->sc_curenb = p->enable; 830 sc->sc_changed |= DATA_ENB_CHANGED; 831 } 832 if (v & WSDISPLAY_CURSOR_DOCMAP) { 833 copyin(p->cmap.red, &cc->cc_color[index], count); 834 copyin(p->cmap.green, &cc->cc_color[index + 2], count); 835 copyin(p->cmap.blue, &cc->cc_color[index + 4], count); 836 sc->sc_changed |= DATA_CURCMAP_CHANGED; 837 } 838 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 839 cc->cc_size = p->size; 840 memset(cc->cc_image, 0, sizeof cc->cc_image); 841 copyin(p->image, cc->cc_image, icount); 842 copyin(p->mask, cc->cc_image+CURSOR_MAX_SIZE, icount); 843 sc->sc_changed |= DATA_CURSHAPE_CHANGED; 844 } 845 846 return (0); 847 #undef cc 848 } 849 850 static int 851 get_cursor(sc, p) 852 struct tfb_softc *sc; 853 struct wsdisplay_cursor *p; 854 { 855 return (ENOTTY); /* XXX */ 856 } 857 858 static void 859 set_curpos(sc, curpos) 860 struct tfb_softc *sc; 861 struct wsdisplay_curpos *curpos; 862 { 863 struct fb_devconfig *dc = sc->sc_dc; 864 int x = curpos->x, y = curpos->y; 865 866 if (y < 0) 867 y = 0; 868 else if (y > dc->dc_ht) 869 y = dc->dc_ht; 870 if (x < 0) 871 x = 0; 872 else if (x > dc->dc_wid) 873 x = dc->dc_wid; 874 sc->sc_cursor.cc_pos.x = x; 875 sc->sc_cursor.cc_pos.y = y; 876 } 877 878 void 879 bt431_set_curpos(sc) 880 struct tfb_softc *sc; 881 { 882 caddr_t tfbbase = (caddr_t)sc->sc_dc->dc_vaddr; 883 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 884 u_int16_t twin; 885 int x, y, s; 886 887 x = sc->sc_cursor.cc_pos.x - sc->sc_cursor.cc_hot.x; 888 y = sc->sc_cursor.cc_pos.y - sc->sc_cursor.cc_hot.y; 889 890 x += sc->sc_cursor.cc_magic.x; 891 y += sc->sc_cursor.cc_magic.y; 892 893 s = spltty(); 894 895 SELECT431(curs, BT431_REG_CURSOR_X_LOW); 896 HALF(curs, bt_ctl) = TWIN_LO(x); tc_wmb(); 897 HALF(curs, bt_ctl) = TWIN_HI(x); tc_wmb(); 898 HALF(curs, bt_ctl) = TWIN_LO(y); tc_wmb(); 899 HALF(curs, bt_ctl) = TWIN_HI(y); tc_wmb(); 900 901 splx(s); 902 } 903
Indexes created Mon Oct 13 00:09:54 GMT 2025