[pcsx_rearmed.git] / libpcsxcore / r3000a.h

/***************************************************************************
 *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
 ***************************************************************************/

#ifndef __R3000A_H__
#define __R3000A_H__

#ifdef __cplusplus
extern "C" {
#endif

#include "psxcommon.h"
#include "psxmem.h"
#include "psxcounters.h"
#include "psxbios.h"

enum {
	R3000ACPU_NOTIFY_CACHE_ISOLATED = 0,
	R3000ACPU_NOTIFY_CACHE_UNISOLATED = 1,
	R3000ACPU_NOTIFY_DMA3_EXE_LOAD = 2
};

typedef struct {
	int  (*Init)();
	void (*Reset)();
	void (*Execute)();		/* executes up to a break */
	void (*ExecuteBlock)();	/* executes up to a jump */
	void (*Clear)(u32 Addr, u32 Size);
	void (*Notify)(int note, void *data);
	void (*ApplyConfig)();
	void (*Shutdown)();
} R3000Acpu;

extern R3000Acpu *psxCpu;
extern R3000Acpu psxInt;
extern R3000Acpu psxRec;

typedef union {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	struct { u8 h3, h2, h, l; } b;
	struct { s8 h3, h2, h, l; } sb;
	struct { u16 h, l; } w;
	struct { s16 h, l; } sw;
#else
	struct { u8 l, h, h2, h3; } b;
	struct { u16 l, h; } w;
	struct { s8 l, h, h2, h3; } sb;
	struct { s16 l, h; } sw;
#endif
} PAIR;

typedef union {
	struct {
		u32   r0, at, v0, v1, a0, a1, a2, a3,
						t0, t1, t2, t3, t4, t5, t6, t7,
						s0, s1, s2, s3, s4, s5, s6, s7,
						t8, t9, k0, k1, gp, sp, s8, ra, lo, hi;
	} n;
	u32 r[34]; /* Lo, Hi in r[32] and r[33] */
	PAIR p[34];
} psxGPRRegs;

typedef union {
	struct {
		u32	Index,     Random,    EntryLo0,  EntryLo1,
						Context,   PageMask,  Wired,     Reserved0,
						BadVAddr,  Count,     EntryHi,   Compare,
						Status,    Cause,     EPC,       PRid,
						Config,    LLAddr,    WatchLO,   WatchHI,
						XContext,  Reserved1, Reserved2, Reserved3,
						Reserved4, Reserved5, ECC,       CacheErr,
						TagLo,     TagHi,     ErrorEPC,  Reserved6;
	} n;
	u32 r[32];
	PAIR p[32];
} psxCP0Regs;

typedef struct {
	short x, y;
} SVector2D;

typedef struct {
	short z, pad;
} SVector2Dz;

typedef struct {
	short x, y, z, pad;
} SVector3D;

typedef struct {
	short x, y, z, pad;
} LVector3D;

typedef struct {
	unsigned char r, g, b, c;
} CBGR;

typedef struct {
	short m11, m12, m13, m21, m22, m23, m31, m32, m33, pad;
} SMatrix3D;

typedef union {
	struct {
		SVector3D     v0, v1, v2;
		CBGR          rgb;
		s32          otz;
		s32          ir0, ir1, ir2, ir3;
		SVector2D     sxy0, sxy1, sxy2, sxyp;
		SVector2Dz    sz0, sz1, sz2, sz3;
		CBGR          rgb0, rgb1, rgb2;
		s32          reserved;
		s32          mac0, mac1, mac2, mac3;
		u32 irgb, orgb;
		s32          lzcs, lzcr;
	} n;
	u32 r[32];
	PAIR p[32];
} psxCP2Data;

typedef union {
	struct {
		SMatrix3D rMatrix;
		s32      trX, trY, trZ;
		SMatrix3D lMatrix;
		s32      rbk, gbk, bbk;
		SMatrix3D cMatrix;
		s32      rfc, gfc, bfc;
		s32      ofx, ofy;
		s32      h;
		s32      dqa, dqb;
		s32      zsf3, zsf4;
		s32      flag;
	} n;
	u32 r[32];
	PAIR p[32];
} psxCP2Ctrl;

enum {
	PSXINT_SIO = 0,
	PSXINT_CDR,
	PSXINT_CDREAD,
	PSXINT_GPUDMA,
	PSXINT_MDECOUTDMA,
	PSXINT_SPUDMA,
	PSXINT_GPUBUSY,
	PSXINT_MDECINDMA,
	PSXINT_GPUOTCDMA,
	PSXINT_CDRDMA,
	PSXINT_NEWDRC_CHECK,
	PSXINT_RCNT,
	PSXINT_CDRLID,
	PSXINT_CDRPLAY_OLD,	/* unused */
	PSXINT_SPU_UPDATE,
	PSXINT_COUNT
};

typedef struct psxCP2Regs {
	psxCP2Data CP2D; 	/* Cop2 data registers */
	psxCP2Ctrl CP2C; 	/* Cop2 control registers */
} psxCP2Regs;

typedef struct {
	psxGPRRegs GPR;		/* General Purpose Registers */
	psxCP0Regs CP0;		/* Coprocessor0 Registers */
	union {
		struct {
			psxCP2Data CP2D; 	/* Cop2 data registers */
			psxCP2Ctrl CP2C; 	/* Cop2 control registers */
		};
		psxCP2Regs CP2;
	};
    u32 pc;				/* Program counter */
    u32 code;			/* The instruction */
	u32 cycle;
	u32 interrupt;
	struct { u32 sCycle, cycle; } intCycle[32];
	u32 gteBusyCycle;
	u32 muldivBusyCycle;
	// warning: changing anything in psxRegisters requires update of all
	// asm in libpcsxcore/new_dynarec/, but this member can be replaced
	u32 reserved[2];
} psxRegisters;

extern boolean writeok;

extern psxRegisters psxRegs;

/* new_dynarec stuff */
extern u32 event_cycles[PSXINT_COUNT];
extern u32 next_interupt;

void new_dyna_before_save(void);
void new_dyna_after_save(void);
void new_dyna_freeze(void *f, int mode);

#define new_dyna_set_event_abs(e, abs) { \
	u32 abs_ = abs; \
	s32 di_ = next_interupt - abs_; \
	event_cycles[e] = abs_; \
	if (di_ > 0) { \
		/*printf("%u: next_interupt %u -> %u\n", psxRegs.cycle, next_interupt, abs_);*/ \
		next_interupt = abs_; \
	} \
}

