/* DirectPad Pro Joystick Scanning Code - V4.9 */
/* (c) Earle F. Philhower, III */
/* See http://www.ziplabel.com/dpadpro for more information */

#define OUTP(a,b) {int aa; for (aa=0; aa<3; aa++) _outp((a), (b));}
#define OUTPS(a,b) {int i; for (i=0; i<8; i++) _outp((a),(b)); }
#define SNES_PWR (128+64+32+16+8)
#define SNES_CLK 1  // base+0
#define SNES_LAT 2  // base+0
#define SIN (negate?((_inp(base+1)&snes_din)?1:0):((_inp(base+1)&snes_din)?0:1))
#define SNESIT(a) {if (snesdelay==3) {int i; for (i=0; i<3; i++) _outp(base, (a));} else {int i; for (i=0; i<snesdelay; i++) _outp(base, (a));} }

typedef struct mySNES
{
	char dn;
	char up;
	char lf;
	char rt;
	char a, b;
	char x, y;
	char l, r;
	char sel, start;
	char vba, vbb;
} mySNES;

typedef struct myJAG
{
	char dn;
	char up;
	char lf;
	char rt;
	char a, b, c, d;
	char pause;
	char opt;
	char kp[12];
} myJAG;

typedef struct {
	char dn;
	char up;
	char lf;
	char rt;
	char start, select, box, cross, circle, triangle;
        char r1, l1, r2, l2, r3, l3;
	char lx, ly, rx, ry;
} myPSX;

typedef struct myTGFX
{
	char dn;
	char up;
	char lf;
	char rt;
	char f1, f2, f3, f4, f5;

} myTGFX;

typedef struct mySATURN
{
	char dn;
	char up;
	char lf;
	char rt;
	char a, b, c;
	char x, y, z;
	char start;
	char r,l;
	char a1, a2, a3;
	char ax, ay, az;
} mySATURN;

typedef struct myGENESIS
{
	char dn;
	char up;
	char lf;
	char rt;
	char a, b, c;
	char start;
	char x, y, z, md;
} myGENESIS;

typedef struct myATARI
{
	char up;
	char dn;
	char lf;
	char rt;
	char btn;
	char btn2;
} myATARI;

typedef struct {
	char dn;
	char up;
	char lf;
	char rt;
	char a, b, z, start, l, r;
	char cdn;
	char cup;
	char clf;
	char crt;
	char x, y;
} myN64;


void ScanN64(myN64 *n64, int base, int id, int snes_din, int negate)
{
	int i;
	DWORD data;
	static myN64 last[6];
	unsigned char on, off;
	unsigned short shtb;
	static unsigned char idon[5] = {0x00, 0xfe /*D0*/, 0xfb /*D2*/, 0xf7 /*D3*/, 0xef /*D4*/};
	
	shtb = (unsigned short)base;
	off = 0xff;
	on = idon[id];

	_disable();				//sti
							//mov dx, [shtb]		
							//mov bl, [on]
							//mov al,0ffh
	_outp( shtb, 0xff );	//out dx,al
							//mov al,bl
	for (i=0; i<7; i++)
	{
		_outp( shtb, on );	//out dx,al		
		_outp( shtb, on );	//out dx,al
		_outp( shtb, on );	//out dx,al
		_outp( shtb, on );	//out dx,al
		_outp( shtb, on );	//out dx,al
		_outp( shtb, on );	//out dx,al		
		_outp( shtb, on );	//out dx,al
							//mov al,0ffh
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al		; ready bit 0

		// Super-dooper extended timing
//		_outp( shtb, off );	//out dx,al		
//		_outp( shtb, off );	//out dx,al

	}
	for (i=7; i<9; i++)
	{
		_outp( shtb, on );	//out dx,al
		_outp( shtb, on );	//out dx,al
							//mov al,0ffh

		// Super-dooper extended timing
//		_outp( shtb, on );	//out dx,al		
//		_outp( shtb, on );	//out dx,al

		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al
		_outp( shtb, off );	//out dx,al		; ready bit 7
							//mov al,bl

	}
	_enable();				//cli

	for (i=0; i<0x90; i++)
		_outp( base, 0xff );

	data = 0;
	for (i=0; i<32; i++)
	{
		data <<= 1;
		_outp( base, 0xfd );
		_outp( base, 0xfd );
		_outp( base, 0xfd );
		data |= (SIN)?0:1;
		_outp( base, 0xff );
		_outp( base, 0xff );
		_outp( base, 0xff );
	}

	if (((data>>23)&1)||((data>>22)&1))  // failed comm
		*n64 = last[id];
	else
	{
		n64->a = (char)((data>>31) & 1);
		n64->b = (char)((data>>30) & 1);
		n64->z = (char)((data>>29) & 1);
		n64->start = (char)((data>>28) & 1);
		n64->up = (char)((data>>27) & 1);
		n64->dn = (char)((data>>26) & 1);
		n64->lf = (char)((data>>25) & 1);
		n64->rt = (char)((data>>24) & 1);
		n64->l = (char)((data>>21) & 1);
		n64->r = (char)((data>>20) & 1);
		n64->cup = (char)((data>>19) & 1);
		n64->cdn = (char)((data>>18) & 1);
		n64->clf = (char)((data>>17) & 1);
		n64->crt = (char)((data>>16) & 1);
		n64->x = (char)((data>>8) & 0xff);
		n64->y = (char)(data & 0xff);
		n64->y = - n64->y;
		last[id] = *n64;
	}
}



