Subversion Repositories planix.SVN

#include "u.h"

#include "../port/lib.h"

#include "mem.h"

#include "dat.h"

#include "fns.h"

#include "io.h"

#include "../port/error.h"

#define	Image	IMAGE

#include <draw.h>

#include <memdraw.h>

#include <cursor.h>

#include "screen.h"

/*

 * #9 Ticket to Ride IV.

 */

enum {

	IndexLo		= 0x10/4,

	IndexHi		= 0x14/4,

	Data		= 0x18/4,

	IndexCtl	= 0x1C/4,

	Zoom		= 0x54/4,

};

enum {						/* index registers */

	CursorSyncCtl	= 0x03,

	  HsyncHi = 0x01,

	  HsyncLo = 0x02,

	  VsyncHi = 0x04,

	  VsyncLo = 0x08,

	CursorCtl	= 0x30,

	CursorXLo	= 0x31,

	CursorXHi	= 0x32,

	CursorYLo	= 0x33,

	CursorYHi	= 0x34,

	CursorHotX	= 0x35,

	CursorHotY	= 0x36,

	CursorR1	= 0x40,

	CursorG1	= 0x41,

	CursorB1	= 0x42,

	CursorR2	= 0x43,

	CursorG2	= 0x44,

	CursorB2	= 0x45,

	CursorR3	= 0x46,

	CursorG3	= 0x47,

	CursorB3	= 0x48,

	CursorArray	= 0x100,

	CursorMode32x32	= 0x23,

	CursorMode64x64	= 0x27,

	CursorMode	= CursorMode32x32,

};

static void

t2r4enable(VGAscr* scr)

{

	Pcidev *p;

	void *mmio;

	if(scr->mmio)

		return;

	if(p = pcimatch(nil, 0x105D, 0)){

		switch(p->did){

		case 0x5348:

			break;

		default:

			return;

		}

	}

	else

		return;

	scr->pci = p;

	mmio = vmap(p->mem[4].bar & ~0x0F, p->mem[4].size);

	if(mmio == nil)

		return;

	addvgaseg("t2r4mmio", p->mem[4].bar & ~0x0F, p->mem[4].size);

	scr->mmio = mmio;

	vgalinearpci(scr);

	if(scr->paddr)

		addvgaseg("t2r4screen", scr->paddr, scr->apsize);

}

static uchar

t2r4xi(VGAscr* scr, int index)

{

	ulong *mmio;

	mmio = scr->mmio;

	mmio[IndexLo] = index & 0xFF;

	mmio[IndexHi] = (index>>8) & 0xFF;

	return mmio[Data];

}

static void

t2r4xo(VGAscr* scr, int index, uchar data)

{

	ulong *mmio;

	mmio = scr->mmio;

	mmio[IndexLo] = index & 0xFF;

	mmio[IndexHi] = (index>>8) & 0xFF;

	mmio[Data] = data;

}

static void

t2r4curdisable(VGAscr* scr)

{

	if(scr->mmio == 0)

		return;

	t2r4xo(scr, CursorCtl, 0x00);

}

static void

t2r4curload(VGAscr* scr, Cursor* curs)

{

	uchar *data;

	int size, x, y, zoom;

	ulong clr, *mmio, pixels, set;

	mmio = scr->mmio;

	if(mmio == 0)

		return;

	/*

	 * Make sure cursor is off by initialising the cursor

	 * control to defaults.

	 */

	t2r4xo(scr, CursorCtl, 0x00);

	/*

	 * Set auto-increment mode for index-register addressing

	 * and initialise the cursor array index.

	 */

	mmio[IndexCtl] = 0x01;

	mmio[IndexLo] = CursorArray & 0xFF;

	mmio[IndexHi] = (CursorArray>>8) & 0xFF;

	/*

	 * Initialise the cursor RAM array. There are 2 planes,

	 * p0 and p1. Data is written 4 pixels per byte, with p1 the

	 * MS bit of each pixel.

	 * The cursor is set in X-Windows mode which gives the following

	 * truth table:

	 *	p1 p0	colour

	 *	 0  0	underlying pixel colour

	 *	 0  1	underlying pixel colour

	 *	 1  0	cursor colour 1

	 *	 1  1	cursor colour 2

	 * Put the cursor into the top-left of the array.

	 *

	 * Although this looks a lot like the IBM RGB524 cursor, the

	 * scanlines appear to be twice as long as they should be and

	 * some of the other features are missing.

	 */

	if(mmio[Zoom] & 0x0F)

		zoom = 32;

	else

		zoom = 16;

	data = (uchar*)&mmio[Data];

	for(y = 0; y < zoom; y++){

		clr = (curs->clr[2*y]<<8)|curs->clr[y*2 + 1];

		set = (curs->set[2*y]<<8)|curs->set[y*2 + 1];

		pixels = 0;

		for(x = 0; x < 16; x++){

			if(set & (1<<x))

				pixels |= 0x03<<(x*2);

			else if(clr & (1<<x))

				pixels |= 0x02<<(x*2);

		}

		*data = pixels>>24;

		*data = pixels>>16;

		*data = pixels>>8;

		*data = pixels;

		*data = 0x00;

		*data = 0x00;

		*data = 0x00;

		*data = 0x00;

		if(CursorMode == CursorMode32x32 && zoom == 16)

			continue;

		*data = pixels>>24;

		*data = pixels>>16;

		*data = pixels>>8;

		*data = pixels;

		*data = 0x00;

		*data = 0x00;

		*data = 0x00;

		*data = 0x00;

	}

	if(CursorMode == CursorMode32x32)

		size = 32;

	else

		size = 64;

	while(y < size){

		for(x = 0; x < size/8; x++){

			*data = 0x00;

			*data = 0x00;

		}

		y++;

	}

	mmio[IndexCtl] = 0x00;

	/*

	 * Initialise the hotpoint and enable the cursor.

	 */

	t2r4xo(scr, CursorHotX, -curs->offset.x);

	zoom = (scr->mmio[Zoom] & 0x0F)+1;

	t2r4xo(scr, CursorHotY, -curs->offset.y*zoom);

	t2r4xo(scr, CursorCtl, CursorMode);

}

