X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fjaguar.cpp;h=f829892333e69db0c91109ae100b92c61b10b455;hb=a0fe543d62fa18a83c2c7d99d483ab5ea0f321b4;hp=b6c9f194ce4d80410e5732882db70d2ba53a6a6c;hpb=f30bf746981a99079e766b0d4e9de5391a4175ff;p=virtualjaguar diff --git a/src/jaguar.cpp b/src/jaguar.cpp index b6c9f19..f829892 100644 --- a/src/jaguar.cpp +++ b/src/jaguar.cpp @@ -16,6 +16,7 @@ #include "jaguar.h" +#include #include #include "SDL_opengl.h" #include "blitter.h" @@ -24,12 +25,14 @@ #include "dsp.h" #include "eeprom.h" #include "event.h" +#include "foooked.h" #include "gpu.h" #include "jerry.h" #include "joystick.h" #include "log.h" -#include "m68k.h" +#include "m68000/m68kinterface.h" //#include "memory.h" +#include "memtrack.h" #include "mmu.h" #include "settings.h" #include "tom.h" @@ -38,17 +41,19 @@ //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 +#define ALPINE_FUNCTIONS // Private function prototypes -unsigned jaguar_unknown_readbyte(unsigned address, uint32 who = UNKNOWN); -unsigned jaguar_unknown_readword(unsigned address, uint32 who = UNKNOWN); -void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who = UNKNOWN); -void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who = UNKNOWN); +unsigned jaguar_unknown_readbyte(unsigned address, uint32_t who = UNKNOWN); +unsigned jaguar_unknown_readword(unsigned address, uint32_t who = UNKNOWN); +void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32_t who = UNKNOWN); +void jaguar_unknown_writeword(unsigned address, unsigned data, uint32_t who = UNKNOWN); void M68K_show_context(void); // External variables @@ -60,24 +65,47 @@ extern int effect_start2, effect_start3, effect_start4, effect_start5, effect_st #endif // Really, need to include memory.h for this, but it might interfere with some stuff... -extern uint8 jagMemSpace[]; +extern uint8_t jagMemSpace[]; // Internal variables -uint32 jaguar_active_memory_dumps = 0; +uint32_t jaguar_active_memory_dumps = 0; -uint32 jaguarMainROMCRC32, jaguarROMSize, jaguarRunAddress; +uint32_t jaguarMainROMCRC32, jaguarROMSize, jaguarRunAddress; bool jaguarCartInserted = false; bool lowerField = false; #ifdef CPU_DEBUG_MEMORY -uint8 writeMemMax[0x400000], writeMemMin[0x400000]; -uint8 readMem[0x400000]; -uint32 returnAddr[4000], raPtr = 0xFFFFFFFF; +uint8_t writeMemMax[0x400000], writeMemMin[0x400000]; +uint8_t readMem[0x400000]; +uint32_t returnAddr[4000], raPtr = 0xFFFFFFFF; #endif -uint32 pcQueue[0x400]; -uint32 pcQPtr = 0; +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 srQueue[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 @@ -88,7 +116,7 @@ static bool start = false; void M68KInstructionHook(void) { - uint32 m68kPC = m68k_get_reg(NULL, M68K_REG_PC); + uint32_t m68kPC = m68k_get_reg(NULL, M68K_REG_PC); // Temp, for comparing... { /* static char buffer[2048];//, mem[64]; @@ -121,24 +149,55 @@ if (inRoutine) 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; + 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); + srQueue[pcQPtr] = m68k_get_reg(NULL, M68K_REG_SR); + 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++) { - m68k_disassemble(buffer, pcQueue[(pcQPtr + i) & 0x3FF], M68K_CPU_TYPE_68000); +// 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, SR=%04X]\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], srQueue[(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); } WriteLog("\n"); - uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7); + uint32_t 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))); @@ -174,17 +233,17 @@ if (inRoutine) log_done(); exit(0); }//*/ -/* uint16 opcode = JaguarReadWord(m68kPC); +/* uint16_t opcode = JaguarReadWord(m68kPC); if (opcode == 0x4E75) // RTS { if (startMemLog) // WriteLog("Jaguar: Returning from subroutine to %08X\n", JaguarReadLong(m68k_get_reg(NULL, M68K_REG_A7))); { - uint32 addr = JaguarReadLong(m68k_get_reg(NULL, M68K_REG_A7)); + uint32_t addr = JaguarReadLong(m68k_get_reg(NULL, M68K_REG_A7)); bool found = false; if (raPtr != 0xFFFFFFFF) { - for(uint32 i=0; i<=raPtr; i++) + for(uint32_t i=0; i<=raPtr; i++) { if (returnAddr[i] == addr) { @@ -270,16 +329,16 @@ if (m68kPC == 0x802058) start = true; 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) { @@ -356,7 +415,7 @@ CD_switch:: -> $306C #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) @@ -374,10 +433,23 @@ CD_switch:: -> $306C #endif WriteLog("\nM68K encountered an illegal instruction at %08X!!!\n\nAborting!\n", m68kPC); - uint32 topOfStack = m68k_get_reg(NULL, M68K_REG_A7); + uint32_t topOfStack = m68k_get_reg(NULL, M68K_REG_A7); WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack)); + uint32_t 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(); @@ -484,17 +556,17 @@ ADDRESS_MAP_END #define NEW_TIMER_SYSTEM /* -uint8 jaguarMainRAM[0x400000]; // 68K CPU RAM -uint8 jaguarMainROM[0x600000]; // 68K CPU ROM -uint8 jaguarBootROM[0x040000]; // 68K CPU BIOS ROM--uses only half of this! -uint8 jaguarCDBootROM[0x040000]; // 68K CPU CD BIOS ROM +uint8_t jaguarMainRAM[0x400000]; // 68K CPU RAM +uint8_t jaguarMainROM[0x600000]; // 68K CPU ROM +uint8_t jaguarBootROM[0x040000]; // 68K CPU BIOS ROM--uses only half of this! +uint8_t jaguarCDBootROM[0x040000]; // 68K CPU CD BIOS ROM bool BIOSLoaded = false; bool CDBIOSLoaded = false; -uint8 cdRAM[0x100]; -uint8 tomRAM[0x4000]; -uint8 jerryRAM[0x10000]; -static uint16 eeprom_ram[64]; +uint8_t cdRAM[0x100]; +uint8_t tomRAM[0x4000]; +uint8_t jerryRAM[0x10000]; +static uint16_t eeprom_ram[64]; // NOTE: CD BIOS ROM is read from cartridge space @ $802000 (it's a cartridge, after all) */ @@ -502,7 +574,7 @@ static uint16 eeprom_ram[64]; enum MemType { MM_NOP = 0, MM_RAM, MM_ROM, MM_IO }; // M68K Memory map/handlers -uint32 { +uint32_t { { 0x000000, 0x3FFFFF, MM_RAM, jaguarMainRAM }, { 0x800000, 0xDFFEFF, MM_ROM, jaguarMainROM }, // Note that this is really memory mapped I/O region... @@ -592,7 +664,7 @@ C3 = C2 = 1 means std. Jag. cntrlr. or nothing attached. */ }; -void WriteByte(uint32 address, uint8 byte, uint32 who/*=UNKNOWN*/) +void WriteByte(uint32_t address, uint8_t byte, uint32_t who/*=UNKNOWN*/) { // Not sure, but I think the system only has 24 address bits... address &= 0x00FFFFFF; @@ -628,7 +700,7 @@ void WriteByte(uint32 address, uint8 byte, uint32 who/*=UNKNOWN*/) { if (address == 0xF00050) { - tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | ((uint16)byte << 8); + tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | ((uint16_t)byte << 8); TOMResetPIT(); return; } @@ -640,7 +712,7 @@ void WriteByte(uint32 address, uint8 byte, uint32 who/*=UNKNOWN*/) } else if (address == 0xF00052) { - tomTimerDivider = (tomTimerDivider & 0x00FF) | ((uint16)byte << 8); + tomTimerDivider = (tomTimerDivider & 0x00FF) | ((uint16_t)byte << 8); TOMResetPIT(); return; } @@ -699,9 +771,9 @@ void WriteByte(uint32 address, uint8 byte, uint32 who/*=UNKNOWN*/) { // WriteLog("JERRY: Writing %02X to SCLK...\n", data); if ((address & 0x03) == 2) - JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0x00FF) | ((uint32)byte << 8); + JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0x00FF) | ((uint32_t)byte << 8); else - JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0xFF00) | (uint32)byte; + JERRYI2SInterruptDivide = (JERRYI2SInterruptDivide & 0xFF00) | (uint32_t)byte; JERRYI2SInterruptTimer = -1; #ifndef NEW_TIMER_SYSTEM @@ -797,27 +869,33 @@ WriteLog("JERRY: (68K int en/lat - Unhandled!) Tried to write $%02X to $%08X!\n" ; // Do nothing } -void WriteWord(uint32 adddress, uint16 word) + +void WriteWord(uint32_t adddress, uint16_t word) { } -void WriteDWord(uint32 adddress, uint32 dword) + +void WriteDWord(uint32_t adddress, uint32_t dword) { } -uint8 ReadByte(uint32 adddress) + +uint8_t ReadByte(uint32_t adddress) { } -uint16 ReadWord(uint32 adddress) + +uint16_t ReadWord(uint32_t adddress) { } -uint32 ReadDWord(uint32 adddress) + +uint32_t ReadDWord(uint32_t adddress) { } #endif + void ShowM68KContext(void) { printf("\t68K PC=%06X\n", m68k_get_reg(NULL, M68K_REG_PC)); @@ -851,8 +929,9 @@ void ShowM68KContext(void) while (disPC < (currpc + 10)); } + // -// Musashi 68000 read/write/IRQ functions +// Custom UAE 68000 read/write/IRQ functions // #if 0 @@ -916,14 +995,23 @@ handler: #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! // (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. + // 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. - // The GPU/DSP/etc are probably *not* issuing an NMI, but it seems to work OK... + // The GPU/DSP/etc are probably *not* issuing an NMI, but it seems to work + // OK... // They aren't, and this causes problems with a, err, specific ROM. :-D if (level == 2) @@ -935,14 +1023,22 @@ 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 - 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; @@ -956,7 +1052,8 @@ unsigned int m68k_read_memory_8(unsigned int address) #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)) @@ -984,11 +1081,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 @@ -1054,12 +1158,22 @@ unsigned int m68k_read_memory_16(unsigned int address) #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)) else if ((address >= 0x800000) && (address <= 0xDFFEFE)) - retVal = (jaguarMainROM[address - 0x800000] << 8) | jaguarMainROM[address - 0x800000 + 1]; + { + // Memory Track reading... + if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47)) + { + retVal = MTReadWord(address); + } + else + retVal = (jaguarMainROM[address - 0x800000] << 8) + | jaguarMainROM[address - 0x800000 + 1]; + } else if ((address >= 0xE00000) && (address <= 0xE3FFFE)) // retVal = (jaguarBootROM[address - 0xE00000] << 8) | jaguarBootROM[address - 0xE00000 + 1]; // retVal = (jaguarDevBootROM1[address - 0xE00000] << 8) | jaguarDevBootROM1[address - 0xE00000 + 1]; @@ -1087,8 +1201,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. @@ -1097,18 +1218,39 @@ unsigned int m68k_read_memory_32(unsigned int address) //WriteLog("--> [RM32]\n"); #ifndef USE_NEW_MMU - return (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2); + uint32_t retVal = 0; + + if ((address >= 0x800000) && (address <= 0xDFFEFE)) + { + // Memory Track reading... + if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47)) + retVal = MTReadLong(address); + else + retVal = GET32(jaguarMainROM, address - 0x800000); + + return retVal; + } + + return (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2); #else return MMURead32(address, M68K); #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 - if ((address >= 0x000000) && (address <= 0x3FFFFF)) + // Note that the Jaguar only has 2M of RAM, not 4! + if ((address >= 0x000000) && (address <= 0x1FFFFF)) { if (startMemLog) { @@ -1136,7 +1278,8 @@ void m68k_write_memory_8(unsigned int address, unsigned int value) 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); @@ -1151,16 +1294,24 @@ 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 - if ((address >= 0x000000) && (address <= 0x3FFFFE)) + // Note that the Jaguar only has 2M of RAM, not 4! + if ((address >= 0x000000) && (address <= 0x1FFFFE)) { if (startMemLog) { - uint8 hi = value >> 8, lo = value & 0xFF; + uint8_t hi = value >> 8, lo = value & 0xFF; if (hi > writeMemMax[address]) writeMemMax[address] = hi; @@ -1183,7 +1334,7 @@ void m68k_write_memory_16(unsigned int address, unsigned int value) // WriteLog("M68K: Writing to blitter --> %04X at %08X\n", value, address); //if (address >= 0x0E75D0 && address <= 0x0E75E7) // WriteLog("M68K: Writing %04X at %08X, M68K PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC)); -/*extern uint32 totalFrames; +/*extern uint32_t totalFrames; if (address == 0xF02114) WriteLog("M68K: Writing to GPU_CTRL (frame:%u)... [M68K PC:%08X]\n", totalFrames, m68k_get_reg(NULL, M68K_REG_PC)); if (address == 0xF02110) @@ -1211,12 +1362,19 @@ if (address == 0xF02110) }//*/ #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;*/ SET16(jaguarMainRAM, address, value); } + // Memory Track device writes.... + else if ((address >= 0x800000) && (address <= 0x87FFFE)) + { + if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47)) + MTWriteWord(address, value); + } else if ((address >= 0xDFFF00) && (address <= 0xDFFFFE)) CDROMWriteWord(address, value, M68K); else if ((address >= 0xF00000) && (address <= 0xF0FFFE)) @@ -1237,8 +1395,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) @@ -1272,17 +1437,19 @@ if (address == 0xF03214 && value == 0x88E30047) } -uint32 JaguarGetHandler(uint32 i) +uint32_t JaguarGetHandler(uint32_t i) { return JaguarReadLong(i * 4); } -bool JaguarInterruptHandlerIsValid(uint32 i) // Debug use only... + +bool JaguarInterruptHandlerIsValid(uint32_t i) // Debug use only... { - uint32 handler = JaguarGetHandler(i); + 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)); @@ -1326,7 +1493,7 @@ void M68K_show_context(void) for(int i=0; i<256; i++) { WriteLog("handler %03i at ", i);//$%08X\n", i, (unsigned int)JaguarGetHandler(i)); - uint32 address = (uint32)JaguarGetHandler(i); + uint32_t address = (uint32_t)JaguarGetHandler(i); if (address == 0) WriteLog(".........\n"); @@ -1335,12 +1502,14 @@ void M68K_show_context(void) } } + // // Unknown read/write byte/word routines // -// It's hard to believe that developers would be sloppy with their memory writes, yet in -// some cases the developers screwed up royal. E.g., Club Drive has the following code: +// It's hard to believe that developers would be sloppy with their memory +// writes, yet in some cases the developers screwed up royal. E.g., Club Drive +// has the following code: // // 807EC4: movea.l #$f1b000, A1 // 807ECA: movea.l #$8129e0, A0 @@ -1351,11 +1520,12 @@ void M68K_show_context(void) // 807EDC: move.l (A0)+, (A1)+ // 807EDE: dbra D1, 807edc // -// The problem is at $807ED0--instead of putting A0 into D0, they really meant to put A1 -// in. This mistake causes it to try and overwrite approximately $700000 worth of address -// space! (That is, unless the 68K causes a bus error...) +// The problem is at $807ED0--instead of putting A0 into D0, they really meant +// to put A1 in. This mistake causes it to try and overwrite approximately +// $700000 worth of address space! (That is, unless the 68K causes a bus +// error...) -void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/) +void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32_t who/*=UNKNOWN*/) { #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)); @@ -1369,7 +1539,8 @@ void jaguar_unknown_writebyte(unsigned address, unsigned data, uint32 who/*=UNKN #endif } -void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who/*=UNKNOWN*/) + +void jaguar_unknown_writeword(unsigned address, unsigned data, uint32_t who/*=UNKNOWN*/) { #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)); @@ -1383,7 +1554,8 @@ void jaguar_unknown_writeword(unsigned address, unsigned data, uint32 who/*=UNKN #endif } -unsigned jaguar_unknown_readbyte(unsigned address, uint32 who/*=UNKNOWN*/) + +unsigned jaguar_unknown_readbyte(unsigned address, uint32_t 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)); @@ -1398,7 +1570,8 @@ unsigned jaguar_unknown_readbyte(unsigned address, uint32 who/*=UNKNOWN*/) return 0xFF; } -unsigned jaguar_unknown_readword(unsigned address, uint32 who/*=UNKNOWN*/) + +unsigned jaguar_unknown_readword(unsigned address, uint32_t 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)); @@ -1413,6 +1586,7 @@ unsigned jaguar_unknown_readword(unsigned address, uint32 who/*=UNKNOWN*/) return 0xFFFF; } + // // Disassemble M68K instructions at the given offset // @@ -1422,23 +1596,26 @@ 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 offset, uint32 qt) + +void JaguarDasm(uint32_t offset, uint32_t qt) { #ifdef CPU_DEBUG static char buffer[2048];//, mem[64]; int pc = offset, oldpc; - for(uint32 i=0; i= 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); @@ -1478,14 +1657,17 @@ uint8 JaguarReadByte(uint32 offset, uint32 who/*=UNKNOWN*/) return data; } -uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/) + +uint16_t JaguarReadWord(uint32_t offset, uint32_t 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]; @@ -1505,8 +1687,13 @@ uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/) return jaguar_unknown_readword(offset, who); } -void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/) + +void JaguarWriteByte(uint32_t offset, uint8_t data, uint32_t who/*=UNKNOWN*/) { +/* if ((offset & 0x1FFFFF) >= 0xE00 && (offset & 0x1FFFFF) < 0xE18) + { + WriteLog("JWB: Byte %02X written at %08X by %s\n", data, offset, whoName[who]); + }//*/ /* if (offset >= 0x4E00 && offset < 0x4E04) WriteLog("JWB: Byte %02X written at %08X by %s\n", data, offset, whoName[who]);//*/ //Need to check for writes in the range of $18FA70 + 8000... @@ -1515,9 +1702,11 @@ void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/) 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)) @@ -1539,9 +1728,15 @@ void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/) jaguar_unknown_writebyte(offset, data, who); } -uint32 starCount; -void JaguarWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/) + +uint32_t starCount; +void JaguarWriteWord(uint32_t offset, uint16_t data, uint32_t who/*=UNKNOWN*/) { +/* if ((offset & 0x1FFFFF) >= 0xE00 && (offset & 0x1FFFFF) < 0xE18) + { + WriteLog("JWW: Word %04X written at %08X by %s\n", data, offset, whoName[who]); + WriteLog(" GPU PC = $%06X\n", GPUReadLong(0xF02110, DEBUG)); + }//*/ /* if (offset >= 0x4E00 && offset < 0x4E04) WriteLog("JWW: Word %04X written at %08X by %s\n", data, offset, whoName[who]);//*/ /*if (offset == 0x0100)//64*4) @@ -1559,7 +1754,8 @@ if (offset == 0x0102)//64*4) offset &= 0xFFFFFF; - if (offset <= 0x3FFFFE) + // First 2M is mirrored in the $0 - $7FFFFF range + if (offset <= 0x7FFFFE) { /* GPU Table (CD BIOS) @@ -1599,12 +1795,12 @@ if ((data & 0xFF00) != 0x7700) /*extern bool doGPUDis; if (offset == 0x120216 && who == GPU) doGPUDis = true;//*/ -/*extern uint32 gpu_pc; +/*extern uint32_t gpu_pc; if (who == GPU && (gpu_pc == 0xF03604 || gpu_pc == 0xF03638)) { - uint32 base = offset - (offset > 0x148000 ? 0x148000 : 0x100000); - uint32 y = base / 0x300; - uint32 x = (base - (y * 0x300)) / 2; + uint32_t base = offset - (offset > 0x148000 ? 0x148000 : 0x100000); + uint32_t y = base / 0x300; + uint32_t x = (base - (y * 0x300)) / 2; WriteLog("JWW: Writing starfield star %04X at %08X (%u/%u) [%s]\n", data, offset, x, y, (gpu_pc == 0xF03604 ? "s" : "L")); }//*/ /* @@ -1614,7 +1810,7 @@ JWW: Writing starfield star 775E at 0011F650 (555984/1447) /*if (who == GPU && offset == (0x001E17F8 + 0x34)) data = 0xFE3C;//*/ // WriteLog("JWW: Write at %08X written to by %s.\n", 0x001E17F8 + 0x34, whoName[who]);//*/ -/*extern uint32 gpu_pc; +/*extern uint32_t gpu_pc; if (who == GPU && (gpu_pc == 0xF03604 || gpu_pc == 0xF03638)) { extern int objectPtr; @@ -1627,9 +1823,9 @@ if (who == GPU && (gpu_pc == 0xF03604 || gpu_pc == 0xF03638)) // if (starCount == 1) // WriteLog("--> Drawing 1st star...\n"); // -// uint32 base = offset - (offset > 0x148000 ? 0x148000 : 0x100000); -// uint32 y = base / 0x300; -// uint32 x = (base - (y * 0x300)) / 2; +// uint32_t base = offset - (offset > 0x148000 ? 0x148000 : 0x100000); +// uint32_t y = base / 0x300; +// uint32_t x = (base - (y * 0x300)) / 2; // WriteLog("JWW: Writing starfield star %04X at %08X (%u/%u) [%s]\n", data, offset, x, y, (gpu_pc == 0xF03604 ? "s" : "L")); //A star of interest... @@ -1647,8 +1843,8 @@ if (who == GPU && (gpu_pc == 0xF03604 || gpu_pc == 0xF03638)) 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) @@ -1673,14 +1869,16 @@ 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 JaguarReadLong(uint32 offset, uint32 who/*=UNKNOWN*/) +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 offset, uint32 data, uint32 who/*=UNKNOWN*/) +void JaguarWriteLong(uint32_t offset, uint32_t data, uint32_t who/*=UNKNOWN*/) { /* extern bool doDSPDis; if (offset < 0x400 && !doDSPDis) @@ -1695,39 +1893,50 @@ void JaguarWriteLong(uint32 offset, uint32 data, uint32 who/*=UNKNOWN*/) JaguarWriteWord(offset+2, data & 0xFFFF, who); } -void JaguarSetScreenBuffer(uint32 * buffer) + +void JaguarSetScreenBuffer(uint32_t * buffer) { // This is in TOM, but we set it here... screenBuffer = buffer; } -void JaguarSetScreenPitch(uint32 pitch) + +void JaguarSetScreenPitch(uint32_t pitch) { // This is in TOM, but we set it here... screenPitch = pitch; } + // // Jaguar console initialization // void JaguarInit(void) { + // For randomizing RAM + srand(time(NULL)); + + // Contents of local RAM are quasi-stable; we simulate this by randomizing RAM contents + for(uint32_t i=0; i<0x200000; i+=4) + *((uint32_t *)(&jaguarMainRAM[i])) = rand(); + #ifdef CPU_DEBUG_MEMORY memset(readMem, 0x00, 0x400000); 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... //Or does it? Hmm... //Seems to want $01010101... Dunno why. Investigate! - memset(jaguarMainROM, 0x01, 0x600000); // & set it to all 01s... +// 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(); @@ -1736,11 +1945,19 @@ void JaguarInit(void) CDROMInit(); } + //New timer based code stuffola... void HalflineCallback(void); void RenderCallback(void); void JaguarReset(void) { + // Only problem with this approach: It wipes out RAM loaded files...! + // Contents of local RAM are quasi-stable; we simulate this by randomizing RAM contents + for(uint32_t i=8; i<0x200000; i+=4) + *((uint32_t *)(&jaguarMainRAM[i])) = rand(); + + // 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 @@ -1761,19 +1978,18 @@ void JaguarReset(void) 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)); } + void JaguarDone(void) { #ifdef CPU_DEBUG_MEMORY /* WriteLog("\nJaguar: Memory Usage Stats (return addresses)\n\n"); - for(uint32 i=0; i<=raPtr; i++) + for(uint32_t i=0; i<=raPtr; i++) { WriteLog("\t%08X\n", returnAddr[i]); WriteLog("M68000 disassembly at $%08X...\n", returnAddr[i] - 16); @@ -1807,10 +2023,27 @@ void JaguarDone(void) //#ifdef CPU_DEBUG // 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)); + int32_t topOfStack = m68k_get_reg(NULL, M68K_REG_A7); + 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_t 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); @@ -1848,12 +2081,6 @@ void JaguarDone(void) M68K_show_context(); //#endif -#if 0 // This is drawn already... - WriteLog("Jaguar: 68K AutoVector table:\n", JaguarReadWord(0x3004)); - for(uint32 i=0x64; i<=0x7C; i+=4) - WriteLog(" #%u: %08X\n", (i-0x64)/4, JaguarReadLong(i)); -#endif - CDROMDone(); GPUDone(); DSPDone(); @@ -1891,100 +2118,17 @@ void JaguarDone(void) 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(0x800830, 0x1000); +// 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 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 @@ -1995,15 +2139,17 @@ void DumpMainMemory(void) if (fp == NULL) return; - fwrite(jaguarMainRAM, 1, 0x400000, fp); + fwrite(jaguarMainRAM, 1, 0x200000, fp); fclose(fp); } -uint8 * GetRamPtr(void) + +uint8_t * GetRamPtr(void) { return jaguarMainRAM; } + // // New Jaguar execution stack // This executes 1 frame's worth of code. @@ -2023,27 +2169,19 @@ void JaguarExecuteNew(void) 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 -// 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. @@ -2054,46 +2192,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 +// 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); + 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 numHalfLines = ((vjs.hardwareTypeNTSC ? 525 : 625) * 2) / 2; + 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... @@ -2112,21 +2241,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 -}