//
// 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
// --- ---------- -----------------------------------------------------------
#include "jerry.h"
#include "joystick.h"
#include "log.h"
-#include "m68k.h"
+#include "m68000/m68kinterface.h"
//#include "memory.h"
#include "mmu.h"
#include "settings.h"
//Do this in makefile??? Yes! Could, but it's easier to define here...
//#define LOG_UNMAPPED_MEMORY_ACCESSES
//#define ABORT_ON_UNMAPPED_MEMORY_ACCESS
-#define ABORT_ON_ILLEGAL_INSTRUCTIONS
+//#define ABORT_ON_ILLEGAL_INSTRUCTIONS
//#define ABORT_ON_OFFICIAL_ILLEGAL_INSTRUCTION
#define CPU_DEBUG_MEMORY
//#define LOG_CD_BIOS_CALLS
+#define CPU_DEBUG_TRACING
// Private function prototypes
uint32 pcQueue[0x400];
uint32 pcQPtr = 0;
+bool startM68KTracing = false;
//
// Callback function to detect illegal instructions
instSeen++;
#endif
+// For code tracing...
+#ifdef CPU_DEBUG_TRACING
+ if (startM68KTracing)
+ {
+ static char buffer[2048];
+
+ m68k_disassemble(buffer, m68kPC, 0);
+ WriteLog("%06X: %s\n", m68kPC, buffer);
+ }
+#endif
+
// For tracebacks...
// Ideally, we'd save all the registers as well...
pcQueue[pcQPtr++] = m68kPC;
static char buffer[2048];
for(int i=0; i<0x400; i++)
{
- m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], M68K_CPU_TYPE_68000);
+ m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], 0);//M68K_CPU_TYPE_68000);
WriteLog("\t%08X: %s\n", pcQueue[(pcQPtr + i) & 0x3FF], buffer);
}
WriteLog("\n");
m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1),
m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1), m68k_get_reg(NULL, M68K_REG_D2));
}//*/
- if (m68kPC == 0x82E1A)
+/* if (m68kPC == 0x82E1A)
{
static char buffer[2048];
- m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
+ m68k_disassemble(buffer, m68kPC, 0);//M68K_CPU_TYPE_68000);
WriteLog("--> [Routine start] %08X: %s", m68kPC, buffer);
WriteLog("\t\tA0=%08X, A1=%08X, D0=%08X(cmd), D1=%08X(# bytes), D2=%08X\n",
m68k_get_reg(NULL, M68K_REG_A0), m68k_get_reg(NULL, M68K_REG_A1),
m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1), m68k_get_reg(NULL, M68K_REG_D2));
}//*/
- if (m68kPC == 0x82E58)
+/* if (m68kPC == 0x82E58)
WriteLog("--> [Routine end]\n");
if (m68kPC == 0x80004)
{
#endif
#ifdef ABORT_ON_ILLEGAL_INSTRUCTIONS
- if (!m68k_is_valid_instruction(m68k_read_memory_16(m68kPC), M68K_CPU_TYPE_68000))
+ if (!m68k_is_valid_instruction(m68k_read_memory_16(m68kPC), 0))//M68K_CPU_TYPE_68000))
{
#ifndef ABORT_ON_OFFICIAL_ILLEGAL_INSTRUCTION
if (m68k_read_memory_16(m68kPC) == 0x4AFC)
WriteLog("\nM68K encountered an illegal instruction at %08X!!!\n\nAborting!\n", m68kPC);
uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
+ uint32 address = topOfStack - (4 * 4 * 3);
+
for(int i=0; i<10; i++)
- WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4)));
+ {
+ WriteLog("%06X:", address);
+
+ for(int j=0; j<4; j++)
+ {
+ WriteLog(" %08X", JaguarReadLong(address));
+ address += 4;
+ }
+
+ WriteLog("\n");
+ }
+
WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VIDEO)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
M68K_show_context();
}
#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
+// Custom UAE 68000 read/write/IRQ functions
//
#if 0
#endif
int irq_ack_handler(int level)
{
+#ifdef CPU_DEBUG_TRACING
+ if (startM68KTracing)
+ {
+ WriteLog("irq_ack_handler: M68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC));
+ }
+#endif
+
// 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!
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)
{
//$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)
{
//$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);
pc += Dasm68000((char *)mem, buffer, 0);
WriteLog("%08X: %s\n", oldpc, buffer);//*/
oldpc = pc;
- pc += m68k_disassemble(buffer, pc, M68K_CPU_TYPE_68000);
+ pc += m68k_disassemble(buffer, pc, 0);//M68K_CPU_TYPE_68000);
WriteLog("%08X: %s\n", oldpc, buffer);//*/
}
#endif
uint8 JaguarReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
{
uint8 data = 0x00;
-
offset &= 0xFFFFFF;
- if (offset < 0x400000)
- data = jaguarMainRAM[offset & 0x3FFFFF];
- else if ((offset >= 0x800000) && (offset < 0xC00000))
+
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset < 0x800000)
+ data = jaguarMainRAM[offset & 0x1FFFFF];
+ else if ((offset >= 0x800000) && (offset < 0xDFFF00))
data = jaguarMainROM[offset - 0x800000];
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
data = CDROMReadByte(offset, who);
uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
{
offset &= 0xFFFFFF;
- if (offset <= 0x3FFFFE)
+
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset < 0x800000)
{
- 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))
+ else if ((offset >= 0x800000) && (offset < 0xDFFF00))
{
offset -= 0x800000;
return (jaguarMainROM[offset+0] << 8) | jaguarMainROM[offset+1];
WriteLog("JWB: Byte %02X written at %08X by %s\n", data, offset, whoName[who]);//*/
offset &= 0xFFFFFF;
- if (offset < 0x400000)
+
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset < 0x800000)
{
- jaguarMainRAM[offset & 0x3FFFFF] = data;
+ jaguarMainRAM[offset & 0x1FFFFF] = data;
return;
}
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
offset &= 0xFFFFFF;
- if (offset <= 0x3FFFFE)
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset <= 0x7FFFFE)
{
/*
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
+ 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_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();
void RenderCallback(void);
void JaguarReset(void)
{
+ // New timer base code stuffola...
+ InitializeEventList();
//Need to change this so it uses the single RAM space and load the BIOS
//into it somewhere...
//Also, have to change this here and in JaguarReadXX() currently
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(HalflineCallback, (vjs.hardwareTypeNTSC ? 31.777777777 : 32.0));
// for(int i=M68K_REG_A0; i<=M68K_REG_A7; i++)
// WriteLog("\tA%i = 0x%.8x\n", i-M68K_REG_A0, m68k_get_reg(NULL, (m68k_register_t)i));
int32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7);
- WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
+ WriteLog("M68K: Top of stack: %08X -> (%08X). Stack trace:\n", topOfStack, JaguarReadLong(topOfStack));
+#if 0
for(int i=-2; i<9; i++)
WriteLog("%06X: %08X\n", topOfStack + (i * 4), JaguarReadLong(topOfStack + (i * 4)));
+#else
+ uint32 address = topOfStack - (4 * 4 * 3);
+
+ for(int i=0; i<10; i++)
+ {
+ WriteLog("%06X:", address);
+
+ for(int j=0; j<4; j++)
+ {
+ WriteLog(" %08X", JaguarReadLong(address));
+ address += 4;
+ }
+
+ WriteLog("\n");
+ }
+#endif
/* WriteLog("\nM68000 disassembly at $802288...\n");
jaguar_dasm(0x802288, 3);
JaguarDasm(0x802000, 6000);
WriteLog("\n");//*/
#endif
-/* WriteLog("\n\nM68000 disassembly at $4000...\n");
- JaguarDasm(0x4000, 10000);
+/* WriteLog("\n\nM68000 disassembly at $6004...\n");
+ JaguarDasm(0x6004, 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);
}
-//
-// Main Jaguar execution loop (1 frame)
-//
-void JaguarExecute(uint32 * backbuffer, bool render)
-{
- uint16 vp = TOMReadWord(0xF0003E, JAGUAR) + 1;
- uint16 vi = TOMReadWord(0xF0004E, JAGUAR);
-//Using WO registers is OK, since we're the ones controlling access--there's nothing wrong here! ;-)
-//Though we shouldn't be able to do it using TOMReadWord... !!! FIX !!!
-
-// uint16 vdb = TOMReadWord(0xF00046, JAGUAR);
-//Note: This is the *definite* end of the display, though VDE *might* be less than this...
-// uint16 vbb = TOMReadWord(0xF00040, JAGUAR);
-//It seems that they mean it when they say that VDE is the end of object processing.
-//However, we need to be able to tell the OP (or TOM) that we've reached the end of the
-//buffer and not to write any more pixels... !!! FIX !!!
-// uint16 vde = TOMReadWord(0xF00048, JAGUAR);
-
- uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50);
- uint32 m68kClockRate = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL);
-//Not sure the above is correct, since the number of lines and timings given in the JTRM
-//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);
-
-/*extern int effect_start;
-if (effect_start)
- WriteLog("JagExe: VP=%u, VI=%u, CPU CPS=%u, GPU CPS=%u\n", vp, vi, M68KCyclesPerScanline, RISCCyclesPerScanline);//*/
-
-//extern int start_logging;
- for(uint16 i=0; i<vp; i++)
- {
- // Increment the horizontal count (why? RNG? Besides which, this is *NOT* cycle accurate!)
- TOMWriteWord(0xF00004, (TOMReadWord(0xF00004, JAGUAR) + 1) & 0x7FF, JAGUAR);
- TOMWriteWord(0xF00006, i, JAGUAR); // Write the VC
-
-//Not sure if this is correct...
-//Seems to be, kinda. According to the JTRM, this should only fire on odd lines in non-interlace mode...
-//Which means that it normally wouldn't go when it's zero.
- if (i == vi && i > 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...
- TOMSetPendingVideoInt();
- m68k_set_irq(2);
- }
-
-//if (start_logging)
-// WriteLog("About to execute M68K (%u)...\n", i);
- m68k_execute(M68KCyclesPerScanline);
-//if (start_logging)
-// WriteLog("About to execute TOM's PIT (%u)...\n", i);
- TOMExecPIT(RISCCyclesPerScanline);
-//if (start_logging)
-// WriteLog("About to execute JERRY's PIT (%u)...\n", i);
- JERRYExecPIT(RISCCyclesPerScanline);
-//if (start_logging)
-// WriteLog("About to execute JERRY's SSI (%u)...\n", i);
- JERRYI2SExec(RISCCyclesPerScanline);
- BUTCHExec(RISCCyclesPerScanline);
-//if (start_logging)
-// WriteLog("About to execute GPU (%u)...\n", i);
- if (vjs.GPUEnabled)
- GPUExec(RISCCyclesPerScanline);
-
- if (vjs.DSPEnabled)
- {
- if (vjs.usePipelinedDSP)
- DSPExecP2(RISCCyclesPerScanline); // Pipelined DSP execution (3 stage)...
- else
- DSPExec(RISCCyclesPerScanline); // Ordinary non-pipelined DSP
-// DSPExecComp(RISCCyclesPerScanline); // Comparison core
- }
-
-//if (start_logging)
-// WriteLog("About to execute OP (%u)...\n", i);
- TOMExecHalfline(i, render);
- }
-}
// Temp debugging stuff
fclose(fp);
}
+
uint8 * GetRamPtr(void)
{
return jaguarMainRAM;
}
+
//
// New Jaguar execution stack
// This executes 1 frame's worth of code.
if (vjs.GPUEnabled)
GPUExec(USEC_TO_RISC_CYCLES(timeToNextEvent));
- if (vjs.DSPEnabled)
- {
- if (vjs.usePipelinedDSP)
- DSPExecP2(USEC_TO_RISC_CYCLES(timeToNextEvent)); // Pipelined DSP execution (3 stage)...
- else
- DSPExec(USEC_TO_RISC_CYCLES(timeToNextEvent)); // Ordinary non-pipelined DSP
- }
-
HandleNextEvent();
}
while (!frameDone);
}
+
#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
// 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
+// 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)
{
#endif
}
+
// This isn't currently used, but maybe it should be...
/*
Nah, the scanline based code is good enough, and runs in 1 frame. The GUI
projects / virtualjaguar / blobdiff