From 09ffe87360f39a76b084fe1c9bac2330d6f6f790 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 17 Apr 2014 21:05:34 -0400
Subject: more various refactors to memory interface

---
 src/core/mem_map_funcs.cpp | 40 +++++++++++++++++-----------------------
 1 file changed, 17 insertions(+), 23 deletions(-)

(limited to 'src/core/mem_map_funcs.cpp')

diff --git a/src/core/mem_map_funcs.cpp b/src/core/mem_map_funcs.cpp
index bb83855fe..40d9dab3a 100644
--- a/src/core/mem_map_funcs.cpp
+++ b/src/core/mem_map_funcs.cpp
@@ -15,8 +15,8 @@ u32 _AddressPhysicalToVirtual(const u32 addr) {
     // Our memory interface read/write functions assume virtual addresses. Put any physical address 
     // to virtual address translations here. This is obviously quite hacky... But we're not doing 
     // any MMU emulation yet or anything
-    if (((addr & 0xF0000000) == MEM_FCRAM_PADDR) && (addr < (MEM_FCRAM_PADDR_END))) {
-        return (addr & MEM_FCRAM_MASK) | MEM_FCRAM_VADDR;
+    if ((addr >= FCRAM_PADDR) && (addr < (FCRAM_PADDR_END))) {
+        return (addr & FCRAM_MASK) | FCRAM_VADDR;
     }
     return addr;
 }
@@ -40,15 +40,15 @@ inline void _Read(T &var, const u32 addr) {
     } else if ((vaddr & 0xFF000000) == 0x10000000 || (vaddr & 0xFF000000) == 0x1E000000) {
         HW::Read<T>(var, vaddr);
 
-    // FCRAM
-    } else if ((vaddr > MEM_FCRAM_VADDR)  && (vaddr < MEM_FCRAM_VADDR_END)) {
-        var = *((const T*)&g_fcram[vaddr & MEM_FCRAM_MASK]);
+    // FCRAM - application heap
+    } else if ((vaddr > HEAP_VADDR)  && (vaddr < HEAP_VADDR_END)) {
+        var = *((const T*)&g_heap[vaddr & HEAP_MASK]);
 
     /*else if ((vaddr & 0x3F800000) == 0x04000000) {
         var = *((const T*)&m_pVRAM[vaddr & VRAM_MASK]);*/
 
     } else {
-        _assert_msg_(MEMMAP, false, "unknown Read%d @ 0x%08X", sizeof(var) * 8, vaddr);
+        //_assert_msg_(MEMMAP, false, "unknown Read%d @ 0x%08X", sizeof(var) * 8, vaddr);
     }
 }
 
@@ -66,20 +66,14 @@ inline void _Write(u32 addr, const T data) {
     // 0x10XXXXXX- is physical address space, 0x1EXXXXXX is virtual address space
     } else if ((vaddr & 0xFF000000) == 0x10000000 || (vaddr & 0xFF000000) == 0x1E000000) {
         HW::Write<T>(vaddr, data);
-    
-    // ExeFS:/.code is loaded here:
-    } else if ((vaddr & 0xFFF00000) == 0x00100000) {
-        // TODO(ShizZy): This is dumb... handle correctly. From 3DBrew:
-        // http://3dbrew.org/wiki/Memory_layout#ARM11_User-land_memory_regions
-        // The ExeFS:/.code is loaded here, executables must be loaded to the 0x00100000 region when
-        // the exheader "special memory" flag is clear. The 0x03F00000-byte size restriction only 
-        // applies when this flag is clear. Executables are usually loaded to 0x14000000 when the 
-        // exheader "special memory" flag is set, however this address can be arbitrary.
-        *(T*)&g_fcram[vaddr & MEM_FCRAM_MASK] = data;
-
-    // FCRAM
-    } else if ((vaddr > MEM_FCRAM_VADDR)  && (vaddr < MEM_FCRAM_VADDR_END)) {
-        *(T*)&g_fcram[vaddr & MEM_FCRAM_MASK] = data;
+
+    // FCRAM - GSP heap
+    //} else if ((vaddr > HEAP_GSP_VADDR)  && (vaddr < HEAP_VADDR_GSP_END)) {
+    //    *(T*)&g_heap_gsp[vaddr & FCRAM_MASK] = data;
+
+    // FCRAM - application heap
+    } else if ((vaddr > HEAP_VADDR)  && (vaddr < HEAP_VADDR_END)) {
+        *(T*)&g_heap[vaddr & HEAP_MASK] = data;
 
     } else if ((vaddr & 0xFF000000) == 0x14000000) {
         _assert_msg_(MEMMAP, false, "umimplemented write to GSP heap");
@@ -104,9 +98,9 @@ inline void _Write(u32 addr, const T data) {
 u8 *GetPointer(const u32 addr) {
     const u32 vaddr = _AddressPhysicalToVirtual(addr);
 
-    // FCRAM
-    if ((vaddr > MEM_FCRAM_VADDR)  && (vaddr < MEM_FCRAM_VADDR_END)) {
-        return g_fcram + (vaddr & MEM_FCRAM_MASK);
+    // FCRAM - application heap
+    if ((vaddr > HEAP_VADDR)  && (vaddr < HEAP_VADDR_END)) {
+        return g_heap + (vaddr & HEAP_MASK);
 
     } else {
         ERROR_LOG(MEMMAP, "Unknown GetPointer @ 0x%08x", vaddr);
-- 
cgit v1.2.3