[virtualjaguar] memtrack support, fix bug with event system, various cleanups

waterbox/virtualjaguar/BizInterface.cpp

@@ -88,9 +88,13 @@ EXPORT void SetCdCallbacks(void (*ctc)(void * dest), void (*cdrc)(int32_t lba, v
 	cd_read_callback = cdrc;
 }
 
-EXPORT void InitWithCd(BizSettings* bizSettings, u8* boot)
+EXPORT void InitWithCd(BizSettings* bizSettings, u8* boot, u8* memtrack)
 {
 	InitCommon(bizSettings);
+	if (memtrack)
+	{
+		JaguarLoadFile(memtrack, 0x20000);
+	}
 	vjs.hardwareTypeAlpine = false;
 
 	SET32(jaguarMainRAM, 0, 0x00200000);
@@ -99,24 +103,50 @@ EXPORT void InitWithCd(BizSettings* bizSettings, u8* boot)
 	JaguarReset();
 }
 
+// standard cart eeprom
 extern u16 eeprom_ram[64];
 extern bool eeprom_dirty;
 
+// memtrack ram (used for jagcd)
+extern u8 mtMem[0x20000];
+extern bool mtDirty;
+
+static inline bool IsMemTrack()
+{
+	return jaguarMainROMCRC32 == 0xFDF37F47;
+}
+
 EXPORT bool SaveRamIsDirty()
 {
-	return eeprom_dirty;
+	return IsMemTrack() ? mtDirty : eeprom_dirty;
 }
 
 EXPORT void GetSaveRam(u8* dst)
 {
-	memcpy(dst, eeprom_ram, sizeof(eeprom_ram));
+	if (IsMemTrack())
-	eeprom_dirty = false;
+	{
+		memcpy(dst, mtMem, sizeof(mtMem));
+		mtDirty = false;
+	}
+	else
+	{
+		memcpy(dst, eeprom_ram, sizeof(eeprom_ram));
+		eeprom_dirty = false;
+	}
 }
 
 EXPORT void PutSaveRam(u8* src)
 {
-	memcpy(eeprom_ram, src, sizeof(eeprom_ram));
+	if (IsMemTrack())
-	eeprom_dirty = false;
+	{
+		memcpy(mtMem, src, sizeof(mtMem));
+		mtDirty = false;
+	}
+	else
+	{
+		memcpy(eeprom_ram, src, sizeof(eeprom_ram));
+		eeprom_dirty = false;
+	}
 }
 
 extern u8 gpu_ram_8[0x1000];
@@ -173,10 +203,20 @@ EXPORT void GetMemoryAreas(MemoryArea* m)
 	m[0].Size = 0x200000;
 	m[0].Flags = MEMORYAREA_FLAGS_WORDSIZE2 | MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_YUGEENDIAN | MEMORYAREA_FLAGS_PRIMARY;
 
-	m[1].Data = eeprom_ram;
+	if (IsMemTrack())
-	m[1].Name = "EEPROM";
+	{
-	m[1].Size = sizeof(eeprom_ram);
+		m[1].Data = mtMem;
-	m[1].Flags = MEMORYAREA_FLAGS_WORDSIZE2 | MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_YUGEENDIAN | MEMORYAREA_FLAGS_SAVERAMMABLE;
+		m[1].Name = "MEMTRACK RAM";
+		m[1].Size = sizeof(mtMem);
+		m[1].Flags = MEMORYAREA_FLAGS_WORDSIZE2 | MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_YUGEENDIAN | MEMORYAREA_FLAGS_SAVERAMMABLE;
+	}
+	else
+	{
+		m[1].Data = jaguarCartInserted ? eeprom_ram : NULL;
+		m[1].Name = "EEPROM";
+		m[1].Size = sizeof(eeprom_ram);
+		m[1].Flags = MEMORYAREA_FLAGS_WORDSIZE2 | MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_YUGEENDIAN | MEMORYAREA_FLAGS_SAVERAMMABLE;
+	}
 
 	m[2].Data = gpu_ram_8;
 	m[2].Name = "GPU RAM";
@@ -291,14 +331,11 @@ void (*ReadCallback)(u32) = 0;
 void (*WriteCallback)(u32) = 0;
 void (*ExecuteCallback)(u32) = 0;
 
-EXPORT void SetMemoryCallback(u32 which, void (*callback)(u32))
+EXPORT void SetMemoryCallbacks(void (*rcb)(u32), void (*wcb)(u32), void (*ecb)(u32))
 {
-	switch (which)
+	ReadCallback = rcb;
-	{
+	WriteCallback = wcb;
-		case 0: ReadCallback = callback; break;
+	ExecuteCallback = ecb;
-		case 1: WriteCallback = callback; break;
-		case 2: ExecuteCallback = callback; break;
-	}
 }
 
 void (*CPUTraceCallback)(u32*) = 0;

waterbox/virtualjaguar/src/cdhle.cpp

@@ -3,6 +3,9 @@
 #include "memory.h"
 #include "jaguar.h"
 #include "jerry.h"
+#include "tom.h"
+#include "dac.h"
+#include "dsp.h"
 #include "event.h"
 #include "m68000/m68kinterface.h"
 
@@ -21,6 +24,7 @@ static bool cd_setup;
 static bool cd_initm;
 static bool cd_muted;
 static bool cd_paused;
+bool cd_jerry;
 static uint8_t cd_mode;
 static uint8_t cd_osamp;
 
@@ -144,9 +148,20 @@ void CDHLEReset(void)
 	cd_initm = false;
 	cd_muted = false;
 	cd_paused = false;
+	cd_jerry = false;
 	cd_mode = 0;
 	cd_osamp = 0;
 
+	cd_is_reading = false;
+	cd_read_orig_addr_start = 0;
+	cd_read_addr_start = 0;
+	cd_read_addr_end = 0;
+	cd_read_lba = 0;
+	memset(cd_buf2352, 0, sizeof(cd_buf2352));
+	cd_buf_pos = 0;
+	cd_buf_rm = 0;
+	cd_buf_circular_size = 0;
+
 	if (cd_read_callback)
 	{
 		// copy TOC to RAM
@@ -208,6 +223,12 @@ void CDHLEReset(void)
 
 		SET32(jaguarMainRAM, 4, cd_boot_addr);
 		SET16(jaguarMainRAM, 0x3004, 0x0403); // BIOS VER
+		DACWriteByte(0xF1A153, 9); // set SCLK to 9
+		if (jaguarMainROMCRC32 == 0xFDF37F47)
+		{
+			TOMWriteWord(0xF00000, (TOMGetMEMCON1() & ~6u) | 4); // set ROM width to 32 bit
+			memcpy(&jaguarMainRAM[0x2400], &jaguarMainROM[0x6D60], 0x790); // copy memtrack "bios" to ram
+		}
 	}
 }
 
