Merge pull request #4431 from wwylele/no-v2p
Memory: remove VirtualToPhysicalAddress
This commit is contained in:
commit
7f727177bf
|
@ -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.
|
||||
CP15[CP15_PHYS_ADDRESS] = Memory::VirtualToPhysicalAddress(value);
|
||||
LOG_ERROR(Core_ARM11, "Unimplemented virtual to physical address");
|
||||
} else if (crm == 5) {
|
||||
if (opcode_2 == 0)
|
||||
CP15[CP15_INVALIDATE_INSTR_CACHE] = value;
|
||||
|
|
|
@ -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_right = Memory::VirtualToPhysicalAddress(info.address_right);
|
||||
PAddr phys_address_left = VirtualToPhysicalAddress(info.address_left);
|
||||
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),
|
||||
|
|
|
@ -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);
|
||||
|
||||
auto maybe_paddr = TryVirtualToPhysicalAddress(overlap_start);
|
||||
ASSERT(maybe_paddr);
|
||||
PAddr physical_start = *maybe_paddr;
|
||||
PAddr physical_start = paddr_region_start + (overlap_start - region_start);
|
||||
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(NEW_LINEAR_HEAP_VADDR, NEW_LINEAR_HEAP_VADDR_END);
|
||||
CheckRegion(VRAM_VADDR, VRAM_VADDR_END);
|
||||
CheckRegion(LINEAR_HEAP_VADDR, LINEAR_HEAP_VADDR_END, FCRAM_PADDR);
|
||||
CheckRegion(NEW_LINEAR_HEAP_VADDR, NEW_LINEAR_HEAP_VADDR_END, FCRAM_PADDR);
|
||||
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();
|
||||
|
|
|
@ -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.
|
||||
*/
|
||||
|
|
Reference in New Issue