#define new_dyna_set_event(e, c) \
	new_dyna_set_event_abs(e, psxRegs.cycle + (c))

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

#define _i32(x) *(s32 *)&x
#define _u32(x) x

#define _i16(x) (((short *)&x)[1])
#define _u16(x) (((unsigned short *)&x)[1])

#define _i8(x) (((char *)&x)[3])
#define _u8(x) (((unsigned char *)&x)[3])

#else

#define _i32(x) *(s32 *)&x
#define _u32(x) x

#define _i16(x) *(short *)&x
#define _u16(x) *(unsigned short *)&x

#define _i8(x) *(char *)&x
#define _u8(x) *(unsigned char *)&x

#endif

/**** R3000A Instruction Macros ****/
#define _PC_       psxRegs.pc       // The next PC to be executed

#define _fOp_(code)		((code >> 26)       )  // The opcode part of the instruction register 
#define _fFunct_(code)	((code      ) & 0x3F)  // The funct part of the instruction register 
#define _fRd_(code)		((code >> 11) & 0x1F)  // The rd part of the instruction register 
#define _fRt_(code)		((code >> 16) & 0x1F)  // The rt part of the instruction register 
#define _fRs_(code)		((code >> 21) & 0x1F)  // The rs part of the instruction register 
#define _fSa_(code)		((code >>  6) & 0x1F)  // The sa part of the instruction register
#define _fIm_(code)		((u16)code)            // The immediate part of the instruction register
#define _fTarget_(code)	(code & 0x03ffffff)    // The target part of the instruction register

