Merge pull request #4597 from Morph1984/mjolnir-p2

Project Mjölnir: Part 2 - Controller Applet

9 files changed, 548 insertions, 131 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index b96ca9374..d0c405ec7 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -126,6 +126,8 @@ add_library(core STATIC
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
+    frontend/applets/controller.cpp
+    frontend/applets/controller.h
     frontend/applets/error.cpp
     frontend/applets/error.h
     frontend/applets/general_frontend.cpp
@@ -244,6 +246,8 @@ add_library(core STATIC
     hle/service/am/applet_oe.h
     hle/service/am/applets/applets.cpp
     hle/service/am/applets/applets.h
+    hle/service/am/applets/controller.cpp
+    hle/service/am/applets/controller.h
     hle/service/am/applets/error.cpp
     hle/service/am/applets/error.h
     hle/service/am/applets/general_backend.cpp
diff --git a/src/core/frontend/applets/controller.cpp b/src/core/frontend/applets/controller.cpp
new file mode 100644
index 000000000..4505da758
--- /dev/null
+++ b/src/core/frontend/applets/controller.cpp
@@ -0,0 +1,81 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/frontend/applets/controller.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/hid.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Core::Frontend {
+
+ControllerApplet::~ControllerApplet() = default;
+
+DefaultControllerApplet::~DefaultControllerApplet() = default;
+
+void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
+                                                     ControllerParameters parameters) const {
+    LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
+
+    auto& npad =
+        Core::System::GetInstance()
+            .ServiceManager()
+            .GetService<Service::HID::Hid>("hid")
+            ->GetAppletResource()
+            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
+
+    auto& players = Settings::values.players;
+
+    const std::size_t min_supported_players =
+        parameters.enable_single_mode ? 1 : parameters.min_players;
+
+    // Disconnect Handheld first.
+    npad.DisconnectNPadAtIndex(8);
+
+    // Deduce the best configuration based on the input parameters.
+    for (std::size_t index = 0; index < players.size() - 2; ++index) {
+        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
+        // This makes it easy to connect the desired controllers.
+        npad.DisconnectNPadAtIndex(index);
+
+        // Only connect the minimum number of required players.
+        if (index >= min_supported_players) {
+            continue;
+        }
+
+        // Connect controllers based on the following priority list from highest to lowest priority:
+        // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
+        if (parameters.allow_pro_controller) {
+            npad.AddNewControllerAt(
+                npad.MapSettingsTypeToNPad(Settings::ControllerType::ProController), index);
+        } else if (parameters.allow_dual_joycons) {
+            npad.AddNewControllerAt(
+                npad.MapSettingsTypeToNPad(Settings::ControllerType::DualJoyconDetached), index);
+        } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
+            // Assign left joycons to even player indices and right joycons to odd player indices.
+            // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
+            // a right Joycon for Player 2 in 2 Player Assist mode.
+            if (index % 2 == 0) {
+                npad.AddNewControllerAt(
+                    npad.MapSettingsTypeToNPad(Settings::ControllerType::LeftJoycon), index);
+            } else {
+                npad.AddNewControllerAt(
+                    npad.MapSettingsTypeToNPad(Settings::ControllerType::RightJoycon), index);
+            }
+        } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
+                   !Settings::values.use_docked_mode) {
+            // We should *never* reach here under any normal circumstances.
+            npad.AddNewControllerAt(npad.MapSettingsTypeToNPad(Settings::ControllerType::Handheld),
+                                    index);
+        } else {
+            UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");
+        }
+    }
+
+    callback();
+}
+
+} // namespace Core::Frontend
diff --git a/src/core/frontend/applets/controller.h b/src/core/frontend/applets/controller.h
new file mode 100644
index 000000000..a227f15cd
--- /dev/null
+++ b/src/core/frontend/applets/controller.h
@@ -0,0 +1,48 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+
+#include "common/common_types.h"
+
+namespace Core::Frontend {
+
+using BorderColor = std::array<u8, 4>;
+using ExplainText = std::array<char, 0x81>;
+
+struct ControllerParameters {
+    s8 min_players{};
+    s8 max_players{};
+    bool keep_controllers_connected{};
+    bool enable_single_mode{};
+    bool enable_border_color{};
+    std::vector<BorderColor> border_colors{};
+    bool enable_explain_text{};
+    std::vector<ExplainText> explain_text{};
+    bool allow_pro_controller{};
+    bool allow_handheld{};
+    bool allow_dual_joycons{};
+    bool allow_left_joycon{};
+    bool allow_right_joycon{};
+};
+
+class ControllerApplet {
+public:
+    virtual ~ControllerApplet();
+
+    virtual void ReconfigureControllers(std::function<void()> callback,
+                                        ControllerParameters parameters) const = 0;
+};
+
+class DefaultControllerApplet final : public ControllerApplet {
+public:
+    ~DefaultControllerApplet() override;
+
+    void ReconfigureControllers(std::function<void()> callback,
+                                ControllerParameters parameters) const override;
+};
+
+} // namespace Core::Frontend
diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp
index c3261f3e6..4e0800f9a 100644
--- a/src/core/hle/service/am/applets/applets.cpp
+++ b/src/core/hle/service/am/applets/applets.cpp
@@ -5,6 +5,7 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
+#include "core/frontend/applets/controller.h"
 #include "core/frontend/applets/error.h"
 #include "core/frontend/applets/general_frontend.h"
 #include "core/frontend/applets/profile_select.h"
