Implement hardware virtual memory

7 files changed, 134 insertions, 18 deletions

diff --git a/tb/avalon.hpp b/tb/avalon.hpp
index f37b306..763065c 100644
--- a/tb/avalon.hpp
+++ b/tb/avalon.hpp
@@ -80,7 +80,7 @@ namespace taller::avalon
 			void attach(slave &dev);
 			void bail() noexcept;
 
-			std::uint32_t dump(std::uint32_t addr);
+			bool dump(std::uint32_t addr, std::uint32_t &word);
 			void patch(std::uint32_t addr, std::uint32_t readdata);
 
 		private:
@@ -100,7 +100,7 @@ namespace taller::avalon
 			bool                 avl_read       = false;
 			bool                 avl_write      = false;
 
-			slave &resolve_external(std::uint32_t avl_address);
+			slave *resolve_external(std::uint32_t avl_address);
 	};
 }
 
diff --git a/tb/avalon.impl.hpp b/tb/avalon.impl.hpp
index 3af60d0..4dee4f2 100644
--- a/tb/avalon.impl.hpp
+++ b/tb/avalon.impl.hpp
@@ -125,49 +125,55 @@ namespace taller::avalon
 	}
 
 	template<class Platform>
-	std::uint32_t interconnect<Platform>::dump(std::uint32_t addr)
+	bool interconnect<Platform>::dump(std::uint32_t addr, std::uint32_t &word)
 	{
 		std::uint32_t avl_address = addr << 2;
-		auto &dev = resolve_external(avl_address);
 
-		auto pos = (avl_address & ~dev.address_mask()) >> dev.word_bits();
+		auto *dev = resolve_external(avl_address);
+		if(!dev)
+		{
+			return false;
+		}
+
+		auto pos = (avl_address & ~dev->address_mask()) >> dev->word_bits();
 
-		std::uint32_t readdata;
-		while(!dev.read(pos, readdata))
+		while(!dev->read(pos, word))
 		{
 			continue;
 		}
 
-		return readdata;
+		return true;
 	}
 
 	template<class Platform>
 	void interconnect<Platform>::patch(std::uint32_t addr, std::uint32_t writedata)
 	{
 		std::uint32_t avl_address = addr << 2;
-		auto &dev = resolve_external(avl_address);
 
-		auto pos = (avl_address & ~dev.address_mask()) >> dev.word_bits();
+		auto *dev = resolve_external(avl_address);
+		assert(dev);
+
+		auto pos = (avl_address & ~dev->address_mask()) >> dev->word_bits();
 
-		while(!dev.write(pos, writedata, 0b1111))
+		while(!dev->write(pos, writedata, 0b1111))
 		{
 			continue;
 		}
 	}
 
 	template<class Platform>
-	slave& interconnect<Platform>::resolve_external(std::uint32_t avl_address)
+	slave* interconnect<Platform>::resolve_external(std::uint32_t avl_address)
 	{
 		for(auto &binding : devices)
 		{
 			if((avl_address & binding.mask) == binding.base)
 			{
-				return binding.dev;
+				return &binding.dev;
 			}
 		}
 
 		fprintf(stderr, "[avl] attempt to access hole at 0x%08x\n", avl_address);
-		assert(false);
+		return nullptr;
 	}
 }
 
diff --git a/tb/mem.impl.hpp b/tb/mem.impl.hpp
index f7bb424..e3c11e8 100644
--- a/tb/mem.impl.hpp
+++ b/tb/mem.impl.hpp
@@ -38,7 +38,7 @@ namespace taller::avalon
 	bool mem<Cell>::read(std::uint32_t addr, std::uint32_t &data)
 	{
 		data = block[addr];
-		return ready();
+		return true;/*ready();*/
 	}
 
 	template<typename Cell>
@@ -67,7 +67,7 @@ namespace taller::avalon
 		}
 
 		block[addr] = (data & bytes) | (block[addr] & ~bytes);
-		return ready();
+		return true;/*ready();*/
 	}
 
 	template<typename Cell>
diff --git a/tb/sim/descifrador.py b/tb/sim/descifrador.py
index 5d81686..e754f2a 100644
--- a/tb/sim/descifrador.py
+++ b/tb/sim/descifrador.py
@@ -5,7 +5,7 @@ START = 0x10000
 
 loads = {START: FILE}
 consts = {0x30050000: 1, 0x30060000: 0}
-cycles = 20000000
+cycles = 23000000
 mem_dumps = [range(START, START + SIZE)]
 
 def final():
