Android 232

.ci/scripts/android/eabuild.sh

@@ -1,21 +0,0 @@
-#!/bin/bash -ex
-
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-export NDK_CCACHE="$(which ccache)"
-ccache -s
-
-export ANDROID_KEYSTORE_FILE="${GITHUB_WORKSPACE}/ks.jks"
-base64 --decode <<< "${EA_PLAY_ANDROID_KEYSTORE_B64}" > "${ANDROID_KEYSTORE_FILE}"
-export ANDROID_KEY_ALIAS="${PLAY_ANDROID_KEY_ALIAS}"
-export ANDROID_KEYSTORE_PASS="${PLAY_ANDROID_KEYSTORE_PASS}"
-export SERVICE_ACCOUNT_KEY_PATH="${GITHUB_WORKSPACE}/sa.json"
-base64 --decode <<< "${EA_SERVICE_ACCOUNT_KEY_B64}" > "${SERVICE_ACCOUNT_KEY_PATH}"
-./gradlew "publishEaReleaseBundle"
-
-ccache -s
-
-if [ ! -z "${ANDROID_KEYSTORE_B64}" ]; then
-    rm "${ANDROID_KEYSTORE_FILE}"
-fi

.ci/scripts/android/mainlinebuild.sh

@@ -1,21 +0,0 @@
-#!/bin/bash -ex
-
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-export NDK_CCACHE="$(which ccache)"
-ccache -s
-
-export ANDROID_KEYSTORE_FILE="${GITHUB_WORKSPACE}/ks.jks"
-base64 --decode <<< "${MAINLINE_PLAY_ANDROID_KEYSTORE_B64}" > "${ANDROID_KEYSTORE_FILE}"
-export ANDROID_KEY_ALIAS="${PLAY_ANDROID_KEY_ALIAS}"
-export ANDROID_KEYSTORE_PASS="${PLAY_ANDROID_KEYSTORE_PASS}"
-export SERVICE_ACCOUNT_KEY_PATH="${GITHUB_WORKSPACE}/sa.json"
-base64 --decode <<< "${MAINLINE_SERVICE_ACCOUNT_KEY_B64}" > "${SERVICE_ACCOUNT_KEY_PATH}"
-./gradlew "publishMainlineReleaseBundle"
-
-ccache -s
-
-if [ ! -z "${ANDROID_KEYSTORE_B64}" ]; then
-    rm "${ANDROID_KEYSTORE_FILE}"
-fi

.github/workflows/android-ea-play-release.yml

@@ -1,66 +0,0 @@
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: yuzu-android-ea-play-release
-
-on:
-  workflow_dispatch:
-    inputs:
-      release-track:
-        description: 'Play store release track (internal/alpha/beta/production)'
-        required: true
-        default: 'alpha'
-
-jobs:
-  android:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'yuzu-emu/yuzu' }}
-    steps:
-      - uses: actions/checkout@v3
-        name: Checkout
-        with:
-          fetch-depth: 0
-          submodules: true
-          token: ${{ secrets.ALT_GITHUB_TOKEN }}
-      - run: npm install execa@5
-      - uses: actions/github-script@v5
-        name: 'Merge and publish Android EA changes'
-        env:
-          ALT_GITHUB_TOKEN: ${{ secrets.ALT_GITHUB_TOKEN }}
-          BUILD_EA: true
-        with:
-          script: |
-            const execa = require("execa");
-            const mergebot = require('./.github/workflows/android-merge.js').mergebot;
-            process.chdir('${{ github.workspace }}');
-            mergebot(github, context, execa);
-      - name: Get tag name
-        run: echo "GIT_TAG_NAME=$(cat tag-name.txt)" >> $GITHUB_ENV
-      - name: Set up JDK 17
-        uses: actions/setup-java@v3
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache apksigner glslang-dev glslang-tools
-      - name: Build
-        run: ./.ci/scripts/android/eabuild.sh
-        env:
-          EA_PLAY_ANDROID_KEYSTORE_B64: ${{ secrets.PLAY_ANDROID_KEYSTORE_B64 }}
-          PLAY_ANDROID_KEY_ALIAS: ${{ secrets.PLAY_ANDROID_KEY_ALIAS }}
-          PLAY_ANDROID_KEYSTORE_PASS: ${{ secrets.PLAY_ANDROID_KEYSTORE_PASS }}
-          EA_SERVICE_ACCOUNT_KEY_B64: ${{ secrets.EA_SERVICE_ACCOUNT_KEY_B64 }}
-          STORE_TRACK: ${{ github.event.inputs.release-track }}
-          AUTO_VERSIONED: true
-          BUILD_EA: true
-      - name: Create release
-        uses: softprops/action-gh-release@v1
-        with:
-          tag_name: ${{ env.EA_TAG_NAME }}
-          name: ${{ env.EA_TAG_NAME }}
-          draft: false
-          prerelease: false
-          repository: yuzu/yuzu-android
-          token: ${{ secrets.ALT_GITHUB_TOKEN }}

.github/workflows/android-mainline-play-release.yml

@@ -1,59 +0,0 @@
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: yuzu-android-mainline-play-release
-
-on:
-  workflow_dispatch:
-    inputs:
-      release-tag:
-        description: 'Tag # from yuzu-android that you want to build and publish'
-        required: true
-        default: '200'
-      release-track:
-        description: 'Play store release track (internal/alpha/beta/production)'
-        required: true
-        default: 'alpha'
-
-jobs:
-  android:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'yuzu-emu/yuzu' }}
-    steps:
-      - uses: actions/checkout@v3
-        name: Checkout
-        with:
-          fetch-depth: 0
-          submodules: true
-          token: ${{ secrets.ALT_GITHUB_TOKEN }}
-      - run: npm install execa@5
-      - uses: actions/github-script@v5
-        name: 'Pull mainline tag'
-        env:
-          MAINLINE_TAG: ${{ github.event.inputs.release-tag }}
-        with:
-          script: |
-            const execa = require("execa");
-            const mergebot = require('./.github/workflows/android-merge.js').getMainlineTag;
-            process.chdir('${{ github.workspace }}');
-            mergebot(execa);
-      - name: Set up JDK 17
-        uses: actions/setup-java@v3
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache apksigner glslang-dev glslang-tools
-      - name: Build
-        run: |
-          echo "GIT_TAG_NAME=android-${{ github.event.inputs.releast-tag }}" >> $GITHUB_ENV
-          ./.ci/scripts/android/mainlinebuild.sh
-        env:
-          MAINLINE_PLAY_ANDROID_KEYSTORE_B64: ${{ secrets.PLAY_ANDROID_KEYSTORE_B64 }}
-          PLAY_ANDROID_KEY_ALIAS: ${{ secrets.PLAY_ANDROID_KEY_ALIAS }}
-          PLAY_ANDROID_KEYSTORE_PASS: ${{ secrets.PLAY_ANDROID_KEYSTORE_PASS }}
-          SERVICE_ACCOUNT_KEY_B64: ${{ secrets.MAINLINE_SERVICE_ACCOUNT_KEY_B64 }}
-          STORE_TRACK: ${{ github.event.inputs.release-track }}
-          AUTO_VERSIONED: true

.github/workflows/android-merge.js

@@ -6,12 +6,9 @@
 
 const fs = require("fs");
 // which label to check for changes
-const CHANGE_LABEL_MAINLINE = 'android-merge';
+const CHANGE_LABEL = 'android-merge';
-const CHANGE_LABEL_EA = 'android-ea-merge';
 // how far back in time should we consider the changes are "recent"? (default: 24 hours)
 const DETECTION_TIME_FRAME = (parseInt(process.env.DETECTION_TIME_FRAME)) || (24 * 3600 * 1000);
