Android #142

renderer_vulkan: exclude steam deck oled from force max clock setting

.gitmodules

@@ -4,9 +4,6 @@
 [submodule "enet"]
 	path = externals/enet
 	url = https://github.com/lsalzman/enet.git
-[submodule "inih"]
-	path = externals/inih/inih
-	url = https://github.com/benhoyt/inih.git
 [submodule "cubeb"]
 	path = externals/cubeb
 	url = https://github.com/mozilla/cubeb.git
@@ -61,6 +58,9 @@
 [submodule "breakpad"]
 	path = externals/breakpad
 	url = https://github.com/yuzu-emu/breakpad.git
+[submodule "simpleini"]
+	path = externals/simpleini
+	url = https://github.com/brofield/simpleini.git
 [submodule "oaknut"]
 	path = externals/oaknut
 	url = https://github.com/merryhime/oaknut

CMakeLists.txt

@@ -285,7 +285,6 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 find_package(Boost 1.79.0 REQUIRED context)
 find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
-find_package(inih 52 MODULE COMPONENTS INIReader)
 find_package(LLVM 17.0.2 MODULE COMPONENTS Demangle)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)

CMakeModules/Findinih.cmake

@@ -1,27 +0,0 @@
-# SPDX-FileCopyrightText: 2022 Alexandre Bouvier <contact@amb.tf>
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-find_package(PkgConfig QUIET)
-pkg_search_module(INIH QUIET IMPORTED_TARGET inih)
-if (INIReader IN_LIST inih_FIND_COMPONENTS)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
-    if (INIREADER_FOUND)
-        set(inih_INIReader_FOUND TRUE)
-    endif()
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(inih
-    REQUIRED_VARS INIH_LINK_LIBRARIES
-    VERSION_VAR INIH_VERSION
-    HANDLE_COMPONENTS
-)
-
-if (inih_FOUND AND NOT TARGET inih::inih)
-    add_library(inih::inih ALIAS PkgConfig::INIH)
-endif()
-
-if (inih_FOUND AND inih_INIReader_FOUND AND NOT TARGET inih::INIReader)
-    add_library(inih::INIReader ALIAS PkgConfig::INIREADER)
-endif()

README.md