static int

t2r4curmove(VGAscr* scr, Point p)

{

	int y, zoom;

	if(scr->mmio == 0)

		return 1;

	t2r4xo(scr, CursorXLo, p.x & 0xFF);

	t2r4xo(scr, CursorXHi, (p.x>>8) & 0x0F);

	zoom = (scr->mmio[Zoom] & 0x0F)+1;

	y = p.y*zoom;

	t2r4xo(scr, CursorYLo, y & 0xFF);

	t2r4xo(scr, CursorYHi, (y>>8) & 0x0F);

	return 0;

}

static void

t2r4curenable(VGAscr* scr)

{

	t2r4enable(scr);

	if(scr->mmio == 0)

		return;

	/*

	 * Make sure cursor is off by initialising the cursor

	 * control to defaults.

	 */

	t2r4xo(scr, CursorCtl, 0x00);

	/*

	 * Cursor colour 1 (white),

	 * cursor colour 2 (black).

	 */

	t2r4xo(scr, CursorR1, Pwhite);

	t2r4xo(scr, CursorG1, Pwhite);

	t2r4xo(scr, CursorB1, Pwhite);

	t2r4xo(scr, CursorR2, Pblack);

	t2r4xo(scr, CursorG2, Pblack);

	t2r4xo(scr, CursorB2, Pblack);

	/*

	 * Load, locate and enable the cursor, 64x64, mode 2.

	 */

	t2r4curload(scr, &arrow);

	t2r4curmove(scr, ZP);

	t2r4xo(scr, CursorCtl, CursorMode);

}

enum {

	Flow		= 0x08/4,

	Busy		= 0x0C/4,

	BufCtl		= 0x20/4,

	DeSorg		= 0x28/4,

	DeDorg		= 0x2C/4,

	DeSptch		= 0x40/4,

	DeDptch		= 0x44/4,

	CmdOpc		= 0x50/4,

	CmdRop		= 0x54/4,

	CmdStyle 	= 0x58/4,

	CmdPatrn 	= 0x5C/4,

	CmdClp		= 0x60/4,

	CmdPf		= 0x64/4,

	Fore		= 0x68/4,

	Back		= 0x6C/4,

	Mask		= 0x70/4,

	DeKey		= 0x74/4,

	Lpat		= 0x78/4,

	Pctrl 		= 0x7C/4,

	Clptl		= 0x80/4,

	Clpbr		= 0x84/4,

	XY0		= 0x88/4,

	XY1		= 0x8C/4,

	XY2		= 0x90/4,

	XY3		= 0x94/4,

	XY4		= 0x98/4,

	Alpha 		= 0x128/4,

	ACtl 		= 0x16C/4,

	RBaseD 		= 0x4000/4,

};

/* wait until pipeline ready for new command */

static void

waitforfifo(VGAscr *scr)

{

	int x;

	ulong *d;

	x = 0;

	d = scr->mmio + RBaseD;

	while((d[Busy]&1) && x++ < 1000000)

		;

	if(x >= 1000000)	/* shouldn't happen */

		iprint("busy %8lux\n", d[Busy]);

}

/* wait until command has finished executing */

static void

waitforcmd(VGAscr *scr)

{

	int x;

	ulong *d;

	x = 0;

	d = scr->mmio + RBaseD;

	while((d[Flow]&0x1B) && x++ < 1000000)

		;

	if(x >= 1000000)	/* shouldn't happen */

		iprint("flow %8lux\n", d[Flow]);

}

/* wait until memory controller not busy (i.e. wait for writes to flush) */

static void

waitformem(VGAscr *scr)

{

	int x;

	ulong *d;

	x = 0;

	d = scr->mmio + RBaseD;

	while((d[Flow]&2)&& x++ < 1000000)

		;

	if(x >= 1000000)	/* shouldn't happen */

		iprint("mem %8lux\n", d[Busy]);

}

