lcg.c revision 1.1
1 /* $NetBSD: lcg.c,v 1.1 2014/12/16 11:34:17 jklos Exp $ */ 2 /* 3 * LCG accelerated framebuffer driver 4 * Copyright (c) 2003, 2004 Blaz Antonic 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the abovementioned copyrights 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /* 32 * Resurrection and dumb framebuffer mode by Bjrn Johannesson 33 * rherdware (at) yahoo.com in December 2014 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: lcg.c,v 1.1 2014/12/16 11:34:17 jklos Exp $"); 38 39 #define LCG_NO_ACCEL 40 41 #include <sys/param.h> 42 #include <sys/device.h> 43 #include <sys/systm.h> 44 #include <sys/callout.h> 45 #include <sys/time.h> 46 #include <sys/malloc.h> 47 #include <sys/conf.h> 48 #include <sys/kernel.h> 49 #include <sys/systm.h> 50 51 #include <machine/vsbus.h> 52 #include <machine/sid.h> 53 #include <machine/cpu.h> 54 #include <machine/lcgreg.h> 55 56 #include <dev/cons.h> 57 58 #include <dev/dec/dzreg.h> 59 #include <dev/dec/dzvar.h> 60 #include <dev/dec/dzkbdvar.h> 61 62 #include <dev/wscons/wsdisplayvar.h> 63 #include <dev/wscons/wsconsio.h> 64 #include <dev/wscons/wscons_callbacks.h> 65 #include <dev/wsfont/wsfont.h> 66 67 #include "machine/scb.h" 68 69 #include "dzkbd.h" 70 71 /* Screen hardware defs */ 72 73 #define LCG_FB_ADDR 0x21801000 /* Frame buffer */ 74 75 /* FIFO defines */ 76 #define LCG_FIFO_SIZE 0x10000 /* 64 KB */ 77 #define LCG_FIFO_WIN_ADDR 0x20180000 78 #define LCG_FIFO_WIN_SIZE VAX_NBPG 79 #define LCG_FIFO_ALIGN 0x10000 80 81 /* font rendering defines */ 82 #define LCG_FONT_ADDR (LCG_FB_ADDR + lcg_fb_size) 83 #define LCG_FONT_STORAGE_SIZE 0x40000 /* 16 KB, enough to accomodate 16x32 font bitmaps */ 84 85 /* register space defines */ 86 #define LCG_REG_ADDR 0x20100000 /* LCG registers */ 87 #define LCG_REG_SIZE 0x4000 /* 16384 bytes */ 88 #define LCG_REG(reg) regaddr[(reg / 4)] 89 90 /* LUT defines */ 91 #define LCG_LUT_ADDR 0x21800800 /* LUT right before onscreen FB */ 92 #define LCG_LUT_OFFSET 0x00000800 93 #define LCG_LUT_SIZE 0x800 /* 2048 bytes */ 94 95 #define LCG_BG_COLOR WSCOL_BLACK 96 #define LCG_FG_COLOR WSCOL_WHITE 97 98 #define LCG_CONFIG 0x200f0010 /* LCG model information */ 99 100 /* implement sanity checks at certain points to ensure safer operation */ 101 #define LCG_SAFE 102 //#define LCG_DEBUG 103 104 static int lcg_match(struct device *, struct cfdata *, void *); 105 static void lcg_attach(struct device *, struct device *, void *); 106 107 struct lcg_softc { 108 struct device ss_dev; 109 bus_dmamap_t sc_dm; 110 }; 111 112 CFATTACH_DECL_NEW(lcg, sizeof(struct lcg_softc), 113 lcg_match, lcg_attach, NULL, NULL); 114 115 static void lcg_cursor(void *, int, int, int); 116 static int lcg_mapchar(void *, int, unsigned int *); 117 static void lcg_putchar(void *, int, int, u_int, long); 118 static void lcg_copycols(void *, int, int, int,int); 119 static void lcg_erasecols(void *, int, int, int, long); 120 static void lcg_copyrows(void *, int, int, int); 121 static void lcg_eraserows(void *, int, int, long); 122 static int lcg_allocattr(void *, int, int, int, long *); 123 static int lcg_get_cmap(struct wsdisplay_cmap *); 124 static int lcg_set_cmap(struct wsdisplay_cmap *); 125 static void lcg_init_common(struct device *, struct vsbus_attach_args *); 126 127 const struct wsdisplay_emulops lcg_emulops = { 128 lcg_cursor, 129 lcg_mapchar, 130 lcg_putchar, 131 lcg_copycols, 132 lcg_erasecols, 133 lcg_copyrows, 134 lcg_eraserows, 135 lcg_allocattr 136 }; 137 138 static char lcg_stdscreen_name[10] = "160x68"; 139 struct wsscreen_descr lcg_stdscreen = { 140 lcg_stdscreen_name, 160, 68, /* dynamically set */ 141 &lcg_emulops, 142 8, 15, /* dynamically set */ 143 WSSCREEN_UNDERLINE|WSSCREEN_REVERSE|WSSCREEN_WSCOLORS, 144 }; 145 146 const struct wsscreen_descr *_lcg_scrlist[] = { 147 &lcg_stdscreen, 148 }; 149 150 const struct wsscreen_list lcg_screenlist = { 151 sizeof(_lcg_scrlist) / sizeof(struct wsscreen_descr *), 152 _lcg_scrlist, 153 }; 154 155 static char *lcgaddr; 156 static char *lutaddr; 157 static volatile long *regaddr; 158 static volatile long *fifoaddr; 159 #ifndef LCG_NO_ACCEL 160 static char *fontaddr; 161 #endif 162 163 static int lcg_xsize; 164 static int lcg_ysize; 165 static int lcg_depth; 166 static int lcg_cols; 167 static int lcg_rows; 168 static int lcg_onerow; 169 static int lcg_fb_size; 170 static int lcg_glyph_size; /* bitmap size in bits */ 171 172 static char *cursor; 173 174 static int cur_on; 175 176 static int cur_fg, cur_bg; 177 178 179 /* Our current hardware colormap */ 180 static struct hwcmap256 { 181 #define CMAP_SIZE 256 /* 256 R/G/B entries */ 182 u_int8_t r[CMAP_SIZE]; 183 u_int8_t g[CMAP_SIZE]; 184 u_int8_t b[CMAP_SIZE]; 185 } lcg_cmap; 186 187 /* The default colormap */ 188 static struct { 189 u_int8_t r[8]; 190 u_int8_t g[8]; 191 u_int8_t b[8]; 192 } lcg_default_cmap = { 193 { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff }, 194 { 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0xff, 0xff }, 195 { 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff } 196 }; 197 198 struct wsdisplay_font lcg_font; 199 static u_char *qf; 200 static u_short *qf2; 201 202 #define QCHAR(c) (c < lcg_font.firstchar ? 0 : \ 203 (c >= (lcg_font.firstchar + lcg_font.numchars) ? 0 : c - lcg_font.firstchar)) 204 #define QFONT(c,line) ((lcg_font.stride == 2 ? \ 205 qf2[QCHAR(c) * lcg_font.fontheight + line] : \ 206 qf[QCHAR(c) * lcg_font.fontheight + line])) 207 #define LCG_ADDR(row, col, line, dot) \ 208 lcgaddr[((col) * lcg_font.fontwidth) + ((row) * lcg_font.fontheight * lcg_xsize) + \ 209 (line) * lcg_xsize + dot] 210 211 212 static int lcg_ioctl(void *, void *, u_long, void *, int, struct lwp *); 213 static paddr_t lcg_mmap(void *, void *, off_t, int); 214 static int lcg_alloc_screen(void *, const struct wsscreen_descr *, 215 void **, int *, int *, long *); 216 static void lcg_free_screen(void *, void *); 217 static int lcg_show_screen(void *, void *, int, 218 void (*) (void *, int, int), void *); 219 static void lcg_crsr_blink(void *); 220 221 /* LCG HW accel functions */ 222 #ifndef LCG_NO_ACCEL 223 static void fifo_put(long data); 224 static int fifo_fill(int iterations); 225 static u_char fifo_counter = 0; 226 227 static void blkcpy(long source, long dest, int xdim, int ydim); 228 static void blkset(long dest, int xdim, int ydim, char color); 229 static void renderchar(long source, long dest, int xdim, int ydim, char fg, char bg); 230 #endif /* LCG_NO_ACCEL */ 231 232 const struct wsdisplay_accessops lcg_accessops = { 233 lcg_ioctl, 234 lcg_mmap, 235 lcg_alloc_screen, 236 lcg_free_screen, 237 lcg_show_screen, 238 0 /* load_font */ 239 }; 240 241 /* TODO allocate ss_image dynamically for consoles beyond first one */ 242 struct lcg_screen { 243 int ss_curx; 244 int ss_cury; 245 int ss_cur_fg; 246 int ss_cur_bg; 247 struct { 248 u_char data; /* Image character */ 249 u_char attr; /* Attribute: 80/70/08/07 */ 250 } ss_image[160 * 128]; /* allow for maximum possible cell matrix */ 251 }; 252 #define LCG_ATTR_UNDERLINE 0x80 253 #define LCG_BG_MASK 0x70 254 #define LCG_ATTR_REVERSE 0x08 255 #define LCG_FG_MASK 0x07 256 257 static struct lcg_screen lcg_conscreen; 258 static struct lcg_screen *curscr; 259 static struct lcg_screen *savescr; 260 261 static callout_t lcg_cursor_ch; 262 263 #ifndef LCG_NO_ACCEL 264 void fifo_put(long data) 265 { 266 fifo_counter &= 0x3; 267 fifoaddr[fifo_counter] = data; 268 fifo_counter++; 269 } 270 271 int fifo_fill(int iterations) 272 { 273 long status; 274 int counter = 0;; 275 276 while (fifo_counter % 4) 277 fifo_put(0); 278 279 #ifdef LCG_SAFE 280 status = LCG_REG(LCG_REG_GRAPHICS_SUB_STATUS); 281 while ((counter < iterations) && ((status & 0x80000000) == 0x80000000)) { 282 delay(1000); 283 status = LCG_REG(LCG_REG_GRAPHICS_SUB_STATUS); 284 counter++; 285 } 286 #endif 287 288 if (counter == 0) 289 return 0; 290 else 291 return 1; 292 } 293 294 void blkcpy(long source, long dest, int xdim, int ydim) 295 { 296 int err; 297 298 #ifdef LCG_SAFE 299 if ((source < LCG_FB_ADDR) || (source > LCG_FB_ADDR + lcg_fb_size)) { 300 printf("lcg: blkcpy: invalid source 0x%lx\n", source); 301 return; 302 } 303 if ((dest < LCG_FB_ADDR) || (dest > LCG_FB_ADDR + lcg_fb_size)) { 304 printf("lcg: blkcpy: invalid destination 0x%lx\n", dest); 305 return; 306 } 307 #endif 308 309 #ifdef LCG_SAFE 310 fifo_put(0x0c010000 | (cur_fg & 0xff)); 311 #endif 312 fifo_put(0x01020006); 313 314 fifo_put(0x06800000); 315 fifo_put(source); 316 fifo_put(lcg_xsize); 317 318 fifo_put(0x05800000); 319 fifo_put(dest); 320 fifo_put(lcg_xsize); 321 322 fifo_put(0x03400000); 323 fifo_put(0xff); 324 325 fifo_put(0x02000003); 326 327 #ifdef LCG_SAFE 328 fifo_put(0x04c00000); 329 fifo_put(0); 330 fifo_put(lcg_xsize); 331 fifo_put(lcg_fb_size - (dest - LCG_FB_ADDR)); 332 #endif 333 334 fifo_put(0x09c00000); 335 fifo_put(((ydim & 0xffff) << 16) | xdim); 336 fifo_put(0); 337 fifo_put(0); 338 339 err = fifo_fill(200); 340 if (err) 341 printf("lcg: AG still busy after 200 msec\n"); 342 } 343 344 void blkset(long dest, int xdim, int ydim, char color) 345 { 346 int err; 347 348 #ifdef LCG_SAFE 349 if ((dest < LCG_FB_ADDR) || (dest > LCG_FB_ADDR + lcg_fb_size)) { 350 printf("lcg: blkset: invalid destination 0x%lx\n", dest); 351 return; 352 } 353 #endif 354 355 fifo_put(0x0c010000 | (color & 0xff)); 356 357 fifo_put(0x01000000); 358 359 fifo_put(0x05800000); 360 fifo_put(dest); 361 fifo_put(lcg_xsize); 362 363 fifo_put(0x03400000); 364 fifo_put(0xff); 365 366 fifo_put(0x02000003); 367 368 #ifdef LCG_SAFE 369 fifo_put(0x04c00000); 370 fifo_put(0); 371 fifo_put(lcg_xsize); 372 fifo_put(lcg_fb_size - (dest - LCG_FB_ADDR)); 373 #endif 374 375 fifo_put(0x09c00000); 376 fifo_put(((ydim & 0xffff) << 16) | xdim); 377 fifo_put(0); 378 fifo_put(0); 379 380 err = fifo_fill(200); 381 if (err) 382 printf("lcg: AG still busy after 200 msec\n"); 383 } 384 385 void renderchar(long source, long dest, int xdim, int ydim, char fg, char bg) 386 { 387 int err; 388 #ifdef LCG_SAFE 389 if ((dest < LCG_FB_ADDR) || (dest > LCG_FB_ADDR + lcg_fb_size)) { 390 printf("lcg: blkset: invalid destination 0x%lx\n", dest); 391 return; 392 } 393 #endif 394 395 fifo_put(0x0c050000 | (bg & 0xff)); 396 fifo_put(0x0c010000 | (fg & 0xff)); 397 398 fifo_put(0x01030008); 399 400 fifo_put(0x06800000); 401 fifo_put(source); 402 //fifo_put(lcg_xsize); 403 fifo_put(lcg_font.stride); 404 405 fifo_put(0x05800000); 406 fifo_put(dest); 407 fifo_put(lcg_xsize); 408 409 fifo_put(0x03400000); 410 fifo_put(0xff); 411 412 fifo_put(0x02000003); 413 414 #ifdef LCG_SAFE 415 fifo_put(0x04c00000); 416 fifo_put(0); 417 fifo_put(lcg_xsize); 418 fifo_put(lcg_fb_size - (dest - LCG_FB_ADDR)); 419 #endif 420 421 fifo_put(0x09c00000); 422 fifo_put(((ydim & 0xffff) << 16) | (xdim & 0xffff)); 423 fifo_put(0); 424 fifo_put(0); 425 426 err = fifo_fill(200); 427 if (err) 428 printf("lcg: AG still busy after 200 msec\n"); 429 } 430 #endif /* LCG_NO_ACCEL */ 431 432 int 433 lcg_match(struct device *parent, struct cfdata *match, void *aux) 434 { 435 struct vsbus_softc *sc = device_private(parent); 436 struct vsbus_attach_args *va = aux; 437 char *ch = (char *)va->va_addr; 438 439 if ((vax_boardtype != VAX_BTYP_46) && (vax_boardtype != VAX_BTYP_48)) 440 return 0; 441 442 *ch = 1; 443 if ((*ch & 1) == 0) 444 return 0; 445 *ch = 0; 446 if ((*ch & 1) != 0) 447 return 0; 448 449 /* XXX use vertical interrupt? */ 450 sc->sc_mask = 0x04; /* XXX - should be generated */ 451 scb_fake(0x120, 0x15); 452 return 20; 453 } 454 455 void 456 lcg_attach(struct device *parent, struct device *self, void *aux) 457 { 458 struct vsbus_attach_args *va = aux; 459 struct wsemuldisplaydev_attach_args aa; 460 461 printf("\n"); 462 aa.console = lcgaddr != NULL; 463 464 lcg_init_common(self, va); 465 466 curscr = &lcg_conscreen; 467 468 aa.scrdata = &lcg_screenlist; 469 aa.accessops = &lcg_accessops; 470 471 /* enable software cursor */ 472 callout_init(&lcg_cursor_ch, 0); 473 callout_reset(&lcg_cursor_ch, hz / 2, lcg_crsr_blink, NULL); 474 475 config_found(self, &aa, wsemuldisplaydevprint); 476 } 477 478 static void 479 lcg_crsr_blink(void *arg) 480 { 481 int dot; 482 483 if (cur_on && curscr != NULL) 484 for (dot = 0; dot < lcg_font.fontwidth; dot++) 485 cursor[dot] = ((cursor[dot] & 0x0f) == cur_fg) ? cur_bg : cur_fg; 486 487 callout_reset(&lcg_cursor_ch, hz / 2, lcg_crsr_blink, NULL); 488 } 489 490 void 491 lcg_cursor(void *id, int on, int row, int col) 492 { 493 struct lcg_screen *ss = id; 494 int dot, attr; 495 496 attr = ss->ss_image[row * lcg_cols + col].attr; 497 if (ss == curscr) { 498 if (cursor != NULL) { 499 int ch = QFONT(ss->ss_image[ss->ss_cury * lcg_cols + 500 ss->ss_curx].data, lcg_font.fontheight - 1); 501 attr = ss->ss_image[ss->ss_cury * lcg_cols + 502 ss->ss_curx].attr; 503 504 if (attr & LCG_ATTR_REVERSE) { 505 cur_bg = attr & LCG_FG_MASK; 506 cur_fg = (attr & LCG_BG_MASK) >> 4; 507 } else { 508 cur_fg = attr & LCG_FG_MASK; 509 cur_bg = (attr & LCG_BG_MASK) >> 4; 510 } 511 for (dot = 0; dot < lcg_font.fontwidth; dot++) 512 cursor[dot] = (ch & (1 << dot)) ? 513 cur_fg : cur_bg; 514 } 515 516 cursor = &LCG_ADDR(row, col, lcg_font.fontheight - 1, 0); 517 cur_on = on; 518 if (attr & LCG_ATTR_REVERSE) { 519 cur_bg = attr & LCG_FG_MASK; 520 cur_fg = (attr & LCG_BG_MASK) >> 4; 521 } else { 522 cur_fg = attr & LCG_FG_MASK; 523 cur_bg = (attr & LCG_BG_MASK) >> 4; 524 } 525 } 526 ss->ss_curx = col; 527 ss->ss_cury = row; 528 if (attr & LCG_ATTR_REVERSE) { 529 ss->ss_cur_bg = attr & LCG_FG_MASK; 530 ss->ss_cur_fg = (attr & LCG_BG_MASK) >> 4; 531 } else { 532 ss->ss_cur_fg = attr & LCG_FG_MASK; 533 ss->ss_cur_bg = (attr & LCG_BG_MASK) >> 4; 534 } 535 } 536 537 int 538 lcg_mapchar(void *id, int uni, unsigned int *index) 539 { 540 if (uni < 256) { 541 *index = uni; 542 return (5); 543 } 544 *index = ' '; 545 return (0); 546 } 547 548 static void 549 lcg_putchar(void *id, int row, int col, u_int c, long attr) 550 { 551 struct lcg_screen *ss = id; 552 int i; 553 char dot_fg, dot_bg; 554 555 c &= 0xff; 556 557 ss->ss_image[row * lcg_cols + col].data = c; 558 ss->ss_image[row * lcg_cols + col].attr = attr; 559 if (ss != curscr) 560 return; 561 562 dot_fg = attr & LCG_FG_MASK; 563 dot_bg = (attr & LCG_BG_MASK) >> 4; 564 if (attr & LCG_ATTR_REVERSE) { 565 dot_fg = (attr & LCG_BG_MASK) >> 4; 566 dot_bg = attr & LCG_FG_MASK; 567 } 568 569 #ifndef LCG_NO_ACCEL 570 renderchar(LCG_FONT_ADDR + (c * lcg_glyph_size), 571 LCG_FB_ADDR + (row * lcg_onerow) + (col * lcg_font.fontwidth), 572 lcg_font.fontwidth, lcg_font.fontheight, dot_fg, dot_bg); 573 #else 574 for (i = 0; i < lcg_font.fontheight; i++) { 575 unsigned char ch = QFONT(c,i); 576 for (int j = 0; j < lcg_font.fontwidth; j++) { 577 LCG_ADDR(row, col, i, j) = ((ch >> j) & 1) ? dot_fg : dot_bg; 578 } 579 } 580 #endif /* LCG_NO_ACCEL */ 581 if (attr & LCG_ATTR_UNDERLINE) { 582 char *p = &LCG_ADDR(row, col, lcg_font.fontheight - 1, 0); 583 for (i = 0; i < lcg_font.fontwidth; i++) 584 p[i] = ~p[i]; 585 } 586 } 587 588 589 590 /* 591 * copies columns inside a row. 592 */ 593 static void 594 lcg_copycols(void *id, int row, int srccol, int dstcol, int ncols) 595 { 596 struct lcg_screen *ss = id; 597 #ifdef LCG_NO_ACCEL 598 int i = 0; 599 #endif 600 601 bcopy(&ss->ss_image[row * lcg_cols + srccol], &ss->ss_image[row * 602 lcg_cols + dstcol], ncols * sizeof(ss->ss_image[0])); 603 if (ss != curscr) 604 return; 605 #ifdef LCG_NO_ACCEL 606 for (i = 0; i < lcg_font.fontheight; i++) 607 memcpy(&LCG_ADDR(row, dstcol, i, 0), 608 &LCG_ADDR(row,srccol, i, 0), ncols * lcg_font.fontwidth); 609 610 #else 611 blkcpy(LCG_FB_ADDR + (row * lcg_onerow) + (srccol * lcg_font.fontwidth), 612 LCG_FB_ADDR + (row * lcg_onerow) + (dstcol * lcg_font.fontwidth), 613 (ncols * lcg_font.fontwidth), lcg_font.fontheight); 614 #endif 615 } 616 617 /* 618 * Erases a bunch of chars inside one row. 619 */ 620 static void 621 lcg_erasecols(void *id, int row, int startcol, int ncols, long fillattr) 622 { 623 struct lcg_screen *ss = id; 624 int i; 625 626 bzero(&ss->ss_image[row * lcg_cols + startcol], ncols * sizeof(ss->ss_image[0])); 627 for (i = row * lcg_cols + startcol; i < row * lcg_cols + startcol + ncols; ++i) 628 ss->ss_image[i].attr = fillattr; 629 if (ss != curscr) 630 return; 631 #ifdef LCG_NO_ACCEL 632 for (i = 0; i < lcg_font.fontheight; i++) 633 memset(&LCG_ADDR(row, startcol, i, 0), 0, ncols * lcg_font.fontwidth); 634 #else 635 blkset(LCG_FB_ADDR + (row * lcg_onerow) + (startcol * lcg_font.fontwidth), 636 (ncols * lcg_font.fontwidth), lcg_font.fontheight, (fillattr & LCG_BG_MASK) >> 4); 637 #endif 638 } 639 640 static void 641 lcg_copyrows(void *id, int srcrow, int dstrow, int nrows) 642 { 643 struct lcg_screen *ss = id; 644 645 bcopy(&ss->ss_image[srcrow * lcg_cols], &ss->ss_image[dstrow * lcg_cols], 646 nrows * lcg_cols * sizeof(ss->ss_image[0])); 647 if (ss != curscr) 648 return; 649 #ifdef LCG_NO_ACCEL 650 memcpy(&lcgaddr[dstrow * lcg_onerow], 651 &lcgaddr[srcrow * lcg_onerow], nrows * lcg_onerow); 652 #else 653 blkcpy(LCG_FB_ADDR + (srcrow * lcg_onerow), LCG_FB_ADDR + (dstrow * lcg_onerow), 654 (lcg_cols * lcg_font.fontwidth), (nrows * lcg_font.fontheight)); 655 #endif 656 } 657 658 static void 659 lcg_eraserows(void *id, int startrow, int nrows, long fillattr) 660 { 661 struct lcg_screen *ss = id; 662 int i; 663 664 bzero(&ss->ss_image[startrow * lcg_cols], nrows * lcg_cols * 665 sizeof(ss->ss_image[0])); 666 for (i = startrow * lcg_cols; i < (startrow + nrows) * lcg_cols; ++i) 667 ss->ss_image[i].attr = fillattr; 668 if (ss != curscr) 669 return; 670 #ifdef LCG_NO_ACCEL 671 memset(&lcgaddr[startrow * lcg_onerow], 0, nrows * lcg_onerow); 672 #else 673 blkset(LCG_FB_ADDR + (startrow * lcg_onerow), (lcg_cols * lcg_font.fontwidth), 674 (nrows * lcg_font.fontheight), (fillattr & LCG_BG_MASK) >> 4); 675 #endif 676 } 677 678 static int 679 lcg_allocattr(void *id, int fg, int bg, int flags, long *attrp) 680 { 681 long myattr; 682 683 if (flags & WSATTR_WSCOLORS) 684 myattr = (fg & LCG_FG_MASK) | ((bg << 4) & LCG_BG_MASK); 685 else 686 myattr = WSCOL_WHITE << 4; /* XXXX */ 687 if (flags & WSATTR_REVERSE) 688 myattr |= LCG_ATTR_REVERSE; 689 if (flags & WSATTR_UNDERLINE) 690 myattr |= LCG_ATTR_UNDERLINE; 691 *attrp = myattr; 692 return 0; 693 } 694 695 static int 696 lcg_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l) 697 { 698 struct wsdisplay_fbinfo *fb = (void *)data; 699 int i; 700 701 switch (cmd) { 702 case WSDISPLAYIO_GTYPE: 703 *(u_int *)data = WSDISPLAY_TYPE_LCG; 704 break; 705 706 case WSDISPLAYIO_GINFO: 707 fb->height = lcg_ysize; 708 fb->width = lcg_xsize; 709 fb->depth = lcg_depth; 710 fb->cmsize = 1 << lcg_depth; 711 break; 712 713 case WSDISPLAYIO_GETCMAP: 714 return lcg_get_cmap((struct wsdisplay_cmap *)data); 715 716 case WSDISPLAYIO_PUTCMAP: 717 return lcg_set_cmap((struct wsdisplay_cmap *)data); 718 719 case WSDISPLAYIO_GMODE: 720 return EPASSTHROUGH; 721 722 case WSDISPLAYIO_SMODE: 723 /* if setting WSDISPLAYIO_MODE_EMUL, restore console cmap, current screen */ 724 if (*(u_int *)data == WSDISPLAYIO_MODE_EMUL) { 725 /* FIXME: if this is meant to reset palette LUT reload has to be triggered too */ 726 bzero(lutaddr, LCG_LUT_SIZE); 727 for (i = 0; i < 8; ++i) { 728 lcg_cmap.r[i] = lcg_default_cmap.r[i]; 729 lcg_cmap.g[i] = lcg_default_cmap.g[i]; 730 lcg_cmap.b[i] = lcg_default_cmap.b[i]; 731 lutaddr[i * 8 + 1] = i; 732 lutaddr[i * 8 + 2] = 1; 733 lutaddr[i * 8 + 3] = lcg_cmap.r[i] >> (lcg_depth & 7); 734 lutaddr[i * 8 + 4] = 1; 735 lutaddr[i * 8 + 5] = lcg_cmap.g[i] >> (lcg_depth & 7); 736 lutaddr[i * 8 + 6] = 1; 737 lutaddr[i * 8 + 7] = lcg_cmap.b[i] >> (lcg_depth & 7); 738 } 739 if (savescr != NULL) 740 lcg_show_screen(NULL, savescr, 0, NULL, NULL); 741 savescr = NULL; 742 } else { /* WSDISPLAYIO_MODE_MAPPED */ 743 savescr = curscr; 744 curscr = NULL; 745 /* clear screen? */ 746 } 747 748 return EPASSTHROUGH; 749 #if 0 750 case WSDISPLAYIO_SVIDEO: 751 if (*(u_int *)data == WSDISPLAYIO_VIDEO_ON) { 752 curcmd = curc; 753 } else { 754 curc = curcmd; 755 curcmd &= ~(CUR_CMD_FOPA|CUR_CMD_ENPA); 756 curcmd |= CUR_CMD_FOPB; 757 } 758 WRITECUR(CUR_CMD, curcmd); 759 break; 760 761 case WSDISPLAYIO_GVIDEO: 762 *(u_int *)data = (curcmd & CUR_CMD_FOPB ? 763 WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON); 764 break; 765 766 #endif 767 default: 768 return EPASSTHROUGH; 769 } 770 return 0; 771 } 772 773 static paddr_t 774 lcg_mmap(void *v, void *vs, off_t offset, int prot) 775 { 776 if (offset >= lcg_fb_size || offset < 0) 777 return -1; 778 return (LCG_FB_ADDR + offset) >> PGSHIFT; 779 } 780 781 int 782 lcg_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep, 783 int *curxp, int *curyp, long *defattrp) 784 { 785 int i; 786 struct lcg_screen *ss; 787 788 *cookiep = malloc(sizeof(struct lcg_screen), M_DEVBUF, M_WAITOK); 789 bzero(*cookiep, sizeof(struct lcg_screen)); 790 *curxp = *curyp = 0; 791 *defattrp = (LCG_BG_COLOR << 4) | LCG_FG_COLOR; 792 ss = *cookiep; 793 for (i = 0; i < lcg_cols * lcg_rows; ++i) 794 ss->ss_image[i].attr = (LCG_BG_COLOR << 4) | LCG_FG_COLOR; 795 return 0; 796 } 797 798 void 799 lcg_free_screen(void *v, void *cookie) 800 { 801 } 802 803 int 804 lcg_show_screen(void *v, void *cookie, int waitok, 805 void (*cb)(void *, int, int), void *cbarg) 806 { 807 struct lcg_screen *ss = cookie; 808 int row, col, dot_fg, dot_bg, j, attr; 809 #ifdef LCG_NO_ACCEL 810 int iter, jter; 811 unsigned char ch; 812 #endif 813 814 if (ss == curscr) 815 return (0); 816 #ifdef LCG_NO_ACCEL 817 memset(lcgaddr, LCG_BG_COLOR, lcg_xsize * lcg_ysize); 818 #endif 819 820 for (row = 0; row < lcg_rows; row++) 821 for (col = 0; col < lcg_cols; col++) { 822 attr = ss->ss_image[row * lcg_cols + col].attr; 823 if (attr & LCG_ATTR_REVERSE) { 824 dot_fg = (attr & LCG_BG_MASK) >> 4; 825 dot_bg = attr & LCG_FG_MASK; 826 } else { 827 dot_fg = attr & LCG_FG_MASK; 828 dot_bg = (attr & LCG_BG_MASK) >> 4; 829 } 830 u_char c = ss->ss_image[row * lcg_cols + col].data; 831 832 if (c < 32) 833 c = 32; 834 #ifndef LCG_NO_ACCEL 835 renderchar(LCG_FONT_ADDR + (c * lcg_glyph_size), 836 LCG_FB_ADDR + (row * lcg_onerow) + (col * lcg_font.fontwidth), 837 lcg_font.fontwidth, lcg_font.fontheight, dot_fg, dot_bg); 838 #else 839 for (iter = 0; iter < lcg_font.fontheight; iter++) { 840 ch = QFONT(c,iter); 841 for (jter = 0; jter < lcg_font.fontwidth; jter++) { 842 LCG_ADDR(row, col, iter, jter) = ((ch >> jter) & 1) ? dot_fg : dot_bg; 843 } 844 } 845 #endif 846 if (attr & LCG_ATTR_UNDERLINE) 847 for (j = 0; j < lcg_font.fontwidth; j++) 848 LCG_ADDR(row, col, 849 lcg_font.fontheight - 1, j) = dot_fg; 850 } 851 852 cursor = &lcgaddr[(ss->ss_cury * lcg_onerow) + 853 ((lcg_font.fontheight - 1) * lcg_xsize) + 854 (ss->ss_curx * lcg_font.fontwidth)]; 855 cur_fg = ss->ss_cur_fg; 856 cur_bg = ss->ss_cur_bg; 857 858 curscr = ss; 859 return (0); 860 } 861 862 static int 863 lcg_get_cmap(struct wsdisplay_cmap *p) 864 { 865 u_int index = p->index, count = p->count; 866 int error; 867 868 if (index >= (1 << lcg_depth) || count > (1 << lcg_depth) - index) 869 return (EINVAL); 870 871 error = copyout(&lcg_cmap.r[index], p->red, count); 872 if (error) 873 return error; 874 error = copyout(&lcg_cmap.g[index], p->green, count); 875 if (error) 876 return error; 877 error = copyout(&lcg_cmap.b[index], p->blue, count); 878 return error; 879 } 880 881 static int 882 lcg_set_cmap(struct wsdisplay_cmap *p) 883 { 884 u_int index = p->index, count = p->count; 885 int error, s; 886 887 if (index >= (1 << lcg_depth) || count > (1 << lcg_depth) - index) 888 return (EINVAL); 889 890 error = copyin(p->red, &lcg_cmap.r[index], count); 891 if (error) 892 return error; 893 error = copyin(p->green, &lcg_cmap.g[index], count); 894 if (error) 895 return error; 896 error = copyin(p->blue, &lcg_cmap.b[index], count); 897 if (error) 898 return error; 899 900 s = spltty(); 901 /* FIXME: if this is meant to set palette LUT reload has to be triggered too */ 902 while (count-- > 0) { 903 lutaddr[index * 8 + 0] = 0; 904 lutaddr[index * 8 + 1] = index; 905 lutaddr[index * 8 + 2] = 1; 906 lutaddr[index * 8 + 3] = lcg_cmap.r[index] >> (lcg_depth & 7); 907 lutaddr[index * 8 + 4] = 1; 908 lutaddr[index * 8 + 5] = lcg_cmap.g[index] >> (lcg_depth & 7); 909 lutaddr[index * 8 + 6] = 1; 910 lutaddr[index * 8 + 7] = lcg_cmap.b[index] >> (lcg_depth & 7); 911 ++index; 912 } 913 splx(s); 914 return (0); 915 } 916 917 cons_decl(lcg); 918 919 void 920 lcgcninit(struct consdev *cndev) 921 { 922 int i; 923 /* Clear screen */ 924 memset(lcgaddr, LCG_BG_COLOR, lcg_xsize * lcg_ysize); 925 926 curscr = &lcg_conscreen; 927 for (i = 0; i < lcg_cols * lcg_rows; ++i) 928 lcg_conscreen.ss_image[i].attr = 929 (LCG_BG_COLOR << 4) | LCG_FG_COLOR; 930 wsdisplay_cnattach(&lcg_stdscreen, &lcg_conscreen, 0, 0, 931 (LCG_BG_COLOR << 4) | LCG_FG_COLOR); 932 cn_tab->cn_pri = CN_INTERNAL; 933 934 935 #if NDZKBD > 0 936 dzkbd_cnattach(0); /* Connect keyboard and screen together */ 937 #endif 938 } 939 940 /* 941 * Called very early to setup the glass tty as console. 942 * Because it's called before the VM system is inited, virtual memory 943 * for the framebuffer can be stolen directly without disturbing anything. 944 */ 945 void 946 lcgcnprobe(struct consdev *cndev) 947 { 948 extern const struct cdevsw wsdisplay_cdevsw; 949 950 if ((vax_boardtype != VAX_BTYP_46) && (vax_boardtype != VAX_BTYP_48)) 951 return; /* Only for VS 4000/60 and VLC */ 952 953 if (vax_confdata & 0x100) 954 return; /* Diagnostic console */ 955 956 lcg_init_common(NULL, NULL); 957 958 /* Set up default LUT */ 959 960 cndev->cn_pri = CN_INTERNAL; 961 cndev->cn_dev = makedev(cdevsw_lookup_major(&wsdisplay_cdevsw), 0); 962 } 963 964 void 965 lcg_init_common(struct device *self, struct vsbus_attach_args *va) 966 { 967 u_int magic, *lcg_config; 968 int i; 969 extern vaddr_t virtual_avail; 970 long video_conf; 971 int cookie; 972 struct wsdisplay_font *wf; 973 974 struct lcg_softc *sc = (void *)self; 975 bus_dma_segment_t seg; 976 int rseg, err; 977 void *fifo_mem_vaddr; 978 #ifndef LCG_NO_ACCEL 979 u_char line; 980 u_int ch, temp; 981 #endif 982 983 if (regaddr != NULL) 984 return; 985 986 /* map LCG registers first */ 987 if (self != NULL) { 988 regaddr = (long*)vax_map_physmem(LCG_REG_ADDR, (LCG_REG_SIZE/VAX_NBPG)); 989 if (regaddr == 0) { 990 printf("%s: Couldn't allocate register memory.\n", self->dv_xname); 991 return; 992 } 993 } else { 994 regaddr = (long*)virtual_avail; 995 virtual_avail += LCG_REG_SIZE; 996 ioaccess((vaddr_t)regaddr, LCG_REG_ADDR, (LCG_REG_SIZE/VAX_NBPG)); 997 } 998 999 /* 1000 * v = *0x200f0010 & VLC ? 0x07 : 0xf0; 1001 * switch(v) { 1002 * 0x05: 1280x1024 1003 * 0x06: conf & 0x80 ? 1024x768 : 640x480 1004 * 0x07: conf & 0x80 ? 1024x768 ? 1024x864 1005 * 0x20: 1024x864 1006 * 0x40: 1024x768 1007 * 0x60: 1024x864 1008 * 0x80: 1280x1024 4BPN 1009 * 0x90: 1280x1024 8BPN 1010 * 0xb0: 1280x1024 8BPN 2HD 1011 */ 1012 if (self != NULL) { 1013 lcg_config = (u_int *)vax_map_physmem(LCG_CONFIG, 1); 1014 } else { 1015 lcg_config = (u_int *)virtual_avail; 1016 ioaccess((vaddr_t)lcg_config, LCG_CONFIG, 1); 1017 } 1018 magic = *lcg_config & (vax_boardtype == VAX_BTYP_46 ? 0xf0 : 0x07); 1019 if (self != NULL) { 1020 vax_unmap_physmem((vaddr_t)lcg_config, 1); 1021 } else { 1022 iounaccess((vaddr_t)lcg_config, 1); 1023 } 1024 lcg_depth = 8; 1025 switch(magic) { 1026 case 0x80: /* KA46 HR 1280x1024 4BPLN */ 1027 lcg_depth = 4; 1028 case 0x05: /* KA48 HR 1280x1024 8BPLN */ 1029 case 0x90: /* KA46 HR 1280x1024 8BPLN */ 1030 case 0xb0: /* KA46 HR 1280x1024 8BPLN 2HD */ 1031 lcg_xsize = 1280; 1032 lcg_ysize = 1024; 1033 break; 1034 case 0x06: /* KA48 1024x768 or 640x480 */ 1035 if (vax_confdata & 0x80) { 1036 lcg_xsize = 1024; 1037 lcg_ysize = 768; 1038 } else { 1039 lcg_xsize = 640; 1040 lcg_ysize = 480; 1041 } 1042 break; 1043 case 0x07: /* KA48 1024x768 or 1024x864 */ 1044 lcg_xsize = 1024; 1045 lcg_ysize = (vax_confdata & 0x80) ? 768 : 864; 1046 break; 1047 case 0x20: /* KA46 1024x864 */ 1048 case 0x60: /* KA46 1024x864 */ 1049 lcg_xsize = 1024; 1050 lcg_ysize = 864; 1051 break; 1052 case 0x40: /* KA46 1024x768 */ 1053 lcg_xsize = 1024; 1054 lcg_ysize = 768; 1055 break; 1056 default: 1057 panic("LCG model not supported"); 1058 } 1059 if (self != NULL) 1060 aprint_normal("%s: framebuffer size %dx%d, depth %d (magic 0x%x)\n", 1061 self->dv_xname, lcg_xsize, lcg_ysize, lcg_depth, magic); 1062 1063 wsfont_init(); 1064 cookie = wsfont_find(NULL, 12, 22, 0, WSDISPLAY_FONTORDER_R2L, 1065 WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP); 1066 if (cookie == -1) 1067 cookie = wsfont_find(NULL, 8, 0, 0, WSDISPLAY_FONTORDER_R2L, 0, 1068 WSFONT_FIND_BITMAP); 1069 if (cookie == -1) 1070 cookie = wsfont_find(NULL, 0, 0, 0, WSDISPLAY_FONTORDER_R2L, 1071 WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP); 1072 if (cookie == -1 || wsfont_lock(cookie, &wf)) 1073 panic("lcg_common_init: can't load console font"); 1074 lcg_font = *wf; 1075 lcg_cols = lcg_xsize / lcg_font.fontwidth; 1076 lcg_rows = lcg_ysize / lcg_font.fontheight; 1077 if (self != NULL) { 1078 aprint_normal("%s: using font %s (%dx%d), ", self->dv_xname, lcg_font.name, 1079 lcg_font.fontwidth, lcg_font.fontheight); 1080 aprint_normal("console size: %dx%d\n", lcg_cols, lcg_rows); 1081 } 1082 lcg_onerow = lcg_xsize * lcg_font.fontheight; 1083 lcg_fb_size = lcg_xsize * lcg_ysize; 1084 lcg_stdscreen.ncols = lcg_cols; 1085 lcg_stdscreen.nrows = lcg_rows; 1086 lcg_stdscreen.fontwidth = lcg_font.fontwidth; 1087 lcg_stdscreen.fontheight = lcg_font.fontheight; 1088 lcg_glyph_size = lcg_font.stride * lcg_font.fontheight; 1089 snprintf(lcg_stdscreen_name, sizeof(lcg_stdscreen_name), "%dx%d", lcg_cols, lcg_rows); 1090 qf = lcg_font.data; 1091 qf2 = (u_short *)lcg_font.data; 1092 1093 if (self != NULL) { 1094 lcgaddr = (void *)vax_map_physmem(va->va_paddr, 1095 ((lcg_fb_size + LCG_FONT_STORAGE_SIZE)/VAX_NBPG)); 1096 if (lcgaddr == 0) { 1097 printf("%s: unable to allocate framebuffer memory.\n", self->dv_xname); 1098 return; 1099 } 1100 #ifndef LCG_NO_ACCEL 1101 fontaddr = lcgaddr + lcg_fb_size; 1102 1103 /* copy font bitmaps */ 1104 for (ch = 0; ch < 256; ch++) 1105 for (line = 0; line < lcg_font.fontheight; line++) { 1106 temp = QFONT(ch, line); 1107 if (lcg_font.stride == 1) 1108 fontaddr[(ch * lcg_font.fontheight) + line] = temp; 1109 else { 1110 /* stride == 2 */ 1111 fontaddr[(ch * lcg_font.stride * lcg_font.fontheight) + line] = temp & 0xff; 1112 fontaddr[(ch * lcg_font.stride * lcg_font.fontheight) + line + 1] = (temp >> 16) & 0xff; 1113 } 1114 } 1115 #endif 1116 1117 lutaddr = (void *)vax_map_physmem(LCG_LUT_ADDR, (LCG_LUT_SIZE/VAX_NBPG)); 1118 if (lutaddr == 0) { 1119 printf("%s: unable to allocate LUT memory.\n", self->dv_xname); 1120 return; 1121 } 1122 fifoaddr = (long*)vax_map_physmem(LCG_FIFO_WIN_ADDR, (LCG_FIFO_WIN_SIZE/VAX_NBPG)); 1123 if (regaddr == 0) { 1124 printf("%s: unable to map FIFO window\n", self->dv_xname); 1125 return; 1126 } 1127 1128 /* allocate contiguous physical memory block for FIFO */ 1129 err = bus_dmamem_alloc(va->va_dmat, LCG_FIFO_SIZE, 1130 LCG_FIFO_ALIGN, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT); 1131 if (err) { 1132 printf("%s: unable to allocate FIFO memory block, err = %d\n", 1133 self->dv_xname, err); 1134 return; 1135 } 1136 1137 err = bus_dmamem_map(va->va_dmat, &seg, rseg, LCG_FIFO_SIZE, 1138 &fifo_mem_vaddr, BUS_DMA_NOWAIT); 1139 if (err) { 1140 printf("%s: unable to map FIFO memory block, err = %d\n", 1141 self->dv_xname, err); 1142 bus_dmamem_free(va->va_dmat, &seg, rseg); 1143 return; 1144 } 1145 1146 err = bus_dmamap_create(va->va_dmat, LCG_FIFO_SIZE, rseg, 1147 LCG_FIFO_SIZE, 0, BUS_DMA_NOWAIT, &sc->sc_dm); 1148 if (err) { 1149 printf("%s: unable to create DMA map, err = %d\n", self->dv_xname, err); 1150 bus_dmamem_unmap(va->va_dmat, fifo_mem_vaddr, LCG_FIFO_SIZE); 1151 bus_dmamem_free(va->va_dmat, &seg, rseg); 1152 return; 1153 } 1154 1155 err = bus_dmamap_load(va->va_dmat, sc->sc_dm, fifo_mem_vaddr, 1156 LCG_FIFO_SIZE, NULL, BUS_DMA_NOWAIT); 1157 if (err) { 1158 printf("%s: unable to load DMA map, err = %d\n", self->dv_xname, err); 1159 bus_dmamap_destroy(va->va_dmat, sc->sc_dm); 1160 bus_dmamem_unmap(va->va_dmat, fifo_mem_vaddr, LCG_FIFO_SIZE); 1161 bus_dmamem_free(va->va_dmat, &seg, rseg); 1162 return; 1163 } 1164 1165 /* initialize LCG hardware */ 1166 LCG_REG(LCG_REG_GRAPHICS_CONTROL) = 0xd8000000; /* gfx reset, FIFO and AG enable */ 1167 // LCG_REG(LCG_REG_WRITE_PROTECT_LOW_HIGH) = (((LCG_FB_ADDR + lcg_fb_size) & 0xffff0000) | (LCG_FB_ADDR >> 16)); 1168 LCG_REG(LCG_REG_WRITE_PROTECT_LOW_HIGH) = 0xffff0000; 1169 LCG_REG(LCG_REG_FIFO_BASE) = sc->sc_dm->dm_segs[0].ds_addr; 1170 LCG_REG(LCG_REG_FIFO_BASE2) = sc->sc_dm->dm_segs[0].ds_addr; 1171 LCG_REG(LCG_REG_FIFO_MASKS) = 0xffff; 1172 LCG_REG(LCG_REG_FIFO_SAVE_HEAD_OFFSET) = sc->sc_dm->dm_segs[0].ds_addr; 1173 // LCG_REG(LCG_REG_GRAPHICS_INT_STATUS) = 0; 1174 // LCG_REG(LCG_REG_GRAPHICS_CONTROL) = 0x50000000; /* FIFO and AG enable */ 1175 LCG_REG(LCG_REG_GRAPHICS_INT_STATUS) = 0xffffffff; 1176 LCG_REG(LCG_REG_GRAPHICS_INT_SET_ENABLE) = 0; 1177 LCG_REG(LCG_REG_GRAPHICS_INT_CLR_ENABLE) = 0xffffffff; 1178 LCG_REG(LCG_REG_LCG_GO) = 3; /* FIFO and AG go */ 1179 // LCG_REG(LCG_REG_BREAKPT_ADDRESS) = 0x2fffffff; 1180 1181 } else { 1182 lcgaddr = (void *)virtual_avail; 1183 virtual_avail += lcg_fb_size + LCG_FONT_STORAGE_SIZE; 1184 ioaccess((vaddr_t)lcgaddr, LCG_FB_ADDR, (lcg_fb_size/VAX_NBPG)); 1185 1186 lutaddr = (void *)virtual_avail; 1187 virtual_avail += LCG_LUT_SIZE; 1188 ioaccess((vaddr_t)lutaddr, LCG_LUT_ADDR, (LCG_LUT_SIZE/VAX_NBPG)); 1189 1190 fifoaddr = (long*)virtual_avail; 1191 virtual_avail += LCG_FIFO_WIN_SIZE; 1192 ioaccess((vaddr_t)fifoaddr, LCG_FIFO_WIN_ADDR, (LCG_FIFO_WIN_SIZE/VAX_NBPG)); 1193 } 1194 1195 bzero(lutaddr, LCG_LUT_SIZE); 1196 for (i = 0; i < 8; ++i) { 1197 lcg_cmap.r[i] = lcg_default_cmap.r[i]; 1198 lcg_cmap.g[i] = lcg_default_cmap.g[i]; 1199 lcg_cmap.b[i] = lcg_default_cmap.b[i]; 1200 lutaddr[i * 8 + 1] = i; 1201 lutaddr[i * 8 + 2] = 1; 1202 lutaddr[i * 8 + 3] = lcg_cmap.r[i] >> (lcg_depth & 7); 1203 lutaddr[i * 8 + 4] = 1; 1204 lutaddr[i * 8 + 5] = lcg_cmap.g[i] >> (lcg_depth & 7); 1205 lutaddr[i * 8 + 6] = 1; 1206 lutaddr[i * 8 + 7] = lcg_cmap.b[i] >> (lcg_depth & 7); 1207 } 1208 1209 /* 1210 * 0xf100165b 4000/60 1211 * 1111 0001 0000 0000 0001 0110 0101 1011 1212 * vvvv vvvv vvvv vvvv vvvv vvvv vvvv vvvv 1213 * 3322 2222 2222 1111 1111 11 1214 * 1098 7654 3210 9876 5432 1098 7654 3210 1215 * 1216 * 0xf1001d7b 4000/VLC 1217 * 1111 0001 0000 0000 0001 1101 0111 1011 1218 * vvvv vvvv vvvv vvvv vvvv vvvv vvvv vvvv 1219 * 3322 2222 2222 1111 1111 11 1220 * 1098 7654 3210 9876 5432 1098 7654 3210 1221 * 1222 * 31-30 11 Vertical state 1223 * 29-38 11 Horizontal state 1224 * 27-26 00 1225 * 25 0 console LUT select 1226 * 24 1 control LUT select 1227 * 23 0 1228 * 22 0 cursor active 1229 * 21-16 000000 1230 * 15 0 video subsystem reset 1231 * 14 0 1232 * 13 0 LUT load size 2KB 1233 * 12 1 enable H sync 1234 * 11 0 Full LUT load 1 1235 * 10 1 video clock select 1236 * 9- 8 10 memory refresh rate 01 1237 * 7- 6 01 video refresh rate 1238 * 5 0 load select 1 1239 * 4 1 read cursor output 1240 * 3 1 LUT load enable 1241 * 2 0 cursor enable 1242 * 1 1 video enable 1243 * 0 1 refresh clock enable 1244 */ 1245 /* prepare video_config reg for LUT relaod */ 1246 video_conf 1247 = (3 << 30) /* vertical state */ 1248 | (3 << 28) /* horizontal state */ 1249 | (0 << 26) /* unused */ 1250 | (0 << 25) /* console LUT select */ 1251 | (0 << 24) /* control LUT select */ 1252 | (0 << 23) /* unused */ 1253 | (0 << 22) /* cursor active */ 1254 | (0 << 16) /* current cursor scanline showing */ 1255 | (0 << 15) /* video subsystem reset */ 1256 | (0 << 14) /* unused */ 1257 | (1 << 13) /* LUT load size 2 KB */ 1258 | (1 << 12) /* enable horizontal sync */ 1259 | (1 << 10) /* video clock select */ 1260 | (1 << 6) /* video refresh select */ 1261 | (1 << 4) /* read curosr output */ 1262 | (1 << 3) /* LUT load enable */ 1263 | (0 << 2) /* cursor enable */ 1264 | (1 << 1) /* video enable */ 1265 | (1 << 0); /* refresh clock enable */ 1266 /* FIXME needs updating for all supported models */ 1267 if (lcg_xsize == 1280) { /* 4000/60 HR 4PLN */ 1268 video_conf |= (0 << 11); /* split LUT load */ 1269 video_conf |= (2 << 8); /* memory refresh select */ 1270 video_conf |= (0 << 5); /* split shift register load */ 1271 } else { /* 4000/VLC LR 8PLN */ 1272 video_conf |= (1 << 11); /* Full LUT load */ 1273 video_conf |= (1 << 8); /* memory refresh select */ 1274 video_conf |= (1 << 5); /* split shift register load */ 1275 } 1276 1277 LCG_REG(LCG_REG_VIDEO_CONFIG) = video_conf; 1278 /* vital !!! */ 1279 LCG_REG(LCG_REG_LUT_CONSOLE_SEL) = 1; 1280 LCG_REG(LCG_REG_LUT_COLOR_BASE_W) = LCG_LUT_OFFSET; 1281 1282 delay(1000); 1283 LCG_REG(LCG_REG_LUT_CONSOLE_SEL) = 0; 1284 1285 #ifdef LCG_DEBUG 1286 if (self != NULL) 1287 printf("%s: video config register set 0x%08lx\n", video_conf, self->dv_xname); 1288 #endif 1289 } 1290
Indexes created Fri Sep 26 20:09:58 GMT 2025