diff --git a/tb/sim/paging.S b/tb/sim/paging.S
new file mode 100644
index 0000000..a2c1d14
--- /dev/null
+++ b/tb/sim/paging.S
@@ -0,0 +1,42 @@
+.global reset
+reset:
+	# Copy code to page 3
+	ldr  r0, =virtual_start
+	ldr  r1, =0x3000
+	ldr  r2, =256
+	.copy_virtual:
+	ldr  r3, [r0], #4
+	str  r3, [r1], #4
+	subs r2, r2, #4
+	bne  .copy_virtual
+
+	# Translation tables
+	mov r0, #0x4000
+	ldr r1, =0x00005001
+	str r1, [r0]
+
+	mov r1, #0x5000
+	ldr r2, =0x00000002
+	str r2, [r1], #4
+	str r2, [r1], #4
+	str r2, [r1], #4
+	str r2, [r1], #4
+	ldr r2, =0x00003002
+	str r2, [r1], #4
+
+	# Set translation base and enable MMU
+	mov r1, #(1 << 0)
+	mcr p15, 0, r0, c2, c0, 0
+	mcr p15, 0, r1, c1, c0, 0
+
+	# Self-relocate to 0x2000 (mirror of 0x0000)
+	ldr r1, =#(0x2000 - 4)
+	add pc, pc, r1
+
+	# Jump to virtual_start (phys: 0x3000, virt: 0x4000)
+	ldr r0, =0x01234567
+	ldr pc, =0x4000
+
+virtual_start:
+	ldr r1, =0x89abcdef
+	mov pc, lr
diff --git a/tb/sim/paging.py b/tb/sim/paging.py
new file mode 100644
index 0000000..799f03d
--- /dev/null
+++ b/tb/sim/paging.py
@@ -0,0 +1,5 @@
+cycles = 4096
+
+def final():
+    assert_reg(r0, 0x01234567)
+    assert_reg(r1, 0x89abcdef)
diff --git a/tb/top/conspiracion.cpp b/tb/top/conspiracion.cpp
index 099baf3..b7ec3eb 100644
--- a/tb/top/conspiracion.cpp
+++ b/tb/top/conspiracion.cpp
@@ -17,6 +17,7 @@
 #include "Vconspiracion_platform.h"
 #include "Vconspiracion_vga_domain.h"
 #include "Vconspiracion_core_control.h"
+#include "Vconspiracion_core_mmu.h"
 #include "Vconspiracion_core_psr.h"
 #include "Vconspiracion_core_regs.h"
 #include "Vconspiracion_core_reg_file.h"
@@ -431,6 +432,57 @@ int main(int argc, char **argv)
 
 	auto do_mem_dump = [&](const mem_region *dumps, std::size_t count)
 	{
+		bool mmu_enabled = top.conspiracion->core->mmu->mmu_enable;
+		std::uint32_t ttbr = top.conspiracion->core->mmu->mmu_ttbr;
+
+		auto pagewalk = [&](std::uint32_t &addr)
+		{
+			if(!mmu_enabled)
+			{
+				return true;
+			}
+
+			std::uint32_t entry;
+			if(!avl.dump(ttbr << 12 | addr >> 18, entry))
+			{
+				return false;
+			}
+
+			switch(entry & 0b11)
+			{
+				case 0b01:
+					break;
+
+				case 0b10:
+					addr = (entry & ~((1 << 20) - 1)) >> 2 | (addr & ((1 << 18) - 1));
+					return true;
+
+				default:
+					return false;
+			}
+
+			std::uint32_t entryaddr = (entry & ~((1 << 10) - 1)) >> 2 | ((addr >> 10) & ((1 << 8) - 1));
+			if(!avl.dump(entryaddr, entry))
+			{
+				return false;
+			}
+
+			switch(entry & 0b11)
+			{
+				case 0b01:
+					addr = (entry & ~((1 << 16) - 1)) >> 2 | (addr & ((1 << 14) - 1));
+					return true;
+
+				case 0b10:
+				case 0b11:
+					addr = (entry & ~((1 << 12) - 1)) >> 2 | (addr & ((1 << 10) - 1));
+					return true;
+
+				default:
+					return false;
+			}
+		};
+
 		std::fputs("=== dump-mem ===\n", ctrl);
 		for(std::size_t i = 0; i < count; ++i)
 		{
@@ -439,7 +491,18 @@ int main(int argc, char **argv)
 			std::fprintf(ctrl, "%08x ", static_cast<std::uint32_t>(dump.start));
 			for(std::size_t i = 0; i < dump.length; ++i)
 			{
-				auto word = avl.dump(dump.start + i);
+				std::uint32_t at = dump.start + i;
+				if(!pagewalk(at))
+				{
+					break;
+				}
+
+				std::uint32_t word;
+				if(!avl.dump(at, word))
+				{
+					break;
+				}
+
 				word = (word & 0xff) << 24
 					 | ((word >> 8) & 0xff) << 16
 					 | ((word >> 16) & 0xff) << 8