void ScanTGFX( myTGFX *tgfx, int num, int base )
{
	int k, l;

	OUTP( base+2, 0x04 );	// 4 extra inputs
	OUTP( base, 0xff );	// all out high
	OUTP( base, 0xff-( 1 << (7-num) ) );
	k = _inp( base+1 );
	l = _inp( base+2 );
	tgfx->up = (k&16)?0:1;
	tgfx->dn = (k&32)?0:1;
	tgfx->lf = (k&64)?0:1;
	tgfx->rt = (k&128)?1:0;
	tgfx->f1 = (k&8)?0:1;
	tgfx->f2 = (l&2)?1:0;
	tgfx->f3 = (l&4)?0:1;
	tgfx->f4 = (l&1)?1:0;
	tgfx->f5 = (l&8)?1:0;
}


void ScanSaturn(mySATURN *saturn, int analog, int id, int base)
{
	const unsigned char tl1 = 4;
	const unsigned char tr1 = 2;  // pad 1
	const unsigned char th1 = 1;  // pad 1
	const unsigned char gnd1 = 64;// pad 1

	const unsigned char tl2 = 4;
	const unsigned char tr2 = 32; // pad 2
	const unsigned char th2 = 16; // pad 2
	const unsigned char gnd2 =128;// pad 2

	const unsigned char r = 16;
	const unsigned char l = 32;
	const unsigned char d = 64;
	const unsigned char u = 128; // inverted!

	int s0, s1, s2, s3;
	int sel2, sel1, sel0, gnd;
	int ad[10];
	unsigned char pwr;


	if (id==1)
	{
		sel2 = th1;
		sel1 = tr1;
		sel0 = tl1;
		gnd = gnd1;
	} else
	{
		sel2 = th2;
		sel1 = tr2;
		sel0 = tl2;
		gnd = gnd2;
	}

	pwr = 255 - (gnd + sel2 + sel1 + sel0);

	if (!analog)
	{
		OUTP( base, pwr+sel2+sel1+sel0 );
		s0=_inp(base+1);

		OUTP( base, pwr     +sel1+sel0 );
		s1=_inp(base+1);

		OUTP( base, pwr+sel2     +sel0 );
		s2=_inp(base+1);

		OUTP( base, pwr          +sel0 );
		s3=_inp(base+1);
	
		saturn->l = NEG(s0, r);

		saturn->rt = NEG(s1, r);
		saturn->lf = NEG(s1, l);
		saturn->dn = NEG(s1, d);
		saturn->up = POS(s1, u);

		saturn->start = NEG(s2, r);
		saturn->a = NEG(s2, l);
		saturn->c = NEG(s2, d);
		saturn->b = POS(s2, u);

		saturn->r = NEG(s3, r);
		saturn->x = NEG(s3, l);
		saturn->y = NEG(s3, d);
		saturn->z = POS(s3, u);
	}
	else
	{
		OUTPS( base, pwr+sel2+sel1+sel0 );  // 1st data
		OUTPS( base, pwr     +sel1+sel0 );  // 2nd data
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 3rd
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 4th
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 5th
		ad[0] = _inp(base+1);
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 6th
		ad[1] = _inp(base+1);
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 7th
		ad[2] = _inp(base+1);
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 8th
		ad[3] = _inp(base+1);
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 9th
		ad[4] = _inp(base+1);
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 10th
		ad[5] = _inp(base+1);
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 11th
		ad[6] = _inp(base+1);
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 12th
		ad[7] = _inp(base+1);
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 13th
		ad[8] = _inp(base+1);
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 14th
		ad[9] = _inp(base+1);
		OUTPS( base, pwr          +sel0 );
		OUTPS( base, pwr                );  // 15th
		OUTPS( base, pwr     +sel1      );
		OUTPS( base, pwr     +sel1+sel0 );  // 16th
		OUTPS( base, pwr+sel2+sel1+sel0 );

		saturn->rt = NEG(ad[0],r);
		saturn->lf = NEG(ad[0],l);
		saturn->dn = NEG(ad[0],d);
		saturn->up = POS(ad[0],u);
		saturn->start = NEG(ad[1],r);
		saturn->a = NEG(ad[1],l);
		saturn->c = NEG(ad[1],d);
		saturn->b = POS(ad[1],u);
		saturn->r = NEG(ad[2],r);
		saturn->x = NEG(ad[2],l);
		saturn->y = NEG(ad[2],d);
		saturn->z = POS(ad[2],u);
		saturn->l = NEG(ad[3],r);
		saturn->a1 = NEG(ad[3],l);
		saturn->a2 = NEG(ad[3],d);
		saturn->a3 = POS(ad[3],u);

		saturn->ax = POS(ad[4],r)*128 + POS(ad[4],l)*64 + POS(ad[4],d)*32 + NEG(ad[4],u)*16 +
						 POS(ad[5],r)*8 + POS(ad[5],l)*4 + POS(ad[5],d)*2 + NEG(ad[5],u)*1;
		saturn->ay = POS(ad[6],r)*128 + POS(ad[6],l)*64 + POS(ad[6],d)*32 + NEG(ad[6],u)*16 +
						 POS(ad[7],r)*8 + POS(ad[7],l)*4 + POS(ad[7],d)*2 + NEG(ad[7],u)*1;
		saturn->az = POS(ad[8],r)*128 + POS(ad[8],l)*64 + POS(ad[8],d)*32 + NEG(ad[8],u)*16 +
						 POS(ad[9],r)*8 + POS(ad[9],l)*4 + POS(ad[9],d)*2 + NEG(ad[9],u)*1;

	}

	if (!joy[curJoy].power)
		OUTP(base,0);		//power down gamepad

}


