DuckDuckWhale/yuzu
1
0
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-12-16 19:56:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

start of 3DS memory map

Browse Source
This commit is contained in:
ShizZy 2013-09-05 23:04:04 -04:00
parent d708e2d68a
commit 62d873da3e
5 changed files with 80 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/src/common_funcs.h
View File

@ -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__))

10
src/common/src/mem_arena.cpp
View File

@ -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;
}

3
src/common/src/mem_arena.h
View File

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

52
src/core/src/mem_map.cpp
View File

@ -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

29
src/core/src/mem_map.h
View File

@ -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;
extern u8* g_vram;
// Base is a pointer to the base of the memory map. Yes, some MMU tricks
// 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;
extern u32 g_memory_mask;
// In 64-bit, this might point to "high memory" (above the 32-bit limit),
// 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();