## diffname pc/vgas3.c 1994/0803
## diff -e /dev/null /n/fornaxdump/1994/0803/sys/src/brazil/pc/vgas3.c
0a
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
#include <libg.h>
#include "screen.h"
#include "vga.h"
/*
* Hardware graphics cursor support for
* generic S3 chipset.
* Assume we're in enhanced mode.
*/
static Lock s3pagelock;
static ulong storage;
extern Bitmap gscreen;
static void
sets3page(int page)
{
uchar crt51;
/*
* I don't understand why these are different.
*/
if(gscreen.ldepth == 3){
/*
* The S3 registers need to be unlocked for this.
* Let's hope they are already:
* vgaxo(Crtx, 0x38, 0x48);
* vgaxo(Crtx, 0x39, 0xA0);
*
* The page is 6 bits, the lower 4 bits in Crt35<3:0>,
* the upper 2 in Crt51<3:2>.
*/
vgaxo(Crtx, 0x35, page & 0x0F);
crt51 = vgaxi(Crtx, 0x51) & 0xF3;
vgaxo(Crtx, 0x51, crt51|((page & 0x30)>>2));
}
else
vgaxo(Crtx, 0x35, (page<<2) & 0x0C);
}
static void
vsyncactive(void)
{
/*
* Hardware cursor information is fetched from display memory
* during the horizontal blank active time. The 80x chips may hang
* if the cursor is turned on or off during this period.
*/
while((vgai(Status1) & 0x08) == 0)
;
}
static void
disable(void)
{
uchar crt45;
/*
* Turn cursor off.
*/
crt45 = vgaxi(Crtx, 0x45) & 0xFE;
vsyncactive();
vgaxo(Crtx, 0x45, crt45);
}
static void
enable(void)
{
int i;
disable();
/*
* Cursor colours. Set both the CR0[EF] and the colour
* stack in case we are using a 16-bit RAMDAC.
*/
vgaxo(Crtx, 0x0E, 0x00);
vgaxo(Crtx, 0x0F, 0xFF);
vgaxi(Crtx, 0x45);
for(i = 0; i < 4; i++)
vgaxo(Crtx, 0x4A, 0x00);
vgaxi(Crtx, 0x45);
for(i = 0; i < 4; i++)
vgaxo(Crtx, 0x4B, 0xFF);
/*
* Find a place for the cursor data in display memory.
* Must be on a 1024-byte boundary.
*/
storage = (gscreen.width*BY2WD*gscreen.r.max.y+1023)/1024;
vgaxo(Crtx, 0x4C, (storage>>8) & 0x0F);
vgaxo(Crtx, 0x4D, storage & 0xFF);
storage *= 1024;
/*
* Enable the cursor in X11 mode.
*/
vgaxo(Crtx, 0x55, vgaxi(Crtx, 0x55)|0x10);
vsyncactive();
vgaxo(Crtx, 0x45, 0x01);
}
static void
load(Cursor *c)
{
uchar *and, *xor;
int x, y;
/*
* Disable the cursor and lock the display
* memory so we can update the cursor bitmap.
* Set the display page (do we need to restore
* the current contents when done?) and the
* pointers to the two planes.
*/
disable();
lock(&s3pagelock);
sets3page(storage>>16);
and = ((uchar*)gscreen.base) + (storage & 0xFFFF);
xor = and + 512;
/*
* The cursor is set in X11 mode which gives the following
* truth table:
* and xor colour
* 0 0 underlying pixel colour
* 0 1 underlying pixel colour
* 1 0 background colour
* 1 1 foreground colour
* Put the cursor into the top-left of the 64x64 array.
*/
for(y = 0; y < 64; y++){
for(x = 0; x < 8; x++){
if(y < 16 && x < 2){
and[8*y + x] = c->clr[2*y + x]^c->set[2*y + x];
xor[8*y + x] = c->set[2*y + x];
}
else {
and[8*y + x] = 0;
xor[8*y + x] = 0;
}
}
}
unlock(&s3pagelock);
/*
* Set the cursor offset and enable the cursor.
*/
vgaxo(Crtx, 0x4E, -c->offset.x);
vgaxo(Crtx, 0x4F, -c->offset.y);
vsyncactive();
vgaxo(Crtx, 0x45, 0x01);
}
static int
move(Point p)
{
vgaxo(Crtx, 0x46, (p.x>>8) & 0x07);
vgaxo(Crtx, 0x47, p.x & 0xFF);
vgaxo(Crtx, 0x49, p.y & 0xFF);
vgaxo(Crtx, 0x48, (p.y>>8) & 0x07);
return 0;
}
Hwgc s3hwgc = {
"s3hwgc",
enable,
load,
move,
disable,
};
void
s3page(int page)
{
if(hwgc == &s3hwgc){
lock(&s3pagelock);
sets3page(page);
unlock(&s3pagelock);
}
else
sets3page(page);
}
.
## diffname pc/vgas3.c 1994/0804
## diff -e /n/fornaxdump/1994/0803/sys/src/brazil/pc/vgas3.c /n/fornaxdump/1994/0804/sys/src/brazil/pc/vgas3.c
166,169c
int x, xo, y, yo;
/*
* Mustn't position the cursor offscreen even partially,
* or it disappears. Therefore, if x or y is -ve, adjust the
* cursor offset instead.
*/
if((x = p.x+hotpoint.x) < 0){
xo = -x;
xo = ((xo+1)/2)*2;
x = 0;
}
else
xo = 0;
if((y = p.y+hotpoint.y) < 0){
yo = -y;
y = 0;
}
else
yo = 0;
vgaxo(Crtx, 0x46, (x>>8) & 0x07);
vgaxo(Crtx, 0x47, x & 0xFF);
vgaxo(Crtx, 0x49, y & 0xFF);
vgaxo(Crtx, 0x4E, xo);
vgaxo(Crtx, 0x4F, yo);
vgaxo(Crtx, 0x48, (y>>8) & 0x07);
.
157,158c
hotpoint = c->offset;
.
155c
* Set the cursor hotpoint and enable the cursor.
.
147,148c
*p++ = 0x00;
*p++ = 0x00;
*p++ = 0x00;
*p++ = 0x00;
.
141,144c
for(x = 0; x < 64/8; x += 2){
if(x < 16/8 && y < 16){
*p++ = c->clr[2*y + x]|c->set[2*y + x];
*p++ = c->clr[2*y + x+1]|c->set[2*y + x+1];
*p++ = c->set[2*y + x];
*p++ = c->set[2*y + x+1];
.
127,128c
p = ((uchar*)gscreen.base) + (storage & 0xFFFF);
.
121c
* pointer to the two planes. What if this crosses
* into a new page?
.
113c
uchar *p;
.
91c
vgaxo(Crtx, 0x4B, 0x00);
.
88c
vgaxo(Crtx, 0x4A, 0xFF);
.
84,85c
vgaxo(Crtx, 0x0E, 0xFF);
vgaxo(Crtx, 0x0F, 0x00);
.
82a
* Why are these colours reversed?
.
18a
static Point hotpoint;
.
## diffname pc/vgas3.c 1994/0809
## diff -e /n/fornaxdump/1994/0804/sys/src/brazil/pc/vgas3.c /n/fornaxdump/1994/0809/sys/src/brazil/pc/vgas3.c
198a
unlock(&s3pagelock);
.
176a
* There seems to be a bug in that if the offset is 1, the
* cursor doesn't disappear off the left edge properly, so
* round it up to be even.
.
172a
if(canlock(&s3pagelock) == 0)
return -1;
.
165a
unlock(&s3pagelock);
.
158d
140a
*
* The cursor pattern in memory is interleaved words of
* AND and XOR patterns.
.
127d
119,120c
* Lock the display memory so we can update the
* cursor bitmap if necessary.
* If it's the same as the last cursor we loaded,
* just make sure it's enabled.
*/
lock(&s3pagelock);
if(memcmp(c, &loaded, sizeof(Cursor)) == 0){
vsyncactive();
vgaxo(Crtx, 0x45, 0x01);
unlock(&s3pagelock);
return;
}
memmove(&loaded, c, sizeof(Cursor));
/*
* Disable the cursor.
.
19a
static Cursor loaded;
.
## diffname pc/vgas3.c 1994/0810
## diff -e /n/fornaxdump/1994/0809/sys/src/brazil/pc/vgas3.c /n/fornaxdump/1994/0810/sys/src/brazil/pc/vgas3.c
192c
return 1;
.
132c
memmove(&curcursor, c, sizeof(Cursor));
.
126c
if(memcmp(c, &curcursor, sizeof(Cursor)) == 0){
.
22a
extern Cursor curcursor;
.
20d
## diffname pc/vgas3.c 1995/0126
## diff -e /n/fornaxdump/1994/0810/sys/src/brazil/pc/vgas3.c /n/fornaxdump/1995/0126/sys/src/brazil/pc/vgas3.c
244a
}
static Vgac s3 = {
"s3",
s3page,
0,
};
void
vgas3link(void)
{
addvgaclink(&s3);
addhwgclink(&s3hwgc);
.
232a
0,
.
94c
vgaxo(Crtx, 0x4B, Pblack);
.
91c
vgaxo(Crtx, 0x4A, Pwhite);
.
87,88c
vgaxo(Crtx, 0x0E, Pwhite);
vgaxo(Crtx, 0x0F, Pblack);
.
29,31d
## diffname pc/vgas3.c 1995/02021
## diff -e /n/fornaxdump/1995/0126/sys/src/brazil/pc/vgas3.c /n/fornaxdump/1995/02021/sys/src/brazil/pc/vgas3.c
234c
static void
.
## diffname pc/vgas3.c 1997/0327
## diff -e /n/fornaxdump/1995/02021/sys/src/brazil/pc/vgas3.c /n/emeliedump/1997/0327/sys/src/brazil/pc/vgas3.c
237,243c
lock(&s3lock);
sets3page(page);
unlock(&s3lock);
.
220c
unlock(&s3lock);
.
188c
if(canlock(&s3lock) == 0)
.
180c
unlock(&s3lock);
.
138c
_disable();
.
126c
unlock(&s3lock);
.
122c
lock(&s3lock);
.
107a
unlock(&s3lock);
.
78a
_disable();
.
77c
lock(&s3lock);
.
72a
disable(void)
{
lock(&s3lock);
_disable();
unlock(&s3lock);
}
static void
.
60c
_disable(void)
.
17c
static Lock s3lock;
.
## diffname pc/vgas3.c 1997/1101
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/pc/vgas3.c /n/emeliedump/1997/1101/sys/src/brazil/pc/vgas3.c
260,266d
254,258c
s3enable,
s3disable,
s3load,
s3move,
.
246,252c
VGAcur vgas3cur = {
"s3hwgc",
.
243a
0,
s3page,
s3linear,
.
236,241c
VGAdev vgas3dev = {
"s3",
.
232d
218c
if((y = p.y+scr->offset.y) < 0){
.
211c
if((x = p.x+scr->offset.x) < 0){
.
200,202d
196c
s3move(VGAscr* scr, Point p)
.
191,192d
188,189c
scr->offset = curs->offset;
s3vsyncactive();
.
186c
* Save the cursor hotpoint and enable the cursor.
.
184a
s3pageset(scr, opage);
unlock(&scr->devlock);
.
171,174c
*p++ = curs->clr[2*y + x]|curs->set[2*y + x];
*p++ = curs->clr[2*y + x+1]|curs->set[2*y + x+1];
*p++ = curs->set[2*y + x];
*p++ = curs->set[2*y + x+1];
.
152,154d
143,150c
p = KADDR(scr->aperture);
lock(&scr->devlock);
opage = s3pageset(scr, scr->storage>>16);
p += (scr->storage & 0xFFFF);
.
134,141c
s3disable(scr);
.
129,132c
* Disable the cursor and
* set the pointer to the two planes.
* Is linear addressing turned on? This will determine
* how we access the cursor storage.
.
126c
int opage, x, y;
.
123c
s3load(VGAscr* scr, Cursor* curs)
.
118,119d
116c
s3vsyncactive();
.
110a
scr->storage = storage;
.
107c
storage = (scr->gscreen->width*BY2WD*scr->gscreen->r.max.y+1023)/1024;
.
87,88d
85c
s3disable(scr);
.
83a
ulong storage;
.
75,82d
73c
s3enable(VGAscr* scr)
.
68c
s3vsyncactive();
.
60c
s3disable(VGAscr*)
.
49a
lock(&scr->devlock);
s3pageset(scr, page);
unlock(&scr->devlock);
}
static ulong
s3linear(VGAscr* scr, int* size, int* align)
{
ulong aperture, oaperture;
int oapsize, wasupamem;
Pcidev *p;
oaperture = scr->aperture;
oapsize = scr->apsize;
wasupamem = scr->isupamem;
if(wasupamem)
upafree(oaperture, oapsize);
scr->isupamem = 0;
if(p = pcimatch(nil, 0x5333, 0)){
aperture = p->mem[0].bar & ~0x0F;
*size = p->mem[0].size;
}
else
aperture = 0;
aperture = upamalloc(aperture, *size, *align);
if(aperture == 0){
if(wasupamem && upamalloc(oaperture, oapsize, 0))
scr->isupamem = 1;
}
else
scr->isupamem = 1;
return aperture;
}
static void
s3vsyncactive(void)
{
.
48c
s3page(VGAscr* scr, int page)
.
44a
opage = (crt35>>2) & 0x03;
}
return opage;
.
43c
else{
.
40,41c
crt51 = vgaxi(Crtx, 0x51);
vgaxo(Crtx, 0x51, (crt51 & ~0x0C)|((page & 0x30)>>2));
opage = ((crt51 & 0x0C)<<2)|(crt35 & 0x0F);
.
29c
crt35 = vgaxi(Crtx, 0x35);
if(scr->gscreen->ldepth == 3){
.
27c
uchar crt35, crt51;
int opage;
.
12,25c
static int
s3pageset(VGAscr* scr, int page)
.
10d
8c
#define Image IMAGE
#include <draw.h>
#include <memdraw.h>
.
5a
#include "io.h"
.
## diffname pc/vgas3.c 1998/0116
## diff -e /n/emeliedump/1997/1101/sys/src/brazil/pc/vgas3.c /n/emeliedump/1998/0116/sys/src/brazil/pc/vgas3.c
198,199c
switch(id){
case 0xE110: /* ViRGE/GX2 */
break;
default:
s3pageset(scr, opage);
unlock(&scr->devlock);
break;
}
.
192,193d
189a
*p++ = 0xFF;
*p++ = 0xFF;
.
184,185c
*p++ = ~(curs->clr[2*y + x]|curs->set[2*y + x]);
*p++ = ~(curs->clr[2*y + x+1]|curs->set[2*y + x+1]);
.
172,175c
* 0 0 background colour
* 0 1 foreground colour
* 1 0 current screen pixel
* 1 1 NOT current screen pixel
.
169,170c
* The cursor is set in Microsoft Windows format (the ViRGE/GX2 no
* longer supports the X11 format) which gives the following truth table:
.
167a
case 0xE110: /* ViRGE/GX2 */
p += scr->storage;
break;
default:
lock(&scr->devlock);
opage = s3pageset(scr, scr->storage>>16);
p += (scr->storage & 0xFFFF);
break;
}
.
164,166c
id = (vgaxi(Crtx, 0x30)<<8)|vgaxi(Crtx, 0x2E);
switch(id){
.
162a
opage = 0;
.
158,159d
153c
int id, opage, x, y;
.
144c
vgaxo(Crtx, 0x55, vgaxi(Crtx, 0x55) & ~0x10);
.
142c
* Enable the cursor in Microsoft Windows format.
.
130a
case 0xE110: /* ViRGE/GX2 */
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4A, Pblack);
vgaxi(Crtx, 0x45);
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4B, Pwhite);
break;
default:
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4A, Pwhite);
vgaxi(Crtx, 0x45);
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4B, Pblack);
break;
}
.
125,129c
id = (vgaxi(Crtx, 0x30)<<8)|vgaxi(Crtx, 0x2E);
switch(id){
.
120c
* This stuff is just a mystery for the ViRGE/GX2.
.
112c
int i, id;
.
47,49c
int id;
id = (vgaxi(Crtx, 0x30)<<8)|vgaxi(Crtx, 0x2E);
switch(id){
case 0xE110: /* ViRGE/GX2 */
break;
default:
lock(&scr->devlock);
s3pageset(scr, page);
unlock(&scr->devlock);
break;
}
.
## diffname pc/vgas3.c 1999/0119
## diff -e /n/emeliedump/1998/0116/sys/src/brazil/pc/vgas3.c /n/emeliedump/1999/0119/sys/src/brazil/pc/vgas3.c
11a
#include <cursor.h>
.
## diffname pc/vgas3.c 1999/0716
## diff -e /n/emeliedump/1999/0119/sys/src/brazil/pc/vgas3.c /n/emeliedump/1999/0716/sys/src/brazil/pc/vgas3.c
92a
memset(&seg, 0, sizeof(seg));
seg.attr = SG_PHYSICAL;
seg.name = smalloc(NAMELEN);
snprint(seg.name, NAMELEN, "s3screen");
seg.pa = aperture;
seg.size = osize;
addphysseg(&seg);
.
72a
osize = *size;
.
69a
Physseg seg;
.
67c
ulong aperture, oaperture, osize;
.
## diffname pc/vgas3.c 1999/0821
## diff -e /n/emeliedump/1999/0716/sys/src/brazil/pc/vgas3.c /n/emeliedump/1999/0821/sys/src/brazil/pc/vgas3.c
244a
case 0xE131: /* ViRGE */
.
201a
case 0xE131: /* ViRGE */
.
## diffname pc/vgas3.c 1999/1005
## diff -e /n/emeliedump/1999/0821/sys/src/brazil/pc/vgas3.c /n/emeliedump/1999/1005/sys/src/brazil/pc/vgas3.c
306a
s3drawinit,
.
299a
/*
* The manual gives byte offsets, but we want ulong offsets, hence /4.
*/
enum {
SrcBase = 0xA4D4/4,
DstBase = 0xA4D8/4,
Stride = 0xA4E4/4,
FgrdData = 0xA4F4/4,
WidthHeight = 0xA504/4,
SrcXY = 0xA508/4,
DestXY = 0xA50C/4,
Command = 0xA500/4,
SubStat = 0x8504/4,
FifoStat = 0x850C/4,
};
/*
* Wait for writes to VGA memory via linear aperture to flush.
*/
enum {Maxloop = 1<<24};
struct {
ulong linear;
ulong fifo;
ulong idle;
} waitcount;
static void
waitforlinearfifo(VGAscr *scr)
{
ulong *mmio;
long x;
static ulong nwaitforlinearfifo;
ulong mask, val;
switch(scr->id){
default:
panic("unknown scr->id in s3 waitforlinearfifo");
case 0xE131: /* ViRGE */
case 0xE13D: /* ViRGE/VX */
mask = 0x0F<<6;
val = 0x08<<6;
break;
case 0xE110: /* ViRGE/GX2 */
mask = 0x1F<<6;
val = 0x10<<6;
break;
}
mmio = scr->mmio;
x = 0;
while((mmio[FifoStat]&mask) != val && x++ < Maxloop)
waitcount.linear++;
}
static void
waitforfifo(VGAscr *scr, int entries)
{
ulong *mmio;
long x;
static ulong nwaitforfifo;
mmio = scr->mmio;
x = 0;
while((mmio[SubStat]&0x1F00) < ((entries+2)<<8) && x++ < Maxloop)
waitcount.fifo++;
}
static void
waitforidle(VGAscr *scr)
{
ulong *mmio;
long x;
mmio = scr->mmio;
x = 0;
while((mmio[SubStat]&0x3F00) != 0x3000 && x++ < Maxloop)
waitcount.idle++;
}
static int
hwscroll(VGAscr *scr, Rectangle r, Rectangle sr)
{
enum { Bitbltop = 0xCC }; /* copy source */
ulong *mmio;
ulong cmd, stride;
Point dp, sp;
int did, d;
d = scr->gscreen->depth;
did = (d-8)/8;
cmd = 0x00000020|(Bitbltop<<17)|(did<<2);
stride = Dx(scr->gscreen->r)*d/8;
if(r.min.x <= sr.min.x){
cmd |= 1<<25;
dp.x = r.min.x;
sp.x = sr.min.x;
}else{
dp.x = r.max.x-1;
sp.x = sr.max.x-1;
}
if(r.min.y <= sr.min.y){
cmd |= 1<<26;
dp.y = r.min.y;
sp.y = sr.min.y;
}else{
dp.y = r.max.y-1;
sp.y = sr.max.y-1;
}
mmio = scr->mmio;
waitforlinearfifo(scr);
waitforfifo(scr, 7);
mmio[SrcBase] = scr->aperture;
mmio[DstBase] = scr->aperture;
mmio[Stride] = (stride<<16)|stride;
mmio[WidthHeight] = ((Dx(r)-1)<<16)|Dy(r);
mmio[SrcXY] = (sp.x<<16)|sp.y;
mmio[DestXY] = (dp.x<<16)|dp.y;
mmio[Command] = cmd;
waitforidle(scr);
return 1;
}
static int
hwfill(VGAscr *scr, Rectangle r, ulong sval)
{
enum { Bitbltop = 0xCC }; /* copy source */
ulong *mmio;
ulong cmd, stride;
int did, d;
d = scr->gscreen->depth;
did = (d-8)/8;
cmd = 0x16000120|(Bitbltop<<17)|(did<<2);
stride = Dx(scr->gscreen->r)*d/8;
mmio = scr->mmio;
waitforlinearfifo(scr);
waitforfifo(scr, 8);
mmio[SrcBase] = scr->aperture;
mmio[DstBase] = scr->aperture;
mmio[DstBase] = scr->aperture;
mmio[Stride] = (stride<<16)|stride;
mmio[FgrdData] = sval;
mmio[WidthHeight] = ((Dx(r)-1)<<16)|Dy(r);
mmio[DestXY] = (r.min.x<<16)|r.min.y;
mmio[Command] = cmd;
waitforidle(scr);
return 1;
}
static void
s3drawinit(VGAscr *scr)
{
ulong id;
id = (vgaxi(Crtx, 0x30)<<8)|vgaxi(Crtx, 0x2E);
scr->id = id;
/*
* It's highly likely that other ViRGEs will work without
* change to the driver, with the exception of the size of
* the linear aperture memory write FIFO. Since we don't
* know that size, I'm not turning them on. See waitforlinearfifo
* above.
*/
switch(id){
case 0xE131: /* ViRGE */
case 0xE13D: /* ViRGE/VX */
case 0xE110: /* ViRGE/GX2 */
scr->mmio = (ulong*)(scr->aperture+0x1000000);
scr->fill = hwfill;
scr->scroll = hwscroll;
}
}
.
246a
case 0xE18A: /* ViRGE/[DG]X */
case 0xE110: /* ViRGE/GX2 */
case 0xE13D: /* ViRGE/VX */
.
245d
202a
case 0xE18A: /* ViRGE/[DG]X */
case 0xE110: /* ViRGE/GX2 */
case 0xE13D: /* ViRGE/VX */
.
201d
157,165d
149,155c
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4A, Pblack);
vgaxi(Crtx, 0x45);
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4B, Pwhite);
.
146,147d
141d
133c
int i;
.
101a
.
94a
if(oaperture)
print("warning (BUG): redefinition of aperture does not change s3screen segment\n");
.
74d
71a
osize = *size;
.
67,68c
ulong aperture, oaperture;
int osize, oapsize, wasupamem;
.
22c
if(scr->gscreen->depth >= 8){
.
## diffname pc/vgas3.c 2000/0326
## diff -e /n/emeliedump/1999/1005/sys/src/brazil/pc/vgas3.c /n/emeliedump/2000/0326/sys/src/9/pc/vgas3.c
465a
/* scr->blank = hwblank; */
.
444a
s3blank(int blank)
{
uchar x;
x = vgaxi(Seqx, CursorSyncCtl);
x &= ~0xF0;
if(blank)
x |= VsyncLo | HsyncLo;
vgaxo(Seqx, CursorSyncCtl, x);
}
static void
.
443a
enum {
CursorSyncCtl = 0x0D, /* in Seqx */
VsyncHi = 0x80,
VsyncLo = 0x40,
HsyncHi = 0x20,
HsyncLo = 0x10,
};
.
## diffname pc/vgas3.c 2000/0611
## diff -e /n/emeliedump/2000/0326/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0611/sys/src/9/pc/vgas3.c
239a
case 0xE122: /* Savage4 */
.
193a
case 0xE122: /* Savage4 */
.
86a
if(wasupamem)
upafree(oaperture, oapsize);
scr->isupamem = 0;
.
81,84c
for(i=0; i<nelem(p->mem); i++){
if(p->mem[i].size >= *size
&& ((p->mem[i].bar & ~0x0F) & (*align-1)) == 0)
break;
}
if(i >= nelem(p->mem)){
print("vgas3: aperture not found\n");
return 0;
}
aperture = p->mem[i].bar & ~0x0F;
*size = p->mem[i].size;
}else
.
76,78d
68c
int i, osize, oapsize, wasupamem;
.
## diffname pc/vgas3.c 2000/0612
## diff -e /n/emeliedump/2000/0611/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0612/sys/src/9/pc/vgas3.c
379a
if(x >= Maxloop)
waitcount.idletimeout++;
.
367a
if(x >= Maxloop)
waitcount.fifotimeout++;
.
354a
if(x >= Maxloop)
waitcount.lineartimeout++;
.
327a
ulong lineartimeout;
ulong fifotimeout;
ulong idletimeout;
.
169c
vgaxo(Crtx, 0x4C, storage>>8);
.
113a
if(mmiosize){
memset(&seg, 0, sizeof(seg));
seg.attr = SG_PHYSICAL;
seg.name = smalloc(NAMELEN);
snprint(seg.name, NAMELEN, mmioname);
seg.pa = mmiobase;
seg.size = mmiosize;
addphysseg(&seg);
}
.
88a
id = (vgaxi(Crtx, 0x30)<<8)|vgaxi(Crtx, 0x2E);
if(id == 0xE122){ /* find Savage4 mmio */
/*
* We could assume that the MMIO registers
* will be in the screen segment and just use
* that, but PCI software is allowed to move them
* if it feels like it, so we look for an aperture of
* the right size; only the first 512k actually means
* anything. The S3 engineers overestimated how
* much space they would need in the first design.
*/
for(j=0; j<nelem(p->mem); j++){
if(i == j)
continue;
if(p->mem[j].size==512*1024 || p->mem[j].size==16*1024*1024){
mmiobase = p->mem[j].bar & ~0x0F;
mmiosize = 512*1024;
mmioname = "savage4mmio";
break;
}
}
if(mmiosize == 0){
print("savage4: mmio not found\n");
return 0;
}
}
.
76a
mmiosize = 0;
mmiobase = 0;
mmioname = nil;
.
67,68c
char *mmioname;
ulong aperture, oaperture, mmiobase, mmiosize;
int i, id, j, osize, oapsize, wasupamem;
.
## diffname pc/vgas3.c 2000/0701
## diff -e /n/emeliedump/2000/0612/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0701/sys/src/9/pc/vgas3.c
289a
case 0xE112: /* Savage4/MX */
.
242a
case 0xE112: /* Savage4/MX */
.
## diffname pc/vgas3.c 2000/0708
## diff -e /n/emeliedump/2000/0701/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0708/sys/src/9/pc/vgas3.c
343a
}
static void
s3enable(VGAscr* scr)
{
int i;
ulong storage;
s3disable(scr);
/*
* Cursor colours. Set both the CR0[EF] and the colour
* stack in case we are using a 16-bit RAMDAC.
*/
vgaxo(Crtx, 0x0E, Pwhite);
vgaxo(Crtx, 0x0F, Pblack);
vgaxi(Crtx, 0x45);
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4A, Pblack);
vgaxi(Crtx, 0x45);
for(i = 0; i < 3; i++)
vgaxo(Crtx, 0x4B, Pwhite);
/*
* Find a place for the cursor data in display memory.
* Must be on a 1024-byte boundary.
*/
storage = (scr->gscreen->width*BY2WD*scr->gscreen->r.max.y+1023)/1024;
vgaxo(Crtx, 0x4C, storage>>8);
vgaxo(Crtx, 0x4D, storage & 0xFF);
storage *= 1024;
scr->storage = storage;
/*
* Load, locate and enable the cursor
* in Microsoft Windows format.
*/
s3load(scr, &arrow);
s3move(scr, ZP);
vgaxo(Crtx, 0x55, vgaxi(Crtx, 0x55) & ~0x10);
s3vsyncactive();
vgaxo(Crtx, 0x45, 0x01);
.
291c
case 0xE112: /* Savage4/IX-MV */
.
243c
case 0xE112: /* Savage4/IX-MV */
.
183,222d
## diffname pc/vgas3.c 2000/0721
## diff -e /n/emeliedump/2000/0708/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0721/sys/src/9/pc/vgas3.c
248c
case 0xE101: /* ViRGE/[DG]X */
.
216,217c
* The cursor is set in Microsoft Windows format (the ViRGE/GX2 doesn't
* support the X11 format) which gives the following truth table:
.
200c
case 0xE101: /* ViRGE/[DG]X */
.
## diffname pc/vgas3.c 2000/0803
## diff -e /n/emeliedump/2000/0721/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0803/sys/src/9/pc/vgas3.c
545,547c
case 0x5631: /* ViRGE */
case 0x883D: /* ViRGE/VX */
case 0x8A10: /* ViRGE/GX2 */
.
394c
case 0x8A10: /* ViRGE/GX2 */
.
389,390c
case 0x5631: /* ViRGE */
case 0x883D: /* ViRGE/VX */
.
247,252c
case 0x5631: /* ViRGE */
case 0x8A01: /* ViRGE/[DG]X */
case 0x8A10: /* ViRGE/GX2 */
case 0x883D: /* ViRGE/VX */
case 0x8A12: /* Savage4/IX-MV */
case 0x8A22: /* Savage4 */
.
199,204c
case 0x5631: /* ViRGE */
case 0x8A01: /* ViRGE/[DG]X */
case 0x8A10: /* ViRGE/GX2 */
case 0x883D: /* ViRGE/VX */
case 0x8A12: /* Savage4/IX-MV */
case 0x8A22: /* Savage4 */
.
94,95c
id = (vgaxi(Crtx, 0x2D)<<8)|vgaxi(Crtx, 0x2E);
if(id == 0x8A22){ /* find Savage4 mmio */
.
53c
case 0x8A10: /* ViRGE/GX2 */
.
50c
id = (vgaxi(Crtx, 0x2D)<<8)|vgaxi(Crtx, 0x2E);
.
## diffname pc/vgas3.c 2000/0809
## diff -e /n/emeliedump/2000/0803/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0809/sys/src/9/pc/vgas3.c
534c
id = (vgaxi(Crtx, 0x2D)<<8)|vgaxi(Crtx, 0x2E);
.
196c
id = (vgaxi(Crtx, 0x2D)<<8)|vgaxi(Crtx, 0x2E);
.
## diffname pc/vgas3.c 2000/0820
## diff -e /n/emeliedump/2000/0809/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0820/sys/src/9/pc/vgas3.c
251c
case 0x8C12: /* Savage4/IX-MV */
.
203c
case 0x8C12: /* Savage4/IX-MV */
.
## diffname pc/vgas3.c 2000/0903
## diff -e /n/emeliedump/2000/0820/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0903/sys/src/9/pc/vgas3.c
551a
break;
case SAVAGE4:
savageinit(scr);
break;
.
545,547c
case VIRGE: /* ViRGE */
case VIRGEVX: /* ViRGE/VX */
case VIRGEGX2: /* ViRGE/GX2 */
.
531a
extern void savageinit(VGAscr*); /* vgasavage.c */
.
528a
.
247,252c
case VIRGE:
case VIRGEDXGX:
case VIRGEGX2:
case VIRGEVX:
case SAVAGEIXMV:
case SAVAGE4:
.
199,204c
case VIRGE:
case VIRGEDXGX:
case VIRGEGX2:
case VIRGEVX:
case SAVAGEIXMV:
case SAVAGE4:
.
110a
scr->mmio = (ulong*)upamalloc(mmiobase, mmiosize, 16*1024*1024);
.
95c
if(id == SAVAGE4){ /* find Savage4 mmio */
.
81c
if(p = pcimatch(nil, PCIS3, 0)){
.
53c
case VIRGEGX2:
.
14a
enum {
PCIS3 = 0x5333, /* PCI VID */
SAVAGE3D = 0x8A20, /* PCI DID */
SAVAGE3DMV = 0x8A21,
SAVAGE4 = 0x8A22,
SAVAGEMXMV = 0x8C10,
SAVAGEMX = 0x8C11,
SAVAGEIXMV = 0x8C12,
SAVAGEIX = 0x8C13,
SAVAGE2000 = 0x9102,
VIRGE = 0x5631,
VIRGEGX2 = 0x8A10,
VIRGEDXGX = 0x8A01,
VIRGEVX = 0x883D,
VIRGEMX = 0x8C01,
VIRGEMXP = 0x8C03,
AURORA64VPLUS = 0x8812,
};
.
## diffname pc/vgas3.c 2000/0904
## diff -e /n/emeliedump/2000/0903/sys/src/9/pc/vgas3.c /n/emeliedump/2000/0904/sys/src/9/pc/vgas3.c
578a
/* scr->mmio is set by s3linear */
.
577a
case SAVAGEIXMV:
scr->mmio = (ulong*)(scr->aperture+0x1000000);
savageinit(scr);
break;
.
570,572c
case VIRGE:
case VIRGEVX:
case VIRGEGX2:
.
## diffname pc/vgas3.c 2001/0405
## diff -e /n/emeliedump/2000/0904/sys/src/9/pc/vgas3.c /n/emeliedump/2001/0405/sys/src/9/pc/vgas3.c
103c
/*
* S3 makes cards other than display controllers, so
* look for the first S3 display controller (device class 3)
* and not one of their sound cards.
*/
p = nil;
while(p = pcimatch(p, PCIS3, 0)){
if(p->ccrb == 0x03)
break;
}
if(p != nil){
.
## diffname pc/vgas3.c 2001/0527
## diff -e /n/emeliedump/2001/0405/sys/src/9/pc/vgas3.c /n/emeliedump/2001/0527/sys/src/9/pc/vgas3.c
182,183c
kstrdup(&seg.name, mmioname);
.
173,174c
kstrdup(&seg.name, "s3screen");
.
103,114c
if(p = pcimatch(nil, PCIS3, 0)){
.
## diffname pc/vgas3.c 2001/0704
## diff -e /n/emeliedump/2001/0527/sys/src/9/pc/vgas3.c /n/emeliedump/2001/0704/sys/src/9/pc/vgas3.c
158c
if(oaperture && oaperture != aperture)
.
## diffname pc/vgas3.c 2001/0908
## diff -e /n/emeliedump/2001/0704/sys/src/9/pc/vgas3.c /n/emeliedump/2001/0908/sys/src/9/pc/vgas3.c
167,174c
if(mmiosize)
addvgaseg(mmioname, mmiobase, mmiosize);
.
160,165c
addvgaseg("s3screen", aperture, osize);
.
103c
/*
* S3 makes cards other than display controllers, so
* look for the first S3 display controller (device class 3)
* and not one of their sound cards.
*/
p = nil;
while(p = pcimatch(p, PCIS3, 0)){
if(p->ccrb == 0x03)
break;
}
if(p != nil){
.
93d
## diffname pc/vgas3.c 2001/1014
## diff -e /n/emeliedump/2001/0908/sys/src/9/pc/vgas3.c /n/emeliedump/2001/1014/sys/src/9/pc/vgas3.c
579a
case SUPERSAVAGEIXC16:
.
514c
stride = round16(Dx(scr->gscreen->r))*d/8;
.
469c
stride = round16(Dx(scr->gscreen->r))*d/8;
.
279d
266,276c
if(dolock){
.
229a
dolock = 1;
.
225a
case SUPERSAVAGEIXC16:
dolock = 0;
.
207c
int id, dolock, opage, x, y;
.
143,144c
scr->mmio = (ulong*)upamalloc(mmiobase, mmiosize, 0);
mmioname = "savagemmio";
.
127c
switch(id){ /* find mmio */
case SAVAGE4:
case SUPERSAVAGEIXC16:
.
24a
SUPERSAVAGEIXC16 = 0x8C2E,
.
14a
#define round16(x) (((x)+15)&~15)
.
## diffname pc/vgas3.c 2001/1015
## diff -e /n/emeliedump/2001/1014/sys/src/9/pc/vgas3.c /n/emeliedump/2001/1015/sys/src/9/pc/vgas3.c
571d
563a
scr->blank = s3blank;
/* hwblank = 1; not known to work well */
.
547d
536c
s3blank(VGAscr*, int blank)
.
511c
stride = Dx(scr->gscreen->r)*d/8;
.
466c
stride = Dx(scr->gscreen->r)*d/8;
.
15,16d
## diffname pc/vgas3.c 2001/1030
## diff -e /n/emeliedump/2001/1015/sys/src/9/pc/vgas3.c /n/emeliedump/2001/1030/sys/src/9/pc/vgas3.c
571a
case SAVAGEMXMV:
.
226a
case SAVAGEMXMV:
.
## diffname pc/vgas3.c 2003/0226
## diff -e /n/emeliedump/2001/1030/sys/src/9/pc/vgas3.c /n/emeliedump/2003/0226/sys/src/9/pc/vgas3.c
579a
case PROSAVAGEP:
case PROSAVAGEK:
.
229a
case PROSAVAGEP:
case PROSAVAGEK:
.
129a
case PROSAVAGEP:
case PROSAVAGEK:
.
20a
PROSAVAGEP = 0x8A25,
PROSAVAGEK = 0x8A26,
.
## diffname pc/vgas3.c 2003/0326
## diff -e /n/emeliedump/2003/0226/sys/src/9/pc/vgas3.c /n/emeliedump/2003/0326/sys/src/9/pc/vgas3.c
411a
case 0x8A01: /* ViRGE/[DG]X. XFree86 says no waiting necessary */
return;
.
|
