#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include <libg.h>
#include <gnot.h>
#include "screen.h"
#define MINX 8
extern GSubfont defont0;
GSubfont *defont;
struct{
Point pos;
int bwid;
}out;
/*
* screen dimensions
*/
/*
#define MAXX 640
#define MAXY 480
*/
#define MAXX 800
#define MAXY 600
#define SCREENMEM (0xA0000 | KZERO)
GBitmap gscreen =
{
(ulong*)SCREENMEM,
0,
640/32,
0,
0, 0, MAXX, MAXY,
0
};
enum
{
EMISCR= 0x3CC, /* control sync polarity */
EMISCW= 0x3C2,
EFCW= 0x3DA, /* feature control */
EFCR= 0x3CA,
GRX= 0x3CE, /* index to graphics registers */
GR= 0x3CF, /* graphics registers */
Grms= 0x04, /* read map select register */
SRX= 0x3C4, /* index to sequence registers */
SR= 0x3C5, /* sequence registers */
Smmask= 0x02, /* map mask */
CRX= 0x3D4, /* index to crt registers */
CR= 0x3D5, /* crt registers */
Cvre= 0x11, /* vertical retrace end */
ARW= 0x3C0, /* attribute registers (writing) */
ARR= 0x3C1, /* attribute registers (reading) */
};
typedef struct VGAmode VGAmode;
struct VGAmode
{
uchar general[2];
uchar sequencer[5];
uchar crt[0x19];
uchar graphics[9];
uchar attribute[0x15];
};
/*
* 640x480 display, 16 bit color.
*/
VGAmode mode12 =
{
/* general */
0xe7, 0x00,
/* 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, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x3f,
0x01, 0x10, 0x0f, 0x00, 0x00,
};
/*
* VESA standard (?) 800x600 display, 16 bit color.
*/
VGAmode mode6a =
{
/* general */
0x67, 0x00, /* 0x70, 0x04, these are read-only */
/* sequence */
0x03, 0x01, 0x0f, 0x00, 0x06,
/* crt */
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 */
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,
/* 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,
#endif
};
void
genout(int reg, int val)
{
if(reg == 0)
outb(EMISCW, val);
else if (reg == 1)
outb(EFCW, val);
}
void
srout(int reg, int val)
{
/*
* needed or the screen goes blank on an ultra VGA card
*/
outb(SRX, reg);
outb(SR, val);
}
void
grout(int reg, int val)
{
outb(GRX, reg);
outb(GR, val);
}
void
arout(int reg, int val)
{
/*
* if this print is missing, we are left with a blank white screen.
*/
inb(0x3DA);
if (reg <= 0xf) {
outb(ARW, reg | 0x0);
outb(ARW, val);
inb(0x3DA);
outb(ARW, reg | 0x20);
} else {
outb(ARW, reg | 0x20);
outb(ARW, val);
}
}
void
crout(int reg, int val)
{
outb(CRX, reg);
outb(CR, val);
}
/*
* m is a bit mask of planes to be affected by CPU writes
*/
vgawrmask(int m)
{
srout(Smmask, m&0xf);
}
/*
* p is the plane that will respond to CPU reads
*/
vgardplane(int p)
{
grout(Grms, p&3);
}
vgadump(void)
{
print("misc is 0x%ux fc is 0x%ux\n", inb(EMISCR), inb(EFCR));
}
void
setmode(VGAmode *v)
{
int i;
for(i = 0; i < sizeof(v->general); i++)
genout(i, v->general[i]);
for(i = 0; i < sizeof(v->sequencer); i++)
srout(i, v->sequencer[i]);
crout(Cvre, 0); /* allow writes to CRT registers 0-7 */
for(i = 0; i < sizeof(v->crt); i++)
crout(i, v->crt[i]);
for(i = 0; i < sizeof(v->graphics); i++)
grout(i, v->graphics[i]);
for(i = 0; i < sizeof(v->attribute); i++)
arout(i, v->attribute[i]);
}
void
getmode(VGAmode *v) {
int i;
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);
}
}
void
printmode(VGAmode *v) {
int i;
print("g %2.2x %2x\n",
v->general[0], v->general[1]);
print("s ");
for(i = 0; i < sizeof(v->sequencer); i++) {
print(" %2.2x", v->sequencer[i]);
}
print("\nc ");
for(i = 0; i < sizeof(v->crt); i++) {
print(" %2.2x", v->crt[i]);
}
print("\ng ");
for(i = 0; i < sizeof(v->graphics); i++) {
print(" %2.2x", v->graphics[i]);
}
print("\na ");
for(i = 0; i < sizeof(v->attribute); i++) {
print(" %2.2x", v->attribute[i]);
}
print("\n");
}
void
dumpmodes(void) {
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));
}
}
#endif
void
screeninit(void)
{
int i, j, k;
int c;
ulong *l;
VGAmode testmode;
setmode(&mode6a);
getmode(&testmode);
/*
* 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);
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, flipD[0]);
out.pos.x = MINX;
out.pos.y = 0;
out.bwid = defont0.info[' '].width;
delay(50000);
setmode(&mode12);
printmode(&testmode);
getmode(&testmode);
printmode(&testmode);
}
void
screenputnl(void)
{
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]);
}
Lock screenlock;
void
screenputs(char *s, int n)
{
Rune r;
int i;
char buf[4];
lock(&screenlock);
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;
gsubfstring(&gscreen, out.pos, defont, " ", flipD[S]);
}
}else{
if(out.pos.x >= gscreen.r.max.x-out.bwid)
screenputnl();
out.pos = gsubfstring(&gscreen, out.pos, defont, buf, flipD[S]);
}
}
unlock(&screenlock);
}
int
screenbits(void)
{
return 1; /* bits per pixel */
}
void
getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb)
{
ulong ans;
/*
* The safari 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)
{
mouseupdate(1);
}
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;
}
}
/*
* 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));
}