![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devvga.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc|
Return to devvga.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc |
1.1 ! root 1: #include "u.h" ! 2: #include "../port/lib.h" ! 3: #include "mem.h" ! 4: #include "dat.h" ! 5: #include "fns.h" ! 6: #include "io.h" ! 7: #include "../port/error.h" ! 8: ! 9: #include <libg.h> ! 10: #include <gnot.h> ! 11: #include "screen.h" ! 12: #include "vga.h" ! 13: ! 14: static void setscreen(int, int, int); ! 15: static void vgaupdate(void); ! 16: ! 17: #define MINX 8 ! 18: ! 19: struct{ ! 20: Point pos; ! 21: int bwid; ! 22: }out; ! 23: ! 24: /* imported */ ! 25: extern GSubfont defont0; ! 26: extern Cursor arrow; ! 27: extern GBitmap cursorback; ! 28: ! 29: /* exported */ ! 30: GSubfont *defont; ! 31: int islittle = 1; /* little endian bit ordering in bytes */ ! 32: GBitmap vgascreen; /* hard screen */ ! 33: GBitmap gscreen; /* soft screen */ ! 34: Lock palettelock; /* access to DAC registers */ ! 35: Cursor curcursor; /* current cursor */ ! 36: ! 37: /* local */ ! 38: static ulong colormap[Pcolours][3]; ! 39: static int cga = 1; /* true if in cga mode */ ! 40: static int vgachanging; /* true while vga is being worked on */ ! 41: ! 42: static Rectangle mbb; ! 43: static Rectangle NULLMBB = {10000, 10000, -10000, -10000}; ! 44: ! 45: /* ! 46: * screen dimensions ! 47: */ ! 48: #define CGAWIDTH 160 ! 49: #define CGAHEIGHT 24 ! 50: ! 51: /* ! 52: * screen memory addresses ! 53: */ ! 54: #define SCREENMEM (0xA0000 | KZERO) ! 55: #define CGASCREEN ((uchar*)(0xB8000 | KZERO)) ! 56: ! 57: static void nopage(int); ! 58: ! 59: static Vgac vga = { ! 60: "vga", ! 61: nopage, ! 62: ! 63: 0, ! 64: }; ! 65: ! 66: static Vgac *vgactlr = &vga; /* available VGA ctlrs */ ! 67: static Vgac *vgac = &vga; /* current VGA ctlr */ ! 68: static Hwgc *hwgctlr; /* available HWGC's */ ! 69: Hwgc *hwgc; /* current HWGC */ ! 70: ! 71: static char interlaced[2]; ! 72: ! 73: Cursor fatarrow = { ! 74: { -1, -1 }, ! 75: { ! 76: 0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c, ! 77: 0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, ! 78: 0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04, ! 79: 0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40, ! 80: }, ! 81: { ! 82: 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0, ! 83: 0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8, ! 84: 0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8, ! 85: 0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00, ! 86: }, ! 87: }; ! 88: ! 89: /* ! 90: * vga device ! 91: */ ! 92: enum { ! 93: Qdir = 0, ! 94: Qvgaiob = 1, ! 95: Qvgaiow = 2, ! 96: Qvgaiol = 3, ! 97: Qvgactl = 4, ! 98: Nvga = Qvgactl, ! 99: }; ! 100: Dirtab vgadir[]={ ! 101: "vgaiob", { Qvgaiob }, 0, 0666, ! 102: "vgaiow", { Qvgaiow }, 0, 0666, ! 103: "vgaiol", { Qvgaiol }, 0, 0666, ! 104: "vgactl", { Qvgactl }, 0, 0666, ! 105: }; ! 106: ! 107: void ! 108: vgareset(void) ! 109: { ! 110: bbinit(); ! 111: } ! 112: ! 113: void ! 114: vgainit(void) ! 115: { ! 116: } ! 117: ! 118: Chan* ! 119: vgaattach(char *upec) ! 120: { ! 121: return devattach('v', upec); ! 122: } ! 123: ! 124: Chan* ! 125: vgaclone(Chan *c, Chan *nc) ! 126: { ! 127: return devclone(c, nc); ! 128: } ! 129: ! 130: int ! 131: vgawalk(Chan *c, char *name) ! 132: { ! 133: return devwalk(c, name, vgadir, Nvga, devgen); ! 134: } ! 135: ! 136: void ! 137: vgastat(Chan *c, char *dp) ! 138: { ! 139: devstat(c, dp, vgadir, Nvga, devgen); ! 140: } ! 141: ! 142: Chan* ! 143: vgaopen(Chan *c, int omode) ! 144: { ! 145: c = devopen(c, omode, vgadir, Nvga, devgen); ! 146: switch(c->qid.path){ ! 147: case Qvgaiob: ! 148: case Qvgaiow: ! 149: case Qvgaiol: ! 150: lock(&palettelock); ! 151: vgachanging++; ! 152: unlock(&palettelock); ! 153: break; ! 154: } ! 155: return c; ! 156: } ! 157: ! 158: void ! 159: vgacreate(Chan *c, char *name, int omode, ulong perm) ! 160: { ! 161: USED(c, name, omode, perm); ! 162: error(Eperm); ! 163: } ! 164: ! 165: void ! 166: vgaclose(Chan *c) ! 167: { ! 168: if(c->flag & COPEN) ! 169: switch(c->qid.path){ ! 170: case Qvgaiob: ! 171: case Qvgaiow: ! 172: case Qvgaiol: ! 173: lock(&palettelock); ! 174: vgachanging--; ! 175: vgaupdate(); ! 176: unlock(&palettelock); ! 177: break; ! 178: } ! 179: } ! 180: ! 181: long ! 182: vgaread(Chan *c, void *buf, long n, ulong offset) ! 183: { ! 184: int port; ! 185: uchar *cp; ! 186: char cbuf[64]; ! 187: ushort *sp; ! 188: ulong *lp; ! 189: Vgac *vgacp; ! 190: ! 191: switch(c->qid.path&~CHDIR){ ! 192: case Qdir: ! 193: return devdirread(c, buf, n, vgadir, Nvga, devgen); ! 194: case Qvgactl: ! 195: if(cga) ! 196: return readstr(offset, buf, n, "type: cga\n"); ! 197: vgacp = vgac; ! 198: port = sprint(cbuf, "type: %s\n", vgacp->name); ! 199: port += sprint(cbuf+port, "size: %dx%dx%d%s\n", ! 200: gscreen.r.max.x, gscreen.r.max.y, ! 201: 1<<gscreen.ldepth, interlaced); ! 202: port += sprint(cbuf+port, "hwgc: "); ! 203: if(hwgc) ! 204: sprint(cbuf+port, "%s\n", hwgc->name); ! 205: else ! 206: sprint(cbuf+port, "off\n"); ! 207: return readstr(offset, buf, n, cbuf); ! 208: case Qvgaiob: ! 209: port = offset; ! 210: /* ! 211: * It would be nice to be able to do this, but ! 212: * impractical as all the cards are different. ! 213: if(checkvgaport(port, n)) ! 214: error(Eperm); ! 215: */ ! 216: for(cp = buf; port < offset+n; port++) ! 217: *cp++ = vgai(port); ! 218: return n; ! 219: case Qvgaiow: ! 220: if((n & 01) || (offset & 01)) ! 221: error(Ebadarg); ! 222: n /= 2; ! 223: for (sp = buf, port=offset; port<offset+n; port+=2) ! 224: *sp++ = ins(port); ! 225: return n*2; ! 226: case Qvgaiol: ! 227: if((n & 03) || (offset & 03)) ! 228: error(Ebadarg); ! 229: n /= 4; ! 230: for (lp = buf, port=offset; port<offset+n; port+=4) ! 231: *lp++ = inl(port); ! 232: return n*4; ! 233: } ! 234: error(Eperm); ! 235: return 0; ! 236: } ! 237: ! 238: static void ! 239: vgactl(char *arg) ! 240: { ! 241: int x, y, z; ! 242: char *cp, *field[3]; ! 243: Hwgc *hwgcp; ! 244: Vgac *vgacp; ! 245: ! 246: if(getfields(arg, field, 3, " \t\n") != 2) ! 247: error(Ebadarg); ! 248: ! 249: if(strcmp(field[0], "hwgc") == 0){ ! 250: if(strcmp(field[1], "off") == 0){ ! 251: if(hwgc){ ! 252: (*hwgc->disable)(); ! 253: hwgc = 0; ! 254: hwcurs = 0; ! 255: cursoron(1); ! 256: } ! 257: return; ! 258: } ! 259: ! 260: for(hwgcp = hwgctlr; hwgcp; hwgcp = hwgcp->link){ ! 261: if(strcmp(field[1], hwgcp->name) == 0){ ! 262: if(hwgc) ! 263: (*hwgc->disable)(); ! 264: else ! 265: cursoroff(1); ! 266: hwgc = hwgcp; ! 267: hwcurs = 1; ! 268: (*hwgc->enable)(); ! 269: setcursor(&curcursor); ! 270: cursoron(1); ! 271: return; ! 272: } ! 273: } ! 274: } ! 275: else if(strcmp(field[0], "type") == 0){ ! 276: for(vgacp = vgactlr; vgacp; vgacp = vgacp->link){ ! 277: if(strcmp(field[1], vgacp->name) == 0){ ! 278: vgac = vgacp; ! 279: return; ! 280: } ! 281: } ! 282: } ! 283: else if(strcmp(field[0], "size") == 0){ ! 284: x = strtoul(field[1], &cp, 0); ! 285: if(x == 0 || x > 2048) ! 286: error(Ebadarg); ! 287: ! 288: if(*cp) ! 289: cp++; ! 290: y = strtoul(cp, &cp, 0); ! 291: if(y == 0 || y > 1280) ! 292: error(Ebadarg); ! 293: ! 294: if(*cp) ! 295: cp++; ! 296: z = 0; /* to make the compiler happy */ ! 297: switch(strtoul(cp, &cp, 0)){ ! 298: case 8: ! 299: z = 3; break; ! 300: case 4: ! 301: z = 2; break; ! 302: case 2: ! 303: z = 1; break; ! 304: case 1: ! 305: z = 0; break; ! 306: default: ! 307: error(Ebadarg); ! 308: } ! 309: interlaced[0] = *cp; ! 310: ! 311: cursoroff(1); ! 312: setscreen(x, y, z); ! 313: cursoron(1); ! 314: return; ! 315: } ! 316: ! 317: error(Ebadarg); ! 318: } ! 319: ! 320: long ! 321: vgawrite(Chan *c, void *buf, long n, ulong offset) ! 322: { ! 323: int port; ! 324: uchar *cp; ! 325: char cbuf[64]; ! 326: ushort *sp; ! 327: ulong *lp; ! 328: ! 329: switch(c->qid.path&~CHDIR){ ! 330: case Qdir: ! 331: error(Eperm); ! 332: case Qvgactl: ! 333: if(offset != 0 || n >= sizeof(cbuf)) ! 334: error(Ebadarg); ! 335: memmove(cbuf, buf, n); ! 336: cbuf[n] = 0; ! 337: vgactl(cbuf); ! 338: return n; ! 339: case Qvgaiob: ! 340: port = offset; ! 341: /* ! 342: if(checkvgaport(port, n)) ! 343: error(Eperm); ! 344: */ ! 345: for(cp = buf; port < offset+n; port++) ! 346: vgao(port, *cp++); ! 347: return n; ! 348: case Qvgaiow: ! 349: if((n & 01) || (offset & 01)) ! 350: error(Ebadarg); ! 351: n /= 2; ! 352: for (sp = buf, port=offset; port<offset+n; port+=2) ! 353: outs(port, *sp++); ! 354: return n*2; ! 355: case Qvgaiol: ! 356: if((n & 03) || (offset & 03)) ! 357: error(Ebadarg); ! 358: n /= 4; ! 359: for (lp = buf, port=offset; port<offset+n; port+=4) ! 360: outl(port, *lp++); ! 361: return n*4; ! 362: } ! 363: error(Eperm); ! 364: return 0; ! 365: } ! 366: ! 367: void ! 368: vgaremove(Chan *c) ! 369: { ! 370: USED(c); ! 371: error(Eperm); ! 372: } ! 373: ! 374: void ! 375: vgawstat(Chan *c, char *dp) ! 376: { ! 377: USED(c, dp); ! 378: error(Eperm); ! 379: } ! 380: ! 381: int ! 382: vgaxi(long port, uchar index) ! 383: { ! 384: uchar data; ! 385: ! 386: switch(port){ ! 387: ! 388: case Seqx: ! 389: case Crtx: ! 390: case Grx: ! 391: outb(port, index); ! 392: data = inb(port+1); ! 393: break; ! 394: ! 395: case Attrx: ! 396: /* ! 397: * Allow processor access to the colour ! 398: * palette registers. Writes to Attrx must ! 399: * be preceded by a read from Status1 to ! 400: * initialise the register to point to the ! 401: * index register and not the data register. ! 402: * Processor access is allowed by turning ! 403: * off bit 0x20. ! 404: */ ! 405: inb(Status1); ! 406: if(index < 0x10){ ! 407: outb(Attrx, index); ! 408: data = inb(Attrx+1); ! 409: inb(Status1); ! 410: outb(Attrx, 0x20|index); ! 411: } ! 412: else{ ! 413: outb(Attrx, 0x20|index); ! 414: data = inb(Attrx+1); ! 415: } ! 416: break; ! 417: ! 418: default: ! 419: return -1; ! 420: } ! 421: ! 422: return data & 0xFF; ! 423: } ! 424: ! 425: int ! 426: vgaxo(long port, uchar index, uchar data) ! 427: { ! 428: switch(port){ ! 429: ! 430: case Seqx: ! 431: case Crtx: ! 432: case Grx: ! 433: /* ! 434: * We could use an outport here, but some chips ! 435: * (e.g. 86C928) have trouble with that for some ! 436: * registers. ! 437: */ ! 438: outb(port, index); ! 439: outb(port+1, data); ! 440: break; ! 441: ! 442: case Attrx: ! 443: inb(Status1); ! 444: if(index < 0x10){ ! 445: outb(Attrx, index); ! 446: outb(Attrx, data); ! 447: inb(Status1); ! 448: outb(Attrx, 0x20|index); ! 449: } ! 450: else{ ! 451: outb(Attrx, 0x20|index); ! 452: outb(Attrx, data); ! 453: } ! 454: break; ! 455: ! 456: default: ! 457: return -1; ! 458: } ! 459: ! 460: return 0; ! 461: } ! 462: ! 463: /* ! 464: * expand n bits of color to 32 ! 465: */ ! 466: static ulong ! 467: xnto32(uchar x, int n) ! 468: { ! 469: int s; ! 470: ulong y; ! 471: ! 472: x &= (1<<n)-1; ! 473: y = 0; ! 474: for(s = 32 - n; s > 0; s -= n) ! 475: y |= x<<s; ! 476: if(s < 0) ! 477: y |= x>>(-s); ! 478: return y; ! 479: } ! 480: ! 481: /* ! 482: * expand 3 and 6 bits of color to 32 ! 483: */ ! 484: static ulong ! 485: x3to32(uchar x) ! 486: { ! 487: ulong y; ! 488: ! 489: x = x&7; ! 490: x= (x<<3)|x; ! 491: y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30)); ! 492: return y; ! 493: } ! 494: static ulong ! 495: x6to32(uchar x) ! 496: { ! 497: ulong y; ! 498: ! 499: x = x&0x3f; ! 500: y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30)); ! 501: return y; ! 502: } ! 503: ! 504: void ! 505: setscreen(int maxx, int maxy, int ldepth) ! 506: { ! 507: int len, vgamaxy, width, i, x, s; ! 508: ulong *p, *oldp; ! 509: ! 510: /* allocate a new soft bitmap area */ ! 511: width = (maxx*(1<<ldepth))/32; ! 512: len = width * BY2WD * maxy; ! 513: p = xalloc(len); ! 514: if(p == 0) ! 515: error(Enobitstore); ! 516: memset(p, 0xff, len); ! 517: mbb = NULLMBB; ! 518: ! 519: /* ! 520: * setup a bitmap for the new size ! 521: */ ! 522: if(ldepth == 3) ! 523: vgascreen.ldepth = 3; ! 524: else ! 525: vgascreen.ldepth = 0; ! 526: vgascreen.width = (maxx*(1<<vgascreen.ldepth))/32; ! 527: if(maxy > (64*1024)/(vgascreen.width*BY2WD)) ! 528: vgamaxy = (64*1024)/(vgascreen.width*BY2WD); ! 529: else ! 530: vgamaxy = maxy; ! 531: vgascreen.base = (void*)SCREENMEM; ! 532: vgascreen.r.min = Pt(0, 0); ! 533: vgascreen.r.max = Pt(maxx, vgamaxy); ! 534: vgascreen.clipr = vgascreen.r; ! 535: ! 536: /* ! 537: * setup new soft screen, free memory for old screen ! 538: */ ! 539: oldp = gscreen.base; ! 540: s = splhi(); ! 541: gscreen.ldepth = ldepth; ! 542: gscreen.width = width; ! 543: gscreen.r.min = Pt(0, 0); ! 544: gscreen.r.max = Pt(maxx, maxy); ! 545: gscreen.clipr = gscreen.r; ! 546: gscreen.base = p; ! 547: splx(s); ! 548: if(oldp) ! 549: xfree(oldp); ! 550: ! 551: /* ! 552: * set depth of cursor backup area ! 553: */ ! 554: bitdepth(); ! 555: ! 556: /* ! 557: * set string pointer to upper left ! 558: */ ! 559: out.pos.x = MINX; ! 560: out.pos.y = 0; ! 561: out.bwid = defont0.info[' '].width; ! 562: ! 563: /* ! 564: * default color map ! 565: */ ! 566: switch(ldepth){ ! 567: case 3: ! 568: for(i = 0; i < Pcolours; i++) ! 569: setcolor(i, x3to32(i>>5), x3to32(i>>2), x3to32(i<<1)); ! 570: setcolor(0x55, xnto32(0x15, 6), xnto32(0x15, 6), xnto32(0x15, 6)); ! 571: setcolor(0xaa, xnto32(0x2a, 6), xnto32(0x2a, 6), xnto32(0x2a, 6)); ! 572: setcolor(0xff, xnto32(0x3f, 6), xnto32(0x3f, 6), xnto32(0x3f, 6)); ! 573: break; ! 574: case 2: ! 575: case 1: ! 576: case 0: ! 577: gscreen.ldepth = 3; ! 578: for(i = 0; i < 16; i++){ ! 579: x = x6to32((i*63)/15); ! 580: setcolor(i, x, x, x); ! 581: } ! 582: gscreen.ldepth = ldepth; ! 583: break; ! 584: } ! 585: ! 586: /* ! 587: * clear screen ! 588: */ ! 589: cga = 0; ! 590: mbb = gscreen.r; ! 591: vgaupdate(); ! 592: } ! 593: ! 594: void ! 595: screeninit(void) ! 596: { ! 597: int i; ! 598: ulong *l; ! 599: ! 600: /* ! 601: * arrow is defined as a big endian ! 602: */ ! 603: memmove(&arrow, &fatarrow, sizeof(fatarrow)); ! 604: pixreverse(arrow.set, 2*16, 0); ! 605: pixreverse(arrow.clr, 2*16, 0); ! 606: ! 607: /* ! 608: * swizzle the font longs. we do both byte and bit swizzling ! 609: * since the font is initialized with big endian longs. ! 610: */ ! 611: defont = &defont0; ! 612: l = defont->bits->base; ! 613: for(i = defont->bits->width*Dy(defont->bits->r); i > 0; i--, l++) ! 614: *l = (*l<<24) | ((*l>>8)&0x0000ff00) | ((*l<<8)&0x00ff0000) | (*l>>24); ! 615: pixreverse((uchar*)defont->bits->base, ! 616: defont->bits->width*BY2WD*Dy(defont->bits->r), 0); ! 617: ! 618: cga = 1; ! 619: memset(CGASCREEN, 0, CGAWIDTH*CGAHEIGHT); ! 620: } ! 621: ! 622: /* ! 623: * collect changes to the 'soft' screen ! 624: */ ! 625: void ! 626: mbbrect(Rectangle r) ! 627: { ! 628: if (r.min.x < mbb.min.x) ! 629: mbb.min.x = r.min.x; ! 630: if (r.min.y < mbb.min.y) ! 631: mbb.min.y = r.min.y; ! 632: if (r.max.x > mbb.max.x) ! 633: mbb.max.x = r.max.x; ! 634: if (r.max.y > mbb.max.y) ! 635: mbb.max.y = r.max.y; ! 636: mousescreenupdate(); ! 637: } ! 638: ! 639: void ! 640: mbbpt(Point p) ! 641: { ! 642: if (p.x < mbb.min.x) ! 643: mbb.min.x = p.x; ! 644: if (p.y < mbb.min.y) ! 645: mbb.min.y = p.y; ! 646: if (p.x >= mbb.max.x) ! 647: mbb.max.x = p.x+1; ! 648: if (p.y >= mbb.max.y) ! 649: mbb.max.y = p.y+1; ! 650: } ! 651: ! 652: /* ! 653: * paging routines for different cards ! 654: */ ! 655: static void ! 656: nopage(int page) ! 657: { ! 658: USED(page); ! 659: } ! 660: ! 661: /* ! 662: * copy little endian soft screen to big endian hard screen ! 663: */ ! 664: static void ! 665: vgaupdate(void) ! 666: { ! 667: uchar *sp, *hp, *edisp; ! 668: int y, len, incs, inch, off, page; ! 669: Rectangle r; ! 670: void* (*f)(void*, void*, long); ! 671: ! 672: if(cga || vgachanging) ! 673: return; ! 674: ! 675: r = mbb; ! 676: mbb = NULLMBB; ! 677: ! 678: /* pad a few bits */ ! 679: r.min.y -= 2; ! 680: r.max.y += 2; ! 681: ! 682: if(Dy(r) < 0) ! 683: return; ! 684: ! 685: if(r.min.x < 0) ! 686: r.min.x = 0; ! 687: if(r.min.y < 0) ! 688: r.min.y = 0; ! 689: if(r.max.x > gscreen.r.max.x) ! 690: r.max.x = gscreen.r.max.x; ! 691: if(r.max.y > gscreen.r.max.y) ! 692: r.max.y = gscreen.r.max.y; ! 693: ! 694: incs = gscreen.width * BY2WD; ! 695: inch = vgascreen.width * BY2WD; ! 696: ! 697: switch(gscreen.ldepth){ ! 698: case 0: ! 699: r.min.x &= ~15; /* 16 pixel allignment for l0update() */ ! 700: f = l0update; ! 701: len = (r.max.x + 7)/8 - r.min.x/8; ! 702: if(len & 1) ! 703: len++; /* 16 bit allignment for l0update() */ ! 704: break; ! 705: case 1: ! 706: r.min.x &= ~15; /* 8 pixel allignment for l1update() */ ! 707: f = l1update; ! 708: len = (r.max.x + 7)/8 - r.min.x/8; ! 709: if(len & 1) ! 710: len++; /* 8 pixel allignment for l1update() */ ! 711: break; ! 712: case 2: ! 713: r.min.x &= ~7; /* 8 pixel allignment for l2update() */ ! 714: f = l2update; ! 715: len = (r.max.x + 7)/8 - r.min.x/8; ! 716: break; ! 717: case 3: ! 718: f = memmove; ! 719: len = r.max.x - r.min.x; ! 720: break; ! 721: default: ! 722: return; ! 723: } ! 724: if(len < 1) ! 725: return; ! 726: ! 727: off = r.min.y * vgascreen.width * BY2WD + (r.min.x>>(3 - vgascreen.ldepth)); ! 728: page = off>>16; ! 729: off &= (1<<16)-1; ! 730: hp = ((uchar*)vgascreen.base) + off; ! 731: off = r.min.y * gscreen.width * BY2WD ! 732: + (r.min.x>>(3 - gscreen.ldepth)); ! 733: sp = ((uchar*)gscreen.base) + off; ! 734: ! 735: edisp = ((uchar*)vgascreen.base) + 64*1024; ! 736: vgac->page(page); ! 737: for(y = r.min.y; y < r.max.y; y++){ ! 738: if(hp + inch < edisp){ ! 739: f(hp, sp, len); ! 740: sp += incs; ! 741: hp += inch; ! 742: } else { ! 743: off = edisp - hp; ! 744: if(off <= len){ ! 745: if(off > 0) ! 746: f(hp, sp, off); ! 747: vgac->page(++page); ! 748: if(len - off > 0) ! 749: f(vgascreen.base, sp+off, len - off); ! 750: } else { ! 751: f(hp, sp, len); ! 752: vgac->page(++page); ! 753: } ! 754: sp += incs; ! 755: hp += inch - 64*1024; ! 756: } ! 757: } ! 758: } ! 759: ! 760: void ! 761: screenupdate(void) ! 762: { ! 763: lock(&palettelock); ! 764: vgaupdate(); ! 765: unlock(&palettelock); ! 766: } ! 767: ! 768: void ! 769: mousescreenupdate(void) ! 770: { ! 771: int x; ! 772: ! 773: if(canlock(&palettelock)){ ! 774: x = spllo(); ! 775: vgaupdate(); ! 776: splx(x); ! 777: unlock(&palettelock); ! 778: } ! 779: } ! 780: ! 781: static int pos; ! 782: ! 783: static void ! 784: cgaregw(uchar index, uchar data) ! 785: { ! 786: outb(0x03D4, index); ! 787: outb(0x03D4+1, data); ! 788: } ! 789: ! 790: static void ! 791: movecursor(void) ! 792: { ! 793: cgaregw(0x0E, (pos/2>>8) & 0xFF); ! 794: cgaregw(0x0F, pos/2 & 0xFF); ! 795: } ! 796: ! 797: static void ! 798: cgascreenputc(int c) ! 799: { ! 800: int i; ! 801: static int color; ! 802: ! 803: if(c == '\n'){ ! 804: pos = pos/CGAWIDTH; ! 805: pos = (pos+1)*CGAWIDTH; ! 806: } else if(c == '\t'){ ! 807: i = 8 - ((pos/2)&7); ! 808: while(i-->0) ! 809: cgascreenputc(' '); ! 810: } else if(c == '\b'){ ! 811: if(pos >= 2) ! 812: pos -= 2; ! 813: cgascreenputc(' '); ! 814: pos -= 2; ! 815: } else { ! 816: CGASCREEN[pos++] = c; ! 817: CGASCREEN[pos++] = 2; /* green on black */ ! 818: } ! 819: if(pos >= CGAWIDTH*CGAHEIGHT){ ! 820: memmove(CGASCREEN, &CGASCREEN[CGAWIDTH], CGAWIDTH*(CGAHEIGHT-1)); ! 821: memset(&CGASCREEN[CGAWIDTH*(CGAHEIGHT-1)], 0, CGAWIDTH); ! 822: pos = CGAWIDTH*(CGAHEIGHT-1); ! 823: } ! 824: movecursor(); ! 825: } ! 826: ! 827: void ! 828: cgascreenputs(char *s, int n) ! 829: { ! 830: while(n-- > 0) ! 831: cgascreenputc(*s++); ! 832: } ! 833: ! 834: void ! 835: screenputnl(void) ! 836: { ! 837: Rectangle r; ! 838: ! 839: out.pos.x = MINX; ! 840: out.pos.y += defont0.height; ! 841: if(out.pos.y > gscreen.r.max.y-defont0.height){ ! 842: vgaupdate(); ! 843: out.pos.y = gscreen.r.min.y; ! 844: } ! 845: r = Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height); ! 846: gbitblt(&gscreen, r.min, &gscreen, r, flipD[0]); ! 847: mbbrect(r); ! 848: vgaupdate(); ! 849: } ! 850: ! 851: void ! 852: screenputs(char *s, int n) ! 853: { ! 854: Rune r; ! 855: int i; ! 856: char buf[4]; ! 857: Rectangle rect; ! 858: ! 859: if(vgachanging) ! 860: return; ! 861: if(cga) { ! 862: cgascreenputs(s, n); ! 863: return; ! 864: } ! 865: ! 866: while(n > 0){ ! 867: i = chartorune(&r, s); ! 868: if(i == 0){ ! 869: s++; ! 870: --n; ! 871: continue; ! 872: } ! 873: memmove(buf, s, i); ! 874: buf[i] = 0; ! 875: n -= i; ! 876: s += i; ! 877: if(r == '\n') ! 878: screenputnl(); ! 879: else if(r == '\t'){ ! 880: out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid; ! 881: if(out.pos.x >= gscreen.r.max.x) ! 882: screenputnl(); ! 883: }else if(r == '\b'){ ! 884: if(out.pos.x >= out.bwid+MINX){ ! 885: out.pos.x -= out.bwid; ! 886: gsubfstring(&gscreen, out.pos, defont, " ", flipD[S]); ! 887: } ! 888: rect.min = Pt(out.pos.x, out.pos.y); ! 889: rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height); ! 890: mbbrect(rect); ! 891: }else{ ! 892: if(out.pos.x >= gscreen.r.max.x-out.bwid) ! 893: screenputnl(); ! 894: rect.min = Pt(out.pos.x, out.pos.y); ! 895: rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height); ! 896: out.pos = gsubfstring(&gscreen, out.pos, defont, buf, flipD[S]); ! 897: mbbrect(rect); ! 898: } ! 899: } ! 900: vgaupdate(); ! 901: } ! 902: ! 903: int ! 904: screenbits(void) ! 905: { ! 906: return 1<<gscreen.ldepth; /* bits per pixel */ ! 907: } ! 908: ! 909: void ! 910: getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb) ! 911: { ! 912: p &= (1<<(1<<gscreen.ldepth))-1; ! 913: lock(&palettelock); ! 914: *pr = colormap[p][Pred]; ! 915: *pg = colormap[p][Pgreen]; ! 916: *pb = colormap[p][Pblue]; ! 917: unlock(&palettelock); ! 918: } ! 919: ! 920: int ! 921: setcolor(ulong p, ulong r, ulong g, ulong b) ! 922: { ! 923: p &= (1<<(1<<gscreen.ldepth))-1; ! 924: lock(&palettelock); ! 925: colormap[p][Pred] = r; ! 926: colormap[p][Pgreen] = g; ! 927: colormap[p][Pblue] = b; ! 928: vgao(PaddrW, p); ! 929: vgao(Pdata, r>>(32-6)); ! 930: vgao(Pdata, g>>(32-6)); ! 931: vgao(Pdata, b>>(32-6)); ! 932: unlock(&palettelock); ! 933: return ~0; ! 934: } ! 935: ! 936: int ! 937: hwgcmove(Point p) ! 938: { ! 939: if(hwgc) ! 940: return (*hwgc->move)(p); ! 941: return 0; ! 942: } ! 943: ! 944: void ! 945: setcursor(Cursor *curs) ! 946: { ! 947: uchar *p; ! 948: int i; ! 949: extern GBitmap set, clr; ! 950: ! 951: if(hwgc) ! 952: (*hwgc->load)(curs); ! 953: else for(i=0; i<16; i++){ ! 954: p = (uchar*)&set.base[i]; ! 955: *p = curs->set[2*i]; ! 956: *(p+1) = curs->set[2*i+1]; ! 957: p = (uchar*)&clr.base[i]; ! 958: *p = curs->clr[2*i]; ! 959: *(p+1) = curs->clr[2*i+1]; ! 960: memmove(&curcursor, curs, sizeof(Cursor)); ! 961: } ! 962: } ! 963: ! 964: void ! 965: addhwgclink(Hwgc *hwgcp) ! 966: { ! 967: hwgcp->link = hwgctlr; ! 968: hwgctlr = hwgcp; ! 969: } ! 970: ! 971: void ! 972: addvgaclink(Vgac *vgacp) ! 973: { ! 974: vgacp->link = vgactlr; ! 975: vgactlr = vgacp; ! 976: } ! 977: ! 978: /* ! 979: * Table for separating and reversing bits in a ldepth 1 bitmap. ! 980: * This aids in coverting a little endian ldepth 1 bitmap into the ! 981: * 2 big-endian ldepth 0 bitmaps used for the VGA bit planes. ! 982: * ! 983: * if the bits in uchar x are labeled ! 984: * 76543210 ! 985: * then l1revsep[x] yields a ushort with bits ! 986: * ________1357________0246 ! 987: * where _ represents a bit whose value is 0. ! 988: * ! 989: * This table is used by l1update() in l.s. l1update is implemented ! 990: * in assembler for speed. ! 991: * ! 992: */ ! 993: ulong l1revsep[] = { ! 994: 0x00000, 0x00008, 0x80000, 0x80008, 0x00004, 0x0000c, 0x80004, 0x8000c, ! 995: 0x40000, 0x40008, 0xc0000, 0xc0008, 0x40004, 0x4000c, 0xc0004, 0xc000c, ! 996: 0x00002, 0x0000a, 0x80002, 0x8000a, 0x00006, 0x0000e, 0x80006, 0x8000e, ! 997: 0x40002, 0x4000a, 0xc0002, 0xc000a, 0x40006, 0x4000e, 0xc0006, 0xc000e, ! 998: 0x20000, 0x20008, 0xa0000, 0xa0008, 0x20004, 0x2000c, 0xa0004, 0xa000c, ! 999: 0x60000, 0x60008, 0xe0000, 0xe0008, 0x60004, 0x6000c, 0xe0004, 0xe000c, ! 1000: 0x20002, 0x2000a, 0xa0002, 0xa000a, 0x20006, 0x2000e, 0xa0006, 0xa000e, ! 1001: 0x60002, 0x6000a, 0xe0002, 0xe000a, 0x60006, 0x6000e, 0xe0006, 0xe000e, ! 1002: 0x00001, 0x00009, 0x80001, 0x80009, 0x00005, 0x0000d, 0x80005, 0x8000d, ! 1003: 0x40001, 0x40009, 0xc0001, 0xc0009, 0x40005, 0x4000d, 0xc0005, 0xc000d, ! 1004: 0x00003, 0x0000b, 0x80003, 0x8000b, 0x00007, 0x0000f, 0x80007, 0x8000f, ! 1005: 0x40003, 0x4000b, 0xc0003, 0xc000b, 0x40007, 0x4000f, 0xc0007, 0xc000f, ! 1006: 0x20001, 0x20009, 0xa0001, 0xa0009, 0x20005, 0x2000d, 0xa0005, 0xa000d, ! 1007: 0x60001, 0x60009, 0xe0001, 0xe0009, 0x60005, 0x6000d, 0xe0005, 0xe000d, ! 1008: 0x20003, 0x2000b, 0xa0003, 0xa000b, 0x20007, 0x2000f, 0xa0007, 0xa000f, ! 1009: 0x60003, 0x6000b, 0xe0003, 0xe000b, 0x60007, 0x6000f, 0xe0007, 0xe000f, ! 1010: 0x10000, 0x10008, 0x90000, 0x90008, 0x10004, 0x1000c, 0x90004, 0x9000c, ! 1011: 0x50000, 0x50008, 0xd0000, 0xd0008, 0x50004, 0x5000c, 0xd0004, 0xd000c, ! 1012: 0x10002, 0x1000a, 0x90002, 0x9000a, 0x10006, 0x1000e, 0x90006, 0x9000e, ! 1013: 0x50002, 0x5000a, 0xd0002, 0xd000a, 0x50006, 0x5000e, 0xd0006, 0xd000e, ! 1014: 0x30000, 0x30008, 0xb0000, 0xb0008, 0x30004, 0x3000c, 0xb0004, 0xb000c, ! 1015: 0x70000, 0x70008, 0xf0000, 0xf0008, 0x70004, 0x7000c, 0xf0004, 0xf000c, ! 1016: 0x30002, 0x3000a, 0xb0002, 0xb000a, 0x30006, 0x3000e, 0xb0006, 0xb000e, ! 1017: 0x70002, 0x7000a, 0xf0002, 0xf000a, 0x70006, 0x7000e, 0xf0006, 0xf000e, ! 1018: 0x10001, 0x10009, 0x90001, 0x90009, 0x10005, 0x1000d, 0x90005, 0x9000d, ! 1019: 0x50001, 0x50009, 0xd0001, 0xd0009, 0x50005, 0x5000d, 0xd0005, 0xd000d, ! 1020: 0x10003, 0x1000b, 0x90003, 0x9000b, 0x10007, 0x1000f, 0x90007, 0x9000f, ! 1021: 0x50003, 0x5000b, 0xd0003, 0xd000b, 0x50007, 0x5000f, 0xd0007, 0xd000f, ! 1022: 0x30001, 0x30009, 0xb0001, 0xb0009, 0x30005, 0x3000d, 0xb0005, 0xb000d, ! 1023: 0x70001, 0x70009, 0xf0001, 0xf0009, 0x70005, 0x7000d, 0xf0005, 0xf000d, ! 1024: 0x30003, 0x3000b, 0xb0003, 0xb000b, 0x30007, 0x3000f, 0xb0007, 0xb000f, ! 1025: 0x70003, 0x7000b, 0xf0003, 0xf000b, 0x70007, 0x7000f, 0xf0007, 0xf000f, ! 1026: }; ! 1027: ! 1028: /* ! 1029: * Table for separating and reversing bits in a ldepth 2 bitmap. ! 1030: * This aids in coverting a little endian ldepth 1 bitmap into the ! 1031: * 4 big-endian ldepth 0 bitmaps used for the VGA bit planes. ! 1032: * ! 1033: * if the bits in uchar x are labeled ! 1034: * 76543210 ! 1035: * then l1revsep[x] yields a ushort with bits ! 1036: * ______37______26______15______04 ! 1037: * where _ represents a bit whose value is 0. ! 1038: * ! 1039: * This table is used by l2update() in l.s. l2update is implemented ! 1040: * in assembler for speed. ! 1041: * ! 1042: */ ! 1043: ulong l2revsep[] = { ! 1044: 0x0000000, 0x0000002, 0x0000200, 0x0000202, 0x0020000, 0x0020002, 0x0020200, 0x0020202, ! 1045: 0x2000000, 0x2000002, 0x2000200, 0x2000202, 0x2020000, 0x2020002, 0x2020200, 0x2020202, ! 1046: 0x0000001, 0x0000003, 0x0000201, 0x0000203, 0x0020001, 0x0020003, 0x0020201, 0x0020203, ! 1047: 0x2000001, 0x2000003, 0x2000201, 0x2000203, 0x2020001, 0x2020003, 0x2020201, 0x2020203, ! 1048: 0x0000100, 0x0000102, 0x0000300, 0x0000302, 0x0020100, 0x0020102, 0x0020300, 0x0020302, ! 1049: 0x2000100, 0x2000102, 0x2000300, 0x2000302, 0x2020100, 0x2020102, 0x2020300, 0x2020302, ! 1050: 0x0000101, 0x0000103, 0x0000301, 0x0000303, 0x0020101, 0x0020103, 0x0020301, 0x0020303, ! 1051: 0x2000101, 0x2000103, 0x2000301, 0x2000303, 0x2020101, 0x2020103, 0x2020301, 0x2020303, ! 1052: 0x0010000, 0x0010002, 0x0010200, 0x0010202, 0x0030000, 0x0030002, 0x0030200, 0x0030202, ! 1053: 0x2010000, 0x2010002, 0x2010200, 0x2010202, 0x2030000, 0x2030002, 0x2030200, 0x2030202, ! 1054: 0x0010001, 0x0010003, 0x0010201, 0x0010203, 0x0030001, 0x0030003, 0x0030201, 0x0030203, ! 1055: 0x2010001, 0x2010003, 0x2010201, 0x2010203, 0x2030001, 0x2030003, 0x2030201, 0x2030203, ! 1056: 0x0010100, 0x0010102, 0x0010300, 0x0010302, 0x0030100, 0x0030102, 0x0030300, 0x0030302, ! 1057: 0x2010100, 0x2010102, 0x2010300, 0x2010302, 0x2030100, 0x2030102, 0x2030300, 0x2030302, ! 1058: 0x0010101, 0x0010103, 0x0010301, 0x0010303, 0x0030101, 0x0030103, 0x0030301, 0x0030303, ! 1059: 0x2010101, 0x2010103, 0x2010301, 0x2010303, 0x2030101, 0x2030103, 0x2030301, 0x2030303, ! 1060: 0x1000000, 0x1000002, 0x1000200, 0x1000202, 0x1020000, 0x1020002, 0x1020200, 0x1020202, ! 1061: 0x3000000, 0x3000002, 0x3000200, 0x3000202, 0x3020000, 0x3020002, 0x3020200, 0x3020202, ! 1062: 0x1000001, 0x1000003, 0x1000201, 0x1000203, 0x1020001, 0x1020003, 0x1020201, 0x1020203, ! 1063: 0x3000001, 0x3000003, 0x3000201, 0x3000203, 0x3020001, 0x3020003, 0x3020201, 0x3020203, ! 1064: 0x1000100, 0x1000102, 0x1000300, 0x1000302, 0x1020100, 0x1020102, 0x1020300, 0x1020302, ! 1065: 0x3000100, 0x3000102, 0x3000300, 0x3000302, 0x3020100, 0x3020102, 0x3020300, 0x3020302, ! 1066: 0x1000101, 0x1000103, 0x1000301, 0x1000303, 0x1020101, 0x1020103, 0x1020301, 0x1020303, ! 1067: 0x3000101, 0x3000103, 0x3000301, 0x3000303, 0x3020101, 0x3020103, 0x3020301, 0x3020303, ! 1068: 0x1010000, 0x1010002, 0x1010200, 0x1010202, 0x1030000, 0x1030002, 0x1030200, 0x1030202, ! 1069: 0x3010000, 0x3010002, 0x3010200, 0x3010202, 0x3030000, 0x3030002, 0x3030200, 0x3030202, ! 1070: 0x1010001, 0x1010003, 0x1010201, 0x1010203, 0x1030001, 0x1030003, 0x1030201, 0x1030203, ! 1071: 0x3010001, 0x3010003, 0x3010201, 0x3010203, 0x3030001, 0x3030003, 0x3030201, 0x3030203, ! 1072: 0x1010100, 0x1010102, 0x1010300, 0x1010302, 0x1030100, 0x1030102, 0x1030300, 0x1030302, ! 1073: 0x3010100, 0x3010102, 0x3010300, 0x3010302, 0x3030100, 0x3030102, 0x3030300, 0x3030302, ! 1074: 0x1010101, 0x1010103, 0x1010301, 0x1010303, 0x1030101, 0x1030103, 0x1030301, 0x1030303, ! 1075: 0x3010101, 0x3010103, 0x3010301, 0x3010303, 0x3030101, 0x3030103, 0x3030301, 0x3030303, ! 1076: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.