[video_core] buffer cache readback for nce invalidations

src/core/memory.cpp

@@ -757,7 +757,7 @@ struct Memory::Impl {
         };
         auto& gpu = system.GPU();
         gpu_device_memory->ApplyOpOnPointer(
-            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size); });
+            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size, true); });
     }
 
     Core::System& system;

src/input_common/drivers/joycon.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -83,21 +83,20 @@ void Joycons::ScanThread(std::stop_token stop_token) {
     constexpr u16 nintendo_vendor_id = 0x057e;
     Common::SetCurrentThreadName("JoyconScanThread");
 
-    auto last_ret = 0u;
     do {
-        auto ret = SDL_hid_device_change_count();
+        SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
-        if (last_ret == 0u || last_ret != ret) {
+        SDL_hid_device_info* cur_dev = devs;
-            last_ret = ret;
+
-            SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
+        while (cur_dev) {
-            for (auto* cur_dev = devs; cur_dev; cur_dev = cur_dev->next) {
+            if (IsDeviceNew(cur_dev)) {
-                if (IsDeviceNew(cur_dev)) {
+                LOG_DEBUG(Input, "Device Found,type : {:04X} {:04X}", cur_dev->vendor_id,
-                    LOG_DEBUG(Input, "Device Found,type : {:04X} {:04X}", cur_dev->vendor_id, cur_dev->product_id);
+                          cur_dev->product_id);
-                    RegisterNewDevice(cur_dev);
+                RegisterNewDevice(cur_dev);
-                }
-                cur_dev = cur_dev->next;
             }
-            SDL_hid_free_enumeration(devs);
+            cur_dev = cur_dev->next;
         }
+
+        SDL_hid_free_enumeration(devs);
     } while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
 }
 

src/video_core/gpu.cpp

@@ -226,7 +226,17 @@ struct GPU::Impl {
     }
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size) {
+    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
+        VideoCore::RasterizerInterface* rasterizer = renderer->ReadRasterizer();
+        if (preserve_gpu_writes && rasterizer->MustFlushRegion(addr, size, VideoCommon::CacheType::BufferCache)) {
+            const u64 fence = RequestSyncOperation([rasterizer, addr, size] {
+                rasterizer->FlushRegion(addr, size, VideoCommon::CacheType::BufferCache);
+                rasterizer->OnCacheInvalidation(addr, size);
+            });
+            gpu_thread.TickGPU(is_async);
+            WaitForSyncOperation(fence);
+            return;
+        }
         gpu_thread.InvalidateRegion(addr, size);
     }
 
@@ -518,8 +528,8 @@ void GPU::FlushRegion(DAddr addr, u64 size) {
     impl->FlushRegion(addr, size);
 }
 
-void GPU::InvalidateRegion(DAddr addr, u64 size) {
+void GPU::InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
-    impl->InvalidateRegion(addr, size);
+    impl->InvalidateRegion(addr, size, preserve_gpu_writes);
 }
 
 bool GPU::OnCPUWrite(DAddr addr, u64 size) {

src/video_core/gpu.h

@@ -248,7 +248,7 @@ public:
     void FlushRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size);
+    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes = false);
 
     /// Notify rasterizer that CPU is trying to write this area. It returns true if the area is
     /// sensible, false otherwise, addr and size must be a valid combination