Move solution and projects to src

2023-04-08 01:22:00 +02:00
parent cd124bda58
commit cee7121058
3466 changed files with 55 additions and 55 deletions
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/EphemeralNetworkSystemClockContextWriter.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/EphemeralNetworkSystemClockContextWriter.cs
@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class EphemeralNetworkSystemClockContextWriter : SystemClockContextUpdateCallback
+    {
+        protected override ResultCode Update()
+        {
+            return ResultCode.Success;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/EphemeralNetworkSystemClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/EphemeralNetworkSystemClockCore.cs
@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class EphemeralNetworkSystemClockCore : SystemClockCore
+    {
+        public EphemeralNetworkSystemClockCore(SteadyClockCore steadyClockCore) : base(steadyClockCore) { }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/LocalSystemClockContextWriter.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/LocalSystemClockContextWriter.cs
@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class LocalSystemClockContextWriter : SystemClockContextUpdateCallback
+    {
+        private TimeSharedMemory _sharedMemory;
+
+        public LocalSystemClockContextWriter(TimeSharedMemory sharedMemory)
+        {
+            _sharedMemory = sharedMemory;
+        }
+
+        protected override ResultCode Update()
+        {
+            _sharedMemory.UpdateLocalSystemClockContext(_context);
+
+            return ResultCode.Success;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/NetworkSystemClockContextWriter.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/NetworkSystemClockContextWriter.cs
@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class NetworkSystemClockContextWriter : SystemClockContextUpdateCallback
+    {
+        private TimeSharedMemory _sharedMemory;
+
+        public NetworkSystemClockContextWriter(TimeSharedMemory sharedMemory)
+        {
+            _sharedMemory = sharedMemory;
+        }
+
+        protected override ResultCode Update()
+        {
+            _sharedMemory.UpdateNetworkSystemClockContext(_context);
+
+            return ResultCode.Success;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardLocalSystemClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardLocalSystemClockCore.cs
@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class StandardLocalSystemClockCore : SystemClockCore
+    {
+        public StandardLocalSystemClockCore(StandardSteadyClockCore steadyClockCore) : base(steadyClockCore) {}
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardNetworkSystemClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardNetworkSystemClockCore.cs
@@ -0,0 +1,36 @@
+using Ryujinx.Cpu;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class StandardNetworkSystemClockCore : SystemClockCore
+    {
+        private TimeSpanType _standardNetworkClockSufficientAccuracy;
+
+        public StandardNetworkSystemClockCore(StandardSteadyClockCore steadyClockCore) : base(steadyClockCore)
+        {
+            _standardNetworkClockSufficientAccuracy = new TimeSpanType(0);
+        }
+
+        public bool IsStandardNetworkSystemClockAccuracySufficient(ITickSource tickSource)
+        {
+            SteadyClockCore      steadyClockCore  = GetSteadyClockCore();
+            SteadyClockTimePoint currentTimePoint = steadyClockCore.GetCurrentTimePoint(tickSource);
+
+            bool isStandardNetworkClockSufficientAccuracy = false;
+
+            ResultCode result = GetClockContext(tickSource, out SystemClockContext context);
+
+            if (result == ResultCode.Success && context.SteadyTimePoint.GetSpanBetween(currentTimePoint, out long outSpan) == ResultCode.Success)
+            {
+                isStandardNetworkClockSufficientAccuracy = outSpan * 1000000000 < _standardNetworkClockSufficientAccuracy.NanoSeconds;
+            }
+
+            return isStandardNetworkClockSufficientAccuracy;
+        }
+
+        public void SetStandardNetworkClockSufficientAccuracy(TimeSpanType standardNetworkClockSufficientAccuracy)
+        {
+            _standardNetworkClockSufficientAccuracy = standardNetworkClockSufficientAccuracy;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardSteadyClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardSteadyClockCore.cs
@@ -0,0 +1,72 @@
+using Ryujinx.Cpu;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class StandardSteadyClockCore : SteadyClockCore
+    {
+        private TimeSpanType _setupValue;
+        private TimeSpanType _testOffset;
+        private TimeSpanType _internalOffset;
+        private TimeSpanType _cachedRawTimePoint;
+
+        public StandardSteadyClockCore()
+        {
+            _setupValue         = TimeSpanType.Zero;
+            _testOffset         = TimeSpanType.Zero;
+            _internalOffset     = TimeSpanType.Zero;
+            _cachedRawTimePoint = TimeSpanType.Zero;
+        }
+
+        public override SteadyClockTimePoint GetTimePoint(ITickSource tickSource)
+        {
+            SteadyClockTimePoint result = new SteadyClockTimePoint
+            {
+                TimePoint     = GetCurrentRawTimePoint(tickSource).ToSeconds(),
+                ClockSourceId = GetClockSourceId()
+            };
+
+            return result;
+        }
+
+        public override TimeSpanType GetTestOffset()
+        {
+            return _testOffset;
+        }
+
+        public override void SetTestOffset(TimeSpanType testOffset)
+        {
+            _testOffset = testOffset;
+        }
+
+        public override TimeSpanType GetInternalOffset()
+        {
+            return _internalOffset;
+        }
+
+        public override void SetInternalOffset(TimeSpanType internalOffset)
+        {
+            _internalOffset = internalOffset;
+        }
+
+        public override TimeSpanType GetCurrentRawTimePoint(ITickSource tickSource)
+        {
+            TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
+
+            TimeSpanType rawTimePoint = new TimeSpanType(_setupValue.NanoSeconds + ticksTimeSpan.NanoSeconds);
+
+            if (rawTimePoint.NanoSeconds < _cachedRawTimePoint.NanoSeconds)
+            {
+                rawTimePoint.NanoSeconds = _cachedRawTimePoint.NanoSeconds;
+            }
+
+            _cachedRawTimePoint = rawTimePoint;
+
+            return rawTimePoint;
+        }
+
+        public void SetSetupValue(TimeSpanType setupValue)
+        {
+            _setupValue = setupValue;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardUserSystemClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/StandardUserSystemClockCore.cs
@@ -0,0 +1,108 @@
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class StandardUserSystemClockCore : SystemClockCore
+    {
+        private StandardLocalSystemClockCore   _localSystemClockCore;
+        private StandardNetworkSystemClockCore _networkSystemClockCore;
+        private bool                           _autoCorrectionEnabled;
+        private SteadyClockTimePoint           _autoCorrectionTime;
+        private KEvent                         _autoCorrectionEvent;
+
+        public StandardUserSystemClockCore(StandardLocalSystemClockCore localSystemClockCore, StandardNetworkSystemClockCore networkSystemClockCore) : base(localSystemClockCore.GetSteadyClockCore())
+        {
+            _localSystemClockCore   = localSystemClockCore;
+            _networkSystemClockCore = networkSystemClockCore;
+            _autoCorrectionEnabled  = false;
+            _autoCorrectionTime     = SteadyClockTimePoint.GetRandom();
+            _autoCorrectionEvent    = null;
+        }
+
+        protected override ResultCode Flush(SystemClockContext context)
+        {
+            // As UserSystemClock isn't a real system clock, this shouldn't happens.
+            throw new NotImplementedException();
+        }
+
+        public override ResultCode GetClockContext(ITickSource tickSource, out SystemClockContext context)
+        {
+            ResultCode result = ApplyAutomaticCorrection(tickSource, false);
+
+            context = new SystemClockContext();
+
+            if (result == ResultCode.Success)
+            {
+                return _localSystemClockCore.GetClockContext(tickSource, out context);
+            }
+
+            return result;
+        }
+
+        public override ResultCode SetClockContext(SystemClockContext context)
+        {
+            return ResultCode.NotImplemented;
+        }
+
+        private ResultCode ApplyAutomaticCorrection(ITickSource tickSource, bool autoCorrectionEnabled)
+        {
+            ResultCode result = ResultCode.Success;
+
+            if (_autoCorrectionEnabled != autoCorrectionEnabled && _networkSystemClockCore.IsClockSetup(tickSource))
+            {
+                result = _networkSystemClockCore.GetClockContext(tickSource, out SystemClockContext context);
+
+                if (result == ResultCode.Success)
+                {
+                    _localSystemClockCore.SetClockContext(context);
+                }
+            }
+
+            return result;
+        }
+
+        internal void CreateAutomaticCorrectionEvent(Horizon system)
+        {
+            _autoCorrectionEvent = new KEvent(system.KernelContext);
+        }
+
+        public ResultCode SetAutomaticCorrectionEnabled(ITickSource tickSource, bool autoCorrectionEnabled)
+        {
+            ResultCode result = ApplyAutomaticCorrection(tickSource, autoCorrectionEnabled);
+
+            if (result == ResultCode.Success)
+            {
+                _autoCorrectionEnabled = autoCorrectionEnabled;
+            }
+
+            return result;
+        }
+
+        public bool IsAutomaticCorrectionEnabled()
+        {
+            return _autoCorrectionEnabled;
+        }
+
+        public KReadableEvent GetAutomaticCorrectionReadableEvent()
+        {
+            return _autoCorrectionEvent.ReadableEvent;
+        }
+
+        public void SetAutomaticCorrectionUpdatedTime(SteadyClockTimePoint steadyClockTimePoint)
+        {
+            _autoCorrectionTime = steadyClockTimePoint;
+        }
+
+        public SteadyClockTimePoint GetAutomaticCorrectionUpdatedTime()
+        {
+            return _autoCorrectionTime;
+        }
+
+        public void SignalAutomaticCorrectionEvent()
+        {
+            _autoCorrectionEvent.WritableEvent.Signal();
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/SteadyClockCore.cs
@@ -0,0 +1,98 @@
+using Ryujinx.Common.Utilities;
+using Ryujinx.Cpu;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    abstract class SteadyClockCore
+    {
+        private UInt128 _clockSourceId;
+        private bool    _isRtcResetDetected;
+        private bool    _isInitialized;
+
+        public SteadyClockCore()
+        {
+            _clockSourceId      = UInt128Utils.CreateRandom();
+            _isRtcResetDetected = false;
+            _isInitialized      = false;
+        }
+
+        public UInt128 GetClockSourceId()
+        {
+            return _clockSourceId;
+        }
+
+        public void SetClockSourceId(UInt128 clockSourceId)
+        {
+            _clockSourceId = clockSourceId;
+        }
+
+        public void SetRtcReset()
+        {
+            _isRtcResetDetected = true;
+        }
+
+        public virtual TimeSpanType GetTestOffset()
+        {
+            return new TimeSpanType(0);
+        }
+
+        public virtual void SetTestOffset(TimeSpanType testOffset) {}
+
+        public ResultCode GetRtcValue(out ulong rtcValue)
+        {
+            rtcValue = 0;
+
+            return ResultCode.NotImplemented;
+        }
+
+        public bool IsRtcResetDetected()
+        {
+            return _isRtcResetDetected;
+        }
+
+        public ResultCode GetSetupResultValue()
+        {
+            return ResultCode.Success;
+        }
+
+        public virtual TimeSpanType GetInternalOffset()
+        {
+            return new TimeSpanType(0);
+        }
+
+        public virtual void SetInternalOffset(TimeSpanType internalOffset) {}
+
+        public virtual SteadyClockTimePoint GetTimePoint(ITickSource tickSource)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual TimeSpanType GetCurrentRawTimePoint(ITickSource tickSource)
+        {
+            SteadyClockTimePoint timePoint = GetTimePoint(tickSource);
+
+            return TimeSpanType.FromSeconds(timePoint.TimePoint);
+        }
+
+        public SteadyClockTimePoint GetCurrentTimePoint(ITickSource tickSource)
+        {
+            SteadyClockTimePoint result = GetTimePoint(tickSource);
+
+            result.TimePoint += GetTestOffset().ToSeconds();
+            result.TimePoint += GetInternalOffset().ToSeconds();
+
+            return result;
+        }
+
+        public bool IsInitialized()
+        {
+            return _isInitialized;
+        }
+
+        public void MarkInitialized()
+        {
+            _isInitialized = true;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockContextUpdateCallback.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockContextUpdateCallback.cs
@@ -0,0 +1,71 @@
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    abstract class SystemClockContextUpdateCallback
+    {
+        private   List<KWritableEvent> _operationEventList;
+        protected SystemClockContext   _context;
+        private   bool                 _hasContext;
+
+        public SystemClockContextUpdateCallback()
+        {
+            _operationEventList = new List<KWritableEvent>();
+            _context            = new SystemClockContext();
+            _hasContext         = false;
+        }
+
+        private bool NeedUpdate(SystemClockContext context)
+        {
+            if (_hasContext)
+            {
+                return _context.Offset != context.Offset || _context.SteadyTimePoint.ClockSourceId != context.SteadyTimePoint.ClockSourceId;
+            }
+
+            return true;
+        }
+
+        public void RegisterOperationEvent(KWritableEvent writableEvent)
+        {
+            Monitor.Enter(_operationEventList);
+            _operationEventList.Add(writableEvent);
+            Monitor.Exit(_operationEventList);
+        }
+
+        private void BroadcastOperationEvent()
+        {
+            Monitor.Enter(_operationEventList);
+
+            foreach (KWritableEvent e in _operationEventList)
+            {
+                e.Signal();
+            }
+
+            Monitor.Exit(_operationEventList);
+        }
+
+        protected abstract ResultCode Update();
+
+        public ResultCode Update(SystemClockContext context)
+        {
+            ResultCode result = ResultCode.Success;
+
+            if (NeedUpdate(context))
+            {
+                _context    = context;
+                _hasContext = true;
+
+                result = Update();
+
+                if (result == ResultCode.Success)
+                {
+                    BroadcastOperationEvent();
+                }
+            }
+
+            return result;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/SystemClockCore.cs
@@ -0,0 +1,144 @@
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    abstract class SystemClockCore
+    {
+        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()
+        {
+            return _steadyClockCore;
+        }
+
+        public ResultCode GetCurrentTime(ITickSource tickSource, out long posixTime)
+        {
+            posixTime = 0;
+
+            SteadyClockTimePoint currentTimePoint = _steadyClockCore.GetCurrentTimePoint(tickSource);
+
+            ResultCode result = GetClockContext(tickSource, 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(ITickSource tickSource, long posixTime)
+        {
+            SteadyClockTimePoint currentTimePoint = _steadyClockCore.GetCurrentTimePoint(tickSource);
+
+            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(ITickSource tickSource, out SystemClockContext context)
+        {
+            context = _context;
+
+            return ResultCode.Success;
+        }
+
+        public virtual ResultCode SetClockContext(SystemClockContext context)
+        {
+            _context = context;
+
+            return ResultCode.Success;
+        }
+
+        protected virtual ResultCode Flush(SystemClockContext context)
+        {
+            if (_systemClockContextUpdateCallback == null)
+            {
+                return ResultCode.Success;
+            }
+
+            return _systemClockContextUpdateCallback.Update(context);
+        }
+
+        public void SetUpdateCallbackInstance(SystemClockContextUpdateCallback systemClockContextUpdateCallback)
+        {
+            _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)
+            {
+                result = Flush(context);
+            }
+
+            return result;
+        }
+
+        public bool IsInitialized()
+        {
+            return _isInitialized;
+        }
+
+        public void MarkInitialized()
+        {
+            _isInitialized = true;
+        }
+
+        public bool IsClockSetup(ITickSource tickSource)
+        {
+            ResultCode result = GetClockContext(tickSource, out SystemClockContext context);
+
+            if (result == ResultCode.Success)
+            {
+                SteadyClockTimePoint steadyClockTimePoint = _steadyClockCore.GetCurrentTimePoint(tickSource);
+
+                return steadyClockTimePoint.ClockSourceId == context.SteadyTimePoint.ClockSourceId;
+            }
+
+            return false;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/TickBasedSteadyClockCore.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/TickBasedSteadyClockCore.cs
@@ -0,0 +1,24 @@
+using Ryujinx.Cpu;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    class TickBasedSteadyClockCore : SteadyClockCore
+    {
+        public TickBasedSteadyClockCore() {}
+
+        public override SteadyClockTimePoint GetTimePoint(ITickSource tickSource)
+        {
+            SteadyClockTimePoint result = new SteadyClockTimePoint
+            {
+                TimePoint     = 0,
+                ClockSourceId = GetClockSourceId()
+            };
+
+            TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
+
+            result.TimePoint = ticksTimeSpan.ToSeconds();
+
+            return result;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/ClockSnapshot.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/ClockSnapshot.cs
@@ -0,0 +1,50 @@
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0xD0)]
+    struct ClockSnapshot
+    {
+        public SystemClockContext     UserContext;
+        public SystemClockContext     NetworkContext;
+        public long                   UserTime;
+        public long                   NetworkTime;
+        public CalendarTime           UserCalendarTime;
+        public CalendarTime           NetworkCalendarTime;
+        public CalendarAdditionalInfo UserCalendarAdditionalTime;
+        public CalendarAdditionalInfo NetworkCalendarAdditionalTime;
+        public SteadyClockTimePoint   SteadyClockTimePoint;
+
+        private LocationNameStorageHolder _locationName;
+
+        public Span<byte> LocationName => MemoryMarshal.Cast<LocationNameStorageHolder, byte>(MemoryMarshal.CreateSpan(ref _locationName, LocationNameStorageHolder.Size));
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool   IsAutomaticCorrectionEnabled;
+        public byte   Type;
+        public ushort Unknown;
+
+
+        [StructLayout(LayoutKind.Sequential, Pack = 1, Size = Size)]
+        private struct LocationNameStorageHolder
+        {
+            public const int Size = 0x24;
+        }
+
+        public static ResultCode GetCurrentTime(out long currentTime, SteadyClockTimePoint steadyClockTimePoint, SystemClockContext context)
+        {
+            currentTime = 0;
+
+            if (steadyClockTimePoint.ClockSourceId == context.SteadyTimePoint.ClockSourceId)
+            {
+                currentTime = steadyClockTimePoint.TimePoint + context.Offset;
+
+                return ResultCode.Success;
+            }
+
+            return ResultCode.TimeMismatch;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/SteadyClockTimePoint.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/SteadyClockTimePoint.cs
@@ -0,0 +1,43 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    struct SteadyClockTimePoint
+    {
+        public long    TimePoint;
+        public UInt128 ClockSourceId;
+
+        public ResultCode GetSpanBetween(SteadyClockTimePoint other, out long outSpan)
+        {
+            outSpan = 0;
+
+            if (ClockSourceId == other.ClockSourceId)
+            {
+                try
+                {
+                    outSpan = checked(other.TimePoint - TimePoint);
+
+                    return ResultCode.Success;
+                }
+                catch (OverflowException)
+                {
+                    return ResultCode.Overflow;
+                }
+            }
+
+            return ResultCode.Overflow;
+        }
+
+        public static SteadyClockTimePoint GetRandom()
+        {
+            return new SteadyClockTimePoint
+            {
+                TimePoint     = 0,
+                ClockSourceId = UInt128Utils.CreateRandom()
+            };
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/SystemClockContext.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/SystemClockContext.cs
@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    struct SystemClockContext
+    {
+        public long                 Offset;
+        public SteadyClockTimePoint SteadyTimePoint;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/TimeSpanType.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Clock/Types/TimeSpanType.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Clock
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct TimeSpanType
+    {
+        private const long NanoSecondsPerSecond = 1000000000;
+
+        public static readonly TimeSpanType Zero = new TimeSpanType(0);
+
+        public long NanoSeconds;
+
+        public TimeSpanType(long nanoSeconds)
+        {
+            NanoSeconds = nanoSeconds;
+        }
+
+        public long ToSeconds()
+        {
+            return NanoSeconds / NanoSecondsPerSecond;
+        }
+
+        public TimeSpanType AddSeconds(long seconds)
+        {
+            return new TimeSpanType(NanoSeconds + (seconds * NanoSecondsPerSecond));
+        }
+
+        public bool IsDaylightSavingTime()
+        {
+            return DateTime.UnixEpoch.AddSeconds(ToSeconds()).ToLocalTime().IsDaylightSavingTime();
+        }
+
+        public static TimeSpanType FromSeconds(long seconds)
+        {
+            return new TimeSpanType(seconds * NanoSecondsPerSecond);
+        }
+
+        public static TimeSpanType FromTimeSpan(TimeSpan timeSpan)
+        {
+            return new TimeSpanType((long)(timeSpan.TotalMilliseconds * 1000000));
+        }
+
+        public static TimeSpanType FromTicks(ulong ticks, ulong frequency)
+        {
+            return FromSeconds((long)ticks / (long)frequency);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/IAlarmService.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/IAlarmService.cs
@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Service("time:al")] // 9.0.0+
+    class IAlarmService : IpcService
+    {
+        public IAlarmService(ServiceCtx context) { }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/IPowerStateRequestHandler.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/IPowerStateRequestHandler.cs
@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Service("time:p")] // 9.0.0+
+    class IPowerStateRequestHandler : IpcService
+    {
+        public IPowerStateRequestHandler(ServiceCtx context) { }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/IStaticServiceForGlue.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/IStaticServiceForGlue.cs
@@ -0,0 +1,184 @@
+using Ryujinx.Common;
+using Ryujinx.HLE.HOS.Services.Pcv.Bpc;
+using Ryujinx.HLE.HOS.Services.Settings;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.HOS.Services.Time.StaticService;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Service("time:a", TimePermissions.Admin)]
+    [Service("time:r", TimePermissions.Repair)]
+    [Service("time:u", TimePermissions.User)]
+    class IStaticServiceForGlue : IpcService
+    {
+        private IStaticServiceForPsc _inner;
+        private TimePermissions      _permissions;
+
+        public IStaticServiceForGlue(ServiceCtx context, TimePermissions permissions) : base(context.Device.System.TimeServer)
+        {
+            _permissions = permissions;
+            _inner       = new IStaticServiceForPsc(context, permissions);
+            _inner.TrySetServer(Server);
+            _inner.SetParent(this);
+        }
+
+        [CommandCmif(0)]
+        // GetStandardUserSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardUserSystemClock(ServiceCtx context)
+        {
+            return _inner.GetStandardUserSystemClock(context);
+        }
+
+        [CommandCmif(1)]
+        // GetStandardNetworkSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardNetworkSystemClock(ServiceCtx context)
+        {
+            return _inner.GetStandardNetworkSystemClock(context);
+        }
+
+        [CommandCmif(2)]
+        // GetStandardSteadyClock() -> object<nn::timesrv::detail::service::ISteadyClock>
+        public ResultCode GetStandardSteadyClock(ServiceCtx context)
+        {
+            return _inner.GetStandardSteadyClock(context);
+        }
+
+        [CommandCmif(3)]
+        // GetTimeZoneService() -> object<nn::timesrv::detail::service::ITimeZoneService>
+        public ResultCode GetTimeZoneService(ServiceCtx context)
+        {
+            MakeObject(context, new ITimeZoneServiceForGlue(TimeManager.Instance.TimeZone, (_permissions & TimePermissions.TimeZoneWritableMask) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(4)]
+        // GetStandardLocalSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardLocalSystemClock(ServiceCtx context)
+        {
+            return _inner.GetStandardLocalSystemClock(context);
+        }
+
+        [CommandCmif(5)] // 4.0.0+
+        // GetEphemeralNetworkSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetEphemeralNetworkSystemClock(ServiceCtx context)
+        {
+            return _inner.GetEphemeralNetworkSystemClock(context);
+        }
+
+        [CommandCmif(20)] // 6.0.0+
+        // GetSharedMemoryNativeHandle() -> handle<copy>
+        public ResultCode GetSharedMemoryNativeHandle(ServiceCtx context)
+        {
+            return _inner.GetSharedMemoryNativeHandle(context);
+        }
+
+        [CommandCmif(50)] // 4.0.0+
+        // SetStandardSteadyClockInternalOffset(nn::TimeSpanType internal_offset)
+        public ResultCode SetStandardSteadyClockInternalOffset(ServiceCtx context)
+        {
+            if ((_permissions & TimePermissions.SteadyClockWritableMask) == 0)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            TimeSpanType internalOffset = context.RequestData.ReadStruct<TimeSpanType>();
+
+            // TODO: set:sys SetExternalSteadyClockInternalOffset(internalOffset.ToSeconds())
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(51)] // 9.0.0+
+        // GetStandardSteadyClockRtcValue() -> u64
+        public ResultCode GetStandardSteadyClockRtcValue(ServiceCtx context)
+        {
+            ResultCode result = (ResultCode)IRtcManager.GetExternalRtcValue(out ulong rtcValue);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.Write(rtcValue);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(100)]
+        // IsStandardUserSystemClockAutomaticCorrectionEnabled() -> bool
+        public ResultCode IsStandardUserSystemClockAutomaticCorrectionEnabled(ServiceCtx context)
+        {
+            return _inner.IsStandardUserSystemClockAutomaticCorrectionEnabled(context);
+        }
+
+        [CommandCmif(101)]
+        // SetStandardUserSystemClockAutomaticCorrectionEnabled(b8)
+        public ResultCode SetStandardUserSystemClockAutomaticCorrectionEnabled(ServiceCtx context)
+        {
+            return _inner.SetStandardUserSystemClockAutomaticCorrectionEnabled(context);
+        }
+
+        [CommandCmif(102)] // 5.0.0+
+        // GetStandardUserSystemClockInitialYear() -> u32
+        public ResultCode GetStandardUserSystemClockInitialYear(ServiceCtx context)
+        {
+            if (!NxSettings.Settings.TryGetValue("time!standard_user_clock_initial_year", out object standardUserSystemClockInitialYear))
+            {
+                throw new InvalidOperationException("standard_user_clock_initial_year isn't defined in system settings!");
+            }
+
+            context.ResponseData.Write((int)standardUserSystemClockInitialYear);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(200)] // 3.0.0+
+        // IsStandardNetworkSystemClockAccuracySufficient() -> bool
+        public ResultCode IsStandardNetworkSystemClockAccuracySufficient(ServiceCtx context)
+        {
+            return _inner.IsStandardNetworkSystemClockAccuracySufficient(context);
+        }
+
+        [CommandCmif(201)] // 6.0.0+
+        // GetStandardUserSystemClockAutomaticCorrectionUpdatedTime() -> nn::time::SteadyClockTimePoint
+        public ResultCode GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(ServiceCtx context)
+        {
+            return _inner.GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(context);
+        }
+
+        [CommandCmif(300)] // 4.0.0+
+        // CalculateMonotonicSystemClockBaseTimePoint(nn::time::SystemClockContext) -> s64
+        public ResultCode CalculateMonotonicSystemClockBaseTimePoint(ServiceCtx context)
+        {
+            return _inner.CalculateMonotonicSystemClockBaseTimePoint(context);
+        }
+
+        [CommandCmif(400)] // 4.0.0+
+        // GetClockSnapshot(u8) -> buffer<nn::time::sf::ClockSnapshot, 0x1a>
+        public ResultCode GetClockSnapshot(ServiceCtx context)
+        {
+            return _inner.GetClockSnapshot(context);
+        }
+
+        [CommandCmif(401)] // 4.0.0+
+        // GetClockSnapshotFromSystemClockContext(u8, nn::time::SystemClockContext, nn::time::SystemClockContext) -> buffer<nn::time::sf::ClockSnapshot, 0x1a>
+        public ResultCode GetClockSnapshotFromSystemClockContext(ServiceCtx context)
+        {
+            return _inner.GetClockSnapshotFromSystemClockContext(context);
+        }
+
+        [CommandCmif(500)] // 4.0.0+
+        // CalculateStandardUserSystemClockDifferenceByUser(buffer<nn::time::sf::ClockSnapshot, 0x19>, buffer<nn::time::sf::ClockSnapshot, 0x19>) -> nn::TimeSpanType
+        public ResultCode CalculateStandardUserSystemClockDifferenceByUser(ServiceCtx context)
+        {
+            return _inner.CalculateStandardUserSystemClockDifferenceByUser(context);
+        }
+
+        [CommandCmif(501)] // 4.0.0+
+        // CalculateSpanBetween(buffer<nn::time::sf::ClockSnapshot, 0x19>, buffer<nn::time::sf::ClockSnapshot, 0x19>) -> nn::TimeSpanType
+        public ResultCode CalculateSpanBetween(ServiceCtx context)
+        {
+            return _inner.CalculateSpanBetween(context);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/IStaticServiceForPsc.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/IStaticServiceForPsc.cs
@@ -0,0 +1,433 @@
+using Ryujinx.Common;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.HOS.Services.Time.StaticService;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using Ryujinx.Horizon.Common;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Service("time:s", TimePermissions.System)]
+    [Service("time:su", TimePermissions.SystemUpdate)]
+    class IStaticServiceForPsc : IpcService
+    {
+        private TimeManager     _timeManager;
+        private TimePermissions _permissions;
+
+        private int _timeSharedMemoryNativeHandle = 0;
+
+        public IStaticServiceForPsc(ServiceCtx context, TimePermissions permissions) : this(TimeManager.Instance, permissions) {}
+
+        public IStaticServiceForPsc(TimeManager manager, TimePermissions permissions)
+        {
+            _permissions = permissions;
+            _timeManager = manager;
+        }
+
+        [CommandCmif(0)]
+        // GetStandardUserSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardUserSystemClock(ServiceCtx context)
+        {
+            MakeObject(context, new ISystemClock(_timeManager.StandardUserSystemClock,
+                (_permissions & TimePermissions.UserSystemClockWritableMask) != 0,
+                (_permissions & TimePermissions.BypassUninitialized) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1)]
+        // GetStandardNetworkSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardNetworkSystemClock(ServiceCtx context)
+        {
+            MakeObject(context, new ISystemClock(_timeManager.StandardNetworkSystemClock,
+                (_permissions & TimePermissions.NetworkSystemClockWritableMask) != 0,
+                (_permissions & TimePermissions.BypassUninitialized) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(2)]
+        // GetStandardSteadyClock() -> object<nn::timesrv::detail::service::ISteadyClock>
+        public ResultCode GetStandardSteadyClock(ServiceCtx context)
+        {
+            MakeObject(context, new ISteadyClock(_timeManager.StandardSteadyClock,
+                (_permissions & TimePermissions.SteadyClockWritableMask) != 0,
+                (_permissions & TimePermissions.BypassUninitialized) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // GetTimeZoneService() -> object<nn::timesrv::detail::service::ITimeZoneService>
+        public ResultCode GetTimeZoneService(ServiceCtx context)
+        {
+            MakeObject(context, new ITimeZoneServiceForPsc(_timeManager.TimeZone.Manager,
+                (_permissions & TimePermissions.TimeZoneWritableMask) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(4)]
+        // GetStandardLocalSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetStandardLocalSystemClock(ServiceCtx context)
+        {
+            MakeObject(context, new ISystemClock(_timeManager.StandardLocalSystemClock,
+                (_permissions & TimePermissions.LocalSystemClockWritableMask) != 0,
+                (_permissions & TimePermissions.BypassUninitialized) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(5)] // 4.0.0+
+        // GetEphemeralNetworkSystemClock() -> object<nn::timesrv::detail::service::ISystemClock>
+        public ResultCode GetEphemeralNetworkSystemClock(ServiceCtx context)
+        {
+            MakeObject(context, new ISystemClock(_timeManager.StandardNetworkSystemClock,
+                (_permissions & TimePermissions.NetworkSystemClockWritableMask) != 0,
+                (_permissions & TimePermissions.BypassUninitialized) != 0));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(20)] // 6.0.0+
+        // GetSharedMemoryNativeHandle() -> handle<copy>
+        public ResultCode GetSharedMemoryNativeHandle(ServiceCtx context)
+        {
+            if (_timeSharedMemoryNativeHandle == 0)
+            {
+                if (context.Process.HandleTable.GenerateHandle(_timeManager.SharedMemory.GetSharedMemory(), out _timeSharedMemoryNativeHandle) != Result.Success)
+                {
+                    throw new InvalidOperationException("Out of handles!");
+                }
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_timeSharedMemoryNativeHandle);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(50)] // 4.0.0+
+        // SetStandardSteadyClockInternalOffset(nn::TimeSpanType internal_offset)
+        public ResultCode SetStandardSteadyClockInternalOffset(ServiceCtx context)
+        {
+            // This is only implemented in glue's StaticService.
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(51)] // 9.0.0+
+        // GetStandardSteadyClockRtcValue() -> u64
+        public ResultCode GetStandardSteadyClockRtcValue(ServiceCtx context)
+        {
+            // This is only implemented in glue's StaticService.
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(100)]
+        // IsStandardUserSystemClockAutomaticCorrectionEnabled() -> bool
+        public ResultCode IsStandardUserSystemClockAutomaticCorrectionEnabled(ServiceCtx context)
+        {
+            StandardUserSystemClockCore userClock = _timeManager.StandardUserSystemClock;
+
+            if (!userClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.Write(userClock.IsAutomaticCorrectionEnabled());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(101)]
+        // SetStandardUserSystemClockAutomaticCorrectionEnabled(b8)
+        public ResultCode SetStandardUserSystemClockAutomaticCorrectionEnabled(ServiceCtx context)
+        {
+            SteadyClockCore             steadyClock = _timeManager.StandardSteadyClock;
+            StandardUserSystemClockCore userClock   = _timeManager.StandardUserSystemClock;
+
+            if (!userClock.IsInitialized() || !steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            if ((_permissions & TimePermissions.UserSystemClockWritableMask) == 0)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            bool autoCorrectionEnabled = context.RequestData.ReadBoolean();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            ResultCode result = userClock.SetAutomaticCorrectionEnabled(tickSource, autoCorrectionEnabled);
+
+            if (result == ResultCode.Success)
+            {
+                _timeManager.SharedMemory.SetAutomaticCorrectionEnabled(autoCorrectionEnabled);
+
+                SteadyClockTimePoint currentTimePoint = userClock.GetSteadyClockCore().GetCurrentTimePoint(tickSource);
+
+                userClock.SetAutomaticCorrectionUpdatedTime(currentTimePoint);
+                userClock.SignalAutomaticCorrectionEvent();
+            }
+
+            return result;
+        }
+
+        [CommandCmif(102)] // 5.0.0+
+        // GetStandardUserSystemClockInitialYear() -> u32
+        public ResultCode GetStandardUserSystemClockInitialYear(ServiceCtx context)
+        {
+            // This is only implemented in glue's StaticService.
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(200)] // 3.0.0+
+        // IsStandardNetworkSystemClockAccuracySufficient() -> bool
+        public ResultCode IsStandardNetworkSystemClockAccuracySufficient(ServiceCtx context)
+        {
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            context.ResponseData.Write(_timeManager.StandardNetworkSystemClock.IsStandardNetworkSystemClockAccuracySufficient(tickSource));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(201)] // 6.0.0+
+        // GetStandardUserSystemClockAutomaticCorrectionUpdatedTime() -> nn::time::SteadyClockTimePoint
+        public ResultCode GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(ServiceCtx context)
+        {
+            StandardUserSystemClockCore userClock = _timeManager.StandardUserSystemClock;
+
+            if (!userClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.WriteStruct(userClock.GetAutomaticCorrectionUpdatedTime());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(300)] // 4.0.0+
+        // CalculateMonotonicSystemClockBaseTimePoint(nn::time::SystemClockContext) -> s64
+        public ResultCode CalculateMonotonicSystemClockBaseTimePoint(ServiceCtx context)
+        {
+            SteadyClockCore steadyClock = _timeManager.StandardSteadyClock;
+
+            if (!steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            SystemClockContext   otherContext     = context.RequestData.ReadStruct<SystemClockContext>();
+            SteadyClockTimePoint currentTimePoint = steadyClock.GetCurrentTimePoint(tickSource);
+
+            ResultCode result = ResultCode.TimeMismatch;
+
+            if (currentTimePoint.ClockSourceId == otherContext.SteadyTimePoint.ClockSourceId)
+            {
+                TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
+                long         baseTimePoint = otherContext.Offset + currentTimePoint.TimePoint - ticksTimeSpan.ToSeconds();
+
+                context.ResponseData.Write(baseTimePoint);
+
+                result = ResultCode.Success;
+            }
+
+            return result;
+        }
+
+        [CommandCmif(400)] // 4.0.0+
+        // GetClockSnapshot(u8) -> buffer<nn::time::sf::ClockSnapshot, 0x1a>
+        public ResultCode GetClockSnapshot(ServiceCtx context)
+        {
+            byte type = context.RequestData.ReadByte();
+
+            context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize((uint)Marshal.SizeOf<ClockSnapshot>());
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            ResultCode result = _timeManager.StandardUserSystemClock.GetClockContext(tickSource, out SystemClockContext userContext);
+
+            if (result == ResultCode.Success)
+            {
+                result = _timeManager.StandardNetworkSystemClock.GetClockContext(tickSource, out SystemClockContext networkContext);
+
+                if (result == ResultCode.Success)
+                {
+                    result = GetClockSnapshotFromSystemClockContextInternal(tickSource, userContext, networkContext, type, out ClockSnapshot clockSnapshot);
+
+                    if (result == ResultCode.Success)
+                    {
+                        WriteClockSnapshotFromBuffer(context, context.Request.RecvListBuff[0], clockSnapshot);
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        [CommandCmif(401)] // 4.0.0+
+        // GetClockSnapshotFromSystemClockContext(u8, nn::time::SystemClockContext, nn::time::SystemClockContext) -> buffer<nn::time::sf::ClockSnapshot, 0x1a>
+        public ResultCode GetClockSnapshotFromSystemClockContext(ServiceCtx context)
+        {
+            byte type = context.RequestData.ReadByte();
+
+            context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize((uint)Unsafe.SizeOf<ClockSnapshot>());
+
+            context.RequestData.BaseStream.Position += 7;
+
+            SystemClockContext userContext    = context.RequestData.ReadStruct<SystemClockContext>();
+            SystemClockContext networkContext = context.RequestData.ReadStruct<SystemClockContext>();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            ResultCode result = GetClockSnapshotFromSystemClockContextInternal(tickSource, userContext, networkContext, type, out ClockSnapshot clockSnapshot);
+
+            if (result == ResultCode.Success)
+            {
+                WriteClockSnapshotFromBuffer(context, context.Request.RecvListBuff[0], clockSnapshot);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(500)] // 4.0.0+
+        // CalculateStandardUserSystemClockDifferenceByUser(buffer<nn::time::sf::ClockSnapshot, 0x19>, buffer<nn::time::sf::ClockSnapshot, 0x19>) -> nn::TimeSpanType
+        public ResultCode CalculateStandardUserSystemClockDifferenceByUser(ServiceCtx context)
+        {
+            ClockSnapshot clockSnapshotA = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[0]);
+            ClockSnapshot clockSnapshotB = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[1]);
+            TimeSpanType  difference     = TimeSpanType.FromSeconds(clockSnapshotB.UserContext.Offset - clockSnapshotA.UserContext.Offset);
+
+            if (clockSnapshotB.UserContext.SteadyTimePoint.ClockSourceId != clockSnapshotA.UserContext.SteadyTimePoint.ClockSourceId || (clockSnapshotB.IsAutomaticCorrectionEnabled && clockSnapshotA.IsAutomaticCorrectionEnabled))
+            {
+                difference = new TimeSpanType(0);
+            }
+
+            context.ResponseData.Write(difference.NanoSeconds);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(501)] // 4.0.0+
+        // CalculateSpanBetween(buffer<nn::time::sf::ClockSnapshot, 0x19>, buffer<nn::time::sf::ClockSnapshot, 0x19>) -> nn::TimeSpanType
+        public ResultCode CalculateSpanBetween(ServiceCtx context)
+        {
+            ClockSnapshot clockSnapshotA = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[0]);
+            ClockSnapshot clockSnapshotB = ReadClockSnapshotFromBuffer(context, context.Request.PtrBuff[1]);
+
+            TimeSpanType result;
+
+            ResultCode resultCode = clockSnapshotA.SteadyClockTimePoint.GetSpanBetween(clockSnapshotB.SteadyClockTimePoint, out long timeSpan);
+
+            if (resultCode != ResultCode.Success)
+            {
+                resultCode = ResultCode.TimeNotFound;
+
+                if (clockSnapshotA.NetworkTime != 0 && clockSnapshotB.NetworkTime != 0)
+                {
+                    result     = TimeSpanType.FromSeconds(clockSnapshotB.NetworkTime - clockSnapshotA.NetworkTime);
+                    resultCode = ResultCode.Success;
+                }
+                else
+                {
+                    return resultCode;
+                }
+            }
+            else
+            {
+                result = TimeSpanType.FromSeconds(timeSpan);
+            }
+
+            context.ResponseData.Write(result.NanoSeconds);
+
+            return resultCode;
+        }
+
+        private ResultCode GetClockSnapshotFromSystemClockContextInternal(ITickSource tickSource, SystemClockContext userContext, SystemClockContext networkContext, byte type, out ClockSnapshot clockSnapshot)
+        {
+            clockSnapshot = new ClockSnapshot();
+
+            SteadyClockCore      steadyClockCore  = _timeManager.StandardSteadyClock;
+            SteadyClockTimePoint currentTimePoint = steadyClockCore.GetCurrentTimePoint(tickSource);
+
+            clockSnapshot.IsAutomaticCorrectionEnabled = _timeManager.StandardUserSystemClock.IsAutomaticCorrectionEnabled();
+            clockSnapshot.UserContext                  = userContext;
+            clockSnapshot.NetworkContext               = networkContext;
+            clockSnapshot.SteadyClockTimePoint         = currentTimePoint;
+
+            ResultCode result = _timeManager.TimeZone.Manager.GetDeviceLocationName(out string deviceLocationName);
+
+            if (result != ResultCode.Success)
+            {
+                return result;
+            }
+
+            ReadOnlySpan<byte> tzName = Encoding.ASCII.GetBytes(deviceLocationName);
+
+            tzName.CopyTo(clockSnapshot.LocationName);
+
+            result = ClockSnapshot.GetCurrentTime(out clockSnapshot.UserTime, currentTimePoint, clockSnapshot.UserContext);
+
+            if (result == ResultCode.Success)
+            {
+                result = _timeManager.TimeZone.Manager.ToCalendarTimeWithMyRules(clockSnapshot.UserTime, out CalendarInfo userCalendarInfo);
+
+                if (result == ResultCode.Success)
+                {
+                    clockSnapshot.UserCalendarTime           = userCalendarInfo.Time;
+                    clockSnapshot.UserCalendarAdditionalTime = userCalendarInfo.AdditionalInfo;
+
+                    if (ClockSnapshot.GetCurrentTime(out clockSnapshot.NetworkTime, currentTimePoint, clockSnapshot.NetworkContext) != ResultCode.Success)
+                    {
+                        clockSnapshot.NetworkTime = 0;
+                    }
+
+                    result = _timeManager.TimeZone.Manager.ToCalendarTimeWithMyRules(clockSnapshot.NetworkTime, out CalendarInfo networkCalendarInfo);
+
+                    if (result == ResultCode.Success)
+                    {
+                        clockSnapshot.NetworkCalendarTime           = networkCalendarInfo.Time;
+                        clockSnapshot.NetworkCalendarAdditionalTime = networkCalendarInfo.AdditionalInfo;
+                        clockSnapshot.Type                          = type;
+
+                        // Probably a version field?
+                        clockSnapshot.Unknown = 0;
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private ClockSnapshot ReadClockSnapshotFromBuffer(ServiceCtx context, IpcPtrBuffDesc ipcDesc)
+        {
+            Debug.Assert(ipcDesc.Size == (ulong)Unsafe.SizeOf<ClockSnapshot>());
+
+            byte[] temp = new byte[ipcDesc.Size];
+
+            context.Memory.Read(ipcDesc.Position, temp);
+
+            using (BinaryReader bufferReader = new BinaryReader(new MemoryStream(temp)))
+            {
+                return bufferReader.ReadStruct<ClockSnapshot>();
+            }
+        }
+
+        private void WriteClockSnapshotFromBuffer(ServiceCtx context, IpcRecvListBuffDesc ipcDesc, ClockSnapshot clockSnapshot)
+        {
+            MemoryHelper.Write(context.Memory, ipcDesc.Position, clockSnapshot);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/ITimeServiceManager.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/ITimeServiceManager.cs
@@ -0,0 +1,231 @@
+using Ryujinx.Common;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.Exceptions;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.Utilities;
+using Ryujinx.Horizon.Common;
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Service("time:m")] // 9.0.0+
+    class ITimeServiceManager : IpcService
+    {
+        private TimeManager _timeManager;
+        private int         _automaticCorrectionEvent;
+
+        public ITimeServiceManager(ServiceCtx context)
+        {
+            _timeManager              = TimeManager.Instance;
+            _automaticCorrectionEvent = 0;
+        }
+
+        [CommandCmif(0)]
+        // GetUserStaticService() -> object<nn::timesrv::detail::service::IStaticService>
+        public ResultCode GetUserStaticService(ServiceCtx context)
+        {
+            MakeObject(context, new IStaticServiceForPsc(_timeManager, TimePermissions.User));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(5)]
+        // GetAdminStaticService() -> object<nn::timesrv::detail::service::IStaticService>
+        public ResultCode GetAdminStaticService(ServiceCtx context)
+        {
+            MakeObject(context, new IStaticServiceForPsc(_timeManager, TimePermissions.Admin));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(6)]
+        // GetRepairStaticService() -> object<nn::timesrv::detail::service::IStaticService>
+        public ResultCode GetRepairStaticService(ServiceCtx context)
+        {
+            MakeObject(context, new IStaticServiceForPsc(_timeManager, TimePermissions.Repair));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(9)]
+        // GetManufactureStaticService() -> object<nn::timesrv::detail::service::IStaticService>
+        public ResultCode GetManufactureStaticService(ServiceCtx context)
+        {
+            MakeObject(context, new IStaticServiceForPsc(_timeManager, TimePermissions.Manufacture));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(10)]
+        // SetupStandardSteadyClock(nn::util::Uuid clock_source_id, nn::TimeSpanType setup_value,  nn::TimeSpanType internal_offset,  nn::TimeSpanType test_offset, bool is_rtc_reset_detected)
+        public ResultCode SetupStandardSteadyClock(ServiceCtx context)
+        {
+            UInt128      clockSourceId      = context.RequestData.ReadStruct<UInt128>();
+            TimeSpanType setupValue         = context.RequestData.ReadStruct<TimeSpanType>();
+            TimeSpanType internalOffset     = context.RequestData.ReadStruct<TimeSpanType>();
+            TimeSpanType testOffset         = context.RequestData.ReadStruct<TimeSpanType>();
+            bool         isRtcResetDetected = context.RequestData.ReadBoolean();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            _timeManager.SetupStandardSteadyClock(tickSource, clockSourceId, setupValue, internalOffset, testOffset, isRtcResetDetected);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(11)]
+        // SetupStandardLocalSystemClock(nn::time::SystemClockContext context, nn::time::PosixTime posix_time)
+        public ResultCode SetupStandardLocalSystemClock(ServiceCtx context)
+        {
+            SystemClockContext clockContext = context.RequestData.ReadStruct<SystemClockContext>();
+            long               posixTime    = context.RequestData.ReadInt64();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            _timeManager.SetupStandardLocalSystemClock(tickSource, clockContext, posixTime);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(12)]
+        // SetupStandardNetworkSystemClock(nn::time::SystemClockContext context, nn::TimeSpanType sufficient_accuracy)
+        public ResultCode SetupStandardNetworkSystemClock(ServiceCtx context)
+        {
+            SystemClockContext clockContext       = context.RequestData.ReadStruct<SystemClockContext>();
+            TimeSpanType       sufficientAccuracy = context.RequestData.ReadStruct<TimeSpanType>();
+
+            _timeManager.SetupStandardNetworkSystemClock(clockContext, sufficientAccuracy);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(13)]
+        // SetupStandardUserSystemClock(bool automatic_correction_enabled, nn::time::SteadyClockTimePoint steady_clock_timepoint)
+        public ResultCode SetupStandardUserSystemClock(ServiceCtx context)
+        {
+            bool isAutomaticCorrectionEnabled = context.RequestData.ReadBoolean();
+
+            context.RequestData.BaseStream.Position += 7;
+
+            SteadyClockTimePoint steadyClockTimePoint = context.RequestData.ReadStruct<SteadyClockTimePoint>();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            _timeManager.SetupStandardUserSystemClock(tickSource, isAutomaticCorrectionEnabled, steadyClockTimePoint);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(14)]
+        // SetupTimeZoneManager(nn::time::LocationName location_name, nn::time::SteadyClockTimePoint timezone_update_timepoint, u32 total_location_name_count, nn::time::TimeZoneRuleVersion timezone_rule_version, buffer<nn::time::TimeZoneBinary, 0x21> timezone_binary)
+        public ResultCode SetupTimeZoneManager(ServiceCtx context)
+        {
+            string               locationName            = StringUtils.ReadInlinedAsciiString(context.RequestData, 0x24);
+            SteadyClockTimePoint timeZoneUpdateTimePoint = context.RequestData.ReadStruct<SteadyClockTimePoint>();
+            uint                 totalLocationNameCount  = context.RequestData.ReadUInt32();
+            UInt128              timeZoneRuleVersion     = context.RequestData.ReadStruct<UInt128>();
+
+            (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
+
+            byte[] temp = new byte[bufferSize];
+
+            context.Memory.Read(bufferPosition, temp);
+
+            using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))
+            {
+                _timeManager.SetupTimeZoneManager(locationName, timeZoneUpdateTimePoint, totalLocationNameCount, timeZoneRuleVersion, timeZoneBinaryStream);
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(15)]
+        // SetupEphemeralNetworkSystemClock()
+        public ResultCode SetupEphemeralNetworkSystemClock(ServiceCtx context)
+        {
+            _timeManager.SetupEphemeralNetworkSystemClock();
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(50)]
+        // Unknown50() -> handle<copy>
+        public ResultCode Unknown50(ServiceCtx context)
+        {
+            // TODO: figure out the usage of this event
+            throw new ServiceNotImplementedException(this, context);
+        }
+
+        [CommandCmif(51)]
+        // Unknown51() -> handle<copy>
+        public ResultCode Unknown51(ServiceCtx context)
+        {
+            // TODO: figure out the usage of this event
+            throw new ServiceNotImplementedException(this, context);
+        }
+
+        [CommandCmif(52)]
+        // Unknown52() -> handle<copy>
+        public ResultCode Unknown52(ServiceCtx context)
+        {
+            // TODO: figure out the usage of this event
+            throw new ServiceNotImplementedException(this, context);
+        }
+
+        [CommandCmif(60)]
+        // GetStandardUserSystemClockAutomaticCorrectionEvent() -> handle<copy>
+        public ResultCode GetStandardUserSystemClockAutomaticCorrectionEvent(ServiceCtx context)
+        {
+            if (_automaticCorrectionEvent == 0)
+            {
+                if (context.Process.HandleTable.GenerateHandle(_timeManager.StandardUserSystemClock.GetAutomaticCorrectionReadableEvent(), out _automaticCorrectionEvent) != Result.Success)
+                {
+                    throw new InvalidOperationException("Out of handles!");
+                }
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_automaticCorrectionEvent);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(100)]
+        // SetStandardSteadyClockRtcOffset(nn::TimeSpanType rtc_offset)
+        public ResultCode SetStandardSteadyClockRtcOffset(ServiceCtx context)
+        {
+            TimeSpanType rtcOffset = context.RequestData.ReadStruct<TimeSpanType>();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            _timeManager.SetStandardSteadyClockRtcOffset(tickSource, rtcOffset);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(200)]
+        // GetAlarmRegistrationEvent() -> handle<copy>
+        public ResultCode GetAlarmRegistrationEvent(ServiceCtx context)
+        {
+            // TODO
+            throw new ServiceNotImplementedException(this, context);
+        }
+
+        [CommandCmif(201)]
+        // UpdateSteadyAlarms()
+        public ResultCode UpdateSteadyAlarms(ServiceCtx context)
+        {
+            // TODO
+            throw new ServiceNotImplementedException(this, context);
+        }
+
+        [CommandCmif(202)]
+        // TryGetNextSteadyClockAlarmSnapshot() -> (bool, nn::time::SteadyClockAlarmSnapshot)
+        public ResultCode TryGetNextSteadyClockAlarmSnapshot(ServiceCtx context)
+        {
+            // TODO
+            throw new ServiceNotImplementedException(this, context);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/ResultCode.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/ResultCode.cs
@@ -0,0 +1,24 @@
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    public enum ResultCode
+    {
+        ModuleId       = 116,
+        ErrorCodeShift = 9,
+
+        Success = 0,
+
+        TimeServiceNotInitialized = (0    << ErrorCodeShift) | ModuleId,
+        PermissionDenied          = (1    << ErrorCodeShift) | ModuleId,
+        TimeMismatch              = (102  << ErrorCodeShift) | ModuleId,
+        UninitializedClock        = (103  << ErrorCodeShift) | ModuleId,
+        TimeNotFound              = (200  << ErrorCodeShift) | ModuleId,
+        Overflow                  = (201  << ErrorCodeShift) | ModuleId,
+        LocationNameTooLong       = (801  << ErrorCodeShift) | ModuleId,
+        OutOfRange                = (902  << ErrorCodeShift) | ModuleId,
+        TimeZoneConversionFailed  = (903  << ErrorCodeShift) | ModuleId,
+        TimeZoneNotFound          = (989  << ErrorCodeShift) | ModuleId,
+        NotImplemented            = (990  << ErrorCodeShift) | ModuleId,
+        NetworkTimeNotAvailable   = (1000 << ErrorCodeShift) | ModuleId,
+        NetworkTimeTaskCanceled   = (1003 << ErrorCodeShift) | ModuleId,
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ISteadyClock.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ISteadyClock.cs
@@ -0,0 +1,155 @@
+using Ryujinx.Common;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+
+namespace Ryujinx.HLE.HOS.Services.Time.StaticService
+{
+    class ISteadyClock : IpcService
+    {
+        private SteadyClockCore _steadyClock;
+        private bool            _writePermission;
+        private bool            _bypassUninitializedClock;
+
+        public ISteadyClock(SteadyClockCore steadyClock, bool writePermission, bool bypassUninitializedClock)
+        {
+            _steadyClock              = steadyClock;
+            _writePermission          = writePermission;
+            _bypassUninitializedClock = bypassUninitializedClock;
+        }
+
+        [CommandCmif(0)]
+        // GetCurrentTimePoint() -> nn::time::SteadyClockTimePoint
+        public ResultCode GetCurrentTimePoint(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            SteadyClockTimePoint currentTimePoint = _steadyClock.GetCurrentTimePoint(tickSource);
+
+            context.ResponseData.WriteStruct(currentTimePoint);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(2)]
+        // GetTestOffset() -> nn::TimeSpanType
+        public ResultCode GetTestOffset(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.WriteStruct(_steadyClock.GetTestOffset());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // SetTestOffset(nn::TimeSpanType)
+        public ResultCode SetTestOffset(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            TimeSpanType testOffset = context.RequestData.ReadStruct<TimeSpanType>();
+
+            _steadyClock.SetTestOffset(testOffset);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(100)] // 2.0.0+
+        // GetRtcValue() -> u64
+        public ResultCode GetRtcValue(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            ResultCode result = _steadyClock.GetRtcValue(out ulong rtcValue);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.Write(rtcValue);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(101)] // 2.0.0+
+        // IsRtcResetDetected() -> bool
+        public ResultCode IsRtcResetDetected(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.Write(_steadyClock.IsRtcResetDetected());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(102)] // 2.0.0+
+        // GetSetupResultValue() -> u32
+        public ResultCode GetSetupResultValue(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.Write((uint)_steadyClock.GetSetupResultValue());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(200)] // 3.0.0+
+        // GetInternalOffset() -> nn::TimeSpanType
+        public ResultCode GetInternalOffset(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            context.ResponseData.WriteStruct(_steadyClock.GetInternalOffset());
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(201)] // 3.0.0-3.0.2
+        // SetInternalOffset(nn::TimeSpanType)
+        public ResultCode SetInternalOffset(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            if (!_bypassUninitializedClock && !_steadyClock.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            TimeSpanType internalOffset = context.RequestData.ReadStruct<TimeSpanType>();
+
+            _steadyClock.SetInternalOffset(internalOffset);
+
+            return ResultCode.Success;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ISystemClock.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ISystemClock.cs
@@ -0,0 +1,131 @@
+using Ryujinx.Common;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.Horizon.Common;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Time.StaticService
+{
+    class ISystemClock : IpcService
+    {
+        private SystemClockCore _clockCore;
+        private bool            _writePermission;
+        private bool            _bypassUninitializedClock;
+        private int             _operationEventReadableHandle;
+
+        public ISystemClock(SystemClockCore clockCore, bool writePermission, bool bypassUninitializedClock)
+        {
+            _clockCore                    = clockCore;
+            _writePermission              = writePermission;
+            _bypassUninitializedClock     = bypassUninitializedClock;
+            _operationEventReadableHandle = 0;
+        }
+
+        [CommandCmif(0)]
+        // GetCurrentTime() -> nn::time::PosixTime
+        public ResultCode GetCurrentTime(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_clockCore.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            ResultCode result = _clockCore.GetCurrentTime(tickSource, out long posixTime);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.Write(posixTime);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(1)]
+        // SetCurrentTime(nn::time::PosixTime)
+        public ResultCode SetCurrentTime(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            if (!_bypassUninitializedClock && !_clockCore.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            long posixTime = context.RequestData.ReadInt64();
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            return _clockCore.SetCurrentTime(tickSource, posixTime);
+        }
+
+        [CommandCmif(2)]
+        // GetClockContext() -> nn::time::SystemClockContext
+        public ResultCode GetSystemClockContext(ServiceCtx context)
+        {
+            if (!_bypassUninitializedClock && !_clockCore.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            ITickSource tickSource = context.Device.System.TickSource;
+
+            ResultCode result = _clockCore.GetClockContext(tickSource, out SystemClockContext clockContext);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.WriteStruct(clockContext);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(3)]
+        // SetClockContext(nn::time::SystemClockContext)
+        public ResultCode SetSystemClockContext(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            if (!_bypassUninitializedClock && !_clockCore.IsInitialized())
+            {
+                return ResultCode.UninitializedClock;
+            }
+
+            SystemClockContext clockContext = context.RequestData.ReadStruct<SystemClockContext>();
+
+            ResultCode result = _clockCore.SetSystemClockContext(clockContext);
+
+            return result;
+        }
+
+        [CommandCmif(4)] // 9.0.0+
+        // GetOperationEventReadableHandle() -> handle<copy>
+        public ResultCode GetOperationEventReadableHandle(ServiceCtx context)
+        {
+            if (_operationEventReadableHandle == 0)
+            {
+                KEvent kEvent = new KEvent(context.Device.System.KernelContext);
+
+                _clockCore.RegisterOperationEvent(kEvent.WritableEvent);
+
+                if (context.Process.HandleTable.GenerateHandle(kEvent.ReadableEvent, out _operationEventReadableHandle) != Result.Success)
+                {
+                    throw new InvalidOperationException("Out of handles!");
+                }
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_operationEventReadableHandle);
+
+            return ResultCode.Success;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ITimeZoneServiceForGlue.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ITimeZoneServiceForGlue.cs
@@ -0,0 +1,142 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using Ryujinx.HLE.Utilities;
+using Ryujinx.Memory;
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Ryujinx.HLE.HOS.Services.Time.StaticService
+{
+    class ITimeZoneServiceForGlue : IpcService
+    {
+        private TimeZoneContentManager _timeZoneContentManager;
+        private ITimeZoneServiceForPsc _inner;
+        private bool                   _writePermission;
+
+        public ITimeZoneServiceForGlue(TimeZoneContentManager timeZoneContentManager, bool writePermission)
+        {
+            _timeZoneContentManager = timeZoneContentManager;
+            _writePermission        = writePermission;
+            _inner                  = new ITimeZoneServiceForPsc(timeZoneContentManager.Manager, writePermission);
+        }
+
+        [CommandCmif(0)]
+        // GetDeviceLocationName() -> nn::time::LocationName
+        public ResultCode GetDeviceLocationName(ServiceCtx context)
+        {
+            return _inner.GetDeviceLocationName(context);
+        }
+
+        [CommandCmif(1)]
+        // SetDeviceLocationName(nn::time::LocationName)
+        public ResultCode SetDeviceLocationName(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            string locationName = StringUtils.ReadInlinedAsciiString(context.RequestData, 0x24);
+
+            return _timeZoneContentManager.SetDeviceLocationName(locationName);
+        }
+
+        [CommandCmif(2)]
+        // GetTotalLocationNameCount() -> u32
+        public ResultCode GetTotalLocationNameCount(ServiceCtx context)
+        {
+            return _inner.GetTotalLocationNameCount(context);
+        }
+
+        [CommandCmif(3)]
+        // LoadLocationNameList(u32 index) -> (u32 outCount, buffer<nn::time::LocationName, 6>)
+        public ResultCode LoadLocationNameList(ServiceCtx context)
+        {
+            uint  index          = context.RequestData.ReadUInt32();
+            ulong bufferPosition = context.Request.ReceiveBuff[0].Position;
+            ulong bufferSize     = context.Request.ReceiveBuff[0].Size;
+
+            ResultCode errorCode = _timeZoneContentManager.LoadLocationNameList(index, out string[] locationNameArray, (uint)bufferSize / 0x24);
+
+            if (errorCode == 0)
+            {
+                uint offset = 0;
+
+                foreach (string locationName in locationNameArray)
+                {
+                    int padding = 0x24 - locationName.Length;
+
+                    if (padding < 0)
+                    {
+                        return ResultCode.LocationNameTooLong;
+                    }
+
+                    context.Memory.Write(bufferPosition + offset, Encoding.ASCII.GetBytes(locationName));
+                    MemoryHelper.FillWithZeros(context.Memory, bufferPosition + offset + (ulong)locationName.Length, padding);
+
+                    offset += 0x24;
+                }
+
+                context.ResponseData.Write((uint)locationNameArray.Length);
+            }
+
+            return errorCode;
+        }
+
+        [CommandCmif(4)]
+        // LoadTimeZoneRule(nn::time::LocationName locationName) -> buffer<nn::time::TimeZoneRule, 0x16>
+        public ResultCode LoadTimeZoneRule(ServiceCtx context)
+        {
+            ulong bufferPosition = context.Request.ReceiveBuff[0].Position;
+            ulong bufferSize     = context.Request.ReceiveBuff[0].Size;
+
+            if (bufferSize != 0x4000)
+            {
+                // TODO: find error code here
+                Logger.Error?.Print(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
+            }
+
+            string locationName = StringUtils.ReadInlinedAsciiString(context.RequestData, 0x24);
+
+            using (WritableRegion region = context.Memory.GetWritableRegion(bufferPosition, Unsafe.SizeOf<TimeZoneRule>()))
+            {
+                ref TimeZoneRule rules = ref MemoryMarshal.Cast<byte, TimeZoneRule>(region.Memory.Span)[0];
+
+                return _timeZoneContentManager.LoadTimeZoneRule(ref rules, locationName);
+            }
+        }
+
+        [CommandCmif(100)]
+        // ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
+        public ResultCode ToCalendarTime(ServiceCtx context)
+        {
+            return _inner.ToCalendarTime(context);
+        }
+
+        [CommandCmif(101)]
+        // ToCalendarTimeWithMyRule(nn::time::PosixTime) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
+        public ResultCode ToCalendarTimeWithMyRule(ServiceCtx context)
+        {
+            return _inner.ToCalendarTimeWithMyRule(context);
+        }
+
+        [CommandCmif(201)]
+        // ToPosixTime(nn::time::CalendarTime calendarTime, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public ResultCode ToPosixTime(ServiceCtx context)
+        {
+            return _inner.ToPosixTime(context);
+        }
+
+        [CommandCmif(202)]
+        // ToPosixTimeWithMyRule(nn::time::CalendarTime calendarTime) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public ResultCode ToPosixTimeWithMyRule(ServiceCtx context)
+        {
+            return _inner.ToPosixTimeWithMyRule(context);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ITimeZoneServiceForPsc.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/StaticService/ITimeZoneServiceForPsc.cs
@@ -0,0 +1,303 @@
+using Ryujinx.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using Ryujinx.HLE.Utilities;
+using Ryujinx.Memory;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.StaticService
+{
+    class ITimeZoneServiceForPsc : IpcService
+    {
+        private TimeZoneManager _timeZoneManager;
+        private bool            _writePermission;
+
+        public ITimeZoneServiceForPsc(TimeZoneManager timeZoneManager, bool writePermission)
+        {
+            _timeZoneManager = timeZoneManager;
+            _writePermission = writePermission;
+        }
+
+        [CommandCmif(0)]
+        // GetDeviceLocationName() -> nn::time::LocationName
+        public ResultCode GetDeviceLocationName(ServiceCtx context)
+        {
+            ResultCode result = _timeZoneManager.GetDeviceLocationName(out string deviceLocationName);
+
+            if (result == ResultCode.Success)
+            {
+                WriteLocationName(context, deviceLocationName);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(1)]
+        // SetDeviceLocationName(nn::time::LocationName)
+        public ResultCode SetDeviceLocationName(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(2)]
+        // GetTotalLocationNameCount() -> u32
+        public ResultCode GetTotalLocationNameCount(ServiceCtx context)
+        {
+            ResultCode result = _timeZoneManager.GetTotalLocationNameCount(out uint totalLocationNameCount);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.Write(totalLocationNameCount);
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // LoadLocationNameList(u32 index) -> (u32 outCount, buffer<nn::time::LocationName, 6>)
+        public ResultCode LoadLocationNameList(ServiceCtx context)
+        {
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(4)]
+        // LoadTimeZoneRule(nn::time::LocationName locationName) -> buffer<nn::time::TimeZoneRule, 0x16>
+        public ResultCode LoadTimeZoneRule(ServiceCtx context)
+        {
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(5)] // 2.0.0+
+        // GetTimeZoneRuleVersion() -> nn::time::TimeZoneRuleVersion
+        public ResultCode GetTimeZoneRuleVersion(ServiceCtx context)
+        {
+            ResultCode result = _timeZoneManager.GetTimeZoneRuleVersion(out UInt128 timeZoneRuleVersion);
+
+            if (result == ResultCode.Success)
+            {
+                context.ResponseData.WriteStruct(timeZoneRuleVersion);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(6)] // 5.0.0+
+        // GetDeviceLocationNameAndUpdatedTime() -> (nn::time::LocationName, nn::time::SteadyClockTimePoint)
+        public ResultCode GetDeviceLocationNameAndUpdatedTime(ServiceCtx context)
+        {
+            ResultCode result = _timeZoneManager.GetDeviceLocationName(out string deviceLocationName);
+
+            if (result == ResultCode.Success)
+            {
+                result = _timeZoneManager.GetUpdatedTime(out SteadyClockTimePoint timeZoneUpdateTimePoint);
+
+                if (result == ResultCode.Success)
+                {
+                    WriteLocationName(context, deviceLocationName);
+
+                    // Skip padding
+                    context.ResponseData.BaseStream.Position += 0x4;
+
+                    context.ResponseData.WriteStruct(timeZoneUpdateTimePoint);
+                }
+            }
+
+            return result;
+        }
+
+        [CommandCmif(7)] // 9.0.0+
+        // SetDeviceLocationNameWithTimeZoneRule(nn::time::LocationName locationName, buffer<nn::time::TimeZoneBinary, 0x21> timeZoneBinary)
+        public ResultCode SetDeviceLocationNameWithTimeZoneRule(ServiceCtx context)
+        {
+            if (!_writePermission)
+            {
+                return ResultCode.PermissionDenied;
+            }
+
+            (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
+
+            string locationName = StringUtils.ReadInlinedAsciiString(context.RequestData, 0x24);
+
+            ResultCode result;
+
+            byte[] temp = new byte[bufferSize];
+
+            context.Memory.Read(bufferPosition, temp);
+
+            using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))
+            {
+                result = _timeZoneManager.SetDeviceLocationNameWithTimeZoneRule(locationName, timeZoneBinaryStream);
+            }
+
+            return result;
+        }
+
+        [CommandCmif(8)] // 9.0.0+
+        // ParseTimeZoneBinary(buffer<nn::time::TimeZoneBinary, 0x21> timeZoneBinary) -> buffer<nn::time::TimeZoneRule, 0x16>
+        public ResultCode ParseTimeZoneBinary(ServiceCtx context)
+        {
+            (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
+
+            ulong timeZoneRuleBufferPosition = context.Request.ReceiveBuff[0].Position;
+            ulong timeZoneRuleBufferSize     = context.Request.ReceiveBuff[0].Size;
+
+            if (timeZoneRuleBufferSize != 0x4000)
+            {
+                // TODO: find error code here
+                Logger.Error?.Print(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{timeZoneRuleBufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
+            }
+
+            ResultCode result;
+
+            byte[] temp = new byte[bufferSize];
+
+            context.Memory.Read(bufferPosition, temp);
+
+            using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))
+            {
+                using (WritableRegion region = context.Memory.GetWritableRegion(timeZoneRuleBufferPosition, Unsafe.SizeOf<TimeZoneRule>()))
+                {
+                    ref TimeZoneRule rule = ref MemoryMarshal.Cast<byte, TimeZoneRule>(region.Memory.Span)[0];
+
+                    result = _timeZoneManager.ParseTimeZoneRuleBinary(ref rule, timeZoneBinaryStream);
+                }
+            }
+
+            return result;
+        }
+
+        [CommandCmif(20)] // 9.0.0+
+        // GetDeviceLocationNameOperationEventReadableHandle() -> handle<copy>
+        public ResultCode GetDeviceLocationNameOperationEventReadableHandle(ServiceCtx context)
+        {
+            return ResultCode.NotImplemented;
+        }
+
+        [CommandCmif(100)]
+        // ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
+        public ResultCode ToCalendarTime(ServiceCtx context)
+        {
+            long  posixTime      = context.RequestData.ReadInt64();
+            ulong bufferPosition = context.Request.SendBuff[0].Position;
+            ulong bufferSize     = context.Request.SendBuff[0].Size;
+
+            if (bufferSize != 0x4000)
+            {
+                // TODO: find error code here
+                Logger.Error?.Print(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
+            }
+
+            ReadOnlySpan<TimeZoneRule> rules = MemoryMarshal.Cast<byte, TimeZoneRule>(context.Memory.GetSpan(bufferPosition, (int)bufferSize));
+
+            ResultCode resultCode = _timeZoneManager.ToCalendarTime(in rules[0], posixTime, out CalendarInfo calendar);
+
+            if (resultCode == 0)
+            {
+                context.ResponseData.WriteStruct(calendar);
+            }
+
+            return resultCode;
+        }
+
+        [CommandCmif(101)]
+        // ToCalendarTimeWithMyRule(nn::time::PosixTime) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
+        public ResultCode ToCalendarTimeWithMyRule(ServiceCtx context)
+        {
+            long posixTime = context.RequestData.ReadInt64();
+
+            ResultCode resultCode = _timeZoneManager.ToCalendarTimeWithMyRules(posixTime, out CalendarInfo calendar);
+
+            if (resultCode == ResultCode.Success)
+            {
+                context.ResponseData.WriteStruct(calendar);
+            }
+
+            return resultCode;
+        }
+
+        [CommandCmif(201)]
+        // ToPosixTime(nn::time::CalendarTime calendarTime, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public ResultCode ToPosixTime(ServiceCtx context)
+        {
+            ulong inBufferPosition = context.Request.SendBuff[0].Position;
+            ulong inBufferSize     = context.Request.SendBuff[0].Size;
+
+            CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
+
+            if (inBufferSize != 0x4000)
+            {
+                // TODO: find error code here
+                Logger.Error?.Print(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{inBufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
+            }
+
+            ReadOnlySpan<TimeZoneRule> rules = MemoryMarshal.Cast<byte, TimeZoneRule>(context.Memory.GetSpan(inBufferPosition, (int)inBufferSize));
+
+            ResultCode resultCode = _timeZoneManager.ToPosixTime(in rules[0], calendarTime, out long posixTime);
+
+            if (resultCode == ResultCode.Success)
+            {
+                ulong outBufferPosition = context.Request.RecvListBuff[0].Position;
+                ulong outBufferSize     = context.Request.RecvListBuff[0].Size;
+
+                context.Memory.Write(outBufferPosition, posixTime);
+                context.ResponseData.Write(1);
+            }
+
+            return resultCode;
+        }
+
+        [CommandCmif(202)]
+        // ToPosixTimeWithMyRule(nn::time::CalendarTime calendarTime) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public ResultCode ToPosixTimeWithMyRule(ServiceCtx context)
+        {
+            CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
+
+            ResultCode resultCode = _timeZoneManager.ToPosixTimeWithMyRules(calendarTime, out long posixTime);
+
+            if (resultCode == ResultCode.Success)
+            {
+                ulong outBufferPosition = context.Request.RecvListBuff[0].Position;
+                ulong outBufferSize     = context.Request.RecvListBuff[0].Size;
+
+                context.Memory.Write(outBufferPosition, posixTime);
+
+                // There could be only one result on one calendar as leap seconds aren't supported.
+                context.ResponseData.Write(1);
+            }
+
+            return resultCode;
+        }
+
+        private void WriteLocationName(ServiceCtx context, string locationName)
+        {
+            char[] locationNameArray = locationName.ToCharArray();
+
+            int padding = 0x24 - locationNameArray.Length;
+
+            Debug.Assert(padding >= 0, "LocationName exceeded limit (0x24 bytes)");
+
+            context.ResponseData.Write(locationNameArray);
+
+            for (int index = 0; index < padding; index++)
+            {
+                context.ResponseData.Write((byte)0);
+            }
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeManager.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeManager.cs
@@ -0,0 +1,182 @@
+using Ryujinx.Cpu;
+using Ryujinx.HLE.Exceptions;
+using Ryujinx.HLE.HOS.Kernel.Memory;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    class TimeManager
+    {
+        private static TimeManager _instance;
+
+        public static TimeManager Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new TimeManager();
+                }
+
+                return _instance;
+            }
+        }
+
+        public StandardSteadyClockCore                  StandardSteadyClock         { get; }
+        public TickBasedSteadyClockCore                 TickBasedSteadyClock        { get; }
+        public StandardLocalSystemClockCore             StandardLocalSystemClock    { get; }
+        public StandardNetworkSystemClockCore           StandardNetworkSystemClock  { get; }
+        public StandardUserSystemClockCore              StandardUserSystemClock     { get; }
+        public TimeZoneContentManager                   TimeZone                    { get; }
+        public EphemeralNetworkSystemClockCore          EphemeralNetworkSystemClock { get; }
+        public TimeSharedMemory                         SharedMemory                { get; }
+        public LocalSystemClockContextWriter            LocalClockContextWriter     { get; }
+        public NetworkSystemClockContextWriter          NetworkClockContextWriter   { get; }
+        public EphemeralNetworkSystemClockContextWriter EphemeralClockContextWriter { get; }
+
+        // TODO: 9.0.0+ power states and alarms
+
+        public TimeManager()
+        {
+            StandardSteadyClock         = new StandardSteadyClockCore();
+            TickBasedSteadyClock        = new TickBasedSteadyClockCore();
+            StandardLocalSystemClock    = new StandardLocalSystemClockCore(StandardSteadyClock);
+            StandardNetworkSystemClock  = new StandardNetworkSystemClockCore(StandardSteadyClock);
+            StandardUserSystemClock     = new StandardUserSystemClockCore(StandardLocalSystemClock, StandardNetworkSystemClock);
+            TimeZone                    = new TimeZoneContentManager();
+            EphemeralNetworkSystemClock = new EphemeralNetworkSystemClockCore(TickBasedSteadyClock);
+            SharedMemory                = new TimeSharedMemory();
+            LocalClockContextWriter     = new LocalSystemClockContextWriter(SharedMemory);
+            NetworkClockContextWriter   = new NetworkSystemClockContextWriter(SharedMemory);
+            EphemeralClockContextWriter = new EphemeralNetworkSystemClockContextWriter();
+        }
+
+        public void Initialize(Switch device, Horizon system, KSharedMemory sharedMemory, SharedMemoryStorage timeSharedMemoryStorage, int timeSharedMemorySize)
+        {
+            SharedMemory.Initialize(device, sharedMemory, timeSharedMemoryStorage, timeSharedMemorySize);
+
+            // Here we use system on purpose as device. System isn't initialized at this point.
+            StandardUserSystemClock.CreateAutomaticCorrectionEvent(system);
+        }
+
+        public void InitializeTimeZone(Switch device)
+        {
+            TimeZone.Initialize(this, device);
+        }
+
+        public void SetupStandardSteadyClock(ITickSource tickSource, UInt128 clockSourceId, TimeSpanType setupValue, TimeSpanType internalOffset, TimeSpanType testOffset, bool isRtcResetDetected)
+        {
+            SetupInternalStandardSteadyClock(clockSourceId, setupValue, internalOffset, testOffset, isRtcResetDetected);
+
+            TimeSpanType currentTimePoint = StandardSteadyClock.GetCurrentRawTimePoint(tickSource);
+
+            SharedMemory.SetupStandardSteadyClock(tickSource, clockSourceId, currentTimePoint);
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        private void SetupInternalStandardSteadyClock(UInt128 clockSourceId, TimeSpanType setupValue, TimeSpanType internalOffset, TimeSpanType testOffset, bool isRtcResetDetected)
+        {
+            StandardSteadyClock.SetClockSourceId(clockSourceId);
+            StandardSteadyClock.SetSetupValue(setupValue);
+            StandardSteadyClock.SetInternalOffset(internalOffset);
+            StandardSteadyClock.SetTestOffset(testOffset);
+
+            if (isRtcResetDetected)
+            {
+                StandardSteadyClock.SetRtcReset();
+            }
+
+            StandardSteadyClock.MarkInitialized();
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetupStandardLocalSystemClock(ITickSource tickSource, SystemClockContext clockContext, long posixTime)
+        {
+            StandardLocalSystemClock.SetUpdateCallbackInstance(LocalClockContextWriter);
+
+            SteadyClockTimePoint currentTimePoint = StandardLocalSystemClock.GetSteadyClockCore().GetCurrentTimePoint(tickSource);
+            if (currentTimePoint.ClockSourceId == clockContext.SteadyTimePoint.ClockSourceId)
+            {
+                StandardLocalSystemClock.SetSystemClockContext(clockContext);
+            }
+            else
+            {
+                if (StandardLocalSystemClock.SetCurrentTime(tickSource, posixTime) != ResultCode.Success)
+                {
+                    throw new InternalServiceException("Cannot set current local time");
+                }
+            }
+
+            StandardLocalSystemClock.MarkInitialized();
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetupStandardNetworkSystemClock(SystemClockContext clockContext, TimeSpanType sufficientAccuracy)
+        {
+            StandardNetworkSystemClock.SetUpdateCallbackInstance(NetworkClockContextWriter);
+
+            if (StandardNetworkSystemClock.SetSystemClockContext(clockContext) != ResultCode.Success)
+            {
+                throw new InternalServiceException("Cannot set network SystemClockContext");
+            }
+
+            StandardNetworkSystemClock.SetStandardNetworkClockSufficientAccuracy(sufficientAccuracy);
+            StandardNetworkSystemClock.MarkInitialized();
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetupTimeZoneManager(string locationName, SteadyClockTimePoint timeZoneUpdatedTimePoint, uint totalLocationNameCount, UInt128 timeZoneRuleVersion, Stream timeZoneBinaryStream)
+        {
+            if (TimeZone.Manager.SetDeviceLocationNameWithTimeZoneRule(locationName, timeZoneBinaryStream) != ResultCode.Success)
+            {
+                throw new InternalServiceException("Cannot set DeviceLocationName with a given TimeZoneBinary");
+            }
+
+            TimeZone.Manager.SetUpdatedTime(timeZoneUpdatedTimePoint, true);
+            TimeZone.Manager.SetTotalLocationNameCount(totalLocationNameCount);
+            TimeZone.Manager.SetTimeZoneRuleVersion(timeZoneRuleVersion);
+            TimeZone.Manager.MarkInitialized();
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetupEphemeralNetworkSystemClock()
+        {
+            EphemeralNetworkSystemClock.SetUpdateCallbackInstance(EphemeralClockContextWriter);
+            EphemeralNetworkSystemClock.MarkInitialized();
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetupStandardUserSystemClock(ITickSource tickSource, bool isAutomaticCorrectionEnabled, SteadyClockTimePoint steadyClockTimePoint)
+        {
+            if (StandardUserSystemClock.SetAutomaticCorrectionEnabled(tickSource, isAutomaticCorrectionEnabled) != ResultCode.Success)
+            {
+                throw new InternalServiceException("Cannot set automatic user time correction state");
+            }
+
+            StandardUserSystemClock.SetAutomaticCorrectionUpdatedTime(steadyClockTimePoint);
+            StandardUserSystemClock.MarkInitialized();
+
+            SharedMemory.SetAutomaticCorrectionEnabled(isAutomaticCorrectionEnabled);
+
+            // TODO: propagate IPC late binding of "time:s" and "time:p"
+        }
+
+        public void SetStandardSteadyClockRtcOffset(ITickSource tickSource, TimeSpanType rtcOffset)
+        {
+            StandardSteadyClock.SetSetupValue(rtcOffset);
+
+            TimeSpanType currentTimePoint = StandardSteadyClock.GetCurrentRawTimePoint(tickSource);
+
+            SharedMemory.SetSteadyClockRawTimePoint(tickSource, currentTimePoint);
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs
@@ -0,0 +1,114 @@
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Kernel.Memory;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.HOS.Services.Time.Types;
+using Ryujinx.HLE.Utilities;
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    class TimeSharedMemory
+    {
+        private Switch              _device;
+        private KSharedMemory       _sharedMemory;
+        private SharedMemoryStorage _timeSharedMemoryStorage;
+        private int                 _timeSharedMemorySize;
+
+        private const uint SteadyClockContextOffset         = 0x00;
+        private const uint LocalSystemClockContextOffset    = 0x38;
+        private const uint NetworkSystemClockContextOffset  = 0x80;
+        private const uint AutomaticCorrectionEnabledOffset = 0xC8;
+
+        public void Initialize(Switch device, KSharedMemory sharedMemory, SharedMemoryStorage timeSharedMemoryStorage, int timeSharedMemorySize)
+        {
+            _device                  = device;
+            _sharedMemory            = sharedMemory;
+            _timeSharedMemoryStorage = timeSharedMemoryStorage;
+            _timeSharedMemorySize    = timeSharedMemorySize;
+
+            // Clean the shared memory
+            timeSharedMemoryStorage.ZeroFill();
+        }
+
+        public KSharedMemory GetSharedMemory()
+        {
+            return _sharedMemory;
+        }
+
+        public void SetupStandardSteadyClock(ITickSource tickSource, UInt128 clockSourceId, TimeSpanType currentTimePoint)
+        {
+            TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
+
+            SteadyClockContext context = new SteadyClockContext
+            {
+                InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds),
+                ClockSourceId  = clockSourceId
+            };
+
+            WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context);
+        }
+
+        public void SetAutomaticCorrectionEnabled(bool isAutomaticCorrectionEnabled)
+        {
+            // We convert the bool to byte here as a bool in C# takes 4 bytes...
+            WriteObjectToSharedMemory(AutomaticCorrectionEnabledOffset, 0, Convert.ToByte(isAutomaticCorrectionEnabled));
+        }
+
+        public void SetSteadyClockRawTimePoint(ITickSource tickSource, TimeSpanType currentTimePoint)
+        {
+            SteadyClockContext context       = ReadObjectFromSharedMemory<SteadyClockContext>(SteadyClockContextOffset, 4);
+            TimeSpanType       ticksTimeSpan = TimeSpanType.FromTicks(tickSource.Counter, tickSource.Frequency);
+
+            context.InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds);
+
+            WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context);
+        }
+
+        public void UpdateLocalSystemClockContext(SystemClockContext context)
+        {
+            WriteObjectToSharedMemory(LocalSystemClockContextOffset, 4, context);
+        }
+
+        public void UpdateNetworkSystemClockContext(SystemClockContext context)
+        {
+            WriteObjectToSharedMemory(NetworkSystemClockContextOffset, 4, context);
+        }
+
+        private T ReadObjectFromSharedMemory<T>(ulong offset, ulong padding) where T : unmanaged
+        {
+            T    result;
+            uint index;
+            uint possiblyNewIndex;
+
+            do
+            {
+                index = _timeSharedMemoryStorage.GetRef<uint>(offset);
+
+                ulong objectOffset = offset + 4 + padding + (ulong)((index & 1) * Unsafe.SizeOf<T>());
+
+                result = _timeSharedMemoryStorage.GetRef<T>(objectOffset);
+
+                Thread.MemoryBarrier();
+
+                possiblyNewIndex = _device.Memory.Read<uint>(offset);
+            } while (index != possiblyNewIndex);
+
+            return result;
+        }
+
+        private void WriteObjectToSharedMemory<T>(ulong offset, ulong padding, T value) where T : unmanaged
+        {
+            uint newIndex = _timeSharedMemoryStorage.GetRef<uint>(offset) + 1;
+
+            ulong objectOffset = offset + 4 + padding + (ulong)((newIndex & 1) * Unsafe.SizeOf<T>());
+
+            _timeSharedMemoryStorage.GetRef<T>(objectOffset) = value;
+
+            Thread.MemoryBarrier();
+
+            _timeSharedMemoryStorage.GetRef<uint>(offset) = newIndex;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZone.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZone.cs
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneContentManager.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneContentManager.cs
@@ -0,0 +1,304 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Logging;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.Exceptions;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.Utilities;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using TimeZoneRuleBox = Ryujinx.Common.Memory.Box<Ryujinx.HLE.HOS.Services.Time.TimeZone.TimeZoneRule>;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    public class TimeZoneContentManager
+    {
+        private const long TimeZoneBinaryTitleId = 0x010000000000080E;
+
+        private readonly string TimeZoneSystemTitleMissingErrorMessage = "TimeZoneBinary system title not found! TimeZone conversions will not work, provide the system archive to fix this error. (See https://github.com/Ryujinx/Ryujinx/wiki/Ryujinx-Setup-&-Configuration-Guide#initial-setup-continued---installation-of-firmware for more information)";
+
+        private VirtualFileSystem   _virtualFileSystem;
+        private IntegrityCheckLevel _fsIntegrityCheckLevel;
+        private ContentManager      _contentManager;
+
+        public string[] LocationNameCache { get; private set; }
+
+        internal TimeZoneManager Manager { get; private set; }
+
+        public TimeZoneContentManager()
+        {
+            Manager = new TimeZoneManager();
+        }
+
+        public void InitializeInstance(VirtualFileSystem virtualFileSystem, ContentManager contentManager, IntegrityCheckLevel fsIntegrityCheckLevel)
+        {
+            _virtualFileSystem     = virtualFileSystem;
+            _contentManager        = contentManager;
+            _fsIntegrityCheckLevel = fsIntegrityCheckLevel;
+
+            InitializeLocationNameCache();
+        }
+
+        public string SanityCheckDeviceLocationName(string locationName)
+        {
+            if (IsLocationNameValid(locationName))
+            {
+                return locationName;
+            }
+
+            Logger.Warning?.Print(LogClass.ServiceTime, $"Invalid device TimeZone {locationName}, switching back to UTC");
+
+            return "UTC";
+        }
+
+        internal void Initialize(TimeManager timeManager, Switch device)
+        {
+            InitializeInstance(device.FileSystem, device.System.ContentManager, device.System.FsIntegrityCheckLevel);
+
+            ITickSource tickSource = device.System.TickSource;
+
+            SteadyClockTimePoint timeZoneUpdatedTimePoint = timeManager.StandardSteadyClock.GetCurrentTimePoint(tickSource);
+
+            string deviceLocationName = SanityCheckDeviceLocationName(device.Configuration.TimeZone);
+
+            ResultCode result = GetTimeZoneBinary(deviceLocationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                // TODO: Read TimeZoneVersion from sysarchive.
+                timeManager.SetupTimeZoneManager(deviceLocationName, timeZoneUpdatedTimePoint, (uint)LocationNameCache.Length, new UInt128(), timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+            else
+            {
+                // In the case the user don't have the timezone system archive, we just mark the manager as initialized.
+                Manager.MarkInitialized();
+            }
+        }
+
+        private void InitializeLocationNameCache()
+        {
+            if (HasTimeZoneBinaryTitle())
+            {
+                using (IStorage ncaFileStream = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open))
+                {
+                    Nca         nca              = new Nca(_virtualFileSystem.KeySet, ncaFileStream);
+                    IFileSystem romfs            = nca.OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel);
+
+                    using var binaryListFile = new UniqueRef<IFile>();
+
+                    romfs.OpenFile(ref binaryListFile.Ref, "/binaryList.txt".ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                    StreamReader reader = new StreamReader(binaryListFile.Get.AsStream());
+
+                    List<string> locationNameList = new List<string>();
+
+                    string locationName;
+                    while ((locationName = reader.ReadLine()) != null)
+                    {
+                        locationNameList.Add(locationName);
+                    }
+
+                    LocationNameCache = locationNameList.ToArray();
+                }
+            }
+            else
+            {
+                LocationNameCache = new string[] { "UTC" };
+
+                Logger.Error?.Print(LogClass.ServiceTime, TimeZoneSystemTitleMissingErrorMessage);
+            }
+        }
+
+        public IEnumerable<(int Offset, string Location, string Abbr)> ParseTzOffsets()
+        {
+            var tzBinaryContentPath = GetTimeZoneBinaryTitleContentPath();
+
+            if (string.IsNullOrEmpty(tzBinaryContentPath))
+            {
+                return new[] { (0, "UTC", "UTC") };
+            }
+
+            List<(int Offset, string Location, string Abbr)> outList = new List<(int Offset, string Location, string Abbr)>();
+            var now = DateTimeOffset.Now.ToUnixTimeSeconds();
+            using (IStorage ncaStorage = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(tzBinaryContentPath), FileAccess.Read, FileMode.Open))
+            using (IFileSystem romfs = new Nca(_virtualFileSystem.KeySet, ncaStorage).OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel))
+            {
+                foreach (string locName in LocationNameCache)
+                {
+                    if (locName.StartsWith("Etc"))
+                    {
+                        continue;
+                    }
+
+                    using var tzif = new UniqueRef<IFile>();
+
+                    if (romfs.OpenFile(ref tzif.Ref, $"/zoneinfo/{locName}".ToU8Span(), OpenMode.Read).IsFailure())
+                    {
+                        Logger.Error?.Print(LogClass.ServiceTime, $"Error opening /zoneinfo/{locName}");
+                        continue;
+                    }
+
+                    TimeZoneRuleBox tzRuleBox = new TimeZoneRuleBox();
+                    ref TimeZoneRule tzRule = ref tzRuleBox.Data;
+
+                    TimeZone.ParseTimeZoneBinary(ref tzRule, tzif.Get.AsStream());
+
+
+                    TimeTypeInfo ttInfo;
+                    if (tzRule.TimeCount > 0) // Find the current transition period
+                    {
+                        int fin = 0;
+                        for (int i = 0; i < tzRule.TimeCount; ++i)
+                        {
+                            if (tzRule.Ats[i] <= now)
+                            {
+                                fin = i;
+                            }
+                        }
+                        ttInfo = tzRule.Ttis[tzRule.Types[fin]];
+                    }
+                    else if (tzRule.TypeCount >= 1) // Otherwise, use the first offset in TTInfo
+                    {
+                        ttInfo = tzRule.Ttis[0];
+                    }
+                    else
+                    {
+                        Logger.Error?.Print(LogClass.ServiceTime, $"Couldn't find UTC offset for zone {locName}");
+                        continue;
+                    }
+
+                    var abbrStart = tzRule.Chars[ttInfo.AbbreviationListIndex..];
+                    int abbrEnd = abbrStart.IndexOf((byte)0);
+
+                    outList.Add((ttInfo.GmtOffset, locName, Encoding.UTF8.GetString(abbrStart[..abbrEnd])));
+                }
+            }
+
+            outList.Sort();
+
+            return outList;
+        }
+
+        private bool IsLocationNameValid(string locationName)
+        {
+            foreach (string cachedLocationName in LocationNameCache)
+            {
+                if (cachedLocationName.Equals(locationName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public ResultCode SetDeviceLocationName(string locationName)
+        {
+            ResultCode result = GetTimeZoneBinary(locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                result = Manager.SetDeviceLocationNameWithTimeZoneRule(locationName, timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+
+            return result;
+        }
+
+        public ResultCode LoadLocationNameList(uint index, out string[] outLocationNameArray, uint maxLength)
+        {
+            List<string> locationNameList = new List<string>();
+
+            for (int i = 0; i < LocationNameCache.Length && i < maxLength; i++)
+            {
+                if (i < index)
+                {
+                    continue;
+                }
+
+                string locationName = LocationNameCache[i];
+
+                // If the location name is too long, error out.
+                if (locationName.Length > 0x24)
+                {
+                    outLocationNameArray = Array.Empty<string>();
+
+                    return ResultCode.LocationNameTooLong;
+                }
+
+                locationNameList.Add(locationName);
+            }
+
+            outLocationNameArray = locationNameList.ToArray();
+
+            return ResultCode.Success;
+        }
+
+        public string GetTimeZoneBinaryTitleContentPath()
+        {
+            return _contentManager.GetInstalledContentPath(TimeZoneBinaryTitleId, StorageId.BuiltInSystem, NcaContentType.Data);
+        }
+
+        public bool HasTimeZoneBinaryTitle()
+        {
+            return !string.IsNullOrEmpty(GetTimeZoneBinaryTitleContentPath());
+        }
+
+        internal ResultCode GetTimeZoneBinary(string locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile)
+        {
+            timeZoneBinaryStream = null;
+            ncaFile              = null;
+
+            if (!HasTimeZoneBinaryTitle() || !IsLocationNameValid(locationName))
+            {
+                return ResultCode.TimeZoneNotFound;
+            }
+
+            ncaFile = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open);
+
+            Nca         nca   = new Nca(_virtualFileSystem.KeySet, ncaFile);
+            IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel);
+
+            using var timeZoneBinaryFile = new UniqueRef<IFile>();
+
+            Result result = romfs.OpenFile(ref timeZoneBinaryFile.Ref, $"/zoneinfo/{locationName}".ToU8Span(), OpenMode.Read);
+
+            timeZoneBinaryStream = timeZoneBinaryFile.Release().AsStream();
+
+            return (ResultCode)result.Value;
+        }
+
+        internal ResultCode LoadTimeZoneRule(ref TimeZoneRule rules, string locationName)
+        {
+            rules = default;
+
+            if (!HasTimeZoneBinaryTitle())
+            {
+                throw new InvalidSystemResourceException(TimeZoneSystemTitleMissingErrorMessage);
+            }
+
+            ResultCode result = GetTimeZoneBinary(locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                result = Manager.ParseTimeZoneRuleBinary(ref rules, timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+
+            return result;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneManager.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneManager.cs
@@ -0,0 +1,261 @@
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    class TimeZoneManager
+    {
+        private bool                 _isInitialized;
+        private Box<TimeZoneRule>    _myRules;
+        private string               _deviceLocationName;
+        private UInt128              _timeZoneRuleVersion;
+        private uint                 _totalLocationNameCount;
+        private SteadyClockTimePoint _timeZoneUpdateTimePoint;
+        private object               _lock;
+
+        public TimeZoneManager()
+        {
+            _isInitialized       = false;
+            _deviceLocationName  = "UTC";
+            _timeZoneRuleVersion = new UInt128();
+            _lock                = new object();
+            _myRules             = new Box<TimeZoneRule>();
+
+            _timeZoneUpdateTimePoint = SteadyClockTimePoint.GetRandom();
+        }
+
+        public bool IsInitialized()
+        {
+            bool res;
+
+            lock (_lock)
+            {
+                res = _isInitialized;
+            }
+
+            return res;
+        }
+
+        public void MarkInitialized()
+        {
+            lock (_lock)
+            {
+                _isInitialized = true;
+            }
+        }
+
+        public ResultCode GetDeviceLocationName(out string deviceLocationName)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            deviceLocationName = null;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    deviceLocationName = _deviceLocationName;
+                    result             = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode SetDeviceLocationNameWithTimeZoneRule(string locationName, Stream timeZoneBinaryStream)
+        {
+            ResultCode result = ResultCode.TimeZoneConversionFailed;
+
+            lock (_lock)
+            {
+                Box<TimeZoneRule> rules = new Box<TimeZoneRule>();
+
+                bool timeZoneConversionSuccess = TimeZone.ParseTimeZoneBinary(ref rules.Data, timeZoneBinaryStream);
+
+                if (timeZoneConversionSuccess)
+                {
+                    _deviceLocationName = locationName;
+                    _myRules            = rules;
+                    result              = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public void SetTotalLocationNameCount(uint totalLocationNameCount)
+        {
+            lock (_lock)
+            {
+                _totalLocationNameCount = totalLocationNameCount;
+            }
+        }
+
+        public ResultCode GetTotalLocationNameCount(out uint totalLocationNameCount)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            totalLocationNameCount = 0;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    totalLocationNameCount = _totalLocationNameCount;
+                    result                 = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode SetUpdatedTime(SteadyClockTimePoint timeZoneUpdatedTimePoint, bool bypassUninitialized = false)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            lock (_lock)
+            {
+                if (_isInitialized || bypassUninitialized)
+                {
+                    _timeZoneUpdateTimePoint = timeZoneUpdatedTimePoint;
+                    result                   = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode GetUpdatedTime(out SteadyClockTimePoint timeZoneUpdatedTimePoint)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    timeZoneUpdatedTimePoint = _timeZoneUpdateTimePoint;
+                    result                   = ResultCode.Success;
+                }
+                else
+                {
+                    timeZoneUpdatedTimePoint = SteadyClockTimePoint.GetRandom();
+                    result                   = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ParseTimeZoneRuleBinary(ref TimeZoneRule outRules, Stream timeZoneBinaryStream)
+        {
+            ResultCode result = ResultCode.Success;
+
+            lock (_lock)
+            {
+                bool timeZoneConversionSuccess = TimeZone.ParseTimeZoneBinary(ref outRules, timeZoneBinaryStream);
+
+                if (!timeZoneConversionSuccess)
+                {
+                    result = ResultCode.TimeZoneConversionFailed;
+                }
+            }
+
+            return result;
+        }
+
+        public void SetTimeZoneRuleVersion(UInt128 timeZoneRuleVersion)
+        {
+            lock (_lock)
+            {
+                _timeZoneRuleVersion = timeZoneRuleVersion;
+            }
+        }
+
+        public ResultCode GetTimeZoneRuleVersion(out UInt128 timeZoneRuleVersion)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    timeZoneRuleVersion = _timeZoneRuleVersion;
+                    result              = ResultCode.Success;
+                }
+                else
+                {
+                    timeZoneRuleVersion = new UInt128();
+                    result              = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToCalendarTimeWithMyRules(long time, out CalendarInfo calendar)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    result = ToCalendarTime(in _myRules.Data, time, out calendar);
+                }
+                else
+                {
+                    calendar = new CalendarInfo();
+                    result   = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToCalendarTime(in TimeZoneRule rules, long time, out CalendarInfo calendar)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                result = TimeZone.ToCalendarTime(in rules, time, out calendar);
+            }
+
+            return result;
+        }
+
+        public ResultCode ToPosixTimeWithMyRules(CalendarTime calendarTime, out long posixTime)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    result = ToPosixTime(in _myRules.Data, calendarTime, out posixTime);
+                }
+                else
+                {
+                    posixTime = 0;
+                    result    = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToPosixTime(in TimeZoneRule rules, CalendarTime calendarTime, out long posixTime)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                result = TimeZone.ToPosixTime(in rules, calendarTime, out posixTime);
+            }
+
+            return result;
+        }
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarAdditionalInfo.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarAdditionalInfo.cs
@@ -0,0 +1,21 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x18, CharSet = CharSet.Ansi)]
+    struct CalendarAdditionalInfo
+    {
+        public uint DayOfWeek;
+        public uint DayOfYear;
+
+        public Array8<byte> TimezoneName;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        public Array3<byte> Padding;
+
+        public int GmtOffset;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarInfo.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarInfo.cs
@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x20, CharSet = CharSet.Ansi)]
+    struct CalendarInfo
+    {
+        public CalendarTime           Time;
+        public CalendarAdditionalInfo AdditionalInfo;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarTime.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarTime.cs
@@ -0,0 +1,15 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x8)]
+    struct CalendarTime
+    {
+        public short Year;
+        public sbyte Month;
+        public sbyte Day;
+        public sbyte Hour;
+        public sbyte Minute;
+        public sbyte Second;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeTypeInfo.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeTypeInfo.cs
@@ -0,0 +1,28 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Size = Size, Pack = 4)]
+    public struct TimeTypeInfo
+    {
+        public const int Size = 0x10;
+
+        public int GmtOffset;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        public Array3<byte> Padding1;
+
+        public int AbbreviationListIndex;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsStandardTimeDaylight;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsGMT;
+
+        public ushort Padding2;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeZoneRule.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeZoneRule.cs
@@ -0,0 +1,56 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 4, Size = 0x4000, CharSet = CharSet.Ansi)]
+    public struct TimeZoneRule
+    {
+        public const int TzMaxTypes = 128;
+        public const int TzMaxChars = 50;
+        public const int TzMaxLeaps = 50;
+        public const int TzMaxTimes = 1000;
+        public const int TzNameMax = 255;
+        public const int TzCharsArraySize = 2 * (TzNameMax + 1);
+
+        public int TimeCount;
+        public int TypeCount;
+        public int CharCount;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool GoBack;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool GoAhead;
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(long) * TzMaxTimes)]
+        private struct AtsStorageStruct { }
+
+        private AtsStorageStruct _ats;
+
+        public Span<long> Ats => SpanHelpers.AsSpan<AtsStorageStruct, long>(ref _ats);
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(byte) * TzMaxTimes)]
+        private struct TypesStorageStruct { }
+
+        private TypesStorageStruct _types;
+
+        public Span<byte> Types => SpanHelpers.AsByteSpan(ref _types);
+
+        [StructLayout(LayoutKind.Sequential, Size = TimeTypeInfo.Size * TzMaxTypes)]
+        private struct TimeTypeInfoStorageStruct { }
+
+        private TimeTypeInfoStorageStruct _ttis;
+
+        public Span<TimeTypeInfo> Ttis => SpanHelpers.AsSpan<TimeTypeInfoStorageStruct, TimeTypeInfo>(ref _ttis);
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(byte) * TzCharsArraySize)]
+        private struct CharsStorageStruct { }
+
+        private CharsStorageStruct _chars;
+        public Span<byte> Chars => SpanHelpers.AsByteSpan(ref _chars);
+
+        public int DefaultType;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TzifHeader.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TzifHeader.cs
@@ -0,0 +1,19 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x2C)]
+    struct TzifHeader
+    {
+        public Array4<byte> Magic;
+        public byte Version;
+        private Array15<byte> _reserved;
+        public int TtisGMTCount;
+        public int TtisSTDCount;
+        public int LeapCount;
+        public int TimeCount;
+        public int TypeCount;
+        public int CharCount;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Types/SteadyClockContext.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Types/SteadyClockContext.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.Types
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    struct SteadyClockContext
+    {
+        public ulong   InternalOffset;
+        public UInt128 ClockSourceId;
+    }
+}
--- a/src/Ryujinx.HLE/HOS/Services/Time/Types/TimePermissions.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Time/Types/TimePermissions.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [Flags]
+    enum TimePermissions
+    {
+        LocalSystemClockWritableMask   = 0x1,
+        UserSystemClockWritableMask    = 0x2,
+        NetworkSystemClockWritableMask = 0x4,
+        TimeZoneWritableMask           = 0x8,
+        SteadyClockWritableMask        = 0x10,
+        BypassUninitialized            = 0x20,
+
+        User         = 0,
+        Admin        = LocalSystemClockWritableMask | UserSystemClockWritableMask | TimeZoneWritableMask,
+        System       = NetworkSystemClockWritableMask,
+        SystemUpdate = BypassUninitialized,
+        Repair       = SteadyClockWritableMask,
+        Manufacture  = LocalSystemClockWritableMask | UserSystemClockWritableMask | NetworkSystemClockWritableMask | TimeZoneWritableMask | SteadyClockWritableMask
+    }
+}