Android 239

README.md

@@ -1,10 +1,14 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
-| [12461](https://github.com/yuzu-emu/yuzu//pull/12461) | [`acc26667b`](https://github.com/yuzu-emu/yuzu//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12461](https://github.com/yuzu-emu/yuzu//pull/12461) | [`54eb8dcc9`](https://github.com/yuzu-emu/yuzu//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
 | [12749](https://github.com/yuzu-emu/yuzu//pull/12749) | [`aad4b0d6f`](https://github.com/yuzu-emu/yuzu//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12756](https://github.com/yuzu-emu/yuzu//pull/12756) | [`4677fd3f6`](https://github.com/yuzu-emu/yuzu//pull/12756/files) | general: applet multiprocess | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12873](https://github.com/yuzu-emu/yuzu//pull/12873) | [`7a4ea8991`](https://github.com/yuzu-emu/yuzu//pull/12873/files) | GPU: Implement channel scheduling. | [FernandoS27](https://github.com/FernandoS27/) | Yes |
-| [12975](https://github.com/yuzu-emu/yuzu//pull/12975) | [`9ce43ee67`](https://github.com/yuzu-emu/yuzu//pull/12975/files) | Texture Cache: Fix untracking on GPU remap | [FernandoS27](https://github.com/FernandoS27/) | Yes |
+| [12756](https://github.com/yuzu-emu/yuzu//pull/12756) | [`cd3de0848`](https://github.com/yuzu-emu/yuzu//pull/12756/files) | general: applet multiprocess | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12920](https://github.com/yuzu-emu/yuzu//pull/12920) | [`2600ac65c`](https://github.com/yuzu-emu/yuzu//pull/12920/files) | android: Move JNI setup and helpers to common | [t895](https://github.com/t895/) | Yes |
+| [12949](https://github.com/yuzu-emu/yuzu//pull/12949) | [`5a64a77df`](https://github.com/yuzu-emu/yuzu//pull/12949/files) | service: add os types and multi wait API | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12951](https://github.com/yuzu-emu/yuzu//pull/12951) | [`fee263c59`](https://github.com/yuzu-emu/yuzu//pull/12951/files) | ipc: additional fixes | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12955](https://github.com/yuzu-emu/yuzu//pull/12955) | [`8d2ad3d8f`](https://github.com/yuzu-emu/yuzu//pull/12955/files) | dmnt: cheat: Avoid invalidating cache on 32bit | [german77](https://github.com/german77/) | Yes |
+| [12964](https://github.com/yuzu-emu/yuzu//pull/12964) | [`af8736567`](https://github.com/yuzu-emu/yuzu//pull/12964/files) | android: Remove foreground service | [t895](https://github.com/t895/) | Yes |
+| [12968](https://github.com/yuzu-emu/yuzu//pull/12968) | [`f44183db9`](https://github.com/yuzu-emu/yuzu//pull/12968/files) | android: Thermal throttling indicator | [t895](https://github.com/t895/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

externals/CMakeLists.txt

@@ -314,10 +314,3 @@ endif()
 if (NOT TARGET SimpleIni::SimpleIni)
     add_subdirectory(simpleini)
 endif()
-
-# sse2neon
-if (ARCHITECTURE_arm64 AND NOT TARGET sse2neon)
-    add_library(sse2neon INTERFACE)
-    target_include_directories(sse2neon INTERFACE sse2neon)
-endif()
-

src/core/CMakeLists.txt

@@ -512,35 +512,10 @@ add_library(core STATIC
     hle/service/audio/hwopus.h
     hle/service/bcat/backend/backend.cpp
     hle/service/bcat/backend/backend.h
-    hle/service/bcat/news/newly_arrived_event_holder.cpp
-    hle/service/bcat/news/newly_arrived_event_holder.h
-    hle/service/bcat/news/news_data_service.cpp
-    hle/service/bcat/news/news_data_service.h
-    hle/service/bcat/news/news_database_service.cpp
-    hle/service/bcat/news/news_database_service.h
-    hle/service/bcat/news/news_service.cpp
-    hle/service/bcat/news/news_service.h
-    hle/service/bcat/news/overwrite_event_holder.cpp
-    hle/service/bcat/news/overwrite_event_holder.h
-    hle/service/bcat/news/service_creator.cpp
-    hle/service/bcat/news/service_creator.h
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
-    hle/service/bcat/bcat_result.h
-    hle/service/bcat/bcat_service.cpp
-    hle/service/bcat/bcat_service.h
-    hle/service/bcat/bcat_types.h
-    hle/service/bcat/bcat_util.h
-    hle/service/bcat/delivery_cache_directory_service.cpp
-    hle/service/bcat/delivery_cache_directory_service.h
-    hle/service/bcat/delivery_cache_file_service.cpp
-    hle/service/bcat/delivery_cache_file_service.h
-    hle/service/bcat/delivery_cache_progress_service.cpp
-    hle/service/bcat/delivery_cache_progress_service.h
-    hle/service/bcat/delivery_cache_storage_service.cpp
-    hle/service/bcat/delivery_cache_storage_service.h
-    hle/service/bcat/service_creator.cpp
-    hle/service/bcat/service_creator.h
+    hle/service/bcat/bcat_module.cpp
+    hle/service/bcat/bcat_module.h
     hle/service/bpc/bpc.cpp
     hle/service/bpc/bpc.h
     hle/service/btdrv/btdrv.cpp

src/core/file_sys/content_archive.cpp

@@ -172,10 +172,6 @@ u32 NCA::GetSDKVersion() const {
     return reader->GetSdkAddonVersion();
 }
 
-u8 NCA::GetKeyGeneration() const {
-    return reader->GetKeyGeneration();
-}
-
 bool NCA::IsUpdate() const {
     return is_update;
 }

src/core/file_sys/content_archive.h

@@ -77,7 +77,6 @@ public:
     u64 GetTitleId() const;
     RightsId GetRightsId() const;
     u32 GetSDKVersion() const;
-    u8 GetKeyGeneration() const;
     bool IsUpdate() const;
 
     VirtualFile GetRomFS() const;

src/core/file_sys/errors.h

@@ -91,7 +91,6 @@ constexpr Result ResultWriteNotPermitted{ErrorModule::FS, 6203};
 constexpr Result ResultUnsupportedSetSizeForIndirectStorage{ErrorModule::FS, 6325};
 constexpr Result ResultUnsupportedWriteForCompressedStorage{ErrorModule::FS, 6387};
 constexpr Result ResultUnsupportedOperateRangeForCompressedStorage{ErrorModule::FS, 6388};
-constexpr Result ResultPermissionDenied{ErrorModule::FS, 6400};
 constexpr Result ResultBufferAllocationFailed{ErrorModule::FS, 6705};
 
 } // namespace FileSys

src/core/hle/service/am/library_applet_creator.cpp

@@ -102,16 +102,8 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
         return {};
     }
 
-    // TODO: enable other versions of applets
-    enum : u8 {
-        Firmware1400 = 14,
-        Firmware1500 = 15,
-        Firmware1600 = 16,
-        Firmware1700 = 17,
-    };
-
     auto process = std::make_unique<Process>(system);
-    if (!process->Initialize(program_id, Firmware1400, Firmware1700)) {
+    if (!process->Initialize(program_id)) {
         // Couldn't initialize the guest process
         return {};
     }

src/core/hle/service/am/process.cpp

@@ -3,7 +3,6 @@
 
 #include "common/scope_exit.h"
 
-#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/kernel/k_process.h"
@@ -21,7 +20,7 @@ Process::~Process() {
     this->Finalize();
 }
 
-bool Process::Initialize(u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
+bool Process::Initialize(u64 program_id) {
     // First, ensure we are not holding another process.
     this->Finalize();
 
@@ -30,33 +29,21 @@ bool Process::Initialize(u64 program_id, u8 minimum_key_generation, u8 maximum_k
 
     // Attempt to load program NCA.
     const FileSys::RegisteredCache* bis_system{};
-    FileSys::VirtualFile nca_raw{};
+    FileSys::VirtualFile nca{};
 
     // Get the program NCA from built-in storage.
     bis_system = fsc.GetSystemNANDContents();
     if (bis_system) {
-        nca_raw = bis_system->GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
+        nca = bis_system->GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
     }
 
     // Ensure we retrieved a program NCA.
-    if (!nca_raw) {
+    if (!nca) {
         return false;
     }
 
-    // Ensure we have a suitable version.
-    if (minimum_key_generation > 0) {
-        FileSys::NCA nca(nca_raw);
-        if (nca.GetStatus() == Loader::ResultStatus::Success &&
-            (nca.GetKeyGeneration() < minimum_key_generation ||
-             nca.GetKeyGeneration() > maximum_key_generation)) {
-            LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id,
-                        nca.GetKeyGeneration());
-            return false;
-        }
-    }
-
     // Get the appropriate loader to parse this NCA.
-    auto app_loader = Loader::GetLoader(m_system, nca_raw, program_id, 0);
+    auto app_loader = Loader::GetLoader(m_system, nca, program_id, 0);
 
     // Ensure we have a loader which can parse the NCA.
     if (!app_loader) {

src/core/hle/service/am/process.h

@@ -21,7 +21,7 @@ public:
     explicit Process(Core::System& system);
     ~Process();
 
-    bool Initialize(u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
+    bool Initialize(u64 program_id);
     void Finalize();
 
     bool Run();

src/core/hle/service/bcat/backend/backend.cpp

@@ -33,18 +33,18 @@ void ProgressServiceBackend::SetTotalSize(u64 size) {
 }
 
 void ProgressServiceBackend::StartConnecting() {
-    impl.status = DeliveryCacheProgressStatus::Connecting;
+    impl.status = DeliveryCacheProgressImpl::Status::Connecting;
     SignalUpdate();
 }
 
 void ProgressServiceBackend::StartProcessingDataList() {
-    impl.status = DeliveryCacheProgressStatus::ProcessingDataList;
+    impl.status = DeliveryCacheProgressImpl::Status::ProcessingDataList;
     SignalUpdate();
 }
 
 void ProgressServiceBackend::StartDownloadingFile(std::string_view dir_name,
                                                   std::string_view file_name, u64 file_size) {
-    impl.status = DeliveryCacheProgressStatus::Downloading;
+    impl.status = DeliveryCacheProgressImpl::Status::Downloading;
     impl.current_downloaded_bytes = 0;
     impl.current_total_bytes = file_size;
     std::memcpy(impl.current_directory.data(), dir_name.data(),
@@ -65,7 +65,7 @@ void ProgressServiceBackend::FinishDownloadingFile() {
 }
 
 void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
-    impl.status = DeliveryCacheProgressStatus::Committing;
+    impl.status = DeliveryCacheProgressImpl::Status::Committing;
     impl.current_file.fill(0);
     impl.current_downloaded_bytes = 0;
     impl.current_total_bytes = 0;
@@ -76,7 +76,7 @@ void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
 
 void ProgressServiceBackend::FinishDownload(Result result) {
     impl.total_downloaded_bytes = impl.total_bytes;
-    impl.status = DeliveryCacheProgressStatus::Done;
+    impl.status = DeliveryCacheProgressImpl::Status::Done;
     impl.result = result;
     SignalUpdate();
 }
@@ -85,15 +85,15 @@ void ProgressServiceBackend::SignalUpdate() {
     update_event->Signal();
 }
 
-BcatBackend::BcatBackend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
+Backend::Backend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
 
-BcatBackend::~BcatBackend() = default;
+Backend::~Backend() = default;
 
-NullBcatBackend::NullBcatBackend(DirectoryGetter getter) : BcatBackend(std::move(getter)) {}
+NullBackend::NullBackend(DirectoryGetter getter) : Backend(std::move(getter)) {}
 
-NullBcatBackend::~NullBcatBackend() = default;
+NullBackend::~NullBackend() = default;
 
-bool NullBcatBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
+bool NullBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
               title.build_id);
 
@@ -101,7 +101,7 @@ bool NullBcatBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend&
     return true;
 }
 
-bool NullBcatBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
+bool NullBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
                                        ProgressServiceBackend& progress) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}, name={}", title.title_id,
               title.build_id, name);
@@ -110,18 +110,18 @@ bool NullBcatBackend::SynchronizeDirectory(TitleIDVersion title, std::string nam
     return true;
 }
 
-bool NullBcatBackend::Clear(u64 title_id) {
+bool NullBackend::Clear(u64 title_id) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
 
     return true;
 }
 
-void NullBcatBackend::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
+void NullBackend::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
               Common::HexToString(passphrase));
 }
 
-std::optional<std::vector<u8>> NullBcatBackend::GetLaunchParameter(TitleIDVersion title) {
+std::optional<std::vector<u8>> NullBackend::GetLaunchParameter(TitleIDVersion title) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
               title.build_id);
     return std::nullopt;

src/core/hle/service/bcat/backend/backend.h

@@ -10,7 +10,6 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs_types.h"
 #include "core/hle/result.h"
-#include "core/hle/service/bcat/bcat_types.h"
 #include "core/hle/service/kernel_helpers.h"
 
 namespace Core {
@@ -25,6 +24,44 @@ class KReadableEvent;
 
 namespace Service::BCAT {
 
+struct DeliveryCacheProgressImpl;
+
+using DirectoryGetter = std::function<FileSys::VirtualDir(u64)>;
+using Passphrase = std::array<u8, 0x20>;
+
+struct TitleIDVersion {
+    u64 title_id;
+    u64 build_id;
+};
+
+using DirectoryName = std::array<char, 0x20>;
+using FileName = std::array<char, 0x20>;
+
+struct DeliveryCacheProgressImpl {
+    enum class Status : s32 {
+        None = 0x0,
+        Queued = 0x1,
+        Connecting = 0x2,
+        ProcessingDataList = 0x3,
+        Downloading = 0x4,
+        Committing = 0x5,
+        Done = 0x9,
+    };
+
+    Status status;
+    Result result = ResultSuccess;
+    DirectoryName current_directory;
+    FileName current_file;
+    s64 current_downloaded_bytes; ///< Bytes downloaded on current file.
+    s64 current_total_bytes;      ///< Bytes total on current file.
+    s64 total_downloaded_bytes;   ///< Bytes downloaded on overall download.
+    s64 total_bytes;              ///< Bytes total on overall download.
+    INSERT_PADDING_BYTES(
+        0x198); ///< Appears to be unused in official code, possibly reserved for future use.
+};
+static_assert(sizeof(DeliveryCacheProgressImpl) == 0x200,
+              "DeliveryCacheProgressImpl has incorrect size.");
+
 // A class to manage the signalling to the game about BCAT download progress.
 // Some of this class is implemented in module.cpp to avoid exposing the implementation structure.
 class ProgressServiceBackend {
@@ -70,10 +107,10 @@ private:
 };
 
 // A class representing an abstract backend for BCAT functionality.
-class BcatBackend {
+class Backend {
 public:
-    explicit BcatBackend(DirectoryGetter getter);
-    virtual ~BcatBackend();
+    explicit Backend(DirectoryGetter getter);
+    virtual ~Backend();
 
     // Called when the backend is needed to synchronize the data for the game with title ID and
     // version in title. A ProgressServiceBackend object is provided to alert the application of
@@ -98,10 +135,10 @@ protected:
 };
 
 // A backend of BCAT that provides no operation.
-class NullBcatBackend : public BcatBackend {
+class NullBackend : public Backend {
 public:
-    explicit NullBcatBackend(DirectoryGetter getter);
-    ~NullBcatBackend() override;
+    explicit NullBackend(DirectoryGetter getter);
+    ~NullBackend() override;
 
     bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
     bool SynchronizeDirectory(TitleIDVersion title, std::string name,
@@ -114,7 +151,6 @@ public:
     std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) override;
 };
 
-std::unique_ptr<BcatBackend> CreateBackendFromSettings(Core::System& system,
-                                                       DirectoryGetter getter);
+std::unique_ptr<Backend> CreateBackendFromSettings(Core::System& system, DirectoryGetter getter);
 
 } // namespace Service::BCAT

src/core/hle/service/bcat/bcat.cpp

@@ -1,38 +1,24 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/hle/service/bcat/backend/backend.h"
 #include "core/hle/service/bcat/bcat.h"
-#include "core/hle/service/bcat/news/service_creator.h"
-#include "core/hle/service/bcat/service_creator.h"
-#include "core/hle/service/server_manager.h"
 
 namespace Service::BCAT {
 
-void LoopProcess(Core::System& system) {
-    auto server_manager = std::make_unique<ServerManager>(system);
-
-    server_manager->RegisterNamedService("bcat:a",
-                                         std::make_shared<IServiceCreator>(system, "bcat:a"));
-    server_manager->RegisterNamedService("bcat:m",
-                                         std::make_shared<IServiceCreator>(system, "bcat:m"));
-    server_manager->RegisterNamedService("bcat:u",
-                                         std::make_shared<IServiceCreator>(system, "bcat:u"));
-    server_manager->RegisterNamedService("bcat:s",
-                                         std::make_shared<IServiceCreator>(system, "bcat:s"));
-
-    server_manager->RegisterNamedService(
-        "news:a", std::make_shared<News::IServiceCreator>(system, 0xffffffff, "news:a"));
-    server_manager->RegisterNamedService(
-        "news:p", std::make_shared<News::IServiceCreator>(system, 0x1, "news:p"));
-    server_manager->RegisterNamedService(
-        "news:c", std::make_shared<News::IServiceCreator>(system, 0x2, "news:c"));
-    server_manager->RegisterNamedService(
-        "news:v", std::make_shared<News::IServiceCreator>(system, 0x4, "news:v"));
-    server_manager->RegisterNamedService(
-        "news:m", std::make_shared<News::IServiceCreator>(system, 0xd, "news:m"));
-
-    ServerManager::RunServer(std::move(server_manager));
+BCAT::BCAT(Core::System& system_, std::shared_ptr<Module> module_,
+           FileSystem::FileSystemController& fsc_, const char* name_)
+    : Interface(system_, std::move(module_), fsc_, name_) {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, &BCAT::CreateBcatService, "CreateBcatService"},
+        {1, &BCAT::CreateDeliveryCacheStorageService, "CreateDeliveryCacheStorageService"},
+        {2, &BCAT::CreateDeliveryCacheStorageServiceWithApplicationId, "CreateDeliveryCacheStorageServiceWithApplicationId"},
+        {3, nullptr, "CreateDeliveryCacheProgressService"},
+        {4, nullptr, "CreateDeliveryCacheProgressServiceWithApplicationId"},
+    };
+    // clang-format on
+    RegisterHandlers(functions);
 }
 
+BCAT::~BCAT() = default;
 } // namespace Service::BCAT

src/core/hle/service/bcat/bcat.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "core/hle/service/service.h"
+#include "core/hle/service/bcat/bcat_module.h"
 
 namespace Core {
 class System;
@@ -11,6 +11,11 @@ class System;
 
 namespace Service::BCAT {
 
-void LoopProcess(Core::System& system);
+class BCAT final : public Module::Interface {
+public:
+    explicit BCAT(Core::System& system_, std::shared_ptr<Module> module_,
+                  FileSystem::FileSystemController& fsc_, const char* name_);
+    ~BCAT() override;
+};
 
 } // namespace Service::BCAT

src/core/hle/service/bcat/bcat_module.cpp

@@ -0,0 +1,606 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cctype>
+#include <mbedtls/md5.h>
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/file_sys/vfs/vfs.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/service/bcat/backend/backend.h"
+#include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/bcat_module.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/server_manager.h"
+
+namespace Service::BCAT {
+
+constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::BCAT, 1};
+constexpr Result ERROR_FAILED_OPEN_ENTITY{ErrorModule::BCAT, 2};
+constexpr Result ERROR_ENTITY_ALREADY_OPEN{ErrorModule::BCAT, 6};
+constexpr Result ERROR_NO_OPEN_ENTITY{ErrorModule::BCAT, 7};
+
+// The command to clear the delivery cache just calls fs IFileSystem DeleteFile on all of the files
+// and if any of them have a non-zero result it just forwards that result. This is the FS error code
+// for permission denied, which is the closest approximation of this scenario.
+constexpr Result ERROR_FAILED_CLEAR_CACHE{ErrorModule::FS, 6400};
+
+using BCATDigest = std::array<u8, 0x10>;
+
+namespace {
+
+u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
+    u64 out{};
+    std::memcpy(&out, id.data(), sizeof(u64));
+    return out;
+}
+
+// The digest is only used to determine if a file is unique compared to others of the same name.
+// Since the algorithm isn't ever checked in game, MD5 is safe.
+BCATDigest DigestFile(const FileSys::VirtualFile& file) {
+    BCATDigest out{};
+    const auto bytes = file->ReadAllBytes();
+    mbedtls_md5_ret(bytes.data(), bytes.size(), out.data());
+    return out;
+}
+
+// For a name to be valid it must be non-empty, must have a null terminating character as the final
+// char, can only contain numbers, letters, underscores and a hyphen if directory and a period if
+// file.
+bool VerifyNameValidInternal(HLERequestContext& ctx, std::array<char, 0x20> name, char match_char) {
+    const auto null_chars = std::count(name.begin(), name.end(), 0);
+    const auto bad_chars = std::count_if(name.begin(), name.end(), [match_char](char c) {
+        return !std::isalnum(static_cast<u8>(c)) && c != '_' && c != match_char && c != '\0';
+    });
+    if (null_chars == 0x20 || null_chars == 0 || bad_chars != 0 || name[0x1F] != '\0') {
+        LOG_ERROR(Service_BCAT, "Name passed was invalid!");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ERROR_INVALID_ARGUMENT);
+        return false;
+    }
+
+    return true;
+}
+
+bool VerifyNameValidDir(HLERequestContext& ctx, DirectoryName name) {
+    return VerifyNameValidInternal(ctx, name, '-');
+}
+
+bool VerifyNameValidFile(HLERequestContext& ctx, FileName name) {
+    return VerifyNameValidInternal(ctx, name, '.');
+}
+
+} // Anonymous namespace
+
+struct DeliveryCacheDirectoryEntry {
+    FileName name;
+    u64 size;
+    BCATDigest digest;
+};
+
+class IDeliveryCacheProgressService final : public ServiceFramework<IDeliveryCacheProgressService> {
+public:
+    explicit IDeliveryCacheProgressService(Core::System& system_, Kernel::KReadableEvent& event_,
+                                           const DeliveryCacheProgressImpl& impl_)
+        : ServiceFramework{system_, "IDeliveryCacheProgressService"}, event{event_}, impl{impl_} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IDeliveryCacheProgressService::GetEvent, "GetEvent"},
+            {1, &IDeliveryCacheProgressService::GetImpl, "GetImpl"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetEvent(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(event);
+    }
+
+    void GetImpl(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        ctx.WriteBuffer(impl);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    Kernel::KReadableEvent& event;
+    const DeliveryCacheProgressImpl& impl;
+};
+
+class IBcatService final : public ServiceFramework<IBcatService> {
+public:
+    explicit IBcatService(Core::System& system_, Backend& backend_)
+        : ServiceFramework{system_, "IBcatService"}, backend{backend_},
+          progress{{
+              ProgressServiceBackend{system_, "Normal"},
+              ProgressServiceBackend{system_, "Directory"},
+          }} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {10100, &IBcatService::RequestSyncDeliveryCache, "RequestSyncDeliveryCache"},
+            {10101, &IBcatService::RequestSyncDeliveryCacheWithDirectoryName, "RequestSyncDeliveryCacheWithDirectoryName"},
+            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
+            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
+            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
+            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
+            {20301, nullptr, "RequestSuspendDeliveryTask"},
+            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
+            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
+            {20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
+            {30100, &IBcatService::SetPassphrase, "SetPassphrase"},
+            {30101, nullptr, "Unknown30101"},
+            {30102, nullptr, "Unknown30102"},
+            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
+            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
+            {30202, nullptr, "BlockDeliveryTask"},
+            {30203, nullptr, "UnblockDeliveryTask"},
+            {30210, nullptr, "SetDeliveryTaskTimer"},
+            {30300, nullptr, "RegisterSystemApplicationDeliveryTasks"},
+            {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
+            {90101, nullptr, "Unknown90101"},
+            {90200, nullptr, "GetDeliveryList"},
+            {90201, &IBcatService::ClearDeliveryCacheStorage, "ClearDeliveryCacheStorage"},
+            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
+            {90300, nullptr, "GetPushNotificationLog"},
+            {90301, nullptr, "Unknown90301"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+private:
+    enum class SyncType {
+        Normal,
+        Directory,
+        Count,
+    };
+
+    std::shared_ptr<IDeliveryCacheProgressService> CreateProgressService(SyncType type) {
+        auto& progress_backend{GetProgressBackend(type)};
+        return std::make_shared<IDeliveryCacheProgressService>(system, progress_backend.GetEvent(),
+                                                               progress_backend.GetImpl());
+    }
+
+    void RequestSyncDeliveryCache(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        backend.Synchronize({system.GetApplicationProcessProgramID(),
+                             GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+                            GetProgressBackend(SyncType::Normal));
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface(CreateProgressService(SyncType::Normal));
+    }
+
+    void RequestSyncDeliveryCacheWithDirectoryName(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto name_raw = rp.PopRaw<DirectoryName>();
+        const auto name =
+            Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
+
+        LOG_DEBUG(Service_BCAT, "called, name={}", name);
+
+        backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
+                                      GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+                                     name, GetProgressBackend(SyncType::Directory));
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface(CreateProgressService(SyncType::Directory));
+    }
+
+    void SetPassphrase(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto title_id = rp.PopRaw<u64>();
+
+        const auto passphrase_raw = ctx.ReadBuffer();
+
+        LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
+                  Common::HexToString(passphrase_raw));
+
+        if (title_id == 0) {
+            LOG_ERROR(Service_BCAT, "Invalid title ID!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ARGUMENT);
+        }
+
+        if (passphrase_raw.size() > 0x40) {
+            LOG_ERROR(Service_BCAT, "Passphrase too large!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ARGUMENT);
+            return;
+        }
+
+        Passphrase passphrase{};
+        std::memcpy(passphrase.data(), passphrase_raw.data(),
+                    std::min(passphrase.size(), passphrase_raw.size()));
+
+        backend.SetPassphrase(title_id, passphrase);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void ClearDeliveryCacheStorage(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto title_id = rp.PopRaw<u64>();
+
+        LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
+
+        if (title_id == 0) {
+            LOG_ERROR(Service_BCAT, "Invalid title ID!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ARGUMENT);
+            return;
+        }
+
+        if (!backend.Clear(title_id)) {
+            LOG_ERROR(Service_BCAT, "Could not clear the directory successfully!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_FAILED_CLEAR_CACHE);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    ProgressServiceBackend& GetProgressBackend(SyncType type) {
+        return progress.at(static_cast<size_t>(type));
+    }
+
+    const ProgressServiceBackend& GetProgressBackend(SyncType type) const {
+        return progress.at(static_cast<size_t>(type));
+    }
+
+    Backend& backend;
+    std::array<ProgressServiceBackend, static_cast<size_t>(SyncType::Count)> progress;
+};
+
+void Module::Interface::CreateBcatService(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IBcatService>(system, *backend);
+}
+
+class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
+public:
+    explicit IDeliveryCacheFileService(Core::System& system_, FileSys::VirtualDir root_)
+        : ServiceFramework{system_, "IDeliveryCacheFileService"}, root(std::move(root_)) {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IDeliveryCacheFileService::Open, "Open"},
+            {1, &IDeliveryCacheFileService::Read, "Read"},
+            {2, &IDeliveryCacheFileService::GetSize, "GetSize"},
+            {3, &IDeliveryCacheFileService::GetDigest, "GetDigest"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void Open(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto dir_name_raw = rp.PopRaw<DirectoryName>();
+        const auto file_name_raw = rp.PopRaw<FileName>();
+
+        const auto dir_name =
+            Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
+        const auto file_name =
+            Common::StringFromFixedZeroTerminatedBuffer(file_name_raw.data(), file_name_raw.size());
+
+        LOG_DEBUG(Service_BCAT, "called, dir_name={}, file_name={}", dir_name, file_name);
+
+        if (!VerifyNameValidDir(ctx, dir_name_raw) || !VerifyNameValidFile(ctx, file_name_raw))
+            return;
+
+        if (current_file != nullptr) {
+            LOG_ERROR(Service_BCAT, "A file has already been opened on this interface!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_ENTITY_ALREADY_OPEN);
+            return;
+        }
+
+        const auto dir = root->GetSubdirectory(dir_name);
+
+        if (dir == nullptr) {
+            LOG_ERROR(Service_BCAT, "The directory of name={} couldn't be opened!", dir_name);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_FAILED_OPEN_ENTITY);
+            return;
+        }
+
+        current_file = dir->GetFile(file_name);
+
+        if (current_file == nullptr) {
+            LOG_ERROR(Service_BCAT, "The file of name={} couldn't be opened!", file_name);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_FAILED_OPEN_ENTITY);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void Read(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto offset{rp.PopRaw<u64>()};
+
+        auto size = ctx.GetWriteBufferSize();
+
+        LOG_DEBUG(Service_BCAT, "called, offset={:016X}, size={:016X}", offset, size);
+
+        if (current_file == nullptr) {
+            LOG_ERROR(Service_BCAT, "There is no file currently open!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NO_OPEN_ENTITY);
+        }
+
+        size = std::min<u64>(current_file->GetSize() - offset, size);
+        const auto buffer = current_file->ReadBytes(size, offset);
+        ctx.WriteBuffer(buffer);
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push<u64>(buffer.size());
+    }
+
+    void GetSize(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        if (current_file == nullptr) {
+            LOG_ERROR(Service_BCAT, "There is no file currently open!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NO_OPEN_ENTITY);
+        }
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push<u64>(current_file->GetSize());
+    }
+
+    void GetDigest(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        if (current_file == nullptr) {
+            LOG_ERROR(Service_BCAT, "There is no file currently open!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NO_OPEN_ENTITY);
+        }
+
+        IPC::ResponseBuilder rb{ctx, 6};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(DigestFile(current_file));
+    }
+
+    FileSys::VirtualDir root;
+    FileSys::VirtualFile current_file;
+};
+
+class IDeliveryCacheDirectoryService final
+    : public ServiceFramework<IDeliveryCacheDirectoryService> {
+public:
+    explicit IDeliveryCacheDirectoryService(Core::System& system_, FileSys::VirtualDir root_)
+        : ServiceFramework{system_, "IDeliveryCacheDirectoryService"}, root(std::move(root_)) {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IDeliveryCacheDirectoryService::Open, "Open"},
+            {1, &IDeliveryCacheDirectoryService::Read, "Read"},
+            {2, &IDeliveryCacheDirectoryService::GetCount, "GetCount"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void Open(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto name_raw = rp.PopRaw<DirectoryName>();
+        const auto name =
+            Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
+
+        LOG_DEBUG(Service_BCAT, "called, name={}", name);
+
+        if (!VerifyNameValidDir(ctx, name_raw))
+            return;
+
+        if (current_dir != nullptr) {
+            LOG_ERROR(Service_BCAT, "A file has already been opened on this interface!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_ENTITY_ALREADY_OPEN);
+            return;
+        }
+
+        current_dir = root->GetSubdirectory(name);
+
+        if (current_dir == nullptr) {
+            LOG_ERROR(Service_BCAT, "Failed to open the directory name={}!", name);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_FAILED_OPEN_ENTITY);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void Read(HLERequestContext& ctx) {
+        auto write_size = ctx.GetWriteBufferNumElements<DeliveryCacheDirectoryEntry>();
+
+        LOG_DEBUG(Service_BCAT, "called, write_size={:016X}", write_size);
+
+        if (current_dir == nullptr) {
+            LOG_ERROR(Service_BCAT, "There is no open directory!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NO_OPEN_ENTITY);
+            return;
+        }
+
+        const auto files = current_dir->GetFiles();
+        write_size = std::min<u64>(write_size, files.size());
+        std::vector<DeliveryCacheDirectoryEntry> entries(write_size);
+        std::transform(
+            files.begin(), files.begin() + write_size, entries.begin(), [](const auto& file) {
+                FileName name{};
+                std::memcpy(name.data(), file->GetName().data(),
+                            std::min(file->GetName().size(), name.size()));
+                return DeliveryCacheDirectoryEntry{name, file->GetSize(), DigestFile(file)};
+            });
+
+        ctx.WriteBuffer(entries);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(static_cast<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry)));
+    }
+
+    void GetCount(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        if (current_dir == nullptr) {
+            LOG_ERROR(Service_BCAT, "There is no open directory!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NO_OPEN_ENTITY);
+            return;
+        }
+
+        const auto files = current_dir->GetFiles();
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(static_cast<u32>(files.size()));
+    }
+
+    FileSys::VirtualDir root;
+    FileSys::VirtualDir current_dir;
+};
+
+class IDeliveryCacheStorageService final : public ServiceFramework<IDeliveryCacheStorageService> {
+public:
+    explicit IDeliveryCacheStorageService(Core::System& system_, FileSys::VirtualDir root_)
+        : ServiceFramework{system_, "IDeliveryCacheStorageService"}, root(std::move(root_)) {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IDeliveryCacheStorageService::CreateFileService, "CreateFileService"},
+            {1, &IDeliveryCacheStorageService::CreateDirectoryService, "CreateDirectoryService"},
+            {10, &IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory, "EnumerateDeliveryCacheDirectory"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+
+        for (const auto& subdir : root->GetSubdirectories()) {
+            DirectoryName name{};
+            std::memcpy(name.data(), subdir->GetName().data(),
+                        std::min(sizeof(DirectoryName) - 1, subdir->GetName().size()));
+            entries.push_back(name);
+        }
+    }
+
+private:
+    void CreateFileService(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<IDeliveryCacheFileService>(system, root);
+    }
+
+    void CreateDirectoryService(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BCAT, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(ResultSuccess);
+        rb.PushIpcInterface<IDeliveryCacheDirectoryService>(system, root);
+    }
+
+    void EnumerateDeliveryCacheDirectory(HLERequestContext& ctx) {
+        auto size = ctx.GetWriteBufferNumElements<DirectoryName>();
+
+        LOG_DEBUG(Service_BCAT, "called, size={:016X}", size);
+
+        size = std::min<u64>(size, entries.size() - next_read_index);
+        ctx.WriteBuffer(entries.data() + next_read_index, size * sizeof(DirectoryName));
+        next_read_index += size;
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(static_cast<u32>(size));
+    }
+
+    FileSys::VirtualDir root;
+    std::vector<DirectoryName> entries;
+    u64 next_read_index = 0;
+};
+
+void Module::Interface::CreateDeliveryCacheStorageService(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    const auto title_id = system.GetApplicationProcessProgramID();
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
+}
+
+void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto title_id = rp.PopRaw<u64>();
+
+    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
+}
+
+std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
+                                                   DirectoryGetter getter) {
+    return std::make_unique<NullBackend>(std::move(getter));
+}
+
+Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> module_,
+                             FileSystem::FileSystemController& fsc_, const char* name)
+    : ServiceFramework{system_, name}, fsc{fsc_}, module{std::move(module_)},
+      backend{CreateBackendFromSettings(system_,
+                                        [&fsc_](u64 tid) { return fsc_.GetBCATDirectory(tid); })} {}
+
+Module::Interface::~Interface() = default;
+
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+    auto module = std::make_shared<Module>();
+
+    server_manager->RegisterNamedService(
+        "bcat:a",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a"));
+    server_manager->RegisterNamedService(
+        "bcat:m",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m"));
+    server_manager->RegisterNamedService(
+        "bcat:u",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u"));
+    server_manager->RegisterNamedService(
+        "bcat:s",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s"));
+    ServerManager::RunServer(std::move(server_manager));
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_module.h

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service {
+
+namespace FileSystem {
+class FileSystemController;
+} // namespace FileSystem
+
+namespace BCAT {
+
+class Backend;
+
+class Module final {
+public:
+    class Interface : public ServiceFramework<Interface> {
+    public:
+        explicit Interface(Core::System& system_, std::shared_ptr<Module> module_,
+                           FileSystem::FileSystemController& fsc_, const char* name);
+        ~Interface() override;
+
+        void CreateBcatService(HLERequestContext& ctx);
+        void CreateDeliveryCacheStorageService(HLERequestContext& ctx);
+        void CreateDeliveryCacheStorageServiceWithApplicationId(HLERequestContext& ctx);
+
+    protected:
+        FileSystem::FileSystemController& fsc;
+
+        std::shared_ptr<Module> module;
+        std::unique_ptr<Backend> backend;
+    };
+};
+
+void LoopProcess(Core::System& system);
+
+} // namespace BCAT
+
+} // namespace Service

src/core/hle/service/bcat/bcat_result.h

@@ -1,15 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::BCAT {
-
-constexpr Result ResultInvalidArgument{ErrorModule::BCAT, 1};
-constexpr Result ResultFailedOpenEntity{ErrorModule::BCAT, 2};
-constexpr Result ResultEntityAlreadyOpen{ErrorModule::BCAT, 6};
-constexpr Result ResultNoOpenEntry{ErrorModule::BCAT, 7};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_service.cpp

@@ -1,132 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/hex_util.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/file_sys/errors.h"
-#include "core/hle/service/bcat/backend/backend.h"
-#include "core/hle/service/bcat/bcat_result.h"
-#include "core/hle/service/bcat/bcat_service.h"
-#include "core/hle/service/bcat/bcat_util.h"
-#include "core/hle/service/bcat/delivery_cache_progress_service.h"
-#include "core/hle/service/bcat/delivery_cache_storage_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::BCAT {
-
-static u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
-    u64 out{};
-    std::memcpy(&out, id.data(), sizeof(u64));
-    return out;
-}
-
-IBcatService::IBcatService(Core::System& system_, BcatBackend& backend_)
-    : ServiceFramework{system_, "IBcatService"}, backend{backend_},
-      progress{{
-          ProgressServiceBackend{system_, "Normal"},
-          ProgressServiceBackend{system_, "Directory"},
-      }} {
-    // clang-format off
-        static const FunctionInfo functions[] = {
-            {10100, D<&IBcatService::RequestSyncDeliveryCache>, "RequestSyncDeliveryCache"},
-            {10101, D<&IBcatService::RequestSyncDeliveryCacheWithDirectoryName>, "RequestSyncDeliveryCacheWithDirectoryName"},
-            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
-            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
-            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
-            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
-            {20301, nullptr, "RequestSuspendDeliveryTask"},
-            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
-            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
-            {20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
-            {30100, D<&IBcatService::SetPassphrase>, "SetPassphrase"},
-            {30101, nullptr, "Unknown30101"},
-            {30102, nullptr, "Unknown30102"},
-            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
-            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
-            {30202, nullptr, "BlockDeliveryTask"},
-            {30203, nullptr, "UnblockDeliveryTask"},
-            {30210, nullptr, "SetDeliveryTaskTimer"},
-            {30300, D<&IBcatService::RegisterSystemApplicationDeliveryTasks>, "RegisterSystemApplicationDeliveryTasks"},
-            {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
-            {90101, nullptr, "Unknown90101"},
-            {90200, nullptr, "GetDeliveryList"},
-            {90201, D<&IBcatService::ClearDeliveryCacheStorage>, "ClearDeliveryCacheStorage"},
-            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
-            {90300, nullptr, "GetPushNotificationLog"},
-            {90301, nullptr, "Unknown90301"},
-        };
-    // clang-format on
-    RegisterHandlers(functions);
-}
-
-IBcatService::~IBcatService() = default;
-
-Result IBcatService::RequestSyncDeliveryCache(
-    OutInterface<IDeliveryCacheProgressService> out_interface) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    auto& progress_backend{GetProgressBackend(SyncType::Normal)};
-    backend.Synchronize({system.GetApplicationProcessProgramID(),
-                         GetCurrentBuildID(system.GetApplicationProcessBuildID())},
-                        GetProgressBackend(SyncType::Normal));
-
-    *out_interface = std::make_shared<IDeliveryCacheProgressService>(
-        system, progress_backend.GetEvent(), progress_backend.GetImpl());
-    R_SUCCEED();
-}
-
-Result IBcatService::RequestSyncDeliveryCacheWithDirectoryName(
-    const DirectoryName& name_raw, OutInterface<IDeliveryCacheProgressService> out_interface) {
-    const auto name = Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
-
-    LOG_DEBUG(Service_BCAT, "called, name={}", name);
-
-    auto& progress_backend{GetProgressBackend(SyncType::Directory)};
-    backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
-                                  GetCurrentBuildID(system.GetApplicationProcessBuildID())},
-                                 name, progress_backend);
-
-    *out_interface = std::make_shared<IDeliveryCacheProgressService>(
-        system, progress_backend.GetEvent(), progress_backend.GetImpl());
-    R_SUCCEED();
-}
-
-Result IBcatService::SetPassphrase(u64 application_id,
-                                   InBuffer<BufferAttr_HipcPointer> passphrase_buffer) {
-    LOG_DEBUG(Service_BCAT, "called, application_id={:016X}, passphrase={}", application_id,
-              Common::HexToString(passphrase_buffer));
-
-    R_UNLESS(application_id != 0, ResultInvalidArgument);
-    R_UNLESS(passphrase_buffer.size() <= 0x40, ResultInvalidArgument);
-
-    Passphrase passphrase{};
-    std::memcpy(passphrase.data(), passphrase_buffer.data(),
-                std::min(passphrase.size(), passphrase_buffer.size()));
-
-    backend.SetPassphrase(application_id, passphrase);
-    R_SUCCEED();
-}
-
-Result IBcatService::RegisterSystemApplicationDeliveryTasks() {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called");
-    R_SUCCEED();
-}
-
-Result IBcatService::ClearDeliveryCacheStorage(u64 application_id) {
-    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", application_id);
-
-    R_UNLESS(application_id != 0, ResultInvalidArgument);
-    R_UNLESS(backend.Clear(application_id), FileSys::ResultPermissionDenied);
-    R_SUCCEED();
-}
-
-ProgressServiceBackend& IBcatService::GetProgressBackend(SyncType type) {
-    return progress.at(static_cast<size_t>(type));
-}
-
-const ProgressServiceBackend& IBcatService::GetProgressBackend(SyncType type) const {
-    return progress.at(static_cast<size_t>(type));
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_service.h

@@ -1,45 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/bcat/backend/backend.h"
-#include "core/hle/service/bcat/bcat_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::BCAT {
-class BcatBackend;
-class IDeliveryCacheStorageService;
-class IDeliveryCacheProgressService;
-
-class IBcatService final : public ServiceFramework<IBcatService> {
-public:
-    explicit IBcatService(Core::System& system_, BcatBackend& backend_);
-    ~IBcatService() override;
-
-private:
-    Result RequestSyncDeliveryCache(OutInterface<IDeliveryCacheProgressService> out_interface);
-
-    Result RequestSyncDeliveryCacheWithDirectoryName(
-        const DirectoryName& name, OutInterface<IDeliveryCacheProgressService> out_interface);
-
-    Result SetPassphrase(u64 application_id, InBuffer<BufferAttr_HipcPointer> passphrase_buffer);
-
-    Result RegisterSystemApplicationDeliveryTasks();
-
-    Result ClearDeliveryCacheStorage(u64 application_id);
-
-private:
-    ProgressServiceBackend& GetProgressBackend(SyncType type);
-    const ProgressServiceBackend& GetProgressBackend(SyncType type) const;
-
-    BcatBackend& backend;
-    std::array<ProgressServiceBackend, static_cast<size_t>(SyncType::Count)> progress;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_types.h

@@ -1,66 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <array>
-#include <functional>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "core/file_sys/vfs/vfs_types.h"
-#include "core/hle/result.h"
-
-namespace Service::BCAT {
-
-using DirectoryName = std::array<char, 0x20>;
-using FileName = std::array<char, 0x20>;
-using BcatDigest = std::array<u8, 0x10>;
-using Passphrase = std::array<u8, 0x20>;
-using DirectoryGetter = std::function<FileSys::VirtualDir(u64)>;
-
-enum class SyncType {
-    Normal,
-    Directory,
-    Count,
-};
-
-enum class DeliveryCacheProgressStatus : s32 {
-    None = 0x0,
-    Queued = 0x1,
-    Connecting = 0x2,
-    ProcessingDataList = 0x3,
-    Downloading = 0x4,
-    Committing = 0x5,
-    Done = 0x9,
-};
-
-struct DeliveryCacheDirectoryEntry {
-    FileName name;
-    u64 size;
-    BcatDigest digest;
-};
-
-struct TitleIDVersion {
-    u64 title_id;
-    u64 build_id;
-};
-
-struct DeliveryCacheProgressImpl {
-    DeliveryCacheProgressStatus status;
-    Result result;
-    DirectoryName current_directory;
-    FileName current_file;
-    s64 current_downloaded_bytes; ///< Bytes downloaded on current file.
-    s64 current_total_bytes;      ///< Bytes total on current file.
-    s64 total_downloaded_bytes;   ///< Bytes downloaded on overall download.
-    s64 total_bytes;              ///< Bytes total on overall download.
-    INSERT_PADDING_BYTES_NOINIT(
-        0x198); ///< Appears to be unused in official code, possibly reserved for future use.
-};
-static_assert(sizeof(DeliveryCacheProgressImpl) == 0x200,
-              "DeliveryCacheProgressImpl has incorrect size.");
-static_assert(std::is_trivial_v<DeliveryCacheProgressImpl>,
-              "DeliveryCacheProgressImpl type must be trivially copyable.");
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_util.h

@@ -1,39 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <array>
-#include <cctype>
-#include <mbedtls/md5.h>
-
-#include "core/hle/service/bcat/bcat_result.h"
-#include "core/hle/service/bcat/bcat_types.h"
-
-namespace Service::BCAT {
-
-// For a name to be valid it must be non-empty, must have a null terminating character as the final
-// char, can only contain numbers, letters, underscores and a hyphen if directory and a period if
-// file.
-constexpr Result VerifyNameValidInternal(std::array<char, 0x20> name, char match_char) {
-    const auto null_chars = std::count(name.begin(), name.end(), 0);
-    const auto bad_chars = std::count_if(name.begin(), name.end(), [match_char](char c) {
-        return !std::isalnum(static_cast<u8>(c)) && c != '_' && c != match_char && c != '\0';
-    });
-    if (null_chars == 0x20 || null_chars == 0 || bad_chars != 0 || name[0x1F] != '\0') {
-        LOG_ERROR(Service_BCAT, "Name passed was invalid!");
-        return ResultInvalidArgument;
-    }
-
-    return ResultSuccess;
-}
-
-constexpr Result VerifyNameValidDir(DirectoryName name) {
-    return VerifyNameValidInternal(name, '-');
-}
-
-constexpr Result VerifyNameValidFile(FileName name) {
-    return VerifyNameValidInternal(name, '.');
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_directory_service.cpp

@@ -1,80 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "common/string_util.h"
-#include "core/file_sys/vfs/vfs_types.h"
-#include "core/hle/service/bcat/bcat_result.h"
-#include "core/hle/service/bcat/bcat_util.h"
-#include "core/hle/service/bcat/delivery_cache_directory_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::BCAT {
-
-// The digest is only used to determine if a file is unique compared to others of the same name.
-// Since the algorithm isn't ever checked in game, MD5 is safe.
-static BcatDigest DigestFile(const FileSys::VirtualFile& file) {
-    BcatDigest out{};
-    const auto bytes = file->ReadAllBytes();
-    mbedtls_md5_ret(bytes.data(), bytes.size(), out.data());
-    return out;
-}
-
-IDeliveryCacheDirectoryService::IDeliveryCacheDirectoryService(Core::System& system_,
-                                                               FileSys::VirtualDir root_)
-    : ServiceFramework{system_, "IDeliveryCacheDirectoryService"}, root(std::move(root_)) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IDeliveryCacheDirectoryService::Open>, "Open"},
-        {1, D<&IDeliveryCacheDirectoryService::Read>, "Read"},
-        {2, D<&IDeliveryCacheDirectoryService::GetCount>, "GetCount"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDeliveryCacheDirectoryService::~IDeliveryCacheDirectoryService() = default;
-
-Result IDeliveryCacheDirectoryService::Open(const DirectoryName& dir_name_raw) {
-    const auto dir_name =
-        Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
-
-    LOG_DEBUG(Service_BCAT, "called, dir_name={}", dir_name);
-
-    R_TRY(VerifyNameValidDir(dir_name_raw));
-    R_UNLESS(current_dir == nullptr, ResultEntityAlreadyOpen);
-
-    const auto dir = root->GetSubdirectory(dir_name);
-    R_UNLESS(dir != nullptr, ResultFailedOpenEntity);
-
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheDirectoryService::Read(
-    Out<s32> out_count, OutArray<DeliveryCacheDirectoryEntry, BufferAttr_HipcMapAlias> out_buffer) {
-    LOG_DEBUG(Service_BCAT, "called, write_size={:016X}", out_buffer.size());
-
-    R_UNLESS(current_dir != nullptr, ResultNoOpenEntry);
-
-    const auto files = current_dir->GetFiles();
-    *out_count = static_cast<s32>(std::min(files.size(), out_buffer.size()));
-    std::transform(files.begin(), files.begin() + *out_count, out_buffer.begin(),
-                   [](const auto& file) {
-                       FileName name{};
-                       std::memcpy(name.data(), file->GetName().data(),
-                                   std::min(file->GetName().size(), name.size()));
-                       return DeliveryCacheDirectoryEntry{name, file->GetSize(), DigestFile(file)};
-                   });
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheDirectoryService::GetCount(Out<s32> out_count) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    R_UNLESS(current_dir != nullptr, ResultNoOpenEntry);
-
-    *out_count = static_cast<s32>(current_dir->GetFiles().size());
-    R_SUCCEED();
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_directory_service.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/file_sys/vfs/vfs.h"
-#include "core/hle/service/bcat/bcat_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::BCAT {
-
-class IDeliveryCacheDirectoryService final
-    : public ServiceFramework<IDeliveryCacheDirectoryService> {
-public:
-    explicit IDeliveryCacheDirectoryService(Core::System& system_, FileSys::VirtualDir root_);
-    ~IDeliveryCacheDirectoryService() override;
-
-private:
-    Result Open(const DirectoryName& dir_name_raw);
-    Result Read(Out<s32> out_count,
-                OutArray<DeliveryCacheDirectoryEntry, BufferAttr_HipcMapAlias> out_buffer);
-    Result GetCount(Out<s32> out_count);
-
-    FileSys::VirtualDir root;
-    FileSys::VirtualDir current_dir;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_file_service.cpp

@@ -1,82 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "common/string_util.h"
-#include "core/hle/service/bcat/bcat_result.h"
-#include "core/hle/service/bcat/bcat_util.h"
-#include "core/hle/service/bcat/delivery_cache_file_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::BCAT {
-
-IDeliveryCacheFileService::IDeliveryCacheFileService(Core::System& system_,
-                                                     FileSys::VirtualDir root_)
-    : ServiceFramework{system_, "IDeliveryCacheFileService"}, root(std::move(root_)) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IDeliveryCacheFileService::Open>, "Open"},
-        {1, D<&IDeliveryCacheFileService::Read>, "Read"},
-        {2, D<&IDeliveryCacheFileService::GetSize>, "GetSize"},
-        {3, D<&IDeliveryCacheFileService::GetDigest>, "GetDigest"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDeliveryCacheFileService::~IDeliveryCacheFileService() = default;
-
-Result IDeliveryCacheFileService::Open(const DirectoryName& dir_name_raw,
-                                       const FileName& file_name_raw) {
-    const auto dir_name =
-        Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
-    const auto file_name =
-        Common::StringFromFixedZeroTerminatedBuffer(file_name_raw.data(), file_name_raw.size());
-
-    LOG_DEBUG(Service_BCAT, "called, dir_name={}, file_name={}", dir_name, file_name);
-
-    R_TRY(VerifyNameValidDir(dir_name_raw));
-    R_TRY(VerifyNameValidDir(file_name_raw));
-    R_UNLESS(current_file == nullptr, ResultEntityAlreadyOpen);
-
-    const auto dir = root->GetSubdirectory(dir_name);
-    R_UNLESS(dir != nullptr, ResultFailedOpenEntity);
-
-    current_file = dir->GetFile(file_name);
-    R_UNLESS(current_file != nullptr, ResultFailedOpenEntity);
-
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheFileService::Read(Out<u64> out_buffer_size, u64 offset,
-                                       OutBuffer<BufferAttr_HipcMapAlias> out_buffer) {
-    LOG_DEBUG(Service_BCAT, "called, offset={:016X}, size={:016X}", offset, out_buffer.size());
-
-    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
-
-    *out_buffer_size = std::min<u64>(current_file->GetSize() - offset, out_buffer.size());
-    const auto buffer = current_file->ReadBytes(*out_buffer_size, offset);
-    memcpy(out_buffer.data(), buffer.data(), buffer.size());
-
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheFileService::GetSize(Out<u64> out_size) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
-
-    *out_size = current_file->GetSize();
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheFileService::GetDigest(Out<BcatDigest> out_digest) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
-
-    //*out_digest = DigestFile(current_file);
-    R_SUCCEED();
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_file_service.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/file_sys/vfs/vfs.h"
-#include "core/hle/service/bcat/bcat_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::BCAT {
-
-class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
-public:
-    explicit IDeliveryCacheFileService(Core::System& system_, FileSys::VirtualDir root_);
-    ~IDeliveryCacheFileService() override;
-
-private:
-    Result Open(const DirectoryName& dir_name_raw, const FileName& file_name_raw);
-    Result Read(Out<u64> out_buffer_size, u64 offset,
-                OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
-    Result GetSize(Out<u64> out_size);
-    Result GetDigest(Out<BcatDigest> out_digest);
-
-    FileSys::VirtualDir root;
-    FileSys::VirtualFile current_file;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_progress_service.cpp

@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/bcat_types.h"
-#include "core/hle/service/bcat/delivery_cache_progress_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::BCAT {
-
-IDeliveryCacheProgressService::IDeliveryCacheProgressService(Core::System& system_,
-                                                             Kernel::KReadableEvent& event_,
-                                                             const DeliveryCacheProgressImpl& impl_)
-    : ServiceFramework{system_, "IDeliveryCacheProgressService"}, event{event_}, impl{impl_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IDeliveryCacheProgressService::GetEvent>, "Get"},
-        {1, D<&IDeliveryCacheProgressService::GetImpl>, "Get"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDeliveryCacheProgressService::~IDeliveryCacheProgressService() = default;
-
-Result IDeliveryCacheProgressService::GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    *out_event = &event;
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheProgressService::GetImpl(
-    OutLargeData<DeliveryCacheProgressImpl, BufferAttr_HipcPointer> out_impl) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    *out_impl = impl;
-    R_SUCCEED();
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_progress_service.h

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KEvent;
-class KReadableEvent;
-} // namespace Kernel
-
-namespace Service::BCAT {
-struct DeliveryCacheProgressImpl;
-
-class IDeliveryCacheProgressService final : public ServiceFramework<IDeliveryCacheProgressService> {
-public:
-    explicit IDeliveryCacheProgressService(Core::System& system_, Kernel::KReadableEvent& event_,
-                                           const DeliveryCacheProgressImpl& impl_);
-    ~IDeliveryCacheProgressService() override;
-
-private:
-    Result GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result GetImpl(OutLargeData<DeliveryCacheProgressImpl, BufferAttr_HipcPointer> out_impl);
-
-    Kernel::KReadableEvent& event;
-    const DeliveryCacheProgressImpl& impl;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_storage_service.cpp

@@ -1,57 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/bcat_result.h"
-#include "core/hle/service/bcat/delivery_cache_directory_service.h"
-#include "core/hle/service/bcat/delivery_cache_file_service.h"
-#include "core/hle/service/bcat/delivery_cache_storage_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::BCAT {
-
-IDeliveryCacheStorageService::IDeliveryCacheStorageService(Core::System& system_,
-                                                           FileSys::VirtualDir root_)
-    : ServiceFramework{system_, "IDeliveryCacheStorageService"}, root(std::move(root_)) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IDeliveryCacheStorageService::CreateFileService>, "CreateFileService"},
-        {1, D<&IDeliveryCacheStorageService::CreateDirectoryService>, "CreateDirectoryService"},
-        {10, D<&IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory>, "EnumerateDeliveryCacheDirectory"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDeliveryCacheStorageService::~IDeliveryCacheStorageService() = default;
-
-Result IDeliveryCacheStorageService::CreateFileService(
-    OutInterface<IDeliveryCacheFileService> out_interface) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    *out_interface = std::make_shared<IDeliveryCacheFileService>(system, root);
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheStorageService::CreateDirectoryService(
-    OutInterface<IDeliveryCacheDirectoryService> out_interface) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    *out_interface = std::make_shared<IDeliveryCacheDirectoryService>(system, root);
-    R_SUCCEED();
-}
-
-Result IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory(
-    Out<s32> out_directory_count,
-    OutArray<DirectoryName, BufferAttr_HipcMapAlias> out_directories) {
-    LOG_DEBUG(Service_BCAT, "called, size={:016X}", out_directories.size());
-
-    *out_directory_count =
-        static_cast<s32>(std::min(out_directories.size(), entries.size() - next_read_index));
-    memcpy(out_directories.data(), entries.data() + next_read_index,
-           *out_directory_count * sizeof(DirectoryName));
-    next_read_index += *out_directory_count;
-    R_SUCCEED();
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_storage_service.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/file_sys/vfs/vfs.h"
-#include "core/hle/service/bcat/bcat_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::BCAT {
-class IDeliveryCacheFileService;
-class IDeliveryCacheDirectoryService;
-
-class IDeliveryCacheStorageService final : public ServiceFramework<IDeliveryCacheStorageService> {
-public:
-    explicit IDeliveryCacheStorageService(Core::System& system_, FileSys::VirtualDir root_);
-    ~IDeliveryCacheStorageService() override;
-
-private:
-    Result CreateFileService(OutInterface<IDeliveryCacheFileService> out_interface);
-    Result CreateDirectoryService(OutInterface<IDeliveryCacheDirectoryService> out_interface);
-    Result EnumerateDeliveryCacheDirectory(
-        Out<s32> out_directory_count,
-        OutArray<DirectoryName, BufferAttr_HipcMapAlias> out_directories);
-
-    FileSys::VirtualDir root;
-    std::vector<DirectoryName> entries;
-    std::size_t next_read_index = 0;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/news/newly_arrived_event_holder.cpp

@@ -1,34 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/newly_arrived_event_holder.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::News {
-
-INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
-                                                                 system_,
-                                                                 "INewlyArrivedEventHolder"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, C<&INewlyArrivedEventHolder::Get>, "Get"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-    arrived_event = service_context.CreateEvent("INewlyArrivedEventHolder::ArrivedEvent");
-}
-
-INewlyArrivedEventHolder::~INewlyArrivedEventHolder() {
-    service_context.CloseEvent(arrived_event);
-}
-
-Result INewlyArrivedEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_INFO(Service_BCAT, "called");
-
-    *out_event = &arrived_event->GetReadableEvent();
-    R_SUCCEED();
-}
-
-} // namespace Service::News

src/core/hle/service/bcat/news/newly_arrived_event_holder.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KEvent;
-class KReadableEvent;
-} // namespace Kernel
-
-namespace Service::News {
-
-class INewlyArrivedEventHolder final : public ServiceFramework<INewlyArrivedEventHolder> {
-public:
-    explicit INewlyArrivedEventHolder(Core::System& system_);
-    ~INewlyArrivedEventHolder() override;
-
-private:
-    Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
-
-    Kernel::KEvent* arrived_event;
-    KernelHelpers::ServiceContext service_context;
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_data_service.cpp

@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/news_data_service.h"
-
-namespace Service::News {
-
-INewsDataService::INewsDataService(Core::System& system_)
-    : ServiceFramework{system_, "INewsDataService"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Open"},
-        {1, nullptr, "OpenWithNewsRecordV1"},
-        {2, nullptr, "Read"},
-        {3, nullptr, "GetSize"},
-        {1001, nullptr, "OpenWithNewsRecord"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-INewsDataService::~INewsDataService() = default;
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_data_service.h

@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::News {
-
-class INewsDataService final : public ServiceFramework<INewsDataService> {
-public:
-    explicit INewsDataService(Core::System& system_);
-    ~INewsDataService() override;
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_database_service.cpp

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/news_database_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::News {
-
-INewsDatabaseService::INewsDatabaseService(Core::System& system_)
-    : ServiceFramework{system_, "INewsDatabaseService"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetListV1"},
-        {1, C<&INewsDatabaseService::Count>, "Count"},
-        {2, nullptr, "CountWithKey"},
-        {3, nullptr, "UpdateIntegerValue"},
-        {4, nullptr, "UpdateIntegerValueWithAddition"},
-        {5, nullptr, "UpdateStringValue"},
-        {1000, nullptr, "GetList"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-INewsDatabaseService::~INewsDatabaseService() = default;
-
-Result INewsDatabaseService::Count(Out<s32> out_count,
-                                   InBuffer<BufferAttr_HipcPointer> buffer_data) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
-    *out_count = 0;
-    R_SUCCEED();
-}
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_database_service.h

@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::News {
-
-class INewsDatabaseService final : public ServiceFramework<INewsDatabaseService> {
-public:
-    explicit INewsDatabaseService(Core::System& system_);
-    ~INewsDatabaseService() override;
-
-private:
-    Result Count(Out<s32> out_count, InBuffer<BufferAttr_HipcPointer> buffer_data);
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_service.cpp

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/news_service.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::News {
-
-INewsService::INewsService(Core::System& system_) : ServiceFramework{system_, "INewsService"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {10100, nullptr, "PostLocalNews"},
-        {20100, nullptr, "SetPassphrase"},
-        {30100, C<&INewsService::GetSubscriptionStatus>, "GetSubscriptionStatus"},
-        {30101, nullptr, "GetTopicList"},
-        {30110, nullptr, "Unknown30110"},
-        {30200, nullptr, "IsSystemUpdateRequired"},
-        {30201, nullptr, "Unknown30201"},
-        {30210, nullptr, "Unknown30210"},
-        {30300, nullptr, "RequestImmediateReception"},
-        {30400, nullptr, "DecodeArchiveFile"},
-        {30500, nullptr, "Unknown30500"},
-        {30900, nullptr, "Unknown30900"},
-        {30901, nullptr, "Unknown30901"},
-        {30902, nullptr, "Unknown30902"},
-        {40100, nullptr, "SetSubscriptionStatus"},
-        {40101, nullptr, "RequestAutoSubscription"},
-        {40200, nullptr, "ClearStorage"},
-        {40201, nullptr, "ClearSubscriptionStatusAll"},
-        {90100, nullptr, "GetNewsDatabaseDump"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-INewsService::~INewsService() = default;
-
-Result INewsService::GetSubscriptionStatus(Out<u32> out_status,
-                                           InBuffer<BufferAttr_HipcPointer> buffer_data) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
-    *out_status = 0;
-    R_SUCCEED();
-}
-
-} // namespace Service::News

src/core/hle/service/bcat/news/news_service.h

@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::News {
-
-class INewsService final : public ServiceFramework<INewsService> {
-public:
-    explicit INewsService(Core::System& system_);
-    ~INewsService() override;
-
-private:
-    Result GetSubscriptionStatus(Out<u32> out_status, InBuffer<BufferAttr_HipcPointer> buffer_data);
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/news/overwrite_event_holder.cpp

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/overwrite_event_holder.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::News {
-
-IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
-                                                                          "IOverwriteEventHolder"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, C<&IOverwriteEventHolder::Get>, "Get"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-    overwrite_event = service_context.CreateEvent("IOverwriteEventHolder::OverwriteEvent");
-}
-
-IOverwriteEventHolder::~IOverwriteEventHolder() {
-    service_context.CloseEvent(overwrite_event);
-}
-
-Result IOverwriteEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_INFO(Service_BCAT, "called");
-
-    *out_event = &overwrite_event->GetReadableEvent();
-    R_SUCCEED();
-}
-
-} // namespace Service::News

src/core/hle/service/bcat/news/overwrite_event_holder.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KEvent;
-class KReadableEvent;
-} // namespace Kernel
-
-namespace Service::News {
-
-class IOverwriteEventHolder final : public ServiceFramework<IOverwriteEventHolder> {
-public:
-    explicit IOverwriteEventHolder(Core::System& system_);
-    ~IOverwriteEventHolder() override;
-
-private:
-    Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
-
-    Kernel::KEvent* overwrite_event;
-    KernelHelpers::ServiceContext service_context;
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/news/service_creator.cpp

@@ -1,64 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/bcat/news/newly_arrived_event_holder.h"
-#include "core/hle/service/bcat/news/news_data_service.h"
-#include "core/hle/service/bcat/news/news_database_service.h"
-#include "core/hle/service/bcat/news/news_service.h"
-#include "core/hle/service/bcat/news/overwrite_event_holder.h"
-#include "core/hle/service/bcat/news/service_creator.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::News {
-
-IServiceCreator::IServiceCreator(Core::System& system_, u32 permissions_, const char* name_)
-    : ServiceFramework{system_, name_}, permissions{permissions_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, C<&IServiceCreator::CreateNewsService>, "CreateNewsService"},
-        {1, C<&IServiceCreator::CreateNewlyArrivedEventHolder>, "CreateNewlyArrivedEventHolder"},
-        {2, C<&IServiceCreator::CreateNewsDataService>, "CreateNewsDataService"},
-        {3, C<&IServiceCreator::CreateNewsDatabaseService>, "CreateNewsDatabaseService"},
-        {4, C<&IServiceCreator::CreateOverwriteEventHolder>, "CreateOverwriteEventHolder"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IServiceCreator::~IServiceCreator() = default;
-
-Result IServiceCreator::CreateNewsService(OutInterface<INewsService> out_interface) {
-    LOG_INFO(Service_BCAT, "called");
-    *out_interface = std::make_shared<INewsService>(system);
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateNewlyArrivedEventHolder(
-    OutInterface<INewlyArrivedEventHolder> out_interface) {
-    LOG_INFO(Service_BCAT, "called");
-    *out_interface = std::make_shared<INewlyArrivedEventHolder>(system);
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateNewsDataService(OutInterface<INewsDataService> out_interface) {
-    LOG_INFO(Service_BCAT, "called");
-    *out_interface = std::make_shared<INewsDataService>(system);
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateNewsDatabaseService(
-    OutInterface<INewsDatabaseService> out_interface) {
-    LOG_INFO(Service_BCAT, "called");
-    *out_interface = std::make_shared<INewsDatabaseService>(system);
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateOverwriteEventHolder(
-    OutInterface<IOverwriteEventHolder> out_interface) {
-    LOG_INFO(Service_BCAT, "called");
-    *out_interface = std::make_shared<IOverwriteEventHolder>(system);
-    R_SUCCEED();
-}
-
-} // namespace Service::News

src/core/hle/service/bcat/news/service_creator.h

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::News {
-class INewsService;
-class INewlyArrivedEventHolder;
-class INewsDataService;
-class INewsDatabaseService;
-class IOverwriteEventHolder;
-
-class IServiceCreator final : public ServiceFramework<IServiceCreator> {
-public:
-    explicit IServiceCreator(Core::System& system_, u32 permissions_, const char* name_);
-    ~IServiceCreator() override;
-
-private:
-    Result CreateNewsService(OutInterface<INewsService> out_interface);
-    Result CreateNewlyArrivedEventHolder(OutInterface<INewlyArrivedEventHolder> out_interface);
-    Result CreateNewsDataService(OutInterface<INewsDataService> out_interface);
-    Result CreateNewsDatabaseService(OutInterface<INewsDatabaseService> out_interface);
-    Result CreateOverwriteEventHolder(OutInterface<IOverwriteEventHolder> out_interface);
-
-    u32 permissions;
-};
-
-} // namespace Service::News

src/core/hle/service/bcat/service_creator.cpp

@@ -1,62 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/bcat/bcat_service.h"
-#include "core/hle/service/bcat/delivery_cache_storage_service.h"
-#include "core/hle/service/bcat/service_creator.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/filesystem/filesystem.h"
-
-namespace Service::BCAT {
-
-std::unique_ptr<BcatBackend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
-                                                       DirectoryGetter getter) {
-    return std::make_unique<NullBcatBackend>(std::move(getter));
-}
-
-IServiceCreator::IServiceCreator(Core::System& system_, const char* name_)
-    : ServiceFramework{system_, name_}, fsc{system.GetFileSystemController()} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IServiceCreator::CreateBcatService>, "CreateBcatService"},
-        {1, D<&IServiceCreator::CreateDeliveryCacheStorageService>, "CreateDeliveryCacheStorageService"},
-        {2, D<&IServiceCreator::CreateDeliveryCacheStorageServiceWithApplicationId>, "CreateDeliveryCacheStorageServiceWithApplicationId"},
-        {3, nullptr, "CreateDeliveryCacheProgressService"},
-        {4, nullptr, "CreateDeliveryCacheProgressServiceWithApplicationId"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
-    backend =
-        CreateBackendFromSettings(system_, [this](u64 tid) { return fsc.GetBCATDirectory(tid); });
-}
-
-IServiceCreator::~IServiceCreator() = default;
-
-Result IServiceCreator::CreateBcatService(ClientProcessId process_id,
-                                          OutInterface<IBcatService> out_interface) {
-    LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
-    *out_interface = std::make_shared<IBcatService>(system, *backend);
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateDeliveryCacheStorageService(
-    ClientProcessId process_id, OutInterface<IDeliveryCacheStorageService> out_interface) {
-    LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
-
-    const auto title_id = system.GetApplicationProcessProgramID();
-    *out_interface =
-        std::make_shared<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
-    R_SUCCEED();
-}
-
-Result IServiceCreator::CreateDeliveryCacheStorageServiceWithApplicationId(
-    u64 application_id, OutInterface<IDeliveryCacheStorageService> out_interface) {
-    LOG_DEBUG(Service_BCAT, "called, application_id={:016X}", application_id);
-    *out_interface = std::make_shared<IDeliveryCacheStorageService>(
-        system, fsc.GetBCATDirectory(application_id));
-    R_SUCCEED();
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/service_creator.h

@@ -1,40 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
-namespace Service::BCAT {
-class BcatBackend;
-class IBcatService;
-class IDeliveryCacheStorageService;
-
-class IServiceCreator final : public ServiceFramework<IServiceCreator> {
-public:
-    explicit IServiceCreator(Core::System& system_, const char* name_);
-    ~IServiceCreator() override;
-
-private:
-    Result CreateBcatService(ClientProcessId process_id, OutInterface<IBcatService> out_interface);
-
-    Result CreateDeliveryCacheStorageService(
-        ClientProcessId process_id, OutInterface<IDeliveryCacheStorageService> out_interface);
-
-    Result CreateDeliveryCacheStorageServiceWithApplicationId(
-        u64 application_id, OutInterface<IDeliveryCacheStorageService> out_interface);
-
-    std::unique_ptr<BcatBackend> backend;
-    Service::FileSystem::FileSystemController& fsc;
-};
-
-} // namespace Service::BCAT

src/core/hle/service/hid/hid_system_server.cpp

@@ -508,8 +508,13 @@ 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(result);
+    rb.Push(ResultSuccess);
 }
 
 void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) {
@@ -519,6 +524,8 @@ 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);

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/memory.h"
 #include "video_core/control/channel_state.h"
-#include "video_core/control/scheduler.h"
 #include "video_core/engines/puller.h"
 #include "video_core/gpu.h"
 #include "video_core/host1x/host1x.h"
@@ -34,7 +33,6 @@ nvhost_gpu::nvhost_gpu(Core::System& system_, EventInterface& events_interface_,
       syncpoint_manager{core_.GetSyncpointManager()}, nvmap{core.GetNvMapFile()},
       channel_state{system.GPU().AllocateChannel()} {
     channel_syncpoint = syncpoint_manager.AllocateSyncpoint(false);
-    channel_state->syncpoint_id = channel_syncpoint;
     sm_exception_breakpoint_int_report_event =
         events_interface.CreateEvent("GpuChannelSMExceptionBreakpointInt");
     sm_exception_breakpoint_pause_report_event =
@@ -159,9 +157,6 @@ NvResult nvhost_gpu::SetErrorNotifier(IoctlSetErrorNotifier& params) {
 
 NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
     channel_priority = params.priority;
-    if (channel_state->initialized) {
-        system.GPU().Scheduler().ChangePriority(channel_state->bind_id, channel_priority);
-    }
     LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
     return NvResult::Success;
 }
@@ -319,7 +314,6 @@ NvResult nvhost_gpu::GetWaitbase(IoctlGetWaitbase& params) {
 NvResult nvhost_gpu::ChannelSetTimeout(IoctlChannelSetTimeout& params) {
     LOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
 
-    channel_state->timeout = params.timeout;
     return NvResult::Success;
 }
 
@@ -327,7 +321,6 @@ NvResult nvhost_gpu::ChannelSetTimeslice(IoctlSetTimeslice& params) {
     LOG_INFO(Service_NVDRV, "called, timeslice=0x{:X}", params.timeslice);
 
     channel_timeslice = params.timeslice;
-    channel_state->timeslice = params.timeslice;
 
     return NvResult::Success;
 }

src/core/hle/service/service.cpp

@@ -15,7 +15,7 @@
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
-#include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/bcat_module.h"
 #include "core/hle/service/bpc/bpc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/btm/btm.h"

src/core/memory/cheat_engine.cpp

@@ -11,7 +11,6 @@
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_process_page_table.h"
-#include "core/hle/kernel/svc_types.h"
 #include "core/hle/service/hid/hid_server.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/memory.h"
@@ -65,7 +64,8 @@ void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64
         return;
     }
 
-    if (system.ApplicationMemory().WriteBlock(address, data, size)) {
+    if (system.ApplicationMemory().WriteBlock(address, data, size) &&
+        system.ApplicationProcess()->Is64Bit()) {
         Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
     }
 }
@@ -88,20 +88,6 @@ u64 StandardVmCallbacks::HidKeysDown() {
     return static_cast<u64>(press_state & HID::NpadButton::All);
 }
 
-void StandardVmCallbacks::PauseProcess() {
-    if (system.ApplicationProcess()->IsSuspended()) {
-        return;
-    }
-    system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Paused);
-}
-
-void StandardVmCallbacks::ResumeProcess() {
-    if (!system.ApplicationProcess()->IsSuspended()) {
-        return;
-    }
-    system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Runnable);
-}
-
 void StandardVmCallbacks::DebugLog(u8 id, u64 value) {
     LOG_INFO(CheatEngine, "Cheat triggered DebugLog: ID '{:01X}' Value '{:016X}'", id, value);
 }

src/core/memory/cheat_engine.h

@@ -30,8 +30,6 @@ public:
     void MemoryReadUnsafe(VAddr address, void* data, u64 size) override;
     void MemoryWriteUnsafe(VAddr address, const void* data, u64 size) override;
     u64 HidKeysDown() override;
-    void PauseProcess() override;
-    void ResumeProcess() override;
     void DebugLog(u8 id, u64 value) override;
     void CommandLog(std::string_view data) override;
 

src/core/memory/dmnt_cheat_vm.cpp

@@ -1205,9 +1205,9 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 static_registers[rw_static_reg->static_idx] = registers[rw_static_reg->idx];
             }
         } else if (std::holds_alternative<PauseProcessOpcode>(cur_opcode.opcode)) {
-            callbacks->PauseProcess();
+            // TODO: Pause cheat process
         } else if (std::holds_alternative<ResumeProcessOpcode>(cur_opcode.opcode)) {
-            callbacks->ResumeProcess();
+            // TODO: Resume cheat process
         } else if (auto debug_log = std::get_if<DebugLogOpcode>(&cur_opcode.opcode)) {
             // Read value from memory.
             u64 log_value = 0;

src/core/memory/dmnt_cheat_vm.h

@@ -271,9 +271,6 @@ public:
 
         virtual u64 HidKeysDown() = 0;
 
-        virtual void PauseProcess() = 0;
-        virtual void ResumeProcess() = 0;
-
         virtual void DebugLog(u8 id, u64 value) = 0;
         virtual void CommandLog(std::string_view data) = 0;
     };

src/frontend_common/config.cpp

@@ -885,9 +885,15 @@ void Config::Reload() {
 }
 
 void Config::ClearControlPlayerValues() const {
-    // Removes the entire [Controls] section
+    // If key is an empty string, all keys in the current group() are removed.
     const char* section = Settings::TranslateCategory(Settings::Category::Controls);
-    config->Delete(section, nullptr, true);
+    CSimpleIniA::TNamesDepend keys;
+    config->GetAllKeys(section, keys);
+    for (const auto& key : keys) {
+        if (std::string(config->GetValue(section, key.pItem)).empty()) {
+            config->Delete(section, key.pItem);
+        }
+    }
 }
 
 const std::string& Config::GetConfigFilePath() const {

src/hid_core/resource_manager.cpp

@@ -314,7 +314,6 @@ 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) {
@@ -325,7 +324,6 @@ 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) {

src/hid_core/resources/npad/npad.cpp

@@ -117,10 +117,6 @@ 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);

src/hid_core/resources/npad/npad.h

@@ -58,8 +58,6 @@ 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);
 

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);
 
-    FreeAppletResourceId(aruid);
+    DestroyStyleSetUpdateEvents(aruid);
     if (aruid_index < AruidIndexMax) {
         state[aruid_index] = {};
         registration_list.flag[aruid_index] = RegistrationStatus::PendingDelete;
@@ -80,18 +80,14 @@ void NPadResource::UnregisterAppletResourceUserId(u64 aruid) {
     }
 }
 
-void NPadResource::FreeAppletResourceId(u64 aruid) {
+void NPadResource::DestroyStyleSetUpdateEvents(u64 aruid) {
     const u64 aruid_index = GetIndexFromAruid(aruid);
 
     if (aruid_index >= AruidIndexMax) {
         return;
     }
 
-    auto& aruid_data = state[aruid_index];
-
-    aruid_data.flag.is_assigned.Assign(false);
-
-    for (auto& controller_state : aruid_data.controller_state) {
+    for (auto& controller_state : state[aruid_index].controller_state) {
         if (!controller_state.is_styleset_update_event_initialized) {
             continue;
         }

src/hid_core/resources/npad/npad_resource.h

@@ -55,7 +55,7 @@ public:
     Result RegisterAppletResourceUserId(u64 aruid);
     void UnregisterAppletResourceUserId(u64 aruid);
 
-    void FreeAppletResourceId(u64 aruid);
+    void DestroyStyleSetUpdateEvents(u64 aruid);
 
     Result Activate(u64 aruid);
     Result Activate();

src/video_core/CMakeLists.txt

@@ -390,8 +390,4 @@ if (ANDROID AND ARCHITECTURE_arm64)
     target_link_libraries(video_core PRIVATE adrenotools)
 endif()
 
-if (ARCHITECTURE_arm64)
-    target_link_libraries(video_core PRIVATE sse2neon)
-endif()
-
 create_target_directory_groups(video_core)

src/video_core/control/channel_state.h

@@ -45,12 +45,6 @@ struct ChannelState {
     void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);
 
     s32 bind_id = -1;
-    /// Scheduling info
-    u32 syncpoint_id = 0xFFFF;
-    u32 priority = 0;
-    u32 timeslice = 0;
-    u32 timeout = 0;
-
     /// 3D engine
     std::unique_ptr<Engines::Maxwell3D> maxwell_3d;
     /// 2D engine

src/video_core/control/scheduler.cpp

@@ -1,245 +1,32 @@
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include <atomic>
-#include <deque>
-#include <map>
 #include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <utility>
 
 #include "common/assert.h"
-#include "common/fiber.h"
+#include "video_core/control/channel_state.h"
 #include "video_core/control/scheduler.h"
-#include "video_core/dma_pusher.h"
 #include "video_core/gpu.h"
 
 namespace Tegra::Control {
-
-struct GPFifoContext {
-    bool is_active;
-    bool is_running;
-    std::shared_ptr<Common::Fiber> context;
-    std::deque<CommandList> pending_work;
-    std::mutex guard;
-    s32 bind_id;
-    std::shared_ptr<ChannelState> info;
-    size_t yield_count;
-    size_t scheduled_count;
-};
-
-struct Scheduler::SchedulerImpl {
-    // Fifos
-    std::map<u32, std::list<size_t>, std::greater<u32>> schedule_priority_queue;
-    std::unordered_map<s32, size_t> channel_gpfifo_ids;
-    std::deque<GPFifoContext> gpfifos;
-    std::deque<size_t> free_fifos;
-
-    // Scheduling
-    std::mutex scheduling_guard;
-    std::shared_ptr<Common::Fiber> master_control;
-    bool must_reschedule{};
-    GPFifoContext* current_fifo{};
-};
-
-Scheduler::Scheduler(GPU& gpu_) : gpu{gpu_} {
-    impl = std::make_unique<SchedulerImpl>();
-}
+Scheduler::Scheduler(GPU& gpu_) : gpu{gpu_} {}
 
 Scheduler::~Scheduler() = default;
 
-void Scheduler::Init() {
-    impl->master_control = Common::Fiber::ThreadToFiber();
-}
-
-void Scheduler::Resume() {
-    while (UpdateHighestPriorityChannel()) {
-        impl->current_fifo->scheduled_count++;
-        Common::Fiber::YieldTo(impl->master_control, *impl->current_fifo->context);
-    }
-}
-
-bool Scheduler::UpdateHighestPriorityChannel() {
-    std::scoped_lock lk(impl->scheduling_guard);
-
-    // Clear needs to schedule state.
-    impl->must_reschedule = false;
-
-    // By default, we don't have a channel to schedule.
-    impl->current_fifo = nullptr;
-
-    // Check each level to see if we can schedule.
-    for (auto& level : impl->schedule_priority_queue) {
-        if (ScheduleLevel(level.second)) {
-            return true;
-        }
-    }
-
-    // Nothing to schedule.
-    return false;
-}
-
-bool Scheduler::ScheduleLevel(std::list<size_t>& queue) {
-    bool found_anything = false;
-    size_t min_schedule_count = std::numeric_limits<size_t>::max();
-    for (auto id : queue) {
-        auto& fifo = impl->gpfifos[id];
-        std::scoped_lock lk(fifo.guard);
-
-        // With no pending work and nothing running, this channel can't be scheduled.
-        if (fifo.pending_work.empty() && !fifo.is_running) {
-            continue;
-        }
-        // Prioritize channels at current priority which have been run the least.
-        if (fifo.scheduled_count > min_schedule_count) {
-            continue;
-        }
-
-        // Try not to select the same channel we just yielded from.
-        if (fifo.scheduled_count < fifo.yield_count) {
-            fifo.scheduled_count++;
-            continue;
-        }
-
-        // Update best selection.
-        min_schedule_count = fifo.scheduled_count;
-        impl->current_fifo = &fifo;
-        found_anything = true;
-    }
-    return found_anything;
-}
-
-void Scheduler::ChangePriority(s32 channel_id, u32 new_priority) {
-    std::scoped_lock lk(impl->scheduling_guard);
-    // Ensure we are tracking this channel.
-    auto fifo_it = impl->channel_gpfifo_ids.find(channel_id);
-    if (fifo_it == impl->channel_gpfifo_ids.end()) {
-        return;
-    }
-
-    // Get the fifo and update its priority.
-    const size_t fifo_id = fifo_it->second;
-    auto& fifo = impl->gpfifos[fifo_id];
-    const auto old_priority = std::exchange(fifo.info->priority, new_priority);
-
-    // Create the new level if needed.
-    impl->schedule_priority_queue.try_emplace(new_priority);
-
-    // Remove the old level and add to the new level.
-    impl->schedule_priority_queue[new_priority].push_back(fifo_id);
-    impl->schedule_priority_queue[old_priority].remove_if(
-        [fifo_id](size_t id) { return id == fifo_id; });
-}
-
-void Scheduler::Yield() {
-    ASSERT(impl->current_fifo != nullptr);
-
-    // Set yield count higher
-    impl->current_fifo->yield_count = impl->current_fifo->scheduled_count + 1;
-    Common::Fiber::YieldTo(impl->current_fifo->context, *impl->master_control);
-    gpu.BindChannel(impl->current_fifo->bind_id);
-}
-
-void Scheduler::CheckStatus() {
-    {
-        std::unique_lock lk(impl->scheduling_guard);
-        // If no reschedule is needed, don't transfer control
-        if (!impl->must_reschedule) {
-            return;
-        }
-    }
-    // Transfer control to the scheduler
-    Common::Fiber::YieldTo(impl->current_fifo->context, *impl->master_control);
-    gpu.BindChannel(impl->current_fifo->bind_id);
-}
-
 void Scheduler::Push(s32 channel, CommandList&& entries) {
-    std::scoped_lock lk(impl->scheduling_guard);
-    // Get and ensure we have this channel.
-    auto it = impl->channel_gpfifo_ids.find(channel);
-    ASSERT(it != impl->channel_gpfifo_ids.end());
-    auto gpfifo_id = it->second;
-    auto& fifo = impl->gpfifos[gpfifo_id];
-    // Add the new new work to the channel.
-    {
-        std::scoped_lock lk2(fifo.guard);
-        fifo.pending_work.emplace_back(std::move(entries));
-    }
-
-    // If the current running FIFO is null or the one being pushed to then
-    // just return
-    if (impl->current_fifo == nullptr || impl->current_fifo == &fifo) {
-        return;
-    }
-
-    // If the current fifo has higher or equal priority to the current fifo then return
-    if (impl->current_fifo->info->priority >= fifo.info->priority) {
-        return;
-    }
-    // Mark scheduler update as required.
-    impl->must_reschedule = true;
-}
-
-void Scheduler::ChannelLoop(size_t gpfifo_id, s32 channel_id) {
-    auto& fifo = impl->gpfifos[gpfifo_id];
-    auto* channel_state = fifo.info.get();
-    const auto SendToPuller = [&] {
-        std::scoped_lock lk(fifo.guard);
-        if (fifo.pending_work.empty()) {
-            // Stop if no work available.
-            fifo.is_running = false;
-            return false;
-        }
-        // Otherwise, send work to puller and mark as running.
-        CommandList&& entries = std::move(fifo.pending_work.front());
+    std::unique_lock lk(scheduling_guard);
+    auto it = channels.find(channel);
+    ASSERT(it != channels.end());
+    auto channel_state = it->second;
+    gpu.BindChannel(channel_state->bind_id);
     channel_state->dma_pusher->Push(std::move(entries));
-        fifo.pending_work.pop_front();
-        fifo.is_running = true;
-        // Succeed.
-        return true;
-    };
-    // Inform the GPU about the current channel.
-    gpu.BindChannel(channel_id);
-    while (true) {
-        while (SendToPuller()) {
-            // Execute.
     channel_state->dma_pusher->DispatchCalls();
-            // Reschedule.
-            CheckStatus();
-        }
-        // Return to host execution when all work is completed.
-        Common::Fiber::YieldTo(fifo.context, *impl->master_control);
-        // Inform the GPU about the current channel.
-        gpu.BindChannel(channel_id);
-    }
 }
 
 void Scheduler::DeclareChannel(std::shared_ptr<ChannelState> new_channel) {
     s32 channel = new_channel->bind_id;
-    std::unique_lock lk(impl->scheduling_guard);
-
-    size_t new_fifo_id;
-    if (!impl->free_fifos.empty()) {
-        new_fifo_id = impl->free_fifos.front();
-        impl->free_fifos.pop_front();
-    } else {
-        new_fifo_id = impl->gpfifos.size();
-        impl->gpfifos.emplace_back();
-    }
-    auto& new_fifo = impl->gpfifos[new_fifo_id];
-    impl->channel_gpfifo_ids[channel] = new_fifo_id;
-    new_fifo.is_active = true;
-    new_fifo.bind_id = channel;
-    new_fifo.pending_work.clear();
-    new_fifo.info = new_channel;
-    new_fifo.scheduled_count = 0;
-    new_fifo.yield_count = 0;
-    new_fifo.is_running = false;
-    impl->schedule_priority_queue.try_emplace(new_channel->priority);
-    impl->schedule_priority_queue[new_channel->priority].push_back(new_fifo_id);
-    std::function<void()> callback = std::bind(&Scheduler::ChannelLoop, this, new_fifo_id, channel);
-    new_fifo.context = std::make_shared<Common::Fiber>(std::move(callback));
+    std::unique_lock lk(scheduling_guard);
+    channels.emplace(channel, new_channel);
 }
 
 } // namespace Tegra::Control

src/video_core/control/scheduler.h

@@ -3,11 +3,10 @@
 
 #pragma once
 
-#include <list>
 #include <memory>
+#include <mutex>
+#include <unordered_map>
 
-#include "common/common_types.h"
-#include "video_core/control/channel_state.h"
 #include "video_core/dma_pusher.h"
 
 namespace Tegra {
@@ -23,27 +22,13 @@ public:
     explicit Scheduler(GPU& gpu_);
     ~Scheduler();
 
-    void Init();
-
-    void Resume();
-
-    void Yield();
-
     void Push(s32 channel, CommandList&& entries);
 
     void DeclareChannel(std::shared_ptr<ChannelState> new_channel);
 
-    void ChangePriority(s32 channel_id, u32 new_priority);
-
 private:
-    void ChannelLoop(size_t gpfifo_id, s32 channel_id);
-    bool ScheduleLevel(std::list<size_t>& queue);
-    void CheckStatus();
-    bool UpdateHighestPriorityChannel();
-
-    struct SchedulerImpl;
-    std::unique_ptr<SchedulerImpl> impl;
-
+    std::unordered_map<s32, std::shared_ptr<ChannelState>> channels;
+    std::mutex scheduling_guard;
     GPU& gpu;
 };
 

src/video_core/engines/puller.cpp

@@ -6,7 +6,6 @@
 #include "common/settings.h"
 #include "core/core.h"
 #include "video_core/control/channel_state.h"
-#include "video_core/control/scheduler.h"
 #include "video_core/dma_pusher.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/kepler_compute.h"
@@ -15,8 +14,6 @@
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/engines/puller.h"
 #include "video_core/gpu.h"
-#include "video_core/host1x/host1x.h"
-#include "video_core/host1x/syncpoint_manager.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 
@@ -63,14 +60,11 @@ void Puller::ProcessBindMethod(const MethodCall& method_call) {
 }
 
 void Puller::ProcessFenceActionMethod() {
-    auto& syncpoint_manager = gpu.Host1x().GetSyncpointManager();
     switch (regs.fence_action.op) {
     case Puller::FenceOperation::Acquire:
-        while (regs.fence_value >
-               syncpoint_manager.GetGuestSyncpointValue(regs.fence_action.syncpoint_id)) {
+        // UNIMPLEMENTED_MSG("Channel Scheduling pending.");
+        // WaitFence(regs.fence_action.syncpoint_id, regs.fence_value);
         rasterizer->ReleaseFences();
-            gpu.Scheduler().Yield();
-        }
         break;
     case Puller::FenceOperation::Increment:
         rasterizer->SignalSyncPoint(regs.fence_action.syncpoint_id);

src/video_core/gpu.cpp

@@ -387,14 +387,6 @@ std::shared_ptr<Control::ChannelState> GPU::AllocateChannel() {
     return impl->AllocateChannel();
 }
 
-Tegra::Control::Scheduler& GPU::Scheduler() {
-    return *impl->scheduler;
-}
-
-const Tegra::Control::Scheduler& GPU::Scheduler() const {
-    return *impl->scheduler;
-}
-
 void GPU::InitChannel(Control::ChannelState& to_init) {
     impl->InitChannel(to_init);
 }

src/video_core/gpu.h

@@ -124,8 +124,7 @@ class KeplerCompute;
 
 namespace Control {
 struct ChannelState;
-class Scheduler;
-} // namespace Control
+}
 
 namespace Host1x {
 class Host1x;
@@ -205,12 +204,6 @@ public:
     /// Returns a const reference to the shader notifier.
     [[nodiscard]] const VideoCore::ShaderNotify& ShaderNotify() const;
 
-    /// Returns GPU Channel Scheduler.
-    [[nodiscard]] Tegra::Control::Scheduler& Scheduler();
-
-    /// Returns GPU Channel Scheduler.
-    [[nodiscard]] const Tegra::Control::Scheduler& Scheduler() const;
-
     [[nodiscard]] u64 GetTicks() const;
 
     [[nodiscard]] bool IsAsync() const;

src/video_core/gpu_thread.cpp

@@ -34,15 +34,13 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
 
     CommandDataContainer next;
 
-    scheduler.Init();
-
     while (!stop_token.stop_requested()) {
         state.queue.PopWait(next, stop_token);
         if (stop_token.stop_requested()) {
             break;
         }
-        if (std::holds_alternative<SubmitListCommand>(next.data)) {
-            scheduler.Resume();
+        if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
+            scheduler.Push(submit_list->channel, std::move(submit_list->entries));
         } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
             system.GPU().TickWork();
         } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
@@ -69,16 +67,14 @@ ThreadManager::~ThreadManager() = default;
 
 void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
                                 Core::Frontend::GraphicsContext& context,
-                                Tegra::Control::Scheduler& scheduler_) {
+                                Tegra::Control::Scheduler& scheduler) {
     rasterizer = renderer.ReadRasterizer();
-    scheduler = &scheduler_;
     thread = std::jthread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
-                          std::ref(scheduler_), std::ref(state));
+                          std::ref(scheduler), std::ref(state));
 }
 
 void ThreadManager::SubmitList(s32 channel, Tegra::CommandList&& entries) {
-    scheduler->Push(channel, std::move(entries));
-    PushCommand(SubmitListCommand());
+    PushCommand(SubmitListCommand(channel, std::move(entries)));
 }
 
 void ThreadManager::FlushRegion(DAddr addr, u64 size) {

src/video_core/gpu_thread.h

@@ -36,7 +36,13 @@ class RendererBase;
 namespace VideoCommon::GPUThread {
 
 /// Command to signal to the GPU thread that a command list is ready for processing
-struct SubmitListCommand final {};
+struct SubmitListCommand final {
+    explicit SubmitListCommand(s32 channel_, Tegra::CommandList&& entries_)
+        : channel{channel_}, entries{std::move(entries_)} {}
+
+    s32 channel;
+    Tegra::CommandList entries;
+};
 
 /// Command to signal to the GPU thread to flush a region
 struct FlushRegionCommand final {
@@ -118,7 +124,6 @@ public:
 private:
     /// Pushes a command to be executed by the GPU thread
     u64 PushCommand(CommandData&& command_data, bool block = false);
-    Tegra::Control::Scheduler* scheduler;
 
     Core::System& system;
     const bool is_async;

src/video_core/host1x/vic.cpp

@@ -12,10 +12,7 @@
 #include <immintrin.h>
 #endif
 #elif defined(ARCHITECTURE_arm64)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wimplicit-int-conversion"
-#include <sse2neon.h>
-#pragma GCC diagnostic pop
+#include <arm_neon.h>
 #endif
 
 extern "C" {
@@ -46,6 +43,8 @@ extern "C" {
 
 #if defined(ARCHITECTURE_x86_64)
 #include "common/x64/cpu_detect.h"
+#elif defined(ARCHITECTURE_arm64)
+// Some ARM64 detect
 #endif
 
 namespace Tegra::Host1x {
@@ -245,9 +244,7 @@ void Vic::ReadProgressiveY8__V8U8_N420(const SlotStruct& slot,
         DecodeLinear();
         return;
     }
-#endif
 
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
     const auto alpha =
         _mm_slli_epi64(_mm_set1_epi64x(static_cast<s64>(slot.config.planar_alpha.Value())), 48);
 
@@ -382,6 +379,8 @@ void Vic::ReadProgressiveY8__V8U8_N420(const SlotStruct& slot,
             // clang-format on
         }
     }
+#elif defined(ARCHITECTURE_arm64)
+    DecodeLinear();
 #else
     DecodeLinear();
 #endif
@@ -625,9 +624,7 @@ void Vic::Blend(const ConfigStruct& config, const SlotStruct& slot) {
             DecodeLinear();
             return;
         }
-#endif
 
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
         // Fill the columns, e.g
         // c0 = [00 00 00 00] [r2c0 r2c0 r2c0 r2c0] [r1c0 r1c0 r1c0 r1c0] [r0c0 r0c0 r0c0 r0c0]
 
@@ -770,6 +767,8 @@ void Vic::Blend(const ConfigStruct& config, const SlotStruct& slot) {
             }
         }
         // clang-format on
+#elif defined(ARCHITECTURE_arm64)
+        DecodeLinear();
 #else
         DecodeLinear();
 #endif
@@ -821,9 +820,7 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) {
             DecodeLinear(out_luma, out_chroma);
             return;
         }
-#endif
 
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
         // luma_mask   = [00 00] [00 00] [00 00] [FF FF] [00 00] [00 00] [00 00] [FF FF]
         const auto luma_mask = _mm_set_epi16(0, 0, 0, -1, 0, 0, 0, -1);
 
@@ -950,6 +947,8 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) {
                 // clang-format on
             }
         }
+#elif defined(ARCHITECTURE_arm64)
+        DecodeLinear(out_luma, out_chroma);
 #else
         DecodeLinear(out_luma, out_chroma);
 #endif
@@ -1080,9 +1079,7 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config) {
             DecodeLinear(out_buffer);
             return;
         }
-#endif
 
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
         for (u32 y = 0; y < surface_height; y++) {
             const auto src = y * surface_stride;
             const auto dst = y * out_luma_stride;
@@ -1147,6 +1144,8 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config) {
                 // clang-format on
             }
         }
+#elif defined(ARCHITECTURE_arm64)
+        DecodeLinear(out_buffer);
 #else
         DecodeLinear(out_buffer);
 #endif

src/video_core/host_shaders/vulkan_present.vert

@@ -19,13 +19,15 @@ layout (push_constant) uniform PushConstants {
 //   Any member of a push constant block that is declared as an
 //   array must only be accessed with dynamically uniform indices.
 ScreenRectVertex GetVertex(int index) {
-    if (index < 1) {
+    switch (index) {
+    case 0:
+    default:
         return vertices[0];
-    } else if (index < 2) {
+    case 1:
         return vertices[1];
-    } else if (index < 3) {
+    case 2:
         return vertices[2];
-    } else {
+    case 3:
         return vertices[3];
     }
 }

src/video_core/texture_cache/image_info.cpp

@@ -42,7 +42,6 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
         };
     }
     rescaleable = false;
-    is_sparse = config.is_sparse != 0;
     tile_width_spacing = config.tile_width_spacing;
     if (config.texture_type != TextureType::Texture2D &&
         config.texture_type != TextureType::Texture2DNoMipmap) {

src/video_core/texture_cache/image_info.h

@@ -41,7 +41,6 @@ struct ImageInfo {
     bool downscaleable = false;
     bool forced_flushed = false;
     bool dma_downloaded = false;
-    bool is_sparse = false;
 };
 
 } // namespace VideoCommon

src/video_core/texture_cache/texture_cache.h

@@ -600,17 +600,17 @@ void TextureCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t siz
                             [&](ImageId id, Image&) { deleted_images.push_back(id); });
     for (const ImageId id : deleted_images) {
         Image& image = slot_images[id];
-        if (False(image.flags & ImageFlagBits::CpuModified)) {
+        if (True(image.flags & ImageFlagBits::CpuModified)) {
+            continue;
+        }
         image.flags |= ImageFlagBits::CpuModified;
-            if (True(image.flags & ImageFlagBits::Tracked)) {
-                UntrackImage(image, id);
-            }
-        }
-
         if (True(image.flags & ImageFlagBits::Remapped)) {
             continue;
         }
         image.flags |= ImageFlagBits::Remapped;
+        if (True(image.flags & ImageFlagBits::Tracked)) {
+            UntrackImage(image, id);
+        }
     }
 }
 
@@ -1469,8 +1469,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
     const ImageId new_image_id = slot_images.insert(runtime, new_info, gpu_addr, cpu_addr);
     Image& new_image = slot_images[new_image_id];
 
-    if (!gpu_memory->IsContinuousRange(new_image.gpu_addr, new_image.guest_size_bytes) &&
-        new_info.is_sparse) {
+    if (!gpu_memory->IsContinuousRange(new_image.gpu_addr, new_image.guest_size_bytes)) {
         new_image.flags |= ImageFlagBits::Sparse;
     }
 

src/yuzu/multiplayer/lobby_p.h

@@ -202,19 +202,12 @@ public:
         case Qt::ForegroundRole: {
             auto members = data(MemberListRole).toList();
             auto max_players = data(MaxPlayerRole).toInt();
-            const QColor room_full_color(255, 48, 32);
-            const QColor room_almost_full_color(255, 140, 32);
-            const QColor room_has_players_color(32, 160, 32);
-            const QColor room_empty_color(128, 128, 128);
-
             if (members.size() >= max_players) {
-                return QBrush(room_full_color);
+                return QBrush(QColor(255, 48, 32));
             } else if (members.size() == (max_players - 1)) {
-                return QBrush(room_almost_full_color);
+                return QBrush(QColor(255, 140, 32));
             } else if (members.size() == 0) {
-                return QBrush(room_empty_color);
-            } else if (members.size() > 0 && members.size() < (max_players - 1)) {
-                return QBrush(room_has_players_color);
+                return QBrush(QColor(128, 128, 128));
             }
             // FIXME: How to return a value that tells Qt not to modify the
             // text color from the default (as if Qt::ForegroundRole wasn't overridden)?