diff options
| author | Thomas Guillemard <me@thog.eu> | 2019-10-08 05:48:49 +0200 |
|---|---|---|
| committer | jduncanator <1518948+jduncanator@users.noreply.github.com> | 2019-10-08 14:48:49 +1100 |
| commit | 1aba033ba7868d29f5f840c99ee11dd29d689972 (patch) | |
| tree | a11692bbf3ba7d8f7d2780193356f112cfbb3356 /Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs | |
| parent | 16869402bf81716ba3d1410621a3b1847bee389c (diff) | |
Update time implementation to 9.0.0 (#783)
* Fix 9.0.0 related services bindings
This was wrong because of a mistake on switchbrew.
* Fix wronog cmdid for ISteadyClock::GetTestOffset/SetTestOffset
* Update ClockCore logics to 9.0.0
Also apply 9.0.0 permissions and comment time:u, and time:a (as those
are going to be moved)
* Move every clocks instances + timezone to a global manager
* Start implementing time:m
Also prepare the skeleton of the shared memory
* Implement SystemClockContextUpdateCallback and co
* Update StaticService to 9.0.0
* Update ISystemClock to 9.0.0
* Rename IStaticService and add glue's IStaticService
* Implement psc's ITimeZoneService
* Integrate psc layer into glue for TimeZoneService
* Rename TimeZoneManagerForPsc => TimeZoneManager
* Use correct TimeZoneService interface for both StaticService implementations
* Accurately implement time shared memory operations
* Fix two critical flaws in TimeZone logic
The first one was the month range being different fron Nintendo one
(0-11 instead of 1-12)
The other flaw was a bad incrementation order during days & months
computation.
* Follow Nintendo's abort logic for TimeManager
* Avoid crashing when timezone sysarchive isn't present
* Update Readme
* Address comments
* Correctly align fields in ISystemClock
* Fix code style and some typos
* Improve timezone system archive warning/error messages
* Rearrange using definitions in Horizon.cs
* Address comments
Diffstat (limited to 'Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs')
| -rw-r--r-- | Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs | 126 |
1 files changed, 126 insertions, 0 deletions
diff --git a/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs b/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs new file mode 100644 index 00000000..f714c662 --- /dev/null +++ b/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs @@ -0,0 +1,126 @@ +using System; +using System.Runtime.InteropServices; +using System.Threading; +using Ryujinx.HLE.HOS.Kernel.Memory; +using Ryujinx.HLE.HOS.Kernel.Threading; +using Ryujinx.HLE.HOS.Services.Time.Clock; +using Ryujinx.HLE.HOS.Services.Time.Types; +using Ryujinx.HLE.Utilities; + +namespace Ryujinx.HLE.HOS.Services.Time +{ + class TimeSharedMemory + { + private Switch _device; + private KSharedMemory _sharedMemory; + private long _timeSharedMemoryAddress; + 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, long timeSharedMemoryAddress, int timeSharedMemorySize) + { + _device = device; + _sharedMemory = sharedMemory; + _timeSharedMemoryAddress = timeSharedMemoryAddress; + _timeSharedMemorySize = timeSharedMemorySize; + + // Clean the shared memory + _device.Memory.FillWithZeros(_timeSharedMemoryAddress, _timeSharedMemorySize); + } + + public KSharedMemory GetSharedMemory() + { + return _sharedMemory; + } + + public void SetupStandardSteadyClock(KThread thread, UInt128 clockSourceId, TimeSpanType currentTimePoint) + { + TimeSpanType ticksTimeSpan; + + // As this may be called before the guest code, we support passing a null thread to make this api usable. + if (thread == null) + { + ticksTimeSpan = TimeSpanType.FromSeconds(0); + } + else + { + ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.CntpctEl0, thread.Context.CntfrqEl0); + } + + 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(KThread thread, TimeSpanType currentTimePoint) + { + SteadyClockContext context = ReadObjectFromSharedMemory<SteadyClockContext>(SteadyClockContextOffset, 4); + TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.CntpctEl0, thread.Context.CntfrqEl0); + + 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>(long offset, long padding) + { + long indexOffset = _timeSharedMemoryAddress + offset; + + T result; + uint index; + uint possiblyNewIndex; + + do + { + index = _device.Memory.ReadUInt32(indexOffset); + + long objectOffset = indexOffset + 4 + padding + (index & 1) * Marshal.SizeOf<T>(); + + result = _device.Memory.ReadStruct<T>(objectOffset); + + Thread.MemoryBarrier(); + + possiblyNewIndex = _device.Memory.ReadUInt32(indexOffset); + } while (index != possiblyNewIndex); + + return result; + } + + private void WriteObjectToSharedMemory<T>(long offset, long padding, T value) + { + long indexOffset = _timeSharedMemoryAddress + offset; + uint newIndex = _device.Memory.ReadUInt32(indexOffset) + 1; + long objectOffset = indexOffset + 4 + padding + (newIndex & 1) * Marshal.SizeOf<T>(); + + _device.Memory.WriteStruct(objectOffset, value); + + Thread.MemoryBarrier(); + + _device.Memory.WriteUInt32(indexOffset, newIndex); + } + } +} |