## diffname pc/vga.c 1991/0723
## diff -e /dev/null /n/bootesdump/1991/0723/sys/src/9/safari/vga.c
0a
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
enum
{
GRX= 0x3CE, /* index to graphics registers */
GR= 0x3CF, /* graphics registers 0-8 */
};
/*
* look at VGA registers
*/
void
vgainit(void)
{
int i;
uchar x;
for(i = 0; i < 9; i++){
outb(GRX, i);
x = inb(GR);
print("GR%d == %ux\n", i, x);
}
panic("for the hell of it");
}
.
## diffname pc/vga.c 1991/0724
## diff -e /n/bootesdump/1991/0723/sys/src/9/safari/vga.c /n/bootesdump/1991/0724/sys/src/9/safari/vga.c
23,28c
srout(2, 0x0f); /* enable all 4 color planes */
srout(4, 0x08); /* quad mode */
grout(5, 0x40); /* pixel bits are sequential */
grout(6, 0x01); /* graphics mode - display starts at 0xA0000 */
for(;;);
display = (uchar*)(0xA0000 | KZERO);
for(i = 0; i < 128*1024; i++)
display[i] = 0x00;
for(i = 0; i < 4*640; i++)
display[i] = 0xff;
.
21d
19a
uchar *display;
.
13a
void
srout(int reg, int val)
{
outb(SRX, reg);
outb(SR, val);
}
void
grout(int reg, int val)
{
outb(GRX, reg);
outb(GR, val);
}
.
11a
SRX= 0x3C4, /* index to sequence registers */
SR= 0x3C5, /* sequence registers 0-7 */
.
## diffname pc/vga.c 1991/0727
## diff -e /n/bootesdump/1991/0724/sys/src/9/safari/vga.c /n/bootesdump/1991/0727/sys/src/9/safari/vga.c
51a
.
44,50c
/*
* zero out display
*/
srout(Smmask, 0x0f); /* enable all 4 color planes for writing */
for(i=0; i<MAXY*(MAXX/8); i++)
display[i] = 0;
munch();
.
39,42c
display = (uchar *)(0xA0000 | KZERO);
arout(Acpe, 0x0f); /* enable all planes */
arout(Amode, 0x01); /* graphics mode - 4 bit pixels */
grout(Gmisc, 0x01); /* graphics mode */
grout(Gmode, 0x00); /* write mode 0, read mode 0 */
grout(Grot, 0x00); /* CPU writes bytes to video mem without modifications */
crout(Cmode, 0xe3); /* turn off address wrap & word mode */
crout(Cmsl, 0x40); /* 1 pixel per scan line */
srout(Smode, 0x06); /* extended memory, odd/even off */
srout(Sclock, 0x01); /* 8 bits/char */
.
37c
int i, j, k;
int c;
.
33a
munch(void)
{
ulong x,y,i,d;
uchar *screen, tab[8], *p;
screen = (uchar *)(0xA0000 | KZERO);
d=0;
tab[0] = 0x80;
tab[1] = 0x40;
tab[2] = 0x20;
tab[3] = 0x10;
tab[4] = 0x08;
tab[5] = 0x04;
tab[6] = 0x02;
tab[7] = 0x01;
for(i=0; i<MAXY*(MAXX/8); i++)
screen[i]=0;
for(;;){
for(x=0; x<SIDE; x++){
y = (x^d) % SIDE;
p = &screen[y*(MAXX/8) + (x/8)];
y = *p;
*p = y ^ tab[x&7];
}
d+=DELTA;
}
}
/*
* Set up for 4 separately addressed bit planes. Each plane is
*/
void
.
32a
vgawrmask(int m)
{
srout(Smmask, m&0xf);
}
/*
* p is the plane that will respond to CPU reads
*/
vgardplane(int p)
{
grout(Grms, p&3);
}
/*
* partial screen munching squares
*/
#define DELTA 1
#define DADDR ((long *) 0)
#define SIDE 256
.
31c
* m is a bit mask of planes to be affected by CPU writes
.
28a
void
arout(int reg, int val)
{
inb(0x3DA);
outb(ARX, reg | 0x20);
outb(AR, val);
}
void
crout(int reg, int val)
{
outb(CRX, reg);
outb(CR, val);
}
.
22d
15a
/*
* screen dimensions
*/
#define MAXX 640
#define MAXY 480
/*
* routines for setting vga registers
*/
.
13c
SR= 0x3C5, /* sequence registers */
Sclock= 0x01, /* clocking register */
Smode= 0x04, /* mode register */
Smmask= 0x02, /* map mask */
CRX= 0x3D4, /* index to crt registers */
CR= 0x3D5, /* crt registers */
Cmode= 0x17, /* mode register */
Cmsl= 0x09, /* max scan line */
ARX= 0x3C0, /* index to attribute registers */
AR= 0x3C1, /* attribute registers */
Amode= 0x10, /* mode register */
Acpe= 0x12, /* color plane enable */
.
11c
GR= 0x3CF, /* graphics registers */
Grot= 0x03, /* data rotate register */
Gmode= 0x05, /* mode register */
Gmisc= 0x06, /* miscillaneous register */
Grms= 0x04, /* read map select register */
.
## diffname pc/vga.c 1991/0730
## diff -e /n/bootesdump/1991/0727/sys/src/9/safari/vga.c /n/bootesdump/1991/0730/sys/src/9/safari/vga.c
149a
void
screenputc(int c)
{
char buf[2];
int nx;
if(c == '\n'){
out.pos.x = MINX;
out.pos.y += defont0.height;
if(out.pos.y > gscreen.r.max.y-defont0.height)
out.pos.y = gscreen.r.min.y;
gbitblt(&gscreen, Pt(0, out.pos.y), &gscreen,
Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height), 0);
}else if(c == '\t'){
out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid;
if(out.pos.x >= gscreen.r.max.x)
screenputc('\n');
}else if(c == '\b'){
if(out.pos.x >= out.bwid+MINX){
out.pos.x -= out.bwid;
screenputc(' ');
out.pos.x -= out.bwid;
}
}else{
if(out.pos.x >= gscreen.r.max.x-out.bwid)
screenputc('\n');
buf[0] = c&0x7F;
buf[1] = 0;
out.pos = gstring(&gscreen, out.pos, defont, buf, S);
}
}
void
screenputs(char *s, int n)
{
while(n-- > 0)
screenputc(*s++);
}
int
screenbits(void)
{
return 1; /* bits per pixel */
}
void
getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb)
{
ulong ans;
/*
* The magnum monochrome says 0 is black (zero intensity)
*/
if(p == 0)
ans = 0;
else
ans = ~0;
*pr = *pg = *pb = ans;
}
int
setcolor(ulong p, ulong r, ulong g, ulong b)
{
return 0; /* can't change mono screen colormap */
}
int
hwcursset(uchar *s, uchar *c, int ox, int oy)
{
return 0;
}
int
hwcursmove(int x, int y)
{
return 0;
}
void
mouseclock(void) /* called splhi */
{
mouseupdate(1);
}
.
143,147c
defont = &defont0; /* save space; let bitblt do the conversion work */
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, 0); /**/
/*
* stick print at the top
*/
out.pos.x = MINX;
out.pos.y = 0;
out.bwid = defont0.info[' '].width;
/*
* swizzle the damn font longs.
* we do it here since the font is in a machine independent (i.e.
* made for the 68020) format.
*/
l = defont->bits->base;
for(i = defont->bits->width*Dy(defont->bits->r); i > 0; i--, l++)
*l = (*l<<24) | ((*l>>8)&0x0000ff00) | ((*l<<8)&0x00ff0000) | (*l>>24);
.
138a
srout(Smmask, 0x0f); /* enable all 4 color planes for writing */
.
129c
display = (uchar *)SCREENMEM;
.
127a
ulong *l;
.
123c
screeninit(void)
.
94c
screen = (uchar *)SCREENMEM;
.
32,37d
7a
#include <libg.h>
#include <gnot.h>
#include "screen.h"
#define MINX 8
extern GFont defont0;
GFont *defont;
struct{
Point pos;
int bwid;
}out;
/*
* screen dimensions
*/
#define MAXX 640
#define MAXY 480
#define SCREENMEM (0xA0000 | KZERO)
GBitmap gscreen =
{
(ulong*)SCREENMEM,
0,
640/32,
0,
0, 0, MAXX, MAXY,
0
};
.
## diffname pc/vga.c 1991/0731
## diff -e /n/bootesdump/1991/0730/sys/src/9/safari/vga.c /n/bootesdump/1991/0731/sys/src/9/safari/vga.c
243c
* The safari monochrome says 0 is black (zero intensity)
.
## diffname pc/vga.c 1991/0801
## diff -e /n/bootesdump/1991/0731/sys/src/9/safari/vga.c /n/bootesdump/1991/0801/sys/src/9/safari/vga.c
220c
out.pos = gstring(&gscreen, out.pos, defont, buf, flipD[S]);
.
204c
Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height), flipD[0]);
.
181,189d
176c
* start printing at the top of screen
.
172,173c
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[0]);
.
169a
* swizzle the font longs.
* we do it here since the font is initialized with big endian longs.
*/
defont = &defont0;
l = defont->bits->base;
for(i = defont->bits->width*Dy(defont->bits->r); i > 0; i--, l++)
*l = (*l<<24) | ((*l>>8)&0x0000ff00) | ((*l<<8)&0x00ff0000) | (*l>>24);
/*
.
## diffname pc/vga.c 1991/0904
## diff -e /n/bootesdump/1991/0801/sys/src/9/safari/vga.c /n/bootesdump/1991/0904/sys/src/9/safari/vga.c
271c
mouseclock(void)
.
156,157d
151d
## diffname pc/vga.c 1991/0921
## diff -e /n/bootesdump/1991/0904/sys/src/9/safari/vga.c /n/bootesdump/1991/0921/sys/src/9/safari/vga.c
168c
* we do it here since the font is initialized with big
* endian longs.
.
## diffname pc/vga.c 1991/0927
## diff -e /n/bootesdump/1991/0921/sys/src/9/safari/vga.c /n/bootesdump/1991/0927/sys/src/9/safari/vga.c
271a
}
vgaset(char *cmd)
{
int set;
int reg;
int val;
set = *cmd++;
cmd++;
reg = strtoul(cmd, &cmd, 0);
cmd++;
val = strtoul(cmd, &cmd, 0);
switch(set){
case 'a':
arout(reg, val);
break;
case 'g':
grout(reg, val);
break;
case 'c':
crout(reg, val);
break;
case 's':
srout(reg, val);
break;
}
.
109,145d
## diffname pc/vga.c 1991/0928
## diff -e /n/bootesdump/1991/0927/sys/src/9/safari/vga.c /n/bootesdump/1991/0928/sys/src/9/safari/vga.c
118,128c
vga1();
.
108a
* 2 bit deep display. the bits are adjacent. maybe this
* will work
* 4 color
* 640x480
*/
vga2(void)
{
int i;
arout(Acpe, 0x00); /* disable planes for output */
gscreen.ldepth = 1;
arout(Amode, 0x01); /* color graphics mode */
grout(Gmisc, 0x01); /* graphics mode */
grout(Gmode, 0x30); /* 2 bits deep, even bytes are
* planes 0 and 2, odd are planes
* 1 and 3 */
grout(Grot, 0x00); /* CPU writes bytes to video
* mem without modifications */
crout(Cmode, 0xe3); /* turn off address wrap &
* word mode */
crout(Cmsl, 0x40); /* 1 pixel per scan line */
crout(Cvertend, MAXY); /* 480 lne display */
srout(Smode, 0x06); /* extended memory, odd/even */
srout(Sclock, 0x01); /* 8 bits/char */
srout(Smmask, 0x0f); /* enable 2 planes for writing */
arout(Acpe, 0x0f); /* enable 2 planes for output */
for(i = 0; i < 128*1024;){
((uchar*)SCREENMEM)[i++] = 0x1b;
((uchar*)SCREENMEM)[i++] = 0xe4;
}
for(;;);
}
/*
* set up like vga mode 0x11
* 2 color
* 640x480
*/
vga1(void)
{
arout(Acpe, 0x00); /* disable planes for output */
gscreen.ldepth = 0;
arout(Amode, 0x01); /* color graphics mode */
grout(Gmisc, 0x01); /* graphics mode */
grout(Gmode, 0x00); /* 1 bit deep */
grout(Grot, 0x00); /* CPU writes bytes to video
* mem without modifications */
crout(Cmode, 0xe3); /* turn off address wrap &
* word mode */
crout(Cmsl, 0x40); /* 1 pixel per scan line */
crout(Cvertend, MAXY); /* 480 lne display */
srout(Smode, 0x06); /* extended memory,
* odd/even off */
srout(Sclock, 0x01); /* 8 bits/char */
srout(Smmask, 0x0f); /* enable 4 planes for writing */
arout(Acpe, 0x0f); /* enable 4 planes for output */
}
/*
.
54a
Cvertend= 0x12, /* vertical display end */
.
## diffname pc/vga.c 1991/0929
## diff -e /n/bootesdump/1991/0928/sys/src/9/safari/vga.c /n/bootesdump/1991/0929/sys/src/9/safari/vga.c
196,199d
192,194d
181a
.
171,173d
## diffname pc/vga.c 1991/1002
## diff -e /n/bootesdump/1991/0929/sys/src/9/safari/vga.c /n/bootesdump/1991/1002/sys/src/9/safari/vga.c
162c
crout(Cvertend, MAXY-1); /* 480 lne display */
.
## diffname pc/vga.c 1991/1107
## diff -e /n/bootesdump/1991/1002/sys/src/9/safari/vga.c /n/bootesdump/1991/1107/sys/src/9/safari/vga.c
91a
crdump(void)
{
uchar x;
int i;
for(i = 0; i < 0x16; i++){
outb(CRX, i);
x = inb(CR);
print("cr[0x%lux] = %ux\n", i, x);
}
}
.
## diffname pc/vga.c 1991/1109
## diff -e /n/bootesdump/1991/1107/sys/src/9/safari/vga.c /n/bootesdump/1991/1109/sys/src/9/safari/vga.c
189c
vga12();
.
172,173c
/* last scan line displayed (first is 0) */
crout(Cvde, MAXY-1);
overflow |= ((MAXY-1)&0x200) ? 0x40 : 0;
overflow |= ((MAXY-1)&0x100) ? 0x2 : 0;
/* total scan lines (including retrace) - 2 */
crout(Cvt, (YPERIOD-2));
overflow |= ((YPERIOD-2)&0x200) ? 0x20 : 0;
overflow |= ((YPERIOD-2)&0x100) ? 0x1 : 0;
/* scan lines at which vertcal retrace starts & ends */
crout(Cvrs, (MAXY+10));
overflow |= ((MAXY+10)&0x200) ? 0x80 : 0;
overflow |= ((MAXY+10)&0x100) ? 0x4 : 0;
crout(Cvre, ((YPERIOD-1)&0xf)|0xa0); /* also disable vertical interrupts */
/* scan lines at which vertical blanking starts & ends */
crout(Cvbs, (MAXY+YBORDER));
msl |= ((MAXY+YBORDER)&0x200) ? 0x20 : 0;
overflow |= ((MAXY+YBORDER)&0x100) ? 0x8 : 0;
crout(Cvbe, (YPERIOD-YBORDER)&0x7f);
/* pixels per scan line (always 0 for graphics) */
crout(Cmsl, 0x40|msl); /* also 10th bit of line compare */
/* the overflow bits from the other registers */
crout(Cvover, 0x10|overflow); /* also 9th bit of line compare */
.
169a
msl = overflow = 0;
.
131,161d
128,129c
int overflow;
int msl;
.
126c
vga12(void)
.
124a
*
* we assume the BIOS left the registers in a
* CGA-like mode. Thus we don't set all the registers.
.
121,123c
* set up like vga mode 0x12
* 16 color (though we only use values 0x0 and 0xf)
.
97,103d
92,95d
57a
Cvrs= 0x10, /* vertical retrace start */
Cvre= 0x11, /* vertical retrace end */
Cvde= 0x12, /* vertical display end */
Cvbs= 0x15, /* vertical blank start */
Cvbe= 0x16, /* vertical blank end */
Cmode= 0x17, /* mode register */
.
55,56c
Cvt= 0x06, /* vertical total */
Cvover= 0x07, /* bits that didn't fit elsewhere */
.
26a
#define XPERIOD 800 /* Hsync freq == 31.47 KHZ */
#define YPERIOD 525 /* Vsync freq == 59.9 HZ */
#define YBORDER 2
.
## diffname pc/vga.c 1991/1112
## diff -e /n/bootesdump/1991/1109/sys/src/9/safari/vga.c /n/bootesdump/1991/1112/sys/src/9/safari/vga.c
164a
/* pixels per scan line (always 0 for graphics) */
crout(Cmsl, 0x40|msl); /* also 10th bit of line compare */
.
157,162c
crout(Cvbs, (MAXY+yborder));
msl |= ((MAXY+yborder)&0x100) ? 0x20 : 0;
overflow |= ((MAXY+yborder)&0x100) ? 0x8 : 0;
crout(Cvbe, (yperiod-yborder)&0x7f);
.
152,155c
crout(Cvrs, (MAXY+0x0a)); /**/
overflow |= ((MAXY+0x0a)&0x200) ? 0x80 : 0;
overflow |= ((MAXY+0x0a)&0x100) ? 0x4 : 0;
crout(Cvre, ((yperiod-1)&0xf)|0xa0); /* also disable vertical interrupts */
.
148,150c
crout(Cvt, (yperiod-2));
overflow |= ((yperiod-2)&0x200) ? 0x20 : 0;
overflow |= ((yperiod-2)&0x100) ? 0x1 : 0;
.
141,142c
/* turn off address wrap & word mode */
crout(Cmode, 0xe3);
.
117a
vgadump(void)
{
print("misc is 0x%ux fc is 0x%ux\n", inb(EMISCR), inb(EFCR));
outb(EMISCW, 0xc7);/**/
}
vgaclock(void)
{
outb(EMISCW, 0xc7);/**/
}
.
44a
EMISCR= 0x3CC, /* control sync polarity */
EMISCW= 0x3C2,
EFCW= 0x3DA, /* feature control */
EFCR= 0x3CA,
.
27,29c
int xperiod = 800; /* Hsync freq == 31.47 KHZ */
int yperiod = 525; /* Vsync freq == 59.9 HZ */
int yborder = 7; /* top/bottom border of screen */
.
## diffname pc/vga.c 1991/1113
## diff -e /n/bootesdump/1991/1112/sys/src/9/safari/vga.c /n/bootesdump/1991/1113/sys/src/9/safari/vga.c
323a
}
/*
* a fatter than usual cursor for the safari
*/
Cursor fatarrow = {
{ -1, -1 },
{
0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c,
0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,
0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04,
0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40,
},
{
0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0,
0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8,
0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8,
0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00,
},
};
void
bigcursor(void)
{
extern Cursor arrow;
memmove(&arrow, &fatarrow, sizeof(fatarrow));
.
196c
setmode(&mode12);
bigcursor();
.
181,186c
for(i = 0; i < sizeof(v->attribute); i++)
arout(i, v->attribute[i]);
.
155,179c
for(i = 0; i < sizeof(v->graphics); i++)
grout(i, v->graphics[i]);
.
148,153c
crout(Cvre, 0); /* allow writes to CRT registers 0-7 */
for(i = 0; i < sizeof(v->crt); i++)
crout(i, v->crt[i]);
.
146c
for(i = 0; i < sizeof(v->sequencer); i++)
srout(i, v->sequencer[i]);
.
133,144c
for(i = 0; i < sizeof(v->general); i++)
genout(i, v->general[i]);
.
130,131c
int i;
.
128c
void
setmode(VGAmode *v)
.
125d
80a
genout(int reg, int val)
{
if(reg == 0)
outb(EMISCW, val);
else if (reg == 1)
outb(EFCW, val);
}
void
.
79a
VGAmode mode12 =
{
/* general */
0xe3, 0x00, 0x70, 0x04,
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x06,
/* crt */
0x5f, 0x4f, 0x50, 0x82, 0x54, 0x80, 0x0b, 0x3e,
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59,
0xea, 0x0c, 0xdf, 0x28, 0x00, 0xe7, 0x04, 0xe3,
0xff,
/* graphics */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0f,
0xff,
/* attribute */
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x01, 0x00, 0x0f, 0x00, 0x00,
};
.
78c
* 640x480 display, 16 bit color
.
76a
typedef struct VGAmode VGAmode;
struct VGAmode
{
uchar general[4];
uchar sequencer[5];
uchar crt[0x19];
uchar graphics[9];
uchar attribute[0x15];
};
.
73,74d
67,70d
62,65d
57,58d
51,53d
27,29d
## diffname pc/vga.c 1991/1211
## diff -e /n/bootesdump/1991/1113/sys/src/9/safari/vga.c /n/bootesdump/1991/1211/sys/src/9/safari/vga.c
116,117c
outb(ARW, reg | 0x20);
outb(ARW, val);
.
55,56c
ARW= 0x3C0, /* attribute registers (writing) */
ARR= 0x3C1, /* attribute registers (reading) */
.
## diffname pc/vga.c 1991/1228
## diff -e /n/bootesdump/1991/1211/sys/src/9/safari/vga.c /n/bootesdump/1991/1228/sys/src/9/safari/vga.c
230,231c
Rune r;
int i;
char buf[4];
lock(&printq);
while(n > 0){
i = chartorune(&r, s);
if(i == 0){
s++;
--n;
continue;
}
memmove(buf, s, i);
buf[i] = 0;
n -= i;
s += i;
if(r == '\n')
screenputnl();
else if(r == '\t'){
out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid;
if(out.pos.x >= gscreen.r.max.x)
screenputnl();
}else if(r == '\b'){
if(out.pos.x >= out.bwid+MINX){
out.pos.x -= out.bwid;
gstring(&gscreen, out.pos, defont, " ", flipD[S]);
}
}else{
if(out.pos.x >= gscreen.r.max.x-out.bwid)
screenputnl();
out.pos = gstring(&gscreen, out.pos, defont, buf, flipD[S]);
}
}
unlock(&printq);
.
198,224c
out.pos.x = MINX;
out.pos.y += defont0.height;
if(out.pos.y > gscreen.r.max.y-defont0.height)
out.pos.y = gscreen.r.min.y;
gbitblt(&gscreen, Pt(0, out.pos.y), &gscreen,
Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height), flipD[0]);
.
196c
screenputnl(void)
.
## diffname pc/vga.c 1992/0208
## diff -e /n/bootesdump/1991/1228/sys/src/9/safari/vga.c /n/bootesdump/1992/0208/sys/src/9/safari/vga.c
239c
out.pos = gsubfstring(&gscreen, out.pos, defont, buf, flipD[S]);
.
234c
gsubfstring(&gscreen, out.pos, defont, " ", flipD[S]);
.
14,15c
extern GSubfont defont0;
GSubfont *defont;
.
## diffname pc/vga.c 1992/0321
## diff -e /n/bootesdump/1992/0208/sys/src/9/safari/vga.c /n/bootesdump/1992/0321/sys/src/9/safari/vga.c
2c
#include "../port/lib.h"
.
## diffname pc/vga.c 1992/0401
## diff -e /n/bootesdump/1992/0321/sys/src/9/safari/vga.c /n/bootesdump/1992/0401/sys/src/9/safari/vga.c
189a
delay(2000);
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[F]);
delay(2000);
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[0]);
.
## diffname pc/vga.c 1992/0402
## diff -e /n/bootesdump/1992/0401/sys/src/9/safari/vga.c /n/bootesdump/1992/0402/sys/src/9/safari/vga.c
246c
unlock(&screenlock);
.
217c
lock(&screenlock);
.
209a
Lock screenlock;
.
190,193d
## diffname pc/vga.c 1992/0409
## diff -e /n/bootesdump/1992/0402/sys/src/9/safari/vga.c /n/bootesdump/1992/0409/sys/src/9/safari/vga.c
177d
## diffname pc/vga.c 1992/0414
## diff -e /n/bootesdump/1992/0409/sys/src/9/safari/vga.c /n/bootesdump/1992/0414/sys/src/9/safari/vga.c
121a
delay(1000); /* needed for 16bit VGA path on Ultra SVGA */
.
114a
/*
* if this print is missing, we are left with a blank white screen.
*/
print("arout %d %2x\n", reg, val);
.
102a
/*
* needed or the screen goes blank on an ultra VGA card
*/
delay(1000);
.
94a
delay(1000);
.
90a
#else
/*
* 640x480 display, 16 bit color - attempt at SVGA version...ches
*/
VGAmode mode12 =
{
/* general */
0xe7, 0x00, 0x70, 0x04,
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x06,
/* crt */
0x65, 0x4f, 0x50, 0x88, 0x55, 0x9a, 0x09, 0x3e,
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xe8, 0x8b, 0xdf, 0x28, 0x00, 0xe7, 0x04, 0xe3,
0xff,
/* graphics */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0f,
0xff,
/* attribute */
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x01, 0x00, 0x0f, 0x00, 0x00,
};
#endif
.
68a
#ifdef ORIGINALSAFARI
.
## diffname pc/vga.c 1992/0417
## diff -e /n/bootesdump/1992/0414/sys/src/9/safari/vga.c /n/bootesdump/1992/0417/sys/src/9/safari/vga.c
113c
0x01, 0x07, 0x0f, 0x00, 0x00,
.
## diffname pc/vga.c 1992/0418
## diff -e /n/bootesdump/1992/0417/sys/src/9/safari/vga.c /n/bootesdump/1992/0418/sys/src/9/safari/vga.c
226a
print("PEL Mask Register = %02x\n", inb(0x3c6)&0xff);
.
156c
delay(TESTDELAY); /* needed for 16bit VGA path on Ultra SVGA */
.
132c
delay(TESTDELAY);
.
120c
delay(TESTDELAY);
.
116a
#define TESTDELAY 1
.
111,113c
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0d, 0x0f,
0x01, 0x10, 0x0f, 0x00, 0x00,
.
## diffname pc/vga.c 1992/0423
## diff -e /n/bootesdump/1992/0418/sys/src/9/safari/vga.c /n/bootesdump/1992/0423/sys/src/9/safari/vga.c
229d
206a
dumpmodes(VGAmode *v)
{
int i;
print("general registers: %02x %02x %02x %02x\n",
inb(0x3cc), inb(0x3ca), inb(0x3c2), inb(0x3da));
print("sequence registers: ");
for(i = 0; i < sizeof(v->sequencer); i++) {
outb(SRX, i);
print(" %02x", inb(SR));
}
print("\nCRT registers: ");
for(i = 0; i < sizeof(v->crt); i++) {
outb(CRX, i);
print(" %02x", inb(CR));
}
print("\nGraphics registers: ");
for(i = 0; i < sizeof(v->graphics); i++) {
outb(GRX, i);
print(" %02x", inb(GR));
}
print("\nAttribute registers: ");
for(i = 0; i < sizeof(v->attribute); i++) {
inb(0x3DA);
outb(ARW, i | 0x20);
print(" %02x", inb(ARR));
}
print("\nPEL Mask Register = %02x\n\n", inb(0x3c6)&0xff);
}
#endif
void
.
205a
#ifdef VGATROUBLE
.
158d
154a
.
152,153c
if (reg <= 0xf) {
outb(ARW, reg | 0x0);
outb(ARW, val);
inb(0x3DA);
outb(ARW, reg | 0x20);
} else {
outb(ARW, reg | 0x20);
outb(ARW, val);
}
.
150d
134d
122d
112c
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x3f,
.
99c
0xe7, 0x00, /* 0x70, 0x04, these are read-only */
.
76c
0xe3, 0x00, /* 0x70, 0x04, these are read-only */
.
62c
uchar general[2];
.
## diffname pc/vga.c 1992/0424
## diff -e /n/bootesdump/1992/0423/sys/src/9/safari/vga.c /n/bootesdump/1992/0424/sys/src/9/safari/vga.c
115,117d
71,93d
69d
## diffname pc/vga.c 1992/0430
## diff -e /n/bootesdump/1992/0424/sys/src/9/safari/vga.c /n/bootesdump/1992/0430/sys/src/9/safari/vga.c
228c
setmode(&mode41);
.
91a
/*
* 800x600 display, 16 bit color
*/
VGAmode mode41 =
{
/* general */
0xe7, 0x00, /* 0x70, 0x04, these are read-only */
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x06,
/* crt */
0x5f, 0x4f, 0x50, 0x82, 0x55, 0x81, 0xbf, 0x1f,
0x00, 0x40, 0x0d, 0x0e, 0x00, 0x00, 0x07, 0x80,
0x9c, 0x8e, 0x8f, 0x28, 0x1f, 0x96, 0xb9, 0xa3,
0xff,
/* graphics */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0f,
0xff,
/* attribute */
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x3f,
0x01, 0x10, 0x0f, 0x00, 0x00,
};
.
70c
* 640x480 display, 16 bit color.
.
25,26c
#define MAXX 800
#define MAXY 600
.
## diffname pc/vga.c 1992/0501
## diff -e /n/bootesdump/1992/0430/sys/src/9/safari/vga.c /n/bootesdump/1992/0501/sys/src/9/safari/vga.c
251c
setmode(&mode12);
.
102,105c
0x7f, 0x63, 0x64, 0x9d, 0x67, 0x92, 0x77, 0xf0,
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x5d, 0x8f, 0x57, 0x32, 0x00, 0x5b, 0x74, 0xc3,
0xff,
.
98c
0x2f, 0x00, /* 0x70, 0x04, these are read-only */
.
95c
VGAmode mode6a =
.
93c
* VESA standard (?) 800x600 display, 16 bit color
.
## diffname pc/vga.c 1992/0502
## diff -e /n/bootesdump/1992/0501/sys/src/9/safari/vga.c /n/bootesdump/1992/0502/sys/src/9/safari/vga.c
249a
VGAmode v;
.
239,240d
211a
void
printmode(VGAmode *v) {
int i;
print("general registers: %02x %02x\n",
v->general[0], v->general[1]);
print("sequence registers: ");
for(i = 0; i < sizeof(v->sequencer); i++) {
print(" %02x", v->sequencer[i]);
}
print("\nCRT registers: ");
for(i = 0; i < sizeof(v->crt); i++) {
print(" %02x", v->crt[i]);
}
print("\nGraphics registers: ");
for(i = 0; i < sizeof(v->graphics); i++) {
print(" %02x", v->graphics[i]);
}
print("\nAttribute registers: ");
for(i = 0; i < sizeof(v->attribute); i++) {
print(" %02x", v->attribute[i]);
}
print("\n");
}
void
dumpmodes(void) {
VGAmode *v;
int i;
.
210a
v->general[0] = inb(0x3cc);
v->general[1] = inb(0x3ca);
for(i = 0; i < sizeof(v->sequencer); i++) {
outb(SRX, i);
v->sequencer[i] = inb(SR);
}
for(i = 0; i < sizeof(v->crt); i++) {
outb(CRX, i);
v->crt[i] = inb(CR);
}
for(i = 0; i < sizeof(v->graphics); i++) {
outb(GRX, i);
v->graphics[i] = inb(GR);
}
for(i = 0; i < sizeof(v->attribute); i++) {
inb(0x3DA);
outb(ARW, i | 0x20);
v->attribute[i] = inb(ARR);
}
}
.
208,209c
getmode(VGAmode *v) {
.
102,103c
0x7f, 0x63, 0x64, 0x02, 0x6a, 0x1d, 0x77, 0xf0,
0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
.
98c
0xe3, 0x00, /* 0x70, 0x04, these are read-only */
.
93c
* VESA standard (?) 800x600 display, 16 bit color.
.
75c
0xe7, 0x00,
.
26a
*/
#define MAXX 640
#define MAXY 480
.
24a
/*
.
## diffname pc/vga.c 1992/0519
## diff -e /n/bootesdump/1992/0502/sys/src/9/safari/vga.c /n/bootesdump/1992/0519/sys/src/9/safari/vga.c
322a
delay(50000);
setmode(&mode12);
printmode(&testmode);
.
307c
setmode(&mode6a);
getmode(&testmode);
.
305c
VGAmode testmode;
.
259c
print(" %2.2x", v->attribute[i]);
.
257c
print("\na ");
.
254c
print(" %2.2x", v->graphics[i]);
.
252c
print("\ng ");
.
249c
print(" %2.2x", v->crt[i]);
.
247c
print("\nc ");
.
244c
print(" %2.2x", v->sequencer[i]);
.
242c
print("s ");
.
239c
print("g %2.2x %2x\n",
.
211d
107,110c
0x7a, 0x63, 0x65, 0x9d, 0x67, 0x92, 0x39, 0x1f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x33, 0x82, 0x2b, 0x32, 0x0f, 0x33, 0x36, 0xe7,
0xff,
.
103c
0x2f, 0x00, /* 0x70, 0x04, these are read-only */
.
## diffname pc/vga.c 1992/0520
## diff -e /n/bootesdump/1992/0519/sys/src/9/safari/vga.c /n/bootesdump/1992/0520/sys/src/9/safari/vga.c
324a
printmode(&testmode);
getmode(&testmode);
.
117a
#endif
.
106a
0x7a, 0x63, 0x65, 0x9d, 0x68, 0x99, 0x38, 0x1f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2c, 0x8e, 0x2b, 0x32, 0x0f, 0x32, 0x34, 0xe7,
0xff,
/* graphics */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0f,
0xff,
/* attribute */
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x3f,
0x01, 0x10, 0x0f, 0x00, 0x00,
#ifdef almost
/* general */
0xe7, 0x00, /* 0x70, 0x04, these are read-only */
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x06,
/* crt */
.
103c
0x67, 0x00, /* 0x70, 0x04, these are read-only */
.
31a
*/
#define MAXX 800
#define MAXY 600
.
27,29d
## diffname pc/vga.c 1992/0527
## diff -e /n/bootesdump/1992/0520/sys/src/9/safari/vga.c /n/bootesdump/1992/0527/sys/src/9/safari/vga.c
341,345d
324,325c
setmode(&mode12);
.
164,166d
118,135d
107,109c
0x5f, 0x4f, 0x50, 0x02, 0x54, 0x80, 0x0b, 0x3e,
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
0xea, 0x8c, 0xdf, 0x28, 0x00, 0xe7, 0x04, 0xe3,
.
103c
0xe3, 0x00, /* 0x70, 0x04, these are read-only */
.
100c
VGAmode mode25 =
.
98c
* cardinal (tseng labs) 800x600 display, 16 bit color.
.
31a
*/
.
29c
/*
.
26d
## diffname pc/vga.c 1992/0528
## diff -e /n/bootesdump/1992/0527/sys/src/9/safari/vga.c /n/bootesdump/1992/0528/sys/src/9/safari/vga.c
131,133d
45,63d
10a
#include "vga.h"
.
## diffname pc/vga.c 1992/0603
## diff -e /n/bootesdump/1992/0528/sys/src/9/safari/vga.c /n/bootesdump/1992/0603/sys/src/9/safari/vga.c
397,424d
293,297c
setscreen(MAXX, MAXY, 1);
.
274a
setscreen(int maxx, int maxy, int bpp) {
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[S]);
gscreen.width = maxx/32;
gscreen.r.max = Pt(maxx, maxy);
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[0]);
out.pos.x = MINX;
out.pos.y = 0;
out.bwid = defont0.info[' '].width;
}
void
.
144,164d
79,100d
29,32d
## diffname pc/vga.c 1992/0604
## diff -e /n/bootesdump/1992/0603/sys/src/9/safari/vga.c /n/bootesdump/1992/0604/sys/src/9/safari/vga.c
231a
gscreen.clipr.max = gscreen.r.max;
.
38c
{ 0, 0, MAXX, MAXY, },
{ 0, 0, MAXX, MAXY, },
.
30,31d
## diffname pc/vga.c 1992/0711
## diff -e /n/bootesdump/1992/0604/sys/src/9/safari/vga.c /n/bootesdump/1992/0711/sys/src/9/safari/vga.c
348a
USED(x, y);
.
342a
USED(s, c, ox, oy);
.
336a
USED(p, r, g, b);
.
244d
241,242c
int i;
.
227c
setscreen(int maxx, int maxy, int bpp)
{
USED(bpp);
.
## diffname pc/vga.c 1992/0914
## diff -e /n/bootesdump/1992/0808/sys/src/9/safari/vga.c /n/bootesdump/1992/0914/sys/src/9/pc/vga.c
309d
280d
## diffname pc/vga.c 1992/1013
## diff -e /n/bootesdump/1992/0914/sys/src/9/pc/vga.c /n/bootesdump/1992/1013/sys/src/9/pc/vga.c
71c
0x01, 0x00, 0x0f, 0x00, 0x00,
.
63c
0xea, 0x2c, 0xdf, 0x28, 0x00, 0xea, 0xeb, 0xe3,
.
61c
0x63, 0x4f, 0x58, 0x81, 0x59, 0x81, 0x0b, 0x3e,
.
57c
0xe3, 0x00,
.
52c
* 640x480 display, 16 bit color.
.
## diffname pc/vga.c 1992/1015
## diff -e /n/bootesdump/1992/1013/sys/src/9/pc/vga.c /n/bootesdump/1992/1015/sys/src/9/pc/vga.c
71c
0x01, 0x10, 0x0f, 0x00, 0x00,
.
63c
0xe8, 0x8b, 0xdf, 0x28, 0x00, 0xe7, 0x04, 0xe3,
.
61c
0x65, 0x4f, 0x50, 0x88, 0x55, 0x9a, 0x09, 0x3e,
.
57c
0xe7, 0x00,
.
52c
* 640x480 display, 16 bit color.
.
## diffname pc/vga.c 1992/1030
## diff -e /n/bootesdump/1992/1015/sys/src/9/pc/vga.c /n/bootesdump/1992/1030/sys/src/9/pc/vga.c
383a
void
screenupdate(Rectangle r)
{
USED(r);
}
.
## diffname pc/vga.c 1992/1104
## diff -e /n/bootesdump/1992/1030/sys/src/9/pc/vga.c /n/bootesdump/1992/1104/sys/src/9/pc/vga.c
384,389d
## diffname pc/vga.c 1992/1105
## diff -e /n/bootesdump/1992/1104/sys/src/9/pc/vga.c /n/bootesdump/1992/1105/sys/src/9/pc/vga.c
383a
/*
* collect changes to the 'soft' screen
*/
static Rectangle mbb;
void
mbbrect(Rectangle r)
{
if(!islcd)
return;
if (r.min.x < mbb.min.x)
mbb.min.x = r.min.x;
if (r.min.y < mbb.min.y)
mbb.min.y = r.min.y;
if (r.max.x > mbb.max.x)
mbb.max.x = r.max.x;
if (r.max.y > mbb.max.y)
mbb.max.y = r.max.y;
}
void
mbbpt(Point p)
{
if(!islcd)
return;
if (p.x < mbb.min.x)
mbb.min.x = p.x;
if (p.y < mbb.min.y)
mbb.min.y = p.y;
if (p.x >= mbb.max.x)
mbb.max.x = p.x+1;
if (p.y >= mbb.max.y)
mbb.max.y = p.y+1;
}
void
screenupdate(void)
{
}
void
mousescreenupdate(void)
{
}
.
## diffname pc/vga.c 1992/1106
## diff -e /n/bootesdump/1992/1105/sys/src/9/pc/vga.c /n/bootesdump/1992/1106/sys/src/9/pc/vga.c
384,429d
382a
bitreverse(arrow.set, 2*16);
bitreverse(arrow.clr, 2*16);
.
380,381d
376a
.
316a
screenupdate(void)
{
uchar *sp, *hp, *se;
int y, len, inc;
Rectangle r=mbb;
if(Dy(r) < 0)
return;
sp = (uchar*)gaddr(&gscreen, r.min);
hp = (uchar*)gaddr(&vgascreen, r.min);
len = (r.max.x * (1<<gscreen.ldepth) + 31)/32
- (r.min.x * (1<<gscreen.ldepth))/32;
len *= BY2WD;
inc = gscreen.width * BY2WD - len;
for (y = r.min.y; y < r.max.y; y++){
for(se = sp + len; sp < se;)
*hp++ = cswizzle[*sp++];
sp += inc;
hp += inc;
}
mbb = NULLMBB;
}
void
mousescreenupdate(void)
{
screenupdate();
}
void
.
315a
/*
* copy litte endian soft screen to big endian hard screen
*/
.
307a
rs.max = Pt(gscreen.r.max.x, out.pos.y+defont0.height);
unlock(&screenlock);
mbbrect(rs);
screenupdate();
.
279a
rs.min = Pt(0, out.pos.y);
.
277a
Rectangle rs;
.
267,268c
r = Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height);
gbitblt(&gscreen, r.min, &gscreen, r, flipD[0]);
mbbrect(r);
screenupdate();
.
262a
Rectangle r;
.
260a
mbbrect(Rectangle r)
{
if (r.min.x < mbb.min.x)
mbb.min.x = r.min.x;
if (r.min.y < mbb.min.y)
mbb.min.y = r.min.y;
if (r.max.x > mbb.max.x)
mbb.max.x = r.max.x;
if (r.max.y > mbb.max.y)
mbb.max.y = r.max.y;
screenupdate();
}
void
mbbpt(Point p)
{
if (p.x < mbb.min.x)
mbb.min.x = p.x;
if (p.y < mbb.min.y)
mbb.min.y = p.y;
if (p.x >= mbb.max.x)
mbb.max.x = p.x+1;
if (p.y >= mbb.max.y)
mbb.max.y = p.y+1;
screenupdate();
}
void
.
259a
/*
* collect changes to the 'soft' screen
*/
.
257c
bitreverse((uchar*)defont->bits->base,
defont->bits->width*BY2WD*Dy(defont->bits->r));
/*
* set up 'soft' and hard screens
*/
if(conf.maxx == 0)
conf.maxx = MAXX;
if(conf.maxy == 0)
conf.maxy = MAXY;
setscreen(conf.maxx, conf.maxy, conf.ldepth);
.
252a
bitreverse(arrow.set, 2*16);
bitreverse(arrow.clr, 2*16);
/*
* swizzle the font longs. we do both byte and bit swizzling
* since the font is initialized with big endian longs.
*/
.
249,251c
* arrow is defined as a big endian
.
234c
len = gscreen.width * 4 * maxy;
gscreen.base = malloc(len);
memset((void*)gscreen.base, 0xff, len);
/*
* set string pointer to upper left
*/
.
229,231c
int len;
mbb = NULLMBB;
/*
* zero hard screen
*/
memset((void*)SCREENMEM, 0xff, 64*1024);
vgascreen.ldepth = 0;
vgascreen.base = (void*)SCREENMEM;
vgascreen.width = (maxx*(1<<ldepth))/32;
vgascreen.r.max = Pt(maxx, maxy);
vgascreen.clipr.max = vgascreen.r.max;
/*
* setup new soft screen
*/
gscreen.ldepth = ldepth;
gscreen.width = (maxx*(1<<ldepth))/32;
.
227c
setscreen(int maxx, int maxy, int ldepth)
.
73a
static Rectangle mbb;
static Rectangle NULLMBB = {10000, 10000, -10000, -10000};
.
30,39c
/*
* 'soft' screen bitmap
*/
GBitmap gscreen;
GBitmap vgascreen;
.
26d
22a
int islittle = 1; /* little endian bit ordering in bytes */
extern Cursor arrow;
extern uchar cswizzle[256];
.
## diffname pc/vga.c 1992/1107
## diff -e /n/bootesdump/1992/1106/sys/src/9/pc/vga.c /n/bootesdump/1992/1107/sys/src/9/pc/vga.c
426d
421,424c
l0update(sp, hp, len);
sp += inc+len;
hp += inc+len;
.
416a
if(len <= 0)
return;
.
410a
if(r.min.x < 0)
r.min.x = 0;
if(r.min.y < 0)
r.min.y = 0;
if(r.max.x > gscreen.r.max.x)
r.max.x = gscreen.r.max.x;
if(r.max.y > gscreen.r.max.y)
r.max.y = gscreen.r.max.y;
.
407a
r = mbb;
mbb = NULLMBB;
.
406c
Rectangle r;
.
328d
253,254c
gscreen.base = ((ulong*)malloc(len+2*1024))+256;
memset((char*)gscreen.base, 0xff, len);
.
## diffname pc/vga.c 1992/1108
## diff -e /n/bootesdump/1992/1107/sys/src/9/pc/vga.c /n/bootesdump/1992/1108/sys/src/9/pc/vga.c
514a
/*
* Table for separating and reversing bits in a ldepth 1 bitmap.
* This aids in coverting a little endian ldepth 1 bitmap into the
* 2 big-endian ldepth 0 bitmaps used for the VGA bit planes.
*
* if the bits in uchar x are labeled
* 76543210
* then l1revsep[x] yields a ushort with bits
* ____0246____1357
* where _ represents a bit whose value is 0.
*
* This table is used by l1update() in l.s. l1update is implemented
* in assembler for speed (yech).
*
*/
ushort l1revsep[] = {
0x0000, 0x0800, 0x0008, 0x0808, 0x0400, 0x0c00, 0x0408, 0x0c08,
0x0004, 0x0804, 0x000c, 0x080c, 0x0404, 0x0c04, 0x040c, 0x0c0c,
0x0200, 0x0a00, 0x0208, 0x0a08, 0x0600, 0x0e00, 0x0608, 0x0e08,
0x0204, 0x0a04, 0x020c, 0x0a0c, 0x0604, 0x0e04, 0x060c, 0x0e0c,
0x0002, 0x0802, 0x000a, 0x080a, 0x0402, 0x0c02, 0x040a, 0x0c0a,
0x0006, 0x0806, 0x000e, 0x080e, 0x0406, 0x0c06, 0x040e, 0x0c0e,
0x0202, 0x0a02, 0x020a, 0x0a0a, 0x0602, 0x0e02, 0x060a, 0x0e0a,
0x0206, 0x0a06, 0x020e, 0x0a0e, 0x0606, 0x0e06, 0x060e, 0x0e0e,
0x0100, 0x0900, 0x0108, 0x0908, 0x0500, 0x0d00, 0x0508, 0x0d08,
0x0104, 0x0904, 0x010c, 0x090c, 0x0504, 0x0d04, 0x050c, 0x0d0c,
0x0300, 0x0b00, 0x0308, 0x0b08, 0x0700, 0x0f00, 0x0708, 0x0f08,
0x0304, 0x0b04, 0x030c, 0x0b0c, 0x0704, 0x0f04, 0x070c, 0x0f0c,
0x0102, 0x0902, 0x010a, 0x090a, 0x0502, 0x0d02, 0x050a, 0x0d0a,
0x0106, 0x0906, 0x010e, 0x090e, 0x0506, 0x0d06, 0x050e, 0x0d0e,
0x0302, 0x0b02, 0x030a, 0x0b0a, 0x0702, 0x0f02, 0x070a, 0x0f0a,
0x0306, 0x0b06, 0x030e, 0x0b0e, 0x0706, 0x0f06, 0x070e, 0x0f0e,
0x0001, 0x0801, 0x0009, 0x0809, 0x0401, 0x0c01, 0x0409, 0x0c09,
0x0005, 0x0805, 0x000d, 0x080d, 0x0405, 0x0c05, 0x040d, 0x0c0d,
0x0201, 0x0a01, 0x0209, 0x0a09, 0x0601, 0x0e01, 0x0609, 0x0e09,
0x0205, 0x0a05, 0x020d, 0x0a0d, 0x0605, 0x0e05, 0x060d, 0x0e0d,
0x0003, 0x0803, 0x000b, 0x080b, 0x0403, 0x0c03, 0x040b, 0x0c0b,
0x0007, 0x0807, 0x000f, 0x080f, 0x0407, 0x0c07, 0x040f, 0x0c0f,
0x0203, 0x0a03, 0x020b, 0x0a0b, 0x0603, 0x0e03, 0x060b, 0x0e0b,
0x0207, 0x0a07, 0x020f, 0x0a0f, 0x0607, 0x0e07, 0x060f, 0x0e0f,
0x0101, 0x0901, 0x0109, 0x0909, 0x0501, 0x0d01, 0x0509, 0x0d09,
0x0105, 0x0905, 0x010d, 0x090d, 0x0505, 0x0d05, 0x050d, 0x0d0d,
0x0301, 0x0b01, 0x0309, 0x0b09, 0x0701, 0x0f01, 0x0709, 0x0f09,
0x0305, 0x0b05, 0x030d, 0x0b0d, 0x0705, 0x0f05, 0x070d, 0x0f0d,
0x0103, 0x0903, 0x010b, 0x090b, 0x0503, 0x0d03, 0x050b, 0x0d0b,
0x0107, 0x0907, 0x010f, 0x090f, 0x0507, 0x0d07, 0x050f, 0x0d0f,
0x0303, 0x0b03, 0x030b, 0x0b0b, 0x0703, 0x0f03, 0x070b, 0x0f0b,
0x0307, 0x0b07, 0x030f, 0x0b0f, 0x0707, 0x0f07, 0x070f, 0x0f0f,
};
.
401,440d
397,399d
330a
screenupdate(void)
{
uchar *sp, *hp;
int y, len, incs, inch;
Rectangle r;
r = mbb;
mbb = NULLMBB;
if(Dy(r) < 0)
return;
if(r.min.x < 0)
r.min.x = 0;
if(r.min.y < 0)
r.min.y = 0;
if(r.max.x > gscreen.r.max.x)
r.max.x = gscreen.r.max.x;
if(r.max.y > gscreen.r.max.y)
r.max.y = gscreen.r.max.y;
sp = (uchar*)gaddr(&gscreen, r.min);
hp = (uchar*)gaddr(&vgascreen, r.min);
len = (r.max.x + 31)/32 - r.min.x/32;
len *= BY2WD;
if(len <= 0)
return;
incs = gscreen.width * BY2WD;
inch = vgascreen.width * BY2WD;
switch(gscreen.ldepth){
case 0:
for (y = r.min.y; y < r.max.y; y++){
l0update(sp, hp, len);
sp += incs;
hp += inch;
}
break;
case 1:
for (y = r.min.y; y < r.max.y; y++){
l1update(sp, hp, len);
sp += incs;
hp += inch;
}
break;
}
}
void
.
329a
/*
* copy litte endian soft screen to big endian hard screen
*/
.
## diffname pc/vga.c 1992/1109
## diff -e /n/bootesdump/1992/1108/sys/src/9/pc/vga.c /n/bootesdump/1992/1109/sys/src/9/pc/vga.c
373a
/* reverse the bits and split into 2 bitmaps */
.
366a
case 3:
/* reverse the bits */
.
357c
len = (r.max.x*bits + 31)/32 - (r.min.x*bits)/32;
.
354a
bits = 1<<vgascreen.ldepth;
.
337c
int y, len, incs, inch, bits;
.
253c
if(gscreen.base){
free(gscreen.base);
gscreen.base = ((ulong*)smalloc(len+2*1024))+256;
} else
gscreen.base = ((ulong*)malloc(len+2*1024))+256;
.
246c
* setup new soft screen, free memory for old screen
.
239c
if(ldepth == 3)
vgascreen.ldepth = 3;
else
vgascreen.ldepth = 0;
.
236c
* zero hard screen and setup a bitmap for the new size
.
## diffname pc/vga.c 1992/1110
## diff -e /n/bootesdump/1992/1109/sys/src/9/pc/vga.c /n/bootesdump/1992/1110/sys/src/9/pc/vga.c
457c
return 1<<gscreen.ldepth; /* bits per pixel */
.
449d
363,366c
off = (r.min.x*bits)>>(3-vgascreen.ldepth);
hp = (uchar*)(vgascreen.base+(r.min.y*vgascreen.width)) + off;
off <<= gscreen.ldepth - vgascreen.ldepth;
sp = (uchar*)(gscreen.base+(r.min.y*gscreen.width)) + off;
len = (r.max.x*bits + 7)/8 - (r.min.x*bits)/8;
.
344c
int y, len, incs, inch, bits, off;
.
304a
/*
* set up default grey scale color map
*/
outb(CMWX, 0);
for(i = 0; i < 16; i++){
x = (i*63)/15;
outb(CM, x);
outb(CM, x);
outb(CM, x);
}
.
303d
274c
int i, x;
.
255c
len = gscreen.width * BY2WD * maxy;
.
244c
vgascreen.width = (maxx*(1<<vgascreen.ldepth))/32;
.
## diffname pc/vga.c 1992/1111
## diff -e /n/bootesdump/1992/1110/sys/src/9/pc/vga.c /n/bootesdump/1992/1111/sys/src/9/pc/vga.c
562,594c
ulong l1revsep[] =
{
0x00000, 0x80000, 0x00008, 0x80008, 0x40000, 0xc0000, 0x40008, 0xc0008,
0x00004, 0x80004, 0x0000c, 0x8000c, 0x40004, 0xc0004, 0x4000c, 0xc000c,
0x20000, 0xa0000, 0x20008, 0xa0008, 0x60000, 0xe0000, 0x60008, 0xe0008,
0x20004, 0xa0004, 0x2000c, 0xa000c, 0x60004, 0xe0004, 0x6000c, 0xe000c,
0x00002, 0x80002, 0x0000a, 0x8000a, 0x40002, 0xc0002, 0x4000a, 0xc000a,
0x00006, 0x80006, 0x0000e, 0x8000e, 0x40006, 0xc0006, 0x4000e, 0xc000e,
0x20002, 0xa0002, 0x2000a, 0xa000a, 0x60002, 0xe0002, 0x6000a, 0xe000a,
0x20006, 0xa0006, 0x2000e, 0xa000e, 0x60006, 0xe0006, 0x6000e, 0xe000e,
0x10000, 0x90000, 0x10008, 0x90008, 0x50000, 0xd0000, 0x50008, 0xd0008,
0x10004, 0x90004, 0x1000c, 0x9000c, 0x50004, 0xd0004, 0x5000c, 0xd000c,
0x30000, 0xb0000, 0x30008, 0xb0008, 0x70000, 0xf0000, 0x70008, 0xf0008,
0x30004, 0xb0004, 0x3000c, 0xb000c, 0x70004, 0xf0004, 0x7000c, 0xf000c,
0x10002, 0x90002, 0x1000a, 0x9000a, 0x50002, 0xd0002, 0x5000a, 0xd000a,
0x10006, 0x90006, 0x1000e, 0x9000e, 0x50006, 0xd0006, 0x5000e, 0xd000e,
0x30002, 0xb0002, 0x3000a, 0xb000a, 0x70002, 0xf0002, 0x7000a, 0xf000a,
0x30006, 0xb0006, 0x3000e, 0xb000e, 0x70006, 0xf0006, 0x7000e, 0xf000e,
0x00001, 0x80001, 0x00009, 0x80009, 0x40001, 0xc0001, 0x40009, 0xc0009,
0x00005, 0x80005, 0x0000d, 0x8000d, 0x40005, 0xc0005, 0x4000d, 0xc000d,
0x20001, 0xa0001, 0x20009, 0xa0009, 0x60001, 0xe0001, 0x60009, 0xe0009,
0x20005, 0xa0005, 0x2000d, 0xa000d, 0x60005, 0xe0005, 0x6000d, 0xe000d,
0x00003, 0x80003, 0x0000b, 0x8000b, 0x40003, 0xc0003, 0x4000b, 0xc000b,
0x00007, 0x80007, 0x0000f, 0x8000f, 0x40007, 0xc0007, 0x4000f, 0xc000f,
0x20003, 0xa0003, 0x2000b, 0xa000b, 0x60003, 0xe0003, 0x6000b, 0xe000b,
0x20007, 0xa0007, 0x2000f, 0xa000f, 0x60007, 0xe0007, 0x6000f, 0xe000f,
0x10001, 0x90001, 0x10009, 0x90009, 0x50001, 0xd0001, 0x50009, 0xd0009,
0x10005, 0x90005, 0x1000d, 0x9000d, 0x50005, 0xd0005, 0x5000d, 0xd000d,
0x30001, 0xb0001, 0x30009, 0xb0009, 0x70001, 0xf0001, 0x70009, 0xf0009,
0x30005, 0xb0005, 0x3000d, 0xb000d, 0x70005, 0xf0005, 0x7000d, 0xf000d,
0x10003, 0x90003, 0x1000b, 0x9000b, 0x50003, 0xd0003, 0x5000b, 0xd000b,
0x10007, 0x90007, 0x1000f, 0x9000f, 0x50007, 0xd0007, 0x5000f, 0xd000f,
0x30003, 0xb0003, 0x3000b, 0xb000b, 0x70003, 0xf0003, 0x7000b, 0xf000b,
0x30007, 0xb0007, 0x3000f, 0xb000f, 0x70007, 0xf0007, 0x7000f, 0xf000f,
};
/*
* Table for separating and reversing bits in a ldepth 2 bitmap.
* This aids in coverting a little endian ldepth 1 bitmap into the
* 4 big-endian ldepth 0 bitmaps used for the VGA bit planes.
*
* if the bits in uchar x are labeled
* 76543210
* then l1revsep[x] yields a ushort with bits
* ______04______15______26______37
* where _ represents a bit whose value is 0.
*
* This table is used by l2update() in l.s. l2update is implemented
* in assembler for speed.
*
*/
ulong l2revsep[] =
{
0x0000000, 0x2000000, 0x0020000, 0x2020000, 0x0000200, 0x2000200, 0x0020200, 0x2020200,
0x0000002, 0x2000002, 0x0020002, 0x2020002, 0x0000202, 0x2000202, 0x0020202, 0x2020202,
0x1000000, 0x3000000, 0x1020000, 0x3020000, 0x1000200, 0x3000200, 0x1020200, 0x3020200,
0x1000002, 0x3000002, 0x1020002, 0x3020002, 0x1000202, 0x3000202, 0x1020202, 0x3020202,
0x0010000, 0x2010000, 0x0030000, 0x2030000, 0x0010200, 0x2010200, 0x0030200, 0x2030200,
0x0010002, 0x2010002, 0x0030002, 0x2030002, 0x0010202, 0x2010202, 0x0030202, 0x2030202,
0x1010000, 0x3010000, 0x1030000, 0x3030000, 0x1010200, 0x3010200, 0x1030200, 0x3030200,
0x1010002, 0x3010002, 0x1030002, 0x3030002, 0x1010202, 0x3010202, 0x1030202, 0x3030202,
0x0000100, 0x2000100, 0x0020100, 0x2020100, 0x0000300, 0x2000300, 0x0020300, 0x2020300,
0x0000102, 0x2000102, 0x0020102, 0x2020102, 0x0000302, 0x2000302, 0x0020302, 0x2020302,
0x1000100, 0x3000100, 0x1020100, 0x3020100, 0x1000300, 0x3000300, 0x1020300, 0x3020300,
0x1000102, 0x3000102, 0x1020102, 0x3020102, 0x1000302, 0x3000302, 0x1020302, 0x3020302,
0x0010100, 0x2010100, 0x0030100, 0x2030100, 0x0010300, 0x2010300, 0x0030300, 0x2030300,
0x0010102, 0x2010102, 0x0030102, 0x2030102, 0x0010302, 0x2010302, 0x0030302, 0x2030302,
0x1010100, 0x3010100, 0x1030100, 0x3030100, 0x1010300, 0x3010300, 0x1030300, 0x3030300,
0x1010102, 0x3010102, 0x1030102, 0x3030102, 0x1010302, 0x3010302, 0x1030302, 0x3030302,
0x0000001, 0x2000001, 0x0020001, 0x2020001, 0x0000201, 0x2000201, 0x0020201, 0x2020201,
0x0000003, 0x2000003, 0x0020003, 0x2020003, 0x0000203, 0x2000203, 0x0020203, 0x2020203,
0x1000001, 0x3000001, 0x1020001, 0x3020001, 0x1000201, 0x3000201, 0x1020201, 0x3020201,
0x1000003, 0x3000003, 0x1020003, 0x3020003, 0x1000203, 0x3000203, 0x1020203, 0x3020203,
0x0010001, 0x2010001, 0x0030001, 0x2030001, 0x0010201, 0x2010201, 0x0030201, 0x2030201,
0x0010003, 0x2010003, 0x0030003, 0x2030003, 0x0010203, 0x2010203, 0x0030203, 0x2030203,
0x1010001, 0x3010001, 0x1030001, 0x3030001, 0x1010201, 0x3010201, 0x1030201, 0x3030201,
0x1010003, 0x3010003, 0x1030003, 0x3030003, 0x1010203, 0x3010203, 0x1030203, 0x3030203,
0x0000101, 0x2000101, 0x0020101, 0x2020101, 0x0000301, 0x2000301, 0x0020301, 0x2020301,
0x0000103, 0x2000103, 0x0020103, 0x2020103, 0x0000303, 0x2000303, 0x0020303, 0x2020303,
0x1000101, 0x3000101, 0x1020101, 0x3020101, 0x1000301, 0x3000301, 0x1020301, 0x3020301,
0x1000103, 0x3000103, 0x1020103, 0x3020103, 0x1000303, 0x3000303, 0x1020303, 0x3020303,
0x0010101, 0x2010101, 0x0030101, 0x2030101, 0x0010301, 0x2010301, 0x0030301, 0x2030301,
0x0010103, 0x2010103, 0x0030103, 0x2030103, 0x0010303, 0x2010303, 0x0030303, 0x2030303,
0x1010101, 0x3010101, 0x1030101, 0x3030101, 0x1010301, 0x3010301, 0x1030301, 0x3030301,
0x1010103, 0x3010103, 0x1030103, 0x3030103, 0x1010303, 0x3010303, 0x1030303, 0x3030303,
.
559c
* in assembler for speed.
.
555c
* ________0246________1357
.
401a
case 2:
off = r.min.x>>3;
hp = (uchar*)(vgascreen.base+(r.min.y*vgascreen.width)) + off;
sp = (uchar*)(gscreen.base+(r.min.y*gscreen.width)) + 4*off;
len = (r.max.x + 7)/8 - r.min.x/8;
if(len < 1)
len = 1;
/* reverse the bits and split into 2 bit planes */
for (y = r.min.y; y < r.max.y; y++){
l2update(sp, hp, len);
sp += incs;
hp += inch;
}
break;
case 3:
y2pg = (64*1024/BY2WD)/gscreen.width;
off = (r.min.y % y2pg) * gscreen.width * BY2WD + r.min.x;
hp = (uchar*)(vgascreen.base) + off;
sp = (uchar*)(gscreen.base) + off;
len = r.max.x - r.min.x;
if(len < 1)
return;
y = r.min.y;
for(page = y/y2pg; y < r.max.y; page++){
unlocktseng();
outb(0x3cd, (page<<4)|page);
ey = (page+1)*y2pg;
if(ey > r.max.y)
ey = r.max.y;
for (; y < ey; y++){
memmove(sp, hp, len);
sp += incs;
hp += inch;
}
hp = (uchar*)(vgascreen.base) + r.min.x;
}
break;
.
395c
r.min.x &= ~15; /* 16 bit allignment for l1update() */
off = r.min.x>>3;
hp = (uchar*)(vgascreen.base+(r.min.y*vgascreen.width)) + off;
sp = (uchar*)(gscreen.base+(r.min.y*gscreen.width)) + 2*off;
len = (r.max.x + 15)/8 - r.min.x/8;
if(len < 2)
len = 2;
/* reverse the bits and split into 2 bit planes */
.
386c
off = r.min.x>>3;
hp = (uchar*)(vgascreen.base+(r.min.y*vgascreen.width)) + off;
sp = (uchar*)(gscreen.base+(r.min.y*gscreen.width)) + off;
len = (r.max.x + 7)/8 - r.min.x/8;
if(len < 1)
return;
.
372,380d
354c
int y, len, incs, inch, off, page, y2pg, ey;
.
346a
void
unlocktseng(void) {
outb(0x3bf, 0x03);
outb(0x3d8, 0xa0);
}
.
314a
outb(CMWX, 5);
outb(CM, 21);
outb(CM, 21);
outb(CM, 21);
outb(CMWX, 0xa);
outb(CM, 42);
outb(CM, 42);
outb(CM, 42);
.
310,313c
outb(CM, colourxpnd(i<<1));
outb(CM, colourxpnd(i>>2));
outb(CM, colourxpnd(i&~1));
.
306c
* set up color map
.
270a
int
colourxpnd(int x)
{
x &= 3;
return (x<<4)|(x<<2)|x;
}
.
258,260c
p = smalloc(len+2*1024));
gscreen.base = ((ulong*)p) + 256;
} else {
p = malloc(len+2*1024));
gscreen.base = ((ulong*)p) + 256;
}
pad1 = p;
pad2 = p + len + 1024;
memset(pad1, 0, 1024);
memset(pad2, 0, 1024);
.
231a
uchar *p;
.
227a
uchar *pad1, *pad2;
.
## diffname pc/vga.c 1992/1112
## diff -e /n/bootesdump/1992/1111/sys/src/9/pc/vga.c /n/bootesdump/1992/1112/sys/src/9/pc/vga.c
570,571c
p &= (1<<(1<<gscreen.ldepth))-1;
lock(&colorlock);
outb(CMWX, p);
outb(CM, r>>(32-6));
outb(CM, g>>(32-6));
outb(CM, b>>(32-6));
unlock(&colorlock);
return ~0;
.
566d
554,563c
p &= (1<<(1<<gscreen.ldepth))-1;
lock(&colorlock);
outb(CMRX, p);
*pr = expand(inb(CM));
*pg = expand(inb(CM));
*pb = expand(inb(CM));
unlock(&colorlock);
.
550a
static ulong
expand(uchar x)
{
return (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24));
}
.
476a
if(nocheck==0 && memcmp(pad1, pad2, 1024)){
nocheck = 1;
print("a: %d %d %d %d\n", r.min.x, r.min.y, r.max.x, r.max.y);
nocheck = 0;
memset(pad1, 0, 1024);
memset(pad2, 0, 1024);
}
.
427,428c
if(len < 0)
return;
.
389a
if(nocheck==0 && memcmp(pad1, pad2, 1024)){
nocheck = 1;
print("b: %d %d %d %d\n", r.min.x, r.min.y, r.max.x, r.max.y);
nocheck = 0;
memset(pad1, 0, 1024);
memset(pad2, 0, 1024);
}
.
385a
static int nocheck;
.
331,338c
unlock(&colorlock);
.
327,329c
x = (i*63)/15;
outb(CM, x);
outb(CM, x);
outb(CM, x);
.
324a
lock(&colorlock);
.
281,287d
273a
* set depth of cursor backup area
*/
bitdepth();
/*
.
271a
memset((void*)SCREENMEM, 0xff, vgascreen.width * BY2WD * maxy);
.
270a
gscreen.base = (ulong*)(p+1024);
.
268c
pad2 = p + 1024 + len;
.
261,266c
p = smalloc(len + 2*1024);
} else
p = malloc(len + 2*1024);
.
257c
gscreen.clipr = gscreen.r;
.
255a
gscreen.r.min = Pt(0, 0);
.
249c
vgascreen.clipr = vgascreen.r;
.
247a
vgascreen.r.min = Pt(0, 0);
.
241d
70c
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
.
28d
25,26c
extern GSubfont defont0;
GSubfont *defont;
extern Cursor arrow;
extern GBitmap cursorback;
static Lock colorlock; /* color map lock */
.
15,17d
## diffname pc/vga.c 1992/1113
## diff -e /n/bootesdump/1992/1112/sys/src/9/pc/vga.c /n/bootesdump/1992/1113/sys/src/9/pc/vga.c
607a
spllo(); /* so we don't cause lost chars on the uart */
.
587c
unlock(&vgalock);
.
582c
lock(&vgalock);
colormap[p][0] = r;
colormap[p][1] = g;
colormap[p][2] = b;
.
570,575c
lock(&vgalock);
*pr = colormap[p][0];
*pg = colormap[p][1];
*pb = colormap[p][2];
unlock(&vgalock);
.
555,566d
544c
vgaupdate();
.
503,504d
500c
vgaupdate();
.
479,484c
void
screenupdate(void)
{
lock(&vgalock);
vgaupdate();
unlock(&vgalock);
}
void
mousescreenupdate(void)
{
if(canlock(&vgalock)){
vgaupdate();
unlock(&vgalock);
.
477a
}
.
456a
off = r.min.y * gscreen.width * BY2WD + r.min.x;
.
383,390d
372,373c
static void
vgaupdate(void)
.
347c
if (Dy(mbb) > 32 || Dx(mbb) > 32)
mousescreenupdate();
.
318,330d
291,292d
288c
int i;
.
282a
/*
* default color map
*/
switch(ldepth){
case 3:
for(i = 0; i < 256; i++)
setcolor(i, x3to32(i>>5), x3to32(i>>2), x3to32(i<<1));
break;
case 2:
case 1:
case 0:
gscreen.ldepth = 3;
for(i = 0; i < 16; i++){
x = x6to32((i*63)/15);
setcolor(i, x, x, x);
}
gscreen.ldepth = ldepth;
break;
}
.
258,270c
gscreen.base = (ulong*)p;
memset(gscreen.base, 0xff, len);
.
254c
gscreen.width = width;
.
252a
if(gscreen.base)
xfree(gscreen.base);
.
248a
memset(vgascreen.base, 0xff, vgascreen.width * BY2WD * vgamaxy);
.
247c
vgascreen.r.max = Pt(maxx, vgamaxy);
.
245a
vgamaxy = maxy % ((64*1024)/vgascreen.width);
vgascreen.base = (void*)SCREENMEM;
.
244d
234a
if(ldepth == 3)
setmode(&mode13);
else
setmode(&mode12);
/* allocate a new soft bitmap area */
width = (maxx*(1<<ldepth))/32;
len = width * BY2WD * maxy;
p = xalloc(len);
if(p == 0)
panic("can't alloc screen bitmap");
.
232c
int len, vgamaxy, width, i, x;
.
228a
x = x&7;
x= (x<<3)|x;
y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30));
return y;
}
static ulong
x6to32(uchar x)
{
ulong y;
x = x&0x3f;
y = (x<<(32-6))|(x<<(32-12))|(x<<(32-18))|(x<<(32-24))|(x<<(32-30));
return y;
}
.
227c
/*
* expand 3 and 6 bits of color to 32
*/
static ulong
x3to32(uchar x)
{
ulong y;
.
225c
#endif asdf
.
191a
#ifdef asdf
.
72a
/*
* 640x480 display, 8 bit color.
*/
VGAmode mode13 =
{
/* general */
0xe7, 0x00,
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x0e,
/* crt */
0x65, 0x4f, 0x50, 0x88, 0x55, 0x9a, 0x09, 0x3e,
0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xe8, 0x8b, 0xdf, 0x28, 0x00, 0xe7, 0x04, 0xA3,
0xff,
/* graphics */
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0f,
0xff,
/* attribute */
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x41, 0x10, 0x0f, 0x00, 0x00,
};
.
51c
* 640x480 display, 1, 2, or 4 bit color.
.
37,38d
27a
/* exported */
GSubfont *defont;
int islittle = 1; /* little endian bit ordering in bytes */
GBitmap gscreen;
/* local */
static Lock vgalock;
static GBitmap vgascreen;
static ulong colormap[256][3];
.
26d
23d
20,21c
/* imported */
.
## diffname pc/vga.c 1992/1114
## diff -e /n/bootesdump/1992/1113/sys/src/9/pc/vga.c /n/bootesdump/1992/1114/sys/src/9/pc/vga.c
632a
if(vgascreen.ldepth == 3)
p = bitrevtab[p];
.
627a
extern uchar bitrevtab[];
.
613d
602,603d
599a
mbbpt(Pt(out.pos.x, out.pos.y+defont0.height));
.
595a
mbbpt(Pt(out.pos.x + out.bwid, out.pos.y+defont0.height));
.
573c
mbbpt(out.pos);
.
570d
558a
}
.
557c
if(out.pos.y > gscreen.r.max.y-defont0.height){
vgaupdate();
.
523c
memmove(hp, sp, len);
.
519c
ey = (page+1)*vgascreen.r.max.y;
.
516c
for(page = y/vgascreen.r.max.y; y < r.max.y; page++){
.
506,507c
off = (r.min.y % vgascreen.r.max.y) * vgascreen.width * BY2WD + r.min.x;
.
436c
int y, len, incs, inch, off, page, ey;
.
312a
v = (uchar*)vgascreen.base;
for(x = 0; x < vgamaxy; x++)
for(i = 0; i < vgascreen.width*BY2WD; i+=8)
*v = 0;
}
.
311a
if(ldepth == 3){
uchar *v;
.
306c
if(maxy > (64*1024)/(vgascreen.width*BY2WD))
vgamaxy = (64*1024)/(vgascreen.width*BY2WD);
else
vgamaxy = maxy;
.
220,255d
88,90c
0x5f, 0x4f, 0x50, 0x82, 0x54, 0x80, 0xbf, 0x1f,
0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
0x9c, 0x8e, 0x8f, 0x28, 0x40, 0x96, 0xb9, 0xa3,
.
84c
0x63, 0x00,
.
79c
* 320x200 display, 8 bit color.
.
## diffname pc/vga.c 1992/1115
## diff -e /n/bootesdump/1992/1114/sys/src/9/pc/vga.c /n/bootesdump/1992/1115/sys/src/9/pc/vga.c
733,766c
ulong l2revsep[] = {
0x0000000, 0x0000002, 0x0000200, 0x0000202, 0x0020000, 0x0020002, 0x0020200, 0x0020202,
0x2000000, 0x2000002, 0x2000200, 0x2000202, 0x2020000, 0x2020002, 0x2020200, 0x2020202,
0x0000001, 0x0000003, 0x0000201, 0x0000203, 0x0020001, 0x0020003, 0x0020201, 0x0020203,
0x2000001, 0x2000003, 0x2000201, 0x2000203, 0x2020001, 0x2020003, 0x2020201, 0x2020203,
0x0000100, 0x0000102, 0x0000300, 0x0000302, 0x0020100, 0x0020102, 0x0020300, 0x0020302,
0x2000100, 0x2000102, 0x2000300, 0x2000302, 0x2020100, 0x2020102, 0x2020300, 0x2020302,
0x0000101, 0x0000103, 0x0000301, 0x0000303, 0x0020101, 0x0020103, 0x0020301, 0x0020303,
0x2000101, 0x2000103, 0x2000301, 0x2000303, 0x2020101, 0x2020103, 0x2020301, 0x2020303,
0x0010000, 0x0010002, 0x0010200, 0x0010202, 0x0030000, 0x0030002, 0x0030200, 0x0030202,
0x2010000, 0x2010002, 0x2010200, 0x2010202, 0x2030000, 0x2030002, 0x2030200, 0x2030202,
0x0010001, 0x0010003, 0x0010201, 0x0010203, 0x0030001, 0x0030003, 0x0030201, 0x0030203,
0x2010001, 0x2010003, 0x2010201, 0x2010203, 0x2030001, 0x2030003, 0x2030201, 0x2030203,
0x0010100, 0x0010102, 0x0010300, 0x0010302, 0x0030100, 0x0030102, 0x0030300, 0x0030302,
0x2010100, 0x2010102, 0x2010300, 0x2010302, 0x2030100, 0x2030102, 0x2030300, 0x2030302,
0x0010101, 0x0010103, 0x0010301, 0x0010303, 0x0030101, 0x0030103, 0x0030301, 0x0030303,
0x2010101, 0x2010103, 0x2010301, 0x2010303, 0x2030101, 0x2030103, 0x2030301, 0x2030303,
0x1000000, 0x1000002, 0x1000200, 0x1000202, 0x1020000, 0x1020002, 0x1020200, 0x1020202,
0x3000000, 0x3000002, 0x3000200, 0x3000202, 0x3020000, 0x3020002, 0x3020200, 0x3020202,
0x1000001, 0x1000003, 0x1000201, 0x1000203, 0x1020001, 0x1020003, 0x1020201, 0x1020203,
0x3000001, 0x3000003, 0x3000201, 0x3000203, 0x3020001, 0x3020003, 0x3020201, 0x3020203,
0x1000100, 0x1000102, 0x1000300, 0x1000302, 0x1020100, 0x1020102, 0x1020300, 0x1020302,
0x3000100, 0x3000102, 0x3000300, 0x3000302, 0x3020100, 0x3020102, 0x3020300, 0x3020302,
0x1000101, 0x1000103, 0x1000301, 0x1000303, 0x1020101, 0x1020103, 0x1020301, 0x1020303,
0x3000101, 0x3000103, 0x3000301, 0x3000303, 0x3020101, 0x3020103, 0x3020301, 0x3020303,
0x1010000, 0x1010002, 0x1010200, 0x1010202, 0x1030000, 0x1030002, 0x1030200, 0x1030202,
0x3010000, 0x3010002, 0x3010200, 0x3010202, 0x3030000, 0x3030002, 0x3030200, 0x3030202,
0x1010001, 0x1010003, 0x1010201, 0x1010203, 0x1030001, 0x1030003, 0x1030201, 0x1030203,
0x3010001, 0x3010003, 0x3010201, 0x3010203, 0x3030001, 0x3030003, 0x3030201, 0x3030203,
0x1010100, 0x1010102, 0x1010300, 0x1010302, 0x1030100, 0x1030102, 0x1030300, 0x1030302,
0x3010100, 0x3010102, 0x3010300, 0x3010302, 0x3030100, 0x3030102, 0x3030300, 0x3030302,
0x1010101, 0x1010103, 0x1010301, 0x1010303, 0x1030101, 0x1030103, 0x1030301, 0x1030303,
0x3010101, 0x3010103, 0x3010301, 0x3010303, 0x3030101, 0x3030103, 0x3030301, 0x3030303,
.
726c
* ______37______26______15______04
.
682,715c
ulong l1revsep[] = {
0x00000, 0x00008, 0x80000, 0x80008, 0x00004, 0x0000c, 0x80004, 0x8000c,
0x40000, 0x40008, 0xc0000, 0xc0008, 0x40004, 0x4000c, 0xc0004, 0xc000c,
0x00002, 0x0000a, 0x80002, 0x8000a, 0x00006, 0x0000e, 0x80006, 0x8000e,
0x40002, 0x4000a, 0xc0002, 0xc000a, 0x40006, 0x4000e, 0xc0006, 0xc000e,
0x20000, 0x20008, 0xa0000, 0xa0008, 0x20004, 0x2000c, 0xa0004, 0xa000c,
0x60000, 0x60008, 0xe0000, 0xe0008, 0x60004, 0x6000c, 0xe0004, 0xe000c,
0x20002, 0x2000a, 0xa0002, 0xa000a, 0x20006, 0x2000e, 0xa0006, 0xa000e,
0x60002, 0x6000a, 0xe0002, 0xe000a, 0x60006, 0x6000e, 0xe0006, 0xe000e,
0x00001, 0x00009, 0x80001, 0x80009, 0x00005, 0x0000d, 0x80005, 0x8000d,
0x40001, 0x40009, 0xc0001, 0xc0009, 0x40005, 0x4000d, 0xc0005, 0xc000d,
0x00003, 0x0000b, 0x80003, 0x8000b, 0x00007, 0x0000f, 0x80007, 0x8000f,
0x40003, 0x4000b, 0xc0003, 0xc000b, 0x40007, 0x4000f, 0xc0007, 0xc000f,
0x20001, 0x20009, 0xa0001, 0xa0009, 0x20005, 0x2000d, 0xa0005, 0xa000d,
0x60001, 0x60009, 0xe0001, 0xe0009, 0x60005, 0x6000d, 0xe0005, 0xe000d,
0x20003, 0x2000b, 0xa0003, 0xa000b, 0x20007, 0x2000f, 0xa0007, 0xa000f,
0x60003, 0x6000b, 0xe0003, 0xe000b, 0x60007, 0x6000f, 0xe0007, 0xe000f,
0x10000, 0x10008, 0x90000, 0x90008, 0x10004, 0x1000c, 0x90004, 0x9000c,
0x50000, 0x50008, 0xd0000, 0xd0008, 0x50004, 0x5000c, 0xd0004, 0xd000c,
0x10002, 0x1000a, 0x90002, 0x9000a, 0x10006, 0x1000e, 0x90006, 0x9000e,
0x50002, 0x5000a, 0xd0002, 0xd000a, 0x50006, 0x5000e, 0xd0006, 0xd000e,
0x30000, 0x30008, 0xb0000, 0xb0008, 0x30004, 0x3000c, 0xb0004, 0xb000c,
0x70000, 0x70008, 0xf0000, 0xf0008, 0x70004, 0x7000c, 0xf0004, 0xf000c,
0x30002, 0x3000a, 0xb0002, 0xb000a, 0x30006, 0x3000e, 0xb0006, 0xb000e,
0x70002, 0x7000a, 0xf0002, 0xf000a, 0x70006, 0x7000e, 0xf0006, 0xf000e,
0x10001, 0x10009, 0x90001, 0x90009, 0x10005, 0x1000d, 0x90005, 0x9000d,
0x50001, 0x50009, 0xd0001, 0xd0009, 0x50005, 0x5000d, 0xd0005, 0xd000d,
0x10003, 0x1000b, 0x90003, 0x9000b, 0x10007, 0x1000f, 0x90007, 0x9000f,
0x50003, 0x5000b, 0xd0003, 0xd000b, 0x50007, 0x5000f, 0xd0007, 0xd000f,
0x30001, 0x30009, 0xb0001, 0xb0009, 0x30005, 0x3000d, 0xb0005, 0xb000d,
0x70001, 0x70009, 0xf0001, 0xf0009, 0x70005, 0x7000d, 0xf0005, 0xf000d,
0x30003, 0x3000b, 0xb0003, 0xb000b, 0x30007, 0x3000f, 0xb0007, 0xb000f,
0x70003, 0x7000b, 0xf0003, 0xf000b, 0x70007, 0x7000f, 0xf0007, 0xf000f,
.
675c
* ________1357________0246
.
663,664c
pixreverse(arrow.set, 2*16, 0);
pixreverse(arrow.clr, 2*16, 0);
.
609,610d
602,603d
576c
mbbrect(rect);
.
574a
rect.min = Pt(out.pos.x, out.pos.y);
rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height);
.
571c
rect.min = Pt(out.pos.x, out.pos.y);
rect.max = Pt(out.pos.x+out.bwid, out.pos.y+defont0.height);
mbbrect(rect);
.
548d
546a
Rectangle rect;
.
354,355c
pixreverse((uchar*)defont->bits->base,
defont->bits->width*BY2WD*Dy(defont->bits->r), 0);
.
343,344c
pixreverse(arrow.set, 2*16, 0);
pixreverse(arrow.clr, 2*16, 0);
.
282,287d
279,280d
165a
/* turn screen on */
srout(1, v->sequencer[1]);
.
155c
if(i == 1)
srout(i, v->sequencer[i]|0x20); /* avoid enabling screen */
else
srout(i, v->sequencer[i]);
.
150a
/* turn screen off (to avoid damage) */
srout(1, 0x21);
.
## diffname pc/vga.c 1992/1117
## diff -e /n/bootesdump/1992/1115/sys/src/9/pc/vga.c /n/bootesdump/1992/1117/sys/src/9/pc/vga.c
548a
if(cga) {
cgascreenputs(s, n);
return;
}
.
525a
cgascreenputs(char *s, int n)
{
while(n-- > 0)
cgascreenputc(*s++);
}
void
.
524a
static void
cgascreenputc(int c)
{
int i;
static int color;
static int pos;
if(c == '\n'){
pos = pos/CGAWIDTH;
pos = (pos+1)*CGAWIDTH;
} else if(c == '\t'){
i = 8 - ((pos/2)&7);
while(i-->0)
cgascreenputc(' ');
} else if(c == '\b'){
if(pos >= 2)
pos -= 2;
cgascreenputc(' ');
pos -= 2;
} else {
CGASCREEN[pos++] = c;
CGASCREEN[pos++] = 2; /* green on black */
}
if(pos >= CGAWIDTH*CGAHEIGHT){
memmove(CGASCREEN, &CGASCREEN[CGAWIDTH], CGAWIDTH*(CGAHEIGHT-1));
memset(&CGASCREEN[CGAWIDTH*(CGAHEIGHT-1)], 0, CGAWIDTH);
pos = CGAWIDTH*(CGAHEIGHT-1);
}
}
.
504d
502c
sp += incs;
hp += inch - 64*1024;
.
490,500c
edisp = ((uchar*)vgascreen.base) + 64*1024;
outb(0x3cd, (page<<4)|page);
for(y = r.min.y; y < r.max.y; y++){
if(hp + inch < edisp){
f(hp, sp, len);
sp += incs;
hp += inch;
} else {
off = edisp - hp;
if(off <= len){
f(hp, sp, off);
page++;
outb(0x3cd, (page<<4)|page);
f(vgascreen.base, sp+off, len - off);
} else {
f(hp, sp, len);
page++;
outb(0x3cd, (page<<4)|page);
.
487,488c
break;
}
if(len < 1)
return;
.
482,485c
f = memmove;
.
471,479d
467,469c
f = l2update;
.
456,464d
451,454c
f = l1update;
.
440,448d
436,438c
f = l0update;
.
433a
off = r.min.y * vgascreen.width * BY2WD + (r.min.x>>(3 - vgascreen.ldepth));
page = off>>16;
off &= (1<<16)-1;
hp = ((uchar*)vgascreen.base) + off;
off = r.min.y * gscreen.width * BY2WD + (r.min.x>>(3 - gscreen.ldepth));
sp = ((uchar*)gscreen.base) + off;
.
430a
outb(0x3bf, 0x03);
outb(0x3d8, 0xa0);
.
414c
void* (*f)(void*, void*, long);
.
411,412c
uchar *sp, *hp, *edisp;
int y, len, incs, inch, off, page;
.
399,404d
358,365c
cga = 1;
crout(0x0a, 0xff); /* turn off cursor */
memset(CGASCREEN, 0, CGAWIDTH*CGAHEIGHT);
.
340a
unlocktseng();
.
269a
cga = 0;
.
104a
unlocktseng(void) {
outb(0x3bf, 0x03);
outb(0x3d8, 0xa0);
}
void
.
33a
static int cga = 1; /* true if in cga mode */
.
## diffname pc/vga.c 1992/1118
## diff -e /n/bootesdump/1992/1117/sys/src/9/pc/vga.c /n/bootesdump/1992/1118/sys/src/9/pc/vga.c
477c
if(len - off > 0)
f(vgascreen.base, sp+off, len - off);
.
474c
if(off > 0)
f(hp, sp, off);
.
459a
default:
return;
.
430,432d
349,350d
340a
cga = 0;
.
277d
106,111d
## diffname pc/vga.c 1997/1101
## diff -e /n/bootesdump/1992/1118/sys/src/9/pc/vga.c /n/emeliedump/1997/1101/sys/src/brazil/pc/vga.c
649,782d
643,647c
screenputs = vgascreenputs;
.
636,641c
window.min = Pt(48, 48);
window.max = addpt(window.min, Pt(10+w*80, 10+h*50));
if(window.max.y >= scr->gscreen->r.max.y)
window.max.y = scr->gscreen->r.max.y-1;
if(window.max.x >= scr->gscreen->r.max.x)
window.max.x = scr->gscreen->r.max.x-1;
window.max.y = window.min.y+((window.max.y-window.min.y)/h)*h;
curpos = window.min;
.
620,634c
h = scr->memdefont->height;
w = scr->memdefont->info[' '].width;
.
612,618c
int h, w;
.
610c
vgascreenwin(VGAscr* scr)
.
603,606c
unlock(&vgascreenlock);
.
600,601c
flushmemscreen(flushr);
.
577,598c
vgascreenputc(scr, buf, &flushr);
.
565a
flushr = Rect(10000, 10000, -10000, -10000);
.
564a
else
lock(&vgascreenlock);
.
561,563c
scr = &vgascreen[0];
if(!islo()){
/*
* Don't deadlock trying to
* print in an interrupt.
*/
if(!canlock(&vgascreenlock))
return;
.
559c
VGAscr *scr;
Rectangle flushr;
.
557d
503,555d
500c
vgascreenputs(char* s, int n)
.
482,495c
*xp++ = curpos.x;
r = Rect(curpos.x, curpos.y, curpos.x+w, curpos.y+h);
memimagedraw(scr->gscreen, r, back, back->r.min, memones, back->r.min);
memimagestring(scr->gscreen, curpos, &conscol, scr->memdefont, buf);
bbox(flushr, r);
curpos.x += w;
.
455,480c
if(curpos.x >= window.max.x-w)
vgascreenputc(scr, "\n", flushr);
.
450,453c
p = memsubfontwidth(scr->memdefont, buf);
w = p.x;
.
437,448c
.
432,435c
case '\b':
if(xp <= xbuf)
break;
xp--;
r = Rect(*xp, curpos.y, curpos.x, curpos.y+h);
memimagedraw(scr->gscreen, r, back, back->r.min, memones, back->r.min);
bbox(flushr, r);
curpos.x = *xp;
.
425,430c
case '\t':
p = memsubfontwidth(scr->memdefont, " ");
w = p.x;
*xp++ = curpos.x;
pos = (curpos.x-window.min.x)/w;
pos = 4-(pos%4);
r = Rect(curpos.x, curpos.y, curpos.x+pos*w, curpos.y+h);
memimagedraw(scr->gscreen, r, back, back->r.min, memones, back->r.min);
bbox(flushr, r);
curpos.x += pos*w;
break;
.
422,423c
case '\r':
xp = xbuf;
curpos.x = window.min.x;
break;
.
413,420c
case '\n':
if(curpos.y+h >= window.max.y){
vgascroll(scr);
*flushr = window;
}
curpos.y += h;
vgascreenputc(scr, "\r", flushr);
break;
.
410,411c
h = scr->memdefont->height;
switch(buf[0]){
.
407,408c
if(xp < xbuf || xp >= &xbuf[sizeof(xbuf)])
xp = xbuf;
.
405d
402,403c
Point p;
int h, w, pos;
.
400c
vgascreenputc(VGAscr* scr, char* buf, Rectangle *flushr)
.
337,398d
303,334c
curpos.y -= o;
.
140,301c
h = scr->memdefont->height;
o = 8*h;
r = Rpt(window.min, Pt(window.max.x, window.max.y-o));
p = Pt(window.min.x, window.min.y+o);
memimagedraw(scr->gscreen, r, scr->gscreen, p, memones, p);
r = Rpt(Pt(window.min.x, window.max.y-o), window.max);
memimagedraw(scr->gscreen, r, back, ZP, memones, ZP);
.
108,138c
int h, o;
Point p;
Rectangle r;
.
105,106c
static void
vgascroll(VGAscr* scr)
.
102,103c
static Point curpos;
static Rectangle window;
static int *xp;
static int xbuf[256];
static Lock vgascreenlock;
.
100a
static Memimage conscol = {
{ 0, 0, 1, 1 },
{ -100000, -100000, 100000, 100000 },
3,
1,
&consdata,
0,
1
};
.
79,99c
static ulong consbits = 0;
static Memdata consdata = {
nil,
&consbits
.
77a
static Memimage* back = &xback;
.
55,76c
static Memimage xback = {
{ 0, 0, 1, 1 },
{ -100000, -100000, 100000, 100000 },
3,
1,
&backdata,
0,
1
.
13,53c
static ulong backbits = (Backgnd<<24)|(Backgnd<<16)|(Backgnd<<8)|Backgnd;
static Memdata backdata = {
nil,
&backbits
.
8,11c
#define Image IMAGE
#include <draw.h>
#include <memdraw.h>
#include "screen.h"
.
1,6c
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
.
## diffname pc/vga.c 1999/0119
## diff -e /n/emeliedump/1997/1101/sys/src/brazil/pc/vga.c /n/emeliedump/1999/0119/sys/src/brazil/pc/vga.c
10a
#include <cursor.h>
.
## diffname pc/vga.c 1999/1005
## diff -e /n/emeliedump/1999/0119/sys/src/brazil/pc/vga.c /n/emeliedump/1999/1005/sys/src/brazil/pc/vga.c
194a
.
131a
// drawdebug = 0;
.
127,128c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min);
memimagestring(scr->gscreen, curpos, conscol, scr->memdefont, buf);
.
113c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, ZP);
.
103c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, ZP);
.
75a
// drawdebug = 1;
.
64c
memimagedraw(scr->gscreen, r, back, ZP, nil, ZP);
.
62c
memimagedraw(scr->gscreen, r, scr->gscreen, p, nil, p);
.
50a
void
vgaimageinit(ulong chan)
{
if(back == nil){
back = allocmemimage(Rect(0,0,1,1), chan); /* RSC BUG */
if(back == nil)
panic("back alloc"); /* RSC BUG */
back->flags |= Frepl;
back->clipr = Rect(-0x3FFFFFF, -0x3FFFFFF, 0x3FFFFFF, 0x3FFFFFF);
memfillcolor(back, DBlack);
}
if(conscol == nil){
conscol = allocmemimage(Rect(0,0,1,1), chan); /* RSC BUG */
if(conscol == nil)
panic("conscol alloc"); /* RSC BUG */
conscol->flags |= Frepl;
conscol->clipr = Rect(-0x3FFFFFF, -0x3FFFFFF, 0x3FFFFFF, 0x3FFFFFF);
memfillcolor(conscol, DWhite);
}
}
.
49a
int drawdebug;
.
30,44d
14,28c
static Memimage* back;
static Memimage *conscol;
.
## diffname pc/vga.c 1999/1106
## diff -e /n/emeliedump/1999/1005/sys/src/brazil/pc/vga.c /n/emeliedump/1999/1106/sys/src/9/pc/vga.c
125c
combinerect(flushr, r);
.
110c
combinerect(flushr, r);
.
100c
combinerect(flushr, r);
.
## diffname pc/vga.c 2000/0104
## diff -e /n/emeliedump/1999/1106/sys/src/9/pc/vga.c /n/emeliedump/2000/0104/sys/src/9/pc/vga.c
124c
memimagestring(scr->gscreen, curpos, conscol, ZP, scr->memdefont, buf);
.
## diffname pc/vga.c 2000/0330
## diff -e /n/emeliedump/2000/0104/sys/src/9/pc/vga.c /n/emeliedump/2000/0330/sys/src/9/pc/vga.c
192a
/*
* Supposedly this is the way to turn DPMS
* monitors off using just the VGA registers.
* Unfortunately, it seems to mess up the video mode
* on the cards I've tried.
*/
void
vgablank(VGAscr*, int blank)
{
uchar seq1, crtc17;
if(blank) {
seq1 = 0x00;
crtc17 = 0x80;
} else {
seq1 = 0x20;
crtc17 = 0x00;
}
outs(Seqx, 0x0100); /* synchronous reset */
seq1 |= vgaxi(Seqx, 1) & ~0x20;
vgaxo(Seqx, 1, seq1);
crtc17 |= vgaxi(Crtx, 0x17) & ~0x80;
delay(10);
vgaxo(Crtx, 0x17, crtc17);
outs(Crtx, 0x0300); /* end synchronous reset */
}
.
## diffname pc/vga.c 2000/1102
## diff -e /n/emeliedump/2000/0330/sys/src/9/pc/vga.c /n/emeliedump/2000/1102/sys/src/9/pc/vga.c
111a
break;
case '\0':
.
98,100c
*xp++ = curpos.x;
r = Rect(curpos.x, curpos.y, curpos.x+pos*w, curpos.y + h);
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min);
.
95c
if(curpos.x >= window.max.x-4*w)
vgascreenputc(scr, "\n", flushr);
.
## diffname pc/vga.c 2001/0104
## diff -e /n/emeliedump/2000/1102/sys/src/9/pc/vga.c /n/emeliedump/2001/0104/sys/src/9/pc/vga.c
186,191c
window = insetrect(scr->gscreen->r, 48);
window.max.x = window.min.x+((window.max.x-window.min.x)/w)*w;
.
## diffname pc/vga.c 2001/0410
## diff -e /n/emeliedump/2001/0104/sys/src/9/pc/vga.c /n/emeliedump/2001/0410/sys/src/9/pc/vga.c
220a
void
addvgaseg(char *name, ulong pa, ulong size)
{
Physseg seg;
memset(&seg, 0, sizeof seg);
seg.attr = SG_PHYSICAL;
/* can we just seg.name = name; ? */
seg.name = smalloc(NAMELEN);
snprint(seg.name, NAMELEN, name);
seg.pa = pa;
seg.size = size;
addphysseg(&seg);
}
.
## diffname pc/vga.c 2001/0527
## diff -e /n/emeliedump/2001/0410/sys/src/9/pc/vga.c /n/emeliedump/2001/0527/sys/src/9/pc/vga.c
221,236d
## diffname pc/vga.c 2001/0822
## diff -e /n/emeliedump/2001/0527/sys/src/9/pc/vga.c /n/emeliedump/2001/0822/sys/src/9/pc/vga.c
191a
.
## diffname pc/vga.c 2001/0908
## diff -e /n/emeliedump/2001/0822/sys/src/9/pc/vga.c /n/emeliedump/2001/0908/sys/src/9/pc/vga.c
221a
void
addvgaseg(char *name, ulong pa, ulong size)
{
Physseg seg;
memset(&seg, 0, sizeof seg);
seg.attr = SG_PHYSICAL;
seg.name = name;
seg.pa = pa;
seg.size = size;
addphysseg(&seg);
}
.
192d
## diffname pc/vga.c 2002/0920
## diff -e /n/emeliedump/2001/0908/sys/src/9/pc/vga.c /n/emeliedump/2002/0920/sys/src/9/pc/vga.c
234a
void
cornerstring(char *s)
{
int h, w;
VGAscr *scr;
Rectangle r;
Point p;
scr = &vgascreen[0];
if(scr->aperture == 0 || screenputs != vgascreenputs)
return;
p = memsubfontwidth(scr->memdefont, s);
w = p.x;
h = scr->memdefont->height;
r = Rect(0, 0, w, h);
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min);
memimagestring(scr->gscreen, r.min, conscol, ZP, scr->memdefont, s);
// flushmemscreen(r);
}
.
## diffname pc/vga.c 2002/1205
## diff -e /n/emeliedump/2002/0920/sys/src/9/pc/vga.c /n/emeliedump/2002/1205/sys/src/9/pc/vga.c
251c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min, S);
.
128c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min, S);
.
111c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, ZP, S);
.
102c
memimagedraw(scr->gscreen, r, back, back->r.min, nil, back->r.min, S);
.
59c
memimagedraw(scr->gscreen, r, back, ZP, nil, ZP, S);
.
57c
memimagedraw(scr->gscreen, r, scr->gscreen, p, nil, p, S);
.
|
