diff --git a/src/core/hle/service/mm/mm_u.cpp b/src/core/hle/service/mm/mm_u.cpp
index 3e2534b11d..54238819a9 100644
--- a/src/core/hle/service/mm/mm_u.cpp
+++ b/src/core/hle/service/mm/mm_u.cpp
@@ -2,6 +2,8 @@
 // SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
+#include <vector>
 #include "common/logging/log.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/mm/mm_u.h"
@@ -25,7 +27,6 @@ public:
             {7, &MM_U::Get, "Get"},
         };
         // clang-format on
-
         RegisterHandlers(functions);
     }
 
@@ -33,11 +34,13 @@ private:
     void InitializeOld(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto module = rp.PopEnum<Module>();
-        const auto priority = rp.Pop<Priority>();
-        const auto event_clear_mode = rp.PopEnum<EventClearMode>();
+        [[maybe_unused]] const auto priority = rp.Pop<u32>();
+        const auto clear_mode = static_cast<EventClearMode>(rp.Pop<u32>());
 
-        LOG_WARNING(Service_MM, "(STUBBED) called, module={:d}, priority={:d}, event_clear_mode={:d}",
-                   static_cast<u32>(module), priority, static_cast<u32>(event_clear_mode));
+        LOG_DEBUG(Service_MM, "called. module={:d}, clear_mode={:d}",
+                 static_cast<u32>(module), static_cast<u32>(clear_mode));
+
+        sessions.emplace_back(module, next_request_id++, clear_mode);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
@@ -47,7 +50,11 @@ private:
         IPC::RequestParser rp{ctx};
         const auto module = rp.PopEnum<Module>();
 
-        LOG_WARNING(Service_MM, "(STUBBED) called, module={:d}", static_cast<u32>(module));
+        LOG_DEBUG(Service_MM, "called. module={:d}", static_cast<u32>(module));
+
+        std::erase_if(sessions, [&module](const auto& session) {
+            return session.GetModule() == module;
+        });
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
@@ -58,13 +65,20 @@ private:
 
         IPC::RequestParser rp{ctx};
         const auto module = rp.PopEnum<Module>();
-        min = rp.Pop<Setting>();
-        max = rp.Pop<Setting>();
+        const auto min = rp.Pop<u32>();
+        const auto max = rp.Pop<s32>();
 
-        LOG_DEBUG(Service_MM, "(STUBBED) called, module={:d}, min=0x{:X}, max=0x{:X}",
+        LOG_DEBUG(Service_MM, "called. module={:d}, min=0x{:X}, max=0x{:X}",
                  static_cast<u32>(module), min, max);
 
-        current = min;
+        if (auto it = std::find_if(sessions.begin(), sessions.end(),
+                                 [&module](const auto& session) {
+                                     return session.GetModule() == module;
+                                 });
+            it != sessions.end()) {
+            it->SetAndWait(min, max);
+        }
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
     }
@@ -73,31 +87,48 @@ private:
         IPC::RequestParser rp{ctx};
         const auto module = rp.PopEnum<Module>();
 
-        LOG_DEBUG(Service_MM, "(STUBBED) called, module={:d}", static_cast<u32>(module));
+        LOG_DEBUG(Service_MM, "called. module={:d}", static_cast<u32>(module));
+
+        u32 current_min = 0;
+        if (auto it = std::find_if(sessions.begin(), sessions.end(),
+                                 [&module](const auto& session) {
+                                     return session.GetModule() == module;
+                                 });
+            it != sessions.end()) {
+            current_min = it->GetMin();
+        }
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(current);
+        rb.Push(current_min);
     }
 
     void Initialize(HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called.");
-
         IPC::RequestParser rp{ctx};
-        module = rp.PopEnum<Module>();
-        priority = rp.Pop<Priority>();
-        event_clear_mode = rp.Pop<u32>();
+        const auto module = rp.PopEnum<Module>();
+        [[maybe_unused]] const auto priority = rp.Pop<u32>();
+        const auto clear_mode = static_cast<EventClearMode>(rp.Pop<u32>());
+
+        LOG_DEBUG(Service_MM, "called. module={:d}, clear_mode={:d}",
+                 static_cast<u32>(module), static_cast<u32>(clear_mode));
+
+        const u32 current_id = next_request_id++;
+        sessions.emplace_back(module, current_id, clear_mode);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(request_id);
+        rb.Push(current_id);
     }
 
     void Finalize(HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called.");
-
         IPC::RequestParser rp{ctx};
-        request_id = rp.Pop<u32>();
+        const auto request_id = rp.Pop<u32>();
+
+        LOG_DEBUG(Service_MM, "called. request_id={:d}", request_id);
+
+        std::erase_if(sessions, [&request_id](const auto& session) {
+            return session.GetRequestId() == request_id;
+        });
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
@@ -107,35 +138,51 @@ private:
         LOG_WARNING(Service_MM, "(STUBBED) called.");
 
         IPC::RequestParser rp{ctx};
-        request_id = rp.Pop<u32>();
-        min = rp.Pop<Setting>();
-        max = rp.Pop<Setting>();
+        const auto request_id = rp.Pop<u32>();
+        const auto min = rp.Pop<u32>();
+        const auto max = rp.Pop<s32>();
+
+        LOG_DEBUG(Service_MM, "called. request_id={:d}, min=0x{:X}, max=0x{:X}",
+                 request_id, min, max);
+
+        if (auto it = std::find_if(sessions.begin(), sessions.end(),
+                                 [&request_id](const auto& session) {
+                                     return session.GetRequestId() == request_id;
+                                 });
+            it != sessions.end()) {
+            it->SetAndWait(min, max);
+        }
 
-        current = min;
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
     }
 
     void Get(HLERequestContext& ctx) {
-        LOG_WARNING(Service_MM, "(STUBBED) called.");
-
         IPC::RequestParser rp{ctx};
-        request_id = rp.Pop<u32>();
+        const auto request_id = rp.Pop<u32>();
+
+        LOG_DEBUG(Service_MM, "called. request_id={:d}", request_id);
+
+        u32 current_min = 0;
+        if (auto it = std::find_if(sessions.begin(), sessions.end(),
+                                 [&request_id](const auto& session) {
+                                     return session.GetRequestId() == request_id;
+                                 });
+            it != sessions.end()) {
+            current_min = it->GetMin();
+        }
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(current);
+        rb.Push(current_min);
     }
 