void ScanGenesis( myGENESIS *genesis, int base )
{
	int s0, s1, s2, c, c2;

	OUTP(base+2, 0x0c);
	OUTP(base, 254); // Power up, select=0
	s0 = _inp(base+1);
	OUTP(base, 255); // Power up, select=1
	s1 = _inp(base+1);
	c = _inp(base+2);
	
	if (joy[curJoy].name==GENESIS6)
	{
		_outp(base, 254); // sel=0;
		_outp(base, 254); // sel=0;
		_outp(base, 255); // sel=1;
		_outp(base, 255); // sel=1;
		_outp(base, 254); // sel=0;
		_outp(base, 254); // sel=0;
		_outp(base, 255); // sel=1;
		_outp(base, 255); // sel=1;
		s2=_inp(base+1);
		c2=_inp(base+2);
	}
	if (!joy[curJoy].power)
		OUTP(base, 0); // Power down joystick
	
	genesis->dn = (c&2)?1:0;
	genesis->up = (c&1)?1:0;
	genesis->lf = (s1&64)?0:1;
	genesis->rt = (s1&128)?1:0;
	genesis->a = (s0&32)?0:1;
	genesis->b = (s1&32)?0:1;
	genesis->c = (s1&16)?0:1;
	genesis->start = (s0&16)?0:1;
	if (joy[curJoy].name==GENESIS6)
	{
		genesis->z = (c2&1)?1:0;
		genesis->y = (c2&2)?1:0;
		genesis->x = (s2&64)?0:1;
		genesis->md = (s2&128)?1:0;
	}
}


