// GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Carwin Jones (BeOS)
// Cleanups and endian wrongness amelioration by James L. Hammons
// Note: Endian wrongness probably stems from the MAME origins of this emu and
-// the braindead way in which MAME handles memory. :-)
+// the braindead way in which MAME handled memory when this was written. :-)
+//
+// JLH = James L. Hammons
+//
+// WHO WHEN WHAT
+// --- ---------- -----------------------------------------------------------
+// JLH 11/25/2009 Major rewrite of memory subsystem and handlers
//
#include "jaguar.h"
#include <SDL.h>
#include "SDL_opengl.h"
+#include "blitter.h"
#include "cdrom.h"
+#include "dac.h"
#include "dsp.h"
+#include "eeprom.h"
#include "event.h"
#include "gpu.h"
-#include "gui.h"
#include "jerry.h"
#include "joystick.h"
#include "log.h"
#include "m68k.h"
-#include "memory.h"
+//#include "memory.h"
+#include "mmu.h"
#include "settings.h"
#include "tom.h"
-#include "video.h"
-#include "blitter.h"
-#include "jerry.h"
-#include "dac.h"
-#include "eeprom.h"
#define CPU_DEBUG
//Do this in makefile??? Yes! Could, but it's easier to define here...
#define ABORT_ON_ILLEGAL_INSTRUCTIONS
//#define ABORT_ON_OFFICIAL_ILLEGAL_INSTRUCTION
#define CPU_DEBUG_MEMORY
+//#define LOG_CD_BIOS_CALLS
// Private function prototypes
extern int effect_start2, effect_start3, effect_start4, effect_start5, effect_start6;
#endif
-// Memory debugging identifiers
+// Really, need to include memory.h for this, but it might interfere with some stuff...
+extern uint8 jagMemSpace[];
-const char * whoName[9] =
- { "Unknown", "Jaguar", "DSP", "GPU", "TOM", "JERRY", "M68K", "Blitter", "OP" };
+// Internal variables
uint32 jaguar_active_memory_dumps = 0;
uint32 jaguarMainROMCRC32, jaguarROMSize, jaguarRunAddress;
-
-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
-bool BIOSLoaded = false;
-bool CDBIOSLoaded = false;
-
-//uint8 cdRAM[0x100];
-uint8 * cdRAM = &jaguarMainROM[0x5FFF00];
-uint8 tomRAM[0x4000];
-uint8 jerryRAM[0x10000];
+bool jaguarCartInserted = false;
#ifdef CPU_DEBUG_MEMORY
uint8 writeMemMax[0x400000], writeMemMin[0x400000];
WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
for(int i=0; i<10; i++)
WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4)));
- WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VBLANK)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
+ WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VIDEO)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
M68K_show_context();
LogDone();
exit(0);
}
+ // Disassemble everything
+/* {
+ static char buffer[2048];
+ m68k_disassemble(buffer, m68kPC, M68K_CPU_TYPE_68000);
+ WriteLog("%08X: %s", m68kPC, buffer);
+ WriteLog("\t\tA0=%08X, A1=%08X, D0=%08X, D1=%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));
+ }//*/
/* if (m68kPC >= 0x807EC4 && m68kPC <= 0x807EDB)
{
static char buffer[2048];
WriteLog("--> [Calling BusWrite2] D2: %08X\n", m68k_get_reg(NULL, M68K_REG_D2));
// m68k_set_reg(M68K_REG_D2, 0x12345678);
}//*/
+
+#ifdef LOG_CD_BIOS_CALLS
/*
CD_init:: -> $3000
BIOS_VER:: -> $3004
WriteLog("\t\tA0=%08X, A1=%08X, D0=%08X, D1=%08X, 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));
-//*/
+#endif
+
#ifdef ABORT_ON_ILLEGAL_INSTRUCTIONS
if (!m68k_is_valid_instruction(m68k_read_memory_16(m68kPC), M68K_CPU_TYPE_68000))
{
WriteLog("M68K: Top of stack: %08X. Stack trace:\n", JaguarReadLong(topOfStack));
for(int i=0; i<10; i++)
WriteLog("%06X: %08X\n", topOfStack - (i * 4), JaguarReadLong(topOfStack - (i * 4)));
- WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VBLANK)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
+ WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VIDEO)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
M68K_show_context();
//temp
*/
#endif
-#define EXPERIMENTAL_MEMORY_HANDLING
+//#define EXPERIMENTAL_MEMORY_HANDLING
// Experimental memory mappage...
// Dunno if this is a good approach or not, but it seems to make better
// sense to have all this crap in one spot intstead of scattered all over
// Musashi 68000 read/write/IRQ functions
//
+#if 0
+IRQs:
+=-=-=
+
+ IPL Name Vector Control
+ ---------+---------------+---------------+---------------
+ 2 VBLANK IRQ $100 INT1 bit #0
+ 2 GPU IRQ $100 INT1 bit #1
+ 2 HBLANK IRQ $100 INT1 bit #2
+ 2 Timer IRQ $100 INT1 bit #3
+
+ Note: Both timer interrupts (JPIT && PIT) are on the same INT1 bit.
+ and are therefore indistinguishable.
+
+ A typical way to install a LEVEL2 handler for the 68000 would be
+ something like this, you gotta supply "last_line" and "handler".
+ Note that the interrupt is auto vectored thru $100 (not $68)
+
+
+ V_AUTO = $100
+ VI = $F004E
+ INT1 = $F00E0
+ INT2 = $F00E2
+
+ IRQS_HANDLED=$909 ;; VBLANK and TIMER
+
+ move.w #$2700,sr ;; no IRQs please
+ move.l #handler,V_AUTO ;; install our routine
+
+ move.w #last_line,VI ;; scanline where IRQ should occur
+ ;; should be 'odd' BTW
+ move.w #IRQS_HANDLE&$FF,INT1 ;; enable VBLANK + TIMER
+ move.w #$2100,sr ;; enable IRQs on the 68K
+ ...
+
+handler:
+ move.w d0,-(a7)
+ move.w INT1,d0
+ btst.b #0,d0
+ bne.b .no_blank
+
+ ...
+
+.no_blank:
+ btst.b #3,d0
+ beq.b .no_timer
+
+ ...
+
+.no_timer:
+ move.w #IRQS_HANDLED,INT1 ; clear latch, keep IRQ alive
+ move.w #0,INT2 ; let GPU run again
+ move.w (a7)+,d0
+ rte
+
+ As you can see, if you have multiple INT1 interrupts coming in,
+ you need to check the lower byte of INT1, to see which interrupt
+ happened.
+#endif
int irq_ack_handler(int level)
{
- int vector = M68K_INT_ACK_AUTOVECTOR;
+ // 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 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.
// 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 == 7)
+ if (level == 2)
{
- m68k_set_irq(0); // Clear the IRQ...
- vector = 64; // Set user interrupt #0
+ m68k_set_irq(0); // Clear the IRQ (NOTE: Without this, the BIOS fails)...
+ return 64; // Set user interrupt #0
}
- return vector;
+ return M68K_INT_ACK_AUTOVECTOR;
}
+//#define USE_NEW_MMU
+
unsigned int m68k_read_memory_8(unsigned int address)
{
#ifdef CPU_DEBUG_MEMORY
/* if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
|| address == 0x1AF05E)
WriteLog("[RM8 PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, jaguar_mainRam[address]);//*/
+#ifndef USE_NEW_MMU
unsigned int retVal = 0;
if ((address >= 0x000000) && (address <= 0x3FFFFF))
- retVal = jaguarMainRam[address];
+ retVal = jaguarMainRAM[address];
// else if ((address >= 0x800000) && (address <= 0xDFFFFF))
else if ((address >= 0x800000) && (address <= 0xDFFEFF))
- retVal = jaguarMainRom[address - 0x800000];
+ retVal = jaguarMainROM[address - 0x800000];
else if ((address >= 0xE00000) && (address <= 0xE3FFFF))
- retVal = jaguarBootRom[address - 0xE00000];
+// retVal = jaguarBootROM[address - 0xE00000];
+// retVal = jaguarDevBootROM1[address - 0xE00000];
+ retVal = jagMemSpace[address];
else if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
retVal = CDROMReadByte(address);
else if ((address >= 0xF00000) && (address <= 0xF0FFFF))
//if (address >= 0x8B5E4 && address <= 0x8B5E4 + 16)
// WriteLog("M68K: Read byte $%02X at $%08X [PC=%08X]\n", retVal, address, m68k_get_reg(NULL, M68K_REG_PC));
return retVal;
+#else
+ return MMURead8(address, M68K);
+#endif
}
void gpu_dump_disassembly(void);
/* if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
|| address == 0x1AF05E)
WriteLog("[RM16 PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, GET16(jaguar_mainRam, address));//*/
+#ifndef USE_NEW_MMU
unsigned int retVal = 0;
if ((address >= 0x000000) && (address <= 0x3FFFFE))
// retVal = (jaguar_mainRam[address] << 8) | jaguar_mainRam[address+1];
- retVal = GET16(jaguarMainRam, address);
+ 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];
+ 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 = (jaguarBootROM[address - 0xE00000] << 8) | jaguarBootROM[address - 0xE00000 + 1];
+// retVal = (jaguarDevBootROM1[address - 0xE00000] << 8) | jaguarDevBootROM1[address - 0xE00000 + 1];
+ retVal = (jagMemSpace[address] << 8) | jagMemSpace[address + 1];
else if ((address >= 0xDFFF00) && (address <= 0xDFFFFE))
retVal = CDROMReadWord(address, M68K);
else if ((address >= 0xF00000) && (address <= 0xF0FFFE))
//if (address >= 0x8B5E4 && address <= 0x8B5E4 + 16)
// WriteLog("M68K: Read word $%04X at $%08X [PC=%08X]\n", retVal, address, m68k_get_reg(NULL, M68K_REG_PC));
return retVal;
+#else
+ return MMURead16(address, M68K);
+#endif
}
unsigned int m68k_read_memory_32(unsigned int address)
WriteLog("[RM32 PC=%08X] Addr: %08X, val: %08X\n", m68k_get_reg(NULL, M68K_REG_PC), address, (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2));//*/
//WriteLog("--> [RM32]\n");
+#ifndef USE_NEW_MMU
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)
}
}
#endif
+/*if (address == 0x4E00)
+ WriteLog("M68K: Writing %02X at %08X, PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
//if ((address >= 0x1FF020 && address <= 0x1FF03F) || (address >= 0x1FF820 && address <= 0x1FF83F))
// WriteLog("M68K: Writing %02X at %08X\n", value, address);
//WriteLog("[WM8 PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);
if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
WriteLog("M68K: Byte %02X written at %08X by 68K\n", value, address);//*/
+#ifndef USE_NEW_MMU
if ((address >= 0x000000) && (address <= 0x3FFFFF))
- jaguarMainRam[address] = value;
+ jaguarMainRAM[address] = value;
else if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
CDROMWriteByte(address, value, M68K);
else if ((address >= 0xF00000) && (address <= 0xF0FFFF))
JERRYWriteByte(address, value, M68K);
else
jaguar_unknown_writebyte(address, value, M68K);
+#else
+ MMUWrite8(address, value, M68K);
+#endif
}
void m68k_write_memory_16(unsigned int address, unsigned int value)
}
}
#endif
+/*if (address == 0x4E00)
+ WriteLog("M68K: Writing %02X at %08X, PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
//if ((address >= 0x1FF020 && address <= 0x1FF03F) || (address >= 0x1FF820 && address <= 0x1FF83F))
// WriteLog("M68K: Writing %04X at %08X\n", value, address);
//WriteLog("[WM16 PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);
|| address == 0x1AF05E)
WriteLog("[WM16 PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+#ifndef USE_NEW_MMU
if ((address >= 0x000000) && (address <= 0x3FFFFE))
{
/* jaguar_mainRam[address] = value >> 8;
jaguar_mainRam[address + 1] = value & 0xFF;*/
- SET16(jaguarMainRam, address, value);
+ SET16(jaguarMainRAM, address, value);
}
else if ((address >= 0xDFFF00) && (address <= 0xDFFFFE))
CDROMWriteWord(address, value, M68K);
m68k_get_reg(NULL, M68K_REG_D0), m68k_get_reg(NULL, M68K_REG_D1));
#endif
}
+#else
+ MMUWrite16(address, value, M68K);
+#endif
}
void m68k_write_memory_32(unsigned int address, unsigned int value)
{
+/*if (address == 0x4E00)
+ WriteLog("M68K: Writing %02X at %08X, PC=%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
//WriteLog("--> [WM32]\n");
/*if (address == 0x0100)//64*4)
WriteLog("M68K: Wrote dword to VI vector value %08X...\n", value);//*/
/* if (address == 0x51136 || address == 0xFB074)
WriteLog("[WM32 PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+#ifndef USE_NEW_MMU
m68k_write_memory_16(address, value >> 16);
m68k_write_memory_16(address + 2, value & 0xFFFF);
+#else
+ MMUWrite32(address, value, M68K);
+#endif
}
WriteLog("..................\n");
- if (TOMIRQEnabled(IRQ_VBLANK))
+ if (TOMIRQEnabled(IRQ_VIDEO))
{
- WriteLog("vblank int: enabled\n");
+ WriteLog("video int: enabled\n");
JaguarDasm(JaguarGetHandler(64), 0x200);
}
else
- WriteLog("vblank int: disabled\n");
+ WriteLog("video int: disabled\n");
WriteLog("..................\n");
for(int i=0; i<256; i++)
- WriteLog("handler %03i at $%08X\n", i, (unsigned int)JaguarGetHandler(i));
+ {
+ WriteLog("handler %03i at ", i);//$%08X\n", i, (unsigned int)JaguarGetHandler(i));
+ uint32 address = (uint32)JaguarGetHandler(i);
+
+ if (address == 0)
+ WriteLog(".........\n");
+ else
+ WriteLog("$%08X\n", address);
+ }
}
//
offset &= 0xFFFFFF;
if (offset < 0x400000)
- data = jaguarMainRam[offset & 0x3FFFFF];
+ data = jaguarMainRAM[offset & 0x3FFFFF];
else if ((offset >= 0x800000) && (offset < 0xC00000))
- data = jaguarMainRom[offset - 0x800000];
+ data = jaguarMainROM[offset - 0x800000];
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
data = CDROMReadByte(offset, who);
else if ((offset >= 0xE00000) && (offset < 0xE40000))
- data = jaguarBootRom[offset & 0x3FFFF];
+// data = jaguarBootROM[offset & 0x3FFFF];
+// data = jaguarDevBootROM1[offset & 0x3FFFF];
+ data = jagMemSpace[offset];
else if ((offset >= 0xF00000) && (offset < 0xF10000))
data = TOMReadByte(offset, who);
else if ((offset >= 0xF10000) && (offset < 0xF20000))
offset &= 0xFFFFFF;
if (offset <= 0x3FFFFE)
{
- return (jaguarMainRam[(offset+0) & 0x3FFFFF] << 8) | jaguarMainRam[(offset+1) & 0x3FFFFF];
+ return (jaguarMainRAM[(offset+0) & 0x3FFFFF] << 8) | jaguarMainRAM[(offset+1) & 0x3FFFFF];
}
else if ((offset >= 0x800000) && (offset <= 0xBFFFFE))
{
offset -= 0x800000;
- return (jaguarMainRom[offset+0] << 8) | jaguarMainRom[offset+1];
+ return (jaguarMainROM[offset+0] << 8) | jaguarMainROM[offset+1];
}
// else if ((offset >= 0xDFFF00) && (offset < 0xDFFF00))
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFE))
return CDROMReadWord(offset, who);
else if ((offset >= 0xE00000) && (offset <= 0xE3FFFE))
- return (jaguarBootRom[(offset+0) & 0x3FFFF] << 8) | jaguarBootRom[(offset+1) & 0x3FFFF];
+// return (jaguarBootROM[(offset+0) & 0x3FFFF] << 8) | jaguarBootROM[(offset+1) & 0x3FFFF];
+// return (jaguarDevBootROM1[(offset+0) & 0x3FFFF] << 8) | jaguarDevBootROM1[(offset+1) & 0x3FFFF];
+ return (jagMemSpace[offset + 0] << 8) | jagMemSpace[offset + 1];
else if ((offset >= 0xF00000) && (offset <= 0xF0FFFE))
return TOMReadWord(offset, who);
else if ((offset >= 0xF10000) && (offset <= 0xF1FFFE))
void JaguarWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
{
+/* 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...
/*if (effect_start)
if (offset >= 0x18FA70 && offset < (0x18FA70 + 8000))
offset &= 0xFFFFFF;
if (offset < 0x400000)
{
- jaguarMainRam[offset & 0x3FFFFF] = data;
+ jaguarMainRAM[offset & 0x3FFFFF] = data;
return;
}
else if ((offset >= 0xDFFF00) && (offset <= 0xDFFFFF))
uint32 starCount;
void JaguarWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
{
+/* if (offset >= 0x4E00 && offset < 0x4E04)
+ WriteLog("JWW: Word %04X written at %08X by %s\n", data, offset, whoName[who]);//*/
/*if (offset == 0x0100)//64*4)
WriteLog("M68K: %s wrote word to VI vector value %04X...\n", whoName[who], data);
if (offset == 0x0102)//64*4)
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) & 0x3FFFFF] = data >> 8;
+ jaguarMainRAM[(offset+1) & 0x3FFFFF] = data & 0xFF;
return;
}
else if (offset >= 0xDFFF00 && offset <= 0xDFFFFE)
JaguarWriteWord(offset+2, data & 0xFFFF, who);
}
+void JaguarSetScreenBuffer(uint32 * buffer)
+{
+ // This is in TOM, but we set it here...
+ screenBuffer = buffer;
+}
+
+void JaguarSetScreenPitch(uint32 pitch)
+{
+ // This is in TOM, but we set it here...
+ screenPitch = pitch;
+}
+
//
// Jaguar console initialization
//
memset(writeMemMin, 0xFF, 0x400000);
memset(writeMemMax, 0x00, 0x400000);
#endif
- memset(jaguarMainRam, 0x00, 0x400000);
+ memset(jaguarMainRAM, 0x00, 0x400000);
// memset(jaguar_mainRom, 0xFF, 0x200000); // & set it to all Fs...
// memset(jaguar_mainRom, 0x00, 0x200000); // & set it to all 0s...
//NOTE: This *doesn't* fix FlipOut...
//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...
m68k_set_cpu_type(M68K_CPU_TYPE_68000);
//New timer based code stuffola...
void ScanlineCallback(void);
void RenderCallback(void);
-//extern uint32 * backbuffer;
void JaguarReset(void)
{
-//NOTE: This causes a (virtual) crash if this is set in the config but not found... !!! FIX !!!
- if (vjs.useJaguarBIOS)
- memcpy(jaguarMainRam, jaguarBootRom, 8);
+//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
+ // Only use the system BIOS if it's available...! (it's always available now!)
+ // AND only if a jaguar cartridge has been inserted.
+ if (vjs.useJaguarBIOS && jaguarCartInserted && !vjs.hardwareTypeAlpine)
+ memcpy(jaguarMainRAM, jagMemSpace + 0xE00000, 8);
else
- SET32(jaguarMainRam, 4, jaguarRunAddress);
+ SET32(jaguarMainRAM, 4, jaguarRunAddress);
// WriteLog("jaguar_reset():\n");
TOMReset();
// New timer base code stuffola...
InitializeEventList();
- TOMResetBackbuffer(backbuffer);
// SetCallbackTime(ScanlineCallback, 63.5555);
SetCallbackTime(ScanlineCallback, 31.77775);
// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time
WriteLog("\n");//*/
// WriteLog("Jaguar: CD BIOS version %04X\n", JaguarReadWord(0x3004));
- WriteLog("Jaguar: Interrupt enable = %02X\n", TOMReadByte(0xF000E1) & 0x1F);
- WriteLog("Jaguar: VBL interrupt is %s\n", ((TOMIRQEnabled(IRQ_VBLANK)) && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled");
+ WriteLog("Jaguar: Interrupt enable = $%02X\n", TOMReadByte(0xF000E1, JAGUAR) & 0x1F);
+ WriteLog("Jaguar: Video interrupt is %s (line=%u)\n", ((TOMIRQEnabled(IRQ_VIDEO))
+ && (JaguarInterruptHandlerIsValid(64))) ? "enabled" : "disabled", TOMReadWord(0xF0004E, JAGUAR));
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();
TOMDone();
JERRYDone();
+
+ // temp, until debugger is in place
+//00802016: jsr $836F1A.l
+//0080201C: jsr $836B30.l
+//00802022: jsr $836B18.l
+//00802028: jsr $8135F0.l
+//00813C1E: jsr $813F76.l
+//00802038: jsr $836D00.l
+//00802098: jsr $8373A4.l
+//008020A2: jsr $83E24A.l
+//008020BA: jsr $83E156.l
+//008020C6: jsr $83E19C.l
+//008020E6: jsr $8445E8.l
+//008020EC: jsr $838C20.l
+//0080211A: jsr $838ED6.l
+//00802124: jsr $89CA56.l
+//0080212A: jsr $802B48.l
+#if 0
+ WriteLog("-------------------------------------------\n");
+ JaguarDasm(0x8445E8, 0x200);
+ WriteLog("-------------------------------------------\n");
+ JaguarDasm(0x838C20, 0x200);
+ WriteLog("-------------------------------------------\n");
+ JaguarDasm(0x838ED6, 0x200);
+ WriteLog("-------------------------------------------\n");
+ JaguarDasm(0x89CA56, 0x200);
+ WriteLog("-------------------------------------------\n");
+ JaguarDasm(0x802B48, 0x200);
+ WriteLog("\n\nM68000 disassembly at $802000...\n");
+ JaguarDasm(0x802000, 6000);
+ WriteLog("\n");//*/
+#endif
+/* WriteLog("\n\nM68000 disassembly at $080000...\n");
+ JaguarDasm(0x080000, 10000);
+ WriteLog("\n");//*/
}
//
//
void JaguarExecute(uint32 * backbuffer, bool render)
{
- uint16 vp = TOMReadWord(0xF0003E) + 1;
- uint16 vi = TOMReadWord(0xF0004E);
+ 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);
+// 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);
+// 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);
+// uint16 vde = TOMReadWord(0xF00048, JAGUAR);
uint16 refreshRate = (vjs.hardwareTypeNTSC ? 60 : 50);
uint32 m68kClockRate = (vjs.hardwareTypeNTSC ? M68K_CLOCK_RATE_NTSC : M68K_CLOCK_RATE_PAL);
uint32 M68KCyclesPerScanline = m68kClockRate / (vp * refreshRate);
uint32 RISCCyclesPerScanline = m68kClockRate / (vp * refreshRate);
- TOMResetBackbuffer(backbuffer);
/*extern int effect_start;
if (effect_start)
WriteLog("JagExe: VP=%u, VI=%u, CPU CPS=%u, GPU CPS=%u\n", vp, vi, M68KCyclesPerScanline, RISCCyclesPerScanline);//*/
for(uint16 i=0; i<vp; i++)
{
// Increment the horizontal count (why? RNG? Besides which, this is *NOT* cycle accurate!)
- TOMWriteWord(0xF00004, (TOMReadWord(0xF00004) + 1) & 0x7FF);
+ TOMWriteWord(0xF00004, (TOMReadWord(0xF00004, JAGUAR) + 1) & 0x7FF, JAGUAR);
+ TOMWriteWord(0xF00006, i, JAGUAR); // Write the VC
- TOMWriteWord(0xF00006, i); // Write the VC
-
-// if (i == vi) // Time for Vertical Interrupt?
//Not sure if this is correct...
//Seems to be, kinda. According to the JTRM, this should only fire on odd lines in non-interlace mode...
//Which means that it normally wouldn't go when it's zero.
- if (i == vi && i > 0 && TOMIRQEnabled(IRQ_VBLANK)) // Time for Vertical Interrupt?
+ if (i == vi && i > 0 && TOMIRQEnabled(IRQ_VIDEO)) // Time for Vertical Interrupt?
{
// We don't have to worry about autovectors & whatnot because the Jaguar
// tells you through its HW registers who sent the interrupt...
TOMSetPendingVideoInt();
- m68k_set_irq(7);
+ m68k_set_irq(2);
}
//if (start_logging)
BUTCHExec(RISCCyclesPerScanline);
//if (start_logging)
// WriteLog("About to execute GPU (%u)...\n", i);
- GPUExec(RISCCyclesPerScanline);
+ if (vjs.GPUEnabled)
+ GPUExec(RISCCyclesPerScanline);
if (vjs.DSPEnabled)
{
if (fp == NULL)
return;
- fwrite(jaguarMainRam, 1, 0x400000, fp);
+ fwrite(jaguarMainRAM, 1, 0x400000, fp);
fclose(fp);
}
uint8 * GetRamPtr(void)
{
- return jaguarMainRam;
+ return jaguarMainRAM;
}
//
// New Jaguar execution stack
+// This executes 1 frame's worth of code.
//
-
-#if 0
-
-void JaguarExecuteNew(void)
-{
- extern bool finished, showGUI;
- extern bool debounceRunKey;
- // Pass a message to the "joystick" code to debounce the ESC key...
- debounceRunKey = true;
- finished = false;
-/* InitializeEventList();
- TOMResetBackbuffer(backbuffer);
-// SetCallbackTime(ScanlineCallback, 63.5555);
- SetCallbackTime(ScanlineCallback, 31.77775);
-// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time
-// SetCallbackTime(RenderCallback, 16651.541); // # Scanlines * scanline time//*/
-// uint8 * keystate = SDL_GetKeyState(NULL);
-
- do
- {
- double timeToNextEvent = GetTimeToNextEvent();
-//WriteLog("JEN: Time to next event (%u) is %f usec (%u RISC cycles)...\n", nextEvent, timeToNextEvent, USEC_TO_RISC_CYCLES(timeToNextEvent));
-
- m68k_execute(USEC_TO_M68K_CYCLES(timeToNextEvent));
- gpu_exec(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();
-
-// if (keystate[SDLK_ESCAPE])
-// break;
-
-// SDL_PumpEvents(); // Needed to keep the keystate current...
- }
- while (!finished);
-}
-
-void ScanlineCallback(void)
-{
- uint16 vc = TOMReadWord(0xF00006);
- uint16 vp = TOMReadWord(0xF0003E) + 1;
- uint16 vi = TOMReadWord(0xF0004E);
-// uint16 vbb = TOMReadWord(0xF00040);
- vc++;
-
- if (vc >= vp)
- vc = 0;
-
-//WriteLog("SLC: Currently on line %u (VP=%u)...\n", vc, vp);
- TOMWriteWord(0xF00006, vc);
-
-//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 == vi && vc > 0 && tom_irq_enabled(IRQ_VBLANK)) // 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...
- tom_set_pending_video_int();
- m68k_set_irq(7);
- }
-
- TOMExecScanline(vc, true);
-
-//Change this to VBB???
-//Doesn't seem to matter (at least for Flip Out & I-War)
- if (vc == 0)
-// if (vc == vbb)
- {
-joystick_exec();
-
- RenderBackbuffer();
- TOMResetBackbuffer(backbuffer);
- }//*/
-
-// if (vc == 0)
-// TOMResetBackbuffer(backbuffer);
-
-// SetCallbackTime(ScanlineCallback, 63.5555);
- SetCallbackTime(ScanlineCallback, 31.77775);
-}
-
-#else
-
bool frameDone;
void JaguarExecuteNew(void)
{
-// extern bool finished, showGUI;
-// extern bool debounceRunKey;
- // Pass a message to the "joystick" code to debounce the ESC key...
-// debounceRunKey = true;
-// finished = false;
-/* InitializeEventList();
- TOMResetBackbuffer(backbuffer);
-// SetCallbackTime(ScanlineCallback, 63.5555);
- SetCallbackTime(ScanlineCallback, 31.77775);
-// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time
-// SetCallbackTime(RenderCallback, 16651.541); // # Scanlines * scanline time//*/
-// uint8 * keystate = SDL_GetKeyState(NULL);
frameDone = false;
do
//WriteLog("JEN: Time to next event (%u) is %f usec (%u RISC cycles)...\n", nextEvent, timeToNextEvent, USEC_TO_RISC_CYCLES(timeToNextEvent));
m68k_execute(USEC_TO_M68K_CYCLES(timeToNextEvent));
- GPUExec(USEC_TO_RISC_CYCLES(timeToNextEvent));
+
+ if (vjs.GPUEnabled)
+ GPUExec(USEC_TO_RISC_CYCLES(timeToNextEvent));
if (vjs.DSPEnabled)
{
}
HandleNextEvent();
-
-// if (keystate[SDLK_ESCAPE])
-// break;
-
-// SDL_PumpEvents(); // Needed to keep the keystate current...
}
while (!frameDone);
}
void ScanlineCallback(void)
{
- uint16 vc = TOMReadWord(0xF00006);
- uint16 vp = TOMReadWord(0xF0003E) + 1;
- uint16 vi = TOMReadWord(0xF0004E);
-// uint16 vbb = TOMReadWord(0xF00040);
+ uint16 vc = TOMReadWord(0xF00006, JAGUAR);
+ uint16 vp = TOMReadWord(0xF0003E, JAGUAR) + 1;
+ uint16 vi = TOMReadWord(0xF0004E, JAGUAR);
+// uint16 vbb = TOMReadWord(0xF00040, JAGUAR);
vc++;
if (vc >= vp)
vc = 0;
//WriteLog("SLC: Currently on line %u (VP=%u)...\n", vc, vp);
- TOMWriteWord(0xF00006, vc);
+ 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 == vi && vc > 0 && TOMIRQEnabled(IRQ_VBLANK)) // Time for Vertical Interrupt?
+ if (vc == vi && vc > 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(7);
+ m68k_set_irq(2);
}
TOMExecScanline(vc, true);
// if (vc == vbb)
{
JoystickExec();
- RenderBackbuffer();
- TOMResetBackbuffer(backbuffer);
frameDone = true;
}//*/
-// if (vc == 0)
-// TOMResetBackbuffer(backbuffer);
-
// SetCallbackTime(ScanlineCallback, 63.5555);
SetCallbackTime(ScanlineCallback, 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)
{
- RenderBackbuffer();
- TOMResetBackbuffer(backbuffer);
// SetCallbackTime(RenderCallback, 33303.082); // # Scanlines * scanline time
SetCallbackTime(RenderCallback, 16651.541); // # Scanlines * scanline time
}
projects / virtualjaguar / blobdiff