@@ -1,7 +1,7 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
 | [11535](https://github.com/yuzu-emu/yuzu//pull/11535) | [`50bcfa5fb`](https://github.com/yuzu-emu/yuzu//pull/11535/files) | renderer_vulkan: Introduce separate cmd buffer for uploads | [GPUCode](https://github.com/GPUCode/) | Yes |
-| [12074](https://github.com/yuzu-emu/yuzu//pull/12074) | [`d0285e882`](https://github.com/yuzu-emu/yuzu//pull/12074/files) | Implement Native Code Execution (NCE) | [GPUCode](https://github.com/GPUCode/) | Yes |
+| [12074](https://github.com/yuzu-emu/yuzu//pull/12074) | [`643250874`](https://github.com/yuzu-emu/yuzu//pull/12074/files) | Implement Native Code Execution (NCE) | [GPUCode](https://github.com/GPUCode/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

dist/languages/.tx/config

@@ -6,3 +6,8 @@ file_filter = <lang>.ts
 source_file = en.ts
 source_lang = en
 type = QT
+
+[o:yuzu-emulator:p:yuzu:r:yuzu-android]
+file_filter = ../../src/android/app/src/main/res/values-<lang>/strings.xml
+source_file = ../../src/android/app/src/main/res/values/strings.xml
+type = ANDROID

externals/CMakeLists.txt

@@ -38,11 +38,6 @@ endif()
 # Glad
 add_subdirectory(glad)
 
-# inih
-if (NOT TARGET inih::INIReader)
-    add_subdirectory(inih)
-endif()
-
 # mbedtls
 add_subdirectory(mbedtls)
 target_include_directories(mbedtls PUBLIC ./mbedtls/include)
@@ -299,3 +294,6 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
         target_link_libraries(dump_syms PRIVATE libbreakpad_client ZLIB::ZLIB)
     endif()
 endif()
+
+# SimpleIni
+add_subdirectory(simpleini)

externals/inih/CMakeLists.txt

@@ -1,13 +0,0 @@
-# SPDX-FileCopyrightText: 2014 Gui Andrade <admin@archshift.com>
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-add_library(inih
-    inih/ini.c
-    inih/ini.h
-    inih/cpp/INIReader.cpp
-    inih/cpp/INIReader.h
-)
-
-create_target_directory_groups(inih)
-target_include_directories(inih INTERFACE inih/cpp)
-add_library(inih::INIReader ALIAS inih)

src/CMakeLists.txt

@@ -187,6 +187,7 @@ add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(network)
 add_subdirectory(input_common)
+add_subdirectory(frontend_common)
 add_subdirectory(shader_recompiler)
 
 if (YUZU_ROOM)

src/android/app/build.gradle.kts

@@ -219,7 +219,6 @@ dependencies {
     implementation("io.coil-kt:coil:2.2.2")
     implementation("androidx.core:core-splashscreen:1.0.1")
     implementation("androidx.window:window:1.2.0-beta03")
-    implementation("org.ini4j:ini4j:0.5.4")
     implementation("androidx.constraintlayout:constraintlayout:2.1.4")
     implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")
     implementation("androidx.navigation:navigation-fragment-ktx:2.7.4")

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -230,8 +230,6 @@ object NativeLibrary {
      */
     external fun onTouchReleased(finger_id: Int)
 
-    external fun reloadSettings()
-
     external fun initGameIni(gameID: String?)
 
     external fun setAppDirectory(directory: String)
@@ -301,6 +299,11 @@ object NativeLibrary {
      */
     external fun getPerfStats(): DoubleArray
 
+    /**
+     * Returns the current CPU backend.
+     */
+    external fun getCpuBackend(): String
+
     /**
      * Notifies the core emulation that the orientation has changed.
      */

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt

@@ -7,7 +7,7 @@ import android.text.TextUtils
 import android.widget.Toast
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
+import org.yuzu.yuzu_emu.utils.NativeConfig
 
 object Settings {
     private val context get() = YuzuApplication.appContext
@@ -19,7 +19,7 @@ object Settings {
                 context.getString(R.string.ini_saved),
                 Toast.LENGTH_SHORT
             ).show()
-            SettingsFile.saveFile(SettingsFile.FILE_NAME_CONFIG)
+            NativeConfig.saveSettings()
         } else {
             // TODO: Save custom game settings
             Toast.makeText(

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -73,7 +73,7 @@ abstract class SettingsItem(
                     R.string.frame_limit_slider,
                     R.string.frame_limit_slider_description,
                     1,
-                    200,
+                    400,
                     "%"
                 )
             )
@@ -82,8 +82,8 @@ abstract class SettingsItem(
                     IntSetting.CPU_BACKEND,
                     R.string.cpu_backend,
                     0,
-                    R.array.cpuBackendNames,
-                    R.array.cpuBackendValues
+                    R.array.cpuBackendArm64Names,
+                    R.array.cpuBackendArm64Values
                 )
             )
             put(

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsActivity.kt

@@ -21,7 +21,6 @@ import androidx.navigation.navArgs
 import com.google.android.material.color.MaterialColors
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
-import org.yuzu.yuzu_emu.NativeLibrary
 import java.io.IOException
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.ActivitySettingsBinding
@@ -165,11 +164,12 @@ class SettingsActivity : AppCompatActivity() {
         settingsViewModel.shouldSave = false
 
         // Delete settings file because the user may have changed values that do not exist in the UI
+        NativeConfig.unloadConfig()
         val settingsFile = SettingsFile.getSettingsFile(SettingsFile.FILE_NAME_CONFIG)
         if (!settingsFile.delete()) {
             throw IOException("Failed to delete $settingsFile")
         }
-        NativeLibrary.reloadSettings()
+        NativeConfig.initializeConfig()
 
         Toast.makeText(
             applicationContext,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/utils/SettingsFile.kt

@@ -3,15 +3,8 @@
 
 package org.yuzu.yuzu_emu.features.settings.utils
 
-import android.widget.Toast
 import java.io.*
-import org.ini4j.Wini
-import org.yuzu.yuzu_emu.R
-import org.yuzu.yuzu_emu.YuzuApplication
-import org.yuzu.yuzu_emu.features.settings.model.*
 import org.yuzu.yuzu_emu.utils.DirectoryInitialization
-import org.yuzu.yuzu_emu.utils.Log
-import org.yuzu.yuzu_emu.utils.NativeConfig
 
 /**
  * Contains static methods for interacting with .ini files in which settings are stored.
@@ -19,41 +12,6 @@ import org.yuzu.yuzu_emu.utils.NativeConfig
 object SettingsFile {
     const val FILE_NAME_CONFIG = "config"
 
-    /**
-     * Saves a Settings HashMap to a given .ini file on disk. If unsuccessful, outputs an error
-     * telling why it failed.
-     *
-     * @param fileName The target filename without a path or extension.
-     */
-    fun saveFile(fileName: String) {
-        val ini = getSettingsFile(fileName)
-        try {
-            val wini = Wini(ini)
-            for (specificCategory in Settings.Category.values()) {
-                val categoryHeader = NativeConfig.getConfigHeader(specificCategory.ordinal)
-                for (setting in Settings.settingsList) {
-                    if (setting.key!!.isEmpty()) continue
-
-                    val settingCategoryHeader =
-                        NativeConfig.getConfigHeader(setting.category.ordinal)
-                    val iniSetting: String? = wini.get(categoryHeader, setting.key)
-                    if (iniSetting != null || settingCategoryHeader == categoryHeader) {
-                        wini.put(settingCategoryHeader, setting.key, setting.valueAsString)
-                    }
-                }
-            }
-            wini.store()
-        } catch (e: IOException) {
-            Log.error("[SettingsFile] File not found: " + fileName + ".ini: " + e.message)
-            val context = YuzuApplication.appContext
-            Toast.makeText(
-                context,
-                context.getString(R.string.error_saving, fileName, e.message),
-                Toast.LENGTH_SHORT
-            ).show()
-        }
-    }
-
     fun getSettingsFile(fileName: String): File =
         File(DirectoryInitialization.userDirectory + "/config/" + fileName + ".ini")
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -414,8 +414,10 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             perfStatsUpdater = {
                 if (emulationViewModel.emulationStarted.value) {
                     val perfStats = NativeLibrary.getPerfStats()
+                    val cpuBackend = NativeLibrary.getCpuBackend()
                     if (_binding != null) {
-                        binding.showFpsText.text = String.format("FPS: %.1f", perfStats[FPS])
+                        binding.showFpsText.text =
+                            String.format("FPS: %.1f\n%s", perfStats[FPS], cpuBackend)
                     }
                     perfStatsUpdateHandler.postDelayed(perfStatsUpdater!!, 800)
                 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/InstallableFragment.kt

@@ -21,6 +21,8 @@ import org.yuzu.yuzu_emu.databinding.FragmentInstallablesBinding
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.model.Installable
 import org.yuzu.yuzu_emu.ui.main.MainActivity
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
 
 class InstallableFragment : Fragment() {
     private var _binding: FragmentInstallablesBinding? = null
@@ -78,7 +80,15 @@ class InstallableFragment : Fragment() {
                     R.string.manage_save_data,
                     R.string.import_export_saves_description,
                     install = { mainActivity.importSaves.launch(arrayOf("application/zip")) },
-                    export = { mainActivity.exportSave() }
+                    export = {
+                        mainActivity.exportSaves.launch(
+                            "yuzu saves - ${
+                            LocalDateTime.now().format(
+                                DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")
+                            )
+                            }.zip"
+                        )
+                    }
                 )
             } else {
                 Installable(

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/Game.kt

@@ -18,8 +18,8 @@ class Game(
     val version: String = "",
     val isHomebrew: Boolean = false
 ) : Parcelable {
-    val keyAddedToLibraryTime get() = "${programId}_AddedToLibraryTime"
-    val keyLastPlayedTime get() = "${programId}_LastPlayed"
+    val keyAddedToLibraryTime get() = "${path}_AddedToLibraryTime"
+    val keyLastPlayedTime get() = "${path}_LastPlayed"
 
     override fun equals(other: Any?): Boolean {
         if (other !is Game) {

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/main/MainActivity.kt

@@ -6,7 +6,6 @@ package org.yuzu.yuzu_emu.ui.main
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
-import android.provider.DocumentsContract
 import android.view.View
 import android.view.ViewGroup.MarginLayoutParams
 import android.view.WindowManager
@@ -20,7 +19,6 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
-import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
@@ -41,7 +39,6 @@ import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.activities.EmulationActivity
 import org.yuzu.yuzu_emu.databinding.ActivityMainBinding
-import org.yuzu.yuzu_emu.features.DocumentProvider
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.fragments.IndeterminateProgressDialogFragment
 import org.yuzu.yuzu_emu.fragments.MessageDialogFragment
@@ -53,9 +50,6 @@ import org.yuzu.yuzu_emu.model.TaskViewModel
 import org.yuzu.yuzu_emu.utils.*
 import java.io.BufferedInputStream
 import java.io.BufferedOutputStream
-import java.io.FileOutputStream
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
 import java.util.zip.ZipEntry
 import java.util.zip.ZipInputStream
 
@@ -73,7 +67,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
     // Get first subfolder in saves folder (should be the user folder)
     val savesFolderRoot get() = File(savesFolder).listFiles()?.firstOrNull()?.canonicalPath ?: ""
-    private var lastZipCreated: File? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         val splashScreen = installSplashScreen()
@@ -632,6 +625,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                 }
 
                 // Clear existing user data
+                NativeConfig.unloadConfig()
                 File(DirectoryInitialization.userDirectory!!).deleteRecursively()
 
                 // Copy archive to internal storage
@@ -650,81 +644,38 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
                 // Reinitialize relevant data
                 NativeLibrary.initializeSystem(true)
+                NativeConfig.initializeConfig()
                 gamesViewModel.reloadGames(false)
 
                 return@newInstance getString(R.string.user_data_import_success)
             }.show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
         }
 
-    /**
-     * Zips the save files located in the given folder path and creates a new zip file with the current date and time.
-     * @return true if the zip file is successfully created, false otherwise.
-     */
-    private fun zipSave(): Boolean {
-        try {
-            val tempFolder = File(getPublicFilesDir().canonicalPath, "temp")
-            tempFolder.mkdirs()
-            val saveFolder = File(savesFolderRoot)
-            val outputZipFile = File(
-                tempFolder,
-                "yuzu saves - ${
-                LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"))
-                }.zip"
-            )
-            outputZipFile.createNewFile()
-            val result = FileUtil.zipFromInternalStorage(
-                saveFolder,
-                savesFolderRoot,
-                BufferedOutputStream(FileOutputStream(outputZipFile))
-            )
-            if (result == TaskState.Failed) {
-                return false
-            }
-            lastZipCreated = outputZipFile
-        } catch (e: Exception) {
-            return false
-        }
-        return true
-    }
-
     /**
      * Exports the save file located in the given folder path by creating a zip file and sharing it via intent.
      */
-    fun exportSave() {
-        CoroutineScope(Dispatchers.IO).launch {
-            val wasZipCreated = zipSave()
-            val lastZipFile = lastZipCreated
-            if (!wasZipCreated || lastZipFile == null) {
-                withContext(Dispatchers.Main) {
-                    Toast.makeText(
-                        this@MainActivity,
-                        getString(R.string.export_save_failed),
-                        Toast.LENGTH_LONG
-                    ).show()
-                }
-                return@launch
-            }
-
-            withContext(Dispatchers.Main) {
-                val file = DocumentFile.fromSingleUri(
-                    this@MainActivity,
-                    DocumentsContract.buildDocumentUri(
-                        DocumentProvider.AUTHORITY,
-                        "${DocumentProvider.ROOT_ID}/temp/${lastZipFile.name}"
-                    )
-                )!!
-                val intent = Intent(Intent.ACTION_SEND)
-                    .setDataAndType(file.uri, "application/zip")
-                    .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                    .putExtra(Intent.EXTRA_STREAM, file.uri)
-                startForResultExportSave.launch(
-                    Intent.createChooser(
-                        intent,
-                        getString(R.string.share_save_file)
-                    )
-                )
-            }
+    val exportSaves = registerForActivityResult(
+        ActivityResultContracts.CreateDocument("application/zip")
+    ) { result ->
+        if (result == null) {
+            return@registerForActivityResult
         }
+
+        IndeterminateProgressDialogFragment.newInstance(
+            this,
+            R.string.save_files_exporting,
+            false
+        ) {
+            val zipResult = FileUtil.zipFromInternalStorage(
+                File(savesFolderRoot),
+                savesFolderRoot,
+                BufferedOutputStream(contentResolver.openOutputStream(result))
+            )
+            return@newInstance when (zipResult) {
+                TaskState.Completed -> getString(R.string.export_success)
+                TaskState.Cancelled, TaskState.Failed -> getString(R.string.export_failed)
+            }
+        }.show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
     }
 
     private val startForResultExportSave =

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/DirectoryInitialization.kt

@@ -16,6 +16,7 @@ object DirectoryInitialization {
         if (!areDirectoriesReady) {
             initializeInternalStorage()
             NativeLibrary.initializeSystem(false)
+            NativeConfig.initializeConfig()
             areDirectoriesReady = true
         }
     }

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/NativeConfig.kt

@@ -4,6 +4,30 @@
 package org.yuzu.yuzu_emu.utils
 
 object NativeConfig {
+    /**
+     * Creates a Config object and opens the emulation config.
+     */
+    @Synchronized
+    external fun initializeConfig()
+
+    /**
+     * Destroys the stored config object. This automatically saves the existing config.
+     */
+    @Synchronized
+    external fun unloadConfig()
+
+    /**
+     * Reads values saved to the config file and saves them.
+     */
+    @Synchronized
+    external fun reloadSettings()
+
+    /**
+     * Saves settings values in memory to disk.
+     */
+    @Synchronized
+    external fun saveSettings()
+
     external fun getBoolean(key: String, getDefault: Boolean): Boolean
     external fun setBoolean(key: String, value: Boolean)
 

src/android/app/src/main/jni/CMakeLists.txt

@@ -6,9 +6,6 @@ add_library(yuzu-android SHARED
     android_common/android_common.h
     applets/software_keyboard.cpp
     applets/software_keyboard.h
-    config.cpp
-    config.h
-    default_ini.h
     emu_window/emu_window.cpp
     emu_window/emu_window.h
     id_cache.cpp
@@ -16,15 +13,17 @@ add_library(yuzu-android SHARED
     native.cpp
     native.h
     native_config.cpp
-    uisettings.cpp
+    android_settings.cpp
     game_metadata.cpp
     native_log.cpp
+    android_config.cpp
+    android_config.h
 )
 
 set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})
 
-target_link_libraries(yuzu-android PRIVATE audio_core common core input_common)
-target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad inih jnigraphics log)
+target_link_libraries(yuzu-android PRIVATE audio_core common core input_common frontend_common)
+target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad jnigraphics log)
 if (ARCHITECTURE_arm64)
     target_link_libraries(yuzu-android PRIVATE adrenotools)
 endif()

src/android/app/src/main/jni/android_config.cpp

@@ -0,0 +1,70 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "android_config.h"
+#include "android_settings.h"
+#include "common/settings_setting.h"
+
+AndroidConfig::AndroidConfig(const std::string& config_name, ConfigType config_type)
+    : Config(config_type) {
+    Initialize(config_name);
+    if (config_type != ConfigType::InputProfile) {
+        ReadAndroidValues();
+        SaveAndroidValues();
+    }
+}
+
+AndroidConfig::~AndroidConfig() {
+    if (global) {
+        AndroidConfig::SaveAllValues();
+    }
+}
+
+void AndroidConfig::ReloadAllValues() {
+    Reload();
+    ReadAndroidValues();
+    SaveAndroidValues();
+}
+
+void AndroidConfig::SaveAllValues() {
+    Save();
+    SaveAndroidValues();
+}
+
+void AndroidConfig::ReadAndroidValues() {
+    if (global) {
+        ReadAndroidUIValues();
+    }
+}
+
+void AndroidConfig::ReadAndroidUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Android));
+
+    ReadCategory(Settings::Category::Android);
+
+    EndGroup();
+}
+
+void AndroidConfig::SaveAndroidValues() {
+    if (global) {
+        SaveAndroidUIValues();
+    }
+
+    WriteToIni();
+}
+
+void AndroidConfig::SaveAndroidUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Android));
+
+    WriteCategory(Settings::Category::Android);
+
+    EndGroup();
+}
+
+std::vector<Settings::BasicSetting*>& AndroidConfig::FindRelevantList(Settings::Category category) {
+    auto& map = Settings::values.linkage.by_category;
+    if (map.contains(category)) {
+        return Settings::values.linkage.by_category[category];
+    }
+    return AndroidSettings::values.linkage.by_category[category];
+}

src/android/app/src/main/jni/android_config.h

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "frontend_common/config.h"
+
+class AndroidConfig final : public Config {
+public:
+    explicit AndroidConfig(const std::string& config_name = "config",
+                           ConfigType config_type = ConfigType::GlobalConfig);
+    ~AndroidConfig() override;
+
+    void ReloadAllValues() override;
+    void SaveAllValues() override;
+
+protected:
+    void ReadAndroidValues();
+    void ReadAndroidUIValues();
+    void ReadHidbusValues() override {}
+    void ReadDebugControlValues() override {}
+    void ReadPathValues() override {}
+    void ReadShortcutValues() override {}
+    void ReadUIValues() override {}
+    void ReadUIGamelistValues() override {}
+    void ReadUILayoutValues() override {}
+    void ReadMultiplayerValues() override {}
+
+    void SaveAndroidValues();
+    void SaveAndroidUIValues();
+    void SaveHidbusValues() override {}
+    void SaveDebugControlValues() override {}
+    void SavePathValues() override {}
+    void SaveShortcutValues() override {}
+    void SaveUIValues() override {}
+    void SaveUIGamelistValues() override {}
+    void SaveUILayoutValues() override {}
+    void SaveMultiplayerValues() override {}
+
+    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
+};

src/android/app/src/main/jni/android_settings.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "uisettings.h"
+#include "android_settings.h"
 
 namespace AndroidSettings {
 

src/android/app/src/main/jni/config.cpp

@@ -1,331 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <memory>
-#include <optional>
-#include <sstream>
-
-#include <INIReader.h>
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "common/settings_enums.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "input_common/main.h"
-#include "jni/config.h"
-#include "jni/default_ini.h"
-#include "uisettings.h"
-
-namespace FS = Common::FS;
-
-Config::Config(const std::string& config_name, ConfigType config_type)
-    : type(config_type), global{config_type == ConfigType::GlobalConfig} {
-    Initialize(config_name);
-}
-
-Config::~Config() = default;
-
-bool Config::LoadINI(const std::string& default_contents, bool retry) {
-    void(FS::CreateParentDir(config_loc));
-    config = std::make_unique<INIReader>(FS::PathToUTF8String(config_loc));
-    const auto config_loc_str = FS::PathToUTF8String(config_loc);
-    if (config->ParseError() < 0) {
-        if (retry) {
-            LOG_WARNING(Config, "Failed to load {}. Creating file from defaults...",
-                        config_loc_str);
-
-            void(FS::CreateParentDir(config_loc));
-            void(FS::WriteStringToFile(config_loc, FS::FileType::TextFile, default_contents));
-
-            config = std::make_unique<INIReader>(config_loc_str);
-
-            return LoadINI(default_contents, false);
-        }
-        LOG_ERROR(Config, "Failed.");
-        return false;
-    }
-    LOG_INFO(Config, "Successfully loaded {}", config_loc_str);
-    return true;
-}
-
-template <>
-void Config::ReadSetting(const std::string& group, Settings::Setting<std::string>& setting) {
-    std::string setting_value = config->Get(group, setting.GetLabel(), setting.GetDefault());
-    if (setting_value.empty()) {
-        setting_value = setting.GetDefault();
-    }
-    setting = std::move(setting_value);
-}
-
-template <>
-void Config::ReadSetting(const std::string& group, Settings::Setting<bool>& setting) {
-    setting = config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
-}
-
-template <typename Type, bool ranged>
-void Config::ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting) {
-    setting = static_cast<Type>(
-        config->GetInteger(group, setting.GetLabel(), static_cast<long>(setting.GetDefault())));
-}
-
-void Config::ReadValues() {
-    ReadSetting("ControlsGeneral", Settings::values.mouse_enabled);
-    ReadSetting("ControlsGeneral", Settings::values.touch_device);
-    ReadSetting("ControlsGeneral", Settings::values.keyboard_enabled);
-    ReadSetting("ControlsGeneral", Settings::values.debug_pad_enabled);
-    ReadSetting("ControlsGeneral", Settings::values.vibration_enabled);
-    ReadSetting("ControlsGeneral", Settings::values.enable_accurate_vibrations);
-    ReadSetting("ControlsGeneral", Settings::values.motion_enabled);
-    Settings::values.touchscreen.enabled =
-        config->GetBoolean("ControlsGeneral", "touch_enabled", true);
-    Settings::values.touchscreen.rotation_angle =
-        config->GetInteger("ControlsGeneral", "touch_angle", 0);
-    Settings::values.touchscreen.diameter_x =
-        config->GetInteger("ControlsGeneral", "touch_diameter_x", 15);
-    Settings::values.touchscreen.diameter_y =
-        config->GetInteger("ControlsGeneral", "touch_diameter_y", 15);
-
-    int num_touch_from_button_maps =
-        config->GetInteger("ControlsGeneral", "touch_from_button_map", 0);
-    if (num_touch_from_button_maps > 0) {
-        for (int i = 0; i < num_touch_from_button_maps; ++i) {
-            Settings::TouchFromButtonMap map;
-            map.name = config->Get("ControlsGeneral",
-                                   std::string("touch_from_button_maps_") + std::to_string(i) +
-                                       std::string("_name"),
-                                   "default");
-            const int num_touch_maps = config->GetInteger(
-                "ControlsGeneral",
-                std::string("touch_from_button_maps_") + std::to_string(i) + std::string("_count"),
-                0);
-            map.buttons.reserve(num_touch_maps);
-
-            for (int j = 0; j < num_touch_maps; ++j) {
-                std::string touch_mapping =
-                    config->Get("ControlsGeneral",
-                                std::string("touch_from_button_maps_") + std::to_string(i) +
-                                    std::string("_bind_") + std::to_string(j),
-                                "");
-                map.buttons.emplace_back(std::move(touch_mapping));
-            }
-
-            Settings::values.touch_from_button_maps.emplace_back(std::move(map));
-        }
-    } else {
-        Settings::values.touch_from_button_maps.emplace_back(
-            Settings::TouchFromButtonMap{"default", {}});
-        num_touch_from_button_maps = 1;
-    }
-    Settings::values.touch_from_button_map_index = std::clamp(
-        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
-
-    ReadSetting("ControlsGeneral", Settings::values.udp_input_servers);
-
-    // Data Storage
-    ReadSetting("Data Storage", Settings::values.use_virtual_sd);
-    FS::SetYuzuPath(FS::YuzuPath::NANDDir,
-                    config->Get("Data Storage", "nand_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
-    FS::SetYuzuPath(FS::YuzuPath::SDMCDir,
-                    config->Get("Data Storage", "sdmc_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)));
-    FS::SetYuzuPath(FS::YuzuPath::LoadDir,
-                    config->Get("Data Storage", "load_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::LoadDir)));
-    FS::SetYuzuPath(FS::YuzuPath::DumpDir,
-                    config->Get("Data Storage", "dump_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    ReadSetting("Data Storage", Settings::values.gamecard_inserted);
-    ReadSetting("Data Storage", Settings::values.gamecard_current_game);
-    ReadSetting("Data Storage", Settings::values.gamecard_path);
-
-    // System
-    ReadSetting("System", Settings::values.current_user);
-    Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
-                                                    Service::Account::MAX_USERS - 1);
-
-    // Disable docked mode by default on Android
-    Settings::values.use_docked_mode.SetValue(config->GetBoolean("System", "use_docked_mode", false)
-                                                  ? Settings::ConsoleMode::Docked
-                                                  : Settings::ConsoleMode::Handheld);
-
-    const auto rng_seed_enabled = config->GetBoolean("System", "rng_seed_enabled", false);
-    if (rng_seed_enabled) {
-        Settings::values.rng_seed.SetValue(config->GetInteger("System", "rng_seed", 0));
-    } else {
-        Settings::values.rng_seed.SetValue(0);
-    }
-    Settings::values.rng_seed_enabled.SetValue(rng_seed_enabled);
-
-    const auto custom_rtc_enabled = config->GetBoolean("System", "custom_rtc_enabled", false);
-    if (custom_rtc_enabled) {
-        Settings::values.custom_rtc = config->GetInteger("System", "custom_rtc", 0);
-    } else {
-        Settings::values.custom_rtc = 0;
-    }
-    Settings::values.custom_rtc_enabled = custom_rtc_enabled;
-
-    ReadSetting("System", Settings::values.language_index);
-    ReadSetting("System", Settings::values.region_index);
-    ReadSetting("System", Settings::values.time_zone_index);
-    ReadSetting("System", Settings::values.sound_index);
-
-    // Core
-    ReadSetting("Core", Settings::values.use_multi_core);
-    ReadSetting("Core", Settings::values.memory_layout_mode);
-
-    // Cpu
-    ReadSetting("Cpu", Settings::values.cpu_backend);
-    ReadSetting("Cpu", Settings::values.cpu_accuracy);
-    ReadSetting("Cpu", Settings::values.cpu_debug_mode);
-    ReadSetting("Cpu", Settings::values.cpuopt_page_tables);
-    ReadSetting("Cpu", Settings::values.cpuopt_block_linking);
-    ReadSetting("Cpu", Settings::values.cpuopt_return_stack_buffer);
-    ReadSetting("Cpu", Settings::values.cpuopt_fast_dispatcher);
-    ReadSetting("Cpu", Settings::values.cpuopt_context_elimination);
-    ReadSetting("Cpu", Settings::values.cpuopt_const_prop);
-    ReadSetting("Cpu", Settings::values.cpuopt_misc_ir);
-    ReadSetting("Cpu", Settings::values.cpuopt_reduce_misalign_checks);
-    ReadSetting("Cpu", Settings::values.cpuopt_fastmem);
-    ReadSetting("Cpu", Settings::values.cpuopt_fastmem_exclusives);
-    ReadSetting("Cpu", Settings::values.cpuopt_recompile_exclusives);
-    ReadSetting("Cpu", Settings::values.cpuopt_ignore_memory_aborts);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_unfuse_fma);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_reduce_fp_error);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_inaccurate_nan);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_fastmem_check);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_global_monitor);
-
-    // Renderer
-    ReadSetting("Renderer", Settings::values.renderer_backend);
-    ReadSetting("Renderer", Settings::values.renderer_debug);
-    ReadSetting("Renderer", Settings::values.renderer_shader_feedback);
-    ReadSetting("Renderer", Settings::values.enable_nsight_aftermath);
-    ReadSetting("Renderer", Settings::values.disable_shader_loop_safety_checks);
-    ReadSetting("Renderer", Settings::values.vulkan_device);
-
-    ReadSetting("Renderer", Settings::values.resolution_setup);
-    ReadSetting("Renderer", Settings::values.scaling_filter);
-    ReadSetting("Renderer", Settings::values.fsr_sharpening_slider);
-    ReadSetting("Renderer", Settings::values.anti_aliasing);
-    ReadSetting("Renderer", Settings::values.fullscreen_mode);
-    ReadSetting("Renderer", Settings::values.aspect_ratio);
-    ReadSetting("Renderer", Settings::values.max_anisotropy);
-    ReadSetting("Renderer", Settings::values.use_speed_limit);
-    ReadSetting("Renderer", Settings::values.speed_limit);
-    ReadSetting("Renderer", Settings::values.use_disk_shader_cache);
-    ReadSetting("Renderer", Settings::values.use_asynchronous_gpu_emulation);
-    ReadSetting("Renderer", Settings::values.vsync_mode);
-    ReadSetting("Renderer", Settings::values.shader_backend);
-    ReadSetting("Renderer", Settings::values.use_asynchronous_shaders);
-    ReadSetting("Renderer", Settings::values.nvdec_emulation);
-    ReadSetting("Renderer", Settings::values.use_fast_gpu_time);
-    ReadSetting("Renderer", Settings::values.use_vulkan_driver_pipeline_cache);
-
-    ReadSetting("Renderer", Settings::values.bg_red);
-    ReadSetting("Renderer", Settings::values.bg_green);
-    ReadSetting("Renderer", Settings::values.bg_blue);
-
-    // Use GPU accuracy normal by default on Android
-    Settings::values.gpu_accuracy = static_cast<Settings::GpuAccuracy>(config->GetInteger(
-        "Renderer", "gpu_accuracy", static_cast<u32>(Settings::GpuAccuracy::Normal)));
-
-    // Use GPU default anisotropic filtering on Android
-    Settings::values.max_anisotropy =
-        static_cast<Settings::AnisotropyMode>(config->GetInteger("Renderer", "max_anisotropy", 1));
-
-    // Disable ASTC compute by default on Android
-    Settings::values.accelerate_astc.SetValue(
-        config->GetBoolean("Renderer", "accelerate_astc", false) ? Settings::AstcDecodeMode::Gpu
-                                                                 : Settings::AstcDecodeMode::Cpu);
-
-    // Enable asynchronous presentation by default on Android
-    Settings::values.async_presentation =
-        config->GetBoolean("Renderer", "async_presentation", true);
-
-    // Disable force_max_clock by default on Android
-    Settings::values.renderer_force_max_clock =
-        config->GetBoolean("Renderer", "force_max_clock", false);
-
-    // Disable use_reactive_flushing by default on Android
-    Settings::values.use_reactive_flushing =
-        config->GetBoolean("Renderer", "use_reactive_flushing", false);
-
-    // Audio
-    ReadSetting("Audio", Settings::values.sink_id);
-    ReadSetting("Audio", Settings::values.audio_output_device_id);
-    ReadSetting("Audio", Settings::values.volume);
-
-    // Miscellaneous
-    // log_filter has a different default here than from common
-    Settings::values.log_filter = "*:Info";
-    ReadSetting("Miscellaneous", Settings::values.use_dev_keys);
-
-    // Debugging
-    Settings::values.record_frame_times =
-        config->GetBoolean("Debugging", "record_frame_times", false);
-    ReadSetting("Debugging", Settings::values.dump_exefs);
-    ReadSetting("Debugging", Settings::values.dump_nso);
-    ReadSetting("Debugging", Settings::values.enable_fs_access_log);
-    ReadSetting("Debugging", Settings::values.reporting_services);
-    ReadSetting("Debugging", Settings::values.quest_flag);
-    ReadSetting("Debugging", Settings::values.use_debug_asserts);
-    ReadSetting("Debugging", Settings::values.use_auto_stub);
-    ReadSetting("Debugging", Settings::values.disable_macro_jit);
-    ReadSetting("Debugging", Settings::values.disable_macro_hle);
-    ReadSetting("Debugging", Settings::values.use_gdbstub);
-    ReadSetting("Debugging", Settings::values.gdbstub_port);
-
-    const auto title_list = config->Get("AddOns", "title_ids", "");
-    std::stringstream ss(title_list);
-    std::string line;
-    while (std::getline(ss, line, '|')) {
-        const auto title_id = std::strtoul(line.c_str(), nullptr, 16);
-        const auto disabled_list = config->Get("AddOns", "disabled_" + line, "");
-
-        std::stringstream inner_ss(disabled_list);
-        std::string inner_line;
-        std::vector<std::string> out;
-        while (std::getline(inner_ss, inner_line, '|')) {
-            out.push_back(inner_line);
-        }
-
-        Settings::values.disabled_addons.insert_or_assign(title_id, out);
-    }
-
-    // Web Service
-    ReadSetting("WebService", Settings::values.enable_telemetry);
-    ReadSetting("WebService", Settings::values.web_api_url);
-    ReadSetting("WebService", Settings::values.yuzu_username);
-    ReadSetting("WebService", Settings::values.yuzu_token);
-
-    // Network
-    ReadSetting("Network", Settings::values.network_interface);
-
-    // Android
-    ReadSetting("Android", AndroidSettings::values.picture_in_picture);
-    ReadSetting("Android", AndroidSettings::values.screen_layout);
-}
-
-void Config::Initialize(const std::string& config_name) {
-    const auto fs_config_loc = FS::GetYuzuPath(FS::YuzuPath::ConfigDir);
-    const auto config_file = fmt::format("{}.ini", config_name);
-
-    switch (type) {
-    case ConfigType::GlobalConfig:
-        config_loc = FS::PathToUTF8String(fs_config_loc / config_file);
-        break;
-    case ConfigType::PerGameConfig:
-        config_loc = FS::PathToUTF8String(fs_config_loc / "custom" / FS::ToU8String(config_file));
-        break;
-    case ConfigType::InputProfile:
-        config_loc = FS::PathToUTF8String(fs_config_loc / "input" / config_file);
-        LoadINI(DefaultINI::android_config_file);
-        return;
-    }
-    LoadINI(DefaultINI::android_config_file);
-    ReadValues();
-}

src/android/app/src/main/jni/config.h

@@ -1,47 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <filesystem>
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "common/settings.h"
-
-class INIReader;
-
-class Config {
-    bool LoadINI(const std::string& default_contents = "", bool retry = true);
-
-public:
-    enum class ConfigType {
-        GlobalConfig,
-        PerGameConfig,
-        InputProfile,
-    };
-
-    explicit Config(const std::string& config_name = "config",
-                    ConfigType config_type = ConfigType::GlobalConfig);
-    ~Config();
-
-    void Initialize(const std::string& config_name);
-
-private:
-    /**
-     * Applies a value read from the config to a Setting.
-     *
-     * @param group The name of the INI group
-     * @param setting The yuzu setting to modify
-     */
-    template <typename Type, bool ranged>
-    void ReadSetting(const std::string& group, Settings::Setting<Type, ranged>& setting);
-
-    void ReadValues();
-
-    const ConfigType type;
-    std::unique_ptr<INIReader> config;
-    std::string config_loc;
-    const bool global;
-};

src/android/app/src/main/jni/default_ini.h

@@ -1,515 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-namespace DefaultINI {
-
-const char* android_config_file = R"(
-
-[ControlsP0]
-# The input devices and parameters for each Switch native input
-# The config section determines the player number where the config will be applied on. For example "ControlsP0", "ControlsP1", ...
-# It should be in the format of "engine:[engine_name],[param1]:[value1],[param2]:[value2]..."
-# Escape characters $0 (for ':'), $1 (for ',') and $2 (for '$') can be used in values
-
-# Indicates if this player should be connected at boot
-connected=
-
-# for button input, the following devices are available:
-#  - "keyboard" (default) for keyboard input. Required parameters:
-#      - "code": the code of the key to bind
-#  - "sdl" for joystick input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "button"(optional): the index of the button to bind
-#      - "hat"(optional): the index of the hat to bind as direction buttons
-#      - "axis"(optional): the index of the axis to bind
-#      - "direction"(only used for hat): the direction name of the hat to bind. Can be "up", "down", "left" or "right"
-#      - "threshold"(only used for axis): a float value in (-1.0, 1.0) which the button is
-#          triggered if the axis value crosses
-#      - "direction"(only used for axis): "+" means the button is triggered when the axis value
-#          is greater than the threshold; "-" means the button is triggered when the axis value
-#          is smaller than the threshold
-button_a=
-button_b=
-button_x=
-button_y=
-button_lstick=
-button_rstick=
-button_l=
-button_r=
-button_zl=
-button_zr=
-button_plus=
-button_minus=
-button_dleft=
-button_dup=
-button_dright=
-button_ddown=
-button_lstick_left=
-button_lstick_up=
-button_lstick_right=
-button_lstick_down=
-button_sl=
-button_sr=
-button_home=
-button_screenshot=
-
-# for analog input, the following devices are available:
-#  - "analog_from_button" (default) for emulating analog input from direction buttons. Required parameters:
-#      - "up", "down", "left", "right": sub-devices for each direction.
-#          Should be in the format as a button input devices using escape characters, for example, "engine$0keyboard$1code$00"
-#      - "modifier": sub-devices as a modifier.
-#      - "modifier_scale": a float number representing the applied modifier scale to the analog input.
-#          Must be in range of 0.0-1.0. Defaults to 0.5
-#  - "sdl" for joystick input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "axis_x": the index of the axis to bind as x-axis (default to 0)
-#      - "axis_y": the index of the axis to bind as y-axis (default to 1)
-lstick=
-rstick=
-
-# for motion input, the following devices are available:
-#  - "keyboard" (default) for emulating random motion input from buttons. Required parameters:
-#      - "code": the code of the key to bind
-#  - "sdl" for motion input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "motion": the index of the motion sensor to bind
-#  - "cemuhookudp" for motion input using Cemu Hook protocol. Required parameters:
-#      - "guid": the IP address of the cemu hook server encoded to a hex string. for example 192.168.0.1 = "c0a80001"
-#      - "port": the port of the cemu hook server
-#      - "pad": the index of the joystick
-#      - "motion": the index of the motion sensor of the joystick to bind
-motionleft=
-motionright=
-
-[ControlsGeneral]
-# To use the debug_pad, prepend `debug_pad_` before each button setting above.
-# i.e. debug_pad_button_a=
-
-# Enable debug pad inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-debug_pad_enabled =
-
-# Whether to enable or disable vibration
-# 0: Disabled, 1 (default): Enabled
-vibration_enabled=
-
-# Whether to enable or disable accurate vibrations
-# 0 (default): Disabled, 1: Enabled
-enable_accurate_vibrations=
-
-# Enables controller motion inputs
-# 0: Disabled, 1 (default): Enabled
-motion_enabled =
-
-# Defines the udp device's touch screen coordinate system for cemuhookudp devices
-#  - "min_x", "min_y", "max_x", "max_y"
-touch_device=
-
-# for mapping buttons to touch inputs.
-#touch_from_button_map=1
-#touch_from_button_maps_0_name=default
-#touch_from_button_maps_0_count=2
-#touch_from_button_maps_0_bind_0=foo
-#touch_from_button_maps_0_bind_1=bar
-# etc.
-
-# List of Cemuhook UDP servers, delimited by ','.
-# Default: 127.0.0.1:26760
-# Example: 127.0.0.1:26760,123.4.5.67:26761
-udp_input_servers =
-
-# Enable controlling an axis via a mouse input.
-# 0 (default): Off, 1: On
-mouse_panning =
-
-# Set mouse sensitivity.
-# Default: 1.0
-mouse_panning_sensitivity =
-
-# Emulate an analog control stick from keyboard inputs.
-# 0 (default): Disabled, 1: Enabled
-emulate_analog_keyboard =
-
-# Enable mouse inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-mouse_enabled =
-
-# Enable keyboard inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-keyboard_enabled =
-
-[Core]
-# Whether to use multi-core for CPU emulation
-# 0: Disabled, 1 (default): Enabled
-use_multi_core =
-
-# Enable unsafe extended guest system memory layout (8GB DRAM)
-# 0 (default): Disabled, 1: Enabled
-use_unsafe_extended_memory_layout =
-
-[Cpu]
-Selects the preferred CPU backend for executing ARM instructions
-# 0 (default): Dynarmic, 1: NCE
-cpu_backend =
-
-# Adjusts various optimizations.
-# Auto-select mode enables choice unsafe optimizations.
-# Accurate enables only safe optimizations.
-# Unsafe allows any unsafe optimizations.
-# 0 (default): Auto-select, 1: Accurate, 2: Enable unsafe optimizations
-cpu_accuracy =
-
-# Allow disabling safe optimizations.
-# 0 (default): Disabled, 1: Enabled
-cpu_debug_mode =
-
-# Enable inline page tables optimization (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_page_tables =
-
-# Enable block linking CPU optimization (reduce block dispatcher use during predictable jumps)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_block_linking =
-
-# Enable return stack buffer CPU optimization (reduce block dispatcher use during predictable returns)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_return_stack_buffer =
-
-# Enable fast dispatcher CPU optimization (use a two-tiered dispatcher architecture)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fast_dispatcher =
-
-# Enable context elimination CPU Optimization (reduce host memory use for guest context)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_context_elimination =
-
-# Enable constant propagation CPU optimization (basic IR optimization)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_const_prop =
-
-# Enable miscellaneous CPU optimizations (basic IR optimization)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_misc_ir =
-
-# Enable reduction of memory misalignment checks (reduce memory fallbacks for misaligned access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_reduce_misalign_checks =
-
-# Enable Host MMU Emulation (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem =
-
-# Enable Host MMU Emulation for exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem_exclusives =
-
-# Enable fallback on failure of fastmem of exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_recompile_exclusives =
-
-# Enable optimization to ignore invalid memory accesses (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_ignore_memory_aborts =
-
-# Enable unfuse FMA (improve performance on CPUs without FMA)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_unfuse_fma =
-
-# Enable faster FRSQRTE and FRECPE
-# Only enabled if cpu_accuracy is set to Unsafe.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_reduce_fp_error =
-
-# Enable faster ASIMD instructions (32 bits only)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_standard_fpcr =
-
-# Enable inaccurate NaN handling
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_inaccurate_nan =
-
-# Disable address space checks (64 bits only)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_fastmem_check =
-
-# Enable faster exclusive instructions
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_global_monitor =
-
-[Renderer]
-# Which backend API to use.
-# 0: OpenGL (unsupported), 1 (default): Vulkan, 2: Null
-backend =
-
-# Whether to enable asynchronous presentation (Vulkan only)
-# 0: Off, 1 (default): On
-async_presentation =
-
-# Forces the GPU to run at the maximum possible clocks (thermal constraints will still be applied).
-# 0 (default): Disabled, 1: Enabled
-force_max_clock =
-
-# Enable graphics API debugging mode.
-# 0 (default): Disabled, 1: Enabled
-debug =
-
-# Enable shader feedback.
-# 0 (default): Disabled, 1: Enabled
-renderer_shader_feedback =
-
-# Enable Nsight Aftermath crash dumps
-# 0 (default): Disabled, 1: Enabled
-nsight_aftermath =
-
-# Disable shader loop safety checks, executing the shader without loop logic changes
-# 0 (default): Disabled, 1: Enabled
-disable_shader_loop_safety_checks =
-
-# Which Vulkan physical device to use (defaults to 0)
-vulkan_device =
-
-# 0: 0.5x (360p/540p) [EXPERIMENTAL]
-# 1: 0.75x (540p/810p) [EXPERIMENTAL]
-# 2 (default): 1x (720p/1080p)
-# 3: 2x (1440p/2160p)
-# 4: 3x (2160p/3240p)
-# 5: 4x (2880p/4320p)
-# 6: 5x (3600p/5400p)
-# 7: 6x (4320p/6480p)
-resolution_setup =
-
-# Pixel filter to use when up- or down-sampling rendered frames.
-# 0: Nearest Neighbor
-# 1 (default): Bilinear
-# 2: Bicubic
-# 3: Gaussian
-# 4: ScaleForce
-# 5: AMD FidelityFX™️ Super Resolution [Vulkan Only]
-scaling_filter =
-
-# Anti-Aliasing (AA)
-# 0 (default): None, 1: FXAA
-anti_aliasing =
-
-# Whether to use fullscreen or borderless window mode
-# 0 (Windows default): Borderless window, 1 (All other default): Exclusive fullscreen
-fullscreen_mode =
-
-# Aspect ratio
-# 0: Default (16:9), 1: Force 4:3, 2: Force 21:9, 3: Force 16:10, 4: Stretch to Window
-aspect_ratio =
-
-# Anisotropic filtering
-# 0: Default, 1: 2x, 2: 4x, 3: 8x, 4: 16x
-max_anisotropy =
-
-# Whether to enable VSync or not.
-# OpenGL: Values other than 0 enable VSync
-# Vulkan: FIFO is selected if the requested mode is not supported by the driver.
-# FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen refresh rate.
-# FIFO Relaxed is similar to FIFO but allows tearing as it recovers from a slow down.
-# Mailbox can have lower latency than FIFO and does not tear but may drop frames.
-# Immediate (no synchronization) just presents whatever is available and can exhibit tearing.
-# 0: Immediate (Off), 1 (Default): Mailbox (On), 2: FIFO, 3: FIFO Relaxed
-use_vsync =
-
-# Selects the OpenGL shader backend. NV_gpu_program5 is required for GLASM. If NV_gpu_program5 is
-# not available and GLASM is selected, GLSL will be used.
-# 0: GLSL, 1 (default): GLASM, 2: SPIR-V
-shader_backend =
-
-# Whether to allow asynchronous shader building.
-# 0 (default): Off, 1: On
-use_asynchronous_shaders =
-
-# Uses reactive flushing instead of predictive flushing. Allowing a more accurate syncing of memory.
-# 0 (default): Off, 1: On
-use_reactive_flushing =
-
-# NVDEC emulation.
-# 0: Disabled, 1: CPU Decoding, 2 (default): GPU Decoding
-nvdec_emulation =
-
-# Accelerate ASTC texture decoding.
-# 0 (default): Off, 1: On
-accelerate_astc =
-
-# Turns on the speed limiter, which will limit the emulation speed to the desired speed limit value
-# 0: Off, 1: On (default)
-use_speed_limit =
-
-# Limits the speed of the game to run no faster than this value as a percentage of target speed
-# 1 - 9999: Speed limit as a percentage of target game speed. 100 (default)
-speed_limit =
-
-# Whether to use disk based shader cache
-# 0: Off, 1 (default): On
-use_disk_shader_cache =
-
-# Which gpu accuracy level to use
-# 0 (default): Normal, 1: High, 2: Extreme (Very slow)
-gpu_accuracy =
-
-# Whether to use asynchronous GPU emulation
-# 0 : Off (slow), 1 (default): On (fast)
-use_asynchronous_gpu_emulation =
-
-# Inform the guest that GPU operations completed more quickly than they did.
-# 0: Off, 1 (default): On
-use_fast_gpu_time =
-
-# Force unmodified buffers to be flushed, which can cost performance.
-# 0: Off (default), 1: On
-use_pessimistic_flushes =
-
-# Whether to use garbage collection or not for GPU caches.
-# 0 (default): Off, 1: On
-use_caches_gc =
-
-# The clear color for the renderer. What shows up on the sides of the bottom screen.
-# Must be in range of 0-255. Defaults to 0 for all.
-bg_red =
-bg_blue =
-bg_green =
-
-[Audio]
-# Which audio output engine to use.
-# auto (default): Auto-select
-# cubeb: Cubeb audio engine (if available)
-# sdl2: SDL2 audio engine (if available)
-# null: No audio output
-output_engine =
-
-# Which audio device to use.
-# auto (default): Auto-select
-output_device =
-
-# Output volume.
-# 100 (default): 100%, 0; mute
-volume =
-
-[Data Storage]
-# Whether to create a virtual SD card.
-# 1: Yes, 0 (default): No
-use_virtual_sd =
-
-# Whether or not to enable gamecard emulation
-# 1: Yes, 0 (default): No
-gamecard_inserted =
-
-# Whether or not the gamecard should be emulated as the current game
-# If 'gamecard_inserted' is 0 this setting is irrelevant
-# 1: Yes, 0 (default): No
-gamecard_current_game =
-
-# Path to an XCI file to use as the gamecard
-# If 'gamecard_inserted' is 0 this setting is irrelevant
-# If 'gamecard_current_game' is 1 this setting is irrelevant
-gamecard_path =
-
-[System]
-# Whether the system is docked
-# 1 (default): Yes, 0: No
-use_docked_mode =
-
-# Sets the seed for the RNG generator built into the switch
-# rng_seed will be ignored and randomly generated if rng_seed_enabled is false
-rng_seed_enabled =
-rng_seed =
-
-# Sets the current time (in seconds since 12:00 AM Jan 1, 1970) that will be used by the time service
-# This will auto-increment, with the time set being the time the game is started
-# This override will only occur if custom_rtc_enabled is true, otherwise the current time is used
-custom_rtc_enabled =
-custom_rtc =
-
-# Sets the systems language index
-# 0: Japanese, 1: English (default), 2: French, 3: German, 4: Italian, 5: Spanish, 6: Chinese,
-# 7: Korean, 8: Dutch, 9: Portuguese, 10: Russian, 11: Taiwanese, 12: British English, 13: Canadian French,
-# 14: Latin American Spanish, 15: Simplified Chinese, 16: Traditional Chinese, 17: Brazilian Portuguese
-language_index =
-
-# The system region that yuzu will use during emulation
-# -1: Auto-select (default), 0: Japan, 1: USA, 2: Europe, 3: Australia, 4: China, 5: Korea, 6: Taiwan
-region_index =
-
-# The system time zone that yuzu will use during emulation
-# 0: Auto-select (default), 1: Default (system archive value), Others: Index for specified time zone
-time_zone_index =
-
-# Sets the sound output mode.
-# 0: Mono, 1 (default): Stereo, 2: Surround
-sound_index =
-
-[Miscellaneous]
-# A filter which removes logs below a certain logging level.
-# Examples: *:Debug Kernel.SVC:Trace Service.*:Critical
-log_filter = *:Trace
-
-# Use developer keys
-# 0 (default): Disabled, 1: Enabled
-use_dev_keys =
-
-[Debugging]
-# Record frame time data, can be found in the log directory. Boolean value
-record_frame_times =
-# Determines whether or not yuzu will dump the ExeFS of all games it attempts to load while loading them
-dump_exefs=false
-# Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
-dump_nso=false
-# Determines whether or not yuzu will save the filesystem access log.
-enable_fs_access_log=false
-# Enables verbose reporting services
-reporting_services =
-# Determines whether or not yuzu will report to the game that the emulated console is in Kiosk Mode
-# false: Retail/Normal Mode (default), true: Kiosk Mode
-quest_flag =
-# Determines whether debug asserts should be enabled, which will throw an exception on asserts.
-# false: Disabled (default), true: Enabled
-use_debug_asserts =
-# Determines whether unimplemented HLE service calls should be automatically stubbed.
-# false: Disabled (default), true: Enabled
-use_auto_stub =
-# Enables/Disables the macro JIT compiler
-disable_macro_jit=false
-# Determines whether to enable the GDB stub and wait for the debugger to attach before running.
-# false: Disabled (default), true: Enabled
-use_gdbstub=false
-# The port to use for the GDB server, if it is enabled.
-gdbstub_port=6543
-
-[WebService]
-# Whether or not to enable telemetry
-# 0: No, 1 (default): Yes
-enable_telemetry =
-# URL for Web API
-web_api_url = https://api.yuzu-emu.org
-# Username and token for yuzu Web Service
-# See https://profile.yuzu-emu.org/ for more info
-yuzu_username =
-yuzu_token =
-
-[Network]
-# Name of the network interface device to use with yuzu LAN play.
-# e.g. On *nix: 'enp7s0', 'wlp6s0u1u3u3', 'lo'
-# e.g. On Windows: 'Ethernet', 'Wi-Fi'
-network_interface =
-
-[AddOns]
-# Used to disable add-ons
-# List of title IDs of games that will have add-ons disabled (separated by '|'):
-title_ids =
-# For each title ID, have a key/value pair called `disabled_<title_id>` equal to the names of the add-ons to disable (sep. by '|')
-# e.x. disabled_0100000000010000 = Update|DLC <- disables Updates and DLC on Super Mario Odyssey
-)";
-} // namespace DefaultINI

src/android/app/src/main/jni/native.cpp

@@ -52,8 +52,8 @@
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
+#include "frontend_common/config.h"
 #include "jni/android_common/android_common.h"
-#include "jni/config.h"
 #include "jni/id_cache.h"
 #include "jni/native.h"
 #include "video_core/renderer_base.h"
@@ -664,8 +664,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_onTouchReleased(JNIEnv* env, jclass c
 
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeSystem(JNIEnv* env, jclass clazz,
                                                             jboolean reload) {
-    // Create the default config.ini.
-    Config{};
     // Initialize the emulated system.
     if (!reload) {
         EmulationSession::GetInstance().System().Initialize();
@@ -680,17 +678,6 @@ jint Java_org_yuzu_yuzu_1emu_NativeLibrary_defaultCPUCore(JNIEnv* env, jclass cl
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_run__Ljava_lang_String_2Ljava_lang_String_2Z(
     JNIEnv* env, jclass clazz, jstring j_file, jstring j_savestate, jboolean j_delete_savestate) {}
 
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_reloadSettings(JNIEnv* env, jclass clazz) {
-    Config{};
-}
-
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_initGameIni(JNIEnv* env, jclass clazz,
-                                                       jstring j_game_id) {
-    std::string_view game_id = env->GetStringUTFChars(j_game_id, 0);
-
-    env->ReleaseStringUTFChars(j_game_id, game_id.data());
-}
-
 jdoubleArray Java_org_yuzu_yuzu_1emu_NativeLibrary_getPerfStats(JNIEnv* env, jclass clazz) {
     jdoubleArray j_stats = env->NewDoubleArray(4);
 
@@ -707,6 +694,14 @@ jdoubleArray Java_org_yuzu_yuzu_1emu_NativeLibrary_getPerfStats(JNIEnv* env, jcl
     return j_stats;
 }
 
+jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getCpuBackend(JNIEnv* env, jclass clazz) {
+    if (Settings::IsNceEnabled()) {
+        return ToJString(env, "NCE");
+    }
+
+    return ToJString(env, "JIT");
+}
+
 void Java_org_yuzu_yuzu_1emu_utils_DirectoryInitialization_setSysDirectory(JNIEnv* env,
                                                                            jclass clazz,
                                                                            jstring j_path) {}

src/android/app/src/main/jni/native_config.cpp

@@ -5,11 +5,14 @@
 
 #include <jni.h>
 
+#include "android_config.h"
+#include "android_settings.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "frontend_common/config.h"
 #include "jni/android_common/android_common.h"
-#include "jni/config.h"
-#include "uisettings.h"
+
+std::unique_ptr<AndroidConfig> config;
 
 template <typename T>
 Settings::Setting<T>* getSetting(JNIEnv* env, jstring jkey) {
@@ -28,6 +31,22 @@ Settings::Setting<T>* getSetting(JNIEnv* env, jstring jkey) {
 
 extern "C" {
 
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_initializeConfig(JNIEnv* env, jobject obj) {
+    config = std::make_unique<AndroidConfig>();
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_unloadConfig(JNIEnv* env, jobject obj) {
+    config.reset();
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_reloadSettings(JNIEnv* env, jobject obj) {
+    config->AndroidConfig::ReloadAllValues();
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_NativeConfig_saveSettings(JNIEnv* env, jobject obj) {
+    config->AndroidConfig::SaveAllValues();
+}
+
 jboolean Java_org_yuzu_yuzu_1emu_utils_NativeConfig_getBoolean(JNIEnv* env, jobject obj,
                                                                jstring jkey, jboolean getDefault) {
     auto setting = getSetting<bool>(env, jkey);

src/android/app/src/main/res/layout/fragment_search.xml

@@ -127,6 +127,7 @@
             android:layout_height="wrap_content"
             android:clipToPadding="false"
             android:paddingVertical="4dp"
+            app:checkedChip="@id/chip_recently_played"
             app:chipSpacingHorizontal="12dp"
             app:singleLine="true"
             app:singleSelection="true">

src/android/app/src/main/res/values/arrays.xml

@@ -175,16 +175,24 @@
         <item>2</item>
     </integer-array>
 
-    <string-array name="cpuBackendNames">
+    <string-array name="cpuBackendArm64Names">
         <item>@string/cpu_backend_dynarmic</item>
         <item>@string/cpu_backend_nce</item>
     </string-array>
 
-    <integer-array name="cpuBackendValues">
+    <integer-array name="cpuBackendArm64Values">
         <item>0</item>
         <item>1</item>
     </integer-array>
 
+    <string-array name="cpuBackendX86Names">
+        <item>@string/cpu_backend_dynarmic</item>
+    </string-array>
+
+    <integer-array name="cpuBackendX86Values">
+        <item>0</item>
+    </integer-array>
+
     <string-array name="cpuAccuracyNames">
         <item>@string/auto</item>
         <item>@string/cpu_accuracy_accurate</item>

src/android/app/src/main/res/values/strings.xml

@@ -91,6 +91,7 @@
     <string name="manage_save_data">Manage save data</string>
     <string name="manage_save_data_description">Save data found. Please select an option below.</string>
     <string name="import_export_saves_description">Import or export save files</string>
+    <string name="save_files_exporting">Exporting save files…</string>
     <string name="save_file_imported_success">Imported successfully</string>
     <string name="save_file_invalid_zip_structure">Invalid save directory structure</string>
     <string name="save_file_invalid_zip_structure_description">The first subfolder name must be the title ID of the game.</string>
@@ -184,7 +185,7 @@
     <string name="frame_limit_enable_description">Limits emulation speed to a specified percentage of normal speed.</string>
     <string name="frame_limit_slider">Limit speed percent</string>
     <string name="frame_limit_slider_description">Specifies the percentage to limit emulation speed. 100% is the normal speed. Values higher or lower will increase or decrease the speed limit.</string>
-    <string name="cpu_backend">CPU Backend</string>
+    <string name="cpu_backend">CPU backend</string>
     <string name="cpu_accuracy">CPU accuracy</string>
     <string name="value_with_units">%1$s%2$s</string>
 
@@ -257,6 +258,7 @@
     <string name="cancelling">Cancelling</string>
     <string name="install">Install</string>
     <string name="delete">Delete</string>
+    <string name="export_success">Exported successfully</string>
 
     <!-- GPU driver installation -->
     <string name="select_gpu_driver">Select GPU driver</string>

src/common/host_memory.cpp

@@ -363,21 +363,12 @@ private:
 
 #ifdef ARCHITECTURE_arm64
 
-static uint64_t GetRandomU64() {
-    uint64_t ret;
-    ASSERT(getrandom(&ret, sizeof(ret), 0) == 0);
-    return ret;
-}
-
 static void* ChooseVirtualBase(size_t virtual_size) {
     constexpr uintptr_t Map39BitSize = (1ULL << 39);
     constexpr uintptr_t Map36BitSize = (1ULL << 36);
 
-    // Seed the MT with some initial strong randomness.
-    //
-    // This is not a cryptographic application, we just want something more
-    // random than the current time.
-    std::mt19937_64 rng(GetRandomU64());
+    // This is not a cryptographic application, we just want something random.
+    std::mt19937_64 rng;
 
     // We want to ensure we are allocating at an address aligned to the L2 block size.
     // For Qualcomm devices, we must also allocate memory above 36 bits.

src/common/settings.cpp

@@ -160,7 +160,7 @@ static bool is_nce_enabled = false;
 
 void SetNceEnabled(bool is_39bit) {
     const bool is_nce_selected = values.cpu_backend.GetValue() == CpuBackend::Nce;
-    is_nce_enabled = is_nce_selected && is_39bit;
+    is_nce_enabled = IsFastmemEnabled() && is_nce_selected && is_39bit;
     if (is_nce_selected && !is_nce_enabled) {
         LOG_WARNING(
             Common,
@@ -223,9 +223,9 @@ const char* TranslateCategory(Category category) {
     case Category::UiAudio:
         return "UiAudio";
     case Category::UiLayout:
-        return "UiLayout";
+        return "UILayout";
     case Category::UiGameList:
-        return "UiGameList";
+        return "UIGameList";
     case Category::Screenshots:
         return "Screenshots";
     case Category::Shortcuts:

src/common/settings.h

@@ -241,7 +241,11 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_gpu_emulation{
         linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
     SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
+#ifdef ANDROID
+                                                            AstcDecodeMode::Cpu,
+#else
                                                             AstcDecodeMode::Gpu,
+#endif
                                                             AstcDecodeMode::Cpu,
                                                             AstcDecodeMode::CpuAsynchronous,
                                                             "accelerate_astc",
@@ -313,7 +317,11 @@ struct Values {
         linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
 
     SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
+#ifdef ANDROID
+                                                      GpuAccuracy::Normal,
+#else
                                                       GpuAccuracy::High,
+#endif
                                                       GpuAccuracy::Normal,
                                                       GpuAccuracy::Extreme,
                                                       "gpu_accuracy",
@@ -322,20 +330,38 @@ struct Values {
                                                       true,
                                                       true};
     GpuAccuracy current_gpu_accuracy{GpuAccuracy::High};
-    SwitchableSetting<AnisotropyMode, true> max_anisotropy{
-        linkage,          AnisotropyMode::Automatic, AnisotropyMode::Automatic, AnisotropyMode::X16,
-        "max_anisotropy", Category::RendererAdvanced};
+    SwitchableSetting<AnisotropyMode, true> max_anisotropy{linkage,
+#ifdef ANDROID
+                                                           AnisotropyMode::Default,
+#else
+                                                           AnisotropyMode::Automatic,
+#endif
+                                                           AnisotropyMode::Automatic,
+                                                           AnisotropyMode::X16,
+                                                           "max_anisotropy",
+                                                           Category::RendererAdvanced};
     SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
                                                                   AstcRecompression::Uncompressed,
                                                                   AstcRecompression::Uncompressed,
                                                                   AstcRecompression::Bc3,
                                                                   "astc_recompression",
                                                                   Category::RendererAdvanced};
-    SwitchableSetting<bool> async_presentation{linkage, false, "async_presentation",
-                                               Category::RendererAdvanced};
+    SwitchableSetting<bool> async_presentation{linkage,
+#ifdef ANDROID
+                                               true,
+#else
+                                               false,
+#endif
+                                               "async_presentation", Category::RendererAdvanced};
     SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
                                                      Category::RendererAdvanced};
-    SwitchableSetting<bool> use_reactive_flushing{linkage, true, "use_reactive_flushing",
+    SwitchableSetting<bool> use_reactive_flushing{linkage,
+#ifdef ANDROID
+                                                  false,
+#else
+                                                  true,
+#endif
+                                                  "use_reactive_flushing",
                                                   Category::RendererAdvanced};
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererAdvanced};
@@ -401,7 +427,11 @@ struct Values {
     Setting<s32> current_user{linkage, 0, "current_user", Category::System};
 
     SwitchableSetting<ConsoleMode> use_docked_mode{linkage,
+#ifdef ANDROID
+                                                   ConsoleMode::Handheld,
+#else
                                                    ConsoleMode::Docked,
+#endif
                                                    "use_docked_mode",
                                                    Category::System,
                                                    Specialization::Radio,

src/core/CMakeLists.txt

@@ -529,6 +529,7 @@ add_library(core STATIC
     hle/service/hid/hid_server.h
     hle/service/hid/hid_system_server.cpp
     hle/service/hid/hid_system_server.h
+    hle/service/hid/hid_util.h
     hle/service/hid/hidbus.cpp
     hle/service/hid/hidbus.h
     hle/service/hid/irs.cpp
@@ -540,8 +541,8 @@ add_library(core STATIC
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
     hle/service/hid/errors.h
-    hle/service/hid/controllers/console_sixaxis.cpp
-    hle/service/hid/controllers/console_sixaxis.h
+    hle/service/hid/controllers/console_six_axis.cpp
+    hle/service/hid/controllers/console_six_axis.h
     hle/service/hid/controllers/controller_base.cpp
     hle/service/hid/controllers/controller_base.h
     hle/service/hid/controllers/debug_pad.cpp
@@ -556,6 +557,10 @@ add_library(core STATIC
     hle/service/hid/controllers/npad.h
     hle/service/hid/controllers/palma.cpp
     hle/service/hid/controllers/palma.h
+    hle/service/hid/controllers/seven_six_axis.cpp
+    hle/service/hid/controllers/seven_six_axis.h
+    hle/service/hid/controllers/six_axis.cpp
+    hle/service/hid/controllers/six_axis.h
     hle/service/hid/controllers/stubbed.cpp
     hle/service/hid/controllers/stubbed.h
     hle/service/hid/controllers/touchscreen.cpp
@@ -921,7 +926,8 @@ if (ENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)
 endif()
 
-if (ARCHITECTURE_arm64)
+if (ARCHITECTURE_arm64 AND (ANDROID OR ${CMAKE_SYSTEM_NAME} STREQUAL "Linux"))
+    target_compile_definitions(core PRIVATE -DHAS_NCE)
     enable_language(C ASM)
     set(CMAKE_ASM_FLAGS "${CFLAGS} -x assembler-with-cpp")
 

src/core/arm/arm_interface.cpp

@@ -201,6 +201,8 @@ void ARM_Interface::Run() {
         if (True(hr & HaltReason::DataAbort)) {
             if (system.DebuggerEnabled()) {
                 system.GetDebugger().NotifyThreadWatchpoint(current_thread, *HaltedWatchpoint());
+            } else {
+                LogBacktrace();
             }
             current_thread->RequestSuspend(SuspendType::Debug);
             break;

src/core/arm/nce/arm_nce.cpp

@@ -116,10 +116,18 @@ bool ARM_NCE::HandleGuestFault(GuestContext* guest_ctx, void* raw_info, void* ra
         return true;
     }
 
-    // We can't handle the access, so trigger an exception.
+    // We can't handle the access, so determine why we crashed.
     const bool is_prefetch_abort = host_ctx.pc == reinterpret_cast<u64>(info->si_addr);
-    guest_ctx->esr_el1.fetch_or(
-        static_cast<u64>(is_prefetch_abort ? HaltReason::PrefetchAbort : HaltReason::DataAbort));
+
+    // For data aborts, skip the instruction and return to guest code.
+    // This will allow games to continue in many scenarios where they would otherwise crash.
+    if (!is_prefetch_abort) {
+        host_ctx.pc += 4;
+        return true;
+    }
+
+    // This is a prefetch abort.
+    guest_ctx->esr_el1.fetch_or(static_cast<u64>(HaltReason::PrefetchAbort));
 
     // Forcibly mark the context as locked. We are still running.
     // We may race with SignalInterrupt here:

src/core/arm/nce/patch.cpp

@@ -20,6 +20,7 @@ using namespace oaknut::util;
 using NativeExecutionParameters = Kernel::KThread::NativeExecutionParameters;
 
 constexpr size_t MaxRelativeBranch = 128_MiB;
+constexpr u32 ModuleCodeIndex = 0x24 / sizeof(u32);
 
 Patcher::Patcher() : c(m_patch_instructions) {}
 
@@ -42,7 +43,7 @@ void Patcher::PatchText(const Kernel::PhysicalMemory& program_image,
         std::span<const u32>{reinterpret_cast<const u32*>(text.data()), text.size() / sizeof(u32)};
 
     // Loop through instructions, patching as needed.
-    for (u32 i = 0; i < static_cast<u32>(text_words.size()); i++) {
+    for (u32 i = ModuleCodeIndex; i < static_cast<u32>(text_words.size()); i++) {
         const u32 inst = text_words[i];
 
         const auto AddRelocations = [&] {
@@ -89,6 +90,10 @@ void Patcher::PatchText(const Kernel::PhysicalMemory& program_image,
             WriteMsrHandler(AddRelocations(), oaknut::XReg{static_cast<int>(msr.GetRt())});
             continue;
         }
+
+        if (auto exclusive = Exclusive{inst}; exclusive.Verify()) {
+            m_exclusives.push_back(i);
+        }
     }
 
     // Determine patching mode for the final relocation step
@@ -161,12 +166,10 @@ void Patcher::RelocateAndCopy(Common::ProcessAddress load_base,
     }
 
     // Cortex-A57 seems to treat all exclusives as ordered, but newer processors do not.
-    // Convert to ordered to preserve this assumption
-    for (u32 i = 0; i < static_cast<u32>(text_words.size()); i++) {
-        const u32 inst = text_words[i];
-        if (auto exclusive = Exclusive{inst}; exclusive.Verify()) {
-            text_words[i] = exclusive.AsOrdered();
-        }
+    // Convert to ordered to preserve this assumption.
+    for (const ModuleTextAddress i : m_exclusives) {
+        auto exclusive = Exclusive{text_words[i]};
+        text_words[i] = exclusive.AsOrdered();
     }
 
     // Copy to program image

src/core/arm/nce/patch.h

@@ -6,12 +6,8 @@
 #include <span>
 #include <unordered_map>
 #include <vector>
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshorten-64-to-32"
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
-#pragma GCC diagnostic pop
 
 #include "common/common_types.h"
 #include "core/hle/kernel/code_set.h"
@@ -93,6 +89,7 @@ private:
     std::vector<Relocation> m_branch_to_patch_relocations{};
     std::vector<Relocation> m_branch_to_module_relocations{};
     std::vector<Relocation> m_write_module_pc_relocations{};
+    std::vector<ModuleTextAddress> m_exclusives{};
     oaknut::Label m_save_context{};
     oaknut::Label m_load_context{};
     PatchMode mode{PatchMode::None};

src/core/device_memory.cpp

@@ -6,7 +6,7 @@
 
 namespace Core {
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
 constexpr size_t VirtualReserveSize = 1ULL << 38;
 #else
 constexpr size_t VirtualReserveSize = 1ULL << 39;

src/core/hid/emulated_controller.cpp

@@ -8,6 +8,7 @@
 #include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
+#include "core/hle/service/hid/hid_util.h"
 
 namespace Core::HID {
 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
@@ -82,7 +83,7 @@ Settings::ControllerType EmulatedController::MapNPadToSettingsType(NpadStyleInde
 }
 
 void EmulatedController::ReloadFromSettings() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
 
     for (std::size_t index = 0; index < player.buttons.size(); ++index) {
@@ -118,7 +119,7 @@ void EmulatedController::ReloadFromSettings() {
 }
 
 void EmulatedController::ReloadColorsFromSettings() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
 
     // Avoid updating colors if overridden by physical controller
@@ -215,7 +216,7 @@ void EmulatedController::LoadDevices() {
 }
 
 void EmulatedController::LoadTASParams() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     Common::ParamPackage common_params{};
     common_params.Set("engine", "tas");
     common_params.Set("port", static_cast<int>(player_index));
@@ -264,7 +265,7 @@ void EmulatedController::LoadTASParams() {
 }
 
 void EmulatedController::LoadVirtualGamepadParams() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     Common::ParamPackage common_params{};
     common_params.Set("engine", "virtual_gamepad");
     common_params.Set("port", static_cast<int>(player_index));
@@ -508,9 +509,11 @@ void EmulatedController::ReloadInput() {
         });
     }
     turbo_button_state = 0;
+    is_initalized = true;
 }
 
 void EmulatedController::UnloadInput() {
+    is_initalized = false;
     for (auto& button : button_devices) {
         button.reset();
     }
@@ -615,7 +618,7 @@ bool EmulatedController::IsConfiguring() const {
 }
 
 void EmulatedController::SaveCurrentConfig() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     auto& player = Settings::values.players.GetValue()[player_index];
     player.connected = is_connected;
     player.controller_type = MapNPadToSettingsType(npad_type);
@@ -1206,13 +1209,16 @@ void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
 }
 
 bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
+    if (!is_initalized) {
+        return false;
+    }
     if (device_index >= output_devices.size()) {
         return false;
     }
     if (!output_devices[device_index]) {
         return false;
     }
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
     const f32 strength = static_cast<f32>(player.vibration_strength) / 100.0f;
 
@@ -1238,9 +1244,13 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
 }
 
 bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
 
+    if (!is_initalized) {
+        return false;
+    }
+
     if (!player.vibration_enabled) {
         return false;
     }
@@ -1260,6 +1270,10 @@ Common::Input::DriverResult EmulatedController::SetPollingMode(
     EmulatedDeviceIndex device_index, Common::Input::PollingMode polling_mode) {
     LOG_INFO(Service_HID, "Set polling mode {}, device_index={}", polling_mode, device_index);
 
+    if (!is_initalized) {
+        return Common::Input::DriverResult::InvalidHandle;
+    }
+
     auto& left_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Left)];
     auto& right_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_output_device = output_devices[3];
@@ -1305,6 +1319,10 @@ bool EmulatedController::SetCameraFormat(
     Core::IrSensor::ImageTransferProcessorFormat camera_format) {
     LOG_INFO(Service_HID, "Set camera format {}", camera_format);
 
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& right_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& camera_output_device = output_devices[2];
 
@@ -1328,6 +1346,11 @@ void EmulatedController::SetRingParam(Common::ParamPackage param) {
 }
 
 bool EmulatedController::HasNfc() const {
+
+    if (!is_initalized) {
+        return false;
+    }
+
     const auto& nfc_output_device = output_devices[3];
 
     switch (npad_type) {
@@ -1365,6 +1388,10 @@ bool EmulatedController::RemoveNfcHandle() {
 }
 
 bool EmulatedController::StartNfcPolling() {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1376,6 +1403,10 @@ bool EmulatedController::StartNfcPolling() {
 }
 
 bool EmulatedController::StopNfcPolling() {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1387,6 +1418,10 @@ bool EmulatedController::StopNfcPolling() {
 }
 
 bool EmulatedController::ReadAmiiboData(std::vector<u8>& data) {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1399,6 +1434,10 @@ bool EmulatedController::ReadAmiiboData(std::vector<u8>& data) {
 
 bool EmulatedController::ReadMifareData(const Common::Input::MifareRequest& request,
                                         Common::Input::MifareRequest& out_data) {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1411,6 +1450,10 @@ bool EmulatedController::ReadMifareData(const Common::Input::MifareRequest& requ
 }
 
 bool EmulatedController::WriteMifareData(const Common::Input::MifareRequest& request) {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1422,6 +1465,10 @@ bool EmulatedController::WriteMifareData(const Common::Input::MifareRequest& req
 }
 
 bool EmulatedController::WriteNfc(const std::vector<u8>& data) {
+    if (!is_initalized) {
+        return false;
+    }
+
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];
 
@@ -1433,6 +1480,10 @@ bool EmulatedController::WriteNfc(const std::vector<u8>& data) {
 }
 
 void EmulatedController::SetLedPattern() {
+    if (!is_initalized) {
+        return;
+    }
+
     for (auto& device : output_devices) {
         if (!device) {
             continue;
@@ -1648,7 +1699,7 @@ void EmulatedController::SetNpadStyleIndex(NpadStyleIndex npad_type_) {
     }
     if (is_connected) {
         LOG_WARNING(Service_HID, "Controller {} type changed while it's connected",
-                    NpadIdTypeToIndex(npad_id_type));
+                    Service::HID::NpadIdTypeToIndex(npad_id_type));
     }
     npad_type = npad_type_;
 }

src/core/hid/emulated_controller.h

@@ -559,6 +559,7 @@ private:
     NpadStyleTag supported_style_tag{NpadStyleSet::All};
     bool is_connected{false};
     bool is_configuring{false};
+    bool is_initalized{false};
     bool system_buttons_enabled{true};
     f32 motion_sensitivity{Core::HID::MotionInput::IsAtRestStandard};
     u32 turbo_button_state{0};

src/core/hid/hid_core.cpp

@@ -6,6 +6,7 @@
 #include "core/hid/emulated_controller.h"
 #include "core/hid/emulated_devices.h"
 #include "core/hid/hid_core.h"
+#include "core/hle/service/hid/hid_util.h"
 
 namespace Core::HID {
 
@@ -98,11 +99,11 @@ const EmulatedDevices* HIDCore::GetEmulatedDevices() const {
 }
 
 EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) {
-    return GetEmulatedController(IndexToNpadIdType(index));
+    return GetEmulatedController(Service::HID::IndexToNpadIdType(index));
 }
 
 const EmulatedController* HIDCore::GetEmulatedControllerByIndex(std::size_t index) const {
-    return GetEmulatedController(IndexToNpadIdType(index));
+    return GetEmulatedController(Service::HID::IndexToNpadIdType(index));
 }
 
 void HIDCore::SetSupportedStyleTag(NpadStyleTag style_tag) {

src/core/hid/hid_types.h

@@ -8,6 +8,7 @@
 #include "common/common_types.h"
 #include "common/point.h"
 #include "common/uuid.h"
+#include "common/vector_math.h"
 
 namespace Core::HID {
 
@@ -218,6 +219,13 @@ enum class NpadIdType : u32 {
     Invalid = 0xFFFFFFFF,
 };
 
+enum class NpadInterfaceType : u8 {
+    Bluetooth = 1,
+    Rail = 2,
+    Usb = 3,
+    Embedded = 4,
+};
+
 // This is nn::hid::NpadStyleIndex
 enum class NpadStyleIndex : u8 {
     None = 0,
@@ -591,6 +599,29 @@ struct SixAxisSensorIcInformation {
 static_assert(sizeof(SixAxisSensorIcInformation) == 0xC8,
               "SixAxisSensorIcInformation is an invalid size");
 
+// This is nn::hid::SixAxisSensorAttribute
+struct SixAxisSensorAttribute {
+    union {
+        u32 raw{};
+        BitField<0, 1, u32> is_connected;
+        BitField<1, 1, u32> is_interpolated;
+    };
+};
+static_assert(sizeof(SixAxisSensorAttribute) == 4, "SixAxisSensorAttribute is an invalid size");
+
+// This is nn::hid::SixAxisSensorState
+struct SixAxisSensorState {
+    s64 delta_time{};
+    s64 sampling_number{};
+    Common::Vec3f accel{};
+    Common::Vec3f gyro{};
+    Common::Vec3f rotation{};
+    std::array<Common::Vec3f, 3> orientation{};
+    SixAxisSensorAttribute attribute{};
+    INSERT_PADDING_BYTES(4); // Reserved
+};
+static_assert(sizeof(SixAxisSensorState) == 0x60, "SixAxisSensorState is an invalid size");
+
 // This is nn::hid::VibrationDeviceHandle
 struct VibrationDeviceHandle {
     NpadStyleIndex npad_type{NpadStyleIndex::None};
@@ -701,60 +732,4 @@ struct UniquePadId {
 };
 static_assert(sizeof(UniquePadId) == 0x8, "UniquePadId is an invalid size");
 
-/// Converts a NpadIdType to an array index.
-constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
-    switch (npad_id_type) {
-    case NpadIdType::Player1:
-        return 0;
-    case NpadIdType::Player2:
-        return 1;
-    case NpadIdType::Player3:
-        return 2;
-    case NpadIdType::Player4:
-        return 3;
-    case NpadIdType::Player5:
-        return 4;
-    case NpadIdType::Player6:
-        return 5;
-    case NpadIdType::Player7:
-        return 6;
-    case NpadIdType::Player8:
-        return 7;
-    case NpadIdType::Handheld:
-        return 8;
-    case NpadIdType::Other:
-        return 9;
-    default:
-        return 0;
-    }
-}
-
-/// Converts an array index to a NpadIdType
-constexpr NpadIdType IndexToNpadIdType(size_t index) {
-    switch (index) {
-    case 0:
-        return NpadIdType::Player1;
-    case 1:
-        return NpadIdType::Player2;
-    case 2:
-        return NpadIdType::Player3;
-    case 3:
-        return NpadIdType::Player4;
-    case 4:
-        return NpadIdType::Player5;
-    case 5:
-        return NpadIdType::Player6;
-    case 6:
-        return NpadIdType::Player7;
-    case 7:
-        return NpadIdType::Player8;
-    case 8:
-        return NpadIdType::Handheld;
-    case 9:
-        return NpadIdType::Other;
-    default:
-        return NpadIdType::Invalid;
-    }
-}
-
 } // namespace Core::HID

src/core/hid/input_interpreter.cpp

@@ -13,14 +13,14 @@ InputInterpreter::InputInterpreter(Core::System& system)
     : npad{system.ServiceManager()
                .GetService<Service::HID::IHidServer>("hid")
                ->GetResourceManager()
-               ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)} {
+               ->GetNpad()} {
     ResetButtonStates();
 }
 
 InputInterpreter::~InputInterpreter() = default;
 
 void InputInterpreter::PollInput() {
-    const auto button_state = npad.GetAndResetPressState();
+    const auto button_state = npad->GetAndResetPressState();
 
     previous_index = current_index;
     current_index = (current_index + 1) % button_states.size();

src/core/hid/input_interpreter.h

@@ -16,7 +16,7 @@ enum class NpadButton : u64;
 }
 
 namespace Service::HID {
-class Controller_NPad;
+class NPad;
 }
 
 /**
@@ -101,7 +101,7 @@ public:
     }
 
 private:
-    Service::HID::Controller_NPad& npad;
+    std::shared_ptr<Service::HID::NPad> npad;
 
     /// Stores 9 consecutive button states polled from HID.
     std::array<Core::HID::NpadButton, 9> button_states{};

src/core/hle/kernel/code_set.h

@@ -75,6 +75,7 @@ struct CodeSet final {
         return segments[2];
     }
 
+#ifdef HAS_NCE
     Segment& PatchSegment() {
         return patch_segment;
     }
@@ -82,13 +83,17 @@ struct CodeSet final {
     const Segment& PatchSegment() const {
         return patch_segment;
     }
+#endif
 
     /// The overall data that backs this code set.
     Kernel::PhysicalMemory memory;
 
     /// The segments that comprise this code set.
     std::array<Segment, 3> segments;
+
+#ifdef HAS_NCE
     Segment patch_segment;
+#endif
 
     /// The entry point address for this code set.
     KProcessAddress entrypoint = 0;

src/core/hle/kernel/k_address_space_info.cpp

@@ -25,7 +25,7 @@ constexpr std::array<KAddressSpaceInfo, 13> AddressSpaceInfos{{
    { .bit_width = 36, .address = 2_GiB       , .size = 64_GiB  - 2_GiB  , .type = KAddressSpaceInfo::Type::MapLarge, },
    { .bit_width = 36, .address = Size_Invalid, .size = 8_GiB            , .type = KAddressSpaceInfo::Type::Heap,     },
    { .bit_width = 36, .address = Size_Invalid, .size = 6_GiB            , .type = KAddressSpaceInfo::Type::Alias,    },
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
    // With NCE, we use a 38-bit address space due to memory limitations. This should (safely) truncate ASLR region.
    { .bit_width = 39, .address = 128_MiB     , .size = 256_GiB - 128_MiB, .type = KAddressSpaceInfo::Type::Map39Bit, },
 #else

src/core/hle/kernel/k_page_table_base.cpp

@@ -96,7 +96,7 @@ constexpr Common::MemoryPermission ConvertToMemoryPermission(KMemoryPermission p
     if (True(perm & KMemoryPermission::UserWrite)) {
         perms |= Common::MemoryPermission::Write;
     }
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
     if (True(perm & KMemoryPermission::UserExecute)) {
         perms |= Common::MemoryPermission::Execute;
     }
@@ -5678,15 +5678,8 @@ Result KPageTableBase::Operate(PageLinkedList* page_list, KProcessAddress virt_a
     case OperationType::ChangePermissions:
     case OperationType::ChangePermissionsAndRefresh:
     case OperationType::ChangePermissionsAndRefreshAndFlush: {
-        const bool read = True(properties.perm & Kernel::KMemoryPermission::UserRead);
-        const bool write = True(properties.perm & Kernel::KMemoryPermission::UserWrite);
-        // todo: this doesn't really belong here and should go into m_memory to handle rasterizer
-        // access todo: ignore exec on non-direct-mapped case
-        const bool exec = True(properties.perm & Kernel::KMemoryPermission::UserExecute);
-        if (Settings::IsFastmemEnabled()) {
-            m_system.DeviceMemory().buffer.Protect(GetInteger(virt_addr), num_pages * PageSize,
-                                                   read, write, exec);
-        }
+        m_memory->ProtectRegion(*m_impl, virt_addr, num_pages * PageSize,
+                                ConvertToMemoryPermission(properties.perm));
         R_SUCCEED();
     }
     default:

src/core/hle/kernel/k_process.h

@@ -112,7 +112,6 @@ private:
     std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{};
     std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
     std::map<KProcessAddress, u64> m_debug_page_refcounts{};
-    std::unordered_map<u64, u64> m_post_handlers{};
     std::atomic<s64> m_cpu_time{};
     std::atomic<s64> m_num_process_switches{};
     std::atomic<s64> m_num_thread_switches{};
@@ -121,6 +120,9 @@ private:
     std::atomic<s64> m_num_ipc_messages{};
     std::atomic<s64> m_num_ipc_replies{};
     std::atomic<s64> m_num_ipc_receives{};
+#ifdef HAS_NCE
+    std::unordered_map<u64, u64> m_post_handlers{};
+#endif
 
 private:
     Result StartTermination();
@@ -468,9 +470,11 @@ public:
 
     static void Switch(KProcess* cur_process, KProcess* next_process);
 
+#ifdef HAS_NCE
     std::unordered_map<u64, u64>& GetPostHandlers() noexcept {
         return m_post_handlers;
     }
+#endif
 
 public:
     // Attempts to insert a watchpoint into a free slot. Returns false if none are available.

src/core/hle/kernel/physical_core.cpp

@@ -4,7 +4,7 @@
 #include "common/settings.h"
 #include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/arm_dynarmic_64.h"
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
 #include "core/arm/nce/arm_nce.h"
 #endif
 #include "core/core.h"
@@ -33,7 +33,7 @@ PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KSchedu
 PhysicalCore::~PhysicalCore() = default;
 
 void PhysicalCore::Initialize(bool is_64_bit) {
-#if defined(ARCHITECTURE_arm64)
+#if defined(HAS_NCE)
     if (Settings::IsNceEnabled()) {
         m_arm_interface = std::make_unique<Core::ARM_NCE>(m_system, m_system.Kernel().IsMulticore(),
                                                           m_core_index);

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

@@ -13,6 +13,7 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/hid/hid_types.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/result.h"
@@ -21,6 +22,7 @@
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/am/applets/applet_cabinet.h"
+#include "core/hle/service/am/applets/applet_controller.h"
 #include "core/hle/service/am/applets/applet_mii_edit_types.h"
 #include "core/hle/service/am/applets/applet_profile_select.h"
 #include "core/hle/service/am/applets/applet_software_keyboard_types.h"
@@ -35,6 +37,7 @@
 #include "core/hle/service/caps/caps_su.h"
 #include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
@@ -73,7 +76,7 @@ IWindowController::IWindowController(Core::System& system_)
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
-        {2, nullptr, "GetAppletResourceUserIdOfCallerApplet"},
+        {2, &IWindowController::GetAppletResourceUserIdOfCallerApplet, "GetAppletResourceUserIdOfCallerApplet"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
         {11, nullptr, "ReleaseForegroundRights"},
         {12, nullptr, "RejectToChangeIntoBackground"},
@@ -97,6 +100,16 @@ void IWindowController::GetAppletResourceUserId(HLERequestContext& ctx) {
     rb.Push<u64>(process_id);
 }
 
+void IWindowController::GetAppletResourceUserIdOfCallerApplet(HLERequestContext& ctx) {
+    const u64 process_id = 0;
+
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(process_id);
+}
+
 void IWindowController::AcquireForegroundRights(HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 2};
@@ -1565,7 +1578,7 @@ ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
         {6, nullptr, "GetPopInteractiveInDataEvent"},
         {10, &ILibraryAppletSelfAccessor::ExitProcessAndReturn, "ExitProcessAndReturn"},
         {11, &ILibraryAppletSelfAccessor::GetLibraryAppletInfo, "GetLibraryAppletInfo"},
-        {12, nullptr, "GetMainAppletIdentityInfo"},
+        {12, &ILibraryAppletSelfAccessor::GetMainAppletIdentityInfo, "GetMainAppletIdentityInfo"},
         {13, nullptr, "CanUseApplicationCore"},
         {14, &ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo, "GetCallerAppletIdentityInfo"},
         {15, nullptr, "GetMainAppletApplicationControlProperty"},
@@ -1609,6 +1622,9 @@ ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
     case Applets::AppletId::SoftwareKeyboard:
         PushInShowSoftwareKeyboard();
         break;
+    case Applets::AppletId::Controller:
+        PushInShowController();
+        break;
     default:
         break;
     }
@@ -1666,13 +1682,33 @@ void ILibraryAppletSelfAccessor::GetLibraryAppletInfo(HLERequestContext& ctx) {
     rb.PushRaw(applet_info);
 }
 
+void ILibraryAppletSelfAccessor::GetMainAppletIdentityInfo(HLERequestContext& ctx) {
+    struct AppletIdentityInfo {
+        Applets::AppletId applet_id;
+        INSERT_PADDING_BYTES(0x4);
+        u64 application_id;
+    };
+    static_assert(sizeof(AppletIdentityInfo) == 0x10, "AppletIdentityInfo has incorrect size.");
+
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    const AppletIdentityInfo applet_info{
+        .applet_id = Applets::AppletId::QLaunch,
+        .application_id = 0x0100000000001000ull,
+    };
+
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(applet_info);
+}
+
 void ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(HLERequestContext& ctx) {
     struct AppletIdentityInfo {
         Applets::AppletId applet_id;
         INSERT_PADDING_BYTES(0x4);
         u64 application_id;
     };
-
+    static_assert(sizeof(AppletIdentityInfo) == 0x10, "AppletIdentityInfo has incorrect size.");
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
     const AppletIdentityInfo applet_info{
@@ -1737,6 +1773,55 @@ void ILibraryAppletSelfAccessor::PushInShowAlbum() {
     queue_data.emplace_back(std::move(settings_data));
 }
 
+void ILibraryAppletSelfAccessor::PushInShowController() {
+    const Applets::CommonArguments common_args = {
+        .arguments_version = Applets::CommonArgumentVersion::Version3,
+        .size = Applets::CommonArgumentSize::Version3,
+        .library_version = static_cast<u32>(Applets::ControllerAppletVersion::Version8),
+        .theme_color = Applets::ThemeColor::BasicBlack,
+        .play_startup_sound = true,
+        .system_tick = system.CoreTiming().GetClockTicks(),
+    };
+
+    Applets::ControllerSupportArgNew user_args = {
+        .header = {.player_count_min = 1,
+                   .player_count_max = 4,
+                   .enable_take_over_connection = true,
+                   .enable_left_justify = false,
+                   .enable_permit_joy_dual = true,
+                   .enable_single_mode = false,
+                   .enable_identification_color = false},
+        .identification_colors = {},
+        .enable_explain_text = false,
+        .explain_text = {},
+    };
+
+    Applets::ControllerSupportArgPrivate private_args = {
+        .arg_private_size = sizeof(Applets::ControllerSupportArgPrivate),
+        .arg_size = sizeof(Applets::ControllerSupportArgNew),
+        .is_home_menu = true,
+        .flag_1 = true,
+        .mode = Applets::ControllerSupportMode::ShowControllerSupport,
+        .caller = Applets::ControllerSupportCaller::
+            Application, // switchbrew: Always zero except with
+                         // ShowControllerFirmwareUpdateForSystem/ShowControllerKeyRemappingForSystem,
+                         // which sets this to the input param
+        .style_set = Core::HID::NpadStyleSet::None,
+        .joy_hold_type = 0,
+    };
+    std::vector<u8> common_args_data(sizeof(common_args));
+    std::vector<u8> private_args_data(sizeof(private_args));
+    std::vector<u8> user_args_data(sizeof(user_args));
+
+    std::memcpy(common_args_data.data(), &common_args, sizeof(common_args));
+    std::memcpy(private_args_data.data(), &private_args, sizeof(private_args));
+    std::memcpy(user_args_data.data(), &user_args, sizeof(user_args));
+
+    queue_data.emplace_back(std::move(common_args_data));
+    queue_data.emplace_back(std::move(private_args_data));
+    queue_data.emplace_back(std::move(user_args_data));
+}
+
 void ILibraryAppletSelfAccessor::PushInShowCabinetData() {
     const Applets::CommonArguments arguments{
         .arguments_version = Applets::CommonArgumentVersion::Version3,

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

@@ -87,6 +87,7 @@ public:
 
 private:
     void GetAppletResourceUserId(HLERequestContext& ctx);
+    void GetAppletResourceUserIdOfCallerApplet(HLERequestContext& ctx);
     void AcquireForegroundRights(HLERequestContext& ctx);
 };
 
@@ -345,6 +346,7 @@ private:
     void PopInData(HLERequestContext& ctx);
     void PushOutData(HLERequestContext& ctx);
     void GetLibraryAppletInfo(HLERequestContext& ctx);
+    void GetMainAppletIdentityInfo(HLERequestContext& ctx);
     void ExitProcessAndReturn(HLERequestContext& ctx);
     void GetCallerAppletIdentityInfo(HLERequestContext& ctx);
     void GetDesirableKeyboardLayout(HLERequestContext& ctx);
@@ -355,6 +357,7 @@ private:
     void PushInShowCabinetData();
     void PushInShowMiiEditData();
     void PushInShowSoftwareKeyboard();
+    void PushInShowController();
 
     std::deque<std::vector<u8>> queue_data;
 };

src/core/hle/service/am/applets/applet_controller.h

@@ -56,7 +56,7 @@ enum class ControllerSupportResult : u32 {
 struct ControllerSupportArgPrivate {
     u32 arg_private_size{};
     u32 arg_size{};
-    bool flag_0{};
+    bool is_home_menu{};
     bool flag_1{};
     ControllerSupportMode mode{};
     ControllerSupportCaller caller{};

src/core/hle/service/btm/btm.cpp

@@ -127,7 +127,7 @@ public:
 
 private:
     void GetCore(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BTM, "called");
+        LOG_WARNING(Service_BTM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
@@ -263,13 +263,13 @@ public:
     explicit IBtmSystemCore(Core::System& system_) : ServiceFramework{system_, "IBtmSystemCore"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "StartGamepadPairing"},
-            {1, nullptr, "CancelGamepadPairing"},
+            {0, &IBtmSystemCore::StartGamepadPairing, "StartGamepadPairing"},
+            {1, &IBtmSystemCore::CancelGamepadPairing, "CancelGamepadPairing"},
             {2, nullptr, "ClearGamepadPairingDatabase"},
             {3, nullptr, "GetPairedGamepadCount"},
             {4, nullptr, "EnableRadio"},
             {5, nullptr, "DisableRadio"},
-            {6, nullptr, "GetRadioOnOff"},
+            {6, &IBtmSystemCore::IsRadioEnabled, "IsRadioEnabled"},
             {7, nullptr, "AcquireRadioEvent"},
             {8, nullptr, "AcquireGamepadPairingEvent"},
             {9, nullptr, "IsGamepadPairingStarted"},
@@ -280,18 +280,58 @@ public:
             {14, nullptr, "AcquireAudioDeviceConnectionEvent"},
             {15, nullptr, "ConnectAudioDevice"},
             {16, nullptr, "IsConnectingAudioDevice"},
-            {17, nullptr, "GetConnectedAudioDevices"},
+            {17, &IBtmSystemCore::GetConnectedAudioDevices, "GetConnectedAudioDevices"},
             {18, nullptr, "DisconnectAudioDevice"},
             {19, nullptr, "AcquirePairedAudioDeviceInfoChangedEvent"},
             {20, nullptr, "GetPairedAudioDevices"},
             {21, nullptr, "RemoveAudioDevicePairing"},
-            {22, nullptr, "RequestAudioDeviceConnectionRejection"},
-            {23, nullptr, "CancelAudioDeviceConnectionRejection"}
+            {22, &IBtmSystemCore::RequestAudioDeviceConnectionRejection, "RequestAudioDeviceConnectionRejection"},
+            {23, &IBtmSystemCore::CancelAudioDeviceConnectionRejection, "CancelAudioDeviceConnectionRejection"}
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
+
+private:
+    void IsRadioEnabled(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_BTM, "(STUBBED) called"); // Spams a lot when controller applet is running
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(true);
+    }
+
+    void StartGamepadPairing(HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void CancelGamepadPairing(HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void CancelAudioDeviceConnectionRejection(HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void GetConnectedAudioDevices(HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u32>(0);
+    }
+
+    void RequestAudioDeviceConnectionRejection(HLERequestContext& ctx) {
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
 };
 
 class BTM_SYS final : public ServiceFramework<BTM_SYS> {
@@ -308,7 +348,7 @@ public:
 
 private:
     void GetCore(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BTM, "called");
+        LOG_WARNING(Service_BTM, "called");
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);

src/core/hle/service/friend/friend.cpp

@@ -32,7 +32,7 @@ public:
             {10200, nullptr, "SendFriendRequestForApplication"},
             {10211, nullptr, "AddFacedFriendRequestForApplication"},
             {10400, &IFriendService::GetBlockedUserListIds, "GetBlockedUserListIds"},
-            {10420, nullptr, "IsBlockedUserListCacheAvailable"},
+            {10420, &IFriendService::CheckBlockedUserListAvailability, "CheckBlockedUserListAvailability"},
             {10421, nullptr, "EnsureBlockedUserListAvailable"},
             {10500, nullptr, "GetProfileList"},
             {10600, nullptr, "DeclareOpenOnlinePlaySession"},
@@ -206,6 +206,17 @@ private:
         rb.Push(true);
     }
 
+    void CheckBlockedUserListAvailability(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto uuid{rp.PopRaw<Common::UUID>()};
+
+        LOG_WARNING(Service_Friend, "(STUBBED) called, uuid=0x{}", uuid.RawString());
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push(true);
+    }
+
     KernelHelpers::ServiceContext service_context;
 
     Kernel::KEvent* completion_event;

src/core/hle/service/hid/controllers/console_six_axis.cpp

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hid/emulated_console.h"
+#include "core/hid/hid_core.h"
+#include "core/hle/service/hid/controllers/console_six_axis.h"
+#include "core/memory.h"
+
+namespace Service::HID {
+constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200;
+
+ConsoleSixAxis::ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
+    : ControllerBase{hid_core_} {
+    console = hid_core.GetEmulatedConsole();
+    static_assert(SHARED_MEMORY_OFFSET + sizeof(ConsoleSharedMemory) < shared_memory_size,
+                  "ConsoleSharedMemory is bigger than the shared memory");
+    shared_memory = std::construct_at(
+        reinterpret_cast<ConsoleSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
+}
+
+ConsoleSixAxis::~ConsoleSixAxis() = default;
+
+void ConsoleSixAxis::OnInit() {}
+
+void ConsoleSixAxis::OnRelease() {}
+
+void ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+    if (!IsControllerActivated()) {
+        return;
+    }
+
+    const auto motion_status = console->GetMotion();
+
+    shared_memory->sampling_number++;
+    shared_memory->is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest;
+    shared_memory->verticalization_error = motion_status.verticalization_error;
+    shared_memory->gyro_bias = motion_status.gyro_bias;
+}
+
+} // namespace Service::HID

src/core/hle/service/hid/controllers/console_six_axis.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/vector_math.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+
+namespace Core::HID {
+class EmulatedConsole;
+} // namespace Core::HID
+
+namespace Service::HID {
+class ConsoleSixAxis final : public ControllerBase {
+public:
+    explicit ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~ConsoleSixAxis() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
+
+private:
+    // This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
+    struct ConsoleSharedMemory {
+        u64 sampling_number{};
+        bool is_seven_six_axis_sensor_at_rest{};
+        INSERT_PADDING_BYTES(3); // padding
+        f32 verticalization_error{};
+        Common::Vec3f gyro_bias{};
+        INSERT_PADDING_BYTES(4); // padding
+    };
+    static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size");
+
+    ConsoleSharedMemory* shared_memory = nullptr;
+    Core::HID::EmulatedConsole* console = nullptr;
+};
+} // namespace Service::HID

src/core/hle/service/hid/controllers/debug_pad.cpp

@@ -13,7 +13,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000;
 
-Controller_DebugPad::Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
+DebugPad::DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
     : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(DebugPadSharedMemory) < shared_memory_size,
                   "DebugPadSharedMemory is bigger than the shared memory");
@@ -22,13 +22,13 @@ Controller_DebugPad::Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_
     controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other);
 }
 
-Controller_DebugPad::~Controller_DebugPad() = default;
+DebugPad::~DebugPad() = default;
 
-void Controller_DebugPad::OnInit() {}
+void DebugPad::OnInit() {}
 
-void Controller_DebugPad::OnRelease() {}
+void DebugPad::OnRelease() {}
 
-void Controller_DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         shared_memory->debug_pad_lifo.buffer_count = 0;
         shared_memory->debug_pad_lifo.buffer_tail = 0;

src/core/hle/service/hid/controllers/debug_pad.h

@@ -15,10 +15,10 @@ struct AnalogStickState;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_DebugPad final : public ControllerBase {
+class DebugPad final : public ControllerBase {
 public:
-    explicit Controller_DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_DebugPad() override;
+    explicit DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~DebugPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/gesture.cpp

@@ -23,7 +23,7 @@ constexpr f32 Square(s32 num) {
     return static_cast<f32>(num * num);
 }
 
-Controller_Gesture::Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
+Gesture::Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
     : ControllerBase(hid_core_) {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(GestureSharedMemory) < shared_memory_size,
                   "GestureSharedMemory is bigger than the shared memory");
@@ -31,17 +31,17 @@ Controller_Gesture::Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_sh
         reinterpret_cast<GestureSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
     console = hid_core.GetEmulatedConsole();
 }
-Controller_Gesture::~Controller_Gesture() = default;
+Gesture::~Gesture() = default;
 
-void Controller_Gesture::OnInit() {
+void Gesture::OnInit() {
     shared_memory->gesture_lifo.buffer_count = 0;
     shared_memory->gesture_lifo.buffer_tail = 0;
     force_update = true;
 }
 
-void Controller_Gesture::OnRelease() {}
+void Gesture::OnRelease() {}
 
-void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         shared_memory->gesture_lifo.buffer_count = 0;
         shared_memory->gesture_lifo.buffer_tail = 0;
@@ -64,7 +64,7 @@ void Controller_Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     UpdateGestureSharedMemory(gesture, time_difference);
 }
 
-void Controller_Gesture::ReadTouchInput() {
+void Gesture::ReadTouchInput() {
     if (!Settings::values.touchscreen.enabled) {
         fingers = {};
         return;
@@ -76,8 +76,7 @@ void Controller_Gesture::ReadTouchInput() {
     }
 }
 
-bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
-                                             f32 time_difference) {
+bool Gesture::ShouldUpdateGesture(const GestureProperties& gesture, f32 time_difference) {
     const auto& last_entry = GetLastGestureEntry();
     if (force_update) {
         force_update = false;
@@ -100,8 +99,7 @@ bool Controller_Gesture::ShouldUpdateGesture(const GestureProperties& gesture,
     return false;
 }
 
-void Controller_Gesture::UpdateGestureSharedMemory(GestureProperties& gesture,
-                                                   f32 time_difference) {
+void Gesture::UpdateGestureSharedMemory(GestureProperties& gesture, f32 time_difference) {
     GestureType type = GestureType::Idle;
     GestureAttribute attributes{};
 
@@ -138,8 +136,8 @@ void Controller_Gesture::UpdateGestureSharedMemory(GestureProperties& gesture,
     shared_memory->gesture_lifo.WriteNextEntry(next_state);
 }
 
-void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
-                                    GestureAttribute& attributes) {
+void Gesture::NewGesture(GestureProperties& gesture, GestureType& type,
+                         GestureAttribute& attributes) {
     const auto& last_entry = GetLastGestureEntry();
 
     gesture.detection_count++;
@@ -152,8 +150,8 @@ void Controller_Gesture::NewGesture(GestureProperties& gesture, GestureType& typ
     }
 }
 
-void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
-                                               f32 time_difference) {
+void Gesture::UpdateExistingGesture(GestureProperties& gesture, GestureType& type,
+                                    f32 time_difference) {
     const auto& last_entry = GetLastGestureEntry();
 
     // Promote to pan type if touch moved
@@ -186,9 +184,8 @@ void Controller_Gesture::UpdateExistingGesture(GestureProperties& gesture, Gestu
     }
 }
 
-void Controller_Gesture::EndGesture(GestureProperties& gesture,
-                                    GestureProperties& last_gesture_props, GestureType& type,
-                                    GestureAttribute& attributes, f32 time_difference) {
+void Gesture::EndGesture(GestureProperties& gesture, GestureProperties& last_gesture_props,
+                         GestureType& type, GestureAttribute& attributes, f32 time_difference) {
     const auto& last_entry = GetLastGestureEntry();
 
     if (last_gesture_props.active_points != 0) {
@@ -222,9 +219,8 @@ void Controller_Gesture::EndGesture(GestureProperties& gesture,
     }
 }
 
-void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
-                                     GestureProperties& last_gesture_props, GestureType& type,
-                                     GestureAttribute& attributes) {
+void Gesture::SetTapEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
+                          GestureType& type, GestureAttribute& attributes) {
     type = GestureType::Tap;
     gesture = last_gesture_props;
     force_update = true;
@@ -236,9 +232,8 @@ void Controller_Gesture::SetTapEvent(GestureProperties& gesture,
     }
 }
 
-void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
-                                        GestureProperties& last_gesture_props, GestureType& type,
-                                        f32 time_difference) {
+void Gesture::UpdatePanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
+                             GestureType& type, f32 time_difference) {
     const auto& last_entry = GetLastGestureEntry();
 
     next_state.delta = gesture.mid_point - last_entry.pos;
@@ -263,9 +258,8 @@ void Controller_Gesture::UpdatePanEvent(GestureProperties& gesture,
     }
 }
 
-void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
-                                     GestureProperties& last_gesture_props, GestureType& type,
-                                     f32 time_difference) {
+void Gesture::EndPanEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
+                          GestureType& type, f32 time_difference) {
     const auto& last_entry = GetLastGestureEntry();
     next_state.vel_x =
         static_cast<f32>(last_entry.delta.x) / (last_pan_time_difference + time_difference);
@@ -287,8 +281,8 @@ void Controller_Gesture::EndPanEvent(GestureProperties& gesture,
     force_update = true;
 }
 
-void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
-                                       GestureProperties& last_gesture_props, GestureType& type) {
+void Gesture::SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_gesture_props,
+                            GestureType& type) {
     const auto& last_entry = GetLastGestureEntry();
 
     type = GestureType::Swipe;
@@ -311,11 +305,11 @@ void Controller_Gesture::SetSwipeEvent(GestureProperties& gesture,
     next_state.direction = GestureDirection::Up;
 }
 
-const Controller_Gesture::GestureState& Controller_Gesture::GetLastGestureEntry() const {
+const Gesture::GestureState& Gesture::GetLastGestureEntry() const {
     return shared_memory->gesture_lifo.ReadCurrentEntry().state;
 }
 
-Controller_Gesture::GestureProperties Controller_Gesture::GetGestureProperties() {
+Gesture::GestureProperties Gesture::GetGestureProperties() {
     GestureProperties gesture;
     std::array<Core::HID::TouchFinger, MAX_POINTS> active_fingers;
     const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(),

src/core/hle/service/hid/controllers/gesture.h

@@ -12,10 +12,10 @@
 #include "core/hle/service/hid/ring_lifo.h"
 
 namespace Service::HID {
-class Controller_Gesture final : public ControllerBase {
+class Gesture final : public ControllerBase {
 public:
-    explicit Controller_Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_Gesture() override;
+    explicit Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~Gesture() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/keyboard.cpp

@@ -12,7 +12,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
 
-Controller_Keyboard::Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
+Keyboard::Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
     : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(KeyboardSharedMemory) < shared_memory_size,
                   "KeyboardSharedMemory is bigger than the shared memory");
@@ -21,13 +21,13 @@ Controller_Keyboard::Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_
     emulated_devices = hid_core.GetEmulatedDevices();
 }
 
-Controller_Keyboard::~Controller_Keyboard() = default;
+Keyboard::~Keyboard() = default;
 
-void Controller_Keyboard::OnInit() {}
+void Keyboard::OnInit() {}
 
-void Controller_Keyboard::OnRelease() {}
+void Keyboard::OnRelease() {}
 
-void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         shared_memory->keyboard_lifo.buffer_count = 0;
         shared_memory->keyboard_lifo.buffer_tail = 0;

src/core/hle/service/hid/controllers/keyboard.h

@@ -14,10 +14,10 @@ struct KeyboardKey;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_Keyboard final : public ControllerBase {
+class Keyboard final : public ControllerBase {
 public:
-    explicit Controller_Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_Keyboard() override;
+    explicit Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~Keyboard() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/mouse.cpp

@@ -12,8 +12,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;
 
-Controller_Mouse::Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
-    : ControllerBase{hid_core_} {
+Mouse::Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(MouseSharedMemory) < shared_memory_size,
                   "MouseSharedMemory is bigger than the shared memory");
     shared_memory = std::construct_at(
@@ -21,12 +20,12 @@ Controller_Mouse::Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared
     emulated_devices = hid_core.GetEmulatedDevices();
 }
 
-Controller_Mouse::~Controller_Mouse() = default;
+Mouse::~Mouse() = default;
 
-void Controller_Mouse::OnInit() {}
-void Controller_Mouse::OnRelease() {}
+void Mouse::OnInit() {}
+void Mouse::OnRelease() {}
 
-void Controller_Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         shared_memory->mouse_lifo.buffer_count = 0;
         shared_memory->mouse_lifo.buffer_tail = 0;

src/core/hle/service/hid/controllers/mouse.h

@@ -14,10 +14,10 @@ struct AnalogStickState;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_Mouse final : public ControllerBase {
+class Mouse final : public ControllerBase {
 public:
-    explicit Controller_Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_Mouse() override;
+    explicit Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~Mouse() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/npad.cpp

@@ -18,6 +18,7 @@
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/errors.h"
+#include "core/hle/service/hid/hid_util.h"
 #include "core/hle/service/kernel_helpers.h"
 
 namespace Service::HID {
@@ -29,60 +30,8 @@ constexpr std::array<Core::HID::NpadIdType, 10> npad_id_list{
     Core::HID::NpadIdType::Handheld,
 };
 
-bool Controller_NPad::IsNpadIdValid(Core::HID::NpadIdType npad_id) {
-    switch (npad_id) {
-    case Core::HID::NpadIdType::Player1:
-    case Core::HID::NpadIdType::Player2:
-    case Core::HID::NpadIdType::Player3:
-    case Core::HID::NpadIdType::Player4:
-    case Core::HID::NpadIdType::Player5:
-    case Core::HID::NpadIdType::Player6:
-    case Core::HID::NpadIdType::Player7:
-    case Core::HID::NpadIdType::Player8:
-    case Core::HID::NpadIdType::Other:
-    case Core::HID::NpadIdType::Handheld:
-        return true;
-    default:
-        LOG_ERROR(Service_HID, "Invalid npad id {}", npad_id);
-        return false;
-    }
-}
-
-Result Controller_NPad::IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle) {
-    const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
-    const bool npad_type = device_handle.npad_type < Core::HID::NpadStyleIndex::MaxNpadType;
-    const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
-
-    if (!npad_type) {
-        return VibrationInvalidStyleIndex;
-    }
-    if (!npad_id) {
-        return VibrationInvalidNpadId;
-    }
-    if (!device_index) {
-        return VibrationDeviceIndexOutOfRange;
-    }
-
-    return ResultSuccess;
-}
-
-Result Controller_NPad::VerifyValidSixAxisSensorHandle(
-    const Core::HID::SixAxisSensorHandle& device_handle) {
-    const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
-    const bool device_index = device_handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
-
-    if (!npad_id) {
-        return InvalidNpadId;
-    }
-    if (!device_index) {
-        return NpadDeviceIndexOutOfRange;
-    }
-
-    return ResultSuccess;
-}
-
-Controller_NPad::Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
-                                 KernelHelpers::ServiceContext& service_context_)
+NPad::NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+           KernelHelpers::ServiceContext& service_context_)
     : ControllerBase{hid_core_}, service_context{service_context_} {
     static_assert(NPAD_OFFSET + (NPAD_COUNT * sizeof(NpadInternalState)) < shared_memory_size);
     for (std::size_t i = 0; i < controller_data.size(); ++i) {
@@ -103,7 +52,7 @@ Controller_NPad::Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_m
     }
 }
 
-Controller_NPad::~Controller_NPad() {
+NPad::~NPad() {
     for (std::size_t i = 0; i < controller_data.size(); ++i) {
         auto& controller = controller_data[i];
         controller.device->DeleteCallback(controller.callback_key);
@@ -111,8 +60,7 @@ Controller_NPad::~Controller_NPad() {
     OnRelease();
 }
 
-void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
-                                       std::size_t controller_idx) {
+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);
         ControllerUpdate(Core::HID::ControllerTriggerType::Battery, controller_idx);
@@ -150,7 +98,7 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
     }
 }
 
-void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
+void NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
     auto& controller = GetControllerFromNpadIdType(npad_id);
     if (!IsControllerSupported(controller.device->GetNpadStyleIndex())) {
         return;
@@ -344,12 +292,13 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         controller.device->SetPollingMode(Core::HID::EmulatedDeviceIndex::AllDevices,
                                           Common::Input::PollingMode::Active);
     }
+
     SignalStyleSetChangedEvent(npad_id);
     WriteEmptyEntry(controller.shared_memory);
     hid_core.SetLastActiveController(npad_id);
 }
 
-void Controller_NPad::OnInit() {
+void NPad::OnInit() {
     if (!IsControllerActivated()) {
         return;
     }
@@ -383,7 +332,7 @@ void Controller_NPad::OnInit() {
     }
 }
 
-void Controller_NPad::WriteEmptyEntry(NpadInternalState* npad) {
+void NPad::WriteEmptyEntry(NpadInternalState* npad) {
     NPadGenericState dummy_pad_state{};
     NpadGcTriggerState dummy_gc_state{};
     dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1;
@@ -404,7 +353,7 @@ void Controller_NPad::WriteEmptyEntry(NpadInternalState* npad) {
     npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }
 
-void Controller_NPad::OnRelease() {
+void NPad::OnRelease() {
     is_controller_initialized = false;
     for (std::size_t i = 0; i < controller_data.size(); ++i) {
         auto& controller = controller_data[i];
@@ -415,7 +364,7 @@ void Controller_NPad::OnRelease() {
     }
 }
 
-void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
+void NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
     std::scoped_lock lock{mutex};
     auto& controller = GetControllerFromNpadIdType(npad_id);
     const auto controller_type = controller.device->GetNpadStyleIndex();
@@ -484,7 +433,7 @@ void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
     }
 }
 
-void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         return;
     }
@@ -614,134 +563,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     }
 }
 
-void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!IsControllerActivated()) {
-        return;
-    }
-
-    for (std::size_t i = 0; i < controller_data.size(); ++i) {
-        auto& controller = controller_data[i];
-
-        const auto& controller_type = controller.device->GetNpadStyleIndex();
-
-        if (controller_type == Core::HID::NpadStyleIndex::None ||
-            !controller.device->IsConnected()) {
-            continue;
-        }
-
-        auto* npad = controller.shared_memory;
-        const auto& motion_state = controller.device->GetMotions();
-        auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
-        auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
-        auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
-        auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
-        auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
-        auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
-
-        // Clear previous state
-        sixaxis_fullkey_state = {};
-        sixaxis_handheld_state = {};
-        sixaxis_dual_left_state = {};
-        sixaxis_dual_right_state = {};
-        sixaxis_left_lifo_state = {};
-        sixaxis_right_lifo_state = {};
-
-        if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
-            controller.sixaxis_at_rest = true;
-            for (std::size_t e = 0; e < motion_state.size(); ++e) {
-                controller.sixaxis_at_rest =
-                    controller.sixaxis_at_rest && motion_state[e].is_at_rest;
-            }
-        }
-
-        const auto set_motion_state = [&](SixAxisSensorState& state,
-                                          const Core::HID::ControllerMotion& hid_state) {
-            using namespace std::literals::chrono_literals;
-            static constexpr SixAxisSensorState default_motion_state = {
-                .delta_time = std::chrono::nanoseconds(5ms).count(),
-                .accel = {0, 0, -1.0f},
-                .orientation =
-                    {
-                        Common::Vec3f{1.0f, 0, 0},
-                        Common::Vec3f{0, 1.0f, 0},
-                        Common::Vec3f{0, 0, 1.0f},
-                    },
-                .attribute = {1},
-            };
-            if (!controller.sixaxis_sensor_enabled) {
-                state = default_motion_state;
-                return;
-            }
-            if (!Settings::values.motion_enabled.GetValue()) {
-                state = default_motion_state;
-                return;
-            }
-            state.attribute.is_connected.Assign(1);
-            state.delta_time = std::chrono::nanoseconds(5ms).count();
-            state.accel = hid_state.accel;
-            state.gyro = hid_state.gyro;
-            state.rotation = hid_state.rotation;
-            state.orientation = hid_state.orientation;
-        };
-
-        switch (controller_type) {
-        case Core::HID::NpadStyleIndex::None:
-            ASSERT(false);
-            break;
-        case Core::HID::NpadStyleIndex::ProController:
-            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::Handheld:
-            set_motion_state(sixaxis_handheld_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconDual:
-            set_motion_state(sixaxis_dual_left_state, motion_state[0]);
-            set_motion_state(sixaxis_dual_right_state, motion_state[1]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconLeft:
-            set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
-            break;
-        case Core::HID::NpadStyleIndex::JoyconRight:
-            set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
-            break;
-        case Core::HID::NpadStyleIndex::Pokeball:
-            using namespace std::literals::chrono_literals;
-            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
-            sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
-            break;
-        default:
-            break;
-        }
-
-        sixaxis_fullkey_state.sampling_number =
-            npad->sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_handheld_state.sampling_number =
-            npad->sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_dual_left_state.sampling_number =
-            npad->sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_dual_right_state.sampling_number =
-            npad->sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_left_lifo_state.sampling_number =
-            npad->sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
-        sixaxis_right_lifo_state.sampling_number =
-            npad->sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
-
-        if (Core::HID::IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
-            // This buffer only is updated on handheld on HW
-            npad->sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state);
-        } else {
-            // Handheld doesn't update this buffer on HW
-            npad->sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state);
-        }
-
-        npad->sixaxis_dual_left_lifo.WriteNextEntry(sixaxis_dual_left_state);
-        npad->sixaxis_dual_right_lifo.WriteNextEntry(sixaxis_dual_right_state);
-        npad->sixaxis_left_lifo.WriteNextEntry(sixaxis_left_lifo_state);
-        npad->sixaxis_right_lifo.WriteNextEntry(sixaxis_right_lifo_state);
-    }
-}
-
-void Controller_NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
+void NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
     hid_core.SetSupportedStyleTag(style_set);
 
     if (is_controller_initialized) {
@@ -752,14 +574,14 @@ void Controller_NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
     is_controller_initialized = true;
 }
 
-Core::HID::NpadStyleTag Controller_NPad::GetSupportedStyleSet() const {
+Core::HID::NpadStyleTag NPad::GetSupportedStyleSet() const {
     if (!is_controller_initialized) {
         return {Core::HID::NpadStyleSet::None};
     }
     return hid_core.GetSupportedStyleTag();
 }
 
-Result Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
+Result NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
     constexpr std::size_t max_number_npad_ids = 0xa;
     const auto length = data.size();
     ASSERT(length > 0 && (length % sizeof(u32)) == 0);
@@ -775,17 +597,17 @@ Result Controller_NPad::SetSupportedNpadIdTypes(std::span<const u8> data) {
     return ResultSuccess;
 }
 
-void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
+void NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
     const auto copy_amount = supported_npad_id_types.size() * sizeof(u32);
     ASSERT(max_length <= copy_amount);
     std::memcpy(data, supported_npad_id_types.data(), copy_amount);
 }
 
-std::size_t Controller_NPad::GetSupportedNpadIdTypesSize() const {
+std::size_t NPad::GetSupportedNpadIdTypesSize() const {
     return supported_npad_id_types.size();
 }
 
-void Controller_NPad::SetHoldType(NpadJoyHoldType joy_hold_type) {
+void NPad::SetHoldType(NpadJoyHoldType joy_hold_type) {
     if (joy_hold_type != NpadJoyHoldType::Horizontal &&
         joy_hold_type != NpadJoyHoldType::Vertical) {
         LOG_ERROR(Service_HID, "Npad joy hold type needs to be valid, joy_hold_type={}",
@@ -795,11 +617,11 @@ void Controller_NPad::SetHoldType(NpadJoyHoldType joy_hold_type) {
     hold_type = joy_hold_type;
 }
 
-Controller_NPad::NpadJoyHoldType Controller_NPad::GetHoldType() const {
+NPad::NpadJoyHoldType NPad::GetHoldType() const {
     return hold_type;
 }
 
-void Controller_NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode) {
+void NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_mode) {
     if (activation_mode >= NpadHandheldActivationMode::MaxActivationMode) {
         ASSERT_MSG(false, "Activation mode should be always None, Single or Dual");
         return;
@@ -808,21 +630,20 @@ void Controller_NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode a
     handheld_activation_mode = activation_mode;
 }
 
-Controller_NPad::NpadHandheldActivationMode Controller_NPad::GetNpadHandheldActivationMode() const {
+NPad::NpadHandheldActivationMode NPad::GetNpadHandheldActivationMode() const {
     return handheld_activation_mode;
 }
 
-void Controller_NPad::SetNpadCommunicationMode(NpadCommunicationMode communication_mode_) {
+void NPad::SetNpadCommunicationMode(NpadCommunicationMode communication_mode_) {
     communication_mode = communication_mode_;
 }
 
-Controller_NPad::NpadCommunicationMode Controller_NPad::GetNpadCommunicationMode() const {
+NPad::NpadCommunicationMode NPad::GetNpadCommunicationMode() const {
     return communication_mode;
 }
 
-bool Controller_NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
-                                  NpadJoyDeviceType npad_device_type,
-                                  NpadJoyAssignmentMode assignment_mode) {
+bool NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,
+                       NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return false;
@@ -891,9 +712,8 @@ bool Controller_NPad::SetNpadMode(Core::HID::NpadIdType& new_npad_id, Core::HID:
     return true;
 }
 
-bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id,
-                                               std::size_t device_index,
-                                               const Core::HID::VibrationValue& vibration_value) {
+bool NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, std::size_t device_index,
+                                    const Core::HID::VibrationValue& vibration_value) {
     auto& controller = GetControllerFromNpadIdType(npad_id);
     if (!controller.device->IsConnected()) {
         return false;
@@ -937,10 +757,9 @@ bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id,
     return controller.device->SetVibration(device_index, vibration);
 }
 
-void Controller_NPad::VibrateController(
-    const Core::HID::VibrationDeviceHandle& vibration_device_handle,
-    const Core::HID::VibrationValue& vibration_value) {
-    if (IsDeviceHandleValid(vibration_device_handle).IsError()) {
+void NPad::VibrateController(const Core::HID::VibrationDeviceHandle& vibration_device_handle,
+                             const Core::HID::VibrationValue& vibration_value) {
+    if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
         return;
     }
 
@@ -984,7 +803,7 @@ void Controller_NPad::VibrateController(
     }
 }
 
-void Controller_NPad::VibrateControllers(
+void NPad::VibrateControllers(
     std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,
     std::span<const Core::HID::VibrationValue> vibration_values) {
     if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {
@@ -1001,9 +820,9 @@ void Controller_NPad::VibrateControllers(
     }
 }
 
-Core::HID::VibrationValue Controller_NPad::GetLastVibration(
+Core::HID::VibrationValue NPad::GetLastVibration(
     const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {
-    if (IsDeviceHandleValid(vibration_device_handle).IsError()) {
+    if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
         return {};
     }
 
@@ -1012,9 +831,9 @@ Core::HID::VibrationValue Controller_NPad::GetLastVibration(
     return controller.vibration[device_index].latest_vibration_value;
 }
 
-void Controller_NPad::InitializeVibrationDevice(
+void NPad::InitializeVibrationDevice(
     const Core::HID::VibrationDeviceHandle& vibration_device_handle) {
-    if (IsDeviceHandleValid(vibration_device_handle).IsError()) {
+    if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
         return;
     }
 
@@ -1023,8 +842,8 @@ void Controller_NPad::InitializeVibrationDevice(
     InitializeVibrationDeviceAtIndex(npad_index, device_index);
 }
 
-void Controller_NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npad_id,
-                                                       std::size_t device_index) {
+void NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npad_id,
+                                            std::size_t device_index) {
     auto& controller = GetControllerFromNpadIdType(npad_id);
     if (!Settings::values.vibration_enabled.GetValue()) {
         controller.vibration[device_index].device_mounted = false;
@@ -1035,13 +854,13 @@ void Controller_NPad::InitializeVibrationDeviceAtIndex(Core::HID::NpadIdType npa
         controller.device->IsVibrationEnabled(device_index);
 }
 
-void Controller_NPad::SetPermitVibrationSession(bool permit_vibration_session) {
+void NPad::SetPermitVibrationSession(bool permit_vibration_session) {
     permit_vibration_session_enabled = permit_vibration_session;
 }
 
-bool Controller_NPad::IsVibrationDeviceMounted(
+bool NPad::IsVibrationDeviceMounted(
     const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {
-    if (IsDeviceHandleValid(vibration_device_handle).IsError()) {
+    if (IsVibrationHandleValid(vibration_device_handle).IsError()) {
         return false;
     }
 
@@ -1050,7 +869,7 @@ bool Controller_NPad::IsVibrationDeviceMounted(
     return controller.vibration[device_index].device_mounted;
 }
 
-Kernel::KReadableEvent& Controller_NPad::GetStyleSetChangedEvent(Core::HID::NpadIdType npad_id) {
+Kernel::KReadableEvent& NPad::GetStyleSetChangedEvent(Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         // Fallback to player 1
@@ -1062,18 +881,17 @@ Kernel::KReadableEvent& Controller_NPad::GetStyleSetChangedEvent(Core::HID::Npad
     return controller.styleset_changed_event->GetReadableEvent();
 }
 
-void Controller_NPad::SignalStyleSetChangedEvent(Core::HID::NpadIdType npad_id) const {
+void NPad::SignalStyleSetChangedEvent(Core::HID::NpadIdType npad_id) const {
     const auto& controller = GetControllerFromNpadIdType(npad_id);
     controller.styleset_changed_event->Signal();
 }
 
-void Controller_NPad::AddNewControllerAt(Core::HID::NpadStyleIndex controller,
-                                         Core::HID::NpadIdType npad_id) {
+void NPad::AddNewControllerAt(Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id) {
     UpdateControllerAt(controller, npad_id, true);
 }
 
-void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type,
-                                         Core::HID::NpadIdType npad_id, bool connected) {
+void NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type, Core::HID::NpadIdType npad_id,
+                              bool connected) {
     auto& controller = GetControllerFromNpadIdType(npad_id);
     if (!connected) {
         DisconnectNpad(npad_id);
@@ -1084,7 +902,7 @@ void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type,
     InitNewlyAddedController(npad_id);
 }
 
-Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
+Result NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1133,54 +951,9 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     return ResultSuccess;
 }
 
-Result Controller_NPad::SetGyroscopeZeroDriftMode(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::GyroscopeZeroDriftMode drift_mode) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    auto& controller = GetControllerFromHandle(sixaxis_handle);
-    sixaxis.gyroscope_zero_drift_mode = drift_mode;
-    controller.device->SetGyroscopeZeroDriftMode(drift_mode);
-
-    return ResultSuccess;
-}
-
-Result Controller_NPad::GetGyroscopeZeroDriftMode(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::GyroscopeZeroDriftMode& drift_mode) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    drift_mode = sixaxis.gyroscope_zero_drift_mode;
-
-    return ResultSuccess;
-}
-
-Result Controller_NPad::IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                              bool& is_at_rest) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto& controller = GetControllerFromHandle(sixaxis_handle);
-    is_at_rest = controller.sixaxis_at_rest;
-    return ResultSuccess;
-}
-
-Result Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
+Result NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
         return is_valid;
@@ -1191,65 +964,9 @@ Result Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
     return ResultSuccess;
 }
 
-Result Controller_NPad::EnableSixAxisSensorUnalteredPassthrough(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    sixaxis.unaltered_passtrough = is_enabled;
-    return ResultSuccess;
-}
-
-Result Controller_NPad::IsSixAxisSensorUnalteredPassthroughEnabled(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    is_enabled = sixaxis.unaltered_passtrough;
-    return ResultSuccess;
-}
-
-Result Controller_NPad::LoadSixAxisSensorCalibrationParameter(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::SixAxisSensorCalibrationParameter& calibration) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    // TODO: Request this data to the controller. On error return 0xd8ca
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    calibration = sixaxis.calibration;
-    return ResultSuccess;
-}
-
-Result Controller_NPad::GetSixAxisSensorIcInformation(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::SixAxisSensorIcInformation& ic_information) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    // TODO: Request this data to the controller. On error return 0xd8ca
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    ic_information = sixaxis.ic_information;
-    return ResultSuccess;
-}
-
-Result Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
+Result NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
         return is_valid;
@@ -1261,83 +978,32 @@ Result Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
     return ResultSuccess;
 }
 
-Result Controller_NPad::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                          bool sixaxis_status) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    auto& controller = GetControllerFromHandle(sixaxis_handle);
-    controller.sixaxis_sensor_enabled = sixaxis_status;
-    return ResultSuccess;
+NPad::SixAxisLifo& NPad::GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_fullkey_lifo;
 }
 
-Result Controller_NPad::IsSixAxisSensorFusionEnabled(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_fusion_enabled) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    is_fusion_enabled = sixaxis.is_fusion_enabled;
-
-    return ResultSuccess;
-}
-Result Controller_NPad::SetSixAxisFusionEnabled(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_fusion_enabled) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    sixaxis.is_fusion_enabled = is_fusion_enabled;
-
-    return ResultSuccess;
+NPad::SixAxisLifo& NPad::GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_handheld_lifo;
 }
 
-Result Controller_NPad::SetSixAxisFusionParameters(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters) {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto param1 = sixaxis_fusion_parameters.parameter1;
-    if (param1 < 0.0f || param1 > 1.0f) {
-        return InvalidSixAxisFusionRange;
-    }
-
-    auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    sixaxis.fusion = sixaxis_fusion_parameters;
-
-    return ResultSuccess;
+NPad::SixAxisLifo& NPad::GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_left_lifo;
 }
 
-Result Controller_NPad::GetSixAxisFusionParameters(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-    Core::HID::SixAxisSensorFusionParameters& parameters) const {
-    const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
-    if (is_valid.IsError()) {
-        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
-        return is_valid;
-    }
-
-    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
-    parameters = sixaxis.fusion;
-
-    return ResultSuccess;
+NPad::SixAxisLifo& NPad::GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_right_lifo;
 }
 
-Result Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
-                                                Core::HID::NpadIdType npad_id_2) {
+NPad::SixAxisLifo& NPad::GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_left_lifo;
+}
+
+NPad::SixAxisLifo& NPad::GetSixAxisRightLifo(Core::HID::NpadIdType npad_id) {
+    return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_right_lifo;
+}
+
+Result NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
+                                     Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
                   npad_id_2);
@@ -1399,18 +1065,17 @@ Result Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
     return ResultSuccess;
 }
 
-void Controller_NPad::StartLRAssignmentMode() {
+void NPad::StartLRAssignmentMode() {
     // Nothing internally is used for lr assignment mode. Since we have the ability to set the
     // controller types from boot, it doesn't really matter about showing a selection screen
     is_in_lr_assignment_mode = true;
 }
 
-void Controller_NPad::StopLRAssignmentMode() {
+void NPad::StopLRAssignmentMode() {
     is_in_lr_assignment_mode = false;
 }
 
-Result Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
-                                           Core::HID::NpadIdType npad_id_2) {
+Result NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
                   npad_id_2);
@@ -1441,8 +1106,7 @@ Result Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
     return ResultSuccess;
 }
 
-Result Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
-                                      Core::HID::LedPattern& pattern) const {
+Result NPad::GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1452,8 +1116,8 @@ Result Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
     return ResultSuccess;
 }
 
-Result Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
-                                                                     bool& is_valid) const {
+Result NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
+                                                          bool& is_valid) const {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1463,8 +1127,8 @@ Result Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::
     return ResultSuccess;
 }
 
-Result Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(
-    bool is_protection_enabled, Core::HID::NpadIdType npad_id) {
+Result NPad::SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled,
+                                                           Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1474,11 +1138,11 @@ Result Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(
     return ResultSuccess;
 }
 
-void Controller_NPad::SetAnalogStickUseCenterClamp(bool use_center_clamp) {
+void NPad::SetAnalogStickUseCenterClamp(bool use_center_clamp) {
     analog_stick_use_center_clamp = use_center_clamp;
 }
 
-void Controller_NPad::ClearAllConnectedControllers() {
+void NPad::ClearAllConnectedControllers() {
     for (auto& controller : controller_data) {
         if (controller.device->IsConnected() &&
             controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None) {
@@ -1488,13 +1152,13 @@ void Controller_NPad::ClearAllConnectedControllers() {
     }
 }
 
-void Controller_NPad::DisconnectAllConnectedControllers() {
+void NPad::DisconnectAllConnectedControllers() {
     for (auto& controller : controller_data) {
         controller.device->Disconnect();
     }
 }
 
-void Controller_NPad::ConnectAllDisconnectedControllers() {
+void NPad::ConnectAllDisconnectedControllers() {
     for (auto& controller : controller_data) {
         if (controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None &&
             !controller.device->IsConnected()) {
@@ -1503,18 +1167,18 @@ void Controller_NPad::ConnectAllDisconnectedControllers() {
     }
 }
 
-void Controller_NPad::ClearAllControllers() {
+void NPad::ClearAllControllers() {
     for (auto& controller : controller_data) {
         controller.device->Disconnect();
         controller.device->SetNpadStyleIndex(Core::HID::NpadStyleIndex::None);
     }
 }
 
-Core::HID::NpadButton Controller_NPad::GetAndResetPressState() {
+Core::HID::NpadButton NPad::GetAndResetPressState() {
     return static_cast<Core::HID::NpadButton>(press_state.exchange(0));
 }
 
-void Controller_NPad::ApplyNpadSystemCommonPolicy() {
+void NPad::ApplyNpadSystemCommonPolicy() {
     Core::HID::NpadStyleTag styletag{};
     styletag.fullkey.Assign(1);
     styletag.handheld.Assign(1);
@@ -1539,7 +1203,7 @@ void Controller_NPad::ApplyNpadSystemCommonPolicy() {
     supported_npad_id_types[9] = Core::HID::NpadIdType::Handheld;
 }
 
-bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const {
+bool NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const {
     if (controller == Core::HID::NpadStyleIndex::Handheld) {
         const bool support_handheld =
             std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(),
@@ -1590,51 +1254,50 @@ bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller
     return false;
 }
 
-Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
-    const Core::HID::SixAxisSensorHandle& device_handle) {
-    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
-    return GetControllerFromNpadIdType(npad_id);
-}
-
-const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
-    const Core::HID::SixAxisSensorHandle& device_handle) const {
-    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
-    return GetControllerFromNpadIdType(npad_id);
-}
-
-Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
+NPad::NpadControllerData& NPad::GetControllerFromHandle(
     const Core::HID::VibrationDeviceHandle& device_handle) {
     const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
     return GetControllerFromNpadIdType(npad_id);
 }
 
-const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromHandle(
+const NPad::NpadControllerData& NPad::GetControllerFromHandle(
     const Core::HID::VibrationDeviceHandle& device_handle) const {
     const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
     return GetControllerFromNpadIdType(npad_id);
 }
 
-Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromNpadIdType(
-    Core::HID::NpadIdType npad_id) {
+NPad::NpadControllerData& NPad::GetControllerFromHandle(
+    const Core::HID::SixAxisSensorHandle& device_handle) {
+    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
+    return GetControllerFromNpadIdType(npad_id);
+}
+
+const NPad::NpadControllerData& NPad::GetControllerFromHandle(
+    const Core::HID::SixAxisSensorHandle& device_handle) const {
+    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
+    return GetControllerFromNpadIdType(npad_id);
+}
+
+NPad::NpadControllerData& NPad::GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         npad_id = Core::HID::NpadIdType::Player1;
     }
-    const auto npad_index = Core::HID::NpadIdTypeToIndex(npad_id);
+    const auto npad_index = NpadIdTypeToIndex(npad_id);
     return controller_data[npad_index];
 }
 
-const Controller_NPad::NpadControllerData& Controller_NPad::GetControllerFromNpadIdType(
+const NPad::NpadControllerData& NPad::GetControllerFromNpadIdType(
     Core::HID::NpadIdType npad_id) const {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         npad_id = Core::HID::NpadIdType::Player1;
     }
-    const auto npad_index = Core::HID::NpadIdTypeToIndex(npad_id);
+    const auto npad_index = NpadIdTypeToIndex(npad_id);
     return controller_data[npad_index];
 }
 
-Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
+Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
     auto& controller = GetControllerFromHandle(sixaxis_handle);
     switch (sixaxis_handle.npad_type) {
@@ -1657,7 +1320,7 @@ Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
     }
 }
 
-const Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
+const Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
     const auto& controller = GetControllerFromHandle(sixaxis_handle);
     switch (sixaxis_handle.npad_type) {
@@ -1680,50 +1343,13 @@ const Core::HID::SixAxisSensorProperties& Controller_NPad::GetSixaxisProperties(
     }
 }
 
-Controller_NPad::SixaxisParameters& Controller_NPad::GetSixaxisState(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
-    auto& controller = GetControllerFromHandle(sixaxis_handle);
-    switch (sixaxis_handle.npad_type) {
-    case Core::HID::NpadStyleIndex::ProController:
-    case Core::HID::NpadStyleIndex::Pokeball:
-        return controller.sixaxis_fullkey;
-    case Core::HID::NpadStyleIndex::Handheld:
-        return controller.sixaxis_handheld;
-    case Core::HID::NpadStyleIndex::JoyconDual:
-        if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
-            return controller.sixaxis_dual_left;
-        }
-        return controller.sixaxis_dual_right;
-    case Core::HID::NpadStyleIndex::JoyconLeft:
-        return controller.sixaxis_left;
-    case Core::HID::NpadStyleIndex::JoyconRight:
-        return controller.sixaxis_right;
-    default:
-        return controller.sixaxis_unknown;
-    }
-}
+NPad::AppletDetailedUiType NPad::GetAppletDetailedUiType(Core::HID::NpadIdType npad_id) {
+    const auto& shared_memory = GetControllerFromNpadIdType(npad_id).shared_memory;
 
-const Controller_NPad::SixaxisParameters& Controller_NPad::GetSixaxisState(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
-    const auto& controller = GetControllerFromHandle(sixaxis_handle);
-    switch (sixaxis_handle.npad_type) {
-    case Core::HID::NpadStyleIndex::ProController:
-    case Core::HID::NpadStyleIndex::Pokeball:
-        return controller.sixaxis_fullkey;
-    case Core::HID::NpadStyleIndex::Handheld:
-        return controller.sixaxis_handheld;
-    case Core::HID::NpadStyleIndex::JoyconDual:
-        if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
-            return controller.sixaxis_dual_left;
-        }
-        return controller.sixaxis_dual_right;
-    case Core::HID::NpadStyleIndex::JoyconLeft:
-        return controller.sixaxis_left;
-    case Core::HID::NpadStyleIndex::JoyconRight:
-        return controller.sixaxis_right;
-    default:
-        return controller.sixaxis_unknown;
-    }
+    return {
+        .ui_variant = 0,
+        .footer = shared_memory->applet_footer_type,
+    };
 }
 
 } // namespace Service::HID

src/core/hle/service/hid/controllers/npad.h

@@ -10,7 +10,6 @@
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "common/vector_math.h"
 
 #include "core/hid/hid_types.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
@@ -34,11 +33,11 @@ union Result;
 
 namespace Service::HID {
 
-class Controller_NPad final : public ControllerBase {
+class NPad final : public ControllerBase {
 public:
-    explicit Controller_NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
-                             KernelHelpers::ServiceContext& service_context_);
-    ~Controller_NPad() override;
+    explicit NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+                  KernelHelpers::ServiceContext& service_context_);
+    ~NPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;
@@ -49,9 +48,6 @@ public:
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
-    // When the controller is requesting a motion update for the shared memory
-    void OnMotionUpdate(const Core::Timing::CoreTiming& core_timing) override;
-
     // This is nn::hid::NpadJoyHoldType
     enum class NpadJoyHoldType : u64 {
         Vertical = 0,
@@ -78,6 +74,46 @@ public:
         MaxActivationMode = 3,
     };
 
+    // This is nn::hid::system::AppletFooterUiAttributesSet
+    struct AppletFooterUiAttributes {
+        INSERT_PADDING_BYTES(0x4);
+    };
+
+    // This is nn::hid::system::AppletFooterUiType
+    enum class AppletFooterUiType : u8 {
+        None = 0,
+        HandheldNone = 1,
+        HandheldJoyConLeftOnly = 2,
+        HandheldJoyConRightOnly = 3,
+        HandheldJoyConLeftJoyConRight = 4,
+        JoyDual = 5,
+        JoyDualLeftOnly = 6,
+        JoyDualRightOnly = 7,
+        JoyLeftHorizontal = 8,
+        JoyLeftVertical = 9,
+        JoyRightHorizontal = 10,
+        JoyRightVertical = 11,
+        SwitchProController = 12,
+        CompatibleProController = 13,
+        CompatibleJoyCon = 14,
+        LarkHvc1 = 15,
+        LarkHvc2 = 16,
+        LarkNesLeft = 17,
+        LarkNesRight = 18,
+        Lucia = 19,
+        Verification = 20,
+        Lagon = 21,
+    };
+
+    using AppletFooterUiVariant = u8;
+
+    // This is "nn::hid::system::AppletDetailedUiType".
+    struct AppletDetailedUiType {
+        AppletFooterUiVariant ui_variant;
+        INSERT_PADDING_BYTES(0x2);
+        AppletFooterUiType footer;
+    };
+    static_assert(sizeof(AppletDetailedUiType) == 0x4, "AppletDetailedUiType is an invalid size");
     // This is nn::hid::NpadCommunicationMode
     enum class NpadCommunicationMode : u64 {
         Mode_5ms = 0,
@@ -93,6 +129,8 @@ public:
         Revision3 = 3,
     };
 
+    using SixAxisLifo = Lifo<Core::HID::SixAxisSensorState, hid_entry_count>;
+
     void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set);
     Core::HID::NpadStyleTag GetSupportedStyleSet() const;
 
@@ -145,37 +183,18 @@ public:
 
     Result DisconnectNpad(Core::HID::NpadIdType npad_id);
 
-    Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                     Core::HID::GyroscopeZeroDriftMode drift_mode);
-    Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                     Core::HID::GyroscopeZeroDriftMode& drift_mode) const;
-    Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                 bool& is_at_rest) const;
     Result IsFirmwareUpdateAvailableForSixAxisSensor(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const;
-    Result EnableSixAxisSensorUnalteredPassthrough(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled);
-    Result IsSixAxisSensorUnalteredPassthroughEnabled(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const;
-    Result LoadSixAxisSensorCalibrationParameter(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-        Core::HID::SixAxisSensorCalibrationParameter& calibration) const;
-    Result GetSixAxisSensorIcInformation(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-        Core::HID::SixAxisSensorIcInformation& ic_information) const;
     Result ResetIsSixAxisSensorDeviceNewlyAssigned(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle);
-    Result SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                             bool sixaxis_status);
-    Result IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                        bool& is_fusion_enabled) const;
-    Result SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                   bool is_fusion_enabled);
-    Result SetSixAxisFusionParameters(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-        Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters);
-    Result GetSixAxisFusionParameters(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                      Core::HID::SixAxisSensorFusionParameters& parameters) const;
+
+    SixAxisLifo& GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id);
+    SixAxisLifo& GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id);
+    SixAxisLifo& GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id);
+    SixAxisLifo& GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id);
+    SixAxisLifo& GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id);
+    SixAxisLifo& GetSixAxisRightLifo(Core::HID::NpadIdType npad_id);
+
     Result GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const;
     Result IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
                                                         bool& is_enabled) const;
@@ -199,10 +218,7 @@ public:
 
     void ApplyNpadSystemCommonPolicy();
 
-    static bool IsNpadIdValid(Core::HID::NpadIdType npad_id);
-    static Result IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle);
-    static Result VerifyValidSixAxisSensorHandle(
-        const Core::HID::SixAxisSensorHandle& device_handle);
+    AppletDetailedUiType GetAppletDetailedUiType(Core::HID::NpadIdType npad_id);
 
 private:
     static constexpr std::size_t NPAD_COUNT = 10;
@@ -261,29 +277,6 @@ private:
     };
     static_assert(sizeof(NPadGenericState) == 0x28, "NPadGenericState is an invalid size");
 
-    // This is nn::hid::SixAxisSensorAttribute
-    struct SixAxisSensorAttribute {
-        union {
-            u32 raw{};
-            BitField<0, 1, u32> is_connected;
-            BitField<1, 1, u32> is_interpolated;
-        };
-    };
-    static_assert(sizeof(SixAxisSensorAttribute) == 4, "SixAxisSensorAttribute is an invalid size");
-
-    // This is nn::hid::SixAxisSensorState
-    struct SixAxisSensorState {
-        s64 delta_time{};
-        s64 sampling_number{};
-        Common::Vec3f accel{};
-        Common::Vec3f gyro{};
-        Common::Vec3f rotation{};
-        std::array<Common::Vec3f, 3> orientation{};
-        SixAxisSensorAttribute attribute{};
-        INSERT_PADDING_BYTES(4); // Reserved
-    };
-    static_assert(sizeof(SixAxisSensorState) == 0x60, "SixAxisSensorState is an invalid size");
-
     // This is nn::hid::server::NpadGcTriggerState
     struct NpadGcTriggerState {
         s64 sampling_number{};
@@ -360,37 +353,6 @@ private:
     static_assert(sizeof(NfcXcdDeviceHandleStateImpl) == 0x18,
                   "NfcXcdDeviceHandleStateImpl is an invalid size");
 
-    // This is nn::hid::system::AppletFooterUiAttributesSet
-    struct AppletFooterUiAttributes {
-        INSERT_PADDING_BYTES(0x4);
-    };
-
-    // This is nn::hid::system::AppletFooterUiType
-    enum class AppletFooterUiType : u8 {
-        None = 0,
-        HandheldNone = 1,
-        HandheldJoyConLeftOnly = 2,
-        HandheldJoyConRightOnly = 3,
-        HandheldJoyConLeftJoyConRight = 4,
-        JoyDual = 5,
-        JoyDualLeftOnly = 6,
-        JoyDualRightOnly = 7,
-        JoyLeftHorizontal = 8,
-        JoyLeftVertical = 9,
-        JoyRightHorizontal = 10,
-        JoyRightVertical = 11,
-        SwitchProController = 12,
-        CompatibleProController = 13,
-        CompatibleJoyCon = 14,
-        LarkHvc1 = 15,
-        LarkHvc2 = 16,
-        LarkNesLeft = 17,
-        LarkNesRight = 18,
-        Lucia = 19,
-        Verification = 20,
-        Lagon = 21,
-    };
-
     // This is nn::hid::NpadLarkType
     enum class NpadLarkType : u32 {
         Invalid,
@@ -434,12 +396,12 @@ private:
         Lifo<NPadGenericState, hid_entry_count> joy_right_lifo{};
         Lifo<NPadGenericState, hid_entry_count> palma_lifo{};
         Lifo<NPadGenericState, hid_entry_count> system_ext_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_fullkey_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_handheld_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_dual_left_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_dual_right_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_left_lifo{};
-        Lifo<SixAxisSensorState, hid_entry_count> sixaxis_right_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_fullkey_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_handheld_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_left_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_right_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_left_lifo{};
+        Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_right_lifo{};
         DeviceType device_type{};
         INSERT_PADDING_BYTES(0x4); // Reserved
         NPadSystemProperties system_properties{};
@@ -473,16 +435,6 @@ private:
         std::chrono::steady_clock::time_point last_vibration_timepoint{};
     };
 
-    struct SixaxisParameters {
-        bool is_fusion_enabled{true};
-        bool unaltered_passtrough{false};
-        Core::HID::SixAxisSensorFusionParameters fusion{};
-        Core::HID::SixAxisSensorCalibrationParameter calibration{};
-        Core::HID::SixAxisSensorIcInformation ic_information{};
-        Core::HID::GyroscopeZeroDriftMode gyroscope_zero_drift_mode{
-            Core::HID::GyroscopeZeroDriftMode::Standard};
-    };
-
     struct NpadControllerData {
         Kernel::KEvent* styleset_changed_event{};
         NpadInternalState* shared_memory = nullptr;
@@ -496,27 +448,10 @@ private:
         bool is_dual_left_connected{true};
         bool is_dual_right_connected{true};
 
-        // Motion parameters
-        bool sixaxis_at_rest{true};
-        bool sixaxis_sensor_enabled{true};
-        SixaxisParameters sixaxis_fullkey{};
-        SixaxisParameters sixaxis_handheld{};
-        SixaxisParameters sixaxis_dual_left{};
-        SixaxisParameters sixaxis_dual_right{};
-        SixaxisParameters sixaxis_left{};
-        SixaxisParameters sixaxis_right{};
-        SixaxisParameters sixaxis_unknown{};
-
         // Current pad state
         NPadGenericState npad_pad_state{};
         NPadGenericState npad_libnx_state{};
         NpadGcTriggerState npad_trigger_state{};
-        SixAxisSensorState sixaxis_fullkey_state{};
-        SixAxisSensorState sixaxis_handheld_state{};
-        SixAxisSensorState sixaxis_dual_left_state{};
-        SixAxisSensorState sixaxis_dual_right_state{};
-        SixAxisSensorState sixaxis_left_lifo_state{};
-        SixAxisSensorState sixaxis_right_lifo_state{};
         int callback_key{};
     };
 
@@ -526,14 +461,14 @@ private:
     void RequestPadStateUpdate(Core::HID::NpadIdType npad_id);
     void WriteEmptyEntry(NpadInternalState* npad);
 
-    NpadControllerData& GetControllerFromHandle(
-        const Core::HID::SixAxisSensorHandle& device_handle);
-    const NpadControllerData& GetControllerFromHandle(
-        const Core::HID::SixAxisSensorHandle& device_handle) const;
     NpadControllerData& GetControllerFromHandle(
         const Core::HID::VibrationDeviceHandle& device_handle);
     const NpadControllerData& GetControllerFromHandle(
         const Core::HID::VibrationDeviceHandle& device_handle) const;
+    NpadControllerData& GetControllerFromHandle(
+        const Core::HID::SixAxisSensorHandle& device_handle);
+    const NpadControllerData& GetControllerFromHandle(
+        const Core::HID::SixAxisSensorHandle& device_handle) const;
     NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id);
     const NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) const;
 
@@ -541,9 +476,6 @@ private:
         const Core::HID::SixAxisSensorHandle& device_handle);
     const Core::HID::SixAxisSensorProperties& GetSixaxisProperties(
         const Core::HID::SixAxisSensorHandle& device_handle) const;
-    SixaxisParameters& GetSixaxisState(const Core::HID::SixAxisSensorHandle& device_handle);
-    const SixaxisParameters& GetSixaxisState(
-        const Core::HID::SixAxisSensorHandle& device_handle) const;
 
     std::atomic<u64> press_state{};
 

src/core/hle/service/hid/controllers/palma.cpp

@@ -12,35 +12,35 @@
 
 namespace Service::HID {
 
-Controller_Palma::Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
-                                   KernelHelpers::ServiceContext& service_context_)
+Palma::Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+             KernelHelpers::ServiceContext& service_context_)
     : ControllerBase{hid_core_}, service_context{service_context_} {
     controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other);
     operation_complete_event = service_context.CreateEvent("hid:PalmaOperationCompleteEvent");
 }
 
-Controller_Palma::~Controller_Palma() {
+Palma::~Palma() {
     service_context.CloseEvent(operation_complete_event);
 };
 
-void Controller_Palma::OnInit() {}
+void Palma::OnInit() {}
 
-void Controller_Palma::OnRelease() {}
+void Palma::OnRelease() {}
 
-void Controller_Palma::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void Palma::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         return;
     }
 }
 
-Result Controller_Palma::GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id,
-                                                  PalmaConnectionHandle& handle) {
+Result Palma::GetPalmaConnectionHandle(Core::HID::NpadIdType npad_id,
+                                       PalmaConnectionHandle& handle) {
     active_handle.npad_id = npad_id;
     handle = active_handle;
     return ResultSuccess;
 }
 
-Result Controller_Palma::InitializePalma(const PalmaConnectionHandle& handle) {
+Result Palma::InitializePalma(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -48,7 +48,7 @@ Result Controller_Palma::InitializePalma(const PalmaConnectionHandle& handle) {
     return ResultSuccess;
 }
 
-Kernel::KReadableEvent& Controller_Palma::AcquirePalmaOperationCompleteEvent(
+Kernel::KReadableEvent& Palma::AcquirePalmaOperationCompleteEvent(
     const PalmaConnectionHandle& handle) const {
     if (handle.npad_id != active_handle.npad_id) {
         LOG_ERROR(Service_HID, "Invalid npad id {}", handle.npad_id);
@@ -56,9 +56,9 @@ Kernel::KReadableEvent& Controller_Palma::AcquirePalmaOperationCompleteEvent(
     return operation_complete_event->GetReadableEvent();
 }
 
-Result Controller_Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
-                                               PalmaOperationType& operation_type,
-                                               PalmaOperationData& data) const {
+Result Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
+                                    PalmaOperationType& operation_type,
+                                    PalmaOperationData& data) const {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -67,8 +67,7 @@ Result Controller_Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& hand
     return ResultSuccess;
 }
 
-Result Controller_Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle,
-                                           u64 palma_activity) {
+Result Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_activity) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -79,8 +78,7 @@ Result Controller_Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle,
     return ResultSuccess;
 }
 
-Result Controller_Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle,
-                                            PalmaFrModeType fr_mode_) {
+Result Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle, PalmaFrModeType fr_mode_) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -88,7 +86,7 @@ Result Controller_Palma::SetPalmaFrModeType(const PalmaConnectionHandle& handle,
     return ResultSuccess;
 }
 
-Result Controller_Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
+Result Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -99,25 +97,25 @@ Result Controller_Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
     return ResultSuccess;
 }
 
-Result Controller_Palma::EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled) {
+Result Palma::EnablePalmaStep(const PalmaConnectionHandle& handle, bool is_enabled) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
     return ResultSuccess;
 }
 
-Result Controller_Palma::ResetPalmaStep(const PalmaConnectionHandle& handle) {
+Result Palma::ResetPalmaStep(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
     return ResultSuccess;
 }
 
-void Controller_Palma::ReadPalmaApplicationSection() {}
+void Palma::ReadPalmaApplicationSection() {}
 
-void Controller_Palma::WritePalmaApplicationSection() {}
+void Palma::WritePalmaApplicationSection() {}
 
-Result Controller_Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
+Result Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -128,7 +126,7 @@ Result Controller_Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle
     return ResultSuccess;
 }
 
-Result Controller_Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
+Result Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -139,10 +137,9 @@ Result Controller_Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle&
     return ResultSuccess;
 }
 
-void Controller_Palma::WritePalmaActivityEntry() {}
+void Palma::WritePalmaActivityEntry() {}
 
-Result Controller_Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle,
-                                                      u64 unknown) {
+Result Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle, u64 unknown) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -153,8 +150,8 @@ Result Controller_Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandl
     return ResultSuccess;
 }
 
-Result Controller_Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave,
-                                             Common::ProcessAddress t_mem, u64 size) {
+Result Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWaveSet wave,
+                                  Common::ProcessAddress t_mem, u64 size) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -165,8 +162,8 @@ Result Controller_Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle
     return ResultSuccess;
 }
 
-Result Controller_Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle,
-                                                               s32 database_id_version_) {
+Result Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle,
+                                                    s32 database_id_version_) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -178,8 +175,7 @@ Result Controller_Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnec
     return ResultSuccess;
 }
 
-Result Controller_Palma::GetPalmaDataBaseIdentificationVersion(
-    const PalmaConnectionHandle& handle) {
+Result Palma::GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -191,26 +187,26 @@ Result Controller_Palma::GetPalmaDataBaseIdentificationVersion(
     return ResultSuccess;
 }
 
-void Controller_Palma::SuspendPalmaFeature() {}
+void Palma::SuspendPalmaFeature() {}
 
-Result Controller_Palma::GetPalmaOperationResult(const PalmaConnectionHandle& handle) const {
+Result Palma::GetPalmaOperationResult(const PalmaConnectionHandle& handle) const {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
     return operation.result;
 }
-void Controller_Palma::ReadPalmaPlayLog() {}
+void Palma::ReadPalmaPlayLog() {}
 
-void Controller_Palma::ResetPalmaPlayLog() {}
+void Palma::ResetPalmaPlayLog() {}
 
-void Controller_Palma::SetIsPalmaAllConnectable(bool is_all_connectable) {
+void Palma::SetIsPalmaAllConnectable(bool is_all_connectable) {
     // If true controllers are able to be paired
     is_connectable = is_all_connectable;
 }
 
-void Controller_Palma::SetIsPalmaPairedConnectable() {}
+void Palma::SetIsPalmaPairedConnectable() {}
 
-Result Controller_Palma::PairPalma(const PalmaConnectionHandle& handle) {
+Result Palma::PairPalma(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
@@ -218,14 +214,14 @@ Result Controller_Palma::PairPalma(const PalmaConnectionHandle& handle) {
     return ResultSuccess;
 }
 
-void Controller_Palma::SetPalmaBoostMode(bool boost_mode) {}
+void Palma::SetPalmaBoostMode(bool boost_mode) {}
 
-void Controller_Palma::CancelWritePalmaWaveEntry() {}
+void Palma::CancelWritePalmaWaveEntry() {}
 
-void Controller_Palma::EnablePalmaBoostMode() {}
+void Palma::EnablePalmaBoostMode() {}
 
-void Controller_Palma::GetPalmaBluetoothAddress() {}
+void Palma::GetPalmaBluetoothAddress() {}
 
-void Controller_Palma::SetDisallowedPalmaConnection() {}
+void Palma::SetDisallowedPalmaConnection() {}
 
 } // namespace Service::HID

src/core/hle/service/hid/controllers/palma.h

@@ -23,7 +23,7 @@ class EmulatedController;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_Palma final : public ControllerBase {
+class Palma final : public ControllerBase {
 public:
     using PalmaOperationData = std::array<u8, 0x140>;
 
@@ -97,9 +97,9 @@ public:
     static_assert(sizeof(PalmaConnectionHandle) == 0x8,
                   "PalmaConnectionHandle has incorrect size.");
 
-    explicit Controller_Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
-                              KernelHelpers::ServiceContext& service_context_);
-    ~Controller_Palma() override;
+    explicit Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_,
+                   KernelHelpers::ServiceContext& service_context_);
+    ~Palma() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/seven_six_axis.cpp

@@ -1,32 +1,29 @@
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <cstring>
+#include "common/common_types.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/frontend/emu_window.h"
 #include "core/hid/emulated_console.h"
+#include "core/hid/emulated_devices.h"
 #include "core/hid/hid_core.h"
-#include "core/hle/service/hid/controllers/console_sixaxis.h"
+#include "core/hle/service/hid/controllers/seven_six_axis.h"
 #include "core/memory.h"
 
 namespace Service::HID {
-constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200;
-
-Controller_ConsoleSixAxis::Controller_ConsoleSixAxis(Core::System& system_, u8* raw_shared_memory_)
+SevenSixAxis::SevenSixAxis(Core::System& system_)
     : ControllerBase{system_.HIDCore()}, system{system_} {
     console = hid_core.GetEmulatedConsole();
-    static_assert(SHARED_MEMORY_OFFSET + sizeof(ConsoleSharedMemory) < shared_memory_size,
-                  "ConsoleSharedMemory is bigger than the shared memory");
-    shared_memory = std::construct_at(
-        reinterpret_cast<ConsoleSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
 }
 
-Controller_ConsoleSixAxis::~Controller_ConsoleSixAxis() = default;
+SevenSixAxis::~SevenSixAxis() = default;
 
-void Controller_ConsoleSixAxis::OnInit() {}
+void SevenSixAxis::OnInit() {}
+void SevenSixAxis::OnRelease() {}
 
-void Controller_ConsoleSixAxis::OnRelease() {}
-
-void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void SevenSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated() || transfer_memory == 0) {
         seven_sixaxis_lifo.buffer_count = 0;
         seven_sixaxis_lifo.buffer_tail = 0;
@@ -53,22 +50,17 @@ void Controller_ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_ti
         -motion_status.quaternion.xyz.z,
     };
 
-    shared_memory->sampling_number++;
-    shared_memory->is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest;
-    shared_memory->verticalization_error = motion_status.verticalization_error;
-    shared_memory->gyro_bias = motion_status.gyro_bias;
-
-    // Update seven six axis transfer memory
     seven_sixaxis_lifo.WriteNextEntry(next_seven_sixaxis_state);
     system.ApplicationMemory().WriteBlock(transfer_memory, &seven_sixaxis_lifo,
                                           sizeof(seven_sixaxis_lifo));
 }
 
-void Controller_ConsoleSixAxis::SetTransferMemoryAddress(Common::ProcessAddress t_mem) {
+void SevenSixAxis::SetTransferMemoryAddress(Common::ProcessAddress t_mem) {
     transfer_memory = t_mem;
 }
 
-void Controller_ConsoleSixAxis::ResetTimestamp() {
+void SevenSixAxis::ResetTimestamp() {
     last_saved_timestamp = last_global_timestamp;
 }
+
 } // namespace Service::HID

src/core/hle/service/hid/controllers/seven_six_axis.h

@@ -1,10 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once
 
-#include <array>
-
+#include "common/common_types.h"
 #include "common/quaternion.h"
 #include "common/typed_address.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
@@ -19,10 +18,10 @@ class EmulatedConsole;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_ConsoleSixAxis final : public ControllerBase {
+class SevenSixAxis final : public ControllerBase {
 public:
-    explicit Controller_ConsoleSixAxis(Core::System& system_, u8* raw_shared_memory_);
-    ~Controller_ConsoleSixAxis() override;
+    explicit SevenSixAxis(Core::System& system_);
+    ~SevenSixAxis() override;
 
     // Called when the controller is initialized
     void OnInit() override;
@@ -51,28 +50,16 @@ private:
     };
     static_assert(sizeof(SevenSixAxisState) == 0x48, "SevenSixAxisState is an invalid size");
 
-    // This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat
-    struct ConsoleSharedMemory {
-        u64 sampling_number{};
-        bool is_seven_six_axis_sensor_at_rest{};
-        INSERT_PADDING_BYTES(3); // padding
-        f32 verticalization_error{};
-        Common::Vec3f gyro_bias{};
-        INSERT_PADDING_BYTES(4); // padding
-    };
-    static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size");
-
     Lifo<SevenSixAxisState, 0x21> seven_sixaxis_lifo{};
     static_assert(sizeof(seven_sixaxis_lifo) == 0xA70, "SevenSixAxisState is an invalid size");
 
-    SevenSixAxisState next_seven_sixaxis_state{};
-    Common::ProcessAddress transfer_memory{};
-    ConsoleSharedMemory* shared_memory = nullptr;
-    Core::HID::EmulatedConsole* console = nullptr;
-
     u64 last_saved_timestamp{};
     u64 last_global_timestamp{};
 
+    SevenSixAxisState next_seven_sixaxis_state{};
+    Common::ProcessAddress transfer_memory{};
+    Core::HID::EmulatedConsole* console = nullptr;
+
     Core::System& system;
 };
 } // namespace Service::HID

src/core/hle/service/hid/controllers/six_axis.cpp

@@ -0,0 +1,413 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/common_types.h"
+#include "core/core_timing.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "core/hle/service/hid/controllers/six_axis.h"
+#include "core/hle/service/hid/errors.h"
+#include "core/hle/service/hid/hid_util.h"
+
+namespace Service::HID {
+
+SixAxis::SixAxis(Core::HID::HIDCore& hid_core_, std::shared_ptr<NPad> npad_)
+    : ControllerBase{hid_core_}, npad{npad_} {
+    for (std::size_t i = 0; i < controller_data.size(); ++i) {
+        auto& controller = controller_data[i];
+        controller.device = hid_core.GetEmulatedControllerByIndex(i);
+    }
+}
+
+SixAxis::~SixAxis() = default;
+
+void SixAxis::OnInit() {}
+void SixAxis::OnRelease() {}
+
+void SixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+    if (!IsControllerActivated()) {
+        return;
+    }
+
+    for (std::size_t i = 0; i < controller_data.size(); ++i) {
+        auto& controller = controller_data[i];
+
+        const auto npad_id = IndexToNpadIdType(i);
+        const auto& controller_type = controller.device->GetNpadStyleIndex();
+
+        if (controller_type == Core::HID::NpadStyleIndex::None ||
+            !controller.device->IsConnected()) {
+            continue;
+        }
+
+        const auto& motion_state = controller.device->GetMotions();
+        auto& sixaxis_fullkey_state = controller.sixaxis_fullkey_state;
+        auto& sixaxis_handheld_state = controller.sixaxis_handheld_state;
+        auto& sixaxis_dual_left_state = controller.sixaxis_dual_left_state;
+        auto& sixaxis_dual_right_state = controller.sixaxis_dual_right_state;
+        auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
+        auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
+
+        auto& sixaxis_fullkey_lifo = npad->GetSixAxisFullkeyLifo(npad_id);
+        auto& sixaxis_handheld_lifo = npad->GetSixAxisHandheldLifo(npad_id);
+        auto& sixaxis_dual_left_lifo = npad->GetSixAxisDualLeftLifo(npad_id);
+        auto& sixaxis_dual_right_lifo = npad->GetSixAxisDualRightLifo(npad_id);
+        auto& sixaxis_left_lifo = npad->GetSixAxisLeftLifo(npad_id);
+        auto& sixaxis_right_lifo = npad->GetSixAxisRightLifo(npad_id);
+
+        // Clear previous state
+        sixaxis_fullkey_state = {};
+        sixaxis_handheld_state = {};
+        sixaxis_dual_left_state = {};
+        sixaxis_dual_right_state = {};
+        sixaxis_left_lifo_state = {};
+        sixaxis_right_lifo_state = {};
+
+        if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
+            controller.sixaxis_at_rest = true;
+            for (std::size_t e = 0; e < motion_state.size(); ++e) {
+                controller.sixaxis_at_rest =
+                    controller.sixaxis_at_rest && motion_state[e].is_at_rest;
+            }
+        }
+
+        const auto set_motion_state = [&](Core::HID::SixAxisSensorState& state,
+                                          const Core::HID::ControllerMotion& hid_state) {
+            using namespace std::literals::chrono_literals;
+            static constexpr Core::HID::SixAxisSensorState default_motion_state = {
+                .delta_time = std::chrono::nanoseconds(5ms).count(),
+                .accel = {0, 0, -1.0f},
+                .orientation =
+                    {
+                        Common::Vec3f{1.0f, 0, 0},
+                        Common::Vec3f{0, 1.0f, 0},
+                        Common::Vec3f{0, 0, 1.0f},
+                    },
+                .attribute = {1},
+            };
+            if (!controller.sixaxis_sensor_enabled) {
+                state = default_motion_state;
+                return;
+            }
+            if (!Settings::values.motion_enabled.GetValue()) {
+                state = default_motion_state;
+                return;
+            }
+            state.attribute.is_connected.Assign(1);
+            state.delta_time = std::chrono::nanoseconds(5ms).count();
+            state.accel = hid_state.accel;
+            state.gyro = hid_state.gyro;
+            state.rotation = hid_state.rotation;
+            state.orientation = hid_state.orientation;
+        };
+
+        switch (controller_type) {
+        case Core::HID::NpadStyleIndex::None:
+            ASSERT(false);
+            break;
+        case Core::HID::NpadStyleIndex::ProController:
+            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
+            break;
+        case Core::HID::NpadStyleIndex::Handheld:
+            set_motion_state(sixaxis_handheld_state, motion_state[0]);
+            break;
+        case Core::HID::NpadStyleIndex::JoyconDual:
+            set_motion_state(sixaxis_dual_left_state, motion_state[0]);
+            set_motion_state(sixaxis_dual_right_state, motion_state[1]);
+            break;
+        case Core::HID::NpadStyleIndex::JoyconLeft:
+            set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
+            break;
+        case Core::HID::NpadStyleIndex::JoyconRight:
+            set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
+            break;
+        case Core::HID::NpadStyleIndex::Pokeball:
+            using namespace std::literals::chrono_literals;
+            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
+            sixaxis_fullkey_state.delta_time = std::chrono::nanoseconds(15ms).count();
+            break;
+        default:
+            break;
+        }
+
+        sixaxis_fullkey_state.sampling_number =
+            sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_handheld_state.sampling_number =
+            sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_dual_left_state.sampling_number =
+            sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_dual_right_state.sampling_number =
+            sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_left_lifo_state.sampling_number =
+            sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_right_lifo_state.sampling_number =
+            sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
+
+        if (IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) {
+            // This buffer only is updated on handheld on HW
+            sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state);
+        } else {
+            // Handheld doesn't update this buffer on HW
+            sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state);
+        }
+
+        sixaxis_dual_left_lifo.WriteNextEntry(sixaxis_dual_left_state);
+        sixaxis_dual_right_lifo.WriteNextEntry(sixaxis_dual_right_state);
+        sixaxis_left_lifo.WriteNextEntry(sixaxis_left_lifo_state);
+        sixaxis_right_lifo.WriteNextEntry(sixaxis_right_lifo_state);
+    }
+}
+
+Result SixAxis::SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                          Core::HID::GyroscopeZeroDriftMode drift_mode) {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    auto& controller = GetControllerFromHandle(sixaxis_handle);
+    sixaxis.gyroscope_zero_drift_mode = drift_mode;
+    controller.device->SetGyroscopeZeroDriftMode(drift_mode);
+
+    return ResultSuccess;
+}
+
+Result SixAxis::GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                          Core::HID::GyroscopeZeroDriftMode& drift_mode) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    drift_mode = sixaxis.gyroscope_zero_drift_mode;
+
+    return ResultSuccess;
+}
+
+Result SixAxis::IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                      bool& is_at_rest) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto& controller = GetControllerFromHandle(sixaxis_handle);
+    is_at_rest = controller.sixaxis_at_rest;
+    return ResultSuccess;
+}
+
+Result SixAxis::LoadSixAxisSensorCalibrationParameter(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+    Core::HID::SixAxisSensorCalibrationParameter& calibration) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    // TODO: Request this data to the controller. On error return 0xd8ca
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    calibration = sixaxis.calibration;
+    return ResultSuccess;
+}
+
+Result SixAxis::GetSixAxisSensorIcInformation(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+    Core::HID::SixAxisSensorIcInformation& ic_information) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    // TODO: Request this data to the controller. On error return 0xd8ca
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    ic_information = sixaxis.ic_information;
+    return ResultSuccess;
+}
+
+Result SixAxis::EnableSixAxisSensorUnalteredPassthrough(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled) {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    sixaxis.unaltered_passtrough = is_enabled;
+    return ResultSuccess;
+}
+
+Result SixAxis::IsSixAxisSensorUnalteredPassthroughEnabled(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    is_enabled = sixaxis.unaltered_passtrough;
+    return ResultSuccess;
+}
+
+Result SixAxis::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                  bool sixaxis_status) {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    auto& controller = GetControllerFromHandle(sixaxis_handle);
+    controller.sixaxis_sensor_enabled = sixaxis_status;
+    return ResultSuccess;
+}
+
+Result SixAxis::IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                             bool& is_fusion_enabled) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    is_fusion_enabled = sixaxis.is_fusion_enabled;
+
+    return ResultSuccess;
+}
+Result SixAxis::SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                        bool is_fusion_enabled) {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    sixaxis.is_fusion_enabled = is_fusion_enabled;
+
+    return ResultSuccess;
+}
+
+Result SixAxis::SetSixAxisFusionParameters(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+    Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters) {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto param1 = sixaxis_fusion_parameters.parameter1;
+    if (param1 < 0.0f || param1 > 1.0f) {
+        return InvalidSixAxisFusionRange;
+    }
+
+    auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    sixaxis.fusion = sixaxis_fusion_parameters;
+
+    return ResultSuccess;
+}
+
+Result SixAxis::GetSixAxisFusionParameters(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+    Core::HID::SixAxisSensorFusionParameters& parameters) const {
+    const auto is_valid = IsSixaxisHandleValid(sixaxis_handle);
+    if (is_valid.IsError()) {
+        LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
+        return is_valid;
+    }
+
+    const auto& sixaxis = GetSixaxisState(sixaxis_handle);
+    parameters = sixaxis.fusion;
+
+    return ResultSuccess;
+}
+
+SixAxis::SixaxisParameters& SixAxis::GetSixaxisState(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
+    auto& controller = GetControllerFromHandle(sixaxis_handle);
+    switch (sixaxis_handle.npad_type) {
+    case Core::HID::NpadStyleIndex::ProController:
+    case Core::HID::NpadStyleIndex::Pokeball:
+        return controller.sixaxis_fullkey;
+    case Core::HID::NpadStyleIndex::Handheld:
+        return controller.sixaxis_handheld;
+    case Core::HID::NpadStyleIndex::JoyconDual:
+        if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
+            return controller.sixaxis_dual_left;
+        }
+        return controller.sixaxis_dual_right;
+    case Core::HID::NpadStyleIndex::JoyconLeft:
+        return controller.sixaxis_left;
+    case Core::HID::NpadStyleIndex::JoyconRight:
+        return controller.sixaxis_right;
+    default:
+        return controller.sixaxis_unknown;
+    }
+}
+
+const SixAxis::SixaxisParameters& SixAxis::GetSixaxisState(
+    const Core::HID::SixAxisSensorHandle& sixaxis_handle) const {
+    const auto& controller = GetControllerFromHandle(sixaxis_handle);
+    switch (sixaxis_handle.npad_type) {
+    case Core::HID::NpadStyleIndex::ProController:
+    case Core::HID::NpadStyleIndex::Pokeball:
+        return controller.sixaxis_fullkey;
+    case Core::HID::NpadStyleIndex::Handheld:
+        return controller.sixaxis_handheld;
+    case Core::HID::NpadStyleIndex::JoyconDual:
+        if (sixaxis_handle.device_index == Core::HID::DeviceIndex::Left) {
+            return controller.sixaxis_dual_left;
+        }
+        return controller.sixaxis_dual_right;
+    case Core::HID::NpadStyleIndex::JoyconLeft:
+        return controller.sixaxis_left;
+    case Core::HID::NpadStyleIndex::JoyconRight:
+        return controller.sixaxis_right;
+    default:
+        return controller.sixaxis_unknown;
+    }
+}
+
+SixAxis::NpadControllerData& SixAxis::GetControllerFromHandle(
+    const Core::HID::SixAxisSensorHandle& device_handle) {
+    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
+    return GetControllerFromNpadIdType(npad_id);
+}
+
+const SixAxis::NpadControllerData& SixAxis::GetControllerFromHandle(
+    const Core::HID::SixAxisSensorHandle& device_handle) const {
+    const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);
+    return GetControllerFromNpadIdType(npad_id);
+}
+
+SixAxis::NpadControllerData& SixAxis::GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) {
+    if (!IsNpadIdValid(npad_id)) {
+        LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
+        npad_id = Core::HID::NpadIdType::Player1;
+    }
+    const auto npad_index = NpadIdTypeToIndex(npad_id);
+    return controller_data[npad_index];
+}
+
+const SixAxis::NpadControllerData& SixAxis::GetControllerFromNpadIdType(
+    Core::HID::NpadIdType npad_id) const {
+    if (!IsNpadIdValid(npad_id)) {
+        LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
+        npad_id = Core::HID::NpadIdType::Player1;
+    }
+    const auto npad_index = NpadIdTypeToIndex(npad_id);
+    return controller_data[npad_index];
+}
+
+} // namespace Service::HID

src/core/hle/service/hid/controllers/six_axis.h

@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hid/hid_types.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/hle/service/hid/ring_lifo.h"
+
+namespace Core::HID {
+class EmulatedController;
+} // namespace Core::HID
+
+namespace Service::HID {
+class NPad;
+
+class SixAxis final : public ControllerBase {
+public:
+    explicit SixAxis(Core::HID::HIDCore& hid_core_, std::shared_ptr<NPad> npad_);
+    ~SixAxis() override;
+
+    // Called when the controller is initialized
+    void OnInit() override;
+
+    // When the controller is released
+    void OnRelease() override;
+
+    // When the controller is requesting an update for the shared memory
+    void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
+
+    Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                     Core::HID::GyroscopeZeroDriftMode drift_mode);
+    Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                     Core::HID::GyroscopeZeroDriftMode& drift_mode) const;
+    Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                 bool& is_at_rest) const;
+    Result EnableSixAxisSensorUnalteredPassthrough(
+        const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled);
+    Result IsSixAxisSensorUnalteredPassthroughEnabled(
+        const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const;
+    Result LoadSixAxisSensorCalibrationParameter(
+        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+        Core::HID::SixAxisSensorCalibrationParameter& calibration) const;
+    Result GetSixAxisSensorIcInformation(
+        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+        Core::HID::SixAxisSensorIcInformation& ic_information) const;
+    Result SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                             bool sixaxis_status);
+    Result IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                        bool& is_fusion_enabled) const;
+    Result SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                   bool is_fusion_enabled);
+    Result SetSixAxisFusionParameters(
+        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+        Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters);
+    Result GetSixAxisFusionParameters(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                      Core::HID::SixAxisSensorFusionParameters& parameters) const;
+
+private:
+    static constexpr std::size_t NPAD_COUNT = 10;
+
+    struct SixaxisParameters {
+        bool is_fusion_enabled{true};
+        bool unaltered_passtrough{false};
+        Core::HID::SixAxisSensorFusionParameters fusion{};
+        Core::HID::SixAxisSensorCalibrationParameter calibration{};
+        Core::HID::SixAxisSensorIcInformation ic_information{};
+        Core::HID::GyroscopeZeroDriftMode gyroscope_zero_drift_mode{
+            Core::HID::GyroscopeZeroDriftMode::Standard};
+    };
+
+    struct NpadControllerData {
+        Core::HID::EmulatedController* device = nullptr;
+
+        // Motion parameters
+        bool sixaxis_at_rest{true};
+        bool sixaxis_sensor_enabled{true};
+        SixaxisParameters sixaxis_fullkey{};
+        SixaxisParameters sixaxis_handheld{};
+        SixaxisParameters sixaxis_dual_left{};
+        SixaxisParameters sixaxis_dual_right{};
+        SixaxisParameters sixaxis_left{};
+        SixaxisParameters sixaxis_right{};
+        SixaxisParameters sixaxis_unknown{};
+
+        // Current pad state
+        Core::HID::SixAxisSensorState sixaxis_fullkey_state{};
+        Core::HID::SixAxisSensorState sixaxis_handheld_state{};
+        Core::HID::SixAxisSensorState sixaxis_dual_left_state{};
+        Core::HID::SixAxisSensorState sixaxis_dual_right_state{};
+        Core::HID::SixAxisSensorState sixaxis_left_lifo_state{};
+        Core::HID::SixAxisSensorState sixaxis_right_lifo_state{};
+        int callback_key{};
+    };
+
+    SixaxisParameters& GetSixaxisState(const Core::HID::SixAxisSensorHandle& device_handle);
+    const SixaxisParameters& GetSixaxisState(
+        const Core::HID::SixAxisSensorHandle& device_handle) const;
+
+    NpadControllerData& GetControllerFromHandle(
+        const Core::HID::SixAxisSensorHandle& device_handle);
+    const NpadControllerData& GetControllerFromHandle(
+        const Core::HID::SixAxisSensorHandle& device_handle) const;
+    NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id);
+    const NpadControllerData& GetControllerFromNpadIdType(Core::HID::NpadIdType npad_id) const;
+
+    std::shared_ptr<NPad> npad;
+    std::array<NpadControllerData, NPAD_COUNT> controller_data{};
+};
+} // namespace Service::HID

src/core/hle/service/hid/controllers/touchscreen.cpp

@@ -15,8 +15,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
 
-Controller_Touchscreen::Controller_Touchscreen(Core::HID::HIDCore& hid_core_,
-                                               u8* raw_shared_memory_)
+TouchScreen::TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
     : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(TouchSharedMemory) < shared_memory_size,
                   "TouchSharedMemory is bigger than the shared memory");
@@ -25,13 +24,13 @@ Controller_Touchscreen::Controller_Touchscreen(Core::HID::HIDCore& hid_core_,
     console = hid_core.GetEmulatedConsole();
 }
 
-Controller_Touchscreen::~Controller_Touchscreen() = default;
+TouchScreen::~TouchScreen() = default;
 
-void Controller_Touchscreen::OnInit() {}
+void TouchScreen::OnInit() {}
 
-void Controller_Touchscreen::OnRelease() {}
+void TouchScreen::OnRelease() {}
 
-void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     shared_memory->touch_screen_lifo.timestamp = core_timing.GetGlobalTimeNs().count();
 
     if (!IsControllerActivated()) {

src/core/hle/service/hid/controllers/touchscreen.h

@@ -14,10 +14,10 @@ class EmulatedConsole;
 } // namespace Core::HID
 
 namespace Service::HID {
-class Controller_Touchscreen final : public ControllerBase {
+class TouchScreen final : public ControllerBase {
 public:
-    explicit Controller_Touchscreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_Touchscreen() override;
+    explicit TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~TouchScreen() override;
 
     // Called when the controller is initialized
     void OnInit() override;

src/core/hle/service/hid/controllers/xpad.cpp

@@ -10,20 +10,19 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;
 
-Controller_XPad::Controller_XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
-    : ControllerBase{hid_core_} {
+XPad::XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(XpadSharedMemory) < shared_memory_size,
                   "XpadSharedMemory is bigger than the shared memory");
     shared_memory = std::construct_at(
         reinterpret_cast<XpadSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET));
 }
-Controller_XPad::~Controller_XPad() = default;
+XPad::~XPad() = default;
 
-void Controller_XPad::OnInit() {}
+void XPad::OnInit() {}
 
-void Controller_XPad::OnRelease() {}
+void XPad::OnRelease() {}
 
-void Controller_XPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
+void XPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     if (!IsControllerActivated()) {
         shared_memory->basic_xpad_lifo.buffer_count = 0;
         shared_memory->basic_xpad_lifo.buffer_tail = 0;

src/core/hle/service/hid/controllers/xpad.h

@@ -10,10 +10,10 @@
 #include "core/hle/service/hid/ring_lifo.h"
 
 namespace Service::HID {
-class Controller_XPad final : public ControllerBase {
+class XPad final : public ControllerBase {
 public:
-    explicit Controller_XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
-    ~Controller_XPad() override;
+    explicit XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_);
+    ~XPad() override;
 
     // Called when the controller is initialized
     void OnInit() override;

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

@@ -16,251 +16,461 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
       resource_manager{resource} {
     // clang-format off
     static const FunctionInfo functions[] = {
-            {31, nullptr, "SendKeyboardLockKeyEvent"},
-            {101, nullptr, "AcquireHomeButtonEventHandle"},
-            {111, nullptr, "ActivateHomeButton"},
-            {121, nullptr, "AcquireSleepButtonEventHandle"},
-            {131, nullptr, "ActivateSleepButton"},
-            {141, nullptr, "AcquireCaptureButtonEventHandle"},
-            {151, nullptr, "ActivateCaptureButton"},
-            {161, nullptr, "GetPlatformConfig"},
-            {210, nullptr, "AcquireNfcDeviceUpdateEventHandle"},
-            {211, nullptr, "GetNpadsWithNfc"},
-            {212, nullptr, "AcquireNfcActivateEventHandle"},
-            {213, nullptr, "ActivateNfc"},
-            {214, nullptr, "GetXcdHandleForNpadWithNfc"},
-            {215, nullptr, "IsNfcActivated"},
-            {230, nullptr, "AcquireIrSensorEventHandle"},
-            {231, nullptr, "ActivateIrSensor"},
-            {232, nullptr, "GetIrSensorState"},
-            {233, nullptr, "GetXcdHandleForNpadWithIrSensor"},
-            {301, nullptr, "ActivateNpadSystem"},
-            {303, &IHidSystemServer::ApplyNpadSystemCommonPolicy, "ApplyNpadSystemCommonPolicy"},
-            {304, nullptr, "EnableAssigningSingleOnSlSrPress"},
-            {305, nullptr, "DisableAssigningSingleOnSlSrPress"},
-            {306, &IHidSystemServer::GetLastActiveNpad, "GetLastActiveNpad"},
-            {307, nullptr, "GetNpadSystemExtStyle"},
-            {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
-            {309, nullptr, "GetNpadFullKeyGripColor"},
-            {310, nullptr, "GetMaskedSupportedNpadStyleSet"},
-            {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
-            {312, nullptr, "SetSupportedNpadStyleSetAll"},
-            {313, nullptr, "GetNpadCaptureButtonAssignment"},
-            {314, nullptr, "GetAppletFooterUiType"},
-            {315, nullptr, "GetAppletDetailedUiType"},
-            {316, nullptr, "GetNpadInterfaceType"},
-            {317, nullptr, "GetNpadLeftRightInterfaceType"},
-            {318, nullptr, "HasBattery"},
-            {319, nullptr, "HasLeftRightBattery"},
-            {321, &IHidSystemServer::GetUniquePadsFromNpad, "GetUniquePadsFromNpad"},
-            {322, nullptr, "GetIrSensorState"},
-            {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
-            {324, nullptr, "GetUniquePadButtonSet"},
-            {325, nullptr, "GetUniquePadColor"},
-            {326, nullptr, "GetUniquePadAppletDetailedUiType"},
-            {327, nullptr, "GetAbstractedPadIdDataFromNpad"},
-            {328, nullptr, "AttachAbstractedPadToNpad"},
-            {329, nullptr, "DetachAbstractedPadAll"},
-            {330, nullptr, "CheckAbstractedPadConnection"},
-            {500, nullptr, "SetAppletResourceUserId"},
-            {501, nullptr, "RegisterAppletResourceUserId"},
-            {502, nullptr, "UnregisterAppletResourceUserId"},
-            {503, nullptr, "EnableAppletToGetInput"},
-            {504, nullptr, "SetAruidValidForVibration"},
-            {505, nullptr, "EnableAppletToGetSixAxisSensor"},
-            {506, nullptr, "EnableAppletToGetPadInput"},
-            {507, nullptr, "EnableAppletToGetTouchScreen"},
-            {510, nullptr, "SetVibrationMasterVolume"},
-            {511, nullptr, "GetVibrationMasterVolume"},
-            {512, nullptr, "BeginPermitVibrationSession"},
-            {513, nullptr, "EndPermitVibrationSession"},
-            {514, nullptr, "Unknown514"},
-            {520, nullptr, "EnableHandheldHids"},
-            {521, nullptr, "DisableHandheldHids"},
-            {522, nullptr, "SetJoyConRailEnabled"},
-            {523, nullptr, "IsJoyConRailEnabled"},
-            {524, nullptr, "IsHandheldHidsEnabled"},
-            {525, nullptr, "IsJoyConAttachedOnAllRail"},
-            {540, nullptr, "AcquirePlayReportControllerUsageUpdateEvent"},
-            {541, nullptr, "GetPlayReportControllerUsages"},
-            {542, nullptr, "AcquirePlayReportRegisteredDeviceUpdateEvent"},
-            {543, nullptr, "GetRegisteredDevicesOld"},
-            {544, nullptr, "AcquireConnectionTriggerTimeoutEvent"},
-            {545, nullptr, "SendConnectionTrigger"},
-            {546, nullptr, "AcquireDeviceRegisteredEventForControllerSupport"},
-            {547, nullptr, "GetAllowedBluetoothLinksCount"},
-            {548, nullptr, "GetRegisteredDevices"},
-            {549, nullptr, "GetConnectableRegisteredDevices"},
-            {700, nullptr, "ActivateUniquePad"},
-            {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
-            {703, nullptr, "GetUniquePadIds"},
-            {751, &IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle, "AcquireJoyDetachOnBluetoothOffEventHandle"},
-            {800, nullptr, "ListSixAxisSensorHandles"},
-            {801, nullptr, "IsSixAxisSensorUserCalibrationSupported"},
-            {802, nullptr, "ResetSixAxisSensorCalibrationValues"},
-            {803, nullptr, "StartSixAxisSensorUserCalibration"},
-            {804, nullptr, "CancelSixAxisSensorUserCalibration"},
-            {805, nullptr, "GetUniquePadBluetoothAddress"},
-            {806, nullptr, "DisconnectUniquePad"},
-            {807, nullptr, "GetUniquePadType"},
-            {808, nullptr, "GetUniquePadInterface"},
-            {809, nullptr, "GetUniquePadSerialNumber"},
-            {810, nullptr, "GetUniquePadControllerNumber"},
-            {811, nullptr, "GetSixAxisSensorUserCalibrationStage"},
-            {812, nullptr, "GetConsoleUniqueSixAxisSensorHandle"},
-            {821, nullptr, "StartAnalogStickManualCalibration"},
-            {822, nullptr, "RetryCurrentAnalogStickManualCalibrationStage"},
-            {823, nullptr, "CancelAnalogStickManualCalibration"},
-            {824, nullptr, "ResetAnalogStickManualCalibration"},
-            {825, nullptr, "GetAnalogStickState"},
-            {826, nullptr, "GetAnalogStickManualCalibrationStage"},
-            {827, nullptr, "IsAnalogStickButtonPressed"},
-            {828, nullptr, "IsAnalogStickInReleasePosition"},
-            {829, nullptr, "IsAnalogStickInCircumference"},
-            {830, nullptr, "SetNotificationLedPattern"},
-            {831, nullptr, "SetNotificationLedPatternWithTimeout"},
-            {832, nullptr, "PrepareHidsForNotificationWake"},
-            {850, &IHidSystemServer::IsUsbFullKeyControllerEnabled, "IsUsbFullKeyControllerEnabled"},
-            {851, nullptr, "EnableUsbFullKeyController"},
-            {852, nullptr, "IsUsbConnected"},
-            {870, nullptr, "IsHandheldButtonPressedOnConsoleMode"},
-            {900, nullptr, "ActivateInputDetector"},
-            {901, nullptr, "NotifyInputDetector"},
-            {1000, nullptr, "InitializeFirmwareUpdate"},
-            {1001, nullptr, "GetFirmwareVersion"},
-            {1002, nullptr, "GetAvailableFirmwareVersion"},
-            {1003, nullptr, "IsFirmwareUpdateAvailable"},
-            {1004, nullptr, "CheckFirmwareUpdateRequired"},
-            {1005, nullptr, "StartFirmwareUpdate"},
-            {1006, nullptr, "AbortFirmwareUpdate"},
-            {1007, nullptr, "GetFirmwareUpdateState"},
-            {1008, nullptr, "ActivateAudioControl"},
-            {1009, nullptr, "AcquireAudioControlEventHandle"},
-            {1010, nullptr, "GetAudioControlStates"},
-            {1011, nullptr, "DeactivateAudioControl"},
-            {1050, nullptr, "IsSixAxisSensorAccurateUserCalibrationSupported"},
-            {1051, nullptr, "StartSixAxisSensorAccurateUserCalibration"},
-            {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
-            {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
-            {1100, nullptr, "GetHidbusSystemServiceObject"},
-            {1120, nullptr, "SetFirmwareHotfixUpdateSkipEnabled"},
-            {1130, nullptr, "InitializeUsbFirmwareUpdate"},
-            {1131, nullptr, "FinalizeUsbFirmwareUpdate"},
-            {1132, nullptr, "CheckUsbFirmwareUpdateRequired"},
-            {1133, nullptr, "StartUsbFirmwareUpdate"},
-            {1134, nullptr, "GetUsbFirmwareUpdateState"},
-            {1150, nullptr, "SetTouchScreenMagnification"},
-            {1151, nullptr, "GetTouchScreenFirmwareVersion"},
-            {1152, nullptr, "SetTouchScreenDefaultConfiguration"},
-            {1153, &IHidSystemServer::GetTouchScreenDefaultConfiguration, "GetTouchScreenDefaultConfiguration"},
-            {1154, nullptr, "IsFirmwareAvailableForNotification"},
-            {1155, nullptr, "SetForceHandheldStyleVibration"},
-            {1156, nullptr, "SendConnectionTriggerWithoutTimeoutEvent"},
-            {1157, nullptr, "CancelConnectionTrigger"},
-            {1200, nullptr, "IsButtonConfigSupported"},
-            {1201, nullptr, "IsButtonConfigEmbeddedSupported"},
-            {1202, nullptr, "DeleteButtonConfig"},
-            {1203, nullptr, "DeleteButtonConfigEmbedded"},
-            {1204, nullptr, "SetButtonConfigEnabled"},
-            {1205, nullptr, "SetButtonConfigEmbeddedEnabled"},
-            {1206, nullptr, "IsButtonConfigEnabled"},
-            {1207, nullptr, "IsButtonConfigEmbeddedEnabled"},
-            {1208, nullptr, "SetButtonConfigEmbedded"},
-            {1209, nullptr, "SetButtonConfigFull"},
-            {1210, nullptr, "SetButtonConfigLeft"},
-            {1211, nullptr, "SetButtonConfigRight"},
-            {1212, nullptr, "GetButtonConfigEmbedded"},
-            {1213, nullptr, "GetButtonConfigFull"},
-            {1214, nullptr, "GetButtonConfigLeft"},
-            {1215, nullptr, "GetButtonConfigRight"},
-            {1250, nullptr, "IsCustomButtonConfigSupported"},
-            {1251, nullptr, "IsDefaultButtonConfigEmbedded"},
-            {1252, nullptr, "IsDefaultButtonConfigFull"},
-            {1253, nullptr, "IsDefaultButtonConfigLeft"},
-            {1254, nullptr, "IsDefaultButtonConfigRight"},
-            {1255, nullptr, "IsButtonConfigStorageEmbeddedEmpty"},
-            {1256, nullptr, "IsButtonConfigStorageFullEmpty"},
-            {1257, nullptr, "IsButtonConfigStorageLeftEmpty"},
-            {1258, nullptr, "IsButtonConfigStorageRightEmpty"},
-            {1259, nullptr, "GetButtonConfigStorageEmbeddedDeprecated"},
-            {1260, nullptr, "GetButtonConfigStorageFullDeprecated"},
-            {1261, nullptr, "GetButtonConfigStorageLeftDeprecated"},
-            {1262, nullptr, "GetButtonConfigStorageRightDeprecated"},
-            {1263, nullptr, "SetButtonConfigStorageEmbeddedDeprecated"},
-            {1264, nullptr, "SetButtonConfigStorageFullDeprecated"},
-            {1265, nullptr, "SetButtonConfigStorageLeftDeprecated"},
-            {1266, nullptr, "SetButtonConfigStorageRightDeprecated"},
-            {1267, nullptr, "DeleteButtonConfigStorageEmbedded"},
-            {1268, nullptr, "DeleteButtonConfigStorageFull"},
-            {1269, nullptr, "DeleteButtonConfigStorageLeft"},
-            {1270, nullptr, "DeleteButtonConfigStorageRight"},
-            {1271, nullptr, "IsUsingCustomButtonConfig"},
-            {1272, nullptr, "IsAnyCustomButtonConfigEnabled"},
-            {1273, nullptr, "SetAllCustomButtonConfigEnabled"},
-            {1274, nullptr, "SetDefaultButtonConfig"},
-            {1275, nullptr, "SetAllDefaultButtonConfig"},
-            {1276, nullptr, "SetHidButtonConfigEmbedded"},
-            {1277, nullptr, "SetHidButtonConfigFull"},
-            {1278, nullptr, "SetHidButtonConfigLeft"},
-            {1279, nullptr, "SetHidButtonConfigRight"},
-            {1280, nullptr, "GetHidButtonConfigEmbedded"},
-            {1281, nullptr, "GetHidButtonConfigFull"},
-            {1282, nullptr, "GetHidButtonConfigLeft"},
-            {1283, nullptr, "GetHidButtonConfigRight"},
-            {1284, nullptr, "GetButtonConfigStorageEmbedded"},
-            {1285, nullptr, "GetButtonConfigStorageFull"},
-            {1286, nullptr, "GetButtonConfigStorageLeft"},
-            {1287, nullptr, "GetButtonConfigStorageRight"},
-            {1288, nullptr, "SetButtonConfigStorageEmbedded"},
-            {1289, nullptr, "SetButtonConfigStorageFull"},
-            {1290, nullptr, "DeleteButtonConfigStorageRight"},
-            {1291, nullptr, "DeleteButtonConfigStorageRight"},
+        {31, nullptr, "SendKeyboardLockKeyEvent"},
+        {101, nullptr, "AcquireHomeButtonEventHandle"},
+        {111, nullptr, "ActivateHomeButton"},
+        {121, nullptr, "AcquireSleepButtonEventHandle"},
+        {131, nullptr, "ActivateSleepButton"},
+        {141, nullptr, "AcquireCaptureButtonEventHandle"},
+        {151, nullptr, "ActivateCaptureButton"},
+        {161, nullptr, "GetPlatformConfig"},
+        {210, nullptr, "AcquireNfcDeviceUpdateEventHandle"},
+        {211, nullptr, "GetNpadsWithNfc"},
+        {212, nullptr, "AcquireNfcActivateEventHandle"},
+        {213, nullptr, "ActivateNfc"},
+        {214, nullptr, "GetXcdHandleForNpadWithNfc"},
+        {215, nullptr, "IsNfcActivated"},
+        {230, nullptr, "AcquireIrSensorEventHandle"},
+        {231, nullptr, "ActivateIrSensor"},
+        {232, nullptr, "GetIrSensorState"},
+        {233, nullptr, "GetXcdHandleForNpadWithIrSensor"},
+        {301, nullptr, "ActivateNpadSystem"},
+        {303, &IHidSystemServer::ApplyNpadSystemCommonPolicy, "ApplyNpadSystemCommonPolicy"},
+        {304, &IHidSystemServer::EnableAssigningSingleOnSlSrPress, "EnableAssigningSingleOnSlSrPress"},
+        {305, &IHidSystemServer::DisableAssigningSingleOnSlSrPress, "DisableAssigningSingleOnSlSrPress"},
+        {306, &IHidSystemServer::GetLastActiveNpad, "GetLastActiveNpad"},
+        {307, nullptr, "GetNpadSystemExtStyle"},
+        {308, &IHidSystemServer::ApplyNpadSystemCommonPolicyFull, "ApplyNpadSystemCommonPolicyFull"},
+        {309, &IHidSystemServer::GetNpadFullKeyGripColor, "GetNpadFullKeyGripColor"},
+        {310, &IHidSystemServer::GetMaskedSupportedNpadStyleSet, "GetMaskedSupportedNpadStyleSet"},
+        {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
+        {312, &IHidSystemServer::SetSupportedNpadStyleSetAll, "SetSupportedNpadStyleSetAll"},
+        {313, nullptr, "GetNpadCaptureButtonAssignment"},
+        {314, nullptr, "GetAppletFooterUiType"},
+        {315, &IHidSystemServer::GetAppletDetailedUiType, "GetAppletDetailedUiType"},
+        {316, &IHidSystemServer::GetNpadInterfaceType, "GetNpadInterfaceType"},
+        {317, &IHidSystemServer::GetNpadLeftRightInterfaceType, "GetNpadLeftRightInterfaceType"},
+        {318, &IHidSystemServer::HasBattery, "HasBattery"},
+        {319, &IHidSystemServer::HasLeftRightBattery, "HasLeftRightBattery"},
+        {321, &IHidSystemServer::GetUniquePadsFromNpad, "GetUniquePadsFromNpad"},
+        {322, &IHidSystemServer::GetIrSensorState, "GetIrSensorState"},
+        {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
+        {324, nullptr, "GetUniquePadButtonSet"},
+        {325, nullptr, "GetUniquePadColor"},
+        {326, nullptr, "GetUniquePadAppletDetailedUiType"},
+        {327, nullptr, "GetAbstractedPadIdDataFromNpad"},
+        {328, nullptr, "AttachAbstractedPadToNpad"},
+        {329, nullptr, "DetachAbstractedPadAll"},
+        {330, nullptr, "CheckAbstractedPadConnection"},
+        {500, nullptr, "SetAppletResourceUserId"},
+        {501, nullptr, "RegisterAppletResourceUserId"},
+        {502, nullptr, "UnregisterAppletResourceUserId"},
+        {503, nullptr, "EnableAppletToGetInput"},
+        {504, nullptr, "SetAruidValidForVibration"},
+        {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+        {506, nullptr, "EnableAppletToGetPadInput"},
+        {507, nullptr, "EnableAppletToGetTouchScreen"},
+        {510, nullptr, "SetVibrationMasterVolume"},
+        {511, nullptr, "GetVibrationMasterVolume"},
+        {512, nullptr, "BeginPermitVibrationSession"},
+        {513, nullptr, "EndPermitVibrationSession"},
+        {514, nullptr, "Unknown514"},
+        {520, nullptr, "EnableHandheldHids"},
+        {521, nullptr, "DisableHandheldHids"},
+        {522, nullptr, "SetJoyConRailEnabled"},
+        {523, nullptr, "IsJoyConRailEnabled"},
+        {524, nullptr, "IsHandheldHidsEnabled"},
+        {525, nullptr, "IsJoyConAttachedOnAllRail"},
+        {540, nullptr, "AcquirePlayReportControllerUsageUpdateEvent"},
+        {541, nullptr, "GetPlayReportControllerUsages"},
+        {542, nullptr, "AcquirePlayReportRegisteredDeviceUpdateEvent"},
+        {543, nullptr, "GetRegisteredDevicesOld"},
+        {544, &IHidSystemServer::AcquireConnectionTriggerTimeoutEvent, "AcquireConnectionTriggerTimeoutEvent"},
+        {545, nullptr, "SendConnectionTrigger"},
+        {546, &IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport, "AcquireDeviceRegisteredEventForControllerSupport"},
+        {547, nullptr, "GetAllowedBluetoothLinksCount"},
+        {548, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevices"},
+        {549, nullptr, "GetConnectableRegisteredDevices"},
+        {700, nullptr, "ActivateUniquePad"},
+        {702, &IHidSystemServer::AcquireUniquePadConnectionEventHandle, "AcquireUniquePadConnectionEventHandle"},
+        {703, &IHidSystemServer::GetUniquePadIds, "GetUniquePadIds"},
+        {751, &IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle, "AcquireJoyDetachOnBluetoothOffEventHandle"},
+        {800, nullptr, "ListSixAxisSensorHandles"},
+        {801, nullptr, "IsSixAxisSensorUserCalibrationSupported"},
+        {802, nullptr, "ResetSixAxisSensorCalibrationValues"},
+        {803, nullptr, "StartSixAxisSensorUserCalibration"},
+        {804, nullptr, "CancelSixAxisSensorUserCalibration"},
+        {805, nullptr, "GetUniquePadBluetoothAddress"},
+        {806, nullptr, "DisconnectUniquePad"},
+        {807, nullptr, "GetUniquePadType"},
+        {808, nullptr, "GetUniquePadInterface"},
+        {809, nullptr, "GetUniquePadSerialNumber"},
+        {810, nullptr, "GetUniquePadControllerNumber"},
+        {811, nullptr, "GetSixAxisSensorUserCalibrationStage"},
+        {812, nullptr, "GetConsoleUniqueSixAxisSensorHandle"},
+        {821, nullptr, "StartAnalogStickManualCalibration"},
+        {822, nullptr, "RetryCurrentAnalogStickManualCalibrationStage"},
+        {823, nullptr, "CancelAnalogStickManualCalibration"},
+        {824, nullptr, "ResetAnalogStickManualCalibration"},
+        {825, nullptr, "GetAnalogStickState"},
+        {826, nullptr, "GetAnalogStickManualCalibrationStage"},
+        {827, nullptr, "IsAnalogStickButtonPressed"},
+        {828, nullptr, "IsAnalogStickInReleasePosition"},
+        {829, nullptr, "IsAnalogStickInCircumference"},
+        {830, nullptr, "SetNotificationLedPattern"},
+        {831, nullptr, "SetNotificationLedPatternWithTimeout"},
+        {832, nullptr, "PrepareHidsForNotificationWake"},
+        {850, &IHidSystemServer::IsUsbFullKeyControllerEnabled, "IsUsbFullKeyControllerEnabled"},
+        {851, nullptr, "EnableUsbFullKeyController"},
+        {852, nullptr, "IsUsbConnected"},
+        {870, &IHidSystemServer::IsHandheldButtonPressedOnConsoleMode, "IsHandheldButtonPressedOnConsoleMode"},
+        {900, nullptr, "ActivateInputDetector"},
+        {901, nullptr, "NotifyInputDetector"},
+        {1000, &IHidSystemServer::InitializeFirmwareUpdate, "InitializeFirmwareUpdate"},
+        {1001, nullptr, "GetFirmwareVersion"},
+        {1002, nullptr, "GetAvailableFirmwareVersion"},
+        {1003, nullptr, "IsFirmwareUpdateAvailable"},
+        {1004, nullptr, "CheckFirmwareUpdateRequired"},
+        {1005, nullptr, "StartFirmwareUpdate"},
+        {1006, nullptr, "AbortFirmwareUpdate"},
+        {1007, nullptr, "GetFirmwareUpdateState"},
+        {1008, nullptr, "ActivateAudioControl"},
+        {1009, nullptr, "AcquireAudioControlEventHandle"},
+        {1010, nullptr, "GetAudioControlStates"},
+        {1011, nullptr, "DeactivateAudioControl"},
+        {1050, nullptr, "IsSixAxisSensorAccurateUserCalibrationSupported"},
+        {1051, nullptr, "StartSixAxisSensorAccurateUserCalibration"},
+        {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
+        {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
+        {1100, nullptr, "GetHidbusSystemServiceObject"},
+        {1120, nullptr, "SetFirmwareHotfixUpdateSkipEnabled"},
+        {1130, nullptr, "InitializeUsbFirmwareUpdate"},
+        {1131, nullptr, "FinalizeUsbFirmwareUpdate"},
+        {1132, nullptr, "CheckUsbFirmwareUpdateRequired"},
+        {1133, nullptr, "StartUsbFirmwareUpdate"},
+        {1134, nullptr, "GetUsbFirmwareUpdateState"},
+        {1135, &IHidSystemServer::InitializeUsbFirmwareUpdateWithoutMemory, "InitializeUsbFirmwareUpdateWithoutMemory"},
+        {1150, nullptr, "SetTouchScreenMagnification"},
+        {1151, nullptr, "GetTouchScreenFirmwareVersion"},
+        {1152, nullptr, "SetTouchScreenDefaultConfiguration"},
+        {1153, &IHidSystemServer::GetTouchScreenDefaultConfiguration, "GetTouchScreenDefaultConfiguration"},
+        {1154, nullptr, "IsFirmwareAvailableForNotification"},
+        {1155, nullptr, "SetForceHandheldStyleVibration"},
+        {1156, nullptr, "SendConnectionTriggerWithoutTimeoutEvent"},
+        {1157, nullptr, "CancelConnectionTrigger"},
+        {1200, nullptr, "IsButtonConfigSupported"},
+        {1201, nullptr, "IsButtonConfigEmbeddedSupported"},
+        {1202, nullptr, "DeleteButtonConfig"},
+        {1203, nullptr, "DeleteButtonConfigEmbedded"},
+        {1204, nullptr, "SetButtonConfigEnabled"},
+        {1205, nullptr, "SetButtonConfigEmbeddedEnabled"},
+        {1206, nullptr, "IsButtonConfigEnabled"},
+        {1207, nullptr, "IsButtonConfigEmbeddedEnabled"},
+        {1208, nullptr, "SetButtonConfigEmbedded"},
+        {1209, nullptr, "SetButtonConfigFull"},
+        {1210, nullptr, "SetButtonConfigLeft"},
+        {1211, nullptr, "SetButtonConfigRight"},
+        {1212, nullptr, "GetButtonConfigEmbedded"},
+        {1213, nullptr, "GetButtonConfigFull"},
+        {1214, nullptr, "GetButtonConfigLeft"},
+        {1215, nullptr, "GetButtonConfigRight"},
+        {1250, nullptr, "IsCustomButtonConfigSupported"},
+        {1251, nullptr, "IsDefaultButtonConfigEmbedded"},
+        {1252, nullptr, "IsDefaultButtonConfigFull"},
+        {1253, nullptr, "IsDefaultButtonConfigLeft"},
+        {1254, nullptr, "IsDefaultButtonConfigRight"},
+        {1255, nullptr, "IsButtonConfigStorageEmbeddedEmpty"},
+        {1256, nullptr, "IsButtonConfigStorageFullEmpty"},
+        {1257, nullptr, "IsButtonConfigStorageLeftEmpty"},
+        {1258, nullptr, "IsButtonConfigStorageRightEmpty"},
+        {1259, nullptr, "GetButtonConfigStorageEmbeddedDeprecated"},
+        {1260, nullptr, "GetButtonConfigStorageFullDeprecated"},
+        {1261, nullptr, "GetButtonConfigStorageLeftDeprecated"},
+        {1262, nullptr, "GetButtonConfigStorageRightDeprecated"},
+        {1263, nullptr, "SetButtonConfigStorageEmbeddedDeprecated"},
+        {1264, nullptr, "SetButtonConfigStorageFullDeprecated"},
+        {1265, nullptr, "SetButtonConfigStorageLeftDeprecated"},
+        {1266, nullptr, "SetButtonConfigStorageRightDeprecated"},
+        {1267, nullptr, "DeleteButtonConfigStorageEmbedded"},
+        {1268, nullptr, "DeleteButtonConfigStorageFull"},
+        {1269, nullptr, "DeleteButtonConfigStorageLeft"},
+        {1270, nullptr, "DeleteButtonConfigStorageRight"},
+        {1271, nullptr, "IsUsingCustomButtonConfig"},
+        {1272, nullptr, "IsAnyCustomButtonConfigEnabled"},
+        {1273, nullptr, "SetAllCustomButtonConfigEnabled"},
+        {1274, nullptr, "SetDefaultButtonConfig"},
+        {1275, nullptr, "SetAllDefaultButtonConfig"},
+        {1276, nullptr, "SetHidButtonConfigEmbedded"},
+        {1277, nullptr, "SetHidButtonConfigFull"},
+        {1278, nullptr, "SetHidButtonConfigLeft"},
+        {1279, nullptr, "SetHidButtonConfigRight"},
+        {1280, nullptr, "GetHidButtonConfigEmbedded"},
+        {1281, nullptr, "GetHidButtonConfigFull"},
+        {1282, nullptr, "GetHidButtonConfigLeft"},
+        {1283, nullptr, "GetHidButtonConfigRight"},
+        {1284, nullptr, "GetButtonConfigStorageEmbedded"},
+        {1285, nullptr, "GetButtonConfigStorageFull"},
+        {1286, nullptr, "GetButtonConfigStorageLeft"},
+        {1287, nullptr, "GetButtonConfigStorageRight"},
+        {1288, nullptr, "SetButtonConfigStorageEmbedded"},
+        {1289, nullptr, "SetButtonConfigStorageFull"},
+        {1290, nullptr, "DeleteButtonConfigStorageRight"},
+        {1291, nullptr, "DeleteButtonConfigStorageRight"},
     };
     // clang-format on
 
     RegisterHandlers(functions);
 
-    joy_detach_event = service_context.CreateEvent("HidSys::JoyDetachEvent");
+    joy_detach_event = service_context.CreateEvent("IHidSystemServer::JoyDetachEvent");
+    acquire_device_registered_event =
+        service_context.CreateEvent("IHidSystemServer::AcquireDeviceRegisteredEvent");
+    acquire_connection_trigger_timeout_event =
+        service_context.CreateEvent("IHidSystemServer::AcquireConnectionTriggerTimeoutEvent");
+    unique_pad_connection_event =
+        service_context.CreateEvent("IHidSystemServer::AcquireUniquePadConnectionEventHandle");
 }
 
 IHidSystemServer::~IHidSystemServer() {
     service_context.CloseEvent(joy_detach_event);
+    service_context.CloseEvent(acquire_device_registered_event);
+    service_context.CloseEvent(acquire_connection_trigger_timeout_event);
+    service_context.CloseEvent(unique_pad_connection_event);
 };
 
 void IHidSystemServer::ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) {
     LOG_WARNING(Service_HID, "called");
 
-    GetResourceManager()
-        ->GetController<Controller_NPad>(HidController::NPad)
-        .ApplyNpadSystemCommonPolicy();
+    GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::EnableAssigningSingleOnSlSrPress(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::DisableAssigningSingleOnSlSrPress(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
 }
 
 void IHidSystemServer::GetLastActiveNpad(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_HID, "(STUBBED) called");
+    LOG_DEBUG(Service_HID, "(STUBBED) called"); // Spams a lot when controller applet is running
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
     rb.PushEnum(system.HIDCore().GetLastActiveController());
 }
 
+void IHidSystemServer::ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "called");
+
+    GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::GetNpadFullKeyGripColor(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    Core::HID::NpadColor left_color{};
+    Core::HID::NpadColor right_color{};
+    // TODO: Get colors from Npad
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(left_color);
+    rb.PushRaw(right_color);
+}
+
+void IHidSystemServer::GetMaskedSupportedNpadStyleSet(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    LOG_INFO(Service_HID, "(STUBBED) called");
+
+    Core::HID::NpadStyleSet supported_styleset =
+        GetResourceManager()->GetNpad()->GetSupportedStyleSet().raw;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(supported_styleset);
+}
+
+void IHidSystemServer::SetSupportedNpadStyleSetAll(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    LOG_INFO(Service_HID, "(STUBBED) called");
+
+    Core::HID::NpadStyleSet supported_styleset =
+        GetResourceManager()->GetNpad()->GetSupportedStyleSet().raw;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(supported_styleset);
+}
+
+void IHidSystemServer::GetAppletDetailedUiType(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    const NPad::AppletDetailedUiType detailed_ui_type =
+        GetResourceManager()->GetNpad()->GetAppletDetailedUiType(npad_id_type);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(detailed_ui_type);
+}
+
+void IHidSystemServer::GetNpadInterfaceType(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(Core::HID::NpadInterfaceType::Bluetooth);
+}
+
+void IHidSystemServer::GetNpadLeftRightInterfaceType(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.PushEnum(Core::HID::NpadInterfaceType::Bluetooth);
+    rb.PushEnum(Core::HID::NpadInterfaceType::Bluetooth);
+}
+
+void IHidSystemServer::HasBattery(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(false);
+}
+
+void IHidSystemServer::HasLeftRightBattery(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
+
+    struct LeftRightBattery {
+        bool left;
+        bool right;
+    };
+
+    LeftRightBattery left_right_battery{
+        .left = false,
+        .right = false,
+    };
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(left_right_battery);
+}
+
 void IHidSystemServer::GetUniquePadsFromNpad(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto npad_id_type{rp.PopEnum<Core::HID::NpadIdType>()};
 
-    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id_type={}", npad_id_type);
+    LOG_DEBUG(Service_HID, "(STUBBED) called, npad_id_type={}",
+              npad_id_type); // Spams a lot when controller applet is running
 
     const std::vector<Core::HID::UniquePadId> unique_pads{};
 
-    ctx.WriteBuffer(unique_pads);
+    if (!unique_pads.empty()) {
+        ctx.WriteBuffer(unique_pads);
+    }
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
     rb.Push(static_cast<u32>(unique_pads.size()));
 }
 
+void IHidSystemServer::GetIrSensorState(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx) {
+    LOG_INFO(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
+}
+
+void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx) {
+    LOG_INFO(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(acquire_device_registered_event->GetReadableEvent());
+}
+
+void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    struct RegisterData {
+        std::array<u8, 0x68> data;
+    };
+    static_assert(sizeof(RegisterData) == 0x68, "RegisterData is an invalid size");
+    std::vector<RegisterData> registered_devices{};
+
+    if (!registered_devices.empty()) {
+        ctx.WriteBuffer(registered_devices);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(registered_devices.size());
+}
+
+void IHidSystemServer::AcquireUniquePadConnectionEventHandle(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.PushCopyObjects(unique_pad_connection_event->GetReadableEvent());
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::GetUniquePadIds(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(0);
+}
+
 void IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle(HLERequestContext& ctx) {
     LOG_INFO(Service_AM, "called");
 
@@ -279,6 +489,31 @@ void IHidSystemServer::IsUsbFullKeyControllerEnabled(HLERequestContext& ctx) {
     rb.Push(is_enabled);
 }
 
+void IHidSystemServer::IsHandheldButtonPressedOnConsoleMode(HLERequestContext& ctx) {
+    const bool button_pressed = false;
+
+    LOG_DEBUG(Service_HID, "(STUBBED) called, is_enabled={}",
+              button_pressed); // Spams a lot when controller applet is open
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(button_pressed);
+}
+
+void IHidSystemServer::InitializeFirmwareUpdate(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IHidSystemServer::InitializeUsbFirmwareUpdateWithoutMemory(HLERequestContext& ctx) {
+    LOG_WARNING(Service_HID, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 void IHidSystemServer::GetTouchScreenDefaultConfiguration(HLERequestContext& ctx) {
     LOG_WARNING(Service_HID, "(STUBBED) called");
 

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

@@ -24,15 +24,38 @@ public:
 
 private:
     void ApplyNpadSystemCommonPolicy(HLERequestContext& ctx);
+    void EnableAssigningSingleOnSlSrPress(HLERequestContext& ctx);
+    void DisableAssigningSingleOnSlSrPress(HLERequestContext& ctx);
     void GetLastActiveNpad(HLERequestContext& ctx);
+    void ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx);
+    void GetNpadFullKeyGripColor(HLERequestContext& ctx);
+    void GetMaskedSupportedNpadStyleSet(HLERequestContext& ctx);
+    void SetSupportedNpadStyleSetAll(HLERequestContext& ctx);
+    void GetAppletDetailedUiType(HLERequestContext& ctx);
+    void GetNpadInterfaceType(HLERequestContext& ctx);
+    void GetNpadLeftRightInterfaceType(HLERequestContext& ctx);
+    void HasBattery(HLERequestContext& ctx);
+    void HasLeftRightBattery(HLERequestContext& ctx);
     void GetUniquePadsFromNpad(HLERequestContext& ctx);
+    void GetIrSensorState(HLERequestContext& ctx);
+    void AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx);
+    void AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx);
+    void GetRegisteredDevices(HLERequestContext& ctx);
+    void AcquireUniquePadConnectionEventHandle(HLERequestContext& ctx);
+    void GetUniquePadIds(HLERequestContext& ctx);
     void AcquireJoyDetachOnBluetoothOffEventHandle(HLERequestContext& ctx);
     void IsUsbFullKeyControllerEnabled(HLERequestContext& ctx);
+    void IsHandheldButtonPressedOnConsoleMode(HLERequestContext& ctx);
+    void InitializeFirmwareUpdate(HLERequestContext& ctx);
+    void InitializeUsbFirmwareUpdateWithoutMemory(HLERequestContext& ctx);
     void GetTouchScreenDefaultConfiguration(HLERequestContext& ctx);
 
     std::shared_ptr<ResourceManager> GetResourceManager();
 
+    Kernel::KEvent* acquire_connection_trigger_timeout_event;
+    Kernel::KEvent* acquire_device_registered_event;
     Kernel::KEvent* joy_detach_event;
+    Kernel::KEvent* unique_pad_connection_event;
     KernelHelpers::ServiceContext service_context;
     std::shared_ptr<ResourceManager> resource_manager;
 };

src/core/hle/service/hid/hid_util.h

@@ -0,0 +1,146 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hid/hid_types.h"
+#include "core/hle/service/hid/errors.h"
+
+namespace Service::HID {
+
+constexpr bool IsNpadIdValid(const Core::HID::NpadIdType npad_id) {
+    switch (npad_id) {
+    case Core::HID::NpadIdType::Player1:
+    case Core::HID::NpadIdType::Player2:
+    case Core::HID::NpadIdType::Player3:
+    case Core::HID::NpadIdType::Player4:
+    case Core::HID::NpadIdType::Player5:
+    case Core::HID::NpadIdType::Player6:
+    case Core::HID::NpadIdType::Player7:
+    case Core::HID::NpadIdType::Player8:
+    case Core::HID::NpadIdType::Other:
+    case Core::HID::NpadIdType::Handheld:
+        return true;
+    default:
+        return false;
+    }
+}
+
+constexpr Result IsSixaxisHandleValid(const Core::HID::SixAxisSensorHandle& handle) {
+    const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(handle.npad_id));
+    const bool device_index = handle.device_index < Core::HID::DeviceIndex::MaxDeviceIndex;
+
+    if (!npad_id) {
+        return InvalidNpadId;
+    }
+    if (!device_index) {
+        return NpadDeviceIndexOutOfRange;
+    }
+
+    return ResultSuccess;
+}
+
+constexpr Result IsVibrationHandleValid(const Core::HID::VibrationDeviceHandle& handle) {
+    switch (handle.npad_type) {
+    case Core::HID::NpadStyleIndex::ProController:
+    case Core::HID::NpadStyleIndex::Handheld:
+    case Core::HID::NpadStyleIndex::JoyconDual:
+    case Core::HID::NpadStyleIndex::JoyconLeft:
+    case Core::HID::NpadStyleIndex::JoyconRight:
+    case Core::HID::NpadStyleIndex::GameCube:
+    case Core::HID::NpadStyleIndex::N64:
+    case Core::HID::NpadStyleIndex::SystemExt:
+    case Core::HID::NpadStyleIndex::System:
+        // These support vibration
+        break;
+    default:
+        return VibrationInvalidStyleIndex;
+    }
+
+    if (!IsNpadIdValid(static_cast<Core::HID::NpadIdType>(handle.npad_id))) {
+        return VibrationInvalidNpadId;
+    }
+
+    if (handle.device_index >= Core::HID::DeviceIndex::MaxDeviceIndex) {
+        return VibrationDeviceIndexOutOfRange;
+    }
+
+    return ResultSuccess;
+}
+
+/// Converts a Core::HID::NpadIdType to an array index.
+constexpr size_t NpadIdTypeToIndex(Core::HID::NpadIdType npad_id_type) {
+    switch (npad_id_type) {
+    case Core::HID::NpadIdType::Player1:
+        return 0;
+    case Core::HID::NpadIdType::Player2:
+        return 1;
+    case Core::HID::NpadIdType::Player3:
+        return 2;
+    case Core::HID::NpadIdType::Player4:
+        return 3;
+    case Core::HID::NpadIdType::Player5:
+        return 4;
+    case Core::HID::NpadIdType::Player6:
+        return 5;
+    case Core::HID::NpadIdType::Player7:
+        return 6;
+    case Core::HID::NpadIdType::Player8:
+        return 7;
+    case Core::HID::NpadIdType::Handheld:
+        return 8;
+    case Core::HID::NpadIdType::Other:
+        return 9;
+    default:
+        return 8;
+    }
+}
+
+/// Converts an array index to a Core::HID::NpadIdType
+constexpr Core::HID::NpadIdType IndexToNpadIdType(size_t index) {
+    switch (index) {
+    case 0:
+        return Core::HID::NpadIdType::Player1;
+    case 1:
+        return Core::HID::NpadIdType::Player2;
+    case 2:
+        return Core::HID::NpadIdType::Player3;
+    case 3:
+        return Core::HID::NpadIdType::Player4;
+    case 4:
+        return Core::HID::NpadIdType::Player5;
+    case 5:
+        return Core::HID::NpadIdType::Player6;
+    case 6:
+        return Core::HID::NpadIdType::Player7;
+    case 7:
+        return Core::HID::NpadIdType::Player8;
+    case 8:
+        return Core::HID::NpadIdType::Handheld;
+    case 9:
+        return Core::HID::NpadIdType::Other;
+    default:
+        return Core::HID::NpadIdType::Invalid;
+    }
+}
+
+constexpr Core::HID::NpadStyleSet GetStylesetByIndex(std::size_t index) {
+    switch (index) {
+    case 0:
+        return Core::HID::NpadStyleSet::Fullkey;
+    case 1:
+        return Core::HID::NpadStyleSet::Handheld;
+    case 2:
+        return Core::HID::NpadStyleSet::JoyDual;
+    case 3:
+        return Core::HID::NpadStyleSet::JoyLeft;
+    case 4:
+        return Core::HID::NpadStyleSet::JoyRight;
+    case 5:
+        return Core::HID::NpadStyleSet::Palma;
+    default:
+        return Core::HID::NpadStyleSet::None;
+    }
+}
+
+} // namespace Service::HID

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

@@ -12,6 +12,7 @@
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/hid/errors.h"
+#include "core/hle/service/hid/hid_util.h"
 #include "core/hle/service/hid/irs.h"
 #include "core/hle/service/hid/irsensor/clustering_processor.h"
 #include "core/hle/service/hid/irsensor/image_transfer_processor.h"
@@ -320,7 +321,7 @@ void IRS::GetNpadIrCameraHandle(HLERequestContext& ctx) {
     }
 
     Core::IrSensor::IrCameraHandle camera_handle{
-        .npad_id = static_cast<u8>(NpadIdTypeToIndex(npad_id)),
+        .npad_id = static_cast<u8>(HID::NpadIdTypeToIndex(npad_id)),
         .npad_type = Core::HID::NpadStyleIndex::None,
     };
 
@@ -545,7 +546,7 @@ void IRS::ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx) {
 
 Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const {
     if (camera_handle.npad_id >
-        static_cast<u8>(NpadIdTypeToIndex(Core::HID::NpadIdType::Handheld))) {
+        static_cast<u8>(HID::NpadIdTypeToIndex(Core::HID::NpadIdType::Handheld))) {
         return InvalidIrCameraHandle;
     }
     if (camera_handle.npad_type != Core::HID::NpadStyleIndex::None) {

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

@@ -9,14 +9,15 @@
 #include "core/hle/service/hid/resource_manager.h"
 #include "core/hle/service/ipc_helpers.h"
 
-#include "core/hle/service/hid/controllers/console_sixaxis.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
+#include "core/hle/service/hid/controllers/console_six_axis.h"
 #include "core/hle/service/hid/controllers/debug_pad.h"
 #include "core/hle/service/hid/controllers/gesture.h"
 #include "core/hle/service/hid/controllers/keyboard.h"
 #include "core/hle/service/hid/controllers/mouse.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/controllers/palma.h"
+#include "core/hle/service/hid/controllers/seven_six_axis.h"
+#include "core/hle/service/hid/controllers/six_axis.h"
 #include "core/hle/service/hid/controllers/stubbed.h"
 #include "core/hle/service/hid/controllers/touchscreen.h"
 #include "core/hle/service/hid/controllers/xpad.h"
@@ -42,76 +43,132 @@ void ResourceManager::Initialize() {
     }
 
     u8* shared_memory = system.Kernel().GetHidSharedMem().GetPointer();
-    MakeController<Controller_DebugPad>(HidController::DebugPad, shared_memory);
-    MakeController<Controller_Touchscreen>(HidController::Touchscreen, shared_memory);
-    MakeController<Controller_Mouse>(HidController::Mouse, shared_memory);
-    MakeController<Controller_Keyboard>(HidController::Keyboard, shared_memory);
-    MakeController<Controller_XPad>(HidController::XPad, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::HomeButton, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::SleepButton, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::CaptureButton, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::InputDetector, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::UniquePad, shared_memory);
-    MakeControllerWithServiceContext<Controller_NPad>(HidController::NPad, shared_memory);
-    MakeController<Controller_Gesture>(HidController::Gesture, shared_memory);
-    MakeController<Controller_ConsoleSixAxis>(HidController::ConsoleSixAxisSensor, shared_memory);
-    MakeController<Controller_Stubbed>(HidController::DebugMouse, shared_memory);
-    MakeControllerWithServiceContext<Controller_Palma>(HidController::Palma, shared_memory);
+    debug_pad = std::make_shared<DebugPad>(system.HIDCore(), shared_memory);
+    mouse = std::make_shared<Mouse>(system.HIDCore(), shared_memory);
+    debug_mouse = std::make_shared<DebugMouse>(system.HIDCore(), shared_memory);
+    keyboard = std::make_shared<Keyboard>(system.HIDCore(), shared_memory);
+    unique_pad = std::make_shared<UniquePad>(system.HIDCore(), shared_memory);
+    npad = std::make_shared<NPad>(system.HIDCore(), shared_memory, service_context);
+    gesture = std::make_shared<Gesture>(system.HIDCore(), shared_memory);
+    touch_screen = std::make_shared<TouchScreen>(system.HIDCore(), shared_memory);
+    xpad = std::make_shared<XPad>(system.HIDCore(), shared_memory);
+
+    palma = std::make_shared<Palma>(system.HIDCore(), shared_memory, service_context);
+
+    home_button = std::make_shared<HomeButton>(system.HIDCore(), shared_memory);
+    sleep_button = std::make_shared<SleepButton>(system.HIDCore(), shared_memory);
+    capture_button = std::make_shared<CaptureButton>(system.HIDCore(), shared_memory);
+
+    six_axis = std::make_shared<SixAxis>(system.HIDCore(), npad);
+    console_six_axis = std::make_shared<ConsoleSixAxis>(system.HIDCore(), shared_memory);
+    seven_six_axis = std::make_shared<SevenSixAxis>(system);
+
+    home_button->SetCommonHeaderOffset(0x4C00);
+    sleep_button->SetCommonHeaderOffset(0x4E00);
+    capture_button->SetCommonHeaderOffset(0x5000);
+    unique_pad->SetCommonHeaderOffset(0x5A00);
+    debug_mouse->SetCommonHeaderOffset(0x3DC00);
 
     // Homebrew doesn't try to activate some controllers, so we activate them by default
-    GetController<Controller_NPad>(HidController::NPad).Activate();
-    GetController<Controller_Touchscreen>(HidController::Touchscreen).Activate();
-
-    GetController<Controller_Stubbed>(HidController::HomeButton).SetCommonHeaderOffset(0x4C00);
-    GetController<Controller_Stubbed>(HidController::SleepButton).SetCommonHeaderOffset(0x4E00);
-    GetController<Controller_Stubbed>(HidController::CaptureButton).SetCommonHeaderOffset(0x5000);
-    GetController<Controller_Stubbed>(HidController::InputDetector).SetCommonHeaderOffset(0x5200);
-    GetController<Controller_Stubbed>(HidController::UniquePad).SetCommonHeaderOffset(0x5A00);
-    GetController<Controller_Stubbed>(HidController::DebugMouse).SetCommonHeaderOffset(0x3DC00);
+    npad->Activate();
+    six_axis->Activate();
+    touch_screen->Activate();
 
     system.HIDCore().ReloadInputDevices();
     is_initialized = true;
 }
+std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const {
+    return capture_button;
+}
+
+std::shared_ptr<ConsoleSixAxis> ResourceManager::GetConsoleSixAxis() const {
+    return console_six_axis;
+}
+
+std::shared_ptr<DebugMouse> ResourceManager::GetDebugMouse() const {
+    return debug_mouse;
+}
+
+std::shared_ptr<DebugPad> ResourceManager::GetDebugPad() const {
+    return debug_pad;
+}
+
+std::shared_ptr<Gesture> ResourceManager::GetGesture() const {
+    return gesture;
+}
+
+std::shared_ptr<HomeButton> ResourceManager::GetHomeButton() const {
+    return home_button;
+}
+
+std::shared_ptr<Keyboard> ResourceManager::GetKeyboard() const {
+    return keyboard;
+}
+
+std::shared_ptr<Mouse> ResourceManager::GetMouse() const {
+    return mouse;
+}
+
+std::shared_ptr<NPad> ResourceManager::GetNpad() const {
+    return npad;
+}
+
+std::shared_ptr<Palma> ResourceManager::GetPalma() const {
+    return palma;
+}
+
+std::shared_ptr<SevenSixAxis> ResourceManager::GetSevenSixAxis() const {
+    return seven_six_axis;
+}
+
+std::shared_ptr<SixAxis> ResourceManager::GetSixAxis() const {
+    return six_axis;
+}
+
+std::shared_ptr<SleepButton> ResourceManager::GetSleepButton() const {
+    return sleep_button;
+}
+
+std::shared_ptr<TouchScreen> ResourceManager::GetTouchScreen() const {
+    return touch_screen;
+}
+
+std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const {
+    return unique_pad;
+}
 
 void ResourceManager::UpdateControllers(std::uintptr_t user_data,
                                         std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
-
-    for (const auto& controller : controllers) {
-        // Keyboard has it's own update event
-        if (controller == controllers[static_cast<size_t>(HidController::Keyboard)]) {
-            continue;
-        }
-        // Mouse has it's own update event
-        if (controller == controllers[static_cast<size_t>(HidController::Mouse)]) {
-            continue;
-        }
-        // Npad has it's own update event
-        if (controller == controllers[static_cast<size_t>(HidController::NPad)]) {
-            continue;
-        }
-        controller->OnUpdate(core_timing);
-    }
+    debug_pad->OnUpdate(core_timing);
+    unique_pad->OnUpdate(core_timing);
+    gesture->OnUpdate(core_timing);
+    touch_screen->OnUpdate(core_timing);
+    palma->OnUpdate(core_timing);
+    home_button->OnUpdate(core_timing);
+    sleep_button->OnUpdate(core_timing);
+    capture_button->OnUpdate(core_timing);
+    xpad->OnUpdate(core_timing);
 }
 
 void ResourceManager::UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
-
-    controllers[static_cast<size_t>(HidController::NPad)]->OnUpdate(core_timing);
+    npad->OnUpdate(core_timing);
 }
 
 void ResourceManager::UpdateMouseKeyboard(std::uintptr_t user_data,
                                           std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
-
-    controllers[static_cast<size_t>(HidController::Mouse)]->OnUpdate(core_timing);
-    controllers[static_cast<size_t>(HidController::Keyboard)]->OnUpdate(core_timing);
+    mouse->OnUpdate(core_timing);
+    debug_mouse->OnUpdate(core_timing);
+    keyboard->OnUpdate(core_timing);
 }
 
 void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
-
-    controllers[static_cast<size_t>(HidController::NPad)]->OnMotionUpdate(core_timing);
+    six_axis->OnUpdate(core_timing);
+    seven_six_axis->OnUpdate(core_timing);
+    console_six_axis->OnUpdate(core_timing);
 }
 
 IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource)

src/core/hle/service/hid/resource_manager.h

@@ -3,10 +3,6 @@
 
 #pragma once
 
-#include <chrono>
-
-#include "core/core.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/service.h"
 
@@ -14,74 +10,85 @@ namespace Core::Timing {
 struct EventType;
 }
 
-namespace Core::HID {
-class HIDCore;
-}
-
 namespace Service::HID {
+class Controller_Stubbed;
+class ConsoleSixAxis;
+class DebugPad;
+class Gesture;
+class Keyboard;
+class Mouse;
+class NPad;
+class Palma;
+class SevenSixAxis;
+class SixAxis;
+class TouchScreen;
+class XPad;
 
-enum class HidController : std::size_t {
-    DebugPad,
-    Touchscreen,
-    Mouse,
-    Keyboard,
-    XPad,
-    HomeButton,
-    SleepButton,
-    CaptureButton,
-    InputDetector,
-    UniquePad,
-    NPad,
-    Gesture,
-    ConsoleSixAxisSensor,
-    DebugMouse,
-    Palma,
+using CaptureButton = Controller_Stubbed;
+using DebugMouse = Controller_Stubbed;
+using HomeButton = Controller_Stubbed;
+using SleepButton = Controller_Stubbed;
+using UniquePad = Controller_Stubbed;
 
-    MaxControllers,
-};
 class ResourceManager {
+
 public:
     explicit ResourceManager(Core::System& system_);
     ~ResourceManager();
 
-    template <typename T>
-    T& GetController(HidController controller) {
-        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
-    }
-
-    template <typename T>
-    const T& GetController(HidController controller) const {
-        return static_cast<T&>(*controllers[static_cast<size_t>(controller)]);
-    }
-
     void Initialize();
 
+    std::shared_ptr<CaptureButton> GetCaptureButton() const;
+    std::shared_ptr<ConsoleSixAxis> GetConsoleSixAxis() const;
+    std::shared_ptr<DebugMouse> GetDebugMouse() const;
+    std::shared_ptr<DebugPad> GetDebugPad() const;
+    std::shared_ptr<Gesture> GetGesture() const;
+    std::shared_ptr<HomeButton> GetHomeButton() const;
+    std::shared_ptr<Keyboard> GetKeyboard() const;
+    std::shared_ptr<Mouse> GetMouse() const;
+    std::shared_ptr<NPad> GetNpad() const;
+    std::shared_ptr<Palma> GetPalma() const;
+    std::shared_ptr<SevenSixAxis> GetSevenSixAxis() const;
+    std::shared_ptr<SixAxis> GetSixAxis() const;
+    std::shared_ptr<SleepButton> GetSleepButton() const;
+    std::shared_ptr<TouchScreen> GetTouchScreen() const;
+    std::shared_ptr<UniquePad> GetUniquePad() const;
+
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
 private:
-    template <typename T>
-    void MakeController(HidController controller, u8* shared_memory) {
-        if constexpr (std::is_constructible_v<T, Core::System&, u8*>) {
-            controllers[static_cast<std::size_t>(controller)] =
-                std::make_unique<T>(system, shared_memory);
-        } else {
-            controllers[static_cast<std::size_t>(controller)] =
-                std::make_unique<T>(system.HIDCore(), shared_memory);
-        }
-    }
-
-    template <typename T>
-    void MakeControllerWithServiceContext(HidController controller, u8* shared_memory) {
-        controllers[static_cast<std::size_t>(controller)] =
-            std::make_unique<T>(system.HIDCore(), shared_memory, service_context);
-    }
-
     bool is_initialized{false};
-    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
-        controllers{};
+
+    std::shared_ptr<CaptureButton> capture_button = nullptr;
+    std::shared_ptr<ConsoleSixAxis> console_six_axis = nullptr;
+    std::shared_ptr<DebugMouse> debug_mouse = nullptr;
+    std::shared_ptr<DebugPad> debug_pad = nullptr;
+    std::shared_ptr<Gesture> gesture = nullptr;
+    std::shared_ptr<HomeButton> home_button = nullptr;
+    std::shared_ptr<Keyboard> keyboard = nullptr;
+    std::shared_ptr<Mouse> mouse = nullptr;
+    std::shared_ptr<NPad> npad = nullptr;
+    std::shared_ptr<Palma> palma = nullptr;
+    std::shared_ptr<SevenSixAxis> seven_six_axis = nullptr;
+    std::shared_ptr<SixAxis> six_axis = nullptr;
+    std::shared_ptr<SleepButton> sleep_button = nullptr;
+    std::shared_ptr<TouchScreen> touch_screen = nullptr;
+    std::shared_ptr<UniquePad> unique_pad = nullptr;
+    std::shared_ptr<XPad> xpad = nullptr;
+
+    // TODO: Create these resources
+    // std::shared_ptr<AudioControl> audio_control = nullptr;
+    // std::shared_ptr<ButtonConfig> button_config = nullptr;
+    // std::shared_ptr<Config> config = nullptr;
+    // std::shared_ptr<Connection> connection = nullptr;
+    // std::shared_ptr<CustomConfig> custom_config = nullptr;
+    // std::shared_ptr<Digitizer> digitizer = nullptr;
+    // std::shared_ptr<Hdls> hdls = nullptr;
+    // std::shared_ptr<PlayReport> play_report = nullptr;
+    // std::shared_ptr<Rail> rail = nullptr;
 
     Core::System& system;
     KernelHelpers::ServiceContext service_context;

src/core/hle/service/ldn/ldn.cpp

@@ -115,12 +115,20 @@ public:
             {400, nullptr, "InitializeSystem"},
             {401, nullptr, "FinalizeSystem"},
             {402, nullptr, "SetOperationMode"},
-            {403, nullptr, "InitializeSystem2"},
+            {403, &ISystemLocalCommunicationService::InitializeSystem2, "InitializeSystem2"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
+
+private:
+    void InitializeSystem2(HLERequestContext& ctx) {
+        LOG_WARNING(Service_LDN, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
 };
 
 class IUserLocalCommunicationService final

src/core/hle/service/nfc/common/device_manager.cpp

@@ -7,6 +7,7 @@
 #include "core/core.h"
 #include "core/hid/hid_types.h"
 #include "core/hle/kernel/k_event.h"
+#include "core/hle/service/hid/hid_util.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/nfc/common/device.h"
 #include "core/hle/service/nfc/common/device_manager.h"
@@ -24,7 +25,7 @@ DeviceManager::DeviceManager(Core::System& system_, KernelHelpers::ServiceContex
 
     for (u32 device_index = 0; device_index < devices.size(); device_index++) {
         devices[device_index] =
-            std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,
+            std::make_shared<NfcDevice>(HID::IndexToNpadIdType(device_index), system,
                                         service_context, availability_change_event);
     }
 

src/core/hle/service/set/set_sys.cpp

@@ -431,8 +431,7 @@ void SET_SYS::GetAutoUpdateEnableFlag(HLERequestContext& ctx) {
 void SET_SYS::GetBatteryPercentageFlag(HLERequestContext& ctx) {
     u8 battery_percentage_flag{1};
 
-    LOG_WARNING(Service_SET, "(STUBBED) called, battery_percentage_flag={}",
-                battery_percentage_flag);
+    LOG_DEBUG(Service_SET, "(STUBBED) called, battery_percentage_flag={}", battery_percentage_flag);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
@@ -492,6 +491,29 @@ void SET_SYS::GetChineseTraditionalInputMethod(HLERequestContext& ctx) {
     rb.PushEnum(ChineseTraditionalInputMethod::Unknown0);
 }
 
+void SET_SYS::GetHomeMenuScheme(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_SET, "(STUBBED) called");
+
+    const HomeMenuScheme default_color = {
+        .main = 0xFF323232,
+        .back = 0xFF323232,
+        .sub = 0xFFFFFFFF,
+        .bezel = 0xFFFFFFFF,
+        .extra = 0xFF000000,
+    };
+
+    IPC::ResponseBuilder rb{ctx, 7};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(default_color);
+}
+
+void SET_SYS::GetHomeMenuSchemeModel(HLERequestContext& ctx) {
+    LOG_WARNING(Service_SET, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(0);
+}
 void SET_SYS::GetFieldTestingFlag(HLERequestContext& ctx) {
     LOG_WARNING(Service_SET, "(STUBBED) called");
 
@@ -674,7 +696,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {171, nullptr, "SetChineseTraditionalInputMethod"},
         {172, nullptr, "GetPtmCycleCountReliability"},
         {173, nullptr, "SetPtmCycleCountReliability"},
-        {174, nullptr, "GetHomeMenuScheme"},
+        {174, &SET_SYS::GetHomeMenuScheme, "GetHomeMenuScheme"},
         {175, nullptr, "GetThemeSettings"},
         {176, nullptr, "SetThemeSettings"},
         {177, nullptr, "GetThemeKey"},
@@ -685,7 +707,7 @@ SET_SYS::SET_SYS(Core::System& system_) : ServiceFramework{system_, "set:sys"} {
         {182, nullptr, "SetT"},
         {183, nullptr, "GetPlatformRegion"},
         {184, nullptr, "SetPlatformRegion"},
-        {185, nullptr, "GetHomeMenuSchemeModel"},
+        {185, &SET_SYS::GetHomeMenuSchemeModel, "GetHomeMenuSchemeModel"},
         {186, nullptr, "GetMemoryUsageRateFlag"},
         {187, nullptr, "GetTouchScreenMode"},
         {188, nullptr, "SetTouchScreenMode"},

src/core/hle/service/set/set_sys.h

@@ -269,6 +269,16 @@ private:
     };
     static_assert(sizeof(EulaVersion) == 0x30, "EulaVersion is incorrect size");
 
+    /// This is nn::settings::system::HomeMenuScheme
+    struct HomeMenuScheme {
+        u32 main;
+        u32 back;
+        u32 sub;
+        u32 bezel;
+        u32 extra;
+    };
+    static_assert(sizeof(HomeMenuScheme) == 0x14, "HomeMenuScheme is incorrect size");
+
     void SetLanguageCode(HLERequestContext& ctx);
     void GetFirmwareVersion(HLERequestContext& ctx);
     void GetFirmwareVersion2(HLERequestContext& ctx);
@@ -305,6 +315,8 @@ private:
     void GetKeyboardLayout(HLERequestContext& ctx);
     void GetChineseTraditionalInputMethod(HLERequestContext& ctx);
     void GetFieldTestingFlag(HLERequestContext& ctx);
+    void GetHomeMenuScheme(HLERequestContext& ctx);
+    void GetHomeMenuSchemeModel(HLERequestContext& ctx);
 
     AccountSettings account_settings{
         .flags = {},

src/core/loader/deconstructed_rom_directory.cpp

@@ -15,7 +15,7 @@
 #include "core/loader/deconstructed_rom_directory.h"
 #include "core/loader/nso.h"
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
 #include "core/arm/nce/patch.h"
 #endif
 
@@ -141,12 +141,12 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     std::size_t code_size{};
 
     // Define an nce patch context for each potential module.
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
     std::array<Core::NCE::Patcher, 13> module_patchers;
 #endif
 
     const auto GetPatcher = [&](size_t i) -> Core::NCE::Patcher* {
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
         if (Settings::IsNceEnabled()) {
             return &module_patchers[i];
         }

src/core/loader/nro.cpp

@@ -22,7 +22,7 @@
 #include "core/loader/nso.h"
 #include "core/memory.h"
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
 #include "core/arm/nce/patch.h"
 #endif
 
@@ -201,7 +201,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     program_image.resize(static_cast<u32>(program_image.size()) + bss_size);
     size_t image_size = program_image.size();
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
     const auto& code = codeset.CodeSegment();
 
     // NROs always have a 39-bit address space.
@@ -247,7 +247,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
 
     // Relocate code patch and copy to the program_image if running under NCE.
     // This needs to be after LoadFromMetadata so we can use the process entry point.
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
     if (Settings::IsNceEnabled()) {
         patch.RelocateAndCopy(process.GetEntryPoint(), code, program_image,
                               &process.GetPostHandlers());

src/core/loader/nso.cpp

@@ -20,7 +20,7 @@
 #include "core/loader/nso.h"
 #include "core/memory.h"
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
 #include "core/arm/nce/patch.h"
 #endif
 
@@ -93,7 +93,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
 
     // Allocate some space at the beginning if we are patching in PreText mode.
     const size_t module_start = [&]() -> size_t {
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
         if (patch && patch->GetPatchMode() == Core::NCE::PatchMode::PreText) {
             return patch->GetSectionSize();
         }
@@ -145,17 +145,19 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
     // Apply patches if necessary
     const auto name = nso_file.GetName();
     if (pm && (pm->HasNSOPatch(nso_header.build_id, name) || Settings::values.dump_nso)) {
-        std::vector<u8> pi_header(sizeof(NSOHeader) + program_image.size());
+        std::span<u8> patchable_section(program_image.data() + module_start,
+                                        program_image.size() - module_start);
+        std::vector<u8> pi_header(sizeof(NSOHeader) + patchable_section.size());
         std::memcpy(pi_header.data(), &nso_header, sizeof(NSOHeader));
-        std::memcpy(pi_header.data() + sizeof(NSOHeader), program_image.data(),
-                    program_image.size());
+        std::memcpy(pi_header.data() + sizeof(NSOHeader), patchable_section.data(),
+                    patchable_section.size());
 
         pi_header = pm->PatchNSO(pi_header, name);
 
-        std::copy(pi_header.begin() + sizeof(NSOHeader), pi_header.end(), program_image.data());
+        std::copy(pi_header.begin() + sizeof(NSOHeader), pi_header.end(), patchable_section.data());
     }
 
-#ifdef ARCHITECTURE_arm64
+#ifdef HAS_NCE
     // If we are computing the process code layout and using nce backend, patch.
     const auto& code = codeset.CodeSegment();
     if (patch && patch->GetPatchMode() == Core::NCE::PatchMode::None) {

src/core/memory.cpp

@@ -78,6 +78,51 @@ struct Memory::Impl {
         }
     }
 
+    void ProtectRegion(Common::PageTable& page_table, VAddr vaddr, u64 size,
+                       Common::MemoryPermission perms) {
+        ASSERT_MSG((size & YUZU_PAGEMASK) == 0, "non-page aligned size: {:016X}", size);
+        ASSERT_MSG((vaddr & YUZU_PAGEMASK) == 0, "non-page aligned base: {:016X}", vaddr);
+
+        if (!Settings::IsFastmemEnabled()) {
+            return;
+        }
+
+        const bool is_r = True(perms & Common::MemoryPermission::Read);
+        const bool is_w = True(perms & Common::MemoryPermission::Write);
+        const bool is_x =
+            True(perms & Common::MemoryPermission::Execute) && Settings::IsNceEnabled();
+
+        if (!current_page_table) {
+            system.DeviceMemory().buffer.Protect(vaddr, size, is_r, is_w, is_x);
+            return;
+        }
+
+        u64 protect_bytes{};
+        u64 protect_begin{};
+        for (u64 addr = vaddr; addr < vaddr + size; addr += YUZU_PAGESIZE) {
+            const Common::PageType page_type{
+                current_page_table->pointers[addr >> YUZU_PAGEBITS].Type()};
+            switch (page_type) {
+            case Common::PageType::RasterizerCachedMemory:
+                if (protect_bytes > 0) {
+                    system.DeviceMemory().buffer.Protect(protect_begin, protect_bytes, is_r, is_w,
+                                                         is_x);
+                    protect_bytes = 0;
+                }
+                break;
+            default:
+                if (protect_bytes == 0) {
+                    protect_begin = addr;
+                }
+                protect_bytes += YUZU_PAGESIZE;
+            }
+        }
+
+        if (protect_bytes > 0) {
+            system.DeviceMemory().buffer.Protect(protect_begin, protect_bytes, is_r, is_w, is_x);
+        }
+    }
+
     [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
         const Common::PhysicalAddress paddr{
             current_page_table->backing_addr[vaddr >> YUZU_PAGEBITS]};
@@ -839,6 +884,11 @@ void Memory::UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress b
     impl->UnmapRegion(page_table, base, size);
 }
 
+void Memory::ProtectRegion(Common::PageTable& page_table, Common::ProcessAddress vaddr, u64 size,
+                           Common::MemoryPermission perms) {
+    impl->ProtectRegion(page_table, GetInteger(vaddr), size, perms);
+}
+
 bool Memory::IsValidVirtualAddress(const Common::ProcessAddress vaddr) const {
     const Kernel::KProcess& process = *system.ApplicationProcess();
     const auto& page_table = process.GetPageTable().GetImpl();

src/core/memory.h

@@ -97,6 +97,17 @@ public:
      */
     void UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size);
 
+    /**
+     * Protects a region of the emulated process address space with the new permissions.
+     *
+     * @param page_table The page table of the emulated process.
+     * @param base       The start address to re-protect. Must be page-aligned.
+     * @param size       The amount of bytes to protect. Must be page-aligned.
+     * @param perms      The permissions the address range is mapped.
+     */
+    void ProtectRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size,
+                       Common::MemoryPermission perms);
+
     /**
      * Checks whether or not the supplied address is a valid virtual
      * address for the current process.

src/core/memory/cheat_engine.cpp

@@ -68,10 +68,7 @@ u64 StandardVmCallbacks::HidKeysDown() {
         return 0;
     }
 
-    const auto press_state =
-        applet_resource
-            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)
-            .GetAndResetPressState();
+    const auto press_state = applet_resource->GetNpad()->GetAndResetPressState();
     return static_cast<u64>(press_state & HID::NpadButton::All);
 }