Merge branch 'master' into timerz

include/applets/applet.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "helpers.hpp"
+#include "memory.hpp"
+#include "result/result.hpp"
+
+namespace Applets {
+	namespace AppletIDs {
+		enum : u32 {
+			None = 0,
+			SysAppletMask = 0x100,
+			HomeMenu = 0x101,
+			AltMenu = 0x103,
+			Camera = 0x110,
+			Friends = 0x112,
+			GameNotes = 0x113,
+			Browser = 0x114,
+			InstructionManual = 0x115,
+			Notifications = 0x116,
+			Miiverse = 0x117,
+			MiiversePosting = 0x118,
+			AmiiboSettings = 0x119,
+			SysLibraryAppletMask = 0x200,
+			SoftwareKeyboard = 0x201,
+			MiiSelector = 0x202,
+			PNote = 0x204,  // TODO: What dis?
+			SNote = 0x205,  // What is this too?
+			ErrDisp = 0x206,
+			EshopMint = 0x207,
+			CirclePadProCalib = 0x208,
+			Notepad = 0x209,
+			Application = 0x300,
+			EshopTiger = 0x301,
+			LibraryAppletMask = 0x400,
+			SoftwareKeyboard2 = 0x401,
+			MiiSelector2 = 0x402,
+			Pnote2 = 0x404,
+			SNote2 = 0x405,
+			ErrDisp2 = 0x406,
+			EshopMint2 = 0x407,
+			CirclePadProCalib2 = 0x408,
+			Notepad2 = 0x409,
+		};
+	}
+
+	enum class APTSignal : u32 {
+		None = 0x0,
+		Wakeup = 0x1,
+		Request = 0x2,
+		Response = 0x3,
+		Exit = 0x4,
+		Message = 0x5,
+		HomeButtonSingle = 0x6,
+		HomeButtonDouble = 0x7,
+		DspSleep = 0x8,
+		DspWakeup = 0x9,
+		WakeupByExit = 0xA,
+		WakeupByPause = 0xB,
+		WakeupByCancel = 0xC,
+		WakeupByCancelAll = 0xD,
+		WakeupByPowerButtonClick = 0xE,
+		WakeupToJumpHome = 0xF,
+		RequestForSysApplet = 0x10,
+		WakeupToLaunchApplication = 0x11,
+	};
+
+	struct Parameter {
+		u32 senderID;
+		u32 destID;
+		APTSignal signal;
+		std::vector<u8> data;
+	};
+
+	class AppletBase {
+		Memory& mem;
+
+	  public:
+		virtual const char* name() = 0;
+
+		// Called by APT::StartLibraryApplet and similar
+		virtual Result::HorizonResult start() = 0;
+		// Transfer parameters from application -> applet
+		virtual Result::HorizonResult receiveParameter() = 0;
+		virtual void reset() = 0;
+
+		AppletBase(Memory& mem) : mem(mem) {}
+	};
+}  // namespace Applets

include/applets/applet_manager.hpp

@@ -0,0 +1,17 @@
+#include "applets/mii_selector.hpp"
+#include "applets/software_keyboard.hpp"
+#include "helpers.hpp"
+#include "memory.hpp"
+#include "result/result.hpp"
+
+namespace Applets {
+	class AppletManager {
+		MiiSelectorApplet miiSelector;
+		SoftwareKeyboardApplet swkbd;
+
+	  public:
+		AppletManager(Memory& mem);
+		void reset();
+		AppletBase* getApplet(u32 id);
+	};
+}  // namespace Applets

include/applets/mii_selector.hpp

@@ -0,0 +1,13 @@
+#include "applets/applet.hpp"
+
+namespace Applets {
+	class MiiSelectorApplet final : public AppletBase {
+	  public:
+		virtual const char* name() override { return "Mii Selector"; }
+		virtual Result::HorizonResult start() override;
+		virtual Result::HorizonResult receiveParameter() override;
+		virtual void reset() override;
+
+		MiiSelectorApplet(Memory& memory) : AppletBase(memory) {}
+	};
+}  // namespace Applets

include/applets/software_keyboard.hpp