@@ -15,6 +16,7 @@
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/controller.h"
 #include "core/hle/service/am/applets/error.h"
 #include "core/hle/service/am/applets/general_backend.h"
 #include "core/hle/service/am/applets/profile_select.h"
@@ -140,14 +142,14 @@ void Applet::Initialize() {
 
 AppletFrontendSet::AppletFrontendSet() = default;
 
-AppletFrontendSet::AppletFrontendSet(ParentalControlsApplet parental_controls, ErrorApplet error,
+AppletFrontendSet::AppletFrontendSet(ControllerApplet controller, ECommerceApplet e_commerce,
+                                     ErrorApplet error, ParentalControlsApplet parental_controls,
                                      PhotoViewer photo_viewer, ProfileSelect profile_select,
-                                     SoftwareKeyboard software_keyboard, WebBrowser web_browser,
-                                     ECommerceApplet e_commerce)
-    : parental_controls{std::move(parental_controls)}, error{std::move(error)},
-      photo_viewer{std::move(photo_viewer)}, profile_select{std::move(profile_select)},
-      software_keyboard{std::move(software_keyboard)}, web_browser{std::move(web_browser)},
-      e_commerce{std::move(e_commerce)} {}
+                                     SoftwareKeyboard software_keyboard, WebBrowser web_browser)
+    : controller{std::move(controller)}, e_commerce{std::move(e_commerce)}, error{std::move(error)},
+      parental_controls{std::move(parental_controls)}, photo_viewer{std::move(photo_viewer)},
+      profile_select{std::move(profile_select)}, software_keyboard{std::move(software_keyboard)},
+      web_browser{std::move(web_browser)} {}
 
 AppletFrontendSet::~AppletFrontendSet() = default;
 
@@ -164,20 +166,37 @@ const AppletFrontendSet& AppletManager::GetAppletFrontendSet() const {
 }
 
 void AppletManager::SetAppletFrontendSet(AppletFrontendSet set) {
-    if (set.parental_controls != nullptr)
-        frontend.parental_controls = std::move(set.parental_controls);
-    if (set.error != nullptr)
+    if (set.controller != nullptr) {
+        frontend.controller = std::move(set.controller);
+    }
+
+    if (set.e_commerce != nullptr) {
+        frontend.e_commerce = std::move(set.e_commerce);
+    }
+
+    if (set.error != nullptr) {
         frontend.error = std::move(set.error);
-    if (set.photo_viewer != nullptr)
+    }
+
+    if (set.parental_controls != nullptr) {
+        frontend.parental_controls = std::move(set.parental_controls);
+    }
+
+    if (set.photo_viewer != nullptr) {
         frontend.photo_viewer = std::move(set.photo_viewer);
-    if (set.profile_select != nullptr)
+    }
+
+    if (set.profile_select != nullptr) {
         frontend.profile_select = std::move(set.profile_select);
-    if (set.software_keyboard != nullptr)
+    }
+
+    if (set.software_keyboard != nullptr) {
         frontend.software_keyboard = std::move(set.software_keyboard);
-    if (set.web_browser != nullptr)
+    }
+
+    if (set.web_browser != nullptr) {
         frontend.web_browser = std::move(set.web_browser);
-    if (set.e_commerce != nullptr)
-        frontend.e_commerce = std::move(set.e_commerce);
+    }
 }
 
 void AppletManager::SetDefaultAppletFrontendSet() {
@@ -186,15 +205,23 @@ void AppletManager::SetDefaultAppletFrontendSet() {
 }
 
 void AppletManager::SetDefaultAppletsIfMissing() {
-    if (frontend.parental_controls == nullptr) {
-        frontend.parental_controls =
-            std::make_unique<Core::Frontend::DefaultParentalControlsApplet>();
+    if (frontend.controller == nullptr) {
+        frontend.controller = std::make_unique<Core::Frontend::DefaultControllerApplet>();
+    }
+
+    if (frontend.e_commerce == nullptr) {
+        frontend.e_commerce = std::make_unique<Core::Frontend::DefaultECommerceApplet>();
     }
 
     if (frontend.error == nullptr) {
         frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
     }
 
+    if (frontend.parental_controls == nullptr) {
+        frontend.parental_controls =
+            std::make_unique<Core::Frontend::DefaultParentalControlsApplet>();
+    }
+
     if (frontend.photo_viewer == nullptr) {
         frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
     }
@@ -211,10 +238,6 @@ void AppletManager::SetDefaultAppletsIfMissing() {
     if (frontend.web_browser == nullptr) {
         frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
     }
-
-    if (frontend.e_commerce == nullptr) {
-        frontend.e_commerce = std::make_unique<Core::Frontend::DefaultECommerceApplet>();
-    }
 }
 
 void AppletManager::ClearAll() {
@@ -225,6 +248,8 @@ std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id) const {
     switch (id) {
     case AppletId::Auth:
         return std::make_shared<Auth>(system, *frontend.parental_controls);
+    case AppletId::Controller:
+        return std::make_shared<Controller>(system, *frontend.controller);
     case AppletId::Error:
         return std::make_shared<Error>(system, *frontend.error);
     case AppletId::ProfileSelect:
diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h
index e75be86a2..a1f4cf897 100644
--- a/src/core/hle/service/am/applets/applets.h
+++ b/src/core/hle/service/am/applets/applets.h
@@ -17,6 +17,7 @@ class System;
 }
 
 namespace Core::Frontend {
+class ControllerApplet;
 class ECommerceApplet;
 class ErrorApplet;
 class ParentalControlsApplet;
@@ -155,19 +156,20 @@ protected:
 };
 
 struct AppletFrontendSet {
-    using ParentalControlsApplet = std::unique_ptr<Core::Frontend::ParentalControlsApplet>;
+    using ControllerApplet = std::unique_ptr<Core::Frontend::ControllerApplet>;
+    using ECommerceApplet = std::unique_ptr<Core::Frontend::ECommerceApplet>;
     using ErrorApplet = std::unique_ptr<Core::Frontend::ErrorApplet>;
+    using ParentalControlsApplet = std::unique_ptr<Core::Frontend::ParentalControlsApplet>;
     using PhotoViewer = std::unique_ptr<Core::Frontend::PhotoViewerApplet>;
     using ProfileSelect = std::unique_ptr<Core::Frontend::ProfileSelectApplet>;
     using SoftwareKeyboard = std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet>;
     using WebBrowser = std::unique_ptr<Core::Frontend::WebBrowserApplet>;
-    using ECommerceApplet = std::unique_ptr<Core::Frontend::ECommerceApplet>;
 
     AppletFrontendSet();
-    AppletFrontendSet(ParentalControlsApplet parental_controls, ErrorApplet error,
-                      PhotoViewer photo_viewer, ProfileSelect profile_select,
-                      SoftwareKeyboard software_keyboard, WebBrowser web_browser,
-                      ECommerceApplet e_commerce);
+    AppletFrontendSet(ControllerApplet controller, ECommerceApplet e_commerce, ErrorApplet error,
+                      ParentalControlsApplet parental_controls, PhotoViewer photo_viewer,
+                      ProfileSelect profile_select, SoftwareKeyboard software_keyboard,
+                      WebBrowser web_browser);
     ~AppletFrontendSet();
 
     AppletFrontendSet(const AppletFrontendSet&) = delete;
@@ -176,13 +178,14 @@ struct AppletFrontendSet {
     AppletFrontendSet(AppletFrontendSet&&) noexcept;
     AppletFrontendSet& operator=(AppletFrontendSet&&) noexcept;
 
-    ParentalControlsApplet parental_controls;
+    ControllerApplet controller;
+    ECommerceApplet e_commerce;
     ErrorApplet error;
+    ParentalControlsApplet parental_controls;
     PhotoViewer photo_viewer;
     ProfileSelect profile_select;
     SoftwareKeyboard software_keyboard;
     WebBrowser web_browser;
-    ECommerceApplet e_commerce;
 };
 
 class AppletManager {
diff --git a/src/core/hle/service/am/applets/controller.cpp b/src/core/hle/service/am/applets/controller.cpp
new file mode 100644
index 000000000..2151da783
--- /dev/null
+++ b/src/core/hle/service/am/applets/controller.cpp
@@ -0,0 +1,210 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstring>
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/frontend/applets/controller.h"
+#include "core/hle/result.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/controller.h"
+#include "core/hle/service/hid/controllers/npad.h"
+
+namespace Service::AM::Applets {
+
+// This error code (0x183ACA) is thrown when the applet fails to initialize.
+[[maybe_unused]] constexpr ResultCode ERR_CONTROLLER_APPLET_3101{ErrorModule::HID, 3101};
+// This error code (0x183CCA) is thrown when the u32 result in ControllerSupportResultInfo is 2.
+[[maybe_unused]] constexpr ResultCode ERR_CONTROLLER_APPLET_3102{ErrorModule::HID, 3102};
+
+static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
+    ControllerSupportArgPrivate private_arg, ControllerSupportArgHeader header, bool enable_text,
+    std::vector<IdentificationColor> identification_colors, std::vector<ExplainText> text) {
+    HID::Controller_NPad::NPadType npad_style_set;
+    npad_style_set.raw = private_arg.style_set;
+
+    return {
+        .min_players = std::max(s8(1), header.player_count_min),
+        .max_players = header.player_count_max,
+        .keep_controllers_connected = header.enable_take_over_connection,
+        .enable_single_mode = header.enable_single_mode,
+        .enable_border_color = header.enable_identification_color,
+        .border_colors = identification_colors,
+        .enable_explain_text = enable_text,
+        .explain_text = text,
+        .allow_pro_controller = npad_style_set.pro_controller == 1,
+        .allow_handheld = npad_style_set.handheld == 1,
+        .allow_dual_joycons = npad_style_set.joycon_dual == 1,
+        .allow_left_joycon = npad_style_set.joycon_left == 1,
+        .allow_right_joycon = npad_style_set.joycon_right == 1,
+    };
+}
+
+Controller::Controller(Core::System& system_, const Core::Frontend::ControllerApplet& frontend_)
+    : Applet{system_.Kernel()}, frontend(frontend_) {}
+
+Controller::~Controller() = default;
+
+void Controller::Initialize() {
+    Applet::Initialize();
+
+    LOG_INFO(Service_HID, "Initializing Controller Applet.");
+
+    LOG_DEBUG(Service_HID,
+              "Initializing Applet with common_args: arg_version={}, lib_version={}, "
+              "play_startup_sound={}, size={}, system_tick={}, theme_color={}",
+              common_args.arguments_version, common_args.library_version,
+              common_args.play_startup_sound, common_args.size, common_args.system_tick,
+              common_args.theme_color);
+
+    library_applet_version = LibraryAppletVersion{common_args.library_version};
+
+    const auto private_arg_storage = broker.PopNormalDataToApplet();
+    ASSERT(private_arg_storage != nullptr);
+
+    const auto& private_arg = private_arg_storage->GetData();
+    ASSERT(private_arg.size() == sizeof(ControllerSupportArgPrivate));
+
+    std::memcpy(&controller_private_arg, private_arg.data(), sizeof(ControllerSupportArgPrivate));
+    ASSERT_MSG(controller_private_arg.arg_private_size == sizeof(ControllerSupportArgPrivate),
+               "Unknown ControllerSupportArgPrivate revision={} with size={}",
+               library_applet_version, controller_private_arg.arg_private_size);
+
+    switch (controller_private_arg.mode) {
+    case ControllerSupportMode::ShowControllerSupport: {
+        const auto user_arg_storage = broker.PopNormalDataToApplet();
+        ASSERT(user_arg_storage != nullptr);
+
+        const auto& user_arg = user_arg_storage->GetData();
+        switch (library_applet_version) {
+        case LibraryAppletVersion::Version3:
+        case LibraryAppletVersion::Version4:
+        case LibraryAppletVersion::Version5:
+            ASSERT(user_arg.size() == sizeof(ControllerSupportArgOld));
+            std::memcpy(&controller_user_arg_old, user_arg.data(), sizeof(ControllerSupportArgOld));
+            break;
+        case LibraryAppletVersion::Version7:
+            ASSERT(user_arg.size() == sizeof(ControllerSupportArgNew));
+            std::memcpy(&controller_user_arg_new, user_arg.data(), sizeof(ControllerSupportArgNew));
+            break;
+        default:
+            UNIMPLEMENTED_MSG("Unknown ControllerSupportArg revision={} with size={}",
+                              library_applet_version, controller_private_arg.arg_size);
+            ASSERT(user_arg.size() >= sizeof(ControllerSupportArgNew));
+            std::memcpy(&controller_user_arg_new, user_arg.data(), sizeof(ControllerSupportArgNew));
+            break;
+        }
+        break;
+    }
+    case ControllerSupportMode::ShowControllerStrapGuide:
+    case ControllerSupportMode::ShowControllerFirmwareUpdate:
+    default: {
+        UNIMPLEMENTED_MSG("Unimplemented ControllerSupportMode={}", controller_private_arg.mode);
+        break;
+    }
+    }
+}
+
+bool Controller::TransactionComplete() const {
+    return complete;
+}
+
+ResultCode Controller::GetStatus() const {
+    return status;
+}
+
+void Controller::ExecuteInteractive() {
+    UNREACHABLE_MSG("Attempted to call interactive execution on non-interactive applet.");
+}
+
+void Controller::Execute() {
+    switch (controller_private_arg.mode) {
+    case ControllerSupportMode::ShowControllerSupport: {
+        const auto parameters = [this] {
+            switch (library_applet_version) {
+            case LibraryAppletVersion::Version3:
+            case LibraryAppletVersion::Version4:
+            case LibraryAppletVersion::Version5:
+                return ConvertToFrontendParameters(
+                    controller_private_arg, controller_user_arg_old.header,
+                    controller_user_arg_old.enable_explain_text,
+                    std::vector<IdentificationColor>(
+                        controller_user_arg_old.identification_colors.begin(),
+                        controller_user_arg_old.identification_colors.end()),
+                    std::vector<ExplainText>(controller_user_arg_old.explain_text.begin(),
+                                             controller_user_arg_old.explain_text.end()));
+            case LibraryAppletVersion::Version7:
+            default:
+                return ConvertToFrontendParameters(
+                    controller_private_arg, controller_user_arg_new.header,
+                    controller_user_arg_new.enable_explain_text,
+                    std::vector<IdentificationColor>(
+                        controller_user_arg_new.identification_colors.begin(),
+                        controller_user_arg_new.identification_colors.end()),
+                    std::vector<ExplainText>(controller_user_arg_new.explain_text.begin(),
+                                             controller_user_arg_new.explain_text.end()));
+            }
+        }();
+
+        is_single_mode = parameters.enable_single_mode;
+
+        LOG_DEBUG(Service_HID,
+                  "Controller Parameters: min_players={}, max_players={}, "
+                  "keep_controllers_connected={}, enable_single_mode={}, enable_border_color={}, "
+                  "enable_explain_text={}, allow_pro_controller={}, allow_handheld={}, "
+                  "allow_dual_joycons={}, allow_left_joycon={}, allow_right_joycon={}",
+                  parameters.min_players, parameters.max_players,
+                  parameters.keep_controllers_connected, parameters.enable_single_mode,
+                  parameters.enable_border_color, parameters.enable_explain_text,
+                  parameters.allow_pro_controller, parameters.allow_handheld,
+                  parameters.allow_dual_joycons, parameters.allow_left_joycon,
+                  parameters.allow_right_joycon);
+
+        frontend.ReconfigureControllers([this] { ConfigurationComplete(); }, parameters);
+        break;
+    }
+    case ControllerSupportMode::ShowControllerStrapGuide:
+    case ControllerSupportMode::ShowControllerFirmwareUpdate:
+    default: {
+        ConfigurationComplete();
+        break;
+    }
+    }
+}
+
+void Controller::ConfigurationComplete() {
+    ControllerSupportResultInfo result_info{};
+
+    const auto& players = Settings::values.players;
+
+    // If enable_single_mode is enabled, player_count is 1 regardless of any other parameters.
+    // Otherwise, only count connected players from P1-P8.
+    result_info.player_count =
+        is_single_mode ? 1
+                       : static_cast<s8>(std::count_if(
+                             players.begin(), players.end() - 2,
+                             [](Settings::PlayerInput player) { return player.connected; }));
+
+    result_info.selected_id = HID::Controller_NPad::IndexToNPad(
+        std::distance(players.begin(),
+                      std::find_if(players.begin(), players.end(),
+                                   [](Settings::PlayerInput player) { return player.connected; })));
+
+    result_info.result = 0;
+
+    LOG_DEBUG(Service_HID, "Result Info: player_count={}, selected_id={}, result={}",
+              result_info.player_count, result_info.selected_id, result_info.result);
+
+    complete = true;
+    out_data = std::vector<u8>(sizeof(ControllerSupportResultInfo));
+    std::memcpy(out_data.data(), &result_info, out_data.size());
+    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(std::move(out_data)));
+    broker.SignalStateChanged();
+}
+
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/controller.h b/src/core/hle/service/am/applets/controller.h
new file mode 100644
index 000000000..f7bb3fba9
--- /dev/null
+++ b/src/core/hle/service/am/applets/controller.h
@@ -0,0 +1,123 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <vector>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "core/hle/result.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::AM::Applets {
+
+using IdentificationColor = std::array<u8, 4>;
+using ExplainText = std::array<char, 0x81>;
+
+enum class LibraryAppletVersion : u32_le {
+    Version3 = 0x3, // 1.0.0 - 2.3.0
+    Version4 = 0x4, // 3.0.0 - 5.1.0
+    Version5 = 0x5, // 6.0.0 - 7.0.1
+    Version7 = 0x7, // 8.0.0+
+};
+
+enum class ControllerSupportMode : u8 {
+    ShowControllerSupport = 0,
+    ShowControllerStrapGuide = 1,
+    ShowControllerFirmwareUpdate = 2,
+};
+
+enum class ControllerSupportCaller : u8 {
+    Application = 0,
+    System = 1,
+};
+
+struct ControllerSupportArgPrivate {
+    u32 arg_private_size{};
+    u32 arg_size{};
+    bool flag_0{};
+    bool flag_1{};
+    ControllerSupportMode mode{};
+    ControllerSupportCaller caller{};
+    u32 style_set{};
+    u32 joy_hold_type{};
+};
+static_assert(sizeof(ControllerSupportArgPrivate) == 0x14,
+              "ControllerSupportArgPrivate has incorrect size.");
+
+struct ControllerSupportArgHeader {
+    s8 player_count_min{};
+    s8 player_count_max{};
+    bool enable_take_over_connection{};
+    bool enable_left_justify{};
+    bool enable_permit_joy_dual{};
+    bool enable_single_mode{};
+    bool enable_identification_color{};
+};
+static_assert(sizeof(ControllerSupportArgHeader) == 0x7,
+              "ControllerSupportArgHeader has incorrect size.");
+
+// LibraryAppletVersion 0x3, 0x4, 0x5
+struct ControllerSupportArgOld {
+    ControllerSupportArgHeader header{};
+    std::array<IdentificationColor, 4> identification_colors{};
+    bool enable_explain_text{};
+    std::array<ExplainText, 4> explain_text{};
+};
+static_assert(sizeof(ControllerSupportArgOld) == 0x21C,
+              "ControllerSupportArgOld has incorrect size.");
+
+// LibraryAppletVersion 0x7
+struct ControllerSupportArgNew {
+    ControllerSupportArgHeader header{};
+    std::array<IdentificationColor, 8> identification_colors{};
+    bool enable_explain_text{};
+    std::array<ExplainText, 8> explain_text{};
+};
+static_assert(sizeof(ControllerSupportArgNew) == 0x430,
+              "ControllerSupportArgNew has incorrect size.");
+
+struct ControllerSupportResultInfo {
+    s8 player_count{};
+    INSERT_PADDING_BYTES(3);
+    u32 selected_id{};
+    u32 result{};
+};
+static_assert(sizeof(ControllerSupportResultInfo) == 0xC,
+              "ControllerSupportResultInfo has incorrect size.");
+
+class Controller final : public Applet {
+public:
+    explicit Controller(Core::System& system_, const Core::Frontend::ControllerApplet& frontend_);
+    ~Controller() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    void ConfigurationComplete();
+
+private:
+    const Core::Frontend::ControllerApplet& frontend;
+
+    LibraryAppletVersion library_applet_version;
+    ControllerSupportArgPrivate controller_private_arg;
+    ControllerSupportArgOld controller_user_arg_old;
+    ControllerSupportArgNew controller_user_arg_new;
+    bool complete{false};
+    ResultCode status{RESULT_SUCCESS};
+    bool is_single_mode{false};
+    std::vector<u8> out_data;
+};
+
+} // namespace Service::AM::Applets
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index e742497e1..7818c098f 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -193,7 +193,8 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
     controller.battery_level[0] = BATTERY_FULL;
     controller.battery_level[1] = BATTERY_FULL;
     controller.battery_level[2] = BATTERY_FULL;
-    styleset_changed_events[controller_idx].writable->Signal();
+
+    SignalStyleSetChangedEvent(IndexToNPad(controller_idx));
 }
 
 void Controller_NPad::OnInit() {
@@ -518,13 +519,17 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
     last_processed_vibration = vibrations.back();
 }
 
+Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
+    return last_processed_vibration;
+}
+
 std::shared_ptr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent(u32 npad_id) const {
     const auto& styleset_event = styleset_changed_events[NPadIdToIndex(npad_id)];
     return styleset_event.readable;
 }
 
-Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
-    return last_processed_vibration;
+void Controller_NPad::SignalStyleSetChangedEvent(u32 npad_id) const {
+    styleset_changed_events[NPadIdToIndex(npad_id)].writable->Signal();
 }
 
 void Controller_NPad::AddNewControllerAt(NPadControllerType controller, std::size_t npad_index) {
@@ -534,7 +539,7 @@ void Controller_NPad::AddNewControllerAt(NPadControllerType controller, std::siz
 void Controller_NPad::UpdateControllerAt(NPadControllerType controller, std::size_t npad_index,
                                          bool connected) {
     if (!connected) {
-        DisconnectNPad(IndexToNPad(npad_index));
+        DisconnectNPadAtIndex(npad_index);
         return;
     }
 
@@ -554,16 +559,19 @@ void Controller_NPad::UpdateControllerAt(NPadControllerType controller, std::siz
 }
 
 void Controller_NPad::DisconnectNPad(u32 npad_id) {
-    const auto npad_index = NPadIdToIndex(npad_id);
-    connected_controllers[npad_index].is_connected = false;
+    DisconnectNPadAtIndex(NPadIdToIndex(npad_id));
+}
+
+void Controller_NPad::DisconnectNPadAtIndex(std::size_t npad_index) {
     Settings::values.players[npad_index].connected = false;
+    connected_controllers[npad_index].is_connected = false;
 
     auto& controller = shared_memory_entries[npad_index];
     controller.joy_styles.raw = 0; // Zero out
     controller.device_type.raw = 0;
     controller.properties.raw = 0;
 
-    styleset_changed_events[npad_index].writable->Signal();
+    SignalStyleSetChangedEvent(IndexToNPad(npad_index));
 }
 
 void Controller_NPad::SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode) {
@@ -666,13 +674,13 @@ void Controller_NPad::ClearAllConnectedControllers() {
 }
 
 void Controller_NPad::DisconnectAllConnectedControllers() {
-    for (ControllerHolder& controller : connected_controllers) {
+    for (auto& controller : connected_controllers) {
         controller.is_connected = false;
     }
 }
 
 void Controller_NPad::ConnectAllDisconnectedControllers() {
-    for (ControllerHolder& controller : connected_controllers) {
+    for (auto& controller : connected_controllers) {
         if (controller.type != NPadControllerType::None && !controller.is_connected) {
             controller.is_connected = true;
         }
@@ -680,7 +688,7 @@ void Controller_NPad::ConnectAllDisconnectedControllers() {
 }
 
 void Controller_NPad::ClearAllControllers() {
-    for (ControllerHolder& controller : connected_controllers) {
+    for (auto& controller : connected_controllers) {
         controller.type = NPadControllerType::None;
         controller.is_connected = false;
     }
@@ -728,92 +736,4 @@ bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const
     return false;
 }
 
-Controller_NPad::NPadControllerType Controller_NPad::DecideBestController(
-    NPadControllerType priority) const {
-    if (IsControllerSupported(priority)) {
-        return priority;
-    }
-    const auto is_docked = Settings::values.use_docked_mode;
-    if (is_docked && priority == NPadControllerType::Handheld) {
-        priority = NPadControllerType::JoyDual;
-        if (IsControllerSupported(priority)) {
-            return priority;
-        }
-    }
-    std::vector<NPadControllerType> priority_list;
-    switch (priority) {
-    case NPadControllerType::ProController:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::Handheld:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyDual:
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyLeft:
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyRight:
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::Pokeball:
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        break;
-    default:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        break;
-    }
-
-    const auto iter = std::find_if(priority_list.begin(), priority_list.end(),
-                                   [this](auto type) { return IsControllerSupported(type); });
-    if (iter == priority_list.end()) {
-        UNIMPLEMENTED_MSG("Could not find supported controller!");
-        return priority;
-    }
-
-    return *iter;
-}
-
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index ad25c6fbf..e9788da8d 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -115,15 +115,19 @@ public:
     void VibrateController(const std::vector<u32>& controller_ids,
                            const std::vector<Vibration>& vibrations);
 
-    std::shared_ptr<Kernel::ReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;
     Vibration GetLastVibration() const;
 
+    std::shared_ptr<Kernel::ReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;
+    void SignalStyleSetChangedEvent(u32 npad_id) const;
+
     // Adds a new controller at an index.
     void AddNewControllerAt(NPadControllerType controller, std::size_t npad_index);
     // Adds a new controller at an index with connection status.
     void UpdateControllerAt(NPadControllerType controller, std::size_t npad_index, bool connected);
 
     void DisconnectNPad(u32 npad_id);
+    void DisconnectNPadAtIndex(std::size_t index);
+
     void SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode);
     GyroscopeZeroDriftMode GetGyroscopeZeroDriftMode() const;
     LedPattern GetLedPattern(u32 npad_id);
@@ -315,7 +319,6 @@ private:
 
     void InitNewlyAddedController(std::size_t controller_idx);
     bool IsControllerSupported(NPadControllerType controller) const;
-    NPadControllerType DecideBestController(NPadControllerType priority) const;
     void RequestPadStateUpdate(u32 npad_id);
 
     u32 press_state{};