1 files changed, 99 insertions, 10 deletions

diff --git a/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs b/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs
index 52f3c908..865b1c09 100644
--- a/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs
+++ b/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs
@@ -1,18 +1,23 @@
-using Ryujinx.HLE.HOS.Kernel.Threading;
+using System;
+using Ryujinx.HLE.HOS.Kernel.Threading;
 
 namespace Ryujinx.HLE.HOS.Services.Time.Clock
 {
     abstract class SystemClockCore
     {
-        private SteadyClockCore    _steadyClockCore;
-        private SystemClockContext _context;
+        private SteadyClockCore                  _steadyClockCore;
+        private SystemClockContext               _context;
+        private bool                             _isInitialized;
+        private SystemClockContextUpdateCallback _systemClockContextUpdateCallback;
 
         public SystemClockCore(SteadyClockCore steadyClockCore)
         {
             _steadyClockCore = steadyClockCore;
             _context         = new SystemClockContext();
+            _isInitialized   = false;
 
             _context.SteadyTimePoint.ClockSourceId = steadyClockCore.GetClockSourceId();
+            _systemClockContextUpdateCallback      = null;
         }
 
         public virtual SteadyClockCore GetSteadyClockCore()
@@ -20,31 +25,115 @@ namespace Ryujinx.HLE.HOS.Services.Time.Clock
             return _steadyClockCore;
         }
 
-        public virtual ResultCode GetSystemClockContext(KThread thread, out SystemClockContext context)
+        public ResultCode GetCurrentTime(KThread thread, out long posixTime)
+        {
+            posixTime = 0;
+
+            SteadyClockTimePoint currentTimePoint = _steadyClockCore.GetCurrentTimePoint(thread);
+
+            ResultCode result = GetClockContext(thread, out SystemClockContext clockContext);
+
+            if (result == ResultCode.Success)
+            {
+                result = ResultCode.TimeMismatch;
+
+                if (currentTimePoint.ClockSourceId == clockContext.SteadyTimePoint.ClockSourceId)
+                {
+                    posixTime = clockContext.Offset + currentTimePoint.TimePoint;
+
+                    result = 0;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode SetCurrentTime(KThread thread, long posixTime)
+        {
+            SteadyClockTimePoint currentTimePoint = _steadyClockCore.GetCurrentTimePoint(thread);
+
+            SystemClockContext clockContext = new SystemClockContext()
+            {
+                Offset          = posixTime - currentTimePoint.TimePoint,
+                SteadyTimePoint = currentTimePoint
+            };
+
+            ResultCode result = SetClockContext(clockContext);
+
+            if (result == ResultCode.Success)
+            {
+                result = Flush(clockContext);
+            }
+
+            return result;
+        }
+
+        public virtual ResultCode GetClockContext(KThread thread, out SystemClockContext context)
         {
             context = _context;
 
             return ResultCode.Success;
         }
 
-        public virtual ResultCode SetSystemClockContext(SystemClockContext context)
+        public virtual ResultCode SetClockContext(SystemClockContext context)
         {
             _context = context;
 
             return ResultCode.Success;
         }
 
-        public abstract ResultCode Flush(SystemClockContext context);
+        protected virtual ResultCode Flush(SystemClockContext context)
+        {
+            if (_systemClockContextUpdateCallback == null)
+            {
+                return ResultCode.Success;
+            }
 
-        public bool IsClockSetup(KThread thread)
+            return _systemClockContextUpdateCallback.Update(context);
+        }
+
+        public void SetUpdateCallbackInstance(SystemClockContextUpdateCallback systemClockContextUpdateCallback)
         {
-            ResultCode result = GetSystemClockContext(thread, out SystemClockContext context);
+            _systemClockContextUpdateCallback = systemClockContextUpdateCallback;
+        }
+
+        public void RegisterOperationEvent(KWritableEvent writableEvent)
+        {
+            if (_systemClockContextUpdateCallback != null)
+            {
+                _systemClockContextUpdateCallback.RegisterOperationEvent(writableEvent);
+            }
+        }
+
+        public ResultCode SetSystemClockContext(SystemClockContext context)
+        {
+            ResultCode result = SetClockContext(context);
 
             if (result == ResultCode.Success)
             {
-                SteadyClockCore steadyClockCore = GetSteadyClockCore();
+                result = Flush(context);
+            }
 
-                SteadyClockTimePoint steadyClockTimePoint = steadyClockCore.GetCurrentTimePoint(thread);
+            return result;
+        }
+
+        public bool IsInitialized()
+        {
+            return _isInitialized;
+        }
+
+        public void MarkInitialized()
+        {
+            _isInitialized = true;
+        }
+
+        public bool IsClockSetup(KThread thread)
+        {
+            ResultCode result = GetClockContext(thread, out SystemClockContext context);
+
+            if (result == ResultCode.Success)
+            {
+                SteadyClockTimePoint steadyClockTimePoint = _steadyClockCore.GetCurrentTimePoint(thread);
 
                 return steadyClockTimePoint.ClockSourceId == context.SteadyTimePoint.ClockSourceId;
             }