#define _fImm_(code)	((s16)code)            // sign-extended immediate
#define _fImmU_(code)	(code&0xffff)          // zero-extended immediate

#define _Op_     _fOp_(psxRegs.code)
#define _Funct_  _fFunct_(psxRegs.code)
#define _Rd_     _fRd_(psxRegs.code)
#define _Rt_     _fRt_(psxRegs.code)
#define _Rs_     _fRs_(psxRegs.code)
#define _Sa_     _fSa_(psxRegs.code)
#define _Im_     _fIm_(psxRegs.code)
#define _Target_ _fTarget_(psxRegs.code)

#define _Imm_	 _fImm_(psxRegs.code)
#define _ImmU_	 _fImmU_(psxRegs.code)

#define _rRs_   psxRegs.GPR.r[_Rs_]   // Rs register
#define _rRt_   psxRegs.GPR.r[_Rt_]   // Rt register
#define _rRd_   psxRegs.GPR.r[_Rd_]   // Rd register
#define _rSa_   psxRegs.GPR.r[_Sa_]   // Sa register
#define _rFs_   psxRegs.CP0.r[_Rd_]   // Fs register

#define _c2dRs_ psxRegs.CP2D.r[_Rs_]  // Rs cop2 data register
#define _c2dRt_ psxRegs.CP2D.r[_Rt_]  // Rt cop2 data register
#define _c2dRd_ psxRegs.CP2D.r[_Rd_]  // Rd cop2 data register
#define _c2dSa_ psxRegs.CP2D.r[_Sa_]  // Sa cop2 data register

#define _rHi_   psxRegs.GPR.n.hi   // The HI register
#define _rLo_   psxRegs.GPR.n.lo   // The LO register

#define _JumpTarget_    ((_Target_ * 4) + (_PC_ & 0xf0000000))   // Calculates the target during a jump instruction
#define _BranchTarget_  ((s16)_Im_ * 4 + _PC_)                 // Calculates the target during a branch instruction

#define _SetLink(x)     psxRegs.GPR.r[x] = _PC_ + 4;       // Sets the return address in the link register

int  psxInit();
void psxReset();
void psxShutdown();
void psxException(u32 code, u32 bd);
void psxBranchTest();
void psxExecuteBios();
int  psxTestLoadDelay(int reg, u32 tmp);
void psxDelayTest(int reg, u32 bpc);
void psxTestSWInts();
void psxJumpTest();