@@ -215,58 +236,35 @@ void CDHLEDone(void)
 {
 }
 
-static void CDSendBlock(void)
+static void RefillCDBuf()
 {
-	if (cd_buf_rm < 64)
+	memmove(&cd_buf2352[0], &cd_buf2352[cd_buf_pos], cd_buf_rm);
-	{
+	cd_read_callback(cd_read_lba++, &cd_buf2352[cd_buf_rm]);
-		memmove(&cd_buf2352[0], &cd_buf2352[cd_buf_pos], cd_buf_rm);
-		cd_read_callback(cd_read_lba++, &cd_buf2352[cd_buf_rm]);
 
-		// hack to force word alignment
+	// hack to force word alignment
-		if (cd_word_alignment)
+	if (cd_word_alignment)
+	{
+		uint8_t temp2352[2352];
+		cd_read_callback(cd_read_lba, temp2352);
+		memmove(&cd_buf2352[cd_buf_rm], &cd_buf2352[cd_buf_rm + cd_word_alignment], 2352 - cd_word_alignment);
+		memcpy(&cd_buf2352[cd_buf_rm + 2352 - cd_word_alignment], &temp2352[0], cd_word_alignment);
+	}
+
+	if (cd_byte_swapped)
+	{
+		uint16_t* cd16buf = (uint16_t*)&cd_buf2352[cd_buf_rm];
+		for (uint32_t i = 0; i < (2352 / 2); i++)
 		{
-			uint8_t temp2352[2352];
+			cd16buf[i] = __builtin_bswap16(cd16buf[i]);
-			cd_read_callback(cd_read_lba, temp2352);
-			memmove(&cd_buf2352[cd_buf_rm], &cd_buf2352[cd_buf_rm + cd_word_alignment], 2352 - cd_word_alignment);
-			memcpy(&cd_buf2352[cd_buf_rm + 2352 - cd_word_alignment], &temp2352[0], cd_word_alignment);
 		}
-
-		if (cd_byte_swapped)
-		{
-			uint16_t* cd16buf = (uint16_t*)&cd_buf2352[cd_buf_rm];
-			for (uint32_t i = 0; i < (2352 / 2); i++)
-			{
-				cd16buf[i] = __builtin_bswap16(cd16buf[i]);
-			}
-		}
-
-		cd_buf_pos = 0;
-		cd_buf_rm += 2352;
 	}
 
-	// send one block of data, one long at a time
+	cd_buf_pos = 0;
-	for (uint32_t i = 0; i < 64; i += 4)
+	cd_buf_rm += 2352;
-	{
-		GPUWriteLong(cd_read_addr_start + i, GET32(cd_buf2352, cd_buf_pos + i), GPU);
-	}
-
-	cd_read_addr_start += 64;
-	cd_buf_pos += 64;
-	cd_buf_rm -= 64;
-
-	if (cd_read_addr_start >= cd_read_addr_end)
-	{
-		cd_is_reading = false;
-	}
-	else if (cd_buf_circular_size && (cd_read_addr_start - cd_read_orig_addr_start) >= cd_buf_circular_size)
-	{
-		cd_read_addr_start = cd_read_orig_addr_start;
-	}
 }
 
 static void CDHLECallback(void)
 {
-	RemoveCallback(CDHLECallback);
 	if (cd_is_reading)
 	{
 		if (!GPURunning())
@@ -274,14 +272,69 @@ static void CDHLECallback(void)
 
 		if (GPURunning() && !cd_paused)
 		{
-			CDSendBlock();
+			if (cd_buf_rm < 64)
+			{
+				RefillCDBuf();
+			}
+
+			// send one block of data, one long at a time
+			for (uint32_t i = 0; i < 64; i += 4)
+			{
+				GPUWriteLong(cd_read_addr_start + i, GET32(cd_buf2352, cd_buf_pos + i), GPU);
+			}
+
+			cd_read_addr_start += 64;
+			cd_buf_pos += 64;
+			cd_buf_rm -= 64;
+
+			if (cd_read_addr_start >= cd_read_addr_end)
+			{
+				cd_is_reading = false;
+			}
+			else if (cd_buf_circular_size && (cd_read_addr_start - cd_read_orig_addr_start) >= cd_buf_circular_size)
+			{
+				cd_read_addr_start = cd_read_orig_addr_start;
+			}
+
 			//GPUSetIRQLine(GPUIRQ_DSP, ASSERT_LINE);
 		}
+
 		SetCallbackTime(CDHLECallback, 285 >> (cd_mode & 1));
 	}
 }
 
-static void LoadISRStub()
+// called from JERRYI2SCallback
+bool CDHLEJerryCallback(void)
+{
+	if (!cd_is_reading || !cd_jerry || cd_paused)
+	{
+		return false;
+	}
+
+	if (cd_buf_rm < 4)
+	{
+		RefillCDBuf();
+	}
+
+	DACWriteWord(0xF1A14A, GET16(cd_buf2352, cd_buf_pos + 0));
+	DACWriteWord(0xF1A14E, GET16(cd_buf2352, cd_buf_pos + 2));
+
+	cd_buf_pos += 4;
+	cd_buf_rm -= 4;
+
+	return true;
+}
+
+static void ResetCallbacks(void)
+{
+	RemoveCallback(CDHLECallback);
+	if (!cd_jerry)
+	{
+		SetCallbackTime(CDHLECallback, 285 >> (cd_mode & 1));
+	}
+}
+
+static void LoadISRStub(void)
 {
 	uint32_t isrAddr = m68k_get_reg(NULL, M68K_REG_A0);
 	uint32_t addr = 0xF03010;
@@ -373,7 +426,13 @@ static void CD_ack(void)
 
 static void CD_jeri(void)
 {
-	fprintf(stderr, "CD_jeri called %d!!!\n", m68k_get_reg(NULL, M68K_REG_D0) & 1);
+	bool njerry = m68k_get_reg(NULL, M68K_REG_D0) & 1;
+	if (cd_jerry ^ njerry)
+	{
+		fprintf(stderr, "changing jerry mode %d -> %d\n", cd_jerry, njerry);
+		cd_jerry = njerry;
+		ResetCallbacks();
+	}
 }
 
 static void CD_spin(void)
@@ -514,8 +573,7 @@ static void CD_read(void)
 						cd_buf_pos = 0;
 						cd_buf_rm = bufRm;
 						cd_buf_circular_size = circBufSz ? (1 << circBufSz) : 0;
-						RemoveCallback(CDHLECallback);
+						ResetCallbacks();
-						SetCallbackTime(CDHLECallback, 285 >> (cd_mode & 1));
 						JERRYWriteWord(0xF10020, 0, M68K);
 						//GPUWriteLong(0xF02100, GPUReadLong(0xF02100, M68K) | 0x20, M68K);
 						break;
@@ -536,8 +594,7 @@ static void CD_read(void)
 			cd_buf_pos = 0;
 			cd_buf_rm = 0;
 			cd_buf_circular_size = 0;
-			RemoveCallback(CDHLECallback);
+			ResetCallbacks();
-			SetCallbackTime(CDHLECallback, 285 >> (cd_mode & 1));
 			JERRYWriteWord(0xF10020, 0, M68K);
 			//GPUWriteLong(0xF02100, GPUReadLong(0xF02100, M68K) | 0x20, M68K);
 		}

waterbox/virtualjaguar/src/cdhle.h

@@ -8,5 +8,6 @@ void CDHLEReset(void);
 void CDHLEDone(void);
 
 void CDHLEHook(uint32_t which);
+bool CDHLEJerryCallback(void);
 
 #endif	// __CDHLE_H__

waterbox/virtualjaguar/src/dac.cpp

@@ -69,10 +69,8 @@ void DSPSampleCallback(void);
 void DACInit(void)
 {
 	ltxd = lrxd = 0;
-	sclk = 19;
 
-	uint32_t riscClockRate = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL);
+	sclk = 19;
-	uint32_t cyclesPerSample = riscClockRate / DAC_AUDIO_RATE;
 }
 
 //