-    Module module{Module::TEST};
-    Priority priority{0};
-    Setting min{0}, max{0}, current{0};
-    u32 request_id{0}, event_clear_mode{0};
+    std::vector<Session> sessions;
+    u32 next_request_id{1};
 };
 
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
-
     server_manager->RegisterNamedService("mm:u", std::make_shared<MM_U>(system));
     ServerManager::RunServer(std::move(server_manager));
 }
diff --git a/src/core/hle/service/mm/mm_u.h b/src/core/hle/service/mm/mm_u.h
index f6849e7726..dd0a567cf1 100644
--- a/src/core/hle/service/mm/mm_u.h
+++ b/src/core/hle/service/mm/mm_u.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <vector>
 #include "common/common_types.h"
 
 namespace Core {
@@ -28,7 +29,8 @@ using Priority = u32;
 using Setting = u32;
 
 enum class EventClearMode : u32 {
-    // TODO: Add specific clear mode values when documented
+    Manual = 0,
+    Auto = 1,
 };
 
 // Consolidate settings into a struct for better organization
@@ -39,6 +41,28 @@ struct Settings {
     u32 id{1};  // Used by newer API versions
 };
 
+class Session {
+public:
+    explicit Session(Module module_, u32 request_id_, EventClearMode clear_mode_)
+        : module{module_}, request_id{request_id_}, clear_mode{clear_mode_} {}
+
+    void SetAndWait(u32 min_, s32 max_) {
+        min = min_;
+        max = max_;
+    }
+
+    [[nodiscard]] u32 GetMin() const { return min; }
+    [[nodiscard]] Module GetModule() const { return module; }
+    [[nodiscard]] u32 GetRequestId() const { return request_id; }
+
+private:
+    Module module;
+    u32 request_id{0};
+    u32 min{0};
+    s32 max{-1};
+    EventClearMode clear_mode;
+};
+
 void LoopProcess(Core::System& system);
 
 } // namespace Service::MM