static int

t2r4hwscroll(VGAscr *scr, Rectangle r, Rectangle sr)

{

	int ctl;

	Point dp, sp;

	ulong *d;

	int depth;

	if(r.min.y == sr.min.y){	/* a purely horizontal scroll */

		depth = scr->gscreen->depth;

		switch(depth){

		case 32:

			/*

			 * Using the SGI flat panels with the Ticket-to-Ride IV, horizontal

			 * 32-bit scrolls don't work perfectly on rectangles of width <= 24.

			 * we bail on a bigger bound for padding.

			 */

			if(Dx(r) < 32)

				return 0;

			break;

		case 16:

			/*

			 * Using the SGI flat panels with the Ticket-to-Ride IV, horizontal

			 * 16-bit scrolls don't work perfectly on rectangles of width <= 96.

			 * we bail on a bigger bound for padding.

			 */

			if(Dx(r) < 104)

				return 0;

			break;

		}

	}

	waitformem(scr);

	waitforfifo(scr);

	d = scr->mmio + RBaseD;

	ctl = 0;

	if(r.min.x <= sr.min.x){

		dp.x = r.min.x;

		sp.x = sr.min.x;

	}else{

		ctl |= 2;

		dp.x = r.max.x-1;

		sp.x = sr.max.x-1;

	}

	if(r.min.y < sr.min.y){

		dp.y = r.min.y;

		sp.y = sr.min.y;

	}else{

		ctl |= 1;

		dp.y = r.max.y-1;

		sp.y = sr.max.y-1;

	}

	d[CmdOpc] = 0x1;	/* bitblt */

	d[CmdRop] = 0xC;	/* copy source */

	d[CmdStyle] = 0;

	d[CmdPatrn] = 0;

	d[Fore] = 0;

	d[Back] = 0;

	/* writing XY1 executes cmd */

	d[XY3] = ctl;

	d[XY0] = (sp.x<<16)|sp.y;

	d[XY2] = (Dx(r)<<16)|Dy(r);

	d[XY4] = 0;

	d[XY1] = (dp.x<<16)|dp.y;

	waitforcmd(scr);

	return 1;

}

static int

t2r4hwfill(VGAscr *scr, Rectangle r, ulong sval)

{

	ulong *d;

	d = scr->mmio + RBaseD;

	waitformem(scr);

	waitforfifo(scr);

	d[CmdOpc] = 0x1;	/* bitblt */

	d[CmdRop] = 0xC;	/* copy source */

	d[CmdStyle] = 1;	/* use source from Fore register */

	d[CmdPatrn] = 0;	/* no stipple */

	d[Fore] = sval;

	d[Back] = sval;

	/* writing XY1 executes cmd */

	d[XY3] = 0;

	d[XY0] = (r.min.x<<16)|r.min.y;

	d[XY2] = (Dx(r)<<16)|Dy(r);

	d[XY4] = 0;

	d[XY1] = (r.min.x<<16)|r.min.y;

	waitforcmd(scr);

	return 1;

}

static void

t2r4blank(VGAscr *scr, int blank)

{

	uchar x;

	x = t2r4xi(scr, CursorSyncCtl);

	x &= ~0x0F;

	if(blank)

		x |= HsyncLo | VsyncLo;

	t2r4xo(scr, CursorSyncCtl, x);

}

static void

t2r4drawinit(VGAscr *scr)

{

	ulong pitch;

	int depth;

	int fmt;

	ulong *d;

	pitch = Dx(scr->gscreen->r);

	depth = scr->gscreen->depth;

	switch(scr->gscreen->chan){

	case RGB16:

		fmt = 3;

		break;

	case XRGB32:

		fmt = 2;

		break;

	case RGB15:

		fmt = 1;

		break;

	default:

		scr->fill = nil;

		scr->scroll = nil;

		return;

	}

	d = scr->mmio + RBaseD;

	d[BufCtl] = fmt<<24;

	d[DeSorg] = 0;

	d[DeDorg] = 0;

	d[DeSptch] = (pitch*depth)/8;

	d[DeDptch] = (pitch*depth)/8;

	d[CmdClp] = 0;	/* 2 = inside rectangle */

	d[Mask] = ~0;

	d[DeKey] = 0;

	d[Clptl] = 0; 

	d[Clpbr] = 0xFFF0FFF0;

	d[Alpha] = 0;

	d[ACtl] = 0;

	scr->fill = t2r4hwfill;

	scr->scroll = t2r4hwscroll;

	scr->blank = t2r4blank;

	hwblank = 1;

}

VGAdev vgat2r4dev = {

	"t2r4",

	t2r4enable,

	nil,

	nil,

	nil,

	t2r4drawinit,

};

VGAcur vgat2r4cur = {

	"t2r4hwgc",

	t2r4curenable,

	t2r4curdisable,

	t2r4curload,

	t2r4curmove,

};