Merge branch 'master' into ICommonStateGetter

Ryujinx.HLE/OsHle/Services/Acc/IAccountServiceForApplication.cs

@@ -0,0 +1,91 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Acc
+{
+    class IAccountServiceForApplication : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAccountServiceForApplication()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,   GetUserCount                        },
+                { 1,   GetUserExistence                    },
+                { 2,   ListAllUsers                        },
+                { 3,   ListOpenUsers                       },
+                { 4,   GetLastOpenedUser                   },
+                { 5,   GetProfile                          },
+                { 100, InitializeApplicationInfo           },
+                { 101, GetBaasAccountManagerForApplication }
+            };
+        }
+
+        public long GetUserCount(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetUserExistence(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ListAllUsers(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ListOpenUsers(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetLastOpenedUser(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetProfile(ServiceCtx Context)
+        {
+            MakeObject(Context, new IProfile());
+
+            return 0;
+        }
+
+        public long InitializeApplicationInfo(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetBaasAccountManagerForApplication(ServiceCtx Context)
+        {
+            MakeObject(Context, new IManagerForApplication());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Acc/IManagerForApplication.cs

@@ -0,0 +1,38 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Acc
+{
+    class IManagerForApplication : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IManagerForApplication()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, CheckAvailability },
+                { 1, GetAccountId      }
+            };
+        }
+
+        public long CheckAvailability(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetAccountId(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            Context.ResponseData.Write(0xcafeL);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Acc/IProfile.cs

@@ -0,0 +1,36 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Acc
+{
+    class IProfile : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IProfile()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 1, GetBase }
+            };
+        }
+
+        public long GetBase(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAcc, "Stubbed.");
+
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/AmErr.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    static class AmErr
+    {
+        public const int NoMessages = 3;
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/FocusState.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    enum FocusState
+    {
+        InFocus    = 1,
+        OutOfFocus = 2
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IAllSystemAppletProxiesService.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IAllSystemAppletProxiesService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAllSystemAppletProxiesService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 100, OpenSystemAppletProxy }
+            };
+        }
+
+        public long OpenSystemAppletProxy(ServiceCtx Context)
+        {
+            MakeObject(Context, new ISystemAppletProxy());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IApplicationCreator.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IApplicationCreator : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IApplicationCreator()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IApplicationFunctions.cs

@@ -0,0 +1,117 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IApplicationFunctions : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IApplicationFunctions()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 1,  PopLaunchParameter          },
+                { 20, EnsureSaveData              },
+                { 21, GetDesiredLanguage          },
+                { 22, SetTerminateResult          },
+                { 23, GetDisplayVersion           },
+                { 40, NotifyRunning               },
+                { 50, GetPseudoDeviceId           },
+                { 66, InitializeGamePlayRecording },
+                { 67, SetGamePlayRecordingState   }
+            };
+        }
+
+        public long PopLaunchParameter(ServiceCtx Context)
+        {
+            //Only the first 0x18 bytes of the Data seems to be actually used.
+            MakeObject(Context, new IStorage(StorageHelper.MakeLaunchParams()));
+
+            return 0;
+        }
+
+        public long EnsureSaveData(ServiceCtx Context)
+        {
+            long UIdLow  = Context.RequestData.ReadInt64();
+            long UIdHigh = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            Context.ResponseData.Write(0L);
+
+            return 0;
+        }
+
+        public long GetDesiredLanguage(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(Context.Ns.Os.SystemState.DesiredLanguageCode);
+
+            return 0;
+        }
+
+        public long SetTerminateResult(ServiceCtx Context)
+        {
+            int ErrorCode = Context.RequestData.ReadInt32();
+
+            string Result = GetFormattedErrorCode(ErrorCode);
+
+            Context.Ns.Log.PrintInfo(LogClass.ServiceAm, $"Result = 0x{ErrorCode:x8} ({Result}).");
+
+            return 0;
+        }
+
+        private string GetFormattedErrorCode(int ErrorCode)
+        {
+            int Module      = (ErrorCode >> 0) & 0x1ff;
+            int Description = (ErrorCode >> 9) & 0x1fff;
+
+            return $"{(2000 + Module):d4}-{Description:d4}";
+        }
+
+        public long GetDisplayVersion(ServiceCtx Context)
+        {
+            //FIXME: Need to check correct version on a switch.
+            Context.ResponseData.Write(1L);
+            Context.ResponseData.Write(0L);
+
+            return 0;
+        }
+
+        public long NotifyRunning(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1);
+
+            return 0;
+        }
+
+        public long GetPseudoDeviceId(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            Context.ResponseData.Write(0L);
+            Context.ResponseData.Write(0L);
+
+            return 0;
+        }
+
+        public long InitializeGamePlayRecording(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetGamePlayRecordingState(ServiceCtx Context)
+        {
+            int State = Context.RequestData.ReadInt32();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IApplicationProxy.cs

@@ -0,0 +1,83 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IApplicationProxy : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IApplicationProxy()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,    GetCommonStateGetter    },
+                { 1,    GetSelfController       },
+                { 2,    GetWindowController     },
+                { 3,    GetAudioController      },
+                { 4,    GetDisplayController    },
+                { 11,   GetLibraryAppletCreator },
+                { 20,   GetApplicationFunctions },
+                { 1000, GetDebugFunctions       }
+            };
+        }
+
+        public long GetCommonStateGetter(ServiceCtx Context)
+        {
+            MakeObject(Context, new ICommonStateGetter());
+
+            return 0;
+        }
+
+        public long GetSelfController(ServiceCtx Context)
+        {
+            MakeObject(Context, new ISelfController());
+
+            return 0;
+        }
+
+        public long GetWindowController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IWindowController());
+
+            return 0;
+        }
+
+        public long GetAudioController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IAudioController());
+
+            return 0;
+        }
+
+        public long GetDisplayController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IDisplayController());
+
+            return 0;
+        }
+
+        public long GetLibraryAppletCreator(ServiceCtx Context)
+        {
+            MakeObject(Context, new ILibraryAppletCreator());
+
+            return 0;
+        }
+
+        public long GetApplicationFunctions(ServiceCtx Context)
+        {
+            MakeObject(Context, new IApplicationFunctions());
+
+            return 0;
+        }
+
+        public long GetDebugFunctions(ServiceCtx Context)
+        {
+            MakeObject(Context, new IDebugFunctions());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IApplicationProxyService.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IApplicationProxyService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IApplicationProxyService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, OpenApplicationProxy }
+            };
+        }
+
+        public long OpenApplicationProxy(ServiceCtx Context)
+        {
+            MakeObject(Context, new IApplicationProxy());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IAudioController.cs

@@ -0,0 +1,72 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IAudioController : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAudioController()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, SetExpectedMasterVolume              },
+                { 1, GetMainAppletExpectedMasterVolume    },
+                { 2, GetLibraryAppletExpectedMasterVolume },
+                { 3, ChangeMainAppletMasterVolume         },
+                { 4, SetTransparentVolumeRate             }
+            };
+        }
+
+        public long SetExpectedMasterVolume(ServiceCtx Context)
+        {
+            float AppletVolume        = Context.RequestData.ReadSingle();
+            float LibraryAppletVolume = Context.RequestData.ReadSingle();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetMainAppletExpectedMasterVolume(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1f);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetLibraryAppletExpectedMasterVolume(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1f);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ChangeMainAppletMasterVolume(ServiceCtx Context)
+        {
+            float Unknown0 = Context.RequestData.ReadSingle();
+            long  Unknown1 = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetTransparentVolumeRate(ServiceCtx Context)
+        {
+            float Unknown0 = Context.RequestData.ReadSingle();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/ICommonStateGetter.cs

@@ -0,0 +1,109 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+using static Ryujinx.HLE.OsHle.ErrorCode;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class ICommonStateGetter : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent DisplayResolutionChangeEvent;
+
+        public ICommonStateGetter()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, GetEventHandle                          },
+                { 1, ReceiveMessage                          },
+                { 5, GetOperationMode                        },
+                { 6, GetPerformanceMode                      },
+                { 8, GetBootMode                             },
+                { 9, GetCurrentFocusState                    },
+                { 60, GetDefaultDisplayResolution            },
+                { 61, GetDefaultDisplayResolutionChangeEvent }
+            };
+
+            DisplayResolutionChangeEvent = new KEvent();
+        }
+
+        public long GetEventHandle(ServiceCtx Context)
+        {
+            KEvent Event = Context.Process.AppletState.MessageEvent;
+
+            int Handle = Context.Process.HandleTable.OpenHandle(Event);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+
+        public long ReceiveMessage(ServiceCtx Context)
+        {
+            if (!Context.Process.AppletState.TryDequeueMessage(out MessageInfo Message))
+            {
+                return MakeError(ErrorModule.Am, AmErr.NoMessages);
+            }
+
+            Context.ResponseData.Write((int)Message);
+
+            return 0;
+        }
+
+        public long GetOperationMode(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((byte)OperationMode.Handheld);
+
+            return 0;
+        }
+
+        public long GetPerformanceMode(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((byte)Apm.PerformanceMode.Handheld);
+
+            return 0;
+        }
+
+        public long GetBootMode(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((byte)0); //Unknown value.
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetCurrentFocusState(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((byte)Context.Process.AppletState.FocusState);
+
+            return 0;
+        }
+
+        public long GetDefaultDisplayResolution(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1280);
+            Context.ResponseData.Write(720);
+
+            // Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetDefaultDisplayResolutionChangeEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(DisplayResolutionChangeEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IDebugFunctions.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IDebugFunctions : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IDebugFunctions()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IDisplayController.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IDisplayController : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IDisplayController()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IGlobalStateController.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IGlobalStateController : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IGlobalStateController()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IHomeMenuFunctions.cs

@@ -0,0 +1,46 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IHomeMenuFunctions : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent ChannelEvent;
+
+        public IHomeMenuFunctions()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 10, RequestToGetForeground        },
+                { 21, GetPopFromGeneralChannelEvent }
+            };
+
+            //ToDo: Signal this Event somewhere in future.
+            ChannelEvent = new KEvent();
+        }
+
+        public long RequestToGetForeground(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetPopFromGeneralChannelEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(ChannelEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/ILibraryAppletAccessor.cs

@@ -0,0 +1,71 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class ILibraryAppletAccessor : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent StateChangedEvent;
+
+        public ILibraryAppletAccessor()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,   GetAppletStateChangedEvent },
+                { 10,  Start                      },
+                { 30,  GetResult                  },
+                { 100, PushInData                 },
+                { 101, PopOutData                 }
+            };
+
+            StateChangedEvent = new KEvent();
+        }
+
+        public long GetAppletStateChangedEvent(ServiceCtx Context)
+        {
+            StateChangedEvent.WaitEvent.Set();
+
+            int Handle = Context.Process.HandleTable.OpenHandle(StateChangedEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long Start(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetResult(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long PushInData(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long PopOutData(ServiceCtx Context)
+        {
+            MakeObject(Context, new IStorage(StorageHelper.MakeLaunchParams()));
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/ILibraryAppletCreator.cs

@@ -0,0 +1,37 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class ILibraryAppletCreator : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ILibraryAppletCreator()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  CreateLibraryApplet },
+                { 10, CreateStorage       }
+            };
+        }
+
+        public long CreateLibraryApplet(ServiceCtx Context)
+        {
+            MakeObject(Context, new ILibraryAppletAccessor());
+
+            return 0;
+        }
+
+        public long CreateStorage(ServiceCtx Context)
+        {
+            long Size = Context.RequestData.ReadInt64();
+
+            MakeObject(Context, new IStorage(new byte[Size]));
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/ISelfController.cs

@@ -0,0 +1,117 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class ISelfController : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent LaunchableEvent;
+
+        public ISelfController()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 1,  LockExit                              },
+                { 9,  GetLibraryAppletLaunchableEvent       },
+                { 10, SetScreenShotPermission               },
+                { 11, SetOperationModeChangedNotification   },
+                { 12, SetPerformanceModeChangedNotification },
+                { 13, SetFocusHandlingMode                  },
+                { 14, SetRestartMessageEnabled              },
+                { 16, SetOutOfFocusSuspendingEnabled        },
+                { 50, SetHandlesRequestToDisplay            }
+            };
+
+            LaunchableEvent = new KEvent();
+        }
+
+        public long LockExit(ServiceCtx Context)
+        {
+            return 0;
+        }
+
+        public long GetLibraryAppletLaunchableEvent(ServiceCtx Context)
+        {
+            LaunchableEvent.WaitEvent.Set();
+
+            int Handle = Context.Process.HandleTable.OpenHandle(LaunchableEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetScreenShotPermission(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetOperationModeChangedNotification(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetPerformanceModeChangedNotification(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetFocusHandlingMode(ServiceCtx Context)
+        {
+            bool Flag1 = Context.RequestData.ReadByte() != 0 ? true : false;
+            bool Flag2 = Context.RequestData.ReadByte() != 0 ? true : false;
+            bool Flag3 = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetRestartMessageEnabled(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetOutOfFocusSuspendingEnabled(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetHandlesRequestToDisplay(ServiceCtx Context)
+        {
+            bool Enable = Context.RequestData.ReadByte() != 0 ? true : false;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IStorage.cs

@@ -0,0 +1,31 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IStorage : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public byte[] Data { get; private set; }
+
+        public IStorage(byte[] Data)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Open }
+            };
+
+            this.Data = Data;
+        }
+
+        public long Open(ServiceCtx Context)
+        {
+            MakeObject(Context, new IStorageAccessor(this));
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IStorageAccessor.cs

@@ -0,0 +1,83 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IStorageAccessor : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private IStorage Storage;
+
+        public IStorageAccessor(IStorage Storage)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  GetSize },
+                { 10, Write   },
+                { 11, Read    }
+            };
+
+            this.Storage = Storage;
+        }
+
+        public long GetSize(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((long)Storage.Data.Length);
+
+            return 0;
+        }
+
+        public long Write(ServiceCtx Context)
+        {
+            //TODO: Error conditions.
+            long WritePosition = Context.RequestData.ReadInt64();
+
+            (long Position, long Size) = Context.Request.GetBufferType0x21();
+
+            if (Size > 0)
+            {
+                long MaxSize = Storage.Data.Length - WritePosition;
+
+                if (Size > MaxSize)
+                {
+                    Size = MaxSize;
+                }
+
+                byte[] Data = Context.Memory.ReadBytes(Position, Size);
+
+                Buffer.BlockCopy(Data, 0, Storage.Data, (int)WritePosition, (int)Size);
+            }
+
+            return 0;
+        }
+
+        public long Read(ServiceCtx Context)
+        {
+            //TODO: Error conditions.
+            long ReadPosition = Context.RequestData.ReadInt64();
+
+            (long Position, long Size) = Context.Request.GetBufferType0x22();
+
+            byte[] Data;
+
+            if (Storage.Data.Length > Size)
+            {
+                Data = new byte[Size];
+
+                Buffer.BlockCopy(Storage.Data, 0, Data, 0, (int)Size);
+            }
+            else
+            {
+                Data = Storage.Data;
+            }
+
+            Context.Memory.WriteBytes(Position, Data);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/ISystemAppletProxy.cs

@@ -0,0 +1,99 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class ISystemAppletProxy : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ISystemAppletProxy()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,    GetCommonStateGetter     },
+                { 1,    GetSelfController        },
+                { 2,    GetWindowController      },
+                { 3,    GetAudioController       },
+                { 4,    GetDisplayController     },
+                { 11,   GetLibraryAppletCreator  },
+                { 20,   GetHomeMenuFunctions     },
+                { 21,   GetGlobalStateController },
+                { 22,   GetApplicationCreator    },
+                { 1000, GetDebugFunctions        }
+            };
+        }
+
+        public long GetCommonStateGetter(ServiceCtx Context)
+        {
+            MakeObject(Context, new ICommonStateGetter());
+
+            return 0;
+        }
+
+        public long GetSelfController(ServiceCtx Context)
+        {
+            MakeObject(Context, new ISelfController());
+
+            return 0;
+        }
+
+        public long GetWindowController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IWindowController());
+
+            return 0;
+        }
+
+        public long GetAudioController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IAudioController());
+
+            return 0;
+        }
+
+        public long GetDisplayController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IDisplayController());
+
+            return 0;
+        }
+
+        public long GetLibraryAppletCreator(ServiceCtx Context)
+        {
+            MakeObject(Context, new ILibraryAppletCreator());
+
+            return 0;
+        }
+
+        public long GetHomeMenuFunctions(ServiceCtx Context)
+        {
+            MakeObject(Context, new IHomeMenuFunctions());
+
+            return 0;
+        }
+
+        public long GetGlobalStateController(ServiceCtx Context)
+        {
+            MakeObject(Context, new IGlobalStateController());
+
+            return 0;
+        }
+
+        public long GetApplicationCreator(ServiceCtx Context)
+        {
+            MakeObject(Context, new IApplicationCreator());
+
+            return 0;
+        }
+
+        public long GetDebugFunctions(ServiceCtx Context)
+        {
+            MakeObject(Context, new IDebugFunctions());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/IWindowController.cs

@@ -0,0 +1,38 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class IWindowController : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IWindowController()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 1,  GetAppletResourceUserId },
+                { 10, AcquireForegroundRights }
+            };
+        }
+
+        public long GetAppletResourceUserId(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            Context.ResponseData.Write(0L);
+
+            return 0;
+        }
+
+        public long AcquireForegroundRights(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/MessageInfo.cs

@@ -0,0 +1,9 @@
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    enum MessageInfo
+    {
+        FocusStateChanged      = 0xf,
+        OperationModeChanged   = 0x1e,
+        PerformanceModeChanged = 0x1f
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/OperationMode.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    enum OperationMode
+    {
+        Handheld = 0,
+        Docked   = 1
+    }
+}

Ryujinx.HLE/OsHle/Services/Am/StorageHelper.cs

@@ -0,0 +1,27 @@
+using System.IO;
+
+namespace Ryujinx.HLE.OsHle.Services.Am
+{
+    class StorageHelper
+    {
+        private const uint LaunchParamsMagic = 0xc79497ca;
+
+        public static byte[] MakeLaunchParams()
+        {
+            //Size needs to be at least 0x88 bytes otherwise application errors.
+            using (MemoryStream MS = new MemoryStream())
+            {
+                BinaryWriter Writer = new BinaryWriter(MS);
+
+                MS.SetLength(0x88);
+
+                Writer.Write(LaunchParamsMagic);
+                Writer.Write(1);  //IsAccountSelected? Only lower 8 bits actually used.
+                Writer.Write(1L); //User Id Low (note: User Id needs to be != 0)
+                Writer.Write(0L); //User Id High
+
+                return MS.ToArray();
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Apm/IManager.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Apm
+{
+    class IManager : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IManager()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, OpenSession }
+            };
+        }
+
+        public long OpenSession(ServiceCtx Context)
+        {
+            MakeObject(Context, new ISession());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Apm/ISession.cs

@@ -0,0 +1,41 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Apm
+{
+    class ISession : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ISession()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, SetPerformanceConfiguration },
+                { 1, GetPerformanceConfiguration }
+            };
+        }
+
+        public long SetPerformanceConfiguration(ServiceCtx Context)
+        {
+            PerformanceMode          PerfMode   = (PerformanceMode)Context.RequestData.ReadInt32();
+            PerformanceConfiguration PerfConfig = (PerformanceConfiguration)Context.RequestData.ReadInt32();
+
+            return 0;
+        }
+
+        public long GetPerformanceConfiguration(ServiceCtx Context)
+        {
+            PerformanceMode PerfMode = (PerformanceMode)Context.RequestData.ReadInt32();
+
+            Context.ResponseData.Write((uint)PerformanceConfiguration.PerformanceConfiguration1);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceApm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Apm/PerformanceConfiguration.cs

@@ -0,0 +1,18 @@
+namespace Ryujinx.HLE.OsHle.Services.Apm
+{
+    enum PerformanceConfiguration : uint
+    {
+        PerformanceConfiguration1  = 0x00010000,
+        PerformanceConfiguration2  = 0x00010001,
+        PerformanceConfiguration3  = 0x00010002,
+        PerformanceConfiguration4  = 0x00020000,
+        PerformanceConfiguration5  = 0x00020001,
+        PerformanceConfiguration6  = 0x00020002,
+        PerformanceConfiguration7  = 0x00020003,
+        PerformanceConfiguration8  = 0x00020004,
+        PerformanceConfiguration9  = 0x00020005,
+        PerformanceConfiguration10 = 0x00020006,
+        PerformanceConfiguration11 = 0x92220007,
+        PerformanceConfiguration12 = 0x92220008
+    }
+}

Ryujinx.HLE/OsHle/Services/Apm/PerformanceMode.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Apm
+{
+    enum PerformanceMode
+    {
+        Handheld = 0,
+        Docked   = 1
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/AudioOutData.cs

@@ -0,0 +1,14 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    [StructLayout(LayoutKind.Sequential)]
+    struct AudioOutData
+    {
+        public long NextBufferPtr;
+        public long SampleBufferPtr;
+        public long SampleBufferCapacity;
+        public long SampleBufferSize;
+        public long SampleBufferInnerOffset;
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/IAudioDevice.cs

@@ -0,0 +1,222 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    class IAudioDevice : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent SystemEvent;
+
+        public IAudioDevice()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  ListAudioDeviceName            },
+                { 1,  SetAudioDeviceOutputVolume     },
+                { 3,  GetActiveAudioDeviceName       },
+                { 4,  QueryAudioDeviceSystemEvent    },
+                { 5,  GetActiveChannelCount          },
+                { 6,  ListAudioDeviceNameAuto        },
+                { 7,  SetAudioDeviceOutputVolumeAuto },
+                { 8,  GetAudioDeviceOutputVolumeAuto },
+                { 10, GetActiveAudioDeviceNameAuto   },
+                { 11, QueryAudioDeviceInputEvent     },
+                { 12, QueryAudioDeviceOutputEvent    }
+            };
+
+            SystemEvent = new KEvent();
+
+            //TODO: We shouldn't be signaling this here.
+            SystemEvent.WaitEvent.Set();
+        }
+
+        public long ListAudioDeviceName(ServiceCtx Context)
+        {
+            string[] DeviceNames = SystemStateMgr.AudioOutputs;
+
+            Context.ResponseData.Write(DeviceNames.Length);
+
+            long Position = Context.Request.ReceiveBuff[0].Position;
+            long Size     = Context.Request.ReceiveBuff[0].Size;
+
+            long BasePosition = Position;
+
+            foreach (string Name in DeviceNames)
+            {
+                byte[] Buffer = Encoding.ASCII.GetBytes(Name + "\0");
+
+                if ((Position - BasePosition) + Buffer.Length > Size)
+                {
+                    Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+
+                    break;
+                }
+
+                Context.Memory.WriteBytes(Position, Buffer);
+
+                Position += Buffer.Length;
+            }
+
+            return 0;
+        }
+
+        public long SetAudioDeviceOutputVolume(ServiceCtx Context)
+        {
+            float Volume = Context.RequestData.ReadSingle();
+
+            long Position = Context.Request.SendBuff[0].Position;
+            long Size     = Context.Request.SendBuff[0].Size;
+
+            byte[] DeviceNameBuffer = Context.Memory.ReadBytes(Position, Size);
+
+            string DeviceName = Encoding.ASCII.GetString(DeviceNameBuffer);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetActiveAudioDeviceName(ServiceCtx Context)
+        {
+            string Name = Context.Ns.Os.SystemState.ActiveAudioOutput;
+
+            long Position = Context.Request.ReceiveBuff[0].Position;
+            long Size     = Context.Request.ReceiveBuff[0].Size;
+
+            byte[] DeviceNameBuffer = Encoding.ASCII.GetBytes(Name + "\0");
+
+            if ((ulong)DeviceNameBuffer.Length <= (ulong)Size)
+            {
+                Context.Memory.WriteBytes(Position, DeviceNameBuffer);
+            }
+            else
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+            }
+
+            return 0;
+        }
+
+        public long QueryAudioDeviceSystemEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(SystemEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetActiveChannelCount(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(2);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ListAudioDeviceNameAuto(ServiceCtx Context)
+        {
+            string[] DeviceNames = SystemStateMgr.AudioOutputs;
+
+            Context.ResponseData.Write(DeviceNames.Length);
+
+            (long Position, long Size) = Context.Request.GetBufferType0x22();
+
+            long BasePosition = Position;
+
+            foreach (string Name in DeviceNames)
+            {
+                byte[] Buffer = Encoding.UTF8.GetBytes(Name + '\0');
+
+                if ((Position - BasePosition) + Buffer.Length > Size)
+                {
+                    Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+
+                    break;
+                }
+
+                Context.Memory.WriteBytes(Position, Buffer);
+
+                Position += Buffer.Length;
+            }
+
+            return 0;
+        }
+
+        public long SetAudioDeviceOutputVolumeAuto(ServiceCtx Context)
+        {
+            float Volume = Context.RequestData.ReadSingle();
+
+            (long Position, long Size) = Context.Request.GetBufferType0x21();
+
+            byte[] DeviceNameBuffer = Context.Memory.ReadBytes(Position, Size);
+
+            string DeviceName = Encoding.UTF8.GetString(DeviceNameBuffer);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetAudioDeviceOutputVolumeAuto(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(1f);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetActiveAudioDeviceNameAuto(ServiceCtx Context)
+        {
+            string Name = Context.Ns.Os.SystemState.ActiveAudioOutput;
+
+            (long Position, long Size) = Context.Request.GetBufferType0x22();
+
+            byte[] DeviceNameBuffer = Encoding.UTF8.GetBytes(Name + '\0');
+
+            if ((ulong)DeviceNameBuffer.Length <= (ulong)Size)
+            {
+                Context.Memory.WriteBytes(Position, DeviceNameBuffer);
+            }
+            else
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+            }
+
+            return 0;
+        }
+
+        public long QueryAudioDeviceInputEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(SystemEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long QueryAudioDeviceOutputEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(SystemEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/IAudioOut.cs

@@ -0,0 +1,154 @@
+using ChocolArm64.Memory;
+using Ryujinx.Audio;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    class IAudioOut : IpcService, IDisposable
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private IAalOutput AudioOut;
+
+        private KEvent ReleaseEvent;
+
+        private int Track;
+
+        public IAudioOut(IAalOutput AudioOut, KEvent ReleaseEvent, int Track)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, GetAudioOutState            },
+                { 1, StartAudioOut               },
+                { 2, StopAudioOut                },
+                { 3, AppendAudioOutBuffer        },
+                { 4, RegisterBufferEvent         },
+                { 5, GetReleasedAudioOutBuffer   },
+                { 6, ContainsAudioOutBuffer      },
+                { 7, AppendAudioOutBufferEx      },
+                { 8, GetReleasedAudioOutBufferEx }
+            };
+
+            this.AudioOut     = AudioOut;
+            this.ReleaseEvent = ReleaseEvent;
+            this.Track        = Track;
+        }
+
+        public long GetAudioOutState(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((int)AudioOut.GetState(Track));
+
+            return 0;
+        }
+
+        public long StartAudioOut(ServiceCtx Context)
+        {
+            AudioOut.Start(Track);
+
+            return 0;
+        }
+
+        public long StopAudioOut(ServiceCtx Context)
+        {
+            AudioOut.Stop(Track);
+
+            return 0;
+        }
+
+        public long AppendAudioOutBuffer(ServiceCtx Context)
+        {
+            long Tag = Context.RequestData.ReadInt64();
+
+            AudioOutData Data = AMemoryHelper.Read<AudioOutData>(
+                Context.Memory,
+                Context.Request.SendBuff[0].Position);
+
+            byte[] Buffer = Context.Memory.ReadBytes(
+                Data.SampleBufferPtr,
+                Data.SampleBufferSize);
+
+            AudioOut.AppendBuffer(Track, Tag, Buffer);
+
+            return 0;
+        }
+
+        public long RegisterBufferEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(ReleaseEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+
+        public long GetReleasedAudioOutBuffer(ServiceCtx Context)
+        {
+            long Position = Context.Request.ReceiveBuff[0].Position;
+            long Size     = Context.Request.ReceiveBuff[0].Size;
+
+            uint Count = (uint)((ulong)Size >> 3);
+
+            long[] ReleasedBuffers = AudioOut.GetReleasedBuffers(Track, (int)Count);
+
+            for (uint Index = 0; Index < Count; Index++)
+            {
+                long Tag = 0;
+
+                if (Index < ReleasedBuffers.Length)
+                {
+                    Tag = ReleasedBuffers[Index];
+                }
+
+                Context.Memory.WriteInt64(Position + Index * 8, Tag);
+            }
+
+            Context.ResponseData.Write(ReleasedBuffers.Length);
+
+            return 0;
+        }
+
+        public long ContainsAudioOutBuffer(ServiceCtx Context)
+        {
+            long Tag = Context.RequestData.ReadInt64();
+
+            Context.ResponseData.Write(AudioOut.ContainsBuffer(Track, Tag) ? 1 : 0);
+
+            return 0;
+        }
+
+        public long AppendAudioOutBufferEx(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetReleasedAudioOutBufferEx(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                AudioOut.CloseTrack(Track);
+
+                ReleaseEvent.Dispose();
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/IAudioOutManager.cs

@@ -0,0 +1,115 @@
+using ChocolArm64.Memory;
+using Ryujinx.Audio;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    class IAudioOutManager : IpcService
+    {
+        private const string DefaultAudioOutput = "DeviceOut";
+
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAudioOutManager()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, ListAudioOuts },
+                { 1, OpenAudioOut  }
+            };
+        }
+
+        public long ListAudioOuts(ServiceCtx Context)
+        {
+            long Position = Context.Request.ReceiveBuff[0].Position;
+            long Size     = Context.Request.ReceiveBuff[0].Size;
+
+            int NameCount = 0;
+
+            byte[] DeviceNameBuffer = Encoding.ASCII.GetBytes(DefaultAudioOutput + "\0");
+
+            if ((ulong)DeviceNameBuffer.Length <= (ulong)Size)
+            {
+                Context.Memory.WriteBytes(Position, DeviceNameBuffer);
+
+                NameCount++;
+            }
+            else
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+            }
+
+            Context.ResponseData.Write(NameCount);
+
+            return 0;
+        }
+
+        public long OpenAudioOut(ServiceCtx Context)
+        {
+            IAalOutput AudioOut = Context.Ns.AudioOut;
+
+            string DeviceName = AMemoryHelper.ReadAsciiString(
+                Context.Memory,
+                Context.Request.SendBuff[0].Position,
+                Context.Request.SendBuff[0].Size);
+
+            if (DeviceName == string.Empty)
+            {
+                DeviceName = DefaultAudioOutput;
+            }
+
+            long Position = Context.Request.ReceiveBuff[0].Position;
+            long Size     = Context.Request.ReceiveBuff[0].Size;
+
+            byte[] DeviceNameBuffer = Encoding.ASCII.GetBytes(DeviceName + "\0");
+
+            if ((ulong)DeviceNameBuffer.Length <= (ulong)Size)
+            {
+                Context.Memory.WriteBytes(Position, DeviceNameBuffer);
+            }
+            else
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Output buffer size {Size} too small!");
+            }
+
+            int SampleRate = Context.RequestData.ReadInt32();
+            int Channels   = Context.RequestData.ReadInt32();
+
+            Channels = (ushort)(Channels >> 16);
+
+            if (SampleRate == 0)
+            {
+                SampleRate = 48000;
+            }
+
+            if (Channels < 1 || Channels > 2)
+            {
+                Channels = 2;
+            }
+
+            KEvent ReleaseEvent = new KEvent();
+
+            ReleaseCallback Callback = () =>
+            {
+                ReleaseEvent.WaitEvent.Set();
+            };
+
+            int Track = AudioOut.OpenTrack(SampleRate, Channels, Callback, out AudioFormat Format);
+
+            MakeObject(Context, new IAudioOut(AudioOut, ReleaseEvent, Track));
+
+            Context.ResponseData.Write(SampleRate);
+            Context.ResponseData.Write(Channels);
+            Context.ResponseData.Write((int)Format);
+            Context.ResponseData.Write((int)PlaybackState.Stopped);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/IAudioRenderer.cs

@@ -0,0 +1,92 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    class IAudioRenderer : IpcService, IDisposable
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent UpdateEvent;
+
+        public IAudioRenderer()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 4, RequestUpdateAudioRenderer },
+                { 5, StartAudioRenderer         },
+                { 6, StopAudioRenderer          },
+                { 7, QuerySystemEvent           }
+            };
+
+            UpdateEvent = new KEvent();
+        }
+
+        public long RequestUpdateAudioRenderer(ServiceCtx Context)
+        {
+            //(buffer<unknown, 5, 0>) -> (buffer<unknown, 6, 0>, buffer<unknown, 6, 0>)
+
+            long Position = Context.Request.ReceiveBuff[0].Position;
+
+            //0x40 bytes header
+            Context.Memory.WriteInt32(Position + 0x4, 0xb0); //Behavior Out State Size? (note: this is the last section)
+            Context.Memory.WriteInt32(Position + 0x8, 0x18e0); //Memory Pool Out State Size?
+            Context.Memory.WriteInt32(Position + 0xc, 0x600); //Voice Out State Size?
+            Context.Memory.WriteInt32(Position + 0x14, 0xe0); //Effect Out State Size?
+            Context.Memory.WriteInt32(Position + 0x1c, 0x20); //Sink Out State Size?
+            Context.Memory.WriteInt32(Position + 0x20, 0x10); //Performance Out State Size?
+            Context.Memory.WriteInt32(Position + 0x3c, 0x20e0); //Total Size (including 0x40 bytes header)
+
+            for (int Offset = 0x40; Offset < 0x40 + 0x18e0; Offset += 0x10)
+            {
+                Context.Memory.WriteInt32(Position + Offset, 5);
+            }
+
+            //TODO: We shouldn't be signaling this here.
+            UpdateEvent.WaitEvent.Set();
+
+            return 0;
+        }
+
+        public long StartAudioRenderer(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long StopAudioRenderer(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceAudio, "Stubbed.");
+
+            return 0;
+        }
+
+        public long QuerySystemEvent(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(UpdateEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                UpdateEvent.Dispose();
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Aud/IAudioRendererManager.cs

@@ -0,0 +1,135 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Aud
+{
+    class IAudioRendererManager : IpcService
+    {
+        private const int Rev0Magic = ('R' << 0)  |
+                                      ('E' << 8)  |
+                                      ('V' << 16) |
+                                      ('0' << 24);
+
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAudioRendererManager()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, OpenAudioRenderer              },
+                { 1, GetAudioRendererWorkBufferSize },
+                { 2, GetAudioDevice                 }
+            };
+        }
+
+        public long OpenAudioRenderer(ServiceCtx Context)
+        {
+            //Same buffer as GetAudioRendererWorkBufferSize is receive here.
+
+            MakeObject(Context, new IAudioRenderer());
+
+            return 0;
+        }
+
+        public long GetAudioRendererWorkBufferSize(ServiceCtx Context)
+        {
+            long SampleRate = Context.RequestData.ReadUInt32();
+            long Unknown4   = Context.RequestData.ReadUInt32();
+            long Unknown8   = Context.RequestData.ReadUInt32();
+            long UnknownC   = Context.RequestData.ReadUInt32();
+            long Unknown10  = Context.RequestData.ReadUInt32(); //VoiceCount
+            long Unknown14  = Context.RequestData.ReadUInt32(); //SinkCount
+            long Unknown18  = Context.RequestData.ReadUInt32(); //EffectCount
+            long Unknown1c  = Context.RequestData.ReadUInt32(); //Boolean
+            long Unknown20  = Context.RequestData.ReadUInt32(); //Not used here in FW3.0.1 - Boolean
+            long Unknown24  = Context.RequestData.ReadUInt32();
+            long Unknown28  = Context.RequestData.ReadUInt32(); //SplitterCount
+            long Unknown2c  = Context.RequestData.ReadUInt32(); //Not used here in FW3.0.1
+            int RevMagic    = Context.RequestData.ReadInt32();
+
+            int Version = (RevMagic - Rev0Magic) >> 24;
+
+            if (Version <= 3) //REV3 Max is supported
+            {
+                long Size  = RoundUp(Unknown8 * 4, 64);
+                     Size += (UnknownC << 10);
+                     Size += (UnknownC + 1) * 0x940;
+                     Size += Unknown10 * 0x3F0;
+                     Size += RoundUp((UnknownC + 1) * 8, 16);
+                     Size += RoundUp(Unknown10 * 8, 16);
+                     Size += RoundUp((0x3C0 * (Unknown14 + UnknownC) + 4 * Unknown4) * (Unknown8 + 6), 64);
+                     Size += 0x2C0 * (Unknown14 + UnknownC) + 0x30 * (Unknown18 + (4 * Unknown10)) + 0x50;
+
+                if (Version >= 3) //IsSplitterSupported
+                {
+                    Size += RoundUp((NodeStatesGetWorkBufferSize((int)UnknownC + 1) + EdgeMatrixGetWorkBufferSize((int)UnknownC + 1)), 16);
+                    Size += 0xE0 * Unknown28 + 0x20 * Unknown24 + RoundUp(Unknown28 * 4, 16);
+                }
+
+                Size = 0x4C0 * Unknown18 + RoundUp(Size, 64) + 0x170 * Unknown14 + ((Unknown10 << 8) | 0x40);
+
+                if (Unknown1c >= 1)
+                {
+                    Size += ((((Unknown18 + Unknown14 + Unknown10 + UnknownC + 1) * 16) + 0x658) * (Unknown1c + 1) + 0x13F) & ~0x3FL;
+                }
+
+                long WorkBufferSize = (Size + 0x1907D) & ~0xFFFL;
+
+                Context.ResponseData.Write(WorkBufferSize);
+
+                Context.Ns.Log.PrintDebug(LogClass.ServiceAudio, $"WorkBufferSize is 0x{WorkBufferSize:x16}.");
+
+                return 0;
+            }
+            else
+            {
+                Context.ResponseData.Write(0L);
+
+                Context.Ns.Log.PrintError(LogClass.ServiceAudio, $"Library Revision 0x{RevMagic:x8} is not supported!");
+
+                return 0x499;
+            }
+        }
+
+        private static long RoundUp(long Value, int Size)
+        {
+            return (Value + (Size - 1)) & ~((long)Size - 1);
+        }
+
+        private static int NodeStatesGetWorkBufferSize(int Value)
+        {
+            int Result = (int)RoundUp(Value, 64);
+
+            if (Result < 0)
+            {
+                Result |= 7;
+            }
+
+            return 4 * (Value * Value) + 0x12 * Value + 2 * (Result / 8);
+        }
+
+        private static int EdgeMatrixGetWorkBufferSize(int Value)
+        {
+            int Result = (int)RoundUp(Value * Value, 64);
+
+            if (Result < 0)
+            {
+                Result |= 7;
+            }
+
+            return Result / 8;
+        }
+
+        public long GetAudioDevice(ServiceCtx Context)
+        {
+            long UserId = Context.RequestData.ReadInt64();
+
+            MakeObject(Context, new IAudioDevice());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Bsd/BsdError.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Bsd
+{
+    //bsd_errno == (SocketException.ErrorCode - 10000)
+    public enum BsdError
+    {
+        Timeout = 60
+    }
+}

Ryujinx.HLE/OsHle/Services/Bsd/BsdSocket.cs

@@ -0,0 +1,18 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.OsHle.Services.Bsd
+{
+    class BsdSocket
+    {
+        public int Family;
+        public int Type;
+        public int Protocol;
+
+        public IPAddress IpAddress;
+
+        public IPEndPoint RemoteEP;
+
+        public Socket Handle;
+    }
+}

Ryujinx.HLE/OsHle/Services/Bsd/IClient.cs

@@ -0,0 +1,445 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using Ryujinx.HLE.OsHle.Utilities;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading.Tasks;
+
+namespace Ryujinx.HLE.OsHle.Services.Bsd
+{
+    class IClient : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private List<BsdSocket> Sockets = new List<BsdSocket>();
+
+        public IClient()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  Initialize      },
+                { 1,  StartMonitoring },
+                { 2,  Socket          },
+                { 6,  Poll            },
+                { 8,  Recv            },
+                { 10, Send            },
+                { 11, SendTo          },
+                { 12, Accept          },
+                { 13, Bind            },
+                { 14, Connect         },
+                { 18, Listen          },
+                { 21, SetSockOpt      },
+                { 26, Close           }
+            };
+        }
+
+        //(u32, u32, u32, u32, u32, u32, u32, u32, u64 pid, u64 transferMemorySize, pid, KObject) -> u32 bsd_errno
+        public long Initialize(ServiceCtx Context)
+        {
+            /*
+            typedef struct  {
+                u32 version;                // Observed 1 on 2.0 LibAppletWeb, 2 on 3.0.
+                u32 tcp_tx_buf_size;        // Size of the TCP transfer (send) buffer (initial or fixed).
+                u32 tcp_rx_buf_size;        // Size of the TCP recieve buffer (initial or fixed).
+                u32 tcp_tx_buf_max_size;    // Maximum size of the TCP transfer (send) buffer. If it is 0, the size of the buffer is fixed to its initial value.
+                u32 tcp_rx_buf_max_size;    // Maximum size of the TCP receive buffer. If it is 0, the size of the buffer is fixed to its initial value.
+                u32 udp_tx_buf_size;        // Size of the UDP transfer (send) buffer (typically 0x2400 bytes).
+                u32 udp_rx_buf_size;        // Size of the UDP receive buffer (typically 0xA500 bytes).
+                u32 sb_efficiency;          // Number of buffers for each socket (standard values range from 1 to 8).
+            } BsdBufferConfig;
+            */
+
+            Context.ResponseData.Write(0);
+
+            //Todo: Stub
+
+            return 0;
+        }
+
+        //(u64, pid)
+        public long StartMonitoring(ServiceCtx Context)
+        {
+            //Todo: Stub
+
+            return 0;
+        }
+
+        //(u32 domain, u32 type, u32 protocol) -> (i32 ret, u32 bsd_errno)
+        public long Socket(ServiceCtx Context)
+        {
+            BsdSocket NewBsdSocket = new BsdSocket
+            {
+                Family   = Context.RequestData.ReadInt32(),
+                Type     = Context.RequestData.ReadInt32(),
+                Protocol = Context.RequestData.ReadInt32()
+            };
+
+            Sockets.Add(NewBsdSocket);
+
+            NewBsdSocket.Handle = new Socket((AddressFamily)NewBsdSocket.Family,
+                                                (SocketType)NewBsdSocket.Type,
+                                              (ProtocolType)NewBsdSocket.Protocol);
+
+            Context.ResponseData.Write(Sockets.Count - 1);
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        //(u32, u32, buffer<unknown, 0x21, 0>) -> (i32 ret, u32 bsd_errno, buffer<unknown, 0x22, 0>)
+        public long Poll(ServiceCtx Context)
+        {
+            int PollCount = Context.RequestData.ReadInt32();
+            int TimeOut   = Context.RequestData.ReadInt32();
+
+            //https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/poll.h
+            //https://msdn.microsoft.com/fr-fr/library/system.net.sockets.socket.poll(v=vs.110).aspx
+            //https://github.com/switchbrew/libnx/blob/e0457c4534b3c37426d83e1a620f82cb28c3b528/nx/source/services/bsd.c#L343
+            //https://github.com/TuxSH/ftpd/blob/switch_pr/source/ftp.c#L1634
+            //https://linux.die.net/man/2/poll
+
+            byte[] SentBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[0].Position,
+                                                         Context.Request.SendBuff[0].Size);
+
+            int SocketId        = Get32(SentBuffer, 0);
+            int RequestedEvents = Get16(SentBuffer, 4);
+            int ReturnedEvents  = Get16(SentBuffer, 6);
+
+            //Todo: Stub - Need to implemented the Type-22 buffer.
+
+            Context.ResponseData.Write(1);
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        //(u32 socket, u32 flags) -> (i32 ret, u32 bsd_errno, buffer<i8, 0x22, 0> message)
+        public long Recv(ServiceCtx Context)
+        {
+            int SocketId    = Context.RequestData.ReadInt32();
+            int SocketFlags = Context.RequestData.ReadInt32();
+
+            byte[] ReceivedBuffer = new byte[Context.Request.ReceiveBuff[0].Size];
+
+            try
+            {
+                int BytesRead = Sockets[SocketId].Handle.Receive(ReceivedBuffer);
+
+                //Logging.Debug("Received Buffer:" + Environment.NewLine + Logging.HexDump(ReceivedBuffer));
+
+                Context.Memory.WriteBytes(Context.Request.ReceiveBuff[0].Position, ReceivedBuffer);
+
+                Context.ResponseData.Write(BytesRead);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, u32 flags, buffer<i8, 0x21, 0>) -> (i32 ret, u32 bsd_errno)
+        public long Send(ServiceCtx Context)
+        {
+            int SocketId    = Context.RequestData.ReadInt32();
+            int SocketFlags = Context.RequestData.ReadInt32();
+
+            byte[] SentBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[0].Position,
+                                                         Context.Request.SendBuff[0].Size);
+
+            try
+            {
+                //Logging.Debug("Sent Buffer:" + Environment.NewLine + Logging.HexDump(SentBuffer));
+
+                int BytesSent = Sockets[SocketId].Handle.Send(SentBuffer);
+
+                Context.ResponseData.Write(BytesSent);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, u32 flags, buffer<i8, 0x21, 0>, buffer<sockaddr, 0x21, 0>) -> (i32 ret, u32 bsd_errno)
+        public long SendTo(ServiceCtx Context)
+        {
+            int SocketId    = Context.RequestData.ReadInt32();
+            int SocketFlags = Context.RequestData.ReadInt32();
+
+            byte[] SentBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[0].Position,
+                                                         Context.Request.SendBuff[0].Size);
+
+            byte[] AddressBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[1].Position,
+                                                            Context.Request.SendBuff[1].Size);
+
+            if (!Sockets[SocketId].Handle.Connected)
+            {
+                try
+                {
+                    ParseAddrBuffer(SocketId, AddressBuffer);
+
+                    Sockets[SocketId].Handle.Connect(Sockets[SocketId].RemoteEP);
+                }
+                catch (SocketException Ex)
+                {
+                    Context.ResponseData.Write(-1);
+                    Context.ResponseData.Write(Ex.ErrorCode - 10000);
+                }
+            }
+
+            try
+            {
+                //Logging.Debug("Sent Buffer:" + Environment.NewLine + Logging.HexDump(SentBuffer));
+
+                int BytesSent = Sockets[SocketId].Handle.Send(SentBuffer);
+
+                Context.ResponseData.Write(BytesSent);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket) -> (i32 ret, u32 bsd_errno, u32 addrlen, buffer<sockaddr, 0x22, 0> addr)
+        public long Accept(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+
+            long AddrBufferPtr = Context.Request.ReceiveBuff[0].Position;
+
+            Socket HandleAccept = null;
+
+            Task TimeOut = Task.Factory.StartNew(() =>
+            {
+                try
+                {
+                    HandleAccept = Sockets[SocketId].Handle.Accept();
+                }
+                catch (SocketException Ex)
+                {
+                    Context.ResponseData.Write(-1);
+                    Context.ResponseData.Write(Ex.ErrorCode - 10000);
+                }
+            });
+
+            TimeOut.Wait(10000);
+
+            if (HandleAccept != null)
+            {
+                BsdSocket NewBsdSocket = new BsdSocket
+                {
+                    IpAddress = ((IPEndPoint)Sockets[SocketId].Handle.LocalEndPoint).Address,
+                    RemoteEP  = ((IPEndPoint)Sockets[SocketId].Handle.LocalEndPoint),
+                    Handle    = HandleAccept
+                };
+
+                Sockets.Add(NewBsdSocket);
+
+                using (MemoryStream MS = new MemoryStream())
+                {
+                    BinaryWriter Writer = new BinaryWriter(MS);
+
+                    Writer.Write((byte)0);
+
+                    Writer.Write((byte)NewBsdSocket.Handle.AddressFamily);
+
+                    Writer.Write((short)((IPEndPoint)NewBsdSocket.Handle.LocalEndPoint).Port);
+
+                    byte[] IpAddress = NewBsdSocket.IpAddress.GetAddressBytes();
+
+                    Writer.Write(IpAddress);
+
+                    Context.Memory.WriteBytes(AddrBufferPtr, MS.ToArray());
+
+                    Context.ResponseData.Write(Sockets.Count - 1);
+                    Context.ResponseData.Write(0);
+                    Context.ResponseData.Write(MS.Length);
+                }
+            }
+            else
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write((int)BsdError.Timeout);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, buffer<sockaddr, 0x21, 0>) -> (i32 ret, u32 bsd_errno)
+        public long Bind(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+
+            byte[] AddressBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[0].Position,
+                                                            Context.Request.SendBuff[0].Size);
+
+            try
+            {
+                ParseAddrBuffer(SocketId, AddressBuffer);
+
+                Context.ResponseData.Write(0);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, buffer<sockaddr, 0x21, 0>) -> (i32 ret, u32 bsd_errno)
+        public long Connect(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+
+            byte[] AddressBuffer = Context.Memory.ReadBytes(Context.Request.SendBuff[0].Position,
+                                                            Context.Request.SendBuff[0].Size);
+
+            try
+            {
+                ParseAddrBuffer(SocketId, AddressBuffer);
+
+                Sockets[SocketId].Handle.Connect(Sockets[SocketId].RemoteEP);
+
+                Context.ResponseData.Write(0);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, u32 backlog) -> (i32 ret, u32 bsd_errno)
+        public long Listen(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+            int BackLog  = Context.RequestData.ReadInt32();
+
+            try
+            {
+                Sockets[SocketId].Handle.Bind(Sockets[SocketId].RemoteEP);
+                Sockets[SocketId].Handle.Listen(BackLog);
+
+                Context.ResponseData.Write(0);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket, u32 level, u32 option_name, buffer<unknown, 0x21, 0>) -> (i32 ret, u32 bsd_errno)
+        public long SetSockOpt(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+
+            SocketOptionLevel SocketLevel      = (SocketOptionLevel)Context.RequestData.ReadInt32();
+            SocketOptionName  SocketOptionName =  (SocketOptionName)Context.RequestData.ReadInt32();
+
+            byte[] SocketOptionValue = Context.Memory.ReadBytes(Context.Request.PtrBuff[0].Position,
+                                                                Context.Request.PtrBuff[0].Size);
+
+            int OptionValue = Get32(SocketOptionValue, 0);
+
+            try
+            {
+                Sockets[SocketId].Handle.SetSocketOption(SocketLevel, SocketOptionName, OptionValue);
+
+                Context.ResponseData.Write(0);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        //(u32 socket) -> (i32 ret, u32 bsd_errno)
+        public long Close(ServiceCtx Context)
+        {
+            int SocketId = Context.RequestData.ReadInt32();
+
+            try
+            {
+                Sockets[SocketId].Handle.Close();
+                Sockets[SocketId] = null;
+
+                Context.ResponseData.Write(0);
+                Context.ResponseData.Write(0);
+            }
+            catch (SocketException Ex)
+            {
+                Context.ResponseData.Write(-1);
+                Context.ResponseData.Write(Ex.ErrorCode - 10000);
+            }
+
+            return 0;
+        }
+
+        public void ParseAddrBuffer(int SocketId, byte[] AddrBuffer)
+        {
+            using (MemoryStream MS = new MemoryStream(AddrBuffer))
+            {
+                BinaryReader Reader = new BinaryReader(MS);
+
+                int Size   = Reader.ReadByte();
+                int Family = Reader.ReadByte();
+                int Port   = EndianSwap.Swap16(Reader.ReadInt16());
+
+                string IpAddress = Reader.ReadByte().ToString() + "." +
+                                   Reader.ReadByte().ToString() + "." +
+                                   Reader.ReadByte().ToString() + "." +
+                                   Reader.ReadByte().ToString();
+
+                Sockets[SocketId].IpAddress = IPAddress.Parse(IpAddress);
+
+                Sockets[SocketId].RemoteEP = new IPEndPoint(Sockets[SocketId].IpAddress, Port);
+            }
+        }
+
+        private int Get16(byte[] Data, int Address)
+        {
+            return
+                Data[Address + 0] << 0 |
+                Data[Address + 1] << 8;
+        }
+
+        private int Get32(byte[] Data, int Address)
+        {
+            return
+                Data[Address + 0] << 0 |
+                Data[Address + 1] << 8 |
+                Data[Address + 2] << 16 |
+                Data[Address + 3] << 24;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Caps/IAlbumAccessorService.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Caps
+{
+    class IAlbumAccessorService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAlbumAccessorService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Caps/IScreenshotService.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Caps
+{
+    class IScreenshotService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IScreenshotService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Friend/IFriendService.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Friend
+{
+    class IFriendService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IFriendService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Friend/IServiceCreator.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Friend
+{
+    class IServiceCreator : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IServiceCreator()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, CreateFriendService }
+            };
+        }
+
+        public static long CreateFriendService(ServiceCtx Context)
+        {
+            MakeObject(Context, new IFriendService());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/FsErr.cs

@@ -0,0 +1,9 @@
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    static class FsErr
+    {
+        public const int PathDoesNotExist  = 1;
+        public const int PathAlreadyExists = 2;
+        public const int PathAlreadyInUse  = 7;
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/IDirectory.cs

@@ -0,0 +1,116 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    class IDirectory : IpcService, IDisposable
+    {
+        private const int DirectoryEntrySize = 0x310;
+
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private List<string> DirectoryEntries;
+
+        private int CurrentItemIndex;
+
+        public event EventHandler<EventArgs> Disposed;
+
+        public string HostPath { get; private set; }
+
+        public IDirectory(string HostPath, int Flags)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Read          },
+                { 1, GetEntryCount }
+            };
+
+            this.HostPath = HostPath;
+
+            DirectoryEntries = new List<string>();
+
+            if ((Flags & 1) != 0)
+            {
+                DirectoryEntries.AddRange(Directory.GetDirectories(HostPath));
+            }
+
+            if ((Flags & 2) != 0)
+            {
+                DirectoryEntries.AddRange(Directory.GetFiles(HostPath));
+            }
+
+            CurrentItemIndex = 0;
+        }
+
+        public long Read(ServiceCtx Context)
+        {
+            long BufferPosition = Context.Request.ReceiveBuff[0].Position;
+            long BufferLen      = Context.Request.ReceiveBuff[0].Size;
+
+            int MaxReadCount = (int)(BufferLen / DirectoryEntrySize);
+
+            int Count = Math.Min(DirectoryEntries.Count - CurrentItemIndex, MaxReadCount);
+
+            for (int Index = 0; Index < Count; Index++)
+            {
+                long Position = BufferPosition + Index * DirectoryEntrySize;
+
+                WriteDirectoryEntry(Context, Position, DirectoryEntries[CurrentItemIndex++]);
+            }
+
+            Context.ResponseData.Write((long)Count);
+
+            return 0;
+        }
+
+        private void WriteDirectoryEntry(ServiceCtx Context, long Position, string FullPath)
+        {
+            for (int Offset = 0; Offset < 0x300; Offset += 8)
+            {
+                Context.Memory.WriteInt64(Position + Offset, 0);
+            }
+
+            byte[] NameBuffer = Encoding.UTF8.GetBytes(Path.GetFileName(FullPath));
+
+            Context.Memory.WriteBytes(Position, NameBuffer);
+
+            int  Type = 0;
+            long Size = 0;
+
+            if (File.Exists(FullPath))
+            {
+                Type = 1;
+                Size = new FileInfo(FullPath).Length;
+            }
+
+            Context.Memory.WriteInt32(Position + 0x300, 0); //Padding?
+            Context.Memory.WriteInt32(Position + 0x304, Type);
+            Context.Memory.WriteInt64(Position + 0x308, Size);
+        }
+
+        public long GetEntryCount(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((long)DirectoryEntries.Count);
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Disposed?.Invoke(this, EventArgs.Empty);
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/IFile.cs

@@ -0,0 +1,110 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    class IFile : IpcService, IDisposable
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private Stream BaseStream;
+
+        public event EventHandler<EventArgs> Disposed;
+
+        public string HostPath { get; private set; }
+
+        public IFile(Stream BaseStream, string HostPath)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Read    },
+                { 1, Write   },
+                { 2, Flush   },
+                { 3, SetSize },
+                { 4, GetSize }
+            };
+
+            this.BaseStream = BaseStream;
+            this.HostPath   = HostPath;
+        }
+
+        public long Read(ServiceCtx Context)
+        {
+            long Position = Context.Request.ReceiveBuff[0].Position;
+
+            long Zero   = Context.RequestData.ReadInt64();
+            long Offset = Context.RequestData.ReadInt64();
+            long Size   = Context.RequestData.ReadInt64();
+
+            byte[] Data = new byte[Size];
+
+            BaseStream.Seek(Offset, SeekOrigin.Begin);
+
+            int ReadSize = BaseStream.Read(Data, 0, (int)Size);
+
+            Context.Memory.WriteBytes(Position, Data);
+
+            Context.ResponseData.Write((long)ReadSize);
+
+            return 0;
+        }
+
+        public long Write(ServiceCtx Context)
+        {
+            long Position = Context.Request.SendBuff[0].Position;
+
+            long Zero   = Context.RequestData.ReadInt64();
+            long Offset = Context.RequestData.ReadInt64();
+            long Size   = Context.RequestData.ReadInt64();
+
+            byte[] Data = Context.Memory.ReadBytes(Position, Size);
+
+            BaseStream.Seek(Offset, SeekOrigin.Begin);
+            BaseStream.Write(Data, 0, (int)Size);
+
+            return 0;
+        }
+
+        public long Flush(ServiceCtx Context)
+        {
+            BaseStream.Flush();
+
+            return 0;
+        }
+
+        public long SetSize(ServiceCtx Context)
+        {
+            long Size = Context.RequestData.ReadInt64();
+
+            BaseStream.SetLength(Size);
+
+            return 0;
+        }
+
+        public long GetSize(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(BaseStream.Length);
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && BaseStream != null)
+            {
+                BaseStream.Dispose();
+
+                Disposed?.Invoke(this, EventArgs.Empty);
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/IFileSystem.cs

@@ -0,0 +1,399 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+using static Ryujinx.HLE.OsHle.ErrorCode;
+
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    class IFileSystem : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private HashSet<string> OpenPaths;
+
+        private string Path;
+
+        public IFileSystem(string Path)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  CreateFile                 },
+                { 1,  DeleteFile                 },
+                { 2,  CreateDirectory            },
+                { 3,  DeleteDirectory            },
+                { 4,  DeleteDirectoryRecursively },
+                { 5,  RenameFile                 },
+                { 6,  RenameDirectory            },
+                { 7,  GetEntryType               },
+                { 8,  OpenFile                   },
+                { 9,  OpenDirectory              },
+                { 10, Commit                     },
+                { 11, GetFreeSpaceSize           },
+                { 12, GetTotalSpaceSize          },
+                //{ 13, CleanDirectoryRecursively  },
+                //{ 14, GetFileTimeStampRaw        }
+            };
+
+            OpenPaths = new HashSet<string>();
+
+            this.Path = Path;
+        }
+
+        public long CreateFile(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            long Mode = Context.RequestData.ReadInt64();
+            int  Size = Context.RequestData.ReadInt32();
+
+            string FileName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (FileName == null)
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (File.Exists(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyExists);
+            }
+
+            if (IsPathAlreadyInUse(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            using (FileStream NewFile = File.Create(FileName))
+            {
+                NewFile.SetLength(Size);
+            }
+
+            return 0;
+        }
+
+        public long DeleteFile(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            string FileName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (!File.Exists(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (IsPathAlreadyInUse(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            File.Delete(FileName);
+
+            return 0;
+        }
+
+        public long CreateDirectory(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            string DirName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (DirName == null)
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (Directory.Exists(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyExists);
+            }
+
+            if (IsPathAlreadyInUse(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            Directory.CreateDirectory(DirName);
+
+            return 0;
+        }
+
+        public long DeleteDirectory(ServiceCtx Context)
+        {
+            return DeleteDirectory(Context, false);
+        }
+
+        public long DeleteDirectoryRecursively(ServiceCtx Context)
+        {
+            return DeleteDirectory(Context, true);
+        }
+
+        private long DeleteDirectory(ServiceCtx Context, bool Recursive)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            string DirName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (!Directory.Exists(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (IsPathAlreadyInUse(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            Directory.Delete(DirName, Recursive);
+
+            return 0;
+        }
+
+        public long RenameFile(ServiceCtx Context)
+        {
+            string OldName = ReadUtf8String(Context, 0);
+            string NewName = ReadUtf8String(Context, 1);
+
+            string OldFileName = Context.Ns.VFs.GetFullPath(Path, OldName);
+            string NewFileName = Context.Ns.VFs.GetFullPath(Path, NewName);
+
+            if (!File.Exists(OldFileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (File.Exists(NewFileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyExists);
+            }
+
+            if (IsPathAlreadyInUse(OldFileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            File.Move(OldFileName, NewFileName);
+
+            return 0;
+        }
+
+        public long RenameDirectory(ServiceCtx Context)
+        {
+            string OldName = ReadUtf8String(Context, 0);
+            string NewName = ReadUtf8String(Context, 1);
+
+            string OldDirName = Context.Ns.VFs.GetFullPath(Path, OldName);
+            string NewDirName = Context.Ns.VFs.GetFullPath(Path, NewName);
+
+            if (!Directory.Exists(OldDirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (Directory.Exists(NewDirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyExists);
+            }
+
+            if (IsPathAlreadyInUse(OldDirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            Directory.Move(OldDirName, NewDirName);
+
+            return 0;
+        }
+
+        public long GetEntryType(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            string FileName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (File.Exists(FileName))
+            {
+                Context.ResponseData.Write(1);
+            }
+            else if (Directory.Exists(FileName))
+            {
+                Context.ResponseData.Write(0);
+            }
+            else
+            {
+                Context.ResponseData.Write(0);
+
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            return 0;
+        }
+
+        public long OpenFile(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            int FilterFlags = Context.RequestData.ReadInt32();
+
+            string Name = ReadUtf8String(Context);
+
+            string FileName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (!File.Exists(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (IsPathAlreadyInUse(FileName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            FileStream Stream = new FileStream(FileName, FileMode.Open);
+
+            IFile FileInterface = new IFile(Stream, FileName);
+
+            FileInterface.Disposed += RemoveFileInUse;
+
+            lock (OpenPaths)
+            {
+                OpenPaths.Add(FileName);
+            }
+
+            MakeObject(Context, FileInterface);
+
+            return 0;
+        }
+
+        public long OpenDirectory(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            int FilterFlags = Context.RequestData.ReadInt32();
+
+            string Name = ReadUtf8String(Context);
+
+            string DirName = Context.Ns.VFs.GetFullPath(Path, Name);
+
+            if (!Directory.Exists(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathDoesNotExist);
+            }
+
+            if (IsPathAlreadyInUse(DirName))
+            {
+                return MakeError(ErrorModule.Fs, FsErr.PathAlreadyInUse);
+            }
+
+            IDirectory DirInterface = new IDirectory(DirName, FilterFlags);
+
+            DirInterface.Disposed += RemoveDirectoryInUse;
+
+            lock (OpenPaths)
+            {
+                OpenPaths.Add(DirName);
+            }
+
+            MakeObject(Context, DirInterface);
+
+            return 0;
+        }
+
+        public long Commit(ServiceCtx Context)
+        {
+            return 0;
+        }
+
+        public long GetFreeSpaceSize(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            Context.ResponseData.Write(Context.Ns.VFs.GetDrive().AvailableFreeSpace);
+
+            return 0;
+        }
+
+        public long GetTotalSpaceSize(ServiceCtx Context)
+        {
+            long Position = Context.Request.PtrBuff[0].Position;
+
+            string Name = ReadUtf8String(Context);
+
+            Context.ResponseData.Write(Context.Ns.VFs.GetDrive().TotalSize);
+
+            return 0;
+        }
+
+        private bool IsPathAlreadyInUse(string Path)
+        {
+            lock (OpenPaths)
+            {
+                return OpenPaths.Contains(Path);
+            }
+        }
+
+        private void RemoveFileInUse(object sender, EventArgs e)
+        {
+            IFile FileInterface = (IFile)sender;
+
+            lock (OpenPaths)
+            {
+                FileInterface.Disposed -= RemoveFileInUse;
+
+                OpenPaths.Remove(FileInterface.HostPath);
+            }
+        }
+
+        private void RemoveDirectoryInUse(object sender, EventArgs e)
+        {
+            IDirectory DirInterface = (IDirectory)sender;
+
+            lock (OpenPaths)
+            {
+                DirInterface.Disposed -= RemoveDirectoryInUse;
+
+                OpenPaths.Remove(DirInterface.HostPath);
+            }
+        }
+
+        private string ReadUtf8String(ServiceCtx Context, int Index = 0)
+        {
+            long Position = Context.Request.PtrBuff[Index].Position;
+            long Size     = Context.Request.PtrBuff[Index].Size;
+
+            using (MemoryStream MS = new MemoryStream())
+            {
+                while (Size-- > 0)
+                {
+                    byte Value = Context.Memory.ReadByte(Position++);
+
+                    if (Value == 0)
+                    {
+                        break;
+                    }
+
+                    MS.WriteByte(Value);
+                }
+
+                return Encoding.UTF8.GetString(MS.ToArray());
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/IFileSystemProxy.cs

@@ -0,0 +1,74 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    class IFileSystemProxy : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IFileSystemProxy()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 1,    SetCurrentProcess                    },
+                { 18,   OpenSdCardFileSystem                 },
+                { 22,   CreateSaveDataFileSystem             },
+                { 51,   OpenSaveDataFileSystem               },
+                { 200,  OpenDataStorageByCurrentProcess      },
+                { 203,  OpenPatchDataStorageByCurrentProcess },
+                { 1005, GetGlobalAccessLogMode               }
+            };
+        }
+
+        public long SetCurrentProcess(ServiceCtx Context)
+        {
+            return 0;
+        }
+
+        public long OpenSdCardFileSystem(ServiceCtx Context)
+        {
+            MakeObject(Context, new IFileSystem(Context.Ns.VFs.GetSdCardPath()));
+
+            return 0;
+        }
+
+        public long CreateSaveDataFileSystem(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceFs, "Stubbed.");
+
+            return 0;
+        }
+
+        public long OpenSaveDataFileSystem(ServiceCtx Context)
+        {
+            MakeObject(Context, new IFileSystem(Context.Ns.VFs.GetGameSavesPath()));
+
+            return 0;
+        }
+
+        public long OpenDataStorageByCurrentProcess(ServiceCtx Context)
+        {
+            MakeObject(Context, new IStorage(Context.Ns.VFs.RomFs));
+
+            return 0;
+        }
+
+        public long OpenPatchDataStorageByCurrentProcess(ServiceCtx Context)
+        {
+            MakeObject(Context, new IStorage(Context.Ns.VFs.RomFs));
+
+            return 0;
+        }
+
+        public long GetGlobalAccessLogMode(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/FspSrv/IStorage.cs

@@ -0,0 +1,51 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Ryujinx.HLE.OsHle.Services.FspSrv
+{
+    class IStorage : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private Stream BaseStream;
+
+        public IStorage(Stream BaseStream)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Read }
+            };
+
+            this.BaseStream = BaseStream;
+        }
+
+        public long Read(ServiceCtx Context)
+        {
+            long Offset = Context.RequestData.ReadInt64();
+            long Size   = Context.RequestData.ReadInt64();
+
+            if (Context.Request.ReceiveBuff.Count > 0)
+            {
+                IpcBuffDesc BuffDesc = Context.Request.ReceiveBuff[0];
+
+                //Use smaller length to avoid overflows.
+                if (Size > BuffDesc.Size)
+                {
+                    Size = BuffDesc.Size;
+                }
+
+                byte[] Data = new byte[Size];
+
+                BaseStream.Seek(Offset, SeekOrigin.Begin);
+                BaseStream.Read(Data, 0, Data.Length);
+
+                Context.Memory.WriteBytes(BuffDesc.Position, Data);
+            }
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Hid/IActiveVibrationDeviceList.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Hid
+{
+    class IActiveApplicationDeviceList : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IActiveApplicationDeviceList()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, ActivateVibrationDevice }
+            };
+        }
+
+        public long ActivateVibrationDevice(ServiceCtx Context)
+        {
+            int VibrationDeviceHandle = Context.RequestData.ReadInt32();
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Hid/IAppletResource.cs

@@ -0,0 +1,34 @@
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Hid
+{
+    class IAppletResource : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private HSharedMem HidSharedMem;
+
+        public IAppletResource(HSharedMem HidSharedMem)
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, GetSharedMemoryHandle }
+            };
+
+            this.HidSharedMem = HidSharedMem;
+        }
+
+        public long GetSharedMemoryHandle(ServiceCtx Context)
+        {
+            int Handle = Context.Process.HandleTable.OpenHandle(HidSharedMem);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Hid/IHidServer.cs

@@ -0,0 +1,270 @@
+using Ryujinx.HLE.Input;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Hid
+{
+    class IHidServer : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IHidServer()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,   CreateAppletResource                    },
+                { 1,   ActivateDebugPad                        },
+                { 11,  ActivateTouchScreen                     },
+                { 21,  ActivateMouse                           },
+                { 31,  ActivateKeyboard                        },
+                { 66,  StartSixAxisSensor                      },
+                { 79,  SetGyroscopeZeroDriftMode               },
+                { 100, SetSupportedNpadStyleSet                },
+                { 101, GetSupportedNpadStyleSet                },
+                { 102, SetSupportedNpadIdType                  },
+                { 103, ActivateNpad                            },
+                { 108, GetPlayerLedPattern                     },
+                { 120, SetNpadJoyHoldType                      },
+                { 121, GetNpadJoyHoldType                      },
+                { 122, SetNpadJoyAssignmentModeSingleByDefault },
+                { 123, SetNpadJoyAssignmentModeSingle          },
+                { 124, SetNpadJoyAssignmentModeDual            },
+                { 125, MergeSingleJoyAsDualJoy                 },
+                { 128, SetNpadHandheldActivationMode           },
+                { 200, GetVibrationDeviceInfo                  },
+                { 201, SendVibrationValue                      },
+                { 203, CreateActiveVibrationDeviceList         },
+                { 206, SendVibrationValues                     }
+            };
+        }
+
+        public long CreateAppletResource(ServiceCtx Context)
+        {
+            MakeObject(Context, new IAppletResource(Context.Ns.Os.HidSharedMem));
+
+            return 0;
+        }
+
+        public long ActivateDebugPad(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ActivateTouchScreen(ServiceCtx Context)
+        {
+            long AppletResourceUserId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ActivateMouse(ServiceCtx Context)
+        {
+            long AppletResourceUserId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ActivateKeyboard(ServiceCtx Context)
+        {
+            long AppletResourceUserId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long StartSixAxisSensor(ServiceCtx Context)
+        {
+            int Handle = Context.RequestData.ReadInt32();
+
+            long AppletResourceUserId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetGyroscopeZeroDriftMode(ServiceCtx Context)
+        {
+            int  Handle               = Context.RequestData.ReadInt32();
+            int  Unknown              = Context.RequestData.ReadInt32();
+            long AppletResourceUserId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetSupportedNpadStyleSet(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetSupportedNpadStyleSet(ServiceCtx Context)
+        {
+            long Unknown0 = Context.RequestData.ReadInt64();
+            long Unknown8 = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetSupportedNpadIdType(ServiceCtx Context)
+        {
+            long Unknown = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long ActivateNpad(ServiceCtx Context)
+        {
+            long Unknown = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetPlayerLedPattern(ServiceCtx Context)
+        {
+            long Unknown = Context.RequestData.ReadInt32();
+
+            Context.ResponseData.Write(0L);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetNpadJoyHoldType(ServiceCtx Context)
+        {
+            long Unknown0 = Context.RequestData.ReadInt64();
+            long Unknown8 = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetNpadJoyHoldType(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0L);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetNpadJoyAssignmentModeSingleByDefault(ServiceCtx Context)
+        {
+            HidControllerId HidControllerId = (HidControllerId)Context.RequestData.ReadInt32();
+
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetNpadJoyAssignmentModeSingle(ServiceCtx Context)
+        {
+            HidControllerId HidControllerId = (HidControllerId)Context.RequestData.ReadInt32();
+
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+            long NpadJoyDeviceType    = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetNpadJoyAssignmentModeDual(ServiceCtx Context)
+        {
+            HidControllerId HidControllerId = (HidControllerId)Context.RequestData.ReadInt32();
+
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long MergeSingleJoyAsDualJoy(ServiceCtx Context)
+        {
+            long Unknown0             = Context.RequestData.ReadInt32();
+            long Unknown8             = Context.RequestData.ReadInt32();
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetNpadHandheldActivationMode(ServiceCtx Context)
+        {
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+            long Unknown              = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetVibrationDeviceInfo(ServiceCtx Context)
+        {
+            int VibrationDeviceHandle = Context.RequestData.ReadInt32();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            Context.ResponseData.Write(0L); //VibrationDeviceInfoForIpc
+
+            return 0;
+        }
+
+        public long SendVibrationValue(ServiceCtx Context)
+        {
+            int VibrationDeviceHandle = Context.RequestData.ReadInt32();
+
+            int VibrationValue1 = Context.RequestData.ReadInt32();
+            int VibrationValue2 = Context.RequestData.ReadInt32();
+            int VibrationValue3 = Context.RequestData.ReadInt32();
+            int VibrationValue4 = Context.RequestData.ReadInt32();
+
+            long AppletUserResourceId = Context.RequestData.ReadInt64();
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+
+        public long CreateActiveVibrationDeviceList(ServiceCtx Context)
+        {
+            MakeObject(Context, new IActiveApplicationDeviceList());
+
+            return 0;
+        }
+
+        public long SendVibrationValues(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceHid, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/IIpcService.cs

@@ -0,0 +1,10 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services
+{
+    interface IIpcService
+    {
+        IReadOnlyDictionary<int, ServiceProcessRequest> Commands { get; }
+    }
+}

Ryujinx.HLE/OsHle/Services/IpcService.cs

@@ -0,0 +1,154 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Ryujinx.HLE.OsHle.Services
+{
+    abstract class IpcService : IIpcService
+    {
+        public abstract IReadOnlyDictionary<int, ServiceProcessRequest> Commands { get; }
+
+        private IdDictionary DomainObjects;
+
+        private int SelfId;
+
+        private bool IsDomain;
+
+        public IpcService()
+        {
+            DomainObjects = new IdDictionary();
+
+            SelfId = -1;
+        }
+
+        public int ConvertToDomain()
+        {
+            if (SelfId == -1)
+            {
+                SelfId = DomainObjects.Add(this);
+            }
+
+            IsDomain = true;
+
+            return SelfId;
+        }
+
+        public void ConvertToSession()
+        {
+            IsDomain = false;
+        }
+
+        public void CallMethod(ServiceCtx Context)
+        {
+            IIpcService Service = this;
+
+            if (IsDomain)
+            {
+                int DomainWord0 = Context.RequestData.ReadInt32();
+                int DomainObjId = Context.RequestData.ReadInt32();
+
+                long Padding = Context.RequestData.ReadInt64();
+
+                int DomainCmd = DomainWord0 & 0xff;
+
+                if (DomainCmd == 1)
+                {
+                    Service = GetObject(DomainObjId);
+
+                    Context.ResponseData.Write(0L);
+                    Context.ResponseData.Write(0L);
+                }
+                else if (DomainCmd == 2)
+                {
+                    Delete(DomainObjId);
+
+                    Context.ResponseData.Write(0L);
+
+                    return;
+                }
+                else
+                {
+                    throw new NotImplementedException($"Domain command: {DomainCmd}");
+                }
+            }
+
+            long SfciMagic =      Context.RequestData.ReadInt64();
+            int  CommandId = (int)Context.RequestData.ReadInt64();
+
+            if (Service.Commands.TryGetValue(CommandId, out ServiceProcessRequest ProcessRequest))
+            {
+                Context.ResponseData.BaseStream.Seek(IsDomain ? 0x20 : 0x10, SeekOrigin.Begin);
+
+                Context.Ns.Log.PrintDebug(LogClass.KernelIpc, $"{Service.GetType().Name}: {ProcessRequest.Method.Name}");
+
+                long Result = ProcessRequest(Context);
+
+                if (IsDomain)
+                {
+                    foreach (int Id in Context.Response.ResponseObjIds)
+                    {
+                        Context.ResponseData.Write(Id);
+                    }
+
+                    Context.ResponseData.BaseStream.Seek(0, SeekOrigin.Begin);
+
+                    Context.ResponseData.Write(Context.Response.ResponseObjIds.Count);
+                }
+
+                Context.ResponseData.BaseStream.Seek(IsDomain ? 0x10 : 0, SeekOrigin.Begin);
+
+                Context.ResponseData.Write(IpcMagic.Sfco);
+                Context.ResponseData.Write(Result);
+            }
+            else
+            {
+                string DbgMessage = $"{Context.Session.ServiceName} {Service.GetType().Name}: {CommandId}";
+
+                throw new NotImplementedException(DbgMessage);
+            }
+        }
+
+        protected static void MakeObject(ServiceCtx Context, IpcService Obj)
+        {
+            IpcService Service = Context.Session.Service;
+
+            if (Service.IsDomain)
+            {
+                Context.Response.ResponseObjIds.Add(Service.Add(Obj));
+            }
+            else
+            {
+                KSession Session = new KSession(Obj, Context.Session.ServiceName);
+
+                int Handle = Context.Process.HandleTable.OpenHandle(Session);
+
+                Context.Response.HandleDesc = IpcHandleDesc.MakeMove(Handle);
+            }
+        }
+
+        private int Add(IIpcService Obj)
+        {
+            return DomainObjects.Add(Obj);
+        }
+
+        private bool Delete(int Id)
+        {
+            object Obj = DomainObjects.Delete(Id);
+
+            if (Obj is IDisposable DisposableObj)
+            {
+                DisposableObj.Dispose();
+            }
+
+            return Obj != null;
+        }
+
+        private IIpcService GetObject(int Id)
+        {
+            return DomainObjects.GetData<IIpcService>(Id);
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Lm/ILogService.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Lm
+{
+    class ILogService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ILogService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Initialize }
+            };
+        }
+
+        public long Initialize(ServiceCtx Context)
+        {
+            MakeObject(Context, new ILogger());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Lm/ILogger.cs

@@ -0,0 +1,86 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Ryujinx.HLE.OsHle.Services.Lm
+{
+    class ILogger : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ILogger()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, Log }
+            };
+        }
+
+        public long Log(ServiceCtx Context)
+        {
+            byte[] LogBuffer = Context.Memory.ReadBytes(
+                Context.Request.PtrBuff[0].Position,
+                Context.Request.PtrBuff[0].Size);
+
+            using (MemoryStream MS = new MemoryStream(LogBuffer))
+            {
+                BinaryReader Reader = new BinaryReader(MS);
+
+                long  Pid           = Reader.ReadInt64();
+                long  ThreadContext = Reader.ReadInt64();
+                short Flags         = Reader.ReadInt16();
+                byte  Level         = Reader.ReadByte();
+                byte  Verbosity     = Reader.ReadByte();
+                int   PayloadLength = Reader.ReadInt32();
+
+                StringBuilder SB = new StringBuilder();
+
+                SB.AppendLine("Guest log:");
+
+                while (MS.Position < MS.Length)
+                {
+                    byte Type = Reader.ReadByte();
+                    byte Size = Reader.ReadByte();
+
+                    LmLogField Field = (LmLogField)Type;
+
+                    string FieldStr = string.Empty;
+
+                    if (Field == LmLogField.Skip)
+                    {
+                        Reader.ReadByte();
+
+                        continue;
+                    }
+                    else if (Field == LmLogField.Line)
+                    {
+                        FieldStr = Field + ": " + Reader.ReadInt32();
+                    }
+                    else
+                    {
+                        FieldStr = Field + ": \"" + Encoding.UTF8.GetString(Reader.ReadBytes(Size)) + "\"";
+                    }
+
+                    SB.AppendLine(" " + FieldStr);
+                }
+
+                string Text = SB.ToString();
+
+                switch((LmLogLevel)Level)
+                {
+                    case LmLogLevel.Trace:    Context.Ns.Log.PrintDebug  (LogClass.ServiceLm, Text); break;
+                    case LmLogLevel.Info:     Context.Ns.Log.PrintInfo   (LogClass.ServiceLm, Text); break;
+                    case LmLogLevel.Warning:  Context.Ns.Log.PrintWarning(LogClass.ServiceLm, Text); break;
+                    case LmLogLevel.Error:    Context.Ns.Log.PrintError  (LogClass.ServiceLm, Text); break;
+                    case LmLogLevel.Critical: Context.Ns.Log.PrintError  (LogClass.ServiceLm, Text); break;
+                }
+            }
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Lm/LmLogField.cs

@@ -0,0 +1,13 @@
+namespace Ryujinx.HLE.OsHle.Services.Lm
+{
+    enum LmLogField
+    {
+        Skip     = 1,
+        Message  = 2,
+        Line     = 3,
+        Filename = 4,
+        Function = 5,
+        Module   = 6,
+        Thread   = 7
+    }
+}

Ryujinx.HLE/OsHle/Services/Lm/LmLogLevel.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.OsHle.Services.Lm
+{
+    enum LmLogLevel
+    {
+        Trace,
+        Info,
+        Warning,
+        Error,
+        Critical
+    }
+}

Ryujinx.HLE/OsHle/Services/Mm/IRequest.cs

@@ -0,0 +1,46 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Mm
+{
+    class IRequest : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IRequest()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 4, Initialize },
+                { 6, SetAndWait },
+                { 7, Get        }
+            };
+        }
+
+        public long Initialize(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceMm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetAndWait(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceMm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long Get(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceMm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nfp/DeviceState.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.OsHle.Services.Nfp
+{
+    enum DeviceState
+    {
+        Initialized = 0
+    }
+}

Ryujinx.HLE/OsHle/Services/Nfp/IUser.cs

@@ -0,0 +1,114 @@
+using Ryujinx.HLE.Input;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nfp
+{
+    class IUser : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private const HidControllerId NpadId = HidControllerId.CONTROLLER_PLAYER_1;
+
+        private State State = State.NonInitialized;
+
+        private DeviceState DeviceState = DeviceState.Initialized;
+
+        private KEvent ActivateEvent;
+
+        private KEvent DeactivateEvent;
+
+        private KEvent AvailabilityChangeEvent;
+
+        public IUser()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  Initialize                    },
+                { 17, AttachActivateEvent           },
+                { 18, AttachDeactivateEvent         },
+                { 19, GetState                      },
+                { 20, GetDeviceState                },
+                { 21, GetNpadId                     },
+                { 23, AttachAvailabilityChangeEvent }
+            };
+
+            ActivateEvent           = new KEvent();
+            DeactivateEvent         = new KEvent();
+            AvailabilityChangeEvent = new KEvent();
+        }
+
+        public long Initialize(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            State = State.Initialized;
+
+            return 0;
+        }
+
+        public long AttachActivateEvent(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            int Handle = Context.Process.HandleTable.OpenHandle(ActivateEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);;
+
+            return 0;
+        }
+
+        public long AttachDeactivateEvent(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            int Handle = Context.Process.HandleTable.OpenHandle(DeactivateEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+
+        public long GetState(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((int)State);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetDeviceState(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((int)DeviceState);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetNpadId(ServiceCtx Context)
+        {
+            Context.ResponseData.Write((int)NpadId);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            return 0;
+        }
+
+        public long AttachAvailabilityChangeEvent(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNfp, "Stubbed.");
+
+            int Handle = Context.Process.HandleTable.OpenHandle(AvailabilityChangeEvent);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nfp/IUserManager.cs

@@ -0,0 +1,27 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nfp
+{
+    class IUserManager : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IUserManager()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0, GetUserInterface }
+            };
+        }
+
+        public long GetUserInterface(ServiceCtx Context)
+        {
+            MakeObject(Context, new IUser());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nfp/State.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nfp
+{
+    enum State
+    {
+        NonInitialized = 0,
+        Initialized = 1
+    }
+}

Ryujinx.HLE/OsHle/Services/Nifm/IGeneralService.cs

@@ -0,0 +1,33 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nifm
+{
+    class IGeneralService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IGeneralService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 4, CreateRequest }
+            };
+        }
+
+        //CreateRequest(i32)
+        public long CreateRequest(ServiceCtx Context)
+        {
+            int Unknown = Context.RequestData.ReadInt32();
+
+            MakeObject(Context, new IRequest());
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nifm/IRequest.cs

@@ -0,0 +1,93 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nifm
+{
+    class IRequest : IpcService, IDisposable
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private KEvent Event;
+
+        public IRequest()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  GetRequestState                 },
+                { 1,  GetResult                       },
+                { 2,  GetSystemEventReadableHandles   },
+                { 3,  Cancel                          },
+                { 4,  Submit                          },
+                { 11, SetConnectionConfirmationOption }
+            };
+
+            Event = new KEvent();
+        }
+
+        public long GetRequestState(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long GetResult(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+
+        //GetSystemEventReadableHandles() -> (KObject, KObject)
+        public long GetSystemEventReadableHandles(ServiceCtx Context)
+        {
+            //FIXME: Is this supposed to return 2 events?
+            int Handle = Context.Process.HandleTable.OpenHandle(Event);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeMove(Handle);
+
+            return 0;
+        }
+
+        public long Cancel(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long Submit(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+
+        public long SetConnectionConfirmationOption(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
+
+            return 0;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                Event.Dispose();
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nifm/IStaticService.cs

@@ -0,0 +1,35 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nifm
+{
+    class IStaticService : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IStaticService()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 4, CreateGeneralServiceOld },
+                { 5, CreateGeneralService    }
+            };
+        }
+
+        public long CreateGeneralServiceOld(ServiceCtx Context)
+        {
+            MakeObject(Context, new IGeneralService());
+
+            return 0;
+        }
+
+        public long CreateGeneralService(ServiceCtx Context)
+        {
+            MakeObject(Context, new IGeneralService());
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Ns/IAddOnContentManager.cs

@@ -0,0 +1,42 @@
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Ns
+{
+    class IAddOnContentManager : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IAddOnContentManager()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 2, CountAddOnContent },
+                { 3, ListAddOnContent  }
+            };
+        }
+
+        public static long CountAddOnContent(ServiceCtx Context)
+        {
+            Context.ResponseData.Write(0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNs, "Stubbed.");
+
+            return 0;
+        }
+
+        public static long ListAddOnContent(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNs, "Stubbed.");
+
+            //TODO: This is supposed to write a u32 array aswell.
+            //It's unknown what it contains.
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Ns/IServiceGetterInterface.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Ns
+{
+    class IServiceGetterInterface : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IServiceGetterInterface()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Ns/ISystemUpdateInterface.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Ns
+{
+    class ISystemUpdateInterface : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public ISystemUpdateInterface()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Ns/IVulnerabilityManagerInterface.cs

@@ -0,0 +1,20 @@
+using Ryujinx.HLE.OsHle.Ipc;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Ns
+{
+    class IVulnerabilityManagerInterface : IpcService
+    {
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        public IVulnerabilityManagerInterface()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                //...
+            };
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/INvDrvServices.cs

@@ -0,0 +1,228 @@
+using ChocolArm64.Memory;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Handles;
+using Ryujinx.HLE.OsHle.Ipc;
+using Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS;
+using Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu;
+using Ryujinx.HLE.OsHle.Services.Nv.NvHostChannel;
+using Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl;
+using Ryujinx.HLE.OsHle.Services.Nv.NvMap;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv
+{
+    class INvDrvServices : IpcService, IDisposable
+    {
+        private delegate int IoctlProcessor(ServiceCtx Context, int Cmd);
+
+        private Dictionary<int, ServiceProcessRequest> m_Commands;
+
+        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
+
+        private static Dictionary<string, IoctlProcessor> IoctlProcessors =
+                   new Dictionary<string, IoctlProcessor>()
+        {
+            { "/dev/nvhost-as-gpu",   ProcessIoctlNvGpuAS       },
+            { "/dev/nvhost-ctrl",     ProcessIoctlNvHostCtrl    },
+            { "/dev/nvhost-ctrl-gpu", ProcessIoctlNvGpuGpu      },
+            { "/dev/nvhost-gpu",      ProcessIoctlNvHostChannel },
+            { "/dev/nvmap",           ProcessIoctlNvMap         }
+        };
+
+        public static GlobalStateTable Fds { get; private set; }
+
+        private KEvent Event;
+
+        public INvDrvServices()
+        {
+            m_Commands = new Dictionary<int, ServiceProcessRequest>()
+            {
+                { 0,  Open             },
+                { 1,  Ioctl            },
+                { 2,  Close            },
+                { 3,  Initialize       },
+                { 4,  QueryEvent       },
+                { 8,  SetClientPid     },
+                { 13, FinishInitialize }
+            };
+
+            Event = new KEvent();
+        }
+
+        static INvDrvServices()
+        {
+            Fds = new GlobalStateTable();
+        }
+
+        public long Open(ServiceCtx Context)
+        {
+            long NamePtr = Context.Request.SendBuff[0].Position;
+
+            string Name = AMemoryHelper.ReadAsciiString(Context.Memory, NamePtr);
+
+            int Fd = Fds.Add(Context.Process, new NvFd(Name));
+
+            Context.ResponseData.Write(Fd);
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        public long Ioctl(ServiceCtx Context)
+        {
+            int Fd  = Context.RequestData.ReadInt32();
+            int Cmd = Context.RequestData.ReadInt32();
+
+            NvFd FdData = Fds.GetData<NvFd>(Context.Process, Fd);
+
+            int Result;
+
+            if (IoctlProcessors.TryGetValue(FdData.Name, out IoctlProcessor Process))
+            {
+                Result = Process(Context, Cmd);
+            }
+            else
+            {
+                throw new NotImplementedException($"{FdData.Name} {Cmd:x4}");
+            }
+
+            //TODO: Verify if the error codes needs to be translated.
+            Context.ResponseData.Write(Result);
+
+            return 0;
+        }
+
+        public long Close(ServiceCtx Context)
+        {
+            int Fd = Context.RequestData.ReadInt32();
+
+            Fds.Delete(Context.Process, Fd);
+
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        public long Initialize(ServiceCtx Context)
+        {
+            long TransferMemSize   = Context.RequestData.ReadInt64();
+            int  TransferMemHandle = Context.Request.HandleDesc.ToCopy[0];
+
+            NvMapIoctl.InitializeNvMap(Context);
+
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        public long QueryEvent(ServiceCtx Context)
+        {
+            int Fd      = Context.RequestData.ReadInt32();
+            int EventId = Context.RequestData.ReadInt32();
+
+            //TODO: Use Fd/EventId, different channels have different events.
+            int Handle = Context.Process.HandleTable.OpenHandle(Event);
+
+            Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
+
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        public long SetClientPid(ServiceCtx Context)
+        {
+            long Pid = Context.RequestData.ReadInt64();
+
+            Context.ResponseData.Write(0);
+
+            return 0;
+        }
+
+        public long FinishInitialize(ServiceCtx Context)
+        {
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return 0;
+        }
+
+        private static int ProcessIoctlNvGpuAS(ServiceCtx Context, int Cmd)
+        {
+            return ProcessIoctl(Context, Cmd, NvGpuASIoctl.ProcessIoctl);
+        }
+
+        private static int ProcessIoctlNvHostCtrl(ServiceCtx Context, int Cmd)
+        {
+            return ProcessIoctl(Context, Cmd, NvHostCtrlIoctl.ProcessIoctl);
+        }
+
+        private static int ProcessIoctlNvGpuGpu(ServiceCtx Context, int Cmd)
+        {
+            return ProcessIoctl(Context, Cmd, NvGpuGpuIoctl.ProcessIoctl);
+        }
+
+        private static int ProcessIoctlNvHostChannel(ServiceCtx Context, int Cmd)
+        {
+            return ProcessIoctl(Context, Cmd, NvHostChannelIoctl.ProcessIoctl);
+        }
+
+        private static int ProcessIoctlNvMap(ServiceCtx Context, int Cmd)
+        {
+            return ProcessIoctl(Context, Cmd, NvMapIoctl.ProcessIoctl);
+        }
+
+        private static int ProcessIoctl(ServiceCtx Context, int Cmd, IoctlProcessor Processor)
+        {
+            if (CmdIn(Cmd) && Context.Request.GetBufferType0x21().Position == 0)
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceNv, "Input buffer is null!");
+
+                return NvResult.InvalidInput;
+            }
+
+            if (CmdOut(Cmd) && Context.Request.GetBufferType0x22().Position == 0)
+            {
+                Context.Ns.Log.PrintError(LogClass.ServiceNv, "Output buffer is null!");
+
+                return NvResult.InvalidInput;
+            }
+
+            return Processor(Context, Cmd);
+        }
+
+        private static bool CmdIn(int Cmd)
+        {
+            return ((Cmd >> 30) & 1) != 0;
+        }
+
+        private static bool CmdOut(int Cmd)
+        {
+            return ((Cmd >> 31) & 1) != 0;
+        }
+
+        public static void UnloadProcess(Process Process)
+        {
+            Fds.DeleteProcess(Process);
+
+            NvGpuASIoctl.UnloadProcess(Process);
+
+            NvHostCtrlIoctl.UnloadProcess(Process);
+
+            NvMapIoctl.UnloadProcess(Process);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                Event.Dispose();
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvFd.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv
+{
+    class NvFd
+    {
+        public string Name { get; private set; }
+
+        public NvFd(string Name)
+        {
+            this.Name = Name;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuAS/NvGpuASAllocSpace.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS
+{
+    struct NvGpuASAllocSpace
+    {
+        public int  Pages;
+        public int  PageSize;
+        public int  Flags;
+        public int  Padding;
+        public long Offset;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuAS/NvGpuASIoctl.cs

@@ -0,0 +1,243 @@
+using ChocolArm64.Memory;
+using Ryujinx.HLE.Gpu;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Services.Nv.NvMap;
+using System;
+using System.Collections.Concurrent;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS
+{
+    class NvGpuASIoctl
+    {
+        private const int FlagFixedOffset = 1;
+
+        private static ConcurrentDictionary<Process, NvGpuVmm> Vmms;
+
+        static NvGpuASIoctl()
+        {
+            Vmms = new ConcurrentDictionary<Process, NvGpuVmm>();
+        }
+
+        public static int ProcessIoctl(ServiceCtx Context, int Cmd)
+        {
+            switch (Cmd & 0xffff)
+            {
+                case 0x4101: return BindChannel (Context);
+                case 0x4102: return AllocSpace  (Context);
+                case 0x4103: return FreeSpace   (Context);
+                case 0x4105: return UnmapBuffer (Context);
+                case 0x4106: return MapBufferEx (Context);
+                case 0x4108: return GetVaRegions(Context);
+                case 0x4109: return InitializeEx(Context);
+                case 0x4114: return Remap       (Context);
+            }
+
+            throw new NotImplementedException(Cmd.ToString("x8"));
+        }
+
+        private static int BindChannel(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int AllocSpace(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuASAllocSpace Args = AMemoryHelper.Read<NvGpuASAllocSpace>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = GetVmm(Context);
+
+            ulong Size = (ulong)Args.Pages *
+                         (ulong)Args.PageSize;
+
+            if ((Args.Flags & FlagFixedOffset) != 0)
+            {
+                Args.Offset = Vmm.Reserve(Args.Offset, (long)Size, 1);
+            }
+            else
+            {
+                Args.Offset = Vmm.Reserve((long)Size, 1);
+            }
+
+            int Result = NvResult.Success;
+
+            if (Args.Offset < 0)
+            {
+                Args.Offset = 0;
+
+                Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"No memory to allocate size {Size:x16}!");
+
+                Result = NvResult.OutOfMemory;
+            }
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return Result;
+        }
+
+        private static int FreeSpace(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuASAllocSpace Args = AMemoryHelper.Read<NvGpuASAllocSpace>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = GetVmm(Context);
+
+            ulong Size = (ulong)Args.Pages *
+                         (ulong)Args.PageSize;
+
+            Vmm.Free(Args.Offset, (long)Size);
+
+            return NvResult.Success;
+        }
+
+        private static int UnmapBuffer(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuASUnmapBuffer Args = AMemoryHelper.Read<NvGpuASUnmapBuffer>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = GetVmm(Context);
+
+            if (!Vmm.Unmap(Args.Offset))
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"Invalid buffer offset {Args.Offset:x16}!");
+            }
+
+            return NvResult.Success;
+        }
+
+        private static int MapBufferEx(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuASMapBufferEx Args = AMemoryHelper.Read<NvGpuASMapBufferEx>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = GetVmm(Context);
+
+            NvMapHandle Map = NvMapIoctl.GetNvMapWithFb(Context, Args.NvMapHandle);
+
+            if (Map == null)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{Args.NvMapHandle:x8}!");
+
+                return NvResult.InvalidInput;
+            }
+
+            long PA = Map.Address + Args.BufferOffset;
+
+            long Size = Args.MappingSize;
+
+            if (Size == 0)
+            {
+                Size = (uint)Map.Size;
+            }
+
+            int Result = NvResult.Success;
+
+            //Note: When the fixed offset flag is not set,
+            //the Offset field holds the alignment size instead.
+            if ((Args.Flags & FlagFixedOffset) != 0)
+            {
+                long MapEnd = Args.Offset + Args.MappingSize;
+
+                if ((ulong)MapEnd <= (ulong)Args.Offset)
+                {
+                    Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"Offset 0x{Args.Offset:x16} and size 0x{Args.MappingSize:x16} results in a overflow!");
+
+                    return NvResult.InvalidInput;
+                }
+
+                if ((Args.Offset & NvGpuVmm.PageMask) != 0)
+                {
+                    Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"Offset 0x{Args.Offset:x16} is not page aligned!");
+
+                    return NvResult.InvalidInput;
+                }
+
+                Args.Offset = Vmm.Map(PA, Args.Offset, Size);
+            }
+            else
+            {
+                Args.Offset = Vmm.Map(PA, Size);
+
+                if (Args.Offset < 0)
+                {
+                    Args.Offset = 0;
+
+                    Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"No memory to map size {Args.MappingSize:x16}!");
+
+                    Result = NvResult.InvalidInput;
+                }
+            }
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return Result;
+        }
+
+        private static int GetVaRegions(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int InitializeEx(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int Remap(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+
+            NvGpuASRemap Args = AMemoryHelper.Read<NvGpuASRemap>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = GetVmm(Context);
+
+            NvMapHandle Map = NvMapIoctl.GetNvMapWithFb(Context, Args.NvMapHandle);
+
+            if (Map == null)
+            {
+                Context.Ns.Log.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{Args.NvMapHandle:x8}!");
+
+                return NvResult.InvalidInput;
+            }
+
+            //FIXME: This is most likely wrong...
+            Vmm.Map(Map.Address, (long)(uint)Args.Offset << 16,
+                                 (long)(uint)Args.Pages  << 16);
+
+            return NvResult.Success;
+        }
+
+        public static NvGpuVmm GetVmm(ServiceCtx Context)
+        {
+            return Vmms.GetOrAdd(Context.Process, (Key) => new NvGpuVmm(Context.Memory));
+        }
+
+        public static void UnloadProcess(Process Process)
+        {
+            Vmms.TryRemove(Process, out _);
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuAS/NvGpuASMapBufferEx.cs

@@ -0,0 +1,13 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS
+{
+    struct NvGpuASMapBufferEx
+    {
+        public int  Flags;
+        public int  Kind;
+        public int  NvMapHandle;
+        public int  PageSize;
+        public long BufferOffset;
+        public long MappingSize;
+        public long Offset;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuAS/NvGpuASRemap.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS
+{
+    struct NvGpuASRemap
+    {
+        public short Flags;
+        public short Kind;
+        public int   NvMapHandle;
+        public int   Padding;
+        public int   Offset;
+        public int   Pages;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuAS/NvGpuASUnmapBuffer.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS
+{
+    struct NvGpuASUnmapBuffer
+    {
+        public long Offset;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuGetActiveSlotMask.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    struct NvGpuGpuGetActiveSlotMask
+    {
+        public int Slot;
+        public int Mask;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuGetCharacteristics.cs

@@ -0,0 +1,43 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    struct NvGpuGpuGetCharacteristics
+    {
+        public long BufferSize;
+        public long BufferAddress;
+        public int  Arch;
+        public int  Impl;
+        public int  Rev;
+        public int  NumGpc;
+        public long L2CacheSize;
+        public long OnBoardVideoMemorySize;
+        public int  NumTpcPerGpc;
+        public int  BusType;
+        public int  BigPageSize;
+        public int  CompressionPageSize;
+        public int  PdeCoverageBitCount;
+        public int  AvailableBigPageSizes;
+        public int  GpcMask;
+        public int  SmArchSmVersion;
+        public int  SmArchSpaVersion;
+        public int  SmArchWarpCount;
+        public int  GpuVaBitCount;
+        public int  Reserved;
+        public long Flags;
+        public int  TwodClass;
+        public int  ThreedClass;
+        public int  ComputeClass;
+        public int  GpfifoClass;
+        public int  InlineToMemoryClass;
+        public int  DmaCopyClass;
+        public int  MaxFbpsCount;
+        public int  FbpEnMask;
+        public int  MaxLtcPerFbp;
+        public int  MaxLtsPerLtc;
+        public int  MaxTexPerTpc;
+        public int  MaxGpcCount;
+        public int  RopL2EnMask0;
+        public int  RopL2EnMask1;
+        public long ChipName;
+        public long GrCompbitStoreBaseHw;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuGetTpcMasks.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    struct NvGpuGpuGetTpcMasks
+    {
+        public int  MaskBufferSize;
+        public int  Reserved;
+        public long MaskBufferAddress;
+        public int  TpcMask;
+        public int  Padding;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuIoctl.cs

@@ -0,0 +1,187 @@
+using ChocolArm64.Memory;
+using Ryujinx.HLE.Logging;
+using System;
+using System.Diagnostics;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    class NvGpuGpuIoctl
+    {
+        private static Stopwatch PTimer;
+
+        private static double TicksToNs;
+
+        static NvGpuGpuIoctl()
+        {
+            PTimer = new Stopwatch();
+
+            PTimer.Start();
+
+            TicksToNs = (1.0 / Stopwatch.Frequency) * 1_000_000_000;
+        }
+
+        public static int ProcessIoctl(ServiceCtx Context, int Cmd)
+        {
+            switch (Cmd & 0xffff)
+            {
+                case 0x4701: return ZcullGetCtxSize   (Context);
+                case 0x4702: return ZcullGetInfo      (Context);
+                case 0x4703: return ZbcSetTable       (Context);
+                case 0x4705: return GetCharacteristics(Context);
+                case 0x4706: return GetTpcMasks       (Context);
+                case 0x4714: return GetActiveSlotMask (Context);
+                case 0x471c: return GetGpuTime        (Context);
+            }
+
+            throw new NotImplementedException(Cmd.ToString("x8"));
+        }
+
+        private static int ZcullGetCtxSize(ServiceCtx Context)
+        {
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuGpuZcullGetCtxSize Args = new NvGpuGpuZcullGetCtxSize();
+
+            Args.Size = 1;
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int ZcullGetInfo(ServiceCtx Context)
+        {
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuGpuZcullGetInfo Args = new NvGpuGpuZcullGetInfo();
+
+            Args.WidthAlignPixels           = 0x20;
+            Args.HeightAlignPixels          = 0x20;
+            Args.PixelSquaresByAliquots     = 0x400;
+            Args.AliquotTotal               = 0x800;
+            Args.RegionByteMultiplier       = 0x20;
+            Args.RegionHeaderSize           = 0x20;
+            Args.SubregionHeaderSize        = 0xc0;
+            Args.SubregionWidthAlignPixels  = 0x20;
+            Args.SubregionHeightAlignPixels = 0x40;
+            Args.SubregionCount             = 0x10;
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int ZbcSetTable(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int GetCharacteristics(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuGpuGetCharacteristics Args = AMemoryHelper.Read<NvGpuGpuGetCharacteristics>(Context.Memory, InputPosition);
+
+            Args.BufferSize = 0xa0;
+
+            Args.Arch                   = 0x120;
+            Args.Impl                   = 0xb;
+            Args.Rev                    = 0xa1;
+            Args.NumGpc                 = 0x1;
+            Args.L2CacheSize            = 0x40000;
+            Args.OnBoardVideoMemorySize = 0x0;
+            Args.NumTpcPerGpc           = 0x2;
+            Args.BusType                = 0x20;
+            Args.BigPageSize            = 0x20000;
+            Args.CompressionPageSize    = 0x20000;
+            Args.PdeCoverageBitCount    = 0x1b;
+            Args.AvailableBigPageSizes  = 0x30000;
+            Args.GpcMask                = 0x1;
+            Args.SmArchSmVersion        = 0x503;
+            Args.SmArchSpaVersion       = 0x503;
+            Args.SmArchWarpCount        = 0x80;
+            Args.GpuVaBitCount          = 0x28;
+            Args.Reserved               = 0x0;
+            Args.Flags                  = 0x55;
+            Args.TwodClass              = 0x902d;
+            Args.ThreedClass            = 0xb197;
+            Args.ComputeClass           = 0xb1c0;
+            Args.GpfifoClass            = 0xb06f;
+            Args.InlineToMemoryClass    = 0xa140;
+            Args.DmaCopyClass           = 0xb0b5;
+            Args.MaxFbpsCount           = 0x1;
+            Args.FbpEnMask              = 0x0;
+            Args.MaxLtcPerFbp           = 0x2;
+            Args.MaxLtsPerLtc           = 0x1;
+            Args.MaxTexPerTpc           = 0x0;
+            Args.MaxGpcCount            = 0x1;
+            Args.RopL2EnMask0           = 0x21d70;
+            Args.RopL2EnMask1           = 0x0;
+            Args.ChipName               = 0x6230326d67;
+            Args.GrCompbitStoreBaseHw   = 0x0;
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return NvResult.Success;
+        }
+
+        private static int GetTpcMasks(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuGpuGetTpcMasks Args = AMemoryHelper.Read<NvGpuGpuGetTpcMasks>(Context.Memory, InputPosition);
+
+            if (Args.MaskBufferSize != 0)
+            {
+                Args.TpcMask = 3;
+            }
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return NvResult.Success;
+        }
+
+        private static int GetActiveSlotMask(ServiceCtx Context)
+        {
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvGpuGpuGetActiveSlotMask Args = new NvGpuGpuGetActiveSlotMask();
+
+            Args.Slot = 0x07;
+            Args.Mask = 0x01;
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int GetGpuTime(ServiceCtx Context)
+        {
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Memory.WriteInt64(OutputPosition, GetPTimerNanoSeconds());
+
+            return NvResult.Success;
+        }
+
+        private static long GetPTimerNanoSeconds()
+        {
+            double Ticks = PTimer.ElapsedTicks;
+
+            return (long)(Ticks * TicksToNs) & 0xff_ffff_ffff_ffff;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuZcullGetCtxSize.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    struct NvGpuGpuZcullGetCtxSize
+    {
+        public int Size;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvGpuGpu/NvGpuGpuZcullGetInfo.cs

@@ -0,0 +1,16 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvGpuGpu
+{
+    struct NvGpuGpuZcullGetInfo
+    {
+        public int WidthAlignPixels;
+        public int HeightAlignPixels;
+        public int PixelSquaresByAliquots;
+        public int AliquotTotal;
+        public int RegionByteMultiplier;
+        public int RegionHeaderSize;
+        public int SubregionHeaderSize;
+        public int SubregionWidthAlignPixels;
+        public int SubregionHeightAlignPixels;
+        public int SubregionCount;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHelper.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv
+{
+    static class NvHelper
+    {
+        public static void Crash()
+        {
+
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostChannel/NvHostChannelIoctl.cs

@@ -0,0 +1,130 @@
+using ChocolArm64.Memory;
+using Ryujinx.HLE.Gpu;
+using Ryujinx.HLE.Logging;
+using Ryujinx.HLE.OsHle.Services.Nv.NvGpuAS;
+using System;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostChannel
+{
+    class NvHostChannelIoctl
+    {
+        public static int ProcessIoctl(ServiceCtx Context, int Cmd)
+        {
+            switch (Cmd & 0xffff)
+            {
+                case 0x4714: return SetUserData     (Context);
+                case 0x4801: return SetNvMap        (Context);
+                case 0x4808: return SubmitGpfifo    (Context);
+                case 0x4809: return AllocObjCtx     (Context);
+                case 0x480b: return ZcullBind       (Context);
+                case 0x480c: return SetErrorNotifier(Context);
+                case 0x480d: return SetPriority     (Context);
+                case 0x481a: return AllocGpfifoEx2  (Context);
+            }
+
+            throw new NotImplementedException(Cmd.ToString("x8"));
+        }
+
+        private static int SetUserData(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int SetNvMap(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int SubmitGpfifo(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvHostChannelSubmitGpfifo Args = AMemoryHelper.Read<NvHostChannelSubmitGpfifo>(Context.Memory, InputPosition);
+
+            NvGpuVmm Vmm = NvGpuASIoctl.GetVmm(Context);
+
+            for (int Index = 0; Index < Args.NumEntries; Index++)
+            {
+                long Gpfifo = Context.Memory.ReadInt64(InputPosition + 0x18 + Index * 8);
+
+                long VA = Gpfifo & 0xff_ffff_ffff;
+
+                int Size = (int)(Gpfifo >> 40) & 0x7ffffc;
+
+                byte[] Data = Vmm.ReadBytes(VA, Size);
+
+                NvGpuPBEntry[] PushBuffer = NvGpuPushBuffer.Decode(Data);
+
+                Context.Ns.Gpu.Fifo.PushBuffer(Vmm, PushBuffer);
+            }
+
+            Args.SyncptId    = 0;
+            Args.SyncptValue = 0;
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return NvResult.Success;
+        }
+
+        private static int AllocObjCtx(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int ZcullBind(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int SetErrorNotifier(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int SetPriority(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int AllocGpfifoEx2(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostChannel/NvHostChannelSubmitGpfifo.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostChannel
+{
+    struct NvHostChannelSubmitGpfifo
+    {
+        public long Gpfifo;
+        public int  NumEntries;
+        public int  Flags;
+        public int  SyncptId;
+        public int  SyncptValue;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs

@@ -0,0 +1,355 @@
+using ChocolArm64.Memory;
+using Ryujinx.HLE.Logging;
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    class NvHostCtrlIoctl
+    {
+        private static ConcurrentDictionary<Process, NvHostCtrlUserCtx> UserCtxs;
+
+        static NvHostCtrlIoctl()
+        {
+            UserCtxs = new ConcurrentDictionary<Process, NvHostCtrlUserCtx>();
+        }
+
+        public static int ProcessIoctl(ServiceCtx Context, int Cmd)
+        {
+            switch (Cmd & 0xffff)
+            {
+                case 0x0014: return SyncptRead    (Context);
+                case 0x0015: return SyncptIncr    (Context);
+                case 0x0016: return SyncptWait    (Context);
+                case 0x0019: return SyncptWaitEx  (Context);
+                case 0x001a: return SyncptReadMax (Context);
+                case 0x001b: return GetConfig     (Context);
+                case 0x001d: return EventWait     (Context);
+                case 0x001e: return EventWaitAsync(Context);
+                case 0x001f: return EventRegister (Context);
+            }
+
+            throw new NotImplementedException(Cmd.ToString("x8"));
+        }
+
+        private static int SyncptRead(ServiceCtx Context)
+        {
+            return SyncptReadMinOrMax(Context, Max: false);
+        }
+
+        private static int SyncptIncr(ServiceCtx Context)
+        {
+            long InputPosition = Context.Request.GetBufferType0x21().Position;
+
+            int Id = Context.Memory.ReadInt32(InputPosition);
+
+            if ((uint)Id >= NvHostSyncpt.SyncptsCount)
+            {
+                return NvResult.InvalidInput;
+            }
+
+            GetUserCtx(Context).Syncpt.Increment(Id);
+
+            return NvResult.Success;
+        }
+
+        private static int SyncptWait(ServiceCtx Context)
+        {
+            return SyncptWait(Context, Extended: false);
+        }
+
+        private static int SyncptWaitEx(ServiceCtx Context)
+        {
+            return SyncptWait(Context, Extended: true);
+        }
+
+        private static int SyncptReadMax(ServiceCtx Context)
+        {
+            return SyncptReadMinOrMax(Context, Max: true);
+        }
+
+        private static int GetConfig(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            string Nv   = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0,    0x41);
+            string Name = AMemoryHelper.ReadAsciiString(Context.Memory, InputPosition + 0x41, 0x41);
+
+            Context.Memory.WriteByte(OutputPosition + 0x82, 0);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int EventWait(ServiceCtx Context)
+        {
+            return EventWait(Context, Async: false);
+        }
+
+        private static int EventWaitAsync(ServiceCtx Context)
+        {
+            return EventWait(Context, Async: true);
+        }
+
+        private static int EventRegister(ServiceCtx Context)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            int EventId = Context.Memory.ReadInt32(InputPosition);
+
+            Context.Ns.Log.PrintStub(LogClass.ServiceNv, "Stubbed.");
+
+            return NvResult.Success;
+        }
+
+        private static int SyncptReadMinOrMax(ServiceCtx Context, bool Max)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvHostCtrlSyncptRead Args = AMemoryHelper.Read<NvHostCtrlSyncptRead>(Context.Memory, InputPosition);
+
+            if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
+            {
+                return NvResult.InvalidInput;
+            }
+
+            if (Max)
+            {
+                Args.Value = GetUserCtx(Context).Syncpt.GetMax(Args.Id);
+            }
+            else
+            {
+                Args.Value = GetUserCtx(Context).Syncpt.GetMin(Args.Id);
+            }
+
+            AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+
+            return NvResult.Success;
+        }
+
+        private static int SyncptWait(ServiceCtx Context, bool Extended)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvHostCtrlSyncptWait Args = AMemoryHelper.Read<NvHostCtrlSyncptWait>(Context.Memory, InputPosition);
+
+            NvHostSyncpt Syncpt = GetUserCtx(Context).Syncpt;
+
+            if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
+            {
+                return NvResult.InvalidInput;
+            }
+
+            int Result;
+
+            if (Syncpt.MinCompare(Args.Id, Args.Thresh))
+            {
+                Result = NvResult.Success;
+            }
+            else if (Args.Timeout == 0)
+            {
+                Result = NvResult.TryAgain;
+            }
+            else
+            {
+                Context.Ns.Log.PrintDebug(LogClass.ServiceNv, "Waiting syncpt with timeout of " + Args.Timeout + "ms...");
+
+                using (ManualResetEvent WaitEvent = new ManualResetEvent(false))
+                {
+                    Syncpt.AddWaiter(Args.Thresh, WaitEvent);
+
+                    //Note: Negative (> INT_MAX) timeouts aren't valid on .NET,
+                    //in this case we just use the maximum timeout possible.
+                    int Timeout = Args.Timeout;
+
+                    if (Timeout < -1)
+                    {
+                        Timeout = int.MaxValue;
+                    }
+
+                    if (Timeout == -1)
+                    {
+                        WaitEvent.WaitOne();
+
+                        Result = NvResult.Success;
+                    }
+                    else if (WaitEvent.WaitOne(Timeout))
+                    {
+                        Result = NvResult.Success;
+                    }
+                    else
+                    {
+                        Result = NvResult.TimedOut;
+                    }
+                }
+
+                Context.Ns.Log.PrintDebug(LogClass.ServiceNv, "Resuming...");
+            }
+
+            if (Extended)
+            {
+                Context.Memory.WriteInt32(OutputPosition + 0xc, Syncpt.GetMin(Args.Id));
+            }
+
+            return Result;
+        }
+
+        private static int EventWait(ServiceCtx Context, bool Async)
+        {
+            long InputPosition  = Context.Request.GetBufferType0x21().Position;
+            long OutputPosition = Context.Request.GetBufferType0x22().Position;
+
+            NvHostCtrlSyncptWaitEx Args = AMemoryHelper.Read<NvHostCtrlSyncptWaitEx>(Context.Memory, InputPosition);
+
+            if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
+            {
+                return NvResult.InvalidInput;
+            }
+
+            void WriteArgs()
+            {
+                AMemoryHelper.Write(Context.Memory, OutputPosition, Args);
+            }
+
+            NvHostSyncpt Syncpt = GetUserCtx(Context).Syncpt;
+
+            if (Syncpt.MinCompare(Args.Id, Args.Thresh))
+            {
+                Args.Value = Syncpt.GetMin(Args.Id);
+
+                WriteArgs();
+
+                return NvResult.Success;
+            }
+
+            if (!Async)
+            {
+                Args.Value = 0;
+            }
+
+            if (Args.Timeout == 0)
+            {
+                WriteArgs();
+
+                return NvResult.TryAgain;
+            }
+
+            NvHostEvent Event;
+
+            int Result, EventIndex;
+
+            if (Async)
+            {
+                EventIndex = Args.Value;
+
+                if ((uint)EventIndex >= NvHostCtrlUserCtx.EventsCount)
+                {
+                    return NvResult.InvalidInput;
+                }
+
+                Event = GetUserCtx(Context).Events[EventIndex];
+            }
+            else
+            {
+                Event = GetFreeEvent(Context, Syncpt, Args.Id, out EventIndex);
+            }
+
+            if (Event != null &&
+               (Event.State == NvHostEventState.Registered ||
+                Event.State == NvHostEventState.Free))
+            {
+                Event.Id     = Args.Id;
+                Event.Thresh = Args.Thresh;
+
+                Event.State = NvHostEventState.Waiting;
+
+                if (!Async)
+                {
+                    Args.Value = ((Args.Id & 0xfff) << 16) | 0x10000000;
+                }
+                else
+                {
+                    Args.Value = Args.Id << 4;
+                }
+
+                Args.Value |= EventIndex;
+
+                Result = NvResult.TryAgain;
+            }
+            else
+            {
+                Result = NvResult.InvalidInput;
+            }
+
+            WriteArgs();
+
+            return Result;
+        }
+
+        private static NvHostEvent GetFreeEvent(
+            ServiceCtx   Context,
+            NvHostSyncpt Syncpt,
+            int          Id,
+            out int      EventIndex)
+        {
+            NvHostEvent[] Events = GetUserCtx(Context).Events;
+
+            EventIndex = NvHostCtrlUserCtx.EventsCount;
+
+            int NullIndex = NvHostCtrlUserCtx.EventsCount;
+
+            for (int Index = 0; Index < NvHostCtrlUserCtx.EventsCount; Index++)
+            {
+                NvHostEvent Event = Events[Index];
+
+                if (Event != null)
+                {
+                    if (Event.State == NvHostEventState.Registered ||
+                        Event.State == NvHostEventState.Free)
+                    {
+                        EventIndex = Index;
+
+                        if (Event.Id == Id)
+                        {
+                            return Event;
+                        }
+                    }
+                }
+                else if (NullIndex == NvHostCtrlUserCtx.EventsCount)
+                {
+                    NullIndex = Index;
+                }
+            }
+
+            if (NullIndex < NvHostCtrlUserCtx.EventsCount)
+            {
+                EventIndex = NullIndex;
+
+                return Events[NullIndex] = new NvHostEvent();
+            }
+
+            if (EventIndex < NvHostCtrlUserCtx.EventsCount)
+            {
+                return Events[EventIndex];
+            }
+
+            return null;
+        }
+
+        public static NvHostCtrlUserCtx GetUserCtx(ServiceCtx Context)
+        {
+            return UserCtxs.GetOrAdd(Context.Process, (Key) => new NvHostCtrlUserCtx());
+        }
+
+        public static void UnloadProcess(Process Process)
+        {
+            UserCtxs.TryRemove(Process, out _);
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlSyncPtRead.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    struct NvHostCtrlSyncptRead
+    {
+        public int Id;
+        public int Value;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlSyncPtWait.cs

@@ -0,0 +1,9 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    struct NvHostCtrlSyncptWait
+    {
+        public int Id;
+        public int Thresh;
+        public int Timeout;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlSyncPtWaitEx.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    struct NvHostCtrlSyncptWaitEx
+    {
+        public int Id;
+        public int Thresh;
+        public int Timeout;
+        public int Value;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostCtrlUserCtx.cs

@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    class NvHostCtrlUserCtx
+    {
+        public const int LocksCount  = 16;
+        public const int EventsCount = 64;
+
+        public NvHostSyncpt Syncpt { get; private set; }
+
+        public NvHostEvent[] Events { get; private set; }
+
+        public NvHostCtrlUserCtx()
+        {
+            Syncpt = new NvHostSyncpt();
+
+            Events = new NvHostEvent[EventsCount];
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostEvent.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    class NvHostEvent
+    {
+        public int Id;
+        public int Thresh;
+
+        public NvHostEventState State;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostEventState.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    enum NvHostEventState
+    {
+        Registered = 0,
+        Waiting    = 1,
+        Busy       = 2,
+        Free       = 5
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvHostCtrl/NvHostSyncPt.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvHostCtrl
+{
+    class NvHostSyncpt
+    {
+        public const int SyncptsCount = 192;
+
+        private int[] CounterMin;
+        private int[] CounterMax;
+
+        private long EventMask;
+
+        private ConcurrentDictionary<EventWaitHandle, int> Waiters;
+
+        public NvHostSyncpt()
+        {
+            CounterMin = new int[SyncptsCount];
+            CounterMax = new int[SyncptsCount];
+
+            Waiters = new ConcurrentDictionary<EventWaitHandle, int>();
+        }
+
+        public int GetMin(int Id)
+        {
+            return CounterMin[Id];
+        }
+
+        public int GetMax(int Id)
+        {
+            return CounterMax[Id];
+        }
+
+        public int Increment(int Id)
+        {
+            if (((EventMask >> Id) & 1) != 0)
+            {
+                Interlocked.Increment(ref CounterMax[Id]);
+            }
+
+            return IncrementMin(Id);
+        }
+
+        public int IncrementMin(int Id)
+        {
+            int Value = Interlocked.Increment(ref CounterMin[Id]);
+
+            WakeUpWaiters(Id, Value);
+
+            return Value;
+        }
+
+        public int IncrementMax(int Id)
+        {
+            return Interlocked.Increment(ref CounterMax[Id]);
+        }
+
+        public void AddWaiter(int Threshold, EventWaitHandle WaitEvent)
+        {
+            if (!Waiters.TryAdd(WaitEvent, Threshold))
+            {
+                throw new InvalidOperationException();
+            }
+        }
+
+        public bool RemoveWaiter(EventWaitHandle WaitEvent)
+        {
+            return Waiters.TryRemove(WaitEvent, out _);
+        }
+
+        private void WakeUpWaiters(int Id, int NewValue)
+        {
+            foreach (KeyValuePair<EventWaitHandle, int> KV in Waiters)
+            {
+                if (MinCompare(Id, NewValue, CounterMax[Id], KV.Value))
+                {
+                    KV.Key.Set();
+
+                    Waiters.TryRemove(KV.Key, out _);
+                }
+            }
+        }
+
+        public bool MinCompare(int Id, int Threshold)
+        {
+            return MinCompare(Id, CounterMin[Id], CounterMax[Id], Threshold);
+        }
+
+        private bool MinCompare(int Id, int Min, int Max, int Threshold)
+        {
+            int MinDiff = Min - Threshold;
+            int MaxDiff = Max - Threshold;
+
+            if (((EventMask >> Id) & 1) != 0)
+            {
+                return MinDiff >= 0;
+            }
+            else
+            {
+                return (uint)MaxDiff >= (uint)MinDiff;
+            }
+        }
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapAlloc.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    struct NvMapAlloc
+    {
+        public int  Handle;
+        public int  HeapMask;
+        public int  Flags;
+        public int  Align;
+        public long Kind;
+        public long Address;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapCreate.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    struct NvMapCreate
+    {
+        public int Size;
+        public int Handle;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapFree.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    struct NvMapFree
+    {
+        public int  Handle;
+        public int  Padding;
+        public long RefCount;
+        public int  Size;
+        public int  Flags;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapFromId.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    struct NvMapFromId
+    {
+        public int Id;
+        public int Handle;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapGetId.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    struct NvMapGetId
+    {
+        public int Id;
+        public int Handle;
+    }
+}

Ryujinx.HLE/OsHle/Services/Nv/NvMap/NvMapHandle.cs

@@ -0,0 +1,37 @@
+using System.Threading;
+
+namespace Ryujinx.HLE.OsHle.Services.Nv.NvMap
+{
+    class NvMapHandle
+    {
+        public int  Handle;
+        public int  Id;
+        public int  Size;
+        public int  Align;
+        public int  Kind;
+        public long Address;
+        public bool Allocated;
+
+        private long Dupes;
+
+        public NvMapHandle()
+        {
+            Dupes = 1;
+        }
+
+        public NvMapHandle(int Size) : this()
+        {
+            this.Size = Size;
+        }
+
+        public long IncrementRefCount()
+        {
+            return Interlocked.Increment(ref Dupes);
+        }
+
+        public long DecrementRefCount()
+        {
+            return Interlocked.Decrement(ref Dupes);
+        }
+    }
+}