mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 07:38:42 +02:00
* 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
195 lines
4.9 KiB
C#
195 lines
4.9 KiB
C#
using ARMeilleure.Memory;
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Ryujinx.HLE
|
|
{
|
|
class DeviceMemory : IDisposable
|
|
{
|
|
public const long RamSize = 4L * 1024 * 1024 * 1024;
|
|
|
|
public IntPtr RamPointer { get; }
|
|
|
|
private unsafe byte* _ramPtr;
|
|
|
|
public unsafe DeviceMemory()
|
|
{
|
|
RamPointer = MemoryManagement.AllocateWriteTracked(RamSize);
|
|
|
|
_ramPtr = (byte*)RamPointer;
|
|
}
|
|
|
|
public sbyte ReadSByte(long position)
|
|
{
|
|
return (sbyte)ReadByte(position);
|
|
}
|
|
|
|
public short ReadInt16(long position)
|
|
{
|
|
return (short)ReadUInt16(position);
|
|
}
|
|
|
|
public int ReadInt32(long position)
|
|
{
|
|
return (int)ReadUInt32(position);
|
|
}
|
|
|
|
public long ReadInt64(long position)
|
|
{
|
|
return (long)ReadUInt64(position);
|
|
}
|
|
|
|
public unsafe byte ReadByte(long position)
|
|
{
|
|
return *(_ramPtr + position);
|
|
}
|
|
|
|
public unsafe ushort ReadUInt16(long position)
|
|
{
|
|
return *((ushort*)(_ramPtr + position));
|
|
}
|
|
|
|
public unsafe uint ReadUInt32(long position)
|
|
{
|
|
return *((uint*)(_ramPtr + position));
|
|
}
|
|
|
|
public unsafe ulong ReadUInt64(long position)
|
|
{
|
|
return *((ulong*)(_ramPtr + position));
|
|
}
|
|
|
|
public unsafe T ReadStruct<T>(long position)
|
|
{
|
|
return Marshal.PtrToStructure<T>((IntPtr)(_ramPtr + position));
|
|
}
|
|
|
|
public void WriteSByte(long position, sbyte value)
|
|
{
|
|
WriteByte(position, (byte)value);
|
|
}
|
|
|
|
public void WriteInt16(long position, short value)
|
|
{
|
|
WriteUInt16(position, (ushort)value);
|
|
}
|
|
|
|
public void WriteInt32(long position, int value)
|
|
{
|
|
WriteUInt32(position, (uint)value);
|
|
}
|
|
|
|
public void WriteInt64(long position, long value)
|
|
{
|
|
WriteUInt64(position, (ulong)value);
|
|
}
|
|
|
|
public unsafe void WriteByte(long position, byte value)
|
|
{
|
|
*(_ramPtr + position) = value;
|
|
}
|
|
|
|
public unsafe void WriteUInt16(long position, ushort value)
|
|
{
|
|
*((ushort*)(_ramPtr + position)) = value;
|
|
}
|
|
|
|
public unsafe void WriteUInt32(long position, uint value)
|
|
{
|
|
*((uint*)(_ramPtr + position)) = value;
|
|
}
|
|
|
|
public unsafe void WriteUInt64(long position, ulong value)
|
|
{
|
|
*((ulong*)(_ramPtr + position)) = value;
|
|
}
|
|
|
|
public unsafe void WriteStruct<T>(long position, T value)
|
|
{
|
|
Marshal.StructureToPtr(value, (IntPtr)(_ramPtr + position), false);
|
|
}
|
|
|
|
public void FillWithZeros(long position, int size)
|
|
{
|
|
int size8 = size & ~(8 - 1);
|
|
|
|
for (int offs = 0; offs < size8; offs += 8)
|
|
{
|
|
WriteInt64(position + offs, 0);
|
|
}
|
|
|
|
for (int offs = size8; offs < (size - size8); offs++)
|
|
{
|
|
WriteByte(position + offs, 0);
|
|
}
|
|
}
|
|
|
|
public void Set(ulong address, byte value, ulong size)
|
|
{
|
|
if (address + size < address)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(size));
|
|
}
|
|
|
|
if (address + size > RamSize)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(address));
|
|
}
|
|
|
|
ulong size8 = size & ~7UL;
|
|
|
|
ulong valueRep = (ulong)value * 0x0101010101010101;
|
|
|
|
for (ulong offs = 0; offs < size8; offs += 8)
|
|
{
|
|
WriteUInt64((long)(address + offs), valueRep);
|
|
}
|
|
|
|
for (ulong offs = size8; offs < (size - size8); offs++)
|
|
{
|
|
WriteByte((long)(address + offs), value);
|
|
}
|
|
}
|
|
|
|
public void Copy(ulong dst, ulong src, ulong size)
|
|
{
|
|
if (dst + size < dst || src + size < src)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(size));
|
|
}
|
|
|
|
if (dst + size > RamSize)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(dst));
|
|
}
|
|
|
|
if (src + size > RamSize)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(src));
|
|
}
|
|
|
|
ulong size8 = size & ~7UL;
|
|
|
|
for (ulong offs = 0; offs < size8; offs += 8)
|
|
{
|
|
WriteUInt64((long)(dst + offs), ReadUInt64((long)(src + offs)));
|
|
}
|
|
|
|
for (ulong offs = size8; offs < (size - size8); offs++)
|
|
{
|
|
WriteByte((long)(dst + offs), ReadByte((long)(src + offs)));
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
MemoryManagement.Free(RamPointer);
|
|
}
|
|
}
|
|
}
|