diff options
Diffstat (limited to 'src')
43 files changed, 940 insertions, 1028 deletions
diff --git a/src/android/app/build.gradle.kts b/src/android/app/build.gradle.kts index 188ef9469..cb026211c 100644 --- a/src/android/app/build.gradle.kts +++ b/src/android/app/build.gradle.kts @@ -3,8 +3,8 @@ import android.annotation.SuppressLint import kotlin.collections.setOf -import org.jetbrains.kotlin.konan.properties.Properties import org.jlleitschuh.gradle.ktlint.reporter.ReporterType +import com.github.triplet.gradle.androidpublisher.ReleaseStatus plugins { id("com.android.application") @@ -13,6 +13,7 @@ plugins { kotlin("plugin.serialization") version "1.9.20" id("androidx.navigation.safeargs.kotlin") id("org.jlleitschuh.gradle.ktlint") version "11.4.0" + id("com.github.triplet.play") version "3.8.6" } /** @@ -58,15 +59,7 @@ android { targetSdk = 34 versionName = getGitVersion() - // If you want to use autoVersion for the versionCode, create a property in local.properties - // named "autoVersioned" and set it to "true" - val properties = Properties() - val versionProperty = try { - properties.load(project.rootProject.file("local.properties").inputStream()) - properties.getProperty("autoVersioned") ?: "" - } catch (e: Exception) { "" } - - versionCode = if (versionProperty == "true") { + versionCode = if (System.getenv("AUTO_VERSIONED") == "true") { autoVersion } else { 1 @@ -221,6 +214,15 @@ ktlint { } } +play { + val keyPath = System.getenv("SERVICE_ACCOUNT_KEY_PATH") + if (keyPath != null) { + serviceAccountCredentials.set(File(keyPath)) + } + track.set(System.getenv("STORE_TRACK") ?: "internal") + releaseStatus.set(ReleaseStatus.COMPLETED) +} + dependencies { implementation("androidx.core:core-ktx:1.12.0") implementation("androidx.appcompat:appcompat:1.6.1") @@ -257,12 +259,18 @@ fun runGitCommand(command: List<String>): String { } fun getGitVersion(): String { + val gitVersion = runGitCommand( + listOf( + "git", + "describe", + "--always", + "--long" + ) + ).replace(Regex("(-0)?-[^-]+$"), "") val versionName = if (System.getenv("GITHUB_ACTIONS") != null) { - val gitTag = System.getenv("GIT_TAG_NAME") ?: "" - gitTag + System.getenv("GIT_TAG_NAME") ?: gitVersion } else { - runGitCommand(listOf("git", "describe", "--always", "--long")) - .replace(Regex("(-0)?-[^-]+$"), "") + gitVersion } return versionName.ifEmpty { "0.0" } } diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index 85926fc8f..c19af2ab8 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -107,6 +107,8 @@ add_library(common STATIC quaternion.h range_map.h range_mutex.h + range_sets.h + range_sets.inc reader_writer_queue.h ring_buffer.h ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp @@ -121,6 +123,7 @@ add_library(common STATIC settings_input.cpp settings_input.h settings_setting.h + slot_vector.h socket_types.h spin_lock.cpp spin_lock.h diff --git a/src/common/range_sets.h b/src/common/range_sets.h new file mode 100644 index 000000000..f8fcee483 --- /dev/null +++ b/src/common/range_sets.h @@ -0,0 +1,73 @@ +// SPDX-FileCopyrightText: 2024 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include <memory> + +#include "common/common_types.h" + +namespace Common { + +template <typename AddressType> +class RangeSet { +public: + RangeSet(); + ~RangeSet(); + + RangeSet(RangeSet const&) = delete; + RangeSet& operator=(RangeSet const&) = delete; + + RangeSet(RangeSet&& other); + RangeSet& operator=(RangeSet&& other); + + void Add(AddressType base_address, size_t size); + void Subtract(AddressType base_address, size_t size); + void Clear(); + bool Empty() const; + + template <typename Func> + void ForEach(Func&& func) const; + + template <typename Func> + void ForEachInRange(AddressType device_addr, size_t size, Func&& func) const; + +private: + struct RangeSetImpl; + std::unique_ptr<RangeSetImpl> m_impl; +}; + +template <typename AddressType> +class OverlapRangeSet { +public: + OverlapRangeSet(); + ~OverlapRangeSet(); + + OverlapRangeSet(OverlapRangeSet const&) = delete; + OverlapRangeSet& operator=(OverlapRangeSet const&) = delete; + + OverlapRangeSet(OverlapRangeSet&& other); + OverlapRangeSet& operator=(OverlapRangeSet&& other); + + void Add(AddressType base_address, size_t size); + void Subtract(AddressType base_address, size_t size); + + template <typename Func> + void Subtract(AddressType base_address, size_t size, Func&& on_delete); + + void DeleteAll(AddressType base_address, size_t size); + void Clear(); + bool Empty() const; + + template <typename Func> + void ForEach(Func&& func) const; + + template <typename Func> + void ForEachInRange(AddressType device_addr, size_t size, Func&& func) const; + +private: + struct OverlapRangeSetImpl; + std::unique_ptr<OverlapRangeSetImpl> m_impl; +}; + +} // namespace Common diff --git a/src/common/range_sets.inc b/src/common/range_sets.inc new file mode 100644 index 000000000..b83eceb7b --- /dev/null +++ b/src/common/range_sets.inc @@ -0,0 +1,304 @@ +// SPDX-FileCopyrightText: 2024 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include <limits> +#include <utility> + +#include <boost/icl/interval.hpp> +#include <boost/icl/interval_base_set.hpp> +#include <boost/icl/interval_map.hpp> +#include <boost/icl/interval_set.hpp> +#include <boost/icl/split_interval_map.hpp> +#include <boost/pool/pool.hpp> +#include <boost/pool/pool_alloc.hpp> +#include <boost/pool/poolfwd.hpp> + +#include "common/range_sets.h" + +namespace Common { + +namespace { +template <class T> +using RangeSetsAllocator = + boost::fast_pool_allocator<T, boost::default_user_allocator_new_delete, + boost::details::pool::default_mutex, 1024, 2048>; +} + +template <typename AddressType> +struct RangeSet<AddressType>::RangeSetImpl { + using IntervalSet = boost::icl::interval_set< + AddressType, std::less, ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, AddressType, std::less), + RangeSetsAllocator>; + using IntervalType = typename IntervalSet::interval_type; + + RangeSetImpl() = default; + ~RangeSetImpl() = default; + + void Add(AddressType base_address, size_t size) { + AddressType end_address = base_address + static_cast<AddressType>(size); + IntervalType interval{base_address, end_address}; + m_ranges_set.add(interval); + } + + void Subtract(AddressType base_address, size_t size) { + AddressType end_address = base_address + static_cast<AddressType>(size); + IntervalType interval{base_address, end_address}; + m_ranges_set.subtract(interval); + } + + template <typename Func> + void ForEach(Func&& func) const { + if (m_ranges_set.empty()) { + return; + } + auto it = m_ranges_set.begin(); + auto end_it = m_ranges_set.end(); + for (; it != end_it; it++) { + const AddressType inter_addr_end = it->upper(); + const AddressType inter_addr = it->lower(); + func(inter_addr, inter_addr_end); + } + } + + template <typename Func> + void ForEachInRange(AddressType base_addr, size_t size, Func&& func) const { + if (m_ranges_set.empty()) { + return; + } + const AddressType start_address = base_addr; + const AddressType end_address = start_address + size; + const RangeSetImpl::IntervalType search_interval{start_address, end_address}; + auto it = m_ranges_set.lower_bound(search_interval); + if (it == m_ranges_set.end()) { + return; + } + auto end_it = m_ranges_set.upper_bound(search_interval); + for (; it != end_it; it++) { + AddressType inter_addr_end = it->upper(); + AddressType inter_addr = it->lower(); + if (inter_addr_end > end_address) { + inter_addr_end = end_address; + } + if (inter_addr < start_address) { + inter_addr = start_address; + } + func(inter_addr, inter_addr_end); + } + } + + IntervalSet m_ranges_set; +}; + +template <typename AddressType> +struct OverlapRangeSet<AddressType>::OverlapRangeSetImpl { + using IntervalSet = boost::icl::split_interval_map< + AddressType, s32, boost::icl::partial_enricher, std::less, boost::icl::inplace_plus, + boost::icl::inter_section, + ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, AddressType, std::less), RangeSetsAllocator>; + using IntervalType = typename IntervalSet::interval_type; + + OverlapRangeSetImpl() = default; + ~OverlapRangeSetImpl() = default; + + void Add(AddressType base_address, size_t size) { + AddressType end_address = base_address + static_cast<AddressType>(size); + IntervalType interval{base_address, end_address}; + m_split_ranges_set += std::make_pair(interval, 1); + } + + template <bool has_on_delete, typename Func> + void Subtract(AddressType base_address, size_t size, s32 amount, + [[maybe_unused]] Func&& on_delete) { + if (m_split_ranges_set.empty()) { + return; + } + AddressType end_address = base_address + static_cast<AddressType>(size); + IntervalType interval{base_address, end_address}; + bool any_removals = false; + m_split_ranges_set += std::make_pair(interval, -amount); + do { + any_removals = false; + auto it = m_split_ranges_set.lower_bound(interval); + if (it == m_split_ranges_set.end()) { + return; + } + auto end_it = m_split_ranges_set.upper_bound(interval); + for (; it != end_it; it++) { + if (it->second <= 0) { + if constexpr (has_on_delete) { + if (it->second == 0) { + on_delete(it->first.lower(), it->first.upper()); + } + } + any_removals = true; + m_split_ranges_set.erase(it); + break; + } + } + } while (any_removals); + } + + template <typename Func> + void ForEach(Func&& func) const { + if (m_split_ranges_set.empty()) { + return; + } + auto it = m_split_ranges_set.begin(); + auto end_it = m_split_ranges_set.end(); + for (; it != end_it; it++) { + const AddressType inter_addr_end = it->first.upper(); + const AddressType inter_addr = it->first.lower(); + func(inter_addr, inter_addr_end, it->second); + } + } + + template <typename Func> + void ForEachInRange(AddressType base_address, size_t size, Func&& func) const { + if (m_split_ranges_set.empty()) { + return; + } + const AddressType start_address = base_address; + const AddressType end_address = start_address + size; + const OverlapRangeSetImpl::IntervalType search_interval{start_address, end_address}; + auto it = m_split_ranges_set.lower_bound(search_interval); + if (it == m_split_ranges_set.end()) { + return; + } + auto end_it = m_split_ranges_set.upper_bound(search_interval); + for (; it != end_it; it++) { + auto& inter = it->first; + AddressType inter_addr_end = inter.upper(); + AddressType inter_addr = inter.lower(); + if (inter_addr_end > end_address) { + inter_addr_end = end_address; + } + if (inter_addr < start_address) { + inter_addr = start_address; + } + func(inter_addr, inter_addr_end, it->second); + } + } + + IntervalSet m_split_ranges_set; +}; + +template <typename AddressType> +RangeSet<AddressType>::RangeSet() { + m_impl = std::make_unique<RangeSet<AddressType>::RangeSetImpl>(); +} + +template <typename AddressType> +RangeSet<AddressType>::~RangeSet() = default; + +template <typename AddressType> +RangeSet<AddressType>::RangeSet(RangeSet&& other) { + m_impl = std::make_unique<RangeSet<AddressType>::RangeSetImpl>(); + m_impl->m_ranges_set = std::move(other.m_impl->m_ranges_set); +} + +template <typename AddressType> +RangeSet<AddressType>& RangeSet<AddressType>::operator=(RangeSet&& other) { + m_impl->m_ranges_set = std::move(other.m_impl->m_ranges_set); +} + +template <typename AddressType> +void RangeSet<AddressType>::Add(AddressType base_address, size_t size) { + m_impl->Add(base_address, size); +} + +template <typename AddressType> +void RangeSet<AddressType>::Subtract(AddressType base_address, size_t size) { + m_impl->Subtract(base_address, size); +} + +template <typename AddressType> +void RangeSet<AddressType>::Clear() { + m_impl->m_ranges_set.clear(); +} + +template <typename AddressType> +bool RangeSet<AddressType>::Empty() const { + return m_impl->m_ranges_set.empty(); +} + +template <typename AddressType> +template <typename Func> +void RangeSet<AddressType>::ForEach(Func&& func) const { + m_impl->ForEach(std::move(func)); +} + +template <typename AddressType> +template <typename Func> +void RangeSet<AddressType>::ForEachInRange(AddressType base_address, size_t size, + Func&& func) const { + m_impl->ForEachInRange(base_address, size, std::move(func)); +} + +template <typename AddressType> +OverlapRangeSet<AddressType>::OverlapRangeSet() { + m_impl = std::make_unique<OverlapRangeSet<AddressType>::OverlapRangeSetImpl>(); +} + +template <typename AddressType> +OverlapRangeSet<AddressType>::~OverlapRangeSet() = default; + +template <typename AddressType> +OverlapRangeSet<AddressType>::OverlapRangeSet(OverlapRangeSet&& other) { + m_impl = std::make_unique<OverlapRangeSet<AddressType>::OverlapRangeSetImpl>(); + m_impl->m_split_ranges_set = std::move(other.m_impl->m_split_ranges_set); +} + +template <typename AddressType> +OverlapRangeSet<AddressType>& OverlapRangeSet<AddressType>::operator=(OverlapRangeSet&& other) { + m_impl->m_split_ranges_set = std::move(other.m_impl->m_split_ranges_set); +} + +template <typename AddressType> +void OverlapRangeSet<AddressType>::Add(AddressType base_address, size_t size) { + m_impl->Add(base_address, size); +} + +template <typename AddressType> +void OverlapRangeSet<AddressType>::Subtract(AddressType base_address, size_t size) { + m_impl->template Subtract<false>(base_address, size, 1, [](AddressType, AddressType) {}); +} + +template <typename AddressType> +template <typename Func> +void OverlapRangeSet<AddressType>::Subtract(AddressType base_address, size_t size, + Func&& on_delete) { + m_impl->template Subtract<true, Func>(base_address, size, 1, std::move(on_delete)); +} + +template <typename AddressType> +void OverlapRangeSet<AddressType>::DeleteAll(AddressType base_address, size_t size) { + m_impl->template Subtract<false>(base_address, size, std::numeric_limits<s32>::max(), + [](AddressType, AddressType) {}); +} + +template <typename AddressType> +void OverlapRangeSet<AddressType>::Clear() { + m_impl->m_split_ranges_set.clear(); +} + +template <typename AddressType> +bool OverlapRangeSet<AddressType>::Empty() const { + return m_impl->m_split_ranges_set.empty(); +} + +template <typename AddressType> +template <typename Func> +void OverlapRangeSet<AddressType>::ForEach(Func&& func) const { + m_impl->ForEach(func); +} + +template <typename AddressType> +template <typename Func> +void OverlapRangeSet<AddressType>::ForEachInRange(AddressType base_address, size_t size, + Func&& func) const { + m_impl->ForEachInRange(base_address, size, std::move(func)); +} + +} // namespace Common diff --git a/src/video_core/texture_cache/slot_vector.h b/src/common/slot_vector.h index 3ffa2a661..34ff7de94 100644 --- a/src/video_core/texture_cache/slot_vector.h +++ b/src/common/slot_vector.h @@ -14,7 +14,7 @@ #include "common/common_types.h" #include "common/polyfill_ranges.h" -namespace VideoCommon { +namespace Common { struct SlotId { static constexpr u32 INVALID_INDEX = std::numeric_limits<u32>::max(); @@ -217,11 +217,11 @@ private: std::vector<u32> free_list; }; -} // namespace VideoCommon +} // namespace Common template <> -struct std::hash<VideoCommon::SlotId> { - size_t operator()(const VideoCommon::SlotId& id) const noexcept { +struct std::hash<Common::SlotId> { + size_t operator()(const Common::SlotId& id) const noexcept { return std::hash<u32>{}(id.index); } }; diff --git a/src/core/device_memory_manager.inc b/src/core/device_memory_manager.inc index b026f4220..6dfee806c 100644 --- a/src/core/device_memory_manager.inc +++ b/src/core/device_memory_manager.inc @@ -532,6 +532,7 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size cache_bytes = 0; } }; + size_t old_vpage = (base_vaddress >> Memory::YUZU_PAGEBITS) - 1; for (; page != page_end; ++page) { CounterAtomicType& count = cached_pages->at(page >> subentries_shift).Count(page); auto [asid_2, vpage] = ExtractCPUBacking(page); @@ -547,6 +548,12 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size memory_device_inter = registered_processes[asid_2.id]; } + if (vpage != old_vpage + 1) [[unlikely]] { + release_pending(); + } + + old_vpage = vpage; + // Adds or subtracts 1, as count is a unsigned 8-bit value count.fetch_add(static_cast<CounterType>(delta), std::memory_order_release); diff --git a/src/core/hle/service/cmif_types.h b/src/core/hle/service/cmif_types.h index 84f4c2456..325304d5c 100644 --- a/src/core/hle/service/cmif_types.h +++ b/src/core/hle/service/cmif_types.h @@ -262,7 +262,7 @@ class OutLargeData { public: static_assert(std::is_trivially_copyable_v<T>, "LargeData type must be trivially copyable"); static_assert((A & BufferAttr_In) == 0, "OutLargeData attr must not be In"); - static constexpr BufferAttr Attr = static_cast<BufferAttr>(A | BufferAttr_In | BufferAttr_FixedSize); + static constexpr BufferAttr Attr = static_cast<BufferAttr>(A | BufferAttr_Out | BufferAttr_FixedSize); using Type = T; /* implicit */ OutLargeData(const OutLargeData& t) : raw(t.raw) {} diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index b60fb9139..1fa9cfbfb 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -36,7 +36,7 @@ void LoopProcess(Core::System& system) { server_manager->RegisterNamedService( "hid:sys", std::make_shared<IHidSystemServer>(system, resource_manager, firmware_settings)); - server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system)); + server_manager->RegisterNamedService("hidbus", std::make_shared<Hidbus>(system)); server_manager->RegisterNamedService("irs", std::make_shared<IRS::IRS>(system)); server_manager->RegisterNamedService("irs:sys", std::make_shared<IRS::IRS_SYS>(system)); diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cpp index 22471e9e2..7126a1dcd 100644 --- a/src/core/hle/service/hid/hid_system_server.cpp +++ b/src/core/hle/service/hid/hid_system_server.cpp @@ -508,13 +508,8 @@ void IHidSystemServer::RegisterAppletResourceUserId(HLERequestContext& ctx) { Result result = GetResourceManager()->RegisterAppletResourceUserId( parameters.applet_resource_user_id, parameters.enable_input); - if (result.IsSuccess()) { - // result = GetResourceManager()->GetNpad()->RegisterAppletResourceUserId( - // parameters.applet_resource_user_id); - } - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); + rb.Push(result); } void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) { @@ -524,8 +519,6 @@ void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) { LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id); GetResourceManager()->UnregisterAppletResourceUserId(applet_resource_user_id); - // GetResourceManager()->GetNpad()->UnregisterAppletResourceUserId(applet_resource_user_id); - // GetResourceManager()->GetPalma()->UnregisterAppletResourceUserId(applet_resource_user_id); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); diff --git a/src/core/hle/service/hid/hidbus.cpp b/src/core/hle/service/hid/hidbus.cpp index c903ee8b8..4fb002bc4 100644 --- a/src/core/hle/service/hid/hidbus.cpp +++ b/src/core/hle/service/hid/hidbus.cpp @@ -9,6 +9,7 @@ #include "core/hle/kernel/k_readable_event.h" #include "core/hle/kernel/k_shared_memory.h" #include "core/hle/kernel/k_transfer_memory.h" +#include "core/hle/service/cmif_serialization.h" #include "core/hle/service/hid/hidbus.h" #include "core/hle/service/ipc_helpers.h" #include "core/hle/service/service.h" @@ -22,25 +23,25 @@ namespace Service::HID { // (15ms, 66Hz) constexpr auto hidbus_update_ns = std::chrono::nanoseconds{15 * 1000 * 1000}; -HidBus::HidBus(Core::System& system_) +Hidbus::Hidbus(Core::System& system_) : ServiceFramework{system_, "hidbus"}, service_context{system_, service_name} { // clang-format off static const FunctionInfo functions[] = { - {1, &HidBus::GetBusHandle, "GetBusHandle"}, - {2, &HidBus::IsExternalDeviceConnected, "IsExternalDeviceConnected"}, - {3, &HidBus::Initialize, "Initialize"}, - {4, &HidBus::Finalize, "Finalize"}, - {5, &HidBus::EnableExternalDevice, "EnableExternalDevice"}, - {6, &HidBus::GetExternalDeviceId, "GetExternalDeviceId"}, - {7, &HidBus::SendCommandAsync, "SendCommandAsync"}, - {8, &HidBus::GetSendCommandAsynceResult, "GetSendCommandAsynceResult"}, - {9, &HidBus::SetEventForSendCommandAsycResult, "SetEventForSendCommandAsycResult"}, - {10, &HidBus::GetSharedMemoryHandle, "GetSharedMemoryHandle"}, - {11, &HidBus::EnableJoyPollingReceiveMode, "EnableJoyPollingReceiveMode"}, - {12, &HidBus::DisableJoyPollingReceiveMode, "DisableJoyPollingReceiveMode"}, + {1, C<&Hidbus::GetBusHandle>, "GetBusHandle"}, + {2, C<&Hidbus::IsExternalDeviceConnected>, "IsExternalDeviceConnected"}, + {3, C<&Hidbus::Initialize>, "Initialize"}, + {4, C<&Hidbus::Finalize>, "Finalize"}, + {5, C<&Hidbus::EnableExternalDevice>, "EnableExternalDevice"}, + {6, C<&Hidbus::GetExternalDeviceId>, "GetExternalDeviceId"}, + {7, C<&Hidbus::SendCommandAsync>, "SendCommandAsync"}, + {8, C<&Hidbus::GetSendCommandAsynceResult>, "GetSendCommandAsynceResult"}, + {9, C<&Hidbus::SetEventForSendCommandAsycResult>, "SetEventForSendCommandAsycResult"}, + {10, C<&Hidbus::GetSharedMemoryHandle>, "GetSharedMemoryHandle"}, + {11, C<&Hidbus::EnableJoyPollingReceiveMode>, "EnableJoyPollingReceiveMode"}, + {12, C<&Hidbus::DisableJoyPollingReceiveMode>, "DisableJoyPollingReceiveMode"}, {13, nullptr, "GetPollingData"}, - {14, &HidBus::SetStatusManagerType, "SetStatusManagerType"}, + {14, C<&Hidbus::SetStatusManagerType>, "SetStatusManagerType"}, }; // clang-format on @@ -60,11 +61,11 @@ HidBus::HidBus(Core::System& system_) hidbus_update_event); } -HidBus::~HidBus() { +Hidbus::~Hidbus() { system.CoreTiming().UnscheduleEvent(hidbus_update_event); } -void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) { +void Hidbus::UpdateHidbus(std::chrono::nanoseconds ns_late) { if (is_hidbus_enabled) { for (std::size_t i = 0; i < devices.size(); ++i) { if (!devices[i].is_device_initialized) { @@ -84,7 +85,7 @@ void HidBus::UpdateHidbus(std::chrono::nanoseconds ns_late) { } } -std::optional<std::size_t> HidBus::GetDeviceIndexFromHandle(BusHandle handle) const { +std::optional<std::size_t> Hidbus::GetDeviceIndexFromHandle(BusHandle handle) const { for (std::size_t i = 0; i < devices.size(); ++i) { const auto& device_handle = devices[i].handle; if (handle.abstracted_pad_id == device_handle.abstracted_pad_id && @@ -98,20 +99,11 @@ std::optional<std::size_t> HidBus::GetDeviceIndexFromHandle(BusHandle handle) co return std::nullopt; } -void HidBus::GetBusHandle(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - struct Parameters { - Core::HID::NpadIdType npad_id; - INSERT_PADDING_WORDS_NOINIT(1); - BusType bus_type; - u64 applet_resource_user_id; - }; - static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size."); - - const auto parameters{rp.PopRaw<Parameters>()}; - - LOG_INFO(Service_HID, "called, npad_id={}, bus_type={}, applet_resource_user_id={}", - parameters.npad_id, parameters.bus_type, parameters.applet_resource_user_id); +Result Hidbus::GetBusHandle(Out<bool> out_is_valid, Out<BusHandle> out_bus_handle, + Core::HID::NpadIdType npad_id, BusType bus_type, + AppletResourceUserId aruid) { + LOG_INFO(Service_HID, "called, npad_id={}, bus_type={}, applet_resource_user_id={}", npad_id, + bus_type, aruid.pid); bool is_handle_found = 0; std::size_t handle_index = 0; @@ -121,8 +113,8 @@ void HidBus::GetBusHandle(HLERequestContext& ctx) { if (!handle.is_valid) { continue; } - if (static_cast<Core::HID::NpadIdType>(handle.player_number) == parameters.npad_id && - handle.bus_type_id == static_cast<u8>(parameters.bus_type)) { + if (handle.player_number.As<Core::HID::NpadIdType>() == npad_id && + handle.bus_type_id == static_cast<u8>(bus_type)) { is_handle_found = true; handle_index = i; break; @@ -135,388 +127,231 @@ void HidBus::GetBusHandle(HLERequestContext& ctx) { if (devices[i].handle.is_valid) { continue; } - devices[i].handle = { - .abstracted_pad_id = static_cast<u8>(i), - .internal_index = static_cast<u8>(i), - .player_number = static_cast<u8>(parameters.npad_id), - .bus_type_id = static_cast<u8>(parameters.bus_type), - .is_valid = true, - }; + devices[i].handle.raw = 0; + devices[i].handle.abstracted_pad_id.Assign(i); + devices[i].handle.internal_index.Assign(i); + devices[i].handle.player_number.Assign(static_cast<u8>(npad_id)); + devices[i].handle.bus_type_id.Assign(static_cast<u8>(bus_type)); + devices[i].handle.is_valid.Assign(true); handle_index = i; break; } } - struct OutData { - bool is_valid; - INSERT_PADDING_BYTES(7); - BusHandle handle; - }; - static_assert(sizeof(OutData) == 0x10, "OutData has incorrect size."); - - const OutData out_data{ - .is_valid = true, - .handle = devices[handle_index].handle, - }; - - IPC::ResponseBuilder rb{ctx, 6}; - rb.Push(ResultSuccess); - rb.PushRaw(out_data); + *out_is_valid = true; + *out_bus_handle = devices[handle_index].handle; + R_SUCCEED(); } -void HidBus::IsExternalDeviceConnected(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::IsExternalDeviceConnected(Out<bool> out_is_connected, BusHandle bus_handle) { LOG_INFO(Service_HID, "Called, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - const auto& device = devices[device_index.value()].device; - const bool is_attached = device->IsDeviceActivated(); + R_UNLESS(device_index.has_value(), ResultUnknown); - IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(ResultSuccess); - rb.Push(is_attached); - return; - } - - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_is_connected = devices[device_index.value()].device->IsDeviceActivated(); + R_SUCCEED(); } -void HidBus::Initialize(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - const auto applet_resource_user_id{rp.Pop<u64>()}; - +Result Hidbus::Initialize(BusHandle bus_handle, AppletResourceUserId aruid) { LOG_INFO(Service_HID, "called, abstracted_pad_id={} bus_type={} internal_index={} " "player_number={} is_valid={}, applet_resource_user_id={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid, applet_resource_user_id); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid, aruid.pid); is_hidbus_enabled = true; - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - const auto entry_index = devices[device_index.value()].handle.internal_index; - auto& cur_entry = hidbus_status.entries[entry_index]; - - if (bus_handle_.internal_index == 0 && Settings::values.enable_ring_controller) { - MakeDevice<RingController>(bus_handle_); - devices[device_index.value()].is_device_initialized = true; - devices[device_index.value()].device->ActivateDevice(); - cur_entry.is_in_focus = true; - cur_entry.is_connected = true; - cur_entry.is_connected_result = ResultSuccess; - cur_entry.is_enabled = false; - cur_entry.is_polling_mode = false; - } else { - MakeDevice<HidbusStubbed>(bus_handle_); - devices[device_index.value()].is_device_initialized = true; - cur_entry.is_in_focus = true; - cur_entry.is_connected = false; - cur_entry.is_connected_result = ResultSuccess; - cur_entry.is_enabled = false; - cur_entry.is_polling_mode = false; - } - - std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, - sizeof(hidbus_status)); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; -} + R_UNLESS(device_index.has_value(), ResultUnknown); -void HidBus::Finalize(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - const auto applet_resource_user_id{rp.Pop<u64>()}; - - LOG_INFO(Service_HID, - "called, abstracted_pad_id={}, bus_type={}, internal_index={}, " - "player_number={}, is_valid={}, applet_resource_user_id={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid, applet_resource_user_id); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - const auto entry_index = devices[device_index.value()].handle.internal_index; - auto& cur_entry = hidbus_status.entries[entry_index]; - auto& device = devices[device_index.value()].device; - devices[device_index.value()].is_device_initialized = false; - device->DeactivateDevice(); + const auto entry_index = devices[device_index.value()].handle.internal_index; + auto& cur_entry = hidbus_status.entries[entry_index]; + if (bus_handle.internal_index == 0 && Settings::values.enable_ring_controller) { + MakeDevice<RingController>(bus_handle); + devices[device_index.value()].is_device_initialized = true; + devices[device_index.value()].device->ActivateDevice(); + cur_entry.is_in_focus = true; + cur_entry.is_connected = true; + cur_entry.is_connected_result = ResultSuccess; + cur_entry.is_enabled = false; + cur_entry.is_polling_mode = false; + } else { + MakeDevice<HidbusStubbed>(bus_handle); + devices[device_index.value()].is_device_initialized = true; cur_entry.is_in_focus = true; cur_entry.is_connected = false; cur_entry.is_connected_result = ResultSuccess; cur_entry.is_enabled = false; cur_entry.is_polling_mode = false; - std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, - sizeof(hidbus_status)); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; } - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, + sizeof(hidbus_status)); + R_SUCCEED(); } -void HidBus::EnableExternalDevice(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - struct Parameters { - bool enable; - INSERT_PADDING_BYTES_NOINIT(7); - BusHandle bus_handle; - u64 inval; - u64 applet_resource_user_id; - }; - static_assert(sizeof(Parameters) == 0x20, "Parameters has incorrect size."); - - const auto parameters{rp.PopRaw<Parameters>()}; +Result Hidbus::Finalize(BusHandle bus_handle, AppletResourceUserId aruid) { + LOG_INFO(Service_HID, + "called, abstracted_pad_id={}, bus_type={}, internal_index={}, " + "player_number={}, is_valid={}, applet_resource_user_id={}", + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid, aruid.pid); + + const auto device_index = GetDeviceIndexFromHandle(bus_handle); + + R_UNLESS(device_index.has_value(), ResultUnknown); + + const auto entry_index = devices[device_index.value()].handle.internal_index; + auto& cur_entry = hidbus_status.entries[entry_index]; + auto& device = devices[device_index.value()].device; + devices[device_index.value()].is_device_initialized = false; + device->DeactivateDevice(); + + cur_entry.is_in_focus = true; + cur_entry.is_connected = false; + cur_entry.is_connected_result = ResultSuccess; + cur_entry.is_enabled = false; + cur_entry.is_polling_mode = false; + std::memcpy(system.Kernel().GetHidBusSharedMem().GetPointer(), &hidbus_status, + sizeof(hidbus_status)); + R_SUCCEED(); +} +Result Hidbus::EnableExternalDevice(bool is_enabled, BusHandle bus_handle, u64 inval, + AppletResourceUserId aruid) { LOG_DEBUG(Service_HID, "called, enable={}, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}, inval={}, applet_resource_user_id{}", - parameters.enable, parameters.bus_handle.abstracted_pad_id, - parameters.bus_handle.bus_type_id, parameters.bus_handle.internal_index, - parameters.bus_handle.player_number, parameters.bus_handle.is_valid, parameters.inval, - parameters.applet_resource_user_id); - - const auto device_index = GetDeviceIndexFromHandle(parameters.bus_handle); - - if (device_index) { - auto& device = devices[device_index.value()].device; - device->Enable(parameters.enable); + is_enabled, bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid, inval, + aruid.pid); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + R_UNLESS(device_index.has_value(), ResultUnknown); + devices[device_index.value()].device->Enable(is_enabled); + R_SUCCEED(); } -void HidBus::GetExternalDeviceId(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::GetExternalDeviceId(Out<u32> out_device_id, BusHandle bus_handle) { LOG_DEBUG(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); - - if (device_index) { - const auto& device = devices[device_index.value()].device; - u32 device_id = device->GetDeviceId(); - IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(ResultSuccess); - rb.Push<u32>(device_id); - return; - } + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; -} + const auto device_index = GetDeviceIndexFromHandle(bus_handle); -void HidBus::SendCommandAsync(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto data = ctx.ReadBuffer(); - const auto bus_handle_{rp.PopRaw<BusHandle>()}; + R_UNLESS(device_index.has_value(), ResultUnknown); + *out_device_id = devices[device_index.value()].device->GetDeviceId(); + R_SUCCEED(); +} + +Result Hidbus::SendCommandAsync(BusHandle bus_handle, + InBuffer<BufferAttr_HipcAutoSelect> buffer_data) { LOG_DEBUG(Service_HID, "called, data_size={}, abstracted_pad_id={}, bus_type={}, internal_index={}, " "player_number={}, is_valid={}", - data.size(), bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, - bus_handle_.internal_index, bus_handle_.player_number, bus_handle_.is_valid); + buffer_data.size(), bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->SetCommand(data); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + devices[device_index.value()].device->SetCommand(buffer_data); + R_SUCCEED(); }; -void HidBus::GetSendCommandAsynceResult(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::GetSendCommandAsynceResult(Out<u64> out_data_size, BusHandle bus_handle, + OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_data) { LOG_DEBUG(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); - - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - if (device_index) { - const auto& device = devices[device_index.value()].device; - const std::vector<u8> data = device->GetReply(); - const u64 data_size = ctx.WriteBuffer(data); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - IPC::ResponseBuilder rb{ctx, 4}; - rb.Push(ResultSuccess); - rb.Push<u64>(data_size); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_data_size = devices[device_index.value()].device->GetReply(out_buffer_data); + R_SUCCEED(); }; -void HidBus::SetEventForSendCommandAsycResult(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::SetEventForSendCommandAsycResult(OutCopyHandle<Kernel::KReadableEvent> out_event, + BusHandle bus_handle) { LOG_INFO(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - const auto& device = devices[device_index.value()].device; - IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(device->GetSendCommandAsycEvent()); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + *out_event = &devices[device_index.value()].device->GetSendCommandAsycEvent(); + R_SUCCEED(); }; -void HidBus::GetSharedMemoryHandle(HLERequestContext& ctx) { +Result Hidbus::GetSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory) { LOG_DEBUG(Service_HID, "called"); - IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(&system.Kernel().GetHidBusSharedMem()); + *out_shared_memory = &system.Kernel().GetHidBusSharedMem(); + R_SUCCEED(); } -void HidBus::EnableJoyPollingReceiveMode(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto t_mem_size{rp.Pop<u32>()}; - const auto t_mem_handle{ctx.GetCopyHandle(0)}; - const auto polling_mode_{rp.PopEnum<JoyPollingMode>()}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode, + BusHandle bus_handle, + InCopyHandle<Kernel::KTransferMemory> t_mem) { ASSERT_MSG(t_mem_size == 0x1000, "t_mem_size is not 0x1000 bytes"); - - auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle); - - if (t_mem.IsNull()) { - LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; - } - - ASSERT_MSG(t_mem->GetSize() == 0x1000, "t_mem has incorrect size"); + ASSERT_MSG(t_mem->GetSize() == t_mem_size, "t_mem has incorrect size"); LOG_INFO(Service_HID, - "called, t_mem_handle=0x{:08X}, polling_mode={}, abstracted_pad_id={}, bus_type={}, " + "called, polling_mode={}, abstracted_pad_id={}, bus_type={}, " "internal_index={}, player_number={}, is_valid={}", - t_mem_handle, polling_mode_, bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, - bus_handle_.internal_index, bus_handle_.player_number, bus_handle_.is_valid); + polling_mode, bus_handle.abstracted_pad_id, bus_handle.bus_type_id, + bus_handle.internal_index, bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->SetPollingMode(polling_mode_); - device->SetTransferMemoryAddress(t_mem->GetSourceAddress()); + R_UNLESS(device_index.has_value(), ResultUnknown); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } - - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + auto& device = devices[device_index.value()].device; + device->SetPollingMode(polling_mode); + device->SetTransferMemoryAddress(t_mem->GetSourceAddress()); + R_SUCCEED(); } -void HidBus::DisableJoyPollingReceiveMode(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto bus_handle_{rp.PopRaw<BusHandle>()}; - +Result Hidbus::DisableJoyPollingReceiveMode(BusHandle bus_handle) { LOG_INFO(Service_HID, "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, " "is_valid={}", - bus_handle_.abstracted_pad_id, bus_handle_.bus_type_id, bus_handle_.internal_index, - bus_handle_.player_number, bus_handle_.is_valid); + bus_handle.abstracted_pad_id, bus_handle.bus_type_id, bus_handle.internal_index, + bus_handle.player_number, bus_handle.is_valid); - const auto device_index = GetDeviceIndexFromHandle(bus_handle_); + const auto device_index = GetDeviceIndexFromHandle(bus_handle); - if (device_index) { - auto& device = devices[device_index.value()].device; - device->DisablePollingMode(); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - return; - } + R_UNLESS(device_index.has_value(), ResultUnknown); - LOG_ERROR(Service_HID, "Invalid handle"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultUnknown); - return; + auto& device = devices[device_index.value()].device; + device->DisablePollingMode(); + R_SUCCEED(); } -void HidBus::SetStatusManagerType(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto manager_type{rp.PopEnum<StatusManagerType>()}; - +Result Hidbus::SetStatusManagerType(StatusManagerType manager_type) { LOG_WARNING(Service_HID, "(STUBBED) called, manager_type={}", manager_type); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); + R_SUCCEED(); }; + } // namespace Service::HID diff --git a/src/core/hle/service/hid/hidbus.h b/src/core/hle/service/hid/hidbus.h index 03d9f6863..af4d95667 100644 --- a/src/core/hle/service/hid/hidbus.h +++ b/src/core/hle/service/hid/hidbus.h @@ -5,8 +5,10 @@ #include <functional> +#include "core/hle/service/cmif_types.h" #include "core/hle/service/kernel_helpers.h" #include "core/hle/service/service.h" +#include "hid_core/hid_types.h" #include "hid_core/hidbus/hidbus_base.h" namespace Core::Timing { @@ -19,10 +21,10 @@ class System; namespace Service::HID { -class HidBus final : public ServiceFramework<HidBus> { +class Hidbus final : public ServiceFramework<Hidbus> { public: - explicit HidBus(Core::System& system_); - ~HidBus() override; + explicit Hidbus(Core::System& system_); + ~Hidbus() override; private: static const std::size_t max_number_of_handles = 0x13; @@ -41,7 +43,7 @@ private: }; // This is nn::hidbus::BusType - enum class BusType : u32 { + enum class BusType : u64 { LeftJoyRail, RightJoyRail, InternalBus, // Lark microphone @@ -51,11 +53,15 @@ private: // This is nn::hidbus::BusHandle struct BusHandle { - u32 abstracted_pad_id; - u8 internal_index; - u8 player_number; - u8 bus_type_id; - bool is_valid; + union { + u64 raw{}; + + BitField<0, 32, u64> abstracted_pad_id; + BitField<32, 8, u64> internal_index; + BitField<40, 8, u64> player_number; + BitField<48, 8, u64> bus_type_id; + BitField<56, 1, u64> is_valid; + }; }; static_assert(sizeof(BusHandle) == 0x8, "BusHandle is an invalid size"); @@ -94,19 +100,38 @@ private: std::unique_ptr<HidbusBase> device{nullptr}; }; - void GetBusHandle(HLERequestContext& ctx); - void IsExternalDeviceConnected(HLERequestContext& ctx); - void Initialize(HLERequestContext& ctx); - void Finalize(HLERequestContext& ctx); - void EnableExternalDevice(HLERequestContext& ctx); - void GetExternalDeviceId(HLERequestContext& ctx); - void SendCommandAsync(HLERequestContext& ctx); - void GetSendCommandAsynceResult(HLERequestContext& ctx); - void SetEventForSendCommandAsycResult(HLERequestContext& ctx); - void GetSharedMemoryHandle(HLERequestContext& ctx); - void EnableJoyPollingReceiveMode(HLERequestContext& ctx); - void DisableJoyPollingReceiveMode(HLERequestContext& ctx); - void SetStatusManagerType(HLERequestContext& ctx); + Result GetBusHandle(Out<bool> out_is_valid, Out<BusHandle> out_bus_handle, + Core::HID::NpadIdType npad_id, BusType bus_type, + AppletResourceUserId aruid); + + Result IsExternalDeviceConnected(Out<bool> out_is_connected, BusHandle bus_handle); + + Result Initialize(BusHandle bus_handle, AppletResourceUserId aruid); + + Result Finalize(BusHandle bus_handle, AppletResourceUserId aruid); + + Result EnableExternalDevice(bool is_enabled, BusHandle bus_handle, u64 inval, + AppletResourceUserId aruid); + + Result GetExternalDeviceId(Out<u32> out_device_id, BusHandle bus_handle); + + Result SendCommandAsync(BusHandle bus_handle, InBuffer<BufferAttr_HipcAutoSelect> buffer_data); + + Result GetSendCommandAsynceResult(Out<u64> out_data_size, BusHandle bus_handle, + OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_data); + + Result SetEventForSendCommandAsycResult(OutCopyHandle<Kernel::KReadableEvent> out_event, + BusHandle bus_handle); + + Result GetSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory); + + Result EnableJoyPollingReceiveMode(u32 t_mem_size, JoyPollingMode polling_mode, + BusHandle bus_handle, + InCopyHandle<Kernel::KTransferMemory> t_mem); + + Result DisableJoyPollingReceiveMode(BusHandle bus_handle); + + Result SetStatusManagerType(StatusManagerType manager_type); void UpdateHidbus(std::chrono::nanoseconds ns_late); std::optional<std::size_t> GetDeviceIndexFromHandle(BusHandle handle) const; diff --git a/src/core/hle/service/nvdrv/core/heap_mapper.cpp b/src/core/hle/service/nvdrv/core/heap_mapper.cpp index 096dc5deb..af17e3e85 100644 --- a/src/core/hle/service/nvdrv/core/heap_mapper.cpp +++ b/src/core/hle/service/nvdrv/core/heap_mapper.cpp @@ -3,110 +3,21 @@ #include <mutex> -#include <boost/container/small_vector.hpp> -#define BOOST_NO_MT -#include <boost/pool/detail/mutex.hpp> -#undef BOOST_NO_MT -#include <boost/icl/interval.hpp> -#include <boost/icl/interval_base_set.hpp> -#include <boost/icl/interval_set.hpp> -#include <boost/icl/split_interval_map.hpp> -#include <boost/pool/pool.hpp> -#include <boost/pool/pool_alloc.hpp> -#include <boost/pool/poolfwd.hpp> - +#include "common/range_sets.h" +#include "common/range_sets.inc" #include "core/hle/service/nvdrv/core/heap_mapper.h" #include "video_core/host1x/host1x.h" -namespace boost { -template <typename T> -class fast_pool_allocator<T, default_user_allocator_new_delete, details::pool::null_mutex, 4096, 0>; -} - namespace Service::Nvidia::NvCore { -using IntervalCompare = std::less<DAddr>; -using IntervalInstance = boost::icl::interval_type_default<DAddr, std::less>; -using IntervalAllocator = boost::fast_pool_allocator<DAddr>; -using IntervalSet = boost::icl::interval_set<DAddr>; -using IntervalType = typename IntervalSet::interval_type; - -template <typename Type> -struct counter_add_functor : public boost::icl::identity_based_inplace_combine<Type> { - // types - typedef counter_add_functor<Type> type; - typedef boost::icl::identity_based_inplace_combine<Type> base_type; - - // public member functions - void operator()(Type& current, const Type& added) const { - current += added; - if (current < base_type::identity_element()) { - current = base_type::identity_element(); - } - } - - // public static functions - static void version(Type&){}; -}; - -using OverlapCombine = counter_add_functor<int>; -using OverlapSection = boost::icl::inter_section<int>; -using OverlapCounter = boost::icl::split_interval_map<DAddr, int>; - struct HeapMapper::HeapMapperInternal { - HeapMapperInternal(Tegra::Host1x::Host1x& host1x) : device_memory{host1x.MemoryManager()} {} + HeapMapperInternal(Tegra::Host1x::Host1x& host1x) : m_device_memory{host1x.MemoryManager()} {} ~HeapMapperInternal() = default; - template <typename Func> - void ForEachInOverlapCounter(OverlapCounter& current_range, VAddr cpu_addr, u64 size, - Func&& func) { - const DAddr start_address = cpu_addr; - const DAddr end_address = start_address + size; - const IntervalType search_interval{start_address, end_address}; - auto it = current_range.lower_bound(search_interval); - if (it == current_range.end()) { - return; - } - auto end_it = current_range.upper_bound(search_interval); - for (; it != end_it; it++) { - auto& inter = it->first; - DAddr inter_addr_end = inter.upper(); - DAddr inter_addr = inter.lower(); - if (inter_addr_end > end_address) { - inter_addr_end = end_address; - } - if (inter_addr < start_address) { - inter_addr = start_address; - } - func(inter_addr, inter_addr_end, it->second); - } - } - - void RemoveEachInOverlapCounter(OverlapCounter& current_range, - const IntervalType search_interval, int subtract_value) { - bool any_removals = false; - current_range.add(std::make_pair(search_interval, subtract_value)); - do { - any_removals = false; - auto it = current_range.lower_bound(search_interval); - if (it == current_range.end()) { - return; - } - auto end_it = current_range.upper_bound(search_interval); - for (; it != end_it; it++) { - if (it->second <= 0) { - any_removals = true; - current_range.erase(it); - break; - } - } - } while (any_removals); - } - - IntervalSet base_set; - OverlapCounter mapping_overlaps; - Tegra::MaxwellDeviceMemoryManager& device_memory; - std::mutex guard; + Common::RangeSet<VAddr> m_temporary_set; + Common::OverlapRangeSet<VAddr> m_mapped_ranges; + Tegra::MaxwellDeviceMemoryManager& m_device_memory; + std::mutex m_guard; }; HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid, @@ -116,60 +27,48 @@ HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, } HeapMapper::~HeapMapper() { - m_internal->device_memory.Unmap(m_daddress, m_size); + // Unmap whatever has been mapped. + m_internal->m_mapped_ranges.ForEach([this](VAddr start_addr, VAddr end_addr, s32 count) { + const size_t sub_size = end_addr - start_addr; + const size_t offset = start_addr - m_vaddress; + m_internal->m_device_memory.Unmap(m_daddress + offset, sub_size); + }); } DAddr HeapMapper::Map(VAddr start, size_t size) { - std::scoped_lock lk(m_internal->guard); - m_internal->base_set.clear(); - const IntervalType interval{start, start + size}; - m_internal->base_set.insert(interval); - m_internal->ForEachInOverlapCounter(m_internal->mapping_overlaps, start, size, - [this](VAddr start_addr, VAddr end_addr, int) { - const IntervalType other{start_addr, end_addr}; - m_internal->base_set.subtract(other); - }); - if (!m_internal->base_set.empty()) { - auto it = m_internal->base_set.begin(); - auto end_it = m_internal->base_set.end(); - for (; it != end_it; it++) { - const VAddr inter_addr_end = it->upper(); - const VAddr inter_addr = it->lower(); - const size_t offset = inter_addr - m_vaddress; - const size_t sub_size = inter_addr_end - inter_addr; - m_internal->device_memory.Map(m_daddress + offset, m_vaddress + offset, sub_size, - m_asid); - } - } - m_internal->mapping_overlaps += std::make_pair(interval, 1); - m_internal->base_set.clear(); - return m_daddress + (start - m_vaddress); + std::scoped_lock lk(m_internal->m_guard); + // Add the mapping range to a temporary range set. + m_internal->m_temporary_set.Clear(); + m_internal->m_temporary_set.Add(start, size); + + // Remove anything that's already mapped from the temporary range set. + m_internal->m_mapped_ranges.ForEachInRange( + start, size, [this](VAddr start_addr, VAddr end_addr, s32) { + m_internal->m_temporary_set.Subtract(start_addr, end_addr - start_addr); + }); + + // Map anything that has not been mapped yet. + m_internal->m_temporary_set.ForEach([this](VAddr start_addr, VAddr end_addr) { + const size_t sub_size = end_addr - start_addr; + const size_t offset = start_addr - m_vaddress; + m_internal->m_device_memory.Map(m_daddress + offset, m_vaddress + offset, sub_size, m_asid); + }); + + // Add the mapping range to the split map, to register the map and overlaps. + m_internal->m_mapped_ranges.Add(start, size); + m_internal->m_temporary_set.Clear(); + return m_daddress + static_cast<DAddr>(start - m_vaddress); } void HeapMapper::Unmap(VAddr start, size_t size) { - std::scoped_lock lk(m_internal->guard); - m_internal->base_set.clear(); - m_internal->ForEachInOverlapCounter(m_internal->mapping_overlaps, start, size, - [this](VAddr start_addr, VAddr end_addr, int value) { - if (value <= 1) { - const IntervalType other{start_addr, end_addr}; - m_internal->base_set.insert(other); - } - }); - if (!m_internal->base_set.empty()) { - auto it = m_internal->base_set.begin(); - auto end_it = m_internal->base_set.end(); - for (; it != end_it; it++) { - const VAddr inter_addr_end = it->upper(); - const VAddr inter_addr = it->lower(); - const size_t offset = inter_addr - m_vaddress; - const size_t sub_size = inter_addr_end - inter_addr; - m_internal->device_memory.Unmap(m_daddress + offset, sub_size); - } - } - const IntervalType to_remove{start, start + size}; - m_internal->RemoveEachInOverlapCounter(m_internal->mapping_overlaps, to_remove, -1); - m_internal->base_set.clear(); + std::scoped_lock lk(m_internal->m_guard); + + // Just subtract the range and whatever is deleted, unmap it. + m_internal->m_mapped_ranges.Subtract(start, size, [this](VAddr start_addr, VAddr end_addr) { + const size_t sub_size = end_addr - start_addr; + const size_t offset = start_addr - m_vaddress; + m_internal->m_device_memory.Unmap(m_daddress + offset, sub_size); + }); } } // namespace Service::Nvidia::NvCore diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp index 14d1a3840..470521f44 100644 --- a/src/core/memory/cheat_engine.cpp +++ b/src/core/memory/cheat_engine.cpp @@ -5,6 +5,7 @@ #include "common/hex_util.h" #include "common/microprofile.h" #include "common/swap.h" +#include "core/arm/debug.h" #include "core/core.h" #include "core/core_timing.h" #include "core/hle/kernel/k_page_table.h" @@ -63,7 +64,9 @@ void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64 return; } - system.ApplicationMemory().WriteBlock(address, data, size); + if (system.ApplicationMemory().WriteBlock(address, data, size)) { + Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size); + } } u64 StandardVmCallbacks::HidKeysDown() { diff --git a/src/hid_core/hidbus/hidbus_base.h b/src/hid_core/hidbus/hidbus_base.h index ec41684e1..c948606e4 100644 --- a/src/hid_core/hidbus/hidbus_base.h +++ b/src/hid_core/hidbus/hidbus_base.h @@ -160,7 +160,7 @@ public: } // Returns a reply from a command - virtual std::vector<u8> GetReply() const { + virtual u64 GetReply(std::span<u8> out_data) const { return {}; } diff --git a/src/hid_core/hidbus/ringcon.cpp b/src/hid_core/hidbus/ringcon.cpp index cedf25c16..4f5eaa505 100644 --- a/src/hid_core/hidbus/ringcon.cpp +++ b/src/hid_core/hidbus/ringcon.cpp @@ -90,32 +90,32 @@ u8 RingController::GetDeviceId() const { return device_id; } -std::vector<u8> RingController::GetReply() const { +u64 RingController::GetReply(std::span<u8> out_data) const { const RingConCommands current_command = command; switch (current_command) { case RingConCommands::GetFirmwareVersion: - return GetFirmwareVersionReply(); + return GetFirmwareVersionReply(out_data); case RingConCommands::ReadId: - return GetReadIdReply(); + return GetReadIdReply(out_data); case RingConCommands::c20105: - return GetC020105Reply(); + return GetC020105Reply(out_data); case RingConCommands::ReadUnkCal: - return GetReadUnkCalReply(); + return GetReadUnkCalReply(out_data); case RingConCommands::ReadFactoryCal: - return GetReadFactoryCalReply(); + return GetReadFactoryCalReply(out_data); case RingConCommands::ReadUserCal: - return GetReadUserCalReply(); + return GetReadUserCalReply(out_data); case RingConCommands::ReadRepCount: - return GetReadRepCountReply(); + return GetReadRepCountReply(out_data); case RingConCommands::ReadTotalPushCount: - return GetReadTotalPushCountReply(); + return GetReadTotalPushCountReply(out_data); case RingConCommands::ResetRepCount: - return GetResetRepCountReply(); + return GetResetRepCountReply(out_data); case RingConCommands::SaveCalData: - return GetSaveDataReply(); + return GetSaveDataReply(out_data); default: - return GetErrorReply(); + return GetErrorReply(out_data); } } @@ -163,16 +163,16 @@ bool RingController::SetCommand(std::span<const u8> data) { } } -std::vector<u8> RingController::GetFirmwareVersionReply() const { +u64 RingController::GetFirmwareVersionReply(std::span<u8> out_data) const { const FirmwareVersionReply reply{ .status = DataValid::Valid, .firmware = version, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadIdReply() const { +u64 RingController::GetReadIdReply(std::span<u8> out_data) const { // The values are hardcoded from a real joycon const ReadIdReply reply{ .status = DataValid::Valid, @@ -184,83 +184,83 @@ std::vector<u8> RingController::GetReadIdReply() const { .id_h_x4 = 8245, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetC020105Reply() const { +u64 RingController::GetC020105Reply(std::span<u8> out_data) const { const Cmd020105Reply reply{ .status = DataValid::Valid, .data = 1, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadUnkCalReply() const { +u64 RingController::GetReadUnkCalReply(std::span<u8> out_data) const { const ReadUnkCalReply reply{ .status = DataValid::Valid, .data = 0, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadFactoryCalReply() const { +u64 RingController::GetReadFactoryCalReply(std::span<u8> out_data) const { const ReadFactoryCalReply reply{ .status = DataValid::Valid, .calibration = factory_calibration, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadUserCalReply() const { +u64 RingController::GetReadUserCalReply(std::span<u8> out_data) const { const ReadUserCalReply reply{ .status = DataValid::Valid, .calibration = user_calibration, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadRepCountReply() const { +u64 RingController::GetReadRepCountReply(std::span<u8> out_data) const { const GetThreeByteReply reply{ .status = DataValid::Valid, .data = {total_rep_count, 0, 0}, .crc = GetCrcValue({total_rep_count, 0, 0, 0}), }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetReadTotalPushCountReply() const { +u64 RingController::GetReadTotalPushCountReply(std::span<u8> out_data) const { const GetThreeByteReply reply{ .status = DataValid::Valid, .data = {total_push_count, 0, 0}, .crc = GetCrcValue({total_push_count, 0, 0, 0}), }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetResetRepCountReply() const { - return GetReadRepCountReply(); +u64 RingController::GetResetRepCountReply(std::span<u8> out_data) const { + return GetReadRepCountReply(out_data); } -std::vector<u8> RingController::GetSaveDataReply() const { +u64 RingController::GetSaveDataReply(std::span<u8> out_data) const { const StatusReply reply{ .status = DataValid::Valid, }; - return GetDataVector(reply); + return GetData(reply, out_data); } -std::vector<u8> RingController::GetErrorReply() const { +u64 RingController::GetErrorReply(std::span<u8> out_data) const { const ErrorReply reply{ .status = DataValid::BadCRC, }; - return GetDataVector(reply); + return GetData(reply, out_data); } u8 RingController::GetCrcValue(const std::vector<u8>& data) const { @@ -281,12 +281,11 @@ u8 RingController::GetCrcValue(const std::vector<u8>& data) const { } template <typename T> -std::vector<u8> RingController::GetDataVector(const T& reply) const { +u64 RingController::GetData(const T& reply, std::span<u8> out_data) const { static_assert(std::is_trivially_copyable_v<T>); - std::vector<u8> data; - data.resize(sizeof(reply)); - std::memcpy(data.data(), &reply, sizeof(reply)); - return data; + const auto data_size = static_cast<u64>(std::min(sizeof(reply), out_data.size())); + std::memcpy(out_data.data(), &reply, data_size); + return data_size; } } // namespace Service::HID diff --git a/src/hid_core/hidbus/ringcon.h b/src/hid_core/hidbus/ringcon.h index 0953e8100..a48eeed45 100644 --- a/src/hid_core/hidbus/ringcon.h +++ b/src/hid_core/hidbus/ringcon.h @@ -34,7 +34,7 @@ public: bool SetCommand(std::span<const u8> data) override; // Returns a reply from a command - std::vector<u8> GetReply() const override; + u64 GetReply(std::span<u8> data) const override; private: // These values are obtained from a real ring controller @@ -184,44 +184,44 @@ private: RingConData GetSensorValue() const; // Returns 8 byte reply with firmware version - std::vector<u8> GetFirmwareVersionReply() const; + u64 GetFirmwareVersionReply(std::span<u8> out_data) const; // Returns 16 byte reply with ID values - std::vector<u8> GetReadIdReply() const; + u64 GetReadIdReply(std::span<u8> out_data) const; // (STUBBED) Returns 8 byte reply - std::vector<u8> GetC020105Reply() const; + u64 GetC020105Reply(std::span<u8> out_data) const; // (STUBBED) Returns 8 byte empty reply - std::vector<u8> GetReadUnkCalReply() const; + u64 GetReadUnkCalReply(std::span<u8> out_data) const; // Returns 20 byte reply with factory calibration values - std::vector<u8> GetReadFactoryCalReply() const; + u64 GetReadFactoryCalReply(std::span<u8> out_data) const; // Returns 20 byte reply with user calibration values - std::vector<u8> GetReadUserCalReply() const; + u64 GetReadUserCalReply(std::span<u8> out_data) const; // Returns 8 byte reply - std::vector<u8> GetReadRepCountReply() const; + u64 GetReadRepCountReply(std::span<u8> out_data) const; // Returns 8 byte reply - std::vector<u8> GetReadTotalPushCountReply() const; + u64 GetReadTotalPushCountReply(std::span<u8> out_data) const; // Returns 8 byte reply - std::vector<u8> GetResetRepCountReply() const; + u64 GetResetRepCountReply(std::span<u8> out_data) const; // Returns 4 byte save data reply - std::vector<u8> GetSaveDataReply() const; + u64 GetSaveDataReply(std::span<u8> out_data) const; // Returns 8 byte error reply - std::vector<u8> GetErrorReply() const; + u64 GetErrorReply(std::span<u8> out_data) const; // Returns 8 bit redundancy check from provided data u8 GetCrcValue(const std::vector<u8>& data) const; // Converts structs to an u8 vector equivalent template <typename T> - std::vector<u8> GetDataVector(const T& reply) const; + u64 GetData(const T& reply, std::span<u8> out_data) const; RingConCommands command{RingConCommands::Error}; diff --git a/src/hid_core/hidbus/starlink.cpp b/src/hid_core/hidbus/starlink.cpp index 31b263aa1..1c4df1d8c 100644 --- a/src/hid_core/hidbus/starlink.cpp +++ b/src/hid_core/hidbus/starlink.cpp @@ -38,7 +38,7 @@ u8 Starlink::GetDeviceId() const { return DEVICE_ID; } -std::vector<u8> Starlink::GetReply() const { +u64 Starlink::GetReply(std::span<u8> out_data) const { return {}; } diff --git a/src/hid_core/hidbus/starlink.h b/src/hid_core/hidbus/starlink.h index ee37763b4..695b69748 100644 --- a/src/hid_core/hidbus/starlink.h +++ b/src/hid_core/hidbus/starlink.h @@ -31,7 +31,7 @@ public: bool SetCommand(std::span<const u8> data) override; // Returns a reply from a command - std::vector<u8> GetReply() const override; + u64 GetReply(std::span<u8> out_data) const override; }; } // namespace Service::HID diff --git a/src/hid_core/hidbus/stubbed.cpp b/src/hid_core/hidbus/stubbed.cpp index f16051aa9..658922a4f 100644 --- a/src/hid_core/hidbus/stubbed.cpp +++ b/src/hid_core/hidbus/stubbed.cpp @@ -38,7 +38,7 @@ u8 HidbusStubbed::GetDeviceId() const { return DEVICE_ID; } -std::vector<u8> HidbusStubbed::GetReply() const { +u64 HidbusStubbed::GetReply(std::span<u8> out_data) const { return {}; } diff --git a/src/hid_core/hidbus/stubbed.h b/src/hid_core/hidbus/stubbed.h index 7a711cea0..f05280b3a 100644 --- a/src/hid_core/hidbus/stubbed.h +++ b/src/hid_core/hidbus/stubbed.h @@ -31,7 +31,7 @@ public: bool SetCommand(std::span<const u8> data) override; // Returns a reply from a command - std::vector<u8> GetReply() const override; + u64 GetReply(std::span<u8> out_data) const override; }; } // namespace Service::HID diff --git a/src/hid_core/resource_manager.cpp b/src/hid_core/resource_manager.cpp index 245da582e..01261ba97 100644 --- a/src/hid_core/resource_manager.cpp +++ b/src/hid_core/resource_manager.cpp @@ -314,6 +314,7 @@ void ResourceManager::UnregisterAppletResourceUserId(u64 aruid) { std::scoped_lock lock{shared_mutex}; applet_resource->UnregisterAppletResourceUserId(aruid); npad->UnregisterAppletResourceUserId(aruid); + // palma->UnregisterAppletResourceUserId(aruid); } Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) { @@ -324,6 +325,7 @@ Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle void ResourceManager::FreeAppletResourceId(u64 aruid) { std::scoped_lock lock{shared_mutex}; applet_resource->FreeAppletResourceId(aruid); + npad->FreeAppletResourceId(aruid); } void ResourceManager::EnableInput(u64 aruid, bool is_enabled) { diff --git a/src/hid_core/resources/npad/npad.cpp b/src/hid_core/resources/npad/npad.cpp index 053625b55..e10e97e1c 100644 --- a/src/hid_core/resources/npad/npad.cpp +++ b/src/hid_core/resources/npad/npad.cpp @@ -117,6 +117,10 @@ Result NPad::ActivateNpadResource(u64 aruid) { return npad_resource.Activate(aruid); } +void NPad::FreeAppletResourceId(u64 aruid) { + return npad_resource.FreeAppletResourceId(aruid); +} + void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx) { if (type == Core::HID::ControllerTriggerType::All) { ControllerUpdate(Core::HID::ControllerTriggerType::Connected, controller_idx); diff --git a/src/hid_core/resources/npad/npad.h b/src/hid_core/resources/npad/npad.h index c63488346..99e761127 100644 --- a/src/hid_core/resources/npad/npad.h +++ b/src/hid_core/resources/npad/npad.h @@ -58,6 +58,8 @@ public: Result ActivateNpadResource(); Result ActivateNpadResource(u64 aruid); + void FreeAppletResourceId(u64 aruid); + // When the controller is requesting an update for the shared memory void OnUpdate(const Core::Timing::CoreTiming& core_timing); diff --git a/src/hid_core/resources/npad/npad_resource.cpp b/src/hid_core/resources/npad/npad_resource.cpp index 8dd86b58e..79f7d74c0 100644 --- a/src/hid_core/resources/npad/npad_resource.cpp +++ b/src/hid_core/resources/npad/npad_resource.cpp @@ -67,7 +67,7 @@ Result NPadResource::RegisterAppletResourceUserId(u64 aruid) { void NPadResource::UnregisterAppletResourceUserId(u64 aruid) { const u64 aruid_index = GetIndexFromAruid(aruid); - DestroyStyleSetUpdateEvents(aruid); + FreeAppletResourceId(aruid); if (aruid_index < AruidIndexMax) { state[aruid_index] = {}; registration_list.flag[aruid_index] = RegistrationStatus::PendingDelete; @@ -80,14 +80,18 @@ void NPadResource::UnregisterAppletResourceUserId(u64 aruid) { } } -void NPadResource::DestroyStyleSetUpdateEvents(u64 aruid) { +void NPadResource::FreeAppletResourceId(u64 aruid) { const u64 aruid_index = GetIndexFromAruid(aruid); if (aruid_index >= AruidIndexMax) { return; } - for (auto& controller_state : state[aruid_index].controller_state) { + auto& aruid_data = state[aruid_index]; + + aruid_data.flag.is_assigned.Assign(false); + + for (auto& controller_state : aruid_data.controller_state) { if (!controller_state.is_styleset_update_event_initialized) { continue; } diff --git a/src/hid_core/resources/npad/npad_resource.h b/src/hid_core/resources/npad/npad_resource.h index aed89eec6..8ee5702fd 100644 --- a/src/hid_core/resources/npad/npad_resource.h +++ b/src/hid_core/resources/npad/npad_resource.h @@ -55,7 +55,7 @@ public: Result RegisterAppletResourceUserId(u64 aruid); void UnregisterAppletResourceUserId(u64 aruid); - void DestroyStyleSetUpdateEvents(u64 aruid); + void FreeAppletResourceId(u64 aruid); Result Activate(u64 aruid); Result Activate(); diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp index 64a4e0e55..44281e407 100644 --- a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp +++ b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp @@ -60,10 +60,11 @@ public: Add(spv::ImageOperandsMask::ConstOffsets, offsets); } - explicit ImageOperands(Id lod, Id ms) { + explicit ImageOperands(EmitContext& ctx, const IR::Value& offset, Id lod, Id ms) { if (Sirit::ValidId(lod)) { Add(spv::ImageOperandsMask::Lod, lod); } + AddOffset(ctx, offset, ImageFetchOffsetAllowed); if (Sirit::ValidId(ms)) { Add(spv::ImageOperandsMask::Sample, ms); } @@ -311,37 +312,6 @@ Id ImageGatherSubpixelOffset(EmitContext& ctx, const IR::TextureInstInfo& info, return coords; } } - -void AddOffsetToCoordinates(EmitContext& ctx, const IR::TextureInstInfo& info, Id& coords, - Id offset) { - if (!Sirit::ValidId(offset)) { - return; - } - - Id result_type{}; - switch (info.type) { - case TextureType::Buffer: - case TextureType::Color1D: - case TextureType::ColorArray1D: { - result_type = ctx.U32[1]; - break; - } - case TextureType::Color2D: - case TextureType::Color2DRect: - case TextureType::ColorArray2D: { - result_type = ctx.U32[2]; - break; - } - case TextureType::Color3D: { - result_type = ctx.U32[3]; - break; - } - case TextureType::ColorCube: - case TextureType::ColorArrayCube: - return; - } - coords = ctx.OpIAdd(result_type, coords, offset); -} } // Anonymous namespace Id EmitBindlessImageSampleImplicitLod(EmitContext&) { @@ -524,10 +494,9 @@ Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, operands.Span()); } -Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset, - Id lod, Id ms) { +Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, + const IR::Value& offset, Id lod, Id ms) { const auto info{inst->Flags<IR::TextureInstInfo>()}; - AddOffsetToCoordinates(ctx, info, coords, offset); if (info.type == TextureType::Buffer) { lod = Id{}; } @@ -535,7 +504,7 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c // This image is multisampled, lod must be implicit lod = Id{}; } - const ImageOperands operands(lod, ms); + const ImageOperands operands(ctx, offset, lod, ms); return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4], TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span()); } diff --git a/src/shader_recompiler/backend/spirv/emit_spirv_instructions.h b/src/shader_recompiler/backend/spirv/emit_spirv_instructions.h index 5c01b1012..08fcabd58 100644 --- a/src/shader_recompiler/backend/spirv/emit_spirv_instructions.h +++ b/src/shader_recompiler/backend/spirv/emit_spirv_instructions.h @@ -537,8 +537,8 @@ Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id const IR::Value& offset, const IR::Value& offset2); Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, const IR::Value& offset, const IR::Value& offset2, Id dref); -Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset, - Id lod, Id ms); +Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, + const IR::Value& offset, Id lod, Id ms); Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod, const IR::Value& skip_mips); Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords); diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt index 16c905db9..55180f4b5 100644 --- a/src/video_core/CMakeLists.txt +++ b/src/video_core/CMakeLists.txt @@ -274,7 +274,6 @@ add_library(video_core STATIC texture_cache/image_view_info.h texture_cache/render_targets.h texture_cache/samples_helper.h - texture_cache/slot_vector.h texture_cache/texture_cache.cpp texture_cache/texture_cache.h texture_cache/texture_cache_base.h diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h index b4bf369d1..6d3d933c5 100644 --- a/src/video_core/buffer_cache/buffer_cache.h +++ b/src/video_core/buffer_cache/buffer_cache.h @@ -7,6 +7,7 @@ #include <memory> #include <numeric> +#include "common/range_sets.inc" #include "video_core/buffer_cache/buffer_cache_base.h" #include "video_core/guest_memory.h" #include "video_core/host1x/gpu_device_memory_manager.h" @@ -20,7 +21,7 @@ BufferCache<P>::BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, R : runtime{runtime_}, device_memory{device_memory_}, memory_tracker{device_memory} { // Ensure the first slot is used for the null buffer void(slot_buffers.insert(runtime, NullBufferParams{})); - common_ranges.clear(); + gpu_modified_ranges.Clear(); inline_buffer_id = NULL_BUFFER_ID; if (!runtime.CanReportMemoryUsage()) { @@ -44,6 +45,9 @@ BufferCache<P>::BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, R } template <class P> +BufferCache<P>::~BufferCache() = default; + +template <class P> void BufferCache<P>::RunGarbageCollector() { const bool aggressive_gc = total_used_memory >= critical_memory; const u64 ticks_to_destroy = aggressive_gc ? 60 : 120; @@ -96,20 +100,17 @@ void BufferCache<P>::TickFrame() { ++frame_tick; delayed_destruction_ring.Tick(); - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - for (auto& buffer : async_buffers_death_ring) { - runtime.FreeDeferredStagingBuffer(buffer); - } - async_buffers_death_ring.clear(); + for (auto& buffer : async_buffers_death_ring) { + runtime.FreeDeferredStagingBuffer(buffer); } + async_buffers_death_ring.clear(); } template <class P> void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) { if (memory_tracker.IsRegionGpuModified(device_addr, size)) { - const IntervalType subtract_interval{device_addr, device_addr + size}; - ClearDownload(subtract_interval); - common_ranges.subtract(subtract_interval); + ClearDownload(device_addr, size); + gpu_modified_ranges.Subtract(device_addr, size); } memory_tracker.MarkRegionAsCpuModified(device_addr, size); } @@ -174,11 +175,11 @@ void BufferCache<P>::DownloadMemory(DAddr device_addr, u64 size) { } template <class P> -void BufferCache<P>::ClearDownload(IntervalType subtract_interval) { - RemoveEachInOverlapCounter(async_downloads, subtract_interval, -1024); - uncommitted_ranges.subtract(subtract_interval); - for (auto& interval_set : committed_ranges) { - interval_set.subtract(subtract_interval); +void BufferCache<P>::ClearDownload(DAddr device_addr, u64 size) { + async_downloads.DeleteAll(device_addr, size); + uncommitted_gpu_modified_ranges.Subtract(device_addr, size); + for (auto& interval_set : committed_gpu_modified_ranges) { + interval_set.Subtract(device_addr, size); } } @@ -195,8 +196,7 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am return false; } - const IntervalType subtract_interval{*cpu_dest_address, *cpu_dest_address + amount}; - ClearDownload(subtract_interval); + ClearDownload(*cpu_dest_address, amount); BufferId buffer_a; BufferId buffer_b; @@ -215,21 +215,20 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am .size = amount, }}; - boost::container::small_vector<IntervalType, 4> tmp_intervals; + boost::container::small_vector<std::pair<DAddr, size_t>, 4> tmp_intervals; auto mirror = [&](DAddr base_address, DAddr base_address_end) { const u64 size = base_address_end - base_address; const DAddr diff = base_address - *cpu_src_address; const DAddr new_base_address = *cpu_dest_address + diff; - const IntervalType add_interval{new_base_address, new_base_address + size}; - tmp_intervals.push_back(add_interval); - uncommitted_ranges.add(add_interval); + tmp_intervals.push_back({new_base_address, size}); + uncommitted_gpu_modified_ranges.Add(new_base_address, size); }; - ForEachInRangeSet(common_ranges, *cpu_src_address, amount, mirror); + gpu_modified_ranges.ForEachInRange(*cpu_src_address, amount, mirror); // This subtraction in this order is important for overlapping copies. - common_ranges.subtract(subtract_interval); + gpu_modified_ranges.Subtract(*cpu_dest_address, amount); const bool has_new_downloads = tmp_intervals.size() != 0; - for (const IntervalType& add_interval : tmp_intervals) { - common_ranges.add(add_interval); + for (const auto& pair : tmp_intervals) { + gpu_modified_ranges.Add(pair.first, pair.second); } const auto& copy = copies[0]; src_buffer.MarkUsage(copy.src_offset, copy.size); @@ -257,9 +256,8 @@ bool BufferCache<P>::DMAClear(GPUVAddr dst_address, u64 amount, u32 value) { } const size_t size = amount * sizeof(u32); - const IntervalType subtract_interval{*cpu_dst_address, *cpu_dst_address + size}; - ClearDownload(subtract_interval); - common_ranges.subtract(subtract_interval); + ClearDownload(*cpu_dst_address, size); + gpu_modified_ranges.Subtract(*cpu_dst_address, size); const BufferId buffer = FindBuffer(*cpu_dst_address, static_cast<u32>(size)); Buffer& dest_buffer = slot_buffers[buffer]; @@ -300,11 +298,11 @@ std::pair<typename P::Buffer*, u32> BufferCache<P>::ObtainCPUBuffer( MarkWrittenBuffer(buffer_id, device_addr, size); break; case ObtainBufferOperation::DiscardWrite: { - DAddr device_addr_start = Common::AlignDown(device_addr, 64); - DAddr device_addr_end = Common::AlignUp(device_addr + size, 64); - IntervalType interval{device_addr_start, device_addr_end}; - ClearDownload(interval); - common_ranges.subtract(interval); + const DAddr device_addr_start = Common::AlignDown(device_addr, 64); + const DAddr device_addr_end = Common::AlignUp(device_addr + size, 64); + const size_t new_size = device_addr_end - device_addr_start; + ClearDownload(device_addr_start, new_size); + gpu_modified_ranges.Subtract(device_addr_start, new_size); break; } default: @@ -504,46 +502,40 @@ void BufferCache<P>::FlushCachedWrites() { template <class P> bool BufferCache<P>::HasUncommittedFlushes() const noexcept { - return !uncommitted_ranges.empty() || !committed_ranges.empty(); + return !uncommitted_gpu_modified_ranges.Empty() || !committed_gpu_modified_ranges.empty(); } template <class P> void BufferCache<P>::AccumulateFlushes() { - if (uncommitted_ranges.empty()) { + if (uncommitted_gpu_modified_ranges.Empty()) { return; } - committed_ranges.emplace_back(std::move(uncommitted_ranges)); + committed_gpu_modified_ranges.emplace_back(std::move(uncommitted_gpu_modified_ranges)); } template <class P> bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept { - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - return (!async_buffers.empty() && async_buffers.front().has_value()); - } else { - return false; - } + return (!async_buffers.empty() && async_buffers.front().has_value()); } template <class P> void BufferCache<P>::CommitAsyncFlushesHigh() { AccumulateFlushes(); - if (committed_ranges.empty()) { - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - async_buffers.emplace_back(std::optional<Async_Buffer>{}); - } + if (committed_gpu_modified_ranges.empty()) { + async_buffers.emplace_back(std::optional<Async_Buffer>{}); return; } MICROPROFILE_SCOPE(GPU_DownloadMemory); - auto it = committed_ranges.begin(); - while (it != committed_ranges.end()) { + auto it = committed_gpu_modified_ranges.begin(); + while (it != committed_gpu_modified_ranges.end()) { auto& current_intervals = *it; auto next_it = std::next(it); - while (next_it != committed_ranges.end()) { - for (auto& interval : *next_it) { - current_intervals.subtract(interval); - } + while (next_it != committed_gpu_modified_ranges.end()) { + next_it->ForEach([¤t_intervals](DAddr start, DAddr end) { + current_intervals.Subtract(start, end - start); + }); next_it++; } it++; @@ -552,10 +544,10 @@ void BufferCache<P>::CommitAsyncFlushesHigh() { boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> downloads; u64 total_size_bytes = 0; u64 largest_copy = 0; - for (const IntervalSet& intervals : committed_ranges) { - for (auto& interval : intervals) { - const std::size_t size = interval.upper() - interval.lower(); - const DAddr device_addr = interval.lower(); + for (const Common::RangeSet<DAddr>& range_set : committed_gpu_modified_ranges) { + range_set.ForEach([&](DAddr interval_lower, DAddr interval_upper) { + const std::size_t size = interval_upper - interval_lower; + const DAddr device_addr = interval_lower; ForEachBufferInRange(device_addr, size, [&](BufferId buffer_id, Buffer& buffer) { const DAddr buffer_start = buffer.CpuAddr(); const DAddr buffer_end = buffer_start + buffer.SizeBytes(); @@ -583,77 +575,35 @@ void BufferCache<P>::CommitAsyncFlushesHigh() { largest_copy = std::max(largest_copy, new_size); }; - ForEachInRangeSet(common_ranges, device_addr_out, range_size, add_download); + gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, + add_download); }); }); - } + }); } - committed_ranges.clear(); + committed_gpu_modified_ranges.clear(); if (downloads.empty()) { - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - async_buffers.emplace_back(std::optional<Async_Buffer>{}); - } + async_buffers.emplace_back(std::optional<Async_Buffer>{}); return; } - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true); - boost::container::small_vector<BufferCopy, 4> normalized_copies; - IntervalSet new_async_range{}; - runtime.PreCopyBarrier(); - for (auto& [copy, buffer_id] : downloads) { - copy.dst_offset += download_staging.offset; - const std::array copies{copy}; - BufferCopy second_copy{copy}; - Buffer& buffer = slot_buffers[buffer_id]; - second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset; - DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset); - const IntervalType base_interval{orig_device_addr, orig_device_addr + copy.size}; - async_downloads += std::make_pair(base_interval, 1); - buffer.MarkUsage(copy.src_offset, copy.size); - runtime.CopyBuffer(download_staging.buffer, buffer, copies, false); - normalized_copies.push_back(second_copy); - } - runtime.PostCopyBarrier(); - pending_downloads.emplace_back(std::move(normalized_copies)); - async_buffers.emplace_back(download_staging); - } else { - if (!Settings::IsGPULevelHigh()) { - committed_ranges.clear(); - uncommitted_ranges.clear(); - } else { - if constexpr (USE_MEMORY_MAPS) { - auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes); - runtime.PreCopyBarrier(); - for (auto& [copy, buffer_id] : downloads) { - // Have in mind the staging buffer offset for the copy - copy.dst_offset += download_staging.offset; - const std::array copies{copy}; - Buffer& buffer = slot_buffers[buffer_id]; - buffer.MarkUsage(copy.src_offset, copy.size); - runtime.CopyBuffer(download_staging.buffer, buffer, copies, false); - } - runtime.PostCopyBarrier(); - runtime.Finish(); - for (const auto& [copy, buffer_id] : downloads) { - const Buffer& buffer = slot_buffers[buffer_id]; - const DAddr device_addr = buffer.CpuAddr() + copy.src_offset; - // Undo the modified offset - const u64 dst_offset = copy.dst_offset - download_staging.offset; - const u8* read_mapped_memory = download_staging.mapped_span.data() + dst_offset; - device_memory.WriteBlockUnsafe(device_addr, read_mapped_memory, copy.size); - } - } else { - const std::span<u8> immediate_buffer = ImmediateBuffer(largest_copy); - for (const auto& [copy, buffer_id] : downloads) { - Buffer& buffer = slot_buffers[buffer_id]; - buffer.ImmediateDownload(copy.src_offset, - immediate_buffer.subspan(0, copy.size)); - const DAddr device_addr = buffer.CpuAddr() + copy.src_offset; - device_memory.WriteBlockUnsafe(device_addr, immediate_buffer.data(), copy.size); - } - } - } + auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true); + boost::container::small_vector<BufferCopy, 4> normalized_copies; + runtime.PreCopyBarrier(); + for (auto& [copy, buffer_id] : downloads) { + copy.dst_offset += download_staging.offset; + const std::array copies{copy}; + BufferCopy second_copy{copy}; + Buffer& buffer = slot_buffers[buffer_id]; + second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset; + const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset); + async_downloads.Add(orig_device_addr, copy.size); + buffer.MarkUsage(copy.src_offset, copy.size); + runtime.CopyBuffer(download_staging.buffer, buffer, copies, false); + normalized_copies.push_back(second_copy); } + runtime.PostCopyBarrier(); + pending_downloads.emplace_back(std::move(normalized_copies)); + async_buffers.emplace_back(download_staging); } template <class P> @@ -676,37 +626,31 @@ void BufferCache<P>::PopAsyncBuffers() { async_buffers.pop_front(); return; } - if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { - auto& downloads = pending_downloads.front(); - auto& async_buffer = async_buffers.front(); - u8* base = async_buffer->mapped_span.data(); - const size_t base_offset = async_buffer->offset; - for (const auto& copy : downloads) { - const DAddr device_addr = static_cast<DAddr>(copy.src_offset); - const u64 dst_offset = copy.dst_offset - base_offset; - const u8* read_mapped_memory = base + dst_offset; - ForEachInOverlapCounter( - async_downloads, device_addr, copy.size, [&](DAddr start, DAddr end, int count) { - device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr], - end - start); - if (count == 1) { - const IntervalType base_interval{start, end}; - common_ranges.subtract(base_interval); - } - }); - const IntervalType subtract_interval{device_addr, device_addr + copy.size}; - RemoveEachInOverlapCounter(async_downloads, subtract_interval, -1); - } - async_buffers_death_ring.emplace_back(*async_buffer); - async_buffers.pop_front(); - pending_downloads.pop_front(); + auto& downloads = pending_downloads.front(); + auto& async_buffer = async_buffers.front(); + u8* base = async_buffer->mapped_span.data(); + const size_t base_offset = async_buffer->offset; + for (const auto& copy : downloads) { + const DAddr device_addr = static_cast<DAddr>(copy.src_offset); + const u64 dst_offset = copy.dst_offset - base_offset; + const u8* read_mapped_memory = base + dst_offset; + async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) { + device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr], + end - start); + }); + async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) { + gpu_modified_ranges.Subtract(start, end - start); + }); } + async_buffers_death_ring.emplace_back(*async_buffer); + async_buffers.pop_front(); + pending_downloads.pop_front(); } template <class P> bool BufferCache<P>::IsRegionGpuModified(DAddr addr, size_t size) { bool is_dirty = false; - ForEachInRangeSet(common_ranges, addr, size, [&](DAddr, DAddr) { is_dirty = true; }); + gpu_modified_ranges.ForEachInRange(addr, size, [&](DAddr, DAddr) { is_dirty = true; }); return is_dirty; } @@ -1320,10 +1264,8 @@ void BufferCache<P>::UpdateComputeTextureBuffers() { template <class P> void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) { memory_tracker.MarkRegionAsGpuModified(device_addr, size); - - const IntervalType base_interval{device_addr, device_addr + size}; - common_ranges.add(base_interval); - uncommitted_ranges.add(base_interval); + gpu_modified_ranges.Add(device_addr, size); + uncommitted_gpu_modified_ranges.Add(device_addr, size); } template <class P> @@ -1600,9 +1542,8 @@ bool BufferCache<P>::InlineMemory(DAddr dest_address, size_t copy_size, template <class P> void BufferCache<P>::InlineMemoryImplementation(DAddr dest_address, size_t copy_size, std::span<const u8> inlined_buffer) { - const IntervalType subtract_interval{dest_address, dest_address + copy_size}; - ClearDownload(subtract_interval); - common_ranges.subtract(subtract_interval); + ClearDownload(dest_address, copy_size); + gpu_modified_ranges.Subtract(dest_address, copy_size); BufferId buffer_id = FindBuffer(dest_address, static_cast<u32>(copy_size)); auto& buffer = slot_buffers[buffer_id]; @@ -1652,12 +1593,9 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64 largest_copy = std::max(largest_copy, new_size); }; - const DAddr start_address = device_addr_out; - const DAddr end_address = start_address + range_size; - ForEachInRangeSet(common_ranges, start_address, range_size, add_download); - const IntervalType subtract_interval{start_address, end_address}; - ClearDownload(subtract_interval); - common_ranges.subtract(subtract_interval); + gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, add_download); + ClearDownload(device_addr_out, range_size); + gpu_modified_ranges.Subtract(device_addr_out, range_size); }); if (total_size_bytes == 0) { return; diff --git a/src/video_core/buffer_cache/buffer_cache_base.h b/src/video_core/buffer_cache/buffer_cache_base.h index 80dbb81e7..240e9f015 100644 --- a/src/video_core/buffer_cache/buffer_cache_base.h +++ b/src/video_core/buffer_cache/buffer_cache_base.h @@ -13,25 +13,15 @@ #include <unordered_map> #include <vector> -#include <boost/container/small_vector.hpp> -#define BOOST_NO_MT -#include <boost/pool/detail/mutex.hpp> -#undef BOOST_NO_MT -#include <boost/icl/interval.hpp> -#include <boost/icl/interval_base_set.hpp> -#include <boost/icl/interval_set.hpp> -#include <boost/icl/split_interval_map.hpp> -#include <boost/pool/pool.hpp> -#include <boost/pool/pool_alloc.hpp> -#include <boost/pool/poolfwd.hpp> - #include "common/common_types.h" #include "common/div_ceil.h" #include "common/literals.h" #include "common/lru_cache.h" #include "common/microprofile.h" +#include "common/range_sets.h" #include "common/scope_exit.h" #include "common/settings.h" +#include "common/slot_vector.h" #include "video_core/buffer_cache/buffer_base.h" #include "video_core/control/channel_state_cache.h" #include "video_core/delayed_destruction_ring.h" @@ -41,21 +31,15 @@ #include "video_core/engines/maxwell_3d.h" #include "video_core/memory_manager.h" #include "video_core/surface.h" -#include "video_core/texture_cache/slot_vector.h" #include "video_core/texture_cache/types.h" -namespace boost { -template <typename T> -class fast_pool_allocator<T, default_user_allocator_new_delete, details::pool::null_mutex, 4096, 0>; -} - namespace VideoCommon { MICROPROFILE_DECLARE(GPU_PrepareBuffers); MICROPROFILE_DECLARE(GPU_BindUploadBuffers); MICROPROFILE_DECLARE(GPU_DownloadMemory); -using BufferId = SlotId; +using BufferId = Common::SlotId; using VideoCore::Surface::PixelFormat; using namespace Common::Literals; @@ -184,7 +168,6 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf static constexpr bool NEEDS_BIND_STORAGE_INDEX = P::NEEDS_BIND_STORAGE_INDEX; static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS; static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS; - static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = P::IMPLEMENTS_ASYNC_DOWNLOADS; static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS; static constexpr s64 DEFAULT_EXPECTED_MEMORY = 512_MiB; @@ -202,34 +185,6 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf using Async_Buffer = typename P::Async_Buffer; using MemoryTracker = typename P::MemoryTracker; - using IntervalCompare = std::less<DAddr>; - using IntervalInstance = boost::icl::interval_type_default<DAddr, std::less>; - using IntervalAllocator = boost::fast_pool_allocator<DAddr>; - using IntervalSet = boost::icl::interval_set<DAddr>; - using IntervalType = typename IntervalSet::interval_type; - - template <typename Type> - struct counter_add_functor : public boost::icl::identity_based_inplace_combine<Type> { - // types - typedef counter_add_functor<Type> type; - typedef boost::icl::identity_based_inplace_combine<Type> base_type; - - // public member functions - void operator()(Type& current, const Type& added) const { - current += added; - if (current < base_type::identity_element()) { - current = base_type::identity_element(); - } - } - - // public static functions - static void version(Type&){}; - }; - - using OverlapCombine = counter_add_functor<int>; - using OverlapSection = boost::icl::inter_section<int>; - using OverlapCounter = boost::icl::split_interval_map<DAddr, int>; - struct OverlapResult { boost::container::small_vector<BufferId, 16> ids; DAddr begin; @@ -240,6 +195,8 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf public: explicit BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, Runtime& runtime_); + ~BufferCache(); + void TickFrame(); void WriteMemory(DAddr device_addr, u64 size); @@ -379,75 +336,6 @@ private: } } - template <typename Func> - void ForEachInRangeSet(IntervalSet& current_range, DAddr device_addr, u64 size, Func&& func) { - const DAddr start_address = device_addr; - const DAddr end_address = start_address + size; - const IntervalType search_interval{start_address, end_address}; - auto it = current_range.lower_bound(search_interval); - if (it == current_range.end()) { - return; - } - auto end_it = current_range.upper_bound(search_interval); - for (; it != end_it; it++) { - DAddr inter_addr_end = it->upper(); - DAddr inter_addr = it->lower(); - if (inter_addr_end > end_address) { - inter_addr_end = end_address; - } - if (inter_addr < start_address) { - inter_addr = start_address; - } - func(inter_addr, inter_addr_end); - } - } - - template <typename Func> - void ForEachInOverlapCounter(OverlapCounter& current_range, DAddr device_addr, u64 size, - Func&& func) { - const DAddr start_address = device_addr; - const DAddr end_address = start_address + size; - const IntervalType search_interval{start_address, end_address}; - auto it = current_range.lower_bound(search_interval); - if (it == current_range.end()) { - return; - } - auto end_it = current_range.upper_bound(search_interval); - for (; it != end_it; it++) { - auto& inter = it->first; - DAddr inter_addr_end = inter.upper(); - DAddr inter_addr = inter.lower(); - if (inter_addr_end > end_address) { - inter_addr_end = end_address; - } - if (inter_addr < start_address) { - inter_addr = start_address; - } - func(inter_addr, inter_addr_end, it->second); - } - } - - void RemoveEachInOverlapCounter(OverlapCounter& current_range, - const IntervalType search_interval, int subtract_value) { - bool any_removals = false; - current_range.add(std::make_pair(search_interval, subtract_value)); - do { - any_removals = false; - auto it = current_range.lower_bound(search_interval); - if (it == current_range.end()) { - return; - } - auto end_it = current_range.upper_bound(search_interval); - for (; it != end_it; it++) { - if (it->second <= 0) { - any_removals = true; - current_range.erase(it); - break; - } - } - } while (any_removals); - } - static bool IsRangeGranular(DAddr device_addr, size_t size) { return (device_addr & ~Core::DEVICE_PAGEMASK) == ((device_addr + size) & ~Core::DEVICE_PAGEMASK); @@ -552,14 +440,14 @@ private: [[nodiscard]] bool HasFastUniformBufferBound(size_t stage, u32 binding_index) const noexcept; - void ClearDownload(IntervalType subtract_interval); + void ClearDownload(DAddr base_addr, u64 size); void InlineMemoryImplementation(DAddr dest_address, size_t copy_size, std::span<const u8> inlined_buffer); Tegra::MaxwellDeviceMemoryManager& device_memory; - SlotVector<Buffer> slot_buffers; + Common::SlotVector<Buffer> slot_buffers; DelayedDestructionRing<Buffer, 8> delayed_destruction_ring; const Tegra::Engines::DrawManager::IndirectParams* current_draw_indirect{}; @@ -567,13 +455,12 @@ private: u32 last_index_count = 0; MemoryTracker memory_tracker; - IntervalSet uncommitted_ranges; - IntervalSet common_ranges; - IntervalSet cached_ranges; - std::deque<IntervalSet> committed_ranges; + Common::RangeSet<DAddr> uncommitted_gpu_modified_ranges; + Common::RangeSet<DAddr> gpu_modified_ranges; + std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges; // Async Buffers - OverlapCounter async_downloads; + Common::OverlapRangeSet<DAddr> async_downloads; std::deque<std::optional<Async_Buffer>> async_buffers; std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads; std::optional<Async_Buffer> current_buffer; diff --git a/src/video_core/query_cache.h b/src/video_core/query_cache.h index 4861b123a..e1019f228 100644 --- a/src/video_core/query_cache.h +++ b/src/video_core/query_cache.h @@ -18,12 +18,12 @@ #include "common/assert.h" #include "common/settings.h" +#include "common/slot_vector.h" #include "video_core/control/channel_state_cache.h" #include "video_core/engines/maxwell_3d.h" #include "video_core/host1x/gpu_device_memory_manager.h" #include "video_core/memory_manager.h" #include "video_core/rasterizer_interface.h" -#include "video_core/texture_cache/slot_vector.h" namespace VideoCore { enum class QueryType { @@ -37,7 +37,7 @@ constexpr std::size_t NumQueryTypes = static_cast<size_t>(QueryType::Count); namespace VideoCommon { -using AsyncJobId = SlotId; +using AsyncJobId = Common::SlotId; static constexpr AsyncJobId NULL_ASYNC_JOB_ID{0}; @@ -341,7 +341,7 @@ private: static constexpr std::uintptr_t YUZU_PAGESIZE = 4096; static constexpr unsigned YUZU_PAGEBITS = 12; - SlotVector<AsyncJob> slot_async_jobs; + Common::SlotVector<AsyncJob> slot_async_jobs; VideoCore::RasterizerInterface& rasterizer; Tegra::MaxwellDeviceMemoryManager& device_memory; diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h index af34c272b..fd471e979 100644 --- a/src/video_core/renderer_opengl/gl_buffer_cache.h +++ b/src/video_core/renderer_opengl/gl_buffer_cache.h @@ -90,7 +90,7 @@ public: void PostCopyBarrier(); void Finish(); - void TickFrame(VideoCommon::SlotVector<Buffer>&) noexcept {} + void TickFrame(Common::SlotVector<Buffer>&) noexcept {} void ClearBuffer(Buffer& dest_buffer, u32 offset, size_t size, u32 value); @@ -251,7 +251,6 @@ struct BufferCacheParams { static constexpr bool NEEDS_BIND_STORAGE_INDEX = true; static constexpr bool USE_MEMORY_MAPS = true; static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = true; - static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true; // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false; diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h index 3e54edcc2..d4165d8e4 100644 --- a/src/video_core/renderer_opengl/gl_texture_cache.h +++ b/src/video_core/renderer_opengl/gl_texture_cache.h @@ -30,13 +30,13 @@ class Image; class ImageView; class Sampler; +using Common::SlotVector; using VideoCommon::ImageId; using VideoCommon::ImageViewId; using VideoCommon::ImageViewType; using VideoCommon::NUM_RT; using VideoCommon::Region2D; using VideoCommon::RenderTargets; -using VideoCommon::SlotVector; struct FormatProperties { GLenum compatibility_class; diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp index 31001d142..e5e1e3ab6 100644 --- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp @@ -368,7 +368,7 @@ u32 BufferCacheRuntime::GetStorageBufferAlignment() const { return static_cast<u32>(device.GetStorageBufferAlignment()); } -void BufferCacheRuntime::TickFrame(VideoCommon::SlotVector<Buffer>& slot_buffers) noexcept { +void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept { for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) { it->ResetUsageTracking(); } diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.h b/src/video_core/renderer_vulkan/vk_buffer_cache.h index e273f4988..efe960258 100644 --- a/src/video_core/renderer_vulkan/vk_buffer_cache.h +++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h @@ -81,7 +81,7 @@ public: ComputePassDescriptorQueue& compute_pass_descriptor_queue, DescriptorPool& descriptor_pool); - void TickFrame(VideoCommon::SlotVector<Buffer>& slot_buffers) noexcept; + void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept; void Finish(); @@ -181,7 +181,6 @@ struct BufferCacheParams { static constexpr bool NEEDS_BIND_STORAGE_INDEX = false; static constexpr bool USE_MEMORY_MAPS = true; static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false; - static constexpr bool IMPLEMENTS_ASYNC_DOWNLOADS = true; static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true; }; diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h index 0dbde65d6..aaeb5ef93 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.h +++ b/src/video_core/renderer_vulkan/vk_texture_cache.h @@ -20,11 +20,11 @@ struct ResolutionScalingInfo; namespace Vulkan { +using Common::SlotVector; using VideoCommon::ImageId; using VideoCommon::NUM_RT; using VideoCommon::Region2D; using VideoCommon::RenderTargets; -using VideoCommon::SlotVector; using VideoCore::Surface::PixelFormat; class BlitImageHelper; diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h index e7b910121..da98a634b 100644 --- a/src/video_core/texture_cache/texture_cache_base.h +++ b/src/video_core/texture_cache/texture_cache_base.h @@ -21,6 +21,7 @@ #include "common/lru_cache.h" #include "common/polyfill_ranges.h" #include "common/scratch_buffer.h" +#include "common/slot_vector.h" #include "common/thread_worker.h" #include "video_core/compatible_formats.h" #include "video_core/control/channel_state_cache.h" @@ -32,7 +33,6 @@ #include "video_core/texture_cache/image_info.h" #include "video_core/texture_cache/image_view_base.h" #include "video_core/texture_cache/render_targets.h" -#include "video_core/texture_cache/slot_vector.h" #include "video_core/texture_cache/types.h" #include "video_core/textures/texture.h" @@ -451,16 +451,16 @@ private: struct PendingDownload { bool is_swizzle; size_t async_buffer_id; - SlotId object_id; + Common::SlotId object_id; }; - SlotVector<Image> slot_images; - SlotVector<ImageMapView> slot_map_views; - SlotVector<ImageView> slot_image_views; - SlotVector<ImageAlloc> slot_image_allocs; - SlotVector<Sampler> slot_samplers; - SlotVector<Framebuffer> slot_framebuffers; - SlotVector<BufferDownload> slot_buffer_downloads; + Common::SlotVector<Image> slot_images; + Common::SlotVector<ImageMapView> slot_map_views; + Common::SlotVector<ImageView> slot_image_views; + Common::SlotVector<ImageAlloc> slot_image_allocs; + Common::SlotVector<Sampler> slot_samplers; + Common::SlotVector<Framebuffer> slot_framebuffers; + Common::SlotVector<BufferDownload> slot_buffer_downloads; // TODO: This data structure is not optimal and it should be reworked diff --git a/src/video_core/texture_cache/types.h b/src/video_core/texture_cache/types.h index 0453456b4..07c304386 100644 --- a/src/video_core/texture_cache/types.h +++ b/src/video_core/texture_cache/types.h @@ -5,21 +5,21 @@ #include "common/common_funcs.h" #include "common/common_types.h" -#include "video_core/texture_cache/slot_vector.h" +#include "common/slot_vector.h" namespace VideoCommon { constexpr size_t NUM_RT = 8; constexpr size_t MAX_MIP_LEVELS = 14; -constexpr SlotId CORRUPT_ID{0xfffffffe}; +constexpr Common::SlotId CORRUPT_ID{0xfffffffe}; -using ImageId = SlotId; -using ImageMapId = SlotId; -using ImageViewId = SlotId; -using ImageAllocId = SlotId; -using SamplerId = SlotId; -using FramebufferId = SlotId; +using ImageId = Common::SlotId; +using ImageMapId = Common::SlotId; +using ImageViewId = Common::SlotId; +using ImageAllocId = Common::SlotId; +using SamplerId = Common::SlotId; +using FramebufferId = Common::SlotId; /// Fake image ID for null image views constexpr ImageId NULL_IMAGE_ID{0}; diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp index dff380cca..fdf3ac846 100644 --- a/src/web_service/web_backend.cpp +++ b/src/web_service/web_backend.cpp @@ -32,9 +32,14 @@ struct Client::Impl { Impl(std::string host_, std::string username_, std::string token_) : host{std::move(host_)}, username{std::move(username_)}, token{std::move(token_)} { std::scoped_lock lock{jwt_cache.mutex}; - if (username == jwt_cache.username && token == jwt_cache.token) { + if (this->username == jwt_cache.username && this->token == jwt_cache.token) { jwt = jwt_cache.jwt; } + + // Normalize host expression + if (!this->host.empty() && this->host.back() == '/') { + static_cast<void>(this->host.pop_back()); + } } /// A generic function handles POST, GET and DELETE request together @@ -71,18 +76,16 @@ struct Client::Impl { const std::string& jwt_ = "", const std::string& username_ = "", const std::string& token_ = "") { if (cli == nullptr) { - cli = std::make_unique<httplib::Client>(host); + cli = std::make_unique<httplib::Client>(host.c_str()); + cli->set_connection_timeout(TIMEOUT_SECONDS); + cli->set_read_timeout(TIMEOUT_SECONDS); + cli->set_write_timeout(TIMEOUT_SECONDS); } - if (!cli->is_valid()) { - LOG_ERROR(WebService, "Client is invalid, skipping request!"); - return {}; + LOG_ERROR(WebService, "Invalid URL {}", host + path); + return WebResult{WebResult::Code::InvalidURL, "Invalid URL", ""}; } - cli->set_connection_timeout(TIMEOUT_SECONDS); - cli->set_read_timeout(TIMEOUT_SECONDS); - cli->set_write_timeout(TIMEOUT_SECONDS); - httplib::Headers params; if (!jwt_.empty()) { params = { @@ -107,15 +110,15 @@ struct Client::Impl { request.headers = params; request.body = data; - httplib::Response response; - httplib::Error error; + httplib::Result result = cli->send(request); - if (!cli->send(request, response, error)) { - LOG_ERROR(WebService, "{} to {} returned null (httplib Error: {})", method, host + path, - httplib::to_string(error)); + if (!result) { + LOG_ERROR(WebService, "{} to {} returned null", method, host + path); return WebResult{WebResult::Code::LibError, "Null response", ""}; } + httplib::Response response = result.value(); + if (response.status >= 400) { LOG_ERROR(WebService, "{} to {} returned error status code: {}", method, host + path, response.status); diff --git a/src/yuzu/configuration/configure_hotkeys.cpp b/src/yuzu/configuration/configure_hotkeys.cpp index 3d18670ce..3f68de12d 100644 --- a/src/yuzu/configuration/configure_hotkeys.cpp +++ b/src/yuzu/configuration/configure_hotkeys.cpp @@ -45,15 +45,23 @@ ConfigureHotkeys::ConfigureHotkeys(Core::HID::HIDCore& hid_core, QWidget* parent controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1); - connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); }); + connect(timeout_timer.get(), &QTimer::timeout, [this] { + const bool is_button_pressed = pressed_buttons != Core::HID::NpadButton::None || + pressed_home_button || pressed_capture_button; + SetPollingResult(!is_button_pressed); + }); connect(poll_timer.get(), &QTimer::timeout, [this] { - const auto buttons = controller->GetNpadButtons(); - const auto home_pressed = controller->GetHomeButtons().home != 0; - const auto capture_pressed = controller->GetCaptureButtons().capture != 0; - if (home_pressed || capture_pressed) { - SetPollingResult(buttons.raw, false); - return; + pressed_buttons |= controller->GetNpadButtons().raw; + pressed_home_button |= this->controller->GetHomeButtons().home != 0; + pressed_capture_button |= this->controller->GetCaptureButtons().capture != 0; + if (pressed_buttons != Core::HID::NpadButton::None || pressed_home_button || + pressed_capture_button) { + const QString button_name = + GetButtonCombinationName(pressed_buttons, pressed_home_button, + pressed_capture_button) + + QStringLiteral("..."); + model->setData(button_model_index, button_name); } }); RetranslateUI(); @@ -154,16 +162,14 @@ void ConfigureHotkeys::ConfigureController(QModelIndex index) { const auto previous_key = model->data(index); - input_setter = [this, index, previous_key](const Core::HID::NpadButton button, - const bool cancel) { + input_setter = [this, index, previous_key](const bool cancel) { if (cancel) { model->setData(index, previous_key); return; } - const auto home_pressed = this->controller->GetHomeButtons().home != 0; - const auto capture_pressed = this->controller->GetCaptureButtons().capture != 0; + const QString button_string = - GetButtonCombinationName(button, home_pressed, capture_pressed); + GetButtonCombinationName(pressed_buttons, pressed_home_button, pressed_capture_button); const auto [key_sequence_used, used_action] = IsUsedControllerKey(button_string); @@ -177,17 +183,22 @@ void ConfigureHotkeys::ConfigureController(QModelIndex index) { } }; + button_model_index = index; + pressed_buttons = Core::HID::NpadButton::None; + pressed_home_button = false; + pressed_capture_button = false; + model->setData(index, tr("[waiting]")); timeout_timer->start(2500); // Cancel after 2.5 seconds - poll_timer->start(200); // Check for new inputs every 200ms + poll_timer->start(100); // Check for new inputs every 100ms // We need to disable configuration to be able to read npad buttons controller->DisableConfiguration(); } -void ConfigureHotkeys::SetPollingResult(Core::HID::NpadButton button, const bool cancel) { +void ConfigureHotkeys::SetPollingResult(const bool cancel) { timeout_timer->stop(); poll_timer->stop(); - (*input_setter)(button, cancel); + (*input_setter)(cancel); // Re-Enable configuration controller->EnableConfiguration(); diff --git a/src/yuzu/configuration/configure_hotkeys.h b/src/yuzu/configuration/configure_hotkeys.h index 5fd1bcbfe..20ea3b515 100644 --- a/src/yuzu/configuration/configure_hotkeys.h +++ b/src/yuzu/configuration/configure_hotkeys.h @@ -4,6 +4,7 @@ #pragma once #include <memory> +#include <QStandardItemModel> #include <QWidget> namespace Common { @@ -54,14 +55,20 @@ private: void RestoreControllerHotkey(QModelIndex index); void RestoreHotkey(QModelIndex index); + void SetPollingResult(bool cancel); + QString GetButtonCombinationName(Core::HID::NpadButton button, bool home, bool capture) const; + std::unique_ptr<Ui::ConfigureHotkeys> ui; QStandardItemModel* model; - void SetPollingResult(Core::HID::NpadButton button, bool cancel); - QString GetButtonCombinationName(Core::HID::NpadButton button, bool home, bool capture) const; + bool pressed_home_button; + bool pressed_capture_button; + QModelIndex button_model_index; + Core::HID::NpadButton pressed_buttons; + Core::HID::EmulatedController* controller; std::unique_ptr<QTimer> timeout_timer; std::unique_ptr<QTimer> poll_timer; - std::optional<std::function<void(Core::HID::NpadButton, bool)>> input_setter; + std::optional<std::function<void(bool)>> input_setter; }; diff --git a/src/yuzu/configuration/configure_ui.cpp b/src/yuzu/configuration/configure_ui.cpp index c8e871151..f3c91586c 100644 --- a/src/yuzu/configuration/configure_ui.cpp +++ b/src/yuzu/configuration/configure_ui.cpp @@ -248,82 +248,22 @@ void ConfigureUi::RetranslateUI() { } void ConfigureUi::InitializeLanguageComboBox() { - // This is a list of lexicographically sorted languages, only the available translations are - // shown to the user. - static const struct { - const QString name; - const char* id; - } languages[] = { - // clang-format off - {QStringLiteral(u"Bahasa Indonesia"), "id"}, // Indonesian - {QStringLiteral(u"Bahasa Melayu"), "ms"}, // Malay - {QStringLiteral(u"Catal\u00E0"), "ca"}, // Catalan - {QStringLiteral(u"\u010Ce\u0161tina"), "cs"}, // Czech - {QStringLiteral(u"Dansk"), "da"}, // Danish - {QStringLiteral(u"Deutsch"), "de"}, // German - {QStringLiteral(u"English"), "en"}, // English - {QStringLiteral(u"Espa\u00F1ol"), "es"}, // Spanish - {QStringLiteral(u"Fran\u00E7ais"), "fr"}, // French - {QStringLiteral(u"Hrvatski"), "hr"}, // Croatian - {QStringLiteral(u"Italiano"), "it"}, // Italian - {QStringLiteral(u"Magyar"), "hu"}, // Hungarian - {QStringLiteral(u"Nederlands"), "nl"}, // Dutch - {QStringLiteral(u"Norsk bokm\u00E5l"), "nb"}, // Norwegian - {QStringLiteral(u"Polski"), "pl"}, // Polish - {QStringLiteral(u"Portugu\u00EAs"), "pt_PT"}, // Portuguese - {QStringLiteral(u"Portugu\u00EAs (Brasil)"), "pt_BR"}, // Portuguese (Brazil) - {QStringLiteral(u"Rom\u00E2n\u0103"), "ro"}, // Romanian - {QStringLiteral(u"Srpski"), "sr"}, // Serbian - {QStringLiteral(u"Suomi"), "fi"}, // Finnish - {QStringLiteral(u"Svenska"), "sv"}, // Swedish - {QStringLiteral(u"Ti\u1EBFng Vi\u1EC7t"), "vi"}, // Vietnamese - {QStringLiteral(u"Ti\u1EBFng Vi\u1EC7t (Vi\u1EC7t Nam)"), "vi_VN"}, // Vietnamese - {QStringLiteral(u"T\u00FCrk\u00E7e"), "tr_TR"}, // Turkish - {QStringLiteral(u"\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC"), "el"}, // Greek - {QStringLiteral(u"\u0420\u0443\u0441\u0441\u043A\u0438\u0439"), "ru_RU"}, // Russian - {QStringLiteral(u"\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430"), - "uk"}, // Ukrainian - {QStringLiteral(u"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"), "ar"}, // Arabic - {QStringLiteral(u"\u0641\u0627\u0631\u0633\u06CC"), "fa"}, // Farsi - {QStringLiteral(u"\uD55C\uAD6D\uC5B4"), "ko_KR"}, // Korean - {QStringLiteral(u"\u65E5\u672C\u8A9E"), "ja_JP"}, // Japanese - {QStringLiteral(u"\u7B80\u4F53\u4E2D\u6587"), "zh_CN"}, // Simplified Chinese - {QStringLiteral(u"\u7E41\u9AD4\u4E2D\u6587"), "zh_TW"}, // Traditional Chinese - // clang-format on - }; ui->language_combobox->addItem(tr("<System>"), QString{}); - QDir languages_dir{QStringLiteral(":/languages")}; - QStringList language_files = languages_dir.entryList(); - for (const auto& lang : languages) { - if (QString::fromLatin1(lang.id) == QStringLiteral("en")) { - ui->language_combobox->addItem(lang.name, QStringLiteral("en")); - language_files.removeOne(QStringLiteral("en.qm")); - continue; - } - for (int i = 0; i < language_files.size(); ++i) { - QString locale = language_files[i]; - locale.truncate(locale.lastIndexOf(QLatin1Char{'.'})); - if (QString::fromLatin1(lang.id) == locale) { - ui->language_combobox->addItem(lang.name, locale); - language_files.removeAt(i); - break; - } - } - } - // Anything remaining will be at the bottom - for (const QString& file : language_files) { - LOG_CRITICAL(Frontend, "Unexpected Language File: {}", file.toStdString()); - QString locale = file; + ui->language_combobox->addItem(tr("English"), QStringLiteral("en")); + QDirIterator it(QStringLiteral(":/languages"), QDirIterator::NoIteratorFlags); + while (it.hasNext()) { + QString locale = it.next(); locale.truncate(locale.lastIndexOf(QLatin1Char{'.'})); - const QString language_name = QLocale::languageToString(QLocale(locale).language()); - const QString lang = QStringLiteral("%1 [%2]").arg(language_name, locale); - ui->language_combobox->addItem(lang, locale); + locale.remove(0, locale.lastIndexOf(QLatin1Char{'/'}) + 1); + const QString lang = QLocale::languageToString(QLocale(locale).language()); + const QString country = QLocale::countryToString(QLocale(locale).country()); + ui->language_combobox->addItem(QStringLiteral("%1 (%2)").arg(lang, country), locale); } // Unlike other configuration changes, interface language changes need to be reflected on the // interface immediately. This is done by passing a signal to the main window, and then // retranslating when passing back. - connect(ui->language_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, + connect(ui->language_combobox, qOverload<int>(&QComboBox::currentIndexChanged), this, &ConfigureUi::OnLanguageChanged); } diff --git a/src/yuzu/hotkeys.cpp b/src/yuzu/hotkeys.cpp index b7693ad0d..170f14684 100644 --- a/src/yuzu/hotkeys.cpp +++ b/src/yuzu/hotkeys.cpp @@ -193,8 +193,7 @@ void ControllerShortcut::ControllerUpdateEvent(Core::HID::ControllerTriggerType if (!Settings::values.controller_navigation) { return; } - if (button_sequence.npad.raw == Core::HID::NpadButton::None && - button_sequence.capture.raw == 0 && button_sequence.home.raw == 0) { + if (button_sequence.npad.raw == Core::HID::NpadButton::None) { return; } |