summaryrefslogtreecommitdiff
path: root/src/core/mem_map.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/mem_map.cpp')
-rw-r--r--src/core/mem_map.cpp163
1 files changed, 0 insertions, 163 deletions
diff --git a/src/core/mem_map.cpp b/src/core/mem_map.cpp
deleted file mode 100644
index cbe993fbe..000000000
--- a/src/core/mem_map.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
1// Copyright 2014 Citra Emulator Project
2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included.
4
5#include <map>
6#include <memory>
7#include <utility>
8#include <vector>
9
10#include "common/common_types.h"
11#include "common/logging/log.h"
12
13#include "core/hle/config_mem.h"
14#include "core/hle/kernel/vm_manager.h"
15#include "core/hle/result.h"
16#include "core/hle/shared_page.h"
17#include "core/mem_map.h"
18#include "core/memory.h"
19#include "core/memory_setup.h"
20
21////////////////////////////////////////////////////////////////////////////////////////////////////
22
23namespace Memory {
24
25namespace {
26
27struct MemoryArea {
28 u32 base;
29 u32 size;
30 const char* name;
31};
32
33// We don't declare the IO regions in here since its handled by other means.
34static MemoryArea memory_areas[] = {
35 {HEAP_VADDR, HEAP_SIZE, "Heap"}, // Application heap (main memory)
36 {SHARED_MEMORY_VADDR, SHARED_MEMORY_SIZE, "Shared Memory"}, // Shared memory
37 {LINEAR_HEAP_VADDR, LINEAR_HEAP_SIZE, "Linear Heap"}, // Linear heap (main memory)
38 {VRAM_VADDR, VRAM_SIZE, "VRAM"}, // Video memory (VRAM)
39 {DSP_RAM_VADDR, DSP_RAM_SIZE, "DSP RAM"}, // DSP memory
40 {TLS_AREA_VADDR, TLS_AREA_SIZE, "TLS Area"}, // TLS memory
41};
42
43/// Represents a block of memory mapped by ControlMemory/MapMemoryBlock
44struct MemoryBlock {
45 MemoryBlock() : handle(0), base_address(0), address(0), size(0), operation(0), permissions(0) {
46 }
47 u32 handle;
48 u32 base_address;
49 u32 address;
50 u32 size;
51 u32 operation;
52 u32 permissions;
53
54 const u32 GetVirtualAddress() const{
55 return base_address + address;
56 }
57};
58
59static std::map<u32, MemoryBlock> heap_map;
60static std::map<u32, MemoryBlock> heap_linear_map;
61
62}
63
64u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) {
65 MemoryBlock block;
66
67 block.base_address = HEAP_VADDR;
68 block.size = size;
69 block.operation = operation;
70 block.permissions = permissions;
71
72 if (heap_map.size() > 0) {
73 const MemoryBlock last_block = heap_map.rbegin()->second;
74 block.address = last_block.address + last_block.size;
75 }
76 heap_map[block.GetVirtualAddress()] = block;
77
78 return block.GetVirtualAddress();
79}
80
81u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) {
82 MemoryBlock block;
83
84 block.base_address = LINEAR_HEAP_VADDR;
85 block.size = size;
86 block.operation = operation;
87 block.permissions = permissions;
88
89 if (heap_linear_map.size() > 0) {
90 const MemoryBlock last_block = heap_linear_map.rbegin()->second;
91 block.address = last_block.address + last_block.size;
92 }
93 heap_linear_map[block.GetVirtualAddress()] = block;
94
95 return block.GetVirtualAddress();
96}
97
98PAddr VirtualToPhysicalAddress(const VAddr addr) {
99 if (addr == 0) {
100 return 0;
101 } else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) {
102 return addr - VRAM_VADDR + VRAM_PADDR;
103 } else if (addr >= LINEAR_HEAP_VADDR && addr < LINEAR_HEAP_VADDR_END) {
104 return addr - LINEAR_HEAP_VADDR + FCRAM_PADDR;
105 } else if (addr >= DSP_RAM_VADDR && addr < DSP_RAM_VADDR_END) {
106 return addr - DSP_RAM_VADDR + DSP_RAM_PADDR;
107 } else if (addr >= IO_AREA_VADDR && addr < IO_AREA_VADDR_END) {
108 return addr - IO_AREA_VADDR + IO_AREA_PADDR;
109 }
110
111 LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr);
112 // To help with debugging, set bit on address so that it's obviously invalid.
113 return addr | 0x80000000;
114}
115
116VAddr PhysicalToVirtualAddress(const PAddr addr) {
117 if (addr == 0) {
118 return 0;
119 } else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) {
120 return addr - VRAM_PADDR + VRAM_VADDR;
121 } else if (addr >= FCRAM_PADDR && addr < FCRAM_PADDR_END) {
122 return addr - FCRAM_PADDR + LINEAR_HEAP_VADDR;
123 } else if (addr >= DSP_RAM_PADDR && addr < DSP_RAM_PADDR_END) {
124 return addr - DSP_RAM_PADDR + DSP_RAM_VADDR;
125 } else if (addr >= IO_AREA_PADDR && addr < IO_AREA_PADDR_END) {
126 return addr - IO_AREA_PADDR + IO_AREA_VADDR;
127 }
128
129 LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr);
130 // To help with debugging, set bit on address so that it's obviously invalid.
131 return addr | 0x80000000;
132}
133
134void Init() {
135 InitMemoryMap();
136 LOG_DEBUG(HW_Memory, "initialized OK");
137}
138
139void InitLegacyAddressSpace(Kernel::VMManager& address_space) {
140 using namespace Kernel;
141
142 for (MemoryArea& area : memory_areas) {
143 auto block = std::make_shared<std::vector<u8>>(area.size);
144 address_space.MapMemoryBlock(area.base, std::move(block), 0, area.size, MemoryState::Private).Unwrap();
145 }
146
147 auto cfg_mem_vma = address_space.MapBackingMemory(CONFIG_MEMORY_VADDR,
148 (u8*)&ConfigMem::config_mem, CONFIG_MEMORY_SIZE, MemoryState::Shared).MoveFrom();
149 address_space.Reprotect(cfg_mem_vma, VMAPermission::Read);
150
151 auto shared_page_vma = address_space.MapBackingMemory(SHARED_PAGE_VADDR,
152 (u8*)&SharedPage::shared_page, SHARED_PAGE_SIZE, MemoryState::Shared).MoveFrom();
153 address_space.Reprotect(shared_page_vma, VMAPermission::Read);
154}
155
156void Shutdown() {
157 heap_map.clear();
158 heap_linear_map.clear();
159
160 LOG_DEBUG(HW_Memory, "shutdown OK");
161}
162
163} // namespace
HIC SVNT DRACONES