void ScanAtari( myATARI *atari, int base, int two )
{
	int c;

	//	Atari		IBM
	//up	1		1	(c0-)
	//dn	2		14	(c1-)
	//lf	3		16	(c2+)
	//rt	4		17	(c3-)
	//btn	6		11	(s7-)  (connect 11 to 4p7R to 2 (d0), drive d0 1)
	//btn2	9		12	(s5+)  (connect 12 to 4p7R to 3 (d1), drive d1 1)
	//gnd	8		18
	OUTP(base+2, 4); //All C's high, disconnected
	OUTP(base, 2+1); // Power joy button sensor
	c = _inp(base+1);
	atari->btn = (c & 128)?1:0;
	atari->btn2 = two?((c & 32)?0:1):0;
	if (!joy[curJoy].power)
		OUTP(base, 0); // Power down joy button sensor
	c=_inp(base+2);
	atari->up = (c&1)?1:0;
	atari->dn = (c&2)?1:0;
	atari->lf = (c&4)?0:1;
	atari->rt = (c&8)?1:0;
}


void ScanSNES(mySNES *snes, int base, int snes_din, int negate)
{
	SNESIT(SNES_PWR+SNES_CLK); // Power up!
	SNESIT(SNES_PWR+SNES_LAT+SNES_CLK); // Latch it!
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->b = SIN;

	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	if (joy[curJoy].name==NES)
		snes->a = SIN;
	else
		snes->y = SIN;

	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->sel = SIN;
	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->start = SIN;
	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->up = SIN;
	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->dn = SIN;
	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->lf = SIN;
	SNESIT(SNES_PWR);
	SNESIT(SNES_PWR+SNES_CLK);
	SNESIT(SNES_PWR);
	snes->rt = SIN;
	if (joy[curJoy].name==SNES || joy[curJoy].name==VBOY)
	{
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->a = SIN;
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->x = SIN;
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->l = SIN;
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->r = SIN;
	}
	if (joy[curJoy].name==VBOY)
	{
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->vba = SIN;
		SNESIT(SNES_PWR);
		SNESIT(SNES_PWR+SNES_CLK);
		SNESIT(SNES_PWR);
		snes->vbb = SIN;
	}
	if (!joy[curJoy].power)
		OUTP(base, 0); // Power it down
}



void ScanJag(myJAG *jag, int base)
{
	int r4, r4p, r3, r2, r1;
	
	OUTP(base, 255-8);
	OUTP(base+2, 4);
	r4 = _inp(base+1);
	jag->dn = (r4 & 16)?0:1;
	jag->up = (r4 & 8)?0:1;
	jag->lf = (r4 & 32)?0:1;
	jag->rt = (r4 & 128)?1:0;
	jag->a = (r4 & 64)?0:1;
	r4p = _inp(base+2);
	jag->pause = (r4p&2)?1:0;
	OUTP(base, 255-4);
	r3 = _inp(base+1);
	jag->b = (r3 & 64)?0:1;
	jag->kp[1] = (r3 & 128)?1:0;
	jag->kp[4] = (r3 & 32)?0:1;
	jag->kp[7] = (r3 & 16)?0:1;
	jag->kp[10]= (r3 & 8)?0:1;
	OUTP(base, 255-2);
	r2 = _inp(base+1);
	jag->c = (r2 & 64)?0:1;
	jag->kp[2] = (r2 & 128)?1:0;
	jag->kp[5] = (r2 & 32)?0:1;
	jag->kp[8] = (r2 & 16)?0:1;
	jag->kp[0] = (r2 & 8)?0:1;
	OUTP(base, 255-1);
	r1 = _inp(base+1);
	jag->opt = (r1 & 64)?0:1;
	jag->kp[3] = (r1 & 128)?1:0;
	jag->kp[6] = (r1 & 32)?0:1;
	jag->kp[9] = (r1 & 16)?0:1;
	jag->kp[11]= (r1 & 8)?0:1;
}