waterbox/virtualjaguar/src/event.cpp

@@ -19,7 +19,9 @@
 
 #include "event.h"
 
+#include <assert.h>
 #include <stdint.h>
+#include <float.h>
 
 #define EVENT_LIST_SIZE       32
 
@@ -145,10 +147,10 @@ double GetTimeToNextEvent(int type)
 {
 	if (type == EVENT_MAIN)
 	{
-		double time = eventList[0].eventTime;
+		double time = DBL_MAX;
-		nextEvent = 0;
+		nextEvent = EVENT_LIST_SIZE;
 
-		for(uint32_t i=1; i<EVENT_LIST_SIZE; i++)
+		for(uint32_t i=0; i<EVENT_LIST_SIZE; i++)
 		{
 			if (eventList[i].valid && (eventList[i].eventTime < time))
 			{
@@ -157,14 +159,15 @@ double GetTimeToNextEvent(int type)
 			}
 		}
 
+		assert(nextEvent != EVENT_LIST_SIZE);
 		return time;
 	}
 	else
 	{
-		double time = eventListJERRY[0].eventTime;
+		double time = DBL_MAX;
-		nextEventJERRY = 0;
+		nextEventJERRY = EVENT_LIST_SIZE;
 
-		for(uint32_t i=1; i<EVENT_LIST_SIZE; i++)
+		for(uint32_t i=0; i<EVENT_LIST_SIZE; i++)
 		{
 			if (eventListJERRY[i].valid && (eventListJERRY[i].eventTime < time))
 			{
@@ -173,6 +176,7 @@ double GetTimeToNextEvent(int type)
 			}
 		}
 
+		assert(nextEventJERRY != EVENT_LIST_SIZE);
 		return time;
 	}
 }

