Merge pull request #4431 from wwylele/no-v2p

Memory: remove VirtualToPhysicalAddress

src/core/arm/skyeye_common/armstate.cpp

@@ -468,8 +468,7 @@ void ARMul_State::WriteCP15Register(u32 value, u32 crn, u32 opcode_1, u32 crm, u
             if (crm == 0 && opcode_2 == 4) {
                 CP15[CP15_WAIT_FOR_INTERRUPT] = value;
             } else if (crm == 4 && opcode_2 == 0) {
-                // NOTE: Not entirely accurate. This should do permission checks.
+                LOG_ERROR(Core_ARM11, "Unimplemented virtual to physical address");
-                CP15[CP15_PHYS_ADDRESS] = Memory::VirtualToPhysicalAddress(value);
             } else if (crm == 5) {
                 if (opcode_2 == 0)
                     CP15[CP15_INVALIDATE_INSTR_CACHE] = value;

src/core/hle/service/gsp/gsp_gpu.cpp

@@ -56,6 +56,29 @@ constexpr u32 MaxGSPThreads = 4;
 /// Thread ids currently in use by the sessions connected to the GSPGPU service.
 static std::array<bool, MaxGSPThreads> used_thread_ids = {false, false, false, false};
 
+static PAddr VirtualToPhysicalAddress(VAddr addr) {
+    if (addr == 0) {
+        return 0;
+    }
+
+    // Note: the region end check is inclusive because the game can pass in an address that
+    // represents an open right boundary
+    if (addr >= Memory::VRAM_VADDR && addr <= Memory::VRAM_VADDR_END) {
+        return addr - Memory::VRAM_VADDR + Memory::VRAM_PADDR;
+    }
+    if (addr >= Memory::LINEAR_HEAP_VADDR && addr <= Memory::LINEAR_HEAP_VADDR_END) {
+        return addr - Memory::LINEAR_HEAP_VADDR + Memory::FCRAM_PADDR;
+    }
+    if (addr >= Memory::NEW_LINEAR_HEAP_VADDR && addr <= Memory::NEW_LINEAR_HEAP_VADDR_END) {
+        return addr - Memory::NEW_LINEAR_HEAP_VADDR + Memory::FCRAM_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.
+    // TODO: find the correct way to handle this error
+    return addr | 0x80000000;
+}
+
 static u32 GetUnusedThreadId() {
     for (u32 id = 0; id < MaxGSPThreads; ++id) {
         if (!used_thread_ids[id])
@@ -258,8 +281,8 @@ void GSP_GPU::ReadHWRegs(Kernel::HLERequestContext& ctx) {
 
 ResultCode SetBufferSwap(u32 screen_id, const FrameBufferInfo& info) {
     u32 base_address = 0x400000;
-    PAddr phys_address_left = Memory::VirtualToPhysicalAddress(info.address_left);
+    PAddr phys_address_left = VirtualToPhysicalAddress(info.address_left);
-    PAddr phys_address_right = Memory::VirtualToPhysicalAddress(info.address_right);
+    PAddr phys_address_right = VirtualToPhysicalAddress(info.address_right);
     if (info.active_fb == 0) {
         WriteSingleHWReg(base_address + 4 * static_cast<u32>(GPU_REG_INDEX(
                                                 framebuffer_config[screen_id].address_left1)),
@@ -495,7 +518,7 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
         }
 
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.address)),
-                         Memory::VirtualToPhysicalAddress(params.address) >> 3);
+                         VirtualToPhysicalAddress(params.address) >> 3);
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(command_processor_config.size)),
                          params.size);
 
@@ -515,9 +538,9 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
 
         if (params.start1 != 0) {
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].address_start)),
-                             Memory::VirtualToPhysicalAddress(params.start1) >> 3);
+                             VirtualToPhysicalAddress(params.start1) >> 3);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].address_end)),
-                             Memory::VirtualToPhysicalAddress(params.end1) >> 3);
+                             VirtualToPhysicalAddress(params.end1) >> 3);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].value_32bit)),
                              params.value1);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[0].control)),
@@ -526,9 +549,9 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
 
         if (params.start2 != 0) {
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].address_start)),
-                             Memory::VirtualToPhysicalAddress(params.start2) >> 3);
+                             VirtualToPhysicalAddress(params.start2) >> 3);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].address_end)),
-                             Memory::VirtualToPhysicalAddress(params.end2) >> 3);
+                             VirtualToPhysicalAddress(params.end2) >> 3);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].value_32bit)),
                              params.value2);
             WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(memory_fill_config[1].control)),
@@ -540,9 +563,9 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
     case CommandId::SET_DISPLAY_TRANSFER: {
         auto& params = command.display_transfer;
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.input_address)),
-                         Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
+                         VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.output_address)),
-                         Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
+                         VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.input_size)),
                          params.in_buffer_size);
         WriteGPURegister(static_cast<u32>(GPU_REG_INDEX(display_transfer_config.output_size)),
@@ -556,9 +579,9 @@ static void ExecuteCommand(const Command& command, u32 thread_id) {
     case CommandId::SET_TEXTURE_COPY: {
         auto& params = command.texture_copy;
         WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.input_address),
-                         Memory::VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
+                         VirtualToPhysicalAddress(params.in_buffer_address) >> 3);
         WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.output_address),
-                         Memory::VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
+                         VirtualToPhysicalAddress(params.out_buffer_address) >> 3);
         WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.texture_copy.size),
                          params.size);
         WriteGPURegister((u32)GPU_REG_INDEX(display_transfer_config.texture_copy.input_size),

src/core/memory.cpp

@@ -426,7 +426,7 @@ void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode) {
 
     VAddr end = start + size;
 
-    auto CheckRegion = [&](VAddr region_start, VAddr region_end) {
+    auto CheckRegion = [&](VAddr region_start, VAddr region_end, PAddr paddr_region_start) {
         if (start >= region_end || end <= region_start) {
             // No overlap with region
             return;
@@ -434,10 +434,7 @@ void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode) {
 
         VAddr overlap_start = std::max(start, region_start);
         VAddr overlap_end = std::min(end, region_end);
-
+        PAddr physical_start = paddr_region_start + (overlap_start - region_start);
-        auto maybe_paddr = TryVirtualToPhysicalAddress(overlap_start);
-        ASSERT(maybe_paddr);
-        PAddr physical_start = *maybe_paddr;
         u32 overlap_size = overlap_end - overlap_start;
 
         auto* rasterizer = VideoCore::g_renderer->Rasterizer();
@@ -454,9 +451,9 @@ void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode) {
         }
     };
 
-    CheckRegion(LINEAR_HEAP_VADDR, LINEAR_HEAP_VADDR_END);
+    CheckRegion(LINEAR_HEAP_VADDR, LINEAR_HEAP_VADDR_END, FCRAM_PADDR);
-    CheckRegion(NEW_LINEAR_HEAP_VADDR, NEW_LINEAR_HEAP_VADDR_END);
+    CheckRegion(NEW_LINEAR_HEAP_VADDR, NEW_LINEAR_HEAP_VADDR_END, FCRAM_PADDR);
-    CheckRegion(VRAM_VADDR, VRAM_VADDR_END);
+    CheckRegion(VRAM_VADDR, VRAM_VADDR_END, VRAM_PADDR);
 }
 
 u8 Read8(const VAddr addr) {
@@ -798,36 +795,6 @@ void WriteMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr, const u64 data)
     mmio_handler->Write64(addr, data);
 }
 
-std::optional<PAddr> TryVirtualToPhysicalAddress(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 >= NEW_LINEAR_HEAP_VADDR && addr < NEW_LINEAR_HEAP_VADDR_END) {
-        return addr - NEW_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;
-    } else if (addr >= N3DS_EXTRA_RAM_VADDR && addr < N3DS_EXTRA_RAM_VADDR_END) {
-        return addr - N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_PADDR;
-    }
-
-    return {};
-}
-
-PAddr VirtualToPhysicalAddress(const VAddr addr) {
-    auto paddr = TryVirtualToPhysicalAddress(addr);
-    if (!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;
-    }
-    return *paddr;
-}
-
 u32 GetFCRAMOffset(u8* pointer) {
     ASSERT(pointer >= fcram.data() && pointer < fcram.data() + fcram.size());
     return pointer - fcram.data();

src/core/memory.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <cstddef>
-#include <optional>
 #include <string>
 #include <vector>
 #include "common/common_types.h"
@@ -214,20 +213,6 @@ u8* GetPointer(VAddr vaddr);
 
 std::string ReadCString(VAddr vaddr, std::size_t max_length);
 
-/**
- * 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.
- */
-std::optional<PAddr> TryVirtualToPhysicalAddress(VAddr addr);
-
-/**
- * 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.
- *
- * @deprecated Use TryVirtualToPhysicalAddress(), which reports failure.
- */
-PAddr VirtualToPhysicalAddress(VAddr addr);
-
 /**
  * Gets a pointer to the memory region beginning at the specified physical address.
  */