tfb.c revision 1.17
1 /* $NetBSD: tfb.c,v 1.17 1999/08/25 07:56:22 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.17 1999/08/25 07:56:22 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 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 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_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 */ 0x19980910; 438 printf("WSDISPLAYIO_GTYPE: %d\n", *(u_int *)data); 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_8BPP_SIZE || offset < 0) 505 return (-1); 506 return machine_btop(sc->sc_dc->dc_paddr + TX_8BPP_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 = (caddr_t)sc->sc_dc->dc_vaddr; 575 void *vdac, *curs; 576 int v; 577 578 *(u_int8_t *)(tfbbase + TX_CONTROL) &= ~0x40; 579 if (sc->sc_changed == 0) 580 goto done; 581 582 vdac = (void *)(tfbbase + TX_BT463_OFFSET); 583 curs = (void *)(tfbbase + TX_BT431_OFFSET); 584 v = sc->sc_changed; 585 sc->sc_changed = 0; 586 if (v & DATA_ENB_CHANGED) { 587 SELECT431(curs, BT431_REG_COMMAND); 588 HALF(curs, bt_ctl) = (sc->sc_curenb) ? 0x4444 : 0x0404; 589 } 590 if (v & DATA_CURCMAP_CHANGED) { 591 u_int8_t *cp = sc->sc_cursor.cc_color; 592 593 SELECT463(vdac, BT463_IREG_CURSOR_COLOR_0); 594 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 595 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 596 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 597 598 BYTE(vdac, bt_reg) = cp[0]; tc_wmb(); 599 BYTE(vdac, bt_reg) = cp[2]; tc_wmb(); 600 BYTE(vdac, bt_reg) = cp[4]; tc_wmb(); 601 602 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 603 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 604 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 605 606 BYTE(vdac, bt_reg) = cp[1]; tc_wmb(); 607 BYTE(vdac, bt_reg) = cp[3]; tc_wmb(); 608 BYTE(vdac, bt_reg) = cp[5]; tc_wmb(); 609 } 610 if (v & DATA_CURSHAPE_CHANGED) { 611 u_int8_t *ip, *mp, img, msk; 612 int bcnt; 613 614 ip = (u_int8_t *)sc->sc_cursor.cc_image; 615 mp = (u_int8_t *)(sc->sc_cursor.cc_image + CURSOR_MAX_SIZE); 616 bcnt = 0; 617 SELECT431(curs, BT431_REG_CRAM_BASE); 618 619 /* 64 pixel scan line is consisted with 16 byte cursor ram */ 620 while (bcnt < sc->sc_cursor.cc_size.y * 16) { 621 /* pad right half 32 pixel when smaller than 33 */ 622 if ((bcnt & 0x8) && sc->sc_cursor.cc_size.x < 33) { 623 HALF(curs, bt_ram) = 0; 624 tc_wmb(); 625 } 626 else { 627 img = *ip++; 628 msk = *mp++; 629 img &= msk; /* cookie off image */ 630 HALF(curs, bt_ram) 631 = (flip[img] << 8) | flip[msk]; 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 done: 655 *(u_int8_t *)(tfbbase + TX_CONTROL) &= ~0x40; /* !? Eeeh !? */ 656 *(u_int8_t *)(tfbbase + TX_CONTROL) |= 0x40; 657 return (1); 658 } 659 660 void 661 tfbinit(dc) 662 struct fb_devconfig *dc; 663 { 664 caddr_t tfbbase = (caddr_t)dc->dc_vaddr; 665 void *vdac = (void *)(tfbbase + TX_BT463_OFFSET); 666 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 667 int i; 668 669 SELECT463(vdac, BT463_IREG_COMMAND_0); 670 BYTE(vdac, bt_reg) = 0x40; tc_wmb(); /* CMD 0 */ 671 BYTE(vdac, bt_reg) = 0x46; tc_wmb(); /* CMD 1 */ 672 BYTE(vdac, bt_reg) = 0xc0; tc_wmb(); /* CMD 2 */ 673 BYTE(vdac, bt_reg) = 0; tc_wmb(); /* !? 204 !? */ 674 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 0:7 */ 675 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 8:15 */ 676 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 16:23 */ 677 BYTE(vdac, bt_reg) = 0xff; tc_wmb(); /* plane 24:27 */ 678 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 0:7 */ 679 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 8:15 */ 680 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 16:23 */ 681 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); /* blink 24:27 */ 682 BYTE(vdac, bt_reg) = 0x00; tc_wmb(); 683 684 #if 0 /* XXX ULTRIX does initialize 16 entry window type here XXX */ 685 { 686 static u_int32_t windowtype[BT463_IREG_WINDOW_TYPE_TABLE] = { 687 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 688 }; 689 690 SELECT463(vdac, BT463_IREG_WINDOW_TYPE_TABLE); 691 for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) { 692 BYTE(vdac, bt_reg) = windowtype[i]; /* 0:7 */ 693 BYTE(vdac, bt_reg) = windowtype[i] >> 8; /* 8:15 */ 694 BYTE(vdac, bt_reg) = windowtype[i] >> 16; /* 16:23 */ 695 } 696 } 697 #endif 698 699 SELECT463(vdac, BT463_IREG_CPALETTE_RAM); 700 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 701 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 702 BYTE(vdac, bt_cmap) = 0; tc_wmb(); 703 for (i = 1; i < 256; i++) { 704 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 705 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 706 BYTE(vdac, bt_cmap) = 0xff; tc_wmb(); 707 } 708 709 /* !? Eeeh !? */ 710 SELECT463(vdac, 0x0100 /* BT463_IREG_CURSOR_COLOR_0 */); 711 for (i = 0; i < 256; i++) { 712 BYTE(vdac, bt_cmap) = i; tc_wmb(); 713 BYTE(vdac, bt_cmap) = i; tc_wmb(); 714 BYTE(vdac, bt_cmap) = i; tc_wmb(); 715 } 716 717 SELECT431(curs, BT431_REG_COMMAND); 718 HALF(curs, bt_ctl) = 0x0404; tc_wmb(); 719 HALF(curs, bt_ctl) = 0; /* XLO */ tc_wmb(); 720 HALF(curs, bt_ctl) = 0; /* XHI */ tc_wmb(); 721 HALF(curs, bt_ctl) = 0; /* YLO */ tc_wmb(); 722 HALF(curs, bt_ctl) = 0; /* YHI */ tc_wmb(); 723 HALF(curs, bt_ctl) = 0; /* XWLO */ tc_wmb(); 724 HALF(curs, bt_ctl) = 0; /* XWHI */ tc_wmb(); 725 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 726 HALF(curs, bt_ctl) = 0; /* WYLO */ tc_wmb(); 727 HALF(curs, bt_ctl) = 0; /* WWLO */ tc_wmb(); 728 HALF(curs, bt_ctl) = 0; /* WWHI */ tc_wmb(); 729 HALF(curs, bt_ctl) = 0; /* WHLO */ tc_wmb(); 730 HALF(curs, bt_ctl) = 0; /* WHHI */ tc_wmb(); 731 732 SELECT431(curs, BT431_REG_CRAM_BASE); 733 for (i = 0; i < 512; i++) { 734 HALF(curs, bt_ram) = 0; tc_wmb(); 735 } 736 } 737 738 static int 739 get_cmap(sc, p) 740 struct tfb_softc *sc; 741 struct wsdisplay_cmap *p; 742 { 743 u_int index = p->index, count = p->count; 744 745 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 746 return (EINVAL); 747 748 if (!uvm_useracc(p->red, count, B_WRITE) || 749 !uvm_useracc(p->green, count, B_WRITE) || 750 !uvm_useracc(p->blue, count, B_WRITE)) 751 return (EFAULT); 752 753 copyout(&sc->sc_cmap.r[index], p->red, count); 754 copyout(&sc->sc_cmap.g[index], p->green, count); 755 copyout(&sc->sc_cmap.b[index], p->blue, count); 756 757 return (0); 758 } 759 760 static int 761 set_cmap(sc, p) 762 struct tfb_softc *sc; 763 struct wsdisplay_cmap *p; 764 { 765 u_int index = p->index, count = p->count; 766 767 if (index >= CMAP_SIZE || (index + count) > CMAP_SIZE) 768 return (EINVAL); 769 770 if (!uvm_useracc(p->red, count, B_READ) || 771 !uvm_useracc(p->green, count, B_READ) || 772 !uvm_useracc(p->blue, count, B_READ)) 773 return (EFAULT); 774 775 copyin(p->red, &sc->sc_cmap.r[index], count); 776 copyin(p->green, &sc->sc_cmap.g[index], count); 777 copyin(p->blue, &sc->sc_cmap.b[index], count); 778 779 sc->sc_changed |= DATA_CMAP_CHANGED; 780 781 return (0); 782 } 783 784 static int 785 set_cursor(sc, p) 786 struct tfb_softc *sc; 787 struct wsdisplay_cursor *p; 788 { 789 #define cc (&sc->sc_cursor) 790 int v, index, count, icount; 791 792 v = p->which; 793 if (v & WSDISPLAY_CURSOR_DOCMAP) { 794 index = p->cmap.index; 795 count = p->cmap.count; 796 if (index >= 2 || (index + count) > 2) 797 return (EINVAL); 798 if (!uvm_useracc(p->cmap.red, count, B_READ) || 799 !uvm_useracc(p->cmap.green, count, B_READ) || 800 !uvm_useracc(p->cmap.blue, count, B_READ)) 801 return (EFAULT); 802 } 803 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 804 if (p->size.x > CURSOR_MAX_SIZE || p->size.y > CURSOR_MAX_SIZE) 805 return (EINVAL); 806 icount = ((p->size.x < 33) ? 4 : 8) * p->size.y; 807 if (!uvm_useracc(p->image, icount, B_READ) || 808 !uvm_useracc(p->mask, icount, B_READ)) 809 return (EFAULT); 810 } 811 if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) { 812 if (v & WSDISPLAY_CURSOR_DOCUR) 813 cc->cc_hot = p->hot; 814 if (v & WSDISPLAY_CURSOR_DOPOS) 815 set_curpos(sc, &p->pos); 816 bt431_set_curpos(sc); 817 } 818 819 sc->sc_changed = 0; 820 if (v & WSDISPLAY_CURSOR_DOCUR) { 821 sc->sc_curenb = p->enable; 822 sc->sc_changed |= DATA_ENB_CHANGED; 823 } 824 if (v & WSDISPLAY_CURSOR_DOCMAP) { 825 copyin(p->cmap.red, &cc->cc_color[index], count); 826 copyin(p->cmap.green, &cc->cc_color[index + 2], count); 827 copyin(p->cmap.blue, &cc->cc_color[index + 4], count); 828 sc->sc_changed |= DATA_CURCMAP_CHANGED; 829 } 830 if (v & WSDISPLAY_CURSOR_DOSHAPE) { 831 cc->cc_size = p->size; 832 memset(cc->cc_image, 0, sizeof cc->cc_image); 833 copyin(p->image, cc->cc_image, icount); 834 copyin(p->mask, cc->cc_image+CURSOR_MAX_SIZE, icount); 835 sc->sc_changed |= DATA_CURSHAPE_CHANGED; 836 } 837 838 return (0); 839 #undef cc 840 } 841 842 static int 843 get_cursor(sc, p) 844 struct tfb_softc *sc; 845 struct wsdisplay_cursor *p; 846 { 847 return (ENOTTY); /* XXX */ 848 } 849 850 static void 851 set_curpos(sc, curpos) 852 struct tfb_softc *sc; 853 struct wsdisplay_curpos *curpos; 854 { 855 struct fb_devconfig *dc = sc->sc_dc; 856 int x = curpos->x, y = curpos->y; 857 858 if (y < 0) 859 y = 0; 860 else if (y > dc->dc_ht) 861 y = dc->dc_ht; 862 if (x < 0) 863 x = 0; 864 else if (x > dc->dc_wid) 865 x = dc->dc_wid; 866 sc->sc_cursor.cc_pos.x = x; 867 sc->sc_cursor.cc_pos.y = y; 868 } 869 870 void 871 bt431_set_curpos(sc) 872 struct tfb_softc *sc; 873 { 874 caddr_t tfbbase = (caddr_t)sc->sc_dc->dc_vaddr; 875 void *curs = (void *)(tfbbase + TX_BT431_OFFSET); 876 u_int16_t twin; 877 int x, y, s; 878 879 x = sc->sc_cursor.cc_pos.x - sc->sc_cursor.cc_hot.x; 880 y = sc->sc_cursor.cc_pos.y - sc->sc_cursor.cc_hot.y; 881 882 x += sc->sc_cursor.cc_magic.x; 883 y += sc->sc_cursor.cc_magic.y; 884 885 s = spltty(); 886 887 SELECT431(curs, BT431_REG_CURSOR_X_LOW); 888 HALF(curs, bt_ctl) = TWIN_LO(x); tc_wmb(); 889 HALF(curs, bt_ctl) = TWIN_HI(x); tc_wmb(); 890 HALF(curs, bt_ctl) = TWIN_LO(y); tc_wmb(); 891 HALF(curs, bt_ctl) = TWIN_HI(y); tc_wmb(); 892 893 splx(s); 894 } 895
Indexes created Mon Oct 13 16:09:52 GMT 2025