#include "jaguar.h"
+#include <time.h>
#include <SDL.h>
#include "SDL_opengl.h"
#include "blitter.h"
#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"
//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
#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
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];
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)));
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)
{
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)
#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();
#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)
*/
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...
*/
};
-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;
{
if (address == 0xF00050)
{
- tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | ((uint16)byte << 8);
+ tomTimerPrescaler = (tomTimerPrescaler & 0x00FF) | ((uint16_t)byte << 8);
TOMResetPIT();
return;
}
}
else if (address == 0xF00052)
{
- tomTimerDivider = (tomTimerDivider & 0x00FF) | ((uint16)byte << 8);
+ tomTimerDivider = (tomTimerDivider & 0x00FF) | ((uint16_t)byte << 8);
TOMResetPIT();
return;
}
{
// 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
; // 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));
while (disPC < (currpc + 10));
}
+
//
// Custom UAE 68000 read/write/IRQ functions
//
#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)
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
#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
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];
#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.
//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
#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 (startMemLog)
{
- uint8 hi = value >> 8, lo = value & 0xFF;
+ uint8_t hi = value >> 8, lo = value & 0xFF;
if (hi > writeMemMax[address])
writeMemMax[address] = hi;
// 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)
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))
#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)
}
-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));
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");
}
}
+
//
// 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
// 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));
#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));
#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));
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));
return 0xFFFF;
}
+
//
// Disassemble M68K instructions at the given offset
//
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<qt; i++)
+ for(uint32_t i=0; i<qt; i++)
{
/* oldpc = pc;
for(int j=0; j<64; j++)
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;
+uint8_t JaguarReadByte(uint32_t offset, uint32_t who/*=UNKNOWN*/)
+{
+ uint8_t data = 0x00;
offset &= 0xFFFFFF;
- if (offset < 0x200000)
- 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);
return data;
}
-uint16 JaguarReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
+
+uint16_t JaguarReadWord(uint32_t offset, uint32_t who/*=UNKNOWN*/)
{
offset &= 0xFFFFFF;
- if (offset <= 0x1FFFFE)
+
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset < 0x800000)
{
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];
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...
WriteLog("JWB: Byte %02X written at %08X by %s\n", data, offset, whoName[who]);//*/
offset &= 0xFFFFFF;
- if (offset < 0x200000)
+
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset < 0x800000)
{
jaguarMainRAM[offset & 0x1FFFFF] = data;
return;
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)
offset &= 0xFFFFFF;
- if (offset <= 0x1FFFFE)
+ // First 2M is mirrored in the $0 - $7FFFFF range
+ if (offset <= 0x7FFFFE)
{
/*
GPU Table (CD BIOS)
/*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"));
}//*/
/*
/*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;
// 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...
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)
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, 0x200000);
+// 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();
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
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);
//#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);
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();
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);
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;
}
if (vjs.GPUEnabled)
GPUExec(USEC_TO_RISC_CYCLES(timeToNextEvent));
-#ifndef NEW_DAC_CODE
- 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
- }
-#endif
-
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.
// 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...
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
-}
projects / virtualjaguar / blobdiff