// =========================
// | o o o | o o o | o o o | Controller plug
//  \_____________________/
//   1 2 3   4 5 6   7 8 9
//
//   Controller          Parallel
//   1 - Data              10(pad1),13(pad2)
//   2 - Command           2
//   3 - 9V(shock)         +9V battery terminal
//   4 - GND               18 , also -9V battery terminal
//   5 - V+                6,7,8,9 through diodes
//   6 - ATT               3
//   7 - Clock             4
//   9 - ack               12(pad1), 15(pad2)

unsigned char p0 = 0xf8+4+2+1;

void Clk(int i, int base)
{
const clk=0x04;            // Bit 3 Base+0 (parallel port)

	if (i)
		p0 |= clk;
	else
		p0 &= ~clk;

	_outp(base+0, p0);
}

void Sel(int i, int id, int base)
{
const power=0xf8;          // Bits 3-7 Base+0 (parallel port)
const att=0x02;            // Bit 2 Base+0 (parallel port)
unsigned char attary[] = { 0, 0x02, 0x08, 0x10, 0x20, 0x40 };
unsigned char attval;

	if (multitap)
		attval = attary[id];
	else
		attval = att;

	p0 |= power;

	if (i)
		p0 |= attval;
	else
		p0 &= ~attval;

	_outp(base+0, p0);
}

void Cmd(int i, int base)
{
const cmd=0x01;            // Bit 1 Base+0 (parallel port)
	if (i)
		p0 |= cmd;
	else
		p0 &= ~cmd;

	_outp(base+0, p0);
}


int Dat(int id, int base)
{
	unsigned char data;
	if (multitap)
		data = 0x40;
	else
	{
		if (id==1) data = 0x40;
		else data = 0x10;
	}
	
	if (_inp(base+1)&data)
		return 1;
	else
		return 0;
}

int Ack(int id, int base)
{
	unsigned char ack;
	if (multitap)
		ack = 0x20;
	else
	{
		if (id==1) ack = 0x20;
		else ack = 0x08;
	}

	if (_inp(base+1)&ack)
		return 1;
	else
		return 0;
}

void Slow(int base)
{
	int i;
	if (psxdelay==3)
	{
		for (i=0; i<3; i++)
			_outp(base+0, p0);
	} else
	{
		for (i=0; i<psxdelay; i++)
			_outp(base+0, p0);
	}
}

unsigned char SendByte(unsigned char byte, int wait, int id, int base)
{
	int i,j; //,k;
	unsigned char data;

	data=0;
	for (i=0; i<8; i++)
	{
		Slow(base);
		Cmd(byte&(1<<i), base);
		Clk(0, base);
		Slow(base);
		data |= (Dat(id, base)?(1<<i):0);  // Moved prior to clock rising edge
		Clk(1, base);
	}
	// Wait for ACK;
	for(j=0; wait && j<30 && Ack(id, base); j++);
//	for(k=0; wait && k<30 && !Ack(id, base); k++);
//	if (j==300 || k==300) data=0;
	return data;
}


void SendPSXString(	int string[], int id, int base )
{
	int i;
	
	Sel(1, id, base);
	Clk(1, base);
	Cmd(1, base);
	Slow(base);
	Slow(base);
	Slow(base);
	Slow(base);
	Sel(0, id, base);
	Slow(base);
	Slow(base);
	Slow(base);
	for (i=0; string[i+1]!=-1; i++)
		SendByte((unsigned char)string[i],1,id,base);
	SendByte((unsigned char)string[i],0,id,base);
	Slow(base);
	Sel(1, id, base);
	Cmd(1,base);
	Clk(1,base);
	Slow(base);
	Slow(base);
}

void Shock(long id, long base, long small, long big)
{
	int i;
	static int ShockString[4][12]= {
		{0x01, 0x43, 0x00, 0x01, 0x00, 0x01, -1},
		{0x01, 0x4d, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x01, -1},
		{0x01, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, -1},
		{0x01, 0x42, 0x00, 0xff, 0xff, 0x01, -1 } };

	ShockString[3][3] = (int)small;
	ShockString[3][4] = (int)big;
	for (i=0; i<4; i++)
	{
		Slow(base);
		Slow(base);
		Slow(base);
		SendPSXString( ShockString[i], id, base );
	}
}


