GIF: Introduce the GIF FIFO

* The GIF similarly to the VIF also contains a 16 qword FIFO
for queueing data. The implementation is very similar to the VIF
and I used similar function names to make it easier to follow.

* In addition introduce proper reset routines. Messing with the
this pointer is not possible in our case, because it breaks the
Handler infrastructure that relies on the pointer not changing.

src/common/emulator.cc

@@ -193,6 +193,7 @@ namespace common
             dmac->tick(cycles);
             vif[0]->tick(cycles);
             vif[1]->tick(cycles);
+            gif->tick(cycles);
 
             /* Tick IOP components */
             cycles /= 4;

src/cpu/ee/dmac.cc

@@ -199,16 +199,20 @@ namespace ee
 						{
 							auto& gif = emulator->gif;
 							uint128_t qword = *(uint128_t*)&emulator->ee->ram[channel.address];
-							uint64_t upper = qword >> 64, lower = qword;
-							fmt::print("[DMAC][GIF] Writing {:#x}{:016x} to PATH3\n", upper, lower);
 
-							gif->write_path3(0x10006000, qword);
-							channel.address += 16;
-							channel.qword_count--;
+							/* Send data to the PATH3 port of the GIF */
+							if (gif->write_path3(NULL, qword))
+							{
+								uint64_t upper = qword >> 64, lower = qword;
+								fmt::print("[DMAC][GIF] Writing {:#x}{:016x} to PATH3\n", upper, lower);
 
-							assert(!channel.control.mode);
-							if (!channel.qword_count)
-								channel.end_transfer = true;
+								channel.address += 16;
+								channel.qword_count--;
+
+								assert(!channel.control.mode);
+								if (!channel.qword_count)
+									channel.end_transfer = true;
+							}
 
 							break;
 						}

src/cpu/vu/vif.cc

@@ -48,7 +48,13 @@ namespace vu
 	void VIF::reset()
 	{
 		/* Reset all the VIF registers */
-		*this = VIF(emulator, id);
+		status = {}; fbrst = {}; cycle = {};
+		err = mark = mode = num = 0;
+		mask = code = itops = 0;
+		base = ofst = tops = itop = top = 0;
+		rn = {}; cn = {}; fifo = {}; command = {};
+		subpacket_count = address = qwords_written = word_cycles = 0;
+		write_mode = WriteMode::Skipping;
 	}
 
 	uint32_t VIF::read(uint32_t address)
@@ -81,6 +87,11 @@ namespace vu
 			break;
 		case 1:
 			fbrst.value = data;
+			
+			/* Reset VIF is RST bit is set */
+			if (fbrst.reset)
+				reset();
+			
 			break;
 		case 2:
 			err = data;

src/cpu/vu/vif.h

 #pragma once
 #include <common/component.h>
-#include <queue>
 #include <utils/queue.h>
+#include <array>
 
 namespace common
 {
@@ -176,7 +176,7 @@ namespace vu
 		/* These only on exist on VIF1 */
 		uint32_t base = 0, ofst = 0;
 		uint32_t tops = 0, itop = 0, top = 0;
-		uint32_t rn[4] = {}, cn[4] = {};
+		std::array<uint32_t, 4> rn = {}, cn = {};
 
 		/* VIF FIFO */
 		util::Queue<uint32_t, 64> fifo;

src/gs/gif.cc

@@ -29,56 +29,104 @@ namespace gs
 	
 	uint32_t GIF::read(uint32_t addr)
 	{
-		assert(addr <= 0x100030A0);
-
-		uint32_t offset = (addr & 0xf0) >> 4;
-		auto ptr = (uint32_t*)&regs + offset;
-
-		fmt::print("[GIF] Read {:#x} from {}\n", *ptr, REGS[offset]);
+		uint32_t data;
+		auto offset = (addr & 0xf0) >> 4;
+		switch (offset)
+		{
+		case 2:
+			/* TODO: repoth PATH status */
+			status.fifo_count = fifo.size<uint128_t>();
+			data = status.value;
+			break;
+		default:
+			fmt::print("[GIF] Read from unknown register {}\n", REGS[offset]);
+			std::abort();
+		}
 
-		return *ptr;
+		return data;
 	}
 	
 	void GIF::write(uint32_t addr, uint32_t data)
 	{
-		assert(addr <= 0x100030A0);
+		auto offset = (addr & 0xf0) >> 4;
+		switch (offset)
+		{
+		case 0:
+			control.value = data;
+			
+			/* Reset the GIF when the RST bit is set */
+			if (control.reset)
+				reset();
+			
+			break;
+		default:
+			fmt::print("[GIF] Write to unknown register {}\n", REGS[offset]);
+			std::abort();
+		}
 
-		uint32_t offset = (addr & 0xf0) >> 4;
-		auto ptr = (uint32_t*)&regs + offset;
+		fmt::print("[GIF] Writing {:#x} to {}\n", data, REGS[offset]);
+	}
 
-		fmt::print("[GIF] Write {:#x} to {}\n", data, REGS[offset]);
+	void GIF::tick(uint32_t cycles)
+	{
+		while (!fifo.empty() && cycles--)
+		{
+			if (!data_count)
+				process_tag();
+			else
+				execute_command();
+		}
+	}
 
-		*ptr = data;
+	void GIF::reset()
+	{
+		/* Reset all class members */
+		control = {};
+		mode = 0;
+		status = {};
+		fifo = {};
+		tag = {};
+		data_count = reg_count = 0;
+		interal_Q = 0;
 	}
 	
-	void GIF::write_path3(uint32_t addr, uint128_t qword)
+	bool GIF::write_path3(uint32_t, uint128_t qword)
 	{
-		assert(addr == 0x10006000);
-
-		if (!data_count) /* Initiallize tag */
+		return fifo.push<uint128_t>(qword);
+	}
+	
+	void GIF::process_tag()
+	{
+		if (fifo.read(&tag.value))
 		{
-			auto& gs_regs = emulator->gs->regs;
-			tag.value = qword;
 			data_count = tag.nloop;
 			reg_count = tag.nreg;
 
+			auto& gs_regs = emulator->gs->regs;
 			fmt::print("[GIF] Received new GS primitive!\n");
 
-			/* Set the GS PRIM register to the PRIM field of GIFTag.
+			/* Set the GS PRIM register to the PRIM field of GIFTag
 			   NOTE: This only happens when PRE == 1 */
-			if (tag.pre)
-				gs_regs.prim = tag.prim;
+			gs_regs.prim = tag.pre ? tag.prim : gs_regs.prim;
 
 			/* The initial value of Q is 1.0f and is set
 			   when the GIFTag is read */
 			gs_regs.rgbaq.q = 1.0f;
+
+			/* Remove tag from fifo */
+			fifo.pop<uint128_t>();
 		}
-		else
+	}
+
+	void GIF::execute_command()
+	{
+		uint128_t qword;
+		if (fifo.read(&qword))
 		{
 			uint16_t format = tag.flg;
 			switch (format)
 			{
-			case Format::PACKED:
+			case Format::Packed:
 			{
 				process_packed(qword);
 				if (!reg_count)
@@ -88,12 +136,10 @@ namespace gs
 				}
 				break;
 			}
-			case Format::IMAGE:
+			case Format::Image:
 			{
-				uint64_t lower = qword;
-				uint64_t upper = qword >> 64;
-				emulator->gs->write_hwreg(lower);
-				emulator->gs->write_hwreg(upper);
+				emulator->gs->write_hwreg(qword);
+				emulator->gs->write_hwreg(qword >> 64);
 				data_count--;
 				break;
 			}
@@ -101,9 +147,11 @@ namespace gs
 				fmt::print("[GIF] Unknown format {:d}\n", format);
 				std::abort();
 			}
+
+			fifo.pop<uint128_t>();
 		}
 	}
