Android #43

src/core/hle/kernel/k_hardware_timer.h

@@ -19,7 +19,13 @@ public:
     void Initialize();
     void Finalize();
 
-    s64 GetTick() const;
+    s64 GetCount() const {
+        return GetTick();
+    }
+
+    void RegisterTask(KTimerTask* task, s64 time_from_now) {
+        this->RegisterAbsoluteTask(task, GetTick() + time_from_now);
+    }
 
     void RegisterAbsoluteTask(KTimerTask* task, s64 task_time) {
         KScopedDisableDispatch dd{m_kernel};
@@ -36,6 +42,7 @@ private:
     void EnableInterrupt(s64 wakeup_time);
     void DisableInterrupt();
     bool GetInterruptEnabled();
+    s64 GetTick() const;
     void DoTask();
 
 private:

src/core/hle/kernel/k_resource_limit.cpp

@@ -5,7 +5,6 @@
 #include "common/overflow.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -16,7 +15,9 @@ KResourceLimit::KResourceLimit(KernelCore& kernel)
     : KAutoObjectWithSlabHeapAndContainer{kernel}, m_lock{m_kernel}, m_cond_var{m_kernel} {}
 KResourceLimit::~KResourceLimit() = default;
 
-void KResourceLimit::Initialize() {}
+void KResourceLimit::Initialize(const Core::Timing::CoreTiming* core_timing) {
+    m_core_timing = core_timing;
+}
 
 void KResourceLimit::Finalize() {}
 
@@ -85,7 +86,7 @@ Result KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
 }
 
 bool KResourceLimit::Reserve(LimitableResource which, s64 value) {
-    return Reserve(which, value, m_kernel.HardwareTimer().GetTick() + DefaultTimeout);
+    return Reserve(which, value, m_core_timing->GetGlobalTimeNs().count() + DefaultTimeout);
 }
 
 bool KResourceLimit::Reserve(LimitableResource which, s64 value, s64 timeout) {
@@ -116,7 +117,7 @@ bool KResourceLimit::Reserve(LimitableResource which, s64 value, s64 timeout) {
         }
 
         if (m_current_hints[index] + value <= m_limit_values[index] &&
-            (timeout < 0 || m_kernel.HardwareTimer().GetTick() < timeout)) {
+            (timeout < 0 || m_core_timing->GetGlobalTimeNs().count() < timeout)) {
             m_waiter_count++;
             m_cond_var.Wait(std::addressof(m_lock), timeout, false);
             m_waiter_count--;
@@ -153,7 +154,7 @@ void KResourceLimit::Release(LimitableResource which, s64 value, s64 hint) {
 
 KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size) {
     auto* resource_limit = KResourceLimit::Create(system.Kernel());
-    resource_limit->Initialize();
+    resource_limit->Initialize(std::addressof(system.CoreTiming()));
 
     // Initialize default resource limit values.
     // TODO(bunnei): These values are the system defaults, the limits for service processes are

src/core/hle/kernel/k_resource_limit.h

@@ -31,7 +31,7 @@ public:
     explicit KResourceLimit(KernelCore& kernel);
     ~KResourceLimit() override;
 
-    void Initialize();
+    void Initialize(const Core::Timing::CoreTiming* core_timing);
     void Finalize() override;
 
     s64 GetLimitValue(LimitableResource which) const;
@@ -57,6 +57,7 @@ private:
     mutable KLightLock m_lock;
     s32 m_waiter_count{};
     KLightConditionVariable m_cond_var;
+    const Core::Timing::CoreTiming* m_core_timing{};
 };
 
 KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size);

src/core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h

@@ -28,7 +28,7 @@ public:
     ~KScopedSchedulerLockAndSleep() {
         // Register the sleep.
         if (m_timeout_tick > 0) {
-            m_timer->RegisterAbsoluteTask(m_thread, m_timeout_tick);
+            m_timer->RegisterTask(m_thread, m_timeout_tick);
         }
 
         // Unlock the scheduler.

src/core/hle/kernel/kernel.cpp

@@ -231,7 +231,7 @@ struct KernelCore::Impl {
     void InitializeSystemResourceLimit(KernelCore& kernel,
                                        const Core::Timing::CoreTiming& core_timing) {
         system_resource_limit = KResourceLimit::Create(system.Kernel());
-        system_resource_limit->Initialize();
+        system_resource_limit->Initialize(&core_timing);
         KResourceLimit::Register(kernel, system_resource_limit);
 
         const auto sizes{memory_layout->GetTotalAndKernelMemorySizes()};

src/core/hle/kernel/svc/svc_address_arbiter.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/core.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
@@ -53,7 +52,7 @@ Result WaitForAddress(Core::System& system, u64 address, ArbitrationType arb_typ
     if (timeout_ns > 0) {
         const s64 offset_tick(timeout_ns);
         if (offset_tick > 0) {
-            timeout = system.Kernel().HardwareTimer().GetTick() + offset_tick + 2;
+            timeout = offset_tick + 2;
             if (timeout <= 0) {
                 timeout = std::numeric_limits<s64>::max();
             }

src/core/hle/kernel/svc/svc_condition_variable.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/core.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
@@ -26,7 +25,7 @@ Result WaitProcessWideKeyAtomic(Core::System& system, u64 address, u64 cv_key, u
     if (timeout_ns > 0) {
         const s64 offset_tick(timeout_ns);
         if (offset_tick > 0) {
-            timeout = system.Kernel().HardwareTimer().GetTick() + offset_tick + 2;
+            timeout = offset_tick + 2;
             if (timeout <= 0) {
                 timeout = std::numeric_limits<s64>::max();
             }

src/core/hle/kernel/svc/svc_ipc.cpp

@@ -5,7 +5,6 @@
 #include "common/scratch_buffer.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_client_session.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/svc.h"
@@ -83,29 +82,12 @@ Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_ad
         R_TRY(session->SendReply());
     }
 
-    // Convert the timeout from nanoseconds to ticks.
-    // NOTE: Nintendo does not use this conversion logic in WaitSynchronization...
-    s64 timeout;
-    if (timeout_ns > 0) {
-        const s64 offset_tick(timeout_ns);
-        if (offset_tick > 0) {
-            timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2;
-            if (timeout <= 0) {
-                timeout = std::numeric_limits<s64>::max();
-            }
-        } else {
-            timeout = std::numeric_limits<s64>::max();
-        }
-    } else {
-        timeout = timeout_ns;
-    }
-
     // Wait for a message.
     while (true) {
         // Wait for an object.
         s32 index;
         Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs.data(),
-                                                     num_handles, timeout);
+                                                     num_handles, timeout_ns);
         if (result == ResultTimedOut) {
             R_RETURN(result);
         }

src/core/hle/kernel/svc/svc_resource_limit.cpp

@@ -21,7 +21,7 @@ Result CreateResourceLimit(Core::System& system, Handle* out_handle) {
     SCOPE_EXIT({ resource_limit->Close(); });
 
     // Initialize the resource limit.
-    resource_limit->Initialize();
+    resource_limit->Initialize(std::addressof(system.CoreTiming()));
 
     // Register the limit.
     KResourceLimit::Register(kernel, resource_limit);

src/core/hle/kernel/svc/svc_synchronization.cpp

@@ -4,7 +4,6 @@
 #include "common/scope_exit.h"
 #include "common/scratch_buffer.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/svc.h"
@@ -84,20 +83,9 @@ Result WaitSynchronization(Core::System& system, int32_t* out_index, u64 user_ha
         }
     });
 
-    // Convert the timeout from nanoseconds to ticks.
-    s64 timeout;
-    if (timeout_ns > 0) {
-        u64 ticks = kernel.HardwareTimer().GetTick();
-        ticks += timeout_ns;
-        ticks += 2;
-
-        timeout = ticks;
-    } else {
-        timeout = timeout_ns;
-    }
-
     // Wait on the objects.
-    Result res = KSynchronizationObject::Wait(kernel, out_index, objs.data(), num_handles, timeout);
+    Result res =
+        KSynchronizationObject::Wait(kernel, out_index, objs.data(), num_handles, timeout_ns);
 
     R_SUCCEED_IF(res == ResultSessionClosed);
     R_RETURN(res);

src/core/hle/kernel/svc/svc_thread.cpp

@@ -4,7 +4,6 @@
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_thread.h"
@@ -43,9 +42,9 @@ Result CreateThread(Core::System& system, Handle* out_handle, u64 entry_point, u
     R_UNLESS(process.CheckThreadPriority(priority), ResultInvalidPriority);
 
     // Reserve a new thread from the process resource limit (waiting up to 100ms).
-    KScopedResourceReservation thread_reservation(std::addressof(process),
-                                                  LimitableResource::ThreadCountMax, 1,
-                                                  kernel.HardwareTimer().GetTick() + 100000000);
+    KScopedResourceReservation thread_reservation(
+        std::addressof(process), LimitableResource::ThreadCountMax, 1,
+        system.CoreTiming().GetGlobalTimeNs().count() + 100000000);
     R_UNLESS(thread_reservation.Succeeded(), ResultLimitReached);
 
     // Create the thread.
@@ -103,31 +102,20 @@ void ExitThread(Core::System& system) {
 }
 
 /// Sleep the current thread
-void SleepThread(Core::System& system, s64 ns) {
+void SleepThread(Core::System& system, s64 nanoseconds) {
     auto& kernel = system.Kernel();
-    const auto yield_type = static_cast<Svc::YieldType>(ns);
+    const auto yield_type = static_cast<Svc::YieldType>(nanoseconds);
 
-    LOG_TRACE(Kernel_SVC, "called nanoseconds={}", ns);
+    LOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
 
     // When the input tick is positive, sleep.
-    if (ns > 0) {
+    if (nanoseconds > 0) {
         // Convert the timeout from nanoseconds to ticks.
         // NOTE: Nintendo does not use this conversion logic in WaitSynchronization...
-        s64 timeout;
-
-        const s64 offset_tick(ns);
-        if (offset_tick > 0) {
-            timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2;
-            if (timeout <= 0) {
-                timeout = std::numeric_limits<s64>::max();
-            }
-        } else {
-            timeout = std::numeric_limits<s64>::max();
-        }
 
         // Sleep.
         // NOTE: Nintendo does not check the result of this sleep.
-        static_cast<void>(GetCurrentThread(kernel).Sleep(timeout));
+        static_cast<void>(GetCurrentThread(kernel).Sleep(nanoseconds));
     } else if (yield_type == Svc::YieldType::WithoutCoreMigration) {
         KScheduler::YieldWithoutCoreMigration(kernel);
     } else if (yield_type == Svc::YieldType::WithCoreMigration) {
@@ -136,6 +124,7 @@ void SleepThread(Core::System& system, s64 ns) {
         KScheduler::YieldToAnyThread(kernel);
     } else {
         // Nintendo does nothing at all if an otherwise invalid value is passed.
+        ASSERT_MSG(false, "Unimplemented sleep yield type '{:016X}'!", nanoseconds);
     }
 }
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1335,8 +1335,7 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     }
     const u32 buffer_size = static_cast<u32>(buffer_operand.pitch * buffer_operand.height);
     static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
-    const auto post_op = IS_IMAGE_UPLOAD ? VideoCommon::ObtainBufferOperation::DoNothing
-                                         : VideoCommon::ObtainBufferOperation::MarkAsWritten;
+    const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
     const auto [buffer, offset] =
         buffer_cache.ObtainBuffer(buffer_operand.address, buffer_size, sync_info, post_op);
 
@@ -1345,12 +1344,8 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     const std::span copy_span{&copy, 1};
 
     if constexpr (IS_IMAGE_UPLOAD) {
-        texture_cache.PrepareImage(image_id, true, false);
         image->UploadMemory(buffer->Handle(), offset, copy_span);
     } else {
-        if (offset % BytesPerBlock(image->info.format)) {
-            return false;
-        }
         texture_cache.DownloadImageIntoBuffer(image, buffer->Handle(), offset, copy_span,
                                               buffer_operand.address, buffer_size);
     }

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -126,7 +126,7 @@ struct FormatTuple {
     {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},              // A1R5G5B5_UNORM
     {VK_FORMAT_A2B10G10R10_UNORM_PACK32, Attachable | Storage}, // A2B10G10R10_UNORM
     {VK_FORMAT_A2B10G10R10_UINT_PACK32, Attachable | Storage},  // A2B10G10R10_UINT
-    {VK_FORMAT_A2R10G10B10_UNORM_PACK32, Attachable},           // A2R10G10B10_UNORM
+    {VK_FORMAT_A2R10G10B10_UNORM_PACK32, Attachable | Storage}, // A2R10G10B10_UNORM
     {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},         // A1B5G5R5_UNORM (flipped with swizzle)
     {VK_FORMAT_R5G5B5A1_UNORM_PACK16},                     // A5B5G5R1_UNORM (specially swizzled)
     {VK_FORMAT_R8_UNORM, Attachable | Storage},            // R8_UNORM

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -830,8 +830,7 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     }
     const u32 buffer_size = static_cast<u32>(buffer_operand.pitch * buffer_operand.height);
     static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
-    const auto post_op = IS_IMAGE_UPLOAD ? VideoCommon::ObtainBufferOperation::DoNothing
-                                         : VideoCommon::ObtainBufferOperation::MarkAsWritten;
+    const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
     const auto [buffer, offset] =
         buffer_cache.ObtainBuffer(buffer_operand.address, buffer_size, sync_info, post_op);
 
@@ -840,12 +839,8 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     const std::span copy_span{&copy, 1};
 
     if constexpr (IS_IMAGE_UPLOAD) {
-        texture_cache.PrepareImage(image_id, true, false);
         image->UploadMemory(buffer->Handle(), offset, copy_span);
     } else {
-        if (offset % BytesPerBlock(image->info.format)) {
-            return false;
-        }
         texture_cache.DownloadImageIntoBuffer(image, buffer->Handle(), offset, copy_span,
                                               buffer_operand.address, buffer_size);
     }

src/video_core/texture_cache/texture_cache_base.h

@@ -243,9 +243,6 @@ public:
     /// Create channel state.
     void CreateChannel(Tegra::Control::ChannelState& channel) final override;
 
-    /// Prepare an image to be used
-    void PrepareImage(ImageId image_id, bool is_modification, bool invalidate);
-
     std::recursive_mutex mutex;
 
 private:
@@ -390,6 +387,9 @@ private:
     /// Synchronize image aliases, copying data if needed
     void SynchronizeAliases(ImageId image_id);
 
+    /// Prepare an image to be used
+    void PrepareImage(ImageId image_id, bool is_modification, bool invalidate);
+
     /// Prepare an image view to be used
     void PrepareImageView(ImageViewId image_view_id, bool is_modification, bool invalidate);
 

src/video_core/vulkan_common/vulkan_device.cpp

@@ -71,11 +71,6 @@ constexpr std::array R8G8B8_SSCALED{
     VK_FORMAT_UNDEFINED,
 };
 
-constexpr std::array VK_FORMAT_R32G32B32_SFLOAT{
-    VK_FORMAT_R32G32B32A32_SFLOAT,
-    VK_FORMAT_UNDEFINED,
-};
-
 } // namespace Alternatives
 
 enum class NvidiaArchitecture {
@@ -108,8 +103,6 @@ constexpr const VkFormat* GetFormatAlternatives(VkFormat format) {
         return Alternatives::R16G16B16_SSCALED.data();
     case VK_FORMAT_R8G8B8_SSCALED:
         return Alternatives::R8G8B8_SSCALED.data();
-    case VK_FORMAT_R32G32B32_SFLOAT:
-        return Alternatives::VK_FORMAT_R32G32B32_SFLOAT.data();
     default:
         return nullptr;
     }
@@ -137,7 +130,6 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
         VK_FORMAT_A2B10G10R10_UINT_PACK32,
         VK_FORMAT_A2B10G10R10_UNORM_PACK32,
         VK_FORMAT_A2B10G10R10_USCALED_PACK32,
-        VK_FORMAT_A2R10G10B10_UNORM_PACK32,
         VK_FORMAT_A8B8G8R8_SINT_PACK32,
         VK_FORMAT_A8B8G8R8_SNORM_PACK32,
         VK_FORMAT_A8B8G8R8_SRGB_PACK32,