add HandleRasterizerDownload

Author: N3xoX1

src/nxemu-module-spec/base.h

@@ -17,7 +17,7 @@
 enum
 {
     MODULE_LOADER_SPECS_VERSION = 0x0106,
-    MODULE_VIDEO_SPECS_VERSION = 0x0106,
+    MODULE_VIDEO_SPECS_VERSION = 0x0107,
     MODULE_CPU_SPECS_VERSION = 0x0102,
     MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0106,
 };

src/nxemu-module-spec/video.h

@@ -26,6 +26,13 @@ struct VideoNvFence
     uint32_t value;
 };
 
+struct RasterizerDownloadArea 
+{
+    uint64_t startAddress;
+    uint64_t endAddress;
+    bool preemtive;
+};
+
 __interface IChannelState
 {
     bool Initialized() const = 0;
@@ -52,6 +59,7 @@ __interface IVideo
     IChannelState * AllocateChannel() = 0;
     void PushGPUEntries(int32_t bindId, const uint64_t * commandList, uint32_t commandListSize, const uint32_t * prefetchCommandlist, uint32_t prefetchCommandlistSize) = 0;
     void ApplyOpOnDeviceMemoryPointer(const uint8_t * pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void * userData) = 0;
+    RasterizerDownloadArea OnCPURead(uint64_t addr, uint64_t size) = 0;
     bool OnCPUWrite(uint64_t addr, uint64_t size) = 0;
     uint32_t HostSyncpointValue(uint32_t id) = 0;
     uint32_t HostSyncpointRegisterAction(uint32_t fence_id, uint32_t target_value, HostActionCallback operation, uint32_t slot, void * userData) = 0;

src/nxemu-os/core/memory.cpp

@@ -797,8 +797,33 @@ struct Memory::Impl {
         return true;
     }
 
+    struct RasterizerDownloadContext {
+        Impl * impl;
+        RasterizerDownloadArea * current_area;
+        size_t core;
+        size_t size;
+    };
+
+    static void HandleRasterizerDownloadCallback(uint64_t address, void * user_data)
+    {
+        RasterizerDownloadContext & context = *((RasterizerDownloadContext *)user_data);
+        const DAddr end_address = address + context.size;
+        if (context.current_area->startAddress <= address && end_address <= context.current_area->endAddress)
+            [[likely]] {
+            return;
+        }
+        *(context.current_area) = context.impl->system.GetVideo().OnCPURead(address, context.size);
+    }
+    
     void HandleRasterizerDownload(VAddr v_address, size_t size) {
-        UNIMPLEMENTED();
+        const auto* p = GetPointerImpl(
+            v_address, []() {}, []() {});
+        RasterizerDownloadContext context;
+        context.impl = this;
+        context.core = system.GetCurrentHostThreadID();
+        context.current_area = &rasterizer_read_areas[context.core];
+        context.size = size;
+        system.GetVideo().ApplyOpOnDeviceMemoryPointer(p, scratch_buffers[context.core].data(), scratch_buffers[context.core].size(), HandleRasterizerDownloadCallback, &context);
     }
 
     struct RasterizerWriteContext {
@@ -858,6 +883,7 @@ struct Memory::Impl {
 
     Core::System& system;
     Common::PageTable* current_page_table = nullptr;
+    std::array<RasterizerDownloadArea, Core::Hardware::NUM_CPU_CORES> rasterizer_read_areas{};
     std::array<GPUDirtyState, Core::Hardware::NUM_CPU_CORES> rasterizer_write_areas{};
     std::array<Common::ScratchBuffer<u32>, Core::Hardware::NUM_CPU_CORES> scratch_buffers{};
     std::span<Core::GPUDirtyMemoryManager> gpu_dirty_managers;

src/nxemu-video/video_manager.cpp

@@ -137,7 +137,7 @@ void VideoManager::MemoryMap(uint64_t address, uint64_t virtualAddress, uint64_t
     impl->m_host1x->MemoryManager().Map(address, virtualAddress, size, Core::Asid{asid}, track);
 }
 
-void VideoManager::ApplyOpOnDeviceMemoryPointer(const uint8_t* pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void* userData)
+void VideoManager::ApplyOpOnDeviceMemoryPointer(const uint8_t * pointer, uint32_t * scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void * userData)
 {
     Common::ScratchBuffer<u32> tempBuffer;
     tempBuffer.resize(scratchBufferSize);
@@ -149,6 +149,11 @@ void VideoManager::ApplyOpOnDeviceMemoryPointer(const uint8_t* pointer, uint32_t
     std::memcpy(scratchBuffer, tempBuffer.data(), tempBuffer.size() * sizeof(uint32_t));
 }
 
+RasterizerDownloadArea VideoManager::OnCPURead(uint64_t addr, uint64_t size)
+{
+    return impl->m_gpuCore->OnCPURead(addr, size);
+}
+
 bool VideoManager::OnCPUWrite(uint64_t addr, uint64_t size)
 {
     return impl->m_gpuCore->OnCPUWrite(addr, size);

src/nxemu-video/video_manager.h

@@ -28,7 +28,8 @@ class VideoManager :
     void UpdateFramebufferLayout(uint32_t width, uint32_t height) override;
     IChannelState * AllocateChannel() override;
     void PushGPUEntries(int32_t bindId, const uint64_t * commandList, uint32_t commandListSize, const uint32_t * prefetchCommandlist, uint32_t prefetchCommandlistSize);
-    void ApplyOpOnDeviceMemoryPointer(const uint8_t* pointer, uint32_t* scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void* userData) override;
+    void ApplyOpOnDeviceMemoryPointer(const uint8_t * pointer, uint32_t* scratchBuffer, size_t scratchBufferSize, DeviceMemoryOperation operation, void* userData) override;
+    RasterizerDownloadArea OnCPURead(uint64_t addr, uint64_t size) override;
     bool OnCPUWrite(uint64_t addr, uint64_t size) override;
     uint32_t HostSyncpointValue(uint32_t id) override;
     uint32_t HostSyncpointRegisterAction(uint32_t fence_id, uint32_t target_value, HostActionCallback operation, uint32_t slot, void * userData) override;

src/yuzu_video_core/buffer_cache/buffer_cache.h

@@ -148,14 +148,14 @@ bool BufferCache<P>::OnCPUWrite(DAddr device_addr, u64 size) {
 }
 
 template <class P>
-std::optional<VideoCore::RasterizerDownloadArea> BufferCache<P>::GetFlushArea(DAddr device_addr,
+std::optional<RasterizerDownloadArea> BufferCache<P>::GetFlushArea(DAddr device_addr,
                                                                               u64 size) {
-    std::optional<VideoCore::RasterizerDownloadArea> area{};
+    std::optional<RasterizerDownloadArea> area{};
     area.emplace();
     DAddr device_addr_start_aligned = Common::AlignDown(device_addr, Core::DEVICE_PAGESIZE);
     DAddr device_addr_end_aligned = Common::AlignUp(device_addr + size, Core::DEVICE_PAGESIZE);
-    area->start_address = device_addr_start_aligned;
-    area->end_address = device_addr_end_aligned;
+    area->startAddress = device_addr_start_aligned;
+    area->endAddress = device_addr_end_aligned;
     if (memory_tracker.IsRegionPreflushable(device_addr, size)) {
         area->preemtive = true;
         return area;

src/yuzu_video_core/buffer_cache/buffer_cache_base.h

@@ -207,7 +207,7 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
 
     void DownloadMemory(DAddr device_addr, u64 size);
 
-    std::optional<VideoCore::RasterizerDownloadArea> GetFlushArea(DAddr device_addr, u64 size);
+    std::optional<RasterizerDownloadArea> GetFlushArea(DAddr device_addr, u64 size);
 
     bool InlineMemory(DAddr dest_address, size_t copy_size, std::span<const u8> inlined_buffer);
 

src/yuzu_video_core/gpu.cpp

@@ -274,15 +274,15 @@ struct GPU::Impl :
         gpu_thread.FlushRegion(addr, size);
     }
 
-    VideoCore::RasterizerDownloadArea OnCPURead(DAddr addr, u64 size) {
+    RasterizerDownloadArea OnCPURead(DAddr addr, u64 size) {
         auto raster_area = rasterizer->GetFlushArea(addr, size);
         if (raster_area.preemtive) {
             return raster_area;
         }
         raster_area.preemtive = true;
         const u64 fence = RequestSyncOperation([this, &raster_area]() {
-            rasterizer->FlushRegion(raster_area.start_address,
-                                    raster_area.end_address - raster_area.start_address);
+            rasterizer->FlushRegion(raster_area.startAddress,
+                                    raster_area.endAddress - raster_area.startAddress);
         });
         gpu_thread.TickGPU();
         WaitForSyncOperation(fence);
@@ -564,7 +564,7 @@ void GPU::ClearCdmaInstance(u32 id) {
     impl->ClearCdmaInstance(id);
 }
 
-VideoCore::RasterizerDownloadArea GPU::OnCPURead(PAddr addr, u64 size) {
+RasterizerDownloadArea GPU::OnCPURead(PAddr addr, u64 size) {
     return impl->OnCPURead(addr, size);
 }
 

src/yuzu_video_core/gpu.h

@@ -10,8 +10,8 @@
 #include "yuzu_common/nvdata.h"
 #include "yuzu_video_core/cdma_pusher.h"
 #include "yuzu_video_core/framebuffer_config.h"
-#include "yuzu_video_core/rasterizer_download_area.h"
 #include <nxemu-module-spec/operating_system.h>
+#include <nxemu-module-spec/video.h>
 
 namespace Core {
 class System;
@@ -245,7 +245,7 @@ class GPU final {
     void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
 
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
-    [[nodiscard]] VideoCore::RasterizerDownloadArea OnCPURead(DAddr addr, u64 size);
+    [[nodiscard]] RasterizerDownloadArea OnCPURead(DAddr addr, u64 size);
 
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     void FlushRegion(DAddr addr, u64 size);