#ifdef __cplusplus
}
#endif
#endif
Commit	Line	Data
ef79bbde P	1	/***************************************************************************
	2	* Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
	3	* *
	4	* This program is free software; you can redistribute it and/or modify *
	5	* it under the terms of the GNU General Public License as published by *
	6	* the Free Software Foundation; either version 2 of the License, or *
	7	* (at your option) any later version. *
	8	* *
	9	* This program is distributed in the hope that it will be useful, *
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	12	* GNU General Public License for more details. *
	13	* *
	14	* You should have received a copy of the GNU General Public License *
	15	* along with this program; if not, write to the *
	16	* Free Software Foundation, Inc., *
	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
	18	***************************************************************************/
	19
	20	#ifndef __R3000A_H__
	21	#define __R3000A_H__
	22
	23	#ifdef __cplusplus
	24	extern "C" {
	25	#endif
	26
	27	#include "psxcommon.h"
	28	#include "psxmem.h"
	29	#include "psxcounters.h"
	30	#include "psxbios.h"
	31
7a811716	32	enum {
	33	R3000ACPU_NOTIFY_CACHE_ISOLATED = 0,
	34	R3000ACPU_NOTIFY_CACHE_UNISOLATED = 1,
	35	R3000ACPU_NOTIFY_DMA3_EXE_LOAD = 2
	36	};
7a811716	37
ef79bbde P	38	typedef struct {
	39	int (*Init)();
	40	void (*Reset)();
	41	void (Execute)(); / executes up to a break */
	42	void (ExecuteBlock)(); / executes up to a jump */
	43	void (*Clear)(u32 Addr, u32 Size);
7a811716	44	void (Notify)(int note, void data);
630b122b	45	void (*ApplyConfig)();
ef79bbde P	46	void (*Shutdown)();
	47	} R3000Acpu;
	48
	49	extern R3000Acpu *psxCpu;
	50	extern R3000Acpu psxInt;
ef79bbde	51	extern R3000Acpu psxRec;
ef79bbde P	52
ef79bbde P	53	typedef union {
ffe97735	54	#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
ef79bbde P	55	struct { u8 h3, h2, h, l; } b;
	56	struct { s8 h3, h2, h, l; } sb;
	57	struct { u16 h, l; } w;
	58	struct { s16 h, l; } sw;
	59	#else
	60	struct { u8 l, h, h2, h3; } b;
	61	struct { u16 l, h; } w;
	62	struct { s8 l, h, h2, h3; } sb;
	63	struct { s16 l, h; } sw;
	64	#endif
	65	} PAIR;
	66
	67	typedef union {
	68	struct {
	69	u32 r0, at, v0, v1, a0, a1, a2, a3,
	70	t0, t1, t2, t3, t4, t5, t6, t7,
	71	s0, s1, s2, s3, s4, s5, s6, s7,
	72	t8, t9, k0, k1, gp, sp, s8, ra, lo, hi;
	73	} n;
	74	u32 r[34]; /* Lo, Hi in r[32] and r[33] */
	75	PAIR p[34];
	76	} psxGPRRegs;
	77
	78	typedef union {
	79	struct {
	80	u32 Index, Random, EntryLo0, EntryLo1,
	81	Context, PageMask, Wired, Reserved0,
	82	BadVAddr, Count, EntryHi, Compare,
	83	Status, Cause, EPC, PRid,
	84	Config, LLAddr, WatchLO, WatchHI,
	85	XContext, Reserved1, Reserved2, Reserved3,
	86	Reserved4, Reserved5, ECC, CacheErr,
	87	TagLo, TagHi, ErrorEPC, Reserved6;
	88	} n;
	89	u32 r[32];
	90	PAIR p[32];
	91	} psxCP0Regs;
	92
	93	typedef struct {
	94	short x, y;
	95	} SVector2D;
	96
	97	typedef struct {
	98	short z, pad;
	99	} SVector2Dz;
	100
	101	typedef struct {
	102	short x, y, z, pad;
	103	} SVector3D;
	104
	105	typedef struct {
	106	short x, y, z, pad;
	107	} LVector3D;
	108
	109	typedef struct {
	110	unsigned char r, g, b, c;
	111	} CBGR;
	112
	113	typedef struct {
	114	short m11, m12, m13, m21, m22, m23, m31, m32, m33, pad;
	115	} SMatrix3D;
	116
	117	typedef union {
	118	struct {
119	SVector3D v0, v1, v2;
120	CBGR rgb;
121	s32 otz;
122	s32 ir0, ir1, ir2, ir3;
123	SVector2D sxy0, sxy1, sxy2, sxyp;
124	SVector2Dz sz0, sz1, sz2, sz3;
125	CBGR rgb0, rgb1, rgb2;
126	s32 reserved;
127	s32 mac0, mac1, mac2, mac3;
128	u32 irgb, orgb;
129	s32 lzcs, lzcr;
130	} n;
131	u32 r[32];
132	PAIR p[32];
133	} psxCP2Data;
134
135	typedef union {
136	struct {
137	SMatrix3D rMatrix;
138	s32 trX, trY, trZ;
139	SMatrix3D lMatrix;
140	s32 rbk, gbk, bbk;
141	SMatrix3D cMatrix;
142	s32 rfc, gfc, bfc;
143	s32 ofx, ofy;
144	s32 h;
145	s32 dqa, dqb;
146	s32 zsf3, zsf4;
147	s32 flag;
148	} n;
149	u32 r[32];
150	PAIR p[32];
151	} psxCP2Ctrl;
152
d28b54b1	153	enum {
	154	PSXINT_SIO = 0,
	155	PSXINT_CDR,
	156	PSXINT_CDREAD,
	157	PSXINT_GPUDMA,
	158	PSXINT_MDECOUTDMA,
	159	PSXINT_SPUDMA,
528ad661	160	PSXINT_GPUBUSY,
528ad661	161	PSXINT_MDECINDMA,
57a757ce	162	PSXINT_GPUOTCDMA,
9f8b032d	163	PSXINT_CDRDMA,
d28b54b1	164	PSXINT_NEWDRC_CHECK,
5b8c000f	165	PSXINT_RCNT,
9f8b032d	166	PSXINT_CDRLID,
28eea6ac	167	PSXINT_CDRPLAY_OLD, /* unused */
2b30c129	168	PSXINT_SPU_UPDATE,
d28b54b1	169	PSXINT_COUNT
	170	};
	171
eac38522	172	typedef struct psxCP2Regs {
	173	psxCP2Data CP2D; /* Cop2 data registers */
	174	psxCP2Ctrl CP2C; /* Cop2 control registers */
	175	} psxCP2Regs;
	176
ef79bbde P	177	typedef struct {
	178	psxGPRRegs GPR; /* General Purpose Registers */
	179	psxCP0Regs CP0; /* Coprocessor0 Registers */
eac38522	180	union {
	181	struct {
	182	psxCP2Data CP2D; /* Cop2 data registers */
	183	psxCP2Ctrl CP2C; /* Cop2 control registers */
	184	};
	185	psxCP2Regs CP2;
	186	};
ef79bbde P	187	u32 pc; /* Program counter */
	188	u32 code; /* The instruction */
	189	u32 cycle;
	190	u32 interrupt;
d28b54b1	191	struct { u32 sCycle, cycle; } intCycle[32];
630b122b	192	u32 gteBusyCycle;
	193	u32 muldivBusyCycle;
	194	// warning: changing anything in psxRegisters requires update of all
	195	// asm in libpcsxcore/new_dynarec/, but this member can be replaced
	196	u32 reserved[2];
ef79bbde P	197	} psxRegisters;
ef79bbde P	198
7a811716	199	extern boolean writeok;
7a811716	200
ef79bbde P	201	extern psxRegisters psxRegs;
ef79bbde P	202
d28b54b1	203	/* new_dynarec stuff */
	204	extern u32 event_cycles[PSXINT_COUNT];
	205	extern u32 next_interupt;
	206
03f55e6b	207	void new_dyna_before_save(void);
5b8c000f	208	void new_dyna_after_save(void);
03f55e6b	209	void new_dyna_freeze(void *f, int mode);
52082bc1	210
9a1338bc	211	#define new_dyna_set_event_abs(e, abs) { \
	212	u32 abs_ = abs; \
	213	s32 di_ = next_interupt - abs_; \
d28b54b1	214	event_cycles[e] = abs_; \
9a1338bc	215	if (di_ > 0) { \
9a1338bc	216	/printf("%u: next_interupt %u -> %u\n", psxRegs.cycle, next_interupt, abs_);/ \
d28b54b1	217	next_interupt = abs_; \
	218	} \
	219	}
	220
