Android 209

Demote dozen to the bottom of the device list

.reuse/dep5

@@ -155,3 +155,7 @@ License: MIT
 Files: externals/gamemode/*
 Copyright: Copyright 2017-2019 Feral Interactive
 License: BSD-3-Clause
+
+Files: src/android/app/debug.keystore
+Copyright: 2023 yuzu Emulator Project
+License: GPL-3.0-or-later

README.md

@@ -1,3 +1,18 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+| [12499](https://github.com/yuzu-emu/yuzu-android//pull/12499) | [`e4915fb7d`](https://github.com/yuzu-emu/yuzu-android//pull/12499/files) | Rework time services | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12749](https://github.com/yuzu-emu/yuzu-android//pull/12749) | [`e3171486d`](https://github.com/yuzu-emu/yuzu-android//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12759](https://github.com/yuzu-emu/yuzu-android//pull/12759) | [`a120f8ff4`](https://github.com/yuzu-emu/yuzu-android//pull/12759/files) | core: miscellaneous fixes | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12769](https://github.com/yuzu-emu/yuzu-android//pull/12769) | [`ad4622da2`](https://github.com/yuzu-emu/yuzu-android//pull/12769/files) | core: hid: Reduce controller requests | [german77](https://github.com/german77/) | Yes |
+| [12777](https://github.com/yuzu-emu/yuzu-android//pull/12777) | [`fb8c0f85f`](https://github.com/yuzu-emu/yuzu-android//pull/12777/files) | android: Add firmware decryption warning | [t895](https://github.com/t895/) | Yes |
+| [12786](https://github.com/yuzu-emu/yuzu-android//pull/12786) | [`5a4dd4ba8`](https://github.com/yuzu-emu/yuzu-android//pull/12786/files) | android: Show driver vendor in FPS overlay | [t895](https://github.com/t895/) | Yes |
+| [12787](https://github.com/yuzu-emu/yuzu-android//pull/12787) | [`7b01454d5`](https://github.com/yuzu-emu/yuzu-android//pull/12787/files) | android: Only compare game contents for GameAdapter | [t895](https://github.com/t895/) | Yes |
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

externals/CMakeLists.txt

@@ -178,6 +178,9 @@ if (NOT TARGET stb::headers)
     add_library(stb::headers ALIAS stb)
 endif()
 
+add_library(tz tz/tz/tz.cpp)
+target_include_directories(tz PUBLIC ./tz)
+
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)
 

externals/tz/tz/tz.h

@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: 1996 Arthur David Olson
+// SPDX-License-Identifier: BSD-2-Clause
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <array>
+#include <time.h>
+
+namespace Tz {
+using u8 = uint8_t;
+using s8 = int8_t;
+using u16 = uint16_t;
+using s16 = int16_t;
+using u32 = uint32_t;
+using s32 = int32_t;
+using u64 = uint64_t;
+using s64 = int64_t;
+
+constexpr size_t TZ_MAX_TIMES = 1000;
+constexpr size_t TZ_MAX_TYPES = 128;
+constexpr size_t TZ_MAX_CHARS = 50;
+constexpr size_t MY_TZNAME_MAX = 255;
+constexpr size_t TZNAME_MAXIMUM = 255;
+constexpr size_t TZ_MAX_LEAPS = 50;
+constexpr s64 TIME_T_MAX = std::numeric_limits<s64>::max();
+constexpr s64 TIME_T_MIN = std::numeric_limits<s64>::min();
+constexpr size_t CHARS_EXTRA = 3;
+constexpr size_t MAX_ZONE_CHARS = std::max(TZ_MAX_CHARS + CHARS_EXTRA, sizeof("UTC"));
+constexpr size_t MAX_TZNAME_CHARS = 2 * (MY_TZNAME_MAX + 1);
+
+struct ttinfo {
+    s32 tt_utoff;
+    bool tt_isdst;
+    s32 tt_desigidx;
+    bool tt_ttisstd;
+    bool tt_ttisut;
+};
+static_assert(sizeof(ttinfo) == 0x10, "ttinfo has the wrong size!");
+
+struct Rule {
+    s32 timecnt;
+    s32 typecnt;
+    s32 charcnt;
+    bool goback;
+    bool goahead;
+    std::array <u8, 0x2> padding0;
+    std::array<s64, TZ_MAX_TIMES> ats;
+    std::array<u8, TZ_MAX_TIMES> types;
+    std::array<ttinfo, TZ_MAX_TYPES> ttis;
+    std::array<char, std::max(MAX_ZONE_CHARS, MAX_TZNAME_CHARS)> chars;
+    s32 defaulttype;
+    std::array <u8, 0x12C4> padding1;
+};
+static_assert(sizeof(Rule) == 0x4000, "Rule has the wrong size!");
+
+struct CalendarTimeInternal {
+    s32 tm_sec;
+    s32 tm_min;
+    s32 tm_hour;
+    s32 tm_mday;
+    s32 tm_mon;
+    s32 tm_year;
+    s32 tm_wday;
+    s32 tm_yday;
+    s32 tm_isdst;
+    std::array<char, 16> tm_zone;
+    s32 tm_utoff;
+    s32 time_index;
+};
+static_assert(sizeof(CalendarTimeInternal) == 0x3C, "CalendarTimeInternal has the wrong size!");
+
+s32 ParseTimeZoneBinary(Rule& out_rule, std::span<const u8> binary);
+
+bool localtime_rz(CalendarTimeInternal* tmp, Rule* sp, time_t* timep);
+u32 mktime_tzname(time_t* out_time, Rule* sp, CalendarTimeInternal* tmp);
+
+} // namespace Tz

src/android/app/build.gradle.kts

@@ -82,8 +82,8 @@ android {
     }
 
     val keystoreFile = System.getenv("ANDROID_KEYSTORE_FILE")
-    if (keystoreFile != null) {
+    signingConfigs {
-        signingConfigs {
+        if (keystoreFile != null) {
             create("release") {
                 storeFile = file(keystoreFile)
                 storePassword = System.getenv("ANDROID_KEYSTORE_PASS")
@@ -91,6 +91,12 @@ android {
                 keyPassword = System.getenv("ANDROID_KEYSTORE_PASS")
             }
         }
+        create("default") {
+            storeFile = file("$projectDir/debug.keystore")
+            storePassword = "android"
+            keyAlias = "androiddebugkey"
+            keyPassword = "android"
+        }
     }
 
     // Define build types, which are orthogonal to product flavors.
@@ -101,7 +107,7 @@ android {
             signingConfig = if (keystoreFile != null) {
                 signingConfigs.getByName("release")
             } else {
-                signingConfigs.getByName("debug")
+                signingConfigs.getByName("default")
             }
 
             resValue("string", "app_name_suffixed", "yuzu")
@@ -118,7 +124,7 @@ android {
         register("relWithDebInfo") {
             isDefault = true
             resValue("string", "app_name_suffixed", "yuzu Debug Release")
-            signingConfig = signingConfigs.getByName("debug")
+            signingConfig = signingConfigs.getByName("default")
             isMinifyEnabled = true
             isDebuggable = true
             proguardFiles(
@@ -133,6 +139,7 @@ android {
         // Signed by debug key disallowing distribution on Play Store.
         // Attaches 'debug' suffix to version and package name, allowing installation alongside the release build.
         debug {
+            signingConfig = signingConfigs.getByName("default")
             resValue("string", "app_name_suffixed", "yuzu Debug")
             isDebuggable = true
             isJniDebuggable = true

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

@@ -23,6 +23,7 @@ import org.yuzu.yuzu_emu.utils.Log
 import org.yuzu.yuzu_emu.utils.SerializableHelper.serializable
 import org.yuzu.yuzu_emu.model.InstallResult
 import org.yuzu.yuzu_emu.model.Patch
+import org.yuzu.yuzu_emu.model.GameVerificationResult
 
 /**
  * Class which contains methods that interact
@@ -302,6 +303,11 @@ object NativeLibrary {
      */
     external fun getCpuBackend(): String
 
+    /**
+     * Returns the current GPU Driver.
+     */
+    external fun getGpuDriver(): String
+
     external fun applySettings()
 
     external fun logSettings()
@@ -564,6 +570,26 @@ object NativeLibrary {
      */
     external fun removeMod(programId: String, name: String)
 
+    /**
+     * Verifies all installed content
+     * @param callback UI callback for verification progress. Return true in the callback to cancel.
+     * @return Array of content that failed verification. Successful if empty.
+     */
+    external fun verifyInstalledContents(
+        callback: (max: Long, progress: Long) -> Boolean
+    ): Array<String>
+
+    /**
+     * Verifies the contents of a game
+     * @param path String path to a game
+     * @param callback UI callback for verification progress. Return true in the callback to cancel.
+     * @return Int that is meant to be converted to a [GameVerificationResult]
+     */
+    external fun verifyGameContents(
+        path: String,
+        callback: (max: Long, progress: Long) -> Boolean
+    ): Int
+
     /**
      * Gets the save location for a specific game
      *
@@ -593,6 +619,16 @@ object NativeLibrary {
      */
     external fun clearFilesystemProvider()
 
+    /**
+     * Checks if all necessary keys are present for decryption
+     */
+    external fun areKeysPresent(): Boolean
+
+    /**
+     * Check if the system firmware can be decrypted by checking the Mii model system archive
+     */
+    external fun canDecryptSystemArchive(): Boolean
+
     /**
      * Button type for use in onTouchEvent
      */

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/AbstractDiffAdapter.kt

@@ -14,15 +14,20 @@ import androidx.recyclerview.widget.RecyclerView
  * Generic adapter that implements an [AsyncDifferConfig] and covers some of the basic boilerplate
  * code used in every [RecyclerView].
  * Type assigned to [Model] must inherit from [Object] in order to be compared properly.
+ * @param exact Decides whether each item will be compared by reference or by their contents
  */
-abstract class AbstractDiffAdapter<Model : Any, Holder : AbstractViewHolder<Model>> :
+abstract class AbstractDiffAdapter<Model : Any, Holder : AbstractViewHolder<Model>>(
-    ListAdapter<Model, Holder>(AsyncDifferConfig.Builder(DiffCallback<Model>()).build()) {
+    exact: Boolean = true
+) : ListAdapter<Model, Holder>(AsyncDifferConfig.Builder(DiffCallback<Model>(exact)).build()) {
     override fun onBindViewHolder(holder: Holder, position: Int) =
         holder.bind(currentList[position])
 
-    private class DiffCallback<Model> : DiffUtil.ItemCallback<Model>() {
+    private class DiffCallback<Model>(val exact: Boolean) : DiffUtil.ItemCallback<Model>() {
         override fun areItemsTheSame(oldItem: Model & Any, newItem: Model & Any): Boolean {
-            return oldItem === newItem
+            if (exact) {
+                return oldItem === newItem
+            }
+            return oldItem == newItem
         }
 
         @SuppressLint("DiffUtilEquals")

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt

@@ -3,9 +3,6 @@
 
 package org.yuzu.yuzu_emu.adapters
 
-import android.content.Intent
-import android.graphics.Bitmap
-import android.graphics.drawable.LayerDrawable
 import android.net.Uri
 import android.text.TextUtils
 import android.view.LayoutInflater
@@ -15,10 +12,6 @@ import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
-import androidx.core.content.res.ResourcesCompat
-import androidx.core.graphics.drawable.IconCompat
-import androidx.core.graphics.drawable.toBitmap
-import androidx.core.graphics.drawable.toDrawable
 import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.lifecycleScope
@@ -30,7 +23,6 @@ import kotlinx.coroutines.withContext
 import org.yuzu.yuzu_emu.HomeNavigationDirections
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
-import org.yuzu.yuzu_emu.activities.EmulationActivity
 import org.yuzu.yuzu_emu.databinding.CardGameBinding
 import org.yuzu.yuzu_emu.model.Game
 import org.yuzu.yuzu_emu.model.GamesViewModel
@@ -38,7 +30,7 @@ import org.yuzu.yuzu_emu.utils.GameIconUtils
 import org.yuzu.yuzu_emu.viewholder.AbstractViewHolder
 
 class GameAdapter(private val activity: AppCompatActivity) :
-    AbstractDiffAdapter<Game, GameAdapter.GameViewHolder>() {
+    AbstractDiffAdapter<Game, GameAdapter.GameViewHolder>(exact = false) {
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GameViewHolder {
         CardGameBinding.inflate(LayoutInflater.from(parent.context), parent, false)
             .also { return GameViewHolder(it) }
@@ -89,36 +81,13 @@ class GameAdapter(private val activity: AppCompatActivity) :
                 )
                 .apply()
 
-            val openIntent =
-                Intent(YuzuApplication.appContext, EmulationActivity::class.java).apply {
-                    action = Intent.ACTION_VIEW
-                    data = Uri.parse(game.path)
-                }
-
             activity.lifecycleScope.launch {
                 withContext(Dispatchers.IO) {
-                    val layerDrawable = ResourcesCompat.getDrawable(
-                        YuzuApplication.appContext.resources,
-                        R.drawable.shortcut,
-                        null
-                    ) as LayerDrawable
-                    layerDrawable.setDrawableByLayerId(
-                        R.id.shortcut_foreground,
-                        GameIconUtils.getGameIcon(activity, game)
-                            .toDrawable(YuzuApplication.appContext.resources)
-                    )
-                    val inset = YuzuApplication.appContext.resources
-                        .getDimensionPixelSize(R.dimen.icon_inset)
-                    layerDrawable.setLayerInset(1, inset, inset, inset, inset)
                     val shortcut =
                         ShortcutInfoCompat.Builder(YuzuApplication.appContext, game.path)
                             .setShortLabel(game.title)
-                            .setIcon(
+                            .setIcon(GameIconUtils.getShortcutIcon(activity, game))
-                                IconCompat.createWithAdaptiveBitmap(
+                            .setIntent(game.launchIntent)
-                                    layerDrawable.toBitmap(config = Bitmap.Config.ARGB_8888)
-                                )
-                            )
-                            .setIntent(openIntent)
                             .build()
                     ShortcutManagerCompat.pushDynamicShortcut(YuzuApplication.appContext, shortcut)
                 }

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

@@ -23,7 +23,8 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     THEME("theme"),
     THEME_MODE("theme_mode"),
     OVERLAY_SCALE("control_scale"),
-    OVERLAY_OPACITY("control_opacity");
+    OVERLAY_OPACITY("control_opacity"),
+    LOCK_DRAWER("lock_drawer");
 
     override fun getInt(needsGlobal: Boolean): Int = NativeConfig.getInt(key, needsGlobal)
 

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

@@ -38,7 +38,6 @@ import androidx.window.layout.WindowLayoutInfo
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.slider.Slider
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.HomeNavigationDirections
@@ -141,7 +140,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
         // So this fragment doesn't restart on configuration changes; i.e. rotation.
         retainInstance = true
-        emulationState = EmulationState(game.path)
+        emulationState = EmulationState(game.path) {
+            return@EmulationState driverViewModel.isInteractionAllowed.value
+        }
     }
 
     /**
@@ -182,11 +183,11 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
 
             override fun onDrawerOpened(drawerView: View) {
-                // No op
+                binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
             }
 
             override fun onDrawerClosed(drawerView: View) {
-                // No op
+                binding.drawerLayout.setDrawerLockMode(IntSetting.LOCK_DRAWER.getInt())
             }
 
             override fun onDrawerStateChanged(newState: Int) {
@@ -196,6 +197,28 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
         binding.inGameMenu.getHeaderView(0).findViewById<TextView>(R.id.text_game_title).text =
             game.title
+
+        binding.inGameMenu.menu.findItem(R.id.menu_lock_drawer).apply {
+            val lockMode = IntSetting.LOCK_DRAWER.getInt()
+            val titleId = if (lockMode == DrawerLayout.LOCK_MODE_LOCKED_CLOSED) {
+                R.string.unlock_drawer
+            } else {
+                R.string.lock_drawer
+            }
+            val iconId = if (lockMode == DrawerLayout.LOCK_MODE_UNLOCKED) {
+                R.drawable.ic_unlock
+            } else {
+                R.drawable.ic_lock
+            }
+
+            title = getString(titleId)
+            icon = ResourcesCompat.getDrawable(
+                resources,
+                iconId,
+                requireContext().theme
+            )
+        }
+
         binding.inGameMenu.setNavigationItemSelectedListener {
             when (it.itemId) {
                 R.id.menu_pause_emulation -> {
@@ -242,6 +265,32 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     true
                 }
 
+                R.id.menu_lock_drawer -> {
+                    when (IntSetting.LOCK_DRAWER.getInt()) {
+                        DrawerLayout.LOCK_MODE_UNLOCKED -> {
+                            IntSetting.LOCK_DRAWER.setInt(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
+                            it.title = resources.getString(R.string.unlock_drawer)
+                            it.icon = ResourcesCompat.getDrawable(
+                                resources,
+                                R.drawable.ic_lock,
+                                requireContext().theme
+                            )
+                        }
+
+                        DrawerLayout.LOCK_MODE_LOCKED_CLOSED -> {
+                            IntSetting.LOCK_DRAWER.setInt(DrawerLayout.LOCK_MODE_UNLOCKED)
+                            it.title = resources.getString(R.string.lock_drawer)
+                            it.icon = ResourcesCompat.getDrawable(
+                                resources,
+                                R.drawable.ic_unlock,
+                                requireContext().theme
+                            )
+                        }
+                    }
+                    NativeConfig.saveGlobalConfig()
+                    true
+                }
+
                 R.id.menu_exit -> {
                     emulationState.stop()
                     emulationViewModel.setIsEmulationStopping(true)
@@ -322,11 +371,20 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     }
                 }
             }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                    driverViewModel.isInteractionAllowed.collect {
+                        if (it) {
+                            startEmulation()
+                        }
+                    }
+                }
+            }
             launch {
                 repeatOnLifecycle(Lifecycle.State.CREATED) {
                     emulationViewModel.emulationStarted.collectLatest {
                         if (it) {
-                            binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
+                            binding.drawerLayout.setDrawerLockMode(IntSetting.LOCK_DRAWER.getInt())
                             ViewUtils.showView(binding.surfaceInputOverlay)
                             ViewUtils.hideView(binding.loadingIndicator)
 
@@ -350,19 +408,10 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     }
                 }
             }
-            launch {
-                repeatOnLifecycle(Lifecycle.State.RESUMED) {
-                    driverViewModel.isInteractionAllowed.collect {
-                        if (it) {
-                            onEmulationStart()
-                        }
-                    }
-                }
-            }
         }
     }
 
-    private fun onEmulationStart() {
+    private fun startEmulation() {
         if (!NativeLibrary.isRunning() && !NativeLibrary.isPaused()) {
             if (!DirectoryInitialization.areDirectoriesReady) {
                 DirectoryInitialization.start()
@@ -437,12 +486,20 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             val FRAMETIME = 2
             val SPEED = 3
             perfStatsUpdater = {
-                if (emulationViewModel.emulationStarted.value) {
+                if (emulationViewModel.emulationStarted.value &&
+                    !emulationViewModel.isEmulationStopping.value
+                ) {
                     val perfStats = NativeLibrary.getPerfStats()
                     val cpuBackend = NativeLibrary.getCpuBackend()
+                    val gpuDriver = NativeLibrary.getGpuDriver()
                     if (_binding != null) {
                         binding.showFpsText.text =
-                            String.format("FPS: %.1f\n%s", perfStats[FPS], cpuBackend)
+                            String.format(
+                                "FPS: %.1f\n%s - %s",
+                                perfStats[FPS],
+                                cpuBackend,
+                                gpuDriver
+                            )
                     }
                     perfStatsUpdateHandler.postDelayed(perfStatsUpdater!!, 800)
                 }
@@ -759,7 +816,10 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
     }
 
-    private class EmulationState(private val gamePath: String) {
+    private class EmulationState(
+        private val gamePath: String,
+        private val emulationCanStart: () -> Boolean
+    ) {
         private var state: State
         private var surface: Surface? = null
 
@@ -853,6 +913,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     State.PAUSED -> Log.warning(
                         "[EmulationFragment] Surface cleared while emulation paused."
                     )
+
                     else -> Log.warning(
                         "[EmulationFragment] Surface cleared while emulation stopped."
                     )
@@ -862,6 +923,10 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
         private fun runWithValidSurface() {
             NativeLibrary.surfaceChanged(surface)
+            if (!emulationCanStart.invoke()) {
+                return
+            }
+
             when (state) {
                 State.STOPPED -> {
                     val emulationThread = Thread({

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

@@ -21,8 +21,10 @@ import androidx.fragment.app.activityViewModels
 import androidx.navigation.findNavController
 import androidx.navigation.fragment.navArgs
 import com.google.android.material.transition.MaterialSharedAxis
+import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.FragmentGameInfoBinding
+import org.yuzu.yuzu_emu.model.GameVerificationResult
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.utils.GameMetadata
 
@@ -101,6 +103,38 @@ class GameInfoFragment : Fragment() {
                 """.trimIndent()
                 copyToClipboard(args.game.title, details)
             }
+
+            buttonVerifyIntegrity.setOnClickListener {
+                ProgressDialogFragment.newInstance(
+                    requireActivity(),
+                    R.string.verifying,
+                    true
+                ) { progressCallback, _ ->
+                    val result = GameVerificationResult.from(
+                        NativeLibrary.verifyGameContents(
+                            args.game.path,
+                            progressCallback
+                        )
+                    )
+                    return@newInstance when (result) {
+                        GameVerificationResult.Success ->
+                            MessageDialogFragment.newInstance(
+                                titleId = R.string.verify_success,
+                                descriptionId = R.string.operation_completed_successfully
+                            )
+                        GameVerificationResult.Failed ->
+                            MessageDialogFragment.newInstance(
+                                titleId = R.string.verify_failure,
+                                descriptionId = R.string.verify_failure_description
+                            )
+                        GameVerificationResult.NotImplemented ->
+                            MessageDialogFragment.newInstance(
+                                titleId = R.string.verify_no_result,
+                                descriptionId = R.string.verify_no_result_description
+                            )
+                    }
+                }.show(parentFragmentManager, ProgressDialogFragment.TAG)
+            }
         }
 
         setInsets()

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

@@ -4,6 +4,8 @@
 package org.yuzu.yuzu_emu.fragments
 
 import android.annotation.SuppressLint
+import android.content.pm.ShortcutInfo
+import android.content.pm.ShortcutManager
 import android.os.Bundle
 import android.text.TextUtils
 import android.view.LayoutInflater
@@ -84,6 +86,24 @@ class GamePropertiesFragment : Fragment() {
             view.findNavController().popBackStack()
         }
 
+        val shortcutManager = requireActivity().getSystemService(ShortcutManager::class.java)
+        binding.buttonShortcut.isEnabled = shortcutManager.isRequestPinShortcutSupported
+        binding.buttonShortcut.setOnClickListener {
+            viewLifecycleOwner.lifecycleScope.launch {
+                withContext(Dispatchers.IO) {
+                    val shortcut = ShortcutInfo.Builder(requireContext(), args.game.title)
+                        .setShortLabel(args.game.title)
+                        .setIcon(
+                            GameIconUtils.getShortcutIcon(requireActivity(), args.game)
+                                .toIcon(requireContext())
+                        )
+                        .setIntent(args.game.launchIntent)
+                        .build()
+                    shortcutManager.requestPinShortcut(shortcut, null)
+                }
+            }
+        }
+
         GameIconUtils.loadGameIcon(args.game, binding.imageGameScreen)
         binding.title.text = args.game.title
         binding.title.postDelayed(

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

@@ -32,6 +32,7 @@ import org.yuzu.yuzu_emu.BuildConfig
 import org.yuzu.yuzu_emu.HomeNavigationDirections
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.adapters.HomeSettingAdapter
 import org.yuzu.yuzu_emu.databinding.FragmentHomeSettingsBinding
 import org.yuzu.yuzu_emu.features.DocumentProvider
@@ -140,6 +141,38 @@ class HomeSettingsFragment : Fragment() {
                     }
                 )
             )
+            add(
+                HomeSetting(
+                    R.string.verify_installed_content,
+                    R.string.verify_installed_content_description,
+                    R.drawable.ic_check_circle,
+                    {
+                        ProgressDialogFragment.newInstance(
+                            requireActivity(),
+                            titleId = R.string.verifying,
+                            cancellable = true
+                        ) { progressCallback, _ ->
+                            val result = NativeLibrary.verifyInstalledContents(progressCallback)
+                            return@newInstance if (result.isEmpty()) {
+                                MessageDialogFragment.newInstance(
+                                    titleId = R.string.verify_success,
+                                    descriptionId = R.string.operation_completed_successfully
+                                )
+                            } else {
+                                val failedNames = result.joinToString("\n")
+                                val errorMessage = YuzuApplication.appContext.getString(
+                                    R.string.verification_failed_for,
+                                    failedNames
+                                )
+                                MessageDialogFragment.newInstance(
+                                    titleId = R.string.verify_failure,
+                                    descriptionString = errorMessage
+                                )
+                            }
+                        }.show(parentFragmentManager, ProgressDialogFragment.TAG)
+                    }
+                )
+            )
             add(
                 HomeSetting(
                     R.string.share_log,

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

@@ -26,9 +26,15 @@ class MessageDialogFragment : DialogFragment() {
         val descriptionId = requireArguments().getInt(DESCRIPTION_ID)
         val descriptionString = requireArguments().getString(DESCRIPTION_STRING)!!
         val helpLinkId = requireArguments().getInt(HELP_LINK)
+        val dismissible = requireArguments().getBoolean(DISMISSIBLE)
+        val clearPositiveAction = requireArguments().getBoolean(CLEAR_POSITIVE_ACTION)
 
         val builder = MaterialAlertDialogBuilder(requireContext())
 
+        if (clearPositiveAction) {
+            messageDialogViewModel.positiveAction = null
+        }
+
         if (messageDialogViewModel.positiveAction == null) {
             builder.setPositiveButton(R.string.close, null)
         } else {
@@ -51,6 +57,8 @@ class MessageDialogFragment : DialogFragment() {
             }
         }
 
+        isCancelable = dismissible
+
         return builder.show()
     }
 
@@ -67,28 +75,38 @@ class MessageDialogFragment : DialogFragment() {
         private const val DESCRIPTION_ID = "DescriptionId"
         private const val DESCRIPTION_STRING = "DescriptionString"
         private const val HELP_LINK = "Link"
+        private const val DISMISSIBLE = "Dismissible"
+        private const val CLEAR_POSITIVE_ACTION = "ClearPositiveAction"
 
         fun newInstance(
-            activity: FragmentActivity,
+            activity: FragmentActivity? = null,
             titleId: Int = 0,
             titleString: String = "",
             descriptionId: Int = 0,
             descriptionString: String = "",
             helpLinkId: Int = 0,
+            dismissible: Boolean = true,
             positiveAction: (() -> Unit)? = null
         ): MessageDialogFragment {
+            var clearPositiveAction = false
+            if (activity != null) {
+                ViewModelProvider(activity)[MessageDialogViewModel::class.java].apply {
+                    clear()
+                    this.positiveAction = positiveAction
+                }
+            } else {
+                clearPositiveAction = true
+            }
+
             val dialog = MessageDialogFragment()
-            val bundle = Bundle()
+            val bundle = Bundle().apply {
-            bundle.apply {
                 putInt(TITLE_ID, titleId)
                 putString(TITLE_STRING, titleString)
                 putInt(DESCRIPTION_ID, descriptionId)
                 putString(DESCRIPTION_STRING, descriptionString)
                 putInt(HELP_LINK, helpLinkId)
-            }
+                putBoolean(DISMISSIBLE, dismissible)
-            ViewModelProvider(activity)[MessageDialogViewModel::class.java].apply {
+                putBoolean(CLEAR_POSITIVE_ACTION, clearPositiveAction)
-                clear()
-                this.positiveAction = positiveAction
             }
             dialog.arguments = bundle
             return dialog

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

@@ -144,6 +144,7 @@ class DriverViewModel : ViewModel() {
         val selectedDriverFile = File(StringSetting.DRIVER_PATH.getString())
         val selectedDriverMetadata = GpuDriverHelper.customDriverSettingData
         if (GpuDriverHelper.installedCustomDriverData == selectedDriverMetadata) {
+            setDriverReady()
             return
         }
 

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

@@ -3,6 +3,7 @@
 
 package org.yuzu.yuzu_emu.model
 
+import android.content.Intent
 import android.net.Uri
 import android.os.Parcelable
 import java.util.HashSet
@@ -11,6 +12,7 @@ import kotlinx.serialization.Serializable
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
+import org.yuzu.yuzu_emu.activities.EmulationActivity
 import org.yuzu.yuzu_emu.utils.DirectoryInitialization
 import org.yuzu.yuzu_emu.utils.FileUtil
 import java.time.LocalDateTime
@@ -61,12 +63,26 @@ class Game(
     val addonDir: String
         get() = DirectoryInitialization.userDirectory + "/load/" + programIdHex + "/"
 
-    override fun equals(other: Any?): Boolean {
+    val launchIntent: Intent
-        if (other !is Game) {
+        get() = Intent(YuzuApplication.appContext, EmulationActivity::class.java).apply {
-            return false
+            action = Intent.ACTION_VIEW
+            data = Uri.parse(path)
         }
 
-        return hashCode() == other.hashCode()
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Game
+
+        if (title != other.title) return false
+        if (path != other.path) return false
+        if (programId != other.programId) return false
+        if (developer != other.developer) return false
+        if (version != other.version) return false
+        if (isHomebrew != other.isHomebrew) return false
+
+        return true
     }
 
     override fun hashCode(): Int {

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

@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package org.yuzu.yuzu_emu.model
+
+enum class GameVerificationResult(val int: Int) {
+    Success(0),
+    Failed(1),
+    NotImplemented(2);
+
+    companion object {
+        fun from(int: Int): GameVerificationResult =
+            entries.firstOrNull { it.int == int } ?: Success
+    }
+}

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

@@ -31,6 +31,12 @@ class HomeViewModel : ViewModel() {
     private val _reloadPropertiesList = MutableStateFlow(false)
     val reloadPropertiesList get() = _reloadPropertiesList.asStateFlow()
 
+    private val _checkKeys = MutableStateFlow(false)
+    val checkKeys = _checkKeys.asStateFlow()
+
+    private val _checkDecryption = MutableStateFlow(false)
+    val checkDecryption = _checkDecryption.asStateFlow()
+
     var navigatedToSetup = false
 
     fun setNavigationVisibility(visible: Boolean, animated: Boolean) {
@@ -66,4 +72,12 @@ class HomeViewModel : ViewModel() {
     fun reloadPropertiesList(reload: Boolean) {
         _reloadPropertiesList.value = reload
     }
+
+    fun setCheckKeys(value: Boolean) {
+        _checkKeys.value = value
+    }
+
+    fun setCheckDecryption(value: Boolean) {
+        _checkDecryption.value = value
+    }
 }

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

@@ -64,6 +64,9 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
     override var themeId: Int = 0
 
+    private val CHECKED_DECRYPTION = "CheckedDecryption"
+    private var checkedDecryption = false
+
     override fun onCreate(savedInstanceState: Bundle?) {
         val splashScreen = installSplashScreen()
         splashScreen.setKeepOnScreenCondition { !DirectoryInitialization.areDirectoriesReady }
@@ -75,6 +78,14 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
         binding = ActivityMainBinding.inflate(layoutInflater)
         setContentView(binding.root)
 
+        if (savedInstanceState != null) {
+            checkedDecryption = savedInstanceState.getBoolean(CHECKED_DECRYPTION)
+        }
+        if (!checkedDecryption) {
+            checkKeys()
+            checkedDecryption = true
+        }
+
         WindowCompat.setDecorFitsSystemWindows(window, false)
         window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
 
@@ -150,6 +161,26 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     }
                 }
             }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    homeViewModel.checkKeys.collect {
+                        if (it) {
+                            checkKeys()
+                            homeViewModel.setCheckKeys(false)
+                        }
+                    }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    homeViewModel.checkDecryption.collect {
+                        if (it) {
+                            checkDecryption()
+                            homeViewModel.setCheckDecryption(false)
+                        }
+                    }
+                }
+            }
         }
 
         // Dismiss previous notifications (should not happen unless a crash occurred)
@@ -158,6 +189,35 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
         setInsets()
     }
 
+    private fun checkKeys() {
+        if (!NativeLibrary.areKeysPresent()) {
+            MessageDialogFragment.newInstance(
+                titleId = R.string.keys_missing,
+                descriptionId = R.string.keys_missing_description,
+                helpLinkId = R.string.keys_missing_help,
+                dismissible = false,
+                positiveAction = { homeViewModel.setCheckDecryption(true) }
+            ).show(supportFragmentManager, MessageDialogFragment.TAG)
+        } else {
+            checkDecryption()
+        }
+    }
+
+    private fun checkDecryption() {
+        if (!NativeLibrary.canDecryptSystemArchive()) {
+            MessageDialogFragment.newInstance(
+                titleId = R.string.decryption_failed,
+                descriptionId = R.string.decryption_failed_description,
+                helpLinkId = R.string.keys_missing_help
+            ).show(supportFragmentManager, MessageDialogFragment.TAG)
+        }
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        outState.putBoolean(CHECKED_DECRYPTION, checkedDecryption)
+    }
+
     fun finishSetup(navController: NavController) {
         navController.navigate(R.id.action_firstTimeSetupFragment_to_gamesFragment)
         (binding.navigationView as NavigationBarView).setupWithNavController(navController)
@@ -349,6 +409,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     R.string.install_keys_success,
                     Toast.LENGTH_SHORT
                 ).show()
+                homeViewModel.setCheckKeys(true)
                 gamesViewModel.reloadGames(true)
                 return true
             } else {
@@ -399,6 +460,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                         firmwarePath.deleteRecursively()
                         cacheFirmwareDir.copyRecursively(firmwarePath, true)
                         NativeLibrary.initializeSystem(true)
+                        homeViewModel.setCheckKeys(true)
                         getString(R.string.save_file_imported_success)
                     }
                 } catch (e: Exception) {

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

@@ -5,7 +5,10 @@ package org.yuzu.yuzu_emu.utils
 
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.graphics.drawable.LayerDrawable
 import android.widget.ImageView
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.graphics.drawable.IconCompat
 import androidx.core.graphics.drawable.toBitmap
 import androidx.core.graphics.drawable.toDrawable
 import androidx.lifecycle.LifecycleOwner
@@ -85,4 +88,22 @@ object GameIconUtils {
         return imageLoader.execute(request)
             .drawable!!.toBitmap(config = Bitmap.Config.ARGB_8888)
     }
+
+    suspend fun getShortcutIcon(lifecycleOwner: LifecycleOwner, game: Game): IconCompat {
+        val layerDrawable = ResourcesCompat.getDrawable(
+            YuzuApplication.appContext.resources,
+            R.drawable.shortcut,
+            null
+        ) as LayerDrawable
+        layerDrawable.setDrawableByLayerId(
+            R.id.shortcut_foreground,
+            getGameIcon(lifecycleOwner, game).toDrawable(YuzuApplication.appContext.resources)
+        )
+        val inset = YuzuApplication.appContext.resources
+            .getDimensionPixelSize(R.dimen.icon_inset)
+        layerDrawable.setLayerInset(1, inset, inset, inset, inset)
+        return IconCompat.createWithAdaptiveBitmap(
+            layerDrawable.toBitmap(config = Bitmap.Config.ARGB_8888)
+        )
+    }
 }

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

@@ -63,6 +63,7 @@ struct Values {
     Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay",
                                                Settings::Category::Overlay};
     Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Category::Overlay};
+    Settings::Setting<s32> lock_drawer{linkage, false, "lock_drawer", Settings::Category::Overlay};
 };
 
 extern Values values;

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

@@ -247,6 +247,7 @@ Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string
     m_system.GetCpuManager().OnGpuReady();
     m_system.RegisterExitCallback([&] { HaltEmulation(); });
 
+    OnEmulationStarted();
     return Core::SystemResultStatus::Success;
 }
 
@@ -463,8 +464,8 @@ int Java_org_yuzu_yuzu_1emu_NativeLibrary_installFileToNand(JNIEnv* env, jobject
     };
 
     return static_cast<int>(
-        ContentManager::InstallNSP(&EmulationSession::GetInstance().System(),
+        ContentManager::InstallNSP(EmulationSession::GetInstance().System(),
-                                   EmulationSession::GetInstance().System().GetFilesystem().get(),
+                                   *EmulationSession::GetInstance().System().GetFilesystem(),
                                    GetJString(env, j_file), callback));
 }
 
@@ -674,6 +675,11 @@ jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getCpuBackend(JNIEnv* env, jclass
     return ToJString(env, "JIT");
 }
 
+jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getGpuDriver(JNIEnv* env, jobject jobj) {
+    return ToJString(env,
+                     EmulationSession::GetInstance().System().GPU().Renderer().GetDeviceVendor());
+}
+
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_applySettings(JNIEnv* env, jobject jobj) {
     EmulationSession::GetInstance().System().ApplySettings();
 }
@@ -819,7 +825,7 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_removeUpdate(JNIEnv* env, jobject job
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_removeDLC(JNIEnv* env, jobject jobj,
                                                      jstring jprogramId) {
     auto program_id = EmulationSession::GetProgramId(env, jprogramId);
-    ContentManager::RemoveAllDLC(&EmulationSession::GetInstance().System(), program_id);
+    ContentManager::RemoveAllDLC(EmulationSession::GetInstance().System(), program_id);
 }
 
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_removeMod(JNIEnv* env, jobject jobj, jstring jprogramId,
@@ -829,6 +835,44 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_removeMod(JNIEnv* env, jobject jobj,
                               program_id, GetJString(env, jname));
 }
 
+jobjectArray Java_org_yuzu_yuzu_1emu_NativeLibrary_verifyInstalledContents(JNIEnv* env,
+                                                                           jobject jobj,
+                                                                           jobject jcallback) {
+    auto jlambdaClass = env->GetObjectClass(jcallback);
+    auto jlambdaInvokeMethod = env->GetMethodID(
+        jlambdaClass, "invoke", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+    const auto callback = [env, jcallback, jlambdaInvokeMethod](size_t max, size_t progress) {
+        auto jwasCancelled = env->CallObjectMethod(jcallback, jlambdaInvokeMethod,
+                                                   ToJDouble(env, max), ToJDouble(env, progress));
+        return GetJBoolean(env, jwasCancelled);
+    };
+
+    auto& session = EmulationSession::GetInstance();
+    std::vector<std::string> result = ContentManager::VerifyInstalledContents(
+        session.System(), *session.GetContentProvider(), callback);
+    jobjectArray jresult =
+        env->NewObjectArray(result.size(), IDCache::GetStringClass(), ToJString(env, ""));
+    for (size_t i = 0; i < result.size(); ++i) {
+        env->SetObjectArrayElement(jresult, i, ToJString(env, result[i]));
+    }
+    return jresult;
+}
+
+jint Java_org_yuzu_yuzu_1emu_NativeLibrary_verifyGameContents(JNIEnv* env, jobject jobj,
+                                                              jstring jpath, jobject jcallback) {
+    auto jlambdaClass = env->GetObjectClass(jcallback);
+    auto jlambdaInvokeMethod = env->GetMethodID(
+        jlambdaClass, "invoke", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+    const auto callback = [env, jcallback, jlambdaInvokeMethod](size_t max, size_t progress) {
+        auto jwasCancelled = env->CallObjectMethod(jcallback, jlambdaInvokeMethod,
+                                                   ToJDouble(env, max), ToJDouble(env, progress));
+        return GetJBoolean(env, jwasCancelled);
+    };
+    auto& session = EmulationSession::GetInstance();
+    return static_cast<jint>(
+        ContentManager::VerifyGameContents(session.System(), GetJString(env, jpath), callback));
+}
+
 jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getSavePath(JNIEnv* env, jobject jobj,
                                                           jstring jprogramId) {
     auto program_id = EmulationSession::GetProgramId(env, jprogramId);
@@ -875,4 +919,16 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_clearFilesystemProvider(JNIEnv* env,
     EmulationSession::GetInstance().GetContentProvider()->ClearAllEntries();
 }
 
+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_areKeysPresent(JNIEnv* env, jobject jobj) {
+    auto& system = EmulationSession::GetInstance().System();
+    system.GetFileSystemController().CreateFactories(*system.GetFilesystem());
+    return ContentManager::AreKeysPresent();
+}
+
+jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_canDecryptSystemArchive(JNIEnv* env, jobject jobj) {
+    auto& system = EmulationSession::GetInstance().System();
+    system.GetFileSystemController().CreateFactories(*system.GetFilesystem());
+    return ContentManager::CanDecryptSystemArchive(EmulationSession::GetInstance().System());
+}
+
 } // extern "C"

src/android/app/src/main/res/drawable/ic_lock.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:height="24dp"
+    android:viewportHeight="24"
+    android:viewportWidth="24"
+    android:width="24dp">
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M18,8h-1L17,6c0,-2.76 -2.24,-5 -5,-5S7,3.24 7,6v2L6,8c-1.1,0 -2,0.9 -2,2v10c0,1.1 0.9,2 2,2h12c1.1,0 2,-0.9 2,-2L20,10c0,-1.1 -0.9,-2 -2,-2zM12,17c-1.1,0 -2,-0.9 -2,-2s0.9,-2 2,-2 2,0.9 2,2 -0.9,2 -2,2zM15.1,8L8.9,8L8.9,6c0,-1.71 1.39,-3.1 3.1,-3.1 1.71,0 3.1,1.39 3.1,3.1v2z" />
+</vector>

src/android/app/src/main/res/drawable/ic_shortcut.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M280,920q-33,0 -56.5,-23.5T200,840v-720q0,-33 23.5,-56.5T280,40h400q33,0 56.5,23.5T760,120v160h-80v-40L280,240v480h400v-40h80v160q0,33 -23.5,56.5T680,920L280,920ZM686,520L480,520v120h-80v-120q0,-33 23.5,-56.5T480,440h206l-62,-64 56,-56 160,160 -160,160 -56,-56 62,-64Z" />
+</vector>

src/android/app/src/main/res/layout-w600dp/fragment_game_properties.xml

@@ -43,16 +43,35 @@
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toTopOf="parent">
 
-        <Button
+        <androidx.constraintlayout.widget.ConstraintLayout
-            android:id="@+id/button_back"
+            android:layout_width="match_parent"
-            style="?attr/materialIconButtonStyle"
-            android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_gravity="start"
             android:layout_margin="8dp"
-            app:icon="@drawable/ic_back"
+            android:orientation="horizontal">
-            app:iconSize="24dp"
+
-            app:iconTint="?attr/colorOnSurface" />
+            <Button
+                android:id="@+id/button_back"
+                style="?attr/materialIconButtonStyle"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                app:icon="@drawable/ic_back"
+                app:iconSize="24dp"
+                app:iconTint="?attr/colorOnSurface"
+                app:layout_constraintStart_toStartOf="parent"
+                app:layout_constraintTop_toTopOf="parent" />
+
+            <Button
+                android:id="@+id/button_shortcut"
+                style="?attr/materialIconButtonStyle"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                app:icon="@drawable/ic_shortcut"
+                app:iconSize="24dp"
+                app:iconTint="?attr/colorOnSurface"
+                app:layout_constraintTop_toTopOf="parent"
+                app:layout_constraintEnd_toEndOf="parent" />
+
+        </androidx.constraintlayout.widget.ConstraintLayout>
 
         <com.google.android.material.card.MaterialCardView
             style="?attr/materialCardViewElevatedStyle"

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

@@ -118,6 +118,14 @@
                 android:layout_marginTop="16dp"
                 android:text="@string/copy_details" />
 
+            <com.google.android.material.button.MaterialButton
+                android:id="@+id/button_verify_integrity"
+                style="@style/Widget.Material3.Button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="10dp"
+                android:text="@string/verify_integrity" />
+
         </LinearLayout>
 
     </androidx.core.widget.NestedScrollView>

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

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
@@ -22,16 +21,35 @@
             android:orientation="vertical"
             android:gravity="center_horizontal">
 
-            <Button
+            <androidx.constraintlayout.widget.ConstraintLayout
-                android:id="@+id/button_back"
+                android:layout_width="match_parent"
-                style="?attr/materialIconButtonStyle"
-                android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_margin="8dp"
-                android:layout_gravity="start"
+                android:orientation="horizontal">
-                app:icon="@drawable/ic_back"
+
-                app:iconSize="24dp"
+                <Button
-                app:iconTint="?attr/colorOnSurface" />
+                    android:id="@+id/button_back"
+                    style="?attr/materialIconButtonStyle"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    app:icon="@drawable/ic_back"
+                    app:iconSize="24dp"
+                    app:iconTint="?attr/colorOnSurface"
+                    app:layout_constraintStart_toStartOf="parent"
+                    app:layout_constraintTop_toTopOf="parent" />
+
+                <Button
+                    android:id="@+id/button_shortcut"
+                    style="?attr/materialIconButtonStyle"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    app:icon="@drawable/ic_shortcut"
+                    app:iconSize="24dp"
+                    app:iconTint="?attr/colorOnSurface"
+                    app:layout_constraintEnd_toEndOf="parent"
+                    app:layout_constraintTop_toTopOf="parent" />
+
+            </androidx.constraintlayout.widget.ConstraintLayout>
 
             <com.google.android.material.card.MaterialCardView
                 style="?attr/materialCardViewElevatedStyle"
@@ -45,7 +63,7 @@
                     android:id="@+id/image_game_screen"
                     android:layout_width="175dp"
                     android:layout_height="175dp"
-                    tools:src="@drawable/default_icon"/>
+                    tools:src="@drawable/default_icon" />
 
             </com.google.android.material.card.MaterialCardView>
 

src/android/app/src/main/res/menu/menu_in_game.xml

@@ -21,6 +21,11 @@
         android:icon="@drawable/ic_controller"
         android:title="@string/emulation_input_overlay" />
 
+    <item
+        android:id="@+id/menu_lock_drawer"
+        android:icon="@drawable/ic_unlock"
+        android:title="@string/emulation_input_overlay" />
+
     <item
         android:id="@+id/menu_exit"
         android:icon="@drawable/ic_exit"

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

@@ -142,6 +142,13 @@
         <item quantity="other">Successfully imported %d saves</item>
     </plurals>
     <string name="no_save_data_found">No save data found</string>
+    <string name="verify_installed_content">Verify installed content</string>
+    <string name="verify_installed_content_description">Checks all installed content for corruption</string>
+    <string name="keys_missing">Encryption keys are missing</string>
+    <string name="keys_missing_description">Firmware and retail games cannot be decrypted</string>
+    <string name="keys_missing_help">https://yuzu-emu.org/help/quickstart/#dumping-decryption-keys</string>
+    <string name="decryption_failed">System archive decryption failed</string>
+    <string name="decryption_failed_description">Encryption keys failed to decrypt firmware</string>
 
     <!-- Applet launcher strings -->
     <string name="applets">Applet launcher</string>
@@ -288,6 +295,7 @@
     <string name="import_complete">Import complete</string>
     <string name="more_options">More options</string>
     <string name="use_global_setting">Use global setting</string>
+    <string name="operation_completed_successfully">The operation completed successfully</string>
 
     <!-- GPU driver installation -->
     <string name="select_gpu_driver">Select GPU driver</string>
@@ -352,6 +360,14 @@
     <string name="content_install_notice_description">The content that you selected does not match this game.\nInstall anyway?</string>
     <string name="confirm_uninstall">Confirm uninstall</string>
     <string name="confirm_uninstall_description">Are you sure you want to uninstall this addon?</string>
+    <string name="verify_integrity">Verify integrity</string>
+    <string name="verifying">Verifying…</string>
+    <string name="verify_success">Integrity verification succeeded!</string>
+    <string name="verify_failure">Integrity verification failed!</string>
+    <string name="verify_failure_description">File contents may be corrupt</string>
+    <string name="verify_no_result">Integrity verification couldn\'t be performed</string>
+    <string name="verify_no_result_description">File contents were not checked for validity</string>
+    <string name="verification_failed_for">Verification failed for the following files:\n%1$s</string>
 
     <!-- ROM loading errors -->
     <string name="loader_error_encrypted">Your ROM is encrypted</string>
@@ -381,6 +397,8 @@
     <string name="emulation_unpause">Unpause emulation</string>
     <string name="emulation_input_overlay">Overlay options</string>
     <string name="touchscreen">Touchscreen</string>
+    <string name="lock_drawer">Lock drawer</string>
+    <string name="unlock_drawer">Unlock drawer</string>
 
     <string name="load_settings">Loading settings…</string>
 

src/audio_core/device/device_session.cpp

@@ -8,6 +8,7 @@
 #include "audio_core/sink/sink_stream.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/guest_memory.h"
 #include "core/memory.h"
 
 #include "core/hle/kernel/k_process.h"

src/audio_core/renderer/command/data_source/decode.cpp

@@ -9,6 +9,7 @@
 #include "common/fixed_point.h"
 #include "common/logging/log.h"
 #include "common/scratch_buffer.h"
+#include "core/guest_memory.h"
 #include "core/memory.h"
 
 namespace AudioCore::Renderer {

src/common/CMakeLists.txt

@@ -106,6 +106,7 @@ add_library(common STATIC
     precompiled_headers.h
     quaternion.h
     range_map.h
+    range_mutex.h
     reader_writer_queue.h
     ring_buffer.h
     ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp

src/common/arm64/native_clock.cpp

@@ -30,27 +30,27 @@ NativeClock::NativeClock() {
 }
 
 std::chrono::nanoseconds NativeClock::GetTimeNS() const {
-    return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_cntfrq_factor)};
+    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_cntfrq_factor)};
 }
 
 std::chrono::microseconds NativeClock::GetTimeUS() const {
-    return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_cntfrq_factor)};
+    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_cntfrq_factor)};
 }
 
 std::chrono::milliseconds NativeClock::GetTimeMS() const {
-    return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_cntfrq_factor)};
+    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_cntfrq_factor)};
 }
 
-u64 NativeClock::GetCNTPCT() const {
+s64 NativeClock::GetCNTPCT() const {
-    return MultiplyHigh(GetHostTicksElapsed(), guest_cntfrq_factor);
+    return MultiplyHigh(GetUptime(), guest_cntfrq_factor);
 }
 
-u64 NativeClock::GetGPUTick() const {
+s64 NativeClock::GetGPUTick() const {
-    return MultiplyHigh(GetHostTicksElapsed(), gputick_cntfrq_factor);
+    return MultiplyHigh(GetUptime(), gputick_cntfrq_factor);
 }
 
-u64 NativeClock::GetHostTicksNow() const {
+s64 NativeClock::GetUptime() const {
-    u64 cntvct_el0 = 0;
+    s64 cntvct_el0 = 0;
     asm volatile("dsb ish\n\t"
                  "mrs %[cntvct_el0], cntvct_el0\n\t"
                  "dsb ish\n\t"
@@ -58,15 +58,11 @@ u64 NativeClock::GetHostTicksNow() const {
     return cntvct_el0;
 }
 
-u64 NativeClock::GetHostTicksElapsed() const {
-    return GetHostTicksNow();
-}
-
 bool NativeClock::IsNative() const {
     return true;
 }
 
-u64 NativeClock::GetHostCNTFRQ() {
+s64 NativeClock::GetHostCNTFRQ() {
     u64 cntfrq_el0 = 0;
     std::string_view board{""};
 #ifdef ANDROID

src/common/arm64/native_clock.h

@@ -17,17 +17,15 @@ public:
 
     std::chrono::milliseconds GetTimeMS() const override;
 
-    u64 GetCNTPCT() const override;
+    s64 GetCNTPCT() const override;
 
-    u64 GetGPUTick() const override;
+    s64 GetGPUTick() const override;
 
-    u64 GetHostTicksNow() const override;
+    s64 GetUptime() const override;
-
-    u64 GetHostTicksElapsed() const override;
 
     bool IsNative() const override;
 
-    static u64 GetHostCNTFRQ();
+    static s64 GetHostCNTFRQ();
 
 public:
     using FactorType = unsigned __int128;

src/common/common_types.h

@@ -45,6 +45,7 @@ using f32 = float;  ///< 32-bit floating point
 using f64 = double; ///< 64-bit floating point
 
 using VAddr = u64;    ///< Represents a pointer in the userspace virtual address space.
+using DAddr = u64;    ///< Represents a pointer in the device specific virtual address space.
 using PAddr = u64;    ///< Represents a pointer in the ARM11 physical address space.
 using GPUVAddr = u64; ///< Represents a pointer in the GPU virtual address space.
 

src/common/memory_detect.h

@@ -18,4 +18,4 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
-} // namespace Common
+} // namespace Common

src/common/range_mutex.h

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+
+#include "common/intrusive_list.h"
+
+namespace Common {
+
+class ScopedRangeLock;
+
+class RangeMutex {
+public:
+    explicit RangeMutex() = default;
+    ~RangeMutex() = default;
+
+private:
+    friend class ScopedRangeLock;
+
+    void Lock(ScopedRangeLock& l);
+    void Unlock(ScopedRangeLock& l);
+    bool HasIntersectionLocked(ScopedRangeLock& l);
+
+private:
+    std::mutex m_mutex;
+    std::condition_variable m_cv;
+
+    using LockList = Common::IntrusiveListBaseTraits<ScopedRangeLock>::ListType;
+    LockList m_list;
+};
+
+class ScopedRangeLock : public Common::IntrusiveListBaseNode<ScopedRangeLock> {
+public:
+    explicit ScopedRangeLock(RangeMutex& mutex, u64 address, u64 size)
+        : m_mutex(mutex), m_address(address), m_size(size) {
+        if (m_size > 0) {
+            m_mutex.Lock(*this);
+        }
+    }
+    ~ScopedRangeLock() {
+        if (m_size > 0) {
+            m_mutex.Unlock(*this);
+        }
+    }
+
+    u64 GetAddress() const {
+        return m_address;
+    }
+
+    u64 GetSize() const {
+        return m_size;
+    }
+
+private:
+    RangeMutex& m_mutex;
+    const u64 m_address{};
+    const u64 m_size{};
+};
+
+inline void RangeMutex::Lock(ScopedRangeLock& l) {
+    std::unique_lock lk{m_mutex};
+    m_cv.wait(lk, [&] { return !HasIntersectionLocked(l); });
+    m_list.push_back(l);
+}
+
+inline void RangeMutex::Unlock(ScopedRangeLock& l) {
+    {
+        std::scoped_lock lk{m_mutex};
+        m_list.erase(m_list.iterator_to(l));
+    }
+    m_cv.notify_all();
+}
+
+inline bool RangeMutex::HasIntersectionLocked(ScopedRangeLock& l) {
+    const auto cur_begin = l.GetAddress();
+    const auto cur_last = l.GetAddress() + l.GetSize() - 1;
+
+    for (const auto& other : m_list) {
+        const auto other_begin = other.GetAddress();
+        const auto other_last = other.GetAddress() + other.GetSize() - 1;
+
+        if (cur_begin <= other_last && other_begin <= cur_last) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+} // namespace Common

src/common/settings.h

@@ -419,9 +419,16 @@ struct Values {
         linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
     SwitchableSetting<s64> custom_rtc{
         linkage, 0,    "custom_rtc",       Category::System, Specialization::Time,
-        true,    true, &custom_rtc_enabled};
+        false,   true, &custom_rtc_enabled};
-    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
+    SwitchableSetting<s64, true> custom_rtc_offset{linkage,
-    s64 custom_rtc_differential;
+                                                   0,
+                                                   std::numeric_limits<int>::min(),
+                                                   std::numeric_limits<int>::max(),
+                                                   "custom_rtc_offset",
+                                                   Category::System,
+                                                   Specialization::Countable,
+                                                   true,
+                                                   true};
     SwitchableSetting<bool> rng_seed_enabled{
         linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
     SwitchableSetting<u32> rng_seed{

src/common/time_zone.cpp

@@ -88,7 +88,17 @@ std::string FindSystemTimeZone() {
             LOG_ERROR(Common, "Time zone {} not handled, defaulting to hour offset.", tz_index);
         }
     }
-    return fmt::format("Etc/GMT{:s}{:d}", hours > 0 ? "-" : "+", std::abs(hours));
+
+    // For some reason the Etc/GMT times are reversed. GMT+6 contains -21600 as its offset,
+    // -6 hours instead of +6 hours, so these signs are purposefully reversed to fix it.
+    std::string postfix{""};
+    if (hours > 0) {
+        postfix = fmt::format("-{:d}", std::abs(hours));
+    } else if (hours < 0) {
+        postfix = fmt::format("+{:d}", std::abs(hours));
+    }
+
+    return fmt::format("Etc/GMT{:s}", postfix);
 }
 
 } // namespace Common::TimeZone

src/common/uuid.h

@@ -12,9 +12,8 @@
 namespace Common {
 
 struct UUID {
-    std::array<u8, 0x10> uuid{};
+    std::array<u8, 0x10> uuid;
 
-    /// Constructs an invalid UUID.
     constexpr UUID() = default;
 
     /// Constructs a UUID from a reference to a 128 bit array.
@@ -34,14 +33,6 @@ struct UUID {
      */
     explicit UUID(std::string_view uuid_string);
 
-    ~UUID() = default;
-
-    constexpr UUID(const UUID&) noexcept = default;
-    constexpr UUID(UUID&&) noexcept = default;
-
-    constexpr UUID& operator=(const UUID&) noexcept = default;
-    constexpr UUID& operator=(UUID&&) noexcept = default;
-
     /**
      * Returns whether the stored UUID is valid or not.
      *
@@ -121,6 +112,7 @@ struct UUID {
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };
 static_assert(sizeof(UUID) == 0x10, "UUID has incorrect size.");
+static_assert(std::is_trivial_v<UUID>);
 
 /// An invalid UUID. This UUID has all its bytes set to 0.
 constexpr UUID InvalidUUID = {};

src/common/wall_clock.cpp

@@ -18,42 +18,40 @@ namespace Common {
 
 class StandardWallClock final : public WallClock {
 public:
-    explicit StandardWallClock() : start_time{SteadyClock::Now()} {}
+    explicit StandardWallClock() {}
 
     std::chrono::nanoseconds GetTimeNS() const override {
-        return SteadyClock::Now() - start_time;
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
     }
 
     std::chrono::microseconds GetTimeUS() const override {
-        return static_cast<std::chrono::microseconds>(GetHostTicksElapsed() / NsToUsRatio::den);
+        return std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
     }
 
     std::chrono::milliseconds GetTimeMS() const override {
-        return static_cast<std::chrono::milliseconds>(GetHostTicksElapsed() / NsToMsRatio::den);
+        return std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch());
     }
 
-    u64 GetCNTPCT() const override {
+    s64 GetCNTPCT() const override {
-        return GetHostTicksElapsed() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
+        return GetUptime() * NsToCNTPCTRatio::num / NsToCNTPCTRatio::den;
     }
 
-    u64 GetGPUTick() const override {
+    s64 GetGPUTick() const override {
-        return GetHostTicksElapsed() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
+        return GetUptime() * NsToGPUTickRatio::num / NsToGPUTickRatio::den;
     }
 
-    u64 GetHostTicksNow() const override {
+    s64 GetUptime() const override {
-        return static_cast<u64>(SteadyClock::Now().time_since_epoch().count());
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
-    }
+                   std::chrono::steady_clock::now().time_since_epoch())
-
+            .count();
-    u64 GetHostTicksElapsed() const override {
-        return static_cast<u64>(GetTimeNS().count());
     }
 
     bool IsNative() const override {
         return false;
     }
-
-private:
-    SteadyClock::time_point start_time;
 };
 
 std::unique_ptr<WallClock> CreateOptimalClock() {

src/common/wall_clock.h

@@ -29,16 +29,13 @@ public:
     virtual std::chrono::milliseconds GetTimeMS() const = 0;
 
     /// @returns The guest CNTPCT ticks since the construction of this clock.
-    virtual u64 GetCNTPCT() const = 0;
+    virtual s64 GetCNTPCT() const = 0;
 
     /// @returns The guest GPU ticks since the construction of this clock.
-    virtual u64 GetGPUTick() const = 0;
+    virtual s64 GetGPUTick() const = 0;
 
     /// @returns The raw host timer ticks since an indeterminate epoch.
-    virtual u64 GetHostTicksNow() const = 0;
+    virtual s64 GetUptime() const = 0;
-
-    /// @returns The raw host timer ticks since the construction of this clock.
-    virtual u64 GetHostTicksElapsed() const = 0;
 
     /// @returns Whether the clock directly uses the host's hardware clock.
     virtual bool IsNative() const = 0;

src/common/x64/native_clock.cpp

@@ -8,39 +8,35 @@
 namespace Common::X64 {
 
 NativeClock::NativeClock(u64 rdtsc_frequency_)
-    : start_ticks{FencedRDTSC()}, rdtsc_frequency{rdtsc_frequency_},
+    : rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,
-      ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency)},
+                                                                               rdtsc_frequency)},
       us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},
       ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},
       cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},
       gputick_rdtsc_factor{GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency)} {}
 
 std::chrono::nanoseconds NativeClock::GetTimeNS() const {
-    return std::chrono::nanoseconds{MultiplyHigh(GetHostTicksElapsed(), ns_rdtsc_factor)};
+    return std::chrono::nanoseconds{MultiplyHigh(GetUptime(), ns_rdtsc_factor)};
 }
 
 std::chrono::microseconds NativeClock::GetTimeUS() const {
-    return std::chrono::microseconds{MultiplyHigh(GetHostTicksElapsed(), us_rdtsc_factor)};
+    return std::chrono::microseconds{MultiplyHigh(GetUptime(), us_rdtsc_factor)};
 }
 
 std::chrono::milliseconds NativeClock::GetTimeMS() const {
-    return std::chrono::milliseconds{MultiplyHigh(GetHostTicksElapsed(), ms_rdtsc_factor)};
+    return std::chrono::milliseconds{MultiplyHigh(GetUptime(), ms_rdtsc_factor)};
 }
 
-u64 NativeClock::GetCNTPCT() const {
+s64 NativeClock::GetCNTPCT() const {
-    return MultiplyHigh(GetHostTicksElapsed(), cntpct_rdtsc_factor);
+    return MultiplyHigh(GetUptime(), cntpct_rdtsc_factor);
 }
 
-u64 NativeClock::GetGPUTick() const {
+s64 NativeClock::GetGPUTick() const {
-    return MultiplyHigh(GetHostTicksElapsed(), gputick_rdtsc_factor);
+    return MultiplyHigh(GetUptime(), gputick_rdtsc_factor);
 }
 
-u64 NativeClock::GetHostTicksNow() const {
+s64 NativeClock::GetUptime() const {
-    return FencedRDTSC();
+    return static_cast<s64>(FencedRDTSC());
-}
-
-u64 NativeClock::GetHostTicksElapsed() const {
-    return FencedRDTSC() - start_ticks;
 }
 
 bool NativeClock::IsNative() const {

src/common/x64/native_clock.h

@@ -17,18 +17,15 @@ public:
 
     std::chrono::milliseconds GetTimeMS() const override;
 
-    u64 GetCNTPCT() const override;
+    s64 GetCNTPCT() const override;
 
-    u64 GetGPUTick() const override;
+    s64 GetGPUTick() const override;
 
-    u64 GetHostTicksNow() const override;
+    s64 GetUptime() const override;
-
-    u64 GetHostTicksElapsed() const override;
 
     bool IsNative() const override;
 
 private:
-    u64 start_ticks;
     u64 rdtsc_frequency;
 
     u64 ns_rdtsc_factor;

src/core/CMakeLists.txt

@@ -37,6 +37,8 @@ add_library(core STATIC
     debugger/gdbstub_arch.h
     debugger/gdbstub.cpp
     debugger/gdbstub.h
+    device_memory_manager.h
+    device_memory_manager.inc
     device_memory.cpp
     device_memory.h
     file_sys/fssystem/fs_i_storage.h
@@ -513,6 +515,24 @@ add_library(core STATIC
     hle/service/glue/glue_manager.h
     hle/service/glue/notif.cpp
     hle/service/glue/notif.h
+    hle/service/glue/time/alarm_worker.cpp
+    hle/service/glue/time/alarm_worker.h
+    hle/service/glue/time/file_timestamp_worker.cpp
+    hle/service/glue/time/file_timestamp_worker.h
+    hle/service/glue/time/manager.cpp
+    hle/service/glue/time/manager.h
+    hle/service/glue/time/pm_state_change_handler.cpp
+    hle/service/glue/time/pm_state_change_handler.h
+    hle/service/glue/time/standard_steady_clock_resource.cpp
+    hle/service/glue/time/standard_steady_clock_resource.h
+    hle/service/glue/time/static.cpp
+    hle/service/glue/time/static.h
+    hle/service/glue/time/time_zone.cpp
+    hle/service/glue/time/time_zone.h
+    hle/service/glue/time/time_zone_binary.cpp
+    hle/service/glue/time/time_zone_binary.h
+    hle/service/glue/time/worker.cpp
+    hle/service/glue/time/worker.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
     hle/service/hid/hid.cpp
@@ -609,6 +629,8 @@ add_library(core STATIC
     hle/service/ns/pdm_qry.h
     hle/service/nvdrv/core/container.cpp
     hle/service/nvdrv/core/container.h
+    hle/service/nvdrv/core/heap_mapper.cpp
+    hle/service/nvdrv/core/heap_mapper.h
     hle/service/nvdrv/core/nvmap.cpp
     hle/service/nvdrv/core/nvmap.h
     hle/service/nvdrv/core/syncpoint_manager.cpp
@@ -689,6 +711,46 @@ add_library(core STATIC
     hle/service/prepo/prepo.h
     hle/service/psc/psc.cpp
     hle/service/psc/psc.h
+    hle/service/psc/time/alarms.cpp
+    hle/service/psc/time/alarms.h
+    hle/service/psc/time/clocks/context_writers.cpp
+    hle/service/psc/time/clocks/context_writers.h
+    hle/service/psc/time/clocks/ephemeral_network_system_clock_core.h
+    hle/service/psc/time/clocks/standard_local_system_clock_core.cpp
+    hle/service/psc/time/clocks/standard_local_system_clock_core.h
+    hle/service/psc/time/clocks/standard_network_system_clock_core.cpp
+    hle/service/psc/time/clocks/standard_network_system_clock_core.h
+    hle/service/psc/time/clocks/standard_steady_clock_core.cpp
+    hle/service/psc/time/clocks/standard_steady_clock_core.h
+    hle/service/psc/time/clocks/standard_user_system_clock_core.cpp
+    hle/service/psc/time/clocks/standard_user_system_clock_core.h
+    hle/service/psc/time/clocks/steady_clock_core.h
+    hle/service/psc/time/clocks/system_clock_core.cpp
+    hle/service/psc/time/clocks/system_clock_core.h
+    hle/service/psc/time/clocks/tick_based_steady_clock_core.cpp
+    hle/service/psc/time/clocks/tick_based_steady_clock_core.h
+    hle/service/psc/time/common.cpp
+    hle/service/psc/time/common.h
+    hle/service/psc/time/errors.h
+    hle/service/psc/time/shared_memory.cpp
+    hle/service/psc/time/shared_memory.h
+    hle/service/psc/time/static.cpp
+    hle/service/psc/time/static.h
+    hle/service/psc/time/manager.h
+    hle/service/psc/time/power_state_service.cpp
+    hle/service/psc/time/power_state_service.h
+    hle/service/psc/time/service_manager.cpp
+    hle/service/psc/time/service_manager.h
+    hle/service/psc/time/steady_clock.cpp
+    hle/service/psc/time/steady_clock.h
+    hle/service/psc/time/system_clock.cpp
+    hle/service/psc/time/system_clock.h
+    hle/service/psc/time/time_zone.cpp
+    hle/service/psc/time/time_zone.h
+    hle/service/psc/time/time_zone_service.cpp
+    hle/service/psc/time/time_zone_service.h
+    hle/service/psc/time/power_state_request_manager.cpp
+    hle/service/psc/time/power_state_request_manager.h
     hle/service/ptm/psm.cpp
     hle/service/ptm/psm.h
     hle/service/ptm/ptm.cpp
@@ -756,40 +818,6 @@ add_library(core STATIC
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
     hle/service/ssl/ssl_backend.h
-    hle/service/time/clock_types.h
-    hle/service/time/ephemeral_network_system_clock_context_writer.h
-    hle/service/time/ephemeral_network_system_clock_core.h
-    hle/service/time/errors.h
-    hle/service/time/local_system_clock_context_writer.h
-    hle/service/time/network_system_clock_context_writer.h
-    hle/service/time/standard_local_system_clock_core.h
-    hle/service/time/standard_network_system_clock_core.h
-    hle/service/time/standard_steady_clock_core.cpp
-    hle/service/time/standard_steady_clock_core.h
-    hle/service/time/standard_user_system_clock_core.cpp
-    hle/service/time/standard_user_system_clock_core.h
-    hle/service/time/steady_clock_core.h
-    hle/service/time/system_clock_context_update_callback.cpp
-    hle/service/time/system_clock_context_update_callback.h
-    hle/service/time/system_clock_core.cpp
-    hle/service/time/system_clock_core.h
-    hle/service/time/tick_based_steady_clock_core.cpp
-    hle/service/time/tick_based_steady_clock_core.h
-    hle/service/time/time.cpp
-    hle/service/time/time.h
-    hle/service/time/time_interface.cpp
-    hle/service/time/time_interface.h
-    hle/service/time/time_manager.cpp
-    hle/service/time/time_manager.h
-    hle/service/time/time_sharedmemory.cpp
-    hle/service/time/time_sharedmemory.h
-    hle/service/time/time_zone_content_manager.cpp
-    hle/service/time/time_zone_content_manager.h
-    hle/service/time/time_zone_manager.cpp
-    hle/service/time/time_zone_manager.h
-    hle/service/time/time_zone_service.cpp
-    hle/service/time/time_zone_service.h
-    hle/service/time/time_zone_types.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/display/vi_display.cpp
@@ -870,7 +898,7 @@ endif()
 
 create_target_directory_groups(core)
 
-target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb)
+target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)
 target_link_libraries(core PUBLIC Boost::headers PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls RenderDoc::API)
 if (MINGW)
     target_link_libraries(core PRIVATE ${MSWSOCK_LIBRARY})

src/core/core.cpp

@@ -28,6 +28,7 @@
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/gpu_dirty_memory_manager.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -39,9 +40,14 @@
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/glue_manager.h"
+#include "core/hle/service/glue/time/static.h"
+#include "core/hle/service/psc/time/static.h"
+#include "core/hle/service/psc/time/steady_clock.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/psc/time/time_zone_service.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/hle/service/time/time_manager.h"
 #include "core/internal_network/network.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
@@ -129,8 +135,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
 struct System::Impl {
     explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, hid_core{}, room_network{}, cpu_manager{system},
+        : kernel{system}, fs_controller{system}, hid_core{}, room_network{},
-          reporter{system}, applet_manager{system}, profile_manager{}, time_manager{system} {}
+          cpu_manager{system}, reporter{system}, applet_manager{system}, profile_manager{} {}
 
     void Initialize(System& system) {
         device_memory = std::make_unique<Core::DeviceMemory>();
@@ -142,8 +148,6 @@ struct System::Impl {
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        RefreshTime();
-
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr) {
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
@@ -181,14 +185,57 @@ struct System::Impl {
         Initialize(system);
     }
 
-    void RefreshTime() {
+    void RefreshTime(System& system) {
+        if (!system.IsPoweredOn()) {
+            return;
+        }
+
+        auto settings_service =
+            system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys",
+                                                                                    true);
+        auto static_service_a =
+            system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:a", true);
+
+        auto static_service_s =
+            system.ServiceManager().GetService<Service::PSC::Time::StaticService>("time:s", true);
+
+        std::shared_ptr<Service::PSC::Time::SystemClock> user_clock;
+        static_service_a->GetStandardUserSystemClock(user_clock);
+
+        std::shared_ptr<Service::PSC::Time::SystemClock> local_clock;
+        static_service_a->GetStandardLocalSystemClock(local_clock);
+
+        std::shared_ptr<Service::PSC::Time::SystemClock> network_clock;
+        static_service_s->GetStandardNetworkSystemClock(network_clock);
+
+        std::shared_ptr<Service::Glue::Time::TimeZoneService> timezone_service;
+        static_service_a->GetTimeZoneService(timezone_service);
+
+        Service::PSC::Time::LocationName name{};
+        auto new_name = Settings::GetTimeZoneString(Settings::values.time_zone_index.GetValue());
+        std::memcpy(name.name.data(), new_name.data(), std::min(name.name.size(), new_name.size()));
+
+        timezone_service->SetDeviceLocation(name);
+
+        u64 time_offset = 0;
+        if (Settings::values.custom_rtc_enabled) {
+            time_offset = Settings::values.custom_rtc_offset.GetValue();
+        }
+
         const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
+        const u64 current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+            +std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
-        Settings::values.custom_rtc_differential =
+        const u64 new_time = current_time + time_offset;
-            (Settings::values.custom_rtc_enabled ? Settings::values.custom_rtc.GetValue()
+
-                                                 : current_time) -
+        Service::PSC::Time::SystemClockContext context{};
-            current_time;
+        settings_service->SetUserSystemClockContext(context);
+        user_clock->SetCurrentTime(new_time);
+
+        local_clock->SetCurrentTime(new_time);
+
+        network_clock->GetSystemClockContext(context);
+        settings_service->SetNetworkSystemClockContext(context);
+        network_clock->SetCurrentTime(new_time);
     }
 
     void Run() {
@@ -264,9 +311,6 @@ struct System::Impl {
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
         services = std::make_unique<Service::Services>(service_manager, system);
 
-        // Initialize time manager, which must happen after kernel is created
-        time_manager.Initialize();
-
         is_powered_on = true;
         exit_locked = false;
         exit_requested = false;
@@ -416,7 +460,6 @@ struct System::Impl {
         fs_controller.Reset();
         cheat_engine.reset();
         telemetry_session.reset();
-        time_manager.Shutdown();
         core_timing.ClearPendingEvents();
         app_loader.reset();
         audio_core.reset();
@@ -532,7 +575,6 @@ struct System::Impl {
     /// Service State
     Service::Glue::ARPManager arp_manager;
     Service::Account::ProfileManager profile_manager;
-    Service::Time::TimeManager time_manager;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -565,6 +607,9 @@ struct System::Impl {
     std::array<u64, Core::Hardware::NUM_CPU_CORES> dynarmic_ticks{};
     std::array<MicroProfileToken, Core::Hardware::NUM_CPU_CORES> microprofile_cpu{};
 
+    std::array<Core::GPUDirtyMemoryManager, Core::Hardware::NUM_CPU_CORES>
+        gpu_dirty_memory_managers;
+
     std::deque<std::vector<u8>> user_channel;
 };
 
@@ -651,8 +696,14 @@ size_t System::GetCurrentHostThreadID() const {
     return impl->kernel.GetCurrentHostThreadID();
 }
 
-void System::GatherGPUDirtyMemory(std::function<void(VAddr, size_t)>& callback) {
+std::span<GPUDirtyMemoryManager> System::GetGPUDirtyMemoryManager() {
-    return this->ApplicationProcess()->GatherGPUDirtyMemory(callback);
+    return impl->gpu_dirty_memory_managers;
+}
+
+void System::GatherGPUDirtyMemory(std::function<void(PAddr, size_t)>& callback) {
+    for (auto& manager : impl->gpu_dirty_memory_managers) {
+        manager.Gather(callback);
+    }
 }
 
 PerfStatsResults System::GetAndResetPerfStats() {
@@ -901,14 +952,6 @@ const Service::Account::ProfileManager& System::GetProfileManager() const {
     return impl->profile_manager;
 }
 
-Service::Time::TimeManager& System::GetTimeManager() {
-    return impl->time_manager;
-}
-
-const Service::Time::TimeManager& System::GetTimeManager() const {
-    return impl->time_manager;
-}
-
 void System::SetExitLocked(bool locked) {
     impl->exit_locked = locked;
 }
@@ -1020,13 +1063,9 @@ void System::Exit() {
 }
 
 void System::ApplySettings() {
-    impl->RefreshTime();
+    impl->RefreshTime(*this);
 
     if (IsPoweredOn()) {
-        if (Settings::values.custom_rtc_enabled) {
-            const s64 posix_time{Settings::values.custom_rtc.GetValue()};
-            GetTimeManager().UpdateLocalSystemClockTime(posix_time);
-        }
         Renderer().RefreshBaseSettings();
     }
 }

src/core/core.h

@@ -8,6 +8,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -72,10 +73,6 @@ namespace SM {
 class ServiceManager;
 } // namespace SM
 
-namespace Time {
-class TimeManager;
-} // namespace Time
-
 } // namespace Service
 
 namespace Tegra {
@@ -116,6 +113,7 @@ class CpuManager;
 class Debugger;
 class DeviceMemory;
 class ExclusiveMonitor;
+class GPUDirtyMemoryManager;
 class PerfStats;
 class Reporter;
 class SpeedLimiter;
@@ -224,7 +222,9 @@ public:
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule(u32 core_index);
 
-    void GatherGPUDirtyMemory(std::function<void(VAddr, size_t)>& callback);
+    std::span<GPUDirtyMemoryManager> GetGPUDirtyMemoryManager();
+
+    void GatherGPUDirtyMemory(std::function<void(PAddr, size_t)>& callback);
 
     [[nodiscard]] size_t GetCurrentHostThreadID() const;
 
@@ -377,9 +377,6 @@ public:
     [[nodiscard]] Service::Account::ProfileManager& GetProfileManager();
     [[nodiscard]] const Service::Account::ProfileManager& GetProfileManager() const;
 
-    [[nodiscard]] Service::Time::TimeManager& GetTimeManager();
-    [[nodiscard]] const Service::Time::TimeManager& GetTimeManager() const;
-
     [[nodiscard]] Core::Debugger& GetDebugger();
     [[nodiscard]] const Core::Debugger& GetDebugger() const;
 

src/core/core_timing.cpp

@@ -157,7 +157,7 @@ void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
             }
         }
 
-        for (auto h : to_remove) {
+        for (auto& h : to_remove) {
             event_queue.erase(h);
         }
 

src/core/device_memory.h

@@ -31,6 +31,12 @@ public:
                DramMemoryMap::Base;
     }
 
+    template <typename T>
+    PAddr GetRawPhysicalAddr(const T* ptr) const {
+        return static_cast<PAddr>(reinterpret_cast<uintptr_t>(ptr) -
+                                  reinterpret_cast<uintptr_t>(buffer.BackingBasePointer()));
+    }
+
     template <typename T>
     T* GetPointer(Common::PhysicalAddress addr) {
         return reinterpret_cast<T*>(buffer.BackingBasePointer() +
@@ -43,6 +49,16 @@ public:
                                     (GetInteger(addr) - DramMemoryMap::Base));
     }
 
+    template <typename T>
+    T* GetPointerFromRaw(PAddr addr) {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + addr);
+    }
+
+    template <typename T>
+    const T* GetPointerFromRaw(PAddr addr) const {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + addr);
+    }
+
     Common::HostMemory buffer;
 };
 

src/core/device_memory_manager.h

@@ -0,0 +1,212 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <deque>
+#include <memory>
+#include <mutex>
+
+#include "common/common_types.h"
+#include "common/range_mutex.h"
+#include "common/scratch_buffer.h"
+#include "common/virtual_buffer.h"
+
+namespace Core {
+
+constexpr size_t DEVICE_PAGEBITS = 12ULL;
+constexpr size_t DEVICE_PAGESIZE = 1ULL << DEVICE_PAGEBITS;
+constexpr size_t DEVICE_PAGEMASK = DEVICE_PAGESIZE - 1ULL;
+
+class DeviceMemory;
+
+namespace Memory {
+class Memory;
+}
+
+template <typename DTraits>
+struct DeviceMemoryManagerAllocator;
+
+struct Asid {
+    size_t id;
+};
+
+template <typename Traits>
+class DeviceMemoryManager {
+    using DeviceInterface = typename Traits::DeviceInterface;
+    using DeviceMethods = typename Traits::DeviceMethods;
+
+public:
+    DeviceMemoryManager(const DeviceMemory& device_memory);
+    ~DeviceMemoryManager();
+
+    void BindInterface(DeviceInterface* device_inter);
+
+    DAddr Allocate(size_t size);
+    void AllocateFixed(DAddr start, size_t size);
+    void Free(DAddr start, size_t size);
+
+    void Map(DAddr address, VAddr virtual_address, size_t size, Asid asid, bool track = false);
+
+    void Unmap(DAddr address, size_t size);
+
+    void TrackContinuityImpl(DAddr address, VAddr virtual_address, size_t size, Asid asid);
+    void TrackContinuity(DAddr address, VAddr virtual_address, size_t size, Asid asid) {
+        std::scoped_lock lk(mapping_guard);
+        TrackContinuityImpl(address, virtual_address, size, asid);
+    }
+
+    // Write / Read
+    template <typename T>
+    T* GetPointer(DAddr address);
+
+    template <typename T>
+    const T* GetPointer(DAddr address) const;
+
+    template <typename Func>
+    void ApplyOpOnPAddr(PAddr address, Common::ScratchBuffer<u32>& buffer, Func&& operation) {
+        DAddr subbits = static_cast<DAddr>(address & page_mask);
+        const u32 base = compressed_device_addr[(address >> page_bits)];
+        if ((base >> MULTI_FLAG_BITS) == 0) [[likely]] {
+            const DAddr d_address = (static_cast<DAddr>(base) << page_bits) + subbits;
+            operation(d_address);
+            return;
+        }
+        InnerGatherDeviceAddresses(buffer, address);
+        for (u32 value : buffer) {
+            operation((static_cast<DAddr>(value) << page_bits) + subbits);
+        }
+    }
+
+    template <typename Func>
+    void ApplyOpOnPointer(const u8* p, Common::ScratchBuffer<u32>& buffer, Func&& operation) {
+        PAddr address = GetRawPhysicalAddr<u8>(p);
+        ApplyOpOnPAddr(address, buffer, operation);
+    }
+
+    PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
+        PAddr subbits = static_cast<PAddr>(address & page_mask);
+        auto paddr = compressed_physical_ptr[(address >> page_bits)];
+        if (paddr == 0) {
+            return 0;
+        }
+        return (static_cast<PAddr>(paddr - 1) << page_bits) + subbits;
+    }
+
+    template <typename T>
+    void Write(DAddr address, T value);
+
+    template <typename T>
+    T Read(DAddr address) const;
+
+    u8* GetSpan(const DAddr src_addr, const std::size_t size);
+    const u8* GetSpan(const DAddr src_addr, const std::size_t size) const;
+
+    void ReadBlock(DAddr address, void* dest_pointer, size_t size);
+    void ReadBlockUnsafe(DAddr address, void* dest_pointer, size_t size);
+    void WriteBlock(DAddr address, const void* src_pointer, size_t size);
+    void WriteBlockUnsafe(DAddr address, const void* src_pointer, size_t size);
+
+    Asid RegisterProcess(Memory::Memory* memory);
+    void UnregisterProcess(Asid id);
+
+    void UpdatePagesCachedCount(DAddr addr, size_t size, s32 delta);
+
+    static constexpr size_t AS_BITS = Traits::device_virtual_bits;
+
+private:
+    static constexpr size_t device_virtual_bits = Traits::device_virtual_bits;
+    static constexpr size_t device_as_size = 1ULL << device_virtual_bits;
+    static constexpr size_t physical_min_bits = 32;
+    static constexpr size_t physical_max_bits = 33;
+    static constexpr size_t page_bits = 12;
+    static constexpr size_t page_size = 1ULL << page_bits;
+    static constexpr size_t page_mask = page_size - 1ULL;
+    static constexpr u32 physical_address_base = 1U << page_bits;
+    static constexpr u32 MULTI_FLAG_BITS = 31;
+    static constexpr u32 MULTI_FLAG = 1U << MULTI_FLAG_BITS;
+    static constexpr u32 MULTI_MASK = ~MULTI_FLAG;
+
+    template <typename T>
+    T* GetPointerFromRaw(PAddr addr) {
+        return reinterpret_cast<T*>(physical_base + addr);
+    }
+
+    template <typename T>
+    const T* GetPointerFromRaw(PAddr addr) const {
+        return reinterpret_cast<T*>(physical_base + addr);
+    }
+
+    template <typename T>
+    PAddr GetRawPhysicalAddr(const T* ptr) const {
+        return static_cast<PAddr>(reinterpret_cast<uintptr_t>(ptr) - physical_base);
+    }
+
+    void WalkBlock(const DAddr addr, const std::size_t size, auto on_unmapped, auto on_memory,
+                   auto increment);
+
+    void InnerGatherDeviceAddresses(Common::ScratchBuffer<u32>& buffer, PAddr address);
+
+    std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;
+
+    const uintptr_t physical_base;
+    DeviceInterface* device_inter;
+    Common::VirtualBuffer<u32> compressed_physical_ptr;
+    Common::VirtualBuffer<u32> compressed_device_addr;
+    Common::VirtualBuffer<u32> continuity_tracker;
+
+    // Process memory interfaces
+
+    std::deque<size_t> id_pool;
+    std::deque<Memory::Memory*> registered_processes;
+
+    // Memory protection management
+
+    static constexpr size_t guest_max_as_bits = 39;
+    static constexpr size_t guest_as_size = 1ULL << guest_max_as_bits;
+    static constexpr size_t guest_mask = guest_as_size - 1ULL;
+    static constexpr size_t asid_start_bit = guest_max_as_bits;
+
+    std::pair<Asid, VAddr> ExtractCPUBacking(size_t page_index) {
+        auto content = cpu_backing_address[page_index];
+        const VAddr address = content & guest_mask;
+        const Asid asid{static_cast<size_t>(content >> asid_start_bit)};
+        return std::make_pair(asid, address);
+    }
+
+    void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
+        cpu_backing_address[page_index] = address | (asid.id << asid_start_bit);
+    }
+
+    Common::VirtualBuffer<VAddr> cpu_backing_address;
+    static constexpr size_t subentries = 8 / sizeof(u8);
+    static constexpr size_t subentries_mask = subentries - 1;
+    class CounterEntry final {
+    public:
+        CounterEntry() = default;
+
+        std::atomic_uint8_t& Count(std::size_t page) {
+            return values[page & subentries_mask];
+        }
+
+        const std::atomic_uint8_t& Count(std::size_t page) const {
+            return values[page & subentries_mask];
+        }
+
+    private:
+        std::array<std::atomic_uint8_t, subentries> values{};
+    };
+    static_assert(sizeof(CounterEntry) == subentries * sizeof(u8),
+                  "CounterEntry should be 8 bytes!");
+
+    static constexpr size_t num_counter_entries =
+        (1ULL << (device_virtual_bits - page_bits)) / subentries;
+    using CachedPages = std::array<CounterEntry, num_counter_entries>;
+    std::unique_ptr<CachedPages> cached_pages;
+    Common::RangeMutex counter_guard;
+    std::mutex mapping_guard;
+};
+
+} // namespace Core

src/core/device_memory_manager.inc

@@ -0,0 +1,572 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <atomic>
+#include <limits>
+#include <memory>
+#include <type_traits>
+
+#include "common/address_space.h"
+#include "common/address_space.inc"
+#include "common/alignment.h"
+#include "common/assert.h"
+#include "common/div_ceil.h"
+#include "common/scope_exit.h"
+#include "common/settings.h"
+#include "core/device_memory.h"
+#include "core/device_memory_manager.h"
+#include "core/memory.h"
+
+namespace Core {
+
+namespace {
+
+class MultiAddressContainer {
+public:
+    MultiAddressContainer() = default;
+    ~MultiAddressContainer() = default;
+
+    void GatherValues(u32 start_entry, Common::ScratchBuffer<u32>& buffer) {
+        buffer.resize(8);
+        buffer.resize(0);
+        size_t index = 0;
+        const auto add_value = [&](u32 value) {
+            buffer.resize(index + 1);
+            buffer[index++] = value;
+        };
+
+        u32 iter_entry = start_entry;
+        Entry* current = &storage[iter_entry - 1];
+        add_value(current->value);
+        while (current->next_entry != 0) {
+            iter_entry = current->next_entry;
+            current = &storage[iter_entry - 1];
+            add_value(current->value);
+        }
+    }
+
+    u32 Register(u32 value) {
+        return RegisterImplementation(value);
+    }
+
+    void Register(u32 value, u32 start_entry) {
+        auto entry_id = RegisterImplementation(value);
+        u32 iter_entry = start_entry;
+        Entry* current = &storage[iter_entry - 1];
+        while (current->next_entry != 0) {
+            iter_entry = current->next_entry;
+            current = &storage[iter_entry - 1];
+        }
+        current->next_entry = entry_id;
+    }
+
+    std::pair<bool, u32> Unregister(u32 value, u32 start_entry) {
+        u32 iter_entry = start_entry;
+        Entry* previous{};
+        Entry* current = &storage[iter_entry - 1];
+        Entry* next{};
+        bool more_than_one_remaining = false;
+        u32 result_start{start_entry};
+        size_t count = 0;
+        while (current->value != value) {
+            count++;
+            previous = current;
+            iter_entry = current->next_entry;
+            current = &storage[iter_entry - 1];
+        }
+        // Find next
+        u32 next_entry = current->next_entry;
+        if (next_entry != 0) {
+            next = &storage[next_entry - 1];
+            more_than_one_remaining = next->next_entry != 0 || previous != nullptr;
+        }
+        if (previous) {
+            previous->next_entry = next_entry;
+        } else {
+            result_start = next_entry;
+        }
+        free_entries.emplace_back(iter_entry);
+        return std::make_pair(more_than_one_remaining || count > 1, result_start);
+    }
+
+    u32 ReleaseEntry(u32 start_entry) {
+        Entry* current = &storage[start_entry - 1];
+        free_entries.emplace_back(start_entry);
+        return current->value;
+    }
+
+private:
+    u32 RegisterImplementation(u32 value) {
+        auto entry_id = GetNewEntry();
+        auto& entry = storage[entry_id - 1];
+        entry.next_entry = 0;
+        entry.value = value;
+        return entry_id;
+    }
+    u32 GetNewEntry() {
+        if (!free_entries.empty()) {
+            u32 result = free_entries.front();
+            free_entries.pop_front();
+            return result;
+        }
+        storage.emplace_back();
+        u32 new_entry = static_cast<u32>(storage.size());
+        return new_entry;
+    }
+
+    struct Entry {
+        u32 next_entry{};
+        u32 value{};
+    };
+
+    std::deque<Entry> storage;
+    std::deque<u32> free_entries;
+};
+
+struct EmptyAllocator {
+    EmptyAllocator([[maybe_unused]] DAddr address) {}
+};
+
+} // namespace
+
+template <typename DTraits>
+struct DeviceMemoryManagerAllocator {
+    static constexpr size_t device_virtual_bits = DTraits::device_virtual_bits;
+    static constexpr DAddr first_address = 1ULL << Memory::YUZU_PAGEBITS;
+    static constexpr DAddr max_device_area = 1ULL << device_virtual_bits;
+
+    DeviceMemoryManagerAllocator() : main_allocator(first_address) {}
+
+    Common::FlatAllocator<DAddr, 0, device_virtual_bits> main_allocator;
+    MultiAddressContainer multi_dev_address;
+
+    /// Returns true when vaddr -> vaddr+size is fully contained in the buffer
+    template <bool pin_area>
+    [[nodiscard]] bool IsInBounds(VAddr addr, u64 size) const noexcept {
+        return addr >= 0 && addr + size <= max_device_area;
+    }
+
+    DAddr Allocate(size_t size) {
+        return main_allocator.Allocate(size);
+    }
+
+    void AllocateFixed(DAddr b_address, size_t b_size) {
+        main_allocator.AllocateFixed(b_address, b_size);
+    }
+
+    void Free(DAddr b_address, size_t b_size) {
+        main_allocator.Free(b_address, b_size);
+    }
+};
+
+template <typename Traits>
+DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
+    : physical_base{reinterpret_cast<const uintptr_t>(device_memory_.buffer.BackingBasePointer())},
+      device_inter{nullptr}, compressed_physical_ptr(device_as_size >> Memory::YUZU_PAGEBITS),
+      compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() ==
+                                               Settings::MemoryLayout::Memory_4Gb
+                                           ? physical_min_bits
+                                           : physical_max_bits) -
+                                      Memory::YUZU_PAGEBITS)),
+      continuity_tracker(device_as_size >> Memory::YUZU_PAGEBITS),
+      cpu_backing_address(device_as_size >> Memory::YUZU_PAGEBITS) {
+    impl = std::make_unique<DeviceMemoryManagerAllocator<Traits>>();
+    cached_pages = std::make_unique<CachedPages>();
+
+    const size_t total_virtual = device_as_size >> Memory::YUZU_PAGEBITS;
+    for (size_t i = 0; i < total_virtual; i++) {
+        compressed_physical_ptr[i] = 0;
+        continuity_tracker[i] = 1;
+        cpu_backing_address[i] = 0;
+    }
+    const size_t total_phys = 1ULL << ((Settings::values.memory_layout_mode.GetValue() ==
+                                                Settings::MemoryLayout::Memory_4Gb
+                                            ? physical_min_bits
+                                            : physical_max_bits) -
+                                       Memory::YUZU_PAGEBITS);
+    for (size_t i = 0; i < total_phys; i++) {
+        compressed_device_addr[i] = 0;
+    }
+}
+
+template <typename Traits>
+DeviceMemoryManager<Traits>::~DeviceMemoryManager() = default;
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::BindInterface(DeviceInterface* device_inter_) {
+    device_inter = device_inter_;
+}
+
+template <typename Traits>
+DAddr DeviceMemoryManager<Traits>::Allocate(size_t size) {
+    return impl->Allocate(size);
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::AllocateFixed(DAddr start, size_t size) {
+    return impl->AllocateFixed(start, size);
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::Free(DAddr start, size_t size) {
+    impl->Free(start, size);
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size_t size,
+                                      Asid asid, bool track) {
+    Core::Memory::Memory* process_memory = registered_processes[asid.id];
+    size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
+    size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
+    std::scoped_lock lk(mapping_guard);
+    for (size_t i = 0; i < num_pages; i++) {
+        const VAddr new_vaddress = virtual_address + i * Memory::YUZU_PAGESIZE;
+        auto* ptr = process_memory->GetPointerSilent(Common::ProcessAddress(new_vaddress));
+        if (ptr == nullptr) [[unlikely]] {
+            compressed_physical_ptr[start_page_d + i] = 0;
+            continue;
+        }
+        auto phys_addr = static_cast<u32>(GetRawPhysicalAddr(ptr) >> Memory::YUZU_PAGEBITS) + 1U;
+        compressed_physical_ptr[start_page_d + i] = phys_addr;
+        InsertCPUBacking(start_page_d + i, new_vaddress, asid);
+        const u32 base_dev = compressed_device_addr[phys_addr - 1U];
+        const u32 new_dev = static_cast<u32>(start_page_d + i);
+        if (base_dev == 0) [[likely]] {
+            compressed_device_addr[phys_addr - 1U] = new_dev;
+            continue;
+        }
+        u32 start_id = base_dev & MULTI_MASK;
+        if ((base_dev >> MULTI_FLAG_BITS) == 0) {
+            start_id = impl->multi_dev_address.Register(base_dev);
+            compressed_device_addr[phys_addr - 1U] = MULTI_FLAG | start_id;
+        }
+        impl->multi_dev_address.Register(new_dev, start_id);
+    }
+    if (track) {
+        TrackContinuityImpl(address, virtual_address, size, asid);
+    }
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::Unmap(DAddr address, size_t size) {
+    size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
+    size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
+    device_inter->InvalidateRegion(address, size);
+    std::scoped_lock lk(mapping_guard);
+    for (size_t i = 0; i < num_pages; i++) {
+        auto phys_addr = compressed_physical_ptr[start_page_d + i];
+        compressed_physical_ptr[start_page_d + i] = 0;
+        cpu_backing_address[start_page_d + i] = 0;
+        if (phys_addr != 0) [[likely]] {
+            const u32 base_dev = compressed_device_addr[phys_addr - 1U];
+            if ((base_dev >> MULTI_FLAG_BITS) == 0) [[likely]] {
+                compressed_device_addr[phys_addr - 1] = 0;
+                continue;
+            }
+            const auto [more_entries, new_start] = impl->multi_dev_address.Unregister(
+                static_cast<u32>(start_page_d + i), base_dev & MULTI_MASK);
+            if (!more_entries) {
+                compressed_device_addr[phys_addr - 1] =
+                    impl->multi_dev_address.ReleaseEntry(new_start);
+                continue;
+            }
+            compressed_device_addr[phys_addr - 1] = new_start | MULTI_FLAG;
+        }
+    }
+}
+template <typename Traits>
+void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtual_address,
+                                                      size_t size, Asid asid) {
+    Core::Memory::Memory* process_memory = registered_processes[asid.id];
+    size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
+    size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
+    uintptr_t last_ptr = 0;
+    size_t page_count = 1;
+    for (size_t i = num_pages; i > 0; i--) {
+        size_t index = i - 1;
+        const VAddr new_vaddress = virtual_address + index * Memory::YUZU_PAGESIZE;
+        const uintptr_t new_ptr = reinterpret_cast<uintptr_t>(
+            process_memory->GetPointerSilent(Common::ProcessAddress(new_vaddress)));
+        if (new_ptr + page_size == last_ptr) {
+            page_count++;
+        } else {
+            page_count = 1;
+        }
+        last_ptr = new_ptr;
+        continuity_tracker[start_page_d + index] = static_cast<u32>(page_count);
+    }
+}
+template <typename Traits>
+u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) {
+    size_t page_index = src_addr >> page_bits;
+    size_t subbits = src_addr & page_mask;
+    if ((static_cast<size_t>(continuity_tracker[page_index]) << page_bits) >= size + subbits) {
+        return GetPointer<u8>(src_addr);
+    }
+    return nullptr;
+}
+
+template <typename Traits>
+const u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) const {
+    size_t page_index = src_addr >> page_bits;
+    size_t subbits = src_addr & page_mask;
+    if ((static_cast<size_t>(continuity_tracker[page_index]) << page_bits) >= size + subbits) {
+        return GetPointer<u8>(src_addr);
+    }
+    return nullptr;
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::InnerGatherDeviceAddresses(Common::ScratchBuffer<u32>& buffer,
+                                                             PAddr address) {
+    size_t phys_addr = address >> page_bits;
+    std::scoped_lock lk(mapping_guard);
+    u32 backing = compressed_device_addr[phys_addr];
+    if ((backing >> MULTI_FLAG_BITS) != 0) {
+        impl->multi_dev_address.GatherValues(backing & MULTI_MASK, buffer);
+        return;
+    }
+    buffer.resize(1);
+    buffer[0] = backing;
+}
+
+template <typename Traits>
+template <typename T>
+T* DeviceMemoryManager<Traits>::GetPointer(DAddr address) {
+    const size_t index = address >> Memory::YUZU_PAGEBITS;
+    const size_t offset = address & Memory::YUZU_PAGEMASK;
+    auto phys_addr = compressed_physical_ptr[index];
+    if (phys_addr == 0) [[unlikely]] {
+        return nullptr;
+    }
+    return GetPointerFromRaw<T>((static_cast<PAddr>(phys_addr - 1) << Memory::YUZU_PAGEBITS) +
+                                offset);
+}
+
+template <typename Traits>
+template <typename T>
+const T* DeviceMemoryManager<Traits>::GetPointer(DAddr address) const {
+    const size_t index = address >> Memory::YUZU_PAGEBITS;
+    const size_t offset = address & Memory::YUZU_PAGEMASK;
+    auto phys_addr = compressed_physical_ptr[index];
+    if (phys_addr == 0) [[unlikely]] {
+        return nullptr;
+    }
+    return GetPointerFromRaw<T>((static_cast<PAddr>(phys_addr - 1) << Memory::YUZU_PAGEBITS) +
+                                offset);
+}
+
+template <typename Traits>
+template <typename T>
+void DeviceMemoryManager<Traits>::Write(DAddr address, T value) {
+    T* ptr = GetPointer<T>(address);
+    if (!ptr) [[unlikely]] {
+        return;
+    }
+    std::memcpy(ptr, &value, sizeof(T));
+}
+
+template <typename Traits>
+template <typename T>
+T DeviceMemoryManager<Traits>::Read(DAddr address) const {
+    const T* ptr = GetPointer<T>(address);
+    T result{};
+    if (!ptr) [[unlikely]] {
+        return result;
+    }
+    std::memcpy(&result, ptr, sizeof(T));
+    return result;
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::WalkBlock(DAddr addr, std::size_t size, auto on_unmapped,
+                                            auto on_memory, auto increment) {
+    std::size_t remaining_size = size;
+    std::size_t page_index = addr >> Memory::YUZU_PAGEBITS;
+    std::size_t page_offset = addr & Memory::YUZU_PAGEMASK;
+
+    while (remaining_size) {
+        const size_t next_pages = static_cast<std::size_t>(continuity_tracker[page_index]);
+        const std::size_t copy_amount =
+            std::min((next_pages << Memory::YUZU_PAGEBITS) - page_offset, remaining_size);
+        const auto current_vaddr =
+            static_cast<u64>((page_index << Memory::YUZU_PAGEBITS) + page_offset);
+        SCOPE_EXIT({
+            page_index += next_pages;
+            page_offset = 0;
+            increment(copy_amount);
+            remaining_size -= copy_amount;
+        });
+
+        auto phys_addr = compressed_physical_ptr[page_index];
+        if (phys_addr == 0) {
+            on_unmapped(copy_amount, current_vaddr);
+            continue;
+        }
+        auto* mem_ptr = GetPointerFromRaw<u8>(
+            (static_cast<PAddr>(phys_addr - 1) << Memory::YUZU_PAGEBITS) + page_offset);
+        on_memory(copy_amount, mem_ptr);
+    }
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::ReadBlock(DAddr address, void* dest_pointer, size_t size) {
+    device_inter->FlushRegion(address, size);
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_ERROR(
+                HW_Memory,
+                "Unmapped Device ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                current_vaddr, address, size);
+            std::memset(dest_pointer, 0, copy_amount);
+        },
+        [&](size_t copy_amount, const u8* const src_ptr) {
+            std::memcpy(dest_pointer, src_ptr, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            dest_pointer = static_cast<u8*>(dest_pointer) + copy_amount;
+        });
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::WriteBlock(DAddr address, const void* src_pointer, size_t size) {
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_ERROR(
+                HW_Memory,
+                "Unmapped Device WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                current_vaddr, address, size);
+        },
+        [&](size_t copy_amount, u8* const dst_ptr) {
+            std::memcpy(dst_ptr, src_pointer, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            src_pointer = static_cast<const u8*>(src_pointer) + copy_amount;
+        });
+    device_inter->InvalidateRegion(address, size);
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::ReadBlockUnsafe(DAddr address, void* dest_pointer, size_t size) {
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_ERROR(
+                HW_Memory,
+                "Unmapped Device ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                current_vaddr, address, size);
+            std::memset(dest_pointer, 0, copy_amount);
+        },
+        [&](size_t copy_amount, const u8* const src_ptr) {
+            std::memcpy(dest_pointer, src_ptr, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            dest_pointer = static_cast<u8*>(dest_pointer) + copy_amount;
+        });
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::WriteBlockUnsafe(DAddr address, const void* src_pointer,
+                                                   size_t size) {
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_ERROR(
+                HW_Memory,
+                "Unmapped Device WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                current_vaddr, address, size);
+        },
+        [&](size_t copy_amount, u8* const dst_ptr) {
+            std::memcpy(dst_ptr, src_pointer, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            src_pointer = static_cast<const u8*>(src_pointer) + copy_amount;
+        });
+}
+
+template <typename Traits>
+Asid DeviceMemoryManager<Traits>::RegisterProcess(Memory::Memory* memory_device_inter) {
+    size_t new_id{};
+    if (!id_pool.empty()) {
+        new_id = id_pool.front();
+        id_pool.pop_front();
+        registered_processes[new_id] = memory_device_inter;
+    } else {
+        registered_processes.emplace_back(memory_device_inter);
+        new_id = registered_processes.size() - 1U;
+    }
+    return Asid{new_id};
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::UnregisterProcess(Asid asid) {
+    registered_processes[asid.id] = nullptr;
+    id_pool.push_front(asid.id);
+}
+
+template <typename Traits>
+void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size, s32 delta) {
+    Common::ScopedRangeLock lk(counter_guard, addr, size);
+    u64 uncache_begin = 0;
+    u64 cache_begin = 0;
+    u64 uncache_bytes = 0;
+    u64 cache_bytes = 0;
+    const auto MarkRegionCaching = &DeviceMemoryManager<Traits>::DeviceMethods::MarkRegionCaching;
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+    const size_t page_end = Common::DivCeil(addr + size, Memory::YUZU_PAGESIZE);
+    size_t page = addr >> Memory::YUZU_PAGEBITS;
+    auto [asid, base_vaddress] = ExtractCPUBacking(page);
+    size_t vpage = base_vaddress >> Memory::YUZU_PAGEBITS;
+    auto* memory_device_inter = registered_processes[asid.id];
+    for (; page != page_end; ++page) {
+        std::atomic_uint8_t& count = cached_pages->at(page >> 3).Count(page);
+
+        if (delta > 0) {
+            ASSERT_MSG(count.load(std::memory_order::relaxed) < std::numeric_limits<u8>::max(),
+                       "Count may overflow!");
+        } else if (delta < 0) {
+            ASSERT_MSG(count.load(std::memory_order::relaxed) > 0, "Count may underflow!");
+        } else {
+            ASSERT_MSG(false, "Delta must be non-zero!");
+        }
+
+        // Adds or subtracts 1, as count is a unsigned 8-bit value
+        count.fetch_add(static_cast<u8>(delta), std::memory_order_release);
+
+        // Assume delta is either -1 or 1
+        if (count.load(std::memory_order::relaxed) == 0) {
+            if (uncache_bytes == 0) {
+                uncache_begin = vpage;
+            }
+            uncache_bytes += Memory::YUZU_PAGESIZE;
+        } else if (uncache_bytes > 0) {
+            MarkRegionCaching(memory_device_inter, uncache_begin << Memory::YUZU_PAGEBITS,
+                              uncache_bytes, false);
+            uncache_bytes = 0;
+        }
+        if (count.load(std::memory_order::relaxed) == 1 && delta > 0) {
+            if (cache_bytes == 0) {
+                cache_begin = vpage;
+            }
+            cache_bytes += Memory::YUZU_PAGESIZE;
+        } else if (cache_bytes > 0) {
+            MarkRegionCaching(memory_device_inter, cache_begin << Memory::YUZU_PAGEBITS, cache_bytes,
+                              true);
+            cache_bytes = 0;
+        }
+        vpage++;
+    }
+    if (uncache_bytes > 0) {
+        MarkRegionCaching(memory_device_inter, uncache_begin << Memory::YUZU_PAGEBITS, uncache_bytes,
+                          false);
+    }
+    if (cache_bytes > 0) {
+        MarkRegionCaching(memory_device_inter, cache_begin << Memory::YUZU_PAGEBITS, cache_bytes,
+                          true);
+    }
+}
+
+} // namespace Core

src/core/file_sys/system_archive/system_archive.cpp

@@ -67,25 +67,29 @@ constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHI
 }};
 
 VirtualFile SynthesizeSystemArchive(const u64 title_id) {
-    if (title_id < SYSTEM_ARCHIVES.front().title_id || title_id > SYSTEM_ARCHIVES.back().title_id)
+    if (title_id < SYSTEM_ARCHIVES.front().title_id || title_id > SYSTEM_ARCHIVES.back().title_id) {
         return nullptr;
+    }
 
     const auto& desc = SYSTEM_ARCHIVES[title_id - SYSTEM_ARCHIVE_BASE_TITLE_ID];
 
     LOG_INFO(Service_FS, "Synthesizing system archive '{}' (0x{:016X}).", desc.name, desc.title_id);
 
-    if (desc.supplier == nullptr)
+    if (desc.supplier == nullptr) {
         return nullptr;
+    }
 
     const auto dir = desc.supplier();
 
-    if (dir == nullptr)
+    if (dir == nullptr) {
         return nullptr;
+    }
 
     const auto romfs = CreateRomFS(dir);
 
-    if (romfs == nullptr)
+    if (romfs == nullptr) {
         return nullptr;
+    }
 
     LOG_INFO(Service_FS, "    - System archive generation successful!");
     return romfs;

src/core/file_sys/system_archive/time_zone_binary.cpp

@@ -6,7 +6,6 @@
 #include "common/swap.h"
 #include "core/file_sys/system_archive/time_zone_binary.h"
 #include "core/file_sys/vfs_vector.h"
-#include "core/hle/service/time/time_zone_types.h"
 
 #include "nx_tzdb.h"
 

src/core/gpu_dirty_memory_manager.h

@@ -10,7 +10,7 @@
 #include <utility>
 #include <vector>
 
-#include "core/memory.h"
+#include "core/device_memory_manager.h"
 
 namespace Core {
 
@@ -23,7 +23,7 @@ public:
 
     ~GPUDirtyMemoryManager() = default;
 
-    void Collect(VAddr address, size_t size) {
+    void Collect(PAddr address, size_t size) {
         TransformAddress t = BuildTransform(address, size);
         TransformAddress tmp, original;
         do {
@@ -47,7 +47,7 @@ public:
                                                 std::memory_order_relaxed));
     }
 
-    void Gather(std::function<void(VAddr, size_t)>& callback) {
+    void Gather(std::function<void(PAddr, size_t)>& callback) {
         {
             std::scoped_lock lk(guard);
             TransformAddress t = current.exchange(default_transform, std::memory_order_relaxed);
@@ -65,7 +65,7 @@ public:
                 mask = mask >> empty_bits;
 
                 const size_t continuous_bits = std::countr_one(mask);
-                callback((static_cast<VAddr>(transform.address) << page_bits) + offset,
+                callback((static_cast<PAddr>(transform.address) << page_bits) + offset,
                          continuous_bits << align_bits);
                 mask = continuous_bits < align_size ? (mask >> continuous_bits) : 0;
                 offset += continuous_bits << align_bits;
@@ -80,7 +80,7 @@ private:
         u32 mask;
     };
 
-    constexpr static size_t page_bits = Memory::YUZU_PAGEBITS - 1;
+    constexpr static size_t page_bits = DEVICE_PAGEBITS - 1;
     constexpr static size_t page_size = 1ULL << page_bits;
     constexpr static size_t page_mask = page_size - 1;
 
@@ -89,7 +89,7 @@ private:
     constexpr static size_t align_mask = align_size - 1;
     constexpr static TransformAddress default_transform = {.address = ~0U, .mask = 0U};
 
-    bool IsValid(VAddr address) {
+    bool IsValid(PAddr address) {
         return address < (1ULL << 39);
     }
 
@@ -103,7 +103,7 @@ private:
         return mask;
     }
 
-    TransformAddress BuildTransform(VAddr address, size_t size) {
+    TransformAddress BuildTransform(PAddr address, size_t size) {
         const size_t minor_address = address & page_mask;
         const size_t minor_bit = minor_address >> align_bits;
         const size_t top_bit = (minor_address + size + align_mask) >> align_bits;

src/core/guest_memory.h

@@ -0,0 +1,214 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <span>
+#include <vector>
+
+#include "common/assert.h"
+#include "common/scratch_buffer.h"
+
+namespace Core::Memory {
+
+enum GuestMemoryFlags : u32 {
+    Read = 1 << 0,
+    Write = 1 << 1,
+    Safe = 1 << 2,
+    Cached = 1 << 3,
+
+    SafeRead = Read | Safe,
+    SafeWrite = Write | Safe,
+    SafeReadWrite = SafeRead | SafeWrite,
+    SafeReadCachedWrite = SafeReadWrite | Cached,
+
+    UnsafeRead = Read,
+    UnsafeWrite = Write,
+    UnsafeReadWrite = UnsafeRead | UnsafeWrite,
+    UnsafeReadCachedWrite = UnsafeReadWrite | Cached,
+};
+
+namespace {
+template <typename M, typename T, GuestMemoryFlags FLAGS>
+class GuestMemory {
+    using iterator = T*;
+    using const_iterator = const T*;
+    using value_type = T;
+    using element_type = T;
+    using iterator_category = std::contiguous_iterator_tag;
+
+public:
+    GuestMemory() = delete;
+    explicit GuestMemory(M& memory, u64 addr, std::size_t size,
+                         Common::ScratchBuffer<T>* backup = nullptr)
+        : m_memory{memory}, m_addr{addr}, m_size{size} {
+        static_assert(FLAGS & GuestMemoryFlags::Read || FLAGS & GuestMemoryFlags::Write);
+        if constexpr (FLAGS & GuestMemoryFlags::Read) {
+            Read(addr, size, backup);
+        }
+    }
+
+    ~GuestMemory() = default;
+
+    T* data() noexcept {
+        return m_data_span.data();
+    }
+
+    const T* data() const noexcept {
+        return m_data_span.data();
+    }
+
+    size_t size() const noexcept {
+        return m_size;
+    }
+
+    size_t size_bytes() const noexcept {
+        return this->size() * sizeof(T);
+    }
+
+    [[nodiscard]] T* begin() noexcept {
+        return this->data();
+    }
+
+    [[nodiscard]] const T* begin() const noexcept {
+        return this->data();
+    }
+
+    [[nodiscard]] T* end() noexcept {
+        return this->data() + this->size();
+    }
+
+    [[nodiscard]] const T* end() const noexcept {
+        return this->data() + this->size();
+    }
+
+    T& operator[](size_t index) noexcept {
+        return m_data_span[index];
+    }
+
+    const T& operator[](size_t index) const noexcept {
+        return m_data_span[index];
+    }
+
+    void SetAddressAndSize(u64 addr, std::size_t size) noexcept {
+        m_addr = addr;
+        m_size = size;
+        m_addr_changed = true;
+    }
+
+    std::span<T> Read(u64 addr, std::size_t size,
+                      Common::ScratchBuffer<T>* backup = nullptr) noexcept {
+        m_addr = addr;
+        m_size = size;
+        if (m_size == 0) {
+            m_is_data_copy = true;
+            return {};
+        }
+
+        if (this->TrySetSpan()) {
+            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
+                m_memory.FlushRegion(m_addr, this->size_bytes());
+            }
+        } else {
+            if (backup) {
+                backup->resize_destructive(this->size());
+                m_data_span = *backup;
+            } else {
+                m_data_copy.resize(this->size());
+                m_data_span = std::span(m_data_copy);
+            }
+            m_is_data_copy = true;
+            m_span_valid = true;
+            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
+                m_memory.ReadBlock(m_addr, this->data(), this->size_bytes());
+            } else {
+                m_memory.ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
+            }
+        }
+        return m_data_span;
+    }
+
+    void Write(std::span<T> write_data) noexcept {
+        if constexpr (FLAGS & GuestMemoryFlags::Cached) {
+            m_memory.WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
+        } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
+            m_memory.WriteBlock(m_addr, write_data.data(), this->size_bytes());
+        } else {
+            m_memory.WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
+        }
+    }
+
+    bool TrySetSpan() noexcept {
+        if (u8* ptr = m_memory.GetSpan(m_addr, this->size_bytes()); ptr) {
+            m_data_span = {reinterpret_cast<T*>(ptr), this->size()};
+            m_span_valid = true;
+            return true;
+        }
+        return false;
+    }
+
+protected:
+    bool IsDataCopy() const noexcept {
+        return m_is_data_copy;
+    }
+
+    bool AddressChanged() const noexcept {
+        return m_addr_changed;
+    }
+
+    M& m_memory;
+    u64 m_addr{};
+    size_t m_size{};
+    std::span<T> m_data_span{};
+    std::vector<T> m_data_copy{};
+    bool m_span_valid{false};
+    bool m_is_data_copy{false};
+    bool m_addr_changed{false};
+};
+
+template <typename M, typename T, GuestMemoryFlags FLAGS>
+class GuestMemoryScoped : public GuestMemory<M, T, FLAGS> {
+public:
+    GuestMemoryScoped() = delete;
+    explicit GuestMemoryScoped(M& memory, u64 addr, std::size_t size,
+                               Common::ScratchBuffer<T>* backup = nullptr)
+        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {
+        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
+            if (!this->TrySetSpan()) {
+                if (backup) {
+                    this->m_data_span = *backup;
+                    this->m_span_valid = true;
+                    this->m_is_data_copy = true;
+                }
+            }
+        }
+    }
+
+    ~GuestMemoryScoped() {
+        if constexpr (FLAGS & GuestMemoryFlags::Write) {
+            if (this->size() == 0) [[unlikely]] {
+                return;
+            }
+
+            if (this->AddressChanged() || this->IsDataCopy()) {
+                ASSERT(this->m_span_valid);
+                if constexpr (FLAGS & GuestMemoryFlags::Cached) {
+                    this->m_memory.WriteBlockCached(this->m_addr, this->data(), this->size_bytes());
+                } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
+                    this->m_memory.WriteBlock(this->m_addr, this->data(), this->size_bytes());
+                } else {
+                    this->m_memory.WriteBlockUnsafe(this->m_addr, this->data(), this->size_bytes());
+                }
+            } else if constexpr ((FLAGS & GuestMemoryFlags::Safe) ||
+                                 (FLAGS & GuestMemoryFlags::Cached)) {
+                this->m_memory.InvalidateRegion(this->m_addr, this->size_bytes());
+            }
+        }
+    }
+};
+} // namespace
+
+} // namespace Core::Memory

src/core/hle/kernel/k_page_table_base.cpp

@@ -69,9 +69,14 @@ public:
 };
 
 template <typename AddressType>
-void InvalidateInstructionCache(KernelCore& kernel, AddressType addr, u64 size) {
+void InvalidateInstructionCache(KernelCore& kernel, KPageTableBase* table, AddressType addr,
+                                u64 size) {
     // TODO: lock the process list
     for (auto& process : kernel.GetProcessList()) {
+        if (std::addressof(process->GetPageTable().GetBasePageTable()) != table) {
+            continue;
+        }
+
         for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
             auto* interface = process->GetArmInterface(i);
             if (interface) {
@@ -1302,7 +1307,7 @@ Result KPageTableBase::UnmapCodeMemory(KProcessAddress dst_address, KProcessAddr
     bool reprotected_pages = false;
     SCOPE_EXIT({
         if (reprotected_pages && any_code_pages) {
-            InvalidateInstructionCache(m_kernel, dst_address, size);
+            InvalidateInstructionCache(m_kernel, this, dst_address, size);
         }
     });
 
@@ -2036,7 +2041,7 @@ Result KPageTableBase::SetProcessMemoryPermission(KProcessAddress addr, size_t s
         for (const auto& block : pg) {
             StoreDataCache(GetHeapVirtualPointer(m_kernel, block.GetAddress()), block.GetSize());
         }
-        InvalidateInstructionCache(m_kernel, addr, size);
+        InvalidateInstructionCache(m_kernel, this, addr, size);
     }
 
     R_SUCCEED();
@@ -3277,7 +3282,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     R_TRY(PerformCopy());
 
     // Invalidate the instruction cache, as this svc allows modifying executable pages.
-    InvalidateInstructionCache(m_kernel, dst_address, size);
+    InvalidateInstructionCache(m_kernel, this, dst_address, size);
 
     R_SUCCEED();
 }

src/core/hle/kernel/k_process.cpp

@@ -5,6 +5,7 @@
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/core.h"
+#include "core/gpu_dirty_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
@@ -320,7 +321,7 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params, const KPa
 
     // Ensure our memory is initialized.
     m_memory.SetCurrentPageTable(*this);
-    m_memory.SetGPUDirtyManagers(m_dirty_memory_managers);
+    m_memory.SetGPUDirtyManagers(m_kernel.System().GetGPUDirtyMemoryManager());
 
     // Ensure we can insert the code region.
     R_UNLESS(m_page_table.CanContain(params.code_address, params.code_num_pages * PageSize,
@@ -417,7 +418,7 @@ Result KProcess::Initialize(const Svc::CreateProcessParameter& params,
 
     // Ensure our memory is initialized.
     m_memory.SetCurrentPageTable(*this);
-    m_memory.SetGPUDirtyManagers(m_dirty_memory_managers);
+    m_memory.SetGPUDirtyManagers(m_kernel.System().GetGPUDirtyMemoryManager());
 
     // Ensure we can insert the code region.
     R_UNLESS(m_page_table.CanContain(params.code_address, code_size, KMemoryState::Code),
@@ -1141,8 +1142,7 @@ void KProcess::Switch(KProcess* cur_process, KProcess* next_process) {}
 KProcess::KProcess(KernelCore& kernel)
     : KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel}, m_state_lock{kernel},
       m_list_lock{kernel}, m_cond_var{kernel.System()}, m_address_arbiter{kernel.System()},
-      m_handle_table{kernel}, m_dirty_memory_managers{},
+      m_handle_table{kernel}, m_exclusive_monitor{}, m_memory{kernel.System()} {}
-      m_exclusive_monitor{}, m_memory{kernel.System()} {}
 KProcess::~KProcess() = default;
 
 Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
@@ -1324,10 +1324,4 @@ bool KProcess::RemoveWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointT
     return true;
 }
 
-void KProcess::GatherGPUDirtyMemory(std::function<void(VAddr, size_t)>& callback) {
-    for (auto& manager : m_dirty_memory_managers) {
-        manager.Gather(callback);
-    }
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_process.h

@@ -7,7 +7,6 @@
 
 #include "core/arm/arm_interface.h"
 #include "core/file_sys/program_metadata.h"
-#include "core/gpu_dirty_memory_manager.h"
 #include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/k_address_arbiter.h"
 #include "core/hle/kernel/k_capabilities.h"
@@ -128,7 +127,6 @@ private:
 #ifdef HAS_NCE
     std::unordered_map<u64, u64> m_post_handlers{};
 #endif
-    std::array<Core::GPUDirtyMemoryManager, Core::Hardware::NUM_CPU_CORES> m_dirty_memory_managers;
     std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor;
     Core::Memory::Memory m_memory;
 
@@ -511,8 +509,6 @@ public:
         return m_memory;
     }
 
-    void GatherGPUDirtyMemory(std::function<void(VAddr, size_t)>& callback);
-
     Core::ExclusiveMonitor& GetExclusiveMonitor() const {
         return *m_exclusive_monitor;
     }

src/core/hle/service/caps/caps_manager.cpp

@@ -10,8 +10,10 @@
 #include "core/core.h"
 #include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_result.h"
-#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/glue/time/static.h"
-#include "core/hle/service/time/time_zone_content_manager.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
 
 namespace Service::Capture {
 
@@ -239,10 +241,15 @@ Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
                                     const ApplicationData& app_data, std::span<const u8> image_data,
                                     u64 aruid) {
     const u64 title_id = system.GetApplicationProcessProgramID();
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
+
+    auto static_service =
+        system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> user_clock{};
+    static_service->GetStandardUserSystemClock(user_clock);
 
     s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
+    auto result = user_clock->GetCurrentTime(posix_time);
 
     if (result.IsError()) {
         return result;
@@ -257,10 +264,14 @@ Result AlbumManager::SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
                                           const ScreenShotAttribute& attribute,
                                           const AlbumFileId& file_id,
                                           std::span<const u8> image_data) {
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
+    auto static_service =
+        system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> user_clock{};
+    static_service->GetStandardUserSystemClock(user_clock);
 
     s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
+    auto result = user_clock->GetCurrentTime(posix_time);
 
     if (result.IsError()) {
         return result;
@@ -455,19 +466,23 @@ Result AlbumManager::SaveImage(ApplicationAlbumEntry& out_entry, std::span<const
 }
 
 AlbumFileDateTime AlbumManager::ConvertToAlbumDateTime(u64 posix_time) const {
-    Time::TimeZone::CalendarInfo calendar_date{};
+    auto static_service =
-    const auto& time_zone_manager =
+        system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
-        system.GetTimeManager().GetTimeZoneContentManager().GetTimeZoneManager();
 
-    time_zone_manager.ToCalendarTimeWithMyRules(posix_time, calendar_date);
+    std::shared_ptr<Service::Glue::Time::TimeZoneService> timezone_service{};
+    static_service->GetTimeZoneService(timezone_service);
+
+    Service::PSC::Time::CalendarTime calendar_time{};
+    Service::PSC::Time::CalendarAdditionalInfo additional_info{};
+    timezone_service->ToCalendarTimeWithMyRule(calendar_time, additional_info, posix_time);
 
     return {
-        .year = calendar_date.time.year,
+        .year = calendar_time.year,
-        .month = calendar_date.time.month,
+        .month = calendar_time.month,
-        .day = calendar_date.time.day,
+        .day = calendar_time.day,
-        .hour = calendar_date.time.hour,
+        .hour = calendar_time.hour,
-        .minute = calendar_date.time.minute,
+        .minute = calendar_time.minute,
-        .second = calendar_date.time.second,
+        .second = calendar_time.second,
         .unique_id = 0,
     };
 }

src/core/hle/service/glue/glue.cpp

@@ -8,6 +8,9 @@
 #include "core/hle/service/glue/ectx.h"
 #include "core/hle/service/glue/glue.h"
 #include "core/hle/service/glue/notif.h"
+#include "core/hle/service/glue/time/manager.h"
+#include "core/hle/service/glue/time/static.h"
+#include "core/hle/service/psc/time/common.h"
 #include "core/hle/service/server_manager.h"
 
 namespace Service::Glue {
@@ -31,6 +34,22 @@ void LoopProcess(Core::System& system) {
     // Notification Services for application
     server_manager->RegisterNamedService("notif:a", std::make_shared<NOTIF_A>(system));
 
+    // Time
+    auto time = std::make_shared<Time::TimeManager>(system);
+
+    server_manager->RegisterNamedService(
+        "time:u",
+        std::make_shared<Time::StaticService>(
+            system, Service::PSC::Time::StaticServiceSetupInfo{0, 0, 0, 0, 0, 0}, time, "time:u"));
+    server_manager->RegisterNamedService(
+        "time:a",
+        std::make_shared<Time::StaticService>(
+            system, Service::PSC::Time::StaticServiceSetupInfo{1, 1, 0, 1, 0, 0}, time, "time:a"));
+    server_manager->RegisterNamedService(
+        "time:r",
+        std::make_shared<Time::StaticService>(
+            system, Service::PSC::Time::StaticServiceSetupInfo{0, 0, 0, 0, 1, 0}, time, "time:r"));
+
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/glue/time/alarm_worker.cpp

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/service/glue/time/alarm_worker.h"
+#include "core/hle/service/psc/time/service_manager.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Glue::Time {
+
+AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource)
+    : m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, m_steady_clock_resource{
+                                                               steady_clock_resource} {}
+
+AlarmWorker::~AlarmWorker() {
+    m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
+
+    m_ctx.CloseEvent(m_timer_event);
+}
+
+void AlarmWorker::Initialize(std::shared_ptr<Service::PSC::Time::ServiceManager> time_m) {
+    m_time_m = std::move(time_m);
+
+    m_timer_event = m_ctx.CreateEvent("Glue:AlarmWorker:TimerEvent");
+    m_timer_timing_event = Core::Timing::CreateEvent(
+        "Glue:AlarmWorker::AlarmTimer",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            m_timer_event->Signal();
+            return std::nullopt;
+        });
+
+    AttachToClosestAlarmEvent();
+}
+
+bool AlarmWorker::GetClosestAlarmInfo(Service::PSC::Time::AlarmInfo& out_alarm_info,
+                                      s64& out_time) {
+    bool is_valid{};
+    Service::PSC::Time::AlarmInfo alarm_info{};
+    s64 closest_time{};
+
+    auto res = m_time_m->GetClosestAlarmInfo(is_valid, alarm_info, closest_time);
+    ASSERT(res == ResultSuccess);
+
+    if (is_valid) {
+        out_alarm_info = alarm_info;
+        out_time = closest_time;
+    }
+
+    return is_valid;
+}
+
+void AlarmWorker::OnPowerStateChanged() {
+    Service::PSC::Time::AlarmInfo closest_alarm_info{};
+    s64 closest_time{};
+    if (!GetClosestAlarmInfo(closest_alarm_info, closest_time)) {
+        m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
+        m_timer_event->Clear();
+        return;
+    }
+
+    if (closest_alarm_info.alert_time <= closest_time) {
+        m_time_m->CheckAndSignalAlarms();
+    } else {
+        auto next_time{closest_alarm_info.alert_time - closest_time};
+
+        m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
+        m_timer_event->Clear();
+
+        m_system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds(next_time),
+                                            m_timer_timing_event);
+    }
+}
+
+Result AlarmWorker::AttachToClosestAlarmEvent() {
+    m_time_m->GetClosestAlarmUpdatedEvent(&m_event);
+    R_SUCCEED();
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/alarm_worker.h

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/psc/time/common.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::PSC::Time {
+class ServiceManager;
+}
+
+namespace Service::Glue::Time {
+class StandardSteadyClockResource;
+
+class AlarmWorker {
+public:
+    explicit AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource);
+    ~AlarmWorker();
+
+    void Initialize(std::shared_ptr<Service::PSC::Time::ServiceManager> time_m);
+
+    Kernel::KEvent& GetEvent() {
+        return *m_event;
+    }
+
+    Kernel::KEvent& GetTimerEvent() {
+        return *m_timer_event;
+    }
+
+    void OnPowerStateChanged();
+
+private:
+    bool GetClosestAlarmInfo(Service::PSC::Time::AlarmInfo& out_alarm_info, s64& out_time);
+    Result AttachToClosestAlarmEvent();
+
+    Core::System& m_system;
+    KernelHelpers::ServiceContext m_ctx;
+    std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m;
+
+    Kernel::KEvent* m_event{};
+    Kernel::KEvent* m_timer_event{};
+    std::shared_ptr<Core::Timing::EventType> m_timer_timing_event;
+    StandardSteadyClockResource& m_steady_clock_resource;
+};
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/file_timestamp_worker.cpp

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/glue/time/file_timestamp_worker.h"
+#include "core/hle/service/psc/time/common.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/psc/time/time_zone_service.h"
+
+namespace Service::Glue::Time {
+
+void FileTimestampWorker::SetFilesystemPosixTime() {
+    s64 time{};
+    Service::PSC::Time::CalendarTime calendar_time{};
+    Service::PSC::Time::CalendarAdditionalInfo additional_info{};
+
+    if (m_initialized && m_system_clock->GetCurrentTime(time) == ResultSuccess &&
+        m_time_zone->ToCalendarTimeWithMyRule(calendar_time, additional_info, time) ==
+            ResultSuccess) {
+        // TODO IFileSystemProxy::SetCurrentPosixTime
+    }
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/file_timestamp_worker.h

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+
+namespace Service::PSC::Time {
+class SystemClock;
+class TimeZoneService;
+} // namespace Service::PSC::Time
+
+namespace Service::Glue::Time {
+
+class FileTimestampWorker {
+public:
+    FileTimestampWorker() = default;
+
+    void SetFilesystemPosixTime();
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> m_system_clock{};
+    std::shared_ptr<Service::PSC::Time::TimeZoneService> m_time_zone{};
+    bool m_initialized{};
+};
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/manager.cpp

@@ -0,0 +1,277 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+
+#include "core/core.h"
+#include "core/core_timing.h"
+
+#include "common/settings.h"
+#include "common/time_zone.h"
+#include "core/file_sys/vfs.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/service/glue/time/manager.h"
+#include "core/hle/service/glue/time/time_zone_binary.h"
+#include "core/hle/service/psc/time/service_manager.h"
+#include "core/hle/service/psc/time/static.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/psc/time/time_zone_service.h"
+#include "core/hle/service/set/system_settings_server.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Glue::Time {
+namespace {
+
+template <typename T>
+T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
+                       const char* category, const char* name) {
+    std::vector<u8> interval_buf;
+    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
+    ASSERT(res == ResultSuccess);
+
+    T v{};
+    std::memcpy(&v, interval_buf.data(), sizeof(T));
+    return v;
+}
+
+s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
+    constexpr auto is_leap = [](s32 year) -> bool {
+        return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
+    };
+    constexpr std::array<s32, 12> MonthStartDayOfYear{
+        0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+    };
+
+    s16 month_s16{calendar.month};
+    s8 month{static_cast<s8>(((month_s16 * 43) & ~std::numeric_limits<s16>::max()) +
+                             ((month_s16 * 43) >> 9))};
+    s8 month_index{static_cast<s8>(calendar.month - 12 * month)};
+    if (month_index == 0) {
+        month_index = 12;
+    }
+    s32 year{(month + calendar.year) - !month_index};
+    s32 v8{year >= 0 ? year : year + 3};
+
+    s64 days_since_epoch = calendar.day + MonthStartDayOfYear[month_index - 1];
+    days_since_epoch += (year * 365) + (v8 / 4) - (year / 100) + (year / 400) - 365;
+
+    if (month_index <= 2 && is_leap(year)) {
+        days_since_epoch--;
+    }
+    auto epoch_s{((24ll * days_since_epoch + calendar.hour) * 60ll + calendar.minute) * 60ll +
+                 calendar.second};
+    return epoch_s - 62135683200ll;
+}
+
+s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
+    Service::PSC::Time::CalendarTime calendar{
+        .year = GetSettingsItemValue<s16>(set_sys, "time", "standard_user_clock_initial_year"),
+        .month = 1,
+        .day = 1,
+        .hour = 0,
+        .minute = 0,
+        .second = 0,
+    };
+    return CalendarTimeToEpoch(calendar);
+}
+
+Service::PSC::Time::LocationName GetTimeZoneString(Service::PSC::Time::LocationName& in_name) {
+    auto configured_zone = Settings::GetTimeZoneString(Settings::values.time_zone_index.GetValue());
+
+    Service::PSC::Time::LocationName configured_name{};
+    std::memcpy(configured_name.name.data(), configured_zone.data(),
+                std::min(configured_name.name.size(), configured_zone.size()));
+
+    if (!IsTimeZoneBinaryValid(configured_name)) {
+        configured_zone = Common::TimeZone::FindSystemTimeZone();
+        configured_name = {};
+        std::memcpy(configured_name.name.data(), configured_zone.data(),
+                    std::min(configured_name.name.size(), configured_zone.size()));
+    }
+
+    ASSERT_MSG(IsTimeZoneBinaryValid(configured_name), "Invalid time zone {}!",
+               configured_name.name.data());
+
+    return configured_name;
+}
+
+} // namespace
+
+TimeManager::TimeManager(Core::System& system)
+    : m_steady_clock_resource{system}, m_worker{system, m_steady_clock_resource,
+                                                m_file_timestamp_worker} {
+    m_time_m =
+        system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
+
+    auto res = m_time_m->GetStaticServiceAsServiceManager(m_time_sm);
+    ASSERT(res == ResultSuccess);
+
+    m_set_sys =
+        system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+
+    res = MountTimeZoneBinary(system);
+    ASSERT(res == ResultSuccess);
+
+    m_worker.Initialize(m_time_sm, m_set_sys);
+
+    res = m_time_sm->GetStandardUserSystemClock(m_file_timestamp_worker.m_system_clock);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_sm->GetTimeZoneService(m_file_timestamp_worker.m_time_zone);
+    ASSERT(res == ResultSuccess);
+
+    res = SetupStandardSteadyClockCore();
+    ASSERT(res == ResultSuccess);
+
+    Service::PSC::Time::SystemClockContext user_clock_context{};
+    res = m_set_sys->GetUserSystemClockContext(user_clock_context);
+    ASSERT(res == ResultSuccess);
+
+    // TODO the local clock should initialise with this epoch time, and be updated somewhere else on
+    // first boot to update it, but I haven't been able to find that point (likely via ntc's auto
+    // correct as it's defaulted to be enabled). So to get a time that isn't stuck in the past for
+    // first boot, grab the current real seconds.
+    auto epoch_time{GetEpochTimeFromInitialYear(m_set_sys)};
+    if (user_clock_context == Service::PSC::Time::SystemClockContext{}) {
+        m_steady_clock_resource.GetRtcTimeInSeconds(epoch_time);
+    }
+
+    res = m_time_m->SetupStandardLocalSystemClockCore(user_clock_context, epoch_time);
+    ASSERT(res == ResultSuccess);
+
+    Service::PSC::Time::SystemClockContext network_clock_context{};
+    res = m_set_sys->GetNetworkSystemClockContext(network_clock_context);
+    ASSERT(res == ResultSuccess);
+
+    auto network_accuracy_m{GetSettingsItemValue<s32>(
+        m_set_sys, "time", "standard_network_clock_sufficient_accuracy_minutes")};
+    auto one_minute_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
+    s64 network_accuracy_ns{network_accuracy_m * one_minute_ns};
+
+    res = m_time_m->SetupStandardNetworkSystemClockCore(network_clock_context, network_accuracy_ns);
+    ASSERT(res == ResultSuccess);
+
+    bool is_automatic_correction_enabled{};
+    res = m_set_sys->IsUserSystemClockAutomaticCorrectionEnabled(is_automatic_correction_enabled);
+    ASSERT(res == ResultSuccess);
+
+    Service::PSC::Time::SteadyClockTimePoint automatic_correction_time_point{};
+    res = m_set_sys->GetUserSystemClockAutomaticCorrectionUpdatedTime(
+        automatic_correction_time_point);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_m->SetupStandardUserSystemClockCore(automatic_correction_time_point,
+                                                     is_automatic_correction_enabled);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_m->SetupEphemeralNetworkSystemClockCore();
+    ASSERT(res == ResultSuccess);
+
+    res = SetupTimeZoneServiceCore();
+    ASSERT(res == ResultSuccess);
+
+    s64 rtc_time_s{};
+    res = m_steady_clock_resource.GetRtcTimeInSeconds(rtc_time_s);
+    ASSERT(res == ResultSuccess);
+
+    // TODO system report "launch"
+    //      "rtc_reset" = m_steady_clock_resource.m_rtc_reset
+    //      "rtc_value" = rtc_time_s
+
+    m_worker.StartThread();
+
+    m_file_timestamp_worker.m_initialized = true;
+
+    s64 system_clock_time{};
+    if (m_file_timestamp_worker.m_system_clock->GetCurrentTime(system_clock_time) ==
+        ResultSuccess) {
+        Service::PSC::Time::CalendarTime calendar_time{};
+        Service::PSC::Time::CalendarAdditionalInfo calendar_additional{};
+        if (m_file_timestamp_worker.m_time_zone->ToCalendarTimeWithMyRule(
+                calendar_time, calendar_additional, system_clock_time) == ResultSuccess) {
+            // TODO IFileSystemProxy::SetCurrentPosixTime(system_clock_time,
+            // calendar_additional.ut_offset)
+        }
+    }
+}
+
+Result TimeManager::SetupStandardSteadyClockCore() {
+    Common::UUID external_clock_source_id{};
+    auto res = m_set_sys->GetExternalSteadyClockSourceId(external_clock_source_id);
+    ASSERT(res == ResultSuccess);
+
+    s64 external_steady_clock_internal_offset_s{};
+    res = m_set_sys->GetExternalSteadyClockInternalOffset(external_steady_clock_internal_offset_s);
+    ASSERT(res == ResultSuccess);
+
+    auto one_second_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
+    s64 external_steady_clock_internal_offset_ns{external_steady_clock_internal_offset_s *
+                                                 one_second_ns};
+
+    s32 standard_steady_clock_test_offset_m{
+        GetSettingsItemValue<s32>(m_set_sys, "time", "standard_steady_clock_test_offset_minutes")};
+    auto one_minute_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
+    s64 standard_steady_clock_test_offset_ns{standard_steady_clock_test_offset_m * one_minute_ns};
+
+    auto reset_detected = m_steady_clock_resource.GetResetDetected();
+    if (reset_detected) {
+        external_clock_source_id = {};
+    }
+
+    Common::UUID clock_source_id{};
+    m_steady_clock_resource.Initialize(&clock_source_id, &external_clock_source_id);
+
+    if (clock_source_id != external_clock_source_id) {
+        m_set_sys->SetExternalSteadyClockSourceId(clock_source_id);
+    }
+
+    res = m_time_m->SetupStandardSteadyClockCore(clock_source_id, m_steady_clock_resource.GetTime(),
+                                                 external_steady_clock_internal_offset_ns,
+                                                 standard_steady_clock_test_offset_ns,
+                                                 reset_detected);
+    ASSERT(res == ResultSuccess);
+    R_SUCCEED();
+}
+
+Result TimeManager::SetupTimeZoneServiceCore() {
+    Service::PSC::Time::LocationName name{};
+    auto res = m_set_sys->GetDeviceTimeZoneLocationName(name);
+    ASSERT(res == ResultSuccess);
+
+    auto configured_zone = GetTimeZoneString(name);
+
+    if (configured_zone.name != name.name) {
+        m_set_sys->SetDeviceTimeZoneLocationName(configured_zone);
+        name = configured_zone;
+
+        std::shared_ptr<Service::PSC::Time::SystemClock> local_clock;
+        m_time_sm->GetStandardLocalSystemClock(local_clock);
+        Service::PSC::Time::SystemClockContext context{};
+        local_clock->GetSystemClockContext(context);
+        m_set_sys->SetDeviceTimeZoneLocationUpdatedTime(context.steady_time_point);
+    }
+
+    Service::PSC::Time::SteadyClockTimePoint time_point{};
+    res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(time_point);
+    ASSERT(res == ResultSuccess);
+
+    auto location_count = GetTimeZoneCount();
+    Service::PSC::Time::RuleVersion rule_version{};
+    GetTimeZoneVersion(rule_version);
+
+    std::span<const u8> rule_buffer{};
+    size_t rule_size{};
+    res = GetTimeZoneRule(rule_buffer, rule_size, name);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_m->SetupTimeZoneServiceCore(name, time_point, rule_version, location_count,
+                                             rule_buffer);
+    ASSERT(res == ResultSuccess);
+
+    R_SUCCEED();
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/manager.h

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <functional>
+#include <string>
+
+#include "common/common_types.h"
+#include "core/file_sys/vfs_types.h"
+#include "core/hle/service/glue/time/file_timestamp_worker.h"
+#include "core/hle/service/glue/time/standard_steady_clock_resource.h"
+#include "core/hle/service/glue/time/worker.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::PSC::Time {
+class ServiceManager;
+class StaticService;
+} // namespace Service::PSC::Time
+
+namespace Service::Glue::Time {
+class TimeManager {
+public:
+    explicit TimeManager(Core::System& system);
+
+    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
+
+    std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m{};
+    std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm{};
+    StandardSteadyClockResource m_steady_clock_resource;
+    FileTimestampWorker m_file_timestamp_worker;
+    TimeWorker m_worker;
+
+private:
+    Result SetupStandardSteadyClockCore();
+    Result SetupTimeZoneServiceCore();
+};
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/pm_state_change_handler.cpp

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/glue/time/pm_state_change_handler.h"
+
+namespace Service::Glue::Time {
+
+PmStateChangeHandler::PmStateChangeHandler(AlarmWorker& alarm_worker)
+    : m_alarm_worker{alarm_worker} {
+    // TODO Initialize IPmModule, dependent on Rtc and Fs
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/pm_state_change_handler.h

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Service::Glue::Time {
+class AlarmWorker;
+
+class PmStateChangeHandler {
+public:
+    explicit PmStateChangeHandler(AlarmWorker& alarm_worker);
+
+    AlarmWorker& m_alarm_worker;
+    s32 m_priority{};
+};
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/standard_steady_clock_resource.cpp

@@ -0,0 +1,123 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/service/glue/time/standard_steady_clock_resource.h"
+#include "core/hle/service/psc/time/errors.h"
+
+namespace Service::Glue::Time {
+namespace {
+[[maybe_unused]] constexpr u32 Max77620PmicSession = 0x3A000001;
+[[maybe_unused]] constexpr u32 Max77620RtcSession = 0x3B000001;
+
+Result GetTimeInSeconds(Core::System& system, s64& out_time_s) {
+    out_time_s = std::chrono::duration_cast<std::chrono::seconds>(
+                     std::chrono::system_clock::now().time_since_epoch())
+                     .count();
+
+    if (Settings::values.custom_rtc_enabled) {
+        out_time_s += Settings::values.custom_rtc_offset.GetValue();
+    }
+    R_SUCCEED();
+}
+} // namespace
+
+StandardSteadyClockResource::StandardSteadyClockResource(Core::System& system) : m_system{system} {}
+
+void StandardSteadyClockResource::Initialize(Common::UUID* out_source_id,
+                                             Common::UUID* external_source_id) {
+    constexpr size_t NUM_TRIES{20};
+
+    size_t i{0};
+    Result res{ResultSuccess};
+    for (; i < NUM_TRIES; i++) {
+        res = SetCurrentTime();
+        if (res == ResultSuccess) {
+            break;
+        }
+        Kernel::Svc::SleepThread(m_system, std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                               std::chrono::milliseconds(1))
+                                               .count());
+    }
+
+    if (i < NUM_TRIES) {
+        m_set_time_result = ResultSuccess;
+        if (*external_source_id != Service::PSC::Time::ClockSourceId{}) {
+            m_clock_source_id = *external_source_id;
+        } else {
+            m_clock_source_id = Common::UUID::MakeRandom();
+        }
+    } else {
+        m_set_time_result = res;
+        auto ticks{m_system.CoreTiming().GetClockTicks()};
+        m_time = -Service::PSC::Time::ConvertToTimeSpan(ticks).count();
+        m_clock_source_id = Common::UUID::MakeRandom();
+    }
+
+    if (out_source_id) {
+        *out_source_id = m_clock_source_id;
+    }
+}
+
+bool StandardSteadyClockResource::GetResetDetected() {
+    // TODO:
+    // call Rtc::GetRtcResetDetected(Max77620RtcSession)
+    // if detected:
+    //      SetSys::SetExternalSteadyClockSourceId(invalid_id)
+    //      Rtc::ClearRtcResetDetected(Max77620RtcSession)
+    // set m_rtc_reset to result
+    // Instead, only set reset to true if we're booting for the first time.
+    m_rtc_reset = false;
+    return m_rtc_reset;
+}
+
+Result StandardSteadyClockResource::SetCurrentTime() {
+    auto start_tick{m_system.CoreTiming().GetClockTicks()};
+
+    s64 rtc_time_s{};
+    // TODO R_TRY(Rtc::GetTimeInSeconds(rtc_time_s, Max77620RtcSession))
+    R_TRY(GetTimeInSeconds(m_system, rtc_time_s));
+
+    auto end_tick{m_system.CoreTiming().GetClockTicks()};
+    auto diff{Service::PSC::Time::ConvertToTimeSpan(end_tick - start_tick)};
+    // Why is this here?
+    R_UNLESS(diff < std::chrono::milliseconds(101), Service::PSC::Time::ResultRtcTimeout);
+
+    auto one_second_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
+    s64 boot_time{rtc_time_s * one_second_ns -
+                  Service::PSC::Time::ConvertToTimeSpan(end_tick).count()};
+
+    std::scoped_lock l{m_mutex};
+    m_time = boot_time;
+    R_SUCCEED();
+}
+
+Result StandardSteadyClockResource::GetRtcTimeInSeconds(s64& out_time) {
+    // TODO
+    // R_TRY(Rtc::GetTimeInSeconds(time_s, Max77620RtcSession)
+    R_RETURN(GetTimeInSeconds(m_system, out_time));
+}
+
+void StandardSteadyClockResource::UpdateTime() {
+    constexpr size_t NUM_TRIES{3};
+
+    size_t i{0};
+    Result res{ResultSuccess};
+    for (; i < NUM_TRIES; i++) {
+        res = SetCurrentTime();
+        if (res == ResultSuccess) {
+            break;
+        }
+        Kernel::Svc::SleepThread(m_system, std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                               std::chrono::milliseconds(1))
+                                               .count());
+    }
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/standard_steady_clock_resource.h

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <mutex>
+
+#include "common/common_types.h"
+#include "core/hle/result.h"
+#include "core/hle/service/psc/time/common.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Glue::Time {
+class StandardSteadyClockResource {
+public:
+    StandardSteadyClockResource(Core::System& system);
+
+    void Initialize(Common::UUID* out_source_id, Common::UUID* external_source_id);
+
+    s64 GetTime() const {
+        return m_time;
+    }
+
+    bool GetResetDetected();
+    Result SetCurrentTime();
+    Result GetRtcTimeInSeconds(s64& out_time);
+    void UpdateTime();
+
+private:
+    Core::System& m_system;
+
+    std::mutex m_mutex;
+    Service::PSC::Time::ClockSourceId m_clock_source_id{};
+    s64 m_time{};
+    Result m_set_time_result;
+    bool m_rtc_reset;
+};
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/static.cpp

@@ -0,0 +1,448 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+
+#include "core/core.h"
+#include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/service/glue/time/file_timestamp_worker.h"
+#include "core/hle/service/glue/time/static.h"
+#include "core/hle/service/psc/time/errors.h"
+#include "core/hle/service/psc/time/service_manager.h"
+#include "core/hle/service/psc/time/static.h"
+#include "core/hle/service/psc/time/steady_clock.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/psc/time/time_zone_service.h"
+#include "core/hle/service/set/system_settings_server.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Glue::Time {
+namespace {
+template <typename T>
+T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
+                       const char* category, const char* name) {
+    std::vector<u8> interval_buf;
+    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
+    ASSERT(res == ResultSuccess);
+
+    T v{};
+    std::memcpy(&v, interval_buf.data(), sizeof(T));
+    return v;
+}
+} // namespace
+
+StaticService::StaticService(Core::System& system_,
+                             Service::PSC::Time::StaticServiceSetupInfo setup_info,
+                             std::shared_ptr<TimeManager> time, const char* name)
+    : ServiceFramework{system_, name}, m_system{system_}, m_time_m{time->m_time_m},
+      m_setup_info{setup_info}, m_time_sm{time->m_time_sm},
+      m_file_timestamp_worker{time->m_file_timestamp_worker}, m_standard_steady_clock_resource{
+                                                                  time->m_steady_clock_resource} {
+    // clang-format off
+        static const FunctionInfo functions[] = {
+            {0,   &StaticService::Handle_GetStandardUserSystemClock, "GetStandardUserSystemClock"},
+            {1,   &StaticService::Handle_GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
+            {2,   &StaticService::Handle_GetStandardSteadyClock, "GetStandardSteadyClock"},
+            {3,   &StaticService::Handle_GetTimeZoneService, "GetTimeZoneService"},
+            {4,   &StaticService::Handle_GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
+            {5,   &StaticService::Handle_GetEphemeralNetworkSystemClock, "GetEphemeralNetworkSystemClock"},
+            {20,  &StaticService::Handle_GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
+            {50,  &StaticService::Handle_SetStandardSteadyClockInternalOffset, "SetStandardSteadyClockInternalOffset"},
+            {51,  &StaticService::Handle_GetStandardSteadyClockRtcValue, "GetStandardSteadyClockRtcValue"},
+            {100, &StaticService::Handle_IsStandardUserSystemClockAutomaticCorrectionEnabled, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {101, &StaticService::Handle_SetStandardUserSystemClockAutomaticCorrectionEnabled, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {102, &StaticService::Handle_GetStandardUserSystemClockInitialYear, "GetStandardUserSystemClockInitialYear"},
+            {200, &StaticService::Handle_IsStandardNetworkSystemClockAccuracySufficient, "IsStandardNetworkSystemClockAccuracySufficient"},
+            {201, &StaticService::Handle_GetStandardUserSystemClockAutomaticCorrectionUpdatedTime, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
+            {300, &StaticService::Handle_CalculateMonotonicSystemClockBaseTimePoint, "CalculateMonotonicSystemClockBaseTimePoint"},
+            {400, &StaticService::Handle_GetClockSnapshot, "GetClockSnapshot"},
+            {401, &StaticService::Handle_GetClockSnapshotFromSystemClockContext, "GetClockSnapshotFromSystemClockContext"},
+            {500, &StaticService::Handle_CalculateStandardUserSystemClockDifferenceByUser, "CalculateStandardUserSystemClockDifferenceByUser"},
+            {501, &StaticService::Handle_CalculateSpanBetween, "CalculateSpanBetween"},
+        };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
+    m_set_sys =
+        m_system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+
+    if (m_setup_info.can_write_local_clock && m_setup_info.can_write_user_clock &&
+        !m_setup_info.can_write_network_clock && m_setup_info.can_write_timezone_device_location &&
+        !m_setup_info.can_write_steady_clock && !m_setup_info.can_write_uninitialized_clock) {
+        m_time_m->GetStaticServiceAsAdmin(m_wrapped_service);
+    } else if (!m_setup_info.can_write_local_clock && !m_setup_info.can_write_user_clock &&
+               !m_setup_info.can_write_network_clock &&
+               !m_setup_info.can_write_timezone_device_location &&
+               !m_setup_info.can_write_steady_clock &&
+               !m_setup_info.can_write_uninitialized_clock) {
+        m_time_m->GetStaticServiceAsUser(m_wrapped_service);
+    } else if (!m_setup_info.can_write_local_clock && !m_setup_info.can_write_user_clock &&
+               !m_setup_info.can_write_network_clock &&
+               !m_setup_info.can_write_timezone_device_location &&
+               m_setup_info.can_write_steady_clock && !m_setup_info.can_write_uninitialized_clock) {
+        m_time_m->GetStaticServiceAsRepair(m_wrapped_service);
+    } else {
+        UNREACHABLE();
+    }
+
+    auto res = m_wrapped_service->GetTimeZoneService(m_time_zone);
+    ASSERT(res == ResultSuccess);
+}
+
+void StaticService::Handle_GetStandardUserSystemClock(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> service{};
+    auto res = GetStandardUserSystemClock(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface<Service::PSC::Time::SystemClock>(std::move(service));
+}
+
+void StaticService::Handle_GetStandardNetworkSystemClock(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> service{};
+    auto res = GetStandardNetworkSystemClock(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface<Service::PSC::Time::SystemClock>(std::move(service));
+}
+
+void StaticService::Handle_GetStandardSteadyClock(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<Service::PSC::Time::SteadyClock> service{};
+    auto res = GetStandardSteadyClock(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface(std::move(service));
+}
+
+void StaticService::Handle_GetTimeZoneService(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<TimeZoneService> service{};
+    auto res = GetTimeZoneService(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface(std::move(service));
+}
+
+void StaticService::Handle_GetStandardLocalSystemClock(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> service{};
+    auto res = GetStandardLocalSystemClock(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface<Service::PSC::Time::SystemClock>(std::move(service));
+}
+
+void StaticService::Handle_GetEphemeralNetworkSystemClock(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    std::shared_ptr<Service::PSC::Time::SystemClock> service{};
+    auto res = GetEphemeralNetworkSystemClock(service);
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(res);
+    rb.PushIpcInterface<Service::PSC::Time::SystemClock>(std::move(service));
+}
+
+void StaticService::Handle_GetSharedMemoryNativeHandle(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Kernel::KSharedMemory* shared_memory{};
+    auto res = GetSharedMemoryNativeHandle(&shared_memory);
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(res);
+    rb.PushCopyObjects(shared_memory);
+}
+
+void StaticService::Handle_SetStandardSteadyClockInternalOffset(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto offset_ns{rp.Pop<s64>()};
+
+    auto res = SetStandardSteadyClockInternalOffset(offset_ns);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void StaticService::Handle_GetStandardSteadyClockRtcValue(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    s64 rtc_value{};
+    auto res = GetStandardSteadyClockRtcValue(rtc_value);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(res);
+    rb.Push(rtc_value);
+}
+
+void StaticService::Handle_IsStandardUserSystemClockAutomaticCorrectionEnabled(
+    HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    bool is_enabled{};
+    auto res = IsStandardUserSystemClockAutomaticCorrectionEnabled(is_enabled);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push<bool>(is_enabled);
+}
+
+void StaticService::Handle_SetStandardUserSystemClockAutomaticCorrectionEnabled(
+    HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto automatic_correction{rp.Pop<bool>()};
+
+    auto res = SetStandardUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void StaticService::Handle_GetStandardUserSystemClockInitialYear(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    s32 initial_year{};
+    auto res = GetStandardUserSystemClockInitialYear(initial_year);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push(initial_year);
+}
+
+void StaticService::Handle_IsStandardNetworkSystemClockAccuracySufficient(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    bool is_sufficient{};
+    auto res = IsStandardNetworkSystemClockAccuracySufficient(is_sufficient);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push<bool>(is_sufficient);
+}
+
+void StaticService::Handle_GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(
+    HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::SteadyClockTimePoint time_point{};
+    auto res = GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
+
+    IPC::ResponseBuilder rb{ctx,
+                            2 + sizeof(Service::PSC::Time::SteadyClockTimePoint) / sizeof(u32)};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::SteadyClockTimePoint>(time_point);
+}
+
+void StaticService::Handle_CalculateMonotonicSystemClockBaseTimePoint(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto context{rp.PopRaw<Service::PSC::Time::SystemClockContext>()};
+
+    s64 time{};
+    auto res = CalculateMonotonicSystemClockBaseTimePoint(time, context);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(res);
+    rb.Push<s64>(time);
+}
+
+void StaticService::Handle_GetClockSnapshot(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto type{rp.PopEnum<Service::PSC::Time::TimeType>()};
+
+    Service::PSC::Time::ClockSnapshot snapshot{};
+    auto res = GetClockSnapshot(snapshot, type);
+
+    ctx.WriteBuffer(snapshot);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void StaticService::Handle_GetClockSnapshotFromSystemClockContext(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto clock_type{rp.PopEnum<Service::PSC::Time::TimeType>()};
+    [[maybe_unused]] auto alignment{rp.Pop<u32>()};
+    auto user_context{rp.PopRaw<Service::PSC::Time::SystemClockContext>()};
+    auto network_context{rp.PopRaw<Service::PSC::Time::SystemClockContext>()};
+
+    Service::PSC::Time::ClockSnapshot snapshot{};
+    auto res =
+        GetClockSnapshotFromSystemClockContext(snapshot, user_context, network_context, clock_type);
+
+    ctx.WriteBuffer(snapshot);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void StaticService::Handle_CalculateStandardUserSystemClockDifferenceByUser(
+    HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::ClockSnapshot a{};
+    Service::PSC::Time::ClockSnapshot b{};
+
+    auto a_buffer{ctx.ReadBuffer(0)};
+    auto b_buffer{ctx.ReadBuffer(1)};
+
+    std::memcpy(&a, a_buffer.data(), sizeof(Service::PSC::Time::ClockSnapshot));
+    std::memcpy(&b, b_buffer.data(), sizeof(Service::PSC::Time::ClockSnapshot));
+
+    s64 difference{};
+    auto res = CalculateStandardUserSystemClockDifferenceByUser(difference, a, b);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(res);
+    rb.Push(difference);
+}
+
+void StaticService::Handle_CalculateSpanBetween(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::ClockSnapshot a{};
+    Service::PSC::Time::ClockSnapshot b{};
+
+    auto a_buffer{ctx.ReadBuffer(0)};
+    auto b_buffer{ctx.ReadBuffer(1)};
+
+    std::memcpy(&a, a_buffer.data(), sizeof(Service::PSC::Time::ClockSnapshot));
+    std::memcpy(&b, b_buffer.data(), sizeof(Service::PSC::Time::ClockSnapshot));
+
+    s64 time{};
+    auto res = CalculateSpanBetween(time, a, b);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(res);
+    rb.Push(time);
+}
+
+// =============================== Implementations ===========================
+
+Result StaticService::GetStandardUserSystemClock(
+    std::shared_ptr<Service::PSC::Time::SystemClock>& out_service) {
+    R_RETURN(m_wrapped_service->GetStandardUserSystemClock(out_service));
+}
+
+Result StaticService::GetStandardNetworkSystemClock(
+    std::shared_ptr<Service::PSC::Time::SystemClock>& out_service) {
+    R_RETURN(m_wrapped_service->GetStandardNetworkSystemClock(out_service));
+}
+
+Result StaticService::GetStandardSteadyClock(
+    std::shared_ptr<Service::PSC::Time::SteadyClock>& out_service) {
+    R_RETURN(m_wrapped_service->GetStandardSteadyClock(out_service));
+}
+
+Result StaticService::GetTimeZoneService(std::shared_ptr<TimeZoneService>& out_service) {
+    out_service = std::make_shared<TimeZoneService>(m_system, m_file_timestamp_worker,
+                                                    m_setup_info.can_write_timezone_device_location,
+                                                    m_time_zone);
+    R_SUCCEED();
+}
+
+Result StaticService::GetStandardLocalSystemClock(
+    std::shared_ptr<Service::PSC::Time::SystemClock>& out_service) {
+    R_RETURN(m_wrapped_service->GetStandardLocalSystemClock(out_service));
+}
+
+Result StaticService::GetEphemeralNetworkSystemClock(
+    std::shared_ptr<Service::PSC::Time::SystemClock>& out_service) {
+    R_RETURN(m_wrapped_service->GetEphemeralNetworkSystemClock(out_service));
+}
+
+Result StaticService::GetSharedMemoryNativeHandle(Kernel::KSharedMemory** out_shared_memory) {
+    R_RETURN(m_wrapped_service->GetSharedMemoryNativeHandle(out_shared_memory));
+}
+
+Result StaticService::SetStandardSteadyClockInternalOffset(s64 offset_ns) {
+    R_UNLESS(m_setup_info.can_write_steady_clock, Service::PSC::Time::ResultPermissionDenied);
+
+    R_RETURN(m_set_sys->SetExternalSteadyClockInternalOffset(
+        offset_ns /
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()));
+}
+
+Result StaticService::GetStandardSteadyClockRtcValue(s64& out_rtc_value) {
+    R_RETURN(m_standard_steady_clock_resource.GetRtcTimeInSeconds(out_rtc_value));
+}
+
+Result StaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled(
+    bool& out_automatic_correction) {
+    R_RETURN(m_wrapped_service->IsStandardUserSystemClockAutomaticCorrectionEnabled(
+        out_automatic_correction));
+}
+
+Result StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled(
+    bool automatic_correction) {
+    R_RETURN(m_wrapped_service->SetStandardUserSystemClockAutomaticCorrectionEnabled(
+        automatic_correction));
+}
+
+Result StaticService::GetStandardUserSystemClockInitialYear(s32& out_year) {
+    out_year = GetSettingsItemValue<s32>(m_set_sys, "time", "standard_user_clock_initial_year");
+    R_SUCCEED();
+}
+
+Result StaticService::IsStandardNetworkSystemClockAccuracySufficient(bool& out_is_sufficient) {
+    R_RETURN(m_wrapped_service->IsStandardNetworkSystemClockAccuracySufficient(out_is_sufficient));
+}
+
+Result StaticService::GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(
+    Service::PSC::Time::SteadyClockTimePoint& out_time_point) {
+    R_RETURN(m_wrapped_service->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(
+        out_time_point));
+}
+
+Result StaticService::CalculateMonotonicSystemClockBaseTimePoint(
+    s64& out_time, Service::PSC::Time::SystemClockContext& context) {
+    R_RETURN(m_wrapped_service->CalculateMonotonicSystemClockBaseTimePoint(out_time, context));
+}
+
+Result StaticService::GetClockSnapshot(Service::PSC::Time::ClockSnapshot& out_snapshot,
+                                       Service::PSC::Time::TimeType type) {
+    R_RETURN(m_wrapped_service->GetClockSnapshot(out_snapshot, type));
+}
+
+Result StaticService::GetClockSnapshotFromSystemClockContext(
+    Service::PSC::Time::ClockSnapshot& out_snapshot,
+    Service::PSC::Time::SystemClockContext& user_context,
+    Service::PSC::Time::SystemClockContext& network_context, Service::PSC::Time::TimeType type) {
+    R_RETURN(m_wrapped_service->GetClockSnapshotFromSystemClockContext(out_snapshot, user_context,
+                                                                       network_context, type));
+}
+
+Result StaticService::CalculateStandardUserSystemClockDifferenceByUser(
+    s64& out_time, Service::PSC::Time::ClockSnapshot& a, Service::PSC::Time::ClockSnapshot& b) {
+    R_RETURN(m_wrapped_service->CalculateStandardUserSystemClockDifferenceByUser(out_time, a, b));
+}
+
+Result StaticService::CalculateSpanBetween(s64& out_time, Service::PSC::Time::ClockSnapshot& a,
+                                           Service::PSC::Time::ClockSnapshot& b) {
+    R_RETURN(m_wrapped_service->CalculateSpanBetween(out_time, a, b));
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/static.h

@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/service/glue/time/manager.h"
+#include "core/hle/service/glue/time/time_zone.h"
+#include "core/hle/service/psc/time/common.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Set {
+class ISystemSettingsServer;
+}
+
+namespace Service::PSC::Time {
+class StaticService;
+class SystemClock;
+class SteadyClock;
+class TimeZoneService;
+class ServiceManager;
+} // namespace Service::PSC::Time
+
+namespace Service::Glue::Time {
+class FileTimestampWorker;
+class StandardSteadyClockResource;
+
+class StaticService final : public ServiceFramework<StaticService> {
+public:
+    explicit StaticService(Core::System& system,
+                           Service::PSC::Time::StaticServiceSetupInfo setup_info,
+                           std::shared_ptr<TimeManager> time, const char* name);
+
+    ~StaticService() override = default;
+
+    Result GetStandardUserSystemClock(
+        std::shared_ptr<Service::PSC::Time::SystemClock>& out_service);
+    Result GetStandardNetworkSystemClock(
+        std::shared_ptr<Service::PSC::Time::SystemClock>& out_service);
+    Result GetStandardSteadyClock(std::shared_ptr<Service::PSC::Time::SteadyClock>& out_service);
+    Result GetTimeZoneService(std::shared_ptr<TimeZoneService>& out_service);
+    Result GetStandardLocalSystemClock(
+        std::shared_ptr<Service::PSC::Time::SystemClock>& out_service);
+    Result GetEphemeralNetworkSystemClock(
+        std::shared_ptr<Service::PSC::Time::SystemClock>& out_service);
+    Result GetSharedMemoryNativeHandle(Kernel::KSharedMemory** out_shared_memory);
+    Result SetStandardSteadyClockInternalOffset(s64 offset);
+    Result GetStandardSteadyClockRtcValue(s64& out_rtc_value);
+    Result IsStandardUserSystemClockAutomaticCorrectionEnabled(bool& out_automatic_correction);
+    Result SetStandardUserSystemClockAutomaticCorrectionEnabled(bool automatic_correction);
+    Result GetStandardUserSystemClockInitialYear(s32& out_year);
+    Result IsStandardNetworkSystemClockAccuracySufficient(bool& out_is_sufficient);
+    Result GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(
+        Service::PSC::Time::SteadyClockTimePoint& out_time_point);
+    Result CalculateMonotonicSystemClockBaseTimePoint(
+        s64& out_time, Service::PSC::Time::SystemClockContext& context);
+    Result GetClockSnapshot(Service::PSC::Time::ClockSnapshot& out_snapshot,
+                            Service::PSC::Time::TimeType type);
+    Result GetClockSnapshotFromSystemClockContext(
+        Service::PSC::Time::ClockSnapshot& out_snapshot,
+        Service::PSC::Time::SystemClockContext& user_context,
+        Service::PSC::Time::SystemClockContext& network_context, Service::PSC::Time::TimeType type);
+    Result CalculateStandardUserSystemClockDifferenceByUser(s64& out_time,
+                                                            Service::PSC::Time::ClockSnapshot& a,
+                                                            Service::PSC::Time::ClockSnapshot& b);
+    Result CalculateSpanBetween(s64& out_time, Service::PSC::Time::ClockSnapshot& a,
+                                Service::PSC::Time::ClockSnapshot& b);
+
+private:
+    Result GetClockSnapshotImpl(Service::PSC::Time::ClockSnapshot& out_snapshot,
+                                Service::PSC::Time::SystemClockContext& user_context,
+                                Service::PSC::Time::SystemClockContext& network_context,
+                                Service::PSC::Time::TimeType type);
+
+    void Handle_GetStandardUserSystemClock(HLERequestContext& ctx);
+    void Handle_GetStandardNetworkSystemClock(HLERequestContext& ctx);
+    void Handle_GetStandardSteadyClock(HLERequestContext& ctx);
+    void Handle_GetTimeZoneService(HLERequestContext& ctx);
+    void Handle_GetStandardLocalSystemClock(HLERequestContext& ctx);
+    void Handle_GetEphemeralNetworkSystemClock(HLERequestContext& ctx);
+    void Handle_GetSharedMemoryNativeHandle(HLERequestContext& ctx);
+    void Handle_SetStandardSteadyClockInternalOffset(HLERequestContext& ctx);
+    void Handle_GetStandardSteadyClockRtcValue(HLERequestContext& ctx);
+    void Handle_IsStandardUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx);
+    void Handle_SetStandardUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx);
+    void Handle_GetStandardUserSystemClockInitialYear(HLERequestContext& ctx);
+    void Handle_IsStandardNetworkSystemClockAccuracySufficient(HLERequestContext& ctx);
+    void Handle_GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(HLERequestContext& ctx);
+    void Handle_CalculateMonotonicSystemClockBaseTimePoint(HLERequestContext& ctx);
+    void Handle_GetClockSnapshot(HLERequestContext& ctx);
+    void Handle_GetClockSnapshotFromSystemClockContext(HLERequestContext& ctx);
+    void Handle_CalculateStandardUserSystemClockDifferenceByUser(HLERequestContext& ctx);
+    void Handle_CalculateSpanBetween(HLERequestContext& ctx);
+
+    Core::System& m_system;
+
+    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
+    std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m;
+    std::shared_ptr<Service::PSC::Time::StaticService> m_wrapped_service;
+
+    Service::PSC::Time::StaticServiceSetupInfo m_setup_info;
+    std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm;
+    std::shared_ptr<Service::PSC::Time::TimeZoneService> m_time_zone;
+    FileTimestampWorker& m_file_timestamp_worker;
+    StandardSteadyClockResource& m_standard_steady_clock_resource;
+};
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/time_zone.cpp

@@ -0,0 +1,377 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+
+#include "core/core.h"
+#include "core/hle/kernel/svc.h"
+#include "core/hle/service/glue/time/file_timestamp_worker.h"
+#include "core/hle/service/glue/time/time_zone.h"
+#include "core/hle/service/glue/time/time_zone_binary.h"
+#include "core/hle/service/psc/time/time_zone_service.h"
+#include "core/hle/service/set/system_settings_server.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Glue::Time {
+namespace {
+static std::mutex g_list_mutex;
+static Common::IntrusiveListBaseTraits<Service::PSC::Time::OperationEvent>::ListType g_list_nodes{};
+} // namespace
+
+TimeZoneService::TimeZoneService(
+    Core::System& system_, FileTimestampWorker& file_timestamp_worker,
+    bool can_write_timezone_device_location,
+    std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
+    : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
+      m_can_write_timezone_device_location{can_write_timezone_device_location},
+      m_file_timestamp_worker{file_timestamp_worker},
+      m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0,   &TimeZoneService::Handle_GetDeviceLocationName, "GetDeviceLocationName"},
+        {1,   &TimeZoneService::Handle_SetDeviceLocationName, "SetDeviceLocationName"},
+        {2,   &TimeZoneService::Handle_GetTotalLocationNameCount, "GetTotalLocationNameCount"},
+        {3,   &TimeZoneService::Handle_LoadLocationNameList, "LoadLocationNameList"},
+        {4,   &TimeZoneService::Handle_LoadTimeZoneRule, "LoadTimeZoneRule"},
+        {5,   &TimeZoneService::Handle_GetTimeZoneRuleVersion, "GetTimeZoneRuleVersion"},
+        {6,   &TimeZoneService::Handle_GetDeviceLocationNameAndUpdatedTime, "GetDeviceLocationNameAndUpdatedTime"},
+        {7,   &TimeZoneService::Handle_SetDeviceLocationNameWithTimeZoneRule, "SetDeviceLocationNameWithTimeZoneRule"},
+        {8,   &TimeZoneService::Handle_ParseTimeZoneBinary, "ParseTimeZoneBinary"},
+        {20,  &TimeZoneService::Handle_GetDeviceLocationNameOperationEventReadableHandle, "GetDeviceLocationNameOperationEventReadableHandle"},
+        {100, &TimeZoneService::Handle_ToCalendarTime, "ToCalendarTime"},
+        {101, &TimeZoneService::Handle_ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
+        {201, &TimeZoneService::Handle_ToPosixTime, "ToPosixTime"},
+        {202, &TimeZoneService::Handle_ToPosixTimeWithMyRule, "ToPosixTimeWithMyRule"},
+    };
+    // clang-format on
+    RegisterHandlers(functions);
+
+    g_list_nodes.clear();
+    m_set_sys =
+        m_system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+}
+
+TimeZoneService::~TimeZoneService() = default;
+
+void TimeZoneService::Handle_GetDeviceLocationName(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::LocationName name{};
+    auto res = GetDeviceLocationName(name);
+
+    IPC::ResponseBuilder rb{ctx, 2 + sizeof(Service::PSC::Time::LocationName) / sizeof(u32)};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::LocationName>(name);
+}
+
+void TimeZoneService::Handle_SetDeviceLocationName(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto name{rp.PopRaw<Service::PSC::Time::LocationName>()};
+
+    auto res = SetDeviceLocation(name);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void TimeZoneService::Handle_GetTotalLocationNameCount(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    u32 count{};
+    auto res = GetTotalLocationNameCount(count);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push(count);
+}
+
+void TimeZoneService::Handle_LoadLocationNameList(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto index{rp.Pop<u32>()};
+
+    auto max_names{ctx.GetWriteBufferSize() / sizeof(Service::PSC::Time::LocationName)};
+
+    std::vector<Service::PSC::Time::LocationName> names{};
+    u32 count{};
+    auto res = LoadLocationNameList(count, names, max_names, index);
+
+    ctx.WriteBuffer(names);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push(count);
+}
+
+void TimeZoneService::Handle_LoadTimeZoneRule(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto name{rp.PopRaw<Service::PSC::Time::LocationName>()};
+
+    Tz::Rule rule{};
+    auto res = LoadTimeZoneRule(rule, name);
+
+    ctx.WriteBuffer(rule);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void TimeZoneService::Handle_GetTimeZoneRuleVersion(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::RuleVersion rule_version{};
+    auto res = GetTimeZoneRuleVersion(rule_version);
+
+    IPC::ResponseBuilder rb{ctx, 2 + sizeof(Service::PSC::Time::RuleVersion) / sizeof(u32)};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::RuleVersion>(rule_version);
+}
+
+void TimeZoneService::Handle_GetDeviceLocationNameAndUpdatedTime(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Service::PSC::Time::LocationName name{};
+    Service::PSC::Time::SteadyClockTimePoint time_point{};
+    auto res = GetDeviceLocationNameAndUpdatedTime(time_point, name);
+
+    IPC::ResponseBuilder rb{ctx,
+                            2 + (sizeof(Service::PSC::Time::LocationName) / sizeof(u32)) +
+                                (sizeof(Service::PSC::Time::SteadyClockTimePoint) / sizeof(u32))};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::LocationName>(name);
+    rb.PushRaw<Service::PSC::Time::SteadyClockTimePoint>(time_point);
+}
+
+void TimeZoneService::Handle_SetDeviceLocationNameWithTimeZoneRule(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    auto res = SetDeviceLocationNameWithTimeZoneRule();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(res);
+}
+
+void TimeZoneService::Handle_ParseTimeZoneBinary(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(Service::PSC::Time::ResultNotImplemented);
+}
+
+void TimeZoneService::Handle_GetDeviceLocationNameOperationEventReadableHandle(
+    HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    Kernel::KEvent* event{};
+    auto res = GetDeviceLocationNameOperationEventReadableHandle(&event);
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(res);
+    rb.PushCopyObjects(event->GetReadableEvent());
+}
+
+void TimeZoneService::Handle_ToCalendarTime(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto time{rp.Pop<s64>()};
+
+    auto rule_buffer{ctx.ReadBuffer()};
+    Tz::Rule rule{};
+    std::memcpy(&rule, rule_buffer.data(), sizeof(Tz::Rule));
+
+    Service::PSC::Time::CalendarTime calendar_time{};
+    Service::PSC::Time::CalendarAdditionalInfo additional_info{};
+    auto res = ToCalendarTime(calendar_time, additional_info, time, rule);
+
+    IPC::ResponseBuilder rb{ctx,
+                            2 + (sizeof(Service::PSC::Time::CalendarTime) / sizeof(u32)) +
+                                (sizeof(Service::PSC::Time::CalendarAdditionalInfo) / sizeof(u32))};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::CalendarTime>(calendar_time);
+    rb.PushRaw<Service::PSC::Time::CalendarAdditionalInfo>(additional_info);
+}
+
+void TimeZoneService::Handle_ToCalendarTimeWithMyRule(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    auto time{rp.Pop<s64>()};
+
+    LOG_DEBUG(Service_Time, "called. time={}", time);
+
+    Service::PSC::Time::CalendarTime calendar_time{};
+    Service::PSC::Time::CalendarAdditionalInfo additional_info{};
+    auto res = ToCalendarTimeWithMyRule(calendar_time, additional_info, time);
+
+    IPC::ResponseBuilder rb{ctx,
+                            2 + (sizeof(Service::PSC::Time::CalendarTime) / sizeof(u32)) +
+                                (sizeof(Service::PSC::Time::CalendarAdditionalInfo) / sizeof(u32))};
+    rb.Push(res);
+    rb.PushRaw<Service::PSC::Time::CalendarTime>(calendar_time);
+    rb.PushRaw<Service::PSC::Time::CalendarAdditionalInfo>(additional_info);
+}
+
+void TimeZoneService::Handle_ToPosixTime(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    auto calendar{rp.PopRaw<Service::PSC::Time::CalendarTime>()};
+
+    LOG_DEBUG(Service_Time, "called. calendar year {} month {} day {} hour {} minute {} second {}",
+              calendar.year, calendar.month, calendar.day, calendar.hour, calendar.minute,
+              calendar.second);
+
+    auto binary{ctx.ReadBuffer()};
+
+    Tz::Rule rule{};
+    std::memcpy(&rule, binary.data(), sizeof(Tz::Rule));
+
+    u32 count{};
+    std::array<s64, 2> times{};
+    u32 times_count{static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(s64))};
+
+    auto res = ToPosixTime(count, times, times_count, calendar, rule);
+
+    ctx.WriteBuffer(times);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push(count);
+}
+
+void TimeZoneService::Handle_ToPosixTimeWithMyRule(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called.");
+
+    IPC::RequestParser rp{ctx};
+    auto calendar{rp.PopRaw<Service::PSC::Time::CalendarTime>()};
+
+    u32 count{};
+    std::array<s64, 2> times{};
+    u32 times_count{static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(s64))};
+
+    auto res = ToPosixTimeWithMyRule(count, times, times_count, calendar);
+
+    ctx.WriteBuffer(times);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(res);
+    rb.Push(count);
+}
+
+// =============================== Implementations ===========================
+
+Result TimeZoneService::GetDeviceLocationName(Service::PSC::Time::LocationName& out_location_name) {
+    R_RETURN(m_wrapped_service->GetDeviceLocationName(out_location_name));
+}
+
+Result TimeZoneService::SetDeviceLocation(Service::PSC::Time::LocationName& location_name) {
+    R_UNLESS(m_can_write_timezone_device_location, Service::PSC::Time::ResultPermissionDenied);
+    R_UNLESS(IsTimeZoneBinaryValid(location_name), Service::PSC::Time::ResultTimeZoneNotFound);
+
+    std::scoped_lock l{m_mutex};
+
+    std::span<const u8> binary{};
+    size_t binary_size{};
+    R_TRY(GetTimeZoneRule(binary, binary_size, location_name))
+
+    R_TRY(m_wrapped_service->SetDeviceLocationNameWithTimeZoneRule(location_name, binary));
+
+    m_file_timestamp_worker.SetFilesystemPosixTime();
+
+    Service::PSC::Time::SteadyClockTimePoint time_point{};
+    Service::PSC::Time::LocationName name{};
+    R_TRY(m_wrapped_service->GetDeviceLocationNameAndUpdatedTime(time_point, name));
+
+    m_set_sys->SetDeviceTimeZoneLocationName(name);
+    m_set_sys->SetDeviceTimeZoneLocationUpdatedTime(time_point);
+
+    std::scoped_lock m{g_list_mutex};
+    for (auto& operation_event : g_list_nodes) {
+        operation_event.m_event->Signal();
+    }
+    R_SUCCEED();
+}
+
+Result TimeZoneService::GetTotalLocationNameCount(u32& out_count) {
+    R_RETURN(m_wrapped_service->GetTotalLocationNameCount(out_count));
+}
+
+Result TimeZoneService::LoadLocationNameList(
+    u32& out_count, std::vector<Service::PSC::Time::LocationName>& out_names, size_t max_names,
+    u32 index) {
+    std::scoped_lock l{m_mutex};
+    R_RETURN(GetTimeZoneLocationList(out_count, out_names, max_names, index));
+}
+
+Result TimeZoneService::LoadTimeZoneRule(Tz::Rule& out_rule,
+                                         Service::PSC::Time::LocationName& name) {
+    std::scoped_lock l{m_mutex};
+    std::span<const u8> binary{};
+    size_t binary_size{};
+    R_TRY(GetTimeZoneRule(binary, binary_size, name))
+    R_RETURN(m_wrapped_service->ParseTimeZoneBinary(out_rule, binary));
+}
+
+Result TimeZoneService::GetTimeZoneRuleVersion(Service::PSC::Time::RuleVersion& out_rule_version) {
+    R_RETURN(m_wrapped_service->GetTimeZoneRuleVersion(out_rule_version));
+}
+
+Result TimeZoneService::GetDeviceLocationNameAndUpdatedTime(
+    Service::PSC::Time::SteadyClockTimePoint& out_time_point,
+    Service::PSC::Time::LocationName& location_name) {
+    R_RETURN(m_wrapped_service->GetDeviceLocationNameAndUpdatedTime(out_time_point, location_name));
+}
+
+Result TimeZoneService::SetDeviceLocationNameWithTimeZoneRule() {
+    R_UNLESS(m_can_write_timezone_device_location, Service::PSC::Time::ResultPermissionDenied);
+    R_RETURN(Service::PSC::Time::ResultNotImplemented);
+}
+
+Result TimeZoneService::GetDeviceLocationNameOperationEventReadableHandle(
+    Kernel::KEvent** out_event) {
+    if (!operation_event_initialized) {
+        operation_event_initialized = false;
+
+        m_operation_event.m_ctx.CloseEvent(m_operation_event.m_event);
+        m_operation_event.m_event =
+            m_operation_event.m_ctx.CreateEvent("Psc:TimeZoneService:OperationEvent");
+        operation_event_initialized = true;
+        std::scoped_lock l{m_mutex};
+        g_list_nodes.push_back(m_operation_event);
+    }
+
+    *out_event = m_operation_event.m_event;
+    R_SUCCEED();
+}
+
+Result TimeZoneService::ToCalendarTime(
+    Service::PSC::Time::CalendarTime& out_calendar_time,
+    Service::PSC::Time::CalendarAdditionalInfo& out_additional_info, s64 time, Tz::Rule& rule) {
+    R_RETURN(m_wrapped_service->ToCalendarTime(out_calendar_time, out_additional_info, time, rule));
+}
+
+Result TimeZoneService::ToCalendarTimeWithMyRule(
+    Service::PSC::Time::CalendarTime& out_calendar_time,
+    Service::PSC::Time::CalendarAdditionalInfo& out_additional_info, s64 time) {
+    R_RETURN(
+        m_wrapped_service->ToCalendarTimeWithMyRule(out_calendar_time, out_additional_info, time));
+}
+
+Result TimeZoneService::ToPosixTime(u32& out_count, std::span<s64, 2> out_times,
+                                    u32 out_times_count,
+                                    Service::PSC::Time::CalendarTime& calendar_time,
+                                    Tz::Rule& rule) {
+    R_RETURN(
+        m_wrapped_service->ToPosixTime(out_count, out_times, out_times_count, calendar_time, rule));
+}
+
+Result TimeZoneService::ToPosixTimeWithMyRule(u32& out_count, std::span<s64, 2> out_times,
+                                              u32 out_times_count,
+                                              Service::PSC::Time::CalendarTime& calendar_time) {
+    R_RETURN(m_wrapped_service->ToPosixTimeWithMyRule(out_count, out_times, out_times_count,
+                                                      calendar_time));
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/time_zone.h

@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <span>
+#include <vector>
+
+#include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/psc/time/common.h"
+#include "core/hle/service/server_manager.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Tz {
+struct Rule;
+}
+
+namespace Service::Set {
+class ISystemSettingsServer;
+}
+
+namespace Service::PSC::Time {
+class TimeZoneService;
+}
+
+namespace Service::Glue::Time {
+class FileTimestampWorker;
+
+class TimeZoneService final : public ServiceFramework<TimeZoneService> {
+public:
+    explicit TimeZoneService(
+        Core::System& system, FileTimestampWorker& file_timestamp_worker,
+        bool can_write_timezone_device_location,
+        std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service);
+
+    ~TimeZoneService() override;
+
+    Result GetDeviceLocationName(Service::PSC::Time::LocationName& out_location_name);
+    Result SetDeviceLocation(Service::PSC::Time::LocationName& location_name);
+    Result GetTotalLocationNameCount(u32& out_count);
+    Result LoadLocationNameList(u32& out_count,
+                                std::vector<Service::PSC::Time::LocationName>& out_names,
+                                size_t max_names, u32 index);
+    Result LoadTimeZoneRule(Tz::Rule& out_rule, Service::PSC::Time::LocationName& name);
+    Result GetTimeZoneRuleVersion(Service::PSC::Time::RuleVersion& out_rule_version);
+    Result GetDeviceLocationNameAndUpdatedTime(
+        Service::PSC::Time::SteadyClockTimePoint& out_time_point,
+        Service::PSC::Time::LocationName& location_name);
+    Result SetDeviceLocationNameWithTimeZoneRule();
+    Result GetDeviceLocationNameOperationEventReadableHandle(Kernel::KEvent** out_event);
+    Result ToCalendarTime(Service::PSC::Time::CalendarTime& out_calendar_time,
+                          Service::PSC::Time::CalendarAdditionalInfo& out_additional_info, s64 time,
+                          Tz::Rule& rule);
+    Result ToCalendarTimeWithMyRule(Service::PSC::Time::CalendarTime& out_calendar_time,
+                                    Service::PSC::Time::CalendarAdditionalInfo& out_additional_info,
+                                    s64 time);
+    Result ToPosixTime(u32& out_count, std::span<s64, 2> out_times, u32 out_times_count,
+                       Service::PSC::Time::CalendarTime& calendar_time, Tz::Rule& rule);
+    Result ToPosixTimeWithMyRule(u32& out_count, std::span<s64, 2> out_times, u32 out_times_count,
+                                 Service::PSC::Time::CalendarTime& calendar_time);
+
+private:
+    void Handle_GetDeviceLocationName(HLERequestContext& ctx);
+    void Handle_SetDeviceLocationName(HLERequestContext& ctx);
+    void Handle_GetTotalLocationNameCount(HLERequestContext& ctx);
+    void Handle_LoadLocationNameList(HLERequestContext& ctx);
+    void Handle_LoadTimeZoneRule(HLERequestContext& ctx);
+    void Handle_GetTimeZoneRuleVersion(HLERequestContext& ctx);
+    void Handle_GetDeviceLocationNameAndUpdatedTime(HLERequestContext& ctx);
+    void Handle_SetDeviceLocationNameWithTimeZoneRule(HLERequestContext& ctx);
+    void Handle_ParseTimeZoneBinary(HLERequestContext& ctx);
+    void Handle_GetDeviceLocationNameOperationEventReadableHandle(HLERequestContext& ctx);
+    void Handle_ToCalendarTime(HLERequestContext& ctx);
+    void Handle_ToCalendarTimeWithMyRule(HLERequestContext& ctx);
+    void Handle_ToPosixTime(HLERequestContext& ctx);
+    void Handle_ToPosixTimeWithMyRule(HLERequestContext& ctx);
+
+    Core::System& m_system;
+    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
+
+    bool m_can_write_timezone_device_location;
+    FileTimestampWorker& m_file_timestamp_worker;
+    std::shared_ptr<Service::PSC::Time::TimeZoneService> m_wrapped_service;
+    std::mutex m_mutex;
+    bool operation_event_initialized{};
+    Service::PSC::Time::OperationEvent m_operation_event;
+};
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/time_zone_binary.cpp

@@ -0,0 +1,221 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
+#include "core/file_sys/system_archive/system_archive.h"
+#include "core/file_sys/vfs.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/glue/time/time_zone_binary.h"
+
+namespace Service::Glue::Time {
+namespace {
+constexpr u64 TimeZoneBinaryId = 0x10000000000080E;
+
+static FileSys::VirtualDir g_time_zone_binary_romfs{};
+static Result g_time_zone_binary_mount_result{ResultUnknown};
+static std::vector<u8> g_time_zone_scratch_space(0x2800, 0);
+
+Result TimeZoneReadBinary(size_t& out_read_size, std::span<u8> out_buffer, size_t out_buffer_size,
+                          std::string_view path) {
+    R_UNLESS(g_time_zone_binary_mount_result == ResultSuccess, g_time_zone_binary_mount_result);
+
+    auto vfs_file{g_time_zone_binary_romfs->GetFileRelative(path)};
+    R_UNLESS(vfs_file, ResultUnknown);
+
+    auto file_size{vfs_file->GetSize()};
+    R_UNLESS(file_size > 0, ResultUnknown);
+
+    R_UNLESS(file_size <= out_buffer_size, Service::PSC::Time::ResultFailed);
+
+    out_read_size = vfs_file->Read(out_buffer.data(), file_size);
+    R_UNLESS(out_read_size > 0, ResultUnknown);
+
+    R_SUCCEED();
+}
+} // namespace
+
+void ResetTimeZoneBinary() {
+    g_time_zone_binary_romfs = {};
+    g_time_zone_binary_mount_result = ResultUnknown;
+    g_time_zone_scratch_space.clear();
+    g_time_zone_scratch_space.resize(0x2800, 0);
+}
+
+Result MountTimeZoneBinary(Core::System& system) {
+    ResetTimeZoneBinary();
+
+    auto& fsc{system.GetFileSystemController()};
+    std::unique_ptr<FileSys::NCA> nca{};
+
+    auto* bis_system = fsc.GetSystemNANDContents();
+
+    R_UNLESS(bis_system, ResultUnknown);
+
+    nca = bis_system->GetEntry(TimeZoneBinaryId, FileSys::ContentRecordType::Data);
+
+    if (nca) {
+        g_time_zone_binary_romfs = FileSys::ExtractRomFS(nca->GetRomFS());
+    }
+
+    if (g_time_zone_binary_romfs) {
+        // Validate that the romfs is readable, using invalid firmware keys can cause this to get
+        // set but the files to be garbage. In that case, we want to hit the next path and
+        // synthesise them instead.
+        Service::PSC::Time::LocationName name{"Etc/GMT"};
+        if (!IsTimeZoneBinaryValid(name)) {
+            ResetTimeZoneBinary();
+        }
+    }
+
+    if (!g_time_zone_binary_romfs) {
+        g_time_zone_binary_romfs = FileSys::ExtractRomFS(
+            FileSys::SystemArchive::SynthesizeSystemArchive(TimeZoneBinaryId));
+    }
+
+    R_UNLESS(g_time_zone_binary_romfs, ResultUnknown);
+
+    g_time_zone_binary_mount_result = ResultSuccess;
+    R_SUCCEED();
+}
+
+void GetTimeZoneBinaryListPath(std::string& out_path) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
+        return;
+    }
+    // out_path = fmt::format("{}:/binaryList.txt", "TimeZoneBinary");
+    out_path = "/binaryList.txt";
+}
+
+void GetTimeZoneBinaryVersionPath(std::string& out_path) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
+        return;
+    }
+    // out_path = fmt::format("{}:/version.txt", "TimeZoneBinary");
+    out_path = "/version.txt";
+}
+
+void GetTimeZoneZonePath(std::string& out_path, Service::PSC::Time::LocationName& name) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
+        return;
+    }
+    // out_path = fmt::format("{}:/zoneinfo/{}", "TimeZoneBinary", name);
+    out_path = fmt::format("/zoneinfo/{}", name.name.data());
+}
+
+bool IsTimeZoneBinaryValid(Service::PSC::Time::LocationName& name) {
+    std::string path{};
+    GetTimeZoneZonePath(path, name);
+
+    auto vfs_file{g_time_zone_binary_romfs->GetFileRelative(path)};
+    if (!vfs_file) {
+        LOG_INFO(Service_Time, "Could not find timezone file {}", path);
+        return false;
+    }
+    return vfs_file->GetSize() != 0;
+}
+
+u32 GetTimeZoneCount() {
+    std::string path{};
+    GetTimeZoneBinaryListPath(path);
+
+    size_t bytes_read{};
+    if (TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space, 0x2800, path) != ResultSuccess) {
+        return 0;
+    }
+    if (bytes_read == 0) {
+        return 0;
+    }
+
+    auto chars = std::span(reinterpret_cast<char*>(g_time_zone_scratch_space.data()), bytes_read);
+    u32 count{};
+    for (auto chr : chars) {
+        if (chr == '\n') {
+            count++;
+        }
+    }
+    return count;
+}
+
+Result GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version) {
+    std::string path{};
+    GetTimeZoneBinaryVersionPath(path);
+
+    auto rule_version_buffer{std::span(reinterpret_cast<u8*>(&out_rule_version),
+                                       sizeof(Service::PSC::Time::RuleVersion))};
+    size_t bytes_read{};
+    R_TRY(TimeZoneReadBinary(bytes_read, rule_version_buffer, rule_version_buffer.size_bytes(),
+                             path));
+
+    rule_version_buffer[bytes_read] = 0;
+    R_SUCCEED();
+}
+
+Result GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
+                       Service::PSC::Time::LocationName& name) {
+    std::string path{};
+    GetTimeZoneZonePath(path, name);
+
+    size_t bytes_read{};
+    R_TRY(TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space,
+                             g_time_zone_scratch_space.size(), path));
+
+    out_rule = std::span(g_time_zone_scratch_space.data(), bytes_read);
+    out_rule_size = bytes_read;
+    R_SUCCEED();
+}
+
+Result GetTimeZoneLocationList(u32& out_count,
+                               std::vector<Service::PSC::Time::LocationName>& out_names,
+                               size_t max_names, u32 index) {
+    std::string path{};
+    GetTimeZoneBinaryListPath(path);
+
+    size_t bytes_read{};
+    R_TRY(TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space,
+                             g_time_zone_scratch_space.size(), path));
+
+    out_count = 0;
+    R_SUCCEED_IF(bytes_read == 0);
+
+    Service::PSC::Time::LocationName current_name{};
+    size_t current_name_len{};
+    std::span<const u8> chars{g_time_zone_scratch_space};
+    u32 name_count{};
+
+    for (auto chr : chars) {
+        if (chr == '\r') {
+            continue;
+        }
+
+        if (chr == '\n') {
+            if (name_count >= index) {
+                out_names.push_back(current_name);
+                out_count++;
+                if (out_count >= max_names) {
+                    break;
+                }
+            }
+            name_count++;
+            current_name_len = 0;
+            current_name = {};
+            continue;
+        }
+
+        if (chr == '\0') {
+            break;
+        }
+
+        R_UNLESS(current_name_len <= current_name.name.size() - 2,
+                 Service::PSC::Time::ResultFailed);
+
+        current_name.name[current_name_len++] = chr;
+    }
+
+    R_SUCCEED();
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/time_zone_binary.h

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <span>
+#include <string>
+#include <string_view>
+
+#include "core/hle/service/psc/time/common.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Glue::Time {
+
+void ResetTimeZoneBinary();
+Result MountTimeZoneBinary(Core::System& system);
+void GetTimeZoneBinaryListPath(std::string& out_path);
+void GetTimeZoneBinaryVersionPath(std::string& out_path);
+void GetTimeZoneZonePath(std::string& out_path, Service::PSC::Time::LocationName& name);
+bool IsTimeZoneBinaryValid(Service::PSC::Time::LocationName& name);
+u32 GetTimeZoneCount();
+Result GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version);
+Result GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
+                       Service::PSC::Time::LocationName& name);
+Result GetTimeZoneLocationList(u32& out_count,
+                               std::vector<Service::PSC::Time::LocationName>& out_names,
+                               size_t max_names, u32 index);
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/worker.cpp

@@ -0,0 +1,338 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/scope_exit.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/service/glue/time/file_timestamp_worker.h"
+#include "core/hle/service/glue/time/standard_steady_clock_resource.h"
+#include "core/hle/service/glue/time/worker.h"
+#include "core/hle/service/psc/time/common.h"
+#include "core/hle/service/psc/time/service_manager.h"
+#include "core/hle/service/psc/time/static.h"
+#include "core/hle/service/psc/time/system_clock.h"
+#include "core/hle/service/set/system_settings_server.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::Glue::Time {
+namespace {
+
+bool g_ig_report_network_clock_context_set{};
+Service::PSC::Time::SystemClockContext g_report_network_clock_context{};
+bool g_ig_report_ephemeral_clock_context_set{};
+Service::PSC::Time::SystemClockContext g_report_ephemeral_clock_context{};
+
+template <typename T>
+T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
+                       const char* category, const char* name) {
+    std::vector<u8> interval_buf;
+    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
+    ASSERT(res == ResultSuccess);
+
+    T v{};
+    std::memcpy(&v, interval_buf.data(), sizeof(T));
+    return v;
+}
+
+} // namespace
+
+TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
+                       FileTimestampWorker& file_timestamp_worker)
+    : m_system{system}, m_ctx{m_system, "Glue:58"}, m_event{m_ctx.CreateEvent("Glue:58:Event")},
+      m_steady_clock_resource{steady_clock_resource},
+      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
+                                                          "Glue:58:SteadyClockTimerEvent")},
+      m_timer_file_system{m_ctx.CreateEvent("Glue:58:FileTimeTimerEvent")},
+      m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
+    g_ig_report_network_clock_context_set = false;
+    g_report_network_clock_context = {};
+    g_ig_report_ephemeral_clock_context_set = false;
+    g_report_ephemeral_clock_context = {};
+
+    m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
+        "Time::SteadyClockEvent",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            m_timer_steady_clock->Signal();
+            return std::nullopt;
+        });
+
+    m_timer_file_system_timing_event = Core::Timing::CreateEvent(
+        "Time::SteadyClockEvent",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            m_timer_file_system->Signal();
+            return std::nullopt;
+        });
+}
+
+TimeWorker::~TimeWorker() {
+    m_local_clock_event->Signal();
+    m_network_clock_event->Signal();
+    m_ephemeral_clock_event->Signal();
+    std::this_thread::sleep_for(std::chrono::milliseconds(16));
+
+    m_thread.request_stop();
+    m_event->Signal();
+    m_thread.join();
+
+    m_ctx.CloseEvent(m_event);
+    m_system.CoreTiming().UnscheduleEvent(m_timer_steady_clock_timing_event);
+    m_ctx.CloseEvent(m_timer_steady_clock);
+    m_system.CoreTiming().UnscheduleEvent(m_timer_file_system_timing_event);
+    m_ctx.CloseEvent(m_timer_file_system);
+}
+
+void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> time_sm,
+                            std::shared_ptr<Service::Set::ISystemSettingsServer> set_sys) {
+    m_set_sys = std::move(set_sys);
+    m_time_m =
+        m_system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
+    m_time_sm = std::move(time_sm);
+
+    m_alarm_worker.Initialize(m_time_m);
+
+    auto steady_clock_interval_m = GetSettingsItemValue<s32>(
+        m_set_sys, "time", "standard_steady_clock_rtc_update_interval_minutes");
+
+    auto one_minute_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
+    s64 steady_clock_interval_ns{steady_clock_interval_m * one_minute_ns};
+
+    m_system.CoreTiming().ScheduleLoopingEvent(std::chrono::nanoseconds(0),
+                                               std::chrono::nanoseconds(steady_clock_interval_ns),
+                                               m_timer_steady_clock_timing_event);
+
+    auto fs_notify_time_s =
+        GetSettingsItemValue<s32>(m_set_sys, "time", "notify_time_to_fs_interval_seconds");
+    auto one_second_ns{
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
+    s64 fs_notify_time_ns{fs_notify_time_s * one_second_ns};
+
+    m_system.CoreTiming().ScheduleLoopingEvent(std::chrono::nanoseconds(0),
+                                               std::chrono::nanoseconds(fs_notify_time_ns),
+                                               m_timer_file_system_timing_event);
+
+    auto res = m_time_sm->GetStandardLocalSystemClock(m_local_clock);
+    ASSERT(res == ResultSuccess);
+    res = m_time_m->GetStandardLocalClockOperationEvent(&m_local_clock_event);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_sm->GetStandardNetworkSystemClock(m_network_clock);
+    ASSERT(res == ResultSuccess);
+    res = m_time_m->GetStandardNetworkClockOperationEventForServiceManager(&m_network_clock_event);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_sm->GetEphemeralNetworkSystemClock(m_ephemeral_clock);
+    ASSERT(res == ResultSuccess);
+    res =
+        m_time_m->GetEphemeralNetworkClockOperationEventForServiceManager(&m_ephemeral_clock_event);
+    ASSERT(res == ResultSuccess);
+
+    res = m_time_m->GetStandardUserSystemClockAutomaticCorrectionUpdatedEvent(
+        &m_standard_user_auto_correct_clock_event);
+    ASSERT(res == ResultSuccess);
+}
+
+void TimeWorker::StartThread() {
+    m_thread = std::jthread(std::bind_front(&TimeWorker::ThreadFunc, this));
+}
+
+void TimeWorker::ThreadFunc(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("TimeWorker");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Low);
+
+    enum class EventType {
+        Exit = 0,
+        IpmModuleService_GetEvent = 1,
+        PowerStateChange = 2,
+        SignalAlarms = 3,
+        UpdateLocalSystemClock = 4,
+        UpdateNetworkSystemClock = 5,
+        UpdateEphemeralSystemClock = 6,
+        UpdateSteadyClock = 7,
+        UpdateFileTimestamp = 8,
+        AutoCorrect = 9,
+        Max = 10,
+    };
+
+    s32 num_objs{};
+    std::array<Kernel::KSynchronizationObject*, static_cast<u32>(EventType::Max)> wait_objs{};
+    std::array<EventType, static_cast<u32>(EventType::Max)> wait_indices{};
+
+    const auto AddWaiter{
+        [&](Kernel::KSynchronizationObject* synchronization_object, EventType type) {
+            // Open a new reference to the object.
+            synchronization_object->Open();
+
+            // Insert into the list.
+            wait_indices[num_objs] = type;
+            wait_objs[num_objs++] = synchronization_object;
+        }};
+
+    while (!stop_token.stop_requested()) {
+        SCOPE_EXIT({
+            for (s32 i = 0; i < num_objs; i++) {
+                wait_objs[i]->Close();
+            }
+        });
+
+        num_objs = {};
+        wait_objs = {};
+        if (m_pm_state_change_handler.m_priority != 0) {
+            AddWaiter(&m_event->GetReadableEvent(), EventType::Exit);
+            // TODO
+            // AddWaiter(gIPmModuleService::GetEvent(), 1);
+            AddWaiter(&m_alarm_worker.GetEvent().GetReadableEvent(), EventType::PowerStateChange);
+        } else {
+            AddWaiter(&m_event->GetReadableEvent(), EventType::Exit);
+            // TODO
+            // AddWaiter(gIPmModuleService::GetEvent(), 1);
+            AddWaiter(&m_alarm_worker.GetEvent().GetReadableEvent(), EventType::PowerStateChange);
+            AddWaiter(&m_alarm_worker.GetTimerEvent().GetReadableEvent(), EventType::SignalAlarms);
+            AddWaiter(&m_local_clock_event->GetReadableEvent(), EventType::UpdateLocalSystemClock);
+            AddWaiter(&m_network_clock_event->GetReadableEvent(),
+                      EventType::UpdateNetworkSystemClock);
+            AddWaiter(&m_ephemeral_clock_event->GetReadableEvent(),
+                      EventType::UpdateEphemeralSystemClock);
+            AddWaiter(&m_timer_steady_clock->GetReadableEvent(), EventType::UpdateSteadyClock);
+            AddWaiter(&m_timer_file_system->GetReadableEvent(), EventType::UpdateFileTimestamp);
+            AddWaiter(&m_standard_user_auto_correct_clock_event->GetReadableEvent(),
+                      EventType::AutoCorrect);
+        }
+
+        s32 out_index{-1};
+        Kernel::KSynchronizationObject::Wait(m_system.Kernel(), &out_index, wait_objs.data(),
+                                             num_objs, -1);
+        ASSERT(out_index >= 0 && out_index < num_objs);
+
+        if (stop_token.stop_requested()) {
+            return;
+        }
+
+        switch (wait_indices[out_index]) {
+        case EventType::Exit:
+            return;
+
+        case EventType::IpmModuleService_GetEvent:
+            // TODO
+            // IPmModuleService::GetEvent()
+            // clear the event
+            // Handle power state change event
+            break;
+
+        case EventType::PowerStateChange:
+            m_alarm_worker.GetEvent().Clear();
+            if (m_pm_state_change_handler.m_priority <= 1) {
+                m_alarm_worker.OnPowerStateChanged();
+            }
+            break;
+
+        case EventType::SignalAlarms:
+            m_alarm_worker.GetTimerEvent().Clear();
+            m_time_m->CheckAndSignalAlarms();
+            break;
+
+        case EventType::UpdateLocalSystemClock: {
+            m_local_clock_event->Clear();
+
+            Service::PSC::Time::SystemClockContext context{};
+            auto res = m_local_clock->GetSystemClockContext(context);
+            ASSERT(res == ResultSuccess);
+
+            m_set_sys->SetUserSystemClockContext(context);
+
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+        } break;
+
+        case EventType::UpdateNetworkSystemClock: {
+            m_network_clock_event->Clear();
+            Service::PSC::Time::SystemClockContext context{};
+            auto res = m_network_clock->GetSystemClockContext(context);
+            ASSERT(res == ResultSuccess);
+            m_set_sys->SetNetworkSystemClockContext(context);
+
+            s64 time{};
+            if (m_network_clock->GetCurrentTime(time) != ResultSuccess) {
+                break;
+            }
+
+            [[maybe_unused]] auto offset_before{
+                g_ig_report_network_clock_context_set ? g_report_network_clock_context.offset : 0};
+            // TODO system report "standard_netclock_operation"
+            //              "clock_time" = time
+            //              "context_offset_before" = offset_before
+            //              "context_offset_after"  = context.offset
+            g_report_network_clock_context = context;
+            if (!g_ig_report_network_clock_context_set) {
+                g_ig_report_network_clock_context_set = true;
+            }
+
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+        } break;
+
+        case EventType::UpdateEphemeralSystemClock: {
+            m_ephemeral_clock_event->Clear();
+
+            Service::PSC::Time::SystemClockContext context{};
+            auto res = m_ephemeral_clock->GetSystemClockContext(context);
+            if (res != ResultSuccess) {
+                break;
+            }
+
+            s64 time{};
+            res = m_ephemeral_clock->GetCurrentTime(time);
+            if (res != ResultSuccess) {
+                break;
+            }
+
+            [[maybe_unused]] auto offset_before{g_ig_report_ephemeral_clock_context_set
+                                                    ? g_report_ephemeral_clock_context.offset
+                                                    : 0};
+            // TODO system report "ephemeral_netclock_operation"
+            //              "clock_time" = time
+            //              "context_offset_before" = offset_before
+            //              "context_offset_after"  = context.offset
+            g_report_ephemeral_clock_context = context;
+            if (!g_ig_report_ephemeral_clock_context_set) {
+                g_ig_report_ephemeral_clock_context_set = true;
+            }
+        } break;
+
+        case EventType::UpdateSteadyClock:
+            m_timer_steady_clock->Clear();
+
+            m_steady_clock_resource.UpdateTime();
+            m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
+            break;
+
+        case EventType::UpdateFileTimestamp:
+            m_timer_file_system->Clear();
+
+            m_file_timestamp_worker.SetFilesystemPosixTime();
+            break;
+
+        case EventType::AutoCorrect: {
+            m_standard_user_auto_correct_clock_event->Clear();
+
+            bool automatic_correction{};
+            auto res = m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
+                automatic_correction);
+            ASSERT(res == ResultSuccess);
+
+            Service::PSC::Time::SteadyClockTimePoint time_point{};
+            res = m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
+            ASSERT(res == ResultSuccess);
+
+            m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
+            m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
+        } break;
+
+        default:
+            UNREACHABLE();
+            break;
+        }
+    }
+}
+
+} // namespace Service::Glue::Time

src/core/hle/service/glue/time/worker.h

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/glue/time/alarm_worker.h"
+#include "core/hle/service/glue/time/pm_state_change_handler.h"
+#include "core/hle/service/kernel_helpers.h"
+
+namespace Service::Set {
+class ISystemSettingsServer;
+}
+
+namespace Service::PSC::Time {
+class StaticService;
+class SystemClock;
+} // namespace Service::PSC::Time
+
+namespace Service::Glue::Time {
+class FileTimestampWorker;
+class StandardSteadyClockResource;
+
+class TimeWorker {
+public:
+    explicit TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
+                        FileTimestampWorker& file_timestamp_worker);
+    ~TimeWorker();
+
+    void Initialize(std::shared_ptr<Service::PSC::Time::StaticService> time_sm,
+                    std::shared_ptr<Service::Set::ISystemSettingsServer> set_sys);
+
+    void StartThread();
+
+private:
+    void ThreadFunc(std::stop_token stop_token);
+
+    Core::System& m_system;
+    KernelHelpers::ServiceContext m_ctx;
+    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
+
+    std::jthread m_thread;
+    Kernel::KEvent* m_event{};
+    std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m;
+    std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm;
+    std::shared_ptr<Service::PSC::Time::SystemClock> m_network_clock;
+    std::shared_ptr<Service::PSC::Time::SystemClock> m_local_clock;
+    std::shared_ptr<Service::PSC::Time::SystemClock> m_ephemeral_clock;
+    StandardSteadyClockResource& m_steady_clock_resource;
+    FileTimestampWorker& m_file_timestamp_worker;
+    Kernel::KEvent* m_local_clock_event{};
+    Kernel::KEvent* m_network_clock_event{};
+    Kernel::KEvent* m_ephemeral_clock_event{};
+    Kernel::KEvent* m_standard_user_auto_correct_clock_event{};
+    Kernel::KEvent* m_timer_steady_clock{};
+    std::shared_ptr<Core::Timing::EventType> m_timer_steady_clock_timing_event;
+    Kernel::KEvent* m_timer_file_system{};
+    std::shared_ptr<Core::Timing::EventType> m_timer_file_system_timing_event;
+    AlarmWorker m_alarm_worker;
+    PmStateChangeHandler m_pm_state_change_handler;
+};
+
+} // namespace Service::Glue::Time

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

@@ -533,7 +533,7 @@ void IHidSystemServer::EnableAppletToGetInput(HLERequestContext& ctx) {
              parameters.is_enabled, parameters.applet_resource_user_id);
 
     GetResourceManager()->EnableInput(parameters.applet_resource_user_id, parameters.is_enabled);
-    // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id);
+    GetResourceManager()->GetNpad()->EnableAppletToGetInput(parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -596,7 +596,7 @@ void IHidSystemServer::EnableAppletToGetPadInput(HLERequestContext& ctx) {
              parameters.is_enabled, parameters.applet_resource_user_id);
 
     GetResourceManager()->EnablePadInput(parameters.applet_resource_user_id, parameters.is_enabled);
-    // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id);
+    GetResourceManager()->GetNpad()->EnableAppletToGetInput(parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

src/core/hle/service/hle_ipc.cpp

@@ -12,6 +12,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/scratch_buffer.h"
+#include "core/guest_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_process.h"
@@ -23,19 +24,6 @@
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"
 
-namespace {
-static thread_local std::array read_buffer_data_a{
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-};
-static thread_local std::array read_buffer_data_x{
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-};
-} // Anonymous namespace
-
 namespace Service {
 
 SessionRequestHandler::SessionRequestHandler(Kernel::KernelCore& kernel_, const char* service_name_)
@@ -343,48 +331,27 @@ std::vector<u8> HLERequestContext::ReadBufferCopy(std::size_t buffer_index) cons
 }
 
 std::span<const u8> HLERequestContext::ReadBufferA(std::size_t buffer_index) const {
-    static thread_local std::array read_buffer_a{
+    Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::UnsafeRead> gm(memory, 0, 0);
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
 
     ASSERT_OR_EXECUTE_MSG(
         BufferDescriptorA().size() > buffer_index, { return {}; },
         "BufferDescriptorA invalid buffer_index {}", buffer_index);
-    auto& read_buffer = read_buffer_a[buffer_index];
+    return gm.Read(BufferDescriptorA()[buffer_index].Address(),
-    return read_buffer.Read(BufferDescriptorA()[buffer_index].Address(),
+                   BufferDescriptorA()[buffer_index].Size(), &read_buffer_data_a[buffer_index]);
-                            BufferDescriptorA()[buffer_index].Size(),
-                            &read_buffer_data_a[buffer_index]);
 }
 
 std::span<const u8> HLERequestContext::ReadBufferX(std::size_t buffer_index) const {
-    static thread_local std::array read_buffer_x{
+    Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::UnsafeRead> gm(memory, 0, 0);
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
 
     ASSERT_OR_EXECUTE_MSG(
         BufferDescriptorX().size() > buffer_index, { return {}; },
         "BufferDescriptorX invalid buffer_index {}", buffer_index);
-    auto& read_buffer = read_buffer_x[buffer_index];
+    return gm.Read(BufferDescriptorX()[buffer_index].Address(),
-    return read_buffer.Read(BufferDescriptorX()[buffer_index].Address(),
+                   BufferDescriptorX()[buffer_index].Size(), &read_buffer_data_x[buffer_index]);
-                            BufferDescriptorX()[buffer_index].Size(),
-                            &read_buffer_data_x[buffer_index]);
 }
 
 std::span<const u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
-    static thread_local std::array read_buffer_a{
+    Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::UnsafeRead> gm(memory, 0, 0);
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
-    static thread_local std::array read_buffer_x{
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
 
     const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                            BufferDescriptorA()[buffer_index].Size()};
@@ -401,18 +368,14 @@ std::span<const u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) cons
         ASSERT_OR_EXECUTE_MSG(
             BufferDescriptorA().size() > buffer_index, { return {}; },
             "BufferDescriptorA invalid buffer_index {}", buffer_index);
-        auto& read_buffer = read_buffer_a[buffer_index];
+        return gm.Read(BufferDescriptorA()[buffer_index].Address(),
-        return read_buffer.Read(BufferDescriptorA()[buffer_index].Address(),
+                       BufferDescriptorA()[buffer_index].Size(), &read_buffer_data_a[buffer_index]);
-                                BufferDescriptorA()[buffer_index].Size(),
-                                &read_buffer_data_a[buffer_index]);
     } else {
         ASSERT_OR_EXECUTE_MSG(
             BufferDescriptorX().size() > buffer_index, { return {}; },
             "BufferDescriptorX invalid buffer_index {}", buffer_index);
-        auto& read_buffer = read_buffer_x[buffer_index];
+        return gm.Read(BufferDescriptorX()[buffer_index].Address(),
-        return read_buffer.Read(BufferDescriptorX()[buffer_index].Address(),
+                       BufferDescriptorX()[buffer_index].Size(), &read_buffer_data_x[buffer_index]);
-                                BufferDescriptorX()[buffer_index].Size(),
-                                &read_buffer_data_x[buffer_index]);
     }
 }
 

src/core/hle/service/hle_ipc.h

@@ -41,6 +41,8 @@ class KernelCore;
 class KHandleTable;
 class KProcess;
 class KServerSession;
+template <typename T>
+class KScopedAutoObject;
 class KThread;
 } // namespace Kernel
 
@@ -424,6 +426,9 @@ private:
 
     Kernel::KernelCore& kernel;
     Core::Memory::Memory& memory;
+
+    mutable std::array<Common::ScratchBuffer<u8>, 3> read_buffer_data_a{};
+    mutable std::array<Common::ScratchBuffer<u8>, 3> read_buffer_data_x{};
 };
 
 } // namespace Service

src/core/hle/service/kernel_helpers.cpp

@@ -65,6 +65,9 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
 }
 
 void ServiceContext::CloseEvent(Kernel::KEvent* event) {
+    if (!event) {
+        return;
+    }
     event->GetReadableEvent().Close();
     event->Close();
 }

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

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/service/glue/time/static.h"
+#include "core/hle/service/psc/time/steady_clock.h"
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4701) // Potentially uninitialized local variable 'result' used
@@ -29,7 +31,8 @@
 #include "core/hle/service/nfc/common/device.h"
 #include "core/hle/service/nfc/mifare_result.h"
 #include "core/hle/service/nfc/nfc_result.h"
-#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
@@ -393,8 +396,7 @@ Result NfcDevice::WriteMifare(std::span<const MifareWriteBlockParameter> paramet
     return result;
 }
 
-Result NfcDevice::SendCommandByPassThrough(const Time::Clock::TimeSpanType& timeout,
+Result NfcDevice::SendCommandByPassThrough(const s64& timeout, std::span<const u8> command_data,
-                                           std::span<const u8> command_data,
                                            std::span<u8> out_data) {
     // Not implemented
     return ResultSuccess;
@@ -1399,27 +1401,41 @@ void NfcDevice::SetAmiiboName(NFP::AmiiboSettings& settings,
 }
 
 NFP::AmiiboDate NfcDevice::GetAmiiboDate(s64 posix_time) const {
-    const auto& time_zone_manager =
+    auto static_service =
-        system.GetTimeManager().GetTimeZoneContentManager().GetTimeZoneManager();
+        system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
-    Time::TimeZone::CalendarInfo calendar_info{};
+
+    std::shared_ptr<Service::Glue::Time::TimeZoneService> timezone_service{};
+    static_service->GetTimeZoneService(timezone_service);
+
+    Service::PSC::Time::CalendarTime calendar_time{};
+    Service::PSC::Time::CalendarAdditionalInfo additional_info{};
+
     NFP::AmiiboDate amiibo_date{};
 
     amiibo_date.SetYear(2000);
     amiibo_date.SetMonth(1);
     amiibo_date.SetDay(1);
 
-    if (time_zone_manager.ToCalendarTime({}, posix_time, calendar_info) == ResultSuccess) {
+    if (timezone_service->ToCalendarTimeWithMyRule(calendar_time, additional_info, posix_time) ==
-        amiibo_date.SetYear(calendar_info.time.year);
+        ResultSuccess) {
-        amiibo_date.SetMonth(calendar_info.time.month);
+        amiibo_date.SetYear(calendar_time.year);
-        amiibo_date.SetDay(calendar_info.time.day);
+        amiibo_date.SetMonth(calendar_time.month);
+        amiibo_date.SetDay(calendar_time.day);
     }
 
     return amiibo_date;
 }
 
-u64 NfcDevice::GetCurrentPosixTime() const {
+s64 NfcDevice::GetCurrentPosixTime() const {
-    auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
+    auto static_service =
-    return standard_steady_clock.GetCurrentTimePoint(system).time_point;
+        system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
+
+    std::shared_ptr<Service::PSC::Time::SteadyClock> steady_clock{};
+    static_service->GetStandardSteadyClock(steady_clock);
+
+    Service::PSC::Time::SteadyClockTimePoint time_point{};
+    R_ASSERT(steady_clock->GetCurrentTimePoint(time_point));
+    return time_point.time_point;
 }
 
 u64 NfcDevice::RemoveVersionByte(u64 application_id) const {

src/core/hle/service/nfc/common/device.h

@@ -11,7 +11,6 @@
 #include "core/hle/service/nfc/nfc_types.h"
 #include "core/hle/service/nfp/nfp_types.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/time/clock_types.h"
 
 namespace Kernel {
 class KEvent;
@@ -49,8 +48,8 @@ public:
 
     Result WriteMifare(std::span<const MifareWriteBlockParameter> parameters);
 
-    Result SendCommandByPassThrough(const Time::Clock::TimeSpanType& timeout,
+    Result SendCommandByPassThrough(const s64& timeout, std::span<const u8> command_data,
-                                    std::span<const u8> command_data, std::span<u8> out_data);
+                                    std::span<u8> out_data);
 
     Result Mount(NFP::ModelType model_type, NFP::MountTarget mount_target);
     Result Unmount();
@@ -108,7 +107,7 @@ private:
     NFP::AmiiboName GetAmiiboName(const NFP::AmiiboSettings& settings) const;
     void SetAmiiboName(NFP::AmiiboSettings& settings, const NFP::AmiiboName& amiibo_name) const;
     NFP::AmiiboDate GetAmiiboDate(s64 posix_time) const;
-    u64 GetCurrentPosixTime() const;
+    s64 GetCurrentPosixTime() const;
     u64 RemoveVersionByte(u64 application_id) const;
     void UpdateSettingsCrc();
     void UpdateRegisterInfoCrc();

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

@@ -6,12 +6,14 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
+#include "core/hle/service/glue/time/static.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/nfc/common/device.h"
 #include "core/hle/service/nfc/common/device_manager.h"
 #include "core/hle/service/nfc/nfc_result.h"
-#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/psc/time/steady_clock.h"
-#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/hid_util.h"
 
@@ -82,11 +84,19 @@ Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices, std::size_t max
             continue;
         }
         if (skip_fatal_errors) {
-            constexpr u64 MinimumRecoveryTime = 60;
+            constexpr s64 MinimumRecoveryTime = 60;
-            auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
-            const u64 elapsed_time = standard_steady_clock.GetCurrentTimePoint(system).time_point -
-                                     time_since_last_error;
 
+            auto static_service =
+                system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u",
+                                                                                       true);
+
+            std::shared_ptr<Service::PSC::Time::SteadyClock> steady_clock{};
+            static_service->GetStandardSteadyClock(steady_clock);
+
+            Service::PSC::Time::SteadyClockTimePoint time_point{};
+            R_ASSERT(steady_clock->GetCurrentTimePoint(time_point));
+
+            const s64 elapsed_time = time_point.time_point - time_since_last_error;
             if (time_since_last_error != 0 && elapsed_time < MinimumRecoveryTime) {
                 continue;
             }
@@ -250,8 +260,7 @@ Result DeviceManager::WriteMifare(u64 device_handle,
     return result;
 }
 
-Result DeviceManager::SendCommandByPassThrough(u64 device_handle,
+Result DeviceManager::SendCommandByPassThrough(u64 device_handle, const s64& timeout,
-                                               const Time::Clock::TimeSpanType& timeout,
                                                std::span<const u8> command_data,
                                                std::span<u8> out_data) {
     std::scoped_lock lock{mutex};
@@ -741,8 +750,16 @@ Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,
 
     if (operation_result == ResultUnknown112 || operation_result == ResultUnknown114 ||
         operation_result == ResultUnknown115) {
-        auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
+        auto static_service =
-        time_since_last_error = standard_steady_clock.GetCurrentTimePoint(system).time_point;
+            system.ServiceManager().GetService<Service::Glue::Time::StaticService>("time:u", true);
+
+        std::shared_ptr<Service::PSC::Time::SteadyClock> steady_clock{};
+        static_service->GetStandardSteadyClock(steady_clock);
+
+        Service::PSC::Time::SteadyClockTimePoint time_point{};
+        R_ASSERT(steady_clock->GetCurrentTimePoint(time_point));
+
+        time_since_last_error = time_point.time_point;
     }
 
     return operation_result;

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

@@ -13,7 +13,6 @@
 #include "core/hle/service/nfc/nfc_types.h"
 #include "core/hle/service/nfp/nfp_types.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/time/clock_types.h"
 #include "hid_core/hid_types.h"
 
 namespace Service::NFC {
@@ -42,7 +41,7 @@ public:
                       std::span<MifareReadBlockData> read_data);
     Result WriteMifare(u64 device_handle,
                        std::span<const MifareWriteBlockParameter> write_parameters);
-    Result SendCommandByPassThrough(u64 device_handle, const Time::Clock::TimeSpanType& timeout,
+    Result SendCommandByPassThrough(u64 device_handle, const s64& timeout,
                                     std::span<const u8> command_data, std::span<u8> out_data);
 
     // Nfp device manager
@@ -92,7 +91,7 @@ private:
     const std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle) const;
 
     bool is_initialized = false;
-    u64 time_since_last_error = 0;
+    s64 time_since_last_error = 0;
     mutable std::mutex mutex;
     std::array<std::shared_ptr<NfcDevice>, 10> devices{};
 

src/core/hle/service/nfc/nfc_interface.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/nfc/nfc_types.h"
 #include "core/hle/service/nfp/nfp_result.h"
-#include "core/hle/service/time/clock_types.h"
 #include "hid_core/hid_types.h"
 
 namespace Service::NFC {
@@ -261,10 +260,10 @@ void NfcInterface::WriteMifare(HLERequestContext& ctx) {
 void NfcInterface::SendCommandByPassThrough(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto device_handle{rp.Pop<u64>()};
-    const auto timeout{rp.PopRaw<Time::Clock::TimeSpanType>()};
+    const auto timeout{rp.PopRaw<s64>()};
     const auto command_data{ctx.ReadBuffer()};
     LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, timeout={}, data_size={}",
-             device_handle, timeout.ToSeconds(), command_data.size());
+             device_handle, timeout, command_data.size());
 
     std::vector<u8> out_data(1);
     auto result =

src/core/hle/service/ns/language.cpp

@@ -415,4 +415,4 @@ std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage
         return std::nullopt;
     }
 }
-} // namespace Service::NS
+} // namespace Service::NS

src/core/hle/service/ns/language.h

@@ -5,10 +5,7 @@
 
 #include <optional>
 #include "common/common_types.h"
-
+#include "core/hle/service/set/system_settings_server.h"
-namespace Service::Set {
-enum class LanguageCode : u64;
-}
 
 namespace Service::NS {
 /// This is nn::ns::detail::ApplicationLanguage

src/core/hle/service/nvdrv/core/container.cpp

@@ -2,27 +2,136 @@
 // SPDX-FileCopyrightText: 2022 Skyline Team and Contributors
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <atomic>
+#include <deque>
+#include <mutex>
+
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
+#include "core/hle/service/nvdrv/core/heap_mapper.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
+#include "core/memory.h"
 #include "video_core/host1x/host1x.h"
 
 namespace Service::Nvidia::NvCore {
 
+Session::Session(SessionId id_, Kernel::KProcess* process_, Core::Asid asid_)
+    : id{id_}, process{process_}, asid{asid_}, has_preallocated_area{}, mapper{}, is_active{} {}
+
+Session::~Session() = default;
+
 struct ContainerImpl {
-    explicit ContainerImpl(Tegra::Host1x::Host1x& host1x_)
+    explicit ContainerImpl(Container& core, Tegra::Host1x::Host1x& host1x_)
-        : file{host1x_}, manager{host1x_}, device_file_data{} {}
+        : host1x{host1x_}, file{core, host1x_}, manager{host1x_}, device_file_data{} {}
+    Tegra::Host1x::Host1x& host1x;
     NvMap file;
     SyncpointManager manager;
     Container::Host1xDeviceFileData device_file_data;
+    std::deque<Session> sessions;
+    size_t new_ids{};
+    std::deque<size_t> id_pool;
+    std::mutex session_guard;
 };
 
 Container::Container(Tegra::Host1x::Host1x& host1x_) {
-    impl = std::make_unique<ContainerImpl>(host1x_);
+    impl = std::make_unique<ContainerImpl>(*this, host1x_);
 }
 
 Container::~Container() = default;
 
+SessionId Container::OpenSession(Kernel::KProcess* process) {
+    using namespace Common::Literals;
+
+    std::scoped_lock lk(impl->session_guard);
+    for (auto& session : impl->sessions) {
+        if (!session.is_active) {
+            continue;
+        }
+        if (session.process == process) {
+            return session.id;
+        }
+    }
+    size_t new_id{};
+    auto* memory_interface = &process->GetMemory();
+    auto& smmu = impl->host1x.MemoryManager();
+    auto asid = smmu.RegisterProcess(memory_interface);
+    if (!impl->id_pool.empty()) {
+        new_id = impl->id_pool.front();
+        impl->id_pool.pop_front();
+        impl->sessions[new_id] = Session{SessionId{new_id}, process, asid};
+    } else {
+        new_id = impl->new_ids++;
+        impl->sessions.emplace_back(SessionId{new_id}, process, asid);
+    }
+    auto& session = impl->sessions[new_id];
+    session.is_active = true;
+    // Optimization
+    if (process->IsApplication()) {
+        auto& page_table = process->GetPageTable().GetBasePageTable();
+        auto heap_start = page_table.GetHeapRegionStart();
+
+        Kernel::KProcessAddress cur_addr = heap_start;
+        size_t region_size = 0;
+        VAddr region_start = 0;
+        while (true) {
+            Kernel::KMemoryInfo mem_info{};
+            Kernel::Svc::PageInfo page_info{};
+            R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info),
+                                          cur_addr));
+            auto svc_mem_info = mem_info.GetSvcMemoryInfo();
+
+            // Check if this memory block is heap.
+            if (svc_mem_info.state == Kernel::Svc::MemoryState::Normal) {
+                if (svc_mem_info.size > region_size) {
+                    region_size = svc_mem_info.size;
+                    region_start = svc_mem_info.base_address;
+                }
+            }
+
+            // Check if we're done.
+            const uintptr_t next_address = svc_mem_info.base_address + svc_mem_info.size;
+            if (next_address <= GetInteger(cur_addr)) {
+                break;
+            }
+
+            cur_addr = next_address;
+        }
+        session.has_preallocated_area = false;
+        auto start_region = region_size >= 32_MiB ? smmu.Allocate(region_size) : 0;
+        if (start_region != 0) {
+            session.mapper = std::make_unique<HeapMapper>(region_start, start_region, region_size,
+                                                          asid, impl->host1x);
+            smmu.TrackContinuity(start_region, region_start, region_size, asid);
+            session.has_preallocated_area = true;
+            LOG_DEBUG(Debug, "Preallocation created!");
+        }
+    }
+    return SessionId{new_id};
+}
+
+void Container::CloseSession(SessionId session_id) {
+    std::scoped_lock lk(impl->session_guard);
+    impl->file.UnmapAllHandles(session_id);
+    auto& session = impl->sessions[session_id.id];
+    auto& smmu = impl->host1x.MemoryManager();
+    if (session.has_preallocated_area) {
+        const DAddr region_start = session.mapper->GetRegionStart();
+        const size_t region_size = session.mapper->GetRegionSize();
+        session.mapper.reset();
+        smmu.Free(region_start, region_size);
+        session.has_preallocated_area = false;
+    }
+    session.is_active = false;
+    smmu.UnregisterProcess(impl->sessions[session_id.id].asid);
+    impl->id_pool.emplace_front(session_id.id);
+}
+
+Session* Container::GetSession(SessionId session_id) {
+    std::atomic_thread_fence(std::memory_order_acquire);
+    return &impl->sessions[session_id.id];
+}
+
 NvMap& Container::GetNvMapFile() {
     return impl->file;
 }

src/core/hle/service/nvdrv/core/container.h

@@ -8,24 +8,56 @@
 #include <memory>
 #include <unordered_map>
 
+#include "core/device_memory_manager.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
+namespace Kernel {
+class KProcess;
+}
+
 namespace Tegra::Host1x {
 class Host1x;
 } // namespace Tegra::Host1x
 
 namespace Service::Nvidia::NvCore {
 
+class HeapMapper;
 class NvMap;
 class SyncpointManager;
 
 struct ContainerImpl;
 
+struct SessionId {
+    size_t id;
+};
+
+struct Session {
+    Session(SessionId id_, Kernel::KProcess* process_, Core::Asid asid_);
+    ~Session();
+
+    Session(const Session&) = delete;
+    Session& operator=(const Session&) = delete;
+    Session(Session&&) = default;
+    Session& operator=(Session&&) = default;
+
+    SessionId id;
+    Kernel::KProcess* process;
+    Core::Asid asid;
+    bool has_preallocated_area{};
+    std::unique_ptr<HeapMapper> mapper{};
+    bool is_active{};
+};
+
 class Container {
 public:
     explicit Container(Tegra::Host1x::Host1x& host1x);
     ~Container();
 
+    SessionId OpenSession(Kernel::KProcess* process);
+    void CloseSession(SessionId id);
+
+    Session* GetSession(SessionId id);
+
     NvMap& GetNvMapFile();
 
     const NvMap& GetNvMapFile() const;

src/core/hle/service/nvdrv/core/heap_mapper.cpp

@@ -0,0 +1,175 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#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 "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() = 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;
+};
+
+HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid,
+                       Tegra::Host1x::Host1x& host1x)
+    : m_vaddress{start_vaddress}, m_daddress{start_daddress}, m_size{size}, m_asid{asid} {
+    m_internal = std::make_unique<HeapMapperInternal>(host1x);
+}
+
+HeapMapper::~HeapMapper() {
+    m_internal->device_memory.Unmap(m_daddress, m_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);
+}
+
+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();
+}
+
+} // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/core/heap_mapper.h

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+#include "core/device_memory_manager.h"
+
+namespace Tegra::Host1x {
+class Host1x;
+} // namespace Tegra::Host1x
+
+namespace Service::Nvidia::NvCore {
+
+class HeapMapper {
+public:
+    HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid,
+               Tegra::Host1x::Host1x& host1x);
+    ~HeapMapper();
+
+    bool IsInBounds(VAddr start, size_t size) const {
+        VAddr end = start + size;
+        return start >= m_vaddress && end <= (m_vaddress + m_size);
+    }
+
+    DAddr Map(VAddr start, size_t size);
+
+    void Unmap(VAddr start, size_t size);
+
+    DAddr GetRegionStart() const {
+        return m_daddress;
+    }
+
+    size_t GetRegionSize() const {
+        return m_size;
+    }
+
+private:
+    struct HeapMapperInternal;
+    VAddr m_vaddress;
+    DAddr m_daddress;
+    size_t m_size;
+    Core::Asid m_asid;
+    std::unique_ptr<HeapMapperInternal> m_internal;
+};
+
+} // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/core/nvmap.cpp

@@ -2,14 +2,19 @@
 // SPDX-FileCopyrightText: 2022 Skyline Team and Contributors
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <functional>
+
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/hle/service/nvdrv/core/container.h"
+#include "core/hle/service/nvdrv/core/heap_mapper.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/memory.h"
 #include "video_core/host1x/host1x.h"
 
 using Core::Memory::YUZU_PAGESIZE;
+constexpr size_t BIG_PAGE_SIZE = YUZU_PAGESIZE * 16;
 
 namespace Service::Nvidia::NvCore {
 NvMap::Handle::Handle(u64 size_, Id id_)
@@ -17,9 +22,9 @@ NvMap::Handle::Handle(u64 size_, Id id_)
     flags.raw = 0;
 }
 
-NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress) {
+NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress,
+                              NvCore::SessionId pSessionId) {
     std::scoped_lock lock(mutex);
-
     // Handles cannot be allocated twice
     if (allocated) {
         return NvResult::AccessDenied;
@@ -28,6 +33,7 @@ NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress)
     flags = pFlags;
     kind = pKind;
     align = pAlign < YUZU_PAGESIZE ? YUZU_PAGESIZE : pAlign;
+    session_id = pSessionId;
 
     // This flag is only applicable for handles with an address passed
     if (pAddress) {
@@ -63,7 +69,7 @@ NvResult NvMap::Handle::Duplicate(bool internal_session) {
     return NvResult::Success;
 }
 
-NvMap::NvMap(Tegra::Host1x::Host1x& host1x_) : host1x{host1x_} {}
+NvMap::NvMap(Container& core_, Tegra::Host1x::Host1x& host1x_) : host1x{host1x_}, core{core_} {}
 
 void NvMap::AddHandle(std::shared_ptr<Handle> handle_description) {
     std::scoped_lock lock(handles_lock);
@@ -78,12 +84,30 @@ void NvMap::UnmapHandle(Handle& handle_description) {
         handle_description.unmap_queue_entry.reset();
     }
 
+    // Free and unmap the handle from Host1x GMMU
+    if (handle_description.pin_virt_address) {
+        host1x.GMMU().Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
+                            handle_description.aligned_size);
+        host1x.Allocator().Free(handle_description.pin_virt_address,
+                                static_cast<u32>(handle_description.aligned_size));
+        handle_description.pin_virt_address = 0;
+    }
+
     // Free and unmap the handle from the SMMU
-    host1x.MemoryManager().Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
+    const size_t map_size = handle_description.aligned_size;
-                                 handle_description.aligned_size);
+    if (!handle_description.in_heap) {
-    host1x.Allocator().Free(handle_description.pin_virt_address,
+        auto& smmu = host1x.MemoryManager();
-                            static_cast<u32>(handle_description.aligned_size));
+        size_t aligned_up = Common::AlignUp(map_size, BIG_PAGE_SIZE);
-    handle_description.pin_virt_address = 0;
+        smmu.Unmap(handle_description.d_address, map_size);
+        smmu.Free(handle_description.d_address, static_cast<size_t>(aligned_up));
+        handle_description.d_address = 0;
+        return;
+    }
+    const VAddr vaddress = handle_description.address;
+    auto* session = core.GetSession(handle_description.session_id);
+    session->mapper->Unmap(vaddress, map_size);
+    handle_description.d_address = 0;
+    handle_description.in_heap = false;
 }
 
 bool NvMap::TryRemoveHandle(const Handle& handle_description) {
@@ -124,22 +148,33 @@ std::shared_ptr<NvMap::Handle> NvMap::GetHandle(Handle::Id handle) {
     }
 }
 
-VAddr NvMap::GetHandleAddress(Handle::Id handle) {
+DAddr NvMap::GetHandleAddress(Handle::Id handle) {
     std::scoped_lock lock(handles_lock);
     try {
-        return handles.at(handle)->address;
+        return handles.at(handle)->d_address;
     } catch (std::out_of_range&) {
         return 0;
     }
 }
 
-u32 NvMap::PinHandle(NvMap::Handle::Id handle) {
+DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
     auto handle_description{GetHandle(handle)};
     if (!handle_description) [[unlikely]] {
         return 0;
     }
 
     std::scoped_lock lock(handle_description->mutex);
+    const auto map_low_area = [&] {
+        if (handle_description->pin_virt_address == 0) {
+            auto& gmmu_allocator = host1x.Allocator();
+            auto& gmmu = host1x.GMMU();
+            u32 address =
+                gmmu_allocator.Allocate(static_cast<u32>(handle_description->aligned_size));
+            gmmu.Map(static_cast<GPUVAddr>(address), handle_description->d_address,
+                     handle_description->aligned_size);
+            handle_description->pin_virt_address = address;
+        }
+    };
     if (!handle_description->pins) {
         // If we're in the unmap queue we can just remove ourselves and return since we're already
         // mapped
@@ -151,37 +186,58 @@ u32 NvMap::PinHandle(NvMap::Handle::Id handle) {
                 unmap_queue.erase(*handle_description->unmap_queue_entry);
                 handle_description->unmap_queue_entry.reset();
 
+                if (low_area_pin) {
+                    map_low_area();
+                    handle_description->pins++;
+                    return static_cast<DAddr>(handle_description->pin_virt_address);
+                }
+
                 handle_description->pins++;
-                return handle_description->pin_virt_address;
+                return handle_description->d_address;
             }
         }
 
+        using namespace std::placeholders;
         // If not then allocate some space and map it
-        u32 address{};
+        DAddr address{};
-        auto& smmu_allocator = host1x.Allocator();
+        auto& smmu = host1x.MemoryManager();
-        auto& smmu_memory_manager = host1x.MemoryManager();
+        auto* session = core.GetSession(handle_description->session_id);
-        while ((address = smmu_allocator.Allocate(
+        const VAddr vaddress = handle_description->address;
-                    static_cast<u32>(handle_description->aligned_size))) == 0) {
+        const size_t map_size = handle_description->aligned_size;
-            // Free handles until the allocation succeeds
+        if (session->has_preallocated_area && session->mapper->IsInBounds(vaddress, map_size)) {
-            std::scoped_lock queueLock(unmap_queue_lock);
+            handle_description->d_address = session->mapper->Map(vaddress, map_size);
-            if (auto freeHandleDesc{unmap_queue.front()}) {
+            handle_description->in_heap = true;
-                // Handles in the unmap queue are guaranteed not to be pinned so don't bother
+        } else {
-                // checking if they are before unmapping
+            size_t aligned_up = Common::AlignUp(map_size, BIG_PAGE_SIZE);
-                std::scoped_lock freeLock(freeHandleDesc->mutex);
+            while ((address = smmu.Allocate(aligned_up)) == 0) {
-                if (handle_description->pin_virt_address)
+                // Free handles until the allocation succeeds
-                    UnmapHandle(*freeHandleDesc);
+                std::scoped_lock queueLock(unmap_queue_lock);
-            } else {
+                if (auto freeHandleDesc{unmap_queue.front()}) {
-                LOG_CRITICAL(Service_NVDRV, "Ran out of SMMU address space!");
+                    // Handles in the unmap queue are guaranteed not to be pinned so don't bother
+                    // checking if they are before unmapping
+                    std::scoped_lock freeLock(freeHandleDesc->mutex);
+                    if (handle_description->d_address)
+                        UnmapHandle(*freeHandleDesc);
+                } else {
+                    LOG_CRITICAL(Service_NVDRV, "Ran out of SMMU address space!");
+                }
             }
-        }
 
-        smmu_memory_manager.Map(static_cast<GPUVAddr>(address), handle_description->address,
+            handle_description->d_address = address;
-                                handle_description->aligned_size);
+            smmu.Map(address, vaddress, map_size, session->asid, true);
-        handle_description->pin_virt_address = address;
+            handle_description->in_heap = false;
+        }
+    }
+
+    if (low_area_pin) {
+        map_low_area();
     }
 
     handle_description->pins++;
-    return handle_description->pin_virt_address;
+    if (low_area_pin) {
+        return static_cast<DAddr>(handle_description->pin_virt_address);
+    }
+    return handle_description->d_address;
 }
 
 void NvMap::UnpinHandle(Handle::Id handle) {
@@ -232,7 +288,7 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
                 LOG_WARNING(Service_NVDRV, "User duplicate count imbalance detected!");
             } else if (handle_description->dupes == 0) {
                 // Force unmap the handle
-                if (handle_description->pin_virt_address) {
+                if (handle_description->d_address) {
                     std::scoped_lock queueLock(unmap_queue_lock);
                     UnmapHandle(*handle_description);
                 }
@@ -270,4 +326,17 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
     return freeInfo;
 }
 
+void NvMap::UnmapAllHandles(NvCore::SessionId session_id) {
+    auto handles_copy = [&] {
+        std::scoped_lock lk{handles_lock};
+        return handles;
+    }();
+
+    for (auto& [id, handle] : handles_copy) {
+        if (handle->session_id.id == session_id.id) {
+            FreeHandle(id, false);
+        }
+    }
+}
+
 } // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/core/nvmap.h

@@ -14,6 +14,7 @@
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Tegra {
@@ -25,6 +26,8 @@ class Host1x;
 } // namespace Tegra
 
 namespace Service::Nvidia::NvCore {
+
+class Container;
 /**
  * @brief The nvmap core class holds the global state for nvmap and provides methods to manage
  * handles
@@ -48,7 +51,7 @@ public:
         using Id = u32;
         Id id; //!< A globally unique identifier for this handle
 
-        s32 pins{};
+        s64 pins{};
         u32 pin_virt_address{};
         std::optional<typename std::list<std::shared_ptr<Handle>>::iterator> unmap_queue_entry{};
 
@@ -61,15 +64,18 @@ public:
         } flags{};
         static_assert(sizeof(Flags) == sizeof(u32));
 
-        u64 address{}; //!< The memory location in the guest's AS that this handle corresponds to,
+        VAddr address{}; //!< The memory location in the guest's AS that this handle corresponds to,
-                       //!< this can also be in the nvdrv tmem
+                         //!< this can also be in the nvdrv tmem
         bool is_shared_mem_mapped{}; //!< If this nvmap has been mapped with the MapSharedMem IPC
                                      //!< call
 
         u8 kind{};        //!< Used for memory compression
         bool allocated{}; //!< If the handle has been allocated with `Alloc`
+        bool in_heap{};
+        NvCore::SessionId session_id{};
 
-        u64 dma_map_addr{}; //! remove me after implementing pinning.
+        DAddr d_address{}; //!< The memory location in the device's AS that this handle corresponds
+                           //!< to, this can also be in the nvdrv tmem
 
         Handle(u64 size, Id id);
 
@@ -77,7 +83,8 @@ public:
          * @brief Sets up the handle with the given memory config, can allocate memory from the tmem
          * if a 0 address is passed
          */
-        [[nodiscard]] NvResult Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress);
+        [[nodiscard]] NvResult Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress,
+                                     NvCore::SessionId pSessionId);
 
         /**
          * @brief Increases the dupe counter of the handle for the given session
@@ -108,7 +115,7 @@ public:
         bool can_unlock;   //!< If the address region is ready to be unlocked
     };
 
-    explicit NvMap(Tegra::Host1x::Host1x& host1x);
+    explicit NvMap(Container& core, Tegra::Host1x::Host1x& host1x);
 
     /**
      * @brief Creates an unallocated handle of the given size
@@ -117,7 +124,7 @@ public:
 
     std::shared_ptr<Handle> GetHandle(Handle::Id handle);
 
-    VAddr GetHandleAddress(Handle::Id handle);
+    DAddr GetHandleAddress(Handle::Id handle);
 
     /**
      * @brief Maps a handle into the SMMU address space
@@ -125,7 +132,7 @@ public:
      * number of calls to `UnpinHandle`
      * @return The SMMU virtual address that the handle has been mapped to
      */
-    u32 PinHandle(Handle::Id handle);
+    DAddr PinHandle(Handle::Id handle, bool low_area_pin);
 
     /**
      * @brief When this has been called an equal number of times to `PinHandle` for the supplied
@@ -145,6 +152,8 @@ public:
      */
     std::optional<FreeInfo> FreeHandle(Handle::Id handle, bool internal_session);
 
+    void UnmapAllHandles(NvCore::SessionId session_id);
+
 private:
     std::list<std::shared_ptr<Handle>> unmap_queue{};
     std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`
@@ -172,5 +181,7 @@ private:
      * @return If the handle was removed from the map
      */
     bool TryRemoveHandle(const Handle& handle_description);
+
+    Container& core;
 };
 } // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/devices/nvdevice.h

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "common/common_types.h"
+#include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Core {
@@ -62,7 +63,7 @@ public:
      * Called once a device is opened
      * @param fd The device fd
      */
-    virtual void OnOpen(DeviceFD fd) = 0;
+    virtual void OnOpen(NvCore::SessionId session_id, DeviceFD fd) = 0;
 
     /**
      * Called once a device is closed

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

@@ -35,14 +35,14 @@ NvResult nvdisp_disp0::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
     return NvResult::NotImplemented;
 }
 
-void nvdisp_disp0::OnOpen(DeviceFD fd) {}
+void nvdisp_disp0::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvdisp_disp0::OnClose(DeviceFD fd) {}
 
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width,
                         u32 height, u32 stride, android::BufferTransformFlags transform,
                         const Common::Rectangle<int>& crop_rect,
                         std::array<Service::Nvidia::NvFence, 4>& fences, u32 num_fences) {
-    const VAddr addr = nvmap.GetHandleAddress(buffer_handle);
+    const DAddr addr = nvmap.GetHandleAddress(buffer_handle);
     LOG_TRACE(Service,
               "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
               addr, offset, width, height, stride, format);

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -32,7 +32,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     /// Performs a screen flip, drawing the buffer pointed to by the handle.