-const BUILD_EA = process.env.BUILD_EA == 'true';
-const MAINLINE_TAG = process.env.MAINLINE_TAG;
 
 async function checkBaseChanges(github) {
     // query the commit date of the latest commit on this branch
@@ -43,7 +40,20 @@ async function checkBaseChanges(github) {
 
 async function checkAndroidChanges(github) {
     if (checkBaseChanges(github)) return true;
-    const pulls = getPulls(github, false);
+    const query = `query($owner:String!, $name:String!, $label:String!) {
+        repository(name:$name, owner:$owner) {
+            pullRequests(labels: [$label], states: OPEN, first: 100) {
+                nodes { number headRepository { pushedAt } }
+            }
+        }
+    }`;
+    const variables = {
+        owner: 'yuzu-emu',
+        name: 'yuzu',
+        label: CHANGE_LABEL,
+    };
+    const result = await github.graphql(query, variables);
+    const pulls = result.repository.pullRequests.nodes;
     for (let i = 0; i < pulls.length; i++) {
         let pull = pulls[i];
         if (new Date() - new Date(pull.headRepository.pushedAt) <= DETECTION_TIME_FRAME) {
@@ -73,13 +83,7 @@ async function tagAndPush(github, owner, repo, execa, commit=false) {
     };
     const tags = await github.graphql(query, variables);
     const tagList = tags.repository.refs.nodes;
-    let lastTag = 'android-1';
+    const lastTag = tagList[0] ? tagList[0].name : 'dummy-0';
-    for (let i = 0; i < tagList.length; ++i) {
-        if (tagList[i].name.includes('android-')) {
-            lastTag = tagList[i].name;
-            break;
-        }
-    }
     const tagNumber = /\w+-(\d+)/.exec(lastTag)[1] | 0;
     const channel = repo.split('-')[1];
     const newTag = `${channel}-${tagNumber + 1}`;
@@ -97,48 +101,6 @@ async function tagAndPush(github, owner, repo, execa, commit=false) {
     console.info('Successfully pushed new changes.');
 }
 
-async function tagAndPushEA(github, owner, repo, execa) {
-    let altToken = process.env.ALT_GITHUB_TOKEN;
-    if (!altToken) {
-        throw `Please set ALT_GITHUB_TOKEN environment variable. This token should have write access to ${owner}/${repo}.`;
-    }
-    const query = `query ($owner:String!, $name:String!) {
-        repository(name:$name, owner:$owner) {
-            refs(refPrefix: "refs/tags/", orderBy: {field: TAG_COMMIT_DATE, direction: DESC}, first: 10) {
-                nodes { name }
-            }
-        }
-    }`;
-    const variables = {
-        owner: owner,
-        name: repo,
-    };
-    const tags = await github.graphql(query, variables);
-    const tagList = tags.repository.refs.nodes;
-    let lastTag = 'ea-1';
-    for (let i = 0; i < tagList.length; ++i) {
-        if (tagList[i].name.includes('ea-')) {
-            lastTag = tagList[i].name;
-            break;
-        }
-    }
-    const tagNumber = /\w+-(\d+)/.exec(lastTag)[1] | 0;
-    const newTag = `ea-${tagNumber + 1}`;
-    console.log(`New tag: ${newTag}`);
-    console.info('Pushing tags to GitHub ...');
-    await execa("git", ["remote", "add", "android", "https://github.com/yuzu-emu/yuzu-android.git"]);
-    await execa("git", ["fetch", "android"]);
-
-    await execa("git", ['tag', newTag]);
-    await execa("git", ['push', 'android', `${newTag}`]);
-
-    fs.writeFile('tag-name.txt', newTag, (err) => {
-        if (err) throw 'Could not write tag name to file!'
-    })
-
-    console.info('Successfully pushed new changes.');
-}
-
 async function generateReadme(pulls, context, mergeResults, execa) {
     let baseUrl = `https://github.com/${context.repo.owner}/${context.repo.repo}/`;
     let output =
@@ -240,7 +202,10 @@ async function resetBranch(execa) {
     }
 }
 
-async function getPulls(github) {
+async function mergebot(github, context, execa) {
+    // Reset our local copy of master to what appears on yuzu-emu/yuzu - master
+    await resetBranch(execa);
+
     const query = `query ($owner:String!, $name:String!, $label:String!) {
         repository(name:$name, owner:$owner) {
             pullRequests(labels: [$label], states: OPEN, first: 100) {
@@ -250,49 +215,13 @@ async function getPulls(github) {
             }
         }
     }`;
-    const mainlineVariables = {
+    const variables = {
         owner: 'yuzu-emu',
         name: 'yuzu',
-        label: CHANGE_LABEL_MAINLINE,
+        label: CHANGE_LABEL,
     };
-    const mainlineResult = await github.graphql(query, mainlineVariables);
+    const result = await github.graphql(query, variables);
-    const pulls = mainlineResult.repository.pullRequests.nodes;
+    const pulls = result.repository.pullRequests.nodes;
-    if (BUILD_EA) {
-        const eaVariables = {
-            owner: 'yuzu-emu',
-            name: 'yuzu',
-            label: CHANGE_LABEL_EA,
-        };
-        const eaResult = await github.graphql(query, eaVariables);
-        const eaPulls = eaResult.repository.pullRequests.nodes;
-        return pulls.concat(eaPulls);
-    }
-    return pulls;
-}
-
-async function getMainlineTag(execa) {
-    console.log(`::group::Getting mainline tag android-${MAINLINE_TAG}`);
-    let hasFailed = false;
-    try {
-        await execa("git", ["remote", "add", "mainline", "https://github.com/yuzu-emu/yuzu-android.git"]);
-        await execa("git", ["fetch", "mainline", "--tags"]);
-        await execa("git", ["checkout", `tags/android-${MAINLINE_TAG}`]);
-        await execa("git", ["submodule", "update", "--init", "--recursive"]);
-    } catch (err) {
-        console.log('::error title=Failed pull tag');
-        hasFailed = true;
-    }
-    console.log("::endgroup::");
-    if (hasFailed) {
-        throw 'Failed pull mainline tag. Aborting!';
-    }
-}
-
-async function mergebot(github, context, execa) {
-    // Reset our local copy of master to what appears on yuzu-emu/yuzu - master
-    await resetBranch(execa);
-
-    const pulls = await getPulls(github);
     let displayList = [];
     for (let i = 0; i < pulls.length; i++) {
         let pull = pulls[i];
@@ -302,17 +231,11 @@ async function mergebot(github, context, execa) {
     console.table(displayList);
     await fetchPullRequests(pulls, "https://github.com/yuzu-emu/yuzu", execa);
     const mergeResults = await mergePullRequests(pulls, execa);
-
+    await generateReadme(pulls, context, mergeResults, execa);
-    if (BUILD_EA) {
+    await tagAndPush(github, 'yuzu-emu', `yuzu-android`, execa, true);
-        await tagAndPushEA(github, 'yuzu-emu', `yuzu-android`, execa);
-    } else {
-        await generateReadme(pulls, context, mergeResults, execa);
-        await tagAndPush(github, 'yuzu-emu', `yuzu-android`, execa, true);
-    }
 }
 
 module.exports.mergebot = mergebot;
 module.exports.checkAndroidChanges = checkAndroidChanges;
 module.exports.tagAndPush = tagAndPush;
 module.exports.checkBaseChanges = checkBaseChanges;
-module.exports.getMainlineTag = getMainlineTag;

.github/workflows/android-publish.yml

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
 name: yuzu-android-publish
@@ -16,7 +16,7 @@ on:
 jobs:
   android:
     runs-on: ubuntu-latest
-    if: ${{ github.event.inputs.android != 'false' && github.repository == 'yuzu-emu/yuzu' }}
+    if: ${{ github.event.inputs.android != 'false' && github.repository == 'yuzu-emu/yuzu-android' }}
     steps:
       # this checkout is required to make sure the GitHub Actions scripts are available
       - uses: actions/checkout@v3

README.md

@@ -1,13 +1,14 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
-| [12461](https://github.com/yuzu-emu/yuzu//pull/12461) | [`4c08a0e6d`](https://github.com/yuzu-emu/yuzu//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12461](https://github.com/yuzu-emu/yuzu-android//pull/12461) | [`4c08a0e6d`](https://github.com/yuzu-emu/yuzu-android//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
-| [12749](https://github.com/yuzu-emu/yuzu//pull/12749) | [`aad4b0d6f`](https://github.com/yuzu-emu/yuzu//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12749](https://github.com/yuzu-emu/yuzu-android//pull/12749) | [`aad4b0d6f`](https://github.com/yuzu-emu/yuzu-android//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12756](https://github.com/yuzu-emu/yuzu//pull/12756) | [`cd3de0848`](https://github.com/yuzu-emu/yuzu//pull/12756/files) | general: applet multiprocess | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12756](https://github.com/yuzu-emu/yuzu-android//pull/12756) | [`cd3de0848`](https://github.com/yuzu-emu/yuzu-android//pull/12756/files) | general: applet multiprocess | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12903](https://github.com/yuzu-emu/yuzu//pull/12903) | [`f296a9ce9`](https://github.com/yuzu-emu/yuzu//pull/12903/files) | shader_recompiler: use only ConstOffset for OpImageFetch | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12873](https://github.com/yuzu-emu/yuzu-android//pull/12873) | [`023c3aa65`](https://github.com/yuzu-emu/yuzu-android//pull/12873/files) | GPU: Implement channel scheduling. | [FernandoS27](https://github.com/FernandoS27/) | Yes |
-| [12914](https://github.com/yuzu-emu/yuzu//pull/12914) | [`fa47ac1c9`](https://github.com/yuzu-emu/yuzu//pull/12914/files) | VideoCore Refactor Part 1. | [FernandoS27](https://github.com/FernandoS27/) | Yes |
+| [12903](https://github.com/yuzu-emu/yuzu-android//pull/12903) | [`f296a9ce9`](https://github.com/yuzu-emu/yuzu-android//pull/12903/files) | shader_recompiler: use only ConstOffset for OpImageFetch | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12920](https://github.com/yuzu-emu/yuzu//pull/12920) | [`62fc6d5c3`](https://github.com/yuzu-emu/yuzu//pull/12920/files) | android: Move JNI setup and helpers to common | [t895](https://github.com/t895/) | Yes |
+| [12905](https://github.com/yuzu-emu/yuzu-android//pull/12905) | [`5eb5c9675`](https://github.com/yuzu-emu/yuzu-android//pull/12905/files) | nvnflinger: release buffers before presentation sleep | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12951](https://github.com/yuzu-emu/yuzu//pull/12951) | [`fee263c59`](https://github.com/yuzu-emu/yuzu//pull/12951/files) | ipc: additional fixes | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12914](https://github.com/yuzu-emu/yuzu-android//pull/12914) | [`3a6d8ae2c`](https://github.com/yuzu-emu/yuzu-android//pull/12914/files) | VideoCore Refactor Part 1. | [FernandoS27](https://github.com/FernandoS27/) | Yes |
-| [12953](https://github.com/yuzu-emu/yuzu//pull/12953) | [`ae833aa9c`](https://github.com/yuzu-emu/yuzu//pull/12953/files) | SMMU: Ensure the backing address range matches the current | [FernandoS27](https://github.com/FernandoS27/) | Yes |
+| [12915](https://github.com/yuzu-emu/yuzu-android//pull/12915) | [`504abbd6e`](https://github.com/yuzu-emu/yuzu-android//pull/12915/files) | dmnt: cheats: Update cheat vm to latest version | [german77](https://github.com/german77/) | Yes |
+| [12920](https://github.com/yuzu-emu/yuzu-android//pull/12920) | [`62fc6d5c3`](https://github.com/yuzu-emu/yuzu-android//pull/12920/files) | android: Move JNI setup and helpers to common | [t895](https://github.com/t895/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

dist/languages/.tx/config

@@ -11,4 +11,3 @@ type = QT
 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
-lang_map = ja_JP:ja, ko_KR:ko, pt_BR:pt-rBR, pt_PT:pt-rPT, ru_RU:ru, vi_VN:vi, zh_CN:zh-rCN, zh_TW:zh-rTW

src/android/app/build.gradle.kts

@@ -3,8 +3,8 @@
 
 import android.annotation.SuppressLint
 import kotlin.collections.setOf
+import org.jetbrains.kotlin.konan.properties.Properties
 import org.jlleitschuh.gradle.ktlint.reporter.ReporterType
-import com.github.triplet.gradle.androidpublisher.ReleaseStatus
 
 plugins {
     id("com.android.application")
@@ -13,7 +13,6 @@ plugins {
     kotlin("plugin.serialization") version "1.9.20"
     id("androidx.navigation.safeargs.kotlin")
     id("org.jlleitschuh.gradle.ktlint") version "11.4.0"
-    id("com.github.triplet.play") version "3.8.6"
 }
 
 /**
@@ -59,7 +58,15 @@ android {
         targetSdk = 34
         versionName = getGitVersion()
 
-        versionCode = if (System.getenv("AUTO_VERSIONED") == "true") {
+        // If you want to use autoVersion for the versionCode, create a property in local.properties
+        // named "autoVersioned" and set it to "true"
+        val properties = Properties()
+        val versionProperty = try {
+            properties.load(project.rootProject.file("local.properties").inputStream())
+            properties.getProperty("autoVersioned") ?: ""
+        } catch (e: Exception) { "" }
+
+        versionCode = if (versionProperty == "true") {
             autoVersion
         } else {
             1
@@ -214,15 +221,6 @@ ktlint {
     }
 }
 
-play {
-    val keyPath = System.getenv("SERVICE_ACCOUNT_KEY_PATH")
-    if (keyPath != null) {
-        serviceAccountCredentials.set(File(keyPath))
-    }
-    track.set(System.getenv("STORE_TRACK") ?: "internal")
-    releaseStatus.set(ReleaseStatus.COMPLETED)
-}
-
 dependencies {
     implementation("androidx.core:core-ktx:1.12.0")
     implementation("androidx.appcompat:appcompat:1.6.1")
@@ -259,13 +257,14 @@ fun runGitCommand(command: List<String>): String {
 }
 
 fun getGitVersion(): String {
-    val gitVersion = runGitCommand(listOf("git", "describe", "--always", "--long"))
     val versionName = if (System.getenv("GITHUB_ACTIONS") != null) {
-        System.getenv("GIT_TAG_NAME") ?: gitVersion
+        val gitTag = System.getenv("GIT_TAG_NAME") ?: ""
+        gitTag
     } else {
-        gitVersion
+        runGitCommand(listOf("git", "describe", "--always", "--long"))
+            .replace(Regex("(-0)?-[^-]+$"), "")
     }
-    return versionName.replace(Regex("(-0)?-[^-]+$"), "").ifEmpty { "0.0" }
+    return versionName.ifEmpty { "0.0" }
 }
 
 fun getGitHash(): String =

src/common/typed_address.h

@@ -186,68 +186,68 @@ static_assert(std::is_trivially_destructible_v<PhysicalAddress>);
 static_assert(std::is_trivially_destructible_v<VirtualAddress>);
 static_assert(std::is_trivially_destructible_v<ProcessAddress>);
 
-static_assert(Null<uint64_t> == 0U);
+static_assert(Null<uint64_t> == 0);
 static_assert(Null<PhysicalAddress> == Null<uint64_t>);
 static_assert(Null<VirtualAddress> == Null<uint64_t>);
 static_assert(Null<ProcessAddress> == Null<uint64_t>);
 
 // Constructor/assignment validations.
 static_assert([] {
-    const PhysicalAddress a(5U);
+    const PhysicalAddress a(5);
     PhysicalAddress b(a);
     return b;
-}() == PhysicalAddress(5U));
+}() == PhysicalAddress(5));
 static_assert([] {
-    const PhysicalAddress a(5U);
+    const PhysicalAddress a(5);
-    PhysicalAddress b(10U);
+    PhysicalAddress b(10);
     b = a;
     return b;
-}() == PhysicalAddress(5U));
+}() == PhysicalAddress(5));
 
 // Arithmetic validations.
-static_assert(PhysicalAddress(10U) + 5U == PhysicalAddress(15U));
+static_assert(PhysicalAddress(10) + 5 == PhysicalAddress(15));
-static_assert(PhysicalAddress(10U) - 5U == PhysicalAddress(5U));
+static_assert(PhysicalAddress(10) - 5 == PhysicalAddress(5));
 static_assert([] {
-    PhysicalAddress v(10U);
+    PhysicalAddress v(10);
-    v += 5U;
+    v += 5;
     return v;
-}() == PhysicalAddress(15U));
+}() == PhysicalAddress(15));
 static_assert([] {
-    PhysicalAddress v(10U);
+    PhysicalAddress v(10);
-    v -= 5U;
+    v -= 5;
     return v;
-}() == PhysicalAddress(5U));
+}() == PhysicalAddress(5));
-static_assert(PhysicalAddress(10U)++ == PhysicalAddress(10U));
+static_assert(PhysicalAddress(10)++ == PhysicalAddress(10));
-static_assert(++PhysicalAddress(10U) == PhysicalAddress(11U));
+static_assert(++PhysicalAddress(10) == PhysicalAddress(11));
-static_assert(PhysicalAddress(10U)-- == PhysicalAddress(10U));
+static_assert(PhysicalAddress(10)-- == PhysicalAddress(10));
-static_assert(--PhysicalAddress(10U) == PhysicalAddress(9U));
+static_assert(--PhysicalAddress(10) == PhysicalAddress(9));
 
 // Logical validations.
-static_assert((PhysicalAddress(0b11111111U) >> 1) == 0b01111111U);
+static_assert((PhysicalAddress(0b11111111) >> 1) == 0b01111111);
-static_assert((PhysicalAddress(0b10101010U) >> 1) == 0b01010101U);
+static_assert((PhysicalAddress(0b10101010) >> 1) == 0b01010101);
-static_assert((PhysicalAddress(0b11111111U) << 1) == 0b111111110U);
+static_assert((PhysicalAddress(0b11111111) << 1) == 0b111111110);
-static_assert((PhysicalAddress(0b01010101U) << 1) == 0b10101010U);
+static_assert((PhysicalAddress(0b01010101) << 1) == 0b10101010);
-static_assert((PhysicalAddress(0b11111111U) & 0b01010101U) == 0b01010101U);
+static_assert((PhysicalAddress(0b11111111) & 0b01010101) == 0b01010101);
-static_assert((PhysicalAddress(0b11111111U) & 0b10101010U) == 0b10101010U);
+static_assert((PhysicalAddress(0b11111111) & 0b10101010) == 0b10101010);
-static_assert((PhysicalAddress(0b01010101U) & 0b10101010U) == 0b00000000U);
+static_assert((PhysicalAddress(0b01010101) & 0b10101010) == 0b00000000);
-static_assert((PhysicalAddress(0b00000000U) | 0b01010101U) == 0b01010101U);
+static_assert((PhysicalAddress(0b00000000) | 0b01010101) == 0b01010101);
-static_assert((PhysicalAddress(0b11111111U) | 0b01010101U) == 0b11111111U);
+static_assert((PhysicalAddress(0b11111111) | 0b01010101) == 0b11111111);
-static_assert((PhysicalAddress(0b10101010U) | 0b01010101U) == 0b11111111U);
+static_assert((PhysicalAddress(0b10101010) | 0b01010101) == 0b11111111);
 
 // Comparisons.
-static_assert(PhysicalAddress(0U) == PhysicalAddress(0U));
+static_assert(PhysicalAddress(0) == PhysicalAddress(0));
-static_assert(PhysicalAddress(0U) != PhysicalAddress(1U));
+static_assert(PhysicalAddress(0) != PhysicalAddress(1));
-static_assert(PhysicalAddress(0U) < PhysicalAddress(1U));
+static_assert(PhysicalAddress(0) < PhysicalAddress(1));
-static_assert(PhysicalAddress(0U) <= PhysicalAddress(1U));
+static_assert(PhysicalAddress(0) <= PhysicalAddress(1));
-static_assert(PhysicalAddress(1U) > PhysicalAddress(0U));
+static_assert(PhysicalAddress(1) > PhysicalAddress(0));
-static_assert(PhysicalAddress(1U) >= PhysicalAddress(0U));
+static_assert(PhysicalAddress(1) >= PhysicalAddress(0));
 
-static_assert(!(PhysicalAddress(0U) == PhysicalAddress(1U)));
+static_assert(!(PhysicalAddress(0) == PhysicalAddress(1)));
-static_assert(!(PhysicalAddress(0U) != PhysicalAddress(0U)));
+static_assert(!(PhysicalAddress(0) != PhysicalAddress(0)));
-static_assert(!(PhysicalAddress(1U) < PhysicalAddress(0U)));
+static_assert(!(PhysicalAddress(1) < PhysicalAddress(0)));
-static_assert(!(PhysicalAddress(1U) <= PhysicalAddress(0U)));
+static_assert(!(PhysicalAddress(1) <= PhysicalAddress(0)));
-static_assert(!(PhysicalAddress(0U) > PhysicalAddress(1U)));
+static_assert(!(PhysicalAddress(0) > PhysicalAddress(1)));
-static_assert(!(PhysicalAddress(0U) >= PhysicalAddress(1U)));
+static_assert(!(PhysicalAddress(0) >= PhysicalAddress(1)));
 
 } // namespace Common
 

src/core/debugger/gdbstub_arch.cpp

@@ -383,7 +383,7 @@ std::string GDBStubA32::RegRead(const Kernel::KThread* thread, size_t id) const
     } else if (id == CPSR_REGISTER) {
         return ValueToHex(context.pstate);
     } else if (id >= D0_REGISTER && id < Q0_REGISTER) {
-        return ValueToHex(fprs[(id - D0_REGISTER) / 2][(id - D0_REGISTER) % 2]);
+        return ValueToHex(fprs[id - D0_REGISTER][0]);
     } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) {
         return ValueToHex(fprs[id - Q0_REGISTER]);
     } else if (id == FPSCR_REGISTER) {
@@ -406,7 +406,7 @@ void GDBStubA32::RegWrite(Kernel::KThread* thread, size_t id, std::string_view v
     } else if (id == CPSR_REGISTER) {
         context.pstate = HexToValue<u32>(value);
     } else if (id >= D0_REGISTER && id < Q0_REGISTER) {
-        fprs[(id - D0_REGISTER) / 2][(id - D0_REGISTER) % 2] = HexToValue<u64>(value);
+        fprs[id - D0_REGISTER] = {HexToValue<u64>(value), 0};
     } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) {
         fprs[id - Q0_REGISTER] = HexToValue<u128>(value);
     } else if (id == FPSCR_REGISTER) {

src/core/device_memory_manager.inc

@@ -532,7 +532,6 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
             cache_bytes = 0;
         }
     };
-    size_t old_vpage = (base_vaddress >> Memory::YUZU_PAGEBITS) - 1;
     for (; page != page_end; ++page) {
         CounterAtomicType& count = cached_pages->at(page >> subentries_shift).Count(page);
         auto [asid_2, vpage] = ExtractCPUBacking(page);
@@ -548,12 +547,6 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
             memory_device_inter = registered_processes[asid_2.id];
         }
 
-        if (vpage != old_vpage + 1) [[unlikely]] {
-            release_pending();
-        }
-
-        old_vpage = vpage;
-
         // Adds or subtracts 1, as count is a unsigned 8-bit value
         count.fetch_add(static_cast<CounterType>(delta), std::memory_order_release);
 

src/core/hle/service/cmif_serialization.h

@@ -280,7 +280,7 @@ void ReadInArgument(bool is_domain, CallArguments& args, const u8* raw_data, HLE
 
             u32 value{};
             std::memcpy(&value, raw_data + ArgOffset, ArgSize);
-            std::get<ArgIndex>(args) = ctx.GetDomainHandler<typename ArgType::element_type>(value - 1);
+            std::get<ArgIndex>(args) = ctx.GetDomainHandler<ArgType::Type>(value - 1);
 
             return ReadInArgument<MethodArguments, CallArguments, ArgAlign, ArgEnd, HandleIndex, InBufferIndex, OutBufferIndex, true, ArgIndex + 1>(is_domain, args, raw_data, ctx, temp);
         } else if constexpr (ArgumentTraits<ArgType>::Type == ArgumentType::InCopyHandle) {

src/core/hle/service/cmif_types.h

@@ -65,14 +65,6 @@ struct ClientProcessId {
 };
 
 struct ProcessId {
-    explicit ProcessId() : pid() {}
-    explicit ProcessId(u64 p) : pid(p) {}
-    /* implicit */ ProcessId(const ClientProcessId& c) : pid(c.pid) {}
-
-    bool operator==(const ProcessId& rhs) const {
-        return pid == rhs.pid;
-    }
-
     explicit operator bool() const {
         return pid != 0;
     }

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

@@ -3,7 +3,6 @@
 
 #include <algorithm>
 
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/hid/hid_debug_server.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "hid_core/hid_types.h"
@@ -12,6 +11,7 @@
 
 #include "hid_core/resources/touch_screen/gesture.h"
 #include "hid_core/resources/touch_screen/touch_screen.h"
+#include "hid_core/resources/touch_screen/touch_types.h"
 
 namespace Service::HID {
 
@@ -24,14 +24,14 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
         {0, nullptr, "DeactivateDebugPad"},
         {1, nullptr, "SetDebugPadAutoPilotState"},
         {2, nullptr, "UnsetDebugPadAutoPilotState"},
-        {10, C<&IHidDebugServer::DeactivateTouchScreen>, "DeactivateTouchScreen"},
+        {10, &IHidDebugServer::DeactivateTouchScreen, "DeactivateTouchScreen"},
-        {11, C<&IHidDebugServer::SetTouchScreenAutoPilotState>, "SetTouchScreenAutoPilotState"},
+        {11, &IHidDebugServer::SetTouchScreenAutoPilotState, "SetTouchScreenAutoPilotState"},
-        {12, C<&IHidDebugServer::UnsetTouchScreenAutoPilotState>, "UnsetTouchScreenAutoPilotState"},
+        {12, &IHidDebugServer::UnsetTouchScreenAutoPilotState, "UnsetTouchScreenAutoPilotState"},
-        {13, C<&IHidDebugServer::GetTouchScreenConfiguration>, "GetTouchScreenConfiguration"},
+        {13, &IHidDebugServer::GetTouchScreenConfiguration, "GetTouchScreenConfiguration"},
-        {14, C<&IHidDebugServer::ProcessTouchScreenAutoTune>, "ProcessTouchScreenAutoTune"},
+        {14, &IHidDebugServer::ProcessTouchScreenAutoTune, "ProcessTouchScreenAutoTune"},
-        {15, C<&IHidDebugServer::ForceStopTouchScreenManagement>, "ForceStopTouchScreenManagement"},
+        {15, &IHidDebugServer::ForceStopTouchScreenManagement, "ForceStopTouchScreenManagement"},
-        {16, C<&IHidDebugServer::ForceRestartTouchScreenManagement>, "ForceRestartTouchScreenManagement"},
+        {16, &IHidDebugServer::ForceRestartTouchScreenManagement, "ForceRestartTouchScreenManagement"},
-        {17, C<&IHidDebugServer::IsTouchScreenManaged>, "IsTouchScreenManaged"},
+        {17, &IHidDebugServer::IsTouchScreenManaged, "IsTouchScreenManaged"},
         {20, nullptr, "DeactivateMouse"},
         {21, nullptr, "SetMouseAutoPilotState"},
         {22, nullptr, "UnsetMouseAutoPilotState"},
@@ -47,7 +47,7 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
         {60, nullptr, "ClearNpadSystemCommonPolicy"},
         {61, nullptr, "DeactivateNpad"},
         {62, nullptr, "ForceDisconnectNpad"},
-        {91, C<&IHidDebugServer::DeactivateGesture>, "DeactivateGesture"},
+        {91, &IHidDebugServer::DeactivateGesture, "DeactivateGesture"},
         {110, nullptr, "DeactivateHomeButton"},
         {111, nullptr, "SetHomeButtonAutoPilotState"},
         {112, nullptr, "UnsetHomeButtonAutoPilotState"},
@@ -160,122 +160,169 @@ IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<Resource
 }
 
 IHidDebugServer::~IHidDebugServer() = default;
-
+void IHidDebugServer::DeactivateTouchScreen(HLERequestContext& ctx) {
-Result IHidDebugServer::DeactivateTouchScreen() {
     LOG_INFO(Service_HID, "called");
 
+    Result result = ResultSuccess;
+
     if (!firmware_settings->IsDeviceManaged()) {
-        R_RETURN(GetResourceManager()->GetTouchScreen()->Deactivate());
+        result = GetResourceManager()->GetTouchScreen()->Deactivate();
     }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::SetTouchScreenAutoPilotState(
+void IHidDebugServer::SetTouchScreenAutoPilotState(HLERequestContext& ctx) {
-    InArray<TouchState, BufferAttr_HipcMapAlias> auto_pilot_buffer) {
     AutoPilotState auto_pilot{};
+    auto_pilot.count = ctx.GetReadBufferNumElements<TouchState>();
+    const auto buffer = ctx.ReadBuffer();
 
-    auto_pilot.count =
+    auto_pilot.count = std::min(auto_pilot.count, static_cast<u64>(auto_pilot.state.size()));
-        static_cast<u64>(std::min(auto_pilot_buffer.size(), auto_pilot.state.size()));
+    memcpy(auto_pilot.state.data(), buffer.data(), auto_pilot.count * sizeof(TouchState));
-    memcpy(auto_pilot.state.data(), auto_pilot_buffer.data(),
-           auto_pilot.count * sizeof(TouchState));
 
     LOG_INFO(Service_HID, "called, auto_pilot_count={}", auto_pilot.count);
 
-    R_RETURN(GetResourceManager()->GetTouchScreen()->SetTouchScreenAutoPilotState(auto_pilot));
+    const Result result =
+        GetResourceManager()->GetTouchScreen()->SetTouchScreenAutoPilotState(auto_pilot);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::UnsetTouchScreenAutoPilotState() {
+void IHidDebugServer::UnsetTouchScreenAutoPilotState(HLERequestContext& ctx) {
     LOG_INFO(Service_HID, "called");
-    R_RETURN(GetResourceManager()->GetTouchScreen()->UnsetTouchScreenAutoPilotState());
+
+    const Result result = GetResourceManager()->GetTouchScreen()->UnsetTouchScreenAutoPilotState();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::GetTouchScreenConfiguration(
+void IHidDebugServer::GetTouchScreenConfiguration(HLERequestContext& ctx) {
-    Out<Core::HID::TouchScreenConfigurationForNx> out_touchscreen_config,
+    IPC::RequestParser rp{ctx};
-    ClientAppletResourceUserId aruid) {
+    const auto applet_resource_user_id{rp.Pop<u64>()};
-    LOG_INFO(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
 
-    R_TRY(GetResourceManager()->GetTouchScreen()->GetTouchScreenConfiguration(
+    LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-        *out_touchscreen_config, aruid.pid));
 
-    if (out_touchscreen_config->mode != Core::HID::TouchScreenModeForNx::Heat2 &&
+    Core::HID::TouchScreenConfigurationForNx touchscreen_config{};
-        out_touchscreen_config->mode != Core::HID::TouchScreenModeForNx::Finger) {
+    const Result result = GetResourceManager()->GetTouchScreen()->GetTouchScreenConfiguration(
-        out_touchscreen_config->mode = Core::HID::TouchScreenModeForNx::UseSystemSetting;
+        touchscreen_config, applet_resource_user_id);
+
+    if (touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Heat2 &&
+        touchscreen_config.mode != Core::HID::TouchScreenModeForNx::Finger) {
+        touchscreen_config.mode = Core::HID::TouchScreenModeForNx::UseSystemSetting;
     }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(result);
+    rb.PushRaw(touchscreen_config);
 }
 
-Result IHidDebugServer::ProcessTouchScreenAutoTune() {
+void IHidDebugServer::ProcessTouchScreenAutoTune(HLERequestContext& ctx) {
     LOG_INFO(Service_HID, "called");
-    R_RETURN(GetResourceManager()->GetTouchScreen()->ProcessTouchScreenAutoTune());
+
+    Result result = GetResourceManager()->GetTouchScreen()->ProcessTouchScreenAutoTune();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::ForceStopTouchScreenManagement() {
+void IHidDebugServer::ForceStopTouchScreenManagement(HLERequestContext& ctx) {
     LOG_INFO(Service_HID, "called");
 
     if (!firmware_settings->IsDeviceManaged()) {
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+        return;
     }
 
+    Result result = ResultSuccess;
+    bool is_touch_active{};
+    bool is_gesture_active{};
     auto touch_screen = GetResourceManager()->GetTouchScreen();
     auto gesture = GetResourceManager()->GetGesture();
 
     if (firmware_settings->IsTouchI2cManaged()) {
-        bool is_touch_active{};
+        result = touch_screen->IsActive(is_touch_active);
-        bool is_gesture_active{};
+        if (result.IsSuccess()) {
-        R_TRY(touch_screen->IsActive(is_touch_active));
+            result = gesture->IsActive(is_gesture_active);
-        R_TRY(gesture->IsActive(is_gesture_active));
-
-        if (is_touch_active) {
-            R_TRY(touch_screen->Deactivate());
         }
-        if (is_gesture_active) {
+        if (result.IsSuccess() && is_touch_active) {
-            R_TRY(gesture->Deactivate());
+            result = touch_screen->Deactivate();
+        }
+        if (result.IsSuccess() && is_gesture_active) {
+            result = gesture->Deactivate();
         }
     }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::ForceRestartTouchScreenManagement(u32 basic_gesture_id,
+void IHidDebugServer::ForceRestartTouchScreenManagement(HLERequestContext& ctx) {
-                                                          ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
-    LOG_INFO(Service_HID, "called, basic_gesture_id={}, applet_resource_user_id={}",
+    struct Parameters {
-             basic_gesture_id, aruid.pid);
+        u32 basic_gesture_id;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
 
+    const auto parameters{rp.PopRaw<Parameters>()};
+
+    LOG_INFO(Service_HID, "called, basic_gesture_id={}, applet_resource_user_id={}",
+             parameters.basic_gesture_id, parameters.applet_resource_user_id);
+
+    Result result = ResultSuccess;
     auto touch_screen = GetResourceManager()->GetTouchScreen();
     auto gesture = GetResourceManager()->GetGesture();
 
     if (firmware_settings->IsDeviceManaged() && firmware_settings->IsTouchI2cManaged()) {
-        R_TRY(gesture->Activate());
+        result = gesture->Activate();
-        R_TRY(gesture->Activate(aruid.pid, basic_gesture_id));
+        if (result.IsSuccess()) {
-        R_TRY(touch_screen->Activate());
+            result =
-        R_TRY(touch_screen->Activate(aruid.pid));
+                gesture->Activate(parameters.applet_resource_user_id, parameters.basic_gesture_id);
+        }
+        if (result.IsSuccess()) {
+            result = touch_screen->Activate();
+        }
+        if (result.IsSuccess()) {
+            result = touch_screen->Activate(parameters.applet_resource_user_id);
+        }
     }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IHidDebugServer::IsTouchScreenManaged(Out<bool> out_is_managed) {
+void IHidDebugServer::IsTouchScreenManaged(HLERequestContext& ctx) {
     LOG_INFO(Service_HID, "called");
 
     bool is_touch_active{};
     bool is_gesture_active{};
-    R_TRY(GetResourceManager()->GetTouchScreen()->IsActive(is_touch_active));
-    R_TRY(GetResourceManager()->GetGesture()->IsActive(is_gesture_active));
 
-    *out_is_managed = is_touch_active || is_gesture_active;
+    Result result = GetResourceManager()->GetTouchScreen()->IsActive(is_touch_active);
-    R_SUCCEED();
+    if (result.IsSuccess()) {
-}
+        result = GetResourceManager()->GetGesture()->IsActive(is_gesture_active);
-
-Result IHidDebugServer::DeactivateGesture() {
-    LOG_INFO(Service_HID, "called");
-
-    if (!firmware_settings->IsDeviceManaged()) {
-        R_RETURN(GetResourceManager()->GetGesture()->Deactivate());
     }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(result);
+    rb.Push(is_touch_active | is_gesture_active);
+}
+
+void IHidDebugServer::DeactivateGesture(HLERequestContext& ctx) {
+    LOG_INFO(Service_HID, "called");
+
+    Result result = ResultSuccess;
+
+    if (!firmware_settings->IsDeviceManaged()) {
+        result = GetResourceManager()->GetGesture()->Deactivate();
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
 std::shared_ptr<ResourceManager> IHidDebugServer::GetResourceManager() {

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

@@ -3,9 +3,7 @@
 
 #pragma once
 
-#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
-#include "hid_core/resources/touch_screen/touch_types.h"
 
 namespace Core {
 class System;
@@ -22,19 +20,15 @@ public:
     ~IHidDebugServer() override;
 
 private:
-    Result DeactivateTouchScreen();
+    void DeactivateTouchScreen(HLERequestContext& ctx);
-    Result SetTouchScreenAutoPilotState(
+    void SetTouchScreenAutoPilotState(HLERequestContext& ctx);
-        InArray<TouchState, BufferAttr_HipcMapAlias> auto_pilot_buffer);
+    void UnsetTouchScreenAutoPilotState(HLERequestContext& ctx);
-    Result UnsetTouchScreenAutoPilotState();
+    void GetTouchScreenConfiguration(HLERequestContext& ctx);
-    Result GetTouchScreenConfiguration(
+    void ProcessTouchScreenAutoTune(HLERequestContext& ctx);
-        Out<Core::HID::TouchScreenConfigurationForNx> out_touchscreen_config,
+    void ForceStopTouchScreenManagement(HLERequestContext& ctx);
-        ClientAppletResourceUserId aruid);
+    void ForceRestartTouchScreenManagement(HLERequestContext& ctx);
-    Result ProcessTouchScreenAutoTune();
+    void IsTouchScreenManaged(HLERequestContext& ctx);
-    Result ForceStopTouchScreenManagement();
+    void DeactivateGesture(HLERequestContext& ctx);
-    Result ForceRestartTouchScreenManagement(u32 basic_gesture_id,
-                                             ClientAppletResourceUserId aruid);
-    Result IsTouchScreenManaged(Out<bool> out_is_managed);
-    Result DeactivateGesture();
 
     std::shared_ptr<ResourceManager> GetResourceManager();
 

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

@@ -9,7 +9,6 @@
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/hid/irs.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"
@@ -29,24 +28,24 @@ namespace Service::IRS {
 IRS::IRS(Core::System& system_) : ServiceFramework{system_, "irs"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {302, C<&IRS::ActivateIrsensor>, "ActivateIrsensor"},
+        {302, &IRS::ActivateIrsensor, "ActivateIrsensor"},
-        {303, C<&IRS::DeactivateIrsensor>, "DeactivateIrsensor"},
+        {303, &IRS::DeactivateIrsensor, "DeactivateIrsensor"},
-        {304, C<&IRS::GetIrsensorSharedMemoryHandle>, "GetIrsensorSharedMemoryHandle"},
+        {304, &IRS::GetIrsensorSharedMemoryHandle, "GetIrsensorSharedMemoryHandle"},
-        {305, C<&IRS::StopImageProcessor>, "StopImageProcessor"},
+        {305, &IRS::StopImageProcessor, "StopImageProcessor"},
-        {306, C<&IRS::RunMomentProcessor>, "RunMomentProcessor"},
+        {306, &IRS::RunMomentProcessor, "RunMomentProcessor"},
-        {307, C<&IRS::RunClusteringProcessor>, "RunClusteringProcessor"},
+        {307, &IRS::RunClusteringProcessor, "RunClusteringProcessor"},
-        {308, C<&IRS::RunImageTransferProcessor>, "RunImageTransferProcessor"},
+        {308, &IRS::RunImageTransferProcessor, "RunImageTransferProcessor"},
-        {309, C<&IRS::GetImageTransferProcessorState>, "GetImageTransferProcessorState"},
+        {309, &IRS::GetImageTransferProcessorState, "GetImageTransferProcessorState"},
-        {310, C<&IRS::RunTeraPluginProcessor>, "RunTeraPluginProcessor"},
+        {310, &IRS::RunTeraPluginProcessor, "RunTeraPluginProcessor"},
-        {311, C<&IRS::GetNpadIrCameraHandle>, "GetNpadIrCameraHandle"},
+        {311, &IRS::GetNpadIrCameraHandle, "GetNpadIrCameraHandle"},
-        {312, C<&IRS::RunPointingProcessor>, "RunPointingProcessor"},
+        {312, &IRS::RunPointingProcessor, "RunPointingProcessor"},
-        {313, C<&IRS::SuspendImageProcessor>, "SuspendImageProcessor"},
+        {313, &IRS::SuspendImageProcessor, "SuspendImageProcessor"},
-        {314, C<&IRS::CheckFirmwareVersion>, "CheckFirmwareVersion"},
+        {314, &IRS::CheckFirmwareVersion, "CheckFirmwareVersion"},
-        {315, C<&IRS::SetFunctionLevel>, "SetFunctionLevel"},
+        {315, &IRS::SetFunctionLevel, "SetFunctionLevel"},
-        {316, C<&IRS::RunImageTransferExProcessor>, "RunImageTransferExProcessor"},
+        {316, &IRS::RunImageTransferExProcessor, "RunImageTransferExProcessor"},
-        {317, C<&IRS::RunIrLedProcessor>, "RunIrLedProcessor"},
+        {317, &IRS::RunIrLedProcessor, "RunIrLedProcessor"},
-        {318, C<&IRS::StopImageProcessorAsync>, "StopImageProcessorAsync"},
+        {318, &IRS::StopImageProcessorAsync, "StopImageProcessorAsync"},
-        {319, C<&IRS::ActivateIrsensorWithFunctionLevel>, "ActivateIrsensorWithFunctionLevel"},
+        {319, &IRS::ActivateIrsensorWithFunctionLevel, "ActivateIrsensorWithFunctionLevel"},
     };
     // clang-format on
 
@@ -58,292 +57,489 @@ IRS::IRS(Core::System& system_) : ServiceFramework{system_, "irs"} {
 }
 IRS::~IRS() = default;
 
-Result IRS::ActivateIrsensor(ClientAppletResourceUserId aruid) {
+void IRS::ActivateIrsensor(HLERequestContext& ctx) {
-    LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
+    IPC::RequestParser rp{ctx};
-    R_SUCCEED();
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}",
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
 }
 
-Result IRS::DeactivateIrsensor(ClientAppletResourceUserId aruid) {
+void IRS::DeactivateIrsensor(HLERequestContext& ctx) {
-    LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
+    IPC::RequestParser rp{ctx};
-    R_SUCCEED();
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
+    LOG_WARNING(Service_IRS, "(STUBBED) called, applet_resource_user_id={}",
+                applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
 }
 
-Result IRS::GetIrsensorSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory,
+void IRS::GetIrsensorSharedMemoryHandle(HLERequestContext& ctx) {
-                                          ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
-    LOG_DEBUG(Service_IRS, "called, applet_resource_user_id={}", aruid.pid);
+    const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    *out_shared_memory = &system.Kernel().GetIrsSharedMem();
+    LOG_DEBUG(Service_IRS, "called, applet_resource_user_id={}", applet_resource_user_id);
-    R_SUCCEED();
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(&system.Kernel().GetIrsSharedMem());
 }
 
-Result IRS::StopImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::StopImageProcessor(HLERequestContext& ctx) {
-                               ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-                camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+                parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+                parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(parameters.camera_handle);
+    if (result.IsSuccess()) {
+        // TODO: Stop Image processor
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::Active);
+        result = ResultSuccess;
+    }
 
-    // TODO: Stop Image processor
+    IPC::ResponseBuilder rb{ctx, 2};
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+    rb.Push(result);
-                                Common::Input::PollingMode::Active);
-    R_SUCCEED();
 }
 
-Result IRS::RunMomentProcessor(
+void IRS::RunMomentProcessor(HLERequestContext& ctx) {
-    Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    IPC::RequestParser rp{ctx};
-    const Core::IrSensor::PackedMomentProcessorConfig& processor_config) {
+    struct Parameters {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+        Core::IrSensor::PackedMomentProcessorConfig processor_config;
+    };
+    static_assert(sizeof(Parameters) == 0x30, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-                camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+                parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+                parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    const auto result = IsIrCameraHandleValid(parameters.camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessorWithCoreContext<MomentProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
-    auto& image_transfer_processor = GetProcessor<MomentProcessor>(camera_handle);
+        MakeProcessorWithCoreContext<MomentProcessor>(parameters.camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor = GetProcessor<MomentProcessor>(parameters.camera_handle);
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        image_transfer_processor.SetConfig(parameters.processor_config);
-                                Common::Input::PollingMode::IR);
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::RunClusteringProcessor(
+void IRS::RunClusteringProcessor(HLERequestContext& ctx) {
-    Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    IPC::RequestParser rp{ctx};
-    const Core::IrSensor::PackedClusteringProcessorConfig& processor_config) {
+    struct Parameters {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+        Core::IrSensor::PackedClusteringProcessorConfig processor_config;
+    };
+    static_assert(sizeof(Parameters) == 0x38, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-                camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+                parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+                parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(parameters.camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessorWithCoreContext<ClusteringProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
-    auto& image_transfer_processor = GetProcessor<ClusteringProcessor>(camera_handle);
+        MakeProcessorWithCoreContext<ClusteringProcessor>(parameters.camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor =
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+            GetProcessor<ClusteringProcessor>(parameters.camera_handle);
-                                Common::Input::PollingMode::IR);
+        image_transfer_processor.SetConfig(parameters.processor_config);
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::RunImageTransferProcessor(
+void IRS::RunImageTransferProcessor(HLERequestContext& ctx) {
-    Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    IPC::RequestParser rp{ctx};
-    const Core::IrSensor::PackedImageTransferProcessorConfig& processor_config,
+    struct Parameters {
-    u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem) {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+        Core::IrSensor::PackedImageTransferProcessorConfig processor_config;
+        u32 transfer_memory_size;
+    };
+    static_assert(sizeof(Parameters) == 0x30, "Parameters has incorrect size.");
 
-    ASSERT_MSG(t_mem->GetSize() == transfer_memory_size, "t_mem has incorrect size");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto t_mem_handle{ctx.GetCopyHandle(0)};
+
+    auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle);
+
+    if (t_mem.IsNull()) {
+        LOG_ERROR(Service_IRS, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultUnknown);
+        return;
+    }
+
+    ASSERT_MSG(t_mem->GetSize() == parameters.transfer_memory_size, "t_mem has incorrect size");
 
     LOG_INFO(Service_IRS,
              "called, npad_type={}, npad_id={}, transfer_memory_size={}, transfer_memory_size={}, "
              "applet_resource_user_id={}",
-             camera_handle.npad_type, camera_handle.npad_id, transfer_memory_size, t_mem->GetSize(),
+             parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
-             aruid.pid);
+             parameters.transfer_memory_size, t_mem->GetSize(), parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    const auto result = IsIrCameraHandleValid(parameters.camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
-    auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
+        MakeProcessorWithCoreContext<ImageTransferProcessor>(parameters.camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor =
-    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+            GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        image_transfer_processor.SetConfig(parameters.processor_config);
-                                Common::Input::PollingMode::IR);
+        image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::GetImageTransferProcessorState(
+void IRS::GetImageTransferProcessorState(HLERequestContext& ctx) {
-    Out<Core::IrSensor::ImageTransferProcessorState> out_state,
+    IPC::RequestParser rp{ctx};
-    Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    struct Parameters {
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data) {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_DEBUG(Service_IRS, "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-              camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+              parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+              parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    const auto result = IsIrCameraHandleValid(parameters.camera_handle);
+    if (result.IsError()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
 
-    const auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    const auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    if (device.mode != Core::IrSensor::IrSensorMode::ImageTransferProcessor) {
-    R_UNLESS(device.mode == Core::IrSensor::IrSensorMode::ImageTransferProcessor,
+        IPC::ResponseBuilder rb{ctx, 2};
-             InvalidProcessorState);
+        rb.Push(InvalidProcessorState);
+        return;
+    }
 
-    *out_state = GetProcessor<ImageTransferProcessor>(camera_handle).GetState(out_buffer_data);
+    std::vector<u8> data{};
+    const auto& image_transfer_processor =
+        GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
+    const auto& state = image_transfer_processor.GetState(data);
 
-    R_SUCCEED();
+    ctx.WriteBuffer(data);
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(state);
 }
 
-Result IRS::RunTeraPluginProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::RunTeraPluginProcessor(HLERequestContext& ctx) {
-                                   Core::IrSensor::PackedTeraPluginProcessorConfig processor_config,
+    IPC::RequestParser rp{ctx};
-                                   ClientAppletResourceUserId aruid) {
+    struct Parameters {
-    LOG_WARNING(Service_IRS,
+        Core::IrSensor::IrCameraHandle camera_handle;
-                "(STUBBED) called, npad_type={}, npad_id={}, mode={}, mcu_version={}.{}, "
+        Core::IrSensor::PackedTeraPluginProcessorConfig processor_config;
-                "applet_resource_user_id={}",
+        INSERT_PADDING_WORDS_NOINIT(1);
-                camera_handle.npad_type, camera_handle.npad_id, processor_config.mode,
+        u64 applet_resource_user_id;
-                processor_config.required_mcu_version.major,
+    };
-                processor_config.required_mcu_version.minor, aruid.pid);
+    static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size.");
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    const auto parameters{rp.PopRaw<Parameters>()};
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    LOG_WARNING(
-    MakeProcessor<TeraPluginProcessor>(camera_handle, device);
+        Service_IRS,
-    auto& image_transfer_processor = GetProcessor<TeraPluginProcessor>(camera_handle);
+        "(STUBBED) called, npad_type={}, npad_id={}, mode={}, mcu_version={}.{}, "
-    image_transfer_processor.SetConfig(processor_config);
+        "applet_resource_user_id={}",
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
-                                Common::Input::PollingMode::IR);
+        parameters.processor_config.mode, parameters.processor_config.required_mcu_version.major,
+        parameters.processor_config.required_mcu_version.minor, parameters.applet_resource_user_id);
 
-    R_SUCCEED();
+    const auto result = IsIrCameraHandleValid(parameters.camera_handle);
+
+    if (result.IsSuccess()) {
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
+        MakeProcessor<TeraPluginProcessor>(parameters.camera_handle, device);
+        auto& image_transfer_processor =
+            GetProcessor<TeraPluginProcessor>(parameters.camera_handle);
+        image_transfer_processor.SetConfig(parameters.processor_config);
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::GetNpadIrCameraHandle(Out<Core::IrSensor::IrCameraHandle> out_camera_handle,
+void IRS::GetNpadIrCameraHandle(HLERequestContext& ctx) {
-                                  Core::HID::NpadIdType npad_id) {
+    IPC::RequestParser rp{ctx};
-    R_UNLESS(HID::IsNpadIdValid(npad_id), HID::ResultInvalidNpadId);
+    const auto npad_id{rp.PopEnum<Core::HID::NpadIdType>()};
 
-    *out_camera_handle = {
+    if (npad_id > Core::HID::NpadIdType::Player8 && npad_id != Core::HID::NpadIdType::Invalid &&
+        npad_id != Core::HID::NpadIdType::Handheld) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(Service::HID::ResultInvalidNpadId);
+        return;
+    }
+
+    Core::IrSensor::IrCameraHandle camera_handle{
         .npad_id = static_cast<u8>(HID::NpadIdTypeToIndex(npad_id)),
         .npad_type = Core::HID::NpadStyleIndex::None,
     };
 
     LOG_INFO(Service_IRS, "called, npad_id={}, camera_npad_id={}, camera_npad_type={}", npad_id,
-             out_camera_handle->npad_id, out_camera_handle->npad_type);
+             camera_handle.npad_id, camera_handle.npad_type);
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(camera_handle);
 }
 
-Result IRS::RunPointingProcessor(
+void IRS::RunPointingProcessor(HLERequestContext& ctx) {
-    Core::IrSensor::IrCameraHandle camera_handle,
+    IPC::RequestParser rp{ctx};
-    const Core::IrSensor::PackedPointingProcessorConfig& processor_config,
+    const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
-    ClientAppletResourceUserId aruid) {
+    const auto processor_config{rp.PopRaw<Core::IrSensor::PackedPointingProcessorConfig>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
     LOG_WARNING(
         Service_IRS,
         "(STUBBED) called, npad_type={}, npad_id={}, mcu_version={}.{}, applet_resource_user_id={}",
         camera_handle.npad_type, camera_handle.npad_id, processor_config.required_mcu_version.major,
-        processor_config.required_mcu_version.minor, aruid.pid);
+        processor_config.required_mcu_version.minor, applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessor<PointingProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
-    auto& image_transfer_processor = GetProcessor<PointingProcessor>(camera_handle);
+        MakeProcessor<PointingProcessor>(camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor = GetProcessor<PointingProcessor>(camera_handle);
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        image_transfer_processor.SetConfig(processor_config);
-                                Common::Input::PollingMode::IR);
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::SuspendImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::SuspendImageProcessor(HLERequestContext& ctx) {
-                                  ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-                camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+                parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+                parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(parameters.camera_handle);
+    if (result.IsSuccess()) {
+        // TODO: Suspend image processor
+        result = ResultSuccess;
+    }
 
-    // TODO: Suspend image processor
+    IPC::ResponseBuilder rb{ctx, 2};
-
+    rb.Push(result);
-    R_SUCCEED();
 }
 
-Result IRS::CheckFirmwareVersion(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::CheckFirmwareVersion(HLERequestContext& ctx) {
-                                 Core::IrSensor::PackedMcuVersion mcu_version,
+    IPC::RequestParser rp{ctx};
-                                 ClientAppletResourceUserId aruid) {
+    const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
+    const auto mcu_version{rp.PopRaw<Core::IrSensor::PackedMcuVersion>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
     LOG_WARNING(
         Service_IRS,
         "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}, mcu_version={}.{}",
-        camera_handle.npad_type, camera_handle.npad_id, aruid.pid, mcu_version.major,
+        camera_handle.npad_type, camera_handle.npad_id, applet_resource_user_id, mcu_version.major,
         mcu_version.minor);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(camera_handle);
+    if (result.IsSuccess()) {
+        // TODO: Check firmware version
+        result = ResultSuccess;
+    }
 
-    // TODO: Check firmware version
+    IPC::ResponseBuilder rb{ctx, 2};
-
+    rb.Push(result);
-    R_SUCCEED();
 }
 
-Result IRS::SetFunctionLevel(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::SetFunctionLevel(HLERequestContext& ctx) {
-                             Core::IrSensor::PackedFunctionLevel function_level,
+    IPC::RequestParser rp{ctx};
-                             ClientAppletResourceUserId aruid) {
+    const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
+    const auto function_level{rp.PopRaw<Core::IrSensor::PackedFunctionLevel>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
     LOG_WARNING(
         Service_IRS,
         "(STUBBED) called, npad_type={}, npad_id={}, function_level={}, applet_resource_user_id={}",
-        camera_handle.npad_type, camera_handle.npad_id, function_level.function_level, aruid.pid);
+        camera_handle.npad_type, camera_handle.npad_id, function_level.function_level,
+        applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(camera_handle);
+    if (result.IsSuccess()) {
+        // TODO: Set Function level
+        result = ResultSuccess;
+    }
 
-    // TODO: Set Function level
+    IPC::ResponseBuilder rb{ctx, 2};
-
+    rb.Push(result);
-    R_SUCCEED();
 }
 
-Result IRS::RunImageTransferExProcessor(
+void IRS::RunImageTransferExProcessor(HLERequestContext& ctx) {
-    Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    IPC::RequestParser rp{ctx};
-    const Core::IrSensor::PackedImageTransferProcessorExConfig& processor_config,
+    struct Parameters {
-    u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem) {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+        Core::IrSensor::PackedImageTransferProcessorExConfig processor_config;
+        u64 transfer_memory_size;
+    };
+    static_assert(sizeof(Parameters) == 0x38, "Parameters has incorrect size.");
 
-    ASSERT_MSG(t_mem->GetSize() == transfer_memory_size, "t_mem has incorrect size");
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto t_mem_handle{ctx.GetCopyHandle(0)};
+
+    auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle);
 
     LOG_INFO(Service_IRS,
              "called, npad_type={}, npad_id={}, transfer_memory_size={}, "
              "applet_resource_user_id={}",
-             camera_handle.npad_type, camera_handle.npad_id, transfer_memory_size, aruid.pid);
+             parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+             parameters.transfer_memory_size, parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(parameters.camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessorWithCoreContext<ImageTransferProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(parameters.camera_handle);
-    auto& image_transfer_processor = GetProcessor<ImageTransferProcessor>(camera_handle);
+        MakeProcessorWithCoreContext<ImageTransferProcessor>(parameters.camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor =
-    image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+            GetProcessor<ImageTransferProcessor>(parameters.camera_handle);
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        image_transfer_processor.SetConfig(parameters.processor_config);
-                                Common::Input::PollingMode::IR);
+        image_transfer_processor.SetTransferMemoryAddress(t_mem->GetSourceAddress());
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::RunIrLedProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::RunIrLedProcessor(HLERequestContext& ctx) {
-                              Core::IrSensor::PackedIrLedProcessorConfig processor_config,
+    IPC::RequestParser rp{ctx};
-                              ClientAppletResourceUserId aruid) {
+    const auto camera_handle{rp.PopRaw<Core::IrSensor::IrCameraHandle>()};
+    const auto processor_config{rp.PopRaw<Core::IrSensor::PackedIrLedProcessorConfig>()};
+    const auto applet_resource_user_id{rp.Pop<u64>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, light_target={}, mcu_version={}.{} "
                 "applet_resource_user_id={}",
                 camera_handle.npad_type, camera_handle.npad_id, processor_config.light_target,
                 processor_config.required_mcu_version.major,
-                processor_config.required_mcu_version.minor, aruid.pid);
+                processor_config.required_mcu_version.minor, applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(camera_handle);
 
-    auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
+    if (result.IsSuccess()) {
-    MakeProcessor<IrLedProcessor>(camera_handle, device);
+        auto& device = GetIrCameraSharedMemoryDeviceEntry(camera_handle);
-    auto& image_transfer_processor = GetProcessor<IrLedProcessor>(camera_handle);
+        MakeProcessor<IrLedProcessor>(camera_handle, device);
-    image_transfer_processor.SetConfig(processor_config);
+        auto& image_transfer_processor = GetProcessor<IrLedProcessor>(camera_handle);
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+        image_transfer_processor.SetConfig(processor_config);
-                                Common::Input::PollingMode::IR);
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::IR);
+    }
 
-    R_SUCCEED();
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(result);
 }
 
-Result IRS::StopImageProcessorAsync(Core::IrSensor::IrCameraHandle camera_handle,
+void IRS::StopImageProcessorAsync(HLERequestContext& ctx) {
-                                    ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        Core::IrSensor::IrCameraHandle camera_handle;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS,
                 "(STUBBED) called, npad_type={}, npad_id={}, applet_resource_user_id={}",
-                camera_handle.npad_type, camera_handle.npad_id, aruid.pid);
+                parameters.camera_handle.npad_type, parameters.camera_handle.npad_id,
+                parameters.applet_resource_user_id);
 
-    R_TRY(IsIrCameraHandleValid(camera_handle));
+    auto result = IsIrCameraHandleValid(parameters.camera_handle);
+    if (result.IsSuccess()) {
+        // TODO: Stop image processor async
+        npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+                                    Common::Input::PollingMode::Active);
+        result = ResultSuccess;
+    }
 
-    // TODO: Stop image processor async
+    IPC::ResponseBuilder rb{ctx, 2};
-    npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,
+    rb.Push(result);
-                                Common::Input::PollingMode::Active);
-
-    R_SUCCEED();
 }
 
-Result IRS::ActivateIrsensorWithFunctionLevel(Core::IrSensor::PackedFunctionLevel function_level,
+void IRS::ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx) {
-                                              ClientAppletResourceUserId aruid) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        Core::IrSensor::PackedFunctionLevel function_level;
+        INSERT_PADDING_WORDS_NOINIT(1);
+        u64 applet_resource_user_id;
+    };
+    static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+
     LOG_WARNING(Service_IRS, "(STUBBED) called, function_level={}, applet_resource_user_id={}",
-                function_level.function_level, aruid.pid);
+                parameters.function_level.function_level, parameters.applet_resource_user_id);
-    R_SUCCEED();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
 }
 
 Result IRS::IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const {

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

@@ -4,7 +4,6 @@
 #pragma once
 
 #include "core/core.h"
-#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/irsensor/irs_types.h"
@@ -36,73 +35,26 @@ private:
     };
     static_assert(sizeof(StatusManager) == 0x8000, "StatusManager is an invalid size");
 
-    Result ActivateIrsensor(ClientAppletResourceUserId aruid);
+    void ActivateIrsensor(HLERequestContext& ctx);
-
+    void DeactivateIrsensor(HLERequestContext& ctx);
-    Result DeactivateIrsensor(ClientAppletResourceUserId aruid);
+    void GetIrsensorSharedMemoryHandle(HLERequestContext& ctx);
-
+    void StopImageProcessor(HLERequestContext& ctx);
-    Result GetIrsensorSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory,
+    void RunMomentProcessor(HLERequestContext& ctx);
-                                         ClientAppletResourceUserId aruid);
+    void RunClusteringProcessor(HLERequestContext& ctx);
-    Result StopImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+    void RunImageTransferProcessor(HLERequestContext& ctx);
-                              ClientAppletResourceUserId aruid);
+    void GetImageTransferProcessorState(HLERequestContext& ctx);
-
+    void RunTeraPluginProcessor(HLERequestContext& ctx);
-    Result RunMomentProcessor(Core::IrSensor::IrCameraHandle camera_handle,
+    void GetNpadIrCameraHandle(HLERequestContext& ctx);
-                              ClientAppletResourceUserId aruid,
+    void RunPointingProcessor(HLERequestContext& ctx);
-                              const Core::IrSensor::PackedMomentProcessorConfig& processor_config);
+    void SuspendImageProcessor(HLERequestContext& ctx);
-
+    void CheckFirmwareVersion(HLERequestContext& ctx);
-    Result RunClusteringProcessor(
+    void SetFunctionLevel(HLERequestContext& ctx);
-        Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
+    void RunImageTransferExProcessor(HLERequestContext& ctx);
-        const Core::IrSensor::PackedClusteringProcessorConfig& processor_config);
+    void RunIrLedProcessor(HLERequestContext& ctx);
-
+    void StopImageProcessorAsync(HLERequestContext& ctx);
-    Result RunImageTransferProcessor(
+    void ActivateIrsensorWithFunctionLevel(HLERequestContext& ctx);
-        Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
-        const Core::IrSensor::PackedImageTransferProcessorConfig& processor_config,
-        u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem);
-
-    Result GetImageTransferProcessorState(
-        Out<Core::IrSensor::ImageTransferProcessorState> out_state,
-        Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
-        OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data);
-
-    Result RunTeraPluginProcessor(Core::IrSensor::IrCameraHandle camera_handle,
-                                  Core::IrSensor::PackedTeraPluginProcessorConfig processor_config,
-                                  ClientAppletResourceUserId aruid);
-
-    Result GetNpadIrCameraHandle(Out<Core::IrSensor::IrCameraHandle> out_camera_handle,
-                                 Core::HID::NpadIdType npad_id);
-
-    Result RunPointingProcessor(
-        Core::IrSensor::IrCameraHandle camera_handle,
-        const Core::IrSensor::PackedPointingProcessorConfig& processor_config,
-        ClientAppletResourceUserId aruid);
-
-    Result SuspendImageProcessor(Core::IrSensor::IrCameraHandle camera_handle,
-                                 ClientAppletResourceUserId aruid);
-
-    Result CheckFirmwareVersion(Core::IrSensor::IrCameraHandle camera_handle,
-                                Core::IrSensor::PackedMcuVersion mcu_version,
-                                ClientAppletResourceUserId aruid);
-
-    Result SetFunctionLevel(Core::IrSensor::IrCameraHandle camera_handle,
-                            Core::IrSensor::PackedFunctionLevel function_level,
-                            ClientAppletResourceUserId aruid);
-
-    Result RunImageTransferExProcessor(
-        Core::IrSensor::IrCameraHandle camera_handle, ClientAppletResourceUserId aruid,
-        const Core::IrSensor::PackedImageTransferProcessorExConfig& processor_config,
-        u64 transfer_memory_size, InCopyHandle<Kernel::KTransferMemory> t_mem);
-
-    Result RunIrLedProcessor(Core::IrSensor::IrCameraHandle camera_handle,
-                             Core::IrSensor::PackedIrLedProcessorConfig processor_config,
-                             ClientAppletResourceUserId aruid);
-
-    Result StopImageProcessorAsync(Core::IrSensor::IrCameraHandle camera_handle,
-                                   ClientAppletResourceUserId aruid);
-
-    Result ActivateIrsensorWithFunctionLevel(Core::IrSensor::PackedFunctionLevel function_level,
-                                             ClientAppletResourceUserId aruid);
 
     Result IsIrCameraHandleValid(const Core::IrSensor::IrCameraHandle& camera_handle) const;
-
     Core::IrSensor::DeviceFormat& GetIrCameraSharedMemoryDeviceEntry(
         const Core::IrSensor::IrCameraHandle& camera_handle);
 

src/core/hle/service/hle_ipc.cpp

@@ -299,12 +299,8 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer() {
     if (GetManager()->IsDomain()) {
         current_offset = domain_offset - static_cast<u32>(outgoing_domain_objects.size());
         for (auto& object : outgoing_domain_objects) {
-            if (object) {
+            GetManager()->AppendDomainHandler(std::move(object));
-                GetManager()->AppendDomainHandler(std::move(object));
+            cmd_buf[current_offset++] = static_cast<u32_le>(GetManager()->DomainHandlerCount());
-                cmd_buf[current_offset++] = static_cast<u32_le>(GetManager()->DomainHandlerCount());
-            } else {
-                cmd_buf[current_offset++] = 0;
-            }
         }
     }
 

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

@@ -123,8 +123,6 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
         vm.va_range_end = params.va_range_end;
     }
 
-    const u64 max_big_page_bits = Common::Log2Ceil64(vm.va_range_end);
-
     const auto start_pages{static_cast<u32>(vm.va_range_start >> VM::PAGE_SIZE_BITS)};
     const auto end_pages{static_cast<u32>(vm.va_range_split >> VM::PAGE_SIZE_BITS)};
     vm.small_page_allocator = std::make_shared<VM::Allocator>(start_pages, end_pages);
@@ -134,8 +132,8 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
         static_cast<u32>((vm.va_range_end - vm.va_range_split) >> vm.big_page_size_bits)};
     vm.big_page_allocator = std::make_unique<VM::Allocator>(start_big_pages, end_big_pages);
 
-    gmmu = std::make_shared<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split,
+    gmmu = std::make_shared<Tegra::MemoryManager>(system, 40, vm.big_page_size_bits,
-                                                  vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
+                                                  VM::PAGE_SIZE_BITS);
     system.GPU().InitAddressSpace(*gmmu);
     vm.initialised = true;
 

src/core/memory/cheat_engine.cpp

@@ -5,7 +5,6 @@
 #include "common/hex_util.h"
 #include "common/microprofile.h"
 #include "common/swap.h"
-#include "core/arm/debug.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_page_table.h"
@@ -48,25 +47,12 @@ StandardVmCallbacks::StandardVmCallbacks(System& system_, const CheatProcessMeta
 
 StandardVmCallbacks::~StandardVmCallbacks() = default;
 
-void StandardVmCallbacks::MemoryReadUnsafe(VAddr address, void* data, u64 size) {
+void StandardVmCallbacks::MemoryRead(VAddr address, void* data, u64 size) {
-    // Return zero on invalid address
+    system.ApplicationMemory().ReadBlock(SanitizeAddress(address), data, size);
-    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        std::memset(data, 0, size);
-        return;
-    }
-
-    system.ApplicationMemory().ReadBlock(address, data, size);
 }
 
-void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64 size) {
+void StandardVmCallbacks::MemoryWrite(VAddr address, const void* data, u64 size) {
-    // Skip invalid memory write address
+    system.ApplicationMemory().WriteBlock(SanitizeAddress(address), data, size);
-    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        return;
-    }
-
-    if (system.ApplicationMemory().WriteBlock(address, data, size)) {
-        Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
-    }
 }
 
 u64 StandardVmCallbacks::HidKeysDown() {
@@ -96,7 +82,7 @@ void StandardVmCallbacks::CommandLog(std::string_view data) {
               data.back() == '\n' ? data.substr(0, data.size() - 1) : data);
 }
 
-bool StandardVmCallbacks::IsAddressInRange(VAddr in) const {
+VAddr StandardVmCallbacks::SanitizeAddress(VAddr in) const {
     if ((in < metadata.main_nso_extents.base ||
          in >= metadata.main_nso_extents.base + metadata.main_nso_extents.size) &&
         (in < metadata.heap_extents.base ||
@@ -111,10 +97,10 @@ bool StandardVmCallbacks::IsAddressInRange(VAddr in) const {
                   "the cheat may be incorrect. However, this may be normal early in execution if "
                   "the game has not properly set up yet.",
                   in);
-        return false; ///< Invalid addresses will hard crash
+        return 0; ///< Invalid addresses will hard crash
     }
 
-    return true;
+    return in;
 }
 
 CheatParser::~CheatParser() = default;

src/core/memory/cheat_engine.h

@@ -27,14 +27,14 @@ public:
     StandardVmCallbacks(System& system_, const CheatProcessMetadata& metadata_);
     ~StandardVmCallbacks() override;
 
-    void MemoryReadUnsafe(VAddr address, void* data, u64 size) override;
+    void MemoryRead(VAddr address, void* data, u64 size) override;
-    void MemoryWriteUnsafe(VAddr address, const void* data, u64 size) override;
+    void MemoryWrite(VAddr address, const void* data, u64 size) override;
     u64 HidKeysDown() override;
     void DebugLog(u8 id, u64 value) override;
     void CommandLog(std::string_view data) override;
 
 private:
-    bool IsAddressInRange(VAddr address) const;
+    VAddr SanitizeAddress(VAddr address) const;
 
     const CheatProcessMetadata& metadata;
     Core::System& system;

src/core/memory/dmnt_cheat_vm.cpp

@@ -773,7 +773,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, store_static->bit_width);
+                callbacks->MemoryWrite(dst_address, &dst_value, store_static->bit_width);
                 break;
             }
         } else if (auto begin_cond = std::get_if<BeginConditionalOpcode>(&cur_opcode.opcode)) {
@@ -786,7 +786,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryReadUnsafe(src_address, &src_value, begin_cond->bit_width);
+                callbacks->MemoryRead(src_address, &src_value, begin_cond->bit_width);
                 break;
             }
             // Check against condition.
@@ -857,8 +857,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryReadUnsafe(src_address, &registers[ldr_memory->reg_index],
+                callbacks->MemoryRead(src_address, &registers[ldr_memory->reg_index],
-                                            ldr_memory->bit_width);
+                                      ldr_memory->bit_width);
                 break;
             }
         } else if (auto str_static = std::get_if<StoreStaticToAddressOpcode>(&cur_opcode.opcode)) {
@@ -874,7 +874,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, str_static->bit_width);
+                callbacks->MemoryWrite(dst_address, &dst_value, str_static->bit_width);
                 break;
             }
             // Increment register if relevant.
@@ -1032,7 +1032,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, str_register->bit_width);
+                callbacks->MemoryWrite(dst_address, &dst_value, str_register->bit_width);
                 break;
             }
 
@@ -1111,8 +1111,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 case 2:
                 case 4:
                 case 8:
-                    callbacks->MemoryReadUnsafe(cond_address, &cond_value,
+                    callbacks->MemoryRead(cond_address, &cond_value, begin_reg_cond->bit_width);
-                                                begin_reg_cond->bit_width);
                     break;
                 }
             }
@@ -1254,7 +1253,7 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 case 2:
                 case 4:
                 case 8:
-                    callbacks->MemoryReadUnsafe(val_address, &log_value, debug_log->bit_width);
+                    callbacks->MemoryRead(val_address, &log_value, debug_log->bit_width);
                     break;
                 }
             }

src/core/memory/dmnt_cheat_vm.h

@@ -266,8 +266,8 @@ public:
     public:
         virtual ~Callbacks();
 
-        virtual void MemoryReadUnsafe(VAddr address, void* data, u64 size) = 0;
+        virtual void MemoryRead(VAddr address, void* data, u64 size) = 0;
-        virtual void MemoryWriteUnsafe(VAddr address, const void* data, u64 size) = 0;
+        virtual void MemoryWrite(VAddr address, const void* data, u64 size) = 0;
 
         virtual u64 HidKeysDown() = 0;
 

src/hid_core/irsensor/image_transfer_processor.cpp

@@ -145,8 +145,9 @@ void ImageTransferProcessor::SetTransferMemoryAddress(Common::ProcessAddress t_m
 }
 
 Core::IrSensor::ImageTransferProcessorState ImageTransferProcessor::GetState(
-    std::span<u8> data) const {
+    std::vector<u8>& data) const {
-    const auto size = std::min(GetDataSize(current_config.trimming_format), data.size());
+    const auto size = GetDataSize(current_config.trimming_format);
+    data.resize(size);
     system.ApplicationMemory().ReadBlock(transfer_memory, data.data(), size);
     return processor_state;
 }

src/hid_core/irsensor/image_transfer_processor.h

@@ -3,8 +3,6 @@
 
 #pragma once
 
-#include <span>
-
 #include "common/typed_address.h"
 #include "hid_core/irsensor/irs_types.h"
 #include "hid_core/irsensor/processor_base.h"
@@ -41,7 +39,7 @@ public:
     // Transfer memory where the image data will be stored
     void SetTransferMemoryAddress(Common::ProcessAddress t_mem);
 
-    Core::IrSensor::ImageTransferProcessorState GetState(std::span<u8> data) const;
+    Core::IrSensor::ImageTransferProcessorState GetState(std::vector<u8>& data) const;
 
 private:
     // This is nn::irsensor::ImageTransferProcessorConfig

src/hid_core/resources/abstracted_pad/abstract_sixaxis_handler.cpp

@@ -57,7 +57,7 @@ Result NpadAbstractSixAxisHandler::UpdateSixAxisState() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        if (data == nullptr || !data->flag.is_assigned) {
+        if (data->flag.is_assigned) {
             continue;
         }
         auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];

src/hid_core/resources/npad/npad.cpp

@@ -131,7 +131,7 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
 
         auto* data = applet_resource_holder.applet_resource->GetAruidDataByIndex(aruid_index);
 
-        if (data == nullptr || !data->flag.is_assigned) {
+        if (!data->flag.is_assigned) {
             continue;
         }
 
@@ -463,13 +463,13 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     std::scoped_lock lock{*applet_resource_holder.shared_mutex};
     for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
         const auto* data = applet_resource_holder.applet_resource->GetAruidDataByIndex(aruid_index);
+        const auto aruid = data->aruid;
 
-        if (data == nullptr || !data->flag.is_assigned) {
+        if (!data->flag.is_assigned) {
             continue;
         }
 
         bool is_set{};
-        const auto aruid = data->aruid;
         npad_resource.IsSupportedNpadStyleSet(is_set, aruid);
         // Wait until style is defined
         if (!is_set) {

src/hid_core/resources/six_axis/six_axis.cpp

@@ -28,148 +28,142 @@ void SixAxis::OnRelease() {}
 
 void SixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     std::scoped_lock shared_lock{*shared_mutex};
+    const u64 aruid = applet_resource->GetActiveAruid();
+    auto* data = applet_resource->GetAruidData(aruid);
 
-    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
+    if (data == nullptr || !data->flag.is_assigned) {
-        const auto* data = applet_resource->GetAruidDataByIndex(aruid_index);
+        return;
+    }
 
-        if (data == nullptr || !data->flag.is_assigned) {
+    if (!IsControllerActivated()) {
+        return;
+    }
+
+    for (std::size_t i = 0; i < controller_data.size(); ++i) {
+        NpadSharedMemoryEntry& shared_memory = data->shared_memory_format->npad.npad_entry[i];
+        auto& controller = controller_data[i];
+        const auto& controller_type = controller.device->GetNpadStyleIndex();
+
+        if (controller_type == Core::HID::NpadStyleIndex::None ||
+            !controller.device->IsConnected()) {
             continue;
         }
 
-        if (!IsControllerActivated()) {
+        const auto& motion_state = controller.device->GetMotions();
-            return;
+        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 = shared_memory.internal_state.sixaxis_fullkey_lifo;
+        auto& sixaxis_handheld_lifo = shared_memory.internal_state.sixaxis_handheld_lifo;
+        auto& sixaxis_dual_left_lifo = shared_memory.internal_state.sixaxis_dual_left_lifo;
+        auto& sixaxis_dual_right_lifo = shared_memory.internal_state.sixaxis_dual_right_lifo;
+        auto& sixaxis_left_lifo = shared_memory.internal_state.sixaxis_left_lifo;
+        auto& sixaxis_right_lifo = shared_memory.internal_state.sixaxis_right_lifo;
+
+        // 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;
+            }
         }
 
-        for (std::size_t i = 0; i < controller_data.size(); ++i) {
+        const auto set_motion_state = [&](Core::HID::SixAxisSensorState& state,
-            NpadSharedMemoryEntry& shared_memory = data->shared_memory_format->npad.npad_entry[i];
+                                          const Core::HID::ControllerMotion& hid_state) {
-            auto& controller = controller_data[i];
+            using namespace std::literals::chrono_literals;
-            const auto& controller_type = controller.device->GetNpadStyleIndex();
+            static constexpr Core::HID::SixAxisSensorState default_motion_state = {
-
+                .delta_time = std::chrono::nanoseconds(5ms).count(),
-            if (!data->flag.enable_six_axis_sensor) {
+                .accel = {0, 0, -1.0f},
-                continue;
+                .orientation =
-            }
+                    {
-
+                        Common::Vec3f{1.0f, 0, 0},
-            if (controller_type == Core::HID::NpadStyleIndex::None ||
+                        Common::Vec3f{0, 1.0f, 0},
-                !controller.device->IsConnected()) {
+                        Common::Vec3f{0, 0, 1.0f},
-                continue;
+                    },
-            }
+                .attribute = {1},
-
-            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 = shared_memory.internal_state.sixaxis_fullkey_lifo;
-            auto& sixaxis_handheld_lifo = shared_memory.internal_state.sixaxis_handheld_lifo;
-            auto& sixaxis_dual_left_lifo = shared_memory.internal_state.sixaxis_dual_left_lifo;
-            auto& sixaxis_dual_right_lifo = shared_memory.internal_state.sixaxis_dual_right_lifo;
-            auto& sixaxis_left_lifo = shared_memory.internal_state.sixaxis_left_lifo;
-            auto& sixaxis_right_lifo = shared_memory.internal_state.sixaxis_right_lifo;
-
-            // 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;
             };
-
+            if (!controller.sixaxis_sensor_enabled) {
-            switch (controller_type) {
+                state = default_motion_state;
-            case Core::HID::NpadStyleIndex::None:
+                return;
-                ASSERT(false);
-                break;
-            case Core::HID::NpadStyleIndex::Fullkey:
-                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;
             }
-
+            if (!Settings::values.motion_enabled.GetValue()) {
-            sixaxis_fullkey_state.sampling_number =
+                state = default_motion_state;
-                sixaxis_fullkey_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+                return;
-            sixaxis_handheld_state.sampling_number =
-                sixaxis_handheld_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-            sixaxis_dual_left_state.sampling_number =
-                sixaxis_dual_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-            sixaxis_dual_right_state.sampling_number =
-                sixaxis_dual_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-            sixaxis_left_lifo_state.sampling_number =
-                sixaxis_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
-            sixaxis_right_lifo_state.sampling_number =
-                sixaxis_right_lifo.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.lifo.WriteNextEntry(sixaxis_handheld_state);
-            } else {
-                // Handheld doesn't update this buffer on HW
-                sixaxis_fullkey_lifo.lifo.WriteNextEntry(sixaxis_fullkey_state);
             }
+            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;
+        };
 
-            sixaxis_dual_left_lifo.lifo.WriteNextEntry(sixaxis_dual_left_state);
+        switch (controller_type) {
-            sixaxis_dual_right_lifo.lifo.WriteNextEntry(sixaxis_dual_right_state);
+        case Core::HID::NpadStyleIndex::None:
-            sixaxis_left_lifo.lifo.WriteNextEntry(sixaxis_left_lifo_state);
+            ASSERT(false);
-            sixaxis_right_lifo.lifo.WriteNextEntry(sixaxis_right_lifo_state);
+            break;
+        case Core::HID::NpadStyleIndex::Fullkey:
+            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.lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_handheld_state.sampling_number =
+            sixaxis_handheld_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_dual_left_state.sampling_number =
+            sixaxis_dual_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_dual_right_state.sampling_number =
+            sixaxis_dual_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_left_lifo_state.sampling_number =
+            sixaxis_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1;
+        sixaxis_right_lifo_state.sampling_number =
+            sixaxis_right_lifo.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.lifo.WriteNextEntry(sixaxis_handheld_state);
+        } else {
+            // Handheld doesn't update this buffer on HW
+            sixaxis_fullkey_lifo.lifo.WriteNextEntry(sixaxis_fullkey_state);
+        }
+
+        sixaxis_dual_left_lifo.lifo.WriteNextEntry(sixaxis_dual_left_state);
+        sixaxis_dual_right_lifo.lifo.WriteNextEntry(sixaxis_dual_right_state);
+        sixaxis_left_lifo.lifo.WriteNextEntry(sixaxis_left_lifo_state);
+        sixaxis_right_lifo.lifo.WriteNextEntry(sixaxis_right_lifo_state);
     }
 }
 

src/hid_core/resources/touch_screen/touch_screen_resource.cpp

@@ -63,7 +63,7 @@ Result TouchResource::ActivateTouch(u64 aruid) {
         auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& touch_data = aruid_data[aruid_index];
 
-        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
+        if (!applet_data->flag.is_assigned) {
             touch_data = {};
             continue;
         }
@@ -124,7 +124,7 @@ Result TouchResource::ActivateGesture(u64 aruid, u32 basic_gesture_id) {
         auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& touch_data = aruid_data[aruid_index];
 
-        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
+        if (!applet_data->flag.is_assigned) {
             touch_data = {};
             continue;
         }
@@ -324,7 +324,7 @@ Result TouchResource::SetTouchScreenConfiguration(
         const auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         TouchAruidData& data = aruid_data[aruid_index];
 
-        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
+        if (!applet_data->flag.is_assigned) {
             continue;
         }
         if (aruid != data.aruid) {
@@ -344,7 +344,7 @@ Result TouchResource::GetTouchScreenConfiguration(
         const auto* applet_data = applet_resource->GetAruidDataByIndex(aruid_index);
         const TouchAruidData& data = aruid_data[aruid_index];
 
-        if (applet_data == nullptr || !applet_data->flag.is_assigned) {
+        if (!applet_data->flag.is_assigned) {
             continue;
         }
         if (aruid != data.aruid) {

src/video_core/control/scheduler.cpp

@@ -13,20 +13,102 @@ Scheduler::Scheduler(GPU& gpu_) : gpu{gpu_} {}
 
 Scheduler::~Scheduler() = default;
 
+void Scheduler::Init() {
+    master_control = Common::Fiber::ThreadToFiber();
+}
+
+void Scheduler::Resume() {
+    bool nothing_pending;
+    do {
+        nothing_pending = true;
+        current_fifo = nullptr;
+        {
+            std::unique_lock lk(scheduling_guard);
+            size_t num_iters = gpfifos.size();
+            for (size_t i = 0; i < num_iters; i++) {
+                size_t current_id = (current_fifo_rotation_id + i) % gpfifos.size();
+                auto& fifo = gpfifos[current_id];
+                if (!fifo.is_active) {
+                    continue;
+                }
+                std::scoped_lock lk2(fifo.guard);
+                if (!fifo.pending_work.empty() || fifo.working.load(std::memory_order_acquire)) {
+                    current_fifo = &fifo;
+                    current_fifo_rotation_id = current_id;
+                    nothing_pending = false;
+                    break;
+                }
+            }
+        }
+        if (current_fifo) {
+            Common::Fiber::YieldTo(master_control, *current_fifo->context);
+            current_fifo = nullptr;
+        }
+    } while (!nothing_pending);
+}
+
+void Scheduler::Yield() {
+    ASSERT(current_fifo != nullptr);
+    Common::Fiber::YieldTo(current_fifo->context, *master_control);
+    gpu.BindChannel(current_fifo->bind_id);
+}
+
 void Scheduler::Push(s32 channel, CommandList&& entries) {
     std::unique_lock lk(scheduling_guard);
-    auto it = channels.find(channel);
+    auto it = channel_gpfifo_ids.find(channel);
-    ASSERT(it != channels.end());
+    ASSERT(it != channel_gpfifo_ids.end());
-    auto channel_state = it->second;
+    auto gpfifo_id = it->second;
-    gpu.BindChannel(channel_state->bind_id);
+    auto& fifo = gpfifos[gpfifo_id];
-    channel_state->dma_pusher->Push(std::move(entries));
+    {
-    channel_state->dma_pusher->DispatchCalls();
+        std::scoped_lock lk2(fifo.guard);
+        fifo.pending_work.emplace_back(std::move(entries));
+    }
+}
+
+void Scheduler::ChannelLoop(size_t gpfifo_id, s32 channel_id) {
+    gpu.BindChannel(channel_id);
+    auto& fifo = gpfifos[gpfifo_id];
+    while (true) {
+        auto* channel_state = channels[channel_id].get();
+        fifo.guard.lock();
+        while (!fifo.pending_work.empty()) {
+            {
+
+                fifo.working.store(true, std::memory_order_release);
+                CommandList&& entries = std::move(fifo.pending_work.front());
+                channel_state->dma_pusher->Push(std::move(entries));
+                fifo.pending_work.pop_front();
+            }
+            fifo.guard.unlock();
+            channel_state->dma_pusher->DispatchCalls();
+            fifo.guard.lock();
+        }
+        fifo.working.store(false, std::memory_order_relaxed);
+        fifo.guard.unlock();
+        Common::Fiber::YieldTo(fifo.context, *master_control);
+        gpu.BindChannel(channel_id);
+    }
 }
 
 void Scheduler::DeclareChannel(std::shared_ptr<ChannelState> new_channel) {
     s32 channel = new_channel->bind_id;
     std::unique_lock lk(scheduling_guard);
     channels.emplace(channel, new_channel);
+    size_t new_fifo_id;
+    if (!free_fifos.empty()) {
+        new_fifo_id = free_fifos.front();
+        free_fifos.pop_front();
+    } else {
+        new_fifo_id = gpfifos.size();
+        gpfifos.emplace_back();
+    }
+    auto& new_fifo = gpfifos[new_fifo_id];
+    channel_gpfifo_ids[channel] = new_fifo_id;
+    new_fifo.is_active = true;
+    new_fifo.bind_id = channel;
+    new_fifo.pending_work.clear();
+    std::function<void()> callback = std::bind(&Scheduler::ChannelLoop, this, new_fifo_id, channel);
+    new_fifo.context = std::make_shared<Common::Fiber>(std::move(callback));
 }
 
 } // namespace Tegra::Control

src/video_core/control/scheduler.h

@@ -3,10 +3,13 @@
 
 #pragma once
 
+#include <atomic>
+#include <deque>
 #include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/fiber.h"
 #include "video_core/dma_pusher.h"
 
 namespace Tegra {
@@ -22,14 +25,36 @@ public:
     explicit Scheduler(GPU& gpu_);
     ~Scheduler();
 
+    void Init();
+
+    void Resume();
+
+    void Yield();
+
     void Push(s32 channel, CommandList&& entries);
 
     void DeclareChannel(std::shared_ptr<ChannelState> new_channel);
 
 private:
+    void ChannelLoop(size_t gpfifo_id, s32 channel_id);
+
     std::unordered_map<s32, std::shared_ptr<ChannelState>> channels;
+    std::unordered_map<s32, size_t> channel_gpfifo_ids;
     std::mutex scheduling_guard;
+    std::shared_ptr<Common::Fiber> master_control;
+    struct GPFifoContext {
+        bool is_active;
+        std::shared_ptr<Common::Fiber> context;
+        std::deque<CommandList> pending_work;
+        std::atomic<bool> working{};
+        std::mutex guard;
+        s32 bind_id;
+    };
+    std::deque<GPFifoContext> gpfifos;
+    std::deque<size_t> free_fifos;
     GPU& gpu;
+    size_t current_fifo_rotation_id{};
+    GPFifoContext* current_fifo{};
 };
 
 } // namespace Control

src/video_core/engines/puller.cpp

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

src/video_core/gpu.cpp

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

src/video_core/gpu.h

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

src/video_core/gpu_thread.cpp

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

src/video_core/gpu_thread.h

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

src/video_core/host1x/host1x.cpp

@@ -10,7 +10,7 @@ namespace Tegra::Host1x {
 
 Host1x::Host1x(Core::System& system_)
     : system{system_}, syncpoint_manager{},
-      memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 0, 12},
+      memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 12},
       allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
 
 Host1x::~Host1x() = default;

src/video_core/memory_manager.cpp

@@ -22,12 +22,11 @@ using Tegra::Memory::GuestMemoryFlags;
 std::atomic<size_t> MemoryManager::unique_identifier_generator{};
 
 MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_,
-                             u64 address_space_bits_, GPUVAddr split_address_, u64 big_page_bits_,
+                             u64 address_space_bits_, u64 big_page_bits_, u64 page_bits_)
-                             u64 page_bits_)
     : system{system_}, memory{memory_}, address_space_bits{address_space_bits_},
-      split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_},
+      page_bits{page_bits_}, big_page_bits{big_page_bits_}, entries{}, big_entries{},
-      entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
+      page_table{address_space_bits, address_space_bits + page_bits - 38,
-                                           page_bits != big_page_bits ? page_bits : 0},
+                 page_bits != big_page_bits ? page_bits : 0},
       kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
                                       1, std::memory_order_acq_rel)},
       accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
@@ -49,10 +48,10 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
     entries.resize(page_table_size / 32, 0);
 }
 
-MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_,
+MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_, u64 big_page_bits_,
-                             GPUVAddr split_address_, u64 big_page_bits_, u64 page_bits_)
+                             u64 page_bits_)
-    : MemoryManager(system_, system_.Host1x().MemoryManager(), address_space_bits_, split_address_,
+    : MemoryManager(system_, system_.Host1x().MemoryManager(), address_space_bits_, big_page_bits_,
-                    big_page_bits_, page_bits_) {}
+                    page_bits_) {}
 
 MemoryManager::~MemoryManager() = default;
 

src/video_core/memory_manager.h

@@ -36,11 +36,10 @@ namespace Tegra {
 class MemoryManager final {
 public:
     explicit MemoryManager(Core::System& system_, u64 address_space_bits_ = 40,
-                           GPUVAddr split_address = 1ULL << 34, u64 big_page_bits_ = 16,
-                           u64 page_bits_ = 12);
-    explicit MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_,
-                           u64 address_space_bits_ = 40, GPUVAddr split_address = 1ULL << 34,
                            u64 big_page_bits_ = 16, u64 page_bits_ = 12);
+    explicit MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_,
+                           u64 address_space_bits_ = 40, u64 big_page_bits_ = 16,
+                           u64 page_bits_ = 12);
     ~MemoryManager();
 
     static constexpr bool HAS_FLUSH_INVALIDATION = true;
@@ -195,7 +194,6 @@ private:
     MaxwellDeviceMemoryManager& memory;
 
     const u64 address_space_bits;
-    GPUVAddr split_address;
     const u64 page_bits;
     u64 address_space_size;
     u64 page_size;

src/web_service/web_backend.cpp

@@ -32,14 +32,9 @@ struct Client::Impl {
     Impl(std::string host_, std::string username_, std::string token_)
         : host{std::move(host_)}, username{std::move(username_)}, token{std::move(token_)} {
         std::scoped_lock lock{jwt_cache.mutex};
-        if (this->username == jwt_cache.username && this->token == jwt_cache.token) {
+        if (username == jwt_cache.username && token == jwt_cache.token) {
             jwt = jwt_cache.jwt;
         }
-
-        // Normalize host expression
-        if (!this->host.empty() && this->host.back() == '/') {
-            static_cast<void>(this->host.pop_back());
-        }
     }
 
     /// A generic function handles POST, GET and DELETE request together
@@ -76,16 +71,18 @@ struct Client::Impl {
                              const std::string& jwt_ = "", const std::string& username_ = "",
                              const std::string& token_ = "") {
         if (cli == nullptr) {
-            cli = std::make_unique<httplib::Client>(host.c_str());
+            cli = std::make_unique<httplib::Client>(host);
-            cli->set_connection_timeout(TIMEOUT_SECONDS);
-            cli->set_read_timeout(TIMEOUT_SECONDS);
-            cli->set_write_timeout(TIMEOUT_SECONDS);
         }
+
         if (!cli->is_valid()) {
-            LOG_ERROR(WebService, "Invalid URL {}", host + path);
+            LOG_ERROR(WebService, "Client is invalid, skipping request!");
-            return WebResult{WebResult::Code::InvalidURL, "Invalid URL", ""};
+            return {};
         }
 
+        cli->set_connection_timeout(TIMEOUT_SECONDS);
+        cli->set_read_timeout(TIMEOUT_SECONDS);
+        cli->set_write_timeout(TIMEOUT_SECONDS);
+
         httplib::Headers params;
         if (!jwt_.empty()) {
             params = {
@@ -110,15 +107,15 @@ struct Client::Impl {
         request.headers = params;
         request.body = data;
 
-        httplib::Result result = cli->send(request);
+        httplib::Response response;
+        httplib::Error error;
 
-        if (!result) {
+        if (!cli->send(request, response, error)) {
-            LOG_ERROR(WebService, "{} to {} returned null", method, host + path);
+            LOG_ERROR(WebService, "{} to {} returned null (httplib Error: {})", method, host + path,
+                      httplib::to_string(error));
             return WebResult{WebResult::Code::LibError, "Null response", ""};
         }
 
-        httplib::Response response = result.value();
-
         if (response.status >= 400) {
             LOG_ERROR(WebService, "{} to {} returned error status code: {}", method, host + path,
                       response.status);

src/yuzu/configuration/configure_hotkeys.cpp

@@ -45,23 +45,15 @@ ConfigureHotkeys::ConfigureHotkeys(Core::HID::HIDCore& hid_core, QWidget* parent
 
     controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);
 
-    connect(timeout_timer.get(), &QTimer::timeout, [this] {
+    connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); });
-        const bool is_button_pressed = pressed_buttons != Core::HID::NpadButton::None ||
-                                       pressed_home_button || pressed_capture_button;
-        SetPollingResult(!is_button_pressed);
-    });
 
     connect(poll_timer.get(), &QTimer::timeout, [this] {
-        pressed_buttons |= controller->GetNpadButtons().raw;
+        const auto buttons = controller->GetNpadButtons();
-        pressed_home_button |= this->controller->GetHomeButtons().home != 0;
+        const auto home_pressed = controller->GetHomeButtons().home != 0;
-        pressed_capture_button |= this->controller->GetCaptureButtons().capture != 0;
+        const auto capture_pressed = controller->GetCaptureButtons().capture != 0;
-        if (pressed_buttons != Core::HID::NpadButton::None || pressed_home_button ||
+        if (home_pressed || capture_pressed) {
-            pressed_capture_button) {
+            SetPollingResult(buttons.raw, false);
-            const QString button_name =
+            return;
-                GetButtonCombinationName(pressed_buttons, pressed_home_button,
-                                         pressed_capture_button) +
-                QStringLiteral("...");
-            model->setData(button_model_index, button_name);
         }
     });
     RetranslateUI();
@@ -162,14 +154,16 @@ void ConfigureHotkeys::ConfigureController(QModelIndex index) {
 
     const auto previous_key = model->data(index);
 
-    input_setter = [this, index, previous_key](const bool cancel) {
+    input_setter = [this, index, previous_key](const Core::HID::NpadButton button,
+                                               const bool cancel) {
         if (cancel) {
             model->setData(index, previous_key);
             return;
         }
-
+        const auto home_pressed = this->controller->GetHomeButtons().home != 0;
+        const auto capture_pressed = this->controller->GetCaptureButtons().capture != 0;
         const QString button_string =
-            GetButtonCombinationName(pressed_buttons, pressed_home_button, pressed_capture_button);
+            GetButtonCombinationName(button, home_pressed, capture_pressed);
 
         const auto [key_sequence_used, used_action] = IsUsedControllerKey(button_string);
 
@@ -183,22 +177,17 @@ void ConfigureHotkeys::ConfigureController(QModelIndex index) {
         }
     };
 
-    button_model_index = index;
-    pressed_buttons = Core::HID::NpadButton::None;
-    pressed_home_button = false;
-    pressed_capture_button = false;
-
     model->setData(index, tr("[waiting]"));
     timeout_timer->start(2500); // Cancel after 2.5 seconds
-    poll_timer->start(100);     // Check for new inputs every 100ms
+    poll_timer->start(200);     // Check for new inputs every 200ms
     // We need to disable configuration to be able to read npad buttons
     controller->DisableConfiguration();
 }
 
-void ConfigureHotkeys::SetPollingResult(const bool cancel) {
+void ConfigureHotkeys::SetPollingResult(Core::HID::NpadButton button, const bool cancel) {
     timeout_timer->stop();
     poll_timer->stop();
-    (*input_setter)(cancel);
+    (*input_setter)(button, cancel);
     // Re-Enable configuration
     controller->EnableConfiguration();
 

src/yuzu/configuration/configure_hotkeys.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include <memory>
-#include <QStandardItemModel>
 #include <QWidget>
 
 namespace Common {
@@ -55,20 +54,14 @@ private:
     void RestoreControllerHotkey(QModelIndex index);
     void RestoreHotkey(QModelIndex index);
 
-    void SetPollingResult(bool cancel);
-    QString GetButtonCombinationName(Core::HID::NpadButton button, bool home, bool capture) const;
-
     std::unique_ptr<Ui::ConfigureHotkeys> ui;
 
     QStandardItemModel* model;
 
-    bool pressed_home_button;
+    void SetPollingResult(Core::HID::NpadButton button, bool cancel);
-    bool pressed_capture_button;
+    QString GetButtonCombinationName(Core::HID::NpadButton button, bool home, bool capture) const;
-    QModelIndex button_model_index;
-    Core::HID::NpadButton pressed_buttons;
-
     Core::HID::EmulatedController* controller;
     std::unique_ptr<QTimer> timeout_timer;
     std::unique_ptr<QTimer> poll_timer;
-    std::optional<std::function<void(bool)>> input_setter;
+    std::optional<std::function<void(Core::HID::NpadButton, bool)>> input_setter;
 };

src/yuzu/configuration/configure_per_game.cpp

@@ -73,11 +73,8 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
     ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("Adv. Graphics"));
     ui->tabWidget->addTab(audio_tab.get(), tr("Audio"));
     ui->tabWidget->addTab(input_tab.get(), tr("Input Profiles"));
-
     // Only show Linux tab on Unix
-    linux_tab->setVisible(false);
 #ifdef __unix__
-    linux_tab->setVisible(true);
     ui->tabWidget->addTab(linux_tab.get(), tr("Linux"));
 #endif
 

src/yuzu/configuration/configure_ui.cpp

@@ -248,22 +248,82 @@ void ConfigureUi::RetranslateUI() {
 }
 
 void ConfigureUi::InitializeLanguageComboBox() {
+    // This is a list of lexicographically sorted languages, only the available translations are
+    // shown to the user.
+    static const struct {
+        const QString name;
+        const char* id;
+    } languages[] = {
+        // clang-format off
+        {QStringLiteral(u"Bahasa Indonesia"), "id"},                                 // Indonesian
+        {QStringLiteral(u"Bahasa Melayu"), "ms"},                                    // Malay
+        {QStringLiteral(u"Catal\u00E0"), "ca"},                                      // Catalan
+        {QStringLiteral(u"\u010Ce\u0161tina"), "cs"},                                // Czech
+        {QStringLiteral(u"Dansk"), "da"},                                            // Danish
+        {QStringLiteral(u"Deutsch"), "de"},                                          // German
+        {QStringLiteral(u"English"), "en"},                                          // English
+        {QStringLiteral(u"Espa\u00F1ol"), "es"},                                     // Spanish
+        {QStringLiteral(u"Fran\u00E7ais"), "fr"},                                    // French
+        {QStringLiteral(u"Hrvatski"), "hr"},                                         // Croatian
+        {QStringLiteral(u"Italiano"), "it"},                                         // Italian
+        {QStringLiteral(u"Magyar"), "hu"},                                           // Hungarian
+        {QStringLiteral(u"Nederlands"), "nl"},                                       // Dutch
+        {QStringLiteral(u"Norsk bokm\u00E5l"), "nb"},                                // Norwegian
+        {QStringLiteral(u"Polski"), "pl"},                                           // Polish
+        {QStringLiteral(u"Portugu\u00EAs"), "pt_PT"},                                // Portuguese
+        {QStringLiteral(u"Portugu\u00EAs (Brasil)"), "pt_BR"},                       // Portuguese (Brazil)
+        {QStringLiteral(u"Rom\u00E2n\u0103"), "ro"},                                 // Romanian
+        {QStringLiteral(u"Srpski"), "sr"},                                           // Serbian
+        {QStringLiteral(u"Suomi"), "fi"},                                            // Finnish
+        {QStringLiteral(u"Svenska"), "sv"},                                          // Swedish
+        {QStringLiteral(u"Ti\u1EBFng Vi\u1EC7t"), "vi"},                             // Vietnamese
+        {QStringLiteral(u"Ti\u1EBFng Vi\u1EC7t (Vi\u1EC7t Nam)"), "vi_VN"},          // Vietnamese
+        {QStringLiteral(u"T\u00FCrk\u00E7e"), "tr_TR"},                              // Turkish
+        {QStringLiteral(u"\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC"), "el"}, // Greek
+        {QStringLiteral(u"\u0420\u0443\u0441\u0441\u043A\u0438\u0439"), "ru_RU"},    // Russian
+        {QStringLiteral(u"\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430"),
+         "uk"},                                                                      // Ukrainian
+        {QStringLiteral(u"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"), "ar"},       // Arabic
+        {QStringLiteral(u"\u0641\u0627\u0631\u0633\u06CC"), "fa"},                   // Farsi
+        {QStringLiteral(u"\uD55C\uAD6D\uC5B4"), "ko_KR"},                            // Korean
+        {QStringLiteral(u"\u65E5\u672C\u8A9E"), "ja_JP"},                            // Japanese
+        {QStringLiteral(u"\u7B80\u4F53\u4E2D\u6587"), "zh_CN"},                      // Simplified Chinese
+        {QStringLiteral(u"\u7E41\u9AD4\u4E2D\u6587"), "zh_TW"},                      // Traditional Chinese
+        // clang-format on
+    };
     ui->language_combobox->addItem(tr("<System>"), QString{});
-    ui->language_combobox->addItem(tr("English"), QStringLiteral("en"));
+    QDir languages_dir{QStringLiteral(":/languages")};
-    QDirIterator it(QStringLiteral(":/languages"), QDirIterator::NoIteratorFlags);
+    QStringList language_files = languages_dir.entryList();
-    while (it.hasNext()) {
+    for (const auto& lang : languages) {
-        QString locale = it.next();
+        if (QString::fromLatin1(lang.id) == QStringLiteral("en")) {
+            ui->language_combobox->addItem(lang.name, QStringLiteral("en"));
+            language_files.removeOne(QStringLiteral("en.qm"));
+            continue;
+        }
+        for (int i = 0; i < language_files.size(); ++i) {
+            QString locale = language_files[i];
+            locale.truncate(locale.lastIndexOf(QLatin1Char{'.'}));
+            if (QString::fromLatin1(lang.id) == locale) {
+                ui->language_combobox->addItem(lang.name, locale);
+                language_files.removeAt(i);
+                break;
+            }
+        }
+    }
+    // Anything remaining will be at the bottom
+    for (const QString& file : language_files) {
+        LOG_CRITICAL(Frontend, "Unexpected Language File: {}", file.toStdString());
+        QString locale = file;
         locale.truncate(locale.lastIndexOf(QLatin1Char{'.'}));
-        locale.remove(0, locale.lastIndexOf(QLatin1Char{'/'}) + 1);
+        const QString language_name = QLocale::languageToString(QLocale(locale).language());
-        const QString lang = QLocale::languageToString(QLocale(locale).language());
+        const QString lang = QStringLiteral("%1 [%2]").arg(language_name, locale);
-        const QString country = QLocale::countryToString(QLocale(locale).country());
+        ui->language_combobox->addItem(lang, locale);
-        ui->language_combobox->addItem(QStringLiteral("%1 (%2)").arg(lang, country), locale);
     }
 
     // Unlike other configuration changes, interface language changes need to be reflected on the
     // interface immediately. This is done by passing a signal to the main window, and then
     // retranslating when passing back.
-    connect(ui->language_combobox, qOverload<int>(&QComboBox::currentIndexChanged), this,
+    connect(ui->language_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
             &ConfigureUi::OnLanguageChanged);
 }
 

src/yuzu/hotkeys.cpp

@@ -193,7 +193,8 @@ void ControllerShortcut::ControllerUpdateEvent(Core::HID::ControllerTriggerType
     if (!Settings::values.controller_navigation) {
         return;
     }
-    if (button_sequence.npad.raw == Core::HID::NpadButton::None) {
+    if (button_sequence.npad.raw == Core::HID::NpadButton::None &&
+        button_sequence.capture.raw == 0 && button_sequence.home.raw == 0) {
         return;
     }