-	
+
 	void GIF::process_packed(uint128_t qword)
 	{
 		int curr_reg = tag.nreg - reg_count;

src/gs/gif.h

 #pragma once
 #include <common/component.h>
+#include <utils/queue.h>
 
 namespace common
 {
@@ -8,40 +9,37 @@ namespace common
 
 namespace gs
 {
-	union GIFSTAT
+	union GIFCTRL
 	{
 		uint32_t value;
 		struct
 		{
-			uint32_t M3R : 1;
-			uint32_t M3P : 1;
-			uint32_t IMT : 1;
-			uint32_t PSE : 1;
-			uint32_t IP3 : 1;
-			uint32_t P3Q : 1;
-			uint32_t P2Q : 1;
-			uint32_t P1Q : 1;
-			uint32_t OPH : 1;
-			uint32_t APATH : 2;
-			uint32_t DIR : 1;
-			uint32_t : 12;
-			uint32_t FQC : 5;
-			uint32_t : 3;
+			uint32_t reset : 1;
+			uint32_t : 2;
+			uint32_t stop : 1;
 		};
 	};
 
-	struct GIFRegs
+	union GIFSTAT
 	{
-		uint32_t GIF_CTRL;
-		uint32_t GIF_MODE;
-		GIFSTAT GIF_STAT;
-		uint32_t GIF_TAG0;
-		uint32_t GIF_TAG1;
-		uint32_t GIF_TAG2;
-		uint32_t GIF_TAG3;
-		uint32_t GIF_CNT;
-		uint32_t GIF_P3CNT;
-		uint32_t GIF_P3TAG;
+		uint32_t value;
+		struct
+		{
+			uint32_t path3_mask : 1;
+			uint32_t path3_vif_mask : 1;
+			uint32_t path3_imt : 1;
+			uint32_t stop : 1;
+			uint32_t : 1;
+			uint32_t path3_interrupted : 1;
+			uint32_t path3_queued : 1;
+			uint32_t path2_queued : 1;
+			uint32_t path1_queued : 1;
+			uint32_t output_path : 1;
+			uint32_t active_path : 2;
+			uint32_t direction : 1;
+			uint32_t : 12;
+			uint32_t fifo_count : 5;
+		};
 	};
 
 	/* The header of each GS Primitive */
@@ -82,31 +80,43 @@ namespace gs
 
 	enum Format : uint32_t
 	{
-		PACKED = 0,
-		REGLIST = 1,
-		IMAGE = 2,
+		Packed = 0,
+		Reglist = 1,
+		Image = 2,
 		Disable = 3
 	};
 
 	struct GIF : public common::Component
 	{
 		GIF(common::Emulator* parent);
-		
+		~GIF() = default;
+
+		void tick(uint32_t cycles);
+		void reset();
+
 		uint32_t read(uint32_t addr);
 		void write(uint32_t addr, uint32_t data);
 
 		/* Writes from various PATHs */
-		void write_path3(uint32_t addr, uint128_t data);
+		bool write_path3(uint32_t, uint128_t data);
 
 	private:
+		void process_tag();
+		void execute_command();
+
 		void process_packed(uint128_t qword);
 
 	private:
 		common::Emulator* emulator;
-		GIFRegs regs = {};
 		
+		/* GIF registers */
+		GIFCTRL control = {};
+		uint32_t mode = 0;
+		GIFSTAT status = {};
+		util::Queue<uint32_t, 64> fifo;
+
 		/* Used during transfers */
-		GIFTag tag;
+		GIFTag tag = {};
 		int data_count = 0, reg_count = 0;
 
 		/* Stores the last Q value provided by ST */