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