start of 3DS memory map

src/common/src/common_funcs.h

@@ -22,6 +22,8 @@ template<> struct CompileTimeAssert<true> {};
 #define b32(x)  (b16(x) | (b16(x) >>16) )
 #define ROUND_UP_POW2(x)	(b32(x - 1) + 1)
 
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
 #if defined __GNUC__ && !defined __SSSE3__ && !defined _M_GENERIC
 #include <emmintrin.h>
 static __inline __m128i __attribute__((__always_inline__))

src/common/src/mem_arena.cpp

@@ -163,14 +163,6 @@ u8* MemArena::Find4GBBase()
 }
 
 
-// yeah, this could also be done in like two bitwise ops...
-#define SKIP(a_flags, b_flags) \
-	if (!(a_flags & MV_WII_ONLY) && (b_flags & MV_WII_ONLY)) \
-		continue; \
-	if (!(a_flags & MV_FAKE_VMEM) && (b_flags & MV_FAKE_VMEM)) \
-		continue; \
-
-
 static bool Memory_TryBase(u8 *base, const MemoryView *views, int num_views, u32 flags, MemArena *arena) {
 	// OK, we know where to find free space. Now grab it!
 	// We just mimic the popular BAT setup.
@@ -189,7 +181,6 @@ static bool Memory_TryBase(u8 *base, const MemoryView *views, int num_views, u32
 	int i;
 	for (i = 0; i < num_views; i++)
 	{
-		SKIP(flags, views[i].flags);
 		if (views[i].flags & MV_MIRROR_PREVIOUS) {
 			position = last_position;
 		} else {
@@ -230,7 +221,6 @@ u8 *MemoryMap_Setup(const MemoryView *views, int num_views, u32 flags, MemArena
 
 	for (int i = 0; i < num_views; i++)
 	{
-		SKIP(flags, views[i].flags);
 		if ((views[i].flags & MV_MIRROR_PREVIOUS) == 0)
 			total_mem += views[i].size;
 	}

src/common/src/mem_arena.h

@@ -37,8 +37,7 @@ private:
 
 enum {
 	MV_MIRROR_PREVIOUS = 1,
-	MV_FAKE_VMEM = 2,
+	MV_IS_PRIMARY_RAM = 0x100,
-	MV_WII_ONLY = 4,
 };
 
 struct MemoryView

src/core/src/mem_map.cpp

@@ -22,10 +22,41 @@
  * http://code.google.com/p/gekko-gc-emu/
  */
 
+#include "common.h"
+#include "mem_arena.h"
+
 #include "mem_map.h"
+#include "core.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace Memory {
 
+	
+u8*	g_mem_base			= NULL;		///< The base pointer to the auto-mirrored arena.
+
+MemArena g_mem_arena;				///< The MemArena class
+
+u8* g_fcram				= NULL;		///< Main memory (FCRAM) pointer
+u8* g_vram				= NULL;		///< Video memory (VRAM) pointer
+
+u8* g_physical_fcram	= NULL;		///< Main physical memory (FCRAM)
+u8* g_physical_vram		= NULL;		///< Video physical memory (VRAM)
+
+// We don't declare the IO region in here since its handled by other means.
+static MemoryView g_mem_views[] =
+{
+	{NULL,		NULL,				0x00000000, MEM_BOOTROM_SIZE,		0},
+	{NULL,		NULL,				0x00010000, MEM_BOOTROM_SIZE,		MV_MIRROR_PREVIOUS},
+	{NULL,      NULL,				0x17E00000, MEM_MPCORE_PRIV_SIZE,	0},
+	{&g_vram,   &g_physical_vram,	0x18000000, MEM_VRAM_SIZE,			0},
+	{NULL,      NULL,				0x1FF00000, MEM_DSP_SIZE,			0},
+	{NULL,      NULL,				0x1FF80000, MEM_AXI_WRAM_SIZE,		0},
+	{&g_ram,    &g_physical_fcram,	0x20000000, MEM_FCRAM_SIZE,			MV_IS_PRIMARY_RAM},
+};
+
+static const int kNumMemViews = sizeof(g_mem_views) / sizeof(MemoryView);	///< Number of mem views
+
 u8 Read8(const u32 addr) {
 	return 0xDE;
 }
@@ -47,6 +78,27 @@ void Write16(const u32 addr, const u32 data) {
 void Write32(const u32 addr, const u32 data) {
 }
 
+void Init() {
+	int flags = 0;
+
+	for (size_t i = 0; i < ARRAY_SIZE(g_mem_views); i++) {
+		if (g_mem_views[i].flags & MV_IS_PRIMARY_RAM)
+			g_mem_views[i].size = MEMORY_SIZE;
+	}
+	g_base = MemoryMap_Setup(g_mem_views, kNumMemViews, flags, &g_mem_arena);
+
+	INFO_LOG(MEMMAP, "Memory system initialized. RAM at %p (mirror at 0 @ %p)", g_fcram, 
+		g_physical_fcram);
+}
+
+void Shutdown() {
+	u32 flags = 0;
+	MemoryMap_Shutdown(g_mem_views, kNumMemViews, flags, &g_mem_arena);
+	g_mem_arena.ReleaseSpace();
+	g_mem_base = NULL;
+	INFO_LOG(MEMMAP, "Memory system shut down.");
+}
+
 
 
 } // namespace

src/core/src/mem_map.h

@@ -32,13 +32,34 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define MEM_BOOTROM_SIZE		0x00010000	///< Bootrom (super secret code/data @ 0x8000) size
+#define MEM_MPCORE_PRIV_SIZE	0x00002000	///< MPCore private memory region size
+#define MEM_VRAM_SIZE			0x00600000	///< VRAM size
+#define MEM_DSP_SIZE			0x00080000	///< DSP memory size
+#define MEM_AXI_WRAM_SIZE		0x00080000	///< AXI WRAM size
+#define MEM_FCRAM_SIZE			0x08000000	///< FCRAM size
+
+#define MEMORY_SIZE				MEM_FCRAM_SIZE
+#define MEMORY_MASK				(MEM_FCRAM_SIZE - 1)	///< Main memory mask
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 namespace Memory {
 
-extern u8* g_ram;
+// Base is a pointer to the base of the memory map. Yes, some MMU tricks
-extern u8* g_vram;
+// are used to set up a full GC or Wii memory map in process memory.  on
+// 32-bit, you have to mask your offsets with 0x3FFFFFFF. This means that
+// some things are mirrored too many times, but eh... it works.
 
-extern u32 g_memory_size;
+// In 64-bit, this might point to "high memory" (above the 32-bit limit),
-extern u32 g_memory_mask;
+// so be sure to load it into a 64-bit register.
+extern u8 *g_base; 
+
+// These are guaranteed to point to "low memory" addresses (sub-32-bit).
+// 64-bit: Pointers to low-mem (sub-0x10000000) mirror
+// 32-bit: Same as the corresponding physical/virtual pointers.
+extern u8* g_ram;			///< Main memory
+extern u8* g_vram;			///< Video memory (VRAM)
 
 void Init();
 void Shutdown();