@@ -0,0 +1,13 @@
+#include "applets/applet.hpp"
+
+namespace Applets {
+	class SoftwareKeyboardApplet final : public AppletBase {
+	  public:
+		virtual const char* name() override { return "Software Keyboard"; }
+		virtual Result::HorizonResult start() override;
+		virtual Result::HorizonResult receiveParameter() override;
+		virtual void reset() override;
+
+		SoftwareKeyboardApplet(Memory& memory) : AppletBase(memory) {}
+	};
+}  // namespace Applets

include/fs/archive_base.hpp

@@ -25,17 +25,22 @@ namespace PathType {
 }
 
 namespace ArchiveID {
-    enum : u32 {
-        SelfNCCH = 3,
-        SaveData = 4,
-        ExtSaveData = 6,
-        SharedExtSaveData = 7,
-        SystemSaveData = 8,
-        SDMC = 9,
-        SDMCWriteOnly = 0xA,
+	enum : u32 {
+		SelfNCCH = 3,
+		SaveData = 4,
+		ExtSaveData = 6,
+		SharedExtSaveData = 7,
+		SystemSaveData = 8,
+		SDMC = 9,
+		SDMCWriteOnly = 0xA,
 
-        SavedataAndNcch = 0x2345678A
-    };
+		SavedataAndNcch = 0x2345678A,
+		// 3DBrew: This is the same as the regular SaveData archive, except with this the savedata ID and mediatype is loaded from the input archive
+		// lowpath.
+		UserSaveData1 = 0x567890B2,
+		// 3DBrew: Similar to 0x567890B2 but can only access Accessible Save specified in exheader?
+		UserSaveData2 = 0x567890B4,
+	};
 
     static std::string toString(u32 id) {
         switch (id) {
@@ -246,4 +251,11 @@ public:
     virtual std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) = 0;
 
     ArchiveBase(Memory& mem) : mem(mem) {}
+};
+
+struct ArchiveResource {
+	u32 sectorSize;   // Size of a sector in bytes
+	u32 clusterSize;  // Size of a cluster in bytes
+	u32 partitionCapacityInClusters;
+	u32 freeSpaceInClusters;
 };

include/fs/archive_user_save_data.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "archive_base.hpp"
+
+class UserSaveDataArchive : public ArchiveBase {
+	u32 archiveID;
+  public:
+	UserSaveDataArchive(Memory& mem, u32 archiveID) : ArchiveBase(mem), archiveID(archiveID) {}
+
+	u64 getFreeBytes() override { return 32_MB; }
+	std::string name() override { return "UserSaveData"; }
+
+	HorizonResult createDirectory(const FSPath& path) override;
+	HorizonResult createFile(const FSPath& path, u64 size) override;
+	HorizonResult deleteFile(const FSPath& path) override;
+
+	Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
+	Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
+	FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
+	std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
+
+	void format(const FSPath& path, const FormatInfo& info) override;
+	Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
+
+	std::filesystem::path getFormatInfoPath() { return IOFile::getAppData() / "FormatInfo" / "SaveData.format"; }
+
+	// Returns whether the cart has save data or not
+	bool cartHasSaveData() {
+		auto cxi = mem.getCXI();
+		return (cxi != nullptr && cxi->hasSaveData());  // We need to have a CXI file with more than 0 bytes of save data
+	}
+};

include/renderer_vk/renderer_vk.hpp

@@ -1,5 +1,12 @@
+#include <map>
+#include <optional>
+
+#include "math_util.hpp"
 #include "renderer.hpp"
-#include "vulkan_api.hpp"
+#include "vk_api.hpp"
+#include "vk_descriptor_heap.hpp"
+#include "vk_descriptor_update_batch.hpp"
+#include "vk_sampler_cache.hpp"
 
 class GPU;
 
@@ -10,7 +17,7 @@ class RendererVK final : public Renderer {
 	vk::UniqueInstance instance = {};
 	vk::UniqueDebugUtilsMessengerEXT debugMessenger = {};
 
-	vk::UniqueSurfaceKHR surface = {};
+	vk::SurfaceKHR swapchainSurface = {};
 
 	vk::PhysicalDevice physicalDevice = {};
 
@@ -32,17 +39,74 @@ class RendererVK final : public Renderer {
 	std::vector<vk::Image> swapchainImages = {};
 	std::vector<vk::UniqueImageView> swapchainImageViews = {};
 
-	// Per-swapchain-image data
-	// Each vector is `swapchainImageCount` in size
-	std::vector<vk::UniqueCommandBuffer> presentCommandBuffers = {};
+	// This value is the degree of parallelism to allow multiple frames to be in-flight
+	// aka: "double-buffer"/"triple-buffering"
+	// Todo: make this a configuration option
+	static constexpr usize frameBufferingCount = 3;
+
+	// Frame-buffering data
+	// Each vector is `frameBufferingCount` in size
 	std::vector<vk::UniqueSemaphore> swapImageFreeSemaphore = {};
 	std::vector<vk::UniqueSemaphore> renderFinishedSemaphore = {};
 	std::vector<vk::UniqueFence> frameFinishedFences = {};
+	std::vector<std::vector<vk::UniqueFramebuffer>> frameFramebuffers = {};
+	std::vector<vk::UniqueCommandBuffer> frameCommandBuffers = {};
+
+	const vk::CommandBuffer& getCurrentCommandBuffer() const { return frameCommandBuffers[frameBufferingIndex].get(); }
+
+	// Todo:
+	// Use `{colourBuffer,depthBuffer}Loc` to maintain an std::map-cache of framebuffers
+	struct Texture {
+		u32 loc = 0;
+		u32 sizePerPixel = 0;
+		std::array<u32, 2> size = {};
+
+		vk::Format format;
+		vk::UniqueImage image;
+		vk::UniqueDeviceMemory imageMemory;
+		vk::UniqueImageView imageView;
+
+		Math::Rect<u32> getSubRect(u32 inputAddress, u32 width, u32 height) {
+			// PICA textures have top-left origin, same as Vulkan
+			const u32 startOffset = (inputAddress - loc) / sizePerPixel;
+			const u32 x0 = (startOffset % (size[0] * 8)) / 8;
+			const u32 y0 = (startOffset / (size[0] * 8)) * 8;
+			return Math::Rect<u32>{x0, y0, x0 + width, y0 + height};
+		}
+	};
+	// Hash(loc, size, format) -> Texture
+	std::map<u64, Texture> textureCache;
+
+	Texture* findRenderTexture(u32 addr);
+	Texture& getColorRenderTexture(u32 addr, PICA::ColorFmt format, u32 width, u32 height);
+	Texture& getDepthRenderTexture(u32 addr, PICA::DepthFmt format, u32 width, u32 height);
+
+	// Framebuffer for the top/bottom image
+	std::vector<vk::UniqueImage> screenTexture = {};
+	std::vector<vk::UniqueImageView> screenTextureViews = {};
+	std::vector<vk::UniqueFramebuffer> screenTextureFramebuffers = {};
+	vk::UniqueDeviceMemory framebufferMemory = {};
+
+	std::map<u64, vk::UniqueRenderPass> renderPassCache;
+
+	vk::RenderPass getRenderPass(vk::Format colorFormat, std::optional<vk::Format> depthFormat);
+	vk::RenderPass getRenderPass(PICA::ColorFmt colorFormat, std::optional<PICA::DepthFmt> depthFormat);
+
+	std::unique_ptr<Vulkan::DescriptorUpdateBatch> descriptorUpdateBatch;
+	std::unique_ptr<Vulkan::SamplerCache> samplerCache;
+
+	// Display pipeline data
+	std::unique_ptr<Vulkan::DescriptorHeap> displayDescriptorHeap;
+	vk::UniquePipeline displayPipeline;
+	vk::UniquePipelineLayout displayPipelineLayout;
+	std::vector<vk::DescriptorSet> topDisplayPipelineDescriptorSet;
+	std::vector<vk::DescriptorSet> bottomDisplayPipelineDescriptorSet;
 
 	// Recreate the swapchain, possibly re-using the old one in the case of a resize
 	vk::Result recreateSwapchain(vk::SurfaceKHR surface, vk::Extent2D swapchainExtent);
 
-	u64 currentFrame = 0;
+	u64 frameBufferingIndex = 0;
+
   public:
 	RendererVK(GPU& gpu, const std::array<u32, regNum>& internalRegs, const std::array<u32, extRegNum>& externalRegs);
 	~RendererVK() override;

include/renderer_vk/vk_debug.hpp

@@ -4,7 +4,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "vulkan_api.hpp"
+#include "vk_api.hpp"
 
 namespace Vulkan {
 

include/renderer_vk/vk_descriptor_heap.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <optional>
+#include <span>
+
+#include "helpers.hpp"
+#include "vk_api.hpp"
+
+namespace Vulkan {
+	// Implements a basic heap of descriptor sets given a layout of particular
+	// bindings. Create a descriptor set by providing a list of bindings and it will
+	// automatically create both the pool, layout, and maintail a heap of descriptor
+	// sets. Descriptor sets will be reused and recycled. Assume that newly
+	// allocated descriptor sets are in an undefined state.
+	class DescriptorHeap {
+	  private:
+		const vk::Device device;
+
+		vk::UniqueDescriptorPool descriptorPool;
+		vk::UniqueDescriptorSetLayout descriptorSetLayout;
+		std::vector<vk::UniqueDescriptorSet> descriptorSets;
+
+		std::vector<vk::DescriptorSetLayoutBinding> bindings;
+
+		std::vector<bool> allocationMap;
+
+		explicit DescriptorHeap(vk::Device device);
+
+	  public:
+		~DescriptorHeap() = default;
+
+		DescriptorHeap(DescriptorHeap&&) = default;
+
+		const vk::DescriptorPool& getDescriptorPool() const { return descriptorPool.get(); };
+
+		const vk::DescriptorSetLayout& getDescriptorSetLayout() const { return descriptorSetLayout.get(); };
+
+		const std::span<const vk::UniqueDescriptorSet> getDescriptorSets() const { return descriptorSets; };
+
+		std::span<const vk::DescriptorSetLayoutBinding> getBindings() const { return bindings; };
+
+		std::optional<vk::DescriptorSet> allocateDescriptorSet();
+		bool freeDescriptorSet(vk::DescriptorSet set);
+
+		static std::optional<DescriptorHeap> create(
+			vk::Device device, std::span<const vk::DescriptorSetLayoutBinding> bindings, u16 descriptorHeapCount = 1024
+		);
+	};
+}  // namespace Vulkan

include/renderer_vk/vk_descriptor_update_batch.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <variant>
+
+#include "helpers.hpp"
+#include "vk_api.hpp"
+
+namespace Vulkan {
+	// Implements a re-usable structure for batching up descriptor writes with a
+	// finite amount of space for both convenience and to reduce the overall amount
+	// of API calls to `vkUpdateDescriptorSets`
+	class DescriptorUpdateBatch {
+	  private:
+		const vk::Device device;
+
+		const usize descriptorWriteMax;
+		const usize descriptorCopyMax;
+
+		using DescriptorInfoUnion = std::variant<vk::DescriptorImageInfo, vk::DescriptorBufferInfo, vk::BufferView>;
+
+		// Todo: Maybe some kind of hash so that these structures can be re-used
+		// among descriptor writes.
+		std::unique_ptr<DescriptorInfoUnion[]> descriptorInfos;
+		std::unique_ptr<vk::WriteDescriptorSet[]> descriptorWrites;
+		std::unique_ptr<vk::CopyDescriptorSet[]> descriptorCopies;
+
+		usize descriptorWriteEnd = 0;
+		usize descriptorCopyEnd = 0;
+
+		DescriptorUpdateBatch(vk::Device device, usize descriptorWriteMax, usize descriptorCopyMax)
+			: device(device), descriptorWriteMax(descriptorWriteMax), descriptorCopyMax(descriptorCopyMax) {}
+
+	  public:
+		~DescriptorUpdateBatch() = default;
+
+		DescriptorUpdateBatch(DescriptorUpdateBatch&&) = default;
+
+		void flush();
+
+		void addImage(
+			vk::DescriptorSet targetDescriptor, u8 targetBinding, vk::ImageView imageView, vk::ImageLayout imageLayout = vk::ImageLayout::eGeneral
+		);
+		void addSampler(vk::DescriptorSet targetDescriptor, u8 targetBinding, vk::Sampler sampler);
+
+		void addImageSampler(
+			vk::DescriptorSet targetDescriptor, u8 targetBinding, vk::ImageView imageView, vk::Sampler sampler,
+			vk::ImageLayout imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal
+		);
+		void addBuffer(
+			vk::DescriptorSet targetDescriptor, u8 targetBinding, vk::Buffer buffer, vk::DeviceSize offset, vk::DeviceSize size = VK_WHOLE_SIZE
+		);
+
+		void copyBinding(
+			vk::DescriptorSet sourceDescriptor, vk::DescriptorSet targetDescriptor, u8 sourceBinding, u8 targetBinding, u8 sourceArrayElement = 0,
+			u8 targetArrayElement = 0, u8 descriptorCount = 1
+		);
+
+		static std::optional<DescriptorUpdateBatch> create(vk::Device device, usize descriptorWriteMax = 256, usize descriptorCopyMax = 256);
+	};
+}  // namespace Vulkan

include/renderer_vk/vk_memory.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <span>
+#include <type_traits>
+#include <utility>
+
+#include "helpers.hpp"
+#include "vk_api.hpp"
+
+namespace Vulkan {
+
+	// Will try to find a memory type that is suitable for the given requirements.
+	// Returns -1 if no suitable memory type was found.
+	s32 findMemoryTypeIndex(
+		vk::PhysicalDevice physicalDevice, u32 memoryTypeMask, vk::MemoryPropertyFlags memoryProperties,
+		vk::MemoryPropertyFlags memoryExcludeProperties = vk::MemoryPropertyFlagBits::eProtected
+	);
+
+	// Given an array of valid Vulkan image-handles or buffer-handles, these
+	// functions will allocate a single block of device-memory for all of them
+	// and bind them consecutively.
+	// There may be a case that all the buffers or images cannot be allocated
+	// to the same device memory due to their required memory-type.
+	std::tuple<vk::Result, vk::UniqueDeviceMemory> commitImageHeap(
+		vk::Device device, vk::PhysicalDevice physicalDevice, const std::span<const vk::Image> images,
+		vk::MemoryPropertyFlags memoryProperties = vk::MemoryPropertyFlagBits::eDeviceLocal,
+		vk::MemoryPropertyFlags memoryExcludeProperties = vk::MemoryPropertyFlagBits::eProtected
+	);
+
+	std::tuple<vk::Result, vk::UniqueDeviceMemory> commitBufferHeap(
+		vk::Device device, vk::PhysicalDevice physicalDevice, const std::span<const vk::Buffer> buffers,
+		vk::MemoryPropertyFlags memoryProperties = vk::MemoryPropertyFlagBits::eDeviceLocal,
+		vk::MemoryPropertyFlags memoryExcludeProperties = vk::MemoryPropertyFlagBits::eProtected
+	);
+
+}  // namespace Vulkan

include/renderer_vk/vk_pica.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "PICA/gpu.hpp"
+#include "helpers.hpp"
+#include "vk_api.hpp"
+
+namespace Vulkan {
+
+	vk::Format colorFormatToVulkan(PICA::ColorFmt colorFormat);
+	vk::Format depthFormatToVulkan(PICA::DepthFmt depthFormat);
+
+}  // namespace Vulkan

include/renderer_vk/vk_sampler_cache.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+
+#include "helpers.hpp"
+#include "vk_api.hpp"
+
+namespace Vulkan {
+	// Implements a simple pool of reusable sampler objects
+	class SamplerCache {
+	  private:
+		const vk::Device device;
+
+		std::unordered_map<std::size_t, vk::UniqueSampler> samplerMap;
+
+		explicit SamplerCache(vk::Device device);
+
+	  public:
+		~SamplerCache() = default;
+
+		SamplerCache(SamplerCache&&) = default;
+
+		const vk::Sampler& getSampler(const vk::SamplerCreateInfo& samplerInfo);
+
+		static std::optional<SamplerCache> create(vk::Device device);
+	};
+}  // namespace Vulkan

include/services/ac.hpp

@@ -1,4 +1,6 @@
 #pragma once
+#include <optional>
+
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -15,10 +17,14 @@ class ACService {
 	void closeAsync(u32 messagePointer);
 	void createDefaultConfig(u32 messagePointer);
 	void getLastErrorCode(u32 messagePointer);
+	void isConnected(u32 messagePointer);
 	void registerDisconnectEvent(u32 messagePointer);
 	void setClientVersion(u32 messagePointer);
 
-public:
+	bool connected = false;
+	std::optional<Handle> disconnectEvent = std::nullopt;
+
+  public:
 	ACService(Memory& mem) : mem(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);

include/services/apt.hpp

@@ -6,6 +6,8 @@
 #include "memory.hpp"
 #include "result/result.hpp"
 
+#include "applets/applet_manager.hpp"
+
 // Yay, more circular dependencies
 class Kernel;
 
@@ -23,6 +25,7 @@ class APTService {
 	std::optional<Handle> resumeEvent = std::nullopt;
 
 	ConsoleModel model = ConsoleModel::Old3DS;
+	Applets::AppletManager appletManager;
 
 	MAKE_LOG_FUNCTION(log, aptLogger)
 
@@ -33,17 +36,22 @@ class APTService {
 	void checkNew3DS(u32 messagePointer);
 	void checkNew3DSApp(u32 messagePointer);
 	void enable(u32 messagePointer);
+	void getAppletInfo(u32 messagePointer);
 	void getSharedFont(u32 messagePointer);
 	void getWirelessRebootInfo(u32 messagePointer);
 	void glanceParameter(u32 messagePointer);
 	void initialize(u32 messagePointer);
 	void inquireNotification(u32 messagePointer);
+	void isRegistered(u32 messagePointer);
 	void notifyToWait(u32 messagePointer);
 	void preloadLibraryApplet(u32 messagePointer);
+	void prepareToStartLibraryApplet(u32 messagePointer);
 	void receiveParameter(u32 messagePointer);
 	void replySleepQuery(u32 messagePointer);
 	void setApplicationCpuTimeLimit(u32 messagePointer);
 	void setScreencapPostPermission(u32 messagePointer);
+	void sendParameter(u32 messagePointer);
+	void startLibraryApplet(u32 messagePointer);
 	void theSmashBrosFunction(u32 messagePointer);
 
 	// Percentage of the syscore available to the application, between 5% and 89%
@@ -67,7 +75,7 @@ class APTService {
 	u32 screencapPostPermission;
 
 public:
-	APTService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
+	APTService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel), appletManager(mem) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
 };

include/services/frd.hpp

@@ -23,7 +23,10 @@ class FRDService {
 
 	// Service commands
 	void attachToEventNotification(u32 messagePointer);
+	void getFriendAttributeFlags(u32 messagePointer);
 	void getFriendKeyList(u32 messagePointer);
+	void getFriendPresence(u32 messagePointer);
+	void getFriendProfile(u32 messagePointer);
 	void getMyFriendKey(u32 messagePointer);
 	void getMyMii(u32 messagePointer);
 	void getMyPresence(u32 messagePointer);
@@ -35,6 +38,15 @@ class FRDService {
 	void setNotificationMask(u32 messagePointer);
 	void updateGameModeDescription(u32 messagePointer);
 
+	struct Profile {
+		u8 region;
+		u8 country;
+		u8 area;
+		u8 language;
+		u32 unknown;
+	};
+	static_assert(sizeof(Profile) == 8);
+
 public:
 	FRDService(Memory& mem) : mem(mem) {}
 	void reset();

include/services/fs.hpp

@@ -4,6 +4,7 @@
 #include "fs/archive_save_data.hpp"
 #include "fs/archive_sdmc.hpp"
 #include "fs/archive_self_ncch.hpp"
+#include "fs/archive_user_save_data.hpp"
 #include "helpers.hpp"
 #include "kernel_types.hpp"
 #include "logger.hpp"
@@ -26,6 +27,10 @@ class FSService {
 	SDMCArchive sdmc;
 	NCCHArchive ncch;
 
+	// UserSaveData archives
+	UserSaveDataArchive userSaveData1;
+	UserSaveDataArchive userSaveData2;
+
 	ExtSaveDataArchive extSaveData_sdmc;
 	ExtSaveDataArchive sharedExtSaveData_nand;
 
@@ -36,6 +41,7 @@ class FSService {
 	FSPath readPath(u32 type, u32 pointer, u32 size);
 
 	// Service commands
+	void abnegateAccessRight(u32 messagePointer);
 	void createDirectory(u32 messagePointer);
 	void createExtSaveData(u32 messagePointer);
 	void createFile(u32 messagePointer);
@@ -45,9 +51,12 @@ class FSService {
 	void deleteFile(u32 messagePointer);
 	void formatSaveData(u32 messagePointer);
 	void formatThisUserSaveData(u32 messagePointer);
+	void getArchiveResource(u32 messagePointer);
 	void getFreeBytes(u32 messagePointer);
 	void getFormatInfo(u32 messagePointer);
 	void getPriority(u32 messagePointer);
+	void getThisSaveDataSecureValue(u32 messagePointer);
+	void theGameboyVCFunction(u32 messagePointer);
 	void initialize(u32 messagePointer);
 	void initializeWithSdkVersion(u32 messagePointer);
 	void isSdmcDetected(u32 messagePointer);
@@ -56,16 +65,17 @@ class FSService {
 	void openDirectory(u32 messagePointer);
 	void openFile(u32 messagePointer);
 	void openFileDirectly(u32 messagePointer);
+	void setArchivePriority(u32 messagePointer);
 	void setPriority(u32 messagePointer);
+	void setThisSaveDataSecureValue(u32 messagePointer);
 
 	// Used for set/get priority: Not sure what sort of priority this is referring to
 	u32 priority;
 
 public:
-	FSService(Memory& mem, Kernel& kernel) : mem(mem), saveData(mem),
-		sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"),
-		sdmc(mem), selfNcch(mem), ncch(mem), kernel(kernel)
-	{}
+	FSService(Memory& mem, Kernel& kernel)
+		: mem(mem), saveData(mem), sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"), sdmc(mem), selfNcch(mem),
+		  ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1), userSaveData2(mem, ArchiveID::UserSaveData2), kernel(kernel) {}
 
 	void reset();
 	void handleSyncRequest(u32 messagePointer);

include/services/gsp_gpu.hpp

@@ -63,7 +63,9 @@ class GPUService {
 	// Service commands
 	void acquireRight(u32 messagePointer);
 	void flushDataCache(u32 messagePointer);
+	void importDisplayCaptureInfo(u32 messagePointer);
 	void registerInterruptRelayQueue(u32 messagePointer);
+	void saveVramSysArea(u32 messagePointer);
 	void setAxiConfigQoSMode(u32 messagePointer);
 	void setBufferSwap(u32 messagePointer);
 	void setInternalPriorities(u32 messagePointer);

include/services/mic.hpp

@@ -5,13 +5,20 @@
 #include "memory.hpp"
 #include "result/result.hpp"
 
+// Circular dependencies, yay
+class Kernel;
+
 class MICService {
 	Handle handle = KernelHandles::MIC;
 	Memory& mem;
+	Kernel& kernel;
 	MAKE_LOG_FUNCTION(log, micLogger)
 
 	// Service commands
+	void getEventHandle(u32 messagePointer);
 	void getGain(u32 messagePointer);
+	void getPower(u32 messagePointer);
+	void isSampling(u32 messagePointer);
 	void mapSharedMem(u32 messagePointer);
 	void setClamp(u32 messagePointer);
 	void setGain(u32 messagePointer);
@@ -19,15 +26,18 @@ class MICService {
 	void setPower(u32 messagePointer);
 	void startSampling(u32 messagePointer);
 	void stopSampling(u32 messagePointer);
+	void unmapSharedMem(u32 messagePointer);
 	void theCaptainToadFunction(u32 messagePointer);
 
 	u8 gain = 0; // How loud our microphone input signal is
 	bool micEnabled = false;
 	bool shouldClamp = false;
-	bool isSampling = false;
+	bool currentlySampling = false;
+
+	std::optional<Handle> eventHandle;
 
 public:
-	MICService(Memory& mem) : mem(mem) {}
+	MICService(Memory& mem, Kernel& kernel) : mem(mem), kernel(kernel) {}
 	void reset();
 	void handleSyncRequest(u32 messagePointer);
 };

include/services/nfc.hpp

@@ -44,7 +44,9 @@ class NFCService {
 	void getTagInRangeEvent(u32 messagePointer);
 	void getTagOutOfRangeEvent(u32 messagePointer);
 	void getTagState(u32 messagePointer);
+	void shutdown(u32 messagePointer);
 	void startCommunication(u32 messagePointer);
+	void startTagScanning(u32 messagePointer);
 	void stopCommunication(u32 messagePointer);
 
 public: