Get the OS calls to be able to push the display list to the video module

Author: N3xoX1

src/nxemu-module-spec/base.h

@@ -17,9 +17,9 @@
 enum
 {
     MODULE_LOADER_SPECS_VERSION = 0x0106,
-    MODULE_VIDEO_SPECS_VERSION = 0x0102,
+    MODULE_VIDEO_SPECS_VERSION = 0x0103,
     MODULE_CPU_SPECS_VERSION = 0x0102,
-    MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0104,
+    MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0105,
 };
 
 enum MODULE_TYPE : uint16_t

src/nxemu-module-spec/operating_system.h

@@ -63,6 +63,11 @@ __interface IDeviceMemory
     const uint8_t * BackingBasePointer() const = 0;
 };
 
+__interface ICacheInvalidator 
+{
+    virtual void OnCacheInvalidation(uint64_t address, uint32_t size) = 0;
+};
+
 __interface IOperatingSystem
 {
     bool Initialize(void) = 0;
@@ -72,6 +77,7 @@ __interface IOperatingSystem
     IDeviceMemory & DeviceMemory(void) = 0;
     void KeyboardKeyPress(int modifier, int keyIndex, int keyCode) = 0;
     void KeyboardKeyRelease(int modifier, int keyIndex, int keyCode) = 0;
+    void GatherGPUDirtyMemory(ICacheInvalidator * invalidator) = 0;
 };
 
 EXPORT IOperatingSystem * CALL CreateOperatingSystem(ISwitchSystem & system);

src/nxemu-module-spec/video.h

@@ -26,15 +26,28 @@ struct VideoNvFence
     uint32_t value;
 };
 
+__interface IChannelState
+{
+    bool Initialized() const = 0;
+    int32_t BindId() const = 0;
+    void Init(uint64_t programId) = 0;
+    void SetMemoryManager(uint32_t id) = 0;
+    void Release() = 0;
+};
+
 __interface IVideo
 {
     bool Initialize(void) = 0;
+    uint32_t AllocAsEx(uint64_t addressSpaceBits, uint64_t splitAddress, uint64_t bigPageBits, uint64_t pageBits) = 0;
+    uint64_t MapBufferEx(uint64_t gpuAddr, uint64_t deviceAddr, uint64_t size, uint8_t kind, bool isBigPages) = 0;
     uint64_t MemoryAllocate(uint64_t size) = 0;
     void MemoryTrackContinuity(uint64_t address, uint64_t virtualAddress, uint64_t size, uint64_t asid) = 0;
     void MemoryMap(uint64_t address, uint64_t virtualAddress, uint64_t size, uint64_t asid, bool track) = 0;
     void RequestComposite(VideoFramebufferConfig * layers, uint32_t layerCount, VideoNvFence * fences, uint32_t fenceCount) = 0;
     uint64_t RegisterProcess(IMemory * memory) = 0;
     void UpdateFramebufferLayout(uint32_t width, uint32_t height) = 0;
+    IChannelState * AllocateChannel() = 0;
+    void PushGPUEntries(int32_t bindId, const uint64_t * commandList, uint32_t commandListSize, const uint32_t * prefetchCommandlist, uint32_t prefetchCommandlistSize) = 0;
 };
 
 EXPORT IVideo * CALL CreateVideo(IRenderWindow & RenderWindow, ISwitchSystem & System);

src/nxemu-os/core/core.cpp

@@ -259,6 +259,12 @@ std::span<GPUDirtyMemoryManager> System::GetGPUDirtyMemoryManager() {
     return impl->gpu_dirty_memory_managers;
 }
 
