X-Git-Url: http://git.hcoop.net/clinton/Virtual-Jaguar-Rx.git/blobdiff_plain/ed31b9990544235632b07e7b8946b5df9e695660..0029c5072f864788020340eab0ed9600ac0f8f4a:/src/jaguar.cpp

diff --git a/src/jaguar.cpp b/src/jaguar.cpp
index 90c35c9..6e4b04a 100644
--- a/src/jaguar.cpp
+++ b/src/jaguar.cpp
@@ -14,6 +14,8 @@
 // ---  ----------  -----------------------------------------------------------
 // JLH  11/25/2009  Major rewrite of memory subsystem and handlers
 // JPM  09/04/2018  Added the new Models and BIOS handler
+// JPM  10/13/2018  Added breakpoints features
+// JPM   Aug./2019  Fix specific breakpoint for ROM cartridge or unknown memory location writing; added a specific breakpoint for the M68K illegal & unimplemented instruction, unknown exceptions and address error exceptions
 //
 
 
@@ -43,7 +45,7 @@
 #include "mmu.h"
 #include "settings.h"
 #include "tom.h"
-//#include "debugger/brkWin.h"
+//#include "debugger/BreakpointsWin.h"
 #ifdef NEWMODELSBIOSHANDLER
 #include "modelsBIOS.h"
 #endif
@@ -119,8 +121,10 @@ bool startM68KTracing = false;
 // Breakpoint on memory access vars (exported)
 bool bpmActive = false;
 bool bpmSaveActive = false;
+size_t bpmHitCounts;
 uint32_t bpmAddress1;
-//BrkInfo bpm;
+S_BrkInfo *brkInfo;
+size_t brkNbr;
 
 
 //
@@ -1048,12 +1052,139 @@ void	M68K_Debughalt(void)
 #endif
 
 
-// 
+// M68000 breakpoints initialisations
+void m68k_brk_init(void)
+{
+	brkNbr = 0;
+	brkInfo = NULL;
+}
+
+
+// Reset the M68000 breakpoints structures
+void m68k_brk_reset(void)
+{
+	// Reset the breakpoints
+	free(brkInfo);
+	brkInfo = NULL;
+	brkNbr = 0;
+}
+
+
+// Delete a M68000 breakpoint (starting from 1)
+void m68k_brk_del(unsigned int NumBrk)
+{
+	// Remove the breakpoint
+	memset((void *)(brkInfo + (NumBrk - 1)), 0, sizeof(S_BrkInfo));
+}
+
+
+// Add a M68000 breakpoint
+// return true if breakpoint has been added, and false if breakpoint already exists
+unsigned int m68k_brk_add(void *PtrInfo)
+{
+	S_BrkInfo *Ptr = NULL;
+
+	// Check if breakpoint already exists
+	for (size_t i = 0; i < brkNbr; i++)
+	{
+		if (brkInfo[i].Used)
+		{
+			if (brkInfo[i].Adr == ((S_BrkInfo *)PtrInfo)->Adr)
+			{
+				return false;
+			}
+		}
+	}
+
+	// Look for an available breakpoint
+	for (size_t i = 0; i < brkNbr, Ptr; i++)
+	{
+		if (!brkInfo[i].Used)
+		{
+			Ptr = &brkInfo[i];
+		}
+	}
+
+	// Add a breakpoint
+	if (!Ptr)
+	{
+		brkInfo = (S_BrkInfo *)realloc(brkInfo, (++brkNbr * sizeof(S_BrkInfo)));
+		Ptr = &brkInfo[brkNbr - 1];
+	}
+
+	// Transfert the breakpoint information and init the activities
+	memcpy((void *)Ptr, PtrInfo, sizeof(S_BrkInfo));
+	Ptr->HitCounts = 0;
+	return (Ptr->Active = Ptr->Used = true);
+}
+
+
+// Check if breakpoint has been reached
+unsigned int m68k_brk_check(unsigned int adr)
+{
+	// Check if BPM has been reached
+	if ((adr == bpmAddress1) && bpmActive)
+	{
+		bpmHitCounts++;
+		return true;
+	}
+	else
+	{
+		// Check user breakpoints
+		for (size_t i = 0; i < brkNbr; i++)
+		{
+			if (brkInfo[i].Used && brkInfo[i].Active)
+			{
+				if (brkInfo[i].Adr == adr)
+				{
+					brkInfo[i].HitCounts++;
+					return true;
+				}
+			}
+		}
+	}
+
+	// No breakpoint found
+	return false;
+}
+
+
+// Disable the M68000 breakpoints
+void m68k_brk_disable(void)
+{
+	// reset active for the breakpoints
+	for (size_t i = 0; i < brkNbr; i++)
+	{
+		brkInfo[i].Active = 0;
+	}
+}
+
+
+// Reset the M68000 breakpoints
+void m68k_brk_hitcounts_reset(void)
+{
+	// reset hit counts for the breakpoints
+	for (size_t i = 0; i < brkNbr; i++)
+	{
+		brkInfo[i].HitCounts = 0;
+	}
+}
+
+
+// Close the M68000 breakpoints structures
+void m68k_brk_close(void)
+{
+	free(brkInfo);
+}
+
+
+// Read 1 byte from address
+// Check if address reaches a breakpoint
 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)