int ScanPSX( myPSX *psx, int base, int id )
{
	extern void ForceFeedback( DWORD dwDeviceID, int controller, int base, int always, myPSX *psx );
	unsigned char data[10];

	Sel(1, id, base);
	Clk(1,base);
	Cmd(1,base);
	Slow(base);
	Slow(base);
	Slow(base);
	Slow(base);
	Slow(base);
	Sel(0, id, base);
	Slow(base);
	Slow(base);
	Slow(base);
	Slow(base);
	data[0]=SendByte(0x01,1,id,base);
	data[1]=SendByte(0x42,1,id,base);
	if (data[1]==0x41) {
		data[2]=SendByte(0x00,1,id,base);
		data[3]=SendByte(0x00,1,id,base);
		data[4]=SendByte(0x00,0,id,base);
	} else if (data[1]==0x53) {
		data[2]=SendByte(0x00,1,id,base);
		data[3]=SendByte(0x00,1,id,base);
		data[4]=SendByte(0x00,1,id,base);
		data[5]=SendByte(0x00,1,id,base);
		data[6]=SendByte(0x00,1,id,base);
		data[7]=SendByte(0x00,1,id,base);
		data[8]=SendByte(0x00,0,id,base);
	} else if (data[1]==0x73 || data[1]==0x23) {
		data[2]=SendByte(0x00,1,id,base);
		data[3]=SendByte(0x00,1,id,base);
		data[4]=SendByte(0x00,1,id,base);
		data[5]=SendByte(0x00,1,id,base);
		data[6]=SendByte(0x00,1,id,base);
		data[7]=SendByte(0x00,1,id,base);
		data[8]=SendByte(0x00,1,id,base);
		data[9]=SendByte(0x00,0,id,base);
	} else {
		data[1] = 0;
		data[2] = 0;
		data[3] = 255;
		data[4] = 255;
		data[5] = 128;
		data[6] = 128;
		data[7] = 128;
		data[8] = 128;
		data[9] = 0;
	}

	Slow(base);
	Slow(base);
	Sel(1, id, base);
	Cmd(1,base);
	Clk(1,base);
	Slow(base);
	
	psx->lf = data[3]&0x80?0:1;
	psx->dn = data[3]&0x40?0:1;
	psx->rt = data[3]&0x20?0:1;
	psx->up = data[3]&0x10?0:1;
	psx->start = data[3]&0x08?0:1;
	psx->select = data[3]&0x01?0:1;
	psx->cross = data[4]&0x40?0:1;
	psx->circle = data[4]&0x20?0:1;
	psx->l2 = data[4]&0x01?0:1;
	psx->r3 = data[3]&0x04?0:1;
	psx->l3 = data[3]&0x02?0:1;
	if (data[1]!=0x41) {
		psx->rx = data[5];
		psx->ry = data[6];
		psx->lx = data[7];
		psx->ly = data[8];
	} else {
		psx->lx = psx->rx = psx->lf?(MINJOY/256):(psx->rt?(MAXJOY/256):(MIDJOY/256));
		psx->ly = psx->ry = psx->up?(MINJOY/256):(psx->dn?(MAXJOY/256):(MIDJOY/256));
	}

	switch (data[1]) {
		case 0x73: //analog red mode
		case 0x53: //analog green mode
			psx->l1 = data[4]&0x04?0:1;
			psx->r1 = data[4]&0x08?0:1;
			psx->triangle = data[4]&0x10?0:1;
			psx->r2 = data[4]&0x02?0:1;
			psx->box = data[4]&0x80?0:1;
			break;
		default:
			psx->box = data[4]&0x80?0:1;
			psx->triangle = data[4]&0x10?0:1;
			psx->r1 = data[4]&0x08?0:1;
			psx->l1 = data[4]&0x04?0:1;
			psx->r2 = data[4]&0x02?0:1;
			break;
	}

	ForceFeedback( curJoy-1, id, base, 0, psx );

	return data[1];
}