From a251721bf3a053ea012ac0b891826f3246273c82 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Tue, 12 May 2015 18:17:04 -0300 Subject: [PATCH 1/5] Memmap: Remove unused declarations --- src/core/mem_map.h | 9 --------- src/core/mem_map_funcs.cpp | 14 +++----------- 2 files changed, 3 insertions(+), 20 deletions(-) diff --git a/src/core/mem_map.h b/src/core/mem_map.h index 71f90cb8a..b6944deb4 100644 --- a/src/core/mem_map.h +++ b/src/core/mem_map.h @@ -134,20 +134,11 @@ extern u8* g_tls_mem; ///< TLS memory void Init(); void Shutdown(); -template -inline void Read(T &var, VAddr addr); - -template -inline void Write(VAddr addr, T data); - u8 Read8(VAddr addr); u16 Read16(VAddr addr); u32 Read32(VAddr addr); u64 Read64(VAddr addr); -u32 Read8_ZX(VAddr addr); -u32 Read16_ZX(VAddr addr); - void Write8(VAddr addr, u8 data); void Write16(VAddr addr, u16 data); void Write32(VAddr addr, u32 data); diff --git a/src/core/mem_map_funcs.cpp b/src/core/mem_map_funcs.cpp index a8e0fed07..f2da60cc6 100644 --- a/src/core/mem_map_funcs.cpp +++ b/src/core/mem_map_funcs.cpp @@ -225,27 +225,19 @@ u8 Read8(const VAddr addr) { u16 Read16(const VAddr addr) { u16_le data = 0; Read(data, addr); - return (u16)data; + return data; } u32 Read32(const VAddr addr) { u32_le data = 0; Read(data, addr); - return (u32)data; + return data; } u64 Read64(const VAddr addr) { u64_le data = 0; Read(data, addr); - return (u64)data; -} - -u32 Read8_ZX(const VAddr addr) { - return (u32)Read8(addr); -} - -u32 Read16_ZX(const VAddr addr) { - return (u32)Read16(addr); + return data; } void Write8(const VAddr addr, const u8 data) { From 7ada357b2d12cf616672425a8961804b865354d6 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Tue, 12 May 2015 22:38:29 -0300 Subject: [PATCH 2/5] Memmap: Re-organize memory function in two files memory.cpp/h contains definitions related to acessing memory and configuring the address space mem_map.cpp/h contains higher-level definitions related to configuring the address space accoording to the kernel and allocating memory. --- src/citra_qt/debugger/callstack.cpp | 2 +- src/citra_qt/debugger/disassembler.cpp | 2 +- .../debugger/graphics_framebuffer.cpp | 2 + src/citra_qt/debugger/ramview.cpp | 2 - src/core/CMakeLists.txt | 3 +- .../arm/dyncom/arm_dyncom_interpreter.cpp | 2 +- src/core/arm/interpreter/arminit.cpp | 1 - src/core/arm/skyeye_common/armmmu.h | 2 +- src/core/core.cpp | 1 - src/core/file_sys/archive_backend.cpp | 2 +- src/core/hle/config_mem.cpp | 2 +- src/core/hle/function_wrappers.h | 6 +- src/core/hle/kernel/address_arbiter.cpp | 2 +- src/core/hle/kernel/process.cpp | 2 +- src/core/hle/kernel/session.h | 2 +- src/core/hle/kernel/shared_memory.cpp | 2 +- src/core/hle/kernel/thread.cpp | 2 +- src/core/hle/kernel/thread.h | 1 - src/core/hle/service/gsp_gpu.cpp | 1 + src/core/hle/shared_page.cpp | 2 +- src/core/hle/svc.cpp | 2 +- src/core/hw/gpu.cpp | 2 +- src/core/loader/3dsx.cpp | 2 +- src/core/loader/elf.cpp | 2 +- src/core/loader/loader.cpp | 1 - src/core/loader/ncch.cpp | 2 +- src/core/mem_map.cpp | 97 +++++++++++- src/core/mem_map.h | 148 ------------------ src/core/{mem_map_funcs.cpp => memory.cpp} | 90 +---------- src/core/memory.h | 125 +++++++++++++++ src/video_core/pica.h | 2 - src/video_core/rasterizer.cpp | 2 + .../renderer_opengl/renderer_opengl.cpp | 2 +- src/video_core/vertex_shader.cpp | 2 - 34 files changed, 254 insertions(+), 266 deletions(-) rename src/core/{mem_map_funcs.cpp => memory.cpp} (68%) create mode 100644 src/core/memory.h diff --git a/src/citra_qt/debugger/callstack.cpp b/src/citra_qt/debugger/callstack.cpp index 3742c2d38..94e204717 100644 --- a/src/citra_qt/debugger/callstack.cpp +++ b/src/citra_qt/debugger/callstack.cpp @@ -8,7 +8,7 @@ #include "core/core.h" #include "core/arm/arm_interface.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "common/symbols.h" #include "core/arm/disassembler/arm_disasm.h" diff --git a/src/citra_qt/debugger/disassembler.cpp b/src/citra_qt/debugger/disassembler.cpp index 780607e82..e99ec1b30 100644 --- a/src/citra_qt/debugger/disassembler.cpp +++ b/src/citra_qt/debugger/disassembler.cpp @@ -7,7 +7,7 @@ #include "../bootmanager.h" #include "../hotkeys.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/core.h" #include "common/break_points.h" diff --git a/src/citra_qt/debugger/graphics_framebuffer.cpp b/src/citra_qt/debugger/graphics_framebuffer.cpp index 3287b4706..0c1a3f47f 100644 --- a/src/citra_qt/debugger/graphics_framebuffer.cpp +++ b/src/citra_qt/debugger/graphics_framebuffer.cpp @@ -10,6 +10,8 @@ #include #include "core/hw/gpu.h" +#include "core/memory.h" + #include "video_core/color.h" #include "video_core/pica.h" #include "video_core/utils.h" diff --git a/src/citra_qt/debugger/ramview.cpp b/src/citra_qt/debugger/ramview.cpp index 7149a0485..b6ebc7fc4 100644 --- a/src/citra_qt/debugger/ramview.cpp +++ b/src/citra_qt/debugger/ramview.cpp @@ -4,8 +4,6 @@ #include "ramview.h" -#include "core/mem_map.h" - GRamView::GRamView(QWidget* parent) : QHexEdit(parent) { diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index ebedcb710..3b67cc49d 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -99,7 +99,7 @@ set(SRCS loader/loader.cpp loader/ncch.cpp mem_map.cpp - mem_map_funcs.cpp + memory.cpp settings.cpp system.cpp ) @@ -211,6 +211,7 @@ set(HEADERS loader/loader.h loader/ncch.h mem_map.h + memory.h settings.h system.h ) diff --git a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp index 8c52bdb72..b79fd1719 100644 --- a/src/core/arm/dyncom/arm_dyncom_interpreter.cpp +++ b/src/core/arm/dyncom/arm_dyncom_interpreter.cpp @@ -10,7 +10,7 @@ #include "common/logging/log.h" #include "common/profiler.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/svc.h" #include "core/arm/disassembler/arm_disasm.h" #include "core/arm/dyncom/arm_dyncom_interpreter.h" diff --git a/src/core/arm/interpreter/arminit.cpp b/src/core/arm/interpreter/arminit.cpp index 31b2bab06..680a94a39 100644 --- a/src/core/arm/interpreter/arminit.cpp +++ b/src/core/arm/interpreter/arminit.cpp @@ -16,7 +16,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include -#include "core/mem_map.h" #include "core/arm/skyeye_common/armdefs.h" #include "core/arm/skyeye_common/armemu.h" #include "core/arm/skyeye_common/vfp/vfp.h" diff --git a/src/core/arm/skyeye_common/armmmu.h b/src/core/arm/skyeye_common/armmmu.h index 0463d83c8..c67d7209b 100644 --- a/src/core/arm/skyeye_common/armmmu.h +++ b/src/core/arm/skyeye_common/armmmu.h @@ -22,7 +22,7 @@ #include "common/swap.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/arm/skyeye_common/armdefs.h" // Register numbers in the MMU diff --git a/src/core/core.cpp b/src/core/core.cpp index 53aae8c2f..79038cd52 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -8,7 +8,6 @@ #include "core/core.h" #include "core/core_timing.h" -#include "core/mem_map.h" #include "core/settings.h" #include "core/arm/arm_interface.h" #include "core/arm/disassembler/arm_disasm.h" diff --git a/src/core/file_sys/archive_backend.cpp b/src/core/file_sys/archive_backend.cpp index 0439868ab..45a559ce8 100644 --- a/src/core/file_sys/archive_backend.cpp +++ b/src/core/file_sys/archive_backend.cpp @@ -8,7 +8,7 @@ #include "common/string_util.h" #include "core/file_sys/archive_backend.h" -#include "core/mem_map.h" +#include "core/memory.h" namespace FileSys { diff --git a/src/core/hle/config_mem.cpp b/src/core/hle/config_mem.cpp index 35dc9cf58..2f7cc7ee5 100644 --- a/src/core/hle/config_mem.cpp +++ b/src/core/hle/config_mem.cpp @@ -9,7 +9,7 @@ #include "common/common_funcs.h" #include "core/core.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/config_mem.h" //////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h index be2626eef..eb52c8fb1 100644 --- a/src/core/hle/function_wrappers.h +++ b/src/core/hle/function_wrappers.h @@ -7,7 +7,7 @@ #include "common/common_types.h" #include "core/arm/arm_interface.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/hle.h" namespace HLE { @@ -109,7 +109,7 @@ template void Wrap(){ template void Wrap() { u32 param_1 = 0; - u32 retval = func(¶m_1, Memory::GetCharPointer(PARAM(1))).raw; + u32 retval = func(¶m_1, (char*)Memory::GetPointer(PARAM(1))).raw; Core::g_app_core->SetReg(1, param_1); FuncReturn(retval); } @@ -163,7 +163,7 @@ template void Wrap() { } template void Wrap() { - func(Memory::GetCharPointer(PARAM(0))); + func((char*)Memory::GetPointer(PARAM(0))); } #undef PARAM diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp index 9d7f6b280..a1221766e 100644 --- a/src/core/hle/kernel/address_arbiter.cpp +++ b/src/core/hle/kernel/address_arbiter.cpp @@ -5,7 +5,7 @@ #include "common/common_types.h" #include "common/logging/log.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/hle.h" #include "core/hle/kernel/address_arbiter.h" diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp index 1e439db9e..0cdfa58d7 100644 --- a/src/core/hle/kernel/process.cpp +++ b/src/core/hle/kernel/process.cpp @@ -8,7 +8,7 @@ #include "core/hle/kernel/process.h" #include "core/hle/kernel/thread.h" -#include "core/mem_map.h" +#include "core/memory.h" namespace Kernel { diff --git a/src/core/hle/kernel/session.h b/src/core/hle/kernel/session.h index 8c3886ffd..54a062971 100644 --- a/src/core/hle/kernel/session.h +++ b/src/core/hle/kernel/session.h @@ -6,7 +6,7 @@ #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/thread.h" -#include "core/mem_map.h" +#include "core/memory.h" namespace Kernel { diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp index 0c59f4876..4137683b5 100644 --- a/src/core/hle/kernel/shared_memory.cpp +++ b/src/core/hle/kernel/shared_memory.cpp @@ -6,7 +6,7 @@ #include "common/logging/log.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/kernel/shared_memory.h" namespace Kernel { diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp index 5bcd03ff3..a5f1904d7 100644 --- a/src/core/hle/kernel/thread.cpp +++ b/src/core/hle/kernel/thread.cpp @@ -21,7 +21,7 @@ #include "core/hle/kernel/thread.h" #include "core/hle/kernel/mutex.h" #include "core/hle/result.h" -#include "core/mem_map.h" +#include "core/memory.h" namespace Kernel { diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h index 6b329c12a..389928178 100644 --- a/src/core/hle/kernel/thread.h +++ b/src/core/hle/kernel/thread.h @@ -12,7 +12,6 @@ #include "common/common_types.h" #include "core/core.h" -#include "core/mem_map.h" #include "core/hle/kernel/kernel.h" #include "core/hle/result.h" diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp index c6252a03b..c11c5faba 100644 --- a/src/core/hle/service/gsp_gpu.cpp +++ b/src/core/hle/service/gsp_gpu.cpp @@ -5,6 +5,7 @@ #include "common/bit_field.h" #include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/kernel/event.h" #include "core/hle/kernel/shared_memory.h" #include "core/hle/result.h" diff --git a/src/core/hle/shared_page.cpp b/src/core/hle/shared_page.cpp index 4f227a370..9de832158 100644 --- a/src/core/hle/shared_page.cpp +++ b/src/core/hle/shared_page.cpp @@ -8,7 +8,7 @@ #include "common/common_funcs.h" #include "core/core.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/hle/config_mem.h" #include "core/hle/shared_page.h" diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp index e8159fbdb..9bf886256 100644 --- a/src/core/hle/svc.cpp +++ b/src/core/hle/svc.cpp @@ -315,7 +315,7 @@ static ResultCode GetResourceLimitCurrentValues(s64* values, Handle resource_lim s32 name_count) { LOG_ERROR(Kernel_SVC, "(UNIMPLEMENTED) called resource_limit=%08X, names=%p, name_count=%d", resource_limit, names, name_count); - Memory::Write32(Core::g_app_core->GetReg(0), 0); // Normmatt: Set used memory to 0 for now + values[0] = 0; // Normmatt: Set used memory to 0 for now return RESULT_SUCCESS; } diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp index e4a0e14c4..8ef1f70df 100644 --- a/src/core/hw/gpu.cpp +++ b/src/core/hw/gpu.cpp @@ -8,7 +8,7 @@ #include "core/settings.h" #include "core/core.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/core_timing.h" #include "core/hle/hle.h" diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp index e28986085..84b13ee52 100644 --- a/src/core/loader/3dsx.cpp +++ b/src/core/loader/3dsx.cpp @@ -12,7 +12,7 @@ #include "core/hle/service/fs/archive.h" #include "core/loader/elf.h" #include "core/loader/ncch.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "3dsx.h" diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp index 47d4e8cea..a951bc80f 100644 --- a/src/core/loader/elf.cpp +++ b/src/core/loader/elf.cpp @@ -12,7 +12,7 @@ #include "core/hle/kernel/kernel.h" #include "core/loader/elf.h" -#include "core/mem_map.h" +#include "core/memory.h" //////////////////////////////////////////////////////////////////////////////////////////////////// // ELF Header Constants diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp index 4f881cf6f..8b14edf00 100644 --- a/src/core/loader/loader.cpp +++ b/src/core/loader/loader.cpp @@ -13,7 +13,6 @@ #include "core/loader/3dsx.h" #include "core/loader/elf.h" #include "core/loader/ncch.h" -#include "core/mem_map.h" //////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp index 3325a6ab8..36e341fd4 100644 --- a/src/core/loader/ncch.cpp +++ b/src/core/loader/ncch.cpp @@ -12,7 +12,7 @@ #include "core/hle/kernel/kernel.h" #include "core/loader/ncch.h" -#include "core/mem_map.h" +#include "core/memory.h" //////////////////////////////////////////////////////////////////////////////////////////////////// // Loader namespace diff --git a/src/core/mem_map.cpp b/src/core/mem_map.cpp index f99520464..66c2f77c0 100644 --- a/src/core/mem_map.cpp +++ b/src/core/mem_map.cpp @@ -2,10 +2,13 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include + #include "common/common_types.h" #include "common/logging/log.h" #include "core/mem_map.h" +#include "core/memory.h" //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -37,19 +40,109 @@ static MemoryArea memory_areas[] = { {&g_tls_mem, TLS_AREA_SIZE }, }; +/// Represents a block of memory mapped by ControlMemory/MapMemoryBlock +struct MemoryBlock { + MemoryBlock() : handle(0), base_address(0), address(0), size(0), operation(0), permissions(0) { + } + u32 handle; + u32 base_address; + u32 address; + u32 size; + u32 operation; + u32 permissions; + + const u32 GetVirtualAddress() const{ + return base_address + address; + } +}; + +static std::map heap_map; +static std::map heap_linear_map; + +} + +u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) { + MemoryBlock block; + + block.base_address = HEAP_VADDR; + block.size = size; + block.operation = operation; + block.permissions = permissions; + + if (heap_map.size() > 0) { + const MemoryBlock last_block = heap_map.rbegin()->second; + block.address = last_block.address + last_block.size; + } + heap_map[block.GetVirtualAddress()] = block; + + return block.GetVirtualAddress(); +} + +u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) { + MemoryBlock block; + + block.base_address = LINEAR_HEAP_VADDR; + block.size = size; + block.operation = operation; + block.permissions = permissions; + + if (heap_linear_map.size() > 0) { + const MemoryBlock last_block = heap_linear_map.rbegin()->second; + block.address = last_block.address + last_block.size; + } + heap_linear_map[block.GetVirtualAddress()] = block; + + return block.GetVirtualAddress(); +} + +PAddr VirtualToPhysicalAddress(const VAddr addr) { + if (addr == 0) { + return 0; + } else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) { + return addr - VRAM_VADDR + VRAM_PADDR; + } else if (addr >= LINEAR_HEAP_VADDR && addr < LINEAR_HEAP_VADDR_END) { + return addr - LINEAR_HEAP_VADDR + FCRAM_PADDR; + } else if (addr >= DSP_RAM_VADDR && addr < DSP_RAM_VADDR_END) { + return addr - DSP_RAM_VADDR + DSP_RAM_PADDR; + } else if (addr >= IO_AREA_VADDR && addr < IO_AREA_VADDR_END) { + return addr - IO_AREA_VADDR + IO_AREA_PADDR; + } + + LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr); + // To help with debugging, set bit on address so that it's obviously invalid. + return addr | 0x80000000; +} + +VAddr PhysicalToVirtualAddress(const PAddr addr) { + if (addr == 0) { + return 0; + } else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) { + return addr - VRAM_PADDR + VRAM_VADDR; + } else if (addr >= FCRAM_PADDR && addr < FCRAM_PADDR_END) { + return addr - FCRAM_PADDR + LINEAR_HEAP_VADDR; + } else if (addr >= DSP_RAM_PADDR && addr < DSP_RAM_PADDR_END) { + return addr - DSP_RAM_PADDR + DSP_RAM_VADDR; + } else if (addr >= IO_AREA_PADDR && addr < IO_AREA_PADDR_END) { + return addr - IO_AREA_PADDR + IO_AREA_VADDR; + } + + LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr); + // To help with debugging, set bit on address so that it's obviously invalid. + return addr | 0x80000000; } void Init() { for (MemoryArea& area : memory_areas) { *area.ptr = new u8[area.size]; } - MemBlock_Init(); LOG_DEBUG(HW_Memory, "initialized OK, RAM at %p", g_heap); } void Shutdown() { - MemBlock_Shutdown(); + heap_map.clear(); + heap_linear_map.clear(); + for (MemoryArea& area : memory_areas) { delete[] *area.ptr; *area.ptr = nullptr; diff --git a/src/core/mem_map.h b/src/core/mem_map.h index b6944deb4..945815cd6 100644 --- a/src/core/mem_map.h +++ b/src/core/mem_map.h @@ -8,121 +8,6 @@ namespace Memory { -//////////////////////////////////////////////////////////////////////////////////////////////////// - -const u32 PAGE_SIZE = 0x1000; - -/// Physical memory regions as seen from the ARM11 -enum : PAddr { - /// IO register area - IO_AREA_PADDR = 0x10100000, - IO_AREA_SIZE = 0x01000000, ///< IO area size (16MB) - IO_AREA_PADDR_END = IO_AREA_PADDR + IO_AREA_SIZE, - - /// MPCore internal memory region - MPCORE_RAM_PADDR = 0x17E00000, - MPCORE_RAM_SIZE = 0x00002000, ///< MPCore internal memory size (8KB) - MPCORE_RAM_PADDR_END = MPCORE_RAM_PADDR + MPCORE_RAM_SIZE, - - /// Video memory - VRAM_PADDR = 0x18000000, - VRAM_SIZE = 0x00600000, ///< VRAM size (6MB) - VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE, - - /// DSP memory - DSP_RAM_PADDR = 0x1FF00000, - DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB) - DSP_RAM_PADDR_END = DSP_RAM_PADDR + DSP_RAM_SIZE, - - /// AXI WRAM - AXI_WRAM_PADDR = 0x1FF80000, - AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB) - AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE, - - /// Main FCRAM - FCRAM_PADDR = 0x20000000, - FCRAM_SIZE = 0x08000000, ///< FCRAM size (128MB) - FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE, -}; - -/// Virtual user-space memory regions -enum : VAddr { - /// Where the application text, data and bss reside. - PROCESS_IMAGE_VADDR = 0x00100000, - PROCESS_IMAGE_MAX_SIZE = 0x03F00000, - PROCESS_IMAGE_VADDR_END = PROCESS_IMAGE_VADDR + PROCESS_IMAGE_MAX_SIZE, - - /// Area where IPC buffers are mapped onto. - IPC_MAPPING_VADDR = 0x04000000, - IPC_MAPPING_SIZE = 0x04000000, - IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE, - - /// Application heap (includes stack). - HEAP_VADDR = 0x08000000, - HEAP_SIZE = 0x08000000, - HEAP_VADDR_END = HEAP_VADDR + HEAP_SIZE, - - /// Area where shared memory buffers are mapped onto. - SHARED_MEMORY_VADDR = 0x10000000, - SHARED_MEMORY_SIZE = 0x04000000, - SHARED_MEMORY_VADDR_END = SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE, - - /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical memory. - LINEAR_HEAP_VADDR = 0x14000000, - LINEAR_HEAP_SIZE = 0x08000000, - LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE, - - /// Maps 1:1 to the IO register area. - IO_AREA_VADDR = 0x1EC00000, - IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE, - - /// Maps 1:1 to VRAM. - VRAM_VADDR = 0x1F000000, - VRAM_VADDR_END = VRAM_VADDR + VRAM_SIZE, - - /// Maps 1:1 to DSP memory. - DSP_RAM_VADDR = 0x1FF00000, - DSP_RAM_VADDR_END = DSP_RAM_VADDR + DSP_RAM_SIZE, - - /// Read-only page containing kernel and system configuration values. - CONFIG_MEMORY_VADDR = 0x1FF80000, - CONFIG_MEMORY_SIZE = 0x00001000, - CONFIG_MEMORY_VADDR_END = CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE, - - /// Usually read-only page containing mostly values read from hardware. - SHARED_PAGE_VADDR = 0x1FF81000, - SHARED_PAGE_SIZE = 0x00001000, - SHARED_PAGE_VADDR_END = SHARED_PAGE_VADDR + SHARED_PAGE_SIZE, - - // TODO(yuriks): The size of this area is dynamic, the kernel grows - // it as more and more threads are created. For now we'll just use a - // hardcoded value. - /// Area where TLS (Thread-Local Storage) buffers are allocated. - TLS_AREA_VADDR = 0x1FF82000, - TLS_AREA_SIZE = 0x00030000, // Each TLS buffer is 0x200 bytes, allows for 300 threads - TLS_AREA_VADDR_END = TLS_AREA_VADDR + TLS_AREA_SIZE, -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - -/// Represents a block of memory mapped by ControlMemory/MapMemoryBlock -struct MemoryBlock { - MemoryBlock() : handle(0), base_address(0), address(0), size(0), operation(0), permissions(0) { - } - u32 handle; - u32 base_address; - u32 address; - u32 size; - u32 operation; - u32 permissions; - - const u32 GetVirtualAddress() const{ - return base_address + address; - } -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - extern u8* g_exefs_code; ///< ExeFS:/.code is loaded here extern u8* g_heap; ///< Application heap (main memory) extern u8* g_shared_mem; ///< Shared memory @@ -134,20 +19,6 @@ extern u8* g_tls_mem; ///< TLS memory void Init(); void Shutdown(); -u8 Read8(VAddr addr); -u16 Read16(VAddr addr); -u32 Read32(VAddr addr); -u64 Read64(VAddr addr); - -void Write8(VAddr addr, u8 data); -void Write16(VAddr addr, u16 data); -void Write32(VAddr addr, u32 data); -void Write64(VAddr addr, u64 data); - -void WriteBlock(VAddr addr, const u8* data, size_t size); - -u8* GetPointer(VAddr virtual_address); - /** * Maps a block of memory on the heap * @param size Size of block in bytes @@ -164,16 +35,6 @@ u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions); */ u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions); -/// Initialize mapped memory blocks -void MemBlock_Init(); - -/// Shutdown mapped memory blocks -void MemBlock_Shutdown(); - -inline const char* GetCharPointer(const VAddr address) { - return (const char *)GetPointer(address); -} - /** * Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical * address. This should be used by services to translate addresses for use by the hardware. @@ -185,13 +46,4 @@ PAddr VirtualToPhysicalAddress(VAddr addr); */ VAddr PhysicalToVirtualAddress(PAddr addr); -/** - * Gets a pointer to the memory region beginning at the specified physical address. - * - * @note This is currently implemented using PhysicalToVirtualAddress(). - */ -inline u8* GetPhysicalPointer(PAddr address) { - return GetPointer(PhysicalToVirtualAddress(address)); -} - } // namespace diff --git a/src/core/mem_map_funcs.cpp b/src/core/memory.cpp similarity index 68% rename from src/core/mem_map_funcs.cpp rename to src/core/memory.cpp index f2da60cc6..517167b0a 100644 --- a/src/core/mem_map_funcs.cpp +++ b/src/core/memory.cpp @@ -2,58 +2,18 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. -#include - #include "common/common_types.h" #include "common/logging/log.h" #include "common/swap.h" -#include "core/mem_map.h" +#include "core/hle/config_mem.h" +#include "core/hle/shared_page.h" #include "core/hw/hw.h" -#include "hle/config_mem.h" -#include "hle/shared_page.h" +#include "core/mem_map.h" +#include "core/memory.h" namespace Memory { -static std::map heap_map; -static std::map heap_linear_map; - -PAddr VirtualToPhysicalAddress(const VAddr addr) { - if (addr == 0) { - return 0; - } else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) { - return addr - VRAM_VADDR + VRAM_PADDR; - } else if (addr >= LINEAR_HEAP_VADDR && addr < LINEAR_HEAP_VADDR_END) { - return addr - LINEAR_HEAP_VADDR + FCRAM_PADDR; - } else if (addr >= DSP_RAM_VADDR && addr < DSP_RAM_VADDR_END) { - return addr - DSP_RAM_VADDR + DSP_RAM_PADDR; - } else if (addr >= IO_AREA_VADDR && addr < IO_AREA_VADDR_END) { - return addr - IO_AREA_VADDR + IO_AREA_PADDR; - } - - LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr); - // To help with debugging, set bit on address so that it's obviously invalid. - return addr | 0x80000000; -} - -VAddr PhysicalToVirtualAddress(const PAddr addr) { - if (addr == 0) { - return 0; - } else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) { - return addr - VRAM_PADDR + VRAM_VADDR; - } else if (addr >= FCRAM_PADDR && addr < FCRAM_PADDR_END) { - return addr - FCRAM_PADDR + LINEAR_HEAP_VADDR; - } else if (addr >= DSP_RAM_PADDR && addr < DSP_RAM_PADDR_END) { - return addr - DSP_RAM_PADDR + DSP_RAM_VADDR; - } else if (addr >= IO_AREA_PADDR && addr < IO_AREA_PADDR_END) { - return addr - IO_AREA_PADDR + IO_AREA_VADDR; - } - - LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr); - // To help with debugging, set bit on address so that it's obviously invalid. - return addr | 0x80000000; -} - template inline void Read(T &var, const VAddr vaddr) { // TODO: Figure out the fastest order of tests for both read and write (they are probably different). @@ -174,46 +134,8 @@ u8 *GetPointer(const VAddr vaddr) { } } -u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) { - MemoryBlock block; - - block.base_address = HEAP_VADDR; - block.size = size; - block.operation = operation; - block.permissions = permissions; - - if (heap_map.size() > 0) { - const MemoryBlock last_block = heap_map.rbegin()->second; - block.address = last_block.address + last_block.size; - } - heap_map[block.GetVirtualAddress()] = block; - - return block.GetVirtualAddress(); -} - -u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) { - MemoryBlock block; - - block.base_address = LINEAR_HEAP_VADDR; - block.size = size; - block.operation = operation; - block.permissions = permissions; - - if (heap_linear_map.size() > 0) { - const MemoryBlock last_block = heap_linear_map.rbegin()->second; - block.address = last_block.address + last_block.size; - } - heap_linear_map[block.GetVirtualAddress()] = block; - - return block.GetVirtualAddress(); -} - -void MemBlock_Init() { -} - -void MemBlock_Shutdown() { - heap_map.clear(); - heap_linear_map.clear(); +u8* GetPhysicalPointer(PAddr address) { + return GetPointer(PhysicalToVirtualAddress(address)); } u8 Read8(const VAddr addr) { diff --git a/src/core/memory.h b/src/core/memory.h new file mode 100644 index 000000000..5ae7784e0 --- /dev/null +++ b/src/core/memory.h @@ -0,0 +1,125 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +namespace Memory { + +const u32 PAGE_SIZE = 0x1000; + +/// Physical memory regions as seen from the ARM11 +enum : PAddr { + /// IO register area + IO_AREA_PADDR = 0x10100000, + IO_AREA_SIZE = 0x01000000, ///< IO area size (16MB) + IO_AREA_PADDR_END = IO_AREA_PADDR + IO_AREA_SIZE, + + /// MPCore internal memory region + MPCORE_RAM_PADDR = 0x17E00000, + MPCORE_RAM_SIZE = 0x00002000, ///< MPCore internal memory size (8KB) + MPCORE_RAM_PADDR_END = MPCORE_RAM_PADDR + MPCORE_RAM_SIZE, + + /// Video memory + VRAM_PADDR = 0x18000000, + VRAM_SIZE = 0x00600000, ///< VRAM size (6MB) + VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE, + + /// DSP memory + DSP_RAM_PADDR = 0x1FF00000, + DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB) + DSP_RAM_PADDR_END = DSP_RAM_PADDR + DSP_RAM_SIZE, + + /// AXI WRAM + AXI_WRAM_PADDR = 0x1FF80000, + AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB) + AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE, + + /// Main FCRAM + FCRAM_PADDR = 0x20000000, + FCRAM_SIZE = 0x08000000, ///< FCRAM size (128MB) + FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE, +}; + +/// Virtual user-space memory regions +enum : VAddr { + /// Where the application text, data and bss reside. + PROCESS_IMAGE_VADDR = 0x00100000, + PROCESS_IMAGE_MAX_SIZE = 0x03F00000, + PROCESS_IMAGE_VADDR_END = PROCESS_IMAGE_VADDR + PROCESS_IMAGE_MAX_SIZE, + + /// Area where IPC buffers are mapped onto. + IPC_MAPPING_VADDR = 0x04000000, + IPC_MAPPING_SIZE = 0x04000000, + IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE, + + /// Application heap (includes stack). + HEAP_VADDR = 0x08000000, + HEAP_SIZE = 0x08000000, + HEAP_VADDR_END = HEAP_VADDR + HEAP_SIZE, + + /// Area where shared memory buffers are mapped onto. + SHARED_MEMORY_VADDR = 0x10000000, + SHARED_MEMORY_SIZE = 0x04000000, + SHARED_MEMORY_VADDR_END = SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE, + + /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical memory. + LINEAR_HEAP_VADDR = 0x14000000, + LINEAR_HEAP_SIZE = 0x08000000, + LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE, + + /// Maps 1:1 to the IO register area. + IO_AREA_VADDR = 0x1EC00000, + IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE, + + /// Maps 1:1 to VRAM. + VRAM_VADDR = 0x1F000000, + VRAM_VADDR_END = VRAM_VADDR + VRAM_SIZE, + + /// Maps 1:1 to DSP memory. + DSP_RAM_VADDR = 0x1FF00000, + DSP_RAM_VADDR_END = DSP_RAM_VADDR + DSP_RAM_SIZE, + + /// Read-only page containing kernel and system configuration values. + CONFIG_MEMORY_VADDR = 0x1FF80000, + CONFIG_MEMORY_SIZE = 0x00001000, + CONFIG_MEMORY_VADDR_END = CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE, + + /// Usually read-only page containing mostly values read from hardware. + SHARED_PAGE_VADDR = 0x1FF81000, + SHARED_PAGE_SIZE = 0x00001000, + SHARED_PAGE_VADDR_END = SHARED_PAGE_VADDR + SHARED_PAGE_SIZE, + + // TODO(yuriks): The size of this area is dynamic, the kernel grows + // it as more and more threads are created. For now we'll just use a + // hardcoded value. + /// Area where TLS (Thread-Local Storage) buffers are allocated. + TLS_AREA_VADDR = 0x1FF82000, + TLS_AREA_SIZE = 0x00030000, // Each TLS buffer is 0x200 bytes, allows for 300 threads + TLS_AREA_VADDR_END = TLS_AREA_VADDR + TLS_AREA_SIZE, +}; + +u8 Read8(VAddr addr); +u16 Read16(VAddr addr); +u32 Read32(VAddr addr); +u64 Read64(VAddr addr); + +void Write8(VAddr addr, u8 data); +void Write16(VAddr addr, u16 data); +void Write32(VAddr addr, u32 data); +void Write64(VAddr addr, u64 data); + +void WriteBlock(VAddr addr, const u8* data, size_t size); + +u8* GetPointer(VAddr virtual_address); + +/** + * Gets a pointer to the memory region beginning at the specified physical address. + * + * @note This is currently implemented using PhysicalToVirtualAddress(). + */ +u8* GetPhysicalPointer(PAddr address); + +} diff --git a/src/video_core/pica.h b/src/video_core/pica.h index a53429716..3fbf95721 100644 --- a/src/video_core/pica.h +++ b/src/video_core/pica.h @@ -16,8 +16,6 @@ #include "common/common_types.h" #include "common/logging/log.h" -#include "core/mem_map.h" - namespace Pica { // Returns index corresponding to the Regs member labeled by field_name diff --git a/src/video_core/rasterizer.cpp b/src/video_core/rasterizer.cpp index 02a08b20e..59eff48f9 100644 --- a/src/video_core/rasterizer.cpp +++ b/src/video_core/rasterizer.cpp @@ -9,6 +9,8 @@ #include "common/profiler.h" #include "core/hw/gpu.h" +#include "core/memory.h" + #include "debug_utils/debug_utils.h" #include "math.h" #include "color.h" diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp index 0c072120d..71ceb021b 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.cpp +++ b/src/video_core/renderer_opengl/renderer_opengl.cpp @@ -5,7 +5,7 @@ #include "core/hw/gpu.h" #include "core/hw/hw.h" #include "core/hw/lcd.h" -#include "core/mem_map.h" +#include "core/memory.h" #include "core/settings.h" #include "common/emu_window.h" diff --git a/src/video_core/vertex_shader.cpp b/src/video_core/vertex_shader.cpp index 4734e546a..981d1a356 100644 --- a/src/video_core/vertex_shader.cpp +++ b/src/video_core/vertex_shader.cpp @@ -8,8 +8,6 @@ #include -#include - #include #include "common/profiler.h" From ec514b16a66c0aca19e3f641836d836eacd59e75 Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Tue, 12 May 2015 23:17:30 -0300 Subject: [PATCH 3/5] Memory: Read ConfigMem directly from Memory::Read --- src/core/hle/config_mem.cpp | 47 +------------------------------------ src/core/hle/config_mem.h | 38 +++++++++++++++++++++++++++--- src/core/memory.cpp | 3 ++- 3 files changed, 38 insertions(+), 50 deletions(-) diff --git a/src/core/hle/config_mem.cpp b/src/core/hle/config_mem.cpp index 2f7cc7ee5..aea936d2d 100644 --- a/src/core/hle/config_mem.cpp +++ b/src/core/hle/config_mem.cpp @@ -16,52 +16,7 @@ namespace ConfigMem { -struct ConfigMemDef { - u8 kernel_unk; // 0 - u8 kernel_version_rev; // 1 - u8 kernel_version_min; // 2 - u8 kernel_version_maj; // 3 - u32 update_flag; // 4 - u64 ns_tid; // 8 - u32 sys_core_ver; // 10 - u8 unit_info; // 14 - u8 boot_firm; // 15 - u8 prev_firm; // 16 - INSERT_PADDING_BYTES(0x1); // 17 - u32 ctr_sdk_ver; // 18 - INSERT_PADDING_BYTES(0x30 - 0x1C); // 1C - u32 app_mem_type; // 30 - INSERT_PADDING_BYTES(0x40 - 0x34); // 34 - u32 app_mem_alloc; // 40 - u32 sys_mem_alloc; // 44 - u32 base_mem_alloc; // 48 - INSERT_PADDING_BYTES(0x60 - 0x4C); // 4C - u8 firm_unk; // 60 - u8 firm_version_rev; // 61 - u8 firm_version_min; // 62 - u8 firm_version_maj; // 63 - u32 firm_sys_core_ver; // 64 - u32 firm_ctr_sdk_ver; // 68 - INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C -}; - -static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE, "Config Memory structure size is wrong"); - -static ConfigMemDef config_mem; - -template -inline void Read(T &var, const u32 addr) { - u32 offset = addr - Memory::CONFIG_MEMORY_VADDR; - ASSERT(offset < Memory::CONFIG_MEMORY_SIZE); - var = *(reinterpret_cast(((uintptr_t)&config_mem) + offset)); -} - -// Explicitly instantiate template functions because we aren't defining this in the header: - -template void Read(u64 &var, const u32 addr); -template void Read(u32 &var, const u32 addr); -template void Read(u16 &var, const u32 addr); -template void Read(u8 &var, const u32 addr); +ConfigMemDef config_mem; void Init() { std::memset(&config_mem, 0, sizeof(config_mem)); diff --git a/src/core/hle/config_mem.h b/src/core/hle/config_mem.h index cbb478fb3..9825a09e8 100644 --- a/src/core/hle/config_mem.h +++ b/src/core/hle/config_mem.h @@ -9,17 +9,49 @@ // bootrom. Because we're not emulating this, and essentially just "stubbing" the functionality, I'm // putting this as a subset of HLE for now. +#include "common/common_funcs.h" #include "common/common_types.h" +#include "common/swap.h" + +#include "core/memory.h" //////////////////////////////////////////////////////////////////////////////////////////////////// namespace ConfigMem { -template -void Read(T &var, const u32 addr); +struct ConfigMemDef { + u8 kernel_unk; // 0 + u8 kernel_version_rev; // 1 + u8 kernel_version_min; // 2 + u8 kernel_version_maj; // 3 + u32_le update_flag; // 4 + u64_le ns_tid; // 8 + u32_le sys_core_ver; // 10 + u8 unit_info; // 14 + u8 boot_firm; // 15 + u8 prev_firm; // 16 + INSERT_PADDING_BYTES(0x1); // 17 + u32_le ctr_sdk_ver; // 18 + INSERT_PADDING_BYTES(0x30 - 0x1C); // 1C + u32_le app_mem_type; // 30 + INSERT_PADDING_BYTES(0x40 - 0x34); // 34 + u32_le app_mem_alloc; // 40 + u32_le sys_mem_alloc; // 44 + u32_le base_mem_alloc; // 48 + INSERT_PADDING_BYTES(0x60 - 0x4C); // 4C + u8 firm_unk; // 60 + u8 firm_version_rev; // 61 + u8 firm_version_min; // 62 + u8 firm_version_maj; // 63 + u32_le firm_sys_core_ver; // 64 + u32_le firm_ctr_sdk_ver; // 68 + INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C +}; +static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE, "Config Memory structure size is wrong"); + +extern ConfigMemDef config_mem; void Init(); - void Shutdown(); } // namespace diff --git a/src/core/memory.cpp b/src/core/memory.cpp index 517167b0a..aee1674b6 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -42,7 +42,8 @@ inline void Read(T &var, const VAddr vaddr) { // Config memory } else if ((vaddr >= CONFIG_MEMORY_VADDR) && (vaddr < CONFIG_MEMORY_VADDR_END)) { - ConfigMem::Read(var, vaddr); + const u8* raw_memory = (const u8*)&ConfigMem::config_mem; + var = *((const T*)&raw_memory[vaddr - CONFIG_MEMORY_VADDR]); // Shared page } else if ((vaddr >= SHARED_PAGE_VADDR) && (vaddr < SHARED_PAGE_VADDR_END)) { From 52158c1b8dccd3b469ab502a42a46a1d277928aa Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Tue, 12 May 2015 23:29:24 -0300 Subject: [PATCH 4/5] Memory: Read SharedPage directly from Memory::Read --- src/core/hle/shared_page.cpp | 57 ++---------------------------------- src/core/hle/shared_page.h | 36 ++++++++++++++++++++--- src/core/memory.cpp | 3 +- 3 files changed, 37 insertions(+), 59 deletions(-) diff --git a/src/core/hle/shared_page.cpp b/src/core/hle/shared_page.cpp index 9de832158..4014eee98 100644 --- a/src/core/hle/shared_page.cpp +++ b/src/core/hle/shared_page.cpp @@ -16,63 +16,12 @@ namespace SharedPage { -// see http://3dbrew.org/wiki/Configuration_Memory#Shared_Memory_Page_For_ARM11_Processes - -#pragma pack(1) -struct DateTime { - u64 date_time; // 0x0 - u64 update_tick; // 0x8 - INSERT_PADDING_BYTES(0x20 - 0x10); // 0x10 -}; - -struct SharedPageDef { - // most of these names are taken from the 3dbrew page linked above. - u32 date_time_selector; // 0x0 - u8 running_hw; // 0x4 - u8 mcu_hw_info; // 0x5: don't know what the acronyms mean - INSERT_PADDING_BYTES(0x20 - 0x6); // 0x6 - DateTime date_time_0; // 0x20 - DateTime date_time_1; // 0x40 - u8 wifi_macaddr[6]; // 0x60 - u8 wifi_unknown1; // 0x66: 3dbrew says these are "Likely wifi hardware related" - u8 wifi_unknown2; // 0x67 - INSERT_PADDING_BYTES(0x80 - 0x68); // 0x68 - float sliderstate_3d; // 0x80 - u8 ledstate_3d; // 0x84 - INSERT_PADDING_BYTES(0xA0 - 0x85); // 0x85 - u64 menu_title_id; // 0xA0 - u64 active_menu_title_id; // 0xA8 - INSERT_PADDING_BYTES(0x1000 - 0xB0); // 0xB0 -}; -#pragma pack() - -static_assert(sizeof(DateTime) == 0x20, "Datetime size is wrong"); -static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE, "Shared page structure size is wrong"); - -static SharedPageDef shared_page; - -template -inline void Read(T &var, const u32 addr) { - u32 offset = addr - Memory::SHARED_PAGE_VADDR; - var = *(reinterpret_cast(((uintptr_t)&shared_page) + offset)); -} - -// Explicitly instantiate template functions because we aren't defining this in the header: -template void Read(u64 &var, const u32 addr); -template void Read(u32 &var, const u32 addr); -template void Read(u16 &var, const u32 addr); -template void Read(u8 &var, const u32 addr); - -void Set3DSlider(float amount) { - std::memset(&shared_page, 0, sizeof(shared_page)); - - shared_page.sliderstate_3d = amount; - shared_page.ledstate_3d = (amount == 0.0f); // off when non-zero -} +SharedPageDef shared_page; void Init() { + std::memset(&shared_page, 0, sizeof(shared_page)); + shared_page.running_hw = 0x1; // product - Set3DSlider(0.0f); } void Shutdown() { diff --git a/src/core/hle/shared_page.h b/src/core/hle/shared_page.h index 1b6e4e581..fd2ab66a2 100644 --- a/src/core/hle/shared_page.h +++ b/src/core/hle/shared_page.h @@ -11,18 +11,46 @@ */ #include "common/common_types.h" +#include "common/swap.h" //////////////////////////////////////////////////////////////////////////////////////////////////// namespace SharedPage { -template -void Read(T &var, const u32 addr); +// See http://3dbrew.org/wiki/Configuration_Memory#Shared_Memory_Page_For_ARM11_Processes -void Set3DSlider(float amount); +struct DateTime { + u64_le date_time; // 0 + u64_le update_tick; // 8 + INSERT_PADDING_BYTES(0x20 - 0x10); // 10 +}; +static_assert(sizeof(DateTime) == 0x20, "Datetime size is wrong"); + +struct SharedPageDef { + // Most of these names are taken from the 3dbrew page linked above. + u32_le date_time_selector; // 0 + u8 running_hw; // 4 + /// "Microcontroller hardware info" + u8 mcu_hw_info; // 5 + INSERT_PADDING_BYTES(0x20 - 0x6); // 6 + DateTime date_time_0; // 20 + DateTime date_time_1; // 40 + u8 wifi_macaddr[6]; // 60 + u8 wifi_unknown1; // 66 + u8 wifi_unknown2; // 67 + INSERT_PADDING_BYTES(0x80 - 0x68); // 68 + float_le sliderstate_3d; // 80 + u8 ledstate_3d; // 84 + INSERT_PADDING_BYTES(0xA0 - 0x85); // 85 + u64_le menu_title_id; // A0 + u64_le active_menu_title_id; // A8 + INSERT_PADDING_BYTES(0x1000 - 0xB0); // B0 +}; +static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE, "Shared page structure size is wrong"); + +extern SharedPageDef shared_page; void Init(); - void Shutdown(); } // namespace diff --git a/src/core/memory.cpp b/src/core/memory.cpp index aee1674b6..8570689dd 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -47,7 +47,8 @@ inline void Read(T &var, const VAddr vaddr) { // Shared page } else if ((vaddr >= SHARED_PAGE_VADDR) && (vaddr < SHARED_PAGE_VADDR_END)) { - SharedPage::Read(var, vaddr); + const u8* raw_memory = (const u8*)&SharedPage::shared_page; + var = *((const T*)&raw_memory[vaddr - SHARED_PAGE_VADDR]); // DSP memory } else if ((vaddr >= DSP_RAM_VADDR) && (vaddr < DSP_RAM_VADDR_END)) { From dd4430609afce172542fba1d2cd53c3029f182ce Mon Sep 17 00:00:00 2001 From: Yuri Kunde Schlesner Date: Tue, 12 May 2015 23:38:56 -0300 Subject: [PATCH 5/5] Memory: Use a table based lookup scheme to read from memory regions --- src/core/CMakeLists.txt | 1 + src/core/mem_map.cpp | 25 +++-- src/core/memory.cpp | 229 ++++++++++++++++++++-------------------- src/core/memory.h | 4 + src/core/memory_setup.h | 29 +++++ 5 files changed, 167 insertions(+), 121 deletions(-) create mode 100644 src/core/memory_setup.h diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 3b67cc49d..e8d8c96d7 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -212,6 +212,7 @@ set(HEADERS loader/ncch.h mem_map.h memory.h + memory_setup.h settings.h system.h ) diff --git a/src/core/mem_map.cpp b/src/core/mem_map.cpp index 66c2f77c0..5ecec9566 100644 --- a/src/core/mem_map.cpp +++ b/src/core/mem_map.cpp @@ -7,8 +7,11 @@ #include "common/common_types.h" #include "common/logging/log.h" +#include "core/hle/config_mem.h" +#include "core/hle/shared_page.h" #include "core/mem_map.h" #include "core/memory.h" +#include "core/memory_setup.h" //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -26,18 +29,19 @@ namespace { struct MemoryArea { u8** ptr; - size_t size; + u32 base; + u32 size; }; // We don't declare the IO regions in here since its handled by other means. static MemoryArea memory_areas[] = { - {&g_exefs_code, PROCESS_IMAGE_MAX_SIZE}, - {&g_heap, HEAP_SIZE }, - {&g_shared_mem, SHARED_MEMORY_SIZE }, - {&g_heap_linear, LINEAR_HEAP_SIZE }, - {&g_vram, VRAM_SIZE }, - {&g_dsp_mem, DSP_RAM_SIZE }, - {&g_tls_mem, TLS_AREA_SIZE }, + {&g_exefs_code, PROCESS_IMAGE_VADDR, PROCESS_IMAGE_MAX_SIZE}, + {&g_heap, HEAP_VADDR, HEAP_SIZE }, + {&g_shared_mem, SHARED_MEMORY_VADDR, SHARED_MEMORY_SIZE }, + {&g_heap_linear, LINEAR_HEAP_VADDR, LINEAR_HEAP_SIZE }, + {&g_vram, VRAM_VADDR, VRAM_SIZE }, + {&g_dsp_mem, DSP_RAM_VADDR, DSP_RAM_SIZE }, + {&g_tls_mem, TLS_AREA_VADDR, TLS_AREA_SIZE }, }; /// Represents a block of memory mapped by ControlMemory/MapMemoryBlock @@ -132,9 +136,14 @@ VAddr PhysicalToVirtualAddress(const PAddr addr) { } void Init() { + InitMemoryMap(); + for (MemoryArea& area : memory_areas) { *area.ptr = new u8[area.size]; + MapMemoryRegion(area.base, area.size, *area.ptr); } + MapMemoryRegion(CONFIG_MEMORY_VADDR, CONFIG_MEMORY_SIZE, (u8*)&ConfigMem::config_mem); + MapMemoryRegion(SHARED_PAGE_VADDR, SHARED_PAGE_SIZE, (u8*)&SharedPage::shared_page); LOG_DEBUG(HW_Memory, "initialized OK, RAM at %p", g_heap); } diff --git a/src/core/memory.cpp b/src/core/memory.cpp index 8570689dd..5d8069acd 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -1,7 +1,10 @@ -// Copyright 2014 Citra Emulator Project +// Copyright 2015 Citra Emulator Project // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include + +#include "common/assert.h" #include "common/common_types.h" #include "common/logging/log.h" #include "common/swap.h" @@ -14,154 +17,154 @@ namespace Memory { -template -inline void Read(T &var, const VAddr vaddr) { - // TODO: Figure out the fastest order of tests for both read and write (they are probably different). - // TODO: Make sure this represents the mirrors in a correct way. - // Could just do a base-relative read, too.... TODO +const u32 PAGE_MASK = PAGE_SIZE - 1; +const int PAGE_BITS = 12; - // Kernel memory command buffer - if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) { - var = *((const T*)&g_tls_mem[vaddr - TLS_AREA_VADDR]); +enum class PageType { + /// Page is unmapped and should cause an access error. + Unmapped, + /// Page is mapped to regular memory. This is the only type you can get pointers to. + Memory, + /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions. + Special, +}; - // ExeFS:/.code is loaded here - } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) { - var = *((const T*)&g_exefs_code[vaddr - PROCESS_IMAGE_VADDR]); +/** + * A (reasonably) fast way of allowing switchable and remmapable process address spaces. It loosely + * mimics the way a real CPU page table works, but instead is optimized for minimal decoding and + * fetching requirements when acessing. In the usual case of an access to regular memory, it only + * requires an indexed fetch and a check for NULL. + */ +struct PageTable { + static const size_t NUM_ENTRIES = 1 << (32 - PAGE_BITS); - // FCRAM - linear heap - } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) { - var = *((const T*)&g_heap_linear[vaddr - LINEAR_HEAP_VADDR]); + /** + * Array of memory pointers backing each page. An entry can only be non-null if the + * corresponding entry in the `attributes` array is of type `Memory`. + */ + std::array pointers; - // FCRAM - application heap - } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { - var = *((const T*)&g_heap[vaddr - HEAP_VADDR]); + /** + * Array of fine grained page attributes. If it is set to any value other than `Memory`, then + * the corresponding entry in `pointer` MUST be set to null. + */ + std::array attributes; +}; - // Shared memory - } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { - var = *((const T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR]); +/// Singular page table used for the singleton process +static PageTable main_page_table; +/// Currently active page table +static PageTable* current_page_table = &main_page_table; - // Config memory - } else if ((vaddr >= CONFIG_MEMORY_VADDR) && (vaddr < CONFIG_MEMORY_VADDR_END)) { - const u8* raw_memory = (const u8*)&ConfigMem::config_mem; - var = *((const T*)&raw_memory[vaddr - CONFIG_MEMORY_VADDR]); +static void MapPages(u32 base, u32 size, u8* memory, PageType type) { + LOG_DEBUG(HW_Memory, "Mapping %p onto %08X-%08X", memory, base * PAGE_SIZE, (base + size) * PAGE_SIZE); - // Shared page - } else if ((vaddr >= SHARED_PAGE_VADDR) && (vaddr < SHARED_PAGE_VADDR_END)) { - const u8* raw_memory = (const u8*)&SharedPage::shared_page; - var = *((const T*)&raw_memory[vaddr - SHARED_PAGE_VADDR]); + u32 end = base + size; - // DSP memory - } else if ((vaddr >= DSP_RAM_VADDR) && (vaddr < DSP_RAM_VADDR_END)) { - var = *((const T*)&g_dsp_mem[vaddr - DSP_RAM_VADDR]); + while (base != end) { + ASSERT_MSG(base < PageTable::NUM_ENTRIES, "out of range mapping at %08X", base); - // VRAM - } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { - var = *((const T*)&g_vram[vaddr - VRAM_VADDR]); + if (current_page_table->attributes[base] != PageType::Unmapped) { + LOG_ERROR(HW_Memory, "overlapping memory ranges at %08X", base * PAGE_SIZE); + } + current_page_table->attributes[base] = type; + current_page_table->pointers[base] = memory; - } else { - LOG_ERROR(HW_Memory, "unknown Read%lu @ 0x%08X", sizeof(var) * 8, vaddr); + base += 1; + memory += PAGE_SIZE; } } -template -inline void Write(const VAddr vaddr, const T data) { - - // Kernel memory command buffer - if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) { - *(T*)&g_tls_mem[vaddr - TLS_AREA_VADDR] = data; - - // ExeFS:/.code is loaded here - } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) { - *(T*)&g_exefs_code[vaddr - PROCESS_IMAGE_VADDR] = data; - - // FCRAM - linear heap - } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) { - *(T*)&g_heap_linear[vaddr - LINEAR_HEAP_VADDR] = data; - - // FCRAM - application heap - } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { - *(T*)&g_heap[vaddr - HEAP_VADDR] = data; - - // Shared memory - } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { - *(T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR] = data; - - // VRAM - } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { - *(T*)&g_vram[vaddr - VRAM_VADDR] = data; - - // DSP memory - } else if ((vaddr >= DSP_RAM_VADDR) && (vaddr < DSP_RAM_VADDR_END)) { - *(T*)&g_dsp_mem[vaddr - DSP_RAM_VADDR] = data; - - //} else if ((vaddr & 0xFFFF0000) == 0x1FF80000) { - // ASSERT_MSG(MEMMAP, false, "umimplemented write to Configuration Memory"); - //} else if ((vaddr & 0xFFFFF000) == 0x1FF81000) { - // ASSERT_MSG(MEMMAP, false, "umimplemented write to shared page"); - - // Error out... - } else { - LOG_ERROR(HW_Memory, "unknown Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32)data, vaddr); - } +void InitMemoryMap() { + main_page_table.pointers.fill(nullptr); + main_page_table.attributes.fill(PageType::Unmapped); } -u8 *GetPointer(const VAddr vaddr) { - // Kernel memory command buffer - if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) { - return g_tls_mem + (vaddr - TLS_AREA_VADDR); +void MapMemoryRegion(VAddr base, u32 size, u8* target) { + ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: %08X", size); + ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: %08X", base); + MapPages(base / PAGE_SIZE, size / PAGE_SIZE, target, PageType::Memory); +} - // ExeFS:/.code is loaded here - } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) { - return g_exefs_code + (vaddr - PROCESS_IMAGE_VADDR); +void MapIoRegion(VAddr base, u32 size) { + ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: %08X", size); + ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: %08X", base); + MapPages(base / PAGE_SIZE, size / PAGE_SIZE, nullptr, PageType::Special); +} - // FCRAM - linear heap - } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) { - return g_heap_linear + (vaddr - LINEAR_HEAP_VADDR); +template +T Read(const VAddr vaddr) { + const u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS]; + if (page_pointer) { + return *reinterpret_cast(page_pointer + (vaddr & PAGE_MASK)); + } - // FCRAM - application heap - } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { - return g_heap + (vaddr - HEAP_VADDR); - - // Shared memory - } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { - return g_shared_mem + (vaddr - SHARED_MEMORY_VADDR); - - // VRAM - } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { - return g_vram + (vaddr - VRAM_VADDR); - - } else { - LOG_ERROR(HW_Memory, "unknown GetPointer @ 0x%08x", vaddr); + PageType type = current_page_table->attributes[vaddr >> PAGE_BITS]; + switch (type) { + case PageType::Unmapped: + LOG_ERROR(HW_Memory, "unmapped Read%lu @ 0x%08X", sizeof(T) * 8, vaddr); return 0; + case PageType::Memory: + ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr); + case PageType::Special: + LOG_ERROR(HW_Memory, "I/O reads aren't implemented yet @ %08X", vaddr); + return 0; + default: + UNREACHABLE(); } } +template +void Write(const VAddr vaddr, const T data) { + u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS]; + if (page_pointer) { + *reinterpret_cast(page_pointer + (vaddr & PAGE_MASK)) = data; + return; + } + + PageType type = current_page_table->attributes[vaddr >> PAGE_BITS]; + switch (type) { + case PageType::Unmapped: + LOG_ERROR(HW_Memory, "unmapped Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32) data, vaddr); + return; + case PageType::Memory: + ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr); + case PageType::Special: + LOG_ERROR(HW_Memory, "I/O writes aren't implemented yet @ %08X", vaddr); + return; + default: + UNREACHABLE(); + } +} + +u8* GetPointer(const VAddr vaddr) { + u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS]; + if (page_pointer) { + return page_pointer + (vaddr & PAGE_MASK); + } + + LOG_ERROR(HW_Memory, "unknown GetPointer @ 0x%08x", vaddr); + return nullptr; +} + u8* GetPhysicalPointer(PAddr address) { return GetPointer(PhysicalToVirtualAddress(address)); } u8 Read8(const VAddr addr) { - u8 data = 0; - Read(data, addr); - return data; + return Read(addr); } u16 Read16(const VAddr addr) { - u16_le data = 0; - Read(data, addr); - return data; + return Read(addr); } u32 Read32(const VAddr addr) { - u32_le data = 0; - Read(data, addr); - return data; + return Read(addr); } u64 Read64(const VAddr addr) { - u64_le data = 0; - Read(data, addr); - return data; + return Read(addr); } void Write8(const VAddr addr, const u8 data) { diff --git a/src/core/memory.h b/src/core/memory.h index 5ae7784e0..2d225801b 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -8,6 +8,10 @@ namespace Memory { +/** + * Page size used by the ARM architecture. This is the smallest granularity with which memory can + * be mapped. + */ const u32 PAGE_SIZE = 0x1000; /// Physical memory regions as seen from the ARM11 diff --git a/src/core/memory_setup.h b/src/core/memory_setup.h new file mode 100644 index 000000000..46263495f --- /dev/null +++ b/src/core/memory_setup.h @@ -0,0 +1,29 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +namespace Memory { + +void InitMemoryMap(); + +/** + * Maps an allocated buffer onto a region of the emulated process address space. + * + * @param base The address to start mapping at. Must be page-aligned. + * @param size The amount of bytes to map. Must be page-aligned. + * @param target Buffer with the memory backing the mapping. Must be of length at least `size`. + */ +void MapMemoryRegion(VAddr base, u32 size, u8* target); + +/** + * Maps a region of the emulated process address space as a IO region. + * @note Currently this can only be used to mark a region as being IO, since actual memory-mapped + * IO isn't yet supported. + */ +void MapIoRegion(VAddr base, u32 size); + +}