9a1338bc	221	#define new_dyna_set_event(e, c) \
	222	new_dyna_set_event_abs(e, psxRegs.cycle + (c))
	223
ffe97735	224	#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
ef79bbde P	225
	226	#define _i32(x) (s32 )&x
	227	#define _u32(x) x
	228
	229	#define _i16(x) (((short *)&x)[1])
	230	#define _u16(x) (((unsigned short *)&x)[1])
	231
	232	#define _i8(x) (((char *)&x)[3])
	233	#define _u8(x) (((unsigned char *)&x)[3])
	234
	235	#else
	236
	237	#define _i32(x) (s32 )&x
	238	#define _u32(x) x
	239
	240	#define _i16(x) (short )&x
	241	#define _u16(x) (unsigned short )&x
	242
	243	#define _i8(x) (char )&x
	244	#define _u8(x) (unsigned char )&x
	245
	246	#endif
	247
	248	/** R3000A Instruction Macros **/
	249	#define _PC_ psxRegs.pc // The next PC to be executed
	250
	251	#define _fOp_(code) ((code >> 26) ) // The opcode part of the instruction register
	252	#define _fFunct_(code) ((code ) & 0x3F) // The funct part of the instruction register
	253	#define _fRd_(code) ((code >> 11) & 0x1F) // The rd part of the instruction register
	254	#define _fRt_(code) ((code >> 16) & 0x1F) // The rt part of the instruction register
	255	#define _fRs_(code) ((code >> 21) & 0x1F) // The rs part of the instruction register
	256	#define _fSa_(code) ((code >> 6) & 0x1F) // The sa part of the instruction register
	257	#define _fIm_(code) ((u16)code) // The immediate part of the instruction register
	258	#define _fTarget_(code) (code & 0x03ffffff) // The target part of the instruction register
	259
	260	#define _fImm_(code) ((s16)code) // sign-extended immediate
	261	#define _fImmU_(code) (code&0xffff) // zero-extended immediate
	262
	263	#define _Op_ _fOp_(psxRegs.code)
	264	#define _Funct_ _fFunct_(psxRegs.code)
	265	#define _Rd_ _fRd_(psxRegs.code)
	266	#define _Rt_ _fRt_(psxRegs.code)
	267	#define _Rs_ _fRs_(psxRegs.code)
	268	#define _Sa_ _fSa_(psxRegs.code)
	269	#define _Im_ _fIm_(psxRegs.code)
	270	#define _Target_ _fTarget_(psxRegs.code)
	271
	272	#define _Imm_ _fImm_(psxRegs.code)
	273	#define _ImmU_ _fImmU_(psxRegs.code)
	274
	275	#define _rRs_ psxRegs.GPR.r[_Rs_] // Rs register
	276	#define _rRt_ psxRegs.GPR.r[_Rt_] // Rt register
	277	#define _rRd_ psxRegs.GPR.r[_Rd_] // Rd register
	278	#define _rSa_ psxRegs.GPR.r[_Sa_] // Sa register
	279	#define _rFs_ psxRegs.CP0.r[_Rd_] // Fs register
	280
	281	#define _c2dRs_ psxRegs.CP2D.r[_Rs_] // Rs cop2 data register
	282	#define _c2dRt_ psxRegs.CP2D.r[_Rt_] // Rt cop2 data register
	283	#define _c2dRd_ psxRegs.CP2D.r[_Rd_] // Rd cop2 data register
	284	#define _c2dSa_ psxRegs.CP2D.r[_Sa_] // Sa cop2 data register
	285
	286	#define _rHi_ psxRegs.GPR.n.hi // The HI register
	287	#define _rLo_ psxRegs.GPR.n.lo // The LO register
	288
289	#define _JumpTarget_ ((_Target_ * 4) + (_PC_ & 0xf0000000)) // Calculates the target during a jump instruction
290	#define _BranchTarget_ ((s16)_Im_ * 4 + _PC_) // Calculates the target during a branch instruction
291
292	#define _SetLink(x) psxRegs.GPR.r[x] = _PC_ + 4; // Sets the return address in the link register
293
294	int psxInit();
295	void psxReset();
296	void psxShutdown();
297	void psxException(u32 code, u32 bd);
298	void psxBranchTest();
299	void psxExecuteBios();
300	int psxTestLoadDelay(int reg, u32 tmp);
301	void psxDelayTest(int reg, u32 bpc);
302	void psxTestSWInts();
303	void psxJumpTest();
304
305	#ifdef __cplusplus
306	}
307	#endif
308	#endif