+void System::GatherGPUDirtyMemory(ICacheInvalidator * invalidator) {
+    for (auto& manager : impl->gpu_dirty_memory_managers) {
+        manager.Gather(invalidator);
+    }
+}
+
 ISwitchSystem & System::GetSwitchSystem()
 {
     return impl->switchSystem;

src/nxemu-os/core/core.h

@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include <nxemu-module-spec/operating_system.h>
 #include "yuzu_common/common_types.h"
 
 enum class StorageId : uint8_t;
@@ -219,18 +220,12 @@ class System {
      */
     [[nodiscard]] bool IsPoweredOn() const;
 
-    /// Gets a reference to the telemetry session for this emulation session.
-    [[nodiscard]] Core::TelemetrySession& TelemetrySession();
-
-    /// Gets a reference to the telemetry session for this emulation session.
-    [[nodiscard]] const Core::TelemetrySession& TelemetrySession() const;
-
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule(u32 core_index);
 
     std::span<GPUDirtyMemoryManager> GetGPUDirtyMemoryManager();
 
-    void GatherGPUDirtyMemory(std::function<void(PAddr, size_t)>& callback);
+    void GatherGPUDirtyMemory(ICacheInvalidator * invalidator);
 
     ISwitchSystem & GetSwitchSystem();
     IVideo & GetVideo();

src/nxemu-os/core/file_sys/filesystem_interfaces.cpp

@@ -1,88 +1,6 @@
 #include "filesystem_interfaces.h"
 #include <nxemu-module-spec/system_loader.h>
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>::InterfacePtr() : 
-    m_ptr(nullptr) 
-{
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>::InterfacePtr(InterfaceType* ptr) : 
-    m_ptr(ptr) 
-{
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>::InterfacePtr(InterfacePtr&& other) noexcept
-    : m_ptr(other.m_ptr) 
-{
-    other.m_ptr = nullptr;
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>::~InterfacePtr() 
-{
-    if (m_ptr) 
-    {
-        m_ptr->Release();
-        m_ptr = nullptr;
-    }
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType> & InterfacePtr<InterfaceType>::operator=(InterfaceType * ptr)
-{
-    if (m_ptr != ptr && m_ptr != nullptr)
-    {
-        m_ptr->Release();
-    }
-    m_ptr = ptr;
-    return *this;
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>& InterfacePtr<InterfaceType>::operator=(InterfacePtr&& other) noexcept 
-{
-    if (this != &other) 
-    {
-        if (m_ptr) {
-            m_ptr->Release();
-        }
-        m_ptr = other.m_ptr;
-        other.m_ptr = nullptr;
-    }
-    return *this;
-}
-
-template<typename InterfaceType>
-InterfaceType** InterfacePtr<InterfaceType>::GetAddressForSet() 
-{
-    if (m_ptr) 
-    {
-        m_ptr->Release();
-        m_ptr = nullptr;
-    }
-    return &m_ptr;
-}
-
-template<typename InterfaceType>
-InterfaceType* InterfacePtr<InterfaceType>::operator->() const 
-{
-    return m_ptr;
-}
-
-template<typename InterfaceType>
-InterfaceType& InterfacePtr<InterfaceType>::operator*() const 
-{
-    return *m_ptr;
-}
-
-template<typename InterfaceType>
-InterfacePtr<InterfaceType>::operator bool() const 
-{
-    return m_ptr != nullptr;
-}
+#include <yuzu_common/interface_pointer_def.h>
 
 std::vector<uint8_t> IVirtualFilePtr::ReadAllBytes() const
 {

src/nxemu-os/core/file_sys/filesystem_interfaces.h

@@ -1,29 +1,6 @@
 #pragma once
 #include <vector>
-
-template<typename InterfaceType>
-class InterfacePtr
-{
-public:
-    InterfacePtr();
-    InterfacePtr(InterfaceType *);
-    InterfacePtr(InterfacePtr && other) noexcept;
-    ~InterfacePtr();
-
-    InterfacePtr & operator=(InterfaceType * ptr);
-    InterfacePtr & operator=(InterfacePtr && other) noexcept;
-    InterfaceType ** GetAddressForSet();
-
-    InterfaceType * operator->() const;
-    InterfaceType & operator*() const;
-    operator bool() const;
-
-protected:
-    InterfacePtr(const InterfacePtr &) = delete;
-    InterfacePtr & operator=(const InterfacePtr &) = delete;
-
-    InterfaceType * m_ptr;
-};
+#include "yuzu_common/interface_pointer.h"
 
 __interface IVirtualDirectory;
 __interface IVirtualFile;

src/nxemu-os/core/gpu_dirty_memory_manager.h

@@ -45,7 +45,7 @@ class GPUDirtyMemoryManager {
                                                 std::memory_order_relaxed));
     }
 
-    void Gather(std::function<void(PAddr, size_t)>& callback) {
+    void Gather(ICacheInvalidator * invalidator) {
         {
             std::scoped_lock lk(guard);
             TransformAddress t = current.exchange(default_transform, std::memory_order_relaxed);
@@ -63,7 +63,7 @@ class GPUDirtyMemoryManager {
                 mask = mask >> empty_bits;
 
                 const size_t continuous_bits = std::countr_one(mask);
-                callback((static_cast<PAddr>(transform.address) << page_bits) + offset,
+                invalidator->OnCacheInvalidation((static_cast<PAddr>(transform.address) << page_bits) + offset,
                          continuous_bits << align_bits);
                 mask = continuous_bits < align_size ? (mask >> continuous_bits) : 0;
                 offset += continuous_bits << align_bits;

src/nxemu-os/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -87,7 +87,7 @@ void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers
         }
     }
 
-    system.GetVideo().RequestComposite(output_layers.data(), output_layers.size(), output_fences.data(), output_fences.size());
+    system.GetVideo().RequestComposite(output_layers.data(), (uint32_t)output_layers.size(), output_fences.data(), (uint32_t)output_fences.size());
     system.SpeedLimiter().DoSpeedLimiting(system.CoreTiming().GetGlobalTimeUs());
     system.GetPerfStats().EndSystemFrame();
     system.GetPerfStats().BeginSystemFrame();