X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fjaguar.cpp;h=af4718a69d2ce3f597830c549ac5e050b5eb43ce;hb=59ca39a29be645918de45bd144865ba6487f4009;hp=28578f54b0e5c91136fefe40319017744046f2bd;hpb=220217373079ff8d737f3d6dc07bbbad8f46e1ca;p=virtualjaguar diff --git a/src/jaguar.cpp b/src/jaguar.cpp index 28578f5..af4718a 100644 --- a/src/jaguar.cpp +++ b/src/jaguar.cpp @@ -1,8 +1,8 @@ // // JAGUAR.CPP // -// by Cal2 -// GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS) +// 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 // Note: Endian wrongness probably stems from the MAME origins of this emu and // the braindead way in which MAME handles memory. :-) @@ -10,11 +10,13 @@ #include "jaguar.h" #include "video.h" +#include "settings.h" //#include "m68kdasmAG.h" #define CPU_DEBUG //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 CPU_DEBUG_MEMORY // Private function prototypes @@ -27,7 +29,7 @@ void M68K_show_context(void); // External variables -extern bool hardwareTypeNTSC; // Set to false for PAL +//extern bool hardwareTypeNTSC; // Set to false for PAL #ifdef CPU_DEBUG_MEMORY extern bool startMemLog; // Set by "e" key extern int effect_start; @@ -39,23 +41,23 @@ extern int effect_start2, effect_start3, effect_start4, effect_start5, effect_st char * whoName[9] = { "Unknown", "Jaguar", "DSP", "GPU", "TOM", "JERRY", "M68K", "Blitter", "OP" }; -// These values are overridden by command line switches... - -extern bool dsp_enabled; -extern bool jaguar_use_bios; // Default is now to USE the BIOS uint32 jaguar_active_memory_dumps = 0; -uint32 jaguar_mainRom_crc32; +uint32 jaguar_mainRom_crc32, jaguarRomSize, jaguarRunAddress; /*static*/ uint8 * jaguar_mainRam = NULL; /*static*/ uint8 * jaguar_bootRom = NULL; /*static*/ uint8 * jaguar_mainRom = NULL; + #ifdef CPU_DEBUG_MEMORY uint8 writeMemMax[0x400000], writeMemMin[0x400000]; uint8 readMem[0x400000]; uint32 returnAddr[4000], raPtr = 0xFFFFFFFF; #endif +uint32 pcQueue[0x400]; +uint32 pcQPtr = 0; + // // Callback function to detect illegal instructions // @@ -64,6 +66,34 @@ uint32 returnAddr[4000], raPtr = 0xFFFFFFFF; void M68KInstructionHook(void) { uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC); + +// For tracebacks... +// Ideally, we'd save all the registers as well... + pcQueue[pcQPtr++] = m68kPC; + pcQPtr &= 0x3FF; + + if (m68kPC & 0x01) // Oops! We're fetching an odd address! + { + WriteLog("M68K: Attempted to execute from an odd adress!\n\nBacktrace:\n\n"); + + static char buffer[2048]; + for(int i=0; i<0x400; i++) + { + m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], M68K_CPU_TYPE_68000); + WriteLog("\t%08X: %s\n", pcQueue[(pcQPtr + i) & 0x3FF], buffer); + } + WriteLog("\n"); + + uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7); + WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack)); + for(int i=0; i<10; i++) + WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4))); + WriteLog("Jaguar: VBL interrupt is %s\n", ((tom_irq_enabled(IRQ_VBLANK)) && (jaguar_interrupt_handler_is_valid(64))) ? "enabled" : "disabled"); + M68K_show_context(); + log_done(); + exit(0); + } + /* if (m68kPC >= 0x807EC4 && m68kPC <= 0x807EDB) { static char buffer[2048]; @@ -433,6 +463,8 @@ void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who/*=UNKN { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES WriteLog("Jaguar: Unknown byte %02X written at %08X by %s (M68K PC=%06X)\n", data, address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC)); +#endif +#ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS extern bool finished; finished = true; extern bool doDSPDis; @@ -445,6 +477,8 @@ void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who/*=UNKN { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES WriteLog("Jaguar: Unknown word %04X written at %08X by %s (M68K PC=%06X)\n", data, address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC)); +#endif +#ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS extern bool finished; finished = true; extern bool doDSPDis; @@ -457,6 +491,8 @@ unsigned jaguar_unknown_readbyte(unsigned address, uint32 who/*=UNKNOWN*/) { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES WriteLog("Jaguar: Unknown byte read at %08X by %s (M68K PC=%06X)\n", address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC)); +#endif +#ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS extern bool finished; finished = true; extern bool doDSPDis; @@ -470,6 +506,8 @@ unsigned jaguar_unknown_readword(unsigned address, uint32 who/*=UNKNOWN*/) { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES WriteLog("Jaguar: Unknown word read at %08X by %s (M68K PC=%06X)\n", address, whoName[who], m68k_get_reg(NULL, M68K_REG_PC)); +#endif +#ifdef ABORT_ON_UNMAPPED_MEMORY_ACCESS extern bool finished; finished = true; extern bool doDSPDis; @@ -597,13 +635,14 @@ void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/) void JaguarWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/) { //TEMP--Mirror of F03000? Yes, but only 32-bit CPUs can do it (i.e., NOT the 68K!) -// PLUS, you would handle this in the GPU/DSP WroteLong code! Not here! +// PLUS, you would handle this in the GPU/DSP WriteLong code! Not here! offset &= 0xFFFFFF; if (offset <= 0x3FFFFE) { -if (offset == 0x670C) - WriteLog("Jaguar: %s writing to location $670C...\n", whoName[who]); +//This MUST be done by the 68K! +/*if (offset == 0x670C) + WriteLog("Jaguar: %s writing to location $670C...\n", whoName[who]);*/ jaguar_mainRam[(offset+0) & 0x3FFFFF] = (data>>8) & 0xFF; jaguar_mainRam[(offset+1) & 0x3FFFFF] = data & 0xFF; @@ -640,6 +679,13 @@ uint32 JaguarReadLong(uint32 offset, uint32 who/*=UNKNOWN*/) // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!! void JaguarWriteLong(uint32 offset, uint32 data, uint32 who/*=UNKNOWN*/) { +/* extern bool doDSPDis; + if (offset < 0x400 && !doDSPDis) + { + WriteLog("JLW: Write to %08X by %s... Starting DSP log!\n\n", offset, whoName[who]); + doDSPDis = true; + }//*/ + JaguarWriteWord(offset, data >> 16, who); JaguarWriteWord(offset+2, data & 0xFFFF, who); } @@ -660,6 +706,7 @@ void jaguar_init(void) memset(jaguar_mainRam, 0x00, 0x400000); // 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... memset(jaguar_mainRom, 0x01, 0x600000); // & set it to all 01s... // cd_bios_boot("C:\\ftp\\jaguar\\cd\\Brain Dead 13.cdi"); @@ -774,21 +821,31 @@ void jaguar_done(void) void jaguar_reset(void) { - if (jaguar_use_bios) + if (vjs.useJaguarBIOS) memcpy(jaguar_mainRam, jaguar_bootRom, 8); else { - SET32(jaguar_mainRam, 4, 0x00802000); +// Should also make a run address global as well, for when we reset the jag (PD mainly) +/* SET32(jaguar_mainRam, 4, 0x00802000); // Handle PD stuff... // This should definitely go elsewhere (like in the cart load section)! +//NOTE: The bytes 'JAGR' should also be at position $1C... if (jaguar_mainRom[0] == 0x60 && jaguar_mainRom[1] == 0x1A) { - uint32 runAddress = GET32(jaguar_mainRom, 0x2A); - uint32 progLength = GET32(jaguar_mainRom, 0x02); - WriteLog("Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, progLength); - memcpy(jaguar_mainRam + runAddress, jaguar_mainRom + 0x2E, progLength); + uint32 loadAddress = GET32(jaguar_mainRom, 0x22), runAddress = GET32(jaguar_mainRom, 0x2A); +//This is not always right! Especially when converted via bin2jag1!!! +//We should have access to the length of the furshlumiger file that was loaded anyway! +//Now, we do! ;-) +// uint32 progLength = GET32(jaguar_mainRom, 0x02); +//jaguarRomSize +//jaguarRunAddress +// WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, progLength); +// memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, progLength); + WriteLog("Jaguar: Setting up PD ROM... Run address: %08X, length: %08X\n", runAddress, jaguarRomSize - 0x2E); + memcpy(jaguar_mainRam + loadAddress, jaguar_mainRom + 0x2E, jaguarRomSize - 0x2E); SET32(jaguar_mainRam, 4, runAddress); - } + }//*/ + SET32(jaguar_mainRam, 4, jaguarRunAddress); } // WriteLog("jaguar_reset():\n"); @@ -812,27 +869,29 @@ void JaguarExecute(int16 * backbuffer, bool render) { uint16 vp = TOMReadWord(0xF0003E) + 1;//Hmm. This is a WO register. Will work? Looks like. But wrong behavior! uint16 vi = TOMReadWord(0xF0004E);//Another WO register... - uint16 vdb = TOMReadWord(0xF00046); +// uint16 vdb = TOMReadWord(0xF00046); //Note: This is the *definite* end of the display, though VDE *might* be less than this... // uint16 vbb = TOMReadWord(0xF00040); //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); +// uint16 vde = TOMReadWord(0xF00048); - uint16 refreshRate = (hardwareTypeNTSC ? 60 : 50); + uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50); // Should these be hardwired or read from VP? Yes, from VP! uint32 M68KCyclesPerScanline - = (hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL) / (vp * refreshRate); + = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL) / (vp * refreshRate); uint32 RISCCyclesPerScanline - = (hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL) / (vp * refreshRate); + = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL) / (vp * refreshRate); + TOMResetBackbuffer(backbuffer); /*extern int effect_start; if (effect_start) { WriteLog("JagExe: VP=%u, VI=%u, VDB=%u, VBB=%u CPU CPS=%u, GPU CPS=%u\n", vp, vi, vdb, vbb, M68KCyclesPerScanline, RISCCyclesPerScanline); }//*/ +//extern int start_logging; for(uint16 i=0; i= vdb && i < vde)//vbb) - { - if (!(i & 0x01)) // Execute OP only on even lines (non-interlaced only!) - { - tom_exec_scanline(backbuffer, i/2, render); // i/2 is a kludge... - backbuffer += GetSDLScreenPitch() / 2; // Convert bytes to words... - } - } + 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); + TOMExecScanline(i, render); } }