midou/citra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Memory: replace PhysicalToVirtualAddress with a more dedicated function

Browse Source 
There is no external use of PhysicalToVirtualAddress any more, so it there is no need to have a generic function that handles all physical regions. Also, the previous APT change makes it possible that linear heap has some regions mapped to old and new VAddr regions at the same time, so we need to check both region and mark cached for the mapped one. RasterizerMarkRegionCached would skip the unmapped one in its loop
This commit is contained in:
Weiyi Wang 2018-11-04 12:15:55 -05:00
parent 8c65433ab5
commit 2654a679b3
2 changed files with 54 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
src/core/memory.cpp
View File

@ -318,6 +318,22 @@ u8* GetPhysicalPointer(PAddr address) {
return target_pointer; return target_pointer;
} }
/// For a rasterizer-accessible PAddr, gets a list of all possible VAddr
static std::vector<VAddr> PhysicalToVirtualAddressForRasterizer(PAddr addr) {
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, addr - FCRAM_PADDR + NEW_LINEAR_HEAP_VADDR};
} else {
// While the physical <-> virtual mapping is 1:1 for the regions supported by the cache,
// some games (like Pokemon Super Mystery Dungeon) will try to use textures that go beyond
// the end address of VRAM, causing the Virtual->Physical translation to fail when flushing
// parts of the texture.
LOG_ERROR(HW_Memory, "Trying to use invalid physical address for rasterizer: {:08X}", addr);
return {};
}
}
void RasterizerMarkRegionCached(PAddr start, u32 size, bool cached) { void RasterizerMarkRegionCached(PAddr start, u32 size, bool cached) {
if (start == 0) { if (start == 0) {
return; return;
@ -327,57 +343,46 @@ void RasterizerMarkRegionCached(PAddr start, u32 size, bool cached) {
PAddr paddr = start; PAddr paddr = start;
for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) { for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) {
std::optional<VAddr> maybe_vaddr = PhysicalToVirtualAddress(paddr); for (VAddr vaddr : PhysicalToVirtualAddressForRasterizer(paddr)) {
// While the physical <-> virtual mapping is 1:1 for the regions supported by the cache, PageType& page_type = current_page_table->attributes[vaddr >> PAGE_BITS];
// some games (like Pokemon Super Mystery Dungeon) will try to use textures that go beyond
// the end address of VRAM, causing the Virtual->Physical translation to fail when flushing
// parts of the texture.
if (!maybe_vaddr) {
LOG_ERROR(HW_Memory,
"Trying to flush a cached region to an invalid physical address {:08X}",
paddr);
continue;
}
VAddr vaddr = *maybe_vaddr;
PageType& page_type = current_page_table->attributes[vaddr >> PAGE_BITS]; if (cached) {
// Switch page type to cached if now cached
if (cached) { switch (page_type) {
// Switch page type to cached if now cached case PageType::Unmapped:
switch (page_type) { // It is not necessary for a process to have this region mapped into its address
case PageType::Unmapped: // space, for example, a system module need not have a VRAM mapping.
// It is not necessary for a process to have this region mapped into its address break;
// space, for example, a system module need not have a VRAM mapping. case PageType::Memory:
break; page_type = PageType::RasterizerCachedMemory;
case PageType::Memory: current_page_table->pointers[vaddr >> PAGE_BITS] = nullptr;
page_type = PageType::RasterizerCachedMemory; break;
current_page_table->pointers[vaddr >> PAGE_BITS] = nullptr; default:
break; UNREACHABLE();
default: }
UNREACHABLE(); } else {
} // Switch page type to uncached if now uncached
} else { switch (page_type) {
// Switch page type to uncached if now uncached case PageType::Unmapped:
switch (page_type) { // It is not necessary for a process to have this region mapped into its address
case PageType::Unmapped: // space, for example, a system module need not have a VRAM mapping.
// It is not necessary for a process to have this region mapped into its address break;
// space, for example, a system module need not have a VRAM mapping. case PageType::RasterizerCachedMemory: {
break; u8* pointer = GetPointerFromVMA(vaddr & ~PAGE_MASK);
case PageType::RasterizerCachedMemory: { if (pointer == nullptr) {
u8* pointer = GetPointerFromVMA(vaddr & ~PAGE_MASK); // It's possible that this function has been called while updating the
if (pointer == nullptr) { // pagetable after unmapping a VMA. In that case the underlying VMA will no
// It's possible that this function has been called while updating the pagetable // longer exist, and we should just leave the pagetable entry blank.
// after unmapping a VMA. In that case the underlying VMA will no longer exist, page_type = PageType::Unmapped;
// and we should just leave the pagetable entry blank. } else {
page_type = PageType::Unmapped; page_type = PageType::Memory;
} else { current_page_table->pointers[vaddr >> PAGE_BITS] = pointer;
page_type = PageType::Memory; }
current_page_table->pointers[vaddr >> PAGE_BITS] = pointer; break;
}
default:
UNREACHABLE();
} }
break;
}
default:
UNREACHABLE();
} }
} }
} }
@ -820,25 +825,6 @@ PAddr VirtualToPhysicalAddress(const VAddr addr) {
return *paddr; return *paddr;
} }
std::optional<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 +
Core::System::GetInstance().Kernel().GetCurrentProcess()->GetLinearHeapAreaAddress();
} 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;
} else if (addr >= N3DS_EXTRA_RAM_PADDR && addr < N3DS_EXTRA_RAM_PADDR_END) {
return addr - N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_VADDR;
}
return {};
}
u32 GetFCRAMOffset(u8* pointer) { u32 GetFCRAMOffset(u8* pointer) {
ASSERT(pointer >= fcram.data() && pointer < fcram.data() + fcram.size()); ASSERT(pointer >= fcram.data() && pointer < fcram.data() + fcram.size());
return pointer - fcram.data(); return pointer - fcram.data();

5
src/core/memory.h
View File

@ -228,11 +228,6 @@ std::optional<PAddr> TryVirtualToPhysicalAddress(VAddr addr);
*/ */
PAddr VirtualToPhysicalAddress(VAddr addr); PAddr VirtualToPhysicalAddress(VAddr addr);
/**
* Undoes a mapping performed by VirtualToPhysicalAddress().
*/
std::optional<VAddr> PhysicalToVirtualAddress(PAddr paddr);
/** /**
* Gets a pointer to the memory region beginning at the specified physical address. * Gets a pointer to the memory region beginning at the specified physical address.
*/ */