waterbox/virtualjaguar/src/jerry.cpp

@@ -27,6 +27,7 @@
 #include "settings.h"
 #include "tom.h"
 #include "wavetable.h"
+#include "cdhle.h"
 
 /*static*/ uint8_t jerry_ram_8[0x10000];
 
@@ -142,12 +143,10 @@ void JERRYI2SCallback(void)
 	}
 	else
 	{
-		if (ButchIsReadyToSend())
+		if (CDHLEJerryCallback())
 		{
-			SetSSIWordsXmittedFromButch();
 			DSPSetIRQLine(DSPIRQ_SSI, ASSERT_LINE);
 		}
-
 		SetCallbackTime(JERRYI2SCallback, 22.675737, EVENT_JERRY);
 	}
 }

waterbox/virtualjaguar/src/memtrack.cpp

@@ -30,6 +30,7 @@ enum { MT_NONE, MT_PROD_ID, MT_RESET, MT_WRITE_ENABLE };
 enum { MT_IDLE, MT_PHASE1, MT_PHASE2 };
 
 uint8_t mtMem[0x20000];
+bool mtDirty;
 uint8_t mtCommand = MT_NONE;
 uint8_t mtState = MT_IDLE;
 
@@ -38,6 +39,7 @@ void MTStateMachine(uint8_t reg, uint16_t data);
 void MTInit(void)
 {
 	memset(mtMem, 0xFF, 0x20000);
+	mtDirty = false;
 }
 
 void MTReset(void)
@@ -90,6 +92,7 @@ void MTWriteWord(uint32_t addr, uint16_t data)
 	if (mtCommand == MT_WRITE_ENABLE)
 	{
 		mtMem[(addr & 0x7FFFC) >> 2] = (uint8_t)(data & 0xFF);
+		mtDirty = true;
 		return;
 	}