update latch

Author: callsop

CpuCommon.h

@@ -1,54 +1,71 @@
 #pragma once
 
+//  Copyright 2015 by Joseph Forgion
+//  This file is part of VCC (Virtual Color Computer).
 //
-// access cc flags 
+//  VCC (Virtual Color Computer) is free software: you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  VCC (Virtual Color Computer) is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with VCC. If not, see <http://www.gnu.org/licenses/>.
+//
+//  2025/05/22 - Craig Allsop - Interrupt handling.
+//
+
+// no includes here, included by 6809.c, 6309.c
+
+//
+// Access cc flags as boolean
 //
 static inline bool CC(char flag) 
 {
 	return cc[flag] ? true : false; 
 }
 
 //
-// interrupt lines (active low)
+// Interrupt lines reading from output of the latch
 //
-static inline bool FIRQ() { return InterruptLatch & Bit(INT_FIRQ) ? true : false; }
-static inline bool IRQ() { return InterruptLatch & Bit(INT_IRQ) ? true : false; }
-static inline bool NMI() { return InterruptLatch & Bit(INT_NMI) ? true : false; }
+static inline bool FIRQ() { return InterruptLatch.Q & Bit(INT_FIRQ) ? true : false; }
+static inline bool IRQ() { return InterruptLatch.Q & Bit(INT_IRQ) ? true : false; }
+static inline bool NMI() { return InterruptLatch.Q & Bit(INT_NMI) ? true : false; }
 
 //
-// latch the interrupt lines, done per instruction top of state A (see figure 15, 6809 spec)
+// Latch the interrupt lines
+// This done per instruction top of state A (see figure 15, 6809 spec) and also waiting in SYNC
 //
 static inline void LatchInterrupts()
 {
-	InterruptLatch = 0;
+	uint8_t OR = 0;
 	for (int is = 0; is < IS_MAX; ++is)
-		InterruptLatch |= InterruptLine[is];
+		OR |= InterruptLine[is];
+
+	// clock next input
+	InterruptLatch.Clock(OR);
 }
 
 //
-// clear the nmi interrupt
+// Clear the nmi interrupt
 //
 static inline void ClearNMI()
 {
 	InterruptLine[IS_NMI] &= BitMask(INT_NMI);
+	LatchInterrupts();
 }
 
 //
-// clear state of all interrupt lines
-//
-static inline void ClearInterrupt(Interrupt interrupt)
-{
-	for (int is = 0; is < IS_MAX; ++is)
-		InterruptLine[is] &= BitMask(interrupt);
-}
-
-//
-// clear state of all interrupt lines
+// Clear state of all interrupt lines
 //
 static inline void ClearInterrupts()
 {
-	InterruptLatch = 0;
 	for (int is = 0; is < IS_MAX; ++is)
 		InterruptLine[is] = 0;
+	InterruptLatch.Reset();
 }
 

defines.h

@@ -155,6 +155,24 @@ namespace VCC
         void Check() {}
     };
 #endif
+
+    // d type flip flop
+    struct DFF 
+    {
+        uint8_t D{}; // d input
+        uint8_t Q{}; // q output
+
+        void Reset()
+        {
+            D = Q = 0;
+        }
+
+        void Clock(uint8_t d)
+        {
+            Q = D;
+            D = d;
+        }
+    };
 }
 
 struct SystemState

hd6309.c

@@ -129,7 +129,7 @@ static unsigned int  temp32;
 static int stemp32;
 static unsigned char temp8; 
 static unsigned char InterruptLine[IS_MAX] = { 0 };
-static unsigned char InterruptLatch = 0;
+static VCC::DFF InterruptLatch;
 static unsigned char Source=0,Dest=0;
 static unsigned char postbyte=0;
 static short unsigned postword=0;
@@ -7544,8 +7544,9 @@ void HD6309AssertInterupt(InterruptSource src, Interrupt interrupt)
 	assert(src >= IS_NMI && src < IS_MAX);
 	assert(interrupt >= INT_IRQ && interrupt <= INT_NMI);
 
-	SyncWaiting=0;
-	InterruptLine[src] |= Bit(interrupt);
+	if (SyncWaiting)
+		LatchInterrupts();
+	SyncWaiting = 0;
 
 	if (EmuState.Debugger.IsTracing())
 		EmuState.Debugger.TraceCaptureInterruptRequest(interrupt, CycleCounter, HD6309GetState());

mc6809.c

@@ -63,7 +63,7 @@ static unsigned int temp32;
 static unsigned short temp16;
 static unsigned char temp8;
 static unsigned char InterruptLine[IS_MAX] = { 0 };
-static unsigned char InterruptLatch = 0;
+static VCC::DFF InterruptLatch;
 static unsigned char Source=0,Dest=0;
 static unsigned char postbyte=0;
 static short unsigned postword=0;
@@ -3229,8 +3229,10 @@ void MC6809AssertInterupt(InterruptSource src, Interrupt interrupt)
 	assert(src >= IS_NMI && src < IS_MAX);
 	assert(interrupt >= INT_IRQ && interrupt <= INT_NMI);
 
-	SyncWaiting = 0;
 	InterruptLine[src] |= Bit(interrupt);
+	if (SyncWaiting)
+		LatchInterrupts();
+	SyncWaiting = 0;
 
 	if (EmuState.Debugger.IsTracing())
 		EmuState.Debugger.TraceCaptureInterruptRequest(interrupt, CycleCounter, MC6809GetState());