arm_dynarmic: Support direct page table access

Stub RequestUpdateAudioRenderer, StartAudioRenderer and StopAudioRenderer

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -85,11 +85,19 @@ public:
     ARM_Dynarmic& parent;
     size_t ticks_remaining = 0;
     size_t num_interpreted_instructions = 0;
-    u64 tpidrr0_el0 = 0;
+    u64 tpidrro_el0 = 0;
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
-    Dynarmic::A64::UserConfig config{cb.get()};
+    const auto page_table = Kernel::g_current_process->vm_manager.page_table.pointers.data();
+
+    Dynarmic::A64::UserConfig config;
+    config.callbacks = cb.get();
+    config.tpidrro_el0 = &cb->tpidrro_el0;
+    config.dczid_el0 = 4;
+    config.page_table = reinterpret_cast<void**>(page_table);
+    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
+    config.silently_mirror_page_table = false;
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
@@ -149,11 +157,11 @@ void ARM_Dynarmic::SetCPSR(u32 cpsr) {
 }
 
 u64 ARM_Dynarmic::GetTlsAddress() const {
-    return cb->tpidrr0_el0;
+    return cb->tpidrro_el0;
 }
 
 void ARM_Dynarmic::SetTlsAddress(u64 address) {
-    cb->tpidrr0_el0 = address;
+    cb->tpidrro_el0 = address;
 }
 
 void ARM_Dynarmic::ExecuteInstructions(int num_instructions) {
@@ -170,7 +178,7 @@ void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpsr = jit->GetPstate();
     ctx.fpu_registers = jit->GetVectors();
     ctx.fpscr = jit->GetFpcr();
-    ctx.tls_address = cb->tpidrr0_el0;
+    ctx.tls_address = cb->tpidrro_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
@@ -180,7 +188,7 @@ void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     jit->SetPstate(static_cast<u32>(ctx.cpsr));
     jit->SetVectors(ctx.fpu_registers);
     jit->SetFpcr(static_cast<u32>(ctx.fpscr));
-    cb->tpidrr0_el0 = ctx.tls_address;
+    cb->tpidrro_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {

src/core/hle/ipc.h

@@ -14,8 +14,6 @@ namespace IPC {
 /// Size of the command buffer area, in 32-bit words.
 constexpr size_t COMMAND_BUFFER_LENGTH = 0x100 / sizeof(u32);
 
-/// Maximum number of static buffers per thread
-constexpr size_t MAX_STATIC_BUFFERS = 16;
 // These errors are commonly returned by invalid IPC translations, so alias them here for
 // convenience.
 // TODO(yuriks): These will probably go away once translation is implemented inside the kernel.

src/core/hle/kernel/hle_ipc.cpp

@@ -7,7 +7,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/kernel.h"
@@ -26,47 +25,13 @@ void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_s
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
-HLERequestContext::HLERequestContext(SharedPtr<ServerSession> server_session)
+HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)
     : server_session(std::move(server_session)) {
     cmd_buf[0] = 0;
 }
 
 HLERequestContext::~HLERequestContext() = default;
 
-SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
-                                                      const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback) {
-    // Put the client thread to sleep until the wait event is signaled or the timeout expires.
-    thread->wakeup_callback =
-        [context = this, callback](ThreadWakeupReason reason, SharedPtr<Thread> thread,
-                                   SharedPtr<WaitObject> object, size_t index) mutable -> bool {
-        ASSERT(thread->status == THREADSTATUS_WAIT_HLE_EVENT);
-        callback(thread, *context, reason);
-
-        auto& process = thread->owner_process;
-        // We must copy the entire command buffer *plus* the entire static buffers area, since
-        // the translation might need to read from it in order to retrieve the StaticBuffer
-        // target addresses.
-        std::array<u32, IPC::COMMAND_BUFFER_LENGTH + 2 * IPC::MAX_STATIC_BUFFERS> cmd_buff;
-        Memory::ReadBlock(*process, thread->GetCommandBufferAddress(), cmd_buff.data(),
-                          cmd_buff.size() * sizeof(u32));
-        context->WriteToOutgoingCommandBuffer(cmd_buff.data(), *process, Kernel::g_handle_table);
-        // Copy the translated command buffer back into the thread's command buffer area.
-        Memory::WriteBlock(*process, thread->GetCommandBufferAddress(), cmd_buff.data(),
-                           cmd_buff.size() * sizeof(u32));
-    };
-
-    auto event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
-    thread->status = THREADSTATUS_WAIT_HLE_EVENT;
-    thread->wait_objects = {event};
-    event->AddWaitingThread(thread);
-
-    if (timeout > 0)
-        thread->WakeAfterDelay(timeout);
-
-    return event;
-}
-
 void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     IPC::RequestParser rp(src_cmdbuf);
     command_header = std::make_unique<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());