+	if (!startM68KTracing && m68k_brk_check(address))
 	{
 		M68KDebugHalt();
 	}
@@ -1145,7 +1276,7 @@ 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))
+	if (!startM68KTracing && m68k_brk_check(address))
 	{
 		M68KDebugHalt();
 	}
@@ -1288,11 +1419,31 @@ unsigned int m68k_read_memory_16(unsigned int address)
 }
 
 
+// Alert message in case of exception vector request
+bool m68k_read_exception_vector(unsigned int address, char *text)
+{
+	QString msg;
+	QMessageBox msgBox;
+
+#if 0
+	msg.sprintf("68000 exception\n%s at $%06x", text, pcQueue[pcQPtr ? (pcQPtr - 1) : 0x3FF]);
+#else
+	msg.sprintf("68000 exception\n$%06x: %s", pcQueue[pcQPtr ? (pcQPtr - 1) : 0x3FF], text);
+#endif
+	msgBox.setText(msg);
+	msgBox.setStandardButtons(QMessageBox::Abort);
+	msgBox.setDefaultButton(QMessageBox::Abort);
+	msgBox.exec();
+	return M68KDebugHalt();
+}
+
+
+// Read 4 bytes from memory
 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)
+	if (!startM68KTracing && m68k_brk_check(address))
 	{
 		M68KDebugHalt();
 	}
@@ -1306,23 +1457,48 @@ unsigned int m68k_read_memory_32(unsigned int address)
 
 //WriteLog("--> [RM32]\n");
 #ifndef USE_NEW_MMU
-	uint32_t retVal = 0;
+	//uint32_t retVal = 0;
 
-	if ((address >= 0x800000) && (address <= 0xDFFEFE))
+	// check exception vectors access
+	if ((address >= 0x8) && (address <= 0x7c))
 	{
-		// Memory Track reading...
-		if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47))
+		switch (address)
 		{
-			retVal = MTReadLong(address);
+		case 0x0c:
+			m68k_read_exception_vector(address, "Address error");
+			break;
+
+		case 0x10:
+			m68k_read_exception_vector(address, "Illegal instruction");
+			break;
+
+		case 0x2c:
+			m68k_read_exception_vector(address, "Unimplemented instruction");
+			break;
+
+		default:
+			m68k_read_exception_vector(address, "Exception not referenced");
+			break;
 		}
-		else
+	}
+	else
+	{
+		// check ROM or Memory Track access
+		if ((address >= 0x800000) && (address <= 0xDFFEFE))
 		{
-			retVal = GET32(jaguarMainROM, address - 0x800000);
+			// Memory Track reading...
+			if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47))
+			{
+				return MTReadLong(address);
+			}
+			else
+			{
+				return GET32(jaguarMainROM, address - 0x800000);
+			}
 		}
-
-		return retVal;
 	}
 
+	// return value from memory
 	return (m68k_read_memory_16(address) << 16) | m68k_read_memory_16(address + 2);
 #else
 	return MMURead32(address, M68K);
@@ -1330,7 +1506,7 @@ unsigned int m68k_read_memory_32(unsigned int address)
 }
 
 
-//
+// Alert message in case of writing to unknown memory location
 bool m68k_write_unknown_alert(unsigned int address, char *bits, unsigned int value)
 {
 	QString msg;
@@ -1338,58 +1514,55 @@ bool m68k_write_unknown_alert(unsigned int address, char *bits, unsigned int val
 
 	msg.sprintf("$%06x: Writing at this unknown memory location $%06x with a (%s bits) value of $%0x", pcQueue[pcQPtr ? (pcQPtr - 1) : 0x3FF], address, bits, value);
 	msgBox.setText(msg);
-	msgBox.setStandardButtons(QMessageBox::Cancel);
-	msgBox.setDefaultButton(QMessageBox::Cancel);
+	msgBox.setStandardButtons(QMessageBox::Abort);
+	msgBox.setDefaultButton(QMessageBox::Abort);
 	msgBox.exec();
 	return M68KDebugHalt();
 }
 
 
-// 
+// Alert message in case of writing to cartridge/ROM memory location
 bool m68k_write_cartridge_alert(unsigned int address, char *bits, unsigned int value)
 {
-	QString msg;
-	QMessageBox msgBox;
+	if (!M68KDebugHaltStatus())
+	{
+		QString msg;
+		QMessageBox msgBox;
 
-	msg.sprintf("$%06x: Writing at this ROM cartridge location $%06x with a (%s bits) value of $%0x", pcQueue[pcQPtr ? (pcQPtr - 1) : 0x3FF], address, bits, value);
-#if 1
-	msgBox.setText(msg);
+		msg.sprintf("$%06x: Writing at this ROM cartridge location $%06x with a (%s bits) value of $%0x", pcQueue[pcQPtr ? (pcQPtr - 1) : 0x3FF], address, bits, value);
+		msgBox.setText(msg);
 
-	if (!M68KDebugHaltStatus() && !strstr(bits, "32"))
-	{
 		msgBox.setInformativeText("Do you want to continue?");
-		msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
-		msgBox.setDefaultButton(QMessageBox::Cancel);
-	}
-	else
-	{
-		msgBox.setStandardButtons(QMessageBox::Cancel);
-		msgBox.setDefaultButton(QMessageBox::Cancel);
-	}
+		msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+		msgBox.setDefaultButton(QMessageBox::No);
 
-	int retVal = msgBox.exec();
-#endif
-#if 0
-	QMessageBox::StandardButton retVal = QMessageBox::question(this, tr("Remove Mapping"), msg, QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
-#endif
+		int retVal = msgBox.exec();
 
-	if (retVal == QMessageBox::Ok)
-	{
-		return false;
+		if (retVal == QMessageBox::Yes)
+		{
+			return false;
+		}
+		else
+		{
+			return M68KDebugHalt();
+		}
 	}
 	else
 	{
-		return M68KDebugHalt();
+		return 1;
 	}
 }
 
 
-// 
+// Check memory write location
+// BPM & cartridge/ROM detections
 bool m68k_write_memory_check(unsigned int address, char *bits, unsigned int value)
 {
+	unsigned int address1;
+
 #ifdef ALPINE_FUNCTIONS
 	// Check if breakpoint on memory is active, and deal with it
-	if (bpmActive && (address == bpmAddress1))
+	if (!M68KDebugHaltStatus() && bpmActive && (address == bpmAddress1))
 	{
 		return M68KDebugHalt();
 	}
@@ -1397,223 +1570,203 @@ bool m68k_write_memory_check(unsigned int address, char *bits, unsigned int valu
 #endif
 	{
 		// Rom writing authorisation detection
-		if (!vjs.allowWritesToROM && ((address >= 0x800000) && (address < 0xDFFF00)))
-		{
-			return m68k_write_cartridge_alert(address, bits, value);
-		}
-		else
+		if (!vjs.allowWritesToROM)
 		{
-			//if ((address & 0xFF000000))
-			//{
-			//	return m68k_write_unknown_alert(address, bits, value);
-			//}
-			//else
-			//{
-				return false;
-			//}
+			// Calcul the end address
+			if (strstr(bits, "32"))
+			{
+				address1 = address + 3;
+			}
+			else
+			{
+				if (strstr(bits, "16"))
+				{
+					address1 = address + 1;
+				}
+				else
+				{
+					address1 = address;
+				}
+			}
+
+			// Rom writing detection
+			if ((address >= 0x800000) && (address1 < 0xDFFF00))
+			{
+				return m68k_write_cartridge_alert(address, bits, value);
+			}
 		}
+
+		return false;
 	}
 }
 
 
-// 
+// Memory write location on 8 bits
 void m68k_write_memory_8(unsigned int address, unsigned int value)
 {
-#if 1
-	m68k_write_memory_check(address, "8", value);
-#else
-#ifdef ALPINE_FUNCTIONS
-	// Check if breakpoint on memory is active, and deal with it
-	if (bpmActive && (address == bpmAddress1))
-	{
-		M68KDebugHalt();
-	}
-	else
-#endif
+	// Check memory write location on 8 bits
+	if (!m68k_write_memory_check(address, "8", value))
 	{
-		// Rom writing authorisation detection
-		if (!vjs.allowWritesToROM && ((address >= 0x800000) && (address < 0xe00000)))
-		{
-			m68k_write_cartridge_alert(address, "8", value);
-		}
-	}
-#endif
-
-	// Musashi does this automagically for you, UAE core does not :-P
-	//address &= 0x00FFFFFF;
+		// Musashi does this automagically for you, UAE core does not :-P
+		//address &= 0x00FFFFFF;
 #ifdef CPU_DEBUG_MEMORY
 	// Note that the Jaguar only has 2M of RAM, not 4!
-	if ((address >= 0x000000) && (address <= 0x1FFFFF))
-	{
-		if (startMemLog)
+		if ((address >= 0x000000) && (address <= 0x1FFFFF))
 		{
-			if (value > writeMemMax[address])
-				writeMemMax[address] = value;
-			if (value < writeMemMin[address])
-				writeMemMin[address] = value;
+			if (startMemLog)
+			{
+				if (value > writeMemMax[address])
+					writeMemMax[address] = value;
+				if (value < writeMemMin[address])
+					writeMemMin[address] = 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 (effect_start)
-	if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
-		WriteLog("M68K: Byte %02X written at %08X by 68K\n", value, address);//*/
-//$53D0
-/*if (address >= 0x53D0 && address <= 0x53FF)
-	printf("M68K: Writing byte $%02X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
-//Testing AvP on UAE core...
-//000075A0: FFFFF80E B6320220 (BITMAP)
-/*if (address == 0x75A0 && value == 0xFF)
-	printf("M68K: (8) Tripwire hit...\n");//*/
+		/*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 (effect_start)
+				if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
+					WriteLog("M68K: Byte %02X written at %08X by 68K\n", value, address);//*/
+					//$53D0
+					/*if (address >= 0x53D0 && address <= 0x53FF)
+						printf("M68K: Writing byte $%02X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
+						//Testing AvP on UAE core...
+						//000075A0: FFFFF80E B6320220 (BITMAP)
+						/*if (address == 0x75A0 && value == 0xFF)
+							printf("M68K: (8) Tripwire hit...\n");//*/
 
 #ifndef USE_NEW_MMU
-	// Note that the Jaguar only has 2M of RAM, not 4!
-	if ((address >= 0x000000) && (address <= (vjs.DRAM_size - 1)))
-	{
-		jaguarMainRAM[address] = value;
-	}
-	else
-	{
-		if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
+							// Note that the Jaguar only has 2M of RAM, not 4!
+		if ((address >= 0x000000) && (address <= (vjs.DRAM_size - 1)))
 		{
-			CDROMWriteByte(address, value, M68K);
+			jaguarMainRAM[address] = value;
 		}
 		else
 		{
-			if ((address >= 0xF00000) && (address <= 0xF0FFFF))
+			if ((address >= 0xDFFF00) && (address <= 0xDFFFFF))
 			{
-				TOMWriteByte(address, value, M68K);
+				CDROMWriteByte(address, value, M68K);
 			}
 			else
 			{
-				if ((address >= 0xF10000) && (address <= 0xF1FFFF))
+				if ((address >= 0xF00000) && (address <= 0xF0FFFF))
 				{
-					JERRYWriteByte(address, value, M68K);
+					TOMWriteByte(address, value, M68K);
 				}
 				else
 				{
-					jaguar_unknown_writebyte(address, value, M68K);
+					if ((address >= 0xF10000) && (address <= 0xF1FFFF))
+					{
+						JERRYWriteByte(address, value, M68K);
+					}
+					else
+					{
+						if ((address >= 0x800000) && (address <= 0xDFFEFF))
+						{
+							jagMemSpace[address] = (uint8_t)value;
+						}
+						else
+						{
+							jaguar_unknown_writebyte(address, value, M68K);
+						}
+					}
 				}
 			}
 		}
-	}
 #else
-	MMUWrite8(address, value, M68K);
+		MMUWrite8(address, value, M68K);
 #endif
+	}
 }
 
 
-// 
+// Memory write location on 16 bits
 void m68k_write_memory_16(unsigned int address, unsigned int value)
 {
-#if 1
-	if (!M68KDebugHaltStatus())
-	{
-		m68k_write_memory_check(address, "16", value);
-	}
-#else
-#ifdef ALPINE_FUNCTIONS
-	// Check if breakpoint on memory is active, and deal with it
-	if (bpmActive && address == bpmAddress1)
-	{
-		M68KDebugHalt();
-	}
-	else
-#endif
+	// Check memory write location on 16 bits
+	if (!m68k_write_memory_check(address, "16", value))
 	{
-		// Rom writing authorisation detection
-		if (!vjs.allowWritesToROM && ((address >= 0x800000) && (address < 0xe00000)))
-		{
-			if (!M68KDebugHaltStatus())
-			{
-				m68k_write_cartridge_alert(address, "16", value);
-			}
-		}
-	}
-#endif
-
-	// Musashi does this automagically for you, UAE core does not :-P
-	//address &= 0x00FFFFFF;
+		// Musashi does this automagically for you, UAE core does not :-P
+		//address &= 0x00FFFFFF;
 #ifdef CPU_DEBUG_MEMORY
 	// Note that the Jaguar only has 2M of RAM, not 4!
-	if ((address >= 0x000000) && (address <= 0x1FFFFE))
-	{
-		if (startMemLog)
+		if ((address >= 0x000000) && (address <= 0x1FFFFE))
 		{
-			uint8_t hi = value >> 8, lo = value & 0xFF;
+			if (startMemLog)
+			{
+				uint8_t hi = value >> 8, lo = value & 0xFF;
 
-			if (hi > writeMemMax[address])
-				writeMemMax[address] = hi;
-			if (hi < writeMemMin[address])
-				writeMemMin[address] = hi;
+				if (hi > writeMemMax[address])
+					writeMemMax[address] = hi;
+				if (hi < writeMemMin[address])
+					writeMemMin[address] = hi;
 
-			if (lo > writeMemMax[address+1])
-				writeMemMax[address+1] = lo;
-			if (lo < writeMemMin[address+1])
-				writeMemMin[address+1] = lo;
+				if (lo > writeMemMax[address + 1])
+					writeMemMax[address + 1] = lo;
+				if (lo < writeMemMin[address + 1])
+					writeMemMin[address + 1] = lo;
+			}
 		}
-	}
 #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);
-//if (address >= 0xF02200 && address <= 0xF0229F)
-//	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_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)
-	WriteLog("M68K: Writing to GPU_PC (frame:%u)... [M68K PC:%08X]\n", totalFrames, m68k_get_reg(NULL, M68K_REG_PC));//*/
-//if (address >= 0xF03B00 && address <= 0xF03DFF)
-//	WriteLog("M68K: Writing %04X to %08X...\n", value, address);
-
-/*if (address == 0x0100)//64*4)
-	WriteLog("M68K: Wrote word to VI vector value %04X...\n", value);//*/
-/*if (effect_start)
-	if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
-		WriteLog("M68K: Word %04X written at %08X by 68K\n", value, address);//*/
-/*	if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
-		|| address == 0x1AF05E)
-		WriteLog("[WM16  PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
-//$53D0
-/*if (address >= 0x53D0 && address <= 0x53FF)
-	printf("M68K: Writing word $%04X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
-//Testing AvP on UAE core...
-//000075A0: FFFFF80E B6320220 (BITMAP)
-/*if (address == 0x75A0 && value == 0xFFFF)
-{
-	printf("\nM68K: (16) Tripwire hit...\n");
-	ShowM68KContext();
-}//*/
+		/*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);
+			//if (address >= 0xF02200 && address <= 0xF0229F)
+			//	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_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)
+				WriteLog("M68K: Writing to GPU_PC (frame:%u)... [M68K PC:%08X]\n", totalFrames, m68k_get_reg(NULL, M68K_REG_PC));//*/
+				//if (address >= 0xF03B00 && address <= 0xF03DFF)
+				//	WriteLog("M68K: Writing %04X to %08X...\n", value, address);
+
+				/*if (address == 0x0100)//64*4)
+					WriteLog("M68K: Wrote word to VI vector value %04X...\n", value);//*/
+					/*if (effect_start)
+						if (address >= 0x18FA70 && address < (0x18FA70 + 8000))
+							WriteLog("M68K: Word %04X written at %08X by 68K\n", value, address);//*/
+							/*	if (address == 0x51136 || address == 0x51138 || address == 0xFB074 || address == 0xFB076
+									|| address == 0x1AF05E)
+									WriteLog("[WM16  PC=%08X] Addr: %08X, val: %04X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+									//$53D0
+									/*if (address >= 0x53D0 && address <= 0x53FF)
+										printf("M68K: Writing word $%04X at $%08X, PC=$%08X\n", value, address, m68k_get_reg(NULL, M68K_REG_PC));//*/
+										//Testing AvP on UAE core...
+										//000075A0: FFFFF80E B6320220 (BITMAP)
+										/*if (address == 0x75A0 && value == 0xFFFF)
+										{
+											printf("\nM68K: (16) Tripwire hit...\n");
+											ShowM68KContext();
+										}//*/
 
 #ifndef USE_NEW_MMU
-	// Note that the Jaguar only has 2M of RAM, not 4!
-	if ((address >= 0x000000) && (address <= (vjs.DRAM_size - 2)))
-	{
-/*		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))
+										// Note that the Jaguar only has 2M of RAM, not 4!
+		if ((address >= 0x000000) && (address <= (vjs.DRAM_size - 2)))
 		{
-			if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47))
-			{
-				MTWriteWord(address, value);
-			}
+			/*		jaguar_mainRam[address] = value >> 8;
+					jaguar_mainRam[address + 1] = value & 0xFF;*/
+			SET16(jaguarMainRAM, address, value);
 		}
 		else
 		{
+			// Memory Track device writes....
+			if ((address >= 0x800000) && (address <= 0x87FFFE))
+			{
+				if (((TOMGetMEMCON1() & 0x0006) == (2 << 1)) && (jaguarMainROMCRC32 == 0xFDF37F47))
+				{
+					MTWriteWord(address, value);
+					return;
+				}
+			}
+
 			if ((address >= 0xDFFF00) && (address <= 0xDFFFFE))
 			{
 				CDROMWriteWord(address, value, M68K);
@@ -1632,76 +1785,65 @@ if (address == 0xF02110)
 					}
 					else
 					{
-						jaguar_unknown_writeword(address, value, M68K);
+						if ((address >= 0x800000) && (address <= 0xDFFEFE))
+						{
+							SET16(jagMemSpace, address, value);
+						}
+						else
+						{
+							jaguar_unknown_writeword(address, value, M68K);
 #ifdef LOG_UNMAPPED_MEMORY_ACCESSES
-						WriteLog("\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));
+							WriteLog("\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));
 #endif
+						}
 					}
 				}
 			}
 		}
-	}
 #else
-	MMUWrite16(address, value, M68K);
+		MMUWrite16(address, value, M68K);
 #endif
+	}
 }
 
 
-// 
+// Memory write location on 32 bits
 void m68k_write_memory_32(unsigned int address, unsigned int value)
 {
-#if 1
-	m68k_write_memory_check(address, "32", value);
-#else
-#ifdef ALPINE_FUNCTIONS
-	// Check if breakpoint on memory is active, and deal with it
-	if (bpmActive && address == bpmAddress1)
-	{
-		M68KDebugHalt();
-	}
-	else
-#endif
-	{
-		// Rom writing authorisation detection
-		if (!vjs.allowWritesToROM && ((address >= 0x800000) && (address < 0xe00000)))
-		{
-			m68k_write_cartridge_alert(address, "32", value);
-		}
-	}
-#endif
-
-	// Musashi does this automagically for you, UAE core does not :-P
-	//address &= 0x00FFFFFF;
-/*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 >= 0xF03214 && address < 0xF0321F)
-	WriteLog("M68K: Writing DWORD (%08X) to GPU RAM (%08X)...\n", value, address);//*/
-//M68K: Writing DWORD (88E30047) to GPU RAM (00F03214)...
-/*extern bool doGPUDis;
-if (address == 0xF03214 && value == 0x88E30047)
-//	start = true;
-	doGPUDis = true;//*/
-/*	if (address == 0x51136 || address == 0xFB074)
-		WriteLog("[WM32  PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
-//Testing AvP on UAE core...
-//000075A0: FFFFF80E B6320220 (BITMAP)
-/*if (address == 0x75A0 && (value & 0xFFFF0000) == 0xFFFF0000)
-{
-	printf("\nM68K: (32) Tripwire hit...\n");
-	ShowM68KContext();
-}//*/
+	// Check memory write location on 32 bits
+	if (!m68k_write_memory_check(address, "32", value))
+	{
+		// Musashi does this automagically for you, UAE core does not :-P
+		//address &= 0x00FFFFFF;
+	/*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 >= 0xF03214 && address < 0xF0321F)
+				WriteLog("M68K: Writing DWORD (%08X) to GPU RAM (%08X)...\n", value, address);//*/
+				//M68K: Writing DWORD (88E30047) to GPU RAM (00F03214)...
+				/*extern bool doGPUDis;
+				if (address == 0xF03214 && value == 0x88E30047)
+				//	start = true;
+					doGPUDis = true;//*/
+					/*	if (address == 0x51136 || address == 0xFB074)
+							WriteLog("[WM32  PC=%08X] Addr: %08X, val: %02X\n", m68k_get_reg(NULL, M68K_REG_PC), address, value);//*/
+							//Testing AvP on UAE core...
+							//000075A0: FFFFF80E B6320220 (BITMAP)
+							/*if (address == 0x75A0 && (value & 0xFFFF0000) == 0xFFFF0000)
+							{
+								printf("\nM68K: (32) Tripwire hit...\n");
+								ShowM68KContext();
+							}//*/
 
 #ifndef USE_NEW_MMU
-	m68k_write_memory_16(address, value >> 16);
-	m68k_write_memory_16(address + 2, value & 0xFFFF);
+		m68k_write_memory_16(address, value >> 16);
+		m68k_write_memory_16(address + 2, value & 0xFFFF);
 #else
-	MMUWrite32(address, value, M68K);
+		MMUWrite32(address, value, M68K);
 #endif
+	}
 }
 
 
@@ -2213,6 +2355,7 @@ memset(jaguarMainRAM + 0x804, 0xFF, 4);
 	TOMInit();
 	JERRYInit();
 	CDROMInit();
+	m68k_brk_init();
 }
 
 
@@ -2258,7 +2401,6 @@ void JaguarReset(void)
 	CDROMReset();
     m68k_pulse_reset();								// Reset the 68000
 	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
 //	SetCallbackTime(ScanlineCallback, 63.5555);
 //	SetCallbackTime(ScanlineCallback, 31.77775);
@@ -2368,6 +2510,7 @@ void JaguarDone(void)
 	DSPDone();
 	TOMDone();
 	JERRYDone();
+	m68k_brk_close();
 
 	// temp, until debugger is in place
 //00802016: jsr     $836F1A.l