The-Homebrew-Cloud/Lime3DS
2
0
Fork 0
mirror of https://github.com/Lime3DS/Lime3DS.git synced 2024-12-18 05:51:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Memory: Re-organize and rename memory area address constants

Browse Source
This commit is contained in:
Yuri Kunde Schlesner 2015-05-09 00:39:56 -03:00
parent eb3eb9f75d
commit 1c0b87edc2
10 changed files with 118 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/core.cpp
View File

@ -63,7 +63,7 @@ int Init() {
// TODO: Whenever TLS is implemented, this should contain // TODO: Whenever TLS is implemented, this should contain
// the address of the 0x200-byte TLS // the address of the 0x200-byte TLS
g_app_core->SetCP15Register(CP15_THREAD_URO, Memory::KERNEL_MEMORY_VADDR); g_app_core->SetCP15Register(CP15_THREAD_URO, Memory::TLS_AREA_VADDR);
LOG_DEBUG(Core, "Initialized OK"); LOG_DEBUG(Core, "Initialized OK");
return 0; return 0;

2
src/core/hle/kernel/session.h
View File

@ -17,7 +17,7 @@ static const int kCommandHeaderOffset = 0x80; ///< Offset into command buffer of
* @return Pointer to command buffer * @return Pointer to command buffer
*/ */
inline static u32* GetCommandBuffer(const int offset=0) { inline static u32* GetCommandBuffer(const int offset=0) {
return (u32*)Memory::GetPointer(Memory::KERNEL_MEMORY_VADDR + kCommandHeaderOffset + offset); return (u32*)Memory::GetPointer(Memory::TLS_AREA_VADDR + kCommandHeaderOffset + offset);
} }
/** /**

5
src/core/hle/kernel/thread.cpp
View File

@ -443,7 +443,8 @@ void Thread::BoostPriority(s32 priority) {
SharedPtr<Thread> SetupIdleThread() { SharedPtr<Thread> SetupIdleThread() {
// We need to pass a few valid values to get around parameter checking in Thread::Create. // We need to pass a few valid values to get around parameter checking in Thread::Create.
auto thread = Thread::Create("idle", Memory::KERNEL_MEMORY_VADDR, THREADPRIO_LOWEST, 0, // TODO(yuriks): Figure out a way to avoid passing the bogus VAddr parameter
auto thread = Thread::Create("idle", Memory::TLS_AREA_VADDR, THREADPRIO_LOWEST, 0,
THREADPROCESSORID_0, 0).MoveFrom(); THREADPROCESSORID_0, 0).MoveFrom();
thread->idle = true; thread->idle = true;
@ -455,7 +456,7 @@ SharedPtr<Thread> SetupMainThread(u32 stack_size, u32 entry_point, s32 priority)
// Initialize new "main" thread // Initialize new "main" thread
auto thread_res = Thread::Create("main", entry_point, priority, 0, auto thread_res = Thread::Create("main", entry_point, priority, 0,
THREADPROCESSORID_0, Memory::SCRATCHPAD_VADDR_END); THREADPROCESSORID_0, Memory::HEAP_VADDR_END - stack_size);
SharedPtr<Thread> thread = thread_res.MoveFrom(); SharedPtr<Thread> thread = thread_res.MoveFrom();

2
src/core/hle/service/dsp_dsp.cpp
View File

@ -42,7 +42,7 @@ static void ConvertProcessAddressFromDspDram(Service::Interface* self) {
u32 addr = cmd_buff[1]; u32 addr = cmd_buff[1];
cmd_buff[1] = 0; // No error cmd_buff[1] = 0; // No error
cmd_buff[2] = (addr << 1) + (Memory::DSP_MEMORY_VADDR + 0x40000); cmd_buff[2] = (addr << 1) + (Memory::DSP_RAM_VADDR + 0x40000);
LOG_WARNING(Service_DSP, "(STUBBED) called with address 0x%08X", addr); LOG_WARNING(Service_DSP, "(STUBBED) called with address 0x%08X", addr);
} }

4
src/core/loader/3dsx.cpp
View File

@ -234,9 +234,9 @@ ResultStatus AppLoader_THREEDSX::Load() {
Kernel::g_current_process->svc_access_mask.set(); Kernel::g_current_process->svc_access_mask.set();
Kernel::g_current_process->address_mappings = default_address_mappings; Kernel::g_current_process->address_mappings = default_address_mappings;
Load3DSXFile(*file, Memory::EXEFS_CODE_VADDR); Load3DSXFile(*file, Memory::PROCESS_IMAGE_VADDR);
Kernel::g_current_process->Run(Memory::EXEFS_CODE_VADDR, 48, Kernel::DEFAULT_STACK_SIZE); Kernel::g_current_process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Kernel::DEFAULT_STACK_SIZE);
is_loaded = true; is_loaded = true;
return ResultStatus::Success; return ResultStatus::Success;

2
src/core/loader/elf.cpp
View File

@ -355,7 +355,7 @@ ResultStatus AppLoader_ELF::Load() {
Kernel::g_current_process->address_mappings = default_address_mappings; Kernel::g_current_process->address_mappings = default_address_mappings;
ElfReader elf_reader(&buffer[0]); ElfReader elf_reader(&buffer[0]);
elf_reader.LoadInto(Memory::EXEFS_CODE_VADDR); elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR);
// TODO: Fill application title // TODO: Fill application title
Kernel::g_current_process->Run(elf_reader.GetEntryPoint(), 48, Kernel::DEFAULT_STACK_SIZE); Kernel::g_current_process->Run(elf_reader.GetEntryPoint(), 48, Kernel::DEFAULT_STACK_SIZE);

18
src/core/mem_map.cpp
View File

@ -12,13 +12,12 @@
namespace Memory { namespace Memory {
u8* g_exefs_code; ///< ExeFS:/.code is loaded here u8* g_exefs_code; ///< ExeFS:/.code is loaded here
u8* g_system_mem; ///< System memory
u8* g_heap; ///< Application heap (main memory) u8* g_heap; ///< Application heap (main memory)
u8* g_heap_linear; ///< Linear heap u8* g_heap_linear; ///< Linear heap
u8* g_vram; ///< Video memory (VRAM) pointer u8* g_vram; ///< Video memory (VRAM) pointer
u8* g_shared_mem; ///< Shared memory u8* g_shared_mem; ///< Shared memory
u8* g_dsp_mem; ///< DSP memory u8* g_dsp_mem; ///< DSP memory
u8* g_kernel_mem; ///< Kernel memory u8* g_tls_mem; ///< TLS memory
namespace { namespace {
@ -29,14 +28,13 @@ struct MemoryArea {
// We don't declare the IO regions in here since its handled by other means. // We don't declare the IO regions in here since its handled by other means.
static MemoryArea memory_areas[] = { static MemoryArea memory_areas[] = {
{&g_exefs_code, EXEFS_CODE_SIZE }, {&g_exefs_code, PROCESS_IMAGE_MAX_SIZE},
{&g_vram, VRAM_SIZE }, {&g_vram, VRAM_SIZE },
{&g_heap, HEAP_SIZE }, {&g_heap, HEAP_SIZE },
{&g_shared_mem, SHARED_MEMORY_SIZE}, {&g_shared_mem, SHARED_MEMORY_SIZE },
{&g_system_mem, SYSTEM_MEMORY_SIZE}, {&g_dsp_mem, DSP_RAM_SIZE },
{&g_dsp_mem, DSP_MEMORY_SIZE }, {&g_tls_mem, TLS_AREA_SIZE },
{&g_kernel_mem, KERNEL_MEMORY_SIZE}, {&g_heap_linear, LINEAR_HEAP_SIZE },
{&g_heap_linear, HEAP_LINEAR_SIZE },
}; };
} }

131
src/core/mem_map.h
View File

@ -12,79 +12,93 @@ namespace Memory {
const u32 PAGE_SIZE = 0x1000; const u32 PAGE_SIZE = 0x1000;
enum : u32 { /// Physical memory regions as seen from the ARM11
BOOTROM_SIZE = 0x00010000, ///< Bootrom (super secret code/data @ 0x8000) size enum : PAddr {
BOOTROM_PADDR = 0x00000000, ///< Bootrom physical address /// IO register area
BOOTROM_PADDR_END = (BOOTROM_PADDR + BOOTROM_SIZE), IO_AREA_PADDR = 0x10100000,
IO_AREA_SIZE = 0x01000000, ///< IO area size (16MB)
IO_AREA_PADDR_END = IO_AREA_PADDR + IO_AREA_SIZE,
BOOTROM_MIRROR_SIZE = 0x00010000, ///< Bootrom Mirror size /// MPCore internal memory region
BOOTROM_MIRROR_PADDR = 0x00010000, ///< Bootrom Mirror physical address MPCORE_RAM_PADDR = 0x17E00000,
BOOTROM_MIRROR_PADDR_END = (BOOTROM_MIRROR_PADDR + BOOTROM_MIRROR_SIZE), MPCORE_RAM_SIZE = 0x00002000, ///< MPCore internal memory size (8KB)
MPCORE_RAM_PADDR_END = MPCORE_RAM_PADDR + MPCORE_RAM_SIZE,
MPCORE_PRIV_SIZE = 0x00002000, ///< MPCore private memory region size /// Video memory
MPCORE_PRIV_PADDR = 0x17E00000, ///< MPCore private memory region physical address VRAM_PADDR = 0x18000000,
MPCORE_PRIV_PADDR_END = (MPCORE_PRIV_PADDR + MPCORE_PRIV_SIZE), VRAM_SIZE = 0x00600000, ///< VRAM size (6MB)
VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE,
FCRAM_SIZE = 0x08000000, ///< FCRAM size /// DSP memory
FCRAM_PADDR = 0x20000000, ///< FCRAM physical address DSP_RAM_PADDR = 0x1FF00000,
FCRAM_PADDR_END = (FCRAM_PADDR + FCRAM_SIZE), DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB)
DSP_RAM_PADDR_END = DSP_RAM_PADDR + DSP_RAM_SIZE,
HEAP_SIZE = FCRAM_SIZE, ///< Application heap size /// AXI WRAM
HEAP_VADDR = 0x08000000, AXI_WRAM_PADDR = 0x1FF80000,
HEAP_VADDR_END = (HEAP_VADDR + HEAP_SIZE), AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB)
AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE,
HEAP_LINEAR_SIZE = FCRAM_SIZE, /// Main FCRAM
HEAP_LINEAR_VADDR = 0x14000000, FCRAM_PADDR = 0x20000000,
HEAP_LINEAR_VADDR_END = (HEAP_LINEAR_VADDR + HEAP_LINEAR_SIZE), FCRAM_SIZE = 0x08000000, ///< FCRAM size (128MB)
FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE,
};
AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size /// Virtual user-space memory regions
AXI_WRAM_PADDR = 0x1FF80000, ///< AXI WRAM physical address enum : VAddr {
AXI_WRAM_PADDR_END = (AXI_WRAM_PADDR + AXI_WRAM_SIZE), /// 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,
SHARED_MEMORY_SIZE = 0x04000000, ///< Shared memory size /// Area where IPC buffers are mapped onto.
SHARED_MEMORY_VADDR = 0x10000000, ///< Shared memory IPC_MAPPING_VADDR = 0x04000000,
SHARED_MEMORY_VADDR_END = (SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE), IPC_MAPPING_SIZE = 0x04000000,
IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE,
DSP_MEMORY_SIZE = 0x00080000, ///< DSP memory size /// Application heap (includes stack).
DSP_MEMORY_VADDR = 0x1FF00000, ///< DSP memory virtual address HEAP_VADDR = 0x08000000,
DSP_MEMORY_VADDR_END = (DSP_MEMORY_VADDR + DSP_MEMORY_SIZE), HEAP_SIZE = 0x08000000,
HEAP_VADDR_END = HEAP_VADDR + HEAP_SIZE,
CONFIG_MEMORY_SIZE = 0x00001000, ///< Configuration memory size /// Area where shared memory buffers are mapped onto.
CONFIG_MEMORY_VADDR = 0x1FF80000, ///< Configuration memory virtual address SHARED_MEMORY_VADDR = 0x10000000,
CONFIG_MEMORY_VADDR_END = (CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE), SHARED_MEMORY_SIZE = 0x04000000,
SHARED_MEMORY_VADDR_END = SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE,
SHARED_PAGE_SIZE = 0x00001000, ///< Shared page size /// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical memory.
SHARED_PAGE_VADDR = 0x1FF81000, ///< Shared page virtual address LINEAR_HEAP_VADDR = 0x14000000,
SHARED_PAGE_VADDR_END = (SHARED_PAGE_VADDR + SHARED_PAGE_SIZE), LINEAR_HEAP_SIZE = 0x08000000,
LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE,
KERNEL_MEMORY_SIZE = 0x00001000, ///< Kernel memory size /// Maps 1:1 to the IO register area.
KERNEL_MEMORY_VADDR = 0xFFFF0000, ///< Kernel memory where the kthread objects etc are IO_AREA_VADDR = 0x1EC00000,
KERNEL_MEMORY_VADDR_END = (KERNEL_MEMORY_VADDR + KERNEL_MEMORY_SIZE), IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE,
EXEFS_CODE_SIZE = 0x03F00000, /// Maps 1:1 to VRAM.
EXEFS_CODE_VADDR = 0x00100000, ///< ExeFS:/.code is loaded here VRAM_VADDR = 0x1F000000,
EXEFS_CODE_VADDR_END = (EXEFS_CODE_VADDR + EXEFS_CODE_SIZE), VRAM_VADDR_END = VRAM_VADDR + VRAM_SIZE,
// Region of FCRAM used by system /// Maps 1:1 to DSP memory.
SYSTEM_MEMORY_SIZE = 0x02C00000, ///< 44MB DSP_RAM_VADDR = 0x1FF00000,
SYSTEM_MEMORY_VADDR = 0x04000000, DSP_RAM_VADDR_END = DSP_RAM_VADDR + DSP_RAM_SIZE,
SYSTEM_MEMORY_VADDR_END = (SYSTEM_MEMORY_VADDR + SYSTEM_MEMORY_SIZE),
HARDWARE_IO_SIZE = 0x01000000, /// Read-only page containing kernel and system configuration values.
HARDWARE_IO_PADDR = 0x10000000, ///< IO physical address start CONFIG_MEMORY_VADDR = 0x1FF80000,
HARDWARE_IO_VADDR = 0x1EC00000, ///< IO virtual address start CONFIG_MEMORY_SIZE = 0x00001000,
HARDWARE_IO_PADDR_END = (HARDWARE_IO_PADDR + HARDWARE_IO_SIZE), CONFIG_MEMORY_VADDR_END = CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE,
HARDWARE_IO_VADDR_END = (HARDWARE_IO_VADDR + HARDWARE_IO_SIZE),
VRAM_SIZE = 0x00600000, /// Usually read-only page containing mostly values read from hardware.
VRAM_PADDR = 0x18000000, SHARED_PAGE_VADDR = 0x1FF81000,
VRAM_VADDR = 0x1F000000, SHARED_PAGE_SIZE = 0x00001000,
VRAM_PADDR_END = (VRAM_PADDR + VRAM_SIZE), SHARED_PAGE_VADDR_END = SHARED_PAGE_VADDR + SHARED_PAGE_SIZE,
VRAM_VADDR_END = (VRAM_VADDR + VRAM_SIZE),
SCRATCHPAD_SIZE = 0x00004000, ///< Typical stack size - TODO: Read from exheader // TODO(yuriks): The exact location and size of this area is uncomfirmed.
SCRATCHPAD_VADDR_END = 0x10000000, /// Area where TLS (Thread-Local Storage) buffers are allocated.
SCRATCHPAD_VADDR = (SCRATCHPAD_VADDR_END - SCRATCHPAD_SIZE), ///< Stack space TLS_AREA_VADDR = 0x1FFA0000,
TLS_AREA_SIZE = 0x00002000, // Each TLS buffer is 0x200 bytes, allows for 16 threads
TLS_AREA_VADDR_END = TLS_AREA_VADDR + TLS_AREA_SIZE,
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
@ -111,9 +125,8 @@ extern u8* g_heap_linear; ///< Linear heap (main memory)
extern u8* g_heap; ///< Application heap (main memory) extern u8* g_heap; ///< Application heap (main memory)
extern u8* g_vram; ///< Video memory (VRAM) extern u8* g_vram; ///< Video memory (VRAM)
extern u8* g_shared_mem; ///< Shared memory extern u8* g_shared_mem; ///< Shared memory
extern u8* g_kernel_mem; ///< Kernel memory extern u8* g_tls_mem; ///< TLS memory
extern u8* g_dsp_mem; ///< DSP memory extern u8* g_dsp_mem; ///< DSP memory
extern u8* g_system_mem; ///< System memory
extern u8* g_exefs_code; ///< ExeFS:/.code is loaded here extern u8* g_exefs_code; ///< ExeFS:/.code is loaded here
void Init(); void Init();

64
src/core/mem_map_funcs.cpp
View File

@ -29,7 +29,7 @@ VAddr PhysicalToVirtualAddress(const PAddr addr) {
} else if ((addr >= VRAM_PADDR) && (addr < VRAM_PADDR_END)) { } else if ((addr >= VRAM_PADDR) && (addr < VRAM_PADDR_END)) {
return addr - VRAM_PADDR + VRAM_VADDR; return addr - VRAM_PADDR + VRAM_VADDR;
} else if ((addr >= FCRAM_PADDR) && (addr < FCRAM_PADDR_END)) { } else if ((addr >= FCRAM_PADDR) && (addr < FCRAM_PADDR_END)) {
return addr - FCRAM_PADDR + HEAP_LINEAR_VADDR; return addr - FCRAM_PADDR + LINEAR_HEAP_VADDR;
} }
LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr); LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr);
@ -46,8 +46,8 @@ PAddr VirtualToPhysicalAddress(const VAddr addr) {
return 0; return 0;
} else if ((addr >= VRAM_VADDR) && (addr < VRAM_VADDR_END)) { } else if ((addr >= VRAM_VADDR) && (addr < VRAM_VADDR_END)) {
return addr - VRAM_VADDR + VRAM_PADDR; return addr - VRAM_VADDR + VRAM_PADDR;
} else if ((addr >= HEAP_LINEAR_VADDR) && (addr < HEAP_LINEAR_VADDR_END)) { } else if ((addr >= LINEAR_HEAP_VADDR) && (addr < LINEAR_HEAP_VADDR_END)) {
return addr - HEAP_LINEAR_VADDR + FCRAM_PADDR; return addr - LINEAR_HEAP_VADDR + FCRAM_PADDR;
} }
LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr); LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr);
@ -61,16 +61,16 @@ inline void Read(T &var, const VAddr vaddr) {
// Could just do a base-relative read, too.... TODO // Could just do a base-relative read, too.... TODO
// Kernel memory command buffer // Kernel memory command buffer
if (vaddr >= KERNEL_MEMORY_VADDR && vaddr < KERNEL_MEMORY_VADDR_END) { if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) {
var = *((const T*)&g_kernel_mem[vaddr - KERNEL_MEMORY_VADDR]); var = *((const T*)&g_tls_mem[vaddr - TLS_AREA_VADDR]);
// ExeFS:/.code is loaded here // ExeFS:/.code is loaded here
} else if ((vaddr >= EXEFS_CODE_VADDR) && (vaddr < EXEFS_CODE_VADDR_END)) { } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) {
var = *((const T*)&g_exefs_code[vaddr - EXEFS_CODE_VADDR]); var = *((const T*)&g_exefs_code[vaddr - PROCESS_IMAGE_VADDR]);
// FCRAM - linear heap // FCRAM - linear heap
} else if ((vaddr >= HEAP_LINEAR_VADDR) && (vaddr < HEAP_LINEAR_VADDR_END)) { } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) {
var = *((const T*)&g_heap_linear[vaddr - HEAP_LINEAR_VADDR]); var = *((const T*)&g_heap_linear[vaddr - LINEAR_HEAP_VADDR]);
// FCRAM - application heap // FCRAM - application heap
} else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
@ -80,10 +80,6 @@ inline void Read(T &var, const VAddr vaddr) {
} else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) {
var = *((const T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR]); var = *((const T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR]);
// System memory
} else if ((vaddr >= SYSTEM_MEMORY_VADDR) && (vaddr < SYSTEM_MEMORY_VADDR_END)) {
var = *((const T*)&g_system_mem[vaddr - SYSTEM_MEMORY_VADDR]);
// Config memory // Config memory
} else if ((vaddr >= CONFIG_MEMORY_VADDR) && (vaddr < CONFIG_MEMORY_VADDR_END)) { } else if ((vaddr >= CONFIG_MEMORY_VADDR) && (vaddr < CONFIG_MEMORY_VADDR_END)) {
ConfigMem::Read<T>(var, vaddr); ConfigMem::Read<T>(var, vaddr);
@ -93,8 +89,8 @@ inline void Read(T &var, const VAddr vaddr) {
SharedPage::Read<T>(var, vaddr); SharedPage::Read<T>(var, vaddr);
// DSP memory // DSP memory
} else if ((vaddr >= DSP_MEMORY_VADDR) && (vaddr < DSP_MEMORY_VADDR_END)) { } else if ((vaddr >= DSP_RAM_VADDR) && (vaddr < DSP_RAM_VADDR_END)) {
var = *((const T*)&g_dsp_mem[vaddr - DSP_MEMORY_VADDR]); var = *((const T*)&g_dsp_mem[vaddr - DSP_RAM_VADDR]);
// VRAM // VRAM
} else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) {
@ -109,16 +105,16 @@ template <typename T>
inline void Write(const VAddr vaddr, const T data) { inline void Write(const VAddr vaddr, const T data) {
// Kernel memory command buffer // Kernel memory command buffer
if (vaddr >= KERNEL_MEMORY_VADDR && vaddr < KERNEL_MEMORY_VADDR_END) { if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) {
*(T*)&g_kernel_mem[vaddr - KERNEL_MEMORY_VADDR] = data; *(T*)&g_tls_mem[vaddr - TLS_AREA_VADDR] = data;
// ExeFS:/.code is loaded here // ExeFS:/.code is loaded here
} else if ((vaddr >= EXEFS_CODE_VADDR) && (vaddr < EXEFS_CODE_VADDR_END)) { } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) {
*(T*)&g_exefs_code[vaddr - EXEFS_CODE_VADDR] = data; *(T*)&g_exefs_code[vaddr - PROCESS_IMAGE_VADDR] = data;
// FCRAM - linear heap // FCRAM - linear heap
} else if ((vaddr >= HEAP_LINEAR_VADDR) && (vaddr < HEAP_LINEAR_VADDR_END)) { } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) {
*(T*)&g_heap_linear[vaddr - HEAP_LINEAR_VADDR] = data; *(T*)&g_heap_linear[vaddr - LINEAR_HEAP_VADDR] = data;
// FCRAM - application heap // FCRAM - application heap
} else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
@ -128,17 +124,13 @@ inline void Write(const VAddr vaddr, const T data) {
} else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) {
*(T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR] = data; *(T*)&g_shared_mem[vaddr - SHARED_MEMORY_VADDR] = data;
// System memory
} else if ((vaddr >= SYSTEM_MEMORY_VADDR) && (vaddr < SYSTEM_MEMORY_VADDR_END)) {
*(T*)&g_system_mem[vaddr - SYSTEM_MEMORY_VADDR] = data;
// VRAM // VRAM
} else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) {
*(T*)&g_vram[vaddr - VRAM_VADDR] = data; *(T*)&g_vram[vaddr - VRAM_VADDR] = data;
// DSP memory // DSP memory
} else if ((vaddr >= DSP_MEMORY_VADDR) && (vaddr < DSP_MEMORY_VADDR_END)) { } else if ((vaddr >= DSP_RAM_VADDR) && (vaddr < DSP_RAM_VADDR_END)) {
*(T*)&g_dsp_mem[vaddr - DSP_MEMORY_VADDR] = data; *(T*)&g_dsp_mem[vaddr - DSP_RAM_VADDR] = data;
//} else if ((vaddr & 0xFFFF0000) == 0x1FF80000) { //} else if ((vaddr & 0xFFFF0000) == 0x1FF80000) {
// ASSERT_MSG(MEMMAP, false, "umimplemented write to Configuration Memory"); // ASSERT_MSG(MEMMAP, false, "umimplemented write to Configuration Memory");
@ -153,16 +145,16 @@ inline void Write(const VAddr vaddr, const T data) {
u8 *GetPointer(const VAddr vaddr) { u8 *GetPointer(const VAddr vaddr) {
// Kernel memory command buffer // Kernel memory command buffer
if (vaddr >= KERNEL_MEMORY_VADDR && vaddr < KERNEL_MEMORY_VADDR_END) { if (vaddr >= TLS_AREA_VADDR && vaddr < TLS_AREA_VADDR_END) {
return g_kernel_mem + (vaddr - KERNEL_MEMORY_VADDR); return g_tls_mem + (vaddr - TLS_AREA_VADDR);
// ExeFS:/.code is loaded here // ExeFS:/.code is loaded here
} else if ((vaddr >= EXEFS_CODE_VADDR) && (vaddr < EXEFS_CODE_VADDR_END)) { } else if ((vaddr >= PROCESS_IMAGE_VADDR) && (vaddr < PROCESS_IMAGE_VADDR_END)) {
return g_exefs_code + (vaddr - EXEFS_CODE_VADDR); return g_exefs_code + (vaddr - PROCESS_IMAGE_VADDR);
// FCRAM - linear heap // FCRAM - linear heap
} else if ((vaddr >= HEAP_LINEAR_VADDR) && (vaddr < HEAP_LINEAR_VADDR_END)) { } else if ((vaddr >= LINEAR_HEAP_VADDR) && (vaddr < LINEAR_HEAP_VADDR_END)) {
return g_heap_linear + (vaddr - HEAP_LINEAR_VADDR); return g_heap_linear + (vaddr - LINEAR_HEAP_VADDR);
// FCRAM - application heap // FCRAM - application heap
} else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) { } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
@ -172,10 +164,6 @@ u8 *GetPointer(const VAddr vaddr) {
} else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) { } else if ((vaddr >= SHARED_MEMORY_VADDR) && (vaddr < SHARED_MEMORY_VADDR_END)) {
return g_shared_mem + (vaddr - SHARED_MEMORY_VADDR); return g_shared_mem + (vaddr - SHARED_MEMORY_VADDR);
// System memory
} else if ((vaddr >= SYSTEM_MEMORY_VADDR) && (vaddr < SYSTEM_MEMORY_VADDR_END)) {
return g_system_mem + (vaddr - SYSTEM_MEMORY_VADDR);
// VRAM // VRAM
} else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) { } else if ((vaddr >= VRAM_VADDR) && (vaddr < VRAM_VADDR_END)) {
return g_vram + (vaddr - VRAM_VADDR); return g_vram + (vaddr - VRAM_VADDR);
@ -206,7 +194,7 @@ u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) {
u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) { u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) {
MemoryBlock block; MemoryBlock block;
block.base_address = HEAP_LINEAR_VADDR; block.base_address = LINEAR_HEAP_VADDR;
block.size = size; block.size = size;
block.operation = operation; block.operation = operation;
block.permissions = permissions; block.permissions = permissions;

2
src/video_core/pica.h
View File

@ -1003,7 +1003,7 @@ inline static u32 PAddrToVAddr(u32 addr) {
if (addr >= Memory::VRAM_PADDR && addr < Memory::VRAM_PADDR + Memory::VRAM_SIZE) { if (addr >= Memory::VRAM_PADDR && addr < Memory::VRAM_PADDR + Memory::VRAM_SIZE) {
return addr - Memory::VRAM_PADDR + Memory::VRAM_VADDR; return addr - Memory::VRAM_PADDR + Memory::VRAM_VADDR;
} else if (addr >= Memory::FCRAM_PADDR && addr < Memory::FCRAM_PADDR + Memory::FCRAM_SIZE) { } else if (addr >= Memory::FCRAM_PADDR && addr < Memory::FCRAM_PADDR + Memory::FCRAM_SIZE) {
return addr - Memory::FCRAM_PADDR + Memory::HEAP_LINEAR_VADDR; return addr - Memory::FCRAM_PADDR + Memory::LINEAR_HEAP_VADDR;
} else { } else {
return 0; return 0;
} }