//
// Originally by David Raingeard (Cal2)
// GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Carwin Jones (BeOS)
-// Cleanups and endian wrongness amelioration by James L. Hammons
+// Cleanups and endian wrongness amelioration by James Hammons
// Note: Endian wrongness probably stems from the MAME origins of this emu and
// the braindead way in which MAME handled memory when this was written. :-)
//
-// JLH = James L. Hammons
+// JLH = James Hammons
//
// WHO WHEN WHAT
// --- ---------- -----------------------------------------------------------
uint32 jaguarMainROMCRC32, jaguarROMSize, jaguarRunAddress;
bool jaguarCartInserted = false;
+bool lowerField = false;
#ifdef CPU_DEBUG_MEMORY
uint8 writeMemMax[0x400000], writeMemMin[0x400000];
void M68KInstructionHook(void)
{
uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC);
+// Temp, for comparing...
+{
+/* static char buffer[2048];//, mem[64];
+ m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
+ printf("%08X: %s\n", m68kPC, buffer);//*/
+}
+//JaguarDasm(m68kPC, 1);
+//Testing Hover Strike...
+#if 0
+//Dasm(regs.pc, 1);
+static int hitCount = 0;
+static int inRoutine = 0;
+static int instSeen;
+
+//if (regs.pc == 0x80340A)
+if (m68kPC == 0x803416)
+{
+ hitCount++;
+ inRoutine = 1;
+ instSeen = 0;
+ printf("%i: $80340A start. A0=%08X, A1=%08X ", hitCount, m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1));
+}
+else if (m68kPC == 0x803422)
+{
+ inRoutine = 0;
+ printf("(%i instructions)\n", instSeen);
+}
+
+if (inRoutine)
+ instSeen++;
+#endif
// For tracebacks...
// Ideally, we'd save all the registers as well...
}
#endif
+void ShowM68KContext(void)
+{
+ printf("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
+
+ for(int i=M68K_REG_D0; i<=M68K_REG_D7; i++)
+ {
+ printf("D%i = %08X ", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
+
+ if (i == M68K_REG_D3 || i == M68K_REG_D7)
+ printf("\n");
+ }
+
+ for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
+ {
+ printf("A%i = %08X ", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
+
+ if (i == M68K_REG_A3 || i == M68K_REG_A7)
+ printf("\n");
+ }
+
+ uint32_t currpc = m68k_get_reg(NULL, M68K_REG_PC);
+ uint32_t disPC = currpc - 30;
+ char buffer[128];
+
+ do
+ {
+ uint32_t oldpc = disPC;
+ disPC += m68k_disassemble(buffer, disPC, 0);
+ printf("%s%08X: %s\n", (oldpc == currpc ? ">" : " "), oldpc, buffer);
+ }
+ while (disPC < (currpc + 10));
+}
+
//
// Musashi 68000 read/write/IRQ functions
//
// Tracing the IPL lines on the Jaguar schematic yields the following:
// IPL1 is connected to INTL on TOM (OUT to 68K)
// IPL0-2 are also tied to Vcc via 4.7K resistors!
- // (DINT on TOM goes into DINT on JERRY (IN from Jerry))
+ // (DINT on TOM goes into DINT on JERRY (IN Tom from Jerry))
// There doesn't seem to be any other path to IPL0 or 2 on the schematic, which means
// that *all* IRQs to the 68K are routed thru TOM at level 2. Which means they're all maskable.
unsigned int m68k_read_memory_8(unsigned int address)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
#ifdef CPU_DEBUG_MEMORY
- if ((address >= 0x000000) && (address <= 0x3FFFFF))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFF))
{
if (startMemLog)
readMem[address] = 1;
#ifndef USE_NEW_MMU
unsigned int retVal = 0;
- if ((address >= 0x000000) && (address <= 0x3FFFFF))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFF))
retVal = jaguarMainRAM[address];
// else if ((address >= 0x800000) && (address <= 0xDFFFFF))
else if ((address >= 0x800000) && (address <= 0xDFFEFF))
unsigned int m68k_read_memory_16(unsigned int address)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
#ifdef CPU_DEBUG_MEMORY
/* if ((address >= 0x000000) && (address <= 0x3FFFFE))
{
#ifndef USE_NEW_MMU
unsigned int retVal = 0;
- if ((address >= 0x000000) && (address <= 0x3FFFFE))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFE))
// retVal = (jaguar_mainRam[address] << 8) | jaguar_mainRam[address+1];
retVal = GET16(jaguarMainRAM, address);
// else if ((address >= 0x800000) && (address <= 0xDFFFFE))
unsigned int m68k_read_memory_32(unsigned int address)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
//; So, it seems that it stores the returned DWORD at $51136 and $FB074.
/* if (address == 0x51136 || address == 0xFB074 || address == 0x1AF05E)
WriteLog("[RM32 PC=%08X] Addr: %08X, val: %08X\n", m68k_get_reg(NULL, M68K_REG_PC), address, (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2));//*/
void m68k_write_memory_8(unsigned int address, unsigned int value)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
#ifdef CPU_DEBUG_MEMORY
- if ((address >= 0x000000) && (address <= 0x3FFFFF))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFF))
{
if (startMemLog)
{
/*if (effect_start)
if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
WriteLog("M68K: Byte %02X written at %08X by 68K\n", value, address);//*/
+//$53D0
+/*if (address >= 0x53D0 && address <= 0x53FF)
+ printf("M68K: Writing byte $%02X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
+//Testing AvP on UAE core...
+//000075A0: FFFFF80E B6320220 (BITMAP)
+/*if (address == 0x75A0 && value == 0xFF)
+ printf("M68K: (8) Tripwire hit...\n");//*/
#ifndef USE_NEW_MMU
- if ((address >= 0x000000) && (address <= 0x3FFFFF))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFF))
jaguarMainRAM[address] = value;
else if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
CDROMWriteByte(address, value, M68K);
void m68k_write_memory_16(unsigned int address, unsigned int value)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
#ifdef CPU_DEBUG_MEMORY
- if ((address >= 0x000000) && (address <= 0x3FFFFE))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFE))
{
if (startMemLog)
{
/* if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
|| address == 0x1AF05E)
WriteLog("[WM16 PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+//$53D0
+/*if (address >= 0x53D0 && address <= 0x53FF)
+ printf("M68K: Writing word $%04X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
+//Testing AvP on UAE core...
+//000075A0: FFFFF80E B6320220 (BITMAP)
+/*if (address == 0x75A0 && value == 0xFFFF)
+{
+ printf("\nM68K: (16) Tripwire hit...\n");
+ ShowM68KContext();
+}//*/
#ifndef USE_NEW_MMU
- if ((address >= 0x000000) && (address <= 0x3FFFFE))
+ // Note that the Jaguar only has 2M of RAM, not 4!
+ if ((address >= 0x000000) && (address <= 0x1FFFFE))
{
/* jaguar_mainRam[address] = value >> 8;
jaguar_mainRam[address + 1] = value & 0xFF;*/
void m68k_write_memory_32(unsigned int address, unsigned int value)
{
+ // Musashi does this automagically for you, UAE core does not :-P
+ address &= 0x00FFFFFF;
/*if (address == 0x4E00)
WriteLog("M68K: Writing %02X at %08X, PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
//WriteLog("--> [WM32]\n");
doGPUDis = true;//*/
/* if (address == 0x51136 || address == 0xFB074)
WriteLog("[WM32 PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+//Testing AvP on UAE core...
+//000075A0: FFFFF80E B6320220 (BITMAP)
+/*if (address == 0x75A0 && (value & 0xFFFF0000) == 0xFFFF0000)
+{
+ printf("\nM68K: (32) Tripwire hit...\n");
+ ShowM68KContext();
+}//*/
#ifndef USE_NEW_MMU
m68k_write_memory_16(address, value >> 16);
void M68K_show_context(void)
{
- WriteLog("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
+ WriteLog("68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
+
for(int i=M68K_REG_D0; i<=M68K_REG_D7; i++)
- WriteLog("\tD%i = %08X\n", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
- WriteLog("\n");
+ {
+ WriteLog("D%i = %08X ", i-M68K_REG_D0, m68k_get_reg(NULL, (m68k_register_t)i));
+
+ if (i == M68K_REG_D3 || i == M68K_REG_D7)
+ WriteLog("\n");
+ }
+
for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
- WriteLog("\tA%i = %08X\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
+ {
+ WriteLog("A%i = %08X ", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
+
+ if (i == M68K_REG_A3 || i == M68K_REG_A7)
+ WriteLog("\n");
+ }
WriteLog("68K disasm\n");
// jaguar_dasm(s68000readPC()-0x1000,0x20000);
uint8 data = 0x00;
offset &= 0xFFFFFF;
- if (offset < 0x400000)
+ if (offset < 0x200000)
data = jaguarMainRAM[offset & 0x3FFFFF];
else if ((offset >= 0x800000) && (offset < 0xC00000))
data = jaguarMainROM[offset - 0x800000];
uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
{
offset &= 0xFFFFFF;
- if (offset <= 0x3FFFFE)
+ if (offset <= 0x1FFFFE)
{
- return (jaguarMainRAM[(offset+0) & 0x3FFFFF] << 8) | jaguarMainRAM[(offset+1) & 0x3FFFFF];
+ return (jaguarMainRAM[(offset+0) & 0x1FFFFF] << 8) | jaguarMainRAM[(offset+1) & 0x1FFFFF];
}
else if ((offset >= 0x800000) && (offset <= 0xBFFFFE))
{
WriteLog("JWB: Byte %02X written at %08X by %s\n", data, offset, whoName[who]);//*/
offset &= 0xFFFFFF;
- if (offset < 0x400000)
+ if (offset < 0x200000)
{
- jaguarMainRAM[offset & 0x3FFFFF] = data;
+ jaguarMainRAM[offset & 0x1FFFFF] = data;
return;
}
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
offset &= 0xFFFFFF;
- if (offset <= 0x3FFFFE)
+ if (offset <= 0x1FFFFE)
{
/*
GPU Table (CD BIOS)
if (offset == 0x11D31A + 0x48000 || offset == 0x11D31A)
WriteLog("JWW: %s writing star %04X at %08X...\n", whoName[who], data, offset);//*/
- jaguarMainRAM[(offset+0) & 0x3FFFFF] = data >> 8;
- jaguarMainRAM[(offset+1) & 0x3FFFFF] = data & 0xFF;
+ jaguarMainRAM[(offset+0) & 0x1FFFFF] = data >> 8;
+ jaguarMainRAM[(offset+1) & 0x1FFFFF] = data & 0xFF;
return;
}
else if (offset >= 0xDFFF00 && offset <= 0xDFFFFE)
memset(writeMemMin, 0xFF, 0x400000);
memset(writeMemMax, 0x00, 0x400000);
#endif
- memset(jaguarMainRAM, 0x00, 0x400000);
+ memset(jaguarMainRAM, 0x00, 0x200000);
// memset(jaguar_mainRom, 0xFF, 0x200000); // & set it to all Fs...
// memset(jaguar_mainRom, 0x00, 0x200000); // & set it to all 0s...
//NOTE: This *doesn't* fix FlipOut...
//Seems to want $01010101... Dunno why. Investigate!
memset(jaguarMainROM, 0x01, 0x600000); // & set it to all 01s...
// memset(jaguar_mainRom, 0xFF, 0x600000); // & set it to all Fs...
+ lowerField = false; // Reset the lower field flag
+//temp, for crappy crap that sux
+memset(jaguarMainRAM + 0x804, 0xFF, 4);
m68k_set_cpu_type(M68K_CPU_TYPE_68000);
+ m68k_pulse_reset(); // Need to do this so UAE disasm doesn't segfault on exit
GPUInit();
DSPInit();
TOMInit();
}
//New timer based code stuffola...
-void ScanlineCallback(void);
+void HalflineCallback(void);
void RenderCallback(void);
void JaguarReset(void)
{
m68k_pulse_reset(); // Reset the 68000
WriteLog("Jaguar: 68K reset. PC=%06X SP=%08X\n", m68k_get_reg(NULL, M68K_REG_PC), m68k_get_reg(NULL, M68K_REG_A7));
+ lowerField = false; // Reset the lower field flag
// New timer base code stuffola...
InitializeEventList();
// SetCallbackTime(ScanlineCallback, 63.5555);
- SetCallbackTime(ScanlineCallback, 31.77775);
-// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time
-// SetCallbackTime(RenderCallback, 16651.541); // # Scanlines * scanline time
+// SetCallbackTime(ScanlineCallback, 31.77775);
+ SetCallbackTime(HalflineCallback, (vjs.hardwareTypeNTSC ? 31.777777777 : 32.0));
}
void JaguarDone(void)
JaguarDasm(0x802000, 6000);
WriteLog("\n");//*/
#endif
-/* WriteLog("\n\nM68000 disassembly at $080000...\n");
- JaguarDasm(0x080000, 10000);
+/* WriteLog("\n\nM68000 disassembly at $4000...\n");
+ JaguarDasm(0x4000, 10000);
WriteLog("\n");//*/
+// WriteLog("\n\nM68000 disassembly at $802000...\n");
+// JaguarDasm(0x802000, 0x1000);
+// WriteLog("\n\nM68000 disassembly at $4100...\n");
+// JaguarDasm(0x4100, 200);
+// WriteLog("\n\nM68000 disassembly at $800800...\n");
+// JaguarDasm(0x800800, 0x1000);
}
//
//seem to indicate the refresh rate is *half* the above...
// uint16 refreshRate = (vjs.hardwareTypeNTSC ? 30 : 25);
// Should these be hardwired or read from VP? Yes, from VP!
+ // Err, actually, they should be hardwired, and hardwired to a set # of
+ // lines as well...
uint32 M68KCyclesPerScanline = m68kClockRate / (vp * refreshRate);
uint32 RISCCyclesPerScanline = m68kClockRate / (vp * refreshRate);
//if (start_logging)
// WriteLog("About to execute OP (%u)...\n", i);
- TOMExecScanline(i, render);
+ TOMExecHalfline(i, render);
}
}
while (!frameDone);
}
-void ScanlineCallback(void)
+#define USE_CORRECT_PAL_TIMINGS
+// A lot of confusion comes from here...
+// The thing to keep in mind is that the VC is advanced every HALF line, regardless
+// of whether the display is interlaced or not. The only difference with an
+// interlaced display is that the high bit of VC will be set when the lower
+// field is being rendered. (NB: The high bit of VC is ALWAYS set on the lower field,
+// regardless of whether it's in interlace mode or not.
+// NB2: Seems it doens't always, not sure what the constraint is...)
+//
+// Normally, TVs will render a full frame in 1/30s (NTSC) or 1/25s (PAL) by
+// rendering two fields that are slighty vertically offset from each other.
+// Each field is created in 1/60s (NTSC) or 1/50s (PAL), and every other line
+// is rendered in this mode so that each field, when overlaid on each other,
+// will yield the final picture at the full resolution for the full frame.
+//
+// We execute a half frame in each timeslice (1/60s NTSC, 1/50s PAL).
+// Since the number of lines in a FULL frame is 525 for NTSC, 625 for PAL,
+// it will be half this number for a half frame. BUT, since we're counting
+// HALF lines, we double this number and we're back at 525 for NTSC, 625 for PAL.
+//
+// Scanline times are 63.5555... µs in NTSC and 64 µs in PAL
+// Half line times are, naturally, half of this. :-P
+void HalflineCallback(void)
{
+//OK, this is hardwired to run in NTSC, and for who knows how long.
+//Need to fix this so that it does a half-line in the correct amount of time
+//and number of lines, depending on which mode we're in. [FIXED]
uint16 vc = TOMReadWord(0xF00006, JAGUAR);
uint16 vp = TOMReadWord(0xF0003E, JAGUAR) + 1;
uint16 vi = TOMReadWord(0xF0004E, JAGUAR);
// uint16 vbb = TOMReadWord(0xF00040, JAGUAR);
vc++;
- if (vc >= vp)
+#ifdef USE_CORRECT_PAL_TIMINGS
+ // Each # of lines is for a full frame == 1/30s (NTSC), 1/25s (PAL).
+ // So we cut the number of half-lines in a frame in half. :-P
+ uint16 numHalfLines = ((vjs.hardwareTypeNTSC ? 525 : 625) * 2) / 2;
+
+ if ((vc & 0x7FF) >= numHalfLines)
+#else
+ if ((vc & 0x7FF) >= vp)
+#endif
+ {
vc = 0;
+// lowerField = !lowerField;
+
+ // If we're rendering the lower field, set the high bit (#12, counting
+ // from 1) of VC
+ if (lowerField)
+ vc = 0x0800;
+ }
//WriteLog("SLC: Currently on line %u (VP=%u)...\n", vc, vp);
TOMWriteWord(0xF00006, vc, JAGUAR);
//This is a crappy kludge, but maybe it'll work for now...
//Maybe it's not so bad, since the IRQ happens on a scanline boundary...
- if (vc == vi && vc > 0 && TOMIRQEnabled(IRQ_VIDEO)) // Time for Vertical Interrupt?
+ if ((vc & 0x7FF) == vi && (vc & 0x7FF) > 0 && TOMIRQEnabled(IRQ_VIDEO)) // Time for Vertical Interrupt?
{
// We don't have to worry about autovectors & whatnot because the Jaguar
// tells you through its HW registers who sent the interrupt...
m68k_set_irq(2);
}
- TOMExecScanline(vc, true);
+ TOMExecHalfline(vc, true);
//Change this to VBB???
//Doesn't seem to matter (at least for Flip Out & I-War)
- if (vc == 0)
+ if ((vc & 0x7FF) == 0)
// if (vc == vbb)
{
JoystickExec();
frameDone = true;
}//*/
-// SetCallbackTime(ScanlineCallback, 63.5555);
- SetCallbackTime(ScanlineCallback, 31.77775);
+#ifdef USE_CORRECT_PAL_TIMINGS
+ SetCallbackTime(HalflineCallback, (vjs.hardwareTypeNTSC ? 31.777777777 : 32.0));
+#else
+// SetCallbackTime(HalflineCallback, 63.5555);
+ SetCallbackTime(HalflineCallback, 31.77775);
+#endif
}
// This isn't currently used, but maybe it should be...
projects / virtualjaguar / blobdiff