X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fjaguar.cpp;h=7cf0bca8f6338238f7103236e93a534da9d30cf7;hb=48dd9ba5b6742935eef61cec80964afe093139ad;hp=f9a4185b6999f4eb2a8873719137dd7222e4e35b;hpb=c0402fe96edb72755d79a7ea40d78141f76ce8cf;p=virtualjaguar diff --git a/src/jaguar.cpp b/src/jaguar.cpp index f9a4185..7cf0bca 100644 --- a/src/jaguar.cpp +++ b/src/jaguar.cpp @@ -25,6 +25,7 @@ #include "dsp.h" #include "eeprom.h" #include "event.h" +#include "foooked.h" #include "gpu.h" #include "jerry.h" #include "joystick.h" @@ -44,6 +45,7 @@ #define CPU_DEBUG_MEMORY //#define LOG_CD_BIOS_CALLS #define CPU_DEBUG_TRACING +#define ALPINE_FUNCTIONS // Private function prototypes @@ -79,11 +81,30 @@ uint32_t returnAddr[4000], raPtr = 0xFFFFFFFF; #endif uint32_t pcQueue[0x400]; +uint32_t a0Queue[0x400]; +uint32_t a1Queue[0x400]; uint32_t a2Queue[0x400]; +uint32_t a3Queue[0x400]; +uint32_t a4Queue[0x400]; +uint32_t a5Queue[0x400]; +uint32_t a6Queue[0x400]; +uint32_t a7Queue[0x400]; uint32_t d0Queue[0x400]; +uint32_t d1Queue[0x400]; +uint32_t d2Queue[0x400]; +uint32_t d3Queue[0x400]; +uint32_t d4Queue[0x400]; +uint32_t d5Queue[0x400]; +uint32_t d6Queue[0x400]; +uint32_t d7Queue[0x400]; uint32_t pcQPtr = 0; bool startM68KTracing = false; +// Breakpoint on memory access vars (exported) +bool bpmActive = false; +uint32_t bpmAddress1; + + // // Callback function to detect illegal instructions // @@ -140,19 +161,34 @@ if (inRoutine) // For tracebacks... // Ideally, we'd save all the registers as well... pcQueue[pcQPtr] = m68kPC; + a0Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A0); + a1Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A1); a2Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A2); + a3Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A3); + a4Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A4); + a5Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A5); + a6Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A6); + a7Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_A7); d0Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D0); + d1Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D1); + d2Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D2); + d3Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D3); + d4Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D4); + d5Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D5); + d6Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D6); + d7Queue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_D7); pcQPtr++; 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"); + WriteLog("M68K: Attempted to execute from an odd address!\n\nBacktrace:\n\n"); static char buffer[2048]; for(int i=0; i<0x400; i++) { - WriteLog("[A2=%08X, D0=%08X]\n", a2Queue[(pcQPtr + i) & 0x3FF], d0Queue[(pcQPtr + i) & 0x3FF]); +// WriteLog("[A2=%08X, D0=%08X]\n", a2Queue[(pcQPtr + i) & 0x3FF], d0Queue[(pcQPtr + i) & 0x3FF]); + WriteLog("[A0=%08X, A1=%08X, A2=%08X, A3=%08X, A4=%08X, A5=%08X, A6=%08X, A7=%08X, D0=%08X, D1=%08X, D2=%08X, D3=%08X, D4=%08X, D5=%08X, D6=%08X, D7=%08X]\n", a0Queue[(pcQPtr + i) & 0x3FF], a1Queue[(pcQPtr + i) & 0x3FF], a2Queue[(pcQPtr + i) & 0x3FF], a3Queue[(pcQPtr + i) & 0x3FF], a4Queue[(pcQPtr + i) & 0x3FF], a5Queue[(pcQPtr + i) & 0x3FF], a6Queue[(pcQPtr + i) & 0x3FF], a7Queue[(pcQPtr + i) & 0x3FF], d0Queue[(pcQPtr + i) & 0x3FF], d1Queue[(pcQPtr + i) & 0x3FF], d2Queue[(pcQPtr + i) & 0x3FF], d3Queue[(pcQPtr + i) & 0x3FF], d4Queue[(pcQPtr + i) & 0x3FF], d5Queue[(pcQPtr + i) & 0x3FF], d6Queue[(pcQPtr + i) & 0x3FF], d7Queue[(pcQPtr + i) & 0x3FF]); m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], 0);//M68K_CPU_TYPE_68000); WriteLog("\t%08X: %s\n", pcQueue[(pcQPtr + i) & 0x3FF], buffer); } @@ -830,27 +866,33 @@ WriteLog("JERRY: (68K int en/lat - Unhandled!) Tried to write $%02X to $%08X!\n" ; // Do nothing } + void WriteWord(uint32_t adddress, uint16_t word) { } + void WriteDWord(uint32_t adddress, uint32_t dword) { } + uint8_t ReadByte(uint32_t adddress) { } + uint16_t ReadWord(uint32_t adddress) { } + uint32_t ReadDWord(uint32_t adddress) { } #endif + void ShowM68KContext(void) { printf("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC)); @@ -884,6 +926,7 @@ void ShowM68KContext(void) while (disPC < (currpc + 10)); } + // // Custom UAE 68000 read/write/IRQ functions // @@ -975,10 +1018,17 @@ int irq_ack_handler(int level) return M68K_INT_ACK_AUTOVECTOR; } + //#define USE_NEW_MMU unsigned int m68k_read_memory_8(unsigned int address) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // Musashi does this automagically for you, UAE core does not :-P address &= 0x00FFFFFF; #ifdef CPU_DEBUG_MEMORY @@ -1026,11 +1076,18 @@ unsigned int m68k_read_memory_8(unsigned int address) #endif } + void gpu_dump_disassembly(void); void gpu_dump_registers(void); unsigned int m68k_read_memory_16(unsigned int address) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // Musashi does this automagically for you, UAE core does not :-P address &= 0x00FFFFFF; #ifdef CPU_DEBUG_MEMORY @@ -1130,8 +1187,15 @@ unsigned int m68k_read_memory_16(unsigned int address) #endif } + unsigned int m68k_read_memory_32(unsigned int address) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // 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. @@ -1146,8 +1210,15 @@ unsigned int m68k_read_memory_32(unsigned int address) #endif } + void m68k_write_memory_8(unsigned int address, unsigned int value) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // Musashi does this automagically for you, UAE core does not :-P address &= 0x00FFFFFF; #ifdef CPU_DEBUG_MEMORY @@ -1196,8 +1267,15 @@ void m68k_write_memory_8(unsigned int address, unsigned int value) #endif } + void m68k_write_memory_16(unsigned int address, unsigned int value) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // Musashi does this automagically for you, UAE core does not :-P address &= 0x00FFFFFF; #ifdef CPU_DEBUG_MEMORY @@ -1284,8 +1362,15 @@ if (address == 0xF02110) #endif } + void m68k_write_memory_32(unsigned int address, unsigned int value) { +#ifdef ALPINE_FUNCTIONS + // Check if breakpoint on memory is active, and deal with it + if (bpmActive && address == bpmAddress1) + M68KDebugHalt(); +#endif + // Musashi does this automagically for you, UAE core does not :-P address &= 0x00FFFFFF; /*if (address == 0x4E00) @@ -1324,12 +1409,14 @@ uint32_t JaguarGetHandler(uint32_t i) return JaguarReadLong(i * 4); } + bool JaguarInterruptHandlerIsValid(uint32_t i) // Debug use only... { uint32_t handler = JaguarGetHandler(i); return (handler && (handler != 0xFFFFFFFF) ? true : false); } + void M68K_show_context(void) { WriteLog("68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC)); @@ -1382,6 +1469,7 @@ void M68K_show_context(void) } } + // // Unknown read/write byte/word routines // @@ -1416,6 +1504,7 @@ void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32_t who/*=UN #endif } + void jaguar_unknown_writeword(unsigned address, unsigned data, uint32_t who/*=UNKNOWN*/) { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES @@ -1430,6 +1519,7 @@ void jaguar_unknown_writeword(unsigned address, unsigned data, uint32_t who/*=UN #endif } + unsigned jaguar_unknown_readbyte(unsigned address, uint32_t who/*=UNKNOWN*/) { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES @@ -1445,6 +1535,7 @@ unsigned jaguar_unknown_readbyte(unsigned address, uint32_t who/*=UNKNOWN*/) return 0xFF; } + unsigned jaguar_unknown_readword(unsigned address, uint32_t who/*=UNKNOWN*/) { #ifdef LOG_UNMAPPED_MEMORY_ACCESSES @@ -1460,6 +1551,7 @@ unsigned jaguar_unknown_readword(unsigned address, uint32_t who/*=UNKNOWN*/) return 0xFFFF; } + // // Disassemble M68K instructions at the given offset // @@ -1469,16 +1561,19 @@ unsigned int m68k_read_disassembler_8(unsigned int address) return m68k_read_memory_8(address); } + unsigned int m68k_read_disassembler_16(unsigned int address) { return m68k_read_memory_16(address); } + unsigned int m68k_read_disassembler_32(unsigned int address) { return m68k_read_memory_32(address); } + void JaguarDasm(uint32_t offset, uint32_t qt) { #ifdef CPU_DEBUG @@ -1500,6 +1595,7 @@ void JaguarDasm(uint32_t offset, uint32_t qt) #endif } + uint8_t JaguarReadByte(uint32_t offset, uint32_t who/*=UNKNOWN*/) { uint8_t data = 0x00; @@ -1526,6 +1622,7 @@ uint8_t JaguarReadByte(uint32_t offset, uint32_t who/*=UNKNOWN*/) return data; } + uint16_t JaguarReadWord(uint32_t offset, uint32_t who/*=UNKNOWN*/) { offset &= 0xFFFFFF; @@ -1555,6 +1652,7 @@ uint16_t JaguarReadWord(uint32_t offset, uint32_t who/*=UNKNOWN*/) return jaguar_unknown_readword(offset, who); } + void JaguarWriteByte(uint32_t offset, uint8_t data, uint32_t who/*=UNKNOWN*/) { /* if (offset >= 0x4E00 && offset < 0x4E04) @@ -1591,6 +1689,7 @@ void JaguarWriteByte(uint32_t offset, uint8_t data, uint32_t who/*=UNKNOWN*/) jaguar_unknown_writebyte(offset, data, who); } + uint32_t starCount; void JaguarWriteWord(uint32_t offset, uint16_t data, uint32_t who/*=UNKNOWN*/) { @@ -1726,12 +1825,14 @@ if (offset == 0x11D31A + 0x48000 || offset == 0x11D31A) jaguar_unknown_writeword(offset, data, who); } + // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!! uint32_t JaguarReadLong(uint32_t offset, uint32_t who/*=UNKNOWN*/) { return (JaguarReadWord(offset, who) << 16) | JaguarReadWord(offset+2, who); } + // We really should re-do this so that it does *real* 32-bit access... !!! FIX !!! void JaguarWriteLong(uint32_t offset, uint32_t data, uint32_t who/*=UNKNOWN*/) { @@ -1748,18 +1849,21 @@ void JaguarWriteLong(uint32_t offset, uint32_t data, uint32_t who/*=UNKNOWN*/) JaguarWriteWord(offset+2, data & 0xFFFF, who); } + void JaguarSetScreenBuffer(uint32_t * buffer) { // This is in TOM, but we set it here... screenBuffer = buffer; } + void JaguarSetScreenPitch(uint32_t pitch) { // This is in TOM, but we set it here... screenPitch = pitch; } + // // Jaguar console initialization // @@ -2027,14 +2131,13 @@ void JaguarExecuteNew(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...) +// +// 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 doesn'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. @@ -2045,46 +2148,37 @@ void JaguarExecuteNew(void) // 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. +// 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_t vc = TOMReadWord(0xF00006, JAGUAR); uint16_t vp = TOMReadWord(0xF0003E, JAGUAR) + 1; uint16_t vi = TOMReadWord(0xF0004E, JAGUAR); // uint16_t vbb = TOMReadWord(0xF00040, JAGUAR); vc++; -#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_t 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; + lowerField = !lowerField; + // If we're rendering the lower field, set the high bit (#11, counting + // from 0) of VC + vc = (lowerField ? 0x0800 : 0x0000); } -//WriteLog("SLC: Currently on line %u (VP=%u)...\n", vc, vp); +//WriteLog("HLC: 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 & 0x7FF) == vi && (vc & 0x7FF) > 0 && TOMIRQEnabled(IRQ_VIDEO)) // Time for Vertical Interrupt? + // Time for Vertical Interrupt? + if ((vc & 0x7FF) == vi && (vc & 0x7FF) > 0 && TOMIRQEnabled(IRQ_VIDEO)) { // We don't have to worry about autovectors & whatnot because the Jaguar // tells you through its HW registers who sent the interrupt... @@ -2103,22 +2197,6 @@ void HalflineCallback(void) frameDone = true; }//*/ -#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... -/* -Nah, the scanline based code is good enough, and runs in 1 frame. The GUI -handles all the rest, so this isn't needed. :-P -*/ -void RenderCallback(void) -{ -// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time - SetCallbackTime(RenderCallback, 16651.541); // # Scanlines * scanline time -}