src/core/hle/kernel/hle_ipc.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <memory>
-#include <string>
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
@@ -14,7 +13,7 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_session.h"
-#include "core/hle/kernel/thread.h"
+
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -25,8 +24,6 @@ class Domain;
 class HandleTable;
 class HLERequestContext;
 class Process;
-class Thread;
-class Event;
 
 /**
  * Interface implemented by HLE Session handlers.
@@ -101,26 +98,10 @@ public:
      * Returns the session through which this request was made. This can be used as a map key to
      * access per-client data on services.
      */
-    SharedPtr<Kernel::ServerSession> Session() const {
+    const SharedPtr<Kernel::ServerSession>& Session() const {
         return server_session;
     }
 
-    using WakeupCallback = std::function<void(SharedPtr<Thread> thread, HLERequestContext& context,
-                                              ThreadWakeupReason reason)>;
-    /*
-     * Puts the specified guest thread to sleep until the returned event is signaled or until the
-     * specified timeout expires.
-     * @param thread Thread to be put to sleep.
-     * @param reason Reason for pausing the thread, to be used for debugging purposes.
-     * @param timeout Timeout in nanoseconds after which the thread will be awoken and the callback
-     * invoked with a Timeout reason.
-     * @param callback Callback to be invoked when the thread is resumed. This callback must write
-     * the entire command response once again, regardless of the state of it before this function
-     * was called.
-     * @returns Event that when signaled will resume the thread and call the callback function.
-     */
-    SharedPtr<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                       u64 timeout, WakeupCallback&& callback);
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 
     /// Populates this context with data from the requesting process/thread.

src/core/hle/kernel/thread.cpp

@@ -247,8 +247,7 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
     bool resume = true;
 
     if (thread->status == THREADSTATUS_WAIT_SYNCH_ANY ||
-        thread->status == THREADSTATUS_WAIT_SYNCH_ALL || thread->status == THREADSTATUS_WAIT_ARB ||
-        thread->status == THREADSTATUS_WAIT_HLE_EVENT) {
+        thread->status == THREADSTATUS_WAIT_SYNCH_ALL || thread->status == THREADSTATUS_WAIT_ARB) {
 
         // Remove the thread from each of its waiting objects' waitlists
         for (auto& object : thread->wait_objects)

src/core/hle/kernel/thread.h

@@ -39,7 +39,6 @@ enum ThreadStatus {
     THREADSTATUS_RUNNING,        ///< Currently running
     THREADSTATUS_READY,          ///< Ready to run
     THREADSTATUS_WAIT_ARB,       ///< Waiting on an address arbiter
-    THREADSTATUS_WAIT_HLE_EVENT, ///< Waiting for hle event to finish
     THREADSTATUS_WAIT_SLEEP,     ///< Waiting due to a SleepThread SVC
     THREADSTATUS_WAIT_SYNCH_ANY, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
     THREADSTATUS_WAIT_SYNCH_ALL, ///< Waiting due to WaitSynchronizationN with wait_all = true

src/core/hle/service/audio/audren_u.cpp

@@ -20,8 +20,8 @@ public:
             {0x2, nullptr, "GetAudioRendererMixBufferCount"},
             {0x3, nullptr, "GetAudioRendererState"},
             {0x4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
-            {0x5, nullptr, "StartAudioRenderer"},
-            {0x6, nullptr, "StopAudioRenderer"},
+            {0x5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
+            {0x6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
             {0x7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
             {0x8, nullptr, "SetAudioRendererRenderingTimeLimit"},
             {0x9, nullptr, "GetAudioRendererRenderingTimeLimit"},
@@ -35,6 +35,42 @@ public:
 
 private:
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
+        AudioRendererResponseData response_data = {0};
+
+        response_data.section_0_size =
+            response_data.state_entries.size() * sizeof(AudioRendererStateEntry);
+        response_data.section_1_size = response_data.section_1.size();
+        response_data.section_2_size = response_data.section_2.size();
+        response_data.section_3_size = response_data.section_3.size();
+        response_data.section_4_size = response_data.section_4.size();
+        response_data.section_5_size = response_data.section_5.size();
+        response_data.total_size = sizeof(AudioRendererResponseData);
+
+        for (unsigned i = 0; i < response_data.state_entries.size(); i++) {
+            // 4 = Busy and 5 = Ready?
+            response_data.state_entries[i].state = 5;
+        }
+
+        auto& buffer = ctx.BufferDescriptorB()[0];
+
+        Memory::WriteBlock(buffer.Address(), &response_data, response_data.total_size);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
+    }
+
+    void StartAudioRenderer(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
+    }
+
+    void StopAudioRenderer(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -52,6 +88,44 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
+    struct AudioRendererStateEntry {
+        u32_le state;
+        u32_le unknown_4;
+        u32_le unknown_8;
+        u32_le unknown_c;
+    };
+    static_assert(sizeof(AudioRendererStateEntry) == 0x10,
+                  "AudioRendererStateEntry has wrong size");
+
+    struct AudioRendererResponseData {
+        u32_le unknown_0;
+        u32_le section_5_size;
+        u32_le section_0_size;
+        u32_le section_1_size;
+        u32_le unknown_10;
+        u32_le section_2_size;
+        u32_le unknown_18;
+        u32_le section_3_size;
+        u32_le section_4_size;
+        u32_le unknown_24;
+        u32_le unknown_28;
+        u32_le unknown_2c;
+        u32_le unknown_30;
+        u32_le unknown_34;
+        u32_le unknown_38;
+        u32_le total_size;
+
+        std::array<AudioRendererStateEntry, 0x18e> state_entries;
+
+        std::array<u8, 0x600> section_1;
+        std::array<u8, 0xe0> section_2;
+        std::array<u8, 0x20> section_3;
+        std::array<u8, 0x10> section_4;
+        std::array<u8, 0xb0> section_5;
+    };
+    static_assert(sizeof(AudioRendererResponseData) == 0x20e0,
+                  "AudioRendererResponseData has wrong size");
+
     Kernel::SharedPtr<Kernel::Event> system_event;
 };
 

src/core/hle/service/service.cpp

@@ -150,15 +150,9 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
     }
 
     u32* cmd_buf = (u32*)Memory::GetPointer(Kernel::GetCurrentThread()->GetTLSAddress());
-    auto thread = Kernel::GetCurrentThread();
-    ASSERT(thread->status == THREADSTATUS_RUNNING || thread->status == THREADSTATUS_WAIT_HLE_EVENT);
-    // Only write the response immediately if the thread is still running. If the HLE handler put
-    // the thread to sleep then the writing of the command buffer will be deferred to the wakeup
-    // callback.
-    if (thread->status == THREADSTATUS_RUNNING) {
-        context.WriteToOutgoingCommandBuffer(cmd_buf, *Kernel::g_current_process,
-                                             Kernel::g_handle_table);
-    }
+    context.WriteToOutgoingCommandBuffer(cmd_buf, *Kernel::g_current_process,
+                                         Kernel::g_handle_table);
+
     return RESULT_SUCCESS;
 }
 

src/core/memory.h

@@ -25,10 +25,11 @@ namespace Memory {
  * Page size used by the ARM architecture. This is the smallest granularity with which memory can
  * be mapped.
  */
-const int PAGE_BITS = 12;
-const u64 PAGE_SIZE = 1 << PAGE_BITS;
-const u64 PAGE_MASK = PAGE_SIZE - 1;
-const size_t PAGE_TABLE_NUM_ENTRIES = 1ULL << (36 - PAGE_BITS);
+constexpr size_t PAGE_BITS = 12;
+constexpr u64 PAGE_SIZE = 1 << PAGE_BITS;
+constexpr u64 PAGE_MASK = PAGE_SIZE - 1;
+constexpr size_t ADDRESS_SPACE_BITS = 36;
+constexpr size_t PAGE_TABLE_NUM_ENTRIES = 1ULL << (ADDRESS_SPACE_BITS - PAGE_BITS);
 
 enum class PageType : u8 {
     /// Page is unmapped and should cause an access error.

src/yuzu/main.cpp

@@ -187,8 +187,7 @@ void GMainWindow::InitializeHotkeys() {
     RegisterHotkey("Main Window", "Load File", QKeySequence::Open);
     RegisterHotkey("Main Window", "Start Emulation");
     RegisterHotkey("Main Window", "Fullscreen", QKeySequence::FullScreen);
-    RegisterHotkey("Main Window", "Exit Fullscreen", QKeySequence(Qt::Key_Escape),
-                   Qt::ApplicationShortcut);
+    RegisterHotkey("Main Window", "Exit Fullscreen", QKeySequence::Cancel, Qt::ApplicationShortcut);
     LoadHotkeys();
 
     connect(GetHotkey("Main Window", "Load